summaryrefslogtreecommitdiff
path: root/packages/linux/linux-mtx-2-2.4.27/46-otg.patch
diff options
context:
space:
mode:
authorPaul Sokolovsky <pmiscml@gmail.com>2006-11-03 00:04:44 +0000
committerPaul Sokolovsky <pmiscml@gmail.com>2006-11-03 00:04:44 +0000
commitf58de2d6d17707c69d6a3bbc88d52af0a29925fa (patch)
treee3a26875913f709e356aa7de307e2e4a012b3be1 /packages/linux/linux-mtx-2-2.4.27/46-otg.patch
parentfd4bce4609eddae2c3fb7df1a8a641ea4962be70 (diff)
parentadc83f0d66fd2cd72fff287122902eae966cccbb (diff)
merge of '5e83a11c1979d1a25e15d1870551427de8ffa53a'
and '88193d154d85992850b54a623cbba5f64fbe4615'
Diffstat (limited to 'packages/linux/linux-mtx-2-2.4.27/46-otg.patch')
-rw-r--r--packages/linux/linux-mtx-2-2.4.27/46-otg.patch56853
1 files changed, 56853 insertions, 0 deletions
diff --git a/packages/linux/linux-mtx-2-2.4.27/46-otg.patch b/packages/linux/linux-mtx-2-2.4.27/46-otg.patch
new file mode 100644
index 0000000000..2004894b3e
--- /dev/null
+++ b/packages/linux/linux-mtx-2-2.4.27/46-otg.patch
@@ -0,0 +1,56853 @@
+--- linux/Makefile-otgorig 2006-09-20 16:02:57.347146612 +0200
++++ linux/Makefile 2006-09-20 16:03:35.280797278 +0200
+@@ -181,6 +181,7 @@
+ DRIVERS-$(CONFIG_HAMRADIO) += drivers/net/hamradio/hamradio.o
+ DRIVERS-$(CONFIG_TC) += drivers/tc/tc.a
+ DRIVERS-$(CONFIG_USB) += drivers/usb/usbdrv.o
++DRIVERS-$(CONFIG_OTG) += drivers/otg/otg_drv.o
+ DRIVERS-$(CONFIG_USB_GADGET) += drivers/usb/gadget/built-in.o
+ DRIVERS-y +=drivers/media/media.o
+ DRIVERS-$(CONFIG_INPUT) += drivers/input/inputdrv.o
+--- linux/arch/mips/config-shared.in-otgorig 2006-09-20 16:09:20.671834564 +0200
++++ linux/arch/mips/config-shared.in 2006-09-20 16:09:28.068156725 +0200
+@@ -1009,6 +1009,7 @@
+ endmenu
+
+ source drivers/usb/Config.in
++source drivers/otg/Config.in
+
+ source net/bluetooth/Config.in
+
+--- linux/drivers/Makefile-otgorig 2006-09-20 16:09:47.100985766 +0200
++++ linux/drivers/Makefile 2006-09-20 16:10:25.730668535 +0200
+@@ -6,7 +6,7 @@
+ #
+
+
+-mod-subdirs := dio hil mtd sbus video macintosh usb input telephony ide \
++mod-subdirs := dio hil mtd sbus video macintosh usb otg input telephony ide \
+ message/i2o message/fusion scsi md ieee1394 pnp isdn atm \
+ fc4 net/hamradio i2c acpi bluetooth usb/gadget sensors
+
+@@ -28,6 +28,7 @@
+ subdir-$(CONFIG_MAC) += macintosh
+ subdir-$(CONFIG_PPC32) += macintosh
+ subdir-$(CONFIG_USB) += usb
++subdir-$(CONFIG_OTG) += otg
+ subdir-$(CONFIG_USB_GADGET) += usb/gadget
+ subdir-$(CONFIG_INPUT) += input
+ subdir-$(CONFIG_PHONE) += telephony
+diff -uNr linux/drivers/no-otg/Config.in linux/drivers/otg/Config.in
+--- linux/drivers/no-otg/Config.in 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/Config.in 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,103 @@
++#
++# USBOTG - Top level configuration of a USB Peripheral or USB On-The-Go Peripheral Device
++#
++# Copyright (c) 2004 Belcarra
++#
++#
++
++mainmenu_option next_comment
++
++ #
++ # Enable/Disable OTG Support
++ #
++ comment 'On-The-Go and USB Peripheral Support'
++ tristate 'Support for On-The-Go and USB Peripherals ' CONFIG_OTG
++
++ if [ "$CONFIG_OTG" != "n" ]; then
++ #
++ # Select appropriate hardware platform, each config file
++ # will only offer options if the kernel is configured for
++ # that specific architecture or platform. They should define
++ # the following to enable the further configuration in this
++ # file:
++ # CONFIG_OTG_PLATFORM_OTG offer OTG configuration
++ #
++ # CONFIG_OTG_PLATFORM_USBD offer USBD configuration and
++ # function selection
++ # CONFIG_OTG_PLATFORM_HOST offer HOST configuration
++ #
++ mainmenu_option next_comment
++ comment 'Select Hardware'
++
++ # platform oriented configurations
++# source drivers/otg/config/Config.in-mainstone
++# source drivers/otg/config/Config.in-pcs-b780
++# source drivers/otg/config/Config.in-pcs-p1
++# source drivers/otg/config/Config.in-mx2ads
++# source drivers/otg/config/Config.in-omap-h2
++ source drivers/otg/config/Config.in-db1550
++# source drivers/otg/config/Config.in-mordor
++
++ # architecture specific configurations
++ source drivers/otg/config/Config.in-au1x00
++# source drivers/otg/config/Config.in-dbmx1
++# source drivers/otg/config/Config.in-lh7a400
++# source drivers/otg/config/Config.in-lubbock
++# source drivers/otg/config/Config.in-smdk2500
++# source drivers/otg/config/Config.in-strongarm
++# source drivers/otg/config/Config.in-superh
++
++ # generic drivers
++ source drivers/otg/config/Config.in-isp1301
++ source drivers/otg/config/Config.in-max3353e
++ endmenu
++
++ if [ "$CONFIG_OTG_PLATFORM_OTG" = "y" -o "$CONFIG_OTG_PLATFORM_USBD" = "y" ]; then
++
++ #
++ # Generic Options
++ #
++ mainmenu_option next_comment
++ comment 'General Support Options'
++ bool 'Enable High Speed Descriptors' CONFIG_OTG_HIGH_SPEED
++ # bool 'Enable Root HUB Function' CONFIG_OTG_ROOT_HUB
++ bool 'OTG Fast Tracing' CONFIG_OTG_TRACE
++ tristate 'USB FUNCTION FS Module' CONFIG_OTG_PROCFSM
++ bool 'Disable C99 initializers' CONFIG_OTG_NOC99
++ endmenu
++
++ #
++ # Select USB Peripheral Function Drivers
++ #
++ mainmenu_option next_comment
++ comment 'Targeted Peripherals (USB Peripheral Function Drivers)'
++ source drivers/otg/functions/acm/Config.in
++ source drivers/otg/functions/mouse/Config.in
++ source drivers/otg/functions/network/Config.in
++ source drivers/otg/functions/msc/Config.in
++# source drivers/otg/functions/test/Config.in
++ endmenu
++
++ mainmenu_option next_comment
++ comment 'Traditional Device Options'
++ bool 'Built-in Minimal USB Device' CONFIG_OTG_FW_MN
++ dep_bool 'Enable Auto-Start' CONFIG_OTG_TR_AUTO $CONFIG_OTG_MN
++ endmenu
++ fi
++ #dep_tristate 'Build OTG minihost core' CONFIG_OTG_HOSTCORE $CONFIG_OTG
++ if [ "$CONFIG_OTG_PLATFORM_HOST" != "n" ]; then
++ #
++ # Host configuration
++ #
++ mainmenu_option next_comment
++ comment 'Host configuration (OTG minihost core and HCD)'
++# source drivers/otg/core/Config.in
++ source drivers/otg/ocd/Config.in
++# source drivers/otg/classes/usblan/Config.in
++ endmenu
++ fi
++
++ fi
++
++endmenu
++
+diff -uNr linux/drivers/no-otg/Config.in-orig linux/drivers/otg/Config.in-orig
+--- linux/drivers/no-otg/Config.in-orig 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/Config.in-orig 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,73 @@
++#
++# OTG - configuration of a USB On-The-Go Device
++#
++# Copyright (c) 2004 Belcarra
++#
++# The otg_export script will delete all comments marked "(Testing)"
++#
++
++mainmenu_option next_comment
++
++comment 'OTG devices'
++
++tristate 'Support for USB On-The-Go Devices ' CONFIG_OTG
++
++if [ "$CONFIG_OTG" = "y" -o "$CONFIG_OTG" = "m" ]; then
++ comment ''
++ bool ' Enable High Speed Descriptors' CONFIG_OTG_HIGH_SPEED
++ bool ' Enable Root HUB Function' CONFIG_OTG_ROOT_HUB
++ comment ''
++
++ bool ' Disable PCD' CONFIG_OTG_DISABLE_PCD
++ bool ' Disable HCD' CONFIG_OTG_DISABLE_HCD
++
++ comment ''
++
++ bool ' OTG Proc FS' CONFIG_OTG_PROCFS
++ tristate ' OTG Proc FS Module' CONFIG_OTG_PROCFSM $CONFIG_OTG
++
++ comment 'On-The-Go Functions'
++
++ source drivers/otg/functions/network/Config.in
++ source drivers/otg/functions/acm/Config.in
++ source drivers/otg/functions/msc/Config.in
++
++ source drivers/otg/functions/isotest/Config.in
++ source drivers/otg/functions/mouse/Config.in
++
++ comment ''
++ comment 'On-The-Go Transceiver Controller Drivers (TCD)'
++
++ source drivers/otg/tcd/isp1301/Config.in
++
++ comment ''
++ comment 'On-The-Go Peripheral Controller Drivers (PCD)'
++
++ source drivers/otg/pcd/au1x00/Config.in
++ source drivers/otg/pcd/mx1/Config.in
++ source drivers/otg/pcd/mx2/Config.in
++ source drivers/otg/pcd/pxa/Config.in
++ source drivers/otg/pcd/sa1100/Config.in
++ source drivers/otg/pcd/lh7a400/Config.in
++ source drivers/otg/pcd/omap/Config.in
++ source drivers/otg/pcd/smdk2500/Config.in
++ source drivers/otg/pcd/superh/Config.in
++ source drivers/otg/pcd/sx2/Config.in
++ source drivers/otg/pcd/wmmx/Config.in
++
++ comment ''
++ comment 'On-The-Go Host Controller Drivers (HCD)'
++
++ source drivers/otg/hcd/omap/Config.in
++
++ comment ''
++ tristate ' OTG Fast Tracing' CONFIG_OTG_TRACE
++ comment ''
++
++ comment 'Non Current Bus Drivers (Testing)'
++ source drivers/otg/functions/pst/Config.in
++ source drivers/otg/functions/datalog/Config.in
++
++fi
++
++endmenu
+diff -uNr linux/drivers/no-otg/FIX-MAKEFILES linux/drivers/otg/FIX-MAKEFILES
+--- linux/drivers/no-otg/FIX-MAKEFILES 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/FIX-MAKEFILES 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,23 @@
++#!/bin/sh
++
++ARG=$1
++shift
++
++[ -z "${ARG}" ] && echo Bad args && exit 1
++
++#find . -name Makefile-${ARG} | while read i
++#do
++# m=`expr $i : "\(.*\)-${ARG}"`
++# ln -sfv $i $m
++#done
++
++find . -type d | while read d
++do
++ pushd $d > /dev/null
++ if [ -s Makefile-${ARG} ] ; then
++ echo -n `pwd` ": "
++ ln -sfv Makefile-${ARG} Makefile
++ fi
++ popd >/dev/null
++done
++
+diff -uNr linux/drivers/no-otg/Kconfig linux/drivers/otg/Kconfig
+--- linux/drivers/no-otg/Kconfig 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/Kconfig 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,115 @@
++menu "On-The-Go and USB Peripheral Support"
++
++ config OTG
++ tristate "Support for On-The-Go and USB Peripheral Support"
++ ---help---
++ Configure all or part of the Belcarra OTG Stack
++
++
++ menu "On-The-Go Support"
++ depends on OTG
++
++ source "drivers/otg/config/Kconfig-scma11-evb"
++ #source "drivers/otg/config/Kconfig-omap-h2"
++
++ endmenu
++
++ menu "On-The-Go Support Configuration"
++ depends on OTG_PLATFORM_OTG
++
++ choice
++ depends on OTG && OTG_PLATFORM_OTG
++ prompt "On-The-Go Device Configuration"
++ config OTG_CFG_TR
++ bool "Traditional USB Peripheral"
++ ---help---
++ Compile as a Traditional USB Peripheral.
++ On-The-Go support is enabled.
++ config OTG_CFG_HO
++ bool "Host Only"
++ ---help---
++ Compile the USB Host support without the USB Peripheral
++ support. This is generally only useful for testing the
++ USB Host support and Host Controller drivers.
++ config OTG_CFG_PO
++ bool "Peripheral Only"
++ ---help---
++ Compile as a On-The-Go Peripheral-Only device. This
++ is similiar to a Traditional USB Peripheral but enables
++ On-The-Go features such as SRP.
++ config OTG_CFG_DR
++ bool "Dual Role"
++ ---help---
++ Compile as an On-The-Go Dual-Role device.
++
++ endchoice
++ endmenu
++
++ menu "Targeted Peripheral List (USB Host Class Drivers)"
++ depends on OTG_PLATFORM_OTG
++ # souce "drivers/otg/xxxx"
++ #
++ #---help---
++ #A list of USB peripherals that this device
++ #can support when it is acting as a host.
++ endmenu
++
++ menu "General Support Options"
++
++ depends on OTG_PLATFORM_OTG|| OTG_PLATFORM_USBD
++
++ # This needs to be a specific defined variable that comes
++ # from Kconfig-platform file
++ #
++ #config usb
++ # tristate 'OTG host core support (separate from native Linux host support)'
++
++ config OTG_HIGH_SPEED
++ bool 'Enable high speed descriptors'
++ depends on OTG!=n
++
++ config OTG_TRACE
++ bool 'OTG Fast Tracing'
++ depends on OTG!=n
++ ---help---
++ This option implements register trace to support
++ driver debugging.
++
++ #config OTG_ROOT_HUB
++ # bool 'Enable Root HUB Function'
++ # depends on OTG!=n
++
++ config OTG_PROCFS
++ bool 'OTG Proc FS'
++ depends on OTG!=n
++ ---help---
++ This option enables /proc/ support in various modules
++ Note: Some information previously exposed via the /proc
++ interface is now exposed via a different mechanism
++
++ config OTG_PROCFSM
++ tristate 'OTG Proc FS Module'
++ depends on OTG != n
++ ---help---
++ Build in extra support to perform various operations
++ through the /proc filesystem. Note: this module is
++ held over from the Device stack and its functions are
++ gradually being transferred to the OTG Admin API.
++
++ endmenu
++
++
++ menu "Targeted Peripherals List (USB Peripheral Function Drivers)"
++ depends on OTG_PLATFORM_OTG || OTG_PLATFORM_USBD
++ #---help---
++ #A list of USB peripheral types that this device
++ #can emulate when it is acting as a peripheral.
++ source "drivers/otg/functions/acm/Kconfig"
++ source "drivers/otg/functions/mouse/Kconfig"
++ source "drivers/otg/functions/msc/Kconfig"
++ source "drivers/otg/functions/network/Kconfig"
++ endmenu
++
++
++endmenu
++
+diff -uNr linux/drivers/no-otg/Makefile linux/drivers/otg/Makefile
+--- linux/drivers/no-otg/Makefile 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/Makefile 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,132 @@
++#
++# Belcarra OTG - On-The-Go
++#
++# Copyright (c) 2004 Belcarra Technologies Corp
++
++TOPDIR ?= ../../..
++
++# order here may be important (determines linking order, thus module init order)
++subdir-y := otgcore functions ocd
++subdir-m := otgcore functions ocd
++subdir-n :=
++subdir- :=
++# The target object and module list name.
++
++O_TARGET := otg_drv.o
++
++# Objects that export symbols.
++
++#export-objs := usbd.o usbd-bops.o usbd-fops.o usbd-pcd.o ep0.o hub.o
++
++# Multipart objects. (core layer)
++
++
++# Optional parts of multipart objects.
++
++# Object file lists.
++
++obj-y :=
++obj-m :=
++obj-n :=
++obj- :=
++
++# Each configuration option enables a list of files.
++
++ifeq ($(CONFIG_OTG),y)
++obj-y += otgcore/otgcore.o
++endif
++
++
++# Object files in subdirectories (There has to be a better way to do this)
++
++#=== Function drivers
++f-obj-y :=
++f-obj-m :=
++f-obj-n :=
++f-obj- :=
++
++f-obj-$(CONFIG_OTG_ACM) += functions/function_target.o
++f-obj-$(CONFIG_OTG_ISOTEST) += functions/function_target.o
++f-obj-$(CONFIG_OTG_MSC) += functions/function_target.o
++f-obj-$(CONFIG_OTG_MOUSE) += functions/function_target.o
++f-obj-$(CONFIG_OTG_NETWORK) += functions/function_target.o
++f-obj-$(CONFIG_OTG_PST) += functions/function_target.o
++
++# Remove any duplicate entries in the list by sorting (since that drops dups)
++obj-y += $(sort $(f-obj-y))
++#obj-m += $(sort $(f-obj-m))
++obj-n += $(sort $(f-obj-n))
++obj- += $(sort $(f-obj-))
++
++#=== Peripheral controller drivers
++p-obj-y :=
++p-obj-m :=
++p-obj-n :=
++p-obj- :=
++
++p-obj-$(CONFIG_OTG_AU1X00) += ocd/ocd_target.o
++p-obj-$(CONFIG_OTG_AU1550_DB1550_TR) += ocd/ocd_target.o
++
++# Remove any duplicate entries in the list by sorting (since that drops dups)
++obj-y += $(sort $(p-obj-y))
++#obj-m += $(sort $(p-obj-m))
++obj-n += $(sort $(p-obj-n))
++obj- += $(sort $(p-obj-))
++
++#=== Host controller drivers
++h-obj-y :=
++h-obj-m :=
++h-obj-n :=
++h-obj- :=
++
++
++# Remove any duplicate entries in the list by sorting (since that drops dups)
++obj-y += $(sort $(h-obj-y))
++#obj-m += $(sort $(h-obj-m))
++obj-n += $(sort $(h-obj-n))
++obj- += $(sort $(h-obj-))
++
++
++#=== Class drivers
++class-obj-y :=
++class-obj-m :=
++class-obj-n :=
++class-obj- :=
++
++#class-obj-$(CONFIG_OTG_CLASS_USBLAN) += classes/class_target.o
++
++# Remove any duplicate entries in the list by sorting (since that drops dups)
++obj-y += $(sort $(class-obj-y))
++#obj-m += $(sort $(f-obj-m))
++#obj-n += $(sort $(f-obj-n))
++#obj- += $(sort $(f-obj-))
++
++
++
++# 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
++
+diff -uNr linux/drivers/no-otg/Makefile-l26 linux/drivers/otg/Makefile-l26
+--- linux/drivers/no-otg/Makefile-l26 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/Makefile-l26 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,7 @@
++#
++# Belcarra OTG - On-The-Go
++#
++# Copyright (c) 2004 Belcarra Technologies Corp
++
++obj-y +=
++obj-m += functions/ ocd/ otgcore/ core/
+diff -uNr linux/drivers/no-otg/OWNER linux/drivers/otg/OWNER
+--- linux/drivers/no-otg/OWNER 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/OWNER 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,20 @@
++OWNER: Belcarra Technologies Corp
++LICENSEE: Freescale
++
++THIS SOURCE CODE KIT IS SUPPLIED UNDER LICENSE
++
++Unless expressly modified elsewhere, the author of
++each source file included herein retains ownership
++of the identified file notwithstanding release of
++a specific version under a Public License such as
++the GNU General Public License.
++
++The line OWNER(entity) in a comment line at or near
++the top of a source file expressly asserts ownership
++of the file by that entity or person.
++
++In addition the presence of an OWNER.TXT or OWNER
++file in a directory asserts ownership of the contents
++of that directory and of the compilation thereof into
++the present and derivative kits.
++
+diff -uNr linux/drivers/no-otg/README linux/drivers/otg/README
+--- linux/drivers/no-otg/README 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/README 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,11 @@
++otg/README
++
++This is the top level of the OTG toolkit source tree.
++
++ classes Host Class drivers
++ functions Peripheral Function drivers
++ ocd OTG Controller drivers
++ otgcore OTG State Machine and USB Device stack
++ otghw Hardware related include files
++ otg Include files
++
+diff -uNr linux/drivers/no-otg/config/Config.in-au1x00 linux/drivers/otg/config/Config.in-au1x00
+--- linux/drivers/no-otg/config/Config.in-au1x00 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/config/Config.in-au1x00 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,29 @@
++#
++# Copyright (c) 2004 Belcarra
++#
++
++# Au1x00 on DB1100, PB1100 and PB1500
++
++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 AU1X00 Bus Interface'
++
++ dep_tristate 'DB1100/PB1100/PB1500 Development Boards Support' CONFIG_OTG_AU1X00 $CONFIG_OTG
++
++ if [ "$CONFIG_OTG_AU1X00" != "n" ]; then
++ int 'AU1X00 System Clock' CONFIG_OTG_AU1X00_SCLOCK 400
++ define_bool CONFIG_AU1000_USB_DEVICE n
++ define_bool CONFIG_AU1X00_USB_DEVICE y
++ define_bool CONFIG_OTG_PLATFORM_USBD y
++ #else
++ # define_bool CONFIG_OTG_PLATFORM_USBD n
++ fi
++ endmenu
++fi
++
+diff -uNr linux/drivers/no-otg/config/Config.in-db1550 linux/drivers/otg/config/Config.in-db1550
+--- linux/drivers/no-otg/config/Config.in-db1550 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/config/Config.in-db1550 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,48 @@
++#
++# Copyright (c) 2004 Belcarra
++#
++
++if [ "$CONFIG_MIPS_DB1550" = "y" -o "$CONFIG_MIPS_MTX2" ]
++then
++ mainmenu_option next_comment
++ comment 'DB1550 Development Board'
++
++ dep_tristate 'DB1550 Development Boards Support' CONFIG_OTG_DB1550 $CONFIG_OTG
++
++ #define_tristate CONFIG_OTG_AU1550
++
++ if [ "$CONFIG_OTG_DB1550" != "n" ]; then
++ int 'AU1X00 System Clock' CONFIG_OTG_AU1X00_SCLOCK 400
++ define_bool CONFIG_AU1000_USB_DEVICE n
++ define_bool CONFIG_AU1X00_USB_DEVICE n
++ define_bool CONFIG_OTG_PLATFORM_USBD y
++ define_tristate CONFIG_OTG_AU1550 $CONFIG_OTG_DB1550
++
++ choice 'Select DB1550 Standard B or Mini A-B Port' \
++ "Mini-B-J14 CONFIG_OTG_DB1550_J14 \
++ Mini-A-B-J15 CONFIG_OTG_DB1550_J15" Mini-B-J14
++
++ if [ "$CONFIG_OTG_DB1550_J14" = "y" ]; then
++ define_bool CONFIG_OTG_PLATFORM_OTG n
++ define_bool CONFIG_OTG_PLATFORM_USBD y
++ define_bool CONFIG_OTG_MAX3353E n
++ define_tristate CONFIG_OTG_AU1550_DB1550_TR $CONFIG_OTG_DB1550
++
++ else
++ if [ "$CONFIG_OTG_DB1550_J15" = "y" ]; then
++ define_bool CONFIG_OTG_PLATFORM_OTG y
++ define_bool CONFIG_OTG_PLATFORM_USBD n
++ define_bool CONFIG_OTG_MAX3353E y
++ define_tristate CONFIG_OTG_MAX3353E_DB1550 $CONFIG_OTG_DB1550
++ define_tristate CONFIG_OTG_AU1550_DB1550_DR $CONFIG_OTG_DB1550
++
++ # J15 is external OTG Transceiver Client
++ define_bool CONFIG_OTG_DB1550_HXOE n
++ define_bool CONFIG_OTG_DB1550_HXS y
++ define_int CONFIG_OTG_DB1550_SEOS 4
++ fi
++ fi
++ fi
++ endmenu
++fi
++
+diff -uNr linux/drivers/no-otg/config/Config.in-dbmx1 linux/drivers/otg/config/Config.in-dbmx1
+--- linux/drivers/no-otg/config/Config.in-dbmx1 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/config/Config.in-dbmx1 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,19 @@
++#
++# Copyright (c) 2004 Belcarra
++#
++
++# MX1ADS - Motorola MX1
++
++if [ "$CONFIG_ARCH_MX1ADS" = "y" ]; then
++
++ mainmenu_option next_comment
++ comment 'Motorola MX1 Bus Interface'
++ dep_tristate 'DBMX1 Developement Board Support' CONFIG_OTG_DBMX1 $CONFIG_OTG
++
++ if [ "$CONFIG_OTG_DBMX1" != "n" ]; then
++ define_bool CONFIG_OTG_PLATFORM_USBD y
++ else
++ define_bool CONFIG_OTG_PLATFORM_USBD n
++ fi
++ endmenu
++fi
+diff -uNr linux/drivers/no-otg/config/Config.in-isp1301 linux/drivers/otg/config/Config.in-isp1301
+--- linux/drivers/no-otg/config/Config.in-isp1301 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/config/Config.in-isp1301 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,25 @@
++
++#
++# Copyright (c) 2004 Belcarra
++#
++# ISP 1301 TCD
++
++#if [ "$CONFIG_OTG_ISP1301" = "y" ]; then
++# mainmenu_option next_comment
++# comment 'ISP 1301'
++#
++# #bool 'Proc FS debug' CONFIG_OTG_ISP1301_PROCFSX
++# #bool 'Enable High Speed Descriptors' CONFIG_OTG_HIGH_SPEEDX
++# define_bool CONFIG_OTG_TEST y
++#
++# endmenu
++#fi
++if [ "$CONFIG_OTG_ISP1301" = "y" ]; then
++
++ mainmenu_option next_comment
++ comment 'ISP 1301'
++ bool 'Proc FS debug' CONFIG_OTG_ISP1301_PROCFS
++
++ endmenu
++fi
++
+diff -uNr linux/drivers/no-otg/config/Config.in-max3353e linux/drivers/otg/config/Config.in-max3353e
+--- linux/drivers/no-otg/config/Config.in-max3353e 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/config/Config.in-max3353e 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,25 @@
++
++#
++# Copyright (c) 2004 Belcarra
++#
++# MAX 3353E TCD
++
++#if [ "$CONFIG_OTG_MAX3353E" = "y" ]; then
++# mainmenu_option next_comment
++# comment 'MAX 3353E'
++#
++# #bool 'Proc FS debug' CONFIG_OTG_MAX3353E_PROCFSX
++# #bool 'Enable High Speed Descriptors' CONFIG_OTG_HIGH_SPEEDX
++# define_bool CONFIG_OTG_TEST y
++#
++# endmenu
++#fi
++if [ "$CONFIG_OTG_MAX3353E" = "y" ]; then
++
++ mainmenu_option next_comment
++ comment 'MAX 3353E'
++ bool 'Proc FS debug' CONFIG_OTG_MAX3353E_PROCFS
++
++ endmenu
++fi
++
+diff -uNr linux/drivers/no-otg/config/Config.in-mordor linux/drivers/otg/config/Config.in-mordor
+--- linux/drivers/no-otg/config/Config.in-mordor 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/config/Config.in-mordor 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,28 @@
++#
++# Copyright (c) 2004 Belcarra
++#
++
++# Au1x00 on DB1100, PB1100 and PB1500
++
++if [ "$CONFIG_AMX_MORDOR" = "y" ]
++then
++ mainmenu_option next_comment
++ comment 'AMX Mordor Board'
++
++ dep_tristate 'AMX Mordor Board Support' CONFIG_OTG_AU1550 $CONFIG_OTG
++ define_tristate CONFIG_OTG_BVD $CONFIG_OTG_AU1550
++
++ if [ "$CONFIG_OTG_AU1550" != "n" ]; then
++ int 'AU1X00 System Clock' CONFIG_OTG_AU1X00_SCLOCK 400
++ define_bool CONFIG_AU1000_USB_DEVICE n
++ define_bool CONFIG_AU1X00_USB_DEVICE n
++ define_bool CONFIG_OTG_PLATFORM_USBD y
++
++ define_bool CONFIG_OTG_PLATFORM_OTG n
++ define_bool CONFIG_OTG_PLATFORM_USBD y
++
++ else
++ define_bool CONFIG_OTG_PLATFORM_USBD n
++ fi
++ endmenu
++fi
+diff -uNr linux/drivers/no-otg/config/Kconfig-omap-h2 linux/drivers/otg/config/Kconfig-omap-h2
+--- linux/drivers/no-otg/config/Kconfig-omap-h2 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/config/Kconfig-omap-h2 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,87 @@
++#
++# Copyright (c) 2004 Belcarra
++#
++
++# OMAP - TI OMAP 1610
++#
++
++# CONFIG_OTG_PLATFORM_OTG # Offer OTG Configuration
++
++# CONFIG_OTG_OMAP # Make OMAP driver
++# CONFIG_OTG_ISP1301 # Make ISP1301 driver
++
++# CONFIG_OTG_ISP1301_OMAP_H2 # Compile ISP1301 OMAP H2 driver
++
++# CONFIG_OTG_OMAP_H2 # OMAP Helen 2 board
++# CONFIG_OTG_OMAP_H2_3_WIRE # Use 3 Wire OTG Configuration
++# CONFIG_OTG_OMAP_H2_4_WIRE # Use 4 Wire OTG Configuration
++# CONFIG_OTG_OMAP_H2_DR # Compile as OTG Dual-role Device
++# CONFIG_OTG_OMAP_H2_TR # Compile as Traditional USB Peripheral
++
++config OTG_OMAP_H2
++ tristate "OMAP 1610 H2 Development Board"
++ depends on OTG && ARCH_OMAP
++ ---help---
++ This implements On-The-Go USB Support for the Helen 2 OMAP
++ Development Board.
++
++choice
++ prompt "Select Transceiver wire configuration"
++ depends on OTG && ARCH_OMAP && OTG_OMAP_H2
++ config OTG_OMAP_H2_3_WIRE
++ bool 'Enable Pin Group 1, 3 Wire Configuration'
++ depends on OMAP_H2 !=n
++ ---help---
++ The H2 board ISP1301 can be configured in either
++ the 3 wire or 4 wire configuration.
++ This enables the ISP1301 on the H2 board on Pin Group 1
++ using the 3-Wire OTG Transceiver Configuration. This
++ requires that the ISP1301 be configured for DAT_SE0.
++
++ config OTG_OMAP_H2_4_WIRE
++ bool 'Enable Pin Group 1, 4 Wire Configuration'
++ depends on OMAP_H2 !=n
++ ---help---
++ The H2 board ISP1301 can be configured in either
++ the 3 wire or 4 wire configuration.
++ This enables the ISP1301 on the H2 board on Pin Group 1
++ using the 3-Wire OTG Transceiver Configuration. This
++ requires that the ISP1301 be configured for VP_VM.
++
++endchoice
++
++config OTG_PLATFORM_OTG
++ bool
++ default OTG_OMAP_H2
++
++config OTG_OMAP_H2_TR
++ tristate
++ depends on OTG_CFG_TR
++ default OTG_OMAP_H2
++
++config OTG_OMAP_H2_HO
++ tristate
++ depends on OTG_CFG_HO
++ default OTG_OMAP_H2
++
++config OTG_OMAP_H2_PO
++ tristate
++ depends on OTG_CFG_PO
++ default OTG_OMAP_H2
++
++config OTG_OMAP_H2_DR
++ tristate
++ depends on OTG_CFG_DR
++ default OTG_OMAP_H2
++
++
++config OTG_ISP1301
++ tristate
++ depends on OTG_OMAP_H2
++ default OTG_OMAP_H2
++
++config OTG_ISP1301_OMAP_H2
++ tristate
++ depends on OTG_OMAP_H2
++ default OTG_OMAP_H2
++
+diff -uNr linux/drivers/no-otg/config/README-CONFIG.txt linux/drivers/otg/config/README-CONFIG.txt
+--- linux/drivers/no-otg/config/README-CONFIG.txt 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/config/README-CONFIG.txt 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,106 @@
++OTG System Configuration Stuart Lynne
++Belcarra Thu Jan 13 15:45:19 PST 2005
++
++This directory contains the linux system configurations to create
++architecture or board level drivers for On-The-Go or USB Device support.
++
++There are four generic configurations available
++
++ - tr - Traditional USB Peripheral
++ - po - OTG Peripheral only
++ - dr - OTG Dual-Role device
++
++Traditional USB Peripheral
++**************************
++
++Older types of systems supported USB peripherals as a separate module. It is
++not generally possible to configure these with On-The-Go support. In most
++cases the only customization available is for detection of the Vbus (cable
++attached) and control over the D-plus pullup resistor (soft-connect.)
++
++For most of these types of systems the generated driver will be of the form:
++
++ xxx_tr
++
++Where xxx is the system architecture:
++
++ au1x00
++ lh7a400
++ mx1
++ pxa
++ sa1100
++ smdk2500
++ superh
++
++
++OTG Modes
++*********
++
++Generally new systems that support On-The-Go have (at least) the following
++components:
++
++ - USB Peripheral
++ - USB Host
++ - OTG Transceiver
++ - Charge Pump (optional)
++
++In general the combination of the above is customized at the board or
++platform level, not the architecture (chip) level. There may be up to four
++different drivers implementing various combinations of the required support.
++
++Required support:
++
++ - pcd - Peripheral Controller Driver
++ - tcd - Transceiver Controller Driver
++ - hcd - Host Controller Driver
++ - ocd - OTG Controller Driver
++
++Typically the pcd and ocd drivers will be in a single module. This module
++will be named:
++
++ xxxx_ss
++
++Where xxxx is the platform, e.g.:
++
++ mainstone
++ mx1ads
++ omap-h2
++
++And ss is the type of OTG support being compiled:
++
++ - tr - traditonal usb
++ - ho - host only
++ - po - peripheral only
++ - dr - dual-role
++
++
++
++OTG Peripheral Only (po)
++************************
++
++This mode allows for implementing a restricted mode of On-The-Go support.
++The host driver module is not configured or available.
++
++
++OTG Dual-Role Device (dr)
++*************************
++
++This mode implements the full On-The-Go stack with both USB Device and Usb
++Host support.
++
++
++Configuration File
++******************
++
++Under linux, older systems (those that support only traditional devices) will
++have a generic Config.in / Kconfig file to generate the required driver.
++
++For newer systems that support OTG type configurations there should be a
++Configuration file for each major platform supported. This will specifically
++enable defines for all of the required drivers and their options.
++
++Platform files may have several sub-types with appropriate configuration
++selectors.
++
++
++
+diff -uNr linux/drivers/no-otg/dirs linux/drivers/otg/dirs
+--- linux/drivers/no-otg/dirs 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/dirs 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,11 @@
++!if 0
++Copyright (c) 2004 Belcarra
++!endif
++
++DIRS= \
++ wince \
++ otgcore \
++ functions/mouse
++
++OPTIONAL_DIRS= \
++
+diff -uNr linux/drivers/no-otg/functions/Makefile linux/drivers/otg/functions/Makefile
+--- linux/drivers/no-otg/functions/Makefile 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/Makefile 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,53 @@
++#
++# Belcarra OTG - On-The-Go
++#
++# Copyright (c) 2004 Belcarra Technologies Corp
++
++TOPDIR ?= ../../../..
++
++subdir-y :=
++subdir-m :=
++subdir-n :=
++subdir- :=
++
++# The target object and module list name.
++
++O_TARGET := function_target.o
++
++# Function Drivers
++subdir-$(CONFIG_OTG_ACM) += acm
++subdir-$(CONFIG_OTG_ISOTEST) += isotest
++subdir-$(CONFIG_OTG_MSC) += msc
++subdir-$(CONFIG_OTG_MOUSE) += mouse
++subdir-$(CONFIG_OTG_NETWORK) += network
++
++# Object file lists.
++
++obj-y :=
++obj-m :=
++obj-n :=
++obj- :=
++
++# Function drivers
++ifeq ($(CONFIG_OTG_ACM),y)
++obj-y += acm/acm_fd_drv.o
++endif
++ifeq ($(CONFIG_OTG_MOUSE),y)
++obj-y += mouse/mouse_target.o
++endif
++ifeq ($(CONFIG_OTG_NETWORK),y)
++obj-y += network/network_target.o
++endif
++ifeq ($(CONFIG_OTG_MSC),y)
++obj-y += msc/msc_target.o
++endif
++ifeq ($(CONFIG_OTG_PST),y)
++obj-y += pst/pst_target.o
++endif
++ifeq ($(CONFIG_OTG_TEST),y)
++obj-y += test/test_target.o
++endif
++
++include $(TOPDIR)/Rules.make
++EXTRA_CFLAGS += -Wno-format -Wall
++
+diff -uNr linux/drivers/no-otg/functions/Makefile-l26 linux/drivers/otg/functions/Makefile-l26
+--- linux/drivers/no-otg/functions/Makefile-l26 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/Makefile-l26 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,12 @@
++#
++# Belcarra OTG - On-The-Go
++#
++# Copyright (c) 2004 Belcarra Technologies Corp
++
++EXTRA_CFLAGS += -Wno-format -Wall
++# Function Drivers
++obj-$(CONFIG_OTG_ACM) += acm/
++obj-$(CONFIG_OTG_MSC) += msc/
++obj-$(CONFIG_OTG_MOUSE) += mouse/
++obj-$(CONFIG_OTG_NETWORK) += network/
++
+diff -uNr linux/drivers/no-otg/functions/acm/Config.in linux/drivers/otg/functions/acm/Config.in
+--- linux/drivers/no-otg/functions/acm/Config.in 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/Config.in 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,28 @@
++#
++# CDC ACM Function Driver
++#
++# Copyright (C) 2003,2004 Belcarra
++#
++
++mainmenu_option next_comment
++comment "USB Peripheral Function Driver - CDC ACM"
++
++dep_tristate ' CDC ACM Function' CONFIG_OTG_ACM $CONFIG_OTG
++if [ "$CONFIG_OTG_ACM" != "n" ]; then
++ hex 'VendorID (hex value)' CONFIG_OTG_ACM_VENDORID "15ec"
++ hex 'ProductID (hex value)' CONFIG_OTG_ACM_PRODUCTID "f002"
++ hex 'bcdDevice (binary-coded decimal)' CONFIG_OTG_ACM_BCDDEVICE "0100"
++
++ string 'iManufacturer (string)' CONFIG_OTG_ACM_MANUFACTURER "Belcarra"
++ string 'iProduct (string)' CONFIG_OTG_ACM_PRODUCT_NAME "Belcarra ACM Device"
++
++ string 'iConfiguration (string)' CONFIG_OTG_ACM_DESC "Acm Cfg"
++ string 'Comm Interface iInterface (string)' CONFIG_OTG_ACM_COMM_INTF "Comm Intf"
++ string 'Data Interface iInterface (string)' CONFIG_OTG_ACM_DATA_INTF "Data Intf"
++
++ comment ''
++ #bool 'Communications Device' CONFIG_OTG_ACM_COMM
++ #bool 'TTY Device' CONFIG_OTG_ACM_TTY
++fi
++
++endmenu
+diff -uNr linux/drivers/no-otg/functions/acm/Kconfig linux/drivers/otg/functions/acm/Kconfig
+--- linux/drivers/no-otg/functions/acm/Kconfig 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/Kconfig 2006-09-01 21:41:25.000000000 +0200
+@@ -0,0 +1,54 @@
++menu "OTG ACM Function"
++
++config OTG_ACM
++ tristate " CDC ACM Function"
++ depends on OTG
++
++menu "OTG ACM function options"
++ depends on OTG && OTG_ACM
++
++config OTG_ACM_VENDORID
++ hex "VendorID (hex value)"
++ depends on OTG_ACM && OTG
++ default "0x15ec"
++
++config OTG_ACM_PRODUCTID
++ depends on OTG_ACM && OTG
++ hex "ProductID (hex value)"
++ default "0xe003"
++config OTG_ACM_BCDDEVICE
++ depends on OTG_ACM && OTG
++ hex "bcdDevice (binary-coded decimal)"
++ default "0x0100"
++
++config OTG_ACM_MANUFACTURER
++ depends on OTG_ACM && OTG
++ string "iManufacturer (string)"
++ default "Belcarra"
++
++config OTG_ACM_PRODUCT_NAME
++ depends on OTG_ACM && OTG
++ string "iProduct (string)"
++ default "Belcarra ACM Device"
++
++config OTG_ACM_DESC
++ depends on OTG_ACM && OTG
++ string "iConfiguration (string)"
++ default "Acm Cfg"
++
++config OTG_ACM_COMM_INTF
++ depends on OTG_ACM && OTG
++ string "Comm Interface iInterface (string)"
++ default "Comm Intf"
++
++config OTG_ACM_DATA_INTF
++ depends on OTG_ACM && OTG
++ string "Data Interface iInterface (string)"
++ default "Data Intf"
++
++config OTG_ACM_TRACE
++ depends on OTG_ACM && OTG
++ bool " ACM Tracing"
++ default n
++endmenu
++endmenu
+diff -uNr linux/drivers/no-otg/functions/acm/Makefile linux/drivers/otg/functions/acm/Makefile
+--- linux/drivers/no-otg/functions/acm/Makefile 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/Makefile 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,80 @@
++#
++# Function driver for a CDC ACM USB Device
++#
++# Copyright (c) 2003 Belcarra
++
++# Multipart objects.
++
++O_TARGET := acm_fd_drv.o
++list-multi := acm_fd.o tty_fd.o
++
++#modem_fd-objs := acm-fd.o modem-l24-os.o modem.o
++#obex_fd-objs := acm-fd.o obex-l24-os.o obex.o
++tty_fd-objs := acm-fd.o tty-l24-os.o tty-fd.o
++
++# Objects that export symbols.
++#export-objs := acm-fd.o
++
++# Object file lists.
++
++obj-y :=
++obj-m :=
++obj-n :=
++obj- :=
++
++# Each configuration option enables a list of files.
++
++#obj-$(CONFIG_OTG_ACM) += modem_fd.o
++#obj-$(CONFIG_OTG_ACM) += obex_fd.o
++obj-$(CONFIG_OTG_ACM) += tty_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.
++
++ACMD=$(OTG)/functions/acm
++
++OTG_DIR=$(TOPDIR)/drivers/otg
++OTGCORE_DIR=$(OTG_DIR)/otgcore
++#USBDCORE_DIR=$(OTG_DIR)/usbdcore
++include $(TOPDIR)/Rules.make
++EXTRA_CFLAGS += -I$(OTG_DIR) -Wno-unused -Wno-format -I$(OTGCORE_DIR)
++EXTRA_CFLAGS_nostdinc += -I$(OTG_DIR) -Wno-unused -Wno-format -I$(OTGCORE_DIR)
++
++# Link rules for multi-part drivers.
++
++modem_fd.o: $(modem_fd-objs)
++ $(LD) -r -o $@ $(modem_fd-objs)
++
++obex_fd.o: $(obex_fd-objs)
++ $(LD) -r -o $@ $(obex_fd-objs)
++
++tty_fd.o: $(tty_fd-objs)
++ $(LD) -r -o $@ $(tty_fd-objs)
++
++# dependencies:
++
++#modem.o: $(USBDCORE_DIR)/usbd.h $(USBDCORE_DIR)/usbd-bus.h $(USBDCORE_DIR)/usbd-func.h
++#obex.o: $(USBDCORE_DIR)/usbd.h $(USBDCORE_DIR)/usbd-bus.h $(USBDCORE_DIR)/usbd-func.h
++#tty.o: $(USBDCORE_DIR)/usbd.h $(USBDCORE_DIR)/usbd-bus.h $(USBDCORE_DIR)/usbd-func.h
++
+diff -uNr linux/drivers/no-otg/functions/acm/Makefile-l26 linux/drivers/otg/functions/acm/Makefile-l26
+--- linux/drivers/no-otg/functions/acm/Makefile-l26 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/Makefile-l26 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,13 @@
++# Function driver for a CDC ACM OTG Device
++#
++# Copyright (c) 2004 Belcarra
++
++acm_fd-objs := acm-fd.o acm-l26-os.o
++
++obj-$(CONFIG_OTG_ACM) += acm_fd.o
++
++OTG=$(TOPDIR)/drivers/otg
++ACMD=$(OTG)/functions/acm
++USBDCORE_DIR=$(OTG)/usbdcore
++EXTRA_CFLAGS += -I$(ACMD) -I$(OTG) -Wno-unused -Wno-format -I$(USBDCORE_DIR)
++EXTRA_CFLAGS_nostdinc += -I$(ACMD) -I$(OTG) -Wno-unused -Wno-format -I$(USBDCORE_DIR)
+diff -uNr linux/drivers/no-otg/functions/acm/OBEX-TODO.txt linux/drivers/otg/functions/acm/OBEX-TODO.txt
+--- linux/drivers/no-otg/functions/acm/OBEX-TODO.txt 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/OBEX-TODO.txt 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,16 @@
++OBEX TODO List Stuart Lynne
++Belcarra Tue Aug 24 21:36:09 PDT 2004
++
++
++1. OBEX documentation
++
++
++2. define obex requirements
++
++ - similiar to acm
++ - uses comm interface for ?
++ - impelements data/nodata inteface
++
++ - socket family interface
++ - char device interface
++
+diff -uNr linux/drivers/no-otg/functions/acm/TODO.txt linux/drivers/otg/functions/acm/TODO.txt
+--- linux/drivers/no-otg/functions/acm/TODO.txt 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/TODO.txt 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,143 @@
++ACM TODO List Stuart Lynne
++Belcarra Wed Sep 01 19:48:38 PDT 2004
++
++
++1. The ACM driver needs to be expanded to allow it to build three ways:
++
++
++ - tty equivalent of old acm, uses linux tty layer
++ - modem present two simple char devices for data and comm interfaces
++ - obex single simple char device
++
++TTY
++ - present a single char device with TTY line discipline
++ - TIOCM calls represent "state" of emulated serial port on this
++ side of null modem
++ - notifications and line state only affect far side of null modem
++
++MODEM
++ - present two simple char device interfaces
++ - data char device will implement TIOCM ioctls
++ - comm char device will use encapsulated data over endpoint zero
++ - TIOCM calls represent state passed to/from host via notifications
++ and line state requests
++
++OBEX
++ - present a single simple char device interface
++ - no requirement for either TIOCM or TTY line discipline
++ - TIOCM calls not implemented
++
++
++
++2. The modem device must implement a virtual NULL modem and support the
++following IOCTL's.
++
++
++
++Virtual NULL Modem
++
++Peripheral to Host via Serial State Notification (write ioctls)
++
++Application TIOCM Null Modem ACM (DCE) Notificaiton Host (DTE)
++-------------------------------------------------------------------------------------------------------------
++Request to send TIOCM_RTS RTS -> CTS CTS Not Available Clear to Send (N/A)
++Data Terminal Ready TIOCM_DTR DTR -> DSR DSR bTxCarrier Data Set Ready
++ DTR -> DCD DCD bRXCarrier Carrier Detect
++Ring Indicator TIOCM_OUT1 OUT1 -> RI RI bRingSignal Ring Indicator
++Send Break TIOCM_OUT2 OUT2 -> Break Break bBreak Break Received
++-------------------------------------------------------------------------------------------------------------
++
++
++Host to Peripheral via Set Control Line State
++
++Host (DTE) Line State ACM (DCE) Null Modem TIOCM Peripheral (DTE)
++-------------------------------------------------------------------------------------------------------------
++Data Terminal Ready D0 DTR DTR -> DSR TIOCM_DSR Data Set Ready
++ DTR -> DCD TIOCM_CAR Carrier Detect
++Request To Send D1 RTS RTS -> CTS TIOCM_CTS Clear to Send
++-------------------------------------------------------------------------------------------------------------
++
++
++3. The following DEVICE REQUESTS have to be implemented and where
++possible support added to hook the results to the upper layers
++and applications.
++
++ SetCommFeature
++ GetCommFeature
++ ClearCommFeature
++
++ SendEncapsulatedCommand
++ GetEncapsulatedResponse
++
++ SetLineCoding
++ GetLineCoding
++
++ SetControlLineState
++
++ SendBreak
++
++4. The following NOTIFICATIONS need to be implemented and where
++possible hooked to appropriate indications from upper layers
++and applications.
++
++
++ RESPONSE_AVAILABLE
++ NETWORK_CONNECTION
++ SERIAL_STATE
++
++
++
++5. ACM documentation needs to be updated to reflect implementation(s).
++
++
++6. POSIX IOCTLS
++ - TIOCM*
++ - hook into flow control or set from flow control as required
++ - baudrate and other device settings
++ - CTS should disable receive urb
++
++7. COMM Interface
++ - GET / SEND Encapsulated command
++ - response available notification
++ - char device interface
++
++8. Optional TTY
++ - register as TTY device only if requested
++ - register as simple char device otherwise
++
++9. select()
++ - trackdown tty layer problem with select()
++ - sometimes fails under stress testing
++
++
++Notes..
++
++1. implementation of the comm and simple char device can probably share
++the same code base. These should queue received urbs. This will mean
++a small change in the os between acm_recv_urb() and the os specific
++layer.
++
++2. Now it is acm_os_recv_chars(), this must change to acm_os_recv_urbs().
++The acm_os_recv_urbs() function will be responsible for deallocing the
++urb when delivered.
++
++3. The various os specific functions will need to have a method to
++distinguish between the comm and data interfaces.
++
++
++
++
++10. WMC - Wireless Mobice Class
++
++ Call Management - bmCapabilities allow call management over data interface
++ ACM - bmCapabilities - 0x06, only SEND_BREAK, SET/GET LINE_CODING
++
++ NETWORK_CONNECTION, XXX_COMM_FEATURE not allowed
++
++ Call management over COMM interface optional
++
++ COMM_FEATURE - optional?
++
++
++
++
+diff -uNr linux/drivers/no-otg/functions/acm/acm-fd.c linux/drivers/otg/functions/acm/acm-fd.c
+--- linux/drivers/no-otg/functions/acm/acm-fd.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/acm-fd.c 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,1077 @@
++/*
++ * otg/functions/acm/acm-fd.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ */
++/*!
++ * @file otg/functions/acm/acm-fd.c
++ * @brief ACM Function Driver private defines
++ *
++ * An ACM (Abstract Control Model) driver is composed of several pieces:
++ *
++ * 1) An OS and function specific piece that handles creating and operating
++ * a device for the given OS suitable for a specific function.
++ *
++ * 2) A set descriptors suitable for the function.
++ *
++ * 3) This acm-fd library which implements the interface to
++ * the usb peripheral and otgcore stacks.
++ *
++ * If the USB piece interfaces with the host usbcore layer you get
++ * an ACM class driver. If the USB piece interfaces with the otgcore
++ * layer you get an ACM function driver.
++ *
++ *
++ * @ingroup ACMFunction
++ */
++
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#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/smp_lock.h>
++#include <linux/slab.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include "acm.h"
++#include "acm-fd.h"
++#include "acm-os.h"
++
++
++static u32 max_queued_urbs;
++static u32 max_queued_bytes;
++
++// 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)
++
++/* ******************************************************************************************* */
++
++STATIC int acm_send_int_notification(struct acm_private *acm, int , int );
++STATIC int acmfd_urb_sent_bulk (struct usbd_urb *urb, int rc);
++STATIC int acmfd_urb_sent_int (struct usbd_urb *urb, int rc);
++STATIC int acmfd_recv_urb (struct usbd_urb *urb, int rc);
++STATIC void acm_schedule_recv(struct acm_private *acm, int interface);
++
++/* ******************************************************************************************* */
++
++/*! acm_ready
++ * @param acm
++ */
++STATIC int acm_ready(struct acm_private *acm)
++{
++ TRACE_MSG5(acm->trace_tag,"CONFIGURED: %x OPENED: %x THROTTLED: %x CARRIER: %x READY: %d",
++ acm->flags & ACM_CONFIGURED, acm->flags & ACM_OPENED,
++ acm->flags & ACM_THROTTLED, acm->flags & ACM_CARRIER,
++ (acm->flags & ACM_CONFIGURED) && (acm->flags & ACM_CARRIER) ? 1 : 0);
++
++ return (acm->flags & ACM_CONFIGURED) &&
++ (acm->flags & ACM_OPENED) &&
++ !(acm->flags & ACM_THROTTLED) &&
++ ((acm->flags & ACM_LOCAL) ? 1 : (acm->flags & ACM_CARRIER) )
++ ;
++
++}
++
++/*! acm_open
++ * @param acm
++ * @param interface
++ * @return int
++ */
++STATIC int acm_open(struct acm_private *acm, int interface)
++{
++ TRACE_MSG0(acm->trace_tag,"OPEN");
++ acm->flags |= ACM_OPENED;
++ acm->flags &= ~ACM_THROTTLED;
++ acm->bmUARTState = CDC_UARTSTATE_BRXCARRIER_DCD | CDC_UARTSTATE_BTXCARRIER_DSR;
++ acm_schedule_recv(acm, interface);
++ TRACE_MSG1(acm->trace_tag,"bmUARTState: %04x", acm->bmUARTState);
++ acm_send_int_notification(acm, CDC_NOTIFICATION_SERIAL_STATE, acm->bmUARTState);
++ return 0;
++}
++
++/*! acm_flush
++ * @param acm
++ * @param interface
++ * @return number of urbs in queue
++ */
++STATIC void acm_flush(struct acm_private *acm, int interface)
++{
++ struct usbd_function_instance *function = acm->function;
++ unsigned long flags;
++ TRACE_MSG0(acm->trace_tag,"FLUSH");
++ RETURN_UNLESS(function);
++ local_irq_save(flags);
++ acm->bytes_received = 0;
++ acm->bytes_forwarded = 0;
++ acm->bmUARTState = CDC_UARTSTATE_BRXCARRIER_DCD | CDC_UARTSTATE_BTXCARRIER_DSR;
++ TRACE_MSG1(acm->trace_tag,"bmUARTState: %04x", acm->bmUARTState);
++ // TBR: 20040705 use ...le32() not le16, spotted by Zhao Liang
++ acm->line_coding.dwDTERate = cpu_to_le32(0x1c200); // 115200
++ acm->line_coding.bDataBits = 0x08;
++
++ usbd_flush_endpoint_index(function, BULK_IN);
++ usbd_flush_endpoint_index(function, BULK_OUT);
++ local_irq_restore(flags);
++}
++
++/*! acm_close
++ * @param acm
++ * @param interface
++ * @return number of urbs in queue
++ */
++STATIC int acm_close(struct acm_private *acm, int interface)
++{
++ TRACE_MSG0(acm->trace_tag,"CLOSE");
++ acm->flags &= ~ACM_OPENED;
++ acm->flags &= ~ACM_THROTTLED;
++ acm_flush(acm, interface);
++ acm->bmUARTState = 0;
++ TRACE_MSG1(acm->trace_tag,"bmUARTState: %04x", acm->bmUARTState);
++ acm_send_int_notification(acm, CDC_NOTIFICATION_SERIAL_STATE, acm->bmUARTState);
++ return 0;
++}
++
++
++/*! acmfd_start_recv_urbs
++ * @param acm
++ * @param interface
++ * @return number of urbs in queue
++ */
++STATIC int acmfd_start_recv_urbs(struct acm_private *acm, int interface)
++{
++ /*
++ * Queue as many receive urbs as the OS layer has room for. Return
++ * the number in the queue (may be more than we queue here).
++ */
++ struct usbd_function_instance *function = acm->function;
++ unsigned long flags;
++ int num_in_queue = 0;
++
++ switch (interface) {
++ case COMM_INTF:
++ return 0;
++ case DATA_INTF:
++ TRACE_MSG1(acm->trace_tag,"START RECV: acm: %x", (int)acm);
++ TRACE_MSG2(acm->trace_tag,"START RECV: connected: %x recv_urbs: %d",
++ acm->flags & ACM_CONFIGURED, acm->recv_urbs);
++
++ local_irq_save(flags);
++ if (acm_ready(acm)) {
++
++ TRACE_MSG2(acm->trace_tag,"START RECV: throttled: %d space_avail: %d", acm->flags & ACM_THROTTLED,
++ acm->function_services->recv_space_available(acm, DATA_INTF));
++
++ while (((acm->recv_urbs + 1) * 64) < acm->function_services->recv_space_available(acm, DATA_INTF)) {
++ struct usbd_urb *urb;
++
++ BREAK_IF(!(urb = usbd_alloc_urb(function, BULK_OUT, usbd_endpoint_transferSize(function,
++ BULK_OUT, usbd_high_speed(function)), acmfd_recv_urb)));
++ acm->recv_urbs++;
++ urb->function_privdata = acm;
++ TRACE_MSG3(acm->trace_tag,"START RECV: %d urb#%p privdata#%p",acm->recv_urbs,urb,acm);
++ CONTINUE_UNLESS (usbd_start_out_urb(urb));
++ acm->recv_urbs--;
++ TRACE_MSG1(acm->trace_tag,"START RECV: %d", acm->recv_urbs);
++ usbd_free_urb(urb);
++ break;
++ }
++ if (!acm->recv_urbs)
++ acm_schedule_recv(acm, interface);
++ }
++ /* There needs to be at least one recv urb queued in order
++ * to keep driving the push to the OS layer, so return how
++ * many there are in case the OS layer must try again later.
++ */
++ num_in_queue = acm->recv_urbs;
++ local_irq_restore(flags);
++ break;
++ }
++ return(num_in_queue);
++}
++
++
++struct acm_work acm_work;
++
++/*! acmfd_start_recv
++ * @param data
++ */
++STATIC void acmfd_start_recv(void *data)
++{
++ struct acm_work *work = data;
++ struct acm_private *acm;
++ unsigned long flags;
++ int interface;
++
++ local_irq_save(flags);
++ acm = work->acm;
++ interface = work->interface;
++ work->acm = NULL;
++ work->interface = -1;
++ acm->recv_tqueue.data = NULL;
++ local_irq_restore(flags);
++ acmfd_start_recv_urbs(acm, interface);
++}
++
++
++/*! acm_schedule_recv
++ * @param acm
++ * @param interface
++ */
++void acm_schedule_recv(struct acm_private *acm, int interface)
++{
++ unsigned long flags;
++ struct acm_work *work = &acm_work;
++ TRACE_MSG1(acm->trace_tag, "sync: %d", acm->recv_tqueue.sync);
++ local_irq_save(flags);
++
++ UNLESS (acm->recv_tqueue.sync && acm->recv_tqueue.data) {
++ work->acm = acm;
++ work->interface = interface;
++ acm->recv_tqueue.routine = &acmfd_start_recv;
++ acm->recv_tqueue.data = work;
++ #if defined(LINUX24)
++ queue_task(&acm->recv_tqueue, &tq_timer);
++ #else
++ SCHEDULE_WORK(acm->recv_tqueue);
++ #endif
++ }
++
++ local_irq_restore(flags);
++}
++
++/* Transmit INTERRUPT ************************************************************************** */
++
++/*! acm_send_int_notfication
++ * Generates a response urb on the notification (INTERRUPT) endpoint.
++ * CALLED from interrupt context.
++ * @return non-zero if error
++ */
++STATIC int acm_send_int_notification(struct acm_private *acm, int bnotification, int data)
++{
++ struct usbd_function_instance *function = acm->function;
++ struct usbd_urb *urb = NULL;
++ struct cdc_notification_descriptor *notification;
++ unsigned long flags;
++ int rc = 0;
++
++ TRACE_MSG4(acm->trace_tag,"used: %d MOD_IN_USE: %d configured: %d data: %04x",
++ atomic_read(&acm->used), MOD_IN_USE, acm->flags & ACM_CONFIGURED, data);
++
++ RETURN_ZERO_UNLESS((acm->flags & ACM_CONFIGURED));
++
++ local_irq_save(flags);
++
++ do {
++ BREAK_IF(!(urb = usbd_alloc_urb(function, INT_IN,
++ sizeof(struct cdc_notification_descriptor),
++ acmfd_urb_sent_int)));
++
++ urb->function_privdata = acm;
++
++ memset(urb->buffer, 0, urb->buffer_length);
++ urb->actual_length = sizeof(struct cdc_notification_descriptor);
++
++ /* 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;
++ }
++
++ BREAK_IF(!(rc = usbd_start_in_urb (urb)));
++
++ urb->function_privdata = NULL;
++ usbd_free_urb (urb);
++
++ TRACE_MSG1(acm->trace_tag,"urbID#%04x --> 0",urbID(urb));
++
++ } while(0);
++
++ local_irq_restore(flags);
++ return(rc);
++}
++
++/* Callback functions for TX urb completion (function chosen when urb is allocated) ***********/
++
++/*! acmfd_urb_sent_bulk - called to indicate bulk URB transmit finished
++ * @param urb pointer to struct usbd_urb
++ * @param rc result
++ * @return non-zero for error
++ */
++STATIC int acmfd_urb_sent_bulk (struct usbd_urb *urb, int rc)
++{
++ struct acm_private *acm = urb->function_privdata;
++ struct usbd_function_instance *function;
++
++ TRACE_MSG2(acm->trace_tag,"entered urbID#%04x rc=%d",urbID(urb),rc);
++ TRACE_MSG3(acm->trace_tag,"used: %d MOD_IN_USE: %d configured: %d",
++ atomic_read(&acm->used), MOD_IN_USE, acm->flags & ACM_CONFIGURED);
++
++ if (!urb || !(function = urb->function_instance)) {
++ TRACE_MSG1(acm->trace_tag,"urbID#%04x --> -EINVAL",urbID(urb));
++ return(-EINVAL);
++ }
++ TRACE_MSG1(acm->trace_tag,"IN length=%d",urb->actual_length);
++
++ atomic_sub(urb->actual_length, &acm->queued_bytes);
++ atomic_dec(&acm->queued_urbs);
++ urb->function_privdata = NULL;
++ usbd_free_urb (urb);
++ if (acm->flags & ACM_OPENED)
++ acm->function_services->schedule_wakeup_writers(acm);
++ TRACE_MSG1(acm->trace_tag,"urbID#%04x --> 0",urbID(urb));
++ return 0;
++}
++
++/*! acmfd_urb_sent_int - called to indicate int URB transmit finished
++ * @param urb pointer to struct usbd_urb
++ * @param rc result
++ * @return non-zero for error
++ */
++STATIC int acmfd_urb_sent_int (struct usbd_urb *urb, int rc)
++{
++ struct acm_private *acm = urb->function_privdata;
++ struct usbd_function_instance *function;
++
++ TRACE_MSG2(acm->trace_tag,"entered urbID#%04x rc=%d",urbID(urb),rc);
++ TRACE_MSG3(acm->trace_tag,"used: %d MOD_IN_USE: %d configured: %d",
++ atomic_read(&acm->used), MOD_IN_USE, acm->flags & ACM_CONFIGURED);
++ if (!urb || !(function = urb->function_instance)) {
++ TRACE_MSG1(acm->trace_tag,"urbID#%04x --> -EINVAL",urbID(urb));
++ return(-EINVAL);
++ }
++ TRACE_MSG1(acm->trace_tag,"INT length=%d",urb->actual_length);
++
++ urb->function_privdata = NULL;
++ usbd_free_urb(urb);
++ TRACE_MSG1(acm->trace_tag,"urbID#%04x --> 0",urbID(urb));
++ return 0;
++}
++
++/*! acmfd_urb_sent_ep0 - called to indicate ep0 URB transmit finished
++ * @param urb pointer to struct usbd_urb
++ * @param rc result
++ * @return non-zero for error
++ */
++STATIC int acmfd_urb_sent_ep0 (struct usbd_urb *urb, int rc)
++{
++ struct acm_private *acm = urb->function_privdata;
++ struct usbd_function_instance *function;
++
++ TRACE_MSG2(acm->trace_tag,"entered urbID#%04x rc=%d",urbID(urb),rc);
++ TRACE_MSG3(acm->trace_tag,"used: %d MOD_IN_USE: %d configured: %d",
++ atomic_read(&acm->used), MOD_IN_USE, acm->flags & ACM_CONFIGURED);
++
++ RETURN_EINVAL_IF (!urb || !(function = urb->function_instance));
++
++ TRACE_MSG1(acm->trace_tag,"INT length=%d",urb->actual_length);
++
++ urb->function_privdata = NULL;
++ usbd_free_urb(urb);
++ return 0;
++}
++
++/* USB Device Functions ************************************************************************ */
++
++typedef enum mesg {
++ mesg_unknown,
++ mesg_configured,
++ mesg_reset,
++} mesg_t;
++mesg_t acm_last_mesg;
++
++char * acm_messages[3] = {
++ "",
++ "ACM Configured",
++ "ACM Reset",
++};
++
++
++/*! acmfd_check_mesg
++ * @param curr_mesg
++ */
++void acmfd_check_mesg(mesg_t curr_mesg)
++{
++ RETURN_UNLESS(acm_last_mesg != curr_mesg);
++ acm_last_mesg = curr_mesg;
++ otg_message(acm_messages[curr_mesg]);
++}
++
++
++/*! acmfd_event_handler - process a device event
++ * @param function
++ * @param event
++ * @param data
++ */
++void acmfd_event_handler (struct usbd_function_instance *function, usbd_device_event_t event, int data)
++{
++ struct acm_private *acm = function->privdata;
++ int i;
++
++ TRACE_MSG1(acm->trace_tag,"entered ev: %d",event);
++ TRACE_MSG3(acm->trace_tag,"used: %d MOD_IN_USE: %d ready: %d", atomic_read(&acm->used), MOD_IN_USE, acm_ready(acm));
++
++ switch (event) {
++
++ case DEVICE_CONFIGURED:
++ TRACE_MSG0(acm->trace_tag,"CONFIGURED");
++ acm->flags |= ACM_CONFIGURED;
++ acmfd_check_mesg(mesg_configured);
++ acmfd_start_recv_urbs(acm, DATA_INTF);
++ break;
++
++ case DEVICE_RESET:
++ case DEVICE_DE_CONFIGURED:
++ TRACE_MSG0(acm->trace_tag,"RESET");
++
++ /* if configured and open then schedule hangup
++ */
++ if ((acm->flags & ACM_OPENED) && (acm->flags & ACM_CONFIGURED))
++ acm->function_services->schedule_hangup(acm);
++
++ acm->flags &= ~(ACM_CONFIGURED | ACM_CARRIER);
++ acmfd_check_mesg(mesg_reset);
++ BREAK_IF(!acm->flags & ACM_CONFIGURED);
++ TRACE_MSG0(acm->trace_tag,"RESET continue");
++ // XXX flush
++ // Release any queued urbs
++ break;
++
++ default:
++ break;
++ }
++ TRACE_MSG0(acm->trace_tag,"exited");
++}
++
++/*! acm_write_room
++ * @param acm
++ * @param interface
++ * @return non-zero if error
++ */
++STATIC int acm_write_room(struct acm_private *acm, int interface)
++{
++ switch (interface) {
++ case COMM_INTF:
++ return 0;
++ case DATA_INTF:
++ return (!acm->function || max_queued_urbs <= atomic_read(&acm->queued_urbs) ||
++ max_queued_bytes <= atomic_read(&acm->queued_bytes) ) ? 0 : acm->writesize ;
++ }
++ return 0;
++}
++
++/*! acm_chars_in_buffer
++ * @param acm
++ * @param interface
++ * @return non-zero if error
++ */
++STATIC int acm_chars_in_buffer(struct acm_private *acm, int interface)
++{
++ int rc;
++ switch (interface) {
++ case COMM_INTF:
++ return 0;
++ case DATA_INTF:
++ return atomic_read(&acm->queued_bytes);
++ }
++ return 0;
++}
++
++static int throttle_count = 0;
++static int unthrottle_count = 0;
++
++/*! acm_throttle
++ * @param acm
++ * @param interface
++ */
++STATIC void acm_throttle(struct acm_private *acm, int interface)
++{
++ switch (interface) {
++ case COMM_INTF:
++ break;
++ case DATA_INTF:
++ throttle_count += 1;
++ TRACE_MSG1(acm->trace_tag,"entered %d",throttle_count);
++ acm->flags |= ACM_THROTTLED;
++ TRACE_MSG1(acm->trace_tag,"exited %d",throttle_count);
++ break;
++ }
++}
++
++/*! acm_unthrottle
++ * @param acm
++ * @param interface
++ */
++STATIC void acm_unthrottle(struct acm_private *acm, int interface)
++{
++ switch (interface) {
++ case COMM_INTF:
++ break;
++ case DATA_INTF:
++ unthrottle_count += 1;
++ TRACE_MSG1(acm->trace_tag,"entered %d",unthrottle_count);
++ acm->flags &= ~ACM_THROTTLED;
++ TRACE_MSG1(acm->trace_tag,"exited %d",unthrottle_count);
++ UNLESS(acm->recv_urbs)
++ acm_schedule_recv(acm, interface);
++ break;
++ }
++}
++
++/*! acm_xmit_chars
++ * @param acm
++ * @param interface
++ * @param count
++ * @param from_user
++ * @param buf
++ * @return number of bytes sent.
++ */
++STATIC int acm_xmit_chars(struct acm_private *acm, int interface, int count, int from_user, const unsigned char *buf)
++{
++ struct usbd_function_instance *function = acm->function;
++ struct usbd_urb *urb;
++
++ RETURN_ZERO_UNLESS((acm->flags & ACM_CONFIGURED) /*&& (acm->flags & ACM_CARRIER)*/);
++
++ TRACE_MSG2(acm->trace_tag, "count: %d from_user: %d", count, from_user);
++
++ switch (interface) {
++ case COMM_INTF:
++ return 0;
++ case DATA_INTF:
++ // sanity check and are we connect
++ RETURN_ZERO_UNLESS(atomic_read(&acm->used));
++ TRACE_MSG0(acm->trace_tag,"used OK");
++ RETURN_ZERO_UNLESS (count);
++ RETURN_ZERO_UNLESS (acm->flags & ACM_CONFIGURED);
++ TRACE_MSG0(acm->trace_tag,"connected OK");
++ RETURN_ZERO_IF(max_queued_urbs <= atomic_read(&acm->queued_urbs));
++ TRACE_MSG0(acm->trace_tag,"max_queued_urbs OK");
++
++ // allocate a write urb
++ count = MIN(count, acm->writesize);
++
++ RETURN_ZERO_UNLESS ((urb = usbd_alloc_urb (function, BULK_IN, count, acmfd_urb_sent_bulk)));
++
++ if (from_user)
++ copy_from_user ((void *)urb->buffer, (void *)buf, count);
++ else
++ memcpy ((void *)urb->buffer, (void *)buf, count);
++
++ urb->function_privdata = acm;
++ urb->actual_length = count;
++ atomic_add(count, &acm->queued_bytes);
++ atomic_inc(&acm->queued_urbs);
++ usbd_start_in_urb(urb);
++ TRACE_MSG2(acm->trace_tag,"urbID#%04x --> count: %d",urbID(urb),count);
++ return count;
++ default:
++ break;
++ }
++ return 0;
++}
++
++/*! acmfd_recv_urb
++ * @param urb
++ * @param rc
++ * @return non-zero if error
++ */
++STATIC int acmfd_recv_urb (struct usbd_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 = urb->function_privdata;
++ unsigned long flags;
++
++ local_irq_save(flags);
++ acm->recv_urbs--; // this could probably be atomic operation....
++ local_irq_restore(flags);
++
++ if (RECV_CANCELLED == rc) {
++ TRACE_MSG1(acm->trace_tag,"cancelled URB=%p",urb);
++ return -EINVAL;
++ }
++ if (RECV_OK != rc) {
++ TRACE_MSG2(acm->trace_tag,"rejected URB=%p rc=%d",urb,rc);
++ usbd_free_urb(urb);
++ acm_schedule_recv(acm, DATA_INTF);
++ //acmfd_start_recv_urbs(acm, DATA_INTF);
++ return 0;
++ }
++
++ /* loopback mode
++ */
++ if (acm->flags & ACM_LOOPBACK)
++ acm_xmit_chars(acm, DATA_INTF, urb->actual_length, 0, urb->buffer);
++
++ /* acmfd_start_recv_urbs() will never queue more urbs than there is currently
++ * room in the upper layer buffer for. So we are guaranteed that any data actually
++ * received can be given to the upper layers without worrying if we will
++ * actually have room.
++ */
++ else
++ if ((rc = acm->function_services->recv_chars(acm, DATA_INTF, urb->buffer, urb->actual_length)))
++ return(rc); // XXX
++
++
++ acm->bytes_received += urb->actual_length;
++ TRACE_MSG1(acm->trace_tag,"bytes_received: %d",acm->bytes_received);
++ usbd_free_urb(urb);
++ acm_schedule_recv(acm, DATA_INTF);
++ return 0;
++
++#if 0
++ // XXX it may be reasonable to schedule here....
++ UNLESS (acmfd_start_recv_urbs(acm, DATA_INTF)) {
++ /* If start recv returns zero it means that there are no-queued urbs,
++ * and we should queue a work item to restart.
++ */
++ acm_schedule_recv(acm, DATA_INTF);
++ }
++#endif
++ return 0;
++}
++
++/*! acmfd_line_coding_urb_received - callback for sent URB
++ *
++ * Handles notification that an urb has been sent (successfully or otherwise).
++ *
++ * @param urb
++ * @param urb_rc
++ * @return non-zero for failure.
++ */
++STATIC int acmfd_line_coding_urb_received (struct usbd_urb *urb, int urb_rc)
++{
++ struct acm_private *acm = urb->function_privdata;
++ TRACE_MSG2(acm->trace_tag,"urbID#%04x rc=%d",urbID(urb),urb_rc);
++
++ RETURN_EINVAL_IF (RECV_OK != urb_rc);
++ RETURN_EINVAL_IF (urb->actual_length < sizeof(struct cdc_acm_line_coding));
++
++ RETURN_EINVAL_UNLESS (memcpy(&acm->line_coding, urb->buffer, sizeof(struct cdc_acm_line_coding)));
++
++ // something changed, copy and notify
++
++ memcpy(&acm->line_coding, urb->buffer, sizeof(struct cdc_acm_line_coding));
++
++ // XXX notify application if baudrate has changed
++
++ return -EINVAL; // caller will de-allocate
++}
++
++/*! acmfd_device_request - called to indicate urb has been received
++ * @param function
++ * @param request
++ * @return non-zero if error
++ */
++int acmfd_device_request (struct usbd_function_instance *function, struct usbd_device_request *request)
++{
++ struct acm_private *acm = (struct acm_private *) (function->privdata);
++
++ TRACE_MSG3(acm->trace_tag,"used: %d MOD_IN_USE: %d configured: %d",
++ atomic_read(&acm->used), MOD_IN_USE, acm->flags & ACM_CONFIGURED);
++
++ TRACE_SETUP(acm->trace_tag,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_MSG0(acm->trace_tag,"--> 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 usbd_urb *urb;
++ int len = le16_to_cpu(request->wLength);
++ TRACE_MSG1(acm->trace_tag,"SET_LINE_CODING wLength=%d",len);
++ if (len <= 0) {
++ TRACE_MSG0(acm->trace_tag,"(len<=0)--> 0");
++ return(0);
++ }
++
++ /* Set up an ep0 recv urb for the rest of it. */
++ UNLESS ((urb = usbd_alloc_urb_ep0(function, len, acmfd_line_coding_urb_received))) {
++ TRACE_MSG0(acm->trace_tag,"no mem for ep0 recv urb");
++ return(-ENOMEM);
++ }
++ urb->function_privdata = acm;
++ if (usbd_start_out_urb(urb)) {
++ TRACE_MSG0(acm->trace_tag,"usbd_start_out_urb() failed");
++ usbd_free_urb(urb); // de-alloc if error
++ TRACE_MSG0(acm->trace_tag,"--> -EINVAL");
++ return(-EINVAL);
++ }
++ }
++ break;
++
++ case CDC_CLASS_REQUEST_SET_CONTROL_LINE_STATE:
++ {
++ unsigned int prev_bmLineState = acm->bmLineState;
++ acm->bmLineState = le16_to_cpu(request->wValue);
++
++ // schedule writers or hangup IFF open
++ BREAK_IF(!acm->privdata);
++ TRACE_MSG3(acm->trace_tag,"set control state, bmLineState: %04x previous: %04x changed: %04x",
++ acm->bmLineState, prev_bmLineState, acm->bmLineState ^ prev_bmLineState);
++
++ // make sure there really is a state change
++ if ((acm->bmLineState ^ prev_bmLineState) & CDC_LINESTATE_D0_DTR) {
++
++ TRACE_MSG1(acm->trace_tag,"DTR state changed -> %x",
++ (acm->bmLineState & CDC_LINESTATE_D0_DTR));
++
++ if (acm->bmLineState & CDC_LINESTATE_D0_DTR) {
++ if (acm->flags & ACM_OPENED)
++ acm->function_services->schedule_wakeup_writers(acm);
++ acm->flags |= ACM_CARRIER;
++ acm_schedule_recv(acm, DATA_INTF);
++ }
++ else {
++ if (acm->flags & ACM_OPENED)
++ acm->function_services->schedule_hangup(acm);
++
++ acm->flags &= ~ACM_CARRIER;
++ acm_flush(acm, DATA_INTF);
++ }
++
++ /* wake up blocked opens */
++ acm->function_services->wakeup_opens(acm);
++
++ /* wake up blocked ioctls */
++ acm->function_services->wakeup_state(acm);
++
++ }
++
++
++
++ /* send notification if we have DCD */
++ TRACE_MSG2(acm->trace_tag,"bmUARTState: %04x privdata: %p sending (DCD|DSR) notification",
++ acm->bmUARTState, acm->privdata);
++
++ acm_send_int_notification(acm, CDC_NOTIFICATION_SERIAL_STATE, acm->bmUARTState);
++ }
++ break;
++
++ case CDC_CLASS_REQUEST_SEND_BREAK: break;
++ default: break;
++ }
++ TRACE_MSG0(acm->trace_tag,"--> 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 usbd_urb *urb;
++ RETURN_ENOMEM_IF (!(urb = usbd_alloc_urb_ep0(function, sizeof(struct cdc_acm_line_coding),
++ acmfd_urb_sent_ep0)));
++ urb->function_privdata = acm;
++
++ memcpy(urb->buffer, &acm->line_coding, sizeof(struct cdc_acm_line_coding));
++
++ urb->actual_length = sizeof(struct cdc_acm_line_coding);
++
++ TRACE_MSG1(acm->trace_tag,"sending line coding urb: %p",(u32)(void*)urb);
++ RETURN_ZERO_UNLESS(usbd_start_in_urb(urb));
++ usbd_free_urb(urb);
++ TRACE_MSG0(acm->trace_tag,"(send failed)--> -EINVAL");
++ }
++ return -EINVAL;
++ default: break;
++ }
++ TRACE_MSG0(acm->trace_tag,"--> 0");
++ return 0;
++
++ case USB_REQ_HOST2DEVICE | USB_REQ_TYPE_VENDOR: break;
++ case USB_REQ_DEVICE2HOST | USB_REQ_TYPE_VENDOR: break;
++
++ default: break;
++ }
++ TRACE_MSG0(acm->trace_tag,"--> 0");
++ return 0;
++}
++
++
++/*! acmfd_function_enable
++ * @param function
++ * @return non-zero if error
++ */
++STATIC int acmfd_function_enable (struct usbd_function_instance *function)
++{
++ struct acm_private *acm = (struct acm_private *) (function->privdata);
++
++ TRACE_MSG0(acm->trace_tag,"entered");
++ TRACE_MSG1(acm->trace_tag,"INC: %d", MOD_IN_USE);
++ acm->function_services->enable(function);
++ acm->writesize = usbd_endpoint_wMaxPacketSize(function, BULK_OUT, 0) * 24;
++
++ TRACE_MSG0(acm->trace_tag,"-> 0");
++ return 0;
++}
++
++/*! acmfd_function_disable
++ * @param function
++ */
++STATIC void acmfd_function_disable (struct usbd_function_instance *function)
++{
++ struct acm_private *acm = (struct acm_private *) (function->privdata);
++
++ TRACE_MSG0(acm->trace_tag,"entered");
++ acm->writesize = 0;
++ acm->function_services->disable(function);
++ TRACE_MSG1(acm->trace_tag,"DEC: %d", MOD_IN_USE);
++ TRACE_MSG0(acm->trace_tag,"exited");
++}
++
++
++/*! function_ops
++ */
++struct usbd_function_operations function_ops = {
++ event_handler: acmfd_event_handler,
++ device_request: acmfd_device_request,
++ function_enable: acmfd_function_enable,
++ function_disable: acmfd_function_disable,
++};
++
++/*! acm_fd_init
++ * @param acm
++ * @param usbd_module_info
++ * @param vendor_id
++ * @param product_id
++ * @param wmax_urbs
++ * @param wmax_bytes
++ * @return non-zero if error
++ */
++STATIC int acm_fd_init(struct acm_private *acm, char *usbd_module_info, u32 vendor_id, u32 product_id,
++ u32 wmax_urbs, u32 wmax_bytes)
++{
++
++ TRACE_MSG0(acm->trace_tag,"entered");
++
++ if (vendor_id)
++ acm->function_driver->idVendor = cpu_to_le16(vendor_id);
++ if (product_id)
++ acm->function_driver->idProduct = cpu_to_le16(product_id);
++ max_queued_urbs = wmax_urbs;
++ max_queued_bytes = wmax_bytes;
++
++ THROW_IF (NULL == (acm->function = usbd_register_function (acm->function_driver, "acm-fd", acm)), error);
++
++ CATCH(error) {
++ printk(KERN_ERR"%s: ERROR\n", __FUNCTION__);
++
++ if (acm->function) {
++ usbd_deregister_function (acm->function);
++ acm->function = NULL;
++ }
++ TRACE_MSG0(acm->trace_tag,"--> -EINVAL");
++ return -EINVAL;
++ }
++ TRACE_MSG0(acm->trace_tag,"--> 0");
++ return 0;
++}
++
++
++
++/*! acm_wait_task
++ * @param acm
++ * @param queue
++ */
++void acm_wait_task(struct acm_private *acm, WORK_ITEM *queue)
++{
++ TRACE_MSG1(acm->trace_tag,"entered data=%p",queue->data);
++ RETURN_IF(!queue->data);
++ queue->data = NULL;
++#if defined(LINUX24)
++ while (queue->sync) {
++ TRACE_MSG1(acm->trace_tag,"waiting for queue: %p",queue);
++ schedule_timeout(HZ);
++ }
++#else
++ while(PENDING_WORK_ITEM((*queue))){
++ TRACE_MSG1(acm->trace_tag,"waiting for queue: %p",queue);
++ SCHEDULE_TIMEOUT(1); // 1 second delay
++ }
++#endif
++ TRACE_MSG0(acm->trace_tag,"exited");
++}
++
++
++/*! acm_get_dtr
++ * Get DTR status.
++ */
++int acm_get_dtr(struct acm_private *acm)
++{
++ return (acm->bmLineState & CDC_LINESTATE_D0_DTR) ? 1 : 0;
++}
++
++/*! acm_get_dsr
++ * Get DSR status
++ */
++int acm_get_dsr(struct acm_private *acm)
++{
++ return (acm->bmUARTState & CDC_UARTSTATE_BTXCARRIER_DSR) ? 1 : 0;
++}
++
++/*! acm_get_dcd
++ * Get DCD status
++ */
++int acm_get_dcd(struct acm_private *acm)
++{
++ return (acm->bmUARTState & CDC_UARTSTATE_BRXCARRIER_DCD) ? 1 : 0;
++}
++
++/*! acm_set_dsr
++ * Set DSR status
++ * @param acm
++ * @param value
++ */
++void acm_set_dsr(struct acm_private *acm, int value)
++{
++ acm->bmUARTState &= ~CDC_UARTSTATE_BTXCARRIER_DSR;
++ acm->bmUARTState |= value ? CDC_UARTSTATE_BTXCARRIER_DSR : 0;
++ acm_send_int_notification(acm, CDC_NOTIFICATION_SERIAL_STATE, acm->bmUARTState);
++}
++
++/*! acm_set_dcd
++ * Set DCD status
++ * @param acm
++ * @param value
++ */
++void acm_set_dcd(struct acm_private *acm, int value)
++{
++ acm->bmUARTState &= ~CDC_UARTSTATE_BRXCARRIER_DCD;
++ acm->bmUARTState |= value ? CDC_UARTSTATE_BRXCARRIER_DCD : 0;
++ acm_send_int_notification(acm, CDC_NOTIFICATION_SERIAL_STATE, acm->bmUARTState);
++}
++
++/*! acm_ring
++ * Indicate Ring signal to host.
++ */
++void acm_ring(struct acm_private *acm)
++{
++ acm->bmUARTState |= CDC_UARTSTATE_BRINGSIGNAL;
++ acm_send_int_notification(acm, CDC_NOTIFICATION_SERIAL_STATE, acm->bmUARTState);
++ acm->bmUARTState &= ~CDC_UARTSTATE_BRINGSIGNAL;
++}
++
++/*! acm_send_break
++ * Indicate Break signal to host.
++ */
++void acm_send_break(struct acm_private *acm)
++{
++ acm->bmUARTState |= CDC_UARTSTATE_BBREAK;
++ acm_send_int_notification(acm, CDC_NOTIFICATION_SERIAL_STATE, acm->bmUARTState);
++ acm->bmUARTState &= ~CDC_UARTSTATE_BBREAK;
++}
++
++/*! acm_overrun
++ * Indicate Overrun signal to host.
++ */
++void acm_overrun(struct acm_private *acm)
++{
++ acm->bmUARTState |= CDC_UARTSTATE_BOVERRUN;
++ acm_send_int_notification(acm, CDC_NOTIFICATION_SERIAL_STATE, acm->bmUARTState);
++ acm->bmUARTState &= ~CDC_UARTSTATE_BOVERRUN;
++}
++
++/*! acm_set_local
++ * Set LOCAL status
++ * @param acm
++ * @param value
++ */
++void acm_set_local(struct acm_private *acm, int value)
++{
++ acm->flags &= ~ACM_LOCAL;
++ acm->flags |= value ? ACM_LOCAL : 0;
++}
++
++/*! acm_set_loopback
++ * Set LOOPBACK status
++ * @param acm
++ * @param value
++ */
++void acm_set_loopback(struct acm_private *acm, int value)
++{
++ acm->flags &= ~ACM_LOOPBACK;
++ acm->flags |= value ? ACM_LOOPBACK : 0;
++}
++
++
++
++/*! acm_fd_term
++ * @param acm
++ */
++STATIC void acm_fd_exit(struct acm_private *acm)
++{
++ //acm_wait_task(acm->recv_tqueue);
++ RETURN_UNLESS (acm->function);
++ usbd_deregister_function (acm->function);
++ acm->function = NULL;
++}
++
++/*!
++ * Function table exported to the OS specific upper layer.
++ */
++struct acm_usb_services acm_fd_usb_ops = {
++ .fd_init = acm_fd_init,
++ .fd_exit = acm_fd_exit,
++ .xmit_chars = acm_xmit_chars,
++ .send_int_notification = acm_send_int_notification,
++ .throttle = acm_throttle,
++ .unthrottle = acm_unthrottle,
++ .write_room = acm_write_room,
++ .chars_in_buffer = acm_chars_in_buffer,
++ .wait_task = acm_wait_task,
++ .schedule_recv = acm_schedule_recv,
++ .open = acm_open,
++ .close = acm_close,
++ .flush = acm_flush,
++ .ready = acm_ready,
++ .get_dtr = acm_get_dtr,
++ .get_dsr = acm_get_dsr,
++ .get_dcd = acm_get_dcd,
++ .set_dsr = acm_set_dsr,
++ .set_dcd = acm_set_dcd,
++ .ring = acm_ring,
++ .send_break = acm_send_break,
++ .overrun = acm_overrun,
++ .set_local = acm_set_local,
++ .set_loopback = acm_set_loopback,
++};
++
+diff -uNr linux/drivers/no-otg/functions/acm/acm-fd.h linux/drivers/otg/functions/acm/acm-fd.h
+--- linux/drivers/no-otg/functions/acm/acm-fd.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/acm-fd.h 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,242 @@
++/*
++ * otg/functions/acm/acm-fd.h
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/functions/acm/acm-fd.h
++ * @brief ACM Function Driver private defines
++ *
++ * The top and bottom halves of the driver comunication via these structures.
++ *
++ * @ingroup ACMFunction
++ */
++
++#ifndef ACM_FD_H
++#define ACM_FD_H 1
++
++typedef void (*cpy_fn)(u8 *dst, u8 *src, int len);
++
++/*! acm_usb_services
++ * Services that the acm_fd library provides.
++ */
++struct acm_usb_services {
++
++ /*! fd_init - called to initialize the acm_fd library
++ * This call initialized the acm_fd library and registers the function driver
++ * with the USB Peripheral Stack.
++ */
++ int (*fd_init)(struct acm_private *acm, char *inf, u32 vendor_id, u32 product_id, u32 wmax_urbs, u32 wmax_bytes);
++
++ /*! fd_exit - called before exiting
++ * This call will cause the function driver to be de-registered.
++ */
++ void (*fd_exit)(struct acm_private *acm);
++
++ /*! open - device open
++ * This is called the device is opened (first open only if non-exclusive opens allowed).
++ */
++ int (*open)(struct acm_private *acm, int interface);
++
++ /*! close - Device close
++ * This is called when the device closed (last close only if non-exclusive opens allowed.)
++ */
++ int (*close)(struct acm_private *acm, int interface);
++
++
++ /*! flush - flush data urbs.
++ * Cancel outstanding data urbs.
++ */
++ void (*flush)(struct acm_private *acm, int interface);
++
++ /*! schedule_recv - queue as many data receive urbs as possible
++ * This will schedule a bottom half hander that will will start as
++ * many receive data urbs as are allowed given the amount of room
++ * available in the upper layer. If no urbs are queued by the
++ * bottom half handler it will re-schedule itself.
++ */
++ void (*schedule_recv)(struct acm_private *acm, int interface);
++
++ /*! throttle - set throttle flag for specified interface
++ * Receive urbs will not be queued when throttled.
++ */
++ void (*throttle)(struct acm_private *acm, int interface);
++
++ /*! unthrottle - reset throttle flag for specified interface
++ * Receive urbs are allowed to be queued. If no urbs are queued a
++ * bottom half handler will be scheduled to queue them.
++ */
++ void (*unthrottle)(struct acm_private *acm, int interface);
++
++
++ /*! xmit_chars - send data via specified interface
++ * This will start a transmit urb to send the specified data. The
++ * number of characters sent will be returned.
++ */
++ int (*xmit_chars)(struct acm_private *acm, int interface, int count, int from_user, const unsigned char *buf);
++
++ /*! write_room
++ * Return amount of data that could be queued for sending.
++ */
++ int (*write_room)(struct acm_private *acm, int interface);
++
++ /*! chars_in_buffer
++ * Return number of chars in xmit buffer.
++ */
++ int (*chars_in_buffer)(struct acm_private *acm, int interface);
++
++
++ /*! send_int_notification - send notification via interrupt endpoint
++ * This can be used to queue network, serial state change notifications.
++ */
++ int (*send_int_notification)(struct acm_private *acm, int bnotification, int data);
++
++ /*! wait_task - wait for task to complete.
++ */
++ void (*wait_task)(struct acm_private *acm, WORK_ITEM *queue);
++
++ /*! ready - return true if connected and carrier
++ */
++ int (*ready)(struct acm_private *acm);
++
++ /*! get_dtr
++ * Get DTR status.
++ */
++ int (*get_dtr)(struct acm_private *acm);
++
++ /*! get_dsr
++ * Get DSR status
++ */
++ int (*get_dsr)(struct acm_private *acm);
++
++ /*! get_dcd
++ * Get DCD status
++ */
++ int (*get_dcd)(struct acm_private *acm);
++
++ /*! set_dsr
++ * Set DSR status
++ */
++ void (*set_dsr)(struct acm_private *acm, int value);
++
++ /*! set_dcd
++ * Set DCD status
++ */
++ void (*set_dcd)(struct acm_private *acm, int value);
++
++ /*! ring
++ * Indicate Ring signal to host.
++ */
++ void (*ring)(struct acm_private *acm);
++
++ /*! send_break
++ * Indicate Break signal to host.
++ */
++ void (*send_break)(struct acm_private *acm);
++
++ /*! overrun
++ * Indicate Overrun signal to host.
++ */
++ void (*overrun)(struct acm_private *acm);
++
++
++ /*! set_local
++ * Set LOCAL status
++ */
++ void (*set_local)(struct acm_private *acm, int value);
++
++ /*! set_loopback - set loopback mode
++ * Sets LOOP flag, data received from the host will be immediately
++ * returned without passing to the upper layer.
++ */
++ void (*set_loopback)(struct acm_private *acm, int value);
++};
++
++/*! acm_function_services
++ * Services that the top level driver provides to the lower library.
++ */
++struct acm_function_services {
++ /*! enable
++ * Enable the function driver.
++ */
++ void (*enable)(struct usbd_function_instance *function);
++
++ /*! disable
++ * Disable the function driver.
++ */
++ void (*disable)(struct usbd_function_instance *function);
++
++ /*! wakeup_opens
++ * Wakeup processes waiting for DTR.
++ */
++ void (*wakeup_opens)(struct acm_private *acm);
++
++ /*! wakeup_opens
++ * Wakeup processes waiting for state change.
++ */
++ void (*wakeup_state)(struct acm_private *acm);
++
++ /*! wakeup writers
++ * Wakeup pending writes.
++ */
++ void (*schedule_wakeup_writers)(struct acm_private *acm);
++
++ /*! recv_space_available
++ * Check for amount of receive space that is available, controls
++ * amount of receive urbs that will be queued.
++ */
++ int (*recv_space_available)(struct acm_private *acm, int interface);
++
++ /*! recv_chars
++ * Process chars received on specified interface.
++ */
++ int (*recv_chars)(struct acm_private *acm, int interface, u8 *cp, int n);
++
++
++ /*! schedule_hangup
++ * Schedule a work item that will perform a hangup.
++ */
++ void (*schedule_hangup)(struct acm_private *acm);
++
++ /*! comm_feature
++ * Tell function that comm feature has changed.
++ */
++ void (*comm_feature)(struct acm_private *acm);
++
++ /*! line_coding
++ * Tell function that line coding has changed.
++ */
++ void (*line_coding)(struct acm_private *acm);
++
++ /*! control_state
++ * Tell function that control state has changed.
++ */
++ void (*control_state)(struct acm_private *acm);
++
++ /*! send_break
++ * Tell function to send a break signal.
++ */
++ void (*send_break)(struct acm_private *acm);
++
++};
++
++extern struct acm_usb_services acm_fd_usb_ops;
++extern struct usbd_function_operations function_ops;
++
++
++/*
++ * otg-trace tag.
++ */
++extern otg_tag_t acm_fd_trace_tag;
++
++#define MAX_QUEUED_BYTES 256
++#define MAX_QUEUED_URBS 10 // Max for write
++
++
++#endif
+diff -uNr linux/drivers/no-otg/functions/acm/acm-os.h linux/drivers/otg/functions/acm/acm-os.h
+--- linux/drivers/no-otg/functions/acm/acm-os.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/acm-os.h 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,74 @@
++/*
++ * otg/functions/acm/acm-os.h
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ *
++ */
++/*!
++ * @file otg/functions/acm/acm-os.h
++ * @brief ACM Function Driver private defines
++ *
++ * An ACM (Abstract Control Model) driver is composed of two pieces:
++ * 1) An OS specific piece that handles creating and operating
++ * a serial device for the given OS.
++ * 2) A USB specific piece that interfaces either with the host
++ * usbcore layer, or with the otgcore layer.
++ *
++ * If the USB piece interfaces with the host usbcore layer you get
++ * an ACM class driver. If the USB piece interfaces with the otgcore
++ * layer you get an ACM function driver.
++ *
++ * This file describes the functions exported by the various acm-*-os.c
++ * files (implementing (1)) for use in acm-fd.c (2).
++ *
++ * @ingroup ACMFunction
++ */
++
++#ifndef ACM_OS_H
++#define ACM_OS_H 1
++
++/*
++ * acm_os_recv_space_available - return the number of bytes of data
++ * the OS specific piece can accept without
++ * dropping some.
++ */
++extern int acm_os_recv_space_available(struct acm_private *acm);
++
++/*
++ * acm_os_recv_chars - receive n bytes starting at cp. This will never be
++ * more than the last call to acm_os_recv_space_available().
++ * This will be called from interrupt context.
++ */
++extern int acm_os_recv_chars(struct acm_private *acm, u8 *cp, int n);
++
++/*
++ * acm_os_wakeup_writers - wakeup any blocked writers. This is called
++ * from interrupt context, so may need to queue
++ * the actual wakeup in a "bottom half".
++ */
++extern void acm_os_wakeup_writers(struct acm_private *acm);
++
++/*
++ * acm_os_hangup - send a hangup to any readers or writers. This can be
++ * called from interrupt context, so may need to queue
++ * the actual hangup in a "bottom half".
++ */
++extern void acm_os_hangup(struct acm_private *acm);
++
++/*
++ * acm_os_wakeup_opens - wakeup any blocked opens. This is called
++ * from interrupt context, so may need to queue
++ * the actual wakeup in a "bottom half".
++ */
++extern void acm_os_wakeup_opens(struct acm_private *acm);
++
++extern void acm_os_enable(struct usbd_function_instance *function);
++extern void acm_os_disable(struct usbd_function_instance *function);
++
++#endif
+diff -uNr linux/drivers/no-otg/functions/acm/acm.h linux/drivers/otg/functions/acm/acm.h
+--- linux/drivers/no-otg/functions/acm/acm.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/acm.h 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,113 @@
++/*
++ * otg/functions/acm/acm.h
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++
++/*!
++ * @defgroup ACMFunction ACM
++ * @ingroup functiongroup
++ */
++
++/*!
++ * @file otg/functions/acm/acm.h
++ * @brief ACM Function Driver private defines
++ *
++ * This is an ACM Function Driver. The upper edge is exposed
++ * to the hosting OS as a Posix type character device. The lower
++ * edge implements the USB Device Stack API.
++ *
++ * This driver implements the CDC ACM driver model and uses the CDC ACM
++ * protocols.
++ *
++ * Note that it appears to be impossible to determine the end of a receive
++ * bulk transfer larger than wMaxPacketsize. The host is free to send
++ * wMaxPacketsize chars in a single transfer. This means that we cannot
++ * queue receive urbs larger than wMaxPacketsize (typically 64 bytes.)
++ *
++ * This does not however prevent queuing transmit urbs with larger amounts
++ * of data. It is interpreted at the receiving (host) end as a series of
++ * wMaxPacketsize transfers but because there is no interpretation to the
++ * amounts of data sent it does affect anything if we treat the data as a
++ * single larger transfer.
++ *
++ * @ingroup ACMFunction
++ */
++
++
++// Endpoint indexes in acm_endpoint_requests[] and the endpoint map.
++#define BULK_OUT 0x00
++#define BULK_IN 0x01
++#define INT_IN 0x02
++#define ENDPOINTS 0x03
++
++#define COMM_INTF 0x00
++#define DATA_INTF 0x01
++
++
++
++// Most hosts don't care about BMAXPOWER, but the UUT tests want it to be 1
++#define BMAXPOWER 1
++#define BMATTRIBUTE 0
++
++#define STATIC
++//#define STATIC static
++//
++
++/*! @name ACM Flags
++ * @{
++ */
++#define ACM_OPENED (1 << 0) /*!< upper layer has opened the device port */
++#define ACM_CONFIGURED (1 << 1) /*!< device is configured */
++#define ACM_THROTTLED (1 << 2) /*!< upper layer doesn't want to receive data */
++#define ACM_CARRIER (1 << 3) /*!< host has set DTR, i.e. host has opened com device */
++#define ACM_LOOPBACK (1 << 4) /*!< upper layer wants local loopback */
++#define ACM_LOCAL (1 << 5) /*!< upper layer specified LOCAL mode */
++
++/*! @} */
++
++/*! struct acm_private
++ */
++struct acm_private {
++ struct usbd_function_instance *function;
++ struct usbd_function_driver *function_driver;
++ struct acm_function_services *function_services;
++ otg_tag_t trace_tag;
++
++ u32 flags;
++
++ int recv_urbs;
++ atomic_t used;
++ atomic_t queued_bytes;
++ atomic_t queued_urbs;
++ unsigned int writesize; // packetsize * 4
++
++ /*TBR debug receive flow control */
++ unsigned long bytes_received;
++ unsigned long bytes_forwarded;
++ /*TBR end debug */
++
++ struct cdc_acm_line_coding line_coding; // C.f. Table 50 - [GS]ET_LINE_CODING Device Request (to/from host)
++ cdc_acm_bmUARTState bmUARTState; // C.f. Table 51 - SET_CONTROL_LINE_STATE Device Request (from host)
++ cdc_acm_bmLineState bmLineState; // C.f. Table 69 - SERIAL_STATE Notification (to host)
++
++
++
++ struct tq_struct recv_tqueue;
++
++ void *privdata;
++
++};
++
++
++struct acm_work {
++ struct acm_private *acm;
++ int interface;
++};
++
+diff -uNr linux/drivers/no-otg/functions/acm/modem-l24-os.c linux/drivers/otg/functions/acm/modem-l24-os.c
+--- linux/drivers/no-otg/functions/acm/modem-l24-os.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/modem-l24-os.c 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,194 @@
++/*
++ * otg/functions/acm/modem-l24-os.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/functions/acm/modem-l24-os.c
++ * @brief ACM Function Driver private defines
++ *
++ * An ACM (Abstract Control Model) driver is composed of two pieces:
++ * 1) An OS specific piece that handles creating and operating
++ * a serial device for the given OS.
++ * 2) A USB specific piece that interfaces either with the host
++ * usbcore layer, or with the otgcore layer.
++ *
++ * If the USB piece interfaces with the host usbcore layer you get
++ * an ACM class driver. If the USB piece interfaces with the otgcore
++ * layer you get an ACM function driver.
++ *
++ * This file is the OS specific piece that interfaces with Linux
++ * (kernel versions 2.4.*). It creates two simple characters devices.
++ * One for the data transport and one for the communications interface.
++ *
++ * @ingroup ACMFunction
++ */
++
++
++//#include <otg/osversion.h>
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++MOD_AUTHOR ("tbr@belcarra.com, sl@belcarra.com");
++
++MOD_DESCRIPTION ("Belcarra CDC-ACM Function");
++EMBED_LICENSE();
++
++
++#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 <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++
++#include <linux/capability.h>
++#include <otg/otg-trace.h>
++#include "acm.h"
++#include "acm-fd.h"
++#include "acm-os.h"
++
++// May need an ifdef here to pick up the acm_cl_usb_ops in the future.
++static struct acm_usb_services *usb_ops = &acm_fd_usb_ops;
++
++#define MDM mdm_fd_trace_tag
++otg_tag_t mdm_fd_trace_tag;
++
++/* 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;
++
++MOD_PARM (vendor_id, "i");
++MOD_PARM (product_id, "i");
++MOD_PARM (max_queued_urbs, "i");
++MOD_PARM (max_queued_bytes, "i");
++
++MOD_PARM_DESC (vendor_id, "Device Vendor ID");
++MOD_PARM_DESC (product_id, "Device Product ID");
++MOD_PARM_DESC (max_queued_urbs, "Maximum TX Queued Urbs");
++MOD_PARM_DESC (max_queued_bytes, "Maximum TX Queued Bytes");
++
++
++/* ACM ***************************************************************************************** */
++
++#define ACM_TTY_MAJOR 166
++#define ACM_TTY_MINOR 0
++#define ACM_TTY_MINORS 1
++
++static struct acm_private acm_private;
++
++/* USB Simple Char Device ********************************************************************** */
++
++
++/* USB Comm Char Device ************************************************************************ */
++
++
++/* 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, tbr@belcarra.com\n");
++ MDM = otg_trace_obtain_tag();
++
++ // 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;
++ //acm_private.recv_tqueue.routine = &acm_start_recv;
++ //acm_private.recv_tqueue.data = &acm_private;
++
++ //init_waitqueue_head(&acm_private.open_wait);
++
++
++ // register as usb function driver
++
++ THROW_IF (usb_ops->initialize_usb_part(&acm_private,"acm_fd",vendor_id,product_id,
++ max_queued_urbs,max_queued_bytes ), error);
++
++ CATCH(error) {
++ printk(KERN_ERR"%s: ERROR\n", __FUNCTION__);
++
++ TRACE_MSG0(MDM,"--> -EINVAL");
++ return -EINVAL;
++ }
++ TRACE_MSG0(MDM,"--> 0");
++ return 0;
++}
++
++void acm_wait_task(WORK_ITEM *queue)
++{
++ TRACE_MSG1(MDM,"entered data=%p",queue->data);
++ RETURN_IF(!queue->data);
++ queue->data = NULL;
++#if defined(LINUX24)
++ while (queue->sync) {
++ TRACE_MSG1(MDM,"waiting for queue: %p",queue);
++ schedule_timeout(HZ);
++ }
++#else
++ while(PENDING_WORK_ITEM((*queue))){
++ TRACE_MSG1(MDM,"waiting for queue: %p",queue);
++ SCHEDULE_TIMEOUT(1); // 1 second delay
++ }
++#endif
++ TRACE_MSG0(MDM,"exited");
++}
++
++/* acm_modexit - module cleanup
++ */
++STATIC void acm_modexit (void)
++{
++ unsigned long flags;
++ struct usbd_urb *urb;
++ TRACE_MSG0(MDM,"entered");
++
++ // 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);
++
++//#if defined(LINUX24)
++// run_task_queue(&tq_timer);
++//#else
++// blk_run_queues();
++//#endif
++
++ //acm_wait_task(&acm_private.recv_tqueue);
++
++ usb_ops->terminate_usb_part(&acm_private);
++ otg_trace_invalidate_tag(MDM);
++}
++
++
++module_init (acm_modinit);
++module_exit (acm_modexit);
+diff -uNr linux/drivers/no-otg/functions/acm/modem.c linux/drivers/otg/functions/acm/modem.c
+--- linux/drivers/no-otg/functions/acm/modem.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/modem.c 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,263 @@
++/*
++ * otg/functions/acm/modem.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ */
++/*!
++ * @file otg/functions/acm/modem.c
++ * @brief ACM-MODEM Descriptor Set
++ *
++ * This file is the USB specific piece that interfaces with the otgcore layer.
++ * If you're looking for the USB specific piece that interfaces with the
++ * host usbcore layer, that's in otg/functions/acm/acm-cl.c
++ *
++ * 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 an interrupt endpoint.
++ *
++ * @ingroup MODEMFunction
++ */
++
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#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/smp_lock.h>
++#include <linux/slab.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++
++#include <otg/otg-trace.h>
++#include "acm.h"
++#include "acm-fd.h"
++#include "acm-os.h"
++
++
++
++/*
++ * CDC ACM Configuration
++ *
++ * Endpoint, Class, Interface, Configuration and Device descriptors/descriptions
++ */
++
++/*! BULK OUT Data Endpoint Descriptor
++ */
++static u8 mdn_alt_1[] = { 0x07, USB_DT_ENDPOINT, USB_DIR_OUT, BULK, 0, 0x00, 0x00, };
++
++/*! BULK In Data Endpoint Descriptor
++ */
++static u8 mdn_alt_2[] = { 0x07, USB_DT_ENDPOINT, USB_DIR_IN, BULK, 0, 0x00, 0x00, };
++
++/*! Data Endpoint Descriptor List
++ */
++static struct usbd_endpoint_descriptor *mdn_alt_endpoints[] = {
++ (struct usbd_endpoint_descriptor *) mdn_alt_1,
++ (struct usbd_endpoint_descriptor *) mdn_alt_2, };
++
++/*! Data Endpoint Index List
++ */
++u8 mdn_alt_indexes[] = { BULK_OUT, BULK_IN, };
++
++/*! INTERRUPT In Comm Endpoint Descriptor
++ */
++static u8 mdn_comm_1[] = { 0x07, USB_DT_ENDPOINT, USB_DIR_IN, INTERRUPT, 0, 0x00, 0x0a, };
++
++/*! Comm Endpoint Descriptor List
++ */
++static struct usbd_endpoint_descriptor *mdn_comm_endpoints[] = { (struct usbd_endpoint_descriptor *) mdn_comm_1 };
++
++
++/*! Comm Endpoint Index List
++ */
++u8 mdn_comm_indexes[] = { INT_IN, };
++
++/*! @{
++ * Class Descriptors
++ */
++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 Class Descriptor
++ * 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 usbd_generic_class_descriptor *cdc_comm_class_descriptors[] =
++ { (struct usbd_generic_class_descriptor *) cdc_class_1,
++ (struct usbd_generic_class_descriptor *) cdc_class_2,
++ (struct usbd_generic_class_descriptor *) cdc_class_3,
++ (struct usbd_generic_class_descriptor *) cdc_class_4, };
++
++
++
++/* Alternate Descriptors */
++// First two bytes are identical in all: bLength, bDescriptorType (0x09 0x04)
++
++/*! Comm Alternate Descriptor
++ */
++static u8 cdc_comm_alternate_descriptor[sizeof(struct usbd_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, COMM_INTF, 0x00, 0x00, // bInterfaceNumber, bAlternateSetting, bNumEndpoints
++ COMMUNICATIONS_INTERFACE_CLASS, COMMUNICATIONS_ACM_SUBCLASS, 0x01, 0x00, };
++
++/*! Data Alternate Descriptor
++ */
++static u8 cdc_data_alternate_descriptor[sizeof(struct usbd_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, DATA_INTF, 0x00, 0x00, // bInterfaceNumber, bAlternateSetting, bNumEndpoints
++ DATA_INTERFACE_CLASS, COMMUNICATIONS_NO_SUBCLASS, COMMUNICATIONS_NO_PROTOCOL, 0x00, };
++
++
++
++/*! Comm alternate descriptions
++ */
++static struct usbd_alternate_description cdc_comm_alternate_descriptions[] = {
++ { iInterface: CONFIG_OTG_ACM_COMM_INTF,
++ interface_descriptor: (struct usbd_interface_descriptor *)&cdc_comm_alternate_descriptor,
++ classes:sizeof (cdc_comm_class_descriptors) / sizeof (struct usbd_generic_class_descriptor *),
++ class_list: cdc_comm_class_descriptors,
++ endpoint_list: mdn_comm_endpoints,
++ endpoints:sizeof (mdn_comm_endpoints) / sizeof(struct usbd_endpoint_descriptor *),
++ endpoint_indexes: mdn_comm_indexes,
++ }, };
++
++/*! Data alternate descriptions
++ */
++static struct usbd_alternate_description cdc_data_alternate_descriptions[] = {
++ { iInterface: CONFIG_OTG_ACM_DATA_INTF,
++ interface_descriptor: (struct usbd_interface_descriptor *)&cdc_data_alternate_descriptor,
++ endpoint_list: mdn_alt_endpoints,
++ endpoints:sizeof (mdn_alt_endpoints) / sizeof(struct usbd_endpoint_descriptor *),
++ endpoint_indexes: mdn_alt_indexes,
++ }, };
++
++
++/*! Interface Descriptions List */
++static struct usbd_interface_description cdc_interfaces[] = {
++ {
++ alternates:sizeof (cdc_comm_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ alternate_list:cdc_comm_alternate_descriptions,
++ },
++
++ {
++ alternates:sizeof (cdc_data_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ alternate_list:cdc_data_alternate_descriptions,
++ },
++};
++
++
++/*! Configuration Descriptor
++ */
++static u8 cdc_configuration_descriptor[sizeof(struct usbd_configuration_descriptor)] = {
++ 0x09, USB_DT_CONFIGURATION, 0x00, 0x00, sizeof (cdc_interfaces) / sizeof (struct usbd_interface_description),
++ 0x01, 0x00, BMATTRIBUTE, BMAXPOWER, };
++
++/*! Configuration Description
++ */
++struct usbd_configuration_description mdn_description[] = {
++ { iConfiguration: CONFIG_OTG_ACM_DESC,
++ configuration_descriptor: (struct usbd_configuration_descriptor *)cdc_configuration_descriptor,
++ }, };
++
++/*! Device Descriptor
++ */
++static struct usbd_device_descriptor mdn_device_descriptor = {
++ bLength: sizeof(struct usbd_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_OTG_ACM_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_ACM_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_ACM_BCDDEVICE),
++};
++
++#ifdef CONFIG_OTG_HIGH_SPEED
++/*! High Speed Device Qualifier Descriptor
++ */
++static struct usbd_device_qualifier_descriptor mdn_device_qualifier_descriptor = {
++ bLength: sizeof(struct usbd_device_qualifier_descriptor),
++ bDescriptorType: USB_DT_DEVICE_QUALIFIER,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: COMMUNICATIONS_DEVICE_CLASS,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++};
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++
++/*! Endpoint Request List
++ */
++static struct usbd_endpoint_request mdn_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, },
++ { 0, },
++};
++
++/*! OTG Descriptor
++ */
++static struct usbd_otg_descriptor mdn_otg_descriptor = {
++ bLength : sizeof(struct usbd_otg_descriptor),
++ bDescriptorType: USB_DT_OTG,
++ bmAttributes: 0,
++};
++
++/*! Device Description
++ */
++struct usbd_device_description mdn_device_description = {
++ device_descriptor: &mdn_device_descriptor,
++#ifdef CONFIG_OTG_HIGH_SPEED
++ device_qualifier_descriptor: &mdn_device_qualifier_descriptor,
++#endif /* CONFIG_OTG_HIGH_SPEED */
++ otg_descriptor: &mdn_otg_descriptor,
++ iManufacturer: CONFIG_OTG_ACM_MANUFACTURER,
++ iProduct: CONFIG_OTG_ACM_PRODUCT_NAME,
++#if !defined(CONFIG_OTG_NO_SERIAL_NUMBER) && defined(CONFIG_OTG_SERIAL_NUMBER_STR)
++ iSerialNumber: CONFIG_OTG_SERIAL_NUMBER_STR,
++#endif
++};
++
++
++
++
++/*! function_driver
++ */
++struct usbd_function_driver modem_function_driver = {
++ name: "ACM-MDM",
++ fops:&function_ops,
++ device_description:&mdn_device_description,
++ bNumConfigurations:sizeof (mdn_description) / sizeof (struct usbd_configuration_description),
++ configuration_description:mdn_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_OTG_ACM_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_ACM_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_ACM_BCDDEVICE),
++ bNumInterfaces:sizeof (cdc_interfaces) / sizeof (struct usbd_interface_description),
++ interface_list:cdc_interfaces,
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: mdn_endpoint_requests,
++};
++
+diff -uNr linux/drivers/no-otg/functions/acm/modem.h linux/drivers/otg/functions/acm/modem.h
+--- linux/drivers/no-otg/functions/acm/modem.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/modem.h 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,118 @@
++/*
++ * otg/functions/acm/modem.h
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @defgroup MODEMFunction ACM-Modem
++ * @ingroup functiongroup
++ */
++/*!
++ * @file otg/functions/acm/modem.h
++ * @brief ACM Function Driver private defines
++ *
++ *
++ * This is an ACM Function Driver. The upper edge is exposed
++ * to the hosting OS as a Posix type character device. The lower
++ * edge implements the USB Device Stack API.
++ *
++ * These are emulated and set by the modem driver as appropriate
++ * to model a virutal serial port. The
++ *
++ * TIOCM_RNG RNG (Ring) not used
++ * TIOCM_LE DSR (Data Set Ready / Line Enable)
++ * TIOCM_DSR DSR (Data Set Ready)
++ * TIOCM_CAR DCD (Data Carrier Detect)
++ * TIOCM_CTS CTS (Clear to Send)
++ * TIOCM_CD TIOCM_CAR
++ * TIOCM_RI TIOCM_RNG
++ *
++ * These are set by the application:
++ *
++ * TIOCM_DTR DTR (Data Terminal Ready)
++ * TIOCM_RTS RTS (Request to Send)
++ *
++ * TIOCM_LOOP Set into loopback mode
++ * TIOCM_OUT1 Not used.
++ * TIOCM_OUT2 Not used.
++ *
++ *
++ * The following File and termio c_cflags are used:
++ *
++ * O_NONBLOCK don't block in modem_open()
++ * O_EXCL don't allow more than one open
++ *
++ * CLOCAL ignore DTR status
++ * CBAUD send break if set to B0
++ *
++ * Virtual NULL Modem
++ *
++ * Peripheral to Host via Serial State Notification (write ioctls)
++ *
++ * Application TIOCM Null Modem ACM (DCE) Notificaiton Host (DTE)
++ * -------------------------------------------------------------------------------------------------------------
++ * Request to send TIOCM_RTS RTS -> CTS CTS Not Available Clear to Send (N/A)
++ * Data Terminal Ready TIOCM_DTR DTR -> DSR DSR bTxCarrier Data Set Ready
++ * DTR -> DCD DCD bRXCarrier Carrier Detect
++ * Ring Indicator TIOCM_OUT1 OUT1 -> RI RI bRingSignal Ring Indicator
++ * Overrun TIOCM_OUT2 OUT2 -> Overrun Overrun bOverrun Overrun
++ * Send Break B0 B0 -> Break Break bBreak Break Received
++ * -------------------------------------------------------------------------------------------------------------
++ *
++ *
++ * Host to Peripheral via Set Control Line State
++ *
++ * Host (DTE) Line State ACM (DCE) Null Modem TIOCM Peripheral (DTE)
++ * -------------------------------------------------------------------------------------------------------------
++ * Data Terminal Ready D0 DTR DTR -> DSR TIOCM_DSR Data Set Ready
++ * DTR -> DCD TIOCM_CAR Carrier Detect
++ * Request To Send D1 RTS RTS -> CTS TIOCM_CTS Clear to Send
++ * -------------------------------------------------------------------------------------------------------------
++ *
++ *
++ * @ingroup MODEMFunction
++ */
++
++
++extern struct usbd_function_driver modem_function_driver;
++
++//#define MODEM_OPENED (1 << 0) /*!< OPENED flag */
++#define MODEMFD_CLOCAL (1 << 1) /*!< CLOCAL flag */
++//#define MODEMFD_LOOPBACK (1 << 2) /*!< LOOPBACK flag */
++#define MODEMFD_EXCLUSIVE (1 << 3) /*!< EXCLUSIVE flag */
++#define MODEMFD_THROTTLED (1 << 4) /*!< THROTTLED flag */
++
++/*! struct modem_private
++ */
++struct modem_private {
++
++ struct modem_driver *modem_driver; /*!< modem structure */
++ int modem_driver_registered; /*!< non-zero if modem_driver registered */
++ int usb_driver_registered; /*!< non-zero if usb function registered */
++
++ struct modem_struct *modem; /*!< non-null if modem open */
++ struct tq_struct wqueue; /*!< task queue for writer wakeup */
++ struct tq_struct hqueue; /*!< task queue for hangup */
++
++ u32 flags; /*!< flags */
++
++ u32 tiocm; /*!< tiocm settings */
++
++ struct serial_struct serial_struct; /*!< serial structure used for TIOCSSERIAL and TIOCGSERIAL */
++
++ wait_queue_head_t tiocm_wait;
++ u32 tiocgicount;
++
++ u32 c_cflag;
++
++ wait_queue_head_t open_wait; // wait queue for blocking open
++ int exiting; // True if module exiting
++};
++
++
+diff -uNr linux/drivers/no-otg/functions/acm/obex-l24-os.c linux/drivers/otg/functions/acm/obex-l24-os.c
+--- linux/drivers/no-otg/functions/acm/obex-l24-os.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/obex-l24-os.c 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,194 @@
++/*
++ * otg/functions/acm/obex-l24-os.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/functions/acm/obex-l24-os.c
++ * @brief ACM Function Driver private defines
++ *
++ * An ACM (Abstract Control Model) driver is composed of two pieces:
++ * 1) An OS specific piece that handles creating and operating
++ * a serial device for the given OS.
++ * 2) A USB specific piece that interfaces either with the host
++ * usbcore layer, or with the otgcore layer.
++ *
++ * If the USB piece interfaces with the host usbcore layer you get
++ * an ACM class driver. If the USB piece interfaces with the otgcore
++ * layer you get an ACM function driver.
++ *
++ * This file is the OS specific piece that interfaces with Linux
++ * (kernel versions 2.4.*). It creates two simple characters devices.
++ * One for the data transport and one for the communications interface.
++ *
++ * @ingroup ACMFunction
++ */
++
++
++//#include <otg/osversion.h>
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++MOD_AUTHOR ("tbr@belcarra.com, sl@belcarra.com");
++
++MOD_DESCRIPTION ("Belcarra CDC-ACM Function");
++EMBED_LICENSE();
++
++
++#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 <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++
++#include <linux/capability.h>
++#include <otg/otg-trace.h>
++#include "acm.h"
++#include "acm-fd.h"
++#include "acm-os.h"
++
++// May need an ifdef here to pick up the acm_cl_usb_ops in the future.
++static struct acm_usb_services *usb_ops = &acm_fd_usb_ops;
++
++#define OBX obx_fd_trace_tag
++otg_tag_t obx_fd_trace_tag;
++
++/* 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;
++
++MOD_PARM (vendor_id, "i");
++MOD_PARM (product_id, "i");
++MOD_PARM (max_queued_urbs, "i");
++MOD_PARM (max_queued_bytes, "i");
++
++MOD_PARM_DESC (vendor_id, "Device Vendor ID");
++MOD_PARM_DESC (product_id, "Device Product ID");
++MOD_PARM_DESC (max_queued_urbs, "Maximum TX Queued Urbs");
++MOD_PARM_DESC (max_queued_bytes, "Maximum TX Queued Bytes");
++
++
++/* ACM ***************************************************************************************** */
++
++#define ACM_TTY_MAJOR 166
++#define ACM_TTY_MINOR 0
++#define ACM_TTY_MINORS 1
++
++static struct acm_private acm_private;
++
++/* USB Simple Char Device ********************************************************************** */
++
++
++/* USB Comm Char Device ************************************************************************ */
++
++
++/* 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, tbr@belcarra.com\n");
++ OBX = otg_trace_obtain_tag();
++
++ // 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;
++ //acm_private.recv_tqueue.routine = &acm_start_recv;
++ //acm_private.recv_tqueue.data = &acm_private;
++
++ //init_waitqueue_head(&acm_private.open_wait);
++
++
++ // register as usb function driver
++
++ THROW_IF (usb_ops->initialize_usb_part(&acm_private,"acm_fd",vendor_id,product_id,
++ max_queued_urbs,max_queued_bytes ), error);
++
++ CATCH(error) {
++ printk(KERN_ERR"%s: ERROR\n", __FUNCTION__);
++
++ TRACE_MSG0(OBX,"--> -EINVAL");
++ return -EINVAL;
++ }
++ TRACE_MSG0(OBX,"--> 0");
++ return 0;
++}
++
++void acm_wait_task(WORK_ITEM *queue)
++{
++ TRACE_MSG1(OBX,"entered data=%p",queue->data);
++ RETURN_IF(!queue->data);
++ queue->data = NULL;
++#if defined(LINUX24)
++ while (queue->sync) {
++ TRACE_MSG1(OBX,"waiting for queue: %p",queue);
++ schedule_timeout(HZ);
++ }
++#else
++ while(PENDING_WORK_ITEM((*queue))){
++ TRACE_MSG1(OBX,"waiting for queue: %p",queue);
++ SCHEDULE_TIMEOUT(1); // 1 second delay
++ }
++#endif
++ TRACE_MSG0(OBX,"exited");
++}
++
++/* acm_modexit - module cleanup
++ */
++STATIC void acm_modexit (void)
++{
++ unsigned long flags;
++ struct usbd_urb *urb;
++ TRACE_MSG0(OBX,"entered");
++
++ // 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);
++
++//#if defined(LINUX24)
++// run_task_queue(&tq_timer);
++//#else
++// blk_run_queues();
++//#endif
++
++ //acm_wait_task(&acm_private.recv_tqueue);
++
++ usb_ops->terminate_usb_part(&acm_private);
++ otg_trace_invalidate_tag(OBX);
++}
++
++
++module_init (acm_modinit);
++module_exit (acm_modexit);
+diff -uNr linux/drivers/no-otg/functions/acm/obex.c linux/drivers/otg/functions/acm/obex.c
+--- linux/drivers/no-otg/functions/acm/obex.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/obex.c 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,263 @@
++/*
++ * otg/functions/acm/obex.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ */
++/*!
++ * @file otg/functions/acm/obex.c
++ * @brief ACM-OBEX Descriptor Set
++ *
++ * This file is the USB specific piece that interfaces with the otgcore layer.
++ * If you're looking for the USB specific piece that interfaces with the
++ * host usbcore layer, that's in otg/functions/acm/acm-cl.c
++ *
++ * 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 an interrupt endpoint.
++ *
++ * @ingroup OBEXFunction
++ */
++
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#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/smp_lock.h>
++#include <linux/slab.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++
++#include <otg/otg-trace.h>
++#include "acm.h"
++#include "acm-fd.h"
++#include "acm-os.h"
++
++
++
++/*
++ * CDC ACM Configuration
++ *
++ * Endpoint, Class, Interface, Configuration and Device descriptors/descriptions
++ */
++
++/*! BULK OUT Data Endpoint Descriptor
++ */
++static u8 obx_alt_1[] = { 0x07, USB_DT_ENDPOINT, USB_DIR_OUT, BULK, 0, 0x00, 0x00, };
++
++/*! BULK In Data Endpoint Descriptor
++ */
++static u8 obx_alt_2[] = { 0x07, USB_DT_ENDPOINT, USB_DIR_IN, BULK, 0, 0x00, 0x00, };
++
++/*! Data Endpoint Descriptor List
++ */
++static struct usbd_endpoint_descriptor *obx_alt_endpoints[] = {
++ (struct usbd_endpoint_descriptor *) obx_alt_1,
++ (struct usbd_endpoint_descriptor *) obx_alt_2, };
++
++/*! Data Endpoint Index List
++ */
++u8 obx_alt_indexes[] = { BULK_OUT, BULK_IN, };
++
++/*! INTERRUPT In Comm Endpoint Descriptor
++ */
++static u8 obx_comm_1[] = { 0x07, USB_DT_ENDPOINT, USB_DIR_IN, INTERRUPT, 0, 0x00, 0x0a, };
++
++/*! Comm Endpoint Descriptor List
++ */
++static struct usbd_endpoint_descriptor *obx_comm_endpoints[] = { (struct usbd_endpoint_descriptor *) obx_comm_1 };
++
++
++/*! Comm Endpoint Index List
++ */
++u8 obx_comm_indexes[] = { INT_IN, };
++
++/*! @{
++ * Class Descriptors
++ */
++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 Class Descriptor
++ * 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 usbd_generic_class_descriptor *cdc_comm_class_descriptors[] =
++ { (struct usbd_generic_class_descriptor *) cdc_class_1,
++ (struct usbd_generic_class_descriptor *) cdc_class_2,
++ (struct usbd_generic_class_descriptor *) cdc_class_3,
++ (struct usbd_generic_class_descriptor *) cdc_class_4, };
++
++
++
++/* Alternate Descriptors */
++// First two bytes are identical in all: bLength, bDescriptorType (0x09 0x04)
++
++/*! Comm Alternate Descriptor
++ */
++static u8 cdc_comm_alternate_descriptor[sizeof(struct usbd_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, COMM_INTF, 0x00, 0x00, // bInterfaceNumber, bAlternateSetting, bNumEndpoints
++ COMMUNICATIONS_INTERFACE_CLASS, COMMUNICATIONS_ACM_SUBCLASS, 0x01, 0x00, };
++
++/*! Data Alternate Descriptor
++ */
++static u8 cdc_data_alternate_descriptor[sizeof(struct usbd_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, DATA_INTF, 0x00, 0x00, // bInterfaceNumber, bAlternateSetting, bNumEndpoints
++ DATA_INTERFACE_CLASS, COMMUNICATIONS_NO_SUBCLASS, COMMUNICATIONS_NO_PROTOCOL, 0x00, };
++
++
++
++/*! Comm alternate descriptions
++ */
++static struct usbd_alternate_description cdc_comm_alternate_descriptions[] = {
++ { iInterface: CONFIG_OTG_ACM_COMM_INTF,
++ interface_descriptor: (struct usbd_interface_descriptor *)&cdc_comm_alternate_descriptor,
++ classes:sizeof (cdc_comm_class_descriptors) / sizeof (struct usbd_generic_class_descriptor *),
++ class_list: cdc_comm_class_descriptors,
++ endpoint_list: obx_comm_endpoints,
++ endpoints:sizeof (obx_comm_endpoints) / sizeof(struct usbd_endpoint_descriptor *),
++ endpoint_indexes: obx_comm_indexes,
++ }, };
++
++/*! Data alternate descriptions
++ */
++static struct usbd_alternate_description cdc_data_alternate_descriptions[] = {
++ { iInterface: CONFIG_OTG_ACM_DATA_INTF,
++ interface_descriptor: (struct usbd_interface_descriptor *)&cdc_data_alternate_descriptor,
++ endpoint_list: obx_alt_endpoints,
++ endpoints:sizeof (obx_alt_endpoints) / sizeof(struct usbd_endpoint_descriptor *),
++ endpoint_indexes: obx_alt_indexes,
++ }, };
++
++
++/*! Interface Descriptions List */
++static struct usbd_interface_description cdc_interfaces[] = {
++ {
++ alternates:sizeof (cdc_comm_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ alternate_list:cdc_comm_alternate_descriptions,
++ },
++
++ {
++ alternates:sizeof (cdc_data_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ alternate_list:cdc_data_alternate_descriptions,
++ },
++
++};
++
++
++/*! Configuration Descriptor
++ */
++static u8 cdc_configuration_descriptor[sizeof(struct usbd_configuration_descriptor)] = {
++ 0x09, USB_DT_CONFIGURATION, 0x00, 0x00, sizeof (cdc_interfaces) / sizeof (struct usbd_interface_description),
++ 0x01, 0x00, BMATTRIBUTE, BMAXPOWER, };
++
++/*! Configuration Description
++ */
++struct usbd_configuration_description obx_description[] = {
++ { iConfiguration: CONFIG_OTG_ACM_DESC,
++ configuration_descriptor: (struct usbd_configuration_descriptor *)cdc_configuration_descriptor,
++ }, };
++
++/*! Device Descriptor
++ */
++static struct usbd_device_descriptor obx_device_descriptor = {
++ bLength: sizeof(struct usbd_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_OTG_ACM_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_ACM_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_ACM_BCDDEVICE),
++};
++
++#ifdef CONFIG_OTG_HIGH_SPEED
++/*! High Speed Device Qualifier Descriptor
++ */
++static struct usbd_device_qualifier_descriptor obx_device_qualifier_descriptor = {
++ bLength: sizeof(struct usbd_device_qualifier_descriptor),
++ bDescriptorType: USB_DT_DEVICE_QUALIFIER,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: COMMUNICATIONS_DEVICE_CLASS,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++};
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++
++/*! Endpoint Request List
++ */
++static struct usbd_endpoint_request obx_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, },
++ { 0, },
++};
++
++/*! OTG Descriptor
++ */
++static struct usbd_otg_descriptor obx_otg_descriptor = {
++ bLength : sizeof(struct usbd_otg_descriptor),
++ bDescriptorType: USB_DT_OTG,
++ bmAttributes: 0,
++};
++
++/*! Device Description
++ */
++struct usbd_device_description obx_device_description = {
++ device_descriptor: &obx_device_descriptor,
++#ifdef CONFIG_OTG_HIGH_SPEED
++ device_qualifier_descriptor: &obx_device_qualifier_descriptor,
++#endif /* CONFIG_OTG_HIGH_SPEED */
++ otg_descriptor: &obx_otg_descriptor,
++ iManufacturer: CONFIG_OTG_ACM_MANUFACTURER,
++ iProduct: CONFIG_OTG_ACM_PRODUCT_NAME,
++#if !defined(CONFIG_OTG_NO_SERIAL_NUMBER) && defined(CONFIG_OTG_SERIAL_NUMBER_STR)
++ iSerialNumber: CONFIG_OTG_SERIAL_NUMBER_STR,
++#endif
++};
++
++
++
++/*! function_driver
++ */
++struct usbd_function_driver obex_function_driver = {
++ name: "ACM-OBX",
++ fops:&function_ops,
++ device_description:&obx_device_description,
++ bNumConfigurations:sizeof (obx_description) / sizeof (struct usbd_configuration_description),
++ configuration_description:obx_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_OTG_ACM_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_ACM_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_ACM_BCDDEVICE),
++ bNumInterfaces:sizeof (cdc_interfaces) / sizeof (struct usbd_interface_description),
++ interface_list:cdc_interfaces,
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: obx_endpoint_requests,
++};
++
+diff -uNr linux/drivers/no-otg/functions/acm/obex.h linux/drivers/otg/functions/acm/obex.h
+--- linux/drivers/no-otg/functions/acm/obex.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/obex.h 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,66 @@
++/*
++ * otg/functions/acm/obex.h
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @defgroup OBEXFunction ACM-OBEX
++ * @ingroup functiongroup
++ */
++/*!
++ * @file otg/functions/acm/obex.h
++ * @brief ACM Function Driver private defines
++ *
++ *
++ * This is an ACM Function Driver. The upper edge is exposed
++ * to the hosting OS as a Posix type character device. The lower
++ * edge implements the USB Device Stack API.
++ *
++ *
++ *
++ * @ingroup OBEXFunction
++ */
++
++
++extern struct usbd_function_driver tty_function_driver;
++
++//#define TTY_OPENED (1 << 0) /*!< OPENED flag */
++#define TTYFD_CLOCAL (1 << 1) /*!< CLOCAL flag */
++//#define TTYFD_LOOPBACK (1 << 2) /*!< LOOPBACK flag */
++#define TTYFD_EXCLUSIVE (1 << 3) /*!< EXCLUSIVE flag */
++#define TTYFD_THROTTLED (1 << 4) /*!< THROTTLED flag */
++
++/*! struct obex_private
++ */
++struct obex_private {
++
++ struct tty_driver *tty_driver; /*!< tty structure */
++ 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 */
++
++ u32 flags; /*!< flags */
++
++ u32 tiocm; /*!< tiocm settings */
++
++ struct serial_struct serial_struct; /*!< serial structure used for TIOCSSERIAL and TIOCGSERIAL */
++
++ wait_queue_head_t tiocm_wait;
++ u32 tiocgicount;
++
++ u32 c_cflag;
++
++ wait_queue_head_t open_wait; // wait queue for blocking open
++ int exiting; // True if module exiting
++};
++
++
+diff -uNr linux/drivers/no-otg/functions/acm/tty-fd.c linux/drivers/otg/functions/acm/tty-fd.c
+--- linux/drivers/no-otg/functions/acm/tty-fd.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/tty-fd.c 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,263 @@
++/*
++ * otg/functions/acm/tty-fd.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ */
++/*!
++ * @file otg/functions/acm/tty-fd.c
++ * @brief ACM-TTY Descriptor Set
++ *
++ * This file is the USB specific piece that interfaces with the otgcore layer.
++ * If you're looking for the USB specific piece that interfaces with the
++ * host usbcore layer, that's in otg/functions/acm/acm-cl.c
++ *
++ * 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 an interrupt endpoint.
++ *
++ * @ingroup TTYFunction
++ */
++
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#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/smp_lock.h>
++#include <linux/slab.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++
++#include <otg/otg-trace.h>
++#include "acm.h"
++#include "acm-fd.h"
++#include "acm-os.h"
++
++
++
++/*
++ * CDC ACM Configuration
++ *
++ * Endpoint, Class, Interface, Configuration and Device descriptors/descriptions
++ */
++
++/*! BULK OUT Data Endpoint Descriptor
++ */
++static u8 tty_alt_1[] = { 0x07, USB_DT_ENDPOINT, USB_DIR_OUT, BULK, 0, 0x00, 0x00, };
++
++/*! BULK In Data Endpoint Descriptor
++ */
++static u8 tty_alt_2[] = { 0x07, USB_DT_ENDPOINT, USB_DIR_IN, BULK, 0, 0x00, 0x00, };
++
++/*! Data Endpoint Descriptor List
++ */
++static struct usbd_endpoint_descriptor *tty_alt_endpoints[] = {
++ (struct usbd_endpoint_descriptor *) tty_alt_1,
++ (struct usbd_endpoint_descriptor *) tty_alt_2, };
++
++/*! Data Endpoint Index List
++ */
++u8 tty_alt_indexes[] = { BULK_OUT, BULK_IN, };
++
++/*! INTERRUPT In Comm Endpoint Descriptor
++ */
++static u8 tty_comm_1[] = { 0x07, USB_DT_ENDPOINT, USB_DIR_IN, INTERRUPT, 0, 0x00, 0x0a, };
++
++/*! Comm Endpoint Descriptor List
++ */
++static struct usbd_endpoint_descriptor *tty_comm_endpoints[] = { (struct usbd_endpoint_descriptor *) tty_comm_1 };
++
++
++/*! Comm Endpoint Index List
++ */
++u8 tty_comm_indexes[] = { INT_IN, };
++
++/*! @{
++ * Class Descriptors
++ */
++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 Class Descriptor
++ * 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 usbd_generic_class_descriptor *cdc_comm_class_descriptors[] =
++ { (struct usbd_generic_class_descriptor *) cdc_class_1,
++ (struct usbd_generic_class_descriptor *) cdc_class_2,
++ (struct usbd_generic_class_descriptor *) cdc_class_3,
++ (struct usbd_generic_class_descriptor *) cdc_class_4, };
++
++
++
++/* Alternate Descriptors */
++// First two bytes are identical in all: bLength, bDescriptorType (0x09 0x04)
++
++/*! Comm Alternate Descriptor
++ */
++static u8 cdc_comm_alternate_descriptor[sizeof(struct usbd_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, COMM_INTF, 0x00, 0x00, // bInterfaceNumber, bAlternateSetting, bNumEndpoints
++ COMMUNICATIONS_INTERFACE_CLASS, COMMUNICATIONS_ACM_SUBCLASS, 0x01, 0x00, };
++
++/*! Data Alternate Descriptor
++ */
++static u8 cdc_data_alternate_descriptor[sizeof(struct usbd_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, DATA_INTF, 0x00, 0x00, // bInterfaceNumber, bAlternateSetting, bNumEndpoints
++ DATA_INTERFACE_CLASS, COMMUNICATIONS_NO_SUBCLASS, COMMUNICATIONS_NO_PROTOCOL, 0x00, };
++
++
++
++/*! Comm alternate descriptions
++ */
++static struct usbd_alternate_description cdc_comm_alternate_descriptions[] = {
++ { iInterface: CONFIG_OTG_ACM_COMM_INTF,
++ interface_descriptor: (struct usbd_interface_descriptor *)&cdc_comm_alternate_descriptor,
++ classes:sizeof (cdc_comm_class_descriptors) / sizeof (struct usbd_generic_class_descriptor *),
++ class_list: cdc_comm_class_descriptors,
++ endpoint_list: tty_comm_endpoints,
++ endpoints:sizeof (tty_comm_endpoints) / sizeof(struct usbd_endpoint_descriptor *),
++ endpoint_indexes: tty_comm_indexes,
++ }, };
++
++/*! Data alternate descriptions
++ */
++static struct usbd_alternate_description cdc_data_alternate_descriptions[] = {
++ { iInterface: CONFIG_OTG_ACM_DATA_INTF,
++ interface_descriptor: (struct usbd_interface_descriptor *)&cdc_data_alternate_descriptor,
++ endpoint_list: tty_alt_endpoints,
++ endpoints:sizeof (tty_alt_endpoints) / sizeof(struct usbd_endpoint_descriptor *),
++ endpoint_indexes: tty_alt_indexes,
++ }, };
++
++
++/*! Interface Descriptions List */
++static struct usbd_interface_description cdc_interfaces[] = {
++ {
++ alternates:sizeof (cdc_comm_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ alternate_list:cdc_comm_alternate_descriptions,
++ },
++
++ {
++ alternates:sizeof (cdc_data_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ alternate_list:cdc_data_alternate_descriptions,
++ },
++
++};
++
++
++/*! Configuration Descriptor
++ */
++static u8 cdc_configuration_descriptor[sizeof(struct usbd_configuration_descriptor)] = {
++ 0x09, USB_DT_CONFIGURATION, 0x00, 0x00, sizeof (cdc_interfaces) / sizeof (struct usbd_interface_description),
++ 0x01, 0x00, BMATTRIBUTE, BMAXPOWER, };
++
++/*! Configuration Description
++ */
++struct usbd_configuration_description tty_description[] = {
++ { iConfiguration: CONFIG_OTG_ACM_DESC,
++ configuration_descriptor: (struct usbd_configuration_descriptor *)cdc_configuration_descriptor,
++ }, };
++
++/*! Device Descriptor
++ */
++static struct usbd_device_descriptor tty_device_descriptor = {
++ bLength: sizeof(struct usbd_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_OTG_ACM_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_ACM_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_ACM_BCDDEVICE),
++};
++
++#ifdef CONFIG_OTG_HIGH_SPEED
++/*! High Speed Device Qualifier Descriptor
++ */
++static struct usbd_device_qualifier_descriptor tty_device_qualifier_descriptor = {
++ bLength: sizeof(struct usbd_device_qualifier_descriptor),
++ bDescriptorType: USB_DT_DEVICE_QUALIFIER,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: COMMUNICATIONS_DEVICE_CLASS,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++};
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++
++/*! Endpoint Request List
++ */
++static struct usbd_endpoint_request tty_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, },
++ { 0, },
++};
++
++/*! OTG Descriptor
++ */
++static struct usbd_otg_descriptor tty_otg_descriptor = {
++ bLength : sizeof(struct usbd_otg_descriptor),
++ bDescriptorType: USB_DT_OTG,
++ bmAttributes: 0,
++};
++
++/*! Device Description
++ */
++struct usbd_device_description tty_device_description = {
++ device_descriptor: &tty_device_descriptor,
++#ifdef CONFIG_OTG_HIGH_SPEED
++ device_qualifier_descriptor: &tty_device_qualifier_descriptor,
++#endif /* CONFIG_OTG_HIGH_SPEED */
++ otg_descriptor: &tty_otg_descriptor,
++ iManufacturer: CONFIG_OTG_ACM_MANUFACTURER,
++ iProduct: CONFIG_OTG_ACM_PRODUCT_NAME,
++#if !defined(CONFIG_OTG_NO_SERIAL_NUMBER) && defined(CONFIG_OTG_SERIAL_NUMBER_STR)
++ iSerialNumber: CONFIG_OTG_SERIAL_NUMBER_STR,
++#endif
++};
++
++/*! function_driver
++ */
++struct usbd_function_driver tty_function_driver = {
++ name: "ACM-TTY",
++ fops:&function_ops,
++ device_description:&tty_device_description,
++ bNumConfigurations:sizeof (tty_description) / sizeof (struct usbd_configuration_description),
++ configuration_description:tty_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_OTG_ACM_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_ACM_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_ACM_BCDDEVICE),
++ bNumInterfaces:sizeof (cdc_interfaces) / sizeof (struct usbd_interface_description),
++ interface_list:cdc_interfaces,
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: tty_endpoint_requests,
++};
++
++
++
+diff -uNr linux/drivers/no-otg/functions/acm/tty-if.c linux/drivers/otg/functions/acm/tty-if.c
+--- linux/drivers/no-otg/functions/acm/tty-if.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/tty-if.c 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,263 @@
++/*
++ * otg/functions/acm/tty-if.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ */
++/*!
++ * @file otg/functions/acm/tty-if.c
++ * @brief ACM-TTY Descriptor Set
++ *
++ * This file is the USB specific piece that interfaces with the otgcore layer.
++ * If you're looking for the USB specific piece that interfaces with the
++ * host usbcore layer, that's in otg/functions/acm/acm-cl.c
++ *
++ * 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 an interrupt endpoint.
++ *
++ * @ingroup TTYFunction
++ */
++
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#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/smp_lock.h>
++#include <linux/slab.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++
++#include <otg/otg-trace.h>
++#include "acm.h"
++#include "acm-fd.h"
++#include "acm-os.h"
++
++
++
++/*
++ * CDC ACM Configuration
++ *
++ * Endpoint, Class, Interface, Configuration and Device descriptors/descriptions
++ */
++
++/*! BULK OUT Data Endpoint Descriptor
++ */
++static u8 tty_alt_1[] = { 0x07, USB_DT_ENDPOINT, USB_DIR_OUT, BULK, 0, 0x00, 0x00, };
++
++/*! BULK In Data Endpoint Descriptor
++ */
++static u8 tty_alt_2[] = { 0x07, USB_DT_ENDPOINT, USB_DIR_IN, BULK, 0, 0x00, 0x00, };
++
++/*! Data Endpoint Descriptor List
++ */
++static struct usbd_endpoint_descriptor *tty_alt_endpoints[] = {
++ (struct usbd_endpoint_descriptor *) tty_alt_1,
++ (struct usbd_endpoint_descriptor *) tty_alt_2, };
++
++/*! Data Endpoint Index List
++ */
++u8 tty_alt_indexes[] = { BULK_OUT, BULK_IN, };
++
++/*! INTERRUPT In Comm Endpoint Descriptor
++ */
++static u8 tty_comm_1[] = { 0x07, USB_DT_ENDPOINT, USB_DIR_IN, INTERRUPT, 0, 0x00, 0x0a, };
++
++/*! Comm Endpoint Descriptor List
++ */
++static struct usbd_endpoint_descriptor *tty_comm_endpoints[] = { (struct usbd_endpoint_descriptor *) tty_comm_1 };
++
++
++/*! Comm Endpoint Index List
++ */
++u8 tty_comm_indexes[] = { INT_IN, };
++
++/*! @{
++ * Class Descriptors
++ */
++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 Class Descriptor
++ * 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 usbd_generic_class_descriptor *cdc_comm_class_descriptors[] =
++ { (struct usbd_generic_class_descriptor *) cdc_class_1,
++ (struct usbd_generic_class_descriptor *) cdc_class_2,
++ (struct usbd_generic_class_descriptor *) cdc_class_3,
++ (struct usbd_generic_class_descriptor *) cdc_class_4, };
++
++
++
++/* Alternate Descriptors */
++// First two bytes are identical in all: bLength, bDescriptorType (0x09 0x04)
++
++/*! Comm Alternate Descriptor
++ */
++static u8 cdc_comm_alternate_descriptor[sizeof(struct usbd_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, COMM_INTF, 0x00, 0x00, // bInterfaceNumber, bAlternateSetting, bNumEndpoints
++ COMMUNICATIONS_INTERFACE_CLASS, COMMUNICATIONS_ACM_SUBCLASS, 0x01, 0x00, };
++
++/*! Data Alternate Descriptor
++ */
++static u8 cdc_data_alternate_descriptor[sizeof(struct usbd_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, DATA_INTF, 0x00, 0x00, // bInterfaceNumber, bAlternateSetting, bNumEndpoints
++ DATA_INTERFACE_CLASS, COMMUNICATIONS_NO_SUBCLASS, COMMUNICATIONS_NO_PROTOCOL, 0x00, };
++
++
++
++/*! Comm alternate descriptions
++ */
++static struct usbd_alternate_description cdc_comm_alternate_descriptions[] = {
++ { iInterface: CONFIG_OTG_ACM_COMM_INTF,
++ interface_descriptor: (struct usbd_interface_descriptor *)&cdc_comm_alternate_descriptor,
++ classes:sizeof (cdc_comm_class_descriptors) / sizeof (struct usbd_generic_class_descriptor *),
++ class_list: cdc_comm_class_descriptors,
++ endpoint_list: tty_comm_endpoints,
++ endpoints:sizeof (tty_comm_endpoints) / sizeof(struct usbd_endpoint_descriptor *),
++ endpoint_indexes: tty_comm_indexes,
++ }, };
++
++/*! Data alternate descriptions
++ */
++static struct usbd_alternate_description cdc_data_alternate_descriptions[] = {
++ { iInterface: CONFIG_OTG_ACM_DATA_INTF,
++ interface_descriptor: (struct usbd_interface_descriptor *)&cdc_data_alternate_descriptor,
++ endpoint_list: tty_alt_endpoints,
++ endpoints:sizeof (tty_alt_endpoints) / sizeof(struct usbd_endpoint_descriptor *),
++ endpoint_indexes: tty_alt_indexes,
++ }, };
++
++
++/*! Interface Descriptions List */
++static struct usbd_interface_description cdc_interfaces[] = {
++ {
++ alternates:sizeof (cdc_comm_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ alternate_list:cdc_comm_alternate_descriptions,
++ },
++
++ {
++ alternates:sizeof (cdc_data_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ alternate_list:cdc_data_alternate_descriptions,
++ },
++
++};
++
++
++/*! Configuration Descriptor
++ */
++static u8 cdc_configuration_descriptor[sizeof(struct usbd_configuration_descriptor)] = {
++ 0x09, USB_DT_CONFIGURATION, 0x00, 0x00, sizeof (cdc_interfaces) / sizeof (struct usbd_interface_description),
++ 0x01, 0x00, BMATTRIBUTE, BMAXPOWER, };
++
++/*! Configuration Description
++ */
++struct usbd_configuration_description tty_description[] = {
++ { iConfiguration: CONFIG_OTG_ACM_DESC,
++ configuration_descriptor: (struct usbd_configuration_descriptor *)cdc_configuration_descriptor,
++ }, };
++
++/*! Device Descriptor
++ */
++static struct usbd_device_descriptor tty_device_descriptor = {
++ bLength: sizeof(struct usbd_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_OTG_ACM_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_ACM_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_ACM_BCDDEVICE),
++};
++
++#ifdef CONFIG_OTG_HIGH_SPEED
++/*! High Speed Device Qualifier Descriptor
++ */
++static struct usbd_device_qualifier_descriptor tty_device_qualifier_descriptor = {
++ bLength: sizeof(struct usbd_device_qualifier_descriptor),
++ bDescriptorType: USB_DT_DEVICE_QUALIFIER,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: COMMUNICATIONS_DEVICE_CLASS,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++};
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++
++/*! Endpoint Request List
++ */
++static struct usbd_endpoint_request tty_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, },
++ { 0, },
++};
++
++/*! OTG Descriptor
++ */
++static struct usbd_otg_descriptor tty_otg_descriptor = {
++ bLength : sizeof(struct usbd_otg_descriptor),
++ bDescriptorType: USB_DT_OTG,
++ bmAttributes: 0,
++};
++
++/*! Device Description
++ */
++struct usbd_device_description tty_device_description = {
++ device_descriptor: &tty_device_descriptor,
++#ifdef CONFIG_OTG_HIGH_SPEED
++ device_qualifier_descriptor: &tty_device_qualifier_descriptor,
++#endif /* CONFIG_OTG_HIGH_SPEED */
++ otg_descriptor: &tty_otg_descriptor,
++ iManufacturer: CONFIG_OTG_ACM_MANUFACTURER,
++ iProduct: CONFIG_OTG_ACM_PRODUCT_NAME,
++#if !defined(CONFIG_OTG_NO_SERIAL_NUMBER) && defined(CONFIG_OTG_SERIAL_NUMBER_STR)
++ iSerialNumber: CONFIG_OTG_SERIAL_NUMBER_STR,
++#endif
++};
++
++/*! function_driver
++ */
++struct usbd_function_driver tty_function_driver = {
++ name: "ACM-TTY",
++ fops:&function_ops,
++ device_description:&tty_device_description,
++ bNumConfigurations:sizeof (tty_description) / sizeof (struct usbd_configuration_description),
++ configuration_description:tty_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_OTG_ACM_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_ACM_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_ACM_BCDDEVICE),
++ bNumInterfaces:sizeof (cdc_interfaces) / sizeof (struct usbd_interface_description),
++ interface_list:cdc_interfaces,
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: tty_endpoint_requests,
++};
++
++
++
+diff -uNr linux/drivers/no-otg/functions/acm/tty-l24-os.c linux/drivers/otg/functions/acm/tty-l24-os.c
+--- linux/drivers/no-otg/functions/acm/tty-l24-os.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/tty-l24-os.c 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,1291 @@
++/*
++ * otg/functions/acm/tty-l24-os.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++
++/*!
++ * @file otg/functions/acm/tty-l24-os.c
++ * @brief ACM Function Driver private defines
++ *
++ * An ACM (Abstract Control Model) driver is composed of two pieces:
++ *
++ * 1) An OS specific piece that handles creating and operating
++ * a serial device for the given OS.
++ *
++ * 2) A USB specific piece that interfaces either with the host
++ * usbcore layer, or with the otgcore layer.
++ *
++ * If the USB piece interfaces with the host usbcore layer you get an ACM
++ * class driver. If the USB piece interfaces with the otgcore layer you get
++ * an ACM function driver.
++ *
++ * This file is the OS specific piece that interfaces with Linux (kernel
++ * versions 2.4.*). It talks to the bottom edge of the Linux tty layer.
++ *
++ * See the file acm/tty.c for USB descriptor definitions used for this
++ * function.
++ *
++ * @ingroup TTYFunction
++ */
++
++
++//#include <otg/osversion.h>
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++MOD_AUTHOR ("tbr@belcarra.com, sl@belcarra.com");
++
++MOD_DESCRIPTION ("Belcarra TTY Function");
++EMBED_LICENSE();
++
++#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 <linux/serial.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++
++#include <linux/capability.h>
++#include "tty.h"
++#include <otg/otg-trace.h>
++#include "acm.h"
++#include "acm-fd.h"
++#include "acm-os.h"
++
++static struct acm_usb_services *usb_ops = &acm_fd_usb_ops;
++
++#define TTY tty_fd_trace_tag
++otg_tag_t tty_fd_trace_tag;
++
++/* 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;
++
++MOD_PARM (vendor_id, "i");
++MOD_PARM (product_id, "i");
++MOD_PARM (max_queued_urbs, "i");
++MOD_PARM (max_queued_bytes, "i");
++
++MOD_PARM_DESC (vendor_id, "Device Vendor ID");
++MOD_PARM_DESC (product_id, "Device Product ID");
++MOD_PARM_DESC (max_queued_urbs, "Maximum TX Queued Urbs");
++MOD_PARM_DESC (max_queued_bytes, "Maximum TX Queued Bytes");
++
++
++/* ACM ***************************************************************************************** */
++
++#define ACM_TTY_MAJOR 166
++#define ACM_TTY_MINOR 0
++#define ACM_TTY_MINORS 1
++
++extern struct acm_private acmfd_private;
++extern struct tty_private ttyfd_private;
++
++
++/* ******************************************************************************************* */
++
++#define TTY_OVERFLOW_SIZE 512
++
++u8 tty_overflow_buffer[TTY_OVERFLOW_SIZE];
++int tty_overflow_used;
++
++/* ******************************************************************************************* */
++
++/*! ttyfd_schedule
++ *
++ * Schedule a bottom half handler work item.
++ *
++ * @param queue
++ */
++STATIC void ttyfd_schedule(WORK_ITEM *queue)
++{
++ RETURN_IF(NO_WORK_DATA((*queue)) || PENDING_WORK_ITEM((*queue)));
++#if defined(LINUX24)
++ queue_task(queue, &tq_immediate);
++ mark_bh(IMMEDIATE_BH);
++ TRACE_MSG1(TTY,"task %p scheduled and marked",queue);
++#else
++ SCHEDULE_WORK((*queue));
++ TRACE_MSG1(TTY,"task %p scheduled",queue);
++#endif
++}
++
++
++/*! ttyfd_block_until_ready
++ *
++ * Called from tty_open to implement blocking open. Wait for DTR indication
++ * from acm-fd.
++ *
++ * Called by TTY layer to open device.
++ *
++ * @param tty
++ * @param filp
++ * @param acm
++ * @returns non-zero for error
++ */
++STATIC int ttyfd_block_until_ready(struct tty_struct *tty, struct file *filp, struct acm_private *acm)
++{
++ struct tty_private *tty_private = (struct tty_private *) acm->privdata;
++ unsigned long flags;
++ int rc = 0;
++
++ local_irq_save(flags);
++ //TRACE_MSG1(TTY,"open_wait_count: %d --> at entry", tty_private->open_wait_count);
++ //tty_private->open_wait_count += 1;
++ for (;;) {
++ /* check if the file has been closed */
++ if (tty_hung_up_p(filp)) {
++ TRACE_MSG0(TTY,"tty_hung_up_p()");
++ rc = -ERESTARTSYS;
++ break;
++ }
++ /* check for pending signals */
++ if (signal_pending(current)) {
++ TRACE_MSG0(TTY,"signal_pending()");
++ rc = -ERESTARTSYS;
++ break;
++ }
++ /* check if the module is unloading */
++ if (tty_private->exiting) {
++ TRACE_MSG0(TTY,"module exiting()");
++ rc = -ENODEV;
++ break;
++ }
++ /* check for what we want, do we have DTR?
++ */
++ if (acm->bmLineState & CDC_LINESTATE_D0_DTR) {
++ // OK, there's somebody on the other end, let's go...
++ TRACE_MSG0(TTY,"found DTR");
++ rc = 0;
++ break;
++ }
++ //TRACE_MSG1(TTY,"open_wait_count: %d sleeping...", tty_private->open_wait_count);
++
++ /* restore irqs */
++ local_irq_restore(flags);
++
++ /* sleep */
++ interruptible_sleep_on(&tty_private->open_wait);
++
++ /* lock irqs again */
++ local_irq_save(flags);
++
++ //TRACE_MSG1(TTY,"open_wait_count: %d got WAKEUP", tty_private->open_wait_count);
++ }
++ //tty_private->open_wait_count -= 1;
++ //TRACE_MSG1(TTY,"open_wait_count: %d <-- at exit", tty_private->open_wait_count);
++ local_irq_restore(flags);
++ return(rc);
++}
++
++/*! ttyfd_call_hangup
++ *
++ * Bottom half handler to safely send hangup signal to process group.
++ *
++ * @param private - point to acm_private dat structure
++ */
++STATIC void ttyfd_call_hangup(void *private)
++{
++ struct acm_private *acm = (struct acm_private *) private;
++ struct tty_private *tty_private = (struct tty_private *) acm->privdata;
++
++ struct tty_struct *tty = (NULL == acm) ? NULL : tty_private->tty;
++
++ TRACE_MSG5(acm->trace_tag,"used: %d MOD_IN_USE: %d configured: %d c_cflag: %04x clocal: %d",
++ atomic_read(&acm->used), MOD_IN_USE, acm->flags & ACM_CONFIGURED,
++ tty_private->c_cflag, tty_private->c_cflag & CLOCAL);
++
++
++ if (tty && !(tty_private->c_cflag & CLOCAL))
++ tty_hangup(tty);
++
++ wake_up_interruptible(&tty_private->open_wait);
++
++ TRACE_MSG0(TTY,"exited");
++}
++
++/*! ttyfd_schedule_hangup
++ *
++ * Schedule hangup bottom half handler.
++ *
++ * @param acm - point to acm_private dat structure
++ */
++void ttyfd_schedule_hangup(struct acm_private *acm)
++{
++ struct tty_private *tty_private = (struct tty_private *) acm->privdata;
++
++ TRACE_MSG0(TTY, "entered");
++ ttyfd_schedule(&tty_private->hqueue);
++}
++
++
++/*! tty_open
++ *
++ * Called by TTY layer to open device.
++ *
++ * @param tty
++ * @param filp
++ * @returns non-zero for error
++ */
++STATIC int tty_open(struct tty_struct *tty, struct file *filp)
++{
++ struct acm_private *acm = &acmfd_private;
++ struct tty_private *tty_private = (struct tty_private *) acm->privdata;
++ int used;
++ int nonblocking;
++ int rc = 0;
++ unsigned long flags;
++
++ TRACE_MSG3(acm->trace_tag,"used: %d MOD_IN_USE: %d configured: %d",
++ atomic_read(&acm->used), MOD_IN_USE, acm->flags & ACM_CONFIGURED);
++
++ TRACE_MSG2(TTY,"f_flags: %08x NONBLOCK: %x",
++ filp->f_flags, filp->f_flags & O_NONBLOCK);
++
++ 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 0
++ 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 {
++ tty_private->flags |= TTYFD_EXCLUSIVE;
++ set_bit(TTY_EXCLUSIVE, &tty->flags);
++ }
++ }
++#if defined(LINUX24)
++ else if ((tty_private->flags & TTYFD_EXCLUSIVE) && !suser())
++#else
++ if ((tty_private->flags & TTYFD_EXCLUSIVE) && !capable(CAP_SYS_TTY_CONFIG))
++#endif
++ {
++ // Only the superuser can do a normal open of an O_EXCL tty
++ rc = -EBUSY;
++ }
++#endif
++ local_irq_restore(flags);
++
++ // OK, now it's safe to make an early return if we are failing.
++ if (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);
++ }
++ local_irq_save(flags);
++
++
++ /* 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.
++ */
++ UNLESS (used) {
++ MOD_INC_USE_COUNT;
++ TRACE_MSG1(TTY,"INC: %d", MOD_IN_USE);
++ // First open.
++ TRACE_MSG2(TTY, "FIRST OPEN nonblocking: %x exclusive: %x", nonblocking, tty_private->flags & TTYFD_EXCLUSIVE);
++ tty->driver_data = acm;
++ tty_private->tty = tty;
++ tty->low_latency = 1;
++ usb_ops->open(acm, DATA_INTF);
++ usb_ops->set_local(acm, 1);
++ }
++ local_irq_restore(flags);
++
++
++ /* All done if configured
++ */
++ RETURN_ZERO_UNLESS(usb_ops->ready(acm));
++
++ /* All done if non blocking open
++ */
++ RETURN_ZERO_IF(nonblocking);
++
++ /* Block open - wait until ready
++ */
++ TRACE_MSG0(TTY, "BLOCKING - wait until ready");
++ rc = ttyfd_block_until_ready(tty,filp,acm);
++
++ /* The tty layer calls tty_close() even if this open fails,
++ * so any cleanup (rc != 0) will be done there.
++ */
++ TRACE_MSG3(acm->trace_tag,"used: %d MOD_IN_USE: %d configured: %d",
++ atomic_read(&acm->used), MOD_IN_USE, acm->flags & ACM_CONFIGURED);
++ return(rc);
++}
++
++/*! ttyfd_wakeup_opens
++ *
++ * Called by acm_fd to wakeup processes blocked in open waiting for DTR.
++ *
++ * @param acm - pointer to acm private data structure
++ */
++void ttyfd_wakeup_opens(struct acm_private *acm)
++{
++ struct tty_private *tty_private = (struct tty_private *) acm->privdata;
++ TRACE_MSG0(TTY, "entered");
++ //if (tty_private->open_wait_count > 0)
++ wake_up_interruptible(&tty_private->open_wait);
++}
++
++/*! tty_close
++ *
++ * Called by TTY layer to close device.
++ *
++ * @param tty
++ * @param filp
++ * @returns non-zero for error
++ */
++STATIC void tty_close(struct tty_struct *tty, struct file *filp)
++{
++ struct acm_private *acm = tty->driver_data;
++ struct tty_private *tty_private = (struct tty_private *) acm->privdata;
++ struct usbd_function_instance *function;
++ int used;
++
++ TRACE_MSG0(TTY, "entered");
++
++ //UNLESS (acm) {
++ // printk(KERN_INFO"%s: ACM null\n", __FUNCTION__);
++ // return;
++ //}
++
++ usb_ops->close(acm, DATA_INTF);
++ tty_private = (struct tty_private *) acm->privdata;
++ function = acm->function;
++ TRACE_MSG3(acm->trace_tag,"used: %d MOD_IN_USE: %d configured: %d",
++ atomic_read(&acm->used), MOD_IN_USE, acm->flags & ACM_CONFIGURED);
++
++ // lock and decrement used counter, save result
++ used = atomic_pre_dec(&acm->used);
++
++ // finished unless this is the last close
++
++ RETURN_IF (used > 0);
++
++ TRACE_MSG0(TTY,"FINAL CLOSE");
++
++ tty_private->tty = NULL;
++
++ /* This should never happen if this is the last close,
++ * but it can't hurt to check.
++ */
++ //if (tty_private->open_wait_count)
++ wake_up_interruptible(&tty_private->open_wait);
++
++ if (tty_private->flags & TTYFD_EXCLUSIVE) {
++ tty_private->flags &= ~TTYFD_EXCLUSIVE;
++ if (tty)
++ clear_bit(TTYFD_EXCLUSIVE, &tty->flags);
++ }
++
++ _MOD_DEC_USE_COUNT;
++ TRACE_MSG1(TTY,"DEC: %d", MOD_IN_USE);
++ TRACE_MSG1(TTY,"LAST CLOSE r-f=%d",(acm->bytes_received-acm->bytes_forwarded));
++
++ MOD_DEC_USE_COUNT;
++
++ TRACE_MSG0(TTY,"FINISHED");
++}
++
++/* Transmit Function - called by tty layer ****************************************************** */
++
++int ttyfd_recv_space_available(struct acm_private *acm, int interface);
++int ttyfd_recv_chars(struct acm_private *acm, int interface, u8 *cp, int n);
++
++#define LOOP_BUF 16
++/*! ttyfd_loop_xmit_chars
++ *
++ * Implement data loop back, send xmit data back as received data.
++ *
++ * @param acm - pointer to acm private data structure
++ * @param interface - data interface to send on
++ * @param count - number of bytes to send
++ * @param from_user - true if from user memory space
++ * @param buf - pointer to data to send
++ * @return count - number of bytes actually sent.
++ */
++STATIC int ttyfd_loop_xmit_chars(struct acm_private *acm, int interface, int count, int from_user, const unsigned char *buf)
++{
++ int received = 0;
++ while (count > 0) {
++ u8 copybuf[LOOP_BUF];
++ int i;
++ int space = ttyfd_recv_space_available(acm, DATA_INTF);
++ int recv = MIN (space, LOOP_BUF);
++ recv = MIN(recv, count);
++
++ //TRACE_MSG7(TTY, "buf: %8x buf+received: %8x received: %d from_user: %d count: %d space: %d recv: %d\n",
++ // buf, buf + received, received, from_user, count, space, recv);
++
++ BREAK_UNLESS(recv);
++
++ if (from_user)
++ copy_from_user ((void *)copybuf, (void*)(buf + received), recv);
++ else
++ memcpy ((void *)copybuf, (void*)(buf + received), recv);
++
++ count -= recv;
++ received += recv;
++ TRACE_MSG3(TTY, "count: %d recv: %d received: %d", count, recv, received);
++ ttyfd_recv_chars(acm, DATA_INTF, copybuf, recv);
++ }
++ return received;
++}
++
++/*! ttyfd_overflow_send
++ *
++ * Check if there is data in overflow buffer and send if neccessary.
++ *
++ * @param acm - pointer to acm private data structure
++ * @param interface - data interface to send on
++ * @param force - force the send
++ */
++void ttyfd_overflow_send(struct acm_private *acm, int interface, int force)
++{
++ int chars_in_buffer;
++ int count;
++
++ unsigned long flags;
++ local_irq_save(flags);
++
++ chars_in_buffer = usb_ops->chars_in_buffer(acm, DATA_INTF);
++
++ TRACE_MSG3(TTY, "overflow_used: %d chars_in_buffer: %d force: %d", tty_overflow_used, chars_in_buffer, force);
++
++ if (force || !chars_in_buffer || tty_overflow_used > 200) {
++
++ count = usb_ops->xmit_chars(acm, DATA_INTF, tty_overflow_used, 0, tty_overflow_buffer);
++
++ TRACE_MSG2(TTY, "overflow_used: %d count: %d", tty_overflow_used, count);
++
++ tty_overflow_used = 0;
++
++ }
++ local_irq_restore(flags);
++}
++
++
++/*! ttyfd_overflow_xmit_chars
++ *
++ * Implement overflow buffer. The TTY layer implements echo with single
++ * character writes which can quickly exhaust the urbs allowed for sending.
++ * This results in data being lost.
++ *
++ * This function is called to accumulate small amounts of data when there is
++ * already an bulk in urb in the queue.
++ *
++ * The urb sent function calls wakeup writers which will call
++ * ttyfd_overflow_send which will send the data.
++ *
++ * @param acm - pointer to acm private data structure
++ * @param interface - data interface to send on
++ * @param count - number of bytes to send
++ * @param from_user - true if from user memory space
++ * @param buf - pointer to data to send
++ * @return count - number of bytes actually sent.
++ */
++STATIC int ttyfd_overflow_xmit_chars(struct acm_private *acm, int interface, int count, int from_user, const unsigned char *buf)
++{
++ unsigned long flags;
++ int overflow_room;
++ int write_room = usb_ops->write_room(acm, DATA_INTF);
++
++ TRACE_MSG2(TTY,"-> count: %d from_usr: %d", count, from_user);
++ local_irq_save(flags);
++
++ if ((overflow_room = TTY_OVERFLOW_SIZE - tty_overflow_used) > 0) {
++
++ count = MIN(overflow_room, count);
++ if (from_user)
++ copy_from_user ((void *)tty_overflow_buffer + tty_overflow_used, (void*)buf, count);
++ else
++ memcpy ((void *)tty_overflow_buffer + tty_overflow_used, (void*)buf, count);
++
++ tty_overflow_used += count;
++ }
++ else
++ count = 0;
++
++ local_irq_restore(flags);
++
++ /* start sending from overflow if neccessary
++ */
++ ttyfd_overflow_send(acm, interface, 0);
++
++ return count;
++}
++
++/*! tty_chars_in_buffer
++ *
++ * Called by TTY layer to determine amount of pending write data.
++ *
++ * @param tty - pointer to tty data structure
++ * @return amount of pending write data
++ */
++STATIC int tty_chars_in_buffer(struct tty_struct *tty)
++{
++ struct acm_private *acm = tty->driver_data;
++ struct tty_private *tty_private = (struct tty_private *) acm->privdata;
++ int rc;
++
++ //TRACE_MSG0(TTY, "entered");
++
++ rc = usb_ops->chars_in_buffer(acm, DATA_INTF);
++ TRACE_MSG1(TTY, "chars in buffer: %d", rc);
++ return rc;
++ //return(usb_ops->chars_in_buffer(acm, DATA_INTF));
++}
++
++/*! tty_write
++ *
++ * Called by TTY layer to write data.
++ * @param tty - pointer to tty data structure
++ * @param from_user - true if from user memory space
++ * @param buf - pointer to data to send
++ * @param count - number of bytes want to send.
++ * @return count - number of bytes actually sent.
++ */
++STATIC int tty_write(struct tty_struct *tty, int from_user, const unsigned char *buf, int count)
++{
++ struct acm_private *acm = tty->driver_data;
++ struct tty_private *tty_private = (struct tty_private *) acm->privdata;
++
++ TRACE_MSG3(TTY,"-> count: %d loopback: %d from_usr: %d", count, tty_private->tiocm & TIOCM_LOOP, from_user);
++
++ /* loopback mode
++ */
++ if (tty_private->tiocm & TIOCM_LOOP)
++ return ttyfd_loop_xmit_chars(acm, DATA_INTF, count, from_user, buf);
++
++ /* overflow mode
++ */
++ if (tty_overflow_used || (tty_chars_in_buffer(tty_private->tty) && (count < 64)))
++ return ttyfd_overflow_xmit_chars(acm, DATA_INTF, count, from_user, buf);
++
++ /* straight through mode
++ */
++ return usb_ops->xmit_chars(acm, DATA_INTF, count, from_user, buf);
++
++}
++
++/*! tty_write_room
++ *
++ * Called by TTY layer get amount of write room available.
++ *
++ * @param tty - pointer to tty data structure
++ * @return amount of write room available
++ */
++STATIC int tty_write_room(struct tty_struct *tty)
++{
++ struct acm_private *acm = tty->driver_data;
++ struct tty_private *tty_private = (struct tty_private *) acm->privdata;
++ int rc;
++
++ TRACE_MSG0(TTY, "entered");
++ /* loopback mode
++ */
++ if (tty_private->tiocm & TIOCM_LOOP)
++ return ttyfd_recv_space_available(acm, DATA_INTF);
++
++ rc = usb_ops->write_room(acm, DATA_INTF) + (TTY_OVERFLOW_SIZE - tty_overflow_used);
++ TRACE_MSG1(TTY, "write room: %d", rc);
++
++ return rc;
++
++
++ //return(usb_ops->write_room(acm, DATA_INTF));
++}
++
++static int throttle_count = 0;
++static int unthrottle_count = 0;
++
++/*! tty_throttle
++ *
++ * Called by TTY layer to throttle (do not allow received data.)
++ *
++ * @return amount of write room available
++ */
++STATIC void tty_throttle(struct tty_struct *tty)
++{
++ struct acm_private *acm = tty->driver_data;
++ struct tty_private *tty_private = (struct tty_private *) acm->privdata;
++
++ TRACE_MSG0(TTY, "entered");
++ //tty_private->flags |= TTYFD_THROTTLED;
++ usb_ops->throttle(acm, DATA_INTF);
++}
++
++/*! tty_unthrottle
++ *
++ * Called by TTY layer to unthrottle (allow received data.)
++ *
++ * @return amount of write room available
++ */
++STATIC void tty_unthrottle(struct tty_struct *tty)
++{
++ struct acm_private *acm = tty->driver_data;
++ struct tty_private *tty_private = (struct tty_private *) acm->privdata;
++
++ TRACE_MSG0(TTY, "entered");
++ //tty_private->flags &= ~TTYFD_THROTTLED;
++ usb_ops->unthrottle(acm, DATA_INTF);
++
++ /* This function is called while the TTY_DONT_FLIP flag is still
++ * set, so there is no point trying to push the flip buffer. Just
++ * try to queue some recv urbs, and keep trying until we do manage
++ * to get some queued.
++ */
++ tty_schedule_flip(tty);
++}
++
++/* ********************************************************************************************** */
++
++/*! ttyfd_tiocm
++ * @param acm
++ * @param tiocm
++ * @return - computed tiocm value
++ */
++unsigned int ttyfd_tiocm(struct acm_private *acm, unsigned int tiocm)
++{
++ tiocm &= ~ ( TIOCM_DTR | TIOCM_DSR | TIOCM_CAR);
++
++ return tiocm |
++ usb_ops->get_dtr(acm) ? TIOCM_DTR : 0 |
++ usb_ops->get_dsr(acm) ? TIOCM_DSR : 0 |
++ usb_ops->get_dcd(acm) ? TIOCM_CAR : 0 ;
++}
++
++/*! tty_ioctl
++ *
++ * Used by TTY layer to execute IOCTL command.
++ *
++ * Called by TTY layer to open device.
++ *
++ * Unhandled commands must return -ENOIOCTLCMD for correct operation.
++ *
++ * @param tty
++ * @param file
++ * @param cmd
++ * @param arg
++ * @returns non-zero for error
++ */
++STATIC int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
++{
++ struct acm_private *acm = tty->driver_data;
++ struct tty_private *tty_private = (struct tty_private *) acm->privdata;
++ unsigned int mask;
++ unsigned int newctrl;
++ unsigned int tiocm;
++ unsigned int saved_tiocm;
++ unsigned int changed_tiocm;
++ int rc;
++
++ //TRACE_MSG3(TTY,"entered: %8x dir: %x size: %x", cmd, _IOC_DIR(cmd), _IOC_SIZE(cmd));
++
++ switch(cmd) {
++
++ case TIOCMGET:
++ TRACE_MSG1(TTY, "TIOCMGET: tiocm: %08x", tiocm);
++ tty_private->tiocm = ttyfd_tiocm(acm, tiocm);
++ RETURN_EINVAL_IF (copy_to_user((void *)arg, &tty_private->tiocm, sizeof(int)));
++ return 0;
++
++ case TIOCMBIS:
++ case TIOCMBIC:
++ case TIOCMSET:
++ TRACE_MSG0(TTY, "TIOCMXXX: copying tiocm arguement");
++
++ TRACE_MSG1(TTY, "access: %d", access_ok(VERIFY_READ, (void *)arg, sizeof(int)));
++ RETURN_EINVAL_UNLESS(access_ok(VERIFY_READ, (void *)arg, sizeof(int)));
++
++
++ //RETURN_EINVAL_IF (copy_from_user(&tiocm, (void *)arg, sizeof(int)));
++ rc = copy_from_user((void *)&tiocm, (void *)arg, sizeof(int));
++ TRACE_MSG2(TTY, "copy_from_user: %d tiocm: %08x", rc, tiocm);
++
++ TRACE_MSG2(TTY, "tiocm: %08x mask: %08x", tiocm,
++ TIOCM_RTS | TIOCM_DTR | TIOCM_OUT1 | TIOCM_OUT2 | TIOCM_LOOP);
++
++ tiocm &= TIOCM_RTS | TIOCM_DTR | TIOCM_OUT1 | TIOCM_OUT2 | TIOCM_LOOP;
++ saved_tiocm = tty_private->tiocm;
++
++ switch (cmd) {
++ case TIOCMBIS:
++ TRACE_MSG1(TTY, "TIOCMBIS: tiocm: %08x", tiocm);
++ tty_private->tiocm |= tiocm; /* turn on flags set in tiocm */
++ break;
++ case TIOCMBIC:
++ TRACE_MSG1(TTY, "TIOCMBIC: tiocm: %08x", tiocm);
++ tty_private->tiocm &= ~tiocm; /* turn off flags set in tiocm */
++ break;
++ case TIOCMSET:
++ TRACE_MSG1(TTY, "TIOCMSET: tiocm: %08x", tiocm);
++ tty_private->tiocm = tiocm; /* set all flags as in tiocm */
++ break;
++ }
++ /* make changes
++ */
++ changed_tiocm = saved_tiocm ^ tty_private->tiocm;
++ TRACE_MSG4(TTY, "TIOCMSET: tiocm: %08x saved: %08x set: %08x changed: %d",
++ tiocm, saved_tiocm, tty_private->tiocm, changed_tiocm);
++
++ if (changed_tiocm) {
++ /* DTR -> (DSR/DCD) */
++ tiocm = tty_private->tiocm;
++ if (changed_tiocm & TIOCM_DTR) {
++ usb_ops->set_dsr(acm, tiocm & TIOCM_DTR);
++ usb_ops->set_dcd(acm, tiocm & TIOCM_DTR);
++ }
++ /* OUT1 -> Ring */
++ if (changed_tiocm & TIOCM_OUT1)
++ usb_ops->ring(acm);
++ /* OUT2 -> Overrun */
++ if (changed_tiocm & TIOCM_OUT2)
++ usb_ops->overrun(acm);
++ /* LOOPBACK */
++ if (changed_tiocm & TIOCM_OUT2)
++ usb_ops->set_loopback(acm, tiocm & TIOCM_LOOP);
++ }
++
++ return 0;
++
++ case TIOCGSERIAL:
++ TRACE_MSG0(TTY, "TIOCGSERIAL");
++ RETURN_EINVAL_IF (copy_to_user((void *)arg, &tty_private->serial_struct, sizeof(struct serial_struct)));
++ return 0;
++
++ case TIOCSSERIAL:
++ TRACE_MSG0(TTY, "TIOCSSERIAL");
++ RETURN_EFAULT_IF (copy_from_user(&tty_private->serial_struct, (void *)arg, sizeof(struct serial_struct)));
++ return 0;
++
++ case TIOCSERCONFIG:
++ case TIOCSERGETLSR: /* Get line status register */
++ case TIOCSERGSTRUCT:
++ TRACE_MSG0(TTY, "TIOCSER*");
++ return -EINVAL;
++
++ /*
++ * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
++ * - mask passed in arg for lines of interest
++ * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
++ * Caller should use TIOCGICOUNT to see which one it was
++ */
++ case TIOCMIWAIT:
++ TRACE_MSG0(TTY, "TIOCGMIWAIT");
++ while (1) {
++
++ saved_tiocm = tty_private->tiocm;
++
++ interruptible_sleep_on(&tty_private->tiocm_wait);
++
++ /* see if a signal did it */
++ if (signal_pending(current))
++ return -ERESTARTSYS;
++
++ tty_private->tiocm = ttyfd_tiocm(acm, tiocm);
++ changed_tiocm = saved_tiocm ^ tty_private->tiocm;
++ RETURN_ZERO_IF ( (changed_tiocm | TIOCM_CAR) | (changed_tiocm | TIOCM_DSR) );
++ /* loop */
++ }
++ /* NOTREACHED */
++
++ /*
++ * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
++ * Return: write counters to the user passed counter struct
++ * NB: both 1->0 and 0->1 transitions are counted except for
++ * RI where only 0->1 is counted.
++ */
++ case TIOCGICOUNT:
++ TRACE_MSG0(TTY, "TIOCGICOUNT");
++ if (copy_to_user((void *)arg, &tty_private->tiocgicount, sizeof(int)))
++ return -EFAULT;
++ return 0;
++
++ case TCSETS:
++ TRACE_MSG1(TTY, "TCSETS: tiocm: %08x", tiocm);
++ return -ENOIOCTLCMD;
++ case TCFLSH:
++ TRACE_MSG1(TTY, "TCFLSH: tiocm: %08x", tiocm);
++ return -ENOIOCTLCMD;
++
++ case TCGETS:
++ TRACE_MSG1(TTY, "TCGETS: tiocm: %08x", tiocm);
++ return -ENOIOCTLCMD;
++
++ default:
++ TRACE_MSG1(TTY, "unknown cmd: %08x", cmd);
++ return -ENOIOCTLCMD;
++ }
++ return -ENOIOCTLCMD;
++}
++
++/*! ttyfd_wakeup_state
++ *
++ * Called by acm_fd to wakeup processes blocked waiting for state change
++ *
++ * @param acm - pointer to acm private data structure
++ */
++void ttyfd_wakeup_state(struct acm_private *acm)
++{
++ struct tty_private *tty_private = (struct tty_private *) acm->privdata;
++ TRACE_MSG0(TTY, "entered");
++ wake_up_interruptible(&tty_private->tiocm_wait);
++}
++
++
++/*! tty_set_termios
++ *
++ * Used by TTY layer to set termios structure according to current status.
++ *
++ * @param tty - pointer to acm private data structure
++ * @param termios_old - termios structure
++ */
++STATIC void tty_set_termios(struct tty_struct *tty, struct termios *termios_old)
++{
++ struct acm_private *acm = tty->driver_data;
++ struct tty_private *tty_private = (struct tty_private *) acm->privdata;
++
++ unsigned int c_cflag = tty->termios->c_cflag;
++
++ /* see if CLOCAL has changed */
++ if ((termios_old->c_cflag ^ tty->termios->c_cflag ) & CLOCAL)
++ usb_ops->set_local(acm, tty->termios->c_cflag & CLOCAL);
++
++ /* save cflags
++ */
++ tty_private->c_cflag = c_cflag;
++
++ /* send break?
++ */
++ if ((termios_old->c_cflag & CBAUD) && !(c_cflag & CBAUD))
++ usb_ops->send_break(acm);
++}
++
++/* ********************************************************************************************* */
++/*! ttyfd_wakeup_writers
++ *
++ * Bottom half handler to wakeup pending writers.
++ *
++ * @param data - pointer to acm private data structure
++ */
++STATIC void ttyfd_wakeup_writers(void *data)
++{
++ struct acm_private *acm = (struct acm_private *) data;
++ struct tty_private *tty_private = (struct tty_private *) acm->privdata;
++ struct tty_struct *tty = tty_private->tty;
++ unsigned long flags;
++
++ TRACE_MSG2(TTY,"used: %d MOD_IN_USE: %d", atomic_read(&acm->used), MOD_IN_USE);
++
++ RETURN_UNLESS(usb_ops->ready(acm));
++ RETURN_UNLESS(atomic_read(&acm->used));
++ RETURN_UNLESS(tty);
++
++ /* start sending from overflow buffer if necessary
++ */
++ ttyfd_overflow_send(acm, DATA_INTF, 0);
++
++ if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && tty->ldisc.write_wakeup)
++ (tty->ldisc.write_wakeup)(tty);
++
++ wake_up_interruptible(&tty->write_wait);
++}
++
++/*! ttyfd_schedule_wakeup_writers
++ *
++ * Called by acm-fd to schedule a wakeup writes bottom half handler.
++ *
++ * @param acm - pointer to acm private data structure
++ */
++void ttyfd_schedule_wakeup_writers(struct acm_private *acm)
++{
++ struct tty_private *tty_private = (struct tty_private *) acm->privdata;
++
++ TRACE_MSG2(TTY,"used: %d MOD_IN_USE: %d", atomic_read(&acm->used), MOD_IN_USE);
++ ttyfd_schedule(&tty_private->wqueue);
++}
++
++/* ********************************************************************************************* */
++
++/*! ttyfd_recv_space_available
++ *
++ * Used by acm-fd to determine receive space available. This will determine
++ * how many receive urbs can be queued as there are never more receive urbs
++ * pending than there is currently room for data to be received.
++ *
++ * @param acm - pointer to acm private data structure
++ * @param interface - data interface to send on
++ * @return count - number of bytes available
++ */
++int ttyfd_recv_space_available(struct acm_private *acm, int interface)
++{
++ struct tty_private *tty_private;
++ struct tty_struct *tty;
++ int rc;
++
++ TRACE_MSG0(TTY, "entered");
++ RETURN_ZERO_UNLESS(acm);
++
++ tty_private = (struct tty_private *) acm->privdata;
++
++ RETURN_ZERO_UNLESS(tty_private);
++
++ RETURN_ZERO_UNLESS(tty_private->tty);
++
++ switch (interface) {
++ case COMM_INTF:
++ return 0;
++ case DATA_INTF:
++ tty = tty_private->tty;
++ rc = TTY_FLIPBUF_SIZE - tty->flip.count;
++ TRACE_MSG1(TTY, "recv space available: %d", rc);
++ return rc;
++ return(TTY_FLIPBUF_SIZE - tty->flip.count);
++ }
++ return 0;
++}
++
++/*! ttyfd_recv_chars
++ *
++ * Called by acm-fd when data has been received. This will
++ * receive n bytes starting at cp. This will never be
++ * more than the last call to ttyfd_recv_space_available().
++ * This will be called from interrupt context.
++ *
++ * @param acm - pointer to acm private data structure
++ * @param interface - data interface to send on
++ * @param n - number of bytes to send
++ * @param cp - pointer to data to send
++ * @return non-zero if error
++ */
++int ttyfd_recv_chars(struct acm_private *acm, int interface, u8 *cp, int n)
++{
++ struct tty_private *tty_private = (struct tty_private *) acm->privdata;
++ struct tty_struct *tty = tty_private->tty;
++ unsigned long flags;
++
++ /* acm_start_recv_urbs() will never queue more urbs than there is currently
++ * room in the upper layer buffer for. So we are guaranteed that any data actually
++ * received can be given to the upper layers without worrying if we will
++ * actually have room.
++ *
++ * XXX I think that if the tty layer does get behind and we reach a point where
++ * there are no outstanding receive urbs, then we will also have been throttled
++ * so we will have an oppourtunity to queue more receive urbs when we get unthrottled.
++ *
++ * XXX If the above assumption is not true that a timer will be needed to periodically
++ * check if we can restart.
++ *
++ * YYY What can happen is that the tty_flip_buffer_push() call can fail for
++ * a variety of reasons (locked out while a read call is in progress, ldisc
++ * buffer is full, and probably others). We need to ensure that we keep
++ * trying to push the flip buffer until it does go, and there is room for
++ * more receive urbs. acm_start_recv_urbs() will queue a task to push and
++ * try again if it can't queue any now.
++ *
++ * ZZZ Yet another failure mode is to call tty_flip_buffer_push() too many
++ * times while throttled. This will result in the ldisc layer silently
++ * dropping data inside the n_tty_receive_buf() routine. (Acutal numbers
++ * for the 2.4.20 kernel this was discovered on are 128 bytes left in the
++ * ldisc buffer when throttle is called, and upto 7 64 byte urbs outstanding.
++ * The urbs will fit into the flip buffer, but NOT the ldisc buffer.) This
++ * means we must not call tty_flip_buffer_push() when throttled. We will
++ * count on the tty_unthrottle() call to kick off the final push.
++ */
++
++ {
++ int i;
++ local_irq_save(flags);
++ TRACE_MSG2(TTY, "recv: %d buffer: %x", n, cp);
++
++ for (i = 0; i < n; i += 8) {
++ TRACE_MSG8(TTY, "%02x %02x %02x %02x %02x %02x %02x %02x",
++ cp[i + 0], cp[i + 1], cp[i + 2], cp[i + 3],
++ cp[i + 4], cp[i + 5], cp[i + 6], cp[i + 7]
++ );
++ }
++
++ local_irq_restore(flags);
++ }
++ switch (interface) {
++ case COMM_INTF:
++ return 0;
++ case DATA_INTF:
++
++ RETURN_EINVAL_UNLESS(tty);
++
++#define WORD_COPY 1
++#if defined(WORD_COPY)
++ local_irq_save(flags);
++ memcpy(tty->flip.char_buf_ptr,cp,n);
++ memset(tty->flip.flag_buf_ptr,TTY_NORMAL,n);
++ tty->flip.count += n;
++ tty->flip.char_buf_ptr += n;
++ tty->flip.flag_buf_ptr += n;
++ acm->bytes_forwarded += n;
++ local_irq_restore(flags);
++#else
++ int i;
++ for (i = 0; i < n; i++) {
++ /* tty_flip_char() has no lock out from any calls
++ * to tty_flip_buffer_push() that may have been queued
++ * by acm_unthrottle() or acm_start_recv_urbs(), so...
++ */
++ local_irq_save(flags);
++ tty_insert_flip_char(tty, *cp++, TTY_NORMAL);
++ local_irq_restore(flags);
++ }
++ acm->bytes_forwarded += n;
++#endif
++
++ UNLESS (test_bit(TTY_THROTTLED, &tty->flags))
++ tty_flip_buffer_push(tty);
++
++ //UNLESS (tty_private->flags & TTYFD_THROTTLED)
++ // tty_flip_buffer_push(tty);
++
++ return 0;
++ }
++ return 0;
++}
++
++/* ********************************************************************************************* */
++
++/*! ttyfd_enable
++ *
++ * Called by acm-fd when the function driver is enabled.
++ */
++void ttyfd_enable(struct usbd_function_instance *function)
++{
++ //function->privdata = &acm_private;
++ //acm_private.function = function;
++}
++
++/*! ttyfd_enable
++ *
++ * Called by acm-fd when the function driver is disabled.
++ */
++void ttyfd_disable(struct usbd_function_instance *function)
++{
++ //function->privdata = NULL;
++ //acm_private.function = NULL;
++}
++
++/* ************************************************************************** */
++
++#if defined(LINUX24)
++static int tty_refcount;
++#else
++//Maintained inside tty_driver in LINUX 2.6
++#endif
++static struct tty_struct *tty_table[ACM_TTY_MINORS];
++static struct termios *tty_termios[ACM_TTY_MINORS];
++static struct termios *tty_termios_locked[ACM_TTY_MINORS];
++
++/*! tty_driver
++ */
++static struct tty_driver 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 = tty_open,
++ .close = tty_close,
++ .write = tty_write,
++ .write_room = tty_write_room,
++ .ioctl = acm_tty_ioctl,
++ .throttle = tty_throttle,
++ .unthrottle = tty_unthrottle,
++ .chars_in_buffer = tty_chars_in_buffer,
++ .set_termios = tty_set_termios,
++
++#if defined(LINUX24)
++ .refcount = &tty_refcount,
++#else
++ .refcount = 0,
++#endif
++ .table = tty_table,
++ .termios = tty_termios,
++ .termios_locked = tty_termios_locked,
++};
++
++/* USB Module init/exit ************************************************************************ */
++
++struct tty_private ttyfd_private = {
++ .tty_driver = &tty_driver,
++ //.wqueue.routine = ttyfd_wakeup_writers,
++ //.wqueue.data = &acmfd_private,
++ .wqueue = {
++ .routine = ttyfd_wakeup_writers,
++ .data = &acmfd_private,
++ },
++ //.hqueue.routine = ttyfd_call_hangup,
++ //.hqueue.data = &acmfd_private,
++ .hqueue = {
++ .routine = ttyfd_call_hangup,
++ .data = &acmfd_private,
++ },
++};
++
++
++/*! tty_function_services
++ *
++ * This structure contains the list of services
++ */
++struct acm_function_services tty_function_services = {
++ .schedule_wakeup_writers = ttyfd_schedule_wakeup_writers,
++ .recv_space_available = ttyfd_recv_space_available,
++ .recv_chars = ttyfd_recv_chars,
++ .enable = ttyfd_enable,
++ .disable = ttyfd_disable,
++ .schedule_hangup = ttyfd_schedule_hangup,
++ .wakeup_opens = ttyfd_wakeup_opens,
++ .wakeup_state = ttyfd_wakeup_state,
++};
++
++struct acm_private acmfd_private = {
++ .function_driver = &tty_function_driver,
++ .function_services = &tty_function_services,
++ .privdata = &ttyfd_private,
++ // TBR: 20040705 use ...le32() not le16, spotted by Zhao Liang
++ //.line_coding.dwDTERate = __constant_cpu_to_le32(0x1c200), // 115200
++ //.line_coding.bDataBits = 0x08,
++ .line_coding = {
++ .dwDTERate = __constant_cpu_to_le32(0x1c200), // 115200
++ .bDataBits = 0x08,
++ },
++};
++
++
++/*! ttyfd_modinit - module init
++ *
++ * This is called immediately after the module is loaded or during
++ * the kernel driver initialization if linked into the kernel.
++ *
++ */
++STATIC int ttyfd_modinit (void)
++{
++ int i;
++
++ /* initialize private structures */
++ acmfd_private.trace_tag = TTY = otg_trace_obtain_tag();
++ init_waitqueue_head(&ttyfd_private.open_wait);
++ init_waitqueue_head(&ttyfd_private.tiocm_wait);
++
++ /* update init_termios and register as tty driver */
++ tty_driver.init_termios = tty_std_termios;
++ tty_driver.init_termios.c_cflag = B115200 | CS8 | CREAD | HUPCL | CLOCAL;
++ tty_driver.init_termios.c_lflag &= ~(ECHO | ICANON);
++ THROW_IF(tty_register_driver(&tty_driver), error);
++ tty_register_devfs(&tty_driver, 0, ACM_TTY_MINOR);
++ ttyfd_private.tty_driver_registered++;
++
++ /* register as usb function driver via acm-fd */
++ THROW_IF (usb_ops->fd_init(&acmfd_private, "acm_fd", vendor_id, product_id, max_queued_urbs,max_queued_bytes ), error);
++
++ CATCH(error) {
++ printk(KERN_ERR"%s: ERROR\n", __FUNCTION__);
++ if (ttyfd_private.tty_driver_registered) {
++ tty_unregister_driver(&tty_driver);
++ ttyfd_private.tty_driver_registered = 0;
++ }
++ return -EINVAL;
++ }
++ return 0;
++}
++
++
++/*! ttyfd_modexit - module cleanup
++ *
++ * This is called prior to the module being unloaded.
++ */
++STATIC void ttyfd_modexit (void)
++{
++ struct acm_private *acm = &acmfd_private;
++ struct tty_private *tty_private = (struct tty_private *) acm->privdata;
++ unsigned long flags;
++ struct usbd_urb *urb;
++
++ /* Wake up any pending opens after setting the exiting flag. */
++ local_irq_save(flags);
++ ttyfd_private.exiting = 1;
++ //if (ttyfd_private.open_wait_count > 0)
++ wake_up_interruptible(&ttyfd_private.open_wait);
++ local_irq_restore(flags);
++
++ /* verify no tasks are running */
++ usb_ops->wait_task(acm, &acm->recv_tqueue);
++ usb_ops->wait_task(acm, &ttyfd_private.wqueue);
++ usb_ops->wait_task(acm, &ttyfd_private.hqueue);
++
++#if defined(LINUX24)
++ run_task_queue(&tq_timer);
++#else
++ blk_run_queues();
++#endif
++ /* de-register as tty and usb drivers */
++ if (ttyfd_private.tty_driver_registered)
++ tty_unregister_driver(&tty_driver);
++
++ /* de-register as function driver via acm-fd */
++ usb_ops->fd_exit(&acmfd_private);
++ otg_trace_invalidate_tag(TTY);
++}
++
++module_init (ttyfd_modinit);
++module_exit (ttyfd_modexit);
++
+diff -uNr linux/drivers/no-otg/functions/acm/tty-os.h linux/drivers/otg/functions/acm/tty-os.h
+--- linux/drivers/no-otg/functions/acm/tty-os.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/tty-os.h 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,74 @@
++/*
++ * otg/functions/acm/tty-os.h
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ *
++ */
++/*!
++ * @file otg/functions/acm/tty-os.h
++ * @brief ACM Function Driver private defines
++ *
++ * An ACM (Abstract Control Model) driver is composed of two pieces:
++ * 1) An OS specific piece that handles creating and operating
++ * a serial device for the given OS.
++ * 2) A USB specific piece that interfaces either with the host
++ * usbcore layer, or with the otgcore layer.
++ *
++ * If the USB piece interfaces with the host usbcore layer you get
++ * an ACM class driver. If the USB piece interfaces with the otgcore
++ * layer you get an ACM function driver.
++ *
++ * This file describes the functions exported by the various acm-*-os.c
++ * files (implementing (1)) for use in acm-fd.c (2).
++ *
++ * @ingroup TTYFunction
++ */
++
++#ifndef ACM_OS_H
++#define ACM_OS_H 1
++
++/*
++ * acm_os_recv_space_available - return the number of bytes of data
++ * the OS specific piece can accept without
++ * dropping some.
++ */
++extern int acm_os_recv_space_available(struct acm_private *acm);
++
++/*
++ * acm_os_recv_chars - receive n bytes starting at cp. This will never be
++ * more than the last call to acm_os_recv_space_available().
++ * This will be called from interrupt context.
++ */
++extern int acm_os_recv_chars(struct acm_private *acm, u8 *cp, int n);
++
++/*
++ * acm_os_wakeup_writers - wakeup any blocked writers. This is called
++ * from interrupt context, so may need to queue
++ * the actual wakeup in a "bottom half".
++ */
++extern void acm_os_wakeup_writers(struct acm_private *acm);
++
++/*
++ * acm_os_hangup - send a hangup to any readers or writers. This can be
++ * called from interrupt context, so may need to queue
++ * the actual hangup in a "bottom half".
++ */
++extern void acm_os_hangup(struct acm_private *acm);
++
++/*
++ * acm_os_wakeup_opens - wakeup any blocked opens. This is called
++ * from interrupt context, so may need to queue
++ * the actual wakeup in a "bottom half".
++ */
++extern void acm_os_wakeup_opens(struct acm_private *acm);
++
++extern void acm_os_enable(struct usbd_function_instance *function);
++extern void acm_os_disable(struct usbd_function_instance *function);
++
++#endif
+diff -uNr linux/drivers/no-otg/functions/acm/tty.h linux/drivers/otg/functions/acm/tty.h
+--- linux/drivers/no-otg/functions/acm/tty.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/acm/tty.h 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,117 @@
++/*
++ * otg/functions/acm/tty.h
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @defgroup TTYFunction ACM-TTY
++ * @ingroup functiongroup
++ */
++/*!
++ * @file otg/functions/acm/tty.h
++ * @brief ACM Function Driver private defines
++ *
++ *
++ * This is an ACM Function Driver. The upper edge is exposed
++ * to the hosting OS as a Posix type character device. The lower
++ * edge implements the USB Device Stack API.
++ *
++ * These are emulated and set by the tty driver as appropriate
++ * to model a virutal serial port. The
++ *
++ * TIOCM_RNG RNG (Ring) not used
++ * TIOCM_LE DSR (Data Set Ready / Line Enable)
++ * TIOCM_DSR DSR (Data Set Ready)
++ * TIOCM_CAR DCD (Data Carrier Detect)
++ * TIOCM_CTS CTS (Clear to Send)
++ * TIOCM_CD TIOCM_CAR
++ * TIOCM_RI TIOCM_RNG
++ *
++ * These are set by the application:
++ *
++ * TIOCM_DTR DTR (Data Terminal Ready)
++ * TIOCM_RTS RTS (Request to Send)
++ *
++ * TIOCM_LOOP Set into loopback mode
++ * TIOCM_OUT1 Not used.
++ * TIOCM_OUT2 Not used.
++ *
++ *
++ * The following File and termio c_cflags are used:
++ *
++ * O_NONBLOCK don't block in tty_open()
++ * O_EXCL don't allow more than one open
++ *
++ * CLOCAL ignore DTR status
++ * CBAUD send break if set to B0
++ *
++ * Virtual NULL Modem
++ *
++ * Peripheral to Host via Serial State Notification (write ioctls)
++ *
++ * Application TIOCM Null Modem ACM (DCE) Notificaiton Host (DTE)
++ * -------------------------------------------------------------------------------------------------------------
++ * Request to send TIOCM_RTS RTS -> CTS CTS Not Available Clear to Send (N/A)
++ * Data Terminal Ready TIOCM_DTR DTR -> DSR DSR bTxCarrier Data Set Ready
++ * DTR -> DCD DCD bRXCarrier Carrier Detect
++ * Ring Indicator TIOCM_OUT1 OUT1 -> RI RI bRingSignal Ring Indicator
++ * Overrun TIOCM_OUT2 OUT2 -> Overrun Overrun bOverrun Overrun
++ * Send Break B0 B0 -> Break Break bBreak Break Received
++ * -------------------------------------------------------------------------------------------------------------
++ *
++ *
++ * Host to Peripheral via Set Control Line State
++ *
++ * Host (DTE) Line State ACM (DCE) Null Modem TIOCM Peripheral (DTE)
++ * -------------------------------------------------------------------------------------------------------------
++ * Data Terminal Ready D0 DTR DTR -> DSR TIOCM_DSR Data Set Ready
++ * DTR -> DCD TIOCM_CAR Carrier Detect
++ * Request To Send D1 RTS RTS -> CTS TIOCM_CTS Clear to Send
++ * -------------------------------------------------------------------------------------------------------------
++ *
++ *
++ * @ingroup TTYFunction
++ */
++
++extern struct usbd_function_driver tty_function_driver;
++
++//#define TTY_OPENED (1 << 0) /*! OPENED flag */
++#define TTYFD_CLOCAL (1 << 1) /*! CLOCAL flag */
++//#define TTYFD_LOOPBACK (1 << 2) /*! LOOPBACK flag */
++#define TTYFD_EXCLUSIVE (1 << 3) /*! EXCLUSIVE flag */
++#define TTYFD_THROTTLED (1 << 4) /*! THROTTLED flag */
++
++/*! @struct tty_private
++ */
++struct tty_private {
++
++ struct tty_driver *tty_driver; /*!< tty structure */
++ 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 */
++
++ u32 flags; /*!< flags */
++
++ u32 tiocm; /*!< tiocm settings */
++
++ struct serial_struct serial_struct; /*!< serial structure used for TIOCSSERIAL and TIOCGSERIAL */
++
++ wait_queue_head_t tiocm_wait;
++ u32 tiocgicount;
++
++ u32 c_cflag;
++
++ wait_queue_head_t open_wait; /*! wait queue for blocking open*/
++ int exiting; /*! True if module exiting */
++};
++
++
+diff -uNr linux/drivers/no-otg/functions/isotest/Config.in linux/drivers/otg/functions/isotest/Config.in
+--- linux/drivers/no-otg/functions/isotest/Config.in 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/isotest/Config.in 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,28 @@
++#
++# Loop Function
++#
++# Copyright (C) 2003-2004 Belcarra
++# Enhanced Jan 2004 to provide greater runtime selection
++# of xmit buffer patterns from the device to the host
++#
++
++mainmenu_option next_comment
++comment "ISO Test Function"
++
++dep_tristate ' Loop Function Driver' CONFIG_OTG_ISOTEST $CONFIG_OTG
++
++if [ "$CONFIG_OTG_ISOTEST" = "y" -o "$CONFIG_OTG_ISOTEST" = "m" ]; then
++
++ hex ' idVendor (hex value)' CONFIG_OTG_ISOTEST_VENDORID "15ec"
++ hex ' idProduct (hex value)' CONFIG_OTG_ISOTEST_PRODUCTID "f004"
++ hex ' bcdDevice (binary-coded decimal)' CONFIG_OTG_ISOTEST_BCDDEVICE "0100"
++ string ' iManufacturer (string)' CONFIG_OTG_ISOTEST_MANUFACTURER ""
++ string ' iProduct (string)' CONFIG_OTG_ISOTEST_PRODUCT_NAME ""
++
++ string ' iConfiguration (string)' CONFIG_OTG_ISOTEST_DESC "ISO Test Cfg"
++ string ' Data Interface iInterface (string)' CONFIG_OTG_ISOTEST_DATA_INTF "ISO Data Intf"
++ #bool ' Runtime pattern buffer selection ' CONFIG_OTG_ISOTEST_XMIT_PATTERN "y"
++
++fi
++
++endmenu
+diff -uNr linux/drivers/no-otg/functions/isotest/Makefile linux/drivers/otg/functions/isotest/Makefile
+--- linux/drivers/no-otg/functions/isotest/Makefile 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/isotest/Makefile 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,73 @@
++#
++# Function driver ISO Test Device
++#
++# Copyright (c) 2003 Belcarra
++
++# Multipart objects.
++
++O_TARGET := isotest_fd_drv.o
++list-multi := isotest_fd.o isotest.o
++
++isotest_fd-objs := iso.o test.o fermat.o
++isotest-objs := host.o test.o
++
++# Objects that export symbols.
++export-objs := iso.o
++
++# Object file lists.
++
++obj-y :=
++obj-m :=
++obj-n :=
++obj- :=
++
++# Each configuration option enables a list of files.
++
++obj-$(CONFIG_OTG_ISOTEST) += isotest_fd.o isotest.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.
++
++OTG=$(TOPDIR)/drivers/otg
++ISOD=$(OTG)/functions/isotest
++USBDCORE_DIR=$(OTG)/usbdcore
++include $(TOPDIR)/Rules.make
++EXTRA_CFLAGS += -I$(ISOD) -I$(OTG) -Wno-unused -Wno-format
++EXTRA_CFLAGS_nostdinc += -I$(ISOD) -I$(OTG) -Wno-unused -Wno-format
++
++# Link rules for multi-part drivers.
++
++isotest_fd.o: $(isotest_fd-objs)
++ $(LD) -r -o $@ $(isotest_fd-objs)
++
++isotest.o: $(isotest-objs)
++ $(LD) -r -o $@ $(isotest-objs)
++
++# dependencies:
++
++isotest.o: $(USBDCORE_DIR)/usbd.h $(USBDCORE_DIR)/usbd-bus.h $(USBDCORE_DIR)/usbd-func.h test.h
++host.o: host.c test.h
++
++test.o:test.h
++
+diff -uNr linux/drivers/no-otg/functions/isotest/fermat.c linux/drivers/otg/functions/isotest/fermat.c
+--- linux/drivers/no-otg/functions/isotest/fermat.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/isotest/fermat.c 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,132 @@
++/*
++ * otg/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_OTG_ISOTEST_MODULE
++
++#include "fermat.h"
++
++#ifndef ISO_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_OTG_ISOTEST */
++
+diff -uNr linux/drivers/no-otg/functions/isotest/fermat.h linux/drivers/otg/functions/isotest/fermat.h
+--- linux/drivers/no-otg/functions/isotest/fermat.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/isotest/fermat.h 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,38 @@
++/*
++ * otg/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 ISO_FERMAT_DEFINED
++#define ISO_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 -uNr linux/drivers/no-otg/functions/isotest/host.c linux/drivers/otg/functions/isotest/host.c
+--- linux/drivers/no-otg/functions/isotest/host.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/isotest/host.c 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,840 @@
++/*
++ * otg/isotest_fd/host.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * USB ISO Test
++ *
++ *
++ * Copyright (c) 2003, 2004 sl@belcarra.com
++ *
++ */
++
++//#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/version.h>
++
++#include <linux/kernel.h>
++//#include <linux/sched.h>
++#include <linux/signal.h>
++#include <linux/errno.h>
++//#include <linux/poll.h>
++#include <linux/init.h>
++#include <linux/slab.h>
++#include <linux/fcntl.h>
++#include <linux/module.h>
++#include <linux/spinlock.h>
++#include <linux/list.h>
++#include <linux/smp_lock.h>
++#include <linux/usb.h>
++#include <linux/interrupt.h>
++#include <linux/pci.h>
++#include <linux/delay.h>
++#include <linux/proc_fs.h>
++
++#include <linux/vmalloc.h>
++
++#include <asm/atomic.h>
++#include <asm/io.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)
++#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
++
++#include "test.h"
++
++
++/* Use our own dbg macro */
++#undef dbg
++#define dbg(format, arg...) do { if (debug) printk(KERN_DEBUG __FILE__ ": " format "\n" , ## arg); } while (0)
++
++#define MIN(a,b) (((a) < (b))?(a):(b))
++#define MAX(a,b) (((a) > (b))?(a):(b))
++
++#define THROW(x) goto x
++#define CATCH(x) while(0) 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(y) if (y) { return; }
++#define RETURN_ZERO_IF(y) if (y) { return 0; }
++#define RETURN_NULL_IF(y) if (y) { return NULL; }
++
++
++/* Version Information */
++#define DRIVER_VERSION "v0.9"
++#define DRIVER_AUTHOR "sl@belcarra.com"
++#define DRIVER_DESC "USB ISO Test"
++
++/* Define these values to match your device */
++
++#ifdef CONFIG_OTG_ISOTEST_VENDORID
++ #undef USB_ISOTEST_VENDOR_ID
++ #define USB_ISOTEST_VENDOR_ID CONFIG_OTG_ISOTEST_VENDORID
++#else
++ #define USB_ISOTEST_VENDOR_ID 0xfff0
++#endif
++
++#ifdef CONFIG_OTG_ISOTEST_PRODUCTID
++ #undef USB_ISOTEST_PRODUCT_ID
++ #define USB_ISOTEST_PRODUCT_ID CONFIG_OTG_ISOTEST_PRODUCTID
++#else
++ #define USB_ISOTEST_PRODUCT_ID 0xfff1
++#endif
++
++/* Module paramaters */
++//MODULE_PARM(debug, "i");
++//MODULE_PARM_DESC(debug, "Debug enabled or not");
++
++static int send;
++MODULE_PARM(send, "i");
++MODULE_PARM_DESC(send, "send test");
++
++static int recv;
++MODULE_PARM(recv, "i");
++MODULE_PARM_DESC(recv, "recv test");
++
++static u32 vendor_id; // no default
++static u32 product_id; // no default
++
++
++MODULE_PARM_DESC(vendor_id, "User specified USB idVendor");
++MODULE_PARM_DESC(product_id, "User specified USB idProduct");
++MODULE_PARM(vendor_id, "i");
++MODULE_PARM(product_id, "i");
++
++
++/* table of devices that work with this driver */
++static struct usb_device_id isotest_table [] = {
++ { USB_DEVICE(USB_ISOTEST_VENDOR_ID, USB_ISOTEST_PRODUCT_ID) },
++ { }, /* extra entry */
++ { }, /* Terminating entry */
++};
++
++MODULE_DEVICE_TABLE (usb, isotest_table);
++
++/* ********************************************************************************************* */
++
++
++/* ********************************************************************************************* */
++/*
++struct iso_test_data {
++
++ // sender info
++ u32 sender_id;
++ time_t send_time;
++ u32 send_crc;
++
++ // loop info
++ u32 recv_id;
++ time_t recv_time;
++ u32 recv_crc;
++
++ // payload
++ u32 size;
++ u8 data[0];
++};
++*/
++
++#define IN_URBS 10
++#define OUT_URBS 10
++
++
++
++
++/* Structure to hold all of our device specific stuff */
++struct usb_isotest {
++ struct usb_device * udev; /* save off the usb device pointer */
++ struct usb_interface * interface; /* the interface for this device */
++
++ u8 closing;
++ u8 num_interrupt_in; /* number of interrupt in endpoints we have */
++ u8 num_iso_in; /* number of iso in endpoints we have */
++ u8 num_iso_out; /* number of iso out endpoints we have */
++
++ int iso_in_size; /* the size of the receive buffer */
++ struct urb * iso_in_urbs[IN_URBS]; /* the urb used to send data */
++ u8 iso_in_endpointAddr; /* the address of the iso in endpoint */
++ int in_urbs;
++
++ int iso_out_size; /* the size of the send buffer */
++ struct urb * iso_out_urbs[OUT_URBS]; /* the urb used to send data */
++ u8 iso_out_endpointAddr; /* the address of the iso out endpoint */
++ int out_urbs;
++
++ struct semaphore sem; /* locks this structure */
++ struct tq_struct iso_bh;
++ wait_queue_head_t iso_wq;
++
++ struct isotest_stats stats;
++
++ int first;
++};
++
++
++/* local function prototypes */
++
++static void * isotest_probe (struct usb_device *, unsigned int , const struct usb_device_id *);
++static void isotest_disconnect (struct usb_device *, void *);
++
++
++void isotest_schedule_bh(struct usb_isotest *isotest);
++
++
++/* ISO OUT - Transmit ************************************************************************** */
++
++
++#if 1
++static void isotest_iso_out_free_urb(struct urb *urb)
++{
++ struct usb_isotest *isotest;
++ int i;
++ unsigned long flags;
++
++ //printk(KERN_INFO"%s: urb: %p\n", __FUNCTION__, urb);
++
++ RETURN_IF(!urb);
++
++ if (urb->transfer_buffer) {
++ kfree(urb->transfer_buffer);
++ }
++
++ isotest = (struct usb_isotest *)urb->context;
++ usb_free_urb(urb);
++
++ RETURN_IF(!isotest);
++
++ local_irq_save (flags);
++ for (i = 0; i < OUT_URBS; i++) {
++ CONTINUE_IF(isotest->iso_out_urbs[i] != urb);
++ //printk(KERN_INFO"%s: zeroing %d urb: %p\n", __FUNCTION__, i, urb);
++ isotest->iso_out_urbs[i] = NULL;
++ break;
++ }
++ local_irq_restore (flags);
++}
++#endif
++
++static int iso_transfer_count;
++
++int iso_out_submit(struct usb_isotest *isotest, struct urb *urb)
++{
++ int i;
++ int j;
++ int rc = 0;
++
++ //printk(KERN_INFO"%s: transfer: %d size: %d frames: %x\n", __FUNCTION__,
++ // iso_transfer_count, urb->transfer_buffer_length, urb->number_of_packets);
++
++ RETURN_ZERO_IF(isotest->closing);
++
++ urb->dev = isotest->udev;
++
++ iso_transfer_count++;
++
++ for (j = urb->transfer_buffer_length, i = 0; i < urb->number_of_packets; i++) {
++
++ int send = MIN(isotest->iso_out_size, j);
++
++ u8 *cp = urb->transfer_buffer + (isotest->iso_out_size * i);
++
++ j -= send;
++
++ urb->iso_frame_desc[i].offset = i * isotest->iso_out_size;
++ urb->iso_frame_desc[i].length = send;
++
++ // iso_transfer_count
++ *cp++ = cpu_to_le16(iso_transfer_count) & 0xff;
++ *cp++ = (cpu_to_le16(iso_transfer_count) >> 8) & 0xff;
++ *cp++ = (cpu_to_le16(iso_transfer_count) >> 16) & 0xff;
++ *cp++ = (cpu_to_le16(iso_transfer_count) >> 24) & 0xff;
++
++ // iso transfer length
++ *cp++ = cpu_to_le16(urb->transfer_buffer_length) & 0xff;
++ *cp++ = (cpu_to_le16(urb->transfer_buffer_length) >> 8) & 0xff;
++
++ // iso frame size
++ *cp++ = cpu_to_le16(isotest->iso_out_size) & 0xff;
++ *cp++ = (cpu_to_le16(isotest->iso_out_size) >> 8) & 0xff;
++
++ // total frames
++ *cp++ = cpu_to_le16(urb->number_of_packets) & 0xff;
++ *cp++ = (cpu_to_le16(urb->number_of_packets) >> 8) & 0xff;
++
++ // this packet number
++ *cp++ = cpu_to_le16(i+1) & 0xff;
++ *cp++ = (cpu_to_le16(i+1) >> 8) & 0xff;
++
++ }
++
++ //printk(KERN_INFO"%s: submitting\n", __FUNCTION__);
++
++ RETURN_ZERO_IF(!(rc = usb_submit_urb(urb)));
++ printk(KERN_INFO"%s: FAILED rc: %x\n", __FUNCTION__, rc);
++
++ return rc;
++}
++
++void isotest_iso_out_complete (struct urb *urb)
++{
++ struct usb_isotest *isotest = (struct usb_isotest *)urb->context;
++ int rc;
++
++ //printk(KERN_INFO"%s: urb: %p\n", __FUNCTION__, urb);
++
++ RETURN_IF(!urb);
++
++ if (urb->status /* && (urb->status != -ENOENT) && (urb->status != -ECONNRESET)*/) {
++ //printk(KERN_INFO"%s: - nonzero write iso status received: %d\n", __FUNCTION__, urb->status);
++ }
++
++ iso_out_submit(isotest, urb);
++}
++
++
++#define ISO_SEND_TOTAL 1000
++#define ISO_SEND_TRANSFERS 1200
++
++static int out_count;
++
++struct urb *iso_out_start(struct usb_isotest *isotest)
++{
++ struct urb * urb = NULL;
++ int rc = 0;
++ int i;
++ int j;
++
++
++ int size = ((ISO_SEND_TOTAL % isotest->iso_out_size) < 20) ? ISO_SEND_TOTAL + 20 : ISO_SEND_TOTAL;
++ int frames = (size / isotest->iso_out_size) + 1;
++
++ //RETURN_NULL_IF(out_count-- <= 0);
++
++ //printk(KERN_INFO"%s: %d %02x\n", __FUNCTION__, out_count, isotest->iso_out_endpointAddr);
++
++
++ //printk(KERN_INFO"%s: frames: %x packet: %d size: %d\n", __FUNCTION__, frames, isotest->iso_out_size, size);
++
++ // allocate urb and buffer, fill buffer with some data
++ THROW_IF(!(urb = usb_alloc_urb(frames + 1)), error);
++
++ THROW_IF (!(urb->transfer_buffer = kmalloc(size, GFP_ATOMIC)), error);
++
++ for (i = 0; i < size; i++) {
++ unsigned char *cp = urb->transfer_buffer + i;
++ *cp = i % 256;
++ }
++
++ //printk(KERN_INFO"%s: CCC\n", __FUNCTION__);
++
++ urb->hcpriv = NULL;
++ urb->context = isotest;
++ urb->transfer_flags = USB_ISO_ASAP;
++ urb->complete = isotest_iso_out_complete;
++ urb->pipe = usb_sndisocpipe(isotest->udev, isotest->iso_out_endpointAddr);
++
++ urb->transfer_buffer_length = size;
++
++ urb->number_of_packets = frames;
++
++ THROW_IF((rc = iso_out_submit(isotest, urb)), error);
++
++ //printk(KERN_INFO"%s: OK frames: %d\n", __FUNCTION__, frames);
++
++ CATCH(error) {
++ printk(KERN_INFO"%s: FAILED rc: %d\n", __FUNCTION__, rc);
++ //isotest_iso_out_free_urb(urb);
++ return NULL;
++ }
++ return urb;
++}
++
++/* ISO IN - Receive **************************************************************************** */
++
++static int in_count = 5;
++static int in_submitted;
++static int in_resubmitted;
++static long in_completed;
++static long in_total_received;
++
++#if 0
++static void isotest_iso_in_free_urb(struct urb *urb)
++{
++ struct usb_isotest *isotest;
++ int i;
++ unsigned long flags;
++
++ //printk(KERN_INFO"%s: urb: %p\n", __FUNCTION__, urb);
++
++ RETURN_IF(!urb);
++
++ if (urb->transfer_buffer) {
++ kfree(urb->transfer_buffer);
++ }
++
++ isotest = (struct usb_isotest *)urb->context;
++ usb_free_urb(urb);
++
++ RETURN_IF(!isotest);
++
++ local_irq_save (flags);
++ for (i = 0; i < IN_URBS; i++) {
++ CONTINUE_IF(isotest->iso_in_urbs[i] != urb);
++ //printk(KERN_INFO"%s: clearing %d urb: %p\n", __FUNCTION__, i, urb);
++ isotest->iso_in_urbs[i] = NULL;
++ break;
++ }
++ local_irq_restore (flags);
++}
++#endif
++
++struct urb *iso_in_start(struct usb_isotest *isotest);
++
++int iso_in_submit(struct usb_isotest *isotest, struct urb *urb)
++{
++ int i;
++ int j;
++ int rc = 0;
++
++ //printk(KERN_INFO"%s: %p\n", __FUNCTION__, urb->complete);
++
++ RETURN_ZERO_IF(isotest->closing);
++
++ urb->dev = isotest->udev;
++ urb->actual_length = 0;
++
++ for (j = urb->transfer_buffer_length, i = 0; i < urb->number_of_packets; i++) {
++
++ int send = MIN(isotest->iso_in_size, j);
++ j -= send;
++ urb->iso_frame_desc[i].offset = i * isotest->iso_in_size;
++ urb->iso_frame_desc[i].length = send;
++ }
++
++ RETURN_ZERO_IF(!(rc = usb_submit_urb(urb)));
++ printk(KERN_INFO"%s: FAILED rc: %x\n", __FUNCTION__, rc);
++
++ //isotest_iso_in_free_urb(urb);
++ return rc;
++}
++
++
++/**
++ * isotest_iso_in_complete
++ */
++void isotest_iso_in_complete (struct urb *urb)
++{
++ struct usb_isotest *isotest = (struct usb_isotest *)urb->context;
++ int i;
++ int rc;
++ int status;
++
++ //printk(KERN_INFO"%s: urb: %p\n", __FUNCTION__, urb);
++
++ RETURN_IF(!urb);
++
++ if (isotest->closing) {
++ //printk(KERN_INFO"%s: urb: %p pre urbs: %d\n", __FUNCTION__, urb, isotest->in_urbs);
++ if (urb->transfer_buffer) {
++ kfree(urb->transfer_buffer);
++ }
++ usb_free_urb(urb);
++ isotest->in_urbs--;
++ //printk(KERN_INFO"%s: urb: %p pre urbs: %d\n", __FUNCTION__, urb, isotest->in_urbs);
++ return;
++ }
++ status = urb->status;
++
++ if (status /* && (status != -ENOENT) && (status != -ECONNRESET)*/) {
++ //printk(KERN_INFO"%s: - urb: %p nonzero write iso status received: %x\n", __FUNCTION__, urb, status);
++ }
++
++ else if (urb->actual_length) {
++ //printk(KERN_INFO"%s: urb: %p lenght: %d\n", __FUNCTION__, urb, urb->actual_length);
++ in_completed++;
++ in_total_received += urb->actual_length;
++
++ //printk(KERN_INFO"%s: ", __FUNCTION__);
++ for (i = 0; i < urb->number_of_packets; i++) {
++
++ iso_trace_recv_data(&isotest->stats,
++ urb->transfer_buffer + urb->iso_frame_desc[i].offset,
++ urb->iso_frame_desc[i].actual_length, 0);
++
++ // printk("%d:%d:%x ", i,
++ // urb->iso_frame_desc[i].actual_length,
++ // urb->iso_frame_desc[i].status);
++
++
++ }
++ //printk("\n");
++ }
++
++ THROW_IF((rc = iso_in_submit(isotest, urb)), error);
++
++ in_resubmitted++;
++
++ CATCH(error) {
++ printk(KERN_INFO"%s: FAILED rc: %x\n", __FUNCTION__, rc);
++ }
++}
++
++
++struct urb *iso_in_start(struct usb_isotest *isotest)
++{
++ struct urb * urb = NULL;
++ int frames = (ISO_SEND_TOTAL + isotest->iso_in_size) / isotest->iso_in_size;
++ int iso_transfer_size;
++ int rc = 0;
++
++
++ //RETURN_NULL_IF(in_count-- <= 0);
++
++ //printk(KERN_INFO"%s: %d %02x\n", __FUNCTION__, in_count, isotest->iso_in_endpointAddr);
++
++ //iso_transfer_size = ((ISO_SEND_TOTAL % isotest->iso_in_size) > 20) ?
++ // ISO_SEND_TOTAL :
++ // ISO_SEND_TOTAL + (20 - (ISO_SEND_TOTAL % isotest->iso_in_size));
++
++ iso_transfer_size = frames * isotest->iso_in_size;
++
++ THROW_IF(!(urb = usb_alloc_urb(frames + 1)), error);
++ THROW_IF (!(urb->transfer_buffer = kmalloc(iso_transfer_size, GFP_ATOMIC)), error);
++ memset(urb->transfer_buffer, 0, isotest->iso_in_size);
++
++ urb->hcpriv = NULL;
++ urb->context = isotest;
++ urb->transfer_flags = USB_ISO_ASAP;
++ urb->complete = isotest_iso_in_complete;
++ urb->pipe = usb_rcvisocpipe(isotest->udev, isotest->iso_in_endpointAddr);
++
++ urb->transfer_buffer_length = iso_transfer_size;
++ urb->number_of_packets = frames;
++
++ THROW_IF((rc = iso_in_submit(isotest, urb)), error);
++ in_submitted++;
++ isotest->in_urbs++;
++ //printk(KERN_INFO"%s: new urbs: %d\n", __FUNCTION__, isotest->in_urbs);
++ return urb;
++
++ CATCH(error) {
++ printk(KERN_INFO"%s: FAILED rc: %x\n", __FUNCTION__, rc);
++ //isotest_iso_in_free_urb(urb);
++ return NULL;
++ }
++}
++
++
++
++
++/* ********************************************************************************************* */
++
++void isotest_schedule_bh(struct usb_isotest *isotest)
++{
++ unsigned long flags;
++
++ //RETURN_IF(!isotest->iso_bh.data);
++
++ // schedule more data
++ local_irq_save (flags);
++ if (isotest->iso_bh.data && !isotest->iso_bh.sync) {
++ MOD_INC_USE_COUNT;
++ queue_task(&isotest->iso_bh, &tq_immediate);
++ mark_bh(IMMEDIATE_BH);
++ }
++ local_irq_restore (flags);
++}
++
++
++static void bottomhalf(void *data)
++{
++ int i;
++ unsigned long flags;
++ struct usb_isotest *isotest = (struct usb_isotest *) data;
++
++ if (isotest->first) {
++ //sleep_on_timeout(&isotest->iso_wq, 200);
++ udelay(100);
++ isotest->first = 0;
++ }
++
++ THROW_IF(!isotest, error);
++
++ if (isotest->closing) {
++ struct urb *urb;
++ //printk(KERN_INFO"%s: closing\n", __FUNCTION__);
++
++ // unlink outstanding urbs, this has side-effect of calling completion routing
++ local_irq_save (flags);
++ for (i = 0; i < IN_URBS; i++) {
++ CONTINUE_IF(!(urb = isotest->iso_in_urbs[i]));
++ //printk(KERN_INFO"%s: unlinking: %d IN urb: %p\n", __FUNCTION__, i, urb);
++ isotest->iso_in_urbs[i] = NULL;
++ urb->transfer_flags |= USB_ASYNC_UNLINK;
++ usb_unlink_urb(urb);
++ }
++ local_irq_restore (flags);
++
++ local_irq_save (flags);
++ for (i = 0; i < OUT_URBS; i++) {
++ CONTINUE_IF(!(urb = isotest->iso_out_urbs[i]));
++ //printk(KERN_INFO"%s: unlinking: %d OUT urb: %p\n", __FUNCTION__, i, urb);
++ isotest->iso_out_urbs[i] = NULL;
++ urb->transfer_flags |= USB_ASYNC_UNLINK;
++ usb_unlink_urb(urb);
++ }
++ local_irq_restore (flags);
++
++ // tell disconnect that we are finished
++ isotest->iso_bh.data = NULL;
++
++ }
++ else {
++
++ //printk(KERN_INFO"%s: normal\n", __FUNCTION__);
++
++ if (send && out_count) {
++ local_irq_save (flags);
++ for (i = 0; i < OUT_URBS; i++) {
++ CONTINUE_IF(isotest->iso_out_urbs[i]);
++ isotest->iso_out_urbs[i] = iso_out_start(isotest);
++ //printk(KERN_INFO"%s: starting: %d OUT urb: %p\n", __FUNCTION__, i, isotest->iso_out_urbs[i]);
++ }
++ local_irq_restore (flags);
++ }
++
++ if (recv && in_count) {
++ local_irq_save (flags);
++ for (i = 0; i < IN_URBS; i++) {
++ CONTINUE_IF(isotest->iso_in_urbs[i]);
++ isotest->iso_in_urbs[i] = iso_in_start(isotest);
++ //printk(KERN_INFO"%s: starting: %d IN urb: %p\n", __FUNCTION__, i, isotest->iso_in_urbs[i]);
++ }
++ local_irq_restore (flags);
++ }
++ }
++
++ CATCH(error) {
++ printk(KERN_ERR"%s: isotest NULL\n", __FUNCTION__);
++ }
++ MOD_DEC_USE_COUNT;
++}
++
++/* ********************************************************************************************* */
++
++/* usb specific object needed to register this driver with the usb subsystem */
++static struct usb_driver isotest_driver = {
++ name: "isotest",
++ probe: isotest_probe,
++ disconnect: isotest_disconnect,
++ id_table: isotest_table,
++};
++
++/**
++ * isotest_probe
++ *
++ * Called by the usb core when a new device is connected that it thinks
++ * this driver might be interested in.
++ */
++static void * isotest_probe(struct usb_device *udev, unsigned int ifnum, const struct usb_device_id *id)
++{
++ struct usb_isotest *isotest = NULL;
++ struct usb_interface *interface;
++ struct usb_device_descriptor *device = &udev->descriptor;
++ struct usb_interface_descriptor *interface_descriptor;
++ int i;
++
++ printk(KERN_INFO"%s: %04x %04x\n", __FUNCTION__, device->idVendor, device->idProduct);
++
++ // See if the device offered us matches what we can accept
++ //if ((device->idVendor != vendor_id) || (device->idProduct != product_id)) {
++ // printk(KERN_INFO"%s: FAILED\n", __FUNCTION__);
++ // return NULL;
++ //}
++
++ // allocate memory for our device state and intialize it
++ if (!(isotest = kmalloc (sizeof(struct usb_isotest), GFP_KERNEL))) {
++ printk(KERN_INFO"%s: Out of memory\n", __FUNCTION__);
++ return NULL;
++ }
++
++ memset (isotest, 0x00, sizeof (*isotest));
++ init_MUTEX (&isotest->sem);
++ init_waitqueue_head(&isotest->iso_wq);
++
++ isotest->udev = udev;
++ isotest->first = 1;
++ isotest->closing = 0;
++ isotest->in_urbs = 0;
++ isotest->interface = interface = &udev->actconfig->interface[ifnum];
++ isotest->iso_bh.routine = bottomhalf;
++ isotest->iso_bh.data = (void *)isotest;
++ interface_descriptor = &interface->altsetting[0];
++
++ // set up the endpoint information and check out the endpoints
++
++ for (i = 0; i < interface_descriptor->bNumEndpoints; ++i) {
++
++ struct usb_endpoint_descriptor *endpoint = &interface_descriptor->endpoint[i];
++
++ //printk(KERN_INFO"%s: looking at %02x\n", __FUNCTION__, endpoint->bEndpointAddress);
++
++ if ((endpoint->bEndpointAddress & 0x80) && ((endpoint->bmAttributes & 3) == 0x01)) {
++
++ //printk(KERN_INFO"%s: found ISO IN %02x\n", __FUNCTION__, endpoint->bEndpointAddress);
++ isotest->iso_in_size = endpoint->wMaxPacketSize;
++ isotest->iso_in_endpointAddr = endpoint->bEndpointAddress;
++ }
++
++ if (((endpoint->bEndpointAddress & 0x80) == 0x00) && ((endpoint->bmAttributes & 3) == 0x01)) {
++
++ //printk(KERN_INFO"%s: found ISO OUT %02x\n", __FUNCTION__, endpoint->bEndpointAddress);
++
++ isotest->iso_out_size = endpoint->wMaxPacketSize;
++ isotest->iso_out_endpointAddr = endpoint->bEndpointAddress;
++ }
++ }
++
++ out_count = ISO_SEND_TRANSFERS;
++
++ // let the user know what node this device is now attached to
++ //printk(KERN_INFO"%s: USB TEST device now attached to ISOTEST\n", __FUNCTION__);
++
++ isotest_schedule_bh(isotest);
++
++ return isotest;
++}
++
++/**
++ * isotest_disconnect
++ *
++ * Called by the usb core when the device is removed from the system.
++ */
++static void isotest_disconnect(struct usb_device *udev, void *ptr)
++{
++ struct usb_isotest *isotest;
++
++ printk(KERN_INFO"%s: in_submitted: %d in_resubmitted: %d in_completed: %ld in_total: %ld\n",
++ __FUNCTION__, in_submitted, in_resubmitted, in_completed, in_total_received);
++
++ RETURN_IF(!(isotest = (struct usb_isotest *)ptr));
++
++ // set flag to say we are closing
++ isotest->closing = 1;
++ isotest_schedule_bh(isotest);
++
++ while (isotest->iso_bh.data) {
++ isotest_schedule_bh(isotest);
++ printk(KERN_INFO"%s: waiting for bh\n", __FUNCTION__);
++ sleep_on_timeout(&isotest->iso_wq, 20);
++ }
++
++ while (isotest->in_urbs) {
++ printk(KERN_INFO"%s: waiting for urbs\n", __FUNCTION__);
++ sleep_on_timeout(&isotest->iso_wq, 20);
++ }
++
++ kfree(isotest);
++
++ printk(KERN_INFO"%s: USB ISOTEST now disconnected\n", __FUNCTION__);
++}
++
++
++/* ********************************************************************************************* */
++
++void iso_start_in(int count)
++{
++
++}
++
++void iso_start_out(int count)
++{
++
++}
++
++
++/**
++ * isotest_init
++ */
++static int isotest_init(void)
++{
++ int result;
++
++ printk(KERN_INFO"%s:\n", __FUNCTION__);
++
++ if (vendor_id && product_id) {
++ int i;
++ for (i = 0; i < (sizeof(isotest_table) / sizeof(struct usb_device_id) - 1); i++) {
++
++ if ((isotest_table[i].idVendor == vendor_id) && isotest_table[i].idProduct == product_id ) {
++ printk(KERN_INFO"%s: vendor_id: %04x product_id: %04x already in table\n",
++ __FUNCTION__, vendor_id, product_id);
++ break;
++ }
++ printk(KERN_INFO"%s: vendor_id: %04x product_id: %04x\n",
++ __FUNCTION__, isotest_table[i].idVendor, isotest_table[i].idProduct);
++ }
++ if (!isotest_table[i].idVendor && !isotest_table[i].idProduct) {
++ printk(KERN_INFO"%s: inserting vendor_id: %04x product_id: %04x into table\n",
++ __FUNCTION__, vendor_id, product_id);
++
++ isotest_table[i].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
++ isotest_table[i].idVendor = vendor_id;
++ isotest_table[i].idProduct = product_id;
++ isotest_table[i].bDeviceClass = 0;
++ isotest_table[i].bDeviceSubClass = 0;
++ }
++ }
++
++ iso_trace_init("isotest_host");
++
++ /* register this driver with the USB subsystem */
++ result = usb_register(&isotest_driver);
++ if (result < 0) {
++ printk(KERN_INFO"%s: usb_register failed for the "__FILE__" driver. Error number %d\n", KERN_INFO, result);
++ return -1;
++ }
++
++ printk(KERN_INFO "%s: " DRIVER_DESC " " DRIVER_VERSION "\n", __FUNCTION__);
++ return 0;
++}
++
++
++/**
++ * isotest_exit
++ */
++static void isotest_exit(void)
++{
++ /* deregister this driver with the USB subsystem */
++ usb_deregister(&isotest_driver);
++
++ iso_trace_exit("isotest_host");
++}
++
++
++module_init (isotest_init);
++module_exit (isotest_exit);
++
++MODULE_AUTHOR(DRIVER_AUTHOR);
++MODULE_DESCRIPTION(DRIVER_DESC);
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,17)
++MODULE_LICENSE("PRIVATE");
++#endif
++
+diff -uNr linux/drivers/no-otg/functions/isotest/iso.c linux/drivers/otg/functions/isotest/iso.c
+--- linux/drivers/no-otg/functions/isotest/iso.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/isotest/iso.c 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,620 @@
++/*
++ * otg/isotest_fd/iso.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ *
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++
++MODULE_AUTHOR ("sl@belcarra.com, tbr@belcarra.com");
++MODULE_DESCRIPTION ("USB Device Serial Function");
++
++#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,17)
++MODULE_LICENSE("GPL");
++#endif
++
++#include <linux/init.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 "usbp-chap9.h"
++#include <usbp-mem.h>
++#include <usbp-func.h>
++#include <usbp-admin.h>
++
++USBD_MODULE_INFO ("isotest_fd 2.0-beta");
++
++#include "test.h"
++#include "fermat.h"
++
++struct usb_isotest {
++ int interface;
++ struct usbd_function_instance *function;
++ rwlock_t rwlock;
++
++ int open;
++ int closing;
++ struct tq_struct iso_bh;
++ wait_queue_head_t iso_wq;
++};
++
++#define ISO_OUT 0x00
++#define ISO_IN 0x01
++
++#define ENDPOINTS 0x02
++
++
++u8 isotest_requested_endpoints[ENDPOINTS+1] = {
++ USB_DIR_OUT | USB_ENDPOINT_ISOCHRONOUS,
++ USB_DIR_IN | USB_ENDPOINT_ISOCHRONOUS,
++ 0,
++};
++
++#define ISO_OUT_PKTSIZE 90
++#define ISO_IN_PKTSIZE 90
++#define isotest_requested_transferSizes xfer_sizes
++
++u16 xfer_sizes[ENDPOINTS+1] = {
++ ISO_OUT_PKTSIZE,
++ ISO_IN_PKTSIZE,
++ 0,
++};
++
++
++
++/* Module Parameters ************************************************************************* */
++// 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");
++
++MODULE_PARM (xfer_sizes, "3-3h");
++MODULE_PARM_DESC (xfer_sizes, "Requested transfer sizes for each endpoint; default 90 for iso in and out");
++
++// packet sizes
++static u32 in = ISO_IN_PKTSIZE;
++MODULE_PARM (in, "i");
++MODULE_PARM_DESC (in, "in size");
++
++static u32 out = ISO_OUT_PKTSIZE;
++MODULE_PARM (out, "i");
++MODULE_PARM_DESC (out, "out size");
++
++static int fermat=0;
++MODULE_PARM (fermat, "i");
++MODULE_PARM_DESC (fermat, "Apply randomization to buffer");
++
++static int custom=0;
++MODULE_PARM (custom, "i");
++MODULE_PARM_DESC (custom, "Supply custom pattern via xmit_pattern parameter");
++
++static int print_all=0;
++MODULE_PARM (print_all, "i");
++MODULE_PARM_DESC (print_all, "Print all buffers, not just the first");
++
++#define ZERO4 0,0,0,0
++#define ZERO16 ZERO4,ZERO4,ZERO4,ZERO4
++#define ZERO64 ZERO16,ZERO16,ZERO16,ZERO16
++static u8 xmit_pattern[256]={1,0xE,1,2,3,4,5,6,7,8,9,0xa,0xb,0xc,0xd,0xe, ZERO16,ZERO16,ZERO16,ZERO64,ZERO64,ZERO64};
++MODULE_PARM(xmit_pattern,"1-256b");
++MODULE_PARM_DESC(xmit_pattern, "pattern to be transmitted, count, size, payload; size is "
++ "the size of the payload following. count is the number of times to repeat the pattern (0=infinite)");
++static struct {
++ int count;
++ int size;
++ u8 *payload_start, *payload_end;
++ u8 *current;
++ int total_size;
++ int sent;
++} xps; // Transmit pattern state
++
++static void xmit_pattern_state_init(void);
++static u8 xmit_pattern_next(void);
++static void fill_xmit_buffer(u32 size, u8*buffer);
++
++static void xmit_pattern_state_init(){
++ xps.count = xmit_pattern[0];
++ xps.size = xmit_pattern[1];
++ xps.payload_start = xmit_pattern+2;
++ xps.payload_end = xps.payload_start + xps.size;
++ xps.current = xps.payload_start;
++ xps.sent = 0;
++ xps.total_size = xps.count * xps.size;
++}
++
++static u8 xmit_pattern_next(){
++
++ // current always points at the next character to send
++ u8 next_value = *xps.current++;
++
++ xps.sent += 1;
++
++ if (xps.current >= xps.payload_end)
++ xps.current = xps.payload_start; //Rewind buffer
++
++ // if Total pattern has been sent; rewind
++ if (xps.sent >= xps.total_size){
++ xmit_pattern_state_init();
++ }
++
++ return next_value;
++}
++
++static void fill_xmit_buffer(u32 size, u8 *buffer)
++{
++ u8 * limit = buffer + size;
++ xmit_pattern_state_init();
++ while(buffer < limit){
++ *buffer++ = xmit_pattern_next();
++ }
++}
++
++static void fill_xmit_buffer_default(u32 size, u8 * buffer){
++ int j;
++ for(j = 0; j < size; j++){
++ buffer[j] = j & 0xff;
++ }
++}
++
++static void print_buffer(u32 size, u8 * buffer){
++ // Print up to 16 bytes of the buffer, first time called only
++ static int first = 1;
++ int n = ( size >=16 ? 16 : size);
++ int j;
++ if((first) || (print_all)){
++ char *prefix = first? "\n" : "";
++ printk(KERN_INFO "%sxmit buffer:", prefix);
++ for( j=0 ; j < n; j++){
++ printk("%02x",buffer[j]);
++ }
++ printk("\n");
++ first = 0;
++ }
++}
++
++
++
++/* ************************************************************************** */
++
++static struct isotest_stats isotest_stats;
++static struct usb_isotest isotest;
++
++
++/* Classes descriptors
++ */
++
++static u8 isotest_ep_1[7] = { 0x07, USB_DT_ENDPOINT, 0, ISOCHRONOUS, ISO_OUT_PKTSIZE&0xff, (ISO_OUT_PKTSIZE>>8)&0xff, 0x00};
++static u8 isotest_ep_2[7] = { 0x07, USB_DT_ENDPOINT, 0, ISOCHRONOUS, ISO_IN_PKTSIZE&0xff, (ISO_IN_PKTSIZE>>8)&0xff, 0x00};
++
++static struct usbd_endpoint_descriptor *isotest_data_endpoints[] = {
++ (struct usbd_endpoint_descriptor *) &isotest_ep_1,
++ (struct usbd_endpoint_descriptor *) &isotest_ep_2 };
++
++u8 isotest_data_indexes [] = { ISO_OUT, ISO_IN, };
++
++
++/* Alternate descriptors
++ */
++static u8 isotest_data_alternate_descriptor[sizeof(struct usbd_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE, 0x00, 0x00, 0x01, // bInterfaceNumber, bAlternateSetting, bNumEndpoints
++ 0x00, 0x00, 0x00, 0x00,
++};
++
++
++/* Alternate descriptions
++ */
++static struct usbd_alternate_description isotest_data_alternate_descriptions[] = {
++ { iInterface:CONFIG_OTG_ISOTEST_DATA_INTF,
++ interface_descriptor: (struct usbd_interface_descriptor *)&isotest_data_alternate_descriptor,
++ endpoints:sizeof (isotest_data_endpoints) / sizeof(u8 *),
++ endpoint_list: isotest_data_endpoints,
++ endpoint_indexes: isotest_data_indexes,
++ },
++};
++
++
++/* Interface descriptions
++ */
++static struct usbd_interface_description isotest_interfaces[] = {
++ { alternates:sizeof (isotest_data_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++alternate_list:isotest_data_alternate_descriptions,
++ },
++};
++
++
++/* Configuration descriptions
++ */
++static u8 isotest_configuration_descriptor[sizeof(struct usbd_configuration_descriptor)] = {
++ 0x09, USB_DT_CONFIGURATION, 0x00, 0x00, // wLength
++ sizeof (isotest_interfaces) / sizeof (struct usbd_interface_description),
++ 0x01, 0x00, // bConfigurationValue, iConfiguration
++ 0, 0,
++};
++
++
++struct usbd_configuration_description isotest_description[] = {
++ { iConfiguration:CONFIG_OTG_ISOTEST_DESC,
++ configuration_descriptor: (struct usbd_configuration_descriptor *)isotest_configuration_descriptor,
++ },
++};
++
++/* Device Description
++ */
++static struct usbd_device_descriptor isotest_device_descriptor = {
++ bLength: sizeof(struct usbd_device_descriptor),
++ bDescriptorType: USB_DT_DEVICE,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: COMMUNICATIONS_DEVICE_CLASS,
++ bDeviceSubClass: 0x00,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++ idVendor: __constant_cpu_to_le16(CONFIG_OTG_ISOTEST_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_ISOTEST_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_ISOTEST_BCDDEVICE),
++};
++
++#ifdef CONFIG_OTG_HIGH_SPEED
++static struct usbd_device_qualifier_descriptor isotest_device_qualifier_descriptor = {
++ bLength: sizeof(struct usbd_device_qualifier_descriptor),
++ bDescriptorType: USB_DT_DEVICE_QUALIFIER,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: COMMUNICATIONS_DEVICE_CLASS,
++ bDeviceSubClass: 0x00,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++};
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++static struct usbd_endpoint_request iso_endpoint_requests[ENDPOINTS+1] = {
++ { 1, 0, 0, USB_DIR_OUT | USB_ENDPOINT_ISOCHRONOUS, ISO_OUT_PKTSIZE, ISO_OUT_PKTSIZE * 4, },
++ { 1, 0, 0, USB_DIR_IN | USB_ENDPOINT_ISOCHRONOUS, ISO_IN_PKTSIZE, ISO_OUT_PKTSIZE * 4, },
++ { 1, },
++};
++
++static struct usbd_otg_descriptor iso_otg_descriptor = {
++bLength : sizeof(struct usbd_otg_descriptor),
++bDescriptorType: USB_DT_OTG,
++bmAttributes: 0,
++};
++
++struct usbd_device_description isotest_device_description = {
++ device_descriptor: &isotest_device_descriptor,
++ #ifdef CONFIG_OTG_HIGH_SPEED
++ device_qualifier_descriptor: &isotest_device_qualifier_descriptor,
++ #endif /* CONFIG_OTG_HIGH_SPEED */
++ otg_descriptor: &iso_otg_descriptor,
++ iManufacturer: CONFIG_OTG_ISOTEST_MANUFACTURER,
++ iProduct: CONFIG_OTG_ISOTEST_PRODUCT_NAME,
++ #if !defined(CONFIG_OTG_NO_SERIAL_NUMBER) && defined(CONFIG_OTG_SERIAL_NUMBER_STR)
++ iSerialNumber: CONFIG_OTG_SERIAL_NUMBER_STR,
++ #endif
++};
++
++void iso_start_in(int count);
++void iso_start_out(int count);
++
++void schedule_bh(void)
++{
++ unsigned long flags;
++
++ //printk(KERN_INFO"%s: GET_USE_COUNT: %d\n", __FUNCTION__, GET_USE_COUNT(THIS_MODULE));
++
++ local_irq_save (flags);
++ if (!isotest.iso_bh.sync) {
++ MOD_INC_USE_COUNT;
++ queue_task(&isotest.iso_bh, &tq_immediate);
++ mark_bh(IMMEDIATE_BH);
++ }
++ local_irq_restore (flags);
++
++ //printk(KERN_INFO"%s: GET_USE_COUNT: %d\n", __FUNCTION__, GET_USE_COUNT(THIS_MODULE));
++}
++
++
++int isotest_urb_sent (struct usbd_urb *urb, int rc);
++int isotest_recv_urb (struct usbd_urb *urb, int rc);
++
++/* Transmit Function *************************************************************************** */
++
++static int out_count;
++static int in_count;
++static int send_size = 1000;
++static int iso_transfer_in_count;
++
++static int isotest_xmit_data (void)
++{
++ int i;
++ int j;
++ int frames;
++ int size = ((send_size % in) < 20) ? send_size + 20 : send_size;
++ struct usbd_urb *urb;
++ struct usbd_function_instance *function = isotest.function;
++
++ //printk(KERN_INFO"%s: open: %d in_count: %d\n", __FUNCTION__, isotest.open, in_count);
++
++ RETURN_ZERO_IF(!isotest.open);
++
++ RETURN_EINVAL_IF(!(urb = usbd_alloc_urb (isotest.function, ISO_IN, size, isotest_urb_sent)));
++
++ frames = (size / in) + 1;
++
++ iso_transfer_in_count++;
++
++ for (i = 0; i < frames; i++) {
++
++ u8 *cp = urb->buffer + (i * in);
++ if(custom){
++ (void) fill_xmit_buffer(in, cp);
++ } else {
++ (void) fill_xmit_buffer_default(in,cp);
++ }
++ if(fermat){
++ fermat_encode(cp, in);
++ }
++ print_buffer(in, cp);
++
++ // iso_transfer_count
++ *cp++ = cpu_to_le16(iso_transfer_in_count) & 0xff;
++ *cp++ = (cpu_to_le16(iso_transfer_in_count) >> 8) & 0xff;
++ *cp++ = (cpu_to_le16(iso_transfer_in_count) >> 16) & 0xff;
++ *cp++ = (cpu_to_le16(iso_transfer_in_count) >> 24) & 0xff;
++
++ // iso transfer length
++ *cp++ = cpu_to_le16(size) & 0xff;
++ *cp++ = (cpu_to_le16(size) >> 8) & 0xff;
++
++ // iso frame size
++ *cp++ = cpu_to_le16(in) & 0xff;
++ *cp++ = (cpu_to_le16(in) >> 8) & 0xff;
++
++ // total frames
++ *cp++ = cpu_to_le16(frames) & 0xff;
++ *cp++ = (cpu_to_le16(frames) >> 8) & 0xff;
++
++ // this packet number
++ *cp++ = cpu_to_le16(i+1) & 0xff;
++ *cp++ = (cpu_to_le16(i+1) >> 8) & 0xff;
++
++ }
++ urb->actual_length = size;
++
++ // push it down into the usb-device layer
++ //printk(KERN_INFO"%s: sending: %p length: %d\n", __FUNCTION__, urb, urb->actual_length);
++ return usbd_start_in_urb (urb);
++}
++
++
++/* isotest_urb_sent - called to indicate URB transmit finished
++ * @urb: pointer to struct usbd_urb
++ * @rc: result
++ */
++int isotest_urb_sent (struct usbd_urb *urb, int rc)
++{
++ //printk(KERN_INFO"%s: sent: %p status: %d\n", __FUNCTION__, urb, urb->status);
++
++ usbd_free_urb (urb);
++
++ //printk(KERN_INFO"%s: calling schedule_bh\n", __FUNCTION__);
++ schedule_bh();
++ return 0;
++}
++
++
++/* USB Device Functions ************************************************************************ */
++
++/* isotest_event_handler - process a device event
++ *
++ */
++void isotest_event_handler (struct usbd_function_instance *function, usbd_device_event_t event, int data)
++{
++ int i;
++ switch (event) {
++
++ case DEVICE_RESET:
++ case DEVICE_DESTROY:
++ if (isotest.open)
++ usbd_disable_irq(NULL);
++
++ isotest.open = 0;
++ break;
++
++ case DEVICE_CONFIGURED:
++ isotest.open = 1;
++ for (i = 0; i < 2; i++) {
++ struct usbd_urb *urb;
++ BREAK_IF(!(urb = usbd_alloc_urb (function, ISO_OUT,
++ usbd_endpoint_transferSize(
++ function, ISO_OUT,usbd_high_speed(function)),
++ isotest_recv_urb
++ )));
++ if (usbd_start_out_urb(urb))
++ usbd_free_urb(urb);
++ }
++ iso_start_in(100);
++ break;
++
++ case DEVICE_BUS_INACTIVE:
++ break;
++
++ case DEVICE_BUS_ACTIVITY:
++ break;
++
++ default:
++ break;
++ }
++}
++
++
++/* isotest_recv_urb - called to indicate URB has been received
++ * @urb - pointer to struct usbd_urb
++ *
++ * Return non-zero if we failed and urb is still valid (not disposed)
++ */
++int isotest_recv_urb (struct usbd_urb *urb, int rc)
++{
++ //struct usbd_device_instance *device = urb->device;
++#if 0
++ printk(KERN_INFO"%s: urb: %p length: %d framenum: %04x %d\n", __FUNCTION__,
++ urb, urb->actual_length, urb->framenum, urb->framenum);
++#endif
++ iso_trace_recv_data(&isotest_stats, urb->buffer, urb->actual_length, 0);
++
++ // start_recv urb
++ return (usbd_start_out_urb (urb));
++}
++
++
++/* ********************************************************************************************* */
++
++void iso_start_in(int count)
++{
++ in_count = count;
++ //printk(KERN_INFO"%s: calling schedule_bh\n", __FUNCTION__);
++ schedule_bh();
++}
++
++void iso_start_out(int count)
++{
++ out_count = count;
++ //printk(KERN_INFO"%s: calling schedule_bh\n", __FUNCTION__);
++ schedule_bh();
++}
++
++static void
++bottomhalf(void *data)
++{
++ //printk(KERN_INFO"%s: closing: %d\n", __FUNCTION__, isotest.closing);
++ if (isotest.closing)
++ isotest.iso_bh.data = NULL;
++
++ else if (isotest.open)
++ isotest_xmit_data ();
++
++ MOD_DEC_USE_COUNT;
++ //printk(KERN_INFO"%s: GET_USE_COUNT: %d\n", __FUNCTION__, GET_USE_COUNT(THIS_MODULE));
++}
++
++
++/* ********************************************************************************************* */
++
++static int isotest_function_enable (struct usbd_function_instance *function)
++{
++ //printk(KERN_INFO"%s:\n", __FUNCTION__);
++ MOD_INC_USE_COUNT;
++
++ //printk(KERN_INFO"%s: calling schedule_bh\n", __FUNCTION__);
++ isotest.closing = 0;
++ schedule_bh();
++ return 0;
++}
++
++static void isotest_function_disable (struct usbd_function_instance *function)
++{
++ isotest.closing = 1;
++ while (isotest.iso_bh.data) {
++ //printk(KERN_INFO"%s: calling schedule_bh\n", __FUNCTION__);
++ schedule_bh();
++ //printk(KERN_INFO"%s: waiting\n", __FUNCTION__);
++ sleep_on_timeout(&isotest.iso_wq, 20);
++ }
++ MOD_DEC_USE_COUNT;
++}
++
++
++struct usbd_function_operations function_ops = {
++ event_handler:isotest_event_handler,
++ function_enable: isotest_function_enable,
++ function_disable: isotest_function_disable,
++};
++
++struct usbd_function_driver function_driver = {
++ name:"ISO Test Function",
++ fops:&function_ops,
++ device_description:&isotest_device_description,
++ bNumConfigurations:sizeof (isotest_description) / sizeof (struct usbd_configuration_description),
++ configuration_description:isotest_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_OTG_ISOTEST_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_ISOTEST_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_ISOTEST_BCDDEVICE),
++ bNumInterfaces:sizeof (isotest_interfaces) / sizeof (struct usbd_interface_description),
++ interface_list:isotest_interfaces,
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: iso_endpoint_requests,
++};
++
++
++/*
++ * isotest_modinit - module init
++ *
++ */
++static int isotest_modinit (void)
++{
++ printk (KERN_INFO "vendor_id: %04x product_id: %04x in: %02x out: %02x\n",
++ vendor_id, product_id, in, out);
++
++ if (vendor_id)
++ function_driver.idVendor = cpu_to_le16(vendor_id);
++
++ if (product_id)
++ function_driver.idProduct = cpu_to_le16(product_id);
++
++
++ isotest_ep_1[4] = out&0xff;
++ isotest_ep_1[5] = (out>>8)&0xff;
++ isotest_ep_2[4] = in&0xff;
++ isotest_ep_2[5] = (in>>8)&0xff;
++
++ // XXX should this be the endpoint request structure?
++ iso_endpoint_requests[0].fs_requestedTransferSize = out;
++ iso_endpoint_requests[1].fs_requestedTransferSize = in;
++
++ iso_trace_init("isotest_fd");
++ if(fermat){
++ fermat_init();
++ }
++
++ isotest.iso_bh.routine = bottomhalf;
++ isotest.iso_bh.data = (void *)&isotest;
++ init_waitqueue_head(&isotest.iso_wq);
++
++ // register us with the usb device support layer
++ RETURN_EINVAL_IF (usbd_register_function (&function_driver, "isotest", NULL));
++
++ // return
++ return 0;
++}
++
++
++/* isotest_modexit - module cleanup
++ */
++static void isotest_modexit (void)
++{
++ usbd_deregister_function (&function_driver);
++ iso_trace_exit("isotest_fd");
++}
++
++module_init (isotest_modinit);
++module_exit (isotest_modexit);
++
+diff -uNr linux/drivers/no-otg/functions/isotest/iso_fermat linux/drivers/otg/functions/isotest/iso_fermat
+--- linux/drivers/no-otg/functions/isotest/iso_fermat 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/isotest/iso_fermat 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,34 @@
++#!/bin/sh
++XFER=$1
++PATTERN=$2
++if [ -z "$PATTERN" ]
++then
++ PATTERN="0x1,0x8,1,2,3,4,5,6,7,8"
++fi
++echo "Using PATTERN='$PATTERN'"
++set -x
++
++insmod /tmp/usbdcore.o
++insmod /tmp/usbdprocfs.o
++
++insmod /tmp/isotest_fd.o vendor_id=0xfff0 product_id=0xfff1 in=$XFER out=$XFER xmit_pattern="$PATTERN" print_all=0 fermat=1 custom=0
++
++insmod /tmp/au1x00_bi.o
++echo "enable" > /proc/usbd-switch
++
++
++set +x
++echo -n "INSERT CABLE"
++sleep 15
++echo -n "; REMOVE CABLE AND PRESS RETURN"
++read junk
++set -x
++cp /proc/isotest_fd client
++cp /proc/isotest_host host
++echo "disable" > /proc/usbd-switch
++
++rmmod au1x00_bi
++rmmod isotest_fd
++rmmod usbdprocfs
++rmmod usbdcore
++
+diff -uNr linux/drivers/no-otg/functions/isotest/iso_one linux/drivers/otg/functions/isotest/iso_one
+--- linux/drivers/no-otg/functions/isotest/iso_one 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/isotest/iso_one 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,34 @@
++#!/bin/sh
++XFER=$1
++PATTERN=$2
++if [ -z "$PATTERN" ]
++then
++ PATTERN="0x1,0x1,0xFF"
++fi
++echo "Using PATTERN='$PATTERN'"
++set -x
++
++insmod /tmp/usbdcore.o
++insmod /tmp/usbdprocfs.o
++
++insmod /tmp/isotest_fd.o vendor_id=0xfff0 product_id=0xfff1 in=$XFER out=$XFER xmit_pattern="$PATTERN" print_all=1 fermat=0 custom=1
++
++insmod /tmp/au1x00_bi.o
++echo "enable" > /proc/usbd-switch
++
++
++set +x
++echo -n "INSERT CABLE"
++sleep 15
++echo -n "; REMOVE CABLE AND PRESS RETURN"
++read junk
++set -x
++cp /proc/isotest_fd client
++cp /proc/isotest_host host
++echo "disable" > /proc/usbd-switch
++
++rmmod au1x00_bi
++rmmod isotest_fd
++rmmod usbdprocfs
++rmmod usbdcore
++
+diff -uNr linux/drivers/no-otg/functions/isotest/iso_zero linux/drivers/otg/functions/isotest/iso_zero
+--- linux/drivers/no-otg/functions/isotest/iso_zero 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/isotest/iso_zero 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,34 @@
++#!/bin/sh
++XFER=$1
++PATTERN=$2
++if [ -z "$PATTERN" ]
++then
++ PATTERN="0x1,0x1,0x00"
++fi
++echo "Using PATTERN='$PATTERN'"
++set -x
++
++insmod /tmp/usbdcore.o
++insmod /tmp/usbdprocfs.o
++
++insmod /tmp/isotest_fd.o vendor_id=0xfff0 product_id=0xfff1 in=$XFER out=$XFER xmit_pattern="$PATTERN" print_all=1 fermat=0 custom=1
++
++insmod /tmp/au1x00_bi.o
++echo "enable" > /proc/usbd-switch
++
++
++set +x
++echo -n "INSERT CABLE"
++sleep 15
++echo -n "; REMOVE CABLE AND PRESS RETURN"
++read junk
++set -x
++cp /proc/isotest_fd client
++cp /proc/isotest_host host
++echo "disable" > /proc/usbd-switch
++
++rmmod au1x00_bi
++rmmod isotest_fd
++rmmod usbdprocfs
++rmmod usbdcore
++
+diff -uNr linux/drivers/no-otg/functions/isotest/iso_zero_silent linux/drivers/otg/functions/isotest/iso_zero_silent
+--- linux/drivers/no-otg/functions/isotest/iso_zero_silent 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/isotest/iso_zero_silent 2006-09-01 21:41:26.000000000 +0200
+@@ -0,0 +1,34 @@
++#!/bin/sh
++XFER=$1
++PATTERN=$2
++if [ -z "$PATTERN" ]
++then
++ PATTERN="0x1,0x1,0x00"
++fi
++echo "Using PATTERN='$PATTERN'"
++set -x
++
++insmod /tmp/usbdcore.o
++insmod /tmp/usbdprocfs.o
++
++insmod /tmp/isotest_fd.o vendor_id=0xfff0 product_id=0xfff1 in=$XFER out=$XFER xmit_pattern="$PATTERN" print_all=0 fermat=0 custom=1
++
++insmod /tmp/au1x00_bi.o
++echo "enable" > /proc/usbd-switch
++
++
++set +x
++echo -n "INSERT CABLE"
++sleep 15
++echo -n "; REMOVE CABLE AND PRESS RETURN"
++read junk
++set -x
++cp /proc/isotest_fd client
++cp /proc/isotest_host host
++echo "disable" > /proc/usbd-switch
++
++rmmod au1x00_bi
++rmmod isotest_fd
++rmmod usbdprocfs
++rmmod usbdcore
++
+diff -uNr linux/drivers/no-otg/functions/isotest/test.c linux/drivers/otg/functions/isotest/test.c
+--- linux/drivers/no-otg/functions/isotest/test.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/isotest/test.c 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,456 @@
++/*
++ * otg/isotest_fd/test.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ *
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/version.h>
++
++#include <linux/kernel.h>
++//#include <linux/sched.h>
++#include <linux/signal.h>
++#include <linux/errno.h>
++//#include <linux/poll.h>
++#include <linux/init.h>
++
++#include <asm/system.h>
++#include <asm/atomic.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/io.h>
++#include <asm/string.h>
++
++#include <linux/proc_fs.h>
++
++#include <linux/netdevice.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)
++#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
++
++#include <asm/uaccess.h>
++#include <asm/io.h>
++#include <asm/pgtable.h>
++#include <asm/pgalloc.h>
++#include "test.h"
++
++
++int iso_trace_first;
++int iso_trace_next;
++iso_trace_t *iso_traces;
++
++
++/* ******************************************************************************************* */
++
++void dump_stats(struct isotest_stats *stats)
++{
++ if (stats->errors || ((stats->ok % 100) == 99)) {
++ TRACE_ISO(stats->iso_transfer_number, stats->total_frames,
++ stats->received, stats->errors, stats->missed, stats->skipped, stats->ok);
++ }
++ if (stats->errors) {
++ memset(stats, 0, sizeof(struct isotest_stats));
++ }
++ else {
++ stats->ok++;
++ stats->iso_transfer_number++;
++ stats->last_packet = 0;
++ }
++}
++
++u16 getu16(u8 **cp)
++{
++ u16 val = 0;
++
++ val = *(*cp)++;
++ val |= *(*cp)++ << 8;
++
++ return val;
++}
++
++u16 getu32(u8 **cp)
++{
++ u32 val = 0;
++
++ val = *(*cp)++;
++ val |= *(*cp)++ << 8;
++ val |= *(*cp)++ << 16;
++ val |= *(*cp)++ << 24;
++
++ return val;
++}
++
++static int iso_in_received;
++
++void iso_trace_recv_data (struct isotest_stats *stats, u8 *cp, int length, int framenum)
++{
++ //struct usb_device_instance *device = urb->device;
++
++ u16 iso_transfer_number;
++ u16 total_size;
++ u16 packet_size;
++ u16 total_frames;
++ u16 this_packet;
++ u8 frames;
++
++
++ iso_transfer_number = getu32(&cp);
++ total_size = getu16(&cp);
++ packet_size = getu16(&cp);
++ total_frames = getu16(&cp);
++ this_packet = getu16(&cp);
++
++
++ // did we miss the end of the last ISO transfer?
++ if (stats->iso_transfer_number && (stats->iso_transfer_number != iso_transfer_number)) {
++ stats->errors++;
++ stats->missed++;
++ //printk(KERN_INFO"%s: ERROR bad iso number: %x %x %x %x %x expecting: %x\n", __FUNCTION__, iso_transfer_number,
++ // total_size, packet_size, total_frames, this_packet, stats->iso_transfer_number);
++ dump_stats(stats);
++ return;
++ }
++
++ if (!stats->iso_transfer_number) {
++ stats->framenum = framenum;
++ stats->iso_transfer_number = iso_transfer_number;
++ stats->total_frames = total_frames;
++ }
++
++ // is this the packet we are expecting?
++ if (stats->last_packet && ((stats->last_packet + 1) != this_packet)) {
++ stats->errors++;
++ stats->missed++;
++ //printk(KERN_INFO"%s: ERROR bad packet: %x %x %x %x %x expecting: %x\n", __FUNCTION__, iso_transfer_number,
++ // total_size, packet_size, total_frames, this_packet, stats->last_packet + 1);
++ }
++
++ // did we miss a frame?
++ frames = (stats->framenum < framenum) ? (framenum - stats->framenum) : (stats->framenum - framenum);
++
++ if (frames > 1) {
++ stats->errors++;
++ stats->skipped++;
++ //printk(KERN_INFO"%s: SKIPPED %x %x %x %x %x\n", __FUNCTION__, iso_transfer_number,
++ // total_size, packet_size, total_frames, this_packet);
++ }
++
++ // update stats
++ stats->received++;
++ stats->last_packet = this_packet;
++
++ // last packet?
++ if (stats->total_frames == this_packet)
++ dump_stats(stats);
++}
++
++
++
++/* Proc Filesystem *************************************************************************** */
++
++/* *
++ * iso_trace_proc_read - implement proc file system read.
++ * @file
++ * @buf
++ * @count
++ * @pos
++ *
++ * Standard proc file system read function.
++ */
++static ssize_t iso_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;
++
++ MOD_INC_USE_COUNT;
++ //printk(KERN_INFO"%s: GET_USE_COUNT: %d\n", __FUNCTION__, GET_USE_COUNT(THIS_MODULE));
++ // get a page, max 4095 bytes of data...
++ if (!(page = get_free_page (GFP_KERNEL))) {
++ MOD_DEC_USE_COUNT;
++ //printk(KERN_INFO"%s: GET_USE_COUNT: %d\n", __FUNCTION__, GET_USE_COUNT(THIS_MODULE));
++ return -ENOMEM;
++ }
++
++ len = 0;
++ oindex = index = (*pos)++;
++
++ if (index == 0) {
++ //len += sprintf ((char *) page + len, " uS Exp Rcv Err Miss Skip OK\n");
++ //len += sprintf ((char *) page + len, " uS Exp Rcv Err Miss Skip Xfers\n");
++ len += sprintf ((char *) page + len, " uS Tr Exp Rcv Err Miss Skip Xfers\n");
++
++// uS Exp Rcv Err Miss Skip Xfers
++// uS Tr Exp Rcv Err Miss Skip Xfers
++// 0 | 100 9 900 0 0 0 99
++
++ }
++
++ index += iso_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", iso_trace_first, iso_trace_next, oindex, index, previous);
++
++ if (
++ ((iso_trace_first < iso_trace_next) && (index >= iso_trace_first) && (index < iso_trace_next)) ||
++ ((iso_trace_first > iso_trace_next) && ((index < iso_trace_next) || (index >= iso_trace_first)))
++ )
++ {
++
++#if defined(CONFIG_ARCH_SA1100) || defined (CONFIG_ARCH_PXA) || defined(CONFIG_MIPS_AU1000) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1100)
++ u32 ticks = 0;
++#elif defined(CONFIG_ARCH_SAMSUNG)
++ u32 ticks = 0;
++#else
++ u64 jifs = 0;
++#endif
++ iso_trace_t *p = iso_traces + index;
++ //unsigned char *cp;
++ //int skip = 0;
++
++ if (oindex > 0) {
++ iso_trace_t *o = iso_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->ocsr) {
++ ticks = (p->ocsr > o->ocsr) ? (p->ocsr - o->ocsr) : (o->ocsr - p->ocsr) ;
++ ticks = (ticks * 60) / 221;
++ }
++
++#elif 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 = (p->cp0_count - o->cp0_count) ;
++ ticks = ticks / CONFIG_OTG_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_OTG_SMDK2500_BCLOCK;
++ }
++#else
++ if (o->jiffies) {
++ jifs = p->jiffies - iso_traces[previous].jiffies;
++ }
++#endif
++
++ //if (o->interrupts != p->interrupts) {
++ // skip++;
++ //}
++ }
++
++
++#if defined(CONFIG_ARCH_SA1100) || defined (CONFIG_ARCH_PXA) || defined(CONFIG_MIPS_AU1000) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1100)
++ len += sprintf ((char *) page + len, "%9d ", 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>>20);
++ }
++ else {
++ len += sprintf ((char *) page + len, "%4d ", (int)jifs);
++ }
++#endif
++
++ len += sprintf ((char *) page + len, "| %8d", p->iso_transfer_number);
++ len += sprintf ((char *) page + len, "%6d", p->expected);
++ len += sprintf ((char *) page + len, "%6d", p->received);
++ len += sprintf ((char *) page + len, "%6d", p->errors);
++ len += sprintf ((char *) page + len, "%6d", p->missed);
++ len += sprintf ((char *) page + len, "%6d", p->skipped);
++ len += sprintf ((char *) page + len, "%6d", p->ok);
++ len += sprintf ((char *) page + len, "\n");
++ }
++
++#if 1
++ if ((len > count) ) {
++ printk(KERN_INFO"%s: ((len > count) count=%d len=%d\n", __FUNCTION__, count, len);
++ len = -EINVAL;
++ }
++
++#else
++ if ((len > count) || (len == 0)) {
++ printk(KERN_INFO"%s: ((len > count) || (len == 0)) count=%d len=%d\n", __FUNCTION__, count, len);
++ len = -EINVAL;
++ }
++#endif
++ else if (len > 0 && copy_to_user (buf, (char *) page, len)) {
++ printk(KERN_INFO"%s: (len > 0 && copy_to_user (buf, (char *) page, len) \n", __FUNCTION__);
++ len = -EFAULT;
++ }
++ free_page (page);
++ MOD_DEC_USE_COUNT;
++ //printk(KERN_INFO"%s: GET_USE_COUNT: %d\n", __FUNCTION__, GET_USE_COUNT(THIS_MODULE));
++ return len;
++}
++
++void iso_start_in(int count);
++void iso_start_out(int count);
++
++/* *
++ * iso_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 iso_trace_proc_write (struct file *file, const char *buf, size_t count, loff_t * pos)
++{
++ //struct usb_device_instance *device;
++ size_t n = count;
++ char command[64];
++ char *cp = command;
++ int i = 0;
++
++ MOD_INC_USE_COUNT;
++ //printk(KERN_INFO"%s: GET_USE_COUNT: %d\n", __FUNCTION__, GET_USE_COUNT(THIS_MODULE));
++ //printk(KERN_DEBUG "%s: count=%u\n",__FUNCTION__,count);
++ while ((n > 0) && (i < 64)) {
++ // Not too efficient, but it shouldn't matter
++ if (copy_from_user (cp++, buf + (count - n), 1)) {
++ count = -EFAULT;
++ break;
++ }
++ *cp = '\0';
++ i++;
++ n -= 1;
++ //printk(KERN_DEBUG "%s: %u/%u %02x\n",__FUNCTION__,count-n,count,c);
++ }
++ if (!strncmp (command, "in", 2)) {
++ iso_start_in (10);
++ }
++ else if (!strncmp (command, "out", 3)) {
++ iso_start_out (10);
++ }
++ // XXX need to be able to set serial number here
++ MOD_DEC_USE_COUNT;
++ //printk(KERN_INFO"%s: GET_USE_COUNT: %d\n", __FUNCTION__, GET_USE_COUNT(THIS_MODULE));
++ return (count);
++}
++
++static struct file_operations iso_trace_proc_operations_functions = {
++read:iso_trace_proc_read,
++write:iso_trace_proc_write,
++};
++
++#if defined(CONFIG_ARCH_SAMSUNG)
++#endif
++
++/**
++ * iso_trace_init
++ *
++ * Return non-zero if not successful.
++ */
++int iso_trace_init (char *name)
++{
++ printk(KERN_INFO"%s:\n", __FUNCTION__);
++ if (!(iso_traces = vmalloc(sizeof(iso_trace_t) * TRACE_MAX))) {
++ printk(KERN_ERR"%s: malloc failed %p %d\n", __FUNCTION__, iso_traces, sizeof(iso_trace_t) * TRACE_MAX);
++ return -EINVAL;
++ }
++ memset(iso_traces, 0, sizeof(iso_trace_t) * TRACE_MAX);
++
++ {
++ struct proc_dir_entry *p;
++
++ // create proc filesystem entries
++ if ((p = create_proc_entry (name, 0, 0)) == NULL) {
++ printk(KERN_INFO"BITRACE PROC FS failed\n");
++ }
++ else {
++ p->proc_fops = &iso_trace_proc_operations_functions;
++ }
++ }
++#if defined(CONFIG_ARCH_SAMSUNG)
++ *(volatile u32 *)TMOD |= 0x3 << 3;
++#endif
++ printk(KERN_INFO"%s: OK\n", __FUNCTION__);
++ return 0;
++}
++
++/**
++ * udc_release_io - release UDC io region
++ */
++void iso_trace_exit (char *name)
++{
++ {
++ unsigned long flags;
++ local_irq_save (flags);
++ remove_proc_entry (name, NULL);
++ if (iso_traces) {
++ iso_trace_t *p = iso_traces;
++ iso_traces = 0;
++ vfree(p);
++ }
++ local_irq_restore (flags);
++ }
++}
++
++
++/* End of FILE */
++
+diff -uNr linux/drivers/no-otg/functions/isotest/test.h linux/drivers/otg/functions/isotest/test.h
+--- linux/drivers/no-otg/functions/isotest/test.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/isotest/test.h 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,129 @@
++/*
++ * otg/isotest_fd/test.h
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ *
++ */
++
++#if defined(CONFIG_ARCH_SAMSUNG)
++#ifndef CONFIG_OTG_SMDK2500_BCLOCK
++#define CONFIG_OTG_SMDK2500_BCLOCK 66
++#endif
++#endif
++
++#define NUSBD_FRAMENUM 0xB0200038
++
++
++struct isotest_stats {
++
++ u16 count;
++
++ u16 iso_transfer_number;
++ u16 total_size;
++ u16 packet_size;
++ u16 total_frames;
++ u16 last_packet;
++
++
++ u16 framenum;
++ u16 received;
++ u16 missed;
++ u16 skipped;
++ u16 errors;
++
++ u32 ok;
++
++};
++
++
++
++
++
++typedef struct iso_trace_types {
++#if defined(CONFIG_ARCH_SA1100) || defined (CONFIG_ARCH_PXA)
++ u32 ocsr;
++#elif defined(CONFIG_MIPS_AU1000) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1100)
++ u32 cp0_count;
++#elif defined(CONFIG_ARCH_SAMSUNG)
++ u32 tcnt1;
++#else
++ u64 jiffies;
++#endif
++ u16 iso_transfer_number;
++
++ u16 expected;
++ u16 received;
++ u16 errors;
++ u16 missed;
++ u16 skipped;
++
++ u32 ok;
++
++} iso_trace_t;
++
++
++#define TRACE_MAX 3000
++
++extern int iso_trace_first;
++extern int iso_trace_next;
++
++extern iso_trace_t *iso_traces;
++
++static __inline__ iso_trace_t *ISO_TRACE_NEXT(void)
++{
++ iso_trace_t *p;
++
++ p = iso_traces + iso_trace_next;
++
++#if defined(CONFIG_ARCH_SA1100) || defined (CONFIG_ARCH_PXA)
++ p->ocsr = OSCR;
++#elif defined(CONFIG_MIPS_AU1000) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1100)
++ p->cp0_count = read_c0_count();
++#elif defined(CONFIG_ARCH_SAMSUNG)
++ p->tcnt1 = *(volatile u32 *)TCNT1;
++#else
++ p->jiffies = jiffies;
++#endif
++//#if defined(CONFIG_MIPS_AU1000) || defined(CONFIG_MIPS_PB1500) || defined(CONFIG_MIPS_PB1100)
++// p->iso_transfer_number = au_readl(NUSBD_FRAMENUM);
++//#endif
++
++ iso_trace_next++;
++ iso_trace_next = (iso_trace_next == TRACE_MAX) ? 0 : iso_trace_next;
++
++ if (iso_trace_next == iso_trace_first) {
++ iso_trace_first++;
++ iso_trace_first = (iso_trace_first == TRACE_MAX) ? 0 : iso_trace_first;
++ }
++
++ return p;
++}
++
++static __inline__ void TRACE_ISO(u16 iso_transfer_number, u16 expected, u16 received, u16 errors, u16 missed, u16 skipped, u32 ok)
++{
++ iso_trace_t *p = NULL;
++
++ //printk(KERN_INFO"%s: %d %d %d %d %d first: %d next: %d traces: %p\n", __FUNCTION__,
++ // expected, received, errors, missed, skipped, iso_trace_first, iso_trace_next, traces);
++
++ if (!iso_traces) return;
++
++ p = ISO_TRACE_NEXT();
++ p->iso_transfer_number = iso_transfer_number;
++ p->expected = expected;
++ p->received = received;
++ p->errors = errors;
++ p->missed = missed;
++ p->skipped = skipped;
++ p->ok = ok;
++}
++
++void iso_trace_recv_data (struct isotest_stats *stats, u8 *cp, int length, int framenum);
++int iso_trace_init (char *str);
++void iso_trace_exit (char *str);
++
+diff -uNr linux/drivers/no-otg/functions/mouse/Config.in linux/drivers/otg/functions/mouse/Config.in
+--- linux/drivers/no-otg/functions/mouse/Config.in 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/mouse/Config.in 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,28 @@
++#
++# Mouse Function Driver
++#
++# Copyright (C) 2003 Belcarra
++#
++
++
++mainmenu_option next_comment
++
++comment "USB Peripheral Function Driver - Random Mouse"
++dep_tristate ' Mouse Function' CONFIG_OTG_MOUSE $CONFIG_OTG
++
++if [ "$CONFIG_OTG_MOUSE" != "n" ]; then
++ hex 'VendorID (hex value)' CONFIG_OTG_MOUSE_VENDORID "15ec"
++ hex 'ProductID (hex value)' CONFIG_OTG_MOUSE_PRODUCTID "f003"
++ hex 'bcdDevice (binary-coded decimal)' CONFIG_OTG_MOUSE_BCDDEVICE "0100"
++
++ string 'iManufacturer (string)' CONFIG_OTG_MOUSE_MANUFACTURER "Belcarra"
++ #string 'iProduct (string)' CONFIG_OTG_MOUSE_PRODUCT_NAME "Belcarra Mouse"
++
++ string 'iConfiguration (string)' CONFIG_OTG_MOUSE_DESC "Mouse Cfg"
++ string 'Comm Interface iInterface (string)' CONFIG_OTG_MOUSE_COMM_INTF "Comm Intf"
++ bool 'Mouse BH Test' CONFIG_OTG_MOUSE_BH
++ int 'Number of packets (zero is continous ' CONFIG_OTG_MOUSE_PACKETS "10"
++ int 'Polling Interval ' CONFIG_OTG_MOUSE_INTERVAL "1"
++
++fi
++endmenu
+diff -uNr linux/drivers/no-otg/functions/mouse/Kconfig linux/drivers/otg/functions/mouse/Kconfig
+--- linux/drivers/no-otg/functions/mouse/Kconfig 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/mouse/Kconfig 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,74 @@
++menu "OTG Random Mouse function"
++ depends on OTG
++
++config OTG_MOUSE
++ tristate " Random Mouse Function"
++ depends on OTG
++ ---help---
++ This implements a simple Mouse driver that sends HID packets with
++ small random movements. This is a good function for initial testing
++ of Peripheral Controller Drivers as it provides for a complicated
++ enumeration but a simple uni-directional (send Interrupt only) data
++ transport.
++
++menu "OTG Random Mouse function options"
++ depends on OTG && OTG_MOUSE
++
++config OTG_MOUSE_VENDORID
++ hex "VendorID (hex value)"
++ depends on OTG && OTG_MOUSE
++ default "0x15ec"
++
++config OTG_MOUSE_PRODUCTID
++ hex "ProductID (hex value)"
++ depends on OTG && OTG_MOUSE
++ default "0xf003"
++
++config OTG_MOUSE_BCDDEVICE
++ hex "bcdDevice (binary-coded decimal)"
++ depends on OTG && OTG_MOUSE
++ default "0x0100"
++
++config OTG_MOUSE_MANUFACTURER
++ string "iManufacturer (string)"
++ depends on OTG && OTG_MOUSE
++ default "Belcarra"
++
++config OTG_MOUSE_PRODUCT_NAME
++ string "iProduct (string)"
++ depends on OTG && OTG_MOUSE
++ default "Random Mouse Class - Interrupt"
++
++config OTG_MOUSE_COMM_INTF
++ string "MOUSE Bulk Only iInterface (string)"
++ depends on OTG && OTG_MOUSE
++ default "MOUSE Data Intf"
++
++config OTG_MOUSE_DESC
++ string "Data Interface iConfiguration (string)"
++ depends on OTG && OTG_MOUSE
++ default "MOUSE Configuration"
++
++config OTG_MOUSE_BH
++ bool " MOUSE BH Test"
++ depends on OTG && OTG_MOUSE
++ default n
++ ---help---
++ Implement the Mouse send packet in a bottom half handler,
++ this will delay responses to test the PCD works correctly
++ when the host polls before a send data urb is queued.
++
++
++config OTG_MOUSE_PACKETS
++ int "Number of packets (zero is continous)"
++ depends on OTG && OTG_MOUSE
++ default 10
++ ---help---
++ Number of Mouse packets to send, will run
++ forever if set to zero.
++
++
++endmenu
++
++
++endmenu
+diff -uNr linux/drivers/no-otg/functions/mouse/Makefile linux/drivers/otg/functions/mouse/Makefile
+--- linux/drivers/no-otg/functions/mouse/Makefile 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/mouse/Makefile 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,81 @@
++#
++# Function driver for a Mouse USB Device
++#
++# Copyright (c) 2003 Belcarra
++
++# Multipart objects.
++
++O_TARGET := mouse_target.o
++#list-multi := mouse_fd.o cmouse_fd.o
++list-multi := mouse_fd.o
++
++mouse_fd-objs := mouse-fd.o mouse-l24.o
++#cmouse_fd-objs := mouse-cf.o mouse-if.o cmouse-l24.o
++#cmouse_fd-objs := mouse-if.o cmouse-l24.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_OTG_MOUSE) += mouse_fd.o
++#obj-$(CONFIG_OTG_MOUSE) += cmouse_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.
++
++#MOUSED=$(OTG)/functions/mouse
++
++OTG_WARNINGS=-Wno-unused -Wno-format
++OTG=$(TOPDIR)/drivers/otg
++OTG_INCLUDES=-I$(OTG)
++OTG_EXTRA=$(OTG_INCLUDES) $(OTG_WARNINGS)
++OTGCORE_DIR=$(OTG)/otgcore
++##USBDCORE_DIR=$(OTG)/usbdcore
++include $(TOPDIR)/Rules.make
++#EXTRA_CFLAGS += -I$(OTG) -Wno-unused -Wno-format -I$(USBDCORE_DIR) -I$(OTGCORE_DIR)
++#EXTRA_CFLAGS_nostdinc += -I$(OTG) -Wno-unused -Wno-format -I$(USBDCORE_DIR) -I$(OTGCORE_DIR)
++EXTRA_CFLAGS += $(OTG_EXTRA)
++EXTRA_CFLAGS_nostdinc += $(OTG_EXTRA)
++
++# Link rules for multi-part drivers.
++
++mouse_fd.o: $(mouse_fd-objs)
++ $(LD) -r -o $@ $(mouse_fd-objs)
++
++#cmouse_fd.o: $(cmouse_fd-objs)
++# $(LD) -r -o $@ $(cmouse_fd-objs)
++
++# dependencies:
++
++#mouse.o: $(USBDCORE_DIR)/usbd.h $(USBDCORE_DIR)/usbd-bus.h $(USBDCORE_DIR)/usbd-func.h
++
++
+diff -uNr linux/drivers/no-otg/functions/mouse/Makefile-l26 linux/drivers/otg/functions/mouse/Makefile-l26
+--- linux/drivers/no-otg/functions/mouse/Makefile-l26 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/mouse/Makefile-l26 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,14 @@
++# Function driver for a Random Mouse
++#
++# Copyright (c) 2004 Belcarra
++
++mouse_fd-objs := mouse-fd.o mouse-l24.o
++
++obj-$(CONFIG_OTG_MOUSE) += mouse_fd.o
++
++OTG=$(TOPDIR)/drivers/otg
++ACMD=$(OTG)/functions/mouse
++OTGCORE_DIR=$(OTG)/otgcore
++USBDCORE_DIR=$(OTG)/usbdcore
++EXTRA_CFLAGS += -I$(ACMD) -I$(OTG) -Wno-unused -Wno-format -I$(USBDCORE_DIR) -I$(OTGCORE_DIR)
++EXTRA_CFLAGS_nostdinc += -I$(ACMD) -I$(OTG) -Wno-unused -Wno-format -I$(USBDCORE_DIR) -I$(OTGCORE_DIR)
+diff -uNr linux/drivers/no-otg/functions/mouse/cmouse-l24.c linux/drivers/otg/functions/mouse/cmouse-l24.c
+--- linux/drivers/no-otg/functions/mouse/cmouse-l24.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/mouse/cmouse-l24.c 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,199 @@
++/*
++ * otg/functions/mouse/cmouse-l24.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/functions/mouse/cmouse-l24.c
++ * @brief Mouse Function Driver Linux 2.4 initialization
++ *
++ *
++ * This file contains the Linux 2.4 module init and exit functions
++ * to load and unload the Random Mouse Function.
++ *
++ * Notes
++ *
++ * This driver does not export any upper edge functionality to
++ * for the user or applications to use. It simply sends a configurable
++ * number of data packets to the USB Host when configured. Each data
++ * packet contains the equivalent of a small mouse report which will
++ * cause the mouse cursor to move on the host.
++ *
++ * To use simply load with something like:
++ *
++ * insmod cmouse_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.
++ *
++ *
++ * 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_OTG_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_device_request() 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.
++ *
++ * 3. The CONFIG_OTG_MOUSE_PACKETS option is used to set the number of
++ * mouse data reports to send. Set to zero for a continous stream
++ * of data.
++ *
++ * @ingroup MouseFunction
++ */
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/otg-trace.h>
++
++#include "cmouse.h"
++
++
++/* Module Parameters ******************************************************** */
++/* !
++ * @name XXXXX MODULE Parameters
++ */
++/* ! @{ */
++
++MOD_AUTHOR ("sl@belcarra.com");
++EMBED_LICENSE();
++MOD_DESCRIPTION ("Belcarra Random Walk MOUSE Function");
++
++static u32 vendor_id; /*!< override built-in vendor ID */
++static u32 product_id; /*!< override built-in product ID */
++
++MOD_PARM (vendor_id, "i");
++MOD_PARM (product_id, "i");
++
++MOD_PARM_DESC (vendor_id, "Device Vendor ID");
++MOD_PARM_DESC (product_id, "Device Product ID");
++
++otg_tag_t MOUSE;
++/* ! *} */
++
++/* USB Module init/exit ***************************************************** */
++
++struct mouse_private mouse_private;
++
++char *mouse_interface_list[2] = {
++ "mouse-random-interface",
++ NULL,
++};
++
++/*!
++ * mouse_modinit() - module init
++ *
++ * This is called by the Linux kernel; either when the module is loaded
++ * if compiled as a module, or during the system intialization if the
++ * driver is linked into the kernel.
++ *
++ * This function will parse module parameters if required and then register
++ * the mouse driver with the USB Device software.
++ *
++ * If the CONFIG_OTG_MOUSE_BH option is enabled it will also setup the mouse
++ * bottom half handler.
++ *
++ */
++static int mouse_modinit (void)
++{
++ struct usbd_function_instance *mfi;
++ printk (KERN_INFO "%s: vendor_id: %04x product_id: %04x\n", __FUNCTION__, vendor_id, product_id);
++
++ #if !defined(OTG_C99)
++ mouse_global_init();
++ mouse_ops_init();
++ #endif /* defined(OTG_C99) */
++
++ MOUSE = otg_trace_obtain_tag();
++ TRACE_MSG2(MOUSE, "vendor_id: %04x product_id: %04x",vendor_id, product_id);
++
++ if (vendor_id)
++ mouse_composite_driver.idVendor = cpu_to_le16(vendor_id);
++ if (product_id)
++ mouse_composite_driver.idProduct = cpu_to_le16(product_id);
++
++ mouse_hid.wItemLength = cpu_to_le16(0x34); // XXX mips compiler bug.....
++
++ // register as usb function driver
++ TRACE_MSG2(MOUSE, "%s %d", mouse_interface_driver.name, mouse_interface_driver.endpointsRequested);
++ THROW_UNLESS ((mouse_private.interface =
++ usbd_register_interface (&mouse_interface_driver, "mouse-random-interface", NULL)), error);
++
++ TRACE_MSG2(MOUSE, "%s %d", mouse_interface_driver.name, mouse_interface_driver.endpointsRequested);
++
++ THROW_UNLESS ((mouse_private.composite =
++ usbd_register_composite (&mouse_composite_driver, "mouse-random-cf",
++ mouse_interface_list, NULL)), error);
++
++ #ifdef CONFIG_OTG_MOUSE_BH
++ mouse_private.notification_bh.routine = mouse_hid_bh;
++ mouse_private.notification_bh.data = NULL;
++ #endif
++ CATCH(error) {
++ if (mouse_private.interface) {
++ usbd_deregister_function (mouse_private.interface);
++ mouse_private.interface = NULL;
++ }
++ if (mouse_private.composite) {
++ usbd_deregister_function (mouse_private.composite);
++ mouse_private.composite = NULL;
++ }
++ otg_trace_invalidate_tag(MOUSE);
++ return -EINVAL;
++ }
++ return 0;
++}
++
++module_init (mouse_modinit);
++
++#if OTG_EPILOGUE
++/*!
++ * mouse_modexit() - module init
++ *
++ * This is called by the Linux kernel; when the module is being unloaded
++ * if compiled as a module. This function is never called if the
++ * driver is linked into the kernel.
++ *
++ * @param void
++ * @return void
++ */
++static void mouse_modexit (void)
++{
++ #ifdef CONFIG_OTG_MOUSE_BH
++ while (PENDING_WORK_ITEM(mouse_private.notification_bh)) {
++ printk(KERN_ERR"%s: waiting for bh\n", __FUNCTION__);
++ schedule_timeout(10 * HZ);
++ }
++ #endif
++ if (mouse_private.interface) {
++ usbd_deregister_function (mouse_private.interface);
++ mouse_private.interface = NULL;
++ }
++ if (mouse_private.composite) {
++ usbd_deregister_function (mouse_private.composite);
++ mouse_private.composite = NULL;
++ }
++
++ otg_trace_invalidate_tag(MOUSE);
++}
++
++module_exit (mouse_modexit);
++#endif
++
+diff -uNr linux/drivers/no-otg/functions/mouse/cmouse.h linux/drivers/otg/functions/mouse/cmouse.h
+--- linux/drivers/no-otg/functions/mouse/cmouse.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/mouse/cmouse.h 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,64 @@
++/*
++ * otg/functions/mouse/mouse.h
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++
++/*!
++ * @defgroup MouseFunction Random Mouse
++ * @ingroup functiongroup
++ */
++/*!
++ * @file otg/functions/mouse/mouse.h
++ * @brief Mouse Function Driver private defines
++ *
++ *
++ * This is a test USB HID Function Driver designed to test and
++ * verify that INTERRUPT IN endpoints work properly.
++ *
++ *
++ * @ingroup MouseFunction
++ */
++
++
++/*!
++ * The mouse_private structure is used to collect all of the mouse driver
++ * global variables into one place.
++ */
++struct mouse_private {
++ struct usbd_function_instance *interface; /*!< function instance for this module */
++ struct usbd_function_instance *composite; /*!< function instance for this module */
++
++#ifdef CONFIG_OTG_MOUSE_BH
++ struct WORK_STRUCT notification_bh;
++#endif /* CONFIG_OTG_MOUSE_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 usbd_urb *tx_urb; /*!< saved copy of current tx urb */
++ int wLength;
++ int x;
++ int y;
++ int last_x;
++ int last_y;
++ int n;
++};
++
++extern struct mouse_private mouse_private;
++extern struct usbd_function_driver mouse_interface_driver;
++extern struct usbd_function_driver mouse_composite_driver;
++extern struct hid_descriptor mouse_hid;
++
++#ifndef OTG_C99
++extern void mouse_global_init(void);
++#endif /* OTG_C99 */
++
++#define MOUSE mouse_trace_tag
++extern otg_tag_t MOUSE;
++
+diff -uNr linux/drivers/no-otg/functions/mouse/getmouse.c linux/drivers/otg/functions/mouse/getmouse.c
+--- linux/drivers/no-otg/functions/mouse/getmouse.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/mouse/getmouse.c 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,107 @@
++/*
++ *
++ *
++ * 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 -uNr linux/drivers/no-otg/functions/mouse/mouse-ce42.c linux/drivers/otg/functions/mouse/mouse-ce42.c
+--- linux/drivers/no-otg/functions/mouse/mouse-ce42.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/mouse/mouse-ce42.c 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,89 @@
++/*
++ * otg/functions/mouse/mouse-ce42.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Chris Lynne <sl@belcarra.com>,
++ * Stuart Lynne <sl@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_OTG_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_device_requesdevice_requesdevice_request
++ * 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 "otg/usbp-chap9.h"
++#include <otg/usbp-mem.h>
++#include <otg/usbp-func.h>
++
++/*
++ * mouse_modinit - module init
++ *
++ */
++static int mouse_modinit (void)
++{
++
++ // register as usb function driver
++ THROW_IF (NULL == (mouse_private.function = usbd_register_function (&mouse_function_driver, "mouse", NULL)), error);
++#ifdef CONFIG_OTG_MOUSE_BH
++ mouse_private.notification_bh.routine = mouse_hid_bh;
++ mouse_private.notification_bh.data = NULL;
++#endif
++ CATCH(error) {
++ if (mouse_private.function) {
++ usbd_deregister_function (mouse_private.function);
++ mouse_private.function = NULL;
++ }
++ return -EINVAL;
++ }
++ return 0;
++}
++
++/* mouse_modexit - module cleanup
++ */
++static void mouse_modexit (void)
++{
++ if (mouse_private.function) {
++ usbd_deregister_function (mouse_private.function);
++ mouse_private.function = NULL;
++ }
++}
++
+diff -uNr linux/drivers/no-otg/functions/mouse/mouse-fd.c linux/drivers/otg/functions/mouse/mouse-fd.c
+--- linux/drivers/no-otg/functions/mouse/mouse-fd.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/mouse/mouse-fd.c 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,826 @@
++/*
++ * otg/functions/mouse/mouse-fd.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/functions/mouse/mouse-fd.c
++ * @brief Mouse Function Driver protocol implementation.
++ *
++ * This file implements the Mouse HID protocols and will generate
++ * random mouse data on the INTERRUPT endpoint.
++ *
++ * The primary purpose of this driver is to demonstrate how to
++ * implement a simple function driver and to provide a simple
++ * uni-directional driver for testing USB Device peripheral drivers.
++ *
++ * The mouse driver has several other characteristics to allow testing of
++ * other features of USB Device peripheral drivers:
++ *
++ * - ep0 ZLP handling
++ *
++ * - ep0 delayed CONTROL READ
++ *
++ * To verify that ep0 ZLP processing is being handling correctly this
++ * driver has a hard coded Product name that is returned as a 32 byte
++ * string. This forces most any implementations that have an endpoint
++ * zero packetsize of 8, 16 or 32 to send a Zero Length Packet to
++ * terminate the string transfer when the Product name is requested
++ * by the host.
++ *
++ * The delayed CONTROL READ test verifies that that USB Device peripheral
++ * drivers will correctly NAK until data is provide for device requests.
++ * This is done by (optionally) delaying the HID report via a bottom half
++ * handler. The device request returns normally and the peripheral driver
++ * must properly recognize that while the device request had a non-zero
++ * wLength field, there is currently no queued urb.
++ *
++ * When the bottom half handler is scheduled the HID report urb will be
++ * queued on endpoint zero and then returned to the host.
++ *
++ *
++ * @ingroup MouseFunction
++ */
++
++#include <linux/config.h>
++#include <otg/otg-compat.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++
++#include "mouse.h"
++
++struct mouse_private mouse_private;
++
++/*
++ * ep0 testing.... ensure that this is exactly 16 bytes
++ */
++#undef CONFIG_OTG_MOUSE_PRODUCT_NAME
++#define CONFIG_OTG_MOUSE_PRODUCT_NAME "Belcarra Mouse"
++
++/*!
++ * @name Mouse Descriptors
++ *
++ * MouseHIDReport
++ * MOUSE Configuration
++ *
++ * Endpoint, Class, Interface, Configuration and Device descriptors/descriptions
++ */
++
++/*!
++ * Mouse Descriptors
++ * @{
++ */
++
++#define BULK_INT 0x00 /*!< Interrupt endpoint number */
++#define ENDPOINTS 0x01 /*!< Number of endpoints required */
++
++/*! List of required endpoint numbers
++ */
++static u8 mouse_indexes[] = { BULK_INT, };
++
++/*! List of requested endpoints
++ */
++static struct usbd_endpoint_request mouse_endpoint_requests[ENDPOINTS+1] = {
++ { 1, 0, 0, USB_DIR_IN | USB_ENDPOINT_INTERRUPT, 16, 64, },
++ { 0, },
++};
++
++/*! This is the HID report returned for the HID Device Request.
++ * There is no pre-defined descriptor type for this.
++ */
++static 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 */
++};
++
++#if !defined(OTG_C99)
++/*! This is the interrupt endpoint descriptor.
++ */
++static struct usbd_endpoint_descriptor mouse_data;
++
++/*! The list of endpoint descriptors
++ */
++static struct usbd_endpoint_descriptor *mouse_default[] = { &mouse_data, };
++
++
++/*! This is the HID desccriptor.
++ */
++struct hid_descriptor mouse_hid;
++
++/*! List of class descriptors
++ */
++static struct usbd_generic_class_descriptor *mouse_hid_descriptors[] = {
++ (struct usbd_generic_class_descriptor *)&mouse_hid, };
++
++
++/*! Data Interface Alternate description
++ */
++static struct usbd_interface_descriptor mouse_data_alternate_descriptor;
++
++/*! Interface Descriptions
++ */
++static struct usbd_alternate_description mouse_data_alternate_descriptions[1];
++
++/*! List of Interface description(s)
++ */
++static struct usbd_interface_description mouse_interfaces[1];
++
++/*! Configuration description(s)
++ */
++static struct usbd_configuration_descriptor mouse_configuration_descriptor;
++
++/*! Mouse Configuration Description
++ */
++struct usbd_configuration_description mouse_configuration_description[1];
++
++/*! Device Description
++ */
++static struct usbd_device_descriptor mouse_device_descriptor;
++
++#ifdef CONFIG_OTG_HIGH_SPEED
++/*! High Speed Device Description
++ */
++static struct usbd_device_qualifier_descriptor mouse_device_qualifier_descriptor;
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++/*! OTG Descriptor
++ */
++static struct usbd_otg_descriptor mouse_otg_descriptor;
++
++/*! Device Description
++ */
++struct usbd_device_description mouse_device_description;
++
++void mouse_global_init(void)
++{
++
++ /*! This is the interrupt endpoint descriptor.
++ */
++ ZERO(mouse_data);
++ mouse_data.bLength = 0x07;
++ mouse_data.bDescriptorType = USB_DT_ENDPOINT;
++ mouse_data.bEndpointAddress = USB_DIR_IN;
++ mouse_data.bmAttributes = INTERRUPT;
++ mouse_data.wMaxPacketSize = __constant_cpu_to_le16(0x10);
++#if defined (CONFIG_OTG_MOUSE_INTERVAL)
++ mouse_data.bInterval = CONFIG_OTG_MOUSE_INTERVAL;
++#else
++ mouse_data.bInterval = 0x01;
++#endif /* defined (CONFIG_OTG_MOUSE_INTERVAL) */
++
++
++ /*! This is the HID desccriptor.
++ */
++ ZERO(mouse_hid);
++ mouse_hid.bLength = 0x09;
++ mouse_hid.bDescriptorType = 0x21;
++ mouse_hid.bcdHID = __constant_cpu_to_le16(0x110);
++ mouse_hid.bCountryCode = 0x00;
++ mouse_hid.bNumDescriptors = 0x01;
++ mouse_hid.bReportType = 0x22;
++ mouse_hid.wItemLength = __constant_cpu_to_le16(0x34);
++
++
++ /*! Data Interface Alternate description
++ */
++ ZERO(mouse_data_alternate_descriptor);
++ mouse_data_alternate_descriptor.bLength = 0x09;
++ mouse_data_alternate_descriptor.bDescriptorType = USB_DT_INTERFACE;
++ mouse_data_alternate_descriptor.bInterfaceNumber = 0x00;
++ mouse_data_alternate_descriptor.bAlternateSetting = 0x00;
++ mouse_data_alternate_descriptor.bNumEndpoints = sizeof (mouse_default) / sizeof(struct usbd_endpoint_descriptor);
++ mouse_data_alternate_descriptor.bInterfaceClass = 0x03;
++ mouse_data_alternate_descriptor.bInterfaceSubClass = 0x01;
++ mouse_data_alternate_descriptor.bInterfaceProtocol = 0x02;
++ mouse_data_alternate_descriptor.iInterface = 0x00;
++
++ /*! Interface Descriptions
++ */
++ ZERO(mouse_data_alternate_descriptions);
++ mouse_data_alternate_descriptions[0].iInterface = "Random Mouse Interface - Interrupt";
++ mouse_data_alternate_descriptions[0].interface_descriptor = &mouse_data_alternate_descriptor;
++ mouse_data_alternate_descriptions[0].classes =
++ sizeof (mouse_hid_descriptors) / sizeof (struct usbd_generic_class_descriptor *);
++ mouse_data_alternate_descriptions[0].class_list = mouse_hid_descriptors;
++ mouse_data_alternate_descriptions[0].endpoints = sizeof (mouse_default) / sizeof(struct usbd_endpoint_descriptor *);
++ mouse_data_alternate_descriptions[0].endpoint_list = mouse_default;
++ mouse_data_alternate_descriptions[0].endpoint_indexes = mouse_indexes;
++
++ /*! List of Interface description(s)
++ */
++ ZERO(mouse_interfaces);
++ mouse_interfaces[0].alternates = sizeof (mouse_data_alternate_descriptions) / sizeof (struct usbd_alternate_description);
++ mouse_interfaces[0].alternate_list = mouse_data_alternate_descriptions;
++
++
++ /*! Configuration description(s)
++ */
++ ZERO(mouse_configuration_descriptor);
++ mouse_configuration_descriptor.bLength = 0x09;
++ mouse_configuration_descriptor.bDescriptorType = USB_DT_CONFIGURATION;
++ mouse_configuration_descriptor.wTotalLength = 0x00;
++ mouse_configuration_descriptor.bNumInterfaces = sizeof (mouse_interfaces) / sizeof (struct usbd_interface_description);
++ mouse_configuration_descriptor.bConfigurationValue = 0x01;
++ mouse_configuration_descriptor.iConfiguration = 0x00;
++ mouse_configuration_descriptor.bmAttributes = 0;
++ mouse_configuration_descriptor.bMaxPower = 0;
++
++ /*! Mouse Configuration Description
++ */
++ ZERO(mouse_configuration_description);
++ mouse_configuration_description[0].configuration_descriptor = &mouse_configuration_descriptor;
++ mouse_configuration_description[0].iConfiguration = "USB Random Mouse Configuration";
++ mouse_configuration_description[0].bNumInterfaces =
++ sizeof (mouse_interfaces) / sizeof (struct usbd_interface_description);
++ mouse_configuration_description[0].interface_list = mouse_interfaces;
++
++ /*! Device Description
++ */
++ ZERO(mouse_device_descriptor);
++ mouse_device_descriptor.bLength = sizeof(struct usbd_device_descriptor);
++ mouse_device_descriptor.bDescriptorType = USB_DT_DEVICE;
++ mouse_device_descriptor.bcdUSB = __constant_cpu_to_le16(USB_BCD_VERSION);
++ mouse_device_descriptor.bDeviceClass = 0x00;
++ mouse_device_descriptor.bDeviceSubClass = 0x00;
++ mouse_device_descriptor.bDeviceProtocol = 0x00;
++ mouse_device_descriptor.bMaxPacketSize0 = 0x00;
++ mouse_device_descriptor.idVendor = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_VENDORID);
++ mouse_device_descriptor.idProduct = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_PRODUCTID);
++ mouse_device_descriptor.bcdDevice = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_BCDDEVICE);
++
++#ifdef CONFIG_OTG_HIGH_SPEED
++ /*! High Speed Device Description
++ */
++ ZERO(mouse_device_qualifier_descriptor);
++ mouse_device_qualifier_descriptor.bLength = sizeof(struct usbd_device_qualifier_descriptor);
++ mouse_device_qualifier_descriptor.bDescriptorType = USB_DT_DEVICE_QUALIFIER;
++ mouse_device_qualifier_descriptor.bcdUSB = __constant_cpu_to_le16(USB_BCD_VERSION);
++ mouse_device_qualifier_descriptor.bDeviceClass = 0x00;
++ mouse_device_qualifier_descriptor.bDeviceSubClass = 0x00;
++ mouse_device_qualifier_descriptor.bDeviceProtocol = 0x00;
++ mouse_device_qualifier_descriptor.bMaxPacketSize0 = 0x00;
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++ /*! OTG Descriptor
++ */
++ ZERO(mouse_otg_descriptor);
++ mouse_otg_descriptor.bLength = sizeof(struct usbd_otg_descriptor);
++ mouse_otg_descriptor.bDescriptorType = USB_DT_OTG;
++ mouse_otg_descriptor.bmAttributes = 0;
++
++ /*! Device Description
++ */
++ ZERO(mouse_device_description);
++ mouse_device_description.device_descriptor = &mouse_device_descriptor;
++#ifdef CONFIG_OTG_HIGH_SPEED
++ mouse_device_description.device_qualifier_descriptor = &mouse_device_qualifier_descriptor;
++#endif /* CONFIG_OTG_HIGH_SPEED */
++ mouse_device_description.otg_descriptor = &mouse_otg_descriptor;
++ mouse_device_description.iManufacturer = CONFIG_OTG_MOUSE_MANUFACTURER;
++ mouse_device_description.iProduct = CONFIG_OTG_MOUSE_PRODUCT_NAME;
++#if !defined(CONFIG_OTG_NO_SERIAL_NUMBER) && defined(CONFIG_OTG_SERIAL_NUMBER_STR)
++ mouse_device_description.iSerialNumber = CONFIG_OTG_SERIAL_NUMBER_STR;
++#endif
++}
++
++#else /* defined(OTG_C99) */
++
++/*! This is the interrupt endpoint descriptor.
++ */
++static struct usbd_endpoint_descriptor mouse_data = {
++ .bLength = 0x07,
++ .bDescriptorType = USB_DT_ENDPOINT,
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = INTERRUPT,
++ .wMaxPacketSize = __constant_cpu_to_le16(0x10),
++#if defined (CONFIG_OTG_MOUSE_INTERVAL)
++ .bInterval = CONFIG_OTG_MOUSE_INTERVAL,
++#else
++ .bInterval = 0x01,
++#endif /* defined (CONFIG_OTG_MOUSE_INTERVAL) */
++};
++
++/*! The list of endpoint descriptors
++ */
++static struct usbd_endpoint_descriptor *mouse_default[] = { &mouse_data, };
++
++/*! This is the HID desccriptor.
++ */
++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),
++};
++
++/*! List of class descriptors
++ */
++static struct usbd_generic_class_descriptor *mouse_hid_descriptors[] = {
++ (struct usbd_generic_class_descriptor *)&mouse_hid, };
++
++
++/*! Data Interface Alternate description
++ */
++static struct usbd_interface_descriptor mouse_data_alternate_descriptor = {
++ .bLength = 0x09,
++ .bDescriptorType = USB_DT_INTERFACE,
++ .bInterfaceNumber = 0x00,
++ .bAlternateSetting = 0x00,
++ .bNumEndpoints = sizeof (mouse_default) / sizeof(struct usbd_endpoint_descriptor),
++ .bInterfaceClass = 0x03,
++ .bInterfaceSubClass = 0x01,
++ .bInterfaceProtocol = 0x02,
++ .iInterface = 0x00,
++};
++
++/*! Interface Descriptions
++ */
++static struct usbd_alternate_description mouse_data_alternate_descriptions[] = {
++ { .iInterface = "Random Mouse Interface - Interrupt",
++ .interface_descriptor = &mouse_data_alternate_descriptor,
++ .classes = sizeof (mouse_hid_descriptors) / sizeof (struct usbd_generic_class_descriptor *),
++ .class_list = mouse_hid_descriptors,
++ .endpoints = sizeof (mouse_default) / sizeof(struct usbd_endpoint_descriptor *),
++ .endpoint_list = mouse_default,
++ .endpoint_indexes = mouse_indexes,
++ },
++};
++
++/*! List of Interface description(s)
++ */
++static struct usbd_interface_description mouse_interfaces[] = {
++ { .alternates = sizeof (mouse_data_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ .alternate_list = mouse_data_alternate_descriptions,},
++};
++
++
++/*! Configuration description(s)
++ */
++static struct usbd_configuration_descriptor mouse_configuration_descriptor = {
++ .bLength = 0x09,
++ .bDescriptorType = USB_DT_CONFIGURATION,
++ .wTotalLength = 0x00,
++ .bNumInterfaces = sizeof (mouse_interfaces) / sizeof (struct usbd_interface_description),
++ .bConfigurationValue = 0x01,
++ .iConfiguration = 0x00,
++ .bmAttributes = 0,
++ .bMaxPower = 0,
++};
++
++/*! Mouse Configuration Description
++ */
++struct usbd_configuration_description mouse_configuration_description[] = {
++ { .configuration_descriptor = &mouse_configuration_descriptor,
++ .iConfiguration = "USB Random Mouse Configuration",
++ },
++};
++
++/*! Device Description
++ */
++static struct usbd_device_descriptor mouse_device_descriptor = {
++ .bLength = sizeof(struct usbd_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_OTG_MOUSE_VENDORID),
++ .idProduct = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_PRODUCTID),
++ .bcdDevice = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_BCDDEVICE),
++};
++
++#ifdef CONFIG_OTG_HIGH_SPEED
++/*! High Speed Device Description
++ */
++static struct usbd_device_qualifier_descriptor mouse_device_qualifier_descriptor = {
++ .bLength = sizeof(struct usbd_device_qualifier_descriptor),
++ .bDescriptorType = USB_DT_DEVICE_QUALIFIER,
++ .bcdUSB = __constant_cpu_to_le16(USB_BCD_VERSION),
++ .bDeviceClass = 0x00,
++ .bDeviceSubClass = 0x00,
++ .bDeviceProtocol = 0x00,
++ .bMaxPacketSize0 = 0x00,
++};
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++/*! OTG Descriptor
++ */
++static struct usbd_otg_descriptor mouse_otg_descriptor = {
++ .bLength = sizeof(struct usbd_otg_descriptor),
++ .bDescriptorType = USB_DT_OTG,
++ .bmAttributes = 0,
++};
++
++/*! Device Description
++ */
++struct usbd_device_description mouse_device_description = {
++ .device_descriptor = &mouse_device_descriptor,
++#ifdef CONFIG_OTG_HIGH_SPEED
++ .device_qualifier_descriptor = &mouse_device_qualifier_descriptor,
++#endif /* CONFIG_OTG_HIGH_SPEED */
++ .otg_descriptor = &mouse_otg_descriptor,
++ .iManufacturer = CONFIG_OTG_MOUSE_MANUFACTURER,
++ .iProduct = CONFIG_OTG_MOUSE_PRODUCT_NAME,
++#if !defined(CONFIG_OTG_NO_SERIAL_NUMBER) && defined(CONFIG_OTG_SERIAL_NUMBER_STR)
++ .iSerialNumber = CONFIG_OTG_SERIAL_NUMBER_STR,
++#endif
++};
++#endif /* defined(OTG_C99) */
++
++
++/*! @} */
++
++static int mouse_count;
++
++/* MOUSE ***************************************************************************************** */
++/* Transmit Function *************************************************************************** */
++
++int get_xy[8] = {
++ 0, 0, 1, 1,
++ 0, 0, -1, -1,
++};
++
++/*!
++ * mouse_send() - send a mouse data urb with random data
++ * @param function
++ * @return void
++ */
++void mouse_send(struct usbd_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;
++
++ }
++ 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_start_in_urb(mouse->tx_urb);
++}
++
++/*!
++ * mouse_urb_sent() - called to indicate URB transmit finished
++ * This function is the callback function for sent urbs.
++ * It simply queues up another urb until the packets to be sent
++ * configuration parameter is reached (or forever if zero.)
++ * @param urb The urb to be sent.
++ * @param rc result
++ * @return int Return non-zero for failure.
++ */
++int mouse_urb_sent (struct usbd_urb *urb, int rc)
++{
++ struct mouse_private *mouse = &mouse_private;
++ struct usbd_function_instance *function = mouse->function;
++
++ RETURN_ZERO_IF(usbd_get_device_status(function) == USBD_CLOSING);
++ RETURN_ZERO_IF(usbd_get_device_status(function) != USBD_OK);
++ RETURN_ZERO_IF(usbd_get_device_state(function) != STATE_CONFIGURED);
++ TRACE_MSG1(MOUSE, "mouse_count: %d", mouse_count);
++ #ifdef CONFIG_OTG_MOUSE_PACKETS
++ RETURN_ZERO_IF (CONFIG_OTG_MOUSE_PACKETS && (mouse_count++ > CONFIG_OTG_MOUSE_PACKETS));
++ #endif /* CONFIG_OTG_MOUSE_PACKETS */
++ mouse_send(function); // re-send
++ return 0;
++}
++
++/* USB Device Functions ************************************************************************ */
++
++typedef enum mesg {
++ mesg_unknown,
++ mesg_configured,
++ mesg_reset,
++} mesg_t;
++mesg_t mouse_last_mesg;
++
++char * mouse_messages[3] = {
++ "",
++ "Mouse Configured",
++ "Mouse Reset",
++};
++
++void mouse_check_mesg(mesg_t curr_mesg)
++{
++ RETURN_UNLESS(mouse_last_mesg != curr_mesg);
++ mouse_last_mesg = curr_mesg;
++ otg_message(mouse_messages[curr_mesg]);
++}
++
++/*!
++ * mouse_event_handler() - process a device event
++ * This function is called to process USB Device Events.
++ *
++ * The DEVICE_CONFIGURED event causes the mouse_send() to be called
++ * to start the data flow.
++ *
++ * The DEVICE_RESET or DEVICE_DE_CONFIGURED events cause the outstanding
++ * transmit urb to be cancelled.
++ *
++ * @param function the function instance
++ * @param event the event
++ * @param data
++ * @return void
++ *
++ */
++void mouse_event_handler (struct usbd_function_instance *function, usbd_device_event_t event, int data)
++{
++ struct mouse_private *mouse = &mouse_private;
++
++ switch (event) {
++ case DEVICE_CONFIGURED:
++ TRACE_MSG0(MOUSE, "Mouse Configured");
++ mouse_check_mesg(mesg_configured);
++ mouse_count = 0;
++ 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:
++ TRACE_MSG0(MOUSE, "Mouse De-Configured");
++ mouse_check_mesg(mesg_reset);
++ BREAK_IF(!mouse->connected);
++ mouse->connected = 0;
++ if (mouse->tx_urb) {
++ usbd_free_urb (mouse->tx_urb);
++ mouse->tx_urb = NULL;
++ }
++ break;
++ default:
++ break;
++ }
++}
++
++/*! copy_report()
++ * This function copies the Mouse HID report into the provided URB.
++ * @param urb Destination
++ * @param data Source
++ * @param size Amount of data to copy.
++ * @param max_buf Size of buffer
++ * @return Non-zero if error.
++ *
++ */
++static int copy_report (struct usbd_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
++ * This is called to send the Mouse HID report.
++ */
++static int mouse_send_hid (void *data)
++{
++ struct mouse_private *mouse = &mouse_private;
++ struct usbd_function_instance *function = mouse->function;
++ struct usbd_urb *urb = usbd_alloc_urb_ep0(function, mouse->wLength, NULL);
++ int wMaxPacketSize = usbd_endpoint_zero_wMaxPacketSize(urb->function_instance, 0);
++
++ TRACE_MSG1(MOUSE, "Send Hid wLength: %d", mouse->wLength);
++ RETURN_EINVAL_IF (copy_report(urb, MouseHIDReport, sizeof(MouseHIDReport), mouse->wLength));
++ RETURN_EINVAL_UNLESS (wMaxPacketSize);
++
++ if (!(urb->actual_length % wMaxPacketSize) && (urb->actual_length < mouse->wLength))
++ urb->flags |= USBD_URB_SENDZLP;
++
++ RETURN_ZERO_IF(!usbd_start_in_urb(urb));
++ usbd_free_urb(urb);
++ return -EINVAL;
++}
++
++#ifdef CONFIG_OTG_MOUSE_BH
++/*!
++ * mouse_hid_bh() - Bottom half handler to send a HID report
++ * @param data
++ */
++static void mouse_hid_bh (void *data)
++{
++ struct usbd_function_instance *function = mouse_private.function;
++ mouse_send_hid(function);
++}
++
++/*! mouse_schedule_bh - schedule a call for mouse_hid_bh
++ * @param void
++ */
++static int mouse_schedule_bh (void)
++{
++ TRACE_MSG0(MOUSE, "Scheduling");
++ return (!schedule_task (&mouse_private.notification_bh)) ? EINVAL : 0;
++}
++#endif /* CONFIG_OTG_MOUSE_BH */
++
++/*!
++ * mouse_device_request - called to indicate urb has been received
++ * @param function
++ * @param request
++ */
++int mouse_device_request (struct usbd_function_instance *function, struct usbd_device_request *request)
++{
++ /* 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_OTG_MOUSE_BH
++ return mouse_schedule_bh();
++ #else
++ return mouse_send_hid(function);
++ #endif
++ }
++ default: break;
++ }
++ break;
++
++ default:
++ break;
++ }
++ return -EINVAL;
++}
++
++
++/*! mouse_function_enable - called by USB Device Core to enable the driver
++ * @param function The function instance for this driver to use.
++ * @return non-zero if error.
++ */
++static int mouse_function_enable (struct usbd_function_instance *function)
++{
++ struct mouse_private *mouse = &mouse_private;
++ 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;
++}
++
++/*! mouse_function_disable - called by the USB Device Core to disable the driver
++ * @param function The function instance for this driver
++ */
++static void mouse_function_disable (struct usbd_function_instance *function)
++{
++ struct mouse_private *mouse = &mouse_private;
++ mouse->function = NULL;
++ mouse->writesize = 0;
++ mouse->function = NULL;
++}
++
++/* ********************************************************************************************* */
++#if !defined(OTG_C99)
++/*! function_ops - operations table for the USB Device Core
++ */
++static struct usbd_function_operations mouse_function_ops;
++
++/*! mouse_function_driver - USB Device Core function driver definition
++ */
++struct usbd_function_driver mouse_function_driver;
++
++void mouse_ops_init(void)
++{
++ /*! function_ops - operations table for the USB Device Core
++ */
++ ZERO(mouse_function_ops);
++ mouse_function_ops.event_handler = mouse_event_handler; /*! called for each USB Device Event */
++ mouse_function_ops.device_request = mouse_device_request; /*! called for each received device request */
++ mouse_function_ops.function_enable = mouse_function_enable; /*! called to enable the function driver */
++ mouse_function_ops.function_disable = mouse_function_disable; /*! called to disable the function driver */
++
++ /*! function_driver - USB Device Core function driver definition
++ */
++ ZERO(mouse_function_driver);
++ mouse_function_driver.name = "mouse-random"; /*! driver name */
++ mouse_function_driver.fops = &mouse_function_ops; /*! operations table */
++ mouse_function_driver.device_description = &mouse_device_description; /*! mouse device description */
++ mouse_function_driver.bNumConfigurations =
++ sizeof (mouse_configuration_description) / sizeof (struct usbd_configuration_description);
++ mouse_function_driver.configuration_description =
++ mouse_configuration_description; /*! mouse configuration description */
++ mouse_function_driver.idVendor = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_VENDORID);
++ mouse_function_driver.idProduct = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_PRODUCTID);
++ mouse_function_driver.bcdDevice = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_BCDDEVICE);
++
++
++ mouse_function_driver.bNumInterfaces = sizeof (mouse_interfaces) / sizeof (struct usbd_interface_description);
++ mouse_function_driver.interface_list = mouse_interfaces;
++ mouse_function_driver.endpointsRequested = ENDPOINTS;
++ mouse_function_driver.requestedEndpoints = mouse_endpoint_requests;
++}
++#else /* defined(OTG_C99) */
++/*! function_ops - operations table for the USB Device Core
++ */
++static struct usbd_function_operations mouse_function_ops = {
++ .event_handler = mouse_event_handler, /*!< called for each USB Device Event */
++ .device_request = mouse_device_request, /*!< called for each received device request */
++ .function_enable = mouse_function_enable, /*!< called to enable the function driver */
++ .function_disable = mouse_function_disable, /*!< called to disable the function driver */
++};
++
++/*! mouse_function_driver - USB Device Core function driver definition
++ */
++struct usbd_function_driver mouse_function_driver = {
++ .name = "mouse-random", /*!< driver name */
++ .fops = &mouse_function_ops, /*!< operations table */
++ .device_description = &mouse_device_description, /*!< mouse device description */
++ .bNumConfigurations = sizeof (mouse_configuration_description) / sizeof (struct usbd_configuration_description),
++ .configuration_description = mouse_configuration_description, /*!< mouse configuration description */
++ .idVendor = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_VENDORID),
++ .idProduct = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_PRODUCTID),
++ .bcdDevice = __constant_cpu_to_le16(CONFIG_OTG_MOUSE_BCDDEVICE),
++ .bNumInterfaces = sizeof (mouse_interfaces) / sizeof (struct usbd_interface_description),
++ .interface_list = mouse_interfaces,
++ .endpointsRequested = ENDPOINTS,
++ .requestedEndpoints = mouse_endpoint_requests,
++};
++#endif /* defined(OTG_C99) */
++
+diff -uNr linux/drivers/no-otg/functions/mouse/mouse-if.c linux/drivers/otg/functions/mouse/mouse-if.c
+--- linux/drivers/no-otg/functions/mouse/mouse-if.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/mouse/mouse-if.c 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,499 @@
++/*
++ * otg/functions/mouse/mouse-if.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/functions/mouse/mouse-if.c
++ * @brief Mouse Interface Function Driver protocol implementation.
++ *
++ * This file implements the Mouse HID protocols and will generate
++ * random mouse data on the INTERRUPT endpoint.
++ *
++ * The primary purpose of this driver is to demonstrate how to
++ * implement a simple function driver and to provide a simple
++ * uni-directional driver for testing USB Device peripheral drivers.
++ *
++ * The mouse driver has several other characteristics to allow testing of
++ * other features of USB Device peripheral drivers:
++ *
++ * - ep0 ZLP handling
++ *
++ * - ep0 delayed CONTROL READ
++ *
++ * To verify that ep0 ZLP processing is being handling correctly this
++ * driver has a hard coded Product name that is returned as a 32 byte
++ * string. This forces most any implementations that have an endpoint
++ * zero packetsize of 8, 16 or 32 to send a Zero Length Packet to
++ * terminate the string transfer when the Product name is requested
++ * by the host.
++ *
++ * The delayed CONTROL READ test verifies that that USB Device peripheral
++ * drivers will correctly NAK until data is provide for device requests.
++ * This is done by (optionally) delaying the HID report via a bottom half
++ * handler. The device request returns normally and the peripheral driver
++ * must properly recognize that while the device request had a non-zero
++ * wLength field, there is currently no queued urb.
++ *
++ * When the bottom half handler is scheduled the HID report urb will be
++ * queued on endpoint zero and then returned to the host.
++ *
++ *
++ * @ingroup MouseFunction
++ */
++
++#include <linux/config.h>
++#include <otg/otg-compat.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++
++#include "mouse.h"
++
++
++/*
++ * ep0 testing.... ensure that this is exactly 16 bytes
++ */
++#undef CONFIG_OTG_MOUSE_PRODUCT_NAME
++#define CONFIG_OTG_MOUSE_PRODUCT_NAME "Belcarra Mouse"
++
++/*!
++ * @name Mouse Descriptors
++ *
++ * MouseHIDReport
++ * MOUSE Configuration
++ *
++ * Endpoint, Class, Interface, Configuration and Device descriptors/descriptions
++ */
++
++/*!
++ * Mouse Descriptors
++ * @{
++ */
++
++#define BULK_INT 0x00 /*!< Interrupt endpoint number */
++#define ENDPOINTS 0x01 /*!< Number of endpoints required */
++
++/*! List of required endpoint numbers
++ */
++static u8 mouse_indexes[] = { BULK_INT, };
++
++/*! List of requested endpoints
++ */
++static struct usbd_endpoint_request mouse_endpoint_requests[ENDPOINTS+1] = {
++ { 1, 0, 0, USB_DIR_IN | USB_ENDPOINT_INTERRUPT, 16, 64, },
++ { 0, },
++};
++
++#if !defined(OTG_C99)
++/*! This is the interrupt endpoint descriptor.
++ */
++static struct usbd_endpoint_descriptor mouse_data;
++
++/*! The list of endpoint descriptors
++ */
++static struct usbd_endpoint_descriptor *mouse_default[] = { &mouse_data, };
++
++
++/*! List of class descriptors
++ */
++static struct usbd_generic_class_descriptor *mouse_hid_descriptors[] = {
++ (struct usbd_generic_class_descriptor *)&mouse_hid, };
++
++
++/*! Data Interface Alternate description
++ */
++static struct usbd_interface_descriptor mouse_data_alternate_descriptor;
++
++/*! Interface Descriptions
++ */
++static struct usbd_alternate_description mouse_data_alternate_descriptions[1];
++
++/*! List of Interface description(s)
++ */
++static struct usbd_interface_description mouse_interfaces[1];
++
++
++void mouse_if_global_init(void)
++{
++
++ /*! This is the interrupt endpoint descriptor.
++ */
++ ZERO(mouse_data);
++ mouse_data.bLength = 0x07;
++ mouse_data.bDescriptorType = USB_DT_ENDPOINT;
++ mouse_data.bEndpointAddress = USB_DIR_IN;
++ mouse_data.bmAttributes = INTERRUPT;
++ mouse_data.wMaxPacketSize = __constant_cpu_to_le16(0x10);
++#if defined (CONFIG_OTG_MOUSE_INTERVAL)
++ mouse_data.bInterval = CONFIG_OTG_MOUSE_INTERVAL;
++#else
++ mouse_data.bInterval = 0x01;
++#endif /* defined (CONFIG_OTG_MOUSE_INTERVAL) */
++
++
++ /*! Data Interface Alternate description
++ */
++ ZERO(mouse_data_alternate_descriptor);
++ mouse_data_alternate_descriptor.bLength = 0x09;
++ mouse_data_alternate_descriptor.bDescriptorType = USB_DT_INTERFACE;
++ mouse_data_alternate_descriptor.bInterfaceNumber = 0x00;
++ mouse_data_alternate_descriptor.bAlternateSetting = 0x00;
++ mouse_data_alternate_descriptor.bNumEndpoints = sizeof (mouse_default) / sizeof(struct usbd_endpoint_descriptor);
++ mouse_data_alternate_descriptor.bInterfaceClass = 0x03;
++ mouse_data_alternate_descriptor.bInterfaceSubClass = 0x01;
++ mouse_data_alternate_descriptor.bInterfaceProtocol = 0x02;
++ mouse_data_alternate_descriptor.iInterface = 0x00;
++
++ /*! Interface Descriptions
++ */
++ ZERO(mouse_data_alternate_descriptions);
++ mouse_data_alternate_descriptions[0].iInterface = "Random Mouse Interface - Interrupt";
++ mouse_data_alternate_descriptions[0].interface_descriptor = &mouse_data_alternate_descriptor;
++ mouse_data_alternate_descriptions[0].classes =
++ sizeof (mouse_hid_descriptors) / sizeof (struct usbd_generic_class_descriptor *);
++ mouse_data_alternate_descriptions[0].class_list = mouse_hid_descriptors;
++ mouse_data_alternate_descriptions[0].endpoints = sizeof (mouse_default) / sizeof(struct usbd_endpoint_descriptor *);
++ mouse_data_alternate_descriptions[0].endpoint_list = mouse_default;
++ mouse_data_alternate_descriptions[0].endpoint_indexes = mouse_indexes;
++
++ /*! List of Interface description(s)
++ */
++ ZERO(mouse_interfaces);
++ mouse_interfaces[0].alternates = sizeof (mouse_data_alternate_descriptions) / sizeof (struct usbd_alternate_description);
++ mouse_interfaces[0].alternate_list = mouse_data_alternate_descriptions;
++
++
++#else /* defined(OTG_C99) */
++
++/*! This is the interrupt endpoint descriptor.
++ */
++static struct usbd_endpoint_descriptor mouse_data = {
++ .bLength = 0x07,
++ .bDescriptorType = USB_DT_ENDPOINT,
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = INTERRUPT,
++ .wMaxPacketSize = __constant_cpu_to_le16(0x10),
++#if defined (CONFIG_OTG_MOUSE_INTERVAL)
++ .bInterval = CONFIG_OTG_MOUSE_INTERVAL,
++#else
++ .bInterval = 0x01,
++#endif /* defined (CONFIG_OTG_MOUSE_INTERVAL) */
++};
++
++/*! The list of endpoint descriptors
++ */
++static struct usbd_endpoint_descriptor *mouse_default[] = { &mouse_data, };
++
++
++/*! List of class descriptors
++ */
++static struct usbd_generic_class_descriptor *mouse_hid_descriptors[] = {
++ (struct usbd_generic_class_descriptor *)&mouse_hid, };
++
++
++/*! Data Interface Alternate description
++ */
++static struct usbd_interface_descriptor mouse_data_alternate_descriptor = {
++ .bLength = 0x09,
++ .bDescriptorType = USB_DT_INTERFACE,
++ .bInterfaceNumber = 0x00,
++ .bAlternateSetting = 0x00,
++ .bNumEndpoints = sizeof (mouse_default) / sizeof(struct usbd_endpoint_descriptor),
++ .bInterfaceClass = 0x03,
++ .bInterfaceSubClass = 0x01,
++ .bInterfaceProtocol = 0x02,
++ .iInterface = 0x00,
++};
++
++/*! Interface Descriptions
++ */
++static struct usbd_alternate_description mouse_data_alternate_descriptions[] = {
++ { .iInterface = "Random Mouse Interface - Interrupt",
++ .interface_descriptor = &mouse_data_alternate_descriptor,
++ .classes = sizeof (mouse_hid_descriptors) / sizeof (struct usbd_generic_class_descriptor *),
++ .class_list = mouse_hid_descriptors,
++ .endpoints = sizeof (mouse_default) / sizeof(struct usbd_endpoint_descriptor *),
++ .endpoint_list = mouse_default,
++ .endpoint_indexes = mouse_indexes,
++ },
++};
++
++/*! List of Interface description(s)
++ */
++static struct usbd_interface_description mouse_interfaces[] = {
++ { .alternates = sizeof (mouse_data_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ .alternate_list = mouse_data_alternate_descriptions,},
++};
++
++#endif /* defined(OTG_C99) */
++
++/*! @} */
++
++static int mouse_count;
++
++/* MOUSE ***************************************************************************************** */
++/* Transmit Function *************************************************************************** */
++
++int get_xy[8] = {
++ 0, 0, 1, 1,
++ 0, 0, -1, -1,
++};
++
++/*!
++ * mouse_send() - send a mouse data urb with random data
++ * @param function
++ * @return void
++ */
++void mouse_send(struct usbd_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;
++
++ }
++ 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_start_in_urb(mouse->tx_urb);
++}
++
++/*!
++ * mouse_urb_sent() - called to indicate URB transmit finished
++ * This function is the callback function for sent urbs.
++ * It simply queues up another urb until the packets to be sent
++ * configuration parameter is reached (or forever if zero.)
++ * @param urb The urb to be sent.
++ * @param rc result
++ * @return int Return non-zero for failure.
++ */
++int mouse_urb_sent (struct usbd_urb *urb, int rc)
++{
++ struct mouse_private *mouse = &mouse_private;
++ struct usbd_function_instance *function = mouse->function;
++
++ RETURN_ZERO_IF(usbd_get_device_status(function) == USBD_CLOSING);
++ RETURN_ZERO_IF(usbd_get_device_status(function) != USBD_OK);
++ RETURN_ZERO_IF(usbd_get_device_state(function) != STATE_CONFIGURED);
++ TRACE_MSG1(MOUSE, "mouse_count: %d", mouse_count);
++ #ifdef CONFIG_OTG_MOUSE_PACKETS
++ RETURN_ZERO_IF (CONFIG_OTG_MOUSE_PACKETS && (mouse_count++ > CONFIG_OTG_MOUSE_PACKETS));
++ #endif /* CONFIG_OTG_MOUSE_PACKETS */
++ mouse_send(function); // re-send
++ return 0;
++}
++
++/* USB Device Functions ************************************************************************ */
++
++typedef enum mesg {
++ mesg_unknown,
++ mesg_configured,
++ mesg_reset,
++} mesg_t;
++static mesg_t mouse_last_mesg;
++
++static char * mouse_messages[3] = {
++ "",
++ "Mouse-if Configured",
++ "Mouse-if Reset",
++};
++
++static void mouse_check_mesg(mesg_t curr_mesg)
++{
++ RETURN_UNLESS(mouse_last_mesg != curr_mesg);
++ mouse_last_mesg = curr_mesg;
++ otg_message(mouse_messages[curr_mesg]);
++}
++
++/*!
++ * mouse_event_handler() - process a device event
++ * This function is called to process USB Device Events.
++ *
++ * The DEVICE_CONFIGURED event causes the mouse_send() to be called
++ * to start the data flow.
++ *
++ * The DEVICE_RESET or DEVICE_DE_CONFIGURED events cause the outstanding
++ * transmit urb to be cancelled.
++ *
++ * @param function the function instance
++ * @param event the event
++ * @param data
++ * @return void
++ *
++ */
++static void mouse_event_handler (struct usbd_function_instance *function, usbd_device_event_t event, int data)
++{
++ struct mouse_private *mouse = &mouse_private;
++
++ switch (event) {
++ case DEVICE_CONFIGURED:
++ TRACE_MSG0(MOUSE, "Mouse-if Configured");
++ mouse_check_mesg(mesg_configured);
++ mouse_count = 0;
++ 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:
++ TRACE_MSG0(MOUSE, "Mouse-if De-Configured");
++ mouse_check_mesg(mesg_reset);
++ BREAK_IF(!mouse->connected);
++ mouse->connected = 0;
++ if (mouse->tx_urb) {
++ usbd_free_urb (mouse->tx_urb);
++ mouse->tx_urb = NULL;
++ }
++ break;
++ default:
++ break;
++ }
++}
++
++#ifdef CONFIG_OTG_MOUSE_BH
++/*!
++ * mouse_hid_bh() - Bottom half handler to send a HID report
++ * @param data
++ */
++static void mouse_hid_bh (void *data)
++{
++ struct usbd_function_instance *function = mouse_private.function;
++ mouse_send_hid(function);
++}
++
++/*! mouse_schedule_bh - schedule a call for mouse_hid_bh
++ * @param void
++ */
++static int mouse_schedule_bh (void)
++{
++ TRACE_MSG0(MOUSE, "Scheduling");
++ return (!schedule_task (&mouse_private.notification_bh)) ? EINVAL : 0;
++}
++#endif /* CONFIG_OTG_MOUSE_BH */
++
++/*!
++ * mouse_device_request - called to indicate urb has been received
++ * @param function
++ * @param request
++ */
++static int mouse_device_request (struct usbd_function_instance *function, struct usbd_device_request *request)
++{
++ return -EINVAL;
++}
++
++
++/*! mouse_function_enable - called by USB Device Core to enable the driver
++ * @param function The function instance for this driver to use.
++ * @return non-zero if error.
++ */
++static int mouse_function_enable (struct usbd_function_instance *function)
++{
++ struct mouse_private *mouse = &mouse_private;
++ 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;
++}
++
++/*! mouse_function_disable - called by the USB Device Core to disable the driver
++ * @param function The function instance for this driver
++ */
++static void mouse_function_disable (struct usbd_function_instance *function)
++{
++ struct mouse_private *mouse = &mouse_private;
++ mouse->function = NULL;
++ mouse->writesize = 0;
++ mouse->function = NULL;
++}
++
++/* ********************************************************************************************* */
++#if !defined(OTG_C99)
++/*! function_ops - operations table for the USB Device Core
++ */
++static struct usbd_function_operations mouse_function_ops;
++
++/*! mouse_interfacedriver - USB Device Core function driver definition
++ */
++struct usbd_function_driver mouse_interfacedriver;
++
++void mouse_if_ops_init(void)
++{
++ /*! function_ops - operations table for the USB Device Core
++ */
++ ZERO(mouse_function_ops);
++ mouse_function_ops.event_handler = mouse_event_handler; /*! called for each USB Device Event */
++ mouse_function_ops.device_request = mouse_device_request; /*! called for each received device request */
++ mouse_function_ops.function_enable = mouse_function_enable; /*! called to enable the function driver */
++ mouse_function_ops.function_disable = mouse_function_disable; /*! called to disable the function driver */
++
++ /*! function_driver - USB Device Core function driver definition
++ */
++ ZERO(mouse_interfacedriver);
++ mouse_interface_driver.name = "mouse-random-if-driver-noc99"; /*! driver name */
++ mouse_interface_driver.fops = &mouse_function_ops; /*! operations table */
++
++ mouse_function_driver.bNumInterfaces = sizeof (mouse_interfaces) / sizeof (struct usbd_interface_description);
++ mouse_function_driver.interface_list = mouse_interfaces;
++ mouse_interface_driver.endpointsRequested = ENDPOINTS;
++ mouse_interface_driver.requestedEndpoints = mouse_endpoint_requests;
++
++}
++#else /* defined(OTG_C99) */
++/*! function_ops - operations table for the USB Device Core
++ */
++static struct usbd_function_operations mouse_function_ops = {
++ .event_handler = mouse_event_handler, /*!< called for each USB Device Event */
++ .device_request = mouse_device_request, /*!< called for each received device request */
++ .function_enable = mouse_function_enable, /*!< called to enable the function driver */
++ .function_disable = mouse_function_disable, /*!< called to disable the function driver */
++};
++
++/*! mouse_interface_driver - USB Device Core function driver definition
++ */
++struct usbd_function_driver mouse_interface_driver = {
++ .name = "mouse-random-if-driver", /*!< driver name */
++ .fops = &mouse_function_ops, /*!< operations table */
++ .endpointsRequested = ENDPOINTS,
++ .requestedEndpoints = mouse_endpoint_requests,
++};
++#endif /* defined(OTG_C99) */
++
+diff -uNr linux/drivers/no-otg/functions/mouse/mouse-l24.c linux/drivers/otg/functions/mouse/mouse-l24.c
+--- linux/drivers/no-otg/functions/mouse/mouse-l24.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/mouse/mouse-l24.c 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,175 @@
++/*
++ * otg/functions/mouse/mouse-l24.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/functions/mouse/mouse-l24.c
++ * @brief Mouse Function Driver Linux 2.4 initialization
++ *
++ *
++ * This file contains the Linux 2.4 module init and exit functions
++ * to load and unload the Random Mouse Function.
++ *
++ * Notes
++ *
++ * This driver does not export any upper edge functionality to
++ * for the user or applications to use. It simply sends a configurable
++ * number of data packets to the USB Host when configured. Each data
++ * packet contains the equivalent of a small mouse report which will
++ * cause the mouse cursor to move on the host.
++ *
++ * 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.
++ *
++ *
++ * 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_OTG_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_device_request() 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.
++ *
++ * 3. The CONFIG_OTG_MOUSE_PACKETS option is used to set the number of
++ * mouse data reports to send. Set to zero for a continous stream
++ * of data.
++ *
++ * @ingroup MouseFunction
++ */
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/otg-trace.h>
++
++#include "mouse.h"
++
++
++/* Module Parameters ******************************************************** */
++/* !
++ * @name XXXXX MODULE Parameters
++ */
++/* ! @{ */
++
++MOD_AUTHOR ("sl@belcarra.com, tbr@belcarra.com");
++EMBED_LICENSE();
++MOD_DESCRIPTION ("Belcarra Random Walk MOUSE Function");
++
++static u32 vendor_id; /*!< override built-in vendor ID */
++static u32 product_id; /*!< override built-in product ID */
++
++MOD_PARM (vendor_id, "i");
++MOD_PARM (product_id, "i");
++
++MOD_PARM_DESC (vendor_id, "Device Vendor ID");
++MOD_PARM_DESC (product_id, "Device Product ID");
++
++otg_tag_t MOUSE;
++/* ! *} */
++
++/* USB Module init/exit ***************************************************** */
++
++/*!
++ * mouse_modinit() - module init
++ *
++ * This is called by the Linux kernel; either when the module is loaded
++ * if compiled as a module, or during the system intialization if the
++ * driver is linked into the kernel.
++ *
++ * This function will parse module parameters if required and then register
++ * the mouse driver with the USB Device software.
++ *
++ * If the CONFIG_OTG_MOUSE_BH option is enabled it will also setup the mouse
++ * bottom half handler.
++ *
++ */
++static int mouse_modinit (void)
++{
++ struct usbd_function_instance *mfi;
++ printk (KERN_INFO "%s: vendor_id: %04x product_id: %04x\n", __FUNCTION__, vendor_id, product_id);
++
++ #if !defined(OTG_C99)
++ mouse_global_init();
++ mouse_ops_init();
++ #endif /* defined(OTG_C99) */
++
++ MOUSE = otg_trace_obtain_tag();
++ TRACE_MSG2(MOUSE, "vendor_id: %04x product_id: %04x",vendor_id, product_id);
++
++ if (vendor_id)
++ mouse_function_driver.idVendor = cpu_to_le16(vendor_id);
++ if (product_id)
++ mouse_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_UNLESS ((mouse_private.function = usbd_register_function (&mouse_function_driver, "mouse", NULL)), error);
++ #ifdef CONFIG_OTG_MOUSE_BH
++ mouse_private.notification_bh.routine = mouse_hid_bh;
++ mouse_private.notification_bh.data = NULL;
++ #endif
++ CATCH(error) {
++ if (mouse_private.function) {
++ usbd_deregister_function (mouse_private.function);
++ mouse_private.function = NULL;
++ }
++ otg_trace_invalidate_tag(MOUSE);
++ return -EINVAL;
++ }
++ return 0;
++}
++
++module_init (mouse_modinit);
++
++#if OTG_EPILOGUE
++/*!
++ * mouse_modexit() - module init
++ *
++ * This is called by the Linux kernel; when the module is being unloaded
++ * if compiled as a module. This function is never called if the
++ * driver is linked into the kernel.
++ *
++ * @param void
++ * @return void
++ */
++static void mouse_modexit (void)
++{
++ #ifdef CONFIG_OTG_MOUSE_BH
++ while (PENDING_WORK_ITEM(mouse_private.notification_bh)) {
++ printk(KERN_ERR"%s: waiting for bh\n", __FUNCTION__);
++ schedule_timeout(10 * HZ);
++ }
++ #endif
++ if (mouse_private.function) {
++ usbd_deregister_function (mouse_private.function);
++ mouse_private.function = NULL;
++ }
++
++ otg_trace_invalidate_tag(MOUSE);
++}
++
++module_exit (mouse_modexit);
++#endif
++
+diff -uNr linux/drivers/no-otg/functions/mouse/mouse.h linux/drivers/otg/functions/mouse/mouse.h
+--- linux/drivers/no-otg/functions/mouse/mouse.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/mouse/mouse.h 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,63 @@
++/*
++ * otg/functions/mouse/mouse.h
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++
++/*!
++ * @defgroup MouseFunction Random Mouse
++ * @ingroup functiongroup
++ */
++/*!
++ * @file otg/functions/mouse/mouse.h
++ * @brief Mouse Function Driver private defines
++ *
++ *
++ * This is a test USB HID Function Driver designed to test and
++ * verify that INTERRUPT IN endpoints work properly.
++ *
++ *
++ * @ingroup MouseFunction
++ */
++
++
++/*!
++ * The mouse_private structure is used to collect all of the mouse driver
++ * global variables into one place.
++ */
++struct mouse_private {
++ struct usbd_function_instance *function; /*!< function instance for this module */
++#ifdef CONFIG_OTG_MOUSE_BH
++ struct WORK_STRUCT notification_bh;
++#endif /* CONFIG_OTG_MOUSE_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 usbd_urb *tx_urb; /*!< saved copy of current tx urb */
++ int wLength;
++ int x;
++ int y;
++ int last_x;
++ int last_y;
++ int n;
++};
++
++extern struct mouse_private mouse_private;
++extern struct usbd_function_driver mouse_function_driver;
++extern struct usbd_function_driver mouse_interface_driver;
++extern struct usbd_function_driver mouse_composite_driver;
++extern struct hid_descriptor mouse_hid;
++
++#ifndef OTG_C99
++extern void mouse_global_init(void);
++#endif /* OTG_C99 */
++
++#define MOUSE mouse_trace_tag
++extern otg_tag_t MOUSE;
++
+diff -uNr linux/drivers/no-otg/functions/msc/Config.in linux/drivers/otg/functions/msc/Config.in
+--- linux/drivers/no-otg/functions/msc/Config.in 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/Config.in 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,25 @@
++#
++# Mass Storage Class Function Drivers
++#
++# Copyright (C) 2003 Belcarra
++#
++
++
++mainmenu_option next_comment
++
++comment "Mass Storage Function "
++dep_tristate ' Mass Storage Function' CONFIG_OTG_MSC $CONFIG_OTG
++
++if [ "$CONFIG_OTG_MSC" = "y" -o "$CONFIG_OTG_MSC" = "m" ]; then
++ hex 'VendorID (hex value)' CONFIG_OTG_MSC_VENDORID "15ec"
++ hex 'ProductID (hex value)' CONFIG_OTG_MSC_PRODUCTID "f006"
++ hex 'bcdDevice (binary-coded decimal)' CONFIG_OTG_MSC_BCDDEVICE "0100"
++
++ string 'iManufacturer (string)' CONFIG_OTG_MSC_MANUFACTURER "Belcarra"
++ string 'iProduct (string)' CONFIG_OTG_MSC_PRODUCT_NAME "Mass Storage Class - Bulk Only"
++ string 'MSC Bulk Only iInterface (string)' CONFIG_OTG_MSC_INTF "MSC BO Data Intf"
++ string 'Data Interface iConfiguration (string)' CONFIG_OTG_MSC_DESC "MSC BO Configuration"
++
++fi
++
++endmenu
+diff -uNr linux/drivers/no-otg/functions/msc/Kconfig linux/drivers/otg/functions/msc/Kconfig
+--- linux/drivers/no-otg/functions/msc/Kconfig 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/Kconfig 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,52 @@
++menu "OTG Mass Storage function"
++ depends on OTG
++
++config OTG_MSC
++ tristate " Mass Storage Function"
++ depends on OTG
++
++menu "OTG Mass Storage function options"
++ depends on OTG && OTG_MSC
++
++config OTG_MSC_VENDORID
++ hex "VendorID (hex value)"
++ depends on OTG && OTG_MSC
++ default "Ox15ec"
++
++config OTG_MSC_PRODUCTID
++ hex "ProductID (hex value)"
++ depends on OTG && OTG_MSC
++ default "Oxf006"
++
++config OTG_MSC_BCDDEVICE
++ hex "bcdDevice (binary-coded decimal)"
++ depends on OTG && OTG_MSC
++ default "Ox0100"
++
++config OTG_MSC_MANUFACTURER
++ string "iManufacturer (string)"
++ depends on OTG && OTG_MSC
++ default "Belcarra"
++
++config OTG_MSC_PRODUCT_NAME
++ string "iProduct (string)"
++ depends on OTG && OTG_MSC
++ default "Mass Storage Class - Bulk Only"
++
++config OTG_MSC_INTF
++ string "MSC Bulk Only iInterface (string)"
++ depends on OTG && OTG_MSC
++ default "MSC BO Data Intf"
++
++config OTG_MSC_DESC
++ string "Data Interface iConfiguration (string)"
++ depends on OTG && OTG_MSC
++ default "MSC BO Configuration"
++
++config OTG_MSC_REGISTER_TRACE
++ bool " MSC Tracing"
++ depends on OTG && OTG_MSC
++ default n
++endmenu
++
++endmenu
+diff -uNr linux/drivers/no-otg/functions/msc/Makefile linux/drivers/otg/functions/msc/Makefile
+--- linux/drivers/no-otg/functions/msc/Makefile 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/Makefile 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,68 @@
++#
++# Function driver for a Mass Storage USB Device
++#
++# Copyright (c) 2003 Belcarra
++
++# Multipart objects.
++
++O_TARGET := msc_target.o
++list-multi := msc_fd.o
++
++#msc_fd-objs := msc.o crc.o
++msc_fd-objs := msc-fd.o crc.o msc-linux.o msc-bo.o msc-io-l24.o
++
++# Objects that export symbols.
++#export-objs := msc.o
++export-objs := msc-fd.o msc-linux.o msc-bo.o
++
++# Object file lists.
++
++obj-y :=
++obj-m :=
++obj-n :=
++obj- :=
++
++# Each configuration option enables a list of files.
++
++obj-$(CONFIG_OTG_MSC) += msc_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.
++
++MSCD=$(OTG)/functions/msc
++
++OTG=$(TOPDIR)/drivers/otg
++include $(TOPDIR)/Rules.make
++EXTRA_CFLAGS += -I$(OTG) -Wno-unused -Wno-format
++EXTRA_CFLAGS_nostdinc += -I$(OTG) -Wno-unused -Wno-format
++
++# Link rules for multi-part drivers.
++
++msc_fd.o: $(msc_fd-objs)
++ $(LD) -r -o $@ $(msc_fd-objs)
++
++# dependencies:
++
++mass.o: $(USBDCORE_DIR)/usbd.h $(USBDCORE_DIR)/usbd-bus.h $(USBDCORE_DIR)/usbd-func.h
++
+diff -uNr linux/drivers/no-otg/functions/msc/TODO.txt linux/drivers/otg/functions/msc/TODO.txt
+--- linux/drivers/no-otg/functions/msc/TODO.txt 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/TODO.txt 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,118 @@
++MSC TODO List Stuart Lynne
++Belcarra Mon Oct 25 00:51:12 PDT 2004
++
++
++1. MSC documentation
++
++ - requirements and specifications
++ - comparison to mass storage specification, bulk-only and rbc
++ - implementation specifics
++ - rbc/spc commands
++ - sense keys
++ - control and usage
++
++2. PSC requirements
++
++ - notification to PSM layer for addroot and deleteroot
++
++
++3. expunge non Belcarra code and header files
++
++
++4. Insertion emulation
++
++ i. If not connected,
++ - do bdget(),
++ - do blkdev_get()
++ - set flags appropriately.
++
++ ii. If connected,
++ - ensure that there are no active requests (sleep if neccessary)
++ - do bdget()
++ - do blkdev_get()
++ - ensure that overlapped requests from the host while
++ doing the open will not cause problems
++
++5. Removal emulation
++
++ i. If not connected
++ - reset flags appropriately
++
++ ii. If connected,
++ - wait for any active requests to complete (sleep if necessary),
++ - reset flags
++ - ensure that overlapped requests from host while
++ resetting the flags will not cause problems
++ - wait for acknowledgement from host
++
++
++Note that all of the above must take place in the thread of execution of
++the ioctl call (i.e. a normal user thread or process.)
++
++The ioctl should not complete until all of the above is complete OR
++cannot complete and you return an error.
++
++
++6. ioctls
++
++Finish ioctl implementation.
++
++ start start using block device (major, minor specified)
++ stop stop using block device
++ status return current connection status
++ connect wait for connection
++ disconnect wait for dis-connection
++ connected return zero if connected, error otherwise
++ disconnected return zero if dis-connected, error otherwise
++
++
++7. tests
++
++Get the tests in the scripts directory working.
++
++These should verify the following:
++
++ 1. connect/disconnect while started/stopped
++ 2. start/stop while connected/disconnected
++
++
++Or as two matrixes:
++
++ Connected Disconnected
++ Start
++ Stop
++
++
++ Started Stopped
++ Connect
++ DisConnect
++
++
++All valid combinations of starting, stopping, connecting and disconnecting
++must be verified.
++
++
++
++8. Windows
++
++Get Windows test applicatoin working.
++
++9. Compatibility
++
++Test against:
++
++ WinXP
++ Win2k
++ Linux 2.4
++ (Linux 2.6)
++ (WinME)
++
++
++
++10. code review
++
++ - review other drivers to verify we have implemented all required
++ rbc/spc-2 commands and sense codes
++
++11. prevent removal
++
+diff -uNr linux/drivers/no-otg/functions/msc/crc.c linux/drivers/otg/functions/msc/crc.c
+--- linux/drivers/no-otg/functions/msc/crc.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/crc.c 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,74 @@
++/*
++ * otg/msc_fd/crc.c - crc table
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Chris Lynne <cl@belcarra.com>
++ * Stuart Lynne <sl@belcarra.com>
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++
++
++#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/mm.h>
++#include <linux/slab.h>
++
++#include <otg/otg-compat.h>
++
++//#include <usbd-chap9.h>
++//#include <usbd-mem.h>
++//#include <usbd.h>
++//#include <usbd-func.h>
++
++#include "crc.h"
++
++unsigned int *msc_crc32_table;
++
++/**
++ * Generate the crc32 table
++ *
++ * return non-zero if malloc fails
++ */
++int make_crc_table(void)
++{
++ unsigned int n;
++ if (msc_crc32_table) return 0;
++ if (!(msc_crc32_table = (unsigned int *)ckmalloc(256*4, GFP_KERNEL))) return -EINVAL;
++ for (n = 0; n < 256; n++) {
++ int k;
++ unsigned int c = n;
++ for (k = 0; k < 8; k++) {
++ c = (c & 1) ? (CRC32_POLY ^ (c >> 1)) : (c >> 1);
++ }
++ msc_crc32_table[n] = c;
++ }
++ return 0;
++}
++
++void free_crc_table(void)
++{
++ if (msc_crc32_table) {
++ lkfree(msc_crc32_table);
++ msc_crc32_table = NULL;
++ }
++}
++
++unsigned int crc32_compute(unsigned char *src, int len, unsigned int val)
++{
++ for (; len-- > 0; val = COMPUTE_FCS (val, *src++));
++ return val;
++}
++
+diff -uNr linux/drivers/no-otg/functions/msc/crc.h linux/drivers/otg/functions/msc/crc.h
+--- linux/drivers/no-otg/functions/msc/crc.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/crc.h 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,29 @@
++/*
++ * otg/msc_fd/crc.c - crc table
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Chris Lynne <cl@belcarra.com>
++ * Stuart Lynne <sl@belcarra.com>
++ * Bruce Balden <balden@belcarra.com>
++ * Ted Powell <ted@belcarra.com>
++ *
++ *
++ */
++
++
++extern unsigned int *msc_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) ^ msc_crc32_table[((val) ^ (c)) & 0xff])
++
++int make_crc_table(void);
++void free_crc_table(void);
++unsigned int crc32_compute(unsigned char *src, int len, unsigned int val);
++
++
+diff -uNr linux/drivers/no-otg/functions/msc/msc-bo.c linux/drivers/otg/functions/msc/msc-bo.c
+--- linux/drivers/no-otg/functions/msc/msc-bo.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/msc-bo.c 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,176 @@
++/*
++ * otg/function/msc/msc-bo.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/functions/msc/msc-bo.c
++ * @brief Mass Storage Driver private defines
++ *
++ * This is a Mass Storage Class Function that uses the Bulk Only protocol.
++ *
++ *
++ * @ingroup MSCFunction
++ */
++
++#include <otg/otg-compat.h>
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/otg-trace.h>
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++
++#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 <linux/blkdev.h>
++
++
++#include "msc-scsi.h"
++#include "msc.h"
++#include "msc-fd.h"
++#include "crc.h"
++
++//#include "rbc.h"
++
++/*!
++ * Mass Storage Class - Bulk Only
++ *
++ * Endpoint, Class, Interface, Configuration and Device descriptors/descriptions
++ */
++
++static u8 msc_data_1[] = { 0x07, USB_DT_ENDPOINT, USB_DIR_OUT, BULK, 0, 0x00, 0x00, };
++static u8 msc_data_2[] = { 0x07, USB_DT_ENDPOINT, USB_DIR_IN, BULK, 0, 0x00, 0x00, };
++static struct usbd_endpoint_descriptor *msc_default[] = {
++ (struct usbd_endpoint_descriptor *) msc_data_1,
++ (struct usbd_endpoint_descriptor *) msc_data_2, };
++u8 msc_indexes[] = { BULK_OUT, BULK_IN, };
++
++
++/*! Endpoint, Interface, Configuration and Device descriptions and descriptors
++ */
++static u8 msc_data_alternate_descriptor[sizeof(struct usbd_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE,
++ 0x00, 0x00, // bInterfaceNumber, bAlternateSetting
++ sizeof (msc_default) / sizeof(struct usbd_endpoint_descriptor), // bNumEndpoints
++ MASS_STORAGE_CLASS,
++ MASS_STORAGE_SUBCLASS_SCSI,
++ MASS_STORAGE_PROTO_BULK_ONLY,
++ 0x00,
++};
++
++static struct usbd_alternate_description msc_data_alternate_descriptions[] = {
++ { iInterface: CONFIG_OTG_MSC_INTF,
++ interface_descriptor: (struct usbd_interface_descriptor *)&msc_data_alternate_descriptor,
++ endpoints:sizeof (msc_default) / sizeof(struct usbd_endpoint_descriptor *),
++ endpoint_list: msc_default,
++ endpoint_indexes: msc_indexes,
++ },
++};
++
++
++struct usbd_interface_description msc_interfaces[] = {
++ { alternates:sizeof (msc_data_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ alternate_list:msc_data_alternate_descriptions,},
++};
++
++u8 msc_configuration_descriptor[sizeof(struct usbd_configuration_descriptor)] = {
++ 0x09, USB_DT_CONFIGURATION, 0x00, 0x00, // wLength
++ sizeof (msc_interfaces) / sizeof (struct usbd_interface_description),
++ 0x01, 0x00, // bConfigurationValue, iConfiguration
++ 0, 0,
++};
++
++struct usbd_configuration_description msc_description[] = {
++ { iConfiguration: CONFIG_OTG_MSC_DESC,
++ configuration_descriptor: (struct usbd_configuration_descriptor *)msc_configuration_descriptor,
++ },
++};
++
++
++static struct usbd_device_descriptor msc_device_descriptor = {
++ bLength: sizeof(struct usbd_device_descriptor),
++ bDescriptorType: USB_DT_DEVICE,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: 0x00,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++ idVendor: __constant_cpu_to_le16(CONFIG_OTG_MSC_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_MSC_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_MSC_BCDDEVICE),
++};
++
++#ifdef CONFIG_OTG_HIGH_SPEED
++static struct usbd_device_qualifier_descriptor msc_device_qualifier_descriptor = {
++ bLength: sizeof(struct usbd_device_qualifier_descriptor),
++ bDescriptorType: USB_DT_DEVICE_QUALIFIER,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: 0x00,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++};
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++
++
++
++static struct usbd_endpoint_request msc_endpoint_requests[ENDPOINTS+1] = {
++ { 1, 0, 0, USB_DIR_OUT | USB_ENDPOINT_BULK, PAGE_SIZE, PAGE_SIZE, },
++ { 1, 0, 0, USB_DIR_IN | USB_ENDPOINT_BULK, PAGE_SIZE, PAGE_SIZE, },
++ { 0, },
++};
++
++struct usbd_otg_descriptor msc_otg_descriptor = {
++ bLength : sizeof(struct usbd_otg_descriptor),
++ bDescriptorType: USB_DT_OTG,
++ bmAttributes: 0,
++};
++
++struct usbd_device_description msc_device_description = {
++ device_descriptor: &msc_device_descriptor,
++#ifdef CONFIG_OTG_HIGH_SPEED
++ device_qualifier_descriptor: &msc_device_qualifier_descriptor,
++#endif /* CONFIG_OTG_HIGH_SPEED */
++ otg_descriptor: &msc_otg_descriptor,
++ iManufacturer: CONFIG_OTG_MSC_MANUFACTURER,
++ iProduct: CONFIG_OTG_MSC_PRODUCT_NAME,
++#if !defined(CONFIG_OTG_NO_SERIAL_NUMBER) && defined(CONFIG_OTG_SERIAL_NUMBER_STR)
++ iSerialNumber: CONFIG_OTG_SERIAL_NUMBER_STR,
++#endif
++};
++
++
++extern struct usbd_function_operations msc_function_ops;
++
++struct usbd_function_driver msc_function_driver = {
++ name: "msc-bulkonly",
++ fops:&msc_function_ops,
++ device_description:&msc_device_description,
++ bNumConfigurations:sizeof (msc_description) / sizeof (struct usbd_configuration_description),
++ configuration_description:msc_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_OTG_MSC_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_MSC_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_MSC_BCDDEVICE),
++ bNumInterfaces:sizeof (msc_interfaces) / sizeof (struct usbd_interface_description),
++ interface_list:msc_interfaces,
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: msc_endpoint_requests,
++};
++
+diff -uNr linux/drivers/no-otg/functions/msc/msc-fd.c linux/drivers/otg/functions/msc/msc-fd.c
+--- linux/drivers/no-otg/functions/msc/msc-fd.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/msc-fd.c 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,1233 @@
++/*
++ * otg/function/msc/msc.-fd.cc
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++
++/*!
++ * @file otg/functions/msc/msc-fd.c
++ * @brief Mass Storage Driver private defines
++ *
++ * This is a Mass Storage Class Function that uses the Bulk Only protocol.
++ *
++ *
++ * Notes:
++ *
++ * 1. Currently we only support the Bulk Only model. Microsoft states that
++ * further support for the mass storage driver will only be done for devices
++ * that conform to the Bulk Only model.
++ *
++ * 2. Multiple LUN's are not supported, but in theory they could be.
++ *
++ * 3. Error handling should be done with STALL but using ZLP seems to also
++ * work. ZLP is usually easier to implement (except possibly on the SA1100.)
++ * We may need to make STALL an option if we find devices (perhaps SA1100)
++ * that cannot reliaby send a ZLP on BULK-IN endpoint.
++ *
++ *
++ * 4. WinXP will match the following:
++ *
++ * USB: Class_08&SubClass_02&Prot_50
++ * USB: Class_08&SubClass_05&Prot_50
++ * USB: Class_08&SubClass_06&Prot_50
++ *
++ * SubClass 02 is MMC or SFF8020I
++ * SubClass 05 is SFF or SFF8070I
++ * SubClass 06 is SCSI
++ *
++ * From the Windows USB Storage FAQ:
++ *
++ * RBC not supported
++ *
++ * SubClass = 6 (SCSI)
++ * CDBs SHOULD NOT be padded to 12 bytes
++ * ModeSense/ModeSelect SHOULD NOT be translated from 1ah/15h to 5ah/55h
++ * should be used for FLASH
++ *
++ * SubClass !=6
++ * CDBs SHOULD be padded to 12 bytes
++ * ModeSense/ModeSelect SHOULD be translated from 1ah/15h to 5ah/55h
++ *
++ * We are using the former, SubClass = 6, and implement the required SCSI operations.
++ *
++ *
++ * TODO
++ *
++ *
++ *
++ * TODO FIXME Bus Interface Notes
++ *
++ * 1. The bus interface driver must correctly implement NAK'ing if not rcv_urb is
++ * present (see au1x00.c or wmmx.c for examples.)
++ *
++ * 2. The bus interface driver must implement USBD_URB_SENDZLP flag (see au1x00.c
++ * for example.)
++ *
++ * @ingroup MSCFunction
++ */
++
++
++#include <otg/otg-compat.h>
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/otg-trace.h>
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++
++#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 <linux/blkdev.h>
++
++
++#include "msc-scsi.h"
++#include "msc.h"
++#include "msc-fd.h"
++#include "crc.h"
++
++
++/* Module Parameters ************************************************************************* */
++
++
++#define DEVICE_EJECTED 0x0001 // MEDIA_EJECTED
++#define DEVICE_INSERTED 0x0002 // MEDIA_INSERT
++
++#define DEVICE_OPEN 0x0004 // WR_PROTECT_OFF
++#define DEVICE_WRITE_PROTECTED 0x0008 // WR_PROTECT_ON
++
++#define DEVICE_CHANGE_ON 0x0010 // MEDIA_CHANGE_ON
++
++#define DEVICE_PREVENT_REMOVAL 0x0020
++
++
++#define DEF_NUMBER_OF_HEADS 0x10
++#define DEF_SECTORS_PER_TRACK 0x20
++
++
++
++/* MSC ******************************************************************************************** */
++
++extern struct msc_private msc_private;
++
++int msc_urb_sent (struct usbd_urb *tx_urb, int rc);
++static int msc_recv_urb (struct usbd_urb *urb, int rc);
++
++otg_tag_t msc_fd_trace_tag;
++
++/* Sense Key *********************************************************************************** */
++
++/*! set_sense_data - set sensedata in msc private struture
++ * @param msc
++ * @param sensedata
++ * @param info
++ *
++ * This saves sense data. Sense data indicates what type of error
++ * has occurred and will be returned to the host when a request sense
++ * command is sent.
++ */
++void set_sense_data(struct msc_private *msc, u32 sensedata, u32 info)
++{
++ TRACE_SENSE(sensedata, info);
++ msc->sensedata = sensedata;
++ msc->info = info;
++}
++
++/* Check blockdev ****************************************************************************** */
++
++/*! msc_check_blockdev_name - check current status of the block device
++ *
++ * Check if the block device is operational, either generate a failed CSW
++ * or a ZLP if not ready.
++ *
++ * Returns non-zero if the block device is not available for I/O operations
++ * and a failed CSW has already been sent.
++ */
++int msc_check_blockdev_name(struct msc_private *msc, int zlp, char *name)
++{
++ if (msc->block_dev_state & DEVICE_EJECTED) {
++ TRACE_MSG0(MSC,"CHECK BLOCKDEV DEVICE_EJECTED");
++ ((SENDZLP == zlp) ? msc_dispatch_query_urb_zlp : msc_start_sending_csw_failed)
++ (msc, SCSI_SENSEKEY_MEDIA_NOT_PRESENT, msc->lba, USB_MSC_FAILED);
++ return -EINVAL;
++ }
++ if (msc->block_dev_state & DEVICE_CHANGE_ON) {
++ msc->block_dev_state &= ~DEVICE_CHANGE_ON;
++ TRACE_MSG0(MSC,"CHECK BLOCKDEV DEVICE_CHANGE_ON");
++ ((SENDZLP == zlp) ? msc_dispatch_query_urb_zlp : msc_start_sending_csw_failed)
++ (msc, SCSI_SENSEKEY_NOT_READY_TO_READY_CHANGE, msc->lba, USB_MSC_FAILED);
++ return -EINVAL;
++ }
++ //TRACE_MSG0(MSC,"CHECK BLOCKDEV DEVICE_INSERTED");
++ return 0;
++}
++
++/* Generic start recv urb and send csw ********************************************************* */
++
++/*! msc_start_recv - queue a receive urb
++ *
++ * Ensure that size is a multiple of the endpoint packetsize.
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_start_recv_urb(struct usbd_function_instance *function, struct msc_private *msc, int size)
++{
++ struct usbd_urb *rcv_urb = NULL;
++ int wMaxPacketSize = usbd_endpoint_wMaxPacketSize(function, BULK_OUT, usbd_high_speed(function));
++ if ((size % wMaxPacketSize))
++ size = ((size + wMaxPacketSize) / wMaxPacketSize) * wMaxPacketSize;
++
++ RETURN_EINVAL_UNLESS((rcv_urb = usbd_alloc_urb (function, BULK_OUT, size, msc_recv_urb)));
++ rcv_urb->function_privdata = msc;
++ msc->rcv_urb_finished = NULL;
++ RETURN_ZERO_UNLESS(usbd_start_out_urb(rcv_urb));
++ TRACE_MSG0(MSC,"START RECV URB ERROR");
++ usbd_free_urb(rcv_urb);
++ return -EINVAL;
++}
++
++/*! msc_start_sending - start sending a new data or csw urb
++ *
++ * Generate a CSW (Command Status Wrapper) to send to the the host.
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_start_sending_csw(struct usbd_function_instance *function, struct msc_private *msc, u8 status)
++{
++ COMMAND_STATUS_WRAPPER *csw;
++ int length = sizeof(COMMAND_STATUS_WRAPPER);
++ struct usbd_urb *tx_urb;
++
++ //TRACE_MSG1(MSC,"START SENDING CSW %08x", status);
++
++ msc->command_state = MSC_STATUS;
++
++ RETURN_EINVAL_UNLESS((tx_urb = usbd_alloc_urb (function, BULK_IN, length, msc_urb_sent)));
++
++ tx_urb->actual_length = length;
++ tx_urb->function_privdata = msc;
++
++ // fill in CSW and queue the urb
++ csw = (COMMAND_STATUS_WRAPPER *) tx_urb->buffer;
++ csw->dCSWSignature = CSW_SIGNATURE;
++ csw->dCSWTag = msc->command.dCBWTag;
++ csw->dCSWDataResidue = msc->command.dCBWDataTransferLength - msc->data_transferred_in_bytes;
++ csw->bCSWStatus = status;
++
++ TRACE_MSG2(MSC,"START SENDING CSW status: %02x data residue: %d", status, csw->dCSWDataResidue);
++
++ RETURN_ZERO_UNLESS(usbd_start_in_urb (tx_urb));
++ TRACE_MSG0(MSC,"START SENDING CSW FAILED");
++ usbd_free_urb (tx_urb);
++ return -EINVAL;
++}
++
++/*! msc_start_sending_csw_failed - starting sending a CSW showing failure
++ *
++ * Sets sensedata and generates a CSW with status set to USB_MSC_FAILED.
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_start_sending_csw_failed(struct msc_private *msc, u32 sensedata, u32 info, int status)
++{
++ TRACE_MSG2(MSC, "sensedata: %x status: %x", sensedata, status);
++ set_sense_data(msc, sensedata, info);
++ return msc_start_sending_csw(msc->function, msc, status);
++}
++
++
++/* ********************************************************************************************* */
++
++/*! msc_alloc_urb - allocate an urb for returning a query
++ *
++ * Returns NULL if there is an error in the USB layer.
++ */
++struct usbd_urb * msc_alloc_urb(struct msc_private *msc, int length)
++{
++ struct usbd_function_instance *function;
++ struct usbd_urb *urb;
++
++ THROW_IF(!(function = msc->function), error);
++ THROW_IF(!(urb = usbd_alloc_urb (function, BULK_IN, length, msc_urb_sent)), error);
++ return urb;
++ CATCH(error) {
++ msc->command_state = MSC_READY;
++ return NULL;
++ }
++}
++
++/*! msc_dispatch_query_urb - dispatch an urb containing query data
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_dispatch_query_urb(struct usbd_urb *urb, struct msc_private *msc, int length, int status)
++{
++ int rc;
++ unsigned long flags;
++
++ TRACE_MSG1(MSC,"DISPATCH URB len: %d", length);
++
++ // save information in msc and urb
++ //
++ urb->function_privdata = msc;
++ urb->actual_length = msc->TransferLength_in_bytes = length;
++
++ // dispatch urb
++ local_irq_save(flags);
++ if ((rc = usbd_start_in_urb (urb))) {
++
++ TRACE_MSG0(MSC,"DISPATCH URB FAILED");
++ usbd_free_urb (urb);
++
++ // stall?
++ msc->command_state = MSC_READY;
++ local_irq_restore(flags);
++ return -EINVAL;
++ }
++ msc->command_state = MSC_QUERY;
++ msc->status = status;
++ local_irq_restore(flags);
++ return 0;
++}
++
++/*! msc_dispatch_query_urb_zlp - send a ZLP
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_dispatch_query_urb_zlp(struct msc_private *msc, u32 sensedata, u32 info, int status)
++{
++ struct usbd_urb *urb;
++ TRACE_MSG2(MSC, "sensedata: %x status: %x", sensedata, status);
++ RETURN_EINVAL_IF(!(urb = msc_alloc_urb(msc, 1)));
++ set_sense_data(msc, sensedata, info);
++ urb->flags |= USBD_URB_SENDZLP;
++ return msc_dispatch_query_urb(urb, msc, 0, status);
++}
++
++/* READ 10 COMMAND - read and send data to the host ******************************************** */
++extern int msc_scsi_read_10(struct msc_private *msc, char *name, int op);
++extern int msc_in_read_10_urb_sent(struct usbd_urb *tx_urb, struct msc_private *msc);
++
++/* WRITE 10 - receive data from host and write to block device ********************************* */
++extern int msc_scsi_write_10(struct msc_private *msc, char *name, int op);
++extern void msc_recv_out_blocks(struct usbd_urb *rcv_urb, struct msc_private *msc);
++
++/* SCSI Commands ******************************************************************************* */
++
++/*! msc_scsi_inquiry - process an inquiry
++ *
++ * Used by:
++ * win2k
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_inquiry(struct msc_private *msc, char *name, int op)
++{
++ SCSI_INQUIRY_COMMAND *command = (SCSI_INQUIRY_COMMAND *)&msc->command.CBWCB;
++ SCSI_INQUIRY_DATA *data;
++ struct usbd_urb *urb;
++ int length = sizeof(SCSI_INQUIRY_DATA);
++
++ /*
++ * C.f. SPC2 7.3 INQUIRY command
++ * C.f. Table 46 - Standard INQUIRY data format
++ *
++ * C.f. Table 47 - Peripheral Qualifier
++ *
++ * 000b The specified peripheral device type is currently connected to this
++ * logical unit.....
++ * 001b The device server is capable of of supporting the peripheral device
++ * type on this logical unit. However, the physical device is not currently
++ * connected to this logical unit.....
++ * 010b Reserved
++ * 011b The device server is not capable of supporting a physical device on
++ * this logical unit....
++ *
++ */
++
++ TRACE_MSG4(MSC,"INQUIRY EnableVPD: %02x LogicalUnitNumber: %02x PageCode: %02x AllocLen: %02x",
++ command->EnableVPD, command->LogicalUnitNumber, command->PageCode, command->AllocationLength);
++
++ // XXX THROW_IF(msc->command_state != MSC_READY, error);
++
++ RETURN_EINVAL_IF(!(urb = msc_alloc_urb(msc, length)));
++
++ data = (SCSI_INQUIRY_DATA *)urb->buffer;
++ data->PeripheralQaulifier = msc->block_dev_state & (DEVICE_EJECTED | DEVICE_CHANGE_ON) ? 0x1 : 0;
++ data->PeripheralDeviceType = 0x00;
++ data->RMB = 0x1;
++ data->ResponseDataFormat = 0x1;
++ data->AdditionalLength = 0x1f;
++
++ strncpy(data->VendorInformation, CONFIG_OTG_MSC_MANUFACTURER, strlen(CONFIG_OTG_MSC_MANUFACTURER));
++ strncpy(data->ProductIdentification, CONFIG_OTG_MSC_PRODUCT_NAME, strlen(CONFIG_OTG_MSC_PRODUCT_NAME));
++
++ return msc_dispatch_query_urb(urb, msc, length, USB_MSC_PASSED);
++}
++
++/*! msc_scsi_read_format_capacity - process a query
++ *
++ * Used by:
++ * win2k
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_read_format_capacity(struct msc_private *msc, char *name, int op)
++{
++ SCSI_READ_FORMAT_CAPACITY_DATA *data;
++ struct usbd_urb *urb;
++ int length = sizeof(SCSI_READ_FORMAT_CAPACITY_DATA);
++ u32 block_num = msc->capacity;
++ u32 block_len;
++
++ RETURN_EINVAL_IF(!(urb = msc_alloc_urb(msc, length)));
++
++ data = (SCSI_READ_FORMAT_CAPACITY_DATA *) urb->buffer;
++
++ data->CapacityListHeader.CapacityListLength = sizeof(data->CurrentMaximumCapacityDescriptor);
++
++ data->CurrentMaximumCapacityDescriptor.NumberofBlocks = block_num;
++ data->CurrentMaximumCapacityDescriptor.DescriptorCode = 0x03;
++ memcpy(data->CurrentMaximumCapacityDescriptor.BlockLength + 1, &block_len, sizeof(block_len));
++
++ return msc_dispatch_query_urb(urb, msc, length, USB_MSC_PASSED);
++}
++
++/*! msc_read_capacity - process a read_capacity command
++ *
++ * Used by:
++ * win2k
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_read_capacity(struct msc_private *msc, char *name, int op)
++{
++ SCSI_READ_CAPACITY_COMMAND *command = (SCSI_READ_CAPACITY_COMMAND *)&msc->command.CBWCB;
++ SCSI_READ_CAPACITY_DATA *data;
++ struct usbd_urb *urb;
++ int length = 8;
++ u32 lba;
++
++ /*
++ * C.f. RBC 5.3
++ */
++ lba = be32_to_cpu(command->LogicalBlockAddress);
++
++ TRACE_MSG1(MSC,"READ CAPACITY LBA: %d", lba);
++
++ if ((command->PMI > 1) || (!command->PMI && lba)) {
++ TRACE_MSG1(MSC,"READ CAPACITY PMI: %d", command->PMI);
++ return msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_INVALID_FIELD_IN_CDB, lba, USB_MSC_FAILED);
++ }
++
++ // alloc urb
++ RETURN_EINVAL_IF(!(urb = msc_alloc_urb(msc, length)));
++
++ data = (SCSI_READ_CAPACITY_DATA *) urb->buffer;
++
++ data->LastLogicalBlockAddress = cpu_to_be32(msc->capacity);
++ data->BlockLengthInBytes = cpu_to_be32(msc->block_size);
++
++ TRACE_MSG2(MSC,"RECV READ CAPACITY lba: %x block_size: %x",
++ be32_to_cpu(data->LastLogicalBlockAddress), be32_to_cpu(data->BlockLengthInBytes));
++
++ return msc_dispatch_query_urb(urb, msc, length, USB_MSC_PASSED);
++}
++
++
++/*! msc_scsi_request_sense - process a request_sense command
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_request_sense(struct msc_private *msc, char *name, int op)
++{
++ SCSI_REQUEST_SENSE_COMMAND* command = (SCSI_REQUEST_SENSE_COMMAND *)&msc->command.CBWCB;
++ SCSI_REQUEST_SENSE_DATA *data;
++
++ /*
++ * C.f. SPC2 7.20 REQUEST SENSE command
++ */
++
++ struct usbd_urb *urb;
++ int length = sizeof(SCSI_REQUEST_SENSE_DATA);
++
++ // alloc urb
++ RETURN_EINVAL_IF(!(urb = msc_alloc_urb(msc, length)));
++
++ data = (SCSI_REQUEST_SENSE_DATA *) urb->buffer;
++ memset(command, 0x0, length);
++ data->ErrorCode = SCSI_ERROR_CURRENT;
++ data->SenseKey = msc->sensedata >> 16;
++ data->AdditionalSenseLength = 0xa; /* XXX is this needed */
++ data->AdditionalSenseCode = msc->sensedata >> 8;
++ data->AdditionalSenseCodeQualifier = msc->sensedata;
++ data->Valid = 1;
++
++ set_sense_data(msc, SCSI_SENSEKEY_NO_SENSE, 0);
++
++ return msc_dispatch_query_urb(urb, msc, length, USB_MSC_PASSED);
++}
++
++/*! msc_scsi_mode_sense - process a request_sense command
++ *
++ * Used by:
++ * win2k
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_mode_sense(struct msc_private *msc, char *name, int op)
++{
++ SCSI_MODE_SENSE_COMMAND *command = (SCSI_MODE_SENSE_COMMAND *)&msc->command.CBWCB;
++ SCSI_MODE_SENSE_DATA *data;
++ int length = sizeof(SCSI_MODE_SENSE_DATA);
++
++ struct usbd_urb *urb;
++ u8 *cp;
++
++ TRACE_MSG4(MSC,"MODE SENSE dbd: %02x PageControl: %02x PageCode: %02x Alloc: %02x",
++ command->DBD, command->PageControl, command->PageCode, 0);
++ length = 8;
++
++ // alloc urb
++ RETURN_EINVAL_IF(!(urb = msc_alloc_urb(msc, length)));
++
++ cp = (u8 *) urb->buffer;
++ memset(cp, 0x0, length);
++
++ cp[0] = 0;
++ cp[1] = 0;
++ cp[2] = 0; // 0x80 is writeprotect
++ cp[3] = 0x08;
++ cp[4] = 0;
++ cp[5] = 0;
++ cp[6] = 0;
++ cp[7] = 0;
++
++ return msc_dispatch_query_urb(urb, msc, length, USB_MSC_PASSED);
++}
++
++/*! msc_scsi_mode_sense - process a request_sense command
++ *
++ * Used by:
++ * win2k
++ *
++ * XXX this doesn't work, need to re-implement and add these pages.
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int new_msc_scsi_mode_sense(struct msc_private *msc, char *name, int op)
++{
++
++ /*
++ * C.f. SPC2 7.8.1 MODE SENSE(6) command
++ */
++
++ static READ_WRITE_ERROR_RECOVERY_PAGE page_01 = {
++ PageCode:0x01,
++ PageLength:0x0A,
++ ReadRetryCount:0x03,
++ WriteRetryCount:0x80,
++ };
++ static FLEXIBLE_DISK_PAGE page_05 = {
++ PageCode:0x05,
++ PageLength:0x1E,
++ TransferRate:__constant_cpu_to_be16(0xFA00),
++ NumberofHeads:0xA0,
++ SectorsperTrack:0x00,
++ DataBytesperSector:__constant_cpu_to_be16(0x0002),
++ NumberofCylinders:__constant_cpu_to_be16(0x0000),
++ MotorOnDelay:0x05,
++ MotorOffDelay:0x1E,
++ MediumRotationRate:__constant_cpu_to_be16(0x6801),
++ };
++ static REMOVABLE_BLOCK_ACCESS_CAPABILITIES_PAGE page_1b = {
++ PageCode:0x1B,
++ PageLength:0x0A,
++ TLUN:0x01,
++ };
++ static TIMER_AND_PROTECT_PAGE page_1c = {
++ PageCode:0x1c,
++ PageLength:0x06,
++ InactivityTimeMultiplier:0x0A,
++ };
++
++ SCSI_MODE_SENSE_COMMAND *command = (SCSI_MODE_SENSE_COMMAND *)&msc->command.CBWCB;
++ SCSI_MODE_SENSE_DATA *data;
++ struct usbd_urb *urb;
++ int length = sizeof(SCSI_MODE_SENSE_DATA);
++
++
++ TRACE_MSG4(MSC,"MODE SENSE dbd: %02x PageControl: %02x PageCode: %02x Alloc: %02x",
++ command->DBD, command->PageControl, command->PageCode, 0);
++
++
++ if (msc->block_dev_state & DEVICE_EJECTED) {
++ u16 sector = htons((unsigned short)msc->block_size);
++ u16 cylinder = 0;
++ page_05.NumberofHeads = 0;
++ page_05.SectorsperTrack = 0;
++ memcpy(&page_05.DataBytesperSector, &sector, sizeof(sector));
++ memcpy(&page_05.NumberofCylinders, &cylinder, sizeof(cylinder));
++ }
++ else {
++ u16 sector = htons((unsigned short)msc->block_size);
++ u32 size = DEF_NUMBER_OF_HEADS * DEF_SECTORS_PER_TRACK * sector;
++ u16 cylinder = htons(msc->capacity / size);
++ page_05.NumberofHeads = DEF_NUMBER_OF_HEADS;
++ page_05.SectorsperTrack = DEF_SECTORS_PER_TRACK;
++ memcpy(&page_05.DataBytesperSector, &sector, sizeof(sector));
++ memcpy(&page_05.NumberofCylinders, &cylinder, sizeof(cylinder));
++ }
++
++ if (SCSI_MODEPAGE_CONTROL_CURRENT != command->PageControl) {
++ TRACE_MSG2(MSC,"MODE SENSE - requeested other than CONTROL_CURRENT: %d %d",
++ command->PageControl, command->PageCode);
++ return msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_INVALID_FIELD_IN_CDB, msc->lba, USB_MSC_FAILED);
++ }
++
++ RETURN_EINVAL_IF(!(urb = msc_alloc_urb(msc, length)));
++ data = (SCSI_MODE_SENSE_DATA *) urb->buffer;
++
++ data->ModeParameterHeader.WriteProtect = msc->block_dev_state & DEVICE_WRITE_PROTECTED ? 1 : 0;
++
++ switch (command->PageCode) {
++ case SCSI_MODEPAGE_ERROR_RECOVERY:
++ TRACE_MSG0(MSC, "MODEPAGE ERROR_RECOVERY");
++ length = sizeof(MODE_PARAMETER_HEADER) + sizeof(page_01);
++ data->ModeParameterHeader.ModeDataLength = length - 1;
++ memcpy(&data->ModePages, &page_01, sizeof(page_01));
++ break;
++ case SCSI_MODEPAGE_FLEXIBLE_DISK_PAGE:
++ TRACE_MSG0(MSC, "MODEPAGE FLEXIBLE_DISK_PAGE");
++ length = sizeof(MODE_PARAMETER_HEADER) + sizeof(page_05);
++ data->ModeParameterHeader.ModeDataLength = length - 1;
++ memcpy(&data->ModePages, &page_05, sizeof(page_05));
++ break;
++ case SCSI_MODEPAGE_REMOVABLE_BLOCK_ACCESS:
++ TRACE_MSG0(MSC, "MODEPAGE REMOVABLE_BLOCK_ACCESS");
++ length = sizeof(MODE_PARAMETER_HEADER) + sizeof(page_1b);
++ data->ModeParameterHeader.ModeDataLength = length - 1;
++ memcpy(&data->ModePages, &page_1b, sizeof(page_1b));
++ break;
++ case SCSI_MODEPAGE_INFORMATION_EXCEPTIONS:
++ TRACE_MSG0(MSC, "MODEPAGE INFORMATION_EXCEPTIONS");
++ length = sizeof(MODE_PARAMETER_HEADER) + sizeof(page_1c);
++ data->ModeParameterHeader.ModeDataLength = length - 1;
++ memcpy(&data->ModePages, &page_1c, sizeof(page_1c));
++ break;
++ case SCSI_MODEPAGE_ALL_SUPPORTED:
++ TRACE_MSG0(MSC, "MODEPAGE ALL_SUPPORTED");
++ length = sizeof(MODE_PARAMETER_HEADER) + sizeof(MODE_ALL_PAGES);
++ data->ModeParameterHeader.ModeDataLength = length - 1;
++ memcpy(&data->ModePages.ModeAllPages.ReadWriteErrorRecoveryPage, &page_01, sizeof(page_01));
++ memcpy(&data->ModePages.ModeAllPages.FlexibleDiskPage, &page_05, sizeof(page_05));
++ memcpy(&data->ModePages.ModeAllPages.RemovableBlockAccessCapabilitiesPage, &page_1b, sizeof(page_1b));
++ memcpy(&data->ModePages.ModeAllPages.TimerAndProtectPage, &page_1c, sizeof(page_1c));
++ break;
++ case SCSI_MODEPAGE_CACHING:
++ // see file_storage.c for an example if we want to support this
++ TRACE_MSG0(MSC, "MODEPAGE CACHING (not supported)");
++ break;
++ }
++
++ TRACE_MSG2(MSC,"LENGTH: %d %d", msc->command.dCBWDataTransferLength, length);
++
++ /*
++ * XXX verify that length is <= 256 bytes, return CHECK_CONDITION if it is
++ */
++ length = MIN(msc->command.dCBWDataTransferLength, length);
++
++ return msc_dispatch_query_urb(urb, msc, length, USB_MSC_PASSED);
++}
++
++
++/*! msc_scsi_test_unit_ready - process a request_sense command
++ *
++ * Used by:
++ * win2k
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_test_unit_ready(struct msc_private *msc, char *name, int op)
++{
++ return msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++}
++
++
++/*! msc_scsi_prevent_allow - process a request_sense command
++ *
++ * Used by:
++ * win2k
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_prevent_allow(struct msc_private *msc, char *name, int op)
++{
++ SCSI_PREVENT_ALLOW_MEDIA_REMOVAL_COMMAND* command = (SCSI_PREVENT_ALLOW_MEDIA_REMOVAL_COMMAND*)&msc->command.CBWCB;
++
++ /*
++ * C.f. SPC2 7.12 Table 78 PREVENT ALLOW MEDIA REMOVAL Prevent Field
++ *
++ * 00b Medium removal shall be allowed from both the data transport
++ * element and the attached medium changer (if any).
++ * 01b Medium removal shall be prohibited from the data transport
++ * element but allowed from the attached medium changer (if any).
++ * 10b Medium removal shall be allowed for the data transport element
++ * but prohibited for the attached medium changer.
++ * 11b Medium remval shall be prohibited from both the data transport
++ * element and the attached medium changer
++ *
++ * Prevention shall terminate after 00b or 10b, after a SYNC CACHE or hard reset.
++ */
++
++ // XXX TODO
++ // this is from storageproto.c, shouldn't we implement something?
++ if (command->Prevent)
++ return msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_INVALID_FIELD_IN_CDB, msc->lba, USB_MSC_FAILED);
++
++ return msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++}
++
++
++/*! msc_scsi_start_stop - process a request_sense command
++ *
++ * C.f. RBC 5.4 and 5.4.2
++ *
++ * Used by:
++ * win2k
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_start_stop(struct msc_private *msc, char *name, int op)
++{
++ SCSI_START_STOP_COMMAND* command = (SCSI_START_STOP_COMMAND*)&msc->command.CBWCB;
++
++ TRACE_MSG4(MSC,"START STOP: Immed: %d Power: %x LoEj: %d Start: %d",
++ command->IMMED, command->PowerConditions, command->LoEj, command->Start);
++ /*
++ * C.f. 5.4
++ *
++ * IMMED - if set return status immediately after command validation, otherwise
++ * return status as soon operation is completed.
++ *
++ * C.f. 5.4.1 Table 8 POWER CONDITIONS
++ *
++ * 0 - M - no change in power condition
++ * 1 - M - place device in active condition
++ * 2 - M - place device in idle condition
++ * 3 - M - place device in Standby condition
++ * 4 - - reserved
++ * 5 - M - place device in Sleep condition
++ * 6 - - reserved
++ * 7 - 0 - Device Control
++ *
++ * C.f. 5.4.2 Table 9 START STOP control bit definitions
++ *
++ * Power Load/Eject Start
++ * 1-7 x x LoEj and Start Ignored
++ * 0 0 0 Stop the medium
++ * 0 0 1 Make the medium ready
++ * 0 1 0 Unload the medium
++ * 0 1 1 Load the medium
++ *
++ */
++ // XXX TODO
++ // this is from storageproto.c, shouldn't we implement something?
++
++ if (command->Start && command->LoEj)
++ return msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_INVALID_FIELD_IN_CDB, msc->lba, USB_MSC_FAILED);
++
++ return msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++}
++
++/*! msc_scsi_verify - process a verify command
++ *
++ * Used by:
++ * win2k
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_verify(struct msc_private *msc, char *name, int op)
++{
++ SCSI_VERIFY_COMMAND *command = (SCSI_VERIFY_COMMAND *)&msc->command.CBWCB;
++
++ /*
++ * C.f. RBC 5.7 VERIFY command
++ */
++ // XXX This actually should use the read_10 function and when
++ // finished reading simply send the following
++ return msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++}
++
++
++/*! msc_scsi_mode_select - process a select command
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_mode_select(struct msc_private *msc, char *name, int op)
++{
++ //SCSI_MODE_SELECT_COMMAND *command = (SCSI_MODE_SELECT_COMMAND *)&msc->command.CBWCB;
++
++ /*
++ * C.f. SPC2 7.6 MODE SELECT(6) command
++ */
++
++ // if less than correct amount of data return USB_MSC_PHASE_ERROR - see MV
++ //
++ return msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++}
++
++/*! msc_private_pcs - process a private command
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_cmd_private_pcs(struct msc_private *msc, char *name, int op)
++{
++ return msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_INVALID_COMMAND, msc->lba, USB_MSC_FAILED);
++}
++
++/*! msc_cmd_unknown - process an unknown command
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_cmd_unknown(struct msc_private *msc, char *name, int op)
++{
++ return msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_INVALID_COMMAND, msc->lba, USB_MSC_FAILED);
++}
++
++struct rbc_dispatch {
++ u8 op;
++ char *name;
++ int (*rbc_command) (struct msc_private *, char *, int op);
++ int device_check;
++};
++
++/*! Command cross reference
++ *
++ * This is the list of commands observed from each host OS. It is necessarily
++ * incomplete in that we not have reached some condition necessary to have
++ * other commands used.
++ * Win2k WinXP
++ * SCSI_TEST_UNIT_READY yes yes
++ * SCSI_READ_10 yes yes
++ * SCSI_WRITE_10 yes yes
++ * SCSI_READ_CAPACITY yes yes
++ * SCSI_VERIFY yes
++ * SCSI_INQUIRY yes yes
++ * SCSI_MODE_SENSE yes
++ * SCSI_READ_FORMAT_CAPACITY yes yes
++ * SCSI_REQUEST_SENSE
++ * SCSI_PREVENT_ALLOW_MEDIA_REMOVAL
++ * SCSI_START_STOP
++ * SCSI_MODE_SELECT
++ * SCSI_FORMAT_UNIT
++ *
++ */
++
++struct rbc_dispatch rbc_dispatch_table[] = {
++ { SCSI_TEST_UNIT_READY, "SCSI_TEST_UNIT_READY", msc_scsi_test_unit_ready, NOZLP },
++ { SCSI_READ_10, "SCSI_READ_10", msc_scsi_read_10, SENDZLP },
++ { SCSI_WRITE_10, "SCSI_WRITE_10", msc_scsi_write_10, NOZLP },
++ { SCSI_READ_CAPACITY, "SCSI_READ_CAPACITY", msc_scsi_read_capacity, SENDZLP },
++ { SCSI_VERIFY, "SCSI_VERIFY", msc_scsi_verify, NOCHK },
++ { SCSI_INQUIRY, "SCSI_INQUIRY", msc_scsi_inquiry, NOCHK },
++ { SCSI_MODE_SENSE, "SCSI_MODE_SENSE", msc_scsi_mode_sense, NOCHK },
++ { SCSI_READ_FORMAT_CAPACITY, "SCSI_READ_FORMAT_CAPACITY", msc_scsi_read_format_capacity, SENDZLP },
++ { SCSI_REQUEST_SENSE, "SCSI_REQUEST_SENSE", msc_scsi_request_sense, NOCHK },
++ { SCSI_PREVENT_ALLOW_MEDIA_REMOVAL, "SCSI_PREVENT_ALLOW_MEDIA_REMOVAL", msc_scsi_prevent_allow, NOZLP },
++ { SCSI_START_STOP, "SCSI_START_STOP", msc_scsi_start_stop, NOZLP },
++ { SCSI_MODE_SELECT, "SCSI_MODE_SELECT", msc_scsi_mode_select, NOCHK },
++ { SCSI_FORMAT_UNIT, "SCSI_FORMAT_UNIT", msc_cmd_unknown, NOCHK },
++
++ { SCSI_READ_6, "SCSI_READ_6", msc_cmd_unknown, NOCHK },
++ { SCSI_WRITE_6, "SCSI_WRITE_6", msc_cmd_unknown, NOCHK },
++ { SCSI_RESERVE, "SCSI_RESERVE", msc_cmd_unknown, NOCHK },
++ { SCSI_RELEASE, "SCSI_RELEASE", msc_cmd_unknown, NOCHK },
++ { SCSI_SEND_DIAGNOSTIC, "SCSI_SEND_DIAGNOSTIC", msc_cmd_unknown, NOCHK },
++ { SCSI_SYNCHRONIZE_CACHE, "SCSI_SYNCHRONIZE_CACHE", msc_cmd_unknown, NOCHK },
++ { SCSI_MODE_SENSE_10, "SCSI_MODE_SENSE_10", msc_cmd_unknown, NOCHK },
++ { SCSI_REZERO_UNIT, "SCSI_REZERO_UNIT", msc_cmd_unknown, NOCHK },
++ { SCSI_SEEK_10, "SCSI_SEEK_10", msc_cmd_unknown, NOCHK },
++ { SCSI_WRITE_AND_VERIFY, "SCSI_WRITE_AND_VERIFY", msc_cmd_unknown, NOCHK },
++ { SCSI_WRITE_12, "SCSI_WRITE_12", msc_cmd_unknown, NOCHK },
++ { SCSI_READ_12, "SCSI_READ_12", msc_cmd_unknown, NOCHK },
++
++ { SCSI_PRIVATE_PCS, "SCSI_PRIVATE_PCS", msc_cmd_private_pcs, NOCHK },
++
++ { 0xff, "SCSI_UNKNOWN", msc_cmd_unknown, NOCHK },
++};
++
++
++/*! msc_recv_command - process a new CBW
++ *
++ * Return non-zero if urb was not disposed of.
++ */
++void msc_recv_command(struct usbd_urb *urb, struct msc_private *msc)
++{
++ COMMAND_BLOCK_WRAPPER *command = (COMMAND_BLOCK_WRAPPER *)urb->buffer;
++ u8 op = command->CBWCB[0];
++ struct rbc_dispatch *dispatch;
++
++ /*
++ * c.f. section 6.2 - Valid and Meaningful CBW
++ * c.f. section 6.2.1 - Valid CBW
++ *
++ * The CBW was received after the device had sent a CSW or after a
++ * reset XXX check that we only set MSC_READY after reset or sending
++ * CSW.
++ *
++ * The CBW is 31 (1Fh) bytes in length and the bCBWSignature is
++ * equal to 43425355h.
++ */
++ THROW_IF(31 != urb->actual_length, error);
++ THROW_IF(CBW_SIGNATURE != le32_to_cpu(command->dCBWSignature), error);
++
++ /*
++ * c.f. section 6.2.2 - Meaningful CBW
++ *
++ * no reserved bits are set
++ * the bCBWLUN contains a valid LUN supported by the device
++ * both bCBWCBlength and the content of the CBWCB are in accordance with bInterfaceSubClass
++ */
++
++ // XXX checklun etc
++
++ /*
++ * Success
++ */
++ memcpy(&msc->command, command, sizeof(COMMAND_BLOCK_WRAPPER));
++ msc->data_transferred_in_bytes = msc->TransferLength_in_blocks = msc->TransferLength_in_bytes = 0;
++
++ TRACE_TAG(command->dCBWTag, urb->framenum);
++ usbd_free_urb(urb);
++ urb = NULL;
++
++ /*
++ * Search using the opcode to find the dispatch function to use and
++ * call it.
++ */
++ for (dispatch = rbc_dispatch_table; dispatch->op != 0xff; dispatch++) {
++ CONTINUE_UNLESS ((dispatch->op == op));
++
++ TRACE_CBW(dispatch->name, dispatch->op, dispatch->device_check);
++ TRACE_RECV(&(command->CBWCB[1]));
++
++ /* Depending on the command we may need to check if the device is available
++ * and either fail or send a ZLP if it is not
++ */
++ if (dispatch->device_check)
++ RETURN_IF (msc_check_blockdev_name(msc, dispatch->device_check, dispatch->name));
++
++ /* Call the specific function that implements the specified command
++ */
++ if (dispatch->rbc_command(msc, dispatch->name, op))
++ TRACE_MSG0(MSC,"COMMAND ERROR");
++ return;
++ }
++
++ /* FALL THROUGH if no match is found */
++
++ CATCH(error) {
++ TRACE_MSG0(MSC,"RECV CBW ERROR");
++ if (urb)
++ usbd_free_urb(urb);
++
++ /* XXX which of these do we stall?
++ */
++ usbd_halt_endpoint(urb->function_instance, BULK_IN);
++ usbd_halt_endpoint(urb->function_instance, BULK_OUT);
++ }
++ msc_cmd_unknown(msc, "CMD_UNKNOWN", op);
++}
++
++
++/* Sent Function - process a sent urb ********************************************************** */
++
++/*! msc_urb_sent - called to indicate URB transmit finished
++ * @param tx_urb: pointer to struct usbd_urb
++ * @param rc: result
++ *
++ * This is called when an urb is sent. Depending on current state
++ * it may:
++ *
++ * - continue sending data
++ * - send a CSW
++ * - start a recv for a CBW
++ *
++ * This is called from BOTTOM HALF context.
++ *
++ * @return non-zero if urb was not disposed of.
++ */
++int msc_urb_sent (struct usbd_urb *tx_urb, int rc)
++{
++ struct usbd_function_instance *function;
++ struct msc_private *msc = &msc_private;
++
++ RETURN_EINVAL_IF(!(function = tx_urb->function_instance));
++ RETURN_EINVAL_IF(usbd_get_device_status(function) == USBD_CLOSING);
++ RETURN_EINVAL_IF(usbd_get_device_state(function) != STATE_CONFIGURED);
++
++ switch (msc->command_state) {
++ case MSC_DATA_IN_READ:
++ case MSC_DATA_IN_READ_FINISHED:
++ TRACE_MSG0(MSC,"URB SENT READ");
++ return msc_in_read_10_urb_sent(tx_urb, msc);
++
++ case MSC_QUERY:
++ // finished, send CSW
++ TRACE_MSG0(MSC,"URB SENT QUERY");
++ msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++ break;
++
++ case MSC_STATUS:
++ default:
++ // sent a CSW need to receive the next CBW
++ TRACE_MSG0(MSC,"URB SENT STATUS");
++ msc->command_state = MSC_READY;
++ msc_start_recv_urb(msc->function, msc, sizeof(COMMAND_BLOCK_WRAPPER));
++ break;
++ }
++ usbd_free_urb (tx_urb);
++ return 0;
++}
++
++
++/* Receive Function - receiving an urb ********************************************************* */
++
++/*! msc_recv_urb - process a received urb
++ *
++ * Return non-zero if urb was not disposed of.
++ */
++static int msc_recv_urb (struct usbd_urb *rcv_urb, int rc)
++{
++ struct msc_private *msc = &msc_private;
++
++ RETURN_EINVAL_IF(!msc->connected);
++
++ //TRACE_MSG2(MSC, "RECV URB length: %d state: %d", rcv_urb->actual_length, msc->command_state);
++
++ switch(msc->command_state) {
++
++ // ready to start a new transaction
++ case MSC_READY:
++ msc_recv_command(rcv_urb, msc);
++ return 0;
++
++ // we think we are receiving data
++ case MSC_DATA_OUT_WRITE:
++ case MSC_DATA_OUT_WRITE_FINISHED:
++ msc_recv_out_blocks(rcv_urb, msc);
++ return 0;
++
++ // we think we are sending data
++ case MSC_DATA_IN_READ:
++ case MSC_DATA_IN_READ_FINISHED:
++ msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_INVALID_COMMAND, msc->lba, USB_MSC_FAILED);
++ break;
++
++ // we think we are sending status
++ case MSC_STATUS:
++ msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_INVALID_COMMAND, msc->lba, USB_MSC_FAILED);
++ break;
++
++ // we don't think
++ case MSC_UNKNOWN:
++ default:
++ TRACE_MSG0(MSC,"RECV URB ERROR");
++ usbd_halt_endpoint(rcv_urb->function_instance, BULK_OUT);
++ }
++ // let caller dispose of urb
++ return -EINVAL;
++}
++
++/* USB Device Functions ************************************************************************ */
++
++
++static void msc_device_request (struct usbd_function_instance *function, struct usbd_device_request *request)
++{
++ TRACE_MSG0(MSC,"--");
++}
++
++static void msc_set_configuration (struct usbd_function_instance *function, int wValue)
++{
++ TRACE_MSG1(MSC,"wValue: %02x", wValue);
++
++}
++
++static void msc_set_interface (struct usbd_function_instance *function, int wIndex, int wValue)
++{
++ TRACE_MSG2(MSC,"wIndex: %02x wValue: %02x", wIndex, wValue);
++
++}
++
++static void msc_endpoint_cleared (struct usbd_function_instance *function, int bEndpointAddress)
++{
++ TRACE_MSG1(MSC,"bEndpointAddress: %02x", bEndpointAddress);
++
++}
++
++/* USB Device Functions ************************************************************************ */
++/*! msc_event_handler - process a device event
++ *
++ * This function is called when an USBD event occurs.
++ *
++ * This is called from INTERRUPT context.
++ */
++void msc_event_handler (struct usbd_function_instance *function, usbd_device_event_t event, int data)
++{
++ unsigned long flags;
++ struct msc_private *msc = &msc_private;
++ int connected;
++ switch (event) {
++ case DEVICE_CONFIGURED:
++ TRACE_MSG0(MSC,"EVENT CONFIGURED");
++ msc->connected = 1;
++ msc->command_state = MSC_READY;
++ msc_start_recv_urb(function, msc, sizeof(COMMAND_BLOCK_WRAPPER));
++ #if 0
++ local_irq_save(flags);
++ if (msc->io_state & MSC_IOCTL_WAITING) {
++ msc->io_state &= ~MSC_IOCTL_WAITING;
++ TRACE_MSG0(MSC, "WAKEUP");
++ }
++ local_irq_restore(flags);
++ #endif
++ wake_up_interruptible(&msc->ioctl_wq);
++ break;
++
++ case DEVICE_BUS_INACTIVE:
++ case DEVICE_RESET:
++ case DEVICE_DE_CONFIGURED:
++ TRACE_MSG2(MSC,"EVENT RESET: connected %d msc->io_state", msc->connected, msc->io_state);
++ connected = msc->connected;
++ msc->connected = 0;
++ #if 0
++ local_irq_save(flags);
++ if (msc->io_state & MSC_IOCTL_WAITING) {
++ msc->io_state &= ~MSC_IOCTL_WAITING;
++ TRACE_MSG0(MSC, "WAKEUP");
++ wake_up_interruptible(&msc->ioctl_wq);
++ }
++ local_irq_restore(flags);
++ #endif
++ wake_up_interruptible(&msc->ioctl_wq);
++ BREAK_UNLESS(connected);
++
++ // XXX we should have a semaphore to protect this
++ BREAK_UNLESS (msc->rcv_urb_finished);
++ usbd_free_urb (msc->rcv_urb_finished);
++ msc->rcv_urb_finished = NULL;
++ break;
++
++ default:
++ TRACE_MSG0(MSC,"EVENT IGNORED");
++ break;
++ }
++}
++
++/*! msc_device_request - called to indicate urb has been received
++ *
++ * This function is called when a SETUP packet has been received that
++ * should be handled by the function driver. It will not be called to
++ * process the standard chapter nine defined requests.
++ *
++ * Return non-zero for failure.
++ */
++int msc_device_handler (struct usbd_function_instance *function, struct usbd_device_request *request)
++{
++ struct msc_private *msc = &msc_private;
++ struct usbd_urb *urb;
++
++ TRACE_MSG0(MSC,"RECV SETUP");
++
++ // verify that this is a usb class request per cdc-acm 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_CLASS:
++ switch (request->bRequest) {
++ case MSC_BULKONLY_RESET:
++ // XXX TODO FIXME
++ return 0;
++ }
++
++ case USB_REQ_DEVICE2HOST | USB_REQ_TYPE_CLASS:
++ switch (request->bRequest) {
++ case MSC_BULKONLY_GETMAXLUN:
++ RETURN_EINVAL_IF(!(urb = usbd_alloc_urb_ep0(function, 1, NULL)));
++ urb->buffer[0] = 0;
++ urb->actual_length = 1;
++ RETURN_ZERO_IF(!usbd_start_in_urb(urb));
++ usbd_free_urb(urb);
++ return -EINVAL;
++ }
++ default:
++ break;
++ }
++ return -EINVAL;
++}
++
++/*! msc_function_enable - this is called by the USBD core layer
++ *
++ * This is called to initialize the function when a bus interface driver
++ * is loaded.
++ */
++static int msc_function_enable (struct usbd_function_instance *function)
++{
++ struct msc_private *msc = &msc_private;
++
++ MOD_INC_USE_COUNT;
++
++ // XXX TODO need to verify that serial number is minimum of 12
++
++ msc->function = function;
++ msc->command_state = MSC_READY;
++
++ return 0;
++}
++
++/*! msc_function_disable - this is called by the USBD core layer
++ *
++ * This is called to close the function when a bus interface driver
++ * is unloaded.
++ */
++static void msc_function_disable (struct usbd_function_instance *function)
++{
++ struct msc_private *msc = &msc_private;
++
++ TRACE_MSG0(MSC,"FUNCTION EXIT");
++
++ msc->function = NULL;
++
++ MOD_DEC_USE_COUNT;
++}
++
++/* ********************************************************************************************* */
++struct usbd_function_operations msc_function_ops = {
++ event_handler: msc_event_handler,
++ device_request: msc_device_request,
++ function_enable: msc_function_enable,
++ function_disable: msc_function_disable,
++ endpoint_cleared: msc_device_request,
++ endpoint_cleared: msc_set_configuration,
++ endpoint_cleared: msc_set_interface,
++ endpoint_cleared: msc_endpoint_cleared,
++};
++
++/* ********************************************************************************************* */
+diff -uNr linux/drivers/no-otg/functions/msc/msc-fd.h linux/drivers/otg/functions/msc/msc-fd.h
+--- linux/drivers/no-otg/functions/msc/msc-fd.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/msc-fd.h 2006-09-01 21:41:27.000000000 +0200
+@@ -0,0 +1,64 @@
++/*
++ * otg/msc_fd/msc.h - Mass Storage Class
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++
++#ifndef MSC_FD_H
++#define MSC_FD_H 1
++
++extern int msc_dispatch_query_urb(struct usbd_urb *urb, struct msc_private *msc, int length, int status);
++extern int msc_start_sending_csw(struct usbd_function_instance *function, struct msc_private *msc, u8 status);
++extern int msc_dispatch_query_urb_zlp(struct msc_private *msc, u32 sensedata, u32 info, int status);
++extern int msc_start_sending_csw_failed(struct msc_private *msc, u32 sensedata, u32 info, int status);
++extern int msc_start_recv_urb(struct usbd_function_instance *function, struct msc_private *msc, int size);
++
++#define NOCHK 0
++#define NOZLP 1
++#define SENDZLP 2
++
++#if 1
++static __inline__ void TRACE_SENSE(unsigned int sense, unsigned int info)
++{
++ TRACE_MSG2(MSC, "--> SENSE: %06x INFO: %08x", sense, info);
++}
++static __inline__ void TRACE_RLBA(unsigned int lba, unsigned int crc)
++{
++ TRACE_MSG2(MSC, "<-- rlba [%8x %08x]", lba, crc);
++}
++static __inline__ void TRACE_SLBA(unsigned int lba, unsigned int crc)
++{
++ TRACE_MSG2(MSC, "--> slba [%8x %08x]", lba, crc);
++}
++static __inline__ void TRACE_TLBA(unsigned int lba, unsigned int crc)
++{
++ TRACE_MSG2(MSC, "--> tlba [%8x %08x]", lba, crc);
++}
++static __inline__ void TRACE_TAG(unsigned int tag, unsigned int frame)
++{
++ TRACE_MSG2(MSC, "--> TAG: %8x FRAME: %03x", tag, frame);
++}
++static __inline__ void TRACE_CBW(char *msg, int val, int check)
++{
++ TRACE_MSG3(MSC, " --> %s %02x check: %d", msg, val, check);
++}
++static __inline__ void TRACE_RECV(unsigned char *cp)
++{
++ TRACE_MSG8(MSC, "<-- recv [%02x %02x %02x %02x %02x %02x %02x %02x]",
++ cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
++}
++static __inline__ void TRACE_SENT(unsigned char *cp)
++{
++ TRACE_MSG8(MSC, "--> sent [%02x %02x %02x %02x %02x %02x %02x %02x]",
++ cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
++}
++
++#endif
++
++
++#endif /* MSC_H */
+diff -uNr linux/drivers/no-otg/functions/msc/msc-io-l24.c linux/drivers/otg/functions/msc/msc-io-l24.c
+--- linux/drivers/no-otg/functions/msc/msc-io-l24.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/msc-io-l24.c 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,272 @@
++/*
++ * otg/function/msc/msc-io-l24.c - MSC IO
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/functions/msc/msc-io-l24.c
++ * @brief
++ *
++ * NOTES
++ *
++ * TODO
++ *
++ * 1. implement prevent removal command.
++ *
++ * @ingroup MSCFunction
++ */
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++
++#include <linux/poll.h>
++#include <linux/sched.h>
++#include <linux/devfs_fs_kernel.h>
++
++#include "msc-scsi.h"
++#include "msc.h"
++#include "msc-fd.h"
++#include "crc.h"
++#include "msc-io.h"
++
++extern void msc_open_blockdev (struct msc_private *msc);
++extern void msc_close_blockdev (struct msc_private *msc);
++extern int msc_connection_blockdev (struct msc_private *msc);
++extern struct msc_private msc_private;
++
++#define DEVICE_EJECTED 0x0001 //MEDIA_EJECTED
++#define DEVICE_INSERTED 0x0002 //MEDIA_INSERT
++#define DEVICE_MOUNTED 0x0001 //DEVICE_MOUNTED
++#define DEVICE_UNMOUNTED 0x0002 //DEVICE_UNMOUNTED
++
++extern u32 major;
++extern u32 minor;
++#if 0
++void msc_io_wait(struct msc_private *msc, u32 flag)
++{
++ unsigned long flags;
++ msc->io_state |= MSC_IOCTL_WAITING | flag;
++ TRACE_MSG1(MSC, "SLEEPING io_state: %x", msc->io_state);
++ interruptible_sleep_on(&msc->ioctl_wq);
++}
++
++void msc_io_wakup(struct msc_private *msc)
++{
++ unsigned long flags;
++ local_irq_save(flags);
++ if (msc->io_state & MSC_IOCTL_WAITING) {
++ msc->io_state &= ~MSC_IOCTL_WAITING;
++ TRACE_MSG0(MSC, "WAKEUP");
++ wake_up_interruptible(&msc->ioctl_wq);
++ }
++ local_irq_restore(flags);
++}
++#endif
++/*! msc_io_ioctl_internal
++ */
++int msc_io_ioctl_internal(unsigned int cmd, unsigned long arg)
++{
++ int i;
++ int len;
++ int flag;
++
++ static char func_buf[32];
++ struct otgmsc_mount mount;
++ struct msc_private *msc = &msc_private;
++ unsigned long flags;
++
++ TRACE_MSG2(MSC, "cmd: %d connect: %d", cmd, msc->connected);
++ memset(&mount, 0, sizeof(mount));
++ switch (cmd) {
++
++ /* Mount - make the specified major/minof device available for use
++ * by the USB Host, this does not require an active connection.
++ */
++ case OTGMSC_START:
++ TRACE_MSG0(MSC, "Mounting the device");
++ RETURN_EINVAL_IF(copy_from_user(&mount, (void *)arg, _IOC_SIZE(cmd)));
++
++ TRACE_MSG3(MSC, "major=%d minor=%d state=%d", mount.major, mount.minor, msc->block_dev_state);
++ major = mount.major;
++ minor = mount.minor;
++
++ //msc->io_state = MSC_INACTIVE;
++ msc_open_blockdev (msc);
++ RETURN_EAGAIN_UNLESS(msc->command_state == MSC_READY);
++
++ mount.status = (msc->block_dev_state == DEVICE_INSERTED) ? DEVICE_MOUNTED : DEVICE_UNMOUNTED;
++
++ TRACE_MSG1(MSC, "Device is mounted status: %d", mount.status);
++
++ // XXX Need to copy result back to user space
++ RETURN_EINVAL_IF (copy_to_user((void *)arg, &mount, sizeof(mount)));
++ TRACE_MSG0(MSC, "Device mounted");
++ return 0;
++
++ /* Umount - make the currently mounted device unavailable to the USB Host,
++ * if there is pending block i/o block until it has finished.
++ * Note that if the driver is unloaded the waiting ioctl process
++ * must be woken up and informed with error code.
++ */
++ case OTGMSC_STOP:
++
++ TRACE_MSG0(MSC, "Unmounting the device");
++
++ RETURN_EINVAL_IF (copy_from_user (&mount, (void *)arg, _IOC_SIZE(cmd)));
++
++ if (msc->command_state != MSC_READY) {
++ TRACE_MSG0(MSC, "SLEEPING");
++ interruptible_sleep_on(&msc->ioctl_wq);
++ TRACE_MSG0(MSC, "AWAKE");
++ }
++
++ RETURN_EAGAIN_UNLESS(msc->command_state == MSC_INACTIVE);
++
++ // XXX Need to copy result back to user space
++ msc->major = mount.major;
++ msc->minor = mount.minor;
++ msc_close_blockdev(msc);
++ mount.status = DEVICE_UNMOUNTED;
++ RETURN_EINVAL_IF (copy_to_user((void *)arg, &mount, sizeof(mount)));
++ TRACE_MSG0(MSC, "Device unmounted");
++ return 0;
++
++
++ /* Status - return the current mount status.
++ */
++ case OTGMSC_STATUS:
++ TRACE_MSG0(MSC, "Mount status");
++ RETURN_EINVAL_IF (copy_from_user (&mount, (void *)arg, _IOC_SIZE(cmd)));
++ if (msc->block_dev_state == DEVICE_EJECTED)
++ mount.status = DEVICE_UNMOUNTED;
++ else
++ mount.status = DEVICE_MOUNTED;
++
++ // XXX Need to copy result back to user space
++ RETURN_EINVAL_IF (copy_to_user((void *)arg, &mount, sizeof(mount)));
++ return 0;
++
++ /* Wait_Connect - if not already connected wait until connected,
++ * Note that if the driver is unloaded the waiting ioctl process
++ * must be woken up and informed with error code.
++ */
++ case OTGMSC_WAIT_CONNECT:
++ TRACE_MSG1(MSC, "Wait for connect: connected: %d", msc->connected);
++ local_irq_save(flags);
++
++ if (msc->connected == 0) {
++ TRACE_MSG0(MSC, "SLEEPING");
++ interruptible_sleep_on (&msc->ioctl_wq);
++ TRACE_MSG0(MSC, "AWAKE");
++ }
++ RETURN_EAGAIN_UNLESS(msc->connected);
++
++ RETURN_EINVAL_IF (copy_from_user (&mount, (void *)arg, _IOC_SIZE(cmd)));
++ RETURN_EINVAL_IF (copy_to_user((void *)arg, &mount, sizeof(mount)));
++ TRACE_MSG0(MSC, "Device connected");
++ return 0;
++
++ /* Wait_DisConnect - if not already disconnected wait until disconnected,
++ * Note that if the driver is unloaded the waiting ioctl process
++ * must be woken up and informed with error code.
++ */
++ case OTGMSC_WAIT_DISCONNECT:
++ TRACE_MSG1(MSC, "Wait for disconnect: connected: %d", msc->connected);
++
++ if (msc->connected == 1) {
++ TRACE_MSG0(MSC, "SLEEPING");
++ interruptible_sleep_on (&msc->ioctl_wq);
++ TRACE_MSG0(MSC, "AWAKE");
++ }
++ RETURN_EAGAIN_IF(msc->connected);
++ RETURN_EINVAL_IF (copy_from_user (&mount, (void *)arg, _IOC_SIZE(cmd)));
++ RETURN_EINVAL_IF (copy_to_user((void *)arg, &mount, sizeof(mount)));
++ TRACE_MSG0(MSC, "Device disconnected");
++ return 0;
++
++ default:
++ TRACE_MSG1(MSC, "Unknown command: %x", cmd);
++ TRACE_MSG1(MSC, "OTGMSC_START: %x", OTGMSC_START);
++ TRACE_MSG1(MSC, "OTGMSC_WRITEPROTECT: %x", OTGMSC_WRITEPROTECT);
++ TRACE_MSG1(MSC, "OTGMSC_STOP: %x", OTGMSC_STOP);
++ TRACE_MSG1(MSC, "OTGMSC_STATUS: %x", OTGMSC_STATUS);
++ TRACE_MSG1(MSC, "OTGMSC_WAIT_CONNECT: %x", OTGMSC_WAIT_CONNECT);
++ TRACE_MSG1(MSC, "OTGMSC_WAIT_DISCONNECT: %x", OTGMSC_WAIT_DISCONNECT);
++ return -EINVAL;
++ }
++ return 0;
++}
++
++
++
++/*! msc_io_ioctl
++ */
++int msc_io_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
++{
++ int i;
++ int len;
++ int flag;
++
++ //printk(KERN_INFO"%s: cmd: %08x arg: %08x\n", __FUNCTION__, cmd, arg);
++ TRACE_MSG6(MSC, "cmd: %08x arg: %08x type: %02d nr: %02d dir: %02d size: %02d",
++ cmd, arg, _IOC_TYPE(cmd), _IOC_NR(cmd), _IOC_DIR(cmd), _IOC_SIZE(cmd));
++
++ RETURN_EINVAL_UNLESS (_IOC_TYPE(cmd) == OTGMSC_MAGIC);
++ RETURN_EINVAL_UNLESS (_IOC_NR(cmd) <= OTGMSC_MAXNR);
++
++ RETURN_EFAULT_IF((_IOC_DIR(cmd) == _IOC_READ) && !access_ok(VERIFY_WRITE, (void *)arg, _IOC_SIZE(cmd)));
++ RETURN_EFAULT_IF((_IOC_DIR(cmd) == _IOC_WRITE) && !access_ok(VERIFY_READ, (void *)arg, _IOC_SIZE(cmd)));
++
++ return msc_io_ioctl_internal(cmd, arg);
++}
++
++
++
++int msc_io_proc_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
++{
++ return msc_io_ioctl(inode, filp, cmd, arg);
++}
++
++
++static struct file_operations msc_io_proc_switch_functions = {
++ ioctl:msc_io_proc_ioctl,
++};
++
++
++/* msc_io_init_l24 - initialize
++ */
++int msc_io_init_l24(void)
++{
++ struct proc_dir_entry *message = NULL;
++
++ THROW_IF (!(message = create_proc_entry ("msc_io", 0666, 0)), error);
++ message->proc_fops = &msc_io_proc_switch_functions;
++ CATCH(error) {
++ printk(KERN_ERR"%s: creating /proc/msc_io failed\n", __FUNCTION__);
++ if (message)
++ remove_proc_entry("msc_io", NULL);
++ return -EINVAL;
++ }
++ return 0;
++}
++
++/* msc_io_exit_l24 - exit
++ */
++void msc_io_exit_l24(void)
++{
++ remove_proc_entry("msc_io", NULL);
++}
++
++
++
+diff -uNr linux/drivers/no-otg/functions/msc/msc-io.h linux/drivers/otg/functions/msc/msc-io.h
+--- linux/drivers/no-otg/functions/msc/msc-io.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/msc-io.h 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,57 @@
++/*
++ * otg/functions/msc/msc-io.h - Mass Storage Class
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/functions/msc/msc-io.h
++ * @brief Mass Storage Driver private defines
++ *
++ * OTGMSC_START - make specified major/minor device available to USB Host
++ * OTGMSC_WRITEPROTECT - set or reset write protect flag
++ *
++ * OTGMSC_STOP - remove access to current device, block until pending I/O finished
++ * OTGMSC_STATUS - remove current USB connection status (connected or disconnected)
++ * OTGMSC_WAIT_CONNECT - wait until device is connected (may return immediately if already connected)
++ * OTGMSC_WAIT_DISCONNECT - wait until device is disconnected (may return immediately if already disconnected)
++ *
++ * @ingroup MSCFunction
++ */
++
++//#ifndef MSC_H
++//#define MSC_H 1
++
++#define MSC_IO "/proc/msc_io"
++
++struct otgmsc_mount {
++ int major;
++ int minor;
++ int lun;
++ int writeprotect;
++ int result;
++ int status;
++};
++
++#define OTGMSC_MAGIC 'M'
++#define OTGMSC_MAXNR 10
++
++#define OTGMSC_START _IOWR(OTGMSC_MAGIC, 1, struct otgmsc_mount)
++#define OTGMSC_WRITEPROTECT _IOWR(OTGMSC_MAGIC, 2, struct otgmsc_mount)
++
++#define OTGMSC_STOP _IOR(OTGMSC_MAGIC, 1, struct otgmsc_mount)
++#define OTGMSC_STATUS _IOR(OTGMSC_MAGIC, 2, struct otgmsc_mount)
++#define OTGMSC_WAIT_CONNECT _IOR(OTGMSC_MAGIC, 3, struct otgmsc_mount)
++#define OTGMSC_WAIT_DISCONNECT _IOR(OTGMSC_MAGIC, 4, struct otgmsc_mount)
++
++
++#define MSC_CONNECTED 0x01
++#define MSC_DISCONNECTED 0x02
++#define MSC_WRITEPROTECTED 0x04
++
++//#endif /* MSC_H */
++
+diff -uNr linux/drivers/no-otg/functions/msc/msc-linux.c linux/drivers/otg/functions/msc/msc-linux.c
+--- linux/drivers/no-otg/functions/msc/msc-linux.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/msc-linux.c 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,935 @@
++/*
++ * otg/function/msc/msc-linux.c
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ *
++ */
++
++/*!
++ * @file otg/functions/msc/msc-linux.c
++ * @brief Mass Storage Driver private defines
++ *
++ *
++ * This is a Mass Storage Class Function that uses the Bulk Only protocol.
++ *
++ * To use simply load with something like:
++ *
++ * insmod msc_fd.o vendor_id=0xffff product_id=0xffff
++ *
++ * Notes:
++ *
++ * 1. Currently block I/O is done a page at a time. I have not determined if
++ * it is possible to dispatch a multiple page generic request. It should at
++ * least be possible to queue page requests.
++ *
++ * 2. Currently for READ operations we have a maximum of one outstanding
++ * read block I/O and send urb. These are allowed to overlap so that we can
++ * continue to read data while sending data to the host.
++ *
++ * 3. Currently for WRITE operations we have a maximum of one outstanding
++ * recv urb and one outstanding write block I/O. These are allowed to
++ * overlap so that we can continue to receive data from the host while
++ * waiting for writing to complete.
++ *
++ * 4. It would be possible to allow multiple writes to be pending, to the
++ * limit of the page cache, if desired.
++ *
++ * 5. It should be possible to allow multiple outstanding reads to be
++ * pending, to the limit of the page cache, but this potentially could
++ * require dealing with out of order completions of the reads. Essentially a
++ * list of completed buffer heads would be required to hold any completed
++ * buffer heads that cannot be sent prior to another, earlier request being
++ * completed.
++ *
++ * 6. Currently ioctl calls are available to start and stop device i/o.
++ *
++ * 7. The driver can optionally generate trace messages showing each sectors
++ * CRC as read or written with LBA. These can be compared by user programs to
++ * ensure that the correct data was read and/or written.
++ *
++ *
++ * TODO
++ *
++ * 1. error handling for block io, e.g. what if using with removable block
++ * device (like CF card) and it is removed.
++ *
++ * 2. Currently we memcpy() data from between the urb buffer and buffer
++ * head page. It should be possible to simply use the page buffer for the
++ * urb.
++ *
++ * 3. Should we offer using fileio as an option? This would allow direct access
++ * to a block device image stored in a normal file or direct access to (for example)
++ * ram disks. It would require implementing a separate file I/O kernel thread to
++ * do the actual I/O.
++ *
++ * 4. It may be interesting to support use of SCSI block device and pass the
++ * scsi commands directly to that. This would allow vendor commands for real
++ * devices to be passed through and executed with results being properly
++ * returned to the host. [This is the intended design for the mass storage
++ * specification.]
++ *
++ *
++ * TODO FIXME Bus Interface Notes
++ *
++ *
++ * @ingroup MSCFunction
++ */
++
++
++#include <otg/otg-compat.h>
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/otg-trace.h>
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++
++#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 <linux/blkdev.h>
++
++
++#include "msc-scsi.h"
++#include "msc.h"
++#include "msc-fd.h"
++#ifdef CONFIG_OTG_MSC_BLOCK_TRACE
++#include "crc.h"
++#endif /* CONFIG_OTG_MSC_BLOCK_TRACE */
++#include "msc-io.h"
++
++
++//#include "rbc.h"
++
++
++/* Module Parameters ************************************************************************* */
++
++u32 vendor_id;
++u32 product_id;
++
++u32 major;
++u32 minor;
++
++MODULE_PARM (vendor_id, "i");
++MODULE_PARM (product_id, "i");
++MODULE_PARM (major, "i");
++MODULE_PARM (minor, "i");
++
++MODULE_PARM_DESC (vendor_id, "Device Vendor ID");
++MODULE_PARM_DESC (product_id, "Device Product ID");
++MODULE_PARM_DESC (major, "Device Major");
++MODULE_PARM_DESC (minor, "Device Minor");
++
++
++#define DEVICE_EJECTED 0x0001 // MEDIA_EJECTED
++#define DEVICE_INSERTED 0x0002 // MEDIA_INSERT
++
++#define DEVICE_OPEN 0x0004 // WR_PROTECT_OFF
++#define DEVICE_WRITE_PROTECTED 0x0008 // WR_PROTECT_ON
++
++#define DEVICE_CHANGE_ON 0x0010 // MEDIA_CHANGE_ON
++
++#define DEVICE_PREVENT_REMOVAL 0x0020
++
++
++#define DEF_NUMBER_OF_HEADS 0x10
++#define DEF_SECTORS_PER_TRACK 0x20
++
++
++DECLARE_MUTEX(msc_sem);
++
++
++/* MSC ******************************************************************************************** */
++
++struct msc_private msc_private;
++
++int msc_urb_sent (struct usbd_urb *tx_urb, int rc);
++
++
++/* Block Device ******************************************************************************** */
++
++/*! msc_open_blockdev - open the block device specified in msc->major, msc->minor
++ *
++ * Sets appropriate fields to show current status of block device.
++ *
++ * XXX TODO - this needs to be tested against RO and absent devices.
++ *
++ */
++void msc_open_blockdev(struct msc_private *msc)
++{
++ int rc;
++
++ down(&msc_sem);
++ msc->block_dev_state = DEVICE_EJECTED;
++
++ TRACE_MSG2(MSC, "OPEN BLOCKDEV: Major: %x Minor: %x", major, minor);
++
++ /*
++ * Check device information and verify access to the block device.
++ */
++ THROW_IF (!major, ejected);
++
++ msc->dev = MKDEV(major, minor);
++
++ THROW_IF (!(msc->bdev = bdget(kdev_t_to_nr(msc->dev))), ejected);
++
++ if ((rc = blkdev_get(msc->bdev, FMODE_READ | FMODE_WRITE, 0, BDEV_RAW))) {
++
++ TRACE_MSG0(MSC,"OPEN BLOCKDEV: cannot open RW");
++ THROW_IF ((rc = blkdev_get(msc->bdev, FMODE_READ, 0, BDEV_RAW)), ejected);
++ msc->block_dev_state |= DEVICE_WRITE_PROTECTED;
++ }
++
++ msc->io_state = MSC_INACTIVE;
++ msc->block_dev_state &= ~DEVICE_EJECTED;
++ msc->block_dev_state |= DEVICE_INSERTED | DEVICE_CHANGE_ON;
++
++ TRACE_MSG1(MSC,"OPEN BLOCKDEV: opened block_dev_state: %x", msc->block_dev_state);
++
++ /*
++ * Note that capacity must return the LBA of the last addressable block
++ * c.f. RBC 4.4, RBC 5.3 and notes below RBC Table 6
++ *
++ * The blk_size array contains the number of addressable blocks or N,
++ * capacity is therefore N-1.
++ */
++
++ msc->capacity = (blk_size[MAJOR(msc_private.dev)][MINOR(msc_private.dev)] << 1) - 1;
++ msc->block_size = get_hardsect_size(msc->dev);
++ msc->max_blocks = PAGE_SIZE / msc->block_size;
++
++ TRACE_MSG2(MSC,"blk_size: %x %d",
++ blk_size[MAJOR(msc_private.dev)][MINOR(msc_private.dev)] << 1,
++ blk_size[MAJOR(msc_private.dev)][MINOR(msc_private.dev)] << 1);
++
++ TRACE_MSG2(MSC,"capacity: %x %d", msc->capacity, msc->capacity);
++ TRACE_MSG2(MSC,"block_size: %x %d", msc->block_size, msc->block_size);
++ TRACE_MSG2(MSC,"max_blocks: %x %d", msc->max_blocks, msc->max_blocks);
++
++ /* setup generic buffer_head
++ * XXX do we need two pages? it should be possible to have a single page
++ * for both read and write, in fact do we need a read_bh and write_bh?
++ * XXX ensure the page (or pages) get deallocated
++ */
++ msc->write_pending = msc->read_pending = 0;
++ msc->write_bh.b_rdev = msc->read_bh.b_rdev = msc->dev;
++ msc->write_bh.b_private = msc->read_bh.b_private = msc;
++ msc->read_bh.b_page = alloc_page(GFP_NOIO); // XXX ensure that this gets de-allocated
++ msc->write_bh.b_page = alloc_page(GFP_NOIO); // XXX ensure that this gets de-allocated
++ msc->read_bh.b_data = page_address(msc->read_bh.b_page);
++ msc->write_bh.b_data = page_address(msc->write_bh.b_page);
++
++ CATCH(ejected) {
++ TRACE_MSG1(MSC,"OPEN BLOCKDEV: EJECTED block_dev_state: %x", msc->block_dev_state);
++ printk(KERN_INFO"%s: Cannot get device %d %d\n", __FUNCTION__, major, minor);
++ }
++ up(&msc_sem);
++}
++
++/*! msc_close_blockdev - close the device for host
++ */
++
++void msc_close_blockdev(struct msc_private *msc)
++{
++
++ RETURN_IF(msc->block_dev_state == DEVICE_EJECTED);
++
++ down(&msc_sem);
++ msc->block_dev_state = DEVICE_EJECTED;
++ if (msc->bdev)
++ blkdev_put(msc->bdev, BDEV_RAW);
++
++ // XXX this should be a wait for read_bh/write_bh to go to NULL
++ //while (msc->read_bh.b_data || msc->write_bh.b_data) {
++ while (msc->read_pending || msc->write_pending) {
++ printk(KERN_INFO"%s: sleeping on read or write bh\n", __FUNCTION__);
++ sleep_on_timeout(&msc->msc_wq, 20);
++ }
++ __free_page((void *)&msc->read_bh.b_page);
++ msc->read_bh.b_page = NULL;
++ __free_page((void *)&msc->write_bh.b_page);
++ msc->write_bh.b_page = NULL;
++ up(&msc_sem);
++}
++
++
++/* READ 10 COMMAND - read and send data to the host ******************************************** */
++
++int msc_start_reading_block_data(struct usbd_function_instance *function, struct msc_private *msc);
++void msc_block_read_finished(struct buffer_head *bh, int flag);
++
++
++/*! msc_scsi_read_10 - process a read(10) command
++ *
++ * We have received a READ(10) CBW, if transfer length is non-zero
++ * initiate a generic block i/o otherwise send a CSW.
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_read_10(struct msc_private *msc, char *name, int op)
++{
++ SCSI_READ_10_COMMAND *command = (SCSI_READ_10_COMMAND *)&msc->command.CBWCB;
++
++ /*
++ * save the CBW information and setup for transmitting data read from the block device
++ */
++ msc->lba = be32_to_cpu(command->LogicalBlockAddress);
++ msc->TransferLength_in_blocks = be16_to_cpu(command->TransferLength);
++ msc->TransferLength_in_bytes = msc->TransferLength_in_blocks * msc->block_size;
++ msc->command_state = MSC_DATA_IN_READ;
++ msc->io_state = MSC_INACTIVE;
++
++ /*
++ * Start reading blocks to send or simply send the CSW if the host
++ * didn't actually ask for a non-zero length.
++ */
++ return (msc->TransferLength_in_blocks) ? msc_start_reading_block_data(msc->function, msc) :
++ msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++}
++
++
++/*! msc_start_reading_block_data - start reading data
++ *
++ * Generate a generic block io request to read some data to transmit.
++ *
++ * This function is initially called by msc_scsi_read_10() but can also be called
++ * by msc_urb_sent() if the amount of data requested was too large.
++ *
++ * The function msc_block_read_finished() will be called to actually send the data
++ * to the host when the I/O request is complete.
++ *
++ */
++int msc_start_reading_block_data(struct usbd_function_instance *function, struct msc_private *msc)
++{
++ int TransferLength_in_blocks = MIN(msc->max_blocks, msc->TransferLength_in_blocks);
++ unsigned long flags;
++
++ TRACE_MSG3(MSC,"START READING BLOCK DATA lba: %x blocks: %d %d ",
++ msc->lba, msc->TransferLength_in_blocks, TransferLength_in_blocks);
++
++ /* ensure that device state is ok
++ */
++ if (msc->block_dev_state != DEVICE_INSERTED) {
++ TRACE_MSG0(MSC,"START READ MEDIA NOT PRESENT");
++ return msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_MEDIA_NOT_PRESENT, msc->lba, USB_MSC_FAILED);
++ }
++
++ // XXX an ioctl has requested that pending io be aborted
++ local_irq_save(flags);
++ if (msc->io_state & MSC_ABORT_IO) {
++ msc->io_state &= ~MSC_ABORT_IO;
++ TRACE_MSG0(MSC,"BLOCK READ ABORTED");
++ local_irq_restore(flags);
++ return msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_UNRECOVERED_READ_ERROR, msc->lba, USB_MSC_FAILED);
++ }
++ local_irq_restore(flags);
++
++ /* sanity check lba against capacity
++ */
++ if (msc->lba >= msc->capacity) {
++ TRACE_MSG2(MSC, "START READ LBA out of range: lba: %d capacity: %d", msc->lba, msc->capacity);
++ return msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_BLOCK_ADDRESS_OUT_OF_RANGE, msc->lba, USB_MSC_FAILED);
++ }
++
++ /* setup buffer head - msc_block_read_finished() will be called when block i/o is finished
++ */
++ msc->read_bh.b_end_io = msc_block_read_finished;
++ msc->read_bh.b_size = TransferLength_in_blocks * msc->block_size;
++ msc->read_bh.b_rsector = msc->lba;
++ msc->read_bh.b_state = (1UL << BH_Mapped) | (1UL << BH_Lock);
++ msc->io_state |= MSC_BLOCKIO_PENDING;
++ msc->read_pending=1;
++
++ memset(msc->read_bh.b_data, 0x0, msc->read_bh.b_size);
++
++ generic_make_request(READ, &msc->read_bh);
++ generic_unplug_device(blk_get_queue(msc->read_bh.b_rdev));
++ return 0;
++}
++
++
++/*! msc_block_read_finished - called by generic request
++ *
++ * Called when block i/o read is complete, send the data to the host if possible.
++ *
++ * The function msc_urb_sent() will be called when the data is sent to
++ * either send additional data or the CSW as appropriate.
++ *
++ * If more data is required then call msc_start_reading_block_data() to
++ * issue another block i/o to get more data.
++ *
++ * These means that there can be two outstanding actions when this
++ * function completes:
++ *
++ * 1. a transmit urb may be pending, sending the most recently
++ * read data to the host
++ * 2. another block i/o may be pending to read additional data
++ *
++ * This leads to a race condition, if the block i/o finished before the urb
++ * transmit, then we must simply exit. The msc_in_read_10_urb_sent()
++ * function will ensure that this is restarted.
++ */
++void msc_block_read_finished(struct buffer_head *bh, int uptodate)
++{
++ //struct msc_private *msc = bh->b_private;
++ //int TransferLength_in_blocks = bh->b_size / msc->block_size;
++
++ struct msc_private *msc;
++ int TransferLength_in_blocks;
++
++ struct usbd_function_instance *function;
++ struct usbd_urb *tx_urb;
++ unsigned long flags;
++ int rc;
++#ifdef CONFIG_OTG_MSC_BLOCK_TRACE
++ u32 crc;
++#endif /* CONFIG_OTG_MSC_BLOCK_TRACE */
++ int i;
++
++ msc = bh->b_private;
++ TransferLength_in_blocks = bh->b_size / msc->block_size;
++
++ TRACE_MSG1(MSC,"BLOCK READ FINISHED size: %x", bh->b_size);
++
++ #if 0
++ local_irq_save(flags);
++ if (msc->io_state & MSC_IOCTL_WAITING) {
++ wake_up_interruptible(&msc->ioctl_wq);
++ msc->io_state &= ~MSC_IOCTL_WAITING;
++ }
++ local_irq_restore(flags);
++ #endif
++
++ wake_up_interruptible(&msc->ioctl_wq);
++
++ /*
++ * Race condition here, if we have not finished sending the
++ * previous tx_urb then we want to simply exit and let
++ * msc_in_read_10_urb_sent() call us again.
++ *
++ * Ensure that we do not reset BLOCKIO flags if SEND PENDING and
++ * that we do reset BLOCKIO if not SEND PENDING
++ */
++ {
++ unsigned long flags;
++ local_irq_save(flags);
++ if (msc->io_state & MSC_SEND_PENDING) {
++ TRACE_MSG0(MSC,"BLOCK READ SEND PENDING");
++ msc->io_state |= MSC_BLOCKIO_FINISHED;
++ msc->uptodate = uptodate;
++ local_irq_restore(flags);
++ return;
++ }
++ msc->io_state &= ~(MSC_BLOCKIO_PENDING | MSC_BLOCKIO_FINISHED);
++
++ local_irq_restore(flags);
++ }
++
++ /* verify that the I/O completed
++ */
++ if (1 != uptodate) {
++ TRACE_MSG0(MSC,"BLOCK READ FAILED");
++ msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_UNRECOVERED_READ_ERROR, msc->lba, USB_MSC_FAILED);
++ return;
++ }
++
++#ifdef CONFIG_OTG_MSC_BLOCK_TRACE
++ /* debug output trace - dump rlba and computed crc
++ */
++ for (i = 0; i < bh->b_size / msc->block_size; i++) {
++ crc = crc32_compute(bh->b_data + (i * msc->block_size), msc->block_size, CRC32_INIT);
++ TRACE_RLBA(bh->b_rsector + i, crc);
++ }
++#endif /* CONFIG_OTG_MSC_BLOCK_TRACE */
++ /* allocate a tx_urb and copy into it
++ */
++ THROW_IF(!(function = msc->function), error);
++ THROW_IF(!(tx_urb = usbd_alloc_urb (function, BULK_IN, bh->b_size, msc_urb_sent)), error);
++ TRACE_MSG1(MSC,"BLOCK READ FINISHED urb: %p", (int)tx_urb);
++
++ tx_urb->function_privdata = msc;
++ tx_urb->actual_length = tx_urb->buffer_length = bh->b_size;
++ memcpy(tx_urb->buffer, bh->b_data, bh->b_size);
++
++ msc->read_pending=0;
++
++ {
++ unsigned long flags;
++ local_irq_save(flags);
++
++ msc->io_state |= MSC_SEND_PENDING;
++ msc->TransferLength_in_bytes -= bh->b_size;
++ msc->TransferLength_in_blocks -= TransferLength_in_blocks;
++ msc->lba += TransferLength_in_blocks;
++
++ if (!msc->TransferLength_in_blocks) {
++ TRACE_MSG0(MSC,"BLOCK READ FINISHED - IO FINISHED");
++ // set flag so that CSW can be sent
++ msc->io_state |= MSC_DATA_IN_READ_FINISHED;
++ }
++ local_irq_restore(flags);
++ }
++
++ /* dispatch urb - msc_urb_sent() will be called when urb is finished
++ */
++ if ((rc = usbd_start_in_urb (tx_urb))) {
++ TRACE_MSG0(MSC,"BLOCK READ FINISHED FAILED");
++ usbd_free_urb (tx_urb);
++ THROW(error);
++ }
++
++ /* if more data is required then call msc_start_reading_block_data() to
++ * issue another block i/o to get more data.
++ */
++ if (!(msc->io_state & MSC_DATA_IN_READ_FINISHED)) {
++ TRACE_MSG0(MSC,"BLOCK READ SEND RESTARTING");
++ msc_start_reading_block_data(msc->function, msc);
++ }
++
++ CATCH(error) {
++ TRACE_MSG0(MSC,"BLOCK READ FINISHED ERROR");
++ // stall?
++ }
++}
++
++/*! msc_in_read_10_urb_sent - called by msc_urb_sent when state is MSC_DATA_IN_READ
++ *
++ * This will process a read_10 urb that has been sent. Specifically if any previous
++ * read_10 block I/O has finished we recall the msc_block_read_finished() function
++ * to transmit another read_10 urb.
++ *
++ * If there is no other pending read_10 to do we create and send a CSW.
++ *
++ * If there is more I/O to do or there is already an outstanding I/O we simply
++ * return after freeing the URB.
++ *
++ * Return non-zero if urb was not disposed of.
++ */
++int msc_in_read_10_urb_sent(struct usbd_urb *tx_urb, struct msc_private *msc)
++{
++ unsigned long flags;
++
++ TRACE_MSG0(MSC,"URB SENT DATA IN");
++
++ /*
++ * Potential race condition here, we may need to restart blockio.
++ */
++ local_irq_save(flags);
++
++ msc->io_state &= ~MSC_SEND_PENDING;
++ msc->data_transferred_in_bytes += tx_urb->actual_length;
++
++ TRACE_MSG1(MSC,"URB SENT DATA IN data transferred: %d", msc->data_transferred_in_bytes);
++
++ if (!tx_urb->actual_length)
++ msc->TransferLength_in_blocks = 0;
++
++ /* XXX We should be checking urb status
++ */
++
++ usbd_free_urb (tx_urb);
++
++ /*
++ * Check to see if we need to send CSW.
++ */
++ if (MSC_DATA_IN_READ_FINISHED & msc->io_state) {
++ TRACE_MSG0(MSC,"URB SENT DATA IN - FINISHED SENDING CSW");
++ local_irq_restore(flags);
++ return msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++ }
++ /*
++ * Check to see if there is a block read needs to be finished.
++ */
++ if (MSC_BLOCKIO_FINISHED & msc->io_state) {
++ TRACE_MSG0(MSC,"URB SENT DATA IN - RESTART");
++ local_irq_restore(flags);
++ // XXX uptodate?
++ msc_block_read_finished(&msc->read_bh, msc->uptodate);
++ return 0;
++ }
++ local_irq_restore(flags);
++ return 0;
++}
++
++
++/* WRITE 10 - receive data from host and write to block device ********************************* */
++
++int msc_start_receiving_data(struct usbd_function_instance *function, struct msc_private *msc);
++void msc_data_written(struct buffer_head *bh, int flag);
++void msc_data_test(struct buffer_head *bh, int flag);
++
++/*! msc_scsi_write_10 - process a write command
++ *
++ * Call either msc_start_receiving_data() or msc_start_sending_csw() as appropriate.
++ * Normally msc_start_receiving_data() is called and it will use msc_start_recv_urb()
++ * to setup a receive urb of the appropriate size.
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_write_10(struct msc_private *msc, char *name, int op)
++{
++ SCSI_WRITE_10_COMMAND *command = (SCSI_WRITE_10_COMMAND *)&msc->command.CBWCB;
++
++ /* save the CBW and setup for receiving data to be written to the block device
++ */
++ msc->lba = be32_to_cpu(command->LogicalBlockAddress);
++ msc->TransferLength_in_blocks = be16_to_cpu(command->TransferLength);
++ msc->TransferLength_in_bytes = msc->TransferLength_in_blocks * msc->block_size;
++
++ msc->command_state = MSC_DATA_OUT_WRITE;
++ msc->io_state = MSC_INACTIVE;
++
++ TRACE_MSG1(MSC,"RECV WRITE lba: %x", msc->lba);
++ TRACE_MSG1(MSC,"RECV WRITE blocks: %d", msc->TransferLength_in_blocks);
++
++ return (msc->TransferLength_in_blocks) ?
++ msc_start_receiving_data(msc->function, msc) :
++ msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++}
++
++
++/*! msc_start_receiving_data - called to initiate an urb to receive WRITE(10) data
++ *
++ * Initiate a receive urb to receive upto PAGE_SIZE WRITE(10) data. The
++ * msc_recv_urb() function will call msc_recv_out_blocks() to actually
++ * write the data.
++ *
++ * This is called from msc_scsi_write_10() to initiate the WRITE(10) and
++ * called from msc_data_written() to start the next page sized receive
++ * urb.
++ */
++int msc_start_receiving_data(struct usbd_function_instance *function, struct msc_private *msc)
++{
++ /*
++ * Calculating the length is most of the work we do :-)
++ */
++ int TransferLength_in_blocks = MIN(msc->max_blocks, msc->TransferLength_in_blocks);
++
++ TRACE_MSG1(MSC,"START RECEIVING DATA lba: %x", msc->lba);
++ TRACE_MSG1(MSC,"START RECEIVING DATA blocks: %d", msc->TransferLength_in_blocks);
++ TRACE_MSG1(MSC,"START RECEIVING DATA blocks: %d", TransferLength_in_blocks);
++ TRACE_MSG1(MSC,"START RECEIVING DATA bytes: %d", TransferLength_in_blocks * msc->block_size);
++
++ THROW_IF(msc->command_state != MSC_DATA_OUT_WRITE, error);
++ THROW_IF(!msc->TransferLength_in_blocks, error);
++
++ msc->io_state |= MSC_RECV_PENDING;
++
++ return msc_start_recv_urb(function, msc, TransferLength_in_blocks * msc->block_size);
++
++ CATCH(error) {
++ TRACE_MSG0(MSC,"START RECEIVING DATA ERROR");
++ return -EINVAL;
++ }
++}
++
++
++/*! msc_recv_out_blocks - process received WRITE(10) data by writing to block device
++ *
++ * We get here indirectly from msc_recv_urb() when state is MSC_DATA_OUT_WRITE.
++ *
++ * Dealloc the urb and call Initiate the generic request to write the
++ * received data. The b_end_io function msc_data_written() will send the
++ * CSW.
++ *
++ */
++void msc_recv_out_blocks(struct usbd_urb *rcv_urb, struct msc_private *msc)
++{
++ int TransferLength_in_bytes = rcv_urb->actual_length;
++ int TransferLength_in_blocks = TransferLength_in_bytes / msc->block_size;
++#ifdef CONFIG_OTG_MSC_BLOCK_TRACE
++ u32 crc;
++#endif /* CONFIG_OTG_MSC_BLOCK_TRACE */
++ int i;
++
++ TRACE_MSG1(MSC,"RECV OUT bytes: %d", TransferLength_in_bytes);
++ TRACE_MSG1(MSC,"RECV OUT iostate: %x", msc->io_state);
++ TRACE_MSG1(MSC,"RECV OUT data transferred: %d", msc->data_transferred_in_bytes);
++
++ /*
++ * Race condition here, we may get to here before the previous block
++ * write completed. If so just exit and the msc_data_written()
++ * function will recall us.
++ */
++ {
++ unsigned long flags;
++ local_irq_save(flags);
++ if (msc->io_state & MSC_BLOCKIO_PENDING) {
++ TRACE_MSG0(MSC,"RECV OUT BLOCKIO PENDING");
++ msc->io_state |= MSC_RECV_FINISHED;
++ msc->rcv_urb_finished = rcv_urb;
++ local_irq_restore(flags);
++ return;
++ }
++ msc->io_state &= ~(MSC_RECV_PENDING |MSC_RECV_FINISHED);
++ local_irq_restore(flags);
++ }
++
++ msc->data_transferred_in_bytes += rcv_urb->actual_length;
++
++#ifdef CONFIG_OTG_MSC_BLOCK_TRACE
++ for (i = 0; i < TransferLength_in_blocks; i++) {
++ crc = crc32_compute(rcv_urb->buffer + (i * msc->block_size), msc->block_size, CRC32_INIT);
++ TRACE_SLBA(msc->lba + i, crc);
++ }
++#endif /* CONFIG_OTG_MSC_BLOCK_TRACE */
++
++ msc->write_pending=1;
++
++ memcpy(msc->write_bh.b_data, rcv_urb->buffer, rcv_urb->actual_length);
++
++ usbd_free_urb(rcv_urb);
++
++ /* ensure media state is ok
++ */
++ if (msc->block_dev_state != DEVICE_INSERTED) {
++ TRACE_MSG0(MSC,"START READ MEDIA NOT PRESENT");
++ msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_MEDIA_NOT_PRESENT, msc->lba, USB_MSC_FAILED);
++ return;
++ }
++
++ // XXX an ioctl has requested that pending io be aborted
++ if (msc->io_state & MSC_ABORT_IO) {
++ unsigned long flags;
++ local_irq_save(flags);
++ msc->io_state &= ~MSC_ABORT_IO;
++ TRACE_MSG0(MSC,"BLOCK READ ABORTED");
++ local_irq_restore(flags);
++ msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_UNRECOVERED_READ_ERROR, msc->lba, USB_MSC_FAILED);
++ return;
++ }
++
++ /* sanity check lba against capacity
++ */
++ if (msc->lba >= msc->capacity) {
++ TRACE_MSG2(MSC, "START READ LBA out of range: lba: %d capacity: %d", msc->lba, msc->capacity);
++ msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_BLOCK_ADDRESS_OUT_OF_RANGE, msc->lba, USB_MSC_FAILED);
++ return;
++ }
++
++ /* additional sanity check for lba - ensure non-zero
++ */
++ if (!msc->TransferLength_in_blocks) {
++ TRACE_MSG0(MSC,"START READ LBA TransferLength_in_blocks zero:");
++ msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_BLOCK_ADDRESS_OUT_OF_RANGE, msc->lba, USB_MSC_FAILED);
++ return;
++ }
++
++ /* XXX additional sanity check required here - verify that the transfer
++ * size agrees with what we where expecting, specifically I think
++ * we need to verify that we have received a multiple of the block
++ * size and either a full bulk transfer (so more will come) or
++ * the actual exact amount that the host said it would send.
++ * An error should generate a CSW with a USB_MSC_PHASE_ERROR
++ */
++
++
++ TRACE_MSG1(MSC,"RECV OUT lba: %x", msc->lba);
++ TRACE_MSG1(MSC,"RECV OUT blocks left: %d", msc->TransferLength_in_blocks);
++ TRACE_MSG1(MSC,"RECV OUT blocks current: %d", TransferLength_in_blocks);
++
++ /* Initiate writing the data - msc_data_written() will be called
++ * when finished.
++ */
++ msc->write_bh.b_end_io = msc_data_written;
++
++ /* set address in buffer head
++ */
++ msc->write_bh.b_size = TransferLength_in_bytes;
++ msc->write_bh.b_rsector = msc->lba;
++
++ /* decrement counters and increment address
++ */
++ msc->TransferLength_in_bytes -= TransferLength_in_bytes;
++ msc->TransferLength_in_blocks -= TransferLength_in_blocks;
++ msc->lba += TransferLength_in_blocks;
++ msc->write_bh.b_state = (1UL << BH_Mapped) | (1UL << BH_Lock);
++ msc->io_state |= MSC_BLOCKIO_PENDING;
++
++
++ /* Check current status of TransferLength - if non-zero then we need
++ * to queue another urb to receive more data.
++ */
++ if (!msc->TransferLength_in_blocks)
++ msc->command_state = MSC_DATA_OUT_WRITE_FINISHED;
++ else
++ msc_start_receiving_data(msc->function, msc);
++
++ /* initiate the block i/o request
++ */
++ generic_make_request(WRITE, &msc->write_bh);
++ generic_unplug_device(blk_get_queue(msc->write_bh.b_rdev));
++}
++
++
++/*! msc_data_written - called by generic request
++ *
++ * Called when current block i/o read is finished, restart block i/o or send the CSW.
++ *
++ */
++void msc_data_written(struct buffer_head *bh, int uptodate)
++{
++ struct msc_private *msc = bh->b_private;
++ unsigned long flags;
++ u8 io_state;
++
++ TRACE_MSG4(MSC,"DATA WRITTEN uptodate: %x b_state: %x state: %x io: %x",
++ uptodate, bh->b_state, msc->command_state, msc->io_state);
++
++ TRACE_MSG1(MSC,"DATA WRITTEN lba: %x", msc->lba);
++
++ local_irq_save(flags);
++ io_state = msc->io_state &= ~MSC_BLOCKIO_PENDING;
++ msc->write_pending=0;
++
++ local_irq_restore(flags);
++
++ // XXX an ioctl has waited for io to complete, need to wake it up
++ #if 0
++ local_irq_save(flags);
++ if (msc->io_state & MSC_IOCTL_WAITING) {
++ wake_up_interruptible(&msc->ioctl_wq);
++ msc->io_state &= ~MSC_IOCTL_WAITING;
++ }
++ local_irq_restore(flags);
++ #endif
++
++ wake_up_interruptible(&msc->ioctl_wq);
++
++ /*
++ * verify that the I/O completed
++ */
++ if (1 != uptodate) {
++ TRACE_MSG0(MSC,"BLOCK READ FAILED");
++ msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_UNRECOVERED_READ_ERROR, msc->lba, USB_MSC_FAILED);
++ // XXX CHECKME
++ if (msc->rcv_urb_finished) {
++ usbd_free_urb(msc->rcv_urb_finished);
++ msc->rcv_urb_finished = NULL;
++ }
++ return;
++ }
++
++ /*
++ * If there was a rcv_urb that was not processed then we need
++ * to process it now. This is done by simply restarting msc_recv_out()
++ */
++ if ((io_state & MSC_RECV_FINISHED) && msc->rcv_urb_finished) {
++ struct usbd_urb *rcv_urb = msc->rcv_urb_finished;
++ msc->rcv_urb_finished = NULL;
++ TRACE_MSG0(MSC,"DATA WRITTEN RECV FINISHED");
++ msc_recv_out_blocks(rcv_urb, msc);
++ }
++ /*
++ * DATA_IN mode and no more data to write
++ */
++ if (MSC_DATA_OUT_WRITE_FINISHED == msc->command_state) {
++ // finished, send CSW
++ TRACE_MSG0(MSC,"DATA WRITTEN send CSW");
++ msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++ }
++}
++
++extern struct usbd_function_operations msc_function_ops;
++extern struct usbd_function_driver msc_function_driver;
++
++
++/* USB Module init/exit ************************************************************************ */
++
++int msc_io_init_l24(void);
++void msc_io_exit_l24(void);
++
++/*! msc_modinit - module init
++ *
++ */
++static int msc_modinit (void)
++{
++ int rc;
++ struct msc_private *msc = &msc_private;
++
++ printk(KERN_INFO "Copyright (c) 2004 Belcarra Technologies; www.belcarra.com; sl@belcarra.com\n");
++ printk (KERN_INFO "%s vendor_id: %04x product_id: %04x major: %d minor: %d\n", __FUNCTION__,
++ vendor_id, product_id, major, minor);
++
++
++ MSC = otg_trace_obtain_tag();
++
++ if (vendor_id)
++ msc_function_driver.idVendor = cpu_to_le16(vendor_id);
++ if (product_id)
++ msc_function_driver.idProduct = cpu_to_le16(product_id);
++
++ init_waitqueue_head(&msc->msc_wq);
++ init_waitqueue_head(&msc->ioctl_wq);
++
++ msc->block_dev_state = DEVICE_EJECTED;
++
++
++ msc->command_state = MSC_READY;
++ msc->io_state = MSC_INACTIVE;
++
++#ifdef CONFIG_OTG_MSC_BLOCK_TRACE
++ make_crc_table();
++#endif /* CONFIG_OTG_MSC_BLOCK_TRACE */
++
++ TRACE_MSG3(MSC,"PAGE_SHIFT: %x PAGE_SIZE: %x %d", PAGE_SHIFT, PAGE_SIZE, PAGE_SIZE);
++
++ THROW_IF(msc_io_init_l24(), error);
++
++ /* register as usb function driver
++ */
++ THROW_UNLESS ((msc->function = usbd_register_function (&msc_function_driver, "msc", NULL)), error);
++ msc->usb_driver_registered++;
++
++ CATCH(error) {
++ if (msc->usb_driver_registered) {
++ usbd_deregister_function (msc->function);
++ msc->usb_driver_registered = 0;
++ }
++ otg_trace_invalidate_tag(MSC);
++ return -EINVAL;
++ }
++ return 0;
++}
++
++/*! msc_modexit - module cleanup
++ */
++static void msc_modexit (void)
++{
++ struct msc_private *msc = &msc_private;
++
++ /* destroy control io interface
++ */
++ msc_io_exit_l24();
++
++ /* flush io and free page buffers
++ */
++ msc_close_blockdev(msc);
++
++ if (msc->usb_driver_registered)
++ usbd_deregister_function (msc->function);
++
++#ifdef CONFIG_OTG_MSC_BLOCK_TRACE
++ free_crc_table();
++#endif /* CONFIG_OTG_MSC_BLOCK_TRACE */
++ otg_trace_invalidate_tag(MSC);
++}
++
++
++module_init (msc_modinit);
++module_exit (msc_modexit);
++
+diff -uNr linux/drivers/no-otg/functions/msc/msc-original.c linux/drivers/otg/functions/msc/msc-original.c
+--- linux/drivers/no-otg/functions/msc/msc-original.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/msc-original.c 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,2209 @@
++/*
++ * otg/msc_fd/msc.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 Mass Storage Class Function that uses the Bulk Only protocol.
++ *
++ * To use simply load with something like:
++ *
++ * insmod msc_fd.o vendor_id=0xffff product_id=0xffff
++ *
++ * Notes:
++ *
++ * 1. Currently block I/O is done a page at a time. I have not determined if
++ * it is possible to dispatch a multiple page generic request. It should at
++ * least be possible to queue page requests.
++ *
++ * 2. Currently for READ operations we have a maximum of one outstanding
++ * read block I/O and send urb. These are allowed to overlap so that we can
++ * continue to read data while sending data to the host.
++ *
++ * 3. Currently for WRITE operations we have a maximum of one outstanding
++ * recv urb and one outstanding write block I/O. These are allowed to
++ * overlap so that we can continue to receive data from the host while
++ * waiting for writing to complete.
++ *
++ * 4. It would be possible to allow multiple writes to be pending, to the
++ * limit of the page cache, if desired.
++ *
++ * 5. It should be possible to allow multiple outstanding reads to be
++ * pending, to the limit of the page cache, but this potentially could
++ * require dealing with out of order completions of the reads. Essentially a
++ * list of completed buffer heads would be required to hold any completed
++ * buffer heads that cannot be sent prior to another, earlier request being
++ * completed.
++ *
++ * 6. Currently we only support the Bulk Only model. Microsoft states that
++ * further support for the mass storage driver will only be done for devices
++ * that conform to the Bulk Only model.
++ *
++ * 7. Multiple LUN's are not supported, but in theory they could be.
++ *
++ * 8. It should be possible to use the removalble disk model to allow for a
++ * hotplug script to umount locally and signal that the block device is now
++ * available. An insertion event would notify the host that it can now use
++ * the device. Similarily applications could notify us to send a removal
++ * event to the host so that the device can be mounted locally.
++ *
++ * 9. Error handling should be done with STALL but using ZLP seems to also
++ * work. ZLP is usually easier to implement (except possibly on the SA1100.)
++ * We may need to make STALL an option if we find devices (perhaps SA1100)
++ * that cannot reliaby send a ZLP on BULK-IN endpoint.
++ *
++ *
++ * 10. WinXP will match the following:
++ *
++ * USB\Class_08&SubClass_02&Prot_50
++ * USB\Class_08&SubClass_05&Prot_50
++ * USB\Class_08&SubClass_06&Prot_50
++ *
++ * SubClass 02 is MMC or SFF8020I
++ * SubClass 05 is SFF or SFF8070I
++ * SubClass 06 is SCSI
++ *
++ * From the Windows USB Storage FAQ:
++ *
++ * RBC not supported
++ *
++ * SubClass = 6 (SCSI)
++ * CDBs SHOULD NOT be padded to 12 bytes
++ * ModeSense/ModeSelect SHOULD NOT be translated from 1ah/15h to 5ah/55h
++ * should be used for FLASH
++ *
++ * SubClass !=6
++ * CDBs SHOULD be padded to 12 bytes
++ * ModeSense/ModeSelect SHOULD be translated from 1ah/15h to 5ah/55h
++ *
++ * We are using the former, SubClass = 6, and implement the required SCSI operations.
++ *
++ *
++ * TODO
++ *
++ * 1. error handling for block io, e.g. what if using with removable block
++ * device (like CF card) and it is removed.
++ *
++ * 2. Currently we memcpy() data from between the urb buffer and buffer
++ * head page. It should be possible to simply use the page buffer for the
++ * urb.
++ *
++ * 3. Should we offer using fileio as an option? This would allow direct access
++ * to a block device image stored in a normal file or direct access to (for example)
++ * ram disks. It would require implementing a separate file I/O kernel thread to
++ * do the actual I/O.
++ *
++ *
++ * TODO FIXME Bus Interface Notes
++ *
++ * 1. The bus interface driver must correctly implement NAK'ing if not rcv_urb is
++ * present (see au1x00.c or wmmx.c for examples.)
++ *
++ * 2. The bus interface driver must implement USBD_URB_SENDZLP flag (see au1x00.c
++ * for example.)
++ *
++ */
++
++#if 1
++#include <otg/otg-compat.h>
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-mesg.h>
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++
++#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 <linux/blkdev.h>
++
++
++#include "msc-scsi.h"
++#include "msc.h"
++#include "crc.h"
++
++static __inline__ void TRACE_SENSE(unsigned int sense, unsigned int info)
++{
++ TRACE_MSG2(MSC, "--> SENSE: %06x INFO: %08x", sense, info);
++}
++static __inline__ void TRACE_RLBA(unsigned int lba, unsigned int crc)
++{
++ TRACE_MSG2(MSC, "<-- rlba [%8x %08x]", lba, crc);
++}
++static __inline__ void TRACE_SLBA(unsigned int lba, unsigned int crc)
++{
++ TRACE_MSG2(MSC, "--> slba [%8x %08x]", lba, crc);
++}
++static __inline__ void TRACE_TLBA(unsigned int lba, unsigned int crc)
++{
++ TRACE_MSG2(MSC, "--> tlba [%8x %08x]", lba, crc);
++}
++static __inline__ void TRACE_TAG(unsigned int tag, unsigned int frame)
++{
++ TRACE_MSG2(MSC, "--> TAG: %8x FRAME: %03x", tag, frame);
++}
++static __inline__ void TRACE_CBW(char *msg, int val)
++{
++ TRACE_MSG2(MSC, " --> %s %02x", msg, val);
++}
++static __inline__ void TRACE_RECV(unsigned char *cp)
++{
++ TRACE_MSG8(MSC, "<-- recv [%02x %02x %02x %02x %02x %02x %02x %02x]",
++ cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
++}
++static __inline__ void TRACE_SENT(unsigned char *cp)
++{
++ TRACE_MSG8(MSC, "--> sent [%02x %02x %02x %02x %02x %02x %02x %02x]",
++ cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
++}
++
++
++#else
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++
++MODULE_AUTHOR ("sl@belcarra.com, tbr@belcarra.com");
++MODULE_LICENSE("PROPRIETARY");
++MODULE_DESCRIPTION ("Belcarra Mass Storage Class Bulk Only 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 <linux/blkdev.h>
++
++#include "usbp-chap9.h"
++#include <usbp-mem.h>
++#include <otg-compat.h>
++#include <usbp-func.h>
++
++USBD_MODULE_INFO ("msc_fd 2.0-beta");
++
++#include "msc-scsi.h"
++#include "msc.h"
++
++#include "trace.h"
++#include "crc.h"
++#endif
++
++//#include "rbc.h"
++
++
++/* Module Parameters ************************************************************************* */
++
++static u32 vendor_id;
++static u32 product_id;
++
++static u32 major;
++static u32 minor;
++
++MODULE_PARM (vendor_id, "i");
++MODULE_PARM (product_id, "i");
++MODULE_PARM (major, "i");
++MODULE_PARM (minor, "i");
++
++MODULE_PARM_DESC (vendor_id, "Device Vendor ID");
++MODULE_PARM_DESC (product_id, "Device Product ID");
++MODULE_PARM_DESC (major, "Device Major");
++MODULE_PARM_DESC (minor, "Device Minor");
++
++/*
++ * MSC Configuration
++ *
++ * Endpoint, Class, Interface, Configuration and Device descriptors/descriptions
++ */
++
++#define BULK_OUT 0x00
++#define BULK_IN 0x01
++#define ENDPOINTS 0x02
++
++/*
++ * Mass Storage Class - Bulk Only
++ *
++ * Endpoint, Class, Interface, Configuration and Device descriptors/descriptions
++ */
++
++static u8 msc_data_1[] = { 0x07, USB_DT_ENDPOINT, USB_DIR_OUT, BULK, 0, 0x00, 0x00, };
++static u8 msc_data_2[] = { 0x07, USB_DT_ENDPOINT, USB_DIR_IN, BULK, 0, 0x00, 0x00, };
++static struct usbd_endpoint_descriptor *msc_default[] = {
++ (struct usbd_endpoint_descriptor *) msc_data_1,
++ (struct usbd_endpoint_descriptor *) msc_data_2, };
++u8 msc_indexes[] = { BULK_OUT, BULK_IN, };
++
++
++/* Endpoint, Interface, Configuration and Device descriptions and descriptors
++ */
++static u8 msc_data_alternate_descriptor[sizeof(struct usbd_interface_descriptor)] = {
++ 0x09, USB_DT_INTERFACE,
++ 0x00, 0x00, // bInterfaceNumber, bAlternateSetting
++ sizeof (msc_default) / sizeof(struct usbd_endpoint_descriptor), // bNumEndpoints
++ MASS_STORAGE_CLASS,
++ MASS_STORAGE_SUBCLASS_SCSI,
++ MASS_STORAGE_PROTO_BULK_ONLY,
++ 0x00,
++};
++
++static struct usbd_alternate_description msc_data_alternate_descriptions[] = {
++ { iInterface: CONFIG_OTG_MSC_INTF,
++ interface_descriptor: (struct usbd_interface_descriptor *)&msc_data_alternate_descriptor,
++ endpoints:sizeof (msc_default) / sizeof(struct usbd_endpoint_descriptor *),
++ endpoint_list: msc_default,
++ endpoint_indexes: msc_indexes,
++ },
++};
++
++
++struct usbd_interface_description msc_interfaces[] = {
++ { alternates:sizeof (msc_data_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ alternate_list:msc_data_alternate_descriptions,},
++};
++
++u8 msc_configuration_descriptor[sizeof(struct usbd_configuration_descriptor)] = {
++ 0x09, USB_DT_CONFIGURATION, 0x00, 0x00, // wLength
++ sizeof (msc_interfaces) / sizeof (struct usbd_interface_description),
++ 0x01, 0x00, // bConfigurationValue, iConfiguration
++ 0, 0,
++};
++
++struct usbd_configuration_description msc_description[] = {
++ { iConfiguration: CONFIG_OTG_MSC_DESC,
++ configuration_descriptor: (struct usbd_configuration_descriptor *)msc_configuration_descriptor,
++ },
++};
++
++
++static struct usbd_device_descriptor msc_device_descriptor = {
++ bLength: sizeof(struct usbd_device_descriptor),
++ bDescriptorType: USB_DT_DEVICE,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: 0x00,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++ idVendor: __constant_cpu_to_le16(CONFIG_OTG_MSC_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_MSC_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_MSC_BCDDEVICE),
++};
++
++#ifdef CONFIG_OTG_HIGH_SPEED
++static struct usbd_device_qualifier_descriptor msc_device_qualifier_descriptor = {
++ bLength: sizeof(struct usbd_device_qualifier_descriptor),
++ bDescriptorType: USB_DT_DEVICE_QUALIFIER,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: 0x00,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++};
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++
++
++
++static struct usbd_endpoint_request msc_endpoint_requests[ENDPOINTS+1] = {
++ { 1, 0, 0, USB_DIR_OUT | USB_ENDPOINT_BULK, PAGE_SIZE, PAGE_SIZE, },
++ { 1, 0, 0, USB_DIR_IN | USB_ENDPOINT_BULK, PAGE_SIZE, PAGE_SIZE, },
++ { 0, },
++};
++
++struct usbd_otg_descriptor msc_otg_descriptor = {
++ bLength : sizeof(struct usbd_otg_descriptor),
++ bDescriptorType: USB_DT_OTG,
++ bmAttributes: 0,
++};
++
++struct usbd_device_description msc_device_description = {
++ device_descriptor: &msc_device_descriptor,
++#ifdef CONFIG_OTG_HIGH_SPEED
++ device_qualifier_descriptor: &msc_device_qualifier_descriptor,
++#endif /* CONFIG_OTG_HIGH_SPEED */
++ otg_descriptor: &msc_otg_descriptor,
++ iManufacturer: CONFIG_OTG_MSC_MANUFACTURER,
++ iProduct: CONFIG_OTG_MSC_PRODUCT_NAME,
++#if !defined(CONFIG_OTG_NO_SERIAL_NUMBER) && defined(CONFIG_OTG_SERIAL_NUMBER_STR)
++ iSerialNumber: CONFIG_OTG_SERIAL_NUMBER_STR,
++#endif
++};
++
++
++#define DEVICE_EJECTED 0x0001 // MEDIA_EJECTED
++#define DEVICE_INSERTED 0x0002 // MEDIA_INSERT
++
++#define DEVICE_OPEN 0x0004 // WR_PROTECT_OFF
++#define DEVICE_WRITE_PROTECTED 0x0008 // WR_PROTECT_ON
++
++#define DEVICE_CHANGE_ON 0x0010 // MEDIA_CHANGE_ON
++
++#define DEVICE_PREVENT_REMOVAL 0x0020
++
++
++#define DEF_NUMBER_OF_HEADS 0x10
++#define DEF_SECTORS_PER_TRACK 0x20
++
++
++
++/* MSC ******************************************************************************************** */
++
++static struct msc_private msc_private;
++int msc_interrupts;
++
++int msc_urb_sent (struct usbd_urb *tx_urb, int rc);
++static int msc_recv_urb (struct usbd_urb *urb, int rc);
++
++
++/* Sense Key *********************************************************************************** */
++
++void set_sense_data(struct msc_private *msc, u32 sensedata, u32 info)
++{
++ TRACE_SENSE(sensedata, info);
++ msc->sensedata = sensedata;
++ msc->info = info;
++}
++
++
++static int msc_reset(void)
++{
++ struct msc_private *msc = &msc_private;
++ msc->device_state = MSC_DEVICE_DN;
++ msc->command_state = MSC_READY;
++ msc->io_state = MSC_INACTIVE;
++ msc->block_dev_state = 0;
++ msc->sensedata = 0;
++ msc->info = 0;
++ return 0;
++}
++
++
++/* Generic start recv urb and send csw ********************************************************* */
++
++/* msc_start_recv - queue a receive urb
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_start_recv_urb(struct usbd_function_instance *function, struct msc_private *msc, int size)
++{
++ struct usbd_urb *rcv_urb = NULL;
++ int wMaxPacketSize;
++
++ TRACE_MSG1(MSC, "START RECV URB size: %d", size);
++
++ // ensure that we are a multiple of the endpoint packetsize
++ wMaxPacketSize = usbd_endpoint_wMaxPacketSize(function, BULK_OUT, usbd_high_speed(function));
++ if ((size % wMaxPacketSize)) {
++ size += wMaxPacketSize;
++ size = (size / wMaxPacketSize) * wMaxPacketSize;
++ }
++
++ // allocate urb and queue it
++ THROW_IF(!(rcv_urb = usbd_alloc_urb (function, BULK_OUT, size, msc_recv_urb)), error);
++ TRACE_MSG1(MSC, "START RECV urb: %p", (int)rcv_urb);
++
++ rcv_urb->function_privdata = msc;
++ msc->rcv_urb_finished = NULL;
++ THROW_IF(usbd_start_out_urb(rcv_urb), error);
++ return 0;
++
++ CATCH(error) {
++ TRACE_MSG0(MSC,"START RECV URB ERROR");
++ if (rcv_urb)
++ usbd_free_urb(rcv_urb);
++ return -EINVAL;
++ }
++}
++
++/* msc_start_sending - start sending a new data or csw urb
++ *
++ * Generate a CSW (Command Status Wrapper) to send to the the host.
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_start_sending_csw(struct usbd_function_instance *function, struct msc_private *msc, u8 status)
++{
++ COMMAND_STATUS_WRAPPER *csw;
++ int length = sizeof(COMMAND_STATUS_WRAPPER);
++ struct usbd_urb *tx_urb;
++
++ TRACE_MSG1(MSC,"START SENDING CSW %08x", status);
++
++ msc->command_state = MSC_STATUS;
++
++ THROW_IF(!(tx_urb = usbd_alloc_urb (function, BULK_IN, length, msc_urb_sent)), error);
++ TRACE_MSG1(MSC,"START sending csw urb: %p", (int)tx_urb);
++ tx_urb->actual_length = length;
++ tx_urb->function_privdata = msc;
++
++ // fill in CSW and queue the urb
++ csw = (COMMAND_STATUS_WRAPPER *) tx_urb->buffer;
++ csw->dCSWSignature = CSW_SIGNATURE;
++ csw->dCSWTag = msc->command.dCBWTag;
++ csw->dCSWDataResidue = msc->command.dCBWDataTransferLength - msc->data_transferred_in_bytes;
++ csw->bCSWStatus = status;
++
++ TRACE_MSG1(MSC,"START SENDING CSW data residue: %d", csw->dCSWDataResidue);
++
++ THROW_IF (usbd_start_in_urb (tx_urb), error);
++
++ CATCH(error) {
++ TRACE_MSG0(MSC,"START SENDING CSW FAILED");
++ if (tx_urb) usbd_free_urb (tx_urb);
++ return -EINVAL;
++ }
++ return 0;
++}
++
++/* msc_start_sending_csw_failed - starting sending a CSW showing failure
++ *
++ * Sets sensedata and generates a CSW with status set to USB_MSC_FAILED.
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_start_sending_csw_failed(struct msc_private *msc, u32 sensedata, u32 info, int status)
++{
++ set_sense_data(msc, sensedata, info);
++ return msc_start_sending_csw(msc->function, msc, status);
++}
++
++
++/* ********************************************************************************************* */
++
++/* msc_alloc_urb - allocate an urb for returning a query
++ *
++ * Returns NULL if there is an error in the USB layer.
++ */
++struct usbd_urb * msc_alloc_urb(struct msc_private *msc, int length)
++{
++ struct usbd_function_instance *function;
++ struct usbd_urb *urb;
++
++ THROW_IF(!(function = msc->function), error);
++ THROW_IF(!(urb = usbd_alloc_urb (function, BULK_IN, length, msc_urb_sent)), error);
++ return urb;
++
++ CATCH(error) {
++ msc->command_state = MSC_READY;
++ return NULL;
++ }
++}
++
++
++/* msc_dispatch_query_urb - dispatch an urb containing query data
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_dispatch_query_urb(struct usbd_urb *urb, struct msc_private *msc, int length, int status)
++{
++ int rc;
++
++ TRACE_MSG1(MSC,"DISPATCH URB len: %d", length);
++
++ // save information in msc and urb
++ //
++ urb->function_privdata = msc;
++ urb->actual_length = msc->TransferLength_in_bytes = length;
++
++ // dispatch urb
++ {
++ unsigned long flags;
++ local_irq_save(flags);
++ if ((rc = usbd_start_in_urb (urb))) {
++
++ TRACE_MSG0(MSC,"DISPATCH URB FAILED");
++ usbd_free_urb (urb);
++
++ // stall?
++ msc->command_state = MSC_READY;
++ local_irq_restore(flags);
++ return -EINVAL;
++ }
++ msc->command_state = MSC_QUERY;
++ msc->status = status;
++ local_irq_restore(flags);
++ }
++ return 0;
++}
++
++
++/* msc_dispatch_query_urb_zlp - send a ZLP
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_dispatch_query_urb_zlp(struct msc_private *msc, u32 sensedata, u32 info, int status)
++{
++ struct usbd_urb *urb;
++ RETURN_EINVAL_IF(!(urb = msc_alloc_urb(msc, 1)));
++ set_sense_data(msc, sensedata, info);
++ urb->flags |= USBD_URB_SENDZLP;
++ return msc_dispatch_query_urb(urb, msc, 0, status);
++}
++
++
++
++/* Block Device ******************************************************************************** */
++
++/* msc_open_blockdev - open the block device specified in msc->major, msc->minor
++ *
++ * Sets appropriate fields to show current status of block device.
++ *
++ * XXX TODO - this needs to be tested against RO and absent devices.
++ *
++ */
++void msc_open_blockdev(struct msc_private *msc)
++{
++ int rc;
++ msc->block_dev_state = DEVICE_EJECTED;
++
++ TRACE_MSG2(MSC, "OPEN BLOCKDEV: Major: %x Minor: %x", major, minor);
++ //printk(KERN_INFO"%s: major: %d minor: %d\n", __FUNCTION__, major, minor);
++
++ /*
++ * Check device information and verify access to the block device.
++ */
++ THROW_IF (!major, ejected);
++
++ msc->dev = MKDEV(major, minor);
++
++ THROW_IF (!(msc->bdev = bdget(kdev_t_to_nr(msc->dev))), ejected);
++
++ if ((rc = blkdev_get(msc->bdev, FMODE_READ | FMODE_WRITE, 0, BDEV_RAW))) {
++
++ TRACE_MSG0(MSC,"OPEN BLOCKDEV: cannot open RW");
++ //printk(KERN_INFO"%s: cannot open RW\n", __FUNCTION__);
++ THROW_IF ((rc = blkdev_get(msc->bdev, FMODE_READ, 0, BDEV_RAW)), ejected);
++ msc->block_dev_state |= DEVICE_WRITE_PROTECTED;
++ }
++
++ msc->block_dev_state &= ~DEVICE_EJECTED;
++ msc->block_dev_state |= DEVICE_INSERTED;
++
++ TRACE_MSG1(MSC,"OPEN BLOCKDEV: opened block_dev_state: %x", msc->block_dev_state);
++
++ /*
++ * Note that capacity must return the LBA of the last addressable block
++ * c.f. RBC 4.4, RBC 5.3 and notes below RBC Table 6
++ *
++ * The blk_size array contains the number of addressable blocks or N,
++ * capacity is therefore N-1.
++ */
++
++ msc->capacity = (blk_size[MAJOR(msc_private.dev)][MINOR(msc_private.dev)] << 1) - 1;
++ msc->block_size = get_hardsect_size(msc->dev);
++ msc->max_blocks = PAGE_SIZE / msc->block_size;
++
++ TRACE_MSG1(MSC,"blk_size: %x", blk_size[MAJOR(msc_private.dev)][MINOR(msc_private.dev)] << 1);
++ TRACE_MSG1(MSC,"blk_size: %d", blk_size[MAJOR(msc_private.dev)][MINOR(msc_private.dev)] << 1);
++
++ TRACE_MSG1(MSC,"capacity: %x", msc->capacity);
++ TRACE_MSG1(MSC,"capacity: %d", msc->capacity);
++
++ TRACE_MSG1(MSC,"block_size: %x", msc->block_size);
++ TRACE_MSG1(MSC,"block_size: %d", msc->block_size);
++
++ TRACE_MSG1(MSC,"max_blocks: %d", msc->max_blocks);
++
++ printk(KERN_INFO"%s: finis\n", __FUNCTION__);
++
++ CATCH(ejected) {
++ TRACE_MSG1(MSC,"OPEN BLOCKDEV: EJECTED block_dev_state: %x", msc->block_dev_state);
++ printk(KERN_INFO"%s: cannot open R)\n", __FUNCTION__);
++ printk(KERN_INFO"%s: Cannot get device %d %d\n", __FUNCTION__, major, minor);
++ }
++}
++
++/* msc_check_blockdev - check current status of the block device
++ *
++ * Check if the block device is operational, generate a failed CSW if not.
++ *
++ * Returns non-zero if the block device is not available for I/O operations
++ * and a failed CSW has already been sent.
++ */
++int msc_check_blockdev(struct msc_private *msc, int zlp)
++{
++ if (msc->block_dev_state & DEVICE_EJECTED) {
++ TRACE_MSG0(MSC,"CHECK BLOCKDEV DEVICE_EJECTED");
++
++ (zlp ? msc_dispatch_query_urb_zlp : msc_start_sending_csw_failed)
++ (msc, SCSI_SENSEKEY_MEDIUM_NOT_PRESENT, msc->lba, USB_MSC_FAILED);
++
++ return -EINVAL;
++ }
++ if (msc->block_dev_state & DEVICE_CHANGE_ON) {
++ TRACE_MSG0(MSC,"CHECK BLOCKDEV DEVICE_CHANGE_ON");
++ (zlp ? msc_dispatch_query_urb_zlp : msc_start_sending_csw_failed)
++ (msc, SCSI_SENSEKEY_NOT_READY_TO_CHANGE, msc->lba, USB_MSC_FAILED);
++ return -EINVAL;
++ }
++ return 0;
++}
++
++
++/* READ 10 COMMAND - read and send data to the host ******************************************** */
++
++int msc_start_reading_block_data(struct usbd_function_instance *function, struct msc_private *msc);
++void msc_block_read_finished(struct buffer_head *bh, int flag);
++
++
++/* msc_scsi_read_10 - process a read(10) command
++ *
++ * We have received a READ(10) CBW, if transfer length is non-zero
++ * initiate a generic block i/o otherwise send a CSW.
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_read_10(struct msc_private *msc, char *name, int op)
++{
++ SCSI_READ_10_COMMAND *command = (SCSI_READ_10_COMMAND *)&msc->command.CBWCB;
++
++ RETURN_ZERO_IF (msc_check_blockdev(msc, 1));
++
++ /*
++ * save the CBW information and setup for transmitting data read from the block device
++ */
++ msc->lba = be32_to_cpu(command->LogicalBlockAddress);
++ msc->TransferLength_in_blocks = be16_to_cpu(command->TransferLength);
++ msc->TransferLength_in_bytes = msc->TransferLength_in_blocks * msc->block_size;
++ msc->command_state = MSC_DATA_IN_READ;
++ msc->io_state = MSC_INACTIVE;
++
++ /*
++ * Start reading blocks to send or simply send the CSW if the host
++ * didn't actually ask for a non-zero length.
++ */
++ return (msc->TransferLength_in_blocks) ? msc_start_reading_block_data(msc->function, msc) :
++ msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++}
++
++
++/* msc_start_reading_block_data - start reading data
++ *
++ * Generate a generic block io request to read some data to transmit.
++ *
++ * This function is initially called by msc_scsi_read_10() but can also be called
++ * by msc_urb_sent() if the amount of data requested was too large.
++ *
++ * The function msc_block_read_finished() will be called to actually send the data
++ * to the host when the I/O request is complete.
++ *
++ */
++int msc_start_reading_block_data(struct usbd_function_instance *function, struct msc_private *msc)
++{
++ int TransferLength_in_blocks = MIN(msc->max_blocks, msc->TransferLength_in_blocks);
++
++ TRACE_MSG1(MSC,"START READING BLOCK DATA lba: %x", msc->lba);
++ TRACE_MSG1(MSC,"START READING BLOCK DATA blocks: %d", msc->TransferLength_in_blocks);
++ TRACE_MSG1(MSC,"START READING BLOCK DATA blocks: %d", TransferLength_in_blocks);
++
++ if (msc->block_dev_state != DEVICE_INSERTED) {
++ TRACE_MSG0(MSC,"START READ MEDIUM NOT PRESENT");
++ return msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_MEDIUM_NOT_PRESENT, msc->lba, USB_MSC_FAILED);
++ }
++
++ if (msc->lba >= msc->capacity) {
++ TRACE_MSG2(MSC, "START READ LBA out of range: lba: %d capacity: %d", msc->lba, msc->capacity);
++ return msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_LOGICAL_BLOCK_OUT_OF_RANGE, msc->lba, USB_MSC_FAILED);
++ }
++
++ // setup buffer head
++ msc->read_bh.b_size = TransferLength_in_blocks * msc->block_size;
++ msc->read_bh.b_end_io = msc_block_read_finished;
++ msc->read_bh.b_rsector = msc->lba;
++ msc->read_bh.b_state = (1UL << BH_Mapped) | (1UL << BH_Lock);
++ msc->io_state |= MSC_BLOCKIO_PENDING;
++ msc->read_bh.b_data = page_address(msc->read_bh.b_page);
++ memset(msc->read_bh.b_data, 0x0, msc->read_bh.b_size);
++
++ generic_make_request(READ, &msc->read_bh);
++ generic_unplug_device(blk_get_queue(msc->read_bh.b_rdev));
++
++ return 0;
++}
++
++
++/* msc_block_read_finished - called by generic request
++ *
++ * Called when block i/o read is complete, send the data to the host if possible.
++ *
++ * The function msc_urb_sent() will be called when the data is sent to
++ * either send additional data or the CSW as appropriate.
++ *
++ */
++void msc_block_read_finished(struct buffer_head *bh, int uptodate)
++{
++ struct msc_private *msc = bh->b_private;
++ int TransferLength_in_blocks = bh->b_size / msc->block_size;
++ struct usbd_function_instance *function;
++ struct usbd_urb *tx_urb;
++ int rc;
++ u32 crc;
++ int i;
++
++ msc_interrupts++;
++ TRACE_MSG1(MSC,"BLOCK READ FINISHED size: %x", bh->b_size);
++
++ /*
++ * Race condition here, if we have not finished sending the
++ * previous tx_urb then we want to simply exit and let
++ * msc_in_read_10_urb_sent() call us again.
++ *
++ * Ensure that we do not reset BLOCKIO flags if SEND PENDING and
++ * that we do reset BLOCKIO if not SEND PENDING
++ */
++ {
++ unsigned long flags;
++ local_irq_save(flags);
++ if (msc->io_state & MSC_SEND_PENDING) {
++ TRACE_MSG0(MSC,"BLOCK READ SEND PENDING");
++ msc->io_state |= MSC_BLOCKIO_FINISHED;
++ msc->uptodate = uptodate;
++ local_irq_restore(flags);
++ return;
++ }
++ msc->io_state &= ~(MSC_BLOCKIO_PENDING | MSC_BLOCKIO_FINISHED);
++ local_irq_restore(flags);
++ }
++
++ // verify that the I/O completed
++ //
++ if (1 != uptodate) {
++ TRACE_MSG0(MSC,"BLOCK READ FAILED");
++ msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_UNRECOVERED_READ_ERROR, msc->lba, USB_MSC_FAILED);
++ return;
++ }
++
++ // debug output trace
++ //
++ for (i = 0; i < bh->b_size / msc->block_size; i++) {
++ crc = crc32_compute(bh->b_data + (i * msc->block_size), msc->block_size, CRC32_INIT);
++ TRACE_RLBA(bh->b_rsector + i, crc);
++ }
++
++ // allocate a tx_urb and copy into it
++ //
++ THROW_IF(!(function = msc->function), error);
++ THROW_IF(!(tx_urb = usbd_alloc_urb (function, BULK_IN, bh->b_size, msc_urb_sent)), error);
++ TRACE_MSG1(MSC,"BLOCK READ FINISHED urb: %p", (int)tx_urb);
++
++ tx_urb->function_privdata = msc;
++ tx_urb->actual_length = tx_urb->buffer_length = bh->b_size;
++ memcpy(tx_urb->buffer, bh->b_data, bh->b_size);
++
++ msc->read_bh.b_data = NULL;
++ {
++ unsigned long flags;
++ local_irq_save(flags);
++
++ msc->io_state |= MSC_SEND_PENDING;
++ msc->TransferLength_in_bytes -= bh->b_size;
++ msc->TransferLength_in_blocks -= TransferLength_in_blocks;
++ msc->lba += TransferLength_in_blocks;
++
++ if (!msc->TransferLength_in_blocks) {
++ TRACE_MSG0(MSC,"BLOCK READ FINISHED - IO FINISHED");
++ // set flag so that CSW can be sent
++ msc->io_state |= MSC_DATA_IN_READ_FINISHED;
++ }
++ local_irq_restore(flags);
++ }
++
++ // dispatch urb
++ if ((rc = usbd_start_in_urb (tx_urb))) {
++ TRACE_MSG0(MSC,"BLOCK READ FINISHED FAILED");
++ usbd_free_urb (tx_urb);
++ THROW(error);
++ }
++ if (!(msc->io_state & MSC_DATA_IN_READ_FINISHED)) {
++ TRACE_MSG0(MSC,"BLOCK READ SEND RESTARTING");
++ msc_start_reading_block_data(msc->function, msc);
++ return;
++ }
++
++ CATCH(error) {
++ TRACE_MSG0(MSC,"BLOCK READ FINISHED ERROR");
++ // stall?
++ }
++}
++
++/* msc_in_read_10_urb_sent - called by msc_urb_sent when state is MSC_DATA_IN_READ
++ *
++ * This will process a read_10 urb that has been sent. Specifically if any previous
++ * read_10 block I/O has finished we recall the msc_block_read_finished() function
++ * to transmit another read_10 urb.
++ *
++ * If there is no other pending read_10 to do we create and send a CSW.
++ *
++ * If there is more I/O to do or there is already an outstanding I/O we simply
++ * return after freeing the URB.
++ *
++ * Return non-zero if urb was not disposed of.
++ */
++int msc_in_read_10_urb_sent(struct usbd_urb *tx_urb, struct msc_private *msc)
++{
++ unsigned long flags;
++
++ TRACE_MSG0(MSC,"URB SENT DATA IN");
++
++ /*
++ * Potential race condition here, we may need to restart blockio.
++ */
++
++ local_irq_save(flags);
++
++ msc->io_state &= ~MSC_SEND_PENDING;
++ msc->data_transferred_in_bytes += tx_urb->actual_length;
++
++ TRACE_MSG1(MSC,"URB SENT DATA IN data transferred: %d", msc->data_transferred_in_bytes);
++
++ if (!tx_urb->actual_length)
++ msc->TransferLength_in_blocks = 0;
++
++ usbd_free_urb (tx_urb);
++
++ /*
++ * Check to see if we need to send CSW.
++ */
++ if (MSC_DATA_IN_READ_FINISHED & msc->io_state) {
++ TRACE_MSG0(MSC,"URB SENT DATA IN - FINISHED SENDING CSW");
++ local_irq_restore(flags);
++ return msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++ }
++ /*
++ * Check to see if there is a block read needs to be finished.
++ */
++ if (MSC_BLOCKIO_FINISHED & msc->io_state) {
++ TRACE_MSG0(MSC,"URB SENT DATA IN - RESTART");
++ local_irq_restore(flags);
++ // XXX uptodate?
++ msc_block_read_finished(&msc->read_bh, msc->uptodate);
++ return 0;
++ }
++ local_irq_restore(flags);
++ return 0;
++}
++
++
++/* WRITE 10 - receive data from host and write to block device ********************************* */
++
++int msc_start_receiving_data(struct usbd_function_instance *function, struct msc_private *msc);
++void msc_data_written(struct buffer_head *bh, int flag);
++void msc_data_test(struct buffer_head *bh, int flag);
++
++/* msc_scsi_write_10 - process a write command
++ *
++ * Call either msc_start_receiving_data() or msc_start_sending_csw() as appropriate.
++ * Normally msc_start_receiving_data() is called and it will use msc_start_recv_urb()
++ * to setup a receive urb of the appropriate size.
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_write_10(struct msc_private *msc, char *name, int op)
++{
++ SCSI_WRITE_10_COMMAND *command = (SCSI_WRITE_10_COMMAND *)&msc->command.CBWCB;
++
++ RETURN_ZERO_IF (msc_check_blockdev(msc, 0));
++
++ // save the CBW and setup for receiving data to be written to the block device
++ //
++ msc->lba = be32_to_cpu(command->LogicalBlockAddress);
++ msc->TransferLength_in_blocks = be16_to_cpu(command->TransferLength);
++ msc->TransferLength_in_bytes = msc->TransferLength_in_blocks * msc->block_size;
++
++ msc->command_state = MSC_DATA_OUT_WRITE;
++ msc->io_state = MSC_INACTIVE;
++
++ TRACE_MSG1(MSC,"RECV WRITE lba: %x", msc->lba);
++ TRACE_MSG1(MSC,"RECV WRITE blocks: %d", msc->TransferLength_in_blocks);
++
++ return (msc->TransferLength_in_blocks) ?
++ msc_start_receiving_data(msc->function, msc) :
++ msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++}
++
++
++/* msc_start_receiving_data - called to initiate an urb to receive WRITE(10) data
++ *
++ * Initiate a receive urb to receive upto PAGE_SIZE WRITE(10) data. The
++ * msc_recv_urb() function will call msc_recv_out_blocks() to actually
++ * write the data.
++ *
++ * This is called from msc_scsi_write_10() to initiate the WRITE(10) and
++ * called from msc_data_written() to start the next page sized receive
++ * urb.
++ *
++ */
++int msc_start_receiving_data(struct usbd_function_instance *function, struct msc_private *msc)
++{
++ /*
++ * Calculating the length is most of the work we do :-)
++ */
++ int TransferLength_in_blocks = MIN(msc->max_blocks, msc->TransferLength_in_blocks);
++
++ TRACE_MSG1(MSC,"START RECEIVING DATA lba: %x", msc->lba);
++ TRACE_MSG1(MSC,"START RECEIVING DATA blocks: %d", msc->TransferLength_in_blocks);
++ TRACE_MSG1(MSC,"START RECEIVING DATA blocks: %d", TransferLength_in_blocks);
++ TRACE_MSG1(MSC,"START RECEIVING DATA bytes: %d", TransferLength_in_blocks * msc->block_size);
++
++ THROW_IF(msc->command_state != MSC_DATA_OUT_WRITE, error);
++ THROW_IF(!msc->TransferLength_in_blocks, error);
++
++ msc->io_state |= MSC_RECV_PENDING;
++
++ return msc_start_recv_urb(function, msc, TransferLength_in_blocks * msc->block_size);
++
++ CATCH(error) {
++ TRACE_MSG0(MSC,"START RECEIVING DATA ERROR");
++ return -EINVAL;
++ }
++}
++
++
++/* msc_recv_out_blocks - process received WRITE(10) data by writing to block device
++ *
++ * We get here indirectly from msc_recv_urb() when state is MSC_DATA_OUT_WRITE.
++ *
++ * Dealloc the urb and call Initiate the generic request to write the
++ * received data. The b_end_io function msc_data_written() will send the
++ * CSW.
++ *
++ */
++void msc_recv_out_blocks(struct usbd_urb *rcv_urb, struct msc_private *msc)
++{
++ int TransferLength_in_bytes = rcv_urb->actual_length;
++ int TransferLength_in_blocks = TransferLength_in_bytes / msc->block_size;
++ u32 crc;
++ int i;
++
++ TRACE_MSG1(MSC,"RECV OUT bytes: %d", TransferLength_in_bytes);
++ TRACE_MSG1(MSC,"RECV OUT iostate: %x", msc->io_state);
++ TRACE_MSG1(MSC,"RECV OUT data transferred: %d", msc->data_transferred_in_bytes);
++
++ /*
++ * Race condition here, we may get to here before the previous block
++ * write completed. If so just exit and the msc_data_written()
++ * function will recall us.
++ */
++ {
++ unsigned long flags;
++ local_irq_save(flags);
++ if (msc->io_state & MSC_BLOCKIO_PENDING) {
++ TRACE_MSG0(MSC,"RECV OUT BLOCKIO PENDING");
++ msc->io_state |= MSC_RECV_FINISHED;
++ msc->rcv_urb_finished = rcv_urb;
++ local_irq_restore(flags);
++ return;
++ }
++ msc->io_state &= ~(MSC_RECV_PENDING |MSC_RECV_FINISHED);
++ local_irq_restore(flags);
++ }
++
++ msc->data_transferred_in_bytes += rcv_urb->actual_length;
++
++ for (i = 0; i < TransferLength_in_blocks; i++) {
++ crc = crc32_compute(rcv_urb->buffer + (i * msc->block_size), msc->block_size, CRC32_INIT);
++ TRACE_SLBA(msc->lba + i, crc);
++ }
++
++ msc->write_bh.b_data = page_address(msc->write_bh.b_page);
++ memcpy(msc->write_bh.b_data, rcv_urb->buffer, rcv_urb->actual_length);
++
++ usbd_free_urb(rcv_urb);
++
++ if (msc->block_dev_state != DEVICE_INSERTED) {
++ TRACE_MSG0(MSC,"START READ MEDIUM NOT PRESENT");
++ msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_MEDIUM_NOT_PRESENT, msc->lba, USB_MSC_FAILED);
++ return;
++ }
++
++ if (msc->lba >= msc->capacity) {
++ TRACE_MSG2(MSC, "START READ LBA out of range: lba: %d capacity: %d", msc->lba, msc->capacity);
++ msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_LOGICAL_BLOCK_OUT_OF_RANGE, msc->lba, USB_MSC_FAILED);
++ return;
++ }
++
++ if (!msc->TransferLength_in_blocks) {
++ TRACE_MSG0(MSC,"START READ LBA TransferLength_in_blocks zero:");
++ msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_LOGICAL_BLOCK_OUT_OF_RANGE, msc->lba, USB_MSC_FAILED);
++ return;
++ }
++
++ // Initiate writing the data
++
++ TRACE_MSG1(MSC,"RECV OUT lba: %x", msc->lba);
++ TRACE_MSG1(MSC,"RECV OUT blocks left: %d", msc->TransferLength_in_blocks);
++ TRACE_MSG1(MSC,"RECV OUT blocks current: %d", TransferLength_in_blocks);
++
++
++ // set address in buffer head
++ msc->write_bh.b_size = TransferLength_in_bytes;
++ msc->write_bh.b_rsector = msc->lba;
++
++ // decrement counters and increment address
++ msc->TransferLength_in_bytes -= TransferLength_in_bytes;
++ msc->TransferLength_in_blocks -= TransferLength_in_blocks;
++ msc->lba += TransferLength_in_blocks;
++ msc->write_bh.b_state = (1UL << BH_Mapped) | (1UL << BH_Lock);
++ msc->write_bh.b_end_io = msc_data_written;
++ msc->io_state |= MSC_BLOCKIO_PENDING;
++
++
++ // start new urb here
++ if (!msc->TransferLength_in_blocks)
++ msc->command_state = MSC_DATA_OUT_WRITE_FINISHED;
++ else
++ msc_start_receiving_data(msc->function, msc);
++
++ generic_make_request(WRITE, &msc->write_bh);
++ generic_unplug_device(blk_get_queue(msc->write_bh.b_rdev));
++}
++
++
++/* msc_data_written - called by generic request
++ *
++ * Called when current block i/o read is finished, restart block i/o or send the CSW.
++ *
++ */
++void msc_data_written(struct buffer_head *bh, int uptodate)
++{
++ struct msc_private *msc = bh->b_private;
++ unsigned long flags;
++ u8 io_state;
++
++ msc_interrupts++;
++
++ TRACE_MSG4(MSC,"DATA WRITTEN uptodate: %x b_state: %x state: %x io: %x",
++ uptodate, bh->b_state, msc->command_state, msc->io_state);
++
++ TRACE_MSG1(MSC,"DATA WRITTEN lba: %x", msc->lba);
++
++ local_irq_save(flags);
++ io_state = msc->io_state &= ~MSC_BLOCKIO_PENDING;
++ msc->write_bh.b_data = NULL;
++ local_irq_restore(flags);
++
++ /*
++ * verify that the I/O completed
++ */
++ if (1 != uptodate) {
++ TRACE_MSG0(MSC,"BLOCK READ FAILED");
++ msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_UNRECOVERED_READ_ERROR, msc->lba, USB_MSC_FAILED);
++ // XXX CHECKME
++ if (msc->rcv_urb_finished) {
++ usbd_free_urb(msc->rcv_urb_finished);
++ msc->rcv_urb_finished = NULL;
++ }
++ return;
++ }
++ /*
++ * If there was a rcv_urb that was not processed then we need
++ * to process it now. This is done by simply restarting msc_recv_out()
++ */
++ if ((io_state & MSC_RECV_FINISHED) && msc->rcv_urb_finished) {
++ struct usbd_urb *rcv_urb = msc->rcv_urb_finished;
++ msc->rcv_urb_finished = NULL;
++ TRACE_MSG0(MSC,"DATA WRITTEN RECV FINISHED");
++ msc_recv_out_blocks(rcv_urb, msc);
++ }
++ /*
++ * DATA_IN mode and no more data to write
++ */
++ if (MSC_DATA_OUT_WRITE_FINISHED == msc->command_state) {
++ // finished, send CSW
++ TRACE_MSG0(MSC,"DATA WRITTEN send CSW");
++ msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++ }
++}
++
++
++/* SCSI Commands ******************************************************************************* */
++
++/* msc_scsi_inquiry - process an inquiry
++ *
++ * Used by:
++ * win2k
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_inquiry(struct msc_private *msc, char *name, int op)
++{
++ SCSI_INQUIRY_COMMAND *command = (SCSI_INQUIRY_COMMAND *)&msc->command.CBWCB;
++ SCSI_INQUIRY_DATA *data;
++ struct usbd_urb *urb;
++ int length = sizeof(SCSI_INQUIRY_DATA);
++
++ /*
++ * C.f. SPC2 7.3 INQUIRY command
++ * C.f. Table 46 - Standard INQUIRY data format
++ *
++ * C.f. Table 47 - Peripheral Qualifier
++ *
++ * 000b The specified peripheral device type is currently connected to this
++ * logical unit.....
++ * 001b The device server is capable of of supporting the peripheral device
++ * type on this logical unit. However, the physical device is not currently
++ * connected to this logical unit.....
++ * 010b Reserved
++ * 011b The device server is not capable of supporting a physical device on
++ * this logical unit....
++ *
++ */
++
++ TRACE_MSG4(MSC,"INQUIRY EnableVPD: %02x LogicalUnitNumber: %02x PageCode: %02x AllocLen: %02x",
++ command->EnableVPD, command->LogicalUnitNumber, command->PageCode, command->AllocationLength);
++
++ // XXX THROW_IF(msc->command_state != MSC_READY, error);
++
++ RETURN_EINVAL_IF(!(urb = msc_alloc_urb(msc, length)));
++
++ data = (SCSI_INQUIRY_DATA *)urb->buffer;
++ data->PeripheralQaulifier = msc->block_dev_state & (DEVICE_EJECTED | DEVICE_CHANGE_ON) ? 0x1 : 0;
++ data->PeripheralDeviceType = 0x00;
++ data->RMB = 0x1;
++ data->ResponseDataFormat = 0x1;
++ data->AdditionalLength = 0x1f;
++
++ strncpy(data->VendorInformation, CONFIG_OTG_MSC_MANUFACTURER, strlen(CONFIG_OTG_MSC_MANUFACTURER));
++ strncpy(data->ProductIdentification, CONFIG_OTG_MSC_PRODUCT_NAME, strlen(CONFIG_OTG_MSC_PRODUCT_NAME));
++
++ return msc_dispatch_query_urb(urb, msc, length, USB_MSC_PASSED);
++}
++
++
++/* old_msc_scsi_read_format_capacity - process a query
++ *
++ * Used by:
++ * win2k
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int old_msc_scsi_read_format_capacity(struct msc_private *msc, char *name, int op)
++{
++ // send ZLP then CSW
++ return msc_dispatch_query_urb_zlp(msc, 0, 0, USB_MSC_PASSED);
++}
++
++/* msc_scsi_read_format_capacity - process a query
++ *
++ * Used by:
++ * win2k
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_read_format_capacity(struct msc_private *msc, char *name, int op)
++{
++ SCSI_READ_FORMAT_CAPACITY_DATA *data;
++ struct usbd_urb *urb;
++ int length = sizeof(SCSI_READ_FORMAT_CAPACITY_DATA);
++ u32 block_num = msc->capacity;
++ u32 block_len;
++
++
++
++ /*
++ * If we don't have a valid block device then simply
++ * send a ZLP.
++ *
++ * XXX VERIFY this is correct thing to do for this situation.
++ */
++ //if (msc->block_dev_state & (DEVICE_EJECTED | DEVICE_CHANGE_ON))
++ // return msc_dispatch_query_urb_zlp(msc);
++ RETURN_ZERO_IF (msc_check_blockdev(msc, 1));
++
++ RETURN_EINVAL_IF(!(urb = msc_alloc_urb(msc, length)));
++
++ data = (SCSI_READ_FORMAT_CAPACITY_DATA *) urb->buffer;
++
++ data->CapacityListHeader.CapacityListLength = sizeof(data->CurrentMaximumCapacityDescriptor);
++
++ data->CurrentMaximumCapacityDescriptor.NumberofBlocks = block_num;
++ data->CurrentMaximumCapacityDescriptor.DescriptorCode = 0x03;
++ memcpy(data->CurrentMaximumCapacityDescriptor.BlockLength + 1, &block_len, sizeof(block_len));
++
++ return msc_dispatch_query_urb(urb, msc, length, USB_MSC_PASSED);
++}
++
++/* msc_read_capacity - process a read_capacity command
++ *
++ * Used by:
++ * win2k
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_read_capacity(struct msc_private *msc, char *name, int op)
++{
++ SCSI_READ_CAPACITY_COMMAND *command = (SCSI_READ_CAPACITY_COMMAND *)&msc->command.CBWCB;
++ SCSI_READ_CAPACITY_DATA *data;
++ struct usbd_urb *urb;
++ int length = 8;
++ u32 lba;
++
++ /*
++ * C.f. RBC 5.3
++ */
++
++ /*
++ * If we don't have a valid block device then simply
++ * send a ZLP.
++ *
++ * XXX VERIFY this is correct thing to do for this situation.
++ */
++ //if (msc->block_dev_state & (DEVICE_EJECTED | DEVICE_CHANGE_ON))
++ // return msc_dispatch_query_urb_zlp(msc);
++
++ RETURN_ZERO_IF (msc_check_blockdev(msc, 1));
++
++ //memcpy(&lba, &command->LogicalBlockAddress, 4);
++ //lba = be32_to_cpu(lba);
++
++ lba = be32_to_cpu(command->LogicalBlockAddress);
++
++ TRACE_MSG1(MSC,"READ CAPACITY LBA: %d", lba);
++
++ if ((command->PMI > 1) || (!command->PMI && lba)) {
++ TRACE_MSG1(MSC,"READ CAPACITY PMI: %d", command->PMI);
++ return msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_INVALID_FIELD_IN_CDB, lba, USB_MSC_FAILED);
++ }
++
++ // alloc urb
++ RETURN_EINVAL_IF(!(urb = msc_alloc_urb(msc, length)));
++
++ data = (SCSI_READ_CAPACITY_DATA *) urb->buffer;
++
++ data->LastLogicalBlockAddress = cpu_to_be32(msc->capacity);
++ data->BlockLengthInBytes = cpu_to_be32(msc->block_size);
++
++ TRACE_MSG1(MSC,"RECV READ CAPACITY lba: %x", be32_to_cpu(data->LastLogicalBlockAddress));
++ TRACE_MSG1(MSC,"RECV READ CAPACITY block_size: %x", be32_to_cpu(data->BlockLengthInBytes));
++
++ return msc_dispatch_query_urb(urb, msc, length, USB_MSC_PASSED);
++}
++
++
++/* msc_scsi_request_sense - process a request_sense command
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_request_sense(struct msc_private *msc, char *name, int op)
++{
++ SCSI_REQUEST_SENSE_COMMAND* command = (SCSI_REQUEST_SENSE_COMMAND *)&msc->command.CBWCB;
++ SCSI_REQUEST_SENSE_DATA *data;
++
++ /*
++ * C.f. SPC2 7.20 REQUEST SENSE command
++ */
++
++ struct usbd_urb *urb;
++ int length = sizeof(SCSI_REQUEST_SENSE_DATA);
++
++ // alloc urb
++ RETURN_EINVAL_IF(!(urb = msc_alloc_urb(msc, length)));
++
++ data = (SCSI_REQUEST_SENSE_DATA *) urb->buffer;
++ memset(command, 0x0, length);
++ data->ErrorCode = SCSI_ERROR_CURRENT;
++ data->SenseKey = msc->sensedata >> 16;
++ data->AdditionalSenseCode = msc->sensedata >> 8;
++ data->AdditionalSenseCodeQualifier = msc->sensedata;
++ data->Valid = 1;
++
++ set_sense_data(msc, SCSI_SENSEKEY_NO_SENSE, 0);
++
++ return msc_dispatch_query_urb(urb, msc, length, USB_MSC_PASSED);
++}
++
++/* msc_scsi_mode_sense - process a request_sense command
++ *
++ * Used by:
++ * win2k
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int old_msc_scsi_mode_sense(struct msc_private *msc, char *name, int op)
++{
++ SCSI_MODE_SENSE_COMMAND *command = (SCSI_MODE_SENSE_COMMAND *)&msc->command.CBWCB;
++ SCSI_MODE_SENSE_DATA *data;
++ int length = sizeof(SCSI_MODE_SENSE_DATA);
++
++ struct usbd_urb *urb;
++ u8 *cp;
++
++
++ TRACE_MSG4(MSC,"MODE SENSE dbd: %02x PageControl: %02x PageCode: %02x Alloc: %02x",
++ command->DBD,
++ command->PageControl,
++ command->PageCode,
++ 0);
++
++ length = 8;
++
++ // alloc urb
++ RETURN_EINVAL_IF(!(urb = msc_alloc_urb(msc, length)));
++
++ cp = (u8 *) urb->buffer;
++ memset(cp, 0x0, length);
++
++ cp[0] = 0;
++ cp[1] = 0;
++ cp[2] = 0; // 0x80 is writeprotect
++ cp[3] = 0x08;
++ cp[4] = 0;
++ cp[5] = 0;
++ cp[6] = 0;
++ cp[7] = 0;
++
++ return msc_dispatch_query_urb(urb, msc, length, USB_MSC_PASSED);
++}
++
++/* msc_scsi_mode_sense - process a request_sense command
++ *
++ * Used by:
++ * win2k
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_mode_sense(struct msc_private *msc, char *name, int op)
++{
++
++ /*
++ * C.f. SPC2 7.8.1 MODE SENSE(6) command
++ */
++
++ static READ_WRITE_ERROR_RECOVERY_PAGE page_01 = {
++ PageCode:0x01,
++ PageLength:0x0A,
++ ReadRetryCount:0x03,
++ WriteRetryCount:0x80,
++ };
++ static FLEXIBLE_DISK_PAGE page_05 = {
++ PageCode:0x05,
++ PageLength:0x1E,
++ TransferRate:__constant_cpu_to_be16(0xFA00),
++ NumberofHeads:0xA0,
++ SectorsperTrack:0x00,
++ DataBytesperSector:__constant_cpu_to_be16(0x0002),
++ NumberofCylinders:__constant_cpu_to_be16(0x0000),
++ MotorOnDelay:0x05,
++ MotorOffDelay:0x1E,
++ MediumRotationRate:__constant_cpu_to_be16(0x6801),
++ };
++ static REMOVABLE_BLOCK_ACCESS_CAPABILITIES_PAGE page_1b = {
++ PageCode:0x1B,
++ PageLength:0x0A,
++ TLUN:0x01,
++ };
++ static TIMER_AND_PROTECT_PAGE page_1c = {
++ PageCode:0x1c,
++ PageLength:0x06,
++ InactivityTimeMultiplier:0x0A,
++ };
++
++ SCSI_MODE_SENSE_COMMAND *command = (SCSI_MODE_SENSE_COMMAND *)&msc->command.CBWCB;
++ SCSI_MODE_SENSE_DATA *data;
++ struct usbd_urb *urb;
++ int length = sizeof(SCSI_MODE_SENSE_DATA);
++
++ TRACE_MSG4(MSC,"MODE SENSE dbd: %02x PageControl: %02x PageCode: %02x Alloc: %02x",
++ command->DBD,
++ command->PageControl,
++ command->PageCode,
++ 0);
++
++
++ if (msc->block_dev_state & DEVICE_EJECTED) {
++ u16 sector = htons((unsigned short)msc->block_size);
++ u16 cylinder = 0;
++ page_05.NumberofHeads = 0;
++ page_05.SectorsperTrack = 0;
++ memcpy(&page_05.DataBytesperSector, &sector, sizeof(sector));
++ memcpy(&page_05.NumberofCylinders, &cylinder, sizeof(cylinder));
++ }
++ else {
++ u16 sector = htons((unsigned short)msc->block_size);
++ u32 size = DEF_NUMBER_OF_HEADS * DEF_SECTORS_PER_TRACK * sector;
++ u16 cylinder = htons(msc->capacity / size);
++ page_05.NumberofHeads = DEF_NUMBER_OF_HEADS;
++ page_05.SectorsperTrack = DEF_SECTORS_PER_TRACK;
++ memcpy(&page_05.DataBytesperSector, &sector, sizeof(sector));
++ memcpy(&page_05.NumberofCylinders, &cylinder, sizeof(cylinder));
++
++ }
++
++
++ if (SCSI_MODEPAGE_CONTROL_CURRENT != command->PageControl) {
++ TRACE_MSG2(MSC,"MODE SENSE - requeested other than CONTROL_CURRENT: %d %d",
++ command->PageControl, command->PageCode);
++ return msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_INVALID_FIELD_IN_CDB, msc->lba, USB_MSC_FAILED);
++ }
++
++ RETURN_EINVAL_IF(!(urb = msc_alloc_urb(msc, length)));
++ data = (SCSI_MODE_SENSE_DATA *) urb->buffer;
++
++ data->ModeParameterHeader.WriteProtect = msc->block_dev_state & DEVICE_WRITE_PROTECTED ? 1 : 0;
++
++ switch (command->PageCode) {
++ case SCSI_MODEPAGE_ERROR_RECOVERY:
++ length = sizeof(MODE_PARAMETER_HEADER) + sizeof(page_01);
++ data->ModeParameterHeader.ModeDataLength = length - 1;
++ memcpy(&data->ModePages, &page_01, sizeof(page_01));
++ break;
++ case SCSI_MODEPAGE_FLEXIBLE_DISK_PAGE:
++ length = sizeof(MODE_PARAMETER_HEADER) + sizeof(page_05);
++ data->ModeParameterHeader.ModeDataLength = length - 1;
++ memcpy(&data->ModePages, &page_05, sizeof(page_05));
++ break;
++ case SCSI_MODEPAGE_REMOVABLE_BLOCK_ACCESS:
++ length = sizeof(MODE_PARAMETER_HEADER) + sizeof(page_1b);
++ data->ModeParameterHeader.ModeDataLength = length - 1;
++ memcpy(&data->ModePages, &page_1b, sizeof(page_1b));
++ break;
++ case SCSI_MODEPAGE_INFORMATION_EXCEPTIONS:
++ length = sizeof(MODE_PARAMETER_HEADER) + sizeof(page_1c);
++ data->ModeParameterHeader.ModeDataLength = length - 1;
++ memcpy(&data->ModePages, &page_1c, sizeof(page_1c));
++ break;
++ case SCSI_MODEPAGE_ALL_SUPPORTED:
++ length = sizeof(MODE_PARAMETER_HEADER) + sizeof(MODE_ALL_PAGES);
++ data->ModeParameterHeader.ModeDataLength = length - 1;
++ memcpy(&data->ModePages.ModeAllPages.ReadWriteErrorRecoveryPage, &page_01, sizeof(page_01));
++ memcpy(&data->ModePages.ModeAllPages.FlexibleDiskPage, &page_05, sizeof(page_05));
++ memcpy(&data->ModePages.ModeAllPages.RemovableBlockAccessCapabilitiesPage, &page_1b, sizeof(page_1b));
++ memcpy(&data->ModePages.ModeAllPages.TimerAndProtectPage, &page_1c, sizeof(page_1c));
++ break;
++ case SCSI_MODEPAGE_CACHING:
++ // see file_storage.c for an example if we want to support this
++ break;
++ }
++
++ TRACE_MSG2(MSC,"LENGTH: %d %d", msc->command.dCBWDataTransferLength, length);
++
++ /*
++ * XXX verify that length is <= 256 bytes, return CHECK_CONDITION if it is
++ */
++ length = MIN(msc->command.dCBWDataTransferLength, length);
++
++ return msc_dispatch_query_urb(urb, msc, length, USB_MSC_PASSED);
++}
++
++
++/* msc_scsi_test_unit_ready - process a request_sense command
++ *
++ * Used by:
++ * win2k
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_test_unit_ready(struct msc_private *msc, char *name, int op)
++{
++ /*
++ * C.f. SPC2 7.25 TEST UNIT READY command
++ *
++ * Return GOOD, illegal request for bad LUN or NOT READY
++ *
++ */
++ RETURN_EINVAL_IF (msc_check_blockdev(msc, 0));
++ return msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++}
++
++
++/* msc_scsi_prevent_allow - process a request_sense command
++ *
++ * Used by:
++ * win2k
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_prevent_allow(struct msc_private *msc, char *name, int op)
++{
++ SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL_COMMAND* command = (SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL_COMMAND*)&msc->command.CBWCB;
++
++ /*
++ * C.f. SPC2 7.12 Table 78 PREVENT ALLOW MEDIUM REMOVAL Prevent Field
++ *
++ * 00b Medium removal shall be allowed from both the data transport
++ * element and the attached medium changer (if any).
++ * 01b Medium removal shall be prohibited from the data transport
++ * element but allowed from the attached medium changer (if any).
++ * 10b Medium removal shall be allowed for the data transport element
++ * but prohibited for the attached medium changer.
++ * 11b Medium remval shall be prohibited from both the data transport
++ * element and the attached medium changer
++ *
++ * Prevention shall terminate after 00b or 10b, after a SYNC CACHE or hard reset.
++ */
++
++ TRACE_MSG1(MSC,"PREVENT: %d", command->Prevent);
++
++ RETURN_EINVAL_IF (msc_check_blockdev(msc, 0));
++
++
++ // XXX TODO
++ // this is from storageproto.c, shouldn't we implement something?
++ if (command->Prevent)
++ return msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_INVALID_FIELD, msc->lba, USB_MSC_FAILED);
++
++ return msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++}
++
++
++/* msc_scsi_start_stop - process a request_sense command
++ *
++ * C.f. RBC 5.4 and 5.4.2
++ *
++ * Used by:
++ * win2k
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_start_stop(struct msc_private *msc, char *name, int op)
++{
++ SCSI_START_STOP_COMMAND* command = (SCSI_START_STOP_COMMAND*)&msc->command.CBWCB;
++
++ TRACE_MSG4(MSC,"START STOP: Immed: %d Power: %x LoEj: %d Start: %d",
++ command->IMMED, command->PowerConditions, command->LoEj, command->Start);
++
++ /*
++ * C.f. 5.4
++ *
++ * IMMED - if set return status immediately after command validation, otherwise
++ * return status as soon operation is completed.
++ *
++ * C.f. 5.4.1 Table 8 POWER CONDITIONS
++ *
++ * 0 - M - no change in power condition
++ * 1 - M - place device in active condition
++ * 2 - M - place device in idle condition
++ * 3 - M - place device in Standby condition
++ * 4 - - reserved
++ * 5 - M - place device in Sleep condition
++ * 6 - - reserved
++ * 7 - 0 - Device Control
++ *
++ * C.f. 5.4.2 Table 9 START STOP control bit definitions
++ *
++ * Power Load/Eject Start
++ * 1-7 x x LoEj and Start Ignored
++ * 0 0 0 Stop the medium
++ * 0 0 1 Make the medium ready
++ * 0 1 0 Unload the medium
++ * 0 1 1 Load the medium
++ *
++ */
++
++
++ RETURN_EINVAL_IF (msc_check_blockdev(msc, 0));
++
++ // XXX TODO
++ // this is from storageproto.c, shouldn't we implement something?
++
++ if (command->Start && command->LoEj)
++ return msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_INVALID_FIELD, msc->lba, USB_MSC_FAILED);
++
++ return msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++}
++
++
++/* msc_scsi_verify - process a verify command
++ *
++ * Used by:
++ * win2k
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_verify(struct msc_private *msc, char *name, int op)
++{
++ SCSI_VERIFY_COMMAND *command = (SCSI_VERIFY_COMMAND *)&msc->command.CBWCB;
++ /*
++ * C.f. RBC 5.7 VERIFY command
++ */
++ // XXX This actually should use the read_10 function and when
++ // finished reading simply send the following
++ return msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++}
++
++
++/* msc_scsi_mode_select - process a select command
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_scsi_mode_select(struct msc_private *msc, char *name, int op)
++{
++ //SCSI_MODE_SELECT_COMMAND *command = (SCSI_MODE_SELECT_COMMAND *)&msc->command.CBWCB;
++
++ /*
++ * C.f. SPC2 7.6 MODE SELECT(6) command
++ */
++
++ // if less than correct amount of data return USB_MSC_PHASE_ERROR - see MV
++ //
++ return msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++}
++
++
++/* msc_cmd_unknown - process an unknown command
++ *
++ *
++ * Returns non-zero if there is an error in the USB layer.
++ */
++int msc_cmd_unknown(struct msc_private *msc, char *name, int op)
++{
++ /*
++ struct usbd_urb *urb;
++ RETURN_EINVAL_IF(!(urb = msc_alloc_urb(msc, 1))); // XXX +1 ?
++ urb->flags |= USBD_URB_SENDZLP;
++ return msc_dispatch_query_urb(urb, msc, 0);
++ */
++
++ printk(KERN_ERR"%s: NOT IMPLEMENTED %s opcode: %02x\n", __FUNCTION__, name, op);
++
++ // should we send ZLP for unknow commands?
++ // return msc_dispatch_query_urb_zlp(msc);
++
++ // or failed
++ return msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_INVALID_COMMAND, msc->lba, USB_MSC_FAILED);
++}
++
++
++struct rbc_dispatch {
++ u8 op;
++ char *name;
++ int (*rbc_command) (struct msc_private *, char *, int op);
++};
++
++/* Command cross reference
++ *
++ * This is the list of commands observed from each host OS. It is necessarily
++ * incomplete in that we not have reached some condition necessary to have
++ * other commands used.
++ * Win2k WinXP
++ * SCSI_TEST_UNIT_READY yes yes
++ * SCSI_READ_10 yes yes
++ * SCSI_WRITE_10 yes yes
++ * SCSI_READ_CAPACITY yes yes
++ * SCSI_VERIFY yes
++ * SCSI_INQUIRY yes yes
++ * SCSI_MODE_SENSE yes
++ * SCSI_READ_FORMAT_CAPACITY yes yes
++ * SCSI_REQUEST_SENSE
++ * SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL
++ * SCSI_START_STOP
++ * SCSI_MODE_SELECT
++ * SCSI_FORMAT_UNIT
++ *
++ */
++
++struct rbc_dispatch rbc_dispatch_table[] = {
++ { SCSI_TEST_UNIT_READY, "SCSI_TEST_UNIT_READY", msc_scsi_test_unit_ready }, //
++ { SCSI_READ_10, "SCSI_READ_10", msc_scsi_read_10 }, //
++ { SCSI_WRITE_10, "SCSI_WRITE_10", msc_scsi_write_10 }, //
++ { SCSI_READ_CAPACITY, "SCSI_READ_CAPACITY", msc_scsi_read_capacity }, //
++ { SCSI_VERIFY, "SCSI_VERIFY", msc_scsi_verify }, //
++ { SCSI_INQUIRY, "SCSI_INQUIRY", msc_scsi_inquiry }, //
++ { SCSI_MODE_SENSE, "SCSI_MODE_SENSE", msc_scsi_mode_sense }, //
++ { SCSI_READ_FORMAT_CAPACITY, "SCSI_READ_FORMAT_CAPACITY", msc_scsi_read_format_capacity }, //
++ { SCSI_REQUEST_SENSE, "SCSI_REQUEST_SENSE", msc_scsi_request_sense }, //
++ { SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL, "SCSI_PREVENT_ALLOW_MEDIUM_REMOVAL", msc_scsi_prevent_allow }, //
++ { SCSI_START_STOP, "SCSI_START_STOP", msc_scsi_start_stop }, //
++ { SCSI_MODE_SELECT, "SCSI_MODE_SELECT", msc_scsi_mode_select },
++ { SCSI_FORMAT_UNIT, "SCSI_FORMAT_UNIT", msc_cmd_unknown },
++
++ { SCSI_READ_6, "SCSI_READ_6", msc_cmd_unknown },
++ { SCSI_WRITE_6, "SCSI_WRITE_6", msc_cmd_unknown },
++ { SCSI_RESERVE, "SCSI_RESERVE", msc_cmd_unknown },
++ { SCSI_RELEASE, "SCSI_RELEASE", msc_cmd_unknown },
++ { SCSI_SEND_DIAGNOSTIC, "SCSI_SEND_DIAGNOSTIC", msc_cmd_unknown },
++ { SCSI_SYNCHRONIZE_CACHE, "SCSI_SYNCHRONIZE_CACHE", msc_cmd_unknown },
++ { SCSI_MODE_SENSE_10, "SCSI_MODE_SENSE_10", msc_cmd_unknown },
++ { SCSI_REZERO_UNIT, "SCSI_REZERO_UNIT", msc_cmd_unknown },
++ { SCSI_SEEK_10, "SCSI_SEEK_10", msc_cmd_unknown },
++ { SCSI_WRITE_AND_VERIFY, "SCSI_WRITE_AND_VERIFY", msc_cmd_unknown },
++ { SCSI_WRITE_12, "SCSI_WRITE_12", msc_cmd_unknown },
++ { SCSI_READ_12, "SCSI_READ_12", msc_cmd_unknown },
++
++ { 0xff, "SCSI_UNKNOWN", msc_cmd_unknown },
++};
++
++
++/* msc_recv_command - process a new CBW
++ *
++ * Return non-zero if urb was not disposed of.
++ */
++int msc_recv_command(struct usbd_urb *urb, struct msc_private *msc)
++{
++ COMMAND_BLOCK_WRAPPER *command = (COMMAND_BLOCK_WRAPPER *)urb->buffer;
++ u8 op = command->CBWCB[0];
++ struct rbc_dispatch *dispatch;
++
++ /*
++ * c.f. section 6.2 - Valid and Meaningful CBW
++ * c.f. section 6.2.1 - Valid CBW
++ *
++ * The CBW was received after the device had sent a CSW or after a
++ * reset XXX check that we only set MSC_READY after reset or sending
++ * CSW.
++ *
++ * The CBW is 31 (1Fh) bytes in length and the bCBWSignature is
++ * equal to 43425355h.
++ */
++ THROW_IF(31 != urb->actual_length, error);
++ THROW_IF(CBW_SIGNATURE != le32_to_cpu(command->dCBWSignature), error);
++
++ /*
++ * c.f. section 6.2.2 - Meaningful CBW
++ *
++ * no reserved bits are set
++ * the bCBWLUN contains a valid LUN supported by the device
++ * both bCBWCBlength and the content of the CBWCB are in accordance with bInterfaceSubClass
++ */
++
++ // XXX checklun etc
++
++ /*
++ * Success
++ */
++ memcpy(&msc->command, command, sizeof(COMMAND_BLOCK_WRAPPER));
++ msc->data_transferred_in_bytes = msc->TransferLength_in_blocks = msc->TransferLength_in_bytes = 0;
++
++ TRACE_TAG(command->dCBWTag, urb->framenum);
++ usbd_free_urb(urb);
++
++ /*
++ * Search using the opcode to find the dispatch function to use and
++ * call it.
++ */
++ for (dispatch = rbc_dispatch_table; dispatch->op != 0xff; dispatch++) {
++ if ((dispatch->op == op)) {
++ TRACE_CBW(dispatch->name, dispatch->op);
++ TRACE_RECV(&(command->CBWCB[1]));
++ if (dispatch->rbc_command(msc, dispatch->name, op))
++ TRACE_MSG0(MSC,"COMMAND ERROR");
++ return 0;
++ }
++ }
++ /* FALL THROUGH if no match is found */
++
++ THROW_IF(msc_cmd_unknown(msc, "CMD_UNKNOWN", op), error);
++ return 0;
++
++ CATCH(error) {
++ TRACE_MSG0(MSC,"RECV CBW ERROR");
++ }
++
++ /*
++ * default behaviour is to stall or send ZLP on BULK-IN endpoint
++ */
++ TRACE_CBW("UNKNOWN COMMAND", op);
++
++ /*
++ * We cannot return error as we have deallocated urb and there is no
++ * other sensible course of action that the usbdcore layer can take
++ * for us.
++ */
++ return 0;
++}
++
++
++/* Sent Function - process a sent urb ********************************************************** */
++
++/* msc_urb_sent - called to indicate URB transmit finished
++ * @urb: pointer to struct usbd_urb
++ * @rc: result
++ *
++ * This is called when an urb is sent. Depending on current state
++ * it may:
++ *
++ * - continue sending data
++ * - send a CSW
++ * - start a recv for a CBW
++ *
++ * This is called from BOTTOM HALF context.
++ *
++ * Return non-zero if urb was not disposed of.
++ */
++int msc_urb_sent (struct usbd_urb *tx_urb, int rc)
++{
++ struct usbd_function_instance *function;
++ struct msc_private *msc = &msc_private;
++
++ msc_interrupts++;
++
++ TRACE_MSG1(MSC,"URB SENT tx_urb: %p", (int)tx_urb);
++ TRACE_MSG1(MSC,"URB SENT function: %p", (int)tx_urb->function_instance);
++
++ RETURN_EINVAL_IF(!(function = tx_urb->function_instance));
++
++ TRACE_MSG1(MSC,"URB SENT status: %p", usbd_get_device_status(function));
++ RETURN_EINVAL_IF(usbd_get_device_status(function) == USBD_CLOSING);
++
++ TRACE_MSG1(MSC,"URB SENT state: %p", usbd_get_device_state(function));
++ RETURN_EINVAL_IF(usbd_get_device_state(function) != STATE_CONFIGURED);
++
++ switch (msc->command_state) {
++ case MSC_DATA_IN_READ:
++ case MSC_DATA_IN_READ_FINISHED:
++ TRACE_MSG0(MSC,"URB SENT READ");
++ return msc_in_read_10_urb_sent(tx_urb, msc);
++ case MSC_QUERY:
++ // finished, send CSW
++ TRACE_MSG0(MSC,"URB SENT QUERY");
++ msc_start_sending_csw(msc->function, msc, USB_MSC_PASSED);
++ break;
++ case MSC_STATUS:
++ default:
++ // sent a CSW need to receive the next CBW
++ TRACE_MSG0(MSC,"URB SENT STATUS");
++ msc->command_state = MSC_READY;
++ msc_start_recv_urb(msc->function, msc, sizeof(COMMAND_BLOCK_WRAPPER));
++ break;
++ }
++ usbd_free_urb (tx_urb);
++ return 0;
++}
++
++
++/* Receive Function - receiving an urb ********************************************************* */
++
++/* msc_recv_urb - process a received urb
++ *
++ * Return non-zero if urb was not disposed of.
++ */
++static int msc_recv_urb (struct usbd_urb *rcv_urb, int rc)
++{
++ struct msc_private *msc = &msc_private;
++
++ msc_interrupts++;
++
++ RETURN_EINVAL_IF(!msc->connected);
++
++ TRACE_MSG2(MSC, "RECV URB length: %d state: %d", rcv_urb->actual_length, msc->command_state);
++
++ switch(msc->command_state) {
++
++ // ready to start a new transaction
++ case MSC_READY:
++ return msc_recv_command(rcv_urb, msc);
++
++ // we think we are receiving data
++ case MSC_DATA_OUT_WRITE:
++ case MSC_DATA_OUT_WRITE_FINISHED:
++ msc_recv_out_blocks(rcv_urb, msc);
++ return 0;
++
++ // we think we are sending data
++ case MSC_DATA_IN_READ:
++ case MSC_DATA_IN_READ_FINISHED:
++ msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_INVALID_COMMAND, msc->lba, USB_MSC_FAILED);
++ break;
++
++ // we think we are sending status
++ case MSC_STATUS:
++ msc_start_sending_csw_failed (msc, SCSI_SENSEKEY_INVALID_COMMAND, msc->lba, USB_MSC_FAILED);
++ break;
++
++ // we don't think
++ case MSC_UNKNOWN:
++ default:
++ TRACE_MSG0(MSC,"RECV URB ERROR");
++ }
++ // let caller dispose of urb
++ return -EINVAL;
++}
++
++/* USB Device Functions ************************************************************************ */
++
++/* msc_event_handler - process a device event
++ *
++ * This function is called when an USBD event occurs.
++ *
++ * This is called from INTERRUPT context.
++ */
++void msc_event_handler (struct usbd_function_instance *function, usbd_device_event_t event, int data)
++{
++ struct msc_private *msc = &msc_private;
++
++ msc_interrupts++;
++
++ TRACE_MSG1(MSC,"EVENT IRQ %d", event);
++
++ switch (event) {
++ case DEVICE_CONFIGURED:
++ TRACE_MSG0(MSC,"EVENT CONFIGURED");
++ msc->connected = 1;
++ msc->command_state = MSC_READY;
++ msc_start_recv_urb(function, msc, sizeof(COMMAND_BLOCK_WRAPPER));
++ break;
++
++ case DEVICE_BUS_INACTIVE:
++ case DEVICE_RESET:
++ case DEVICE_DE_CONFIGURED:
++ TRACE_MSG0(MSC,"EVENT RESET");
++ BREAK_IF(!msc->connected);
++ msc->connected = 0;
++ if (msc->rcv_urb_finished) {
++ usbd_free_urb (msc->rcv_urb_finished);
++ msc->rcv_urb_finished = NULL;
++ }
++ break;
++
++ default:
++ TRACE_MSG0(MSC,"EVENT IGNORED");
++ break;
++ }
++}
++
++
++/* msc_device_request - called to indicate urb has been received
++ *
++ * This function is called when a SETUP packet has been received that
++ * should be handled by the function driver. It will not be called to
++ * process the standard chapter nine defined requests.
++ *
++ * Return non-zero for failure.
++ */
++int msc_device_request (struct usbd_function_instance *function, struct usbd_device_request *request)
++{
++ struct msc_private *msc = &msc_private;
++ struct usbd_urb *urb;
++
++ TRACE_MSG0(MSC,"RECV SETUP");
++ msc_interrupts++;
++
++ // verify that this is a usb class request per cdc-acm 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_CLASS:
++ switch (request->bRequest) {
++ case MSC_BULKONLY_RESET:
++ // XXX TODO FIXME
++ return 0;
++ }
++
++ case USB_REQ_DEVICE2HOST | USB_REQ_TYPE_CLASS:
++ switch (request->bRequest) {
++ case MSC_BULKONLY_GETMAXLUN:
++ RETURN_EINVAL_IF(!(urb = usbd_alloc_urb_ep0(function, 1, NULL)));
++ urb->buffer[0] = 0;
++ urb->actual_length = 1;
++ RETURN_ZERO_IF(!usbd_start_in_urb(urb));
++ usbd_free_urb(urb);
++ return -EINVAL;
++ }
++ default:
++ break;
++ }
++ return -EINVAL;
++}
++
++/* msc_function_enable - this is called by the USBD core layer
++ *
++ * This is called to initialize the function when a bus interface driver
++ * is loaded.
++ */
++static int msc_function_enable (struct usbd_function_instance *function)
++{
++ struct msc_private *msc = &msc_private;
++
++ MOD_INC_USE_COUNT;
++
++ // XXX TODO need to verify that serial number is minimum of 12
++
++ msc_interrupts++;
++
++ msc->function = function;
++ msc->command_state = MSC_READY;
++
++ //msc_open_blockdev(msc);
++ return 0;
++}
++
++/* msc_function_disable - this is called by the USBD core layer
++ *
++ * This is called to close the function when a bus interface driver
++ * is unloaded.
++ */
++static void msc_function_disable (struct usbd_function_instance *function)
++{
++ struct msc_private *msc = &msc_private;
++
++ msc_interrupts++;
++
++ TRACE_MSG0(MSC,"FUNCTION EXIT");
++
++ msc->function = NULL;
++
++ MOD_DEC_USE_COUNT;
++}
++
++static struct usbd_function_operations function_ops = {
++ event_handler: msc_event_handler,
++ device_request: msc_device_request,
++ function_enable: msc_function_enable,
++ function_disable: msc_function_disable,
++};
++
++static struct usbd_function_driver function_driver = {
++ name: "msc-bulkonly",
++ fops:&function_ops,
++ device_description:&msc_device_description,
++ bNumConfigurations:sizeof (msc_description) / sizeof (struct usbd_configuration_description),
++ configuration_description:msc_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_OTG_MSC_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_MSC_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_MSC_BCDDEVICE),
++ bNumInterfaces:sizeof (msc_interfaces) / sizeof (struct usbd_interface_description),
++ interface_list:msc_interfaces,
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: msc_endpoint_requests,
++};
++
++
++/* USB Module init/exit ************************************************************************ */
++
++/*
++ * msc_modinit - module init
++ *
++ */
++static int msc_modinit (void)
++{
++ int rc;
++ struct msc_private *msc = &msc_private;
++
++ printk(KERN_INFO "Copyright (c) 2004 Belcarra Technologies; www.belcarra.com; sl@belcarra.com\n");
++ printk (KERN_INFO "%s vendor_id: %04x product_id: %04x major: %d minor: %d\n", __FUNCTION__,
++ vendor_id, product_id, major, minor);
++
++ if (vendor_id)
++ function_driver.idVendor = cpu_to_le16(vendor_id);
++ if (product_id)
++ function_driver.idProduct = cpu_to_le16(product_id);
++
++ init_waitqueue_head(&msc->msc_wq);
++#if 0
++ /*
++ * Check device information and verify access to the block device.
++ */
++ RETURN_EINVAL_IF(!major && !minor);
++ msc->dev = MKDEV(major, minor);
++ if(!(msc->bdev = bdget(kdev_t_to_nr(msc->dev)))) {
++ printk(KERN_INFO"%s: Cannot find device %d %d\n", __FUNCTION__, major, minor);
++ return -EINVAL;
++ }
++ if ((rc = blkdev_get(msc->bdev, FMODE_READ | FMODE_WRITE, 0, BDEV_RAW))) {
++ printk(KERN_INFO"%s: Cannot get device %d %d\n", __FUNCTION__, major, minor);
++ return -EINVAL;
++ }
++
++ /*
++ * Note that capacity must return the LBA of the last addressable block
++ * c.f. RBC 4.4, RBC 5.3 and notes below RBC Table 6
++ *
++ * The blk_size array contains the number of addressable blocks or N,
++ * capacity is therefore N-1.
++ */
++
++ msc->capacity = (blk_size[MAJOR(msc_private.dev)][MINOR(msc_private.dev)] << 1) - 1;
++ msc->block_size = get_hardsect_size(msc->dev);
++ msc->max_blocks = PAGE_SIZE / msc->block_size;
++#endif
++
++ msc->block_dev_state = DEVICE_EJECTED;
++
++ msc_open_blockdev(msc);
++
++ /*
++ * setup generic buffer_head
++ */
++
++ msc->read_bh.b_rdev = msc->dev;
++ msc->read_bh.b_private = msc;
++ msc->read_bh.b_page = alloc_page(GFP_NOIO);
++
++ msc->write_bh.b_rdev = msc->dev;
++ msc->write_bh.b_private = msc;
++ msc->write_bh.b_page = alloc_page(GFP_NOIO);
++
++ msc->command_state = MSC_READY;
++ msc->io_state = MSC_INACTIVE;
++
++ msc_trace_init("msctrace", &msc_private);
++ make_crc_table();
++
++ TRACE_MSG1(MSC,"PAGE_SHIFT: %x", PAGE_SHIFT);
++ TRACE_MSG1(MSC,"PAGE_SIZE: %x", PAGE_SIZE);
++ TRACE_MSG1(MSC,"PAGE_SIZE: %d", PAGE_SIZE);
++
++ // register as usb function driver
++ THROW_IF (usbd_register_function (&function_driver, NULL), error);
++ msc->usb_driver_registered++;
++
++ CATCH(error) {
++ if (msc->usb_driver_registered) {
++ usbd_deregister_function (&function_driver);
++ msc->usb_driver_registered = 0;
++ }
++ return -EINVAL;
++ }
++ return 0;
++}
++
++/* msc_modexit - module cleanup
++ */
++static void msc_modexit (void)
++{
++ struct msc_private *msc = &msc_private;
++
++ if (msc->bdev) {
++ blkdev_put(msc->bdev, BDEV_RAW);
++ }
++ // XXX this should be a wait for read_bh/write_bh to go to NULL
++ while (msc->read_bh.b_data) {
++ printk(KERN_INFO"%s: sleeping on read bh\n", __FUNCTION__);
++ sleep_on_timeout(&msc->msc_wq, 20);
++ }
++
++ while (msc->write_bh.b_data) {
++ printk(KERN_INFO"%s: sleeping on read bh\n", __FUNCTION__);
++ sleep_on_timeout(&msc->msc_wq, 20);
++ }
++
++ printk(KERN_INFO"%s: freeing read bh\n", __FUNCTION__);
++ __free_page((void *)&msc->read_bh.b_page);
++ msc->read_bh.b_page = NULL;
++
++ printk(KERN_INFO"%s: freeing write bh\n", __FUNCTION__);
++ __free_page((void *)&msc->write_bh.b_page);
++ msc->write_bh.b_page = NULL;
++
++ if (msc->usb_driver_registered) {
++ usbd_deregister_function (&function_driver);
++ }
++
++ msc_trace_exit("msctrace");
++ free_crc_table();
++}
++
++
++module_init (msc_modinit);
++module_exit (msc_modexit);
+diff -uNr linux/drivers/no-otg/functions/msc/msc-scsi.h linux/drivers/otg/functions/msc/msc-scsi.h
+--- linux/drivers/no-otg/functions/msc/msc-scsi.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/msc-scsi.h 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,795 @@
++/*
++ * otg/msc_fd/msc_scsi.h - mass storage protocol library header
++ *
++ * Copyright(c) 2004, Belcarra
++ *
++ * Adapated from work:
++ *
++ * Copyright (c) 2003 Lineo Solutions, Inc.
++ *
++ * Written by Shunnosuke kabata
++ *
++ * 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.
++ *
++ */
++
++
++/*
++ *
++ * Documents
++ * Universal Serial Bus Mass Storage Class - Specification Overview
++ * Universal Serial Bus Mass Storage Class - Bulk-Only Transport
++ * T10/1240-D - Information technology - Reduced Block Commands
++ *
++ * Notes
++ *
++ * 1. Reduced Block Command set C.f. Table 2 RBC
++ *
++ * Command Support
++ * Name OpCode Fixed Removable Reference
++ * Format Unit 04h O O RBC
++ * Inquiry 12h M M SPC-2
++ * Mode Select (6) 15h M M SPC-2
++ * Mode Sense (6) 1Ah M M SPC-2
++ * Perisstent Reserve In 5Eh O O SPC-2
++ * Persistent Reserve Out 5Fh O O SPC-2
++ * Prevent/Allow Medium Removal 1Eh N/A M SPC-2
++ * Read (10) 28h M M RBC
++ * Read Capacity 25h M M RBC
++ * Reelase (6) 17h O O SPC-2
++ * Request Sense 03h O O SPC-2
++ * Reserve (6) 16h O O SPC-2
++ * Start Stop Unit 1Bh M M RBC
++ * Synchronize Cache 35h O O RBC
++ * Test Unit Ready 00h M M SPC-2
++ * Verify (10) 2Fh M M RBC
++ * Write (10) 2Ah M M RBC
++ * Write Buffer 3Bh M O SPC-2
++ *
++ * 2. Other commands seen?
++ * Sh MV FS
++ * SCSI_REZERO_UNIT 0x01 no
++ * SCSI_READ_6 0x08 yes
++ * SCSI_WRITE_6 0x0a yes
++ * SCSI_SEND_DIAGNOSTIC 0x1d no yes
++ * SCSI_READ_FORMAT_CAPACITY 0x23 yes yes
++ * SCSI_WRITE_AND_VERIFY 0x2e no
++ * SCSI_SEEK_10 0x2b no
++ * SCSI_MODE_SELECT_10 0x55 no yes yes
++ * SCSI_READ_12 0xa8 no yes
++ * SCSI_WRITE_12 0xaa no yes
++ *
++ *
++ * 3. Status - C.f. Chapter 5 - RBC
++ *
++ * Check Condition 02h
++ *
++ *
++ * 4. Sense Keys - C.f. Chapter 5 - RBC
++ *
++ * Not Ready 02h
++ * Media Error 03h
++ * Illegal Request 05h
++ * Unit Attention 06h
++ *
++ * 5. ASC/ASCQ - C.f. Chapter 5 - RBC
++ *
++ * Logical Unit Not Ready 04h
++ * Logical Unit Not Ready, Format in Progress 04h,04h
++ * Invalid Command Operation Code 20h
++ * Invalide Field in CDB 24h
++ * Format Command Failed 31h,01h
++ * Status Notification / Power Management Class Event 38h,02h
++ * Status Notification / Media Class Event 38h,04h
++ * Status Notification / Device Busy Class Event 38h,06h
++ * Low Power Condition Active 5Eh,00
++ * Power Condition Change to Active 5Eh,41h
++ * Power Condition Change to Idle 5Eh,42h
++ * Power Condition Change to Standby 5Eh,43h
++ * Power Condition Change to Sleep 5Eh,45h
++ * Power Condition Change to Device Control 5Eh,47h
++ *
++ * 6. ASCQ - C.f. Chapter 5 - RBC
++ *
++ *
++ *
++ * 7. Sense Keys C.f. Chapter 5 - RBC
++ *
++ * Command Status Sense Key ASC/ASCQ
++ *
++ * 5.1 Format Unit
++ * Format progress Check Condition Not Ready, Logical Unit Note Ready, Format in Progress
++ * Sueccsful completion Check Condition Unit Attention, Status Notification / Media Class Event
++ * Failure Check Condition Media error, Format Command Failed
++ *
++ * 5.2 Read (10)
++ *
++ * 5.3 Read Capacity
++ * No Media Check Condition Not Ready, Logical Unit Not Ready
++ *
++ * 5.4 Start Stop Unit
++ * Power Consumption Check Condition Illegal Request,Low Power Condition Active
++ *
++ * 5.5 Synchronize Cache Check Condition Illegal Request,Invalid Command Operation Code
++ *
++ * 5.6 Write (10
++ *
++ * 5.7 Verify
++ *
++ * 5.8 Mode
++ *
++ * 6.1 Inquiry
++ *
++ * 6.2 Mode Select (6)
++ * Cannot Save Check Condition Illegal Request,Invalid Field in CDB
++ *
++ * 6.3 Mode Sense (6)
++ *
++ * 6.4 Prevent Allow Medium Removal
++ *
++ * 6.5 Request Sense
++ *
++ * 6.6 Test Unit Ready
++ *
++ * 6.7 Write Buffer
++ *
++ * 7.1 Unit Attention
++ * Power Contition change Check Condition Unit Attention, Power Condition Change Notification
++ *
++ * 7.4.1 Event Status Sense
++ *
++ * Power Management Event Check Condition Unit Attention, Event Status Notification / Power Managment
++ * Media Class Event Check Condition Unit Attention, Event Status Notification / Media Class
++ * Device Busy Event Check Condition Unit Attention, Event Status Notification / Device Busy Class
++ *
++ * 7.4.6 Removable Medium Device Initial Response
++ * Ready Check Condition Unit Attention, Event Status Notification / Media Class Event
++ * Power Check Condition Unit Attention, Event Status Notification / Power Management Class Event
++ */
++
++#ifndef _MSCSCSIPROTO_H_
++#define _MSCSCSIPROTO_H_
++
++
++/*
++ * Class Specific Requests - C.f. MSC BO Chapter 3
++ */
++
++#define MSC_BULKONLY_RESET 0xff
++#define MSC_BULKONLY_GETMAXLUN 0xfe
++
++
++/*
++ * Class Code
++ */
++
++#define MASS_STORAGE_CLASS 0x08
++
++/*
++ * MSC - Specification Overview
++ *
++ * SubClass Codes - C.f MSC Table 2.1
++ */
++
++#define MASS_STORAGE_SUBCLASS_RBC 0x01
++#define MASS_STORAGE_SUBCLASS_SFF8020I 0x02
++#define MASS_STORAGE_SUBCLASS_QIC157 0x03
++#define MASS_STORAGE_SUBCLASS_UFI 0x04
++#define MASS_STORAGE_SUBCLASS_SFF8070I 0x05
++#define MASS_STORAGE_SUBCLASS_SCSI 0x06
++
++/*
++ * Protocol - C.f MSC Table 3.1
++ */
++
++#define MASS_STORAGE_PROTO_CBI_WITH_COMP 0x00
++#define MASS_STORAGE_PROTO_CBI_NO_COMP 0x01
++#define MASS_STORAGE_PROTO_BULK_ONLY 0x50
++
++/*
++ * SCSI Command
++*/
++
++#define SCSI_TEST_UNIT_READY 0x00
++#define SCSI_REQUEST_SENSE 0x03
++#define SCSI_FORMAT_UNIT 0x04
++#define SCSI_INQUIRY 0x12
++#define SCSI_MODE_SELECT 0x15 // aka MODE_SELECT_6
++#define SCSI_MODE_SENSE 0x1a // aka MODE_SENSE_6
++#define SCSI_START_STOP 0x1b
++#define SCSI_PREVENT_ALLOW_MEDIA_REMOVAL 0x1e
++#define SCSI_READ_FORMAT_CAPACITY 0x23
++#define SCSI_READ_CAPACITY 0x25
++#define SCSI_READ_10 0x28
++#define SCSI_WRITE_10 0x2a
++#define SCSI_VERIFY 0x2f
++
++#define SCSI_READ_6 0x08
++#define SCSI_WRITE_6 0x0a
++#define SCSI_RESERVE 0x16
++#define SCSI_RELEASE 0x17
++#define SCSI_SEND_DIAGNOSTIC 0x1d
++#define SCSI_SYNCHRONIZE_CACHE 0x35
++#define SCSI_MODE_SENSE_10 0x5a
++
++#define SCSI_REZERO_UNIT 0x01
++#define SCSI_REASSIGN_BLOCKS 0x07
++#define SCSI_COPY 0x18
++#define SCSI_RECEIVE_DIAGNOSTIC_RESULTS 0x1c
++#define SCSI_WRITE_AND_VERIFY 0x2e
++#define SCSI_PREFETCH 0x34
++#define SCSI_READ_DEFECT_DATA 0x37
++#define SCSI_COMPARE 0x39
++#define SCSI_COPY_AND_VERIFY 0x3a
++#define SCSI_WRITE_BUFFER 0x3b
++#define SCSI_READ_BUFFER 0x3c
++#define SCSI_READ_LONG 0x3e
++#define SCSI_WRITE_LONG 0x3f
++#define SCSI_CHANGE_DEFINITION 0x40
++#define SCSI_WRITE_SAME 0x41
++#define SCSI_LOG_SELECT 0x4c
++#define SCSI_LOG_SENSE 0x4d
++#define SCSI_XD_WRITE 0x50
++#define SCSI_XP_WRITE 0x51
++#define SCSI_XD_READ 0x52
++#define SCSI_MODE_SELECT_10 0x55
++#define SCSI_RESERVE_10 0x56
++#define SCSI_RELEASE_10 0x57
++#define SCSI_MODE_SELECT_10 0x55
++#define SCSI_XD_WRITE_EXTENDED 0x80
++#define SCSI_REBUILD 0x81
++#define SCSI_REGENERATE 0x82
++
++#define SCSI_SEEK_10 0x2b
++#define SCSI_WRITE_AND_VERIFY 0x2e
++#define SCSI_WRITE_12 0xaa
++#define SCSI_READ_12 0xa8
++
++/*
++ * Private
++ */
++#define SCSI_PRIVATE_PCS 0xff
++
++/*
++ * SCSI Command Parameter
++ */
++
++#define CBW_SIGNATURE 0x43425355 /* USBC */
++#define CSW_SIGNATURE 0x53425355 /* USBS */
++
++#define PRODUCT_REVISION_LEVEL "1.00"
++
++/*
++ * Command Block Status Values - C.f MSC BO Table 5.3
++ */
++
++#define USB_MSC_PASSED 0x00 // good
++#define USB_MSC_FAILED 0x01 // bad
++#define USB_MSC_PHASE_ERROR 0x02 // we want to be reset
++
++
++
++
++/*
++ * SCSI Sense
++ * SenseKey
++ * AdditionalSenseCode
++ * SenseCodeQualifier
++ */
++
++#define SCSI_ERROR_CURRENT 0x70
++#define SCSI_ERROR_DEFERRED 0x07
++
++/*
++ * SCSI Sense Keys
++ */
++
++#define SK_NO_SENSE 0x00
++#define SK_RECOVERED_ERROR 0x01
++#define SK_NOT_READY 0x02
++#define SK_MEDIA_ERROR 0x03
++#define SK_HARDWARE_ERROR 0x04
++#define SK_ILLEGAL_REQUEST 0x05
++#define SK_UNIT_ATTENTION 0x06
++#define SK_DATA_PROTECT 0x07
++#define SK_BLANK_CHECK 0x08
++#define SK_COPY_ABORTED 0x0a
++#define SK_ABORTED_COMMAND 0x0b
++#define SK_VOLUME_OVERFLOW 0x0d
++#define SK_MISCOMPARE 0x0e
++
++/*
++ * 5. ASC/ASCQ - C.f. Chapter 5 - RBC
++ */
++
++#define SK(SenseKey,ASC,ASCQ) ((SenseKey<<16) | (ASC << 8) | (ASCQ))
++
++#define SCSI_SENSEKEY_NO_SENSE SK(SK_NO_SENSE, 0x00,0x00) // 0x000000
++
++#define SCSI_FAILURE_PREDICTION_THRESHOLD_EXCEEDED SK(SK_RECOVERED_ERROR, 0x5d,0x00) // 0x015d00
++
++#define SCSI_SENSEKEY_LOGICAL_UNIT_NOT_READY SK(SK_NOT_READY, 0x04,0x00) // 0x020400
++#define SCSI_SENSEKEY_FORMAT_IN_PROGRESS SK(SK_NOT_READY, 0x04,0x04) // 0x020404
++#define SCSI_SENSEKEY_MEDIA_NOT_PRESENT SK(SK_NOT_READY, 0x3a,0x00) // 0x023a00
++
++#define SCSI_SENSEKEY_WRITE_ERROR SK(SK_MEDIA_ERROR, 0x0c,0x02) // 0x030c02
++#define SCSI_SENSEKEY_UNRECOVERED_READ_ERROR SK(SK_MEDIA_ERROR, 0x11,0x00) // 0x031100
++#define SCSI_FORMAT_COMMAND_FAILED SK(SK_MEDIA_ERROR, 0x31,0x01) // 0x033101
++
++#define SCSI_SENSEKEY_COMMUNICATION_FAILURE SK(SK_HARDWARE_ERROR, 0x08,0x00) // 0x040800
++
++#define SCSI_SENSEKEY_INVALID_COMMAND SK(SK_ILLEGAL_REQUEST, 0x20,0x00) // 0x052000
++#define SCSI_SENSEKEY_BLOCK_ADDRESS_OUT_OF_RANGE SK(SK_ILLEGAL_REQUEST, 0x21,0x00) // 0x052100
++#define SCSI_SENSEKEY_INVALID_FIELD_IN_CDB SK(SK_ILLEGAL_REQUEST, 0x24,0x00) // 0x052400
++#define SCSI_SENSEKEY_LOGICAL_UNIT_NOT_SUPPORTED SK(SK_ILLEGAL_REQUEST, 0x25,0x00) // 0x052500
++#define SCSI_SENSEKEY_SAVING_PARAMETERS_NOT_SUPPORTED SK(SK_ILLEGAL_REQUEST, 0x39,0x00) // 0x053900
++#define SCSI_MEDIA_REMOVAL_PREVENTED SK(SK_ILLEGAL_REQUEST, 0x53,0x02) // 0x055302
++
++#define SCSI_SENSEKEY_NOT_READY_TO_READY_CHANGE SK(SK_UNIT_ATTENTION, 0x28,0x00) // 0x062800
++#define SCSI_SENSEKEY_RESET_OCCURRED SK(SK_UNIT_ATTENTION, 0x29,0x00) // 0x062900
++
++#define SCSI_SENSEKEY_STATUS_NOTIFICATION_POWER_CLASS SK(SK_UNIT_ATTENTION, 0x38,0x02) // 0x063802
++#define SCSI_SENSEKEY_STATUS_NOTIFICATION_MEDIA_CLASS SK(SK_UNIT_ATTENTION, 0x38,0x04) // 0x063804
++#define SCSI_SENSEKEY_STATUS_NOTIFICATION_DEVICE_BUSY SK(SK_UNIT_ATTENTION, 0x38,0x06) // 0x063806
++
++#define SCSI_SENSEKEY_LOW_POWER_CONDITION_ACTIVE SK(SK_UNIT_ATTENTION, 0x5e,0x00) // 0x065e00
++#define SCSI_SENSEKEY_POWER_CONDITION_CHANGE_TO_ACTIVE SK(SK_UNIT_ATTENTION, 0x5e,0x41) // 0x065e41
++#define SCSI_SENSEKEY_POWER_CONDITION_CHANGE_TO_IDLE SK(SK_UNIT_ATTENTION, 0x5e,0x42) // 0x065e42
++#define SCSI_SENSEKEY_POWER_CONDITION_CHANGE_TO_STANDBY SK(SK_UNIT_ATTENTION, 0x5e,0x43) // 0x065e43
++#define SCSI_SENSEKEY_POWER_CONDITION_CHANGE_TO_SLEEP SK(SK_UNIT_ATTENTION, 0x5e,0x45) // 0x065e45
++#define SCSI_SENSEKEY_POWER_CONDITION_CHANGE_TO_DEVICE SK(SK_UNIT_ATTENTION, 0x5e,0x47) // 0x065e47
++
++
++#define SCSI_SENSEKEY_WRITE_PROTECTED SK(SK_DATA_PROTECT, 0x27,0x00) // 0x072700
++
++
++/*
++ * Mode Page Code and Page Control
++ */
++#define SCSI_MODEPAGE_CONTROL_CURRENT 0x0
++#define SCSI_MODEPAGE_CONTROL_CHANGEABLE 0x1
++#define SCSI_MODEPAGE_CONTROL_DEFAULT 0x2
++#define SCSI_MODEPAGE_CONTROL_SAVED 0x3
++
++#define SCSI_MODEPAGE_UNIT_ATTENTION 0x00
++#define SCSI_MODEPAGE_ERROR_RECOVERY 0x01
++#define SCSI_MODEPAGE_DISCONNNECT_RECONNECT 0x02
++#define SCSI_MODEPAGE_FORMAT 0x03
++#define SCSI_MODEPAGE_RIGID_DRIVE_GEOMETRY 0x04
++#define SCSI_MODEPAGE_FLEXIBLE_DISK_PAGE 0x05 // check
++#define SCSI_MODEPAGE_VERIFY_ERROR_RECOVERY 0x07
++#define SCSI_MODEPAGE_CACHING 0x08
++#define SCSI_MODEPAGE_CONTROL_MODE 0x0a
++#define SCSI_MODEPAGE_NOTCH_AND_PARTITION 0x0c
++#define SCSI_MODEPAGE_POWER_CONDITION 0x0d
++#define SCSI_MODEPAGE_XOR 0x10
++#define SCSI_MODEPAGE_CONTROL_MODE_ALIAS 0x1a
++#define SCSI_MODEPAGE_REMOVABLE_BLOCK_ACCESS 0x1b// check
++#define SCSI_MODEPAGE_INFORMATION_EXCEPTIONS 0x1c
++#define SCSI_MODEPAGE_ALL_SUPPORTED 0x3f
++
++
++
++/*
++ * Command Block Wrapper / Command Status Wrapper
++ */
++
++/*
++ * Command Block Wrapper
++ */
++typedef struct{
++ unsigned long dCBWSignature;
++ unsigned long dCBWTag;
++ unsigned long dCBWDataTransferLength;
++ u8 bmCBWFlags;
++ u8 bCBWLUN:4,
++ Reserved:4;
++ u8 bCBWCBLength:5,
++ Reserved2:3;
++ u8 CBWCB[16];
++} __attribute__((packed)) COMMAND_BLOCK_WRAPPER;
++
++/*
++ * Command Status Wrapper
++ */
++typedef struct{
++ unsigned long dCSWSignature;
++ unsigned long dCSWTag;
++ unsigned long dCSWDataResidue;
++ u8 bCSWStatus;
++} __attribute__((packed)) COMMAND_STATUS_WRAPPER;
++
++/*
++ * SCSI Command
++ */
++
++/*
++ * INQUIRY
++ */
++
++typedef struct{
++ u8 OperationCode;
++ u8 EnableVPD:1,
++ Reserved1:4,
++ LogicalUnitNumber:3;
++ u8 PageCode;
++ u8 Reserved2;
++ u8 AllocationLength;
++ u8 Reserved3;
++ u8 Reserved4;
++ u8 Reserved5;
++ u8 Reserved6;
++ u8 Reserved7;
++ u8 Reserved8;
++ u8 Reserved9;
++} __attribute__((packed)) SCSI_INQUIRY_COMMAND;
++
++typedef struct{
++ u8 PeripheralDeviceType:5,
++ PeripheralQaulifier:3;
++ u8 Reserved2:7,
++ RMB:1;
++ u8 ANSIVersion:3,
++ ECMAVersion:3,
++ ISOVersion:2;
++ u8 ResponseDataFormat:4,
++ Reserved3:4;
++ u8 AdditionalLength;
++ u8 Reserved4;
++ u8 Reserved5;
++ u8 Reserved6;
++ u8 VendorInformation[8];
++ u8 ProductIdentification[16];
++ u8 ProductRevisionLevel[4];
++} __attribute__((packed)) SCSI_INQUIRY_DATA;
++
++/*
++ * READ FORMAT CAPACITY
++ */
++
++typedef struct{
++ u8 OperationCode;
++ u8 Reserved1:5,
++ LogicalUnitNumber:3;
++ u8 Reserved2;
++ u8 Reserved3;
++ u8 Reserved4;
++ u8 Reserved5;
++ u8 Reserved6;
++ u16 AllocationLength;
++ u8 Reserved7;
++ u8 Reserved8;
++ u8 Reserved9;
++} __attribute__((packed)) SCSI_READ_FORMAT_CAPACITY_COMMAND;
++
++typedef struct{
++ struct{
++ u8 Reserved1;
++ u8 Reserved2;
++ u8 Reserved3;
++ u8 CapacityListLength;
++ } __attribute__((packed)) CapacityListHeader;
++
++ struct{
++ u32 NumberofBlocks;
++ u8 DescriptorCode:2,
++ Reserved1:6;
++ u8 BlockLength[3];
++ } __attribute__((packed)) CurrentMaximumCapacityDescriptor;
++
++} __attribute__((packed)) SCSI_READ_FORMAT_CAPACITY_DATA;
++
++/*
++ * READ FORMAT CAPACITY
++ */
++
++typedef struct{
++ u8 OperationCode;
++ u8 RelAdr:1,
++ Reserved1:4,
++ LogicalUnitNumber:3;
++ u32 LogicalBlockAddress;
++ u8 Reserved2;
++ u8 Reserved3;
++ u8 PMI:1,
++ Reserved4:7;
++ u8 Reserved5;
++ u8 Reserved6;
++ u8 Reserved7;
++} __attribute__((packed)) SCSI_READ_CAPACITY_COMMAND;
++
++typedef struct{
++ u32 LastLogicalBlockAddress;
++ u32 BlockLengthInBytes;
++} __attribute__((packed)) SCSI_READ_CAPACITY_DATA;
++
++/*
++ * REQUEST SENSE
++ */
++
++typedef struct{
++ u8 OperationCode;
++ u8 Reserved1:5,
++ LogicalUnitNumber:3;
++ u8 Reserved2;
++ u8 Reserved3;
++ u8 AllocationLength;
++ u8 Reserved4;
++ u8 Reserved5;
++ u8 Reserved6;
++ u8 Reserved7;
++ u8 Reserved8;
++ u8 Reserved9;
++ u8 Reserved10;
++} __attribute__((packed)) SCSI_REQUEST_SENSE_COMMAND;
++
++typedef struct{
++ u8 ErrorCode:7,
++ Valid:1;
++ u8 Reserved1;
++ u8 SenseKey:4,
++ Reserved2:4;
++ u32 Information;
++ u8 AdditionalSenseLength;
++ u8 Reserved3[4];
++ u8 AdditionalSenseCode;
++ u8 AdditionalSenseCodeQualifier;
++ u8 Reserved4;
++ u8 Reserved5[3];
++} __attribute__((packed)) SCSI_REQUEST_SENSE_DATA;
++
++/*
++ * READ(10)
++ */
++
++typedef struct{
++ u8 OperationCode;
++ u8 RelAdr:1,
++ Reserved1:2,
++ FUA:1,
++ DPO:1,
++ LogicalUnitNumber:3;
++ u32 LogicalBlockAddress;
++ u8 Reserved2;
++ u16 TransferLength;
++ u8 Reserved3;
++ u8 Reserved4;
++ u8 Reserved5;
++} __attribute__((packed)) SCSI_READ_10_COMMAND;
++
++/*
++ * MODE SENSE
++ */
++typedef struct{
++ u8 OperationCode;
++ u8 Reserved1:3,
++ DBD:1,
++ Reserved2:1,
++ LogicalUnitNumber:3;
++ u8 PageCode:6,
++ PageControl:2; // PC
++ u8 Reserved3;
++ u8 Reserved4;
++ u8 Reserved5;
++ u8 Reserved6;
++ u16 ParameterListLength;
++ u8 Reserved7;
++ u8 Reserved8;
++ u8 Reserved9;
++} __attribute__((packed)) SCSI_MODE_SENSE_COMMAND;
++
++typedef struct{
++ u8 ModeDataLength;
++ u8 MediumTypeCode;
++ u8 Reserved1:4,
++ DPOFUA:1,
++ Reserved2:2,
++ WriteProtect:1;
++ u8 Reserved3;
++} __attribute__((packed)) MODE_PARAMETER_HEADER;
++
++typedef struct{
++ u8 PageCode:6,
++ Reserved1:1,
++ PS:1;
++ u8 PageLength;
++ u8 DCR:1,
++ Reserved2:1,
++ PER:1,
++ Reserved3:1,
++ RC:1,
++ Reserved4:1,
++ Reserved5:1,
++ AWRE:1;
++ u8 ReadRetryCount;
++ u8 Reserved6[4];
++ u8 WriteRetryCount;
++ u8 Reserved7[3];
++} __attribute__((packed)) READ_WRITE_ERROR_RECOVERY_PAGE;
++
++typedef struct{
++ u8 PageCode:6,
++ Reserved1:1,
++ PS:1;
++ u8 PageLength;
++ u16 TransferRate;
++ u8 NumberofHeads;
++ u8 SectorsperTrack;
++ u16 DataBytesperSector;
++ u16 NumberofCylinders;
++ u8 Reserved2[9];
++ u8 MotorOnDelay;
++ u8 MotorOffDelay;
++ u8 Reserved3[7];
++ u16 MediumRotationRate;
++ u8 Reserved4;
++ u8 Reserved5;
++} __attribute__((packed)) FLEXIBLE_DISK_PAGE;
++
++typedef struct{
++ u8 PageCode:6,
++ Reserved1:1,
++ PS:1;
++ u8 PageLength;
++ u8 Reserved2:6,
++ SRFP:1,
++ SFLP:1;
++ u8 TLUN:3,
++ Reserved3:3,
++ SML:1,
++ NCD:1;
++ u8 Reserved4[8];
++} __attribute__((packed)) REMOVABLE_BLOCK_ACCESS_CAPABILITIES_PAGE;
++
++typedef struct{
++ u8 PageCode:6,
++ Reserved1:1,
++ PS:1;
++ u8 PageLength;
++ u8 Reserved2;
++ u8 InactivityTimeMultiplier:4,
++ Reserved3:4;
++ u8 SWPP:1,
++ DISP:1,
++ Reserved4:6;
++ u8 Reserved5;
++ u8 Reserved6;
++ u8 Reserved7;
++} __attribute__((packed)) TIMER_AND_PROTECT_PAGE;
++
++typedef struct{
++ READ_WRITE_ERROR_RECOVERY_PAGE ReadWriteErrorRecoveryPage;
++ FLEXIBLE_DISK_PAGE FlexibleDiskPage;
++ REMOVABLE_BLOCK_ACCESS_CAPABILITIES_PAGE RemovableBlockAccessCapabilitiesPage;
++ TIMER_AND_PROTECT_PAGE TimerAndProtectPage;
++} __attribute__((packed)) MODE_ALL_PAGES;
++
++typedef struct{
++ MODE_PARAMETER_HEADER ModeParameterHeader;
++ union{
++ READ_WRITE_ERROR_RECOVERY_PAGE ReadWriteErrorRecoveryPage;
++ FLEXIBLE_DISK_PAGE FlexibleDiskPage;
++ REMOVABLE_BLOCK_ACCESS_CAPABILITIES_PAGE RemovableBlockAccessCapabilitiesPage;
++ TIMER_AND_PROTECT_PAGE TimerAndProtectPage;
++ MODE_ALL_PAGES ModeAllPages;
++ } __attribute__((packed)) ModePages;
++} __attribute__((packed)) SCSI_MODE_SENSE_DATA;
++
++/*
++ * TEST UNIT READY
++ */
++
++typedef struct{
++ u8 OperationCode;
++ u8 Reserved1:5,
++ LogicalUnitNumber:3;
++ u8 Reserved2;
++ u8 Reserved3;
++ u8 Reserved4;
++ u8 Reserved5;
++ u8 Reserved6;
++ u8 Reserved7;
++ u8 Reserved8;
++ u8 Reserved9;
++ u8 Reserved10;
++ u8 Reserved11;
++} __attribute__((packed)) SCSI_TEST_UNIT_READY_COMMAND;
++
++/*
++ * PREVENT-ALLOW MEDIA REMOVAL
++ */
++
++typedef struct{
++ u8 OperationCode;
++ u8 Reserved1:5,
++ LogicalUnitNumber:3;
++ u8 Reserved2;
++ u8 Reserved3;
++ u8 Prevent:2,
++ Reserved4:6;
++ u8 Reserved5;
++ u8 Reserved6;
++ u8 Reserved7;
++ u8 Reserved8;
++ u8 Reserved9;
++ u8 Reserved10;
++ u8 Reserved11;
++} __attribute__((packed)) SCSI_PREVENT_ALLOW_MEDIA_REMOVAL_COMMAND;
++
++/*
++ * START-STOP UNIT
++ */
++
++typedef struct{
++ u8 OperationCode;
++ u8 IMMED:1,
++ Reserved1:4,
++ LogicalUnitNumber:3;
++ u8 Reserved2;
++ u8 Reserved3;
++ u8 Start:1,
++ LoEj:1,
++ Reserved4:2,
++ PowerConditions:4;
++ u8 Reserved5;
++ u8 Reserved6;
++ u8 Reserved7;
++ u8 Reserved8;
++ u8 Reserved9;
++ u8 Reserved10;
++ u8 Reserved11;
++} __attribute__((packed)) SCSI_START_STOP_COMMAND;
++
++/*
++ * WRITE(10)
++ */
++
++typedef struct{
++ u8 OperationCode;
++ u8 RelAdr:1,
++ Reserved1:2,
++ FUA:1,
++ DPO:1,
++ LogicalUnitNumber:3;
++ u32 LogicalBlockAddress;
++ u8 Reserved2;
++ u16 TransferLength;
++ u8 Reserved3;
++ u8 Reserved4;
++ u8 Reserved5;
++} __attribute__((packed)) SCSI_WRITE_10_COMMAND;
++
++/*
++ * VERIFY
++ */
++
++typedef struct{
++ u8 OperationCode;
++ u8 RelAdr:1,
++ ByteChk:1,
++ Reserved1:1,
++ Reserved2:1,
++ DPO:1,
++ LogicalUnitNumber:3;
++ u32 LogicalBlockAddress;
++ u8 Reserved3;
++ u16 VerificationLength;
++ u8 Reserved4;
++ u8 Reserved5;
++ u8 Reserved6;
++} __attribute__((packed)) SCSI_VERIFY_COMMAND;
++
++#endif /* _MSCSCSIPROTO_H_ */
++
+diff -uNr linux/drivers/no-otg/functions/msc/msc.h linux/drivers/otg/functions/msc/msc.h
+--- linux/drivers/no-otg/functions/msc/msc.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/msc.h 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,141 @@
++/*
++ * otg/function/msc/msc.h - Mass Storage Class
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @defgroup MSCFunction Mass Storage
++ * @ingroup functiongroup
++ */
++/*!
++ * @file otg/functions/msc/msc.h
++ * @brief Mass Storage Driver private defines
++ *
++ *
++ * @ingroup MSCFunction
++ */
++
++#ifndef MSC_H
++#define MSC_H 1
++
++extern otg_tag_t msc_fd_trace_tag;
++#define MSC msc_fd_trace_tag
++
++/*
++ * Command/Data/Status Flow
++ * C.f. 5 - Figure 1
++ */
++
++typedef enum msc_state {
++ MSC_READY,
++ MSC_DATA_OUT_WRITE,
++ MSC_DATA_OUT_WRITE_FINISHED,
++ MSC_DATA_IN_READ,
++ MSC_DATA_IN_READ_FINISHED,
++ MSC_STATUS,
++ MSC_QUERY,
++ MSC_PHASE_ERROR,
++ MSC_UNKNOWN
++} msc_state_t;
++
++
++/*
++ * Device Transfer state
++ * C.F. Table 6.1
++ */
++
++typedef enum msc_device_state {
++ MSC_DEVICE_DN, // The device intends to transfer no data
++ MSC_DEVICE_DI, // The device intends to send data to the host
++ MSC_DEVICE_DO, // The device intents to received data from the host
++} msc_device_state_t;
++
++#define MSC_INACTIVE 0x0000
++#define MSC_BLOCKIO_PENDING 0x0001
++#define MSC_BLOCKIO_FINISHED 0x0002
++#define MSC_RECV_PENDING 0x0010
++#define MSC_RECV_FINISHED 0x0020
++#define MSC_SEND_PENDING 0x0040
++#define MSC_SEND_FINISHED 0x0080
++#define MSC_IOCTL_WAITING 0x0100 // there is an ioctl call waiting for I/O completion
++#define MSC_ABORT_IO 0x0200 // please abort current i/o
++
++#if 0
++struct SPC_inquiry_cdb {
++ u8 OperationCode; /* 12H */
++ u8 EnableVPD:1;
++ u8 CmdSupportData:1;
++ u8 Reserved0:6;
++ u8 PageCode;
++ u8 Reserved1;
++ u8 AllocationLen;
++ u8 Control;
++} __attribute__((packed));
++#endif
++
++struct msc_private {
++ struct usbd_function_instance *function;
++
++ int usb_driver_registered; // non-zero if usb function registered
++ unsigned char connected; // non-zero if connected to host (configured)
++
++ struct usbd_urb *rcv_urb_finished;
++
++ struct buffer_head read_bh;
++ struct buffer_head write_bh;
++
++ u16 read_pending;
++ u16 write_pending;
++
++ msc_device_state_t device_state;
++ msc_state_t command_state; // current command state
++ u16 io_state; // current IO state
++
++ COMMAND_BLOCK_WRAPPER command;
++
++ u32 lba; // next lba to read/write from
++ u32 transfer_blocks;
++ u32 TransferLength_in_blocks; // amount of transfer remaining
++ u32 TransferLength_in_bytes; // amount of transfer remaining
++ u32 data_transferred_in_bytes; // amount of data actually transferred
++
++ int major;
++ int minor;
++ kdev_t dev;
++ struct block_device *bdev;
++ u32 block_size;
++ u32 capacity;
++ u32 max_blocks;
++
++ int uptodate;
++
++ wait_queue_head_t msc_wq;
++ wait_queue_head_t ioctl_wq;
++
++ u32 status;
++ u32 block_dev_state;
++ u32 sensedata;
++ u32 info;
++};
++
++
++/*
++ * MSC Configuration
++ *
++ * Endpoint, Class, Interface, Configuration and Device descriptors/descriptions
++ */
++
++#define BULK_OUT 0x00
++#define BULK_IN 0x01
++#define ENDPOINTS 0x02
++
++extern struct usbd_function_operations function_ops;
++extern struct usbd_function_driver function_driver;
++
++
++#endif
+diff -uNr linux/drivers/no-otg/functions/msc/scripts/test1 linux/drivers/otg/functions/msc/scripts/test1
+--- linux/drivers/no-otg/functions/msc/scripts/test1 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/scripts/test1 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,37 @@
++#!/bin/sh
++#
++# Basic Start/Stop test
++#
++#
++# 1. Wait for connection
++# 2. loop making block device available for 10 second intervals
++# 3. exit if disconnected
++#
++
++MAJOR=7
++MINOR=0
++
++TIMEOUT=5
++
++set -x
++
++# wait for connection
++msc_check connect
++
++while sleep 1
++do
++
++ # make block device available
++ msc_check start $MAJOR $MINOR
++
++ sleep $TIMEOUT
++
++ # make block device un-available
++ msc_check stop
++
++ sleep $TIMEOUT
++
++ msc_check connected || break
++
++done
++
+diff -uNr linux/drivers/no-otg/functions/msc/scripts/test2 linux/drivers/otg/functions/msc/scripts/test2
+--- linux/drivers/no-otg/functions/msc/scripts/test2 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/scripts/test2 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,35 @@
++#!/bin/sh
++#
++# Basic Start/Stop test on connect/disconnect.
++#
++# Loop
++# 1. wait for connection
++# 2. making block device available for 10 seconds
++# 3. wait for disconnect
++# 4. continue
++#
++
++MAJOR=7
++MINOR=0
++
++TIMEOUT=5
++
++set -x
++
++while sleep 1
++do
++ # wait for connection
++ msc_check connect
++
++ # make block device available
++ msc_check start $MAJOR $MINOR
++
++ sleep $TIMEOUT
++
++ # make block device un-available
++ msc_check stop
++
++ msc_check disconnect
++
++done
++
+diff -uNr linux/drivers/no-otg/functions/msc/scripts/test3 linux/drivers/otg/functions/msc/scripts/test3
+--- linux/drivers/no-otg/functions/msc/scripts/test3 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/scripts/test3 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,46 @@
++#!/bin/sh
++#
++# Force connect/disconnect with start/stop.
++#
++# 1. loop making block device available for 10 second intervals
++# 2. exit if disconnected
++# 3. start
++# 4. stop
++# 5. force disconnect
++#
++
++MAJOR=7
++MINOR=0
++
++TIMEOUT=5
++
++set -x
++
++while sleep 1
++do
++
++ # bus request
++ otgd bus_req
++
++ # wait for connection
++ msc_check connect
++
++ # make block device available
++ msc_check start $MAJOR $MINOR
++
++ sleep $TIMEOUT
++
++ # make block device un-available
++ msc_check stop
++
++ sleep $TIMEOUT
++
++ # bus request/
++ otgd bus_req/
++
++ msc_check disconnect
++
++ sleep $TIMEOUT
++
++done
++
+diff -uNr linux/drivers/no-otg/functions/msc/scripts/test4 linux/drivers/otg/functions/msc/scripts/test4
+--- linux/drivers/no-otg/functions/msc/scripts/test4 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/scripts/test4 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,47 @@
++#!/bin/sh
++
++# Force connect/disconnect without start/stop.
++#
++#
++# 1. loop making block device available for 10 second intervals
++# 2. exit if disconnected
++# 3. force disconnect
++# 4. force connect
++#
++
++MAJOR=7
++MINOR=0
++
++TIMEOUT=5
++
++set -x
++
++# make block device available
++msc_check start $MAJOR $MINOR
++
++
++while sleep 1
++do
++
++ # bus request
++ otgd bus_req
++
++ # wait for connection
++ msc_check connect
++
++ sleep $TIMEOUT
++
++ sleep $TIMEOUT
++
++ # bus request/
++ otgd bus_req/
++
++ msc_check disconnect
++
++ sleep $TIMEOUT
++
++done
++
++# make block device un-available
++msc_check stop
++
+diff -uNr linux/drivers/no-otg/functions/msc/scripts/test5 linux/drivers/otg/functions/msc/scripts/test5
+--- linux/drivers/no-otg/functions/msc/scripts/test5 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/scripts/test5 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,47 @@
++#!/bin/sh
++#
++# Force connect/disconnect with start/stop.
++#
++# 1. loop making block device available for 10 second intervals
++# 2. exit if disconnected
++# 3. start
++# 4. force disconnect
++# 5. stop
++# 6. force connect
++#
++
++MAJOR=7
++MINOR=0
++
++TIMEOUT=5
++
++set -x
++
++while sleep 1
++do
++
++ # bus request
++ otgd bus_req
++
++ # wait for connection
++ msc_check connect
++
++ # make block device available
++ msc_check start $MAJOR $MINOR
++
++ sleep $TIMEOUT
++
++ # bus request/
++ otgd bus_req/
++
++ # make block device un-available
++ msc_check stop
++
++ sleep $TIMEOUT
++
++ msc_check disconnect
++
++ sleep $TIMEOUT
++
++done
++
+diff -uNr linux/drivers/no-otg/functions/msc/trace.c linux/drivers/otg/functions/msc/trace.c
+--- linux/drivers/no-otg/functions/msc/trace.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/trace.c 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,340 @@
++/*
++ * otg/msc_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>,
++ *
++ */
++
++#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>
++
++#include <linux/netdevice.h>
++#include <linux/pci.h>
++#include <linux/cache.h>
++
++
++
++#include <asm/uaccess.h>
++#include <asm/io.h>
++#include <asm/pgtable.h>
++#include <asm/pgalloc.h>
++
++#include <usbp-chap9.h>
++#include <usbp-mem.h>
++#include <usbp-func.h>
++#include "msc-scsi.h"
++#include "msc.h"
++#include "trace.h"
++
++
++static struct msc_private *msc_private;
++int msc_trace_first;
++int msc_trace_next;
++msc_trace_t *msc_traces;
++
++extern int msc_interrupts;
++
++
++#if defined(CONFIG_OTG_MSC_REGISTER_TRACE) && defined(CONFIG_PROC_FS)
++
++msc_trace_t *MSC_TRACE_NEXT(msc_trace_types_t msc_trace_type)
++{
++ msc_trace_t *p;
++
++ p = msc_traces + msc_trace_next;
++
++ if (msc_private) {
++ p->ticks = usbd_ticks(msc_private->function);
++ p->sofs = usbd_framenum(msc_private->function);
++ }
++ p->interrupts = msc_interrupts;
++ p->msc_trace_type = msc_trace_type;
++
++ msc_trace_next++;
++ msc_trace_next = (msc_trace_next == TRACE_MAX) ? 0 : msc_trace_next;
++
++ if (msc_trace_next == msc_trace_first) {
++ msc_trace_first++;
++ msc_trace_first = (msc_trace_first == TRACE_MAX) ? 0 : msc_trace_first;
++ }
++
++ return p;
++}
++
++/* Proc Filesystem *************************************************************************** */
++
++/* *
++ * msc_trace_proc_read - implement proc file system read.
++ * @file
++ * @buf
++ * @count
++ * @pos
++ *
++ * Standard proc file system read function.
++ */
++static ssize_t msc_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;
++
++ MOD_INC_USE_COUNT;
++ // get a page, max 4095 bytes of data...
++ if (!(page = get_free_page (GFP_KERNEL))) {
++ MOD_DEC_USE_COUNT;
++ return -ENOMEM;
++ }
++
++ len = 0;
++ oindex = index = (*pos)++;
++
++ if (index == 0)
++ len += sprintf ((char *) page + len, " Index Ints Ticks\n");
++
++
++ index += msc_trace_first;
++ if (index >= TRACE_MAX)
++ index -= TRACE_MAX;
++
++ previous = (index) ? (index - 1) : (TRACE_MAX - 1);
++
++
++ if (
++ ((msc_trace_first < msc_trace_next) && (index >= msc_trace_first) && (index < msc_trace_next)) ||
++ ((msc_trace_first > msc_trace_next) && ((index < msc_trace_next) || (index >= msc_trace_first)))
++ )
++ {
++
++ u64 ticks = 0;
++
++ msc_trace_t *p = msc_traces + index;
++ unsigned char *cp;
++ unsigned int *ip;
++ int skip = 0;
++
++ if (oindex > 0) {
++ msc_trace_t *o = msc_traces + previous;
++
++ if (o->ticks)
++ ticks = (p->ticks > o->ticks) ? (p->ticks - o->ticks) : (o->ticks - p->ticks) ;
++
++ 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 (ticks > 1024*1024)
++ len += sprintf ((char *) page + len, "%8dM ", ticks>>20);
++ else
++ len += sprintf ((char *) page + len, "%8d ", ticks);
++
++ len += sprintf ((char *) page + len, "%6d ", (int)p->sofs);
++
++ switch (p->msc_trace_type) {
++ case msc_trace_msg:
++ len += sprintf ((char *) page + len, " -- ");
++ len += sprintf ((char *) page + len, p->trace.msg.msg);
++ break;
++
++ case msc_trace_w:
++ len += sprintf ((char *) page + len, " --> ");
++ len += sprintf ((char *) page + len, "[%8x] W %s", p->trace.msg32.val, p->trace.msg32.msg);
++ break;
++
++ case msc_trace_r:
++ len += sprintf ((char *) page + len, "<-- ");
++ len += sprintf ((char *) page + len, "[%8x] R %s", p->trace.msg32.val, p->trace.msg32.msg);
++ break;
++
++ case msc_trace_msg32:
++ len += sprintf ((char *) page + len, " -- ");
++ len += sprintf ((char *) page + len, p->trace.msg32.msg, p->trace.msg32.val);
++ break;
++
++ case msc_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 msc_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 msc_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 msc_trace_recv:
++ case msc_trace_sent:
++ cp = (unsigned char *)&p->trace.sent;
++ len += sprintf ((char *) page + len,
++ "%s %s [%02x %02x %02x %02x %02x %02x %02x %02x]",
++ ( p->msc_trace_type == msc_trace_recv)?"<-- ":" -->",
++ ( p->msc_trace_type == msc_trace_recv)?"recv":"sent",
++ cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
++ break;
++ case msc_trace_rlba:
++ ip = (unsigned int *)&p->trace.ints;
++ len += sprintf ((char *) page + len,
++ "%s %s [%8x %08x]",
++ "<-- ", "rlba", ip[0], ip[1]);
++ break;
++ case msc_trace_slba:
++ case msc_trace_tlba:
++ ip = (unsigned int *)&p->trace.ints;
++ len += sprintf ((char *) page + len,
++ "%s %s [%8x %08x]", " -->",
++ ( p->msc_trace_type == msc_trace_tlba)?"tlba":"slba",
++ ip[0], ip[1]);
++ break;
++
++ case msc_trace_tag:
++ ip = (unsigned int *)&p->trace.ints;
++ len += sprintf ((char *) page + len,
++ "%s TAG: %8x FRAME: %03x", " -->",
++ ip[0], ip[1]);
++ break;
++
++ case msc_trace_sense:
++ ip = (unsigned int *)&p->trace.ints;
++ len += sprintf ((char *) page + len,
++ "%s SENSE: %06x INFO: %08x", " -->",
++ ip[0], ip[1]);
++ break;
++
++ case msc_trace_cbw:
++ len += sprintf ((char *) page + len, " --> ");
++ len += sprintf ((char *) page + len, "%s %02x", p->trace.msg32.msg, p->trace.msg32.val);
++ 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;
++}
++
++/* *
++ * msc_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 msc_trace_proc_write (struct file *file, const char *buf, size_t count, loff_t * pos)
++{
++ return count;
++}
++
++static struct file_operations msc_trace_proc_operations_functions = {
++ read:msc_trace_proc_read,
++ write:msc_trace_proc_write,
++};
++
++
++/**
++ * msc_trace_init
++ *
++ * Return non-zero if not successful.
++ */
++int msc_trace_init (char *name, struct msc_private *msc)
++{
++ printk(KERN_INFO"%s:\n", __FUNCTION__);
++ if (!(msc_traces = vmalloc(sizeof(msc_trace_t) * TRACE_MAX))) {
++ printk(KERN_ERR"%s: malloc failed %p %d\n", __FUNCTION__, msc_traces, sizeof(msc_trace_t) * TRACE_MAX);
++ return -EINVAL;
++ }
++ memset(msc_traces, 0, sizeof(msc_trace_t) * TRACE_MAX);
++
++ {
++ struct proc_dir_entry *p;
++
++ // create proc filesystem entries
++ if ((p = create_proc_entry (name, 0, 0)) == NULL) {
++ printk(KERN_INFO"BITRACE PROC FS failed\n");
++ }
++ else {
++ p->proc_fops = &msc_trace_proc_operations_functions;
++ }
++ }
++ printk(KERN_INFO"%s: OK\n", __FUNCTION__);
++ msc_private = msc;
++ return 0;
++}
++
++/**
++ * udc_release_io - release UDC io region
++ */
++void msc_trace_exit (char *name)
++{
++ msc_private = NULL;
++ {
++ unsigned long flags;
++ local_irq_save (flags);
++ remove_proc_entry (name, NULL);
++ if (msc_traces) {
++ msc_trace_t *p = msc_traces;
++ msc_traces = NULL;
++ vfree(p);
++ }
++ local_irq_restore (flags);
++ }
++}
++
++
++#else
++int msc_trace_init (void)
++{
++ return 0;
++}
++
++void msc_trace_exit (char *)
++{
++ return;
++}
++#endif
++
+diff -uNr linux/drivers/no-otg/functions/msc/trace.h linux/drivers/otg/functions/msc/trace.h
+--- linux/drivers/no-otg/functions/msc/trace.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/msc/trace.h 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,303 @@
++/*
++ * otg/msc_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>,
++ *
++ *
++ */
++
++
++typedef enum msc_trace_int_types {
++ msc_trace_int_udc, msc_trace_int_ep0, msc_trace_int_in, msc_trace_int_out, msc_trace_int_int
++} msc_trace_int_types_t;
++
++typedef struct msc_trace_int {
++ u32 last;
++ u32 total;
++ u32 samples;
++} msc_trace_int_t;
++
++
++typedef enum msc_trace_types {
++ msc_trace_setup, msc_trace_msg, msc_trace_msg32, msc_trace_msg16,
++ msc_trace_msg8, msc_trace_recv, msc_trace_sent, msc_trace_w, msc_trace_r,
++ msc_trace_rlba, msc_trace_slba, msc_trace_tlba, msc_trace_tag,
++ msc_trace_sense, msc_trace_cbw
++} msc_trace_types_t;
++
++
++typedef struct msc_trace_regs32 {
++ u32 reg;
++ char * msg;
++} msc_trace_regs32_t;
++
++
++typedef struct msc_trace_msg {
++ char *msg;
++} msc_trace_msg_t;
++
++typedef struct msc_trace_msg32 {
++ u32 val;
++ char *msg;
++} msc_trace_msg32_t;
++
++typedef struct msc_trace_msg16 {
++ u16 val0;
++ u16 val1;
++ char *msg;
++} msc_trace_msg16_t;
++
++typedef struct msc_trace_msg8 {
++ u8 val0;
++ u8 val1;
++ u8 val2;
++ u8 val3;
++ char *msg;
++} msc_trace_msg8_t;
++
++
++typedef struct trace {
++ msc_trace_types_t msc_trace_type;
++ char *function;
++ u32 interrupts;
++ u64 ticks;
++ u64 sofs;
++
++ union {
++ msc_trace_msg_t msg;
++ msc_trace_msg8_t msg8;
++ msc_trace_msg16_t msg16;
++ msc_trace_msg32_t msg32;
++
++ struct usbd_device_request setup;
++ unsigned char recv[8];
++ unsigned char sent[8];
++
++ unsigned int ints[2];
++
++ } trace;
++
++} msc_trace_t;
++
++
++#define TRACE_MAX 30000
++
++extern int msc_trace_first;
++extern int msc_trace_next;
++
++extern msc_trace_int_t *msc_trace_ints;
++extern msc_trace_t *msc_traces;
++
++#ifdef CONFIG_OTG_MSC_REGISTER_TRACE
++
++msc_trace_t *MSC_TRACE_NEXT(msc_trace_types_t msc_trace_type);
++
++static __inline__ void TRACE_SETUP(struct usbd_device_request *setup)
++{
++ if (msc_traces) {
++ msc_trace_t *p = MSC_TRACE_NEXT(msc_trace_setup);
++ p->msc_trace_type = msc_trace_setup;
++ memcpy(&p->trace.setup, setup, sizeof(struct usbd_device_request));
++ }
++}
++
++static __inline__ void TRACE_MSG(char *msg)
++{
++ if (msc_traces) {
++ msc_trace_t *p = MSC_TRACE_NEXT(msc_trace_msg);
++ p->trace.msg.msg = msg;
++ }
++}
++
++static __inline__ void TRACE_W(char *msg, u32 val)
++{
++ if (msc_traces) {
++ msc_trace_t *p = MSC_TRACE_NEXT(msc_trace_w);
++ p->trace.msg32.val = val;
++ p->trace.msg32.msg = msg;
++ }
++}
++
++static __inline__ void TRACE_R(char *msg, u32 val)
++{
++ if (msc_traces) {
++ msc_trace_t *p = MSC_TRACE_NEXT(msc_trace_r);
++ p->trace.msg32.val = val;
++ p->trace.msg32.msg = msg;
++ }
++}
++
++static __inline__ void TRACE_MSG32(char *msg, u32 val)
++{
++ if (msc_traces) {
++ msc_trace_t *p = MSC_TRACE_NEXT(msc_trace_msg32);
++ p->trace.msg32.val = val;
++ p->trace.msg32.msg = msg;
++ }
++}
++
++static __inline__ void TRACE_MSG16(char *msg, u16 val0, u16 val1)
++{
++ if (msc_traces) {
++ msc_trace_t *p = MSC_TRACE_NEXT(msc_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 (msc_traces) {
++ msc_trace_t *p = MSC_TRACE_NEXT(msc_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 (msc_traces) {
++ msc_trace_t *p = MSC_TRACE_NEXT(msc_trace_recv);
++ memcpy(&p->trace.recv, cp, 8);
++ }
++}
++
++static __inline__ void TRACE_RECVN(unsigned char *cp, int bytes)
++{
++ if (msc_traces) {
++ msc_trace_t *p = MSC_TRACE_NEXT(msc_trace_recv);
++ memset(&p->trace.recv, 0, 8);
++ memcpy(&p->trace.recv, cp, bytes);
++ }
++}
++
++static __inline__ void TRACE_SENT(unsigned char *cp)
++{
++ if (msc_traces) {
++ msc_trace_t *p = MSC_TRACE_NEXT(msc_trace_sent);
++ memcpy(&p->trace.sent, cp, 8);
++ }
++}
++
++
++static __inline__ void TRACE_RLBA(unsigned int lba, unsigned int crc)
++{
++ if (msc_traces) {
++ msc_trace_t *p = MSC_TRACE_NEXT(msc_trace_rlba);
++ p->trace.ints[0] = lba;
++ p->trace.ints[1] = crc;
++ }
++}
++
++static __inline__ void TRACE_SLBA(unsigned int lba, unsigned int crc)
++{
++ if (msc_traces) {
++ msc_trace_t *p = MSC_TRACE_NEXT(msc_trace_slba);
++ p->trace.ints[0] = lba;
++ p->trace.ints[1] = crc;
++ }
++}
++
++static __inline__ void TRACE_TLBA(unsigned int lba, unsigned int crc)
++{
++ if (msc_traces) {
++ msc_trace_t *p = MSC_TRACE_NEXT(msc_trace_tlba);
++ p->trace.ints[0] = lba;
++ p->trace.ints[1] = crc;
++ }
++}
++
++static __inline__ void TRACE_TAG(unsigned int tag, unsigned int frame)
++{
++ if (msc_traces) {
++ msc_trace_t *p = MSC_TRACE_NEXT(msc_trace_tag);
++ p->trace.ints[0] = tag;
++ p->trace.ints[1] = frame;
++ }
++}
++
++static __inline__ void TRACE_SENSE(unsigned int sense, unsigned int info)
++{
++ if (msc_traces) {
++ msc_trace_t *p = MSC_TRACE_NEXT(msc_trace_sense);
++ p->trace.ints[0] = sense;
++ p->trace.ints[1] = info;
++ }
++}
++
++static __inline__ void TRACE_CBW(char *msg, int val)
++{
++ if (msc_traces) {
++ msc_trace_t *p = MSC_TRACE_NEXT(msc_trace_cbw);
++ p->trace.msg32.val = val;
++ p->trace.msg32.msg = msg;
++ }
++}
++
++#else
++
++static __inline__ void TRACE_SETUP(struct usbd_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_TLBA(char *msg, u16 val0, u16 val1)
++{
++}
++
++static __inline__ void TRACE_TAG(char *msg, u16 val0, u16 val1)
++{
++}
++
++static __inline__ void TRACE_SENSE(char *msg, u8 val0, u8 val1, u8 val2, u8 vale)
++{
++}
++
++#endif
++
++int msc_trace_init (char *str, struct msc_private *);
++void msc_trace_exit (char *str);
++
+diff -uNr linux/drivers/no-otg/functions/network/Config.in linux/drivers/otg/functions/network/Config.in
+--- linux/drivers/no-otg/functions/network/Config.in 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/Config.in 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,70 @@
++#
++# Network Function
++#
++# Copyright (C) 2002-2004 Belcarra
++#
++
++mainmenu_option next_comment
++comment "USB Peripheral Function Driver - Network"
++
++dep_tristate ' Network Function Driver' CONFIG_OTG_NETWORK $CONFIG_OTG
++
++if [ "$CONFIG_OTG_NETWORK" != "n" ]; then
++
++ hex 'VendorID (hex value)' CONFIG_OTG_NETWORK_VENDORID "15ec"
++ hex 'ProductID (hex value)' CONFIG_OTG_NETWORK_PRODUCTID "e003"
++ hex 'bcdDevice (binary-coded decimal)' CONFIG_OTG_NETWORK_BCDDEVICE "0100"
++
++ string 'iManufacturer (string)' CONFIG_OTG_NETWORK_MANUFACTURER "Belcarra"
++ string 'iProduct (string)' CONFIG_OTG_NETWORK_PRODUCT_NAME "Belcarra BLAN Device"
++
++ choice "Mode" "\
++ MDLM-BLAN-Networking-for-personal-devices CONFIG_OTG_NETWORK_BLAN \
++ MDLM-SAFE-Networking-for-Bridge-Routers CONFIG_OTG_NETWORK_SAFE \
++ CDC-Networking-for-Bridge-Routers CONFIG_OTG_NETWORK_CDC \
++ Failsafe-BASIC-Networking-testing-only CONFIG_OTG_NETWORK_BASIC \
++ Failsafe-BASIC2-Networking-testing-only CONFIG_OTG_NETWORK_BASIC2 \
++ Experimental-Ethernet-Mode-Networking-testing-only CONFIG_OTG_NETWORK_EEM \
++ " MDLM-BLAN-Networking-for-personal-devices
++
++ if [ "$CONFIG_OTG_NETWORK_BLAN" = "y" ]; then
++ source drivers/otg/functions/network/Config.in-blan
++ fi
++
++ if [ "$CONFIG_OTG_NETWORK_SAFE" = "y" ]; then
++ source drivers/otg/functions/network/Config.in-safe
++ fi
++
++ if [ "$CONFIG_OTG_NETWORK_CDC" = "y" ]; then
++ source drivers/otg/functions/network/Config.in-cdc
++ fi
++
++ if [ "$CONFIG_OTG_NETWORK_BASIC" = "y" ]; then
++ source drivers/otg/functions/network/Config.in-basic
++ fi
++
++ if [ "$CONFIG_OTG_NETWORK_BASIC2" = "y" ]; then
++ source drivers/otg/functions/network/Config.in-basic2
++ fi
++
++ if [ "$CONFIG_OTG_NETWORK_EEM" = "y" ]; then
++ source drivers/otg/functions/network/Config.in-eem
++ fi
++
++ comment ''
++ comment 'Testing Options'
++ bool 'Start Single Urb Test' CONFIG_OTG_NETWORK_START_SINGLE
++ bool 'EP0 Test' CONFIG_OTG_NETWORK_EP0TEST
++ dep_bool "Hotplug-config" CONFIG_OTG_NETWORK_HOTPLUG $CONFIG_HOTPLUG
++
++else
++ define_bool CONFIG_OTG_NETWORK_BLAN n
++ define_bool CONFIG_OTG_NETWORK_SAFE n
++ define_bool CONFIG_OTG_NETWORK_CDC n
++ define_bool CONFIG_OTG_NETWORK_BASIC n
++ define_bool CONFIG_OTG_NETWORK_BASIC2 n
++ define_bool CONFIG_OTG_NETWORK_EEM n
++fi
++
++endmenu
++
+diff -uNr linux/drivers/no-otg/functions/network/Config.in-basic linux/drivers/otg/functions/network/Config.in-basic
+--- linux/drivers/no-otg/functions/network/Config.in-basic 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/Config.in-basic 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,17 @@
++#
++# Network Function
++#
++# Copyright (C) 2002-2003 Belcarra
++#
++
++mainmenu_option next_comment
++comment "BASIC Networking Configuration"
++
++ #bool " Failsafe BASIC Networking mode" CONFIG_OTG_NETWORK_BASIC
++ if [ "$CONFIG_OTG_NETWORK_BASIC" = "y" ]; then
++ comment 'BASIC Configuration'
++ string 'Data Interface iConfiguration (string)' CONFIG_OTG_NETWORK_BASIC_DESC "BASIC Net Cfg"
++ string 'Data Interface iInterface (string)' CONFIG_OTG_NETWORK_BASIC_INTF "Data Intf"
++ fi
++
++endmenu
+diff -uNr linux/drivers/no-otg/functions/network/Config.in-basic2 linux/drivers/otg/functions/network/Config.in-basic2
+--- linux/drivers/no-otg/functions/network/Config.in-basic2 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/Config.in-basic2 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,13 @@
++#
++# Network Function
++#
++# Copyright (C) 2002-2003 Belcarra
++#
++
++mainmenu_option next_comment
++ comment "BASIC2 Networking Configuration"
++ string 'Data Interface iConfiguration (string)' CONFIG_OTG_NETWORK_BASIC2_DESC "BASIC Net Cfg"
++ string 'Comm Interface iInterface (string)' CONFIG_OTG_NETWORK_BASIC2_COMM_INTF "Comm Intf"
++ string 'Data Interface iInterface (string)' CONFIG_OTG_NETWORK_BASIC2_DATA_INTF "Data Intf"
++
++endmenu
+diff -uNr linux/drivers/no-otg/functions/network/Config.in-blan linux/drivers/otg/functions/network/Config.in-blan
+--- linux/drivers/no-otg/functions/network/Config.in-blan 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/Config.in-blan 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,38 @@
++#
++# Network Function
++#
++# Copyright (C) 2002-2003 Belcarra
++#
++
++mainmenu_option next_comment
++ comment "MBLM-BLAN Networking Configuration"
++
++ string 'iConfiguration (string)' CONFIG_OTG_NETWORK_BLAN_DESC "BLAN Net Cfg"
++ string 'iInterface (string)' CONFIG_OTG_NETWORK_BLAN_INTF "Comm/Data Intf"
++
++
++ comment 'Special Framing Options'
++ bool "CRC" CONFIG_OTG_NETWORK_BLAN_CRC
++ if [ "$CONFIG_OTG_NETWORK_BLAN_CRC" = "y" ]; then
++
++ bool "Pad Before CRC (to wMaxPacketSize-1)" CONFIG_OTG_NETWORK_BLAN_PADBEFORE
++ bool "Pad After CRC" CONFIG_OTG_NETWORK_BLAN_PADAFTER
++ if [ "$CONFIG_OTG_NETWORK_BLAN" = "y" -a "$CONFIG_OTG_NETWORK_BLAN_PADAFTER" = "y" ]; then
++ int 'Pad multiple' CONFIG_OTG_NETWORK_BLAN_PADBYTES "8"
++ fi
++ bool "Fermat Randomizer" CONFIG_OTG_NETWORK_BLAN_FERMAT
++ fi
++
++ comment 'USBLAN Options'
++ bool "Do not Set Time" CONFIG_OTG_NETWORK_BLAN_DO_NOT_SETTIME
++ bool "Request Hostname" CONFIG_OTG_NETWORK_BLAN_HOSTNAME
++ bool "Infrastructure Device" CONFIG_OTG_NETWORK_BLAN_NONBRIDGED
++ bool "Data Notification OK" CONFIG_OTG_NETWORK_BLAN_DATA_NOTIFY_OK
++ int 'Pad multiple' CONFIG_OTG_NETWORK_BLAN_PADBYTES "8"
++ int 'Polling Interval ' CONFIG_OTG_NETWORK_BLAN_INTERVAL "4"
++ bool "Set iProduct from IPADDR" CONFIG_OTG_NETWORK_BLAN_IPADDR
++ bool "Auto-config" CONFIG_OTG_NETWORK_BLAN_AUTO_CONFIG
++ comment ''
++
++
++endmenu
+diff -uNr linux/drivers/no-otg/functions/network/Config.in-cdc linux/drivers/otg/functions/network/Config.in-cdc
+--- linux/drivers/no-otg/functions/network/Config.in-cdc 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/Config.in-cdc 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,16 @@
++#
++# Network Function
++#
++# Copyright (C) 2002-2003 Belcarra
++#
++
++mainmenu_option next_comment
++ comment "CDC Networking Configuration"
++
++ string 'iConfiguration (string)' CONFIG_OTG_NETWORK_CDC_DESC "SAFE Net Cfg"
++ string 'Comm Interface iInterface (string)' CONFIG_OTG_NETWORK_CDC_COMM_INTF "Comm Intf"
++ string 'Data (diabled) iInterface (string)' CONFIG_OTG_NETWORK_CDC_NODATA_INTF "Data (Disabled) Intf"
++ string 'Data Interface iInterface (string)' CONFIG_OTG_NETWORK_CDC_DATA_INTF "Data Intf"
++
++
++endmenu
+diff -uNr linux/drivers/no-otg/functions/network/Config.in-eem linux/drivers/otg/functions/network/Config.in-eem
+--- linux/drivers/no-otg/functions/network/Config.in-eem 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/Config.in-eem 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,17 @@
++#
++# Network Function
++#
++# Copyright (C) 2002-2003 Belcarra
++#
++
++mainmenu_option next_comment
++comment "EEM Networking Configuration"
++
++ #bool " Experimental Ethernet Mode" CONFIG_OTG_NETWORK_EEM
++ if [ "$CONFIG_OTG_NETWORK_EEM" = "y" ]; then
++ comment 'EEM Configuration'
++ string 'Data Interface iConfiguration (string)' CONFIG_OTG_NETWORK_EEM_DESC "EEM Net Cfg"
++ string 'Data Interface iInterface (string)' CONFIG_OTG_NETWORK_EEM_INTF "Data Intf"
++ fi
++
++endmenu
+diff -uNr linux/drivers/no-otg/functions/network/Config.in-safe linux/drivers/otg/functions/network/Config.in-safe
+--- linux/drivers/no-otg/functions/network/Config.in-safe 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/Config.in-safe 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,21 @@
++#
++# Network Function
++#
++# Copyright (C) 2002-2003 Belcarra
++#
++
++mainmenu_option next_comment
++ comment "MDLM-SAFE Networking Configuration"
++
++ string 'Data Interface iConfiguration (string)' CONFIG_OTG_NETWORK_SAFE_DESC "SAFE Net Cfg"
++ string 'Data Interface iInterface (string)' CONFIG_OTG_NETWORK_SAFE_INTF "Data Intf"
++ bool " Do not Set Time" CONFIG_OTG_NETWORK_SAFE_DO_NOT_SETTIME
++ bool " CRC" CONFIG_OTG_NETWORK_SAFE_CRC
++ if [ "$CONFIG_OTG_NETWORK_SAFE_CRC" = "y" ]; then
++ bool "Pad Before CRC (to wMaxPacketSize-1)" CONFIG_OTG_NETWORK_SAFE_PADBEFORE
++ fi
++ bool "Infrastructure Device" CONFIG_OTG_NETWORK_SAFE_NONBRIDGED
++ comment ''
++
++
++endmenu
+diff -uNr linux/drivers/no-otg/functions/network/Kconfig linux/drivers/otg/functions/network/Kconfig
+--- linux/drivers/no-otg/functions/network/Kconfig 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/Kconfig 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,131 @@
++menu "OTG Network Function"
++ depends on OTG
++
++config OTG_NETWORK
++ tristate " Network Function Driver"
++ depends on OTG
++
++menu "OTG Network Function options"
++ depends on OTG_NETWORK
++
++config OTG_NETWORK_VENDORID
++ hex "VendorID (hex value)"
++ depends on OTG && OTG_NETWORK
++ default "0x15ec"
++
++config OTG_NETWORK_PRODUCTID
++ hex "ProductID (hex value)"
++ depends on OTG && OTG_NETWORK
++ default "0xe003"
++
++config OTG_NETWORK_BCDDEVICE
++ hex "bcdDevice (binary-coded decimal)"
++ depends on OTG && OTG_NETWORK
++ default "0x0100"
++
++config OTG_NETWORK_MANUFACTURER
++ string "iManufacturer (string)"
++ depends on OTG && OTG_NETWORK
++ default "Belcarra"
++
++config OTG_NETWORK_PRODUCT_NAME
++ string "iProduct (string)"
++ depends on OTG && OTG_NETWORK
++ default "Belcarra BLAN Device"
++
++config OTG_NETWORK_BLAN_DESC
++ string " iConfiguration (string)"
++ depends on OTG && OTG_NETWORK
++ default "BLAN Net Cfg"
++
++config OTG_NETWORK_MANUFACTURER
++ string "iManufacturer (string)"
++ depends on OTG && OTG_NETWORK
++ default "Belcarra"
++
++config OTG_NETWORK_PRODUCT_NAME
++ string "iProduct (string)"
++ depends on OTG && OTG_NETWORK
++ default "Belcarra BLAN Device"
++
++config OTG_NETWORK_BLAN_DESC
++ string " iConfiguration (string)"
++ depends on OTG && OTG_NETWORK
++ default "BLAN Net Cfg"
++
++config OTG_NETWORK_BLAN_INTF
++ string " iInterface (string)"
++ depends on OTG && OTG_NETWORK
++ default "Comm/Data Intf"
++
++config OTG_NETWORK_BLAN_PADBYTES
++ int " Pad multiple"
++ default "8"
++
++config OTG_NETWORK_SAFE_DESC
++ string " Data Interface iConfiguration (string)"
++ depends on OTG && OTG_NETWORK
++ default "SAFE Net Cfg"
++
++config OTG_NETWORK_SAFE_INTF
++ string " Data Interface iInterface (string)"
++ depends on OTG && OTG_NETWORK
++ default "Data Intf"
++
++config OTG_NETWORK_CDC_DESC
++ string " iConfiguration (string)"
++ depends on OTG && OTG_NETWORK
++ default "SAFE Net Cfg"
++
++config OTG_NETWORK_CDC_COMM_INTF
++ string " Comm Interface iInterface (string)"
++ depends on OTG && OTG_NETWORK
++ default "Comm Intf"
++
++config OTG_NETWORK_CDC_NODATA_INTF
++ string " Data (diabled) iInterface (string)"
++ depends on OTG && OTG_NETWORK
++ default "Data (Disabled) Intf"
++
++config OTG_NETWORK_CDC_DATA_INTF
++ string " Data Interface iInterface (string)"
++ depends on OTG && OTG_NETWORK
++ default "Data Intf"
++
++config OTG_NETWORK_BASIC_DESC
++ string " Data Interface iConfiguration (string)"
++ depends on OTG && OTG_NETWORK
++ default "BASIC Net Cfg"
++
++config OTG_NETWORK_BASIC_INTF
++ string " Data Interface iInterface (string)"
++ depends on OTG && OTG_NETWORK
++ default "Data Intf"
++
++config OTG_NETWORK_BASIC2_DESC
++ string " Data Interface iConfiguration (string)"
++ depends on OTG && OTG_NETWORK
++ default "BASIC Net Cfg"
++
++config OTG_NETWORK_BASIC2_COMM_INTF
++ string " Comm Interface iInterface (string)"
++ depends on OTG && OTG_NETWORK
++ default "Comm Intf"
++
++config OTG_NETWORK_BASIC2_DATA_INTF
++ string " Data Interface iInterface (string)"
++ depends on OTG && OTG_NETWORK
++ default "Data Intf"
++
++config OTG_NETWORK_START_SINGLE
++ bool " Start Single Urb Test"
++ depends on OTG && OTG_NETWORK
++ default n
++
++config OTG_NETWORK_EP0TEST
++ bool " EP0 Test"
++ depends on OTG && OTG_NETWORK
++ default n
++
++endmenu
++endmenu
+diff -uNr linux/drivers/no-otg/functions/network/Makefile linux/drivers/otg/functions/network/Makefile
+--- linux/drivers/no-otg/functions/network/Makefile 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/Makefile 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,70 @@
++#
++# Network Function Driver
++#
++# Copyright (C) 2002-2003 Belcarra
++
++
++O_TARGET := network_target.o
++list-multi := network_fd.o
++
++network_fd-objs := net-l24-os.o net-fd.o basic.o basic2.o blan.o cdc.o safe.o fermat.o
++
++# Objects that export symbols.
++export-objs := net-l24-os.o net-fd.o
++
++
++# Object file lists.
++
++obj-y :=
++obj-m :=
++obj-n :=
++obj- :=
++
++# Each configuration option enables a list of files.
++
++obj-$(CONFIG_OTG_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.
++
++
++OTG_DIR=$(TOPDIR)/drivers/otg
++NETWORK_DIR=$(OTG_DIR)/functions/network
++include $(TOPDIR)/Rules.make
++EXTRA_CFLAGS += -Wno-unused -Wstrict-prototypes -Wno-format
++EXTRA_CFLAGS += -I$(NETWORK_DIR) -I$(OTG_DIR)
++EXTRA_CFLAGS_nostdinc += -Wstrict-prototypes -Wno-unused -Wno-format
++EXTRA_CFLAGS_nostdinc += -I$(NETWORK_DIR) -I$(OTG_DIR)
++
++# Link rules for multi-part drivers.
++
++network_fd.o: $(network_fd-objs)
++ $(LD) -r -o $@ $(network_fd-objs)
++
++# dependencies:
++
++net-fd.o: net-fd.h net-os.h network.h
++net-l24-os.o: net-fd.h net-os.h network.h
++
++
+diff -uNr linux/drivers/no-otg/functions/network/Makefile-l26 linux/drivers/otg/functions/network/Makefile-l26
+--- linux/drivers/no-otg/functions/network/Makefile-l26 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/Makefile-l26 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,22 @@
++#
++# Network Function Driver
++#
++# Copyright (C) 2002-2004 Belcarra Technologies Corp
++
++
++OTG=$(TOPDIR)/drivers/otg
++NETWORKD=$(OTG)/functions/network
++OTGCORE_DIR=$(OTG)/otgcore
++USBDCORE_DIR=$(OTG)/usbdcore
++EXTRA_CFLAGS += -I$(NETWORKD) -I$(OTG) -Wno-unused -Wno-format -I$(USBDCORE_DIR) -I$(OTGCORE_DIR)
++EXTRA_CFLAGS_nostdinc += -I$(NETWORKD) -I$(OTG) -Wno-unused -Wno-format -I$(USBDCORE_DIR) -I$(OTGCORE_DIR)
++
++network_fd-objs := network.o basic.o basic2.o blan.o cdc.o safe.o fermat.o
++obj-$(CONFIG_OTG_NETWORK) += network_fd.o
++
++
++# Link rules for multi-part drivers.
++
++network_fd.o: $(network_fd-objs)
++ $(LD) -r -o $@ $(network_fd-objs)
++
+diff -uNr linux/drivers/no-otg/functions/network/TODO.txt linux/drivers/otg/functions/network/TODO.txt
+--- linux/drivers/no-otg/functions/network/TODO.txt 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/TODO.txt 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,32 @@
++NETWORK TODO List Stuart Lynne
++Belcarra Tue Aug 24 21:36:09 PDT 2004
++
++
++1. NETWORK documentation
++
++
++2. BLAN
++ - data notification
++ - timeout to resend data notification after XX mS
++
++3. CDC
++ - filters
++
++
++4. RNDIS
++ - should we add back in?
++
++
++5. NOTIFICATIONS
++
++ NETWORK_CONNECTION
++ CONNECTION_SPEED_CHANGE
++
++
++
++I suspect that we should make the data notification a runtime option,
++the host driver would "enable" this after a certain number of devices
++are plugged in (say 5 or more, some configurable number.) This would
++be done by sending a vendor device request to the peripheral to tell
++the network driver that it needs to use this mechanism.
++
+diff -uNr linux/drivers/no-otg/functions/network/basic.c linux/drivers/otg/functions/network/basic.c
+--- linux/drivers/no-otg/functions/network/basic.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/basic.c 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,247 @@
++/*
++ * otg/functions/network/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.
++ *
++ */
++/*!
++ * @file otg/functions/network/basic.c
++ * @brief This file implements the required descriptors to implement
++ * a basic network device with a single interface.
++ *
++ * The BASIC network driver implements a very simple descriptor set.
++ * A single interface with two BULK data endpoints and a optional
++ * INTERRUPT endpoint.
++ *
++ * @ingroup NetworkFunction
++ */
++
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++#include <linux/utsname.h>
++#include <linux/netdevice.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++
++#include "network.h"
++
++#define NTT network_fd_trace_tag
++
++#ifdef CONFIG_OTG_NETWORK_BASIC
++/* USB BASIC Configuration ******************************************************************** */
++
++/* BASIC Communication Interface Class descriptors
++ */
++/*! BULK OUT data endpoint descriptor
++ */
++static struct usbd_endpoint_descriptor basic_data_1 = {
++ bLength:sizeof(struct usbd_endpoint_descriptor),
++ bDescriptorType:USB_DT_ENDPOINT,
++ bEndpointAddress:USB_DIR_OUT,
++ bmAttributes: BULK,
++ wMaxPacketSize: 0,
++ bInterval: 0,
++};
++/*! BULK IN data endpoint descriptor
++ */
++static struct usbd_endpoint_descriptor basic_data_2 =// { 0x07, USB_DT_ENDPOINT, USB_DIR_IN, BULK, 0, 0x00, 0x00, };
++{
++ bLength:sizeof(struct usbd_endpoint_descriptor),
++ bDescriptorType:USB_DT_ENDPOINT,
++ bEndpointAddress:USB_DIR_IN,
++ bmAttributes: BULK,
++ wMaxPacketSize: 0,
++ bInterval: 0x0,
++};
++
++/*! INTERRUPT IN data endpoint descriptor
++ */
++static struct usbd_endpoint_descriptor basic_comm_1 = //{ 0x07, USB_DT_ENDPOINT, USB_DIR_IN, INTERRUPT,0, 0x00, 0x0a, };
++{
++ bLength:sizeof(struct usbd_endpoint_descriptor),
++ bDescriptorType:USB_DT_ENDPOINT,
++ bEndpointAddress:USB_DIR_IN,
++ bmAttributes: INTERRUPT,
++ wMaxPacketSize: 0,
++ bInterval: 0xa,
++};
++
++/*! Endpoint descriptor list
++ */
++static struct usbd_endpoint_descriptor *basic_default[] = { &basic_data_1,
++ &basic_data_2,
++ &basic_comm_1, };
++u8 basic_indexes[] = { BULK_OUT, BULK_IN, INT_IN, };
++
++/*! Data Interface Descriptor
++ */
++static struct usbd_interface_descriptor basic_data_alternate_descriptor = {
++ bLength:sizeof(struct usbd_interface_descriptor),
++ bDescriptorType:USB_DT_INTERFACE,
++ bInterfaceNumber: 0x00,
++ bAlternateSetting: 0x00, // bInterfaceNumber, bAlternateSetting
++ sizeof (basic_default) / sizeof(struct usbd_endpoint_descriptor *), // bNumEndpoints
++ bInterfaceClass:LINEO_CLASS,
++ bInterfaceSubClass:LINEO_SUBCLASS_BASIC_NET,
++ bInterfaceProtocol:LINEO_BASIC_NET_CRC,
++ iInterface:0x00,
++};
++
++/*! Data Alternate Interface Description List
++ */
++static struct usbd_alternate_description basic_data_alternate_descriptions[] = {
++ { iInterface: CONFIG_OTG_NETWORK_BASIC_INTF,
++ interface_descriptor: (struct usbd_interface_descriptor *)&basic_data_alternate_descriptor,
++ endpoints:sizeof (basic_default) / sizeof(struct usbd_endpoint_descriptor *),
++ endpoint_list: basic_default,
++ endpoint_indexes: basic_indexes,
++ },
++};
++
++
++/* BASIC Data Interface Alternate descriptions and descriptors
++ */
++
++/* BASIC Interface descriptions and descriptors
++ */
++/*! Interface Description List
++ */
++struct usbd_interface_description basic_interfaces[] = {
++ { alternates:sizeof (basic_data_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ alternate_list:basic_data_alternate_descriptions,},
++};
++
++/* BASIC Configuration descriptions and descriptors
++ */
++/*! Configuration Descriptor
++ */
++u8 basic_configuration_descriptor[sizeof(struct usbd_configuration_descriptor)] = {
++ 0x09, USB_DT_CONFIGURATION, 0x00, 0x00, // wLength
++ sizeof (basic_interfaces) / sizeof (struct usbd_interface_description),
++ 0x01, 0x00, // bConfigurationValue, iConfiguration
++ 0, 0,
++};
++
++/*! Configuration Description List
++ */
++struct usbd_configuration_description basic_description[] = {
++ { iConfiguration: CONFIG_OTG_NETWORK_BASIC_DESC,
++ configuration_descriptor: (struct usbd_configuration_descriptor *)basic_configuration_descriptor,
++ },
++
++};
++
++/* BASIC Device Description
++ */
++/*! Device Descriptor
++ */
++static struct usbd_device_descriptor basic_device_descriptor = {
++ bLength: sizeof(struct usbd_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_OTG_NETWORK_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_BCDDEVICE),
++};
++
++#ifdef CONFIG_OTG_HIGH_SPEED
++/*! High Speed Device Qualifier Descriptor
++ */
++static struct usbd_device_qualifier_descriptor basic_device_qualifier_descriptor = {
++ bLength: sizeof(struct usbd_device_qualifier_descriptor),
++ bDescriptorType: USB_DT_DEVICE_QUALIFIER,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: COMMUNICATIONS_DEVICE_CLASS,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++};
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++/*! Endpoint Request List
++ */
++static struct usbd_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, },
++};
++
++/*! OTG Descriptor
++ */
++static struct usbd_otg_descriptor basic_otg_descriptor = {
++ bLength : sizeof(struct usbd_otg_descriptor),
++ bDescriptorType: USB_DT_OTG,
++ bmAttributes: 0,
++};
++
++/*! Device Description
++ */
++struct usbd_device_description basic_device_description = {
++ device_descriptor: &basic_device_descriptor,
++#ifdef CONFIG_OTG_HIGH_SPEED
++ device_qualifier_descriptor: &basic_device_qualifier_descriptor,
++#endif /* CONFIG_OTG_HIGH_SPEED */
++ otg_descriptor: &basic_otg_descriptor,
++ iManufacturer: CONFIG_OTG_NETWORK_MANUFACTURER,
++ iProduct: CONFIG_OTG_NETWORK_PRODUCT_NAME,
++#if !defined(CONFIG_OTG_NO_SERIAL_NUMBER) && defined(CONFIG_OTG_SERIAL_NUMBER_STR)
++ iSerialNumber:CONFIG_OTG_SERIAL_NUMBER_STR,
++#endif
++};
++
++
++/*! basic_init
++ * @param function The function instance
++ */
++void basic_init (struct usbd_function_instance *function)
++{
++ basic_data_alternate_descriptions[0].endpoints = Usb_network_private.have_interrupt ? 3 : 2;
++}
++
++/*! function driver description
++ */
++struct usbd_function_driver basic_function_driver = {
++ name: "network-BASIC",
++ fops: &net_fd_function_ops,
++ device_description: &basic_device_description,
++ bNumConfigurations: sizeof (basic_description) / sizeof (struct usbd_configuration_description),
++ configuration_description: basic_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_BCDDEVICE),
++ bNumInterfaces:sizeof (basic_interfaces) / sizeof (struct usbd_interface_description),
++ interface_list:basic_interfaces,
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: basic_endpoint_requests,
++};
++#endif /* CONFIG_OTG_NETWORK_BASIC */
++
+diff -uNr linux/drivers/no-otg/functions/network/basic2.c linux/drivers/otg/functions/network/basic2.c
+--- linux/drivers/no-otg/functions/network/basic2.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/basic2.c 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,320 @@
++/*
++ * otg/functions/network/basic2.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.
++ *
++ */
++/*!
++ * @file otg/functions/network/basic2.c
++ * @brief This file implements the required descriptors to implement
++ * a basic network device with two interfaces.
++ *
++ * The BASIC2 network driver implements a very simple descriptor set.
++ * A data interface with two BULK data endpoints and comm interface with
++ * an INTERRUPT endpoint.
++ *
++ * @ingroup NetworkFunction
++ */
++
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++#include <linux/utsname.h>
++#include <linux/netdevice.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/otg-compat.h>
++#include <otg/usbp-func.h>
++
++#include "network.h"
++
++#define NTT network_fd_trace_tag
++
++#ifdef CONFIG_OTG_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, USB_DIR_OUT, BULK, 0, 0x00, 0x00, };
++//static u8 basic2_data_2[] = { 0x07, USB_DT_ENDPOINT, USB_DIR_IN, BULK, 0, 0x00, 0x00, };
++//static u8 basic2_comm_1[] = { 0x07, USB_DT_ENDPOINT, USB_DIR_IN, INTERRUPT,0, 0x00, 0x0a, };
++
++/*! BULK OUT data endpoint descriptor
++ */
++static struct usbd_endpoint_descriptor basic2_data_1 = {
++ bLength:sizeof(struct usbd_endpoint_descriptor),
++ bDescriptorType:USB_DT_ENDPOINT,
++ bEndpointAddress:USB_DIR_OUT,
++ bmAttributes: BULK,
++ wMaxPacketSize: 0,
++ bInterval: 0,
++};
++/*! BULK IN data endpoint descriptor
++ */
++static struct usbd_endpoint_descriptor basic2_data_2 = {
++ bLength:sizeof(struct usbd_endpoint_descriptor),
++ bDescriptorType:USB_DT_ENDPOINT,
++ bEndpointAddress:USB_DIR_IN,
++ bmAttributes: BULK,
++ wMaxPacketSize: 0,
++ bInterval: 0x0,
++};
++
++/*! INTERRUPT IN data endpoint descriptor
++ */
++static struct usbd_endpoint_descriptor basic2_comm_1 = {
++ bLength:sizeof(struct usbd_endpoint_descriptor),
++ bDescriptorType:USB_DT_ENDPOINT,
++ bEndpointAddress:USB_DIR_IN,
++ bmAttributes: INTERRUPT,
++ wMaxPacketSize: 0,
++ bInterval: 0xa,
++};
++
++/*! Endpoint descriptor list
++ */
++static struct usbd_endpoint_descriptor *basic2_default[] = {
++ &basic2_data_1,
++ &basic2_data_2,
++ &basic2_comm_1, };
++u8 basic2_indexes[] = { BULK_OUT, BULK_IN, INT_IN, };
++
++static struct usbd_endpoint_descriptor *basic2_comm_endpoints[] = {
++ (struct usbd_endpoint_descriptor *) &basic2_comm_1, };
++
++/*! Endpoint descriptor list
++ */
++static struct usbd_endpoint_descriptor *basic2_data_endpoints[] = {
++ (struct usbd_endpoint_descriptor *) &basic2_data_1,
++ (struct usbd_endpoint_descriptor *) &basic2_data_2, };
++
++u8 basic2_comm_indexes[] = { INT_IN, };
++u8 basic2_data_indexes[] = { BULK_OUT, BULK_IN, };
++
++
++/* BASIC2 Data Interface Alternate endpoints
++ */
++
++
++#ifndef COMMUNICATIONS_NETWORK_SUBCLASS
++#define COMMUNICATIONS_NETWORK_SUBCLASS 0
++#endif
++
++#ifndef VENDOR_PROTOCOL
++#define VENDOR_PROTOCOL 0xFF
++#endif
++/*! Comm Interface Descriptor
++ */
++static struct usbd_interface_descriptor basic2_comm_alternate_descriptor = {
++ bLength:sizeof(struct usbd_interface_descriptor),
++ bDescriptorType:USB_DT_INTERFACE,
++ bInterfaceNumber: 0x00,
++ bAlternateSetting: 0x00, // bInterfaceNumber, bAlternateSetting
++ sizeof (basic2_default) / sizeof(struct usbd_endpoint_descriptor *), // bNumEndpoints
++ bInterfaceClass:COMMUNICATIONS_INTERFACE_CLASS,
++ bInterfaceSubClass:COMMUNICATIONS_NETWORK_SUBCLASS,
++ bInterfaceProtocol:VENDOR_PROTOCOL,
++ iInterface:0x00,
++};
++
++/*! Data Interface Descriptor
++ */
++static struct usbd_interface_descriptor basic2_data_alternate_descriptor = {
++ bLength:sizeof(struct usbd_interface_descriptor),
++ bDescriptorType:USB_DT_INTERFACE,
++ bInterfaceNumber: 0x01,
++ bAlternateSetting: 0x00, // bInterfaceNumber, bAlternateSetting
++ sizeof (basic2_default) / sizeof(struct usbd_endpoint_descriptor *), // bNumEndpoints
++ bInterfaceClass:DATA_INTERFACE_CLASS,
++ bInterfaceSubClass:COMMUNICATIONS_NO_SUBCLASS,
++ bInterfaceProtocol:COMMUNICATIONS_NO_PROTOCOL,
++ iInterface:0x00,
++};
++
++/*! Comm Alternate Interface Description List
++ */
++static struct usbd_alternate_description basic2_comm_alternate_descriptions[] = {
++ { iInterface: CONFIG_OTG_NETWORK_BASIC2_COMM_INTF,
++ interface_descriptor: (struct usbd_interface_descriptor *)&basic2_comm_alternate_descriptor,
++ endpoints:sizeof (basic2_comm_endpoints) / sizeof(struct usbd_endpoint_descriptor *),
++ endpoint_list:basic2_comm_endpoints,
++ endpoint_indexes:basic2_comm_indexes,
++ },
++};
++
++
++/*! Data Alternate Interface Description List
++ */
++static struct usbd_alternate_description basic2_data_alternate_descriptions[] = {
++ { iInterface: CONFIG_OTG_NETWORK_BASIC2_DATA_INTF,
++ interface_descriptor: (struct usbd_interface_descriptor *)&basic2_data_alternate_descriptor,
++ endpoints:sizeof (basic2_data_endpoints) / sizeof(struct usbd_endpoint_descriptor *),
++ endpoint_list: basic2_data_endpoints,
++ endpoint_indexes: basic2_data_indexes,
++ },
++};
++
++
++/* BASIC Data Interface Alternate descriptions and descriptors
++ */
++
++/* BASIC Interface descriptions and descriptors
++ */
++/*! Interface Description List
++ */
++static struct usbd_interface_description basic2_interfaces[] = {
++ { alternates:sizeof (basic2_comm_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ alternate_list:basic2_comm_alternate_descriptions,},
++
++ { alternates:sizeof (basic2_data_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ alternate_list:basic2_data_alternate_descriptions,},
++};
++
++
++/* BASIC Configuration descriptions and descriptors
++ */
++/*! Configuration Descriptor
++ */
++u8 basic2_configuration_descriptor[sizeof(struct usbd_configuration_descriptor)] = {
++ 0x09, USB_DT_CONFIGURATION, 0x00, 0x00, // wLength
++ sizeof (basic2_interfaces) / sizeof (struct usbd_interface_description),
++ 0x01, 0x00, // bConfigurationValue, iConfiguration
++ 0, 0,
++};
++
++/*! Configuration Description List
++ */
++struct usbd_configuration_description basic2_description[] = {
++ { iConfiguration: CONFIG_OTG_NETWORK_BASIC2_DESC,
++ configuration_descriptor: (struct usbd_configuration_descriptor *)basic2_configuration_descriptor,
++ },
++
++};
++
++/* BASIC Device Description
++ */
++/*! Device Descriptor
++ */
++static struct usbd_device_descriptor basic2_device_descriptor = {
++ bLength: sizeof(struct usbd_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_OTG_NETWORK_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_BCDDEVICE),
++};
++
++#ifdef CONFIG_OTG_HIGH_SPEED
++/*! High Speed Device Qualifier Descriptor
++ */
++static struct usbd_device_qualifier_descriptor basic2_device_qualifier_descriptor = {
++ bLength: sizeof(struct usbd_device_qualifier_descriptor),
++ bDescriptorType: USB_DT_DEVICE_QUALIFIER,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: COMMUNICATIONS_DEVICE_CLASS,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++};
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++/*! Endpoint Request List
++ */
++static struct usbd_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, },
++};
++
++/*! OTG Descriptor
++ */
++static struct usbd_otg_descriptor basic2_otg_descriptor = {
++ bLength : sizeof(struct usbd_otg_descriptor),
++ bDescriptorType: USB_DT_OTG,
++ bmAttributes: 0,
++};
++/*! Device Description
++ */
++struct usbd_device_description basic2_device_description = {
++ device_descriptor: &basic2_device_descriptor,
++#ifdef CONFIG_OTG_HIGH_SPEED
++ device_qualifier_descriptor: &basic2_device_qualifier_descriptor,
++#endif /* CONFIG_OTG_HIGH_SPEED */
++ otg_descriptor: &basic2_otg_descriptor,
++ iManufacturer: CONFIG_OTG_NETWORK_MANUFACTURER,
++ iProduct: CONFIG_OTG_NETWORK_PRODUCT_NAME,
++#if !defined(CONFIG_OTG_NO_SERIAL_NUMBER) && defined(CONFIG_OTG_SERIAL_NUMBER_STR)
++ iSerialNumber:CONFIG_OTG_SERIAL_NUMBER_STR,
++#endif
++};
++
++
++/*! basic2_init
++ * @param function The function instance
++ */
++void basic2_init (struct usbd_function_instance *function)
++{
++ TRACE_MSG0(NTT,"entered");
++
++ basic2_comm_alternate_descriptions[0].endpoints = Usb_network_private.have_interrupt ? 1 : 0;
++
++ TRACE_MSG2(NTT,"alternate: %p endpoints: %d",
++ basic2_data_alternate_descriptions,
++ basic2_data_alternate_descriptions->endpoints
++ );
++
++ TRACE_MSG0(NTT,"exited");
++}
++
++
++/*! function driver description
++ */
++struct usbd_function_driver basic2_function_driver = {
++ name: "network-BASIC2",
++ fops: &net_fd_function_ops,
++ device_description: &basic2_device_description,
++ bNumConfigurations: sizeof (basic2_description) / sizeof (struct usbd_configuration_description),
++ configuration_description: basic2_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_BCDDEVICE),
++ bNumInterfaces:sizeof (basic2_interfaces) / sizeof (struct usbd_interface_description),
++ interface_list:basic2_interfaces,
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: basic2_endpoint_requests,
++};
++#endif /* CONFIG_OTG_NETWORK_BASIC2 */
++
+diff -uNr linux/drivers/no-otg/functions/network/blan.c linux/drivers/otg/functions/network/blan.c
+--- linux/drivers/no-otg/functions/network/blan.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/blan.c 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,403 @@
++/*
++ * otg/functions/network/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.
++ *
++ */
++/*!
++ * @file otg/functions/network/blan.c
++ * @brief This file implements the required descriptors to implement
++ * a BLAN network device with a single interface.
++ *
++ * The BLAN network driver implements the BLAN protocol descriptors.
++ *
++ * The BLAN protocol is designed to support smart devices that want
++ * to create a virtual network between them host and other similiar
++ * devices.
++ *
++ * @ingroup NetworkFunction
++ */
++
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++#include <linux/utsname.h>
++#include <linux/netdevice.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++
++#include "network.h"
++
++#define NTT network_fd_trace_tag
++
++#ifdef CONFIG_OTG_NETWORK_BLAN
++/* USB BLAN Configuration ******************************************************************** */
++
++/*
++ * BLAN Ethernet Configuration
++ */
++
++/* Communication Interface Class descriptors
++ */
++
++/*! BULK OUT data endpoint descriptor
++ */
++static struct usbd_endpoint_descriptor blan_data_1 = {
++ .bLength = sizeof(struct usbd_endpoint_descriptor),
++ .bDescriptorType = USB_DT_ENDPOINT,
++ .bEndpointAddress = USB_DIR_OUT,
++ .bmAttributes = BULK,
++ .wMaxPacketSize = 0,
++ .bInterval = 0,
++};
++/*! BULK IN data endpoint descriptor
++ */
++static struct usbd_endpoint_descriptor blan_data_2 =// { 0x07, USB_DT_ENDPOINT, USB_DIR_IN, BULK, 0, 0x00, 0x00, };
++{
++ .bLength = sizeof(struct usbd_endpoint_descriptor),
++ .bDescriptorType = USB_DT_ENDPOINT,
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = BULK,
++ .wMaxPacketSize = 0,
++ .bInterval = 0x0,
++};
++
++/*! INTERRUPT IN data endpoint descriptor
++ */
++static struct usbd_endpoint_descriptor blan_comm_1 = //{ 0x07, USB_DT_ENDPOINT, USB_DIR_IN, INTERRUPT,0, 0x00, 0x0a, };
++{
++ .bLength = sizeof(struct usbd_endpoint_descriptor),
++ .bDescriptorType = USB_DT_ENDPOINT,
++ .bEndpointAddress = USB_DIR_IN,
++ .bmAttributes = INTERRUPT,
++ .wMaxPacketSize = 0,
++#if defined (CONFIG_OTG_NETWORK_BLAN_INTERVAL)
++ .bInterval = CONFIG_OTG_NETWORK_BLAN_INTERVAL,
++#else
++ .bInterval = 0x08,
++#endif /* defined (CONFIG_OTG_NETWORK_BLAN_INTERVAL) */
++};
++
++//static u8 blan_class_1[] = { 0x05, CS_INTERFACE, USB_ST_HEADER, 0x10, 0x01, /* CLASS_BDC_VERSION, CLASS_BDC_VERSION */ };
++static struct usbd_class_header_function_descriptor blan_class_1 = {
++ .bFunctionLength = 0x05, /* Length */
++ .bDescriptorType = CS_INTERFACE,
++ .bDescriptorSubtype = USB_ST_HEADER,
++ .bcdCDC = __constant_cpu_to_le16(0x0110) /*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 */
++static struct usbd_class_mdlm_descriptor blan_class_2 = {
++ .bFunctionLength = 0x15,
++ .bDescriptorType = CS_INTERFACE,
++ .bDescriptorSubtype = USB_ST_MDLM,
++ .bcdVersion = __constant_cpu_to_le16(0x0100),
++ .bGUID = {
++ 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 struct usbd_class_blan_descriptor blan_class_3 = {
++ .bFunctionLength = 0x07,
++ .bDescriptorType = CS_INTERFACE,
++ .bDescriptorSubtype = USB_ST_MDLMD,
++ .bGuidDescriptorType = 0x01,
++ .bmNetworkCapabilities = 0x00,
++ .bmDataCapabilities = 0x00,
++ .bPad = 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 struct usbd_class_ethernet_networking_descriptor blan_class_4 = {
++ .bFunctionLength = 0x0d,
++ .bDescriptorType = CS_INTERFACE,
++ .bDescriptorSubtype = USB_ST_ENF,
++ .iMACAddress = 0x00,
++ .bmEthernetStatistics = 0x00,
++ .wMaxSegmentSize = 0x05ea, /* 1514 maximum frame size */
++ .wNumberMCFilters = 0x00,
++ .bNumberPowerFilters = 0x00 ,
++};
++
++//static u8 blan_class_5[] = { 0x07, CS_INTERFACE, USB_ST_NCT, 0x00, 0x00, 0x00, 0x00, };
++static struct usbd_class_network_channel_descriptor blan_class_5 = {
++ .bFunctionLength = 0x07,
++ .bDescriptorType = CS_INTERFACE,
++ .bDescriptorSubtype = USB_ST_NCT,
++ .bEntityId = 0,
++ .iName = 0,
++ .bChannelIndex = 0,
++ .bPhysicalInterface = 0,
++};
++
++
++/*! Endpoint descriptor list
++ */
++static struct usbd_endpoint_descriptor *blan_alt_endpoints[] = {
++ (struct usbd_endpoint_descriptor *) &blan_data_1,
++ (struct usbd_endpoint_descriptor *) &blan_data_2,
++ (struct usbd_endpoint_descriptor *) &blan_comm_1, };
++
++u8 blan_alt_indexes[] = { BULK_OUT, BULK_IN, INT_IN, };
++
++static struct usbd_generic_class_descriptor *blan_comm_class_descriptors[] = {
++ (struct usbd_generic_class_descriptor *) &blan_class_1,
++ (struct usbd_generic_class_descriptor *) &blan_class_2,
++ (struct usbd_generic_class_descriptor *) &blan_class_3,
++ (struct usbd_generic_class_descriptor *) &blan_class_4,
++ (struct usbd_generic_class_descriptor *) &blan_class_5, };
++
++
++/*! Data Interface Descriptor
++ */
++static struct usbd_interface_descriptor blan_alternate_descriptor = {
++ .bLength = 0x09,
++ .bDescriptorType = USB_DT_INTERFACE,
++ .bInterfaceNumber = 0x00,
++ .bAlternateSetting = 0x00, // bInterfaceNumber, bAlternateSetting
++ .bNumEndpoints = sizeof (blan_alt_endpoints) / sizeof(struct usbd_endpoint_descriptor *), // bNumEndpoints
++ .bInterfaceClass = COMMUNICATIONS_INTERFACE_CLASS,
++ .bInterfaceSubClass = COMMUNICATIONS_MDLM_SUBCLASS,
++ .bInterfaceProtocol = COMMUNICATIONS_NO_PROTOCOL,
++ .iInterface = 0x00,
++};
++
++/*! Data Alternate Interface Description List
++ */
++static struct usbd_alternate_description blan_alternate_descriptions[] = {
++ {
++ .iInterface = CONFIG_OTG_NETWORK_BLAN_INTF,
++ .interface_descriptor = (struct usbd_interface_descriptor *)&blan_alternate_descriptor,
++ .classes = sizeof (blan_comm_class_descriptors) / sizeof (struct usbd_generic_class_descriptor *),
++ .class_list = blan_comm_class_descriptors,
++ .endpoints = sizeof (blan_alt_endpoints) / sizeof(struct usbd_endpoint_descriptor *),
++ .endpoint_list = blan_alt_endpoints,
++ .endpoint_indexes = blan_alt_indexes,
++ },
++};
++/* Interface descriptions and descriptors
++ */
++/*! Interface Description List
++ */
++static struct usbd_interface_description blan_interfaces[] = {
++ {
++ .alternates = sizeof (blan_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ .alternate_list = blan_alternate_descriptions,
++ },
++};
++
++
++/* Configuration descriptions and descriptors
++ */
++
++/*! Configuration Descriptor
++ */
++static struct usbd_configuration_descriptor blan_configuration_descriptor = {
++ .bLength = 0x09,
++ .bDescriptorType = USB_DT_CONFIGURATION,
++ .wTotalLength = 0x00, // wLength
++ .bNumInterfaces = sizeof (blan_interfaces) / sizeof (struct usbd_interface_description),
++ .bConfigurationValue = 0x01,
++ .iConfiguration = 0x00, // bConfigurationValue, iConfiguration
++ .bmAttributes = 0,
++ .bMaxPower = 0,
++};
++
++/*! Configuration Description List
++ */
++struct usbd_configuration_description blan_description[] = {
++ {
++ .iConfiguration = CONFIG_OTG_NETWORK_BLAN_DESC,
++ .configuration_descriptor = &blan_configuration_descriptor,
++ },
++};
++
++/* Device Description
++ */
++
++/*! Device Descriptor
++ */
++static struct usbd_device_descriptor blan_device_descriptor = {
++ .bLength = sizeof(struct usbd_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_OTG_NETWORK_VENDORID),
++ .idProduct = __constant_cpu_to_le16(CONFIG_OTG_NETWORK_PRODUCTID),
++ .bcdDevice = __constant_cpu_to_le16(CONFIG_OTG_NETWORK_BCDDEVICE),
++};
++
++#ifdef CONFIG_OTG_HIGH_SPEED
++/*! High Speed Device Qualifier Descriptor
++ */
++static struct usbd_device_qualifier_descriptor blan_device_qualifier_descriptor = {
++ .bLength = sizeof(struct usbd_device_qualifier_descriptor),
++ .bDescriptorType = USB_DT_DEVICE_QUALIFIER,
++ .bcdUSB = __constant_cpu_to_le16(USB_BCD_VERSION),
++ .bDeviceClass = COMMUNICATIONS_DEVICE_CLASS,
++ .bDeviceSubClass = 0x02,
++ .bDeviceProtocol = 0x00,
++ .bMaxPacketSize0 = 0x00,
++};
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++/*! Endpoint Request List
++ */
++static struct usbd_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, },
++};
++
++/*! OTG Descriptor
++ */
++static struct usbd_otg_descriptor blan_otg_descriptor = {
++ .bLength = sizeof(struct usbd_otg_descriptor),
++ .bDescriptorType = USB_DT_OTG,
++ .bmAttributes = 0,
++};
++
++/*! Device Description
++ */
++struct usbd_device_description blan_device_description = {
++ .device_descriptor = &blan_device_descriptor,
++#ifdef CONFIG_OTG_HIGH_SPEED
++ .device_qualifier_descriptor = &blan_device_qualifier_descriptor,
++#endif /* CONFIG_OTG_HIGH_SPEED */
++ .otg_descriptor = &blan_otg_descriptor,
++ .iManufacturer = CONFIG_OTG_NETWORK_MANUFACTURER,
++ .iProduct = CONFIG_OTG_NETWORK_PRODUCT_NAME,
++#if !defined(CONFIG_OTG_NO_SERIAL_NUMBER) && defined(CONFIG_OTG_SERIAL_NUMBER_STR)
++ .iSerialNumber = CONFIG_OTG_SERIAL_NUMBER_STR,
++#endif
++};
++
++
++/*! blan_init
++ * @param function The function instance
++ */
++void blan_init (struct usbd_function_instance *function)
++{
++ struct usbd_class_ethernet_networking_descriptor *ethernet;
++ struct usbd_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
++ TRACE_MSG0(NTT,"alloc mac string");
++ if ((ethernet = &blan_class_4))
++ ethernet->iMACAddress = usbd_alloc_string(address_str);
++ TRACE_MSG0(NTT,"alloc mac string done");
++ }
++ TRACE_MSG0(NTT,"alloc channel string");
++ if ((channel = &blan_class_5))
++ channel->iName = usbd_alloc_string(system_utsname.nodename);
++ TRACE_MSG0(NTT,"alloc channel string done");
++
++#ifdef CONFIG_OTG_NETWORK_BLAN_PADBYTES
++ blan_class_3.bPad = CONFIG_OTG_NETWORK_BLAN_PADBYTES;
++ len += sprintf(buf + len, "PADBYTES: %02x ", blan_class_3.bPad);
++#endif
++#ifdef CONFIG_OTG_NETWORK_BLAN_PADBEFORE
++ blan_class_3.bmDataCapabilities |= BMDATA_PADBEFORE;
++ len += sprintf(buf + len, "PADBEFORE: %02x ", blan_class_3.bmDataCapabilities);
++#endif
++#ifdef CONFIG_OTG_NETWORK_BLAN_PADAFTER
++ blan_class_3.bmDataCapabilities |= BMDATA_PADAFTER;
++ len += sprintf(buf + len, "PADAFTER: %02x ", blan_class_3.bmDataCapabilities);
++#endif
++#ifdef CONFIG_OTG_NETWORK_BLAN_CRC
++ blan_class_3.bmDataCapabilities |= BMDATA_CRC;
++ len += sprintf(buf + len, "CRC: %02x ", blan_class_3.bmDataCapabilities);
++#endif
++#ifdef CONFIG_OTG_NETWORK_BLAN_FERMAT
++ blan_class_3.bmDataCapabilities |= BMDATA_FERMAT;
++ len += sprintf(buf + len, "FERMAT: %02x ", blan_class_3.bmDataCapabilities);
++#endif
++#ifdef CONFIG_OTG_NETWORK_BLAN_HOSTNAME
++ blan_class_3.bmDataCapabilities |= BMDATA_HOSTNAME;
++ len += sprintf(buf + len, "HOSTNAME: %02x ", blan_class_3.bmDataCapabilities);
++#endif
++#ifdef CONFIG_OTG_NETWORK_BLAN_NONBRIDGED
++ blan_class_3.bmNetworkCapabilities |= BMNETWORK_NONBRIDGED;
++ len += sprintf(buf + len, "NONBRIDGE: %02x ", blan_class_3.bmNetworkCapabilities);
++#endif
++#ifdef CONFIG_OTG_NETWORK_BLAN_DATA_NOTIFY_OK
++ blan_class_3.bmNetworkCapabilities |= BMNETWORK_DATA_NOTIFY_OK;
++ len += sprintf(buf + len, "DATA NOTIFY: %02x ", blan_class_3.bmNetworkCapabilities);
++#endif
++ if (strlen(buf))
++ TRACE_MSG1(NTT,"%s", buf);
++}
++
++/*! function driver description
++ */
++struct usbd_function_driver blan_function_driver = {
++ .name = "network-BLAN",
++ .fops = &net_fd_function_ops,
++ .device_description = &blan_device_description,
++ .bNumConfigurations = sizeof (blan_description) / sizeof (struct usbd_configuration_description),
++ .configuration_description = blan_description,
++ .idVendor = __constant_cpu_to_le16(CONFIG_OTG_NETWORK_VENDORID),
++ .idProduct = __constant_cpu_to_le16(CONFIG_OTG_NETWORK_PRODUCTID),
++ .bcdDevice = __constant_cpu_to_le16(CONFIG_OTG_NETWORK_BCDDEVICE),
++ .bNumInterfaces = sizeof (blan_interfaces) / sizeof (struct usbd_interface_description),
++ .interface_list = blan_interfaces,
++ .endpointsRequested = ENDPOINTS,
++ .requestedEndpoints = blan_endpoint_requests,
++};
++#endif /* CONFIG_OTG_NETWORK_BLAN */
++
+diff -uNr linux/drivers/no-otg/functions/network/cdc.c linux/drivers/otg/functions/network/cdc.c
+--- linux/drivers/no-otg/functions/network/cdc.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/cdc.c 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,376 @@
++/*
++ * otg/functions/network/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.
++ *
++ * The CDC network driver implements the standard CDC Ethernet descriptors.
++ *
++ * The CDC protocol is suitable for infrastructure devices that
++ * are implementing a bridged or routed connection betwen an
++ * external network and the USB Host.
++ *
++ */
++/*!
++ * @file otg/functions/network/cdc.c
++ * @brief This file implements the required descriptors to implement
++ * a CDC network device with two interfaces.
++ *
++ * @ingroup NetworkFunction
++ */
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#include <linux/interrupt.h>
++#include <linux/utsname.h>
++#include <linux/netdevice.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++
++#include "network.h"
++
++#define NTT network_fd_trace_tag
++
++
++#ifdef CONFIG_OTG_NETWORK_CDC
++/* USB CDC Configuration ********************************************************************* */
++
++/* CDC Communication Interface Class descriptors
++ */
++/*! BULK OUT data endpoint descriptor
++ */
++static struct usbd_endpoint_descriptor cdc_data_1 = {
++ bLength: 0x07,
++ bDescriptorType: USB_DT_ENDPOINT,
++ bEndpointAddress: USB_DIR_OUT,
++ bmAttributes: BULK,
++ wMaxPacketSize: __constant_cpu_to_le16(0x00),
++ bInterval: 0x00,
++};
++
++/*! BULK IN data endpoint descriptor
++ */
++static struct usbd_endpoint_descriptor cdc_data_2 = {
++ bLength: 0x07,
++ bDescriptorType: USB_DT_ENDPOINT,
++ bEndpointAddress: USB_DIR_IN,
++ bmAttributes: BULK,
++ wMaxPacketSize: __constant_cpu_to_le16(0x00),
++ bInterval: 0x00,
++};
++
++/*! INTERRUPT IN data endpoint descriptor
++ */
++static struct usbd_endpoint_descriptor cdc_comm_1 = {
++ bLength: 0x07,
++ bDescriptorType: USB_DT_ENDPOINT,
++ bEndpointAddress: USB_DIR_IN,
++ bmAttributes: INTERRUPT,
++ wMaxPacketSize: __constant_cpu_to_le16(0x00),
++ bInterval: 0x0a,
++};
++
++
++
++
++//static u8 cdc_class_1[] = { 0x05, CS_INTERFACE, USB_ST_HEADER, 0x10, 0x01, /* CLASS_BDC_VERSION, CLASS_BDC_VERSION */ };
++
++static struct usbd_class_header_function_descriptor cdc_class_1 = {
++ bFunctionLength: 0x05,
++ bDescriptorType: CS_INTERFACE,
++ bDescriptorSubtype: USB_ST_HEADER,
++ bcdCDC: __constant_cpu_to_le16(0x0110),
++};
++
++
++//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 struct usbd_class_ethernet_networking_descriptor cdc_class_2 = {
++ bFunctionLength: 0x0D,
++ bDescriptorType: CS_INTERFACE,
++ bDescriptorSubtype: USB_ST_HEADER,
++ iMACAddress: 0x00,
++ bmEthernetStatistics: 0x00,
++ wMaxSegmentSize: __constant_cpu_to_le16(0x05ea),
++ wNumberMCFilters: 0,
++ bNumberPowerFilters: 0,
++};
++
++//static u8 cdc_class_3[] = { 0x05, CS_INTERFACE, USB_ST_UF, 0x00, 0x01, /* bMasterInterface, bSlaveInterface */};
++
++static struct usbd_class_union_function_descriptor cdc_class_3 =
++{
++ bFunctionLength: 0x05,
++ bDescriptorType: CS_INTERFACE,
++ bDescriptorSubtype: USB_ST_UF,
++ bMasterInterface: 0x00,
++ bSlaveInterface0: {1},
++
++};
++
++static usbd_class_descriptor_t *cdc_comm_class_descriptors[] = {
++ (struct usbd_generic_class_descriptor *) &cdc_class_1,
++ (struct usbd_generic_class_descriptor *) &cdc_class_2,
++ (struct usbd_generic_class_descriptor *) &cdc_class_3,
++};
++
++/*! Endpoint descriptor list
++ */
++static usbd_endpoint_descriptor_t *cdc_data_endpoints[] = {
++ (struct usbd_endpoint_descriptor *) &cdc_data_1,
++ (struct usbd_endpoint_descriptor *) &cdc_data_2,
++};
++static usbd_endpoint_descriptor_t *cdc_comm_endpoints[] = {
++ (usbd_endpoint_descriptor_t *) &cdc_comm_1, };
++
++u8 cdc_comm_indexes[] = { INT_IN, };
++u8 cdc_data_indexes[] = { BULK_OUT, BULK_IN, };
++
++
++/*! Comm Interface Descriptor
++ */
++static struct usbd_interface_descriptor cdc_comm_alternate_descriptor = {
++ bLength: sizeof(struct usbd_interface_descriptor),
++ bDescriptorType: USB_DT_INTERFACE,
++ bInterfaceNumber: 0x00,
++ bAlternateSetting: 0x00,
++ bNumEndpoints: sizeof(cdc_comm_endpoints)/sizeof(usbd_endpoint_descriptor_t *),
++ bInterfaceClass: COMMUNICATIONS_INTERFACE_CLASS,
++ bInterfaceSubClass: COMMUNICATIONS_ENCM_SUBCLASS,
++ bInterfaceProtocol: COMMUNICATIONS_NO_PROTOCOL,
++ iInterface: 0x00
++};
++
++/*! No Data Interface Descriptor
++ */
++static struct usbd_interface_descriptor cdc_nodata_alternate_descriptor = {
++ bLength: sizeof(struct usbd_interface_descriptor),
++ bDescriptorType: USB_DT_INTERFACE,
++ bInterfaceNumber: 0x01,
++ bAlternateSetting: 0x00,
++ bNumEndpoints: 0,
++ bInterfaceClass: DATA_INTERFACE_CLASS,
++ bInterfaceSubClass: COMMUNICATIONS_NO_SUBCLASS,
++ bInterfaceProtocol: COMMUNICATIONS_NO_PROTOCOL,
++ iInterface: 0x00
++};
++
++/*! Data Interface Descriptor
++ */
++static struct usbd_interface_descriptor cdc_data_alternate_descriptor = {
++ bLength: sizeof(struct usbd_interface_descriptor),
++ bDescriptorType: USB_DT_INTERFACE,
++ bInterfaceNumber: 0x01,
++ bAlternateSetting: 0x01,
++ bNumEndpoints: sizeof(cdc_comm_endpoints)/sizeof(usbd_endpoint_descriptor_t *),
++ bInterfaceClass: DATA_INTERFACE_CLASS,
++ bInterfaceSubClass: COMMUNICATIONS_NO_SUBCLASS,
++ bInterfaceProtocol: COMMUNICATIONS_NO_PROTOCOL,
++ iInterface: 0x00
++};
++
++/*! Comm Alternate Interface Description List
++ */
++static struct usbd_alternate_description cdc_comm_alternate_descriptions[] = {
++ {
++ iInterface: CONFIG_OTG_NETWORK_CDC_COMM_INTF,
++ interface_descriptor: &cdc_comm_alternate_descriptor,
++ classes:sizeof (cdc_comm_class_descriptors) / sizeof (struct usbd_generic_class_descriptor *),
++ class_list: cdc_comm_class_descriptors,
++
++ endpoints:sizeof (cdc_comm_endpoints) / sizeof(struct usbd_endpoint_descriptor *),
++ endpoint_list: cdc_comm_endpoints,
++ endpoint_indexes: cdc_comm_indexes,
++ },
++};
++
++
++/*! Data Alternate Interface Description List
++ */
++static struct usbd_alternate_description cdc_data_alternate_descriptions[] = {
++ {
++ iInterface: CONFIG_OTG_NETWORK_CDC_NODATA_INTF,
++ interface_descriptor: (struct usbd_interface_descriptor *)&cdc_nodata_alternate_descriptor,
++ },
++ {
++ iInterface: CONFIG_OTG_NETWORK_CDC_DATA_INTF,
++ interface_descriptor: &cdc_data_alternate_descriptor,
++ endpoints:sizeof (cdc_data_endpoints) / sizeof(struct usbd_endpoint_descriptor *),
++ endpoint_list: cdc_data_endpoints,
++ endpoint_indexes: cdc_data_indexes,
++ },
++};
++
++/* Interface descriptions and descriptors
++ */
++/*! Interface Description List
++ */
++static struct usbd_interface_description cdc_interfaces[] = {
++ {
++ alternates:sizeof (cdc_comm_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ alternate_list:cdc_comm_alternate_descriptions,
++ },
++ {
++ alternates:sizeof (cdc_data_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ alternate_list:cdc_data_alternate_descriptions,
++ },
++};
++
++
++/* Configuration descriptions and descriptors
++ */
++
++/*! Configuration Descriptor
++ */
++static struct usbd_configuration_descriptor cdc_configuration_descriptor = {
++ bLength: sizeof(struct usbd_configuration_descriptor),
++ bDescriptorType: USB_DT_CONFIGURATION,
++ wTotalLength:0,
++ bNumInterfaces:sizeof(cdc_interfaces)/sizeof(struct usbd_interface_description *),
++ bConfigurationValue: 0x01,
++ iConfiguration: 0x00,
++ bmAttributes:0,
++ bMaxPower:0,
++};
++
++/*! Configuration Description List
++ */
++static struct usbd_configuration_description cdc_description[] = {
++ { iConfiguration: CONFIG_OTG_NETWORK_CDC_DESC,
++ configuration_descriptor: &cdc_configuration_descriptor,
++ },
++};
++
++
++
++/* Device Description
++ */
++
++/*! Device Descriptor
++ */
++static struct usbd_device_descriptor cdc_device_descriptor = {
++ bLength: sizeof(struct usbd_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_OTG_NETWORK_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_BCDDEVICE),
++};
++
++#ifdef CONFIG_OTG_HIGH_SPEED
++/*! High Speed Device Qualifier Descriptor
++ */
++static struct usbd_device_qualifier_descriptor cdc_device_qualifier_descriptor = {
++ bLength: sizeof(struct usbd_device_qualifier_descriptor),
++ bDescriptorType: USB_DT_DEVICE_QUALIFIER,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: COMMUNICATIONS_DEVICE_CLASS,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++};
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++/*! Endpoint Request List
++ */
++static struct usbd_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, },
++};
++
++/*! OTG Descriptor
++ */
++static struct usbd_otg_descriptor cdc_otg_descriptor = {
++ bLength : sizeof(struct usbd_otg_descriptor),
++ bDescriptorType: USB_DT_OTG,
++ bmAttributes: 0,
++};
++
++/*! Device Description
++ */
++struct usbd_device_description cdc_device_description = {
++ device_descriptor: &cdc_device_descriptor,
++#ifdef CONFIG_OTG_HIGH_SPEED
++ device_qualifier_descriptor: &cdc_device_qualifier_descriptor,
++#endif /* CONFIG_OTG_HIGH_SPEED */
++ otg_descriptor: &cdc_otg_descriptor,
++ iManufacturer: CONFIG_OTG_NETWORK_MANUFACTURER,
++ iProduct: CONFIG_OTG_NETWORK_PRODUCT_NAME,
++#if !defined(CONFIG_OTG_NO_SERIAL_NUMBER) && defined(CONFIG_OTG_SERIAL_NUMBER_STR)
++ iSerialNumber:CONFIG_OTG_SERIAL_NUMBER_STR,
++#endif
++};
++
++
++
++/*! cdc_init
++ * @param function The function instance
++ */
++void cdc_init (struct usbd_function_instance *function)
++{
++ struct usbd_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 = &cdc_class_2)) {
++ if (ethernet->iMACAddress) {
++ usbd_free_string_descriptor(ethernet->iMACAddress);
++ }
++ ethernet->iMACAddress = usbd_alloc_string(address_str);
++ }
++ }
++}
++
++
++/*! function driver description
++ */
++struct usbd_function_driver cdc_function_driver = {
++ name: "network-CDC",
++ fops: &net_fd_function_ops,
++ device_description: &cdc_device_description,
++ bNumConfigurations: sizeof (cdc_description) / sizeof (struct usbd_configuration_description),
++ configuration_description: cdc_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_BCDDEVICE),
++ bNumInterfaces:sizeof (cdc_interfaces) / sizeof (struct usbd_interface_description),
++ interface_list:cdc_interfaces,
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: cdc_endpoint_requests,
++};
++#endif /* CONFIG_OTG_NETWORK_CDC */
++
+diff -uNr linux/drivers/no-otg/functions/network/eem.c linux/drivers/otg/functions/network/eem.c
+--- linux/drivers/no-otg/functions/network/eem.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/eem.c 2006-09-01 21:41:28.000000000 +0200
+@@ -0,0 +1,247 @@
++/*
++ * otg/functions/network/eem.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.
++ *
++ */
++/*!
++ * @file otg/functions/network/eem.c
++ * @brief This file implements the required descriptors to implement
++ * a eem network device with a single interface.
++ *
++ * The BASIC network driver implements a very simple descriptor set.
++ * A single interface with two BULK data endpoints and a optional
++ * INTERRUPT endpoint.
++ *
++ * @ingroup NetworkFunction
++ */
++
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++#include <linux/utsname.h>
++#include <linux/netdevice.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++
++#include "network.h"
++
++#define NTT network_fd_trace_tag
++
++#ifdef CONFIG_OTG_NETWORK_BASIC
++/* USB BASIC Configuration ******************************************************************** */
++
++/* BASIC Communication Interface Class descriptors
++ */
++/*! BULK OUT data endpoint descriptor
++ */
++static struct usbd_endpoint_descriptor eem_data_1 = {
++ bLength:sizeof(struct usbd_endpoint_descriptor),
++ bDescriptorType:USB_DT_ENDPOINT,
++ bEndpointAddress:USB_DIR_OUT,
++ bmAttributes: BULK,
++ wMaxPacketSize: 0,
++ bInterval: 0,
++};
++/*! BULK IN data endpoint descriptor
++ */
++static struct usbd_endpoint_descriptor eem_data_2 =// { 0x07, USB_DT_ENDPOINT, USB_DIR_IN, BULK, 0, 0x00, 0x00, };
++{
++ bLength:sizeof(struct usbd_endpoint_descriptor),
++ bDescriptorType:USB_DT_ENDPOINT,
++ bEndpointAddress:USB_DIR_IN,
++ bmAttributes: BULK,
++ wMaxPacketSize: 0,
++ bInterval: 0x0,
++};
++
++/*! INTERRUPT IN data endpoint descriptor
++ */
++static struct usbd_endpoint_descriptor eem_comm_1 = //{ 0x07, USB_DT_ENDPOINT, USB_DIR_IN, INTERRUPT,0, 0x00, 0x0a, };
++{
++ bLength:sizeof(struct usbd_endpoint_descriptor),
++ bDescriptorType:USB_DT_ENDPOINT,
++ bEndpointAddress:USB_DIR_IN,
++ bmAttributes: INTERRUPT,
++ wMaxPacketSize: 0,
++ bInterval: 0xa,
++};
++
++/*! Endpoint descriptor list
++ */
++static struct usbd_endpoint_descriptor *eem_default[] = { &eem_data_1,
++ &eem_data_2,
++ &eem_comm_1, };
++u8 eem_indexes[] = { BULK_OUT, BULK_IN, INT_IN, };
++
++/*! Data Interface Descriptor
++ */
++static struct usbd_interface_descriptor eem_data_alternate_descriptor = {
++ bLength:sizeof(struct usbd_interface_descriptor),
++ bDescriptorType:USB_DT_INTERFACE,
++ bInterfaceNumber: 0x00,
++ bAlternateSetting: 0x00, // bInterfaceNumber, bAlternateSetting
++ sizeof (eem_default) / sizeof(struct usbd_endpoint_descriptor *), // bNumEndpoints
++ bInterfaceClass:LINEO_CLASS,
++ bInterfaceSubClass:LINEO_SUBCLASS_BASIC_NET,
++ bInterfaceProtocol:LINEO_BASIC_NET_CRC,
++ iInterface:0x00,
++};
++
++/*! Data Alternate Interface Description List
++ */
++static struct usbd_alternate_description eem_data_alternate_descriptions[] = {
++ { iInterface: CONFIG_OTG_NETWORK_BASIC_INTF,
++ interface_descriptor: (struct usbd_interface_descriptor *)&eem_data_alternate_descriptor,
++ endpoints:sizeof (eem_default) / sizeof(struct usbd_endpoint_descriptor *),
++ endpoint_list: eem_default,
++ endpoint_indexes: eem_indexes,
++ },
++};
++
++
++/* BASIC Data Interface Alternate descriptions and descriptors
++ */
++
++/* BASIC Interface descriptions and descriptors
++ */
++/*! Interface Description List
++ */
++struct usbd_interface_description eem_interfaces[] = {
++ { alternates:sizeof (eem_data_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ alternate_list:eem_data_alternate_descriptions,},
++};
++
++/* BASIC Configuration descriptions and descriptors
++ */
++/*! Configuration Descriptor
++ */
++u8 eem_configuration_descriptor[sizeof(struct usbd_configuration_descriptor)] = {
++ 0x09, USB_DT_CONFIGURATION, 0x00, 0x00, // wLength
++ sizeof (eem_interfaces) / sizeof (struct usbd_interface_description),
++ 0x01, 0x00, // bConfigurationValue, iConfiguration
++ 0, 0,
++};
++
++/*! Configuration Description List
++ */
++struct usbd_configuration_description eem_description[] = {
++ { iConfiguration: CONFIG_OTG_NETWORK_BASIC_DESC,
++ configuration_descriptor: (struct usbd_configuration_descriptor *)eem_configuration_descriptor,
++ },
++
++};
++
++/* BASIC Device Description
++ */
++/*! Device Descriptor
++ */
++static struct usbd_device_descriptor eem_device_descriptor = {
++ bLength: sizeof(struct usbd_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_OTG_NETWORK_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_BCDDEVICE),
++};
++
++#ifdef CONFIG_OTG_HIGH_SPEED
++/*! High Speed Device Qualifier Descriptor
++ */
++static struct usbd_device_qualifier_descriptor eem_device_qualifier_descriptor = {
++ bLength: sizeof(struct usbd_device_qualifier_descriptor),
++ bDescriptorType: USB_DT_DEVICE_QUALIFIER,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: COMMUNICATIONS_DEVICE_CLASS,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++};
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++/*! Endpoint Request List
++ */
++static struct usbd_endpoint_request eem_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, },
++};
++
++/*! OTG Descriptor
++ */
++static struct usbd_otg_descriptor eem_otg_descriptor = {
++ bLength : sizeof(struct usbd_otg_descriptor),
++ bDescriptorType: USB_DT_OTG,
++ bmAttributes: 0,
++};
++
++/*! Device Description
++ */
++struct usbd_device_description eem_device_description = {
++ device_descriptor: &eem_device_descriptor,
++#ifdef CONFIG_OTG_HIGH_SPEED
++ device_qualifier_descriptor: &eem_device_qualifier_descriptor,
++#endif /* CONFIG_OTG_HIGH_SPEED */
++ otg_descriptor: &eem_otg_descriptor,
++ iManufacturer: CONFIG_OTG_NETWORK_MANUFACTURER,
++ iProduct: CONFIG_OTG_NETWORK_PRODUCT_NAME,
++#if !defined(CONFIG_OTG_NO_SERIAL_NUMBER) && defined(CONFIG_OTG_SERIAL_NUMBER_STR)
++ iSerialNumber:CONFIG_OTG_SERIAL_NUMBER_STR,
++#endif
++};
++
++
++/*! eem_init
++ * @param function The function instance
++ */
++void eem_init (struct usbd_function_instance *function)
++{
++ eem_data_alternate_descriptions[0].endpoints = Usb_network_private.have_interrupt ? 3 : 2;
++}
++
++/*! function driver description
++ */
++struct usbd_function_driver eem_function_driver = {
++ name: "network-BASIC",
++ fops: &net_fd_function_ops,
++ device_description: &eem_device_description,
++ bNumConfigurations: sizeof (eem_description) / sizeof (struct usbd_configuration_description),
++ configuration_description: eem_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_BCDDEVICE),
++ bNumInterfaces:sizeof (eem_interfaces) / sizeof (struct usbd_interface_description),
++ interface_list:eem_interfaces,
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: eem_endpoint_requests,
++};
++#endif /* CONFIG_OTG_NETWORK_BASIC */
++
+diff -uNr linux/drivers/no-otg/functions/network/fermat.c linux/drivers/otg/functions/network/fermat.c
+--- linux/drivers/no-otg/functions/network/fermat.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/fermat.c 2006-09-01 21:41:30.000000000 +0200
+@@ -0,0 +1,140 @@
++/*
++ * otg/functions/network/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.
++ *
++ */
++/*!
++ * @file otg/functions/network/fermat.c
++ * @brief This implements a special data munging function that
++ * randomizes data. This is a very specific fix for a device
++ * that had trouble with runs of zeros.
++ *
++ * @ingroup NetworkFunction
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++
++#ifdef CONFIG_OTG_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_OTG_NETWORK_BLAN_FERMAT */
++
+diff -uNr linux/drivers/no-otg/functions/network/fermat.h linux/drivers/otg/functions/network/fermat.h
+--- linux/drivers/no-otg/functions/network/fermat.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/fermat.h 2006-09-01 21:41:30.000000000 +0200
+@@ -0,0 +1,46 @@
++/*
++ * otg/functions/network/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.
++ *
++ *
++ */
++/*!
++ * @file otg/functions/network/fermat.h
++ * @brief Fermat related data structures.
++ *
++ *
++ * @ingroup NetworkFunction
++ */
++
++#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 -uNr linux/drivers/no-otg/functions/network/net-fd.c linux/drivers/otg/functions/network/net-fd.c
+--- linux/drivers/no-otg/functions/network/net-fd.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/net-fd.c 2006-09-01 21:41:30.000000000 +0200
+@@ -0,0 +1,1463 @@
++/*
++ * otg/functions/network/net-fd.c - Network Function Driver
++ *
++ * Copyright (c) 2002, 2003, 2004 Belcarra
++ *
++ * By:
++ * Tom Rushworth <tbr@belcarra.com>
++ * 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.
++ *
++ */
++/*!
++ * @file otg/functions/network/net-fd.c
++ * @brief The lower edge (USB Device Function) implementation of
++ * the Network Function Driver. This performs the core protocol
++ * handling and data encpasulation.
++ *
++ * This implements the lower edge (USB Device) layer of the Network Function
++ * Driver. Specifically the data encapsulation, envent and protocol handlers.
++ *
++ *
++ *
++ * 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/
++ *
++ * When configured for CDC it can also work with any CDC Class driver.
++ *
++ *
++ * @ingroup NetworkFunction
++ */
++
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++//#include <linux/config.h>
++//#include <linux/module.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 <otg/usbp-chap9.h>
++//#include <otg/usbd-mem.h>
++#include <otg/usbp-func.h>
++
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++
++#include "network.h"
++#include "net-fd.h"
++#include "net-os.h"
++#ifdef CONFIG_OTG_NETWORK_BLAN_FERMAT
++#include "fermat.h"
++#endif
++
++otg_tag_t network_fd_trace_tag;
++#define NTT network_fd_trace_tag
++
++#if defined(CONFIG_OTG_NETWORK_CDC)
++void cdc_init(struct usbd_function_instance *);
++extern struct usbd_function_driver cdc_function_driver;
++#endif
++
++#ifdef CONFIG_OTG_NETWORK_EEM
++void eem_init(struct usbd_function_instance *);
++extern struct usbd_function_driver eem_function_driver;
++#endif
++
++#ifdef CONFIG_OTG_NETWORK_BASIC
++void basic_init(struct usbd_function_instance *);
++extern struct usbd_function_driver basic_function_driver;
++#endif
++
++#ifdef CONFIG_OTG_NETWORK_BASIC2
++void basic2_init(struct usbd_function_instance *);
++extern struct usbd_function_driver basic2_function_driver;
++#endif
++
++#ifdef CONFIG_OTG_NETWORK_SAFE
++void safe_init(struct usbd_function_instance *);
++extern struct usbd_function_driver safe_function_driver;
++#endif
++
++#ifdef CONFIG_OTG_NETWORK_BLAN
++void blan_init(struct usbd_function_instance *);
++extern struct usbd_function_driver blan_function_driver;
++#endif
++
++static char ip_addr_str[20];
++u32 ip_addr;
++u32 router_ip;
++u32 network_mask;
++u32 dns_server_ip;
++
++//_________________________________________________________________________________________________
++
++/*
++ * 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_OTG_NETWORK_CRC_DUFF4
++#undef CONFIG_OTG_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
++
++/*! make_crc_table
++ * 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_OTG_NETWORK_CRC_DUFF4) && !defined(CONFIG_OTG_NETWORK_CRC_DUFF8)
++/*! crc32_copy
++ * Copies a specified number of bytes, computing the 32-bit CRC FCS as it does so.
++ *
++ * @param dst Pointer to the destination memory area.
++ * @param src Pointer to the source memory area.
++ * @param len Number of bytes to copy.
++ * @param val Starting value for the CRC FCS.
++ *
++ * @return 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 */
++
++/*! crc32_copy
++ * Copies a specified number of bytes, computing the 32-bit CRC FCS as it does so.
++ *
++ * @param dst Pointer to the destination memory area.
++ * @param src Pointer to the source memory area.
++ * @param len Number of bytes to copy.
++ * @param val Starting value for the CRC FCS.
++ *
++ * @return Final value of the CRC FCS.
++ *
++ * @sa crc32_pad
++ */
++static u32 crc32_copy (u8 *dst, u8 *src, int len, u32 val)
++{
++#if defined(CONFIG_OTG_NETWORK_CRC_DUFF8)
++ int n = (len + 7) / 8;
++ switch (len % 8)
++#elif defined(CONFIG_OTG_NETWORK_CRC_DUFF4)
++ int n = (len + 3) / 4;
++ switch (len % 4)
++#endif
++ {
++ case 0: do {
++ val = COMPUTE_FCS (val, *dst++ = *src++);
++#if defined(CONFIG_OTG_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
++ *
++ * @return CRC FCS
++ */
++static u32 __inline__ crc32_pad (u8 *dst, int len, u32 val)
++{
++ for (; len-- > 0; val = COMPUTE_FCS (val, *dst++ = '\0'));
++ return val;
++}
++
++//_________________________________________________________________________________________________
++// net_fd_send_int
++//
++
++/*! net_fd_urb_sent_int - callback for completed INT URB
++ *
++ * Handles notification that an urb has been sent (successfully or otherwise).
++ *
++ * @return non-zero for failure.
++ */
++STATIC int net_fd_urb_sent_int (struct usbd_urb *urb, int urb_rc)
++{
++ unsigned long flags;
++ int rc = -EINVAL;
++ struct usb_network_private *npd = urb->function_privdata;
++
++ TRACE_MSG3(NTT,"urb: %p npd: %p urb_rc: %d", urb, npd, urb_rc);
++
++ local_irq_save(flags);
++ npd->int_urb = NULL;
++ usbd_free_urb (urb);
++ local_irq_restore(flags);
++ return 0;
++}
++
++/*! net_fd_send_int_blan - send an interrupt notification response
++ *
++ * Generates a response urb on the notification (INTERRUPT) endpoint.
++ *
++ * This is called from either a scheduled task or from the process context
++ * that calls network_open() or network_close().
++ * This must be called with interrupts locked out as net_fd_event_handler can
++ * change the NETWORK_ATTACHED status
++ *
++ */
++STATIC void net_fd_send_int_blan(struct usb_network_private *npd, int connected, int data)
++{
++ struct usbd_urb *urb;
++ struct cdc_notification_descriptor *cdc;
++ int rc;
++ struct usbd_function_instance *function = (npd?npd->function:NULL);
++
++ TRACE_MSG2(NTT,"npd=%p function=%p",npd,function);
++
++ do {
++ BREAK_IF(!function);
++
++
++ BREAK_IF(npd->network_type != network_blan);
++ BREAK_IF(!npd->have_interrupt);
++
++ BREAK_IF(!(npd->flags & NETWORK_ATTACHED));
++
++ TRACE_MSG3(NTT,"connected: %d network: %d %d", connected,
++ npd->network_type, network_blan);
++
++ BREAK_IF(usbd_get_device_status(function) != USBD_OK);
++
++ //if (npd->int_urb) {
++ // printk(KERN_INFO"%s: int_urb: %p\n", __FUNCTION__, npd->int_urb);
++ // usbd_cancel_urb_irq(npd->int_urb);
++ // npd->int_urb = NULL;
++ //}
++
++ BREAK_IF(!(urb = usbd_alloc_urb (function, INT_IN,
++ sizeof(struct cdc_notification_descriptor), net_fd_urb_sent_int)));
++
++ urb->actual_length = sizeof(struct cdc_notification_descriptor);
++ memset(urb->buffer, 0, sizeof(struct cdc_notification_descriptor));
++ urb->function_privdata = npd;
++
++ cdc = (struct cdc_notification_descriptor *)urb->buffer;
++
++ cdc->bmRequestType = 0xa1;
++
++ if (data) {
++ cdc->bNotification = 0xf0;
++ cdc->wValue = 1;
++ }
++ else {
++ cdc->bNotification = 0x00;
++ cdc->wValue = connected ? 0x01 : 0x00;
++ }
++ cdc->wIndex = 0x00; // XXX interface - check that this is correct
++
++
++ npd->int_urb = urb;
++ TRACE_MSG1(NTT,"int_urb: %p", urb);
++ BREAK_IF (!(rc = usbd_start_in_urb (urb)));
++
++ TRACE_MSG1(NTT,"usbd_start_in_urb failed err: %x", rc);
++ printk(KERN_ERR"%s: usbd_start_in_urb failed err: %x\n", __FUNCTION__, rc);
++ urb->function_privdata = NULL;
++ npd->int_urb = NULL;
++ usbd_free_urb (urb);
++
++ } while(0);
++}
++
++//_________________________________________________________________________________________________
++// net_fd_start_xmit
++
++/*! net_fd_urb_sent_bulk - callback for completed BULK xmit URB
++ *
++ * Handles notification that an urb has been sent (successfully or otherwise).
++ *
++ * @param urb Pointer to the urb that has been sent.
++ * @param urb_rc Result code from the send operation.
++ *
++ * @return non-zero for failure.
++ */
++STATIC int net_fd_urb_sent_bulk (struct usbd_urb *urb, int urb_rc)
++{
++ unsigned long flags;
++ void *buff_ctx;
++ int rc = -EINVAL;
++
++ TRACE_MSG2(NTT,"urb: %p urb_rc: %d", urb, urb_rc);
++
++ local_irq_save(flags);
++ do {
++
++ BREAK_IF(!urb);
++ buff_ctx = urb->function_privdata;
++ TRACE_MSG2(NTT,"urb: %p buff_ctx: %p", urb, buff_ctx);
++ urb->function_privdata = NULL;
++
++ BREAK_IF(net_os_xmit_done(urb->function_instance,buff_ctx,urb_rc));
++
++ usbd_free_urb (urb);
++ rc = 0;
++
++ } while (0);
++ local_irq_restore(flags);
++ return rc;
++}
++
++/*! net_fd_start_xmit - start sending a buffer
++ *
++ * Called with net_os_mutex_enter()d.
++ *
++ * @return: 0 if all OK
++ * -EINVAL, -EUNATCH, -ENOMEM
++ * rc from usbd_start_in_urb() if that fails (is != 0, may be one of err values above)
++ * Note: -ECOMM is interpreted by calling routine as signal to leave IF stopped.
++ */
++STATIC int net_fd_start_xmit (struct usb_network_private *npd, u8 *buff, int len, void *buff_ctx)
++{
++ struct usbd_function_instance *function = (npd?npd->function:NULL);
++ struct usbd_urb *urb = NULL;
++ int rc;
++ int in_pkt_sz;
++ u8 *cp;
++ u32 crc;
++ TRACE_MSG2(NTT,"npd=%p function=%p",npd,function);
++
++#if 0
++ printk(KERN_INFO"%s: %s len: %d encap: %d\n", __FUNCTION__, net_device->name, len, npd->encapsulation);
++ printk(KERN_INFO"start_xmit: len: %x data: %p\n", len, buff);
++ {
++ u8 *cp = buff;
++ int i;
++ for (i = 0; i < len; i++) {
++ if ((i%32) == 0) {
++ printk("\ntx[%2x] ", i);
++ }
++ printk("%02x ", *cp++);
++ }
++ printk("\n");
++ }
++#endif
++
++ if (!(npd->flags & NETWORK_ATTACHED)) {
++ return -EUNATCH;
++ }
++ if (usbd_get_device_status(function) != USBD_OK) {
++ return -EINVAL;
++ }
++
++#if defined(CONFIG_OTG_NETWORK_CDC)
++ // verify interface is enabled - non-zero altsetting means data is enabled
++ if (!usbd_interface_AltSetting(function, DATA_INTF)) {
++ return -EINVAL;
++ }
++#endif
++ in_pkt_sz = usbd_endpoint_wMaxPacketSize(function, BULK_IN, usbd_high_speed(function));
++
++ if (npd->encapsulation != simple_crc) {
++ TRACE_MSG0(NTT,"unknown encapsulation");
++ printk(KERN_ERR"%s: unknown encapsulation\n", __FUNCTION__);
++ // Since we are now only really using one, just fix it.
++ npd->encapsulation = simple_crc;
++ }
++ //TRACE_MSG0(NTT,"SIMPLE_CRC");
++ // allocate urb 5 bytes larger than required
++ if (!(urb = usbd_alloc_urb (function, BULK_IN, len + 5 + 4 + in_pkt_sz, net_fd_urb_sent_bulk ))) {
++ u8 epa = usbd_endpoint_bEndpointAddress(function, BULK_IN, usbd_high_speed(function));
++ TRACE_MSG2(NTT,"urb alloc failed len: %d endpoint: %02x", len, epa);
++ printk(KERN_ERR"%s: urb alloc failed len: %d endpoint: %02x\n", __FUNCTION__, len, epa);
++ return -ENOMEM;
++ }
++
++ switch (npd->network_type) {
++ case network_eem:
++ cp = urb->buffer + 2;
++ urb->actual_length = len + 2;
++ break;
++ default:
++ cp = urb->buffer;
++ urb->actual_length = len;
++ break;
++ }
++ // copy and crc len bytes
++ crc = crc32_copy(cp, buff, len, CRC32_INIT);
++
++ switch (npd->network_type) {
++ case network_eem:
++ break;
++ default:
++ if ((urb->actual_length % in_pkt_sz) == (in_pkt_sz - 4)) {
++
++ #undef CONFIG_OTG_NETWORK_PADBYTE
++ #ifdef CONFIG_OTG_NETWORK_PADBYTE
++ // 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.
++ crc = crc32_pad(urb->buffer + urb->actual_length, 1, crc);
++ urb->actual_length++;
++ #else /* CONFIG_OTG_NETWORK_PADBYTE */
++ urb->flags |= USBD_URB_SENDZLP;
++ TRACE_MSG2(NTT,"setting ZLP: urb: %p flags: %x", urb, urb->flags);
++ #endif /* CONFIG_OTG_NETWORK_PADBYTE */
++ }
++ break;
++ }
++ // 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;
++ // End of CRC processing
++ //
++ switch (npd->network_type) {
++ case network_eem:
++ break;
++ default:
++ break;
++ }
++
++ TRACE_MSG3(NTT,"urb=%p buff_ctx=%p priv=%p",urb,buff_ctx,urb->function_privdata);
++ urb->function_privdata = (void *) buff_ctx;
++#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_OTG_NETWORK_BLAN_FERMAT)
++ if (npd->fermat) {
++ fermat_encode(urb->buffer, urb->actual_length);
++ }
++#endif
++ TRACE_MSG1(NTT,"sending urb: %p", urb);
++ if ((rc = usbd_start_in_urb (urb))) {
++
++ TRACE_MSG1(NTT,"FAILED: %d", rc);
++ printk(KERN_ERR"%s: FAILED: %d\n", __FUNCTION__, rc);
++ urb->function_privdata = NULL;
++ usbd_free_urb (urb);
++
++ return(rc);
++ }
++ #if 0
++ {
++ static int xmit_count = 0;
++ if (xmit_count++ == 100) {
++ TRACE_MSG1(NTT, "halt test: %02x", BULK_IN);
++ usbd_halt_endpoint(function, BULK_IN);
++ }
++ }
++ #endif
++
++ TRACE_MSG0(NTT,"OK");
++ return 0;
++}
++
++
++//_________________________________________________________________________________________________
++
++/*! net_fd_recv_urb - callback to process a received URB
++ *
++ * @return non-zero for failure.
++ */
++STATIC int net_fd_recv_urb(struct usbd_urb *urb, int rc)
++{
++ struct usbd_function_instance *function = urb->function_instance;
++ struct usb_network_private *npd = urb->function_privdata;
++ void *buff_ctx = NULL;
++ u8 *buff;
++ int crc_bad = 0;
++ int trim = 0;
++ int len;
++ int out_pkt_sz;
++ u32 crc;
++
++#if 0
++ printk(KERN_INFO"%s: urb: %p len: %d maxtransfer: %d encap: %d\n", __FUNCTION__,
++ urb, urb->actual_length, npd->maxtransfer, npd->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
++ if (!urb || !urb->function_instance || !npd || !npd->function ||
++ urb->function_instance != npd->function) {
++ TRACE_MSG4(NTT,"urb=%p npd=%p u->f=%p n->f=%p",
++ urb,(urb?npd:NULL),(urb?urb->function_instance:NULL),
++ ((urb&&npd)?npd->function:NULL));
++ }
++
++ THROW_IF(urb->status != RECV_OK, error);
++
++ out_pkt_sz = usbd_endpoint_wMaxPacketSize(function, BULK_OUT, usbd_high_speed(function));
++ // There is only one working encapsulation.
++ if (npd->encapsulation != simple_crc) {
++ npd->encapsulation = simple_crc;
++ }
++
++ len = urb->actual_length;
++ trim = 0;
++ buff_ctx = net_os_alloc_buff(npd, &buff, len);
++ THROW_IF((NULL == buff_ctx), error);
++
++#if defined(CONFIG_OTG_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 *src = urb->buffer;
++ int copied;
++
++ // 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, *buff++ = *src++));
++
++ for (; (len-- > 0) && (CRC32_GOOD != crc); crc = COMPUTE_FCS (crc, *buff++ = *src++));
++
++ trim = len + 4;
++
++ if (CRC32_GOOD != crc) {
++ TRACE_MSG1(NTT,"AAA frame: %03x", urb->framenum);
++ THROW_IF(npd->crc, crc_error);
++ }
++ else
++ npd->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
++ crc = crc32_copy(buff, urb->buffer, len - 1, CRC32_INIT);
++ buff += len - 1;
++
++ // if the CRC is good then this is case 1
++ if (CRC32_GOOD != crc) {
++
++ crc = crc32_copy(buff, urb->buffer + len - 1, 1, crc);
++ buff += 1;
++
++ if (CRC32_GOOD != crc) {
++ //crc_errors[len%64]++;
++ TRACE_MSG2(NTT,"A CRC error %08x %03x", crc, urb->framenum);
++ THROW_IF(npd->crc, crc_error);
++ }
++ else
++ npd->crc = 1;
++ }
++ else
++ npd->crc = 1;
++ }
++ else {
++ crc = crc32_copy(buff, urb->buffer, len, CRC32_INIT);
++ buff += len;
++
++ if (CRC32_GOOD != crc) {
++ //crc_errors[len%64]++;
++ TRACE_MSG2(NTT,"B CRC error %08x %03x", crc, urb->framenum);
++ THROW_IF(npd->crc, crc_error);
++ }
++ else
++ npd->crc = 1;
++ }
++ // trim IFF we are paying attention to crc
++ if (npd->crc)
++ trim = 4;
++#endif
++ // catch a simple error, just increment missed error and general error
++ CATCH(error) {
++ TRACE_MSG4(NTT,"CATCH(error) urb: %p status: %d len: %d function: %p",
++ urb, urb->status, urb->actual_length, function);
++ // catch a CRC error
++ CATCH(crc_error) {
++ crc_bad = 1;
++#if 0
++ printk(KERN_INFO"%s: urb: %p status: %d len: %d maxtransfer: %d encap: %d\n", __FUNCTION__,
++ urb, urb->status, urb->actual_length, npd->maxtransfer,
++ npd->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
++ }
++ }
++ net_os_recv_buff(npd,buff_ctx,crc_bad,trim);
++ TRACE_MSG1(NTT,"restart: %p", urb);
++ return (usbd_start_out_urb (urb));
++}
++/*! net_fd_recv_urb_eem - callback to process a received URB
++ *
++ * @return non-zero for failure.
++ */
++STATIC int net_fd_recv_urb_eem(struct usbd_urb *urb, int rc)
++{
++ return 0;
++}
++
++//_________________________________________________________________________________________________
++// net_fd_device_request
++//
++/*! net_fd_urb_received_ep0 - callback for sent URB
++ *
++ * Handles notification that an urb has been sent (successfully or otherwise).
++ *
++ * @return non-zero for failure.
++ */
++STATIC int net_fd_urb_received_ep0 (struct usbd_urb *urb, int urb_rc)
++{
++ TRACE_MSG2(NTT,"urb: %p status: %d", urb, urb->status);
++
++ printk(KERN_INFO"%s:\n", __FUNCTION__);
++ RETURN_EINVAL_IF (RECV_OK != urb->status);
++
++ // TRACE_MSG1(NTT,"%s", urb->buffer); // QQSV is this really a NUL-terminated string???
++
++ printk(KERN_INFO"%s: ok\n", __FUNCTION__);
++ return -EINVAL; // caller will de-allocate
++}
++
++/*! net_fd_device_request - process a received SETUP URB
++ *
++ * Processes a received setup packet and CONTROL WRITE data.
++ * Results for a CONTROL READ are placed in urb->buffer.
++ *
++ * @return non-zero for failure.
++ */
++STATIC int net_fd_device_request (struct usbd_function_instance *function, struct usbd_device_request *request)
++{
++ struct usb_network_private *npd = (struct usb_network_private *) (function->privdata);
++ struct usbd_urb *urb;
++ int index;
++
++ // 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;
++ npd->encapsulation = simple_crc;
++ return 0;
++
++ case BELCARRA_PING:
++ TRACE_MSG1(NTT,"H2D VENDOR IP: %08x", ip_addr);
++ if ((npd->network_type == network_blan))
++ net_os_send_notification_later(npd);
++ break;
++
++#if !defined(CONFIG_OTG_NETWORK_BLAN_DO_NOT_SETTIME) || !defined(CONFIG_OTG_NETWORK_SAFE_DO_NOT_SETTIME)
++ case BELCARRA_SETTIME:
++ {
++#if defined(LINUX24)
++ struct timeval tv;
++#else
++ struct timespec tv;
++#endif
++ memset(&tv, 0, sizeof(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;
++
++ TRACE_MSG1(NTT,"H2D VENDOR TIME: %08x", tv.tv_sec);
++
++ // set the time
++ do_settimeofday(&tv);
++ } break;
++#endif
++ case BELCARRA_SETIP:
++ ip_addr = ntohl( request->wValue << 16 | request->wIndex);
++ // XXX need to get in correct order here
++ npd->local_dev_addr[2] = (ip_addr >> 24) & 0xff;
++ npd->local_dev_addr[3] = (ip_addr >> 16) & 0xff;
++ npd->local_dev_addr[4] = (ip_addr >> 8) & 0xff;
++ npd->local_dev_addr[5] = (ip_addr >> 0) & 0xff;
++#ifdef CONFIG_OTG_NETWORK_BLAN_IPADDR
++ snprintf(ip_addr_str, sizeof(ip_addr_str), "%d.%d.%d.%d",
++ (ip_addr >> 24) & 0xff, (ip_addr >> 16) & 0xff,
++ (ip_addr >> 8) & 0xff, (ip_addr) & 0xff);
++ index = usbd_realloc_string(
++ npd->function_driver->device_description->device_descriptor->iProduct, ip_addr_str);
++#endif /* CONFIG_OTG_NETWORK_IPADDR */
++ 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_OTG_NETWORK_BLAN_FERMAT
++ case BELCARRA_SETFERMAT:
++ npd->fermat = 1;
++ break;
++#endif
++#ifdef CONFIG_OTG_NETWORK_BLAN_HOSTNAME
++ case BELCARRA_HOSTNAME:
++ TRACE_MSG0(NTT,"HOSTNAME");
++ RETURN_EINVAL_IF(!(urb = usbd_alloc_urb_ep0(function, le16_to_cpu(request->wLength),
++ net_fd_urb_received_ep0) ));
++ RETURN_ZERO_IF(!usbd_start_out_urb(urb)); // return if no error
++ usbd_free_urb(urb); // de-alloc if error
++ return -EINVAL;
++#endif
++#ifdef CONFIG_OTG_NETWORK_BLAN_DATA_NOTIFY_OK
++ case BELCARRA_DATA_NOTIFY:
++ TRACE_MSG0(NTT,"DATA NOTIFY");
++ npd->data_notify = 1;
++ 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, npd->local_dev_addr, ETH_ALEN);
++ urb->actual_length = ETH_ALEN;
++ return 0;
++ }
++ }
++#endif
++ return 0;
++ default:
++ break;
++ }
++ return -EINVAL;
++}
++//_________________________________________________________________________________________________
++
++#ifdef CONFIG_OTG_NETWORK_START_SINGLE
++#define NETWORK_START_URBS 1
++#else
++#define NETWORK_START_URBS 2
++#endif
++
++typedef enum mesg {
++ mesg_unknown,
++ mesg_configured,
++ mesg_reset,
++} mesg_t;
++mesg_t net_last_mesg;
++
++char * net_messages[3] = {
++ "",
++ "Network Configured",
++ "Network Reset",
++};
++
++/*! net_check_mesg
++ */
++void net_check_mesg(mesg_t curr_mesg)
++{
++ RETURN_UNLESS(net_last_mesg != curr_mesg);
++ net_last_mesg = curr_mesg;
++ otg_message(net_messages[curr_mesg]);
++}
++
++
++
++/*! net_fd_start_recv - start recv urb(s)
++ */
++STATIC void net_fd_start_recv(struct usbd_function_instance *function)
++{
++ struct usb_network_private *npd = (struct usb_network_private *) (function->privdata);
++ int i;
++ for (i = 0; i < NETWORK_START_URBS; i++) {
++ struct usbd_urb *urb;
++ BREAK_IF(!(urb = usbd_alloc_urb(function, BULK_OUT,
++ usbd_endpoint_transferSize(function, BULK_OUT, usbd_high_speed(function)),
++ net_fd_recv_urb)));
++ TRACE_MSG5(NTT,"i: %d urb=%p priv=%p npd=%p function=%p",
++ i, urb, urb->function_privdata, npd, function);
++
++ urb->function_privdata = npd;
++ if (usbd_start_out_urb(urb)) {
++ urb->function_privdata = NULL;
++ usbd_free_urb(urb);
++ }
++ }
++}
++
++/*! net_fd_start_recv_eem - start recv urb(s)
++ */
++STATIC void net_fd_start_recv_eem(struct usbd_function_instance *function)
++{
++}
++
++/*! net_fd_event_handler - Processes a USB event.
++ */
++STATIC void net_fd_event_handler (struct usbd_function_instance *function, usbd_device_event_t event, int data)
++{
++ struct usb_network_private *npd = (struct usb_network_private *) (function->privdata);
++
++ switch (event) {
++
++ case DEVICE_RESET:
++ case DEVICE_DESTROY:
++ case DEVICE_BUS_INACTIVE:
++ case DEVICE_DE_CONFIGURED:
++ TRACE_MSG1(NTT,"RESET/DESTROY/BUS_INACTIVE/DE_CONFIGURED %08x",ip_addr);
++ net_check_mesg(mesg_reset);
++ {
++ // Return if argument is null.
++
++ // XXX flush
++
++ npd->flags &= ~NETWORK_ATTACHED;
++ npd->int_urb = NULL;
++
++ // Disable our net-device.
++ // Apparently it doesn't matter if we should do this more than once.
++
++ net_os_carrier_off(npd);
++
++ // If we aren't already tearing things down, do it now.
++ if (!(npd->flags & NETWORK_DESTROYING)) {
++ npd->flags |= NETWORK_DESTROYING;
++ //npd->device = NULL;
++ }
++ }
++ npd->crc = 0;
++ break;
++
++ case DEVICE_CONFIGURED:
++ case DEVICE_BUS_ACTIVITY:
++ TRACE_MSG1(NTT,"CONFIGURED/BUS_ACTIVITY %08x",ip_addr);
++ net_check_mesg(mesg_configured);
++ npd->flags |= NETWORK_ATTACHED;
++ if ((npd->network_type == network_blan) && (npd->flags & NETWORK_OPEN))
++ net_os_send_notification_later(npd);
++ net_os_carrier_on(npd);
++ (npd->network_type == network_eem) ? net_fd_start_recv_eem : net_fd_start_recv(function);
++ 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;
++ }
++ // Let the OS layer know, if it's interested.
++ net_os_config(npd);
++ net_os_hotplug(npd);
++}
++
++
++/*! net_fd_endpoint_cleared -
++ */
++STATIC void net_fd_endpoint_cleared (struct usbd_function_instance *function, int bEndpointAddress, int wIndex)
++{
++ TRACE_MSG2(NTT, "bEndpointAddress: %02x wIndex: %02x", bEndpointAddress, wIndex);
++}
++
++
++//_________________________________________________________________________________________________
++
++/*! net_fd_function_enable - enable the function driver
++ *
++ * Called for usbd_function_enable() from usbd_register_device()
++ */
++
++STATIC int net_fd_function_enable (struct usbd_function_instance *function)
++{
++ struct usb_network_private *npd;
++#if 0
++ /* This is the first time we've seen the function instance
++ (it's allocated by the usbdcore), so we need to let the OS
++ layer see it and initialize the privdata pointer. */
++ net_os_enable(function);
++ npd = (struct usb_network_private *) (function->privdata);
++ TRACE_MSG0(NTT,"semaphore DOWN");
++ net_os_mutex_enter(npd);
++#else
++ npd = (struct usb_network_private *) (function->privdata);
++ TRACE_MSG0(NTT,"semaphore DOWN");
++ net_os_mutex_enter(npd);
++ net_os_enable(function);
++#endif
++ _MOD_INC_USE_COUNT; // QQQ Should this be _before_ the mutex_enter()?
++ TRACE_MSG1(NTT, "INC: %d", MOD_IN_USE);
++
++ // set the network device address from the local device address
++ // Now done in net_os_enable() above.
++ // memcpy(npd->net_dev->dev_addr, npd->local_dev_addr, ETH_ALEN);
++
++ npd->have_interrupt = usbd_endpoint_bEndpointAddress(function, INT_IN, usbd_high_speed(function)) ? 1 : 0;
++
++ npd->flags |= NETWORK_ENABLED;
++
++#if defined(CONFIG_OTG_NETWORK_CDC)
++ cdc_init(function);
++#endif /* CONFIG_OTG_NETWORK_CDC */
++
++#ifdef CONFIG_OTG_NETWORK_EEM
++ eem_init(function);
++#endif
++
++#ifdef CONFIG_OTG_NETWORK_BASIC
++ basic_init(function);
++#endif
++
++#ifdef CONFIG_OTG_NETWORK_BASIC2
++ basic2_init(function);
++#endif
++
++#ifdef CONFIG_OTG_NETWORK_SAFE
++ safe_init(function);
++#endif
++#ifdef CONFIG_OTG_NETWORK_BLAN
++ blan_init(function);
++#endif
++ net_os_mutex_exit(npd);
++ TRACE_MSG0(NTT,"semaphore UP");
++ return 0;
++}
++
++/*! net_fd_function_disable - disable the function driver
++ *
++ */
++STATIC void net_fd_function_disable (struct usbd_function_instance *function)
++{
++ struct usb_network_private *npd = (struct usb_network_private *) (function->privdata);
++ TRACE_MSG0(NTT,"semaphore DOWN");
++ net_os_mutex_enter(npd);
++ npd->flags &= ~NETWORK_ENABLED;
++ _MOD_DEC_USE_COUNT; // QQQ Should this be _after_ the up()?
++ TRACE_MSG1(NTT, "DEC: %d", MOD_IN_USE);
++ net_os_mutex_exit(npd);
++ TRACE_MSG0(NTT,"semaphore UP");
++}
++
++/*! net_fd_function_ops - operations table for network function driver
++ */
++struct usbd_function_operations net_fd_function_ops = {
++ device_request: net_fd_device_request,
++ event_handler: net_fd_event_handler,
++ function_enable: net_fd_function_enable,
++ function_disable: net_fd_function_disable,
++ endpoint_cleared: net_fd_endpoint_cleared,
++};
++
++//______________________________________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 -
++ */
++static 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 -
++ */
++static int macstrtest(char *mac_address_str)
++{
++ int l = 0;
++
++ if (mac_address_str) {
++ l = strlen(mac_address_str);
++ }
++ return ((l != 0) && (l != 12));
++}
++
++/*! select_network_type
++ *
++ */
++STATIC network_type_t select_network_type(struct usb_network_params *p)
++{
++ /*
++ * Figure out what network mode to operate in.
++ */
++ network_type_t network_type = network_unknown;
++ /*
++ * Step 1. Look to see if network_type is specified by something like module params.
++ */
++#if defined(CONFIG_OTG_NETWORK_CDC)
++ p->cdc_capable = 1;
++ if (p->cdc) {
++ TRACE_MSG0(NTT,"cdc");
++ network_type = network_cdc;
++ }
++#endif
++#ifdef CONFIG_OTG_NETWORK_EEM
++ p->eem_capable = 1;
++ if (p->eem) {
++ THROW_IF (network_type != network_unknown, select_error);
++ TRACE_MSG0(NTT,"eem");
++ network_type = network_eem;
++ }
++#endif
++#ifdef CONFIG_OTG_NETWORK_BASIC
++ p->basic_capable = 1;
++ if (p->basic) {
++ THROW_IF (network_type != network_unknown, select_error);
++ TRACE_MSG0(NTT,"basic");
++ network_type = network_basic;
++ }
++#endif
++#ifdef CONFIG_OTG_NETWORK_BASIC2
++ p->basic2_capable = 1;
++ if (p->basic2) {
++ THROW_IF (network_type != network_unknown, select_error);
++ TRACE_MSG0(NTT,"basic2");
++ network_type = network_basic2;
++ }
++#endif
++#ifdef CONFIG_OTG_NETWORK_SAFE
++ p->safe_capable = 1;
++ if (p->safe) {
++ THROW_IF (network_type != network_unknown, select_error);
++ TRACE_MSG0(NTT,"safe");
++ network_type = network_safe;
++ }
++#endif
++#ifdef CONFIG_OTG_NETWORK_BLAN
++ p->blan_capable = 1;
++ if (p->blan) {
++ THROW_IF (network_type != network_unknown, select_error);
++ TRACE_MSG0(NTT,"blan");
++ network_type = network_blan;
++ }
++#endif
++
++ /*
++ * Step 2. If nothing was specified by parameter, default to
++ * to the first available (i.e. compiled) of:
++ * CDC, BASIC, BASIC2, SAFE, BLAN.
++ */
++#if defined(CONFIG_OTG_NETWORK_CDC)
++ if (network_type == network_unknown) {
++ TRACE_MSG0(NTT,"unknown => cdc");
++ network_type = network_cdc;
++ }
++#endif
++#if defined(CONFIG_OTG_NETWORK_EEM)
++ if (network_type == network_unknown) {
++ TRACE_MSG0(NTT,"unknown => eem");
++ network_type = network_eem;
++ }
++#endif
++#if defined(CONFIG_OTG_NETWORK_BASIC)
++ if (network_type == network_unknown) {
++ TRACE_MSG0(NTT,"unknown => basic");
++ network_type = network_basic;
++ }
++#endif
++#if defined(CONFIG_OTG_NETWORK_BASIC2)
++ if (network_type == network_unknown) {
++ TRACE_MSG0(NTT,"unknown => basic2");
++ network_type = network_basic2;
++ }
++#endif
++#if defined(CONFIG_OTG_NETWORK_SAFE)
++ if (network_type == network_unknown) {
++ TRACE_MSG0(NTT,"unknown => safe");
++ network_type = network_safe;
++ }
++#endif
++#if defined(CONFIG_OTG_NETWORK_BLAN)
++ if (network_type == network_unknown) {
++ TRACE_MSG0(NTT,"unknown => blan");
++ network_type = network_blan;
++ }
++#endif
++ CATCH(select_error) {
++ network_type == network_unknown;
++ }
++ return(network_type);
++}
++
++/*! select_descriptors
++ *
++ */
++STATIC struct usbd_function_driver * select_descriptors(network_type_t network_type)
++{
++ // select the function driver descriptors based on network_type
++
++ switch (network_type) {
++
++#if defined(CONFIG_OTG_NETWORK_CDC)
++ case network_cdc:
++ TRACE_MSG0(NTT,"fd=cdc");
++ return(&cdc_function_driver);
++#endif
++#if defined(CONFIG_OTG_NETWORK_EEM)
++ case network_eem:
++ TRACE_MSG0(NTT,"fd=eem");
++ return(&eem_function_driver);
++#endif
++#if defined(CONFIG_OTG_NETWORK_BASIC)
++ case network_basic:
++ TRACE_MSG0(NTT,"fd=basic");
++ return(&basic_function_driver);
++#endif
++#if defined(CONFIG_OTG_NETWORK_BASIC2)
++ case network_basic2:
++ TRACE_MSG0(NTT,"fd=basic2");
++ return(&basic2_function_driver);
++#endif
++#if defined(CONFIG_OTG_NETWORK_SAFE)
++ case network_safe:
++ TRACE_MSG1(NTT,"fd=safe bNumConfigurations: %d",
++ safe_function_driver.bNumConfigurations);
++ return(&safe_function_driver);
++#endif
++#if defined(CONFIG_OTG_NETWORK_BLAN)
++ case network_blan:
++ TRACE_MSG1(NTT,"fd=blan bNumConfigurations: %d",
++ blan_function_driver.bNumConfigurations);
++ return(&blan_function_driver);
++#endif
++ default:
++ break;
++ }
++ return(NULL);
++}
++
++/*! net_fd_init - function driver usb part intialization
++ *
++ * @return non-zero for failure.
++ */
++STATIC int net_fd_init(struct usb_network_private *npd, char *info_str)
++{
++ struct usb_network_params *p = npd->params;
++
++ printk(KERN_INFO "Copyright (c) 2002-2004 Belcarra Technologies; www.belcarra.com; sl@belcarra.com\n");
++ NTT = otg_trace_obtain_tag();
++
++ /*
++ * Figure out what network mode to operate in.
++ */
++ if (network_unknown == (npd->network_type = select_network_type(p)) ||
++ NULL == (npd->function_driver = select_descriptors(npd->network_type))) {
++ printk(KERN_INFO"configuration selection error");
++ otg_trace_invalidate_tag(NTT);
++ return -EINVAL;
++ }
++
++#ifdef CONFIG_OTG_NETWORK_ALLOW_SETID
++ TRACE_MSG2(NTT,"checking idVendor: %04x idProduct: %04x", p->vendor_id, p->product_id);
++
++ if (p->vendor_id)
++ npd->function_driver->idVendor = cpu_to_le16(p->vendor_id);
++
++ if (p->product_id)
++ npd->function_driver->idProduct = cpu_to_le16(p->product_id);
++#endif
++ printk(KERN_INFO "%s: %s vendor_id: %04x product_id: %04x\n",
++ __FUNCTION__, info_str,
++ le16_to_cpu(npd->function_driver->idVendor),
++ le16_to_cpu(npd->function_driver->idProduct));
++ TRACE_MSG3(NTT,"%s vendor_id: %04x product_id: %04x", info_str,
++ le16_to_cpu(npd->function_driver->idVendor),
++ le16_to_cpu(npd->function_driver->idProduct));
++
++#ifdef CONFIG_OTG_NETWORK_BLAN_FERMAT
++ TRACE_MSG0(NTT,"fermat");
++ fermat_init();
++#endif
++
++#ifdef CONFIG_OTG_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.
++ *
++ */
++ //UNLESS (ep0test)
++ // ep0test = usbd_endpoint_zero_wMaxPacketsize(function);
++
++ if (ep0test) {
++ switch (ep0test) {
++ case 8: npd->function_driver->device_description->iProduct = "012"; break;
++ case 16: npd->function_driver->device_description->iProduct = "0123456"; break;
++ case 32: npd->function_driver->device_description->iProduct = "0123456789abcde"; break;
++ case 64: npd->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;
++ }
++ TRACE_MSG1(NTT,"ep0test: iProduct set to: %s",
++ npd->function_driver->device_description->iProduct);
++ printk(KERN_INFO"%s: ep0test: iProduct set to: %s\n", __FUNCTION__,
++ npd->function_driver->device_description->iProduct);
++ }
++ else {
++ TRACE_MSG0(NTT,"ep0test: not set");
++ printk(KERN_INFO"%s: ep0test: not set\n", __FUNCTION__);
++ }
++#endif /* CONFIG_OTG_NETWORK_EP0TEST */
++
++
++#ifdef CONFIG_OTG_NETWORK_LOCAL_MACADDR
++ if (NULL == p->local_mac_address_str) {
++ /* There is a configured override, and it has NOT been
++ overridden in turn by a module load time parameter, so use it. */
++ p->local_mac_address_str = CONFIG_OTG_NETWORK_LOCAL_MACADDR;
++ }
++#endif
++#ifdef CONFIG_OTG_NETWORK_REMOTE_MACADDR
++ if (NULL == p->remote_mac_address_str) {
++ /* There is a configured override, and it has NOT been
++ overridden in turn by a module load time parameter, so use it. */
++ p->remote_mac_address_str = CONFIG_OTG_NETWORK_REMOTE_MACADDR;
++ }
++#endif
++ if ((macstrtest(p->local_mac_address_str) || macstrtest(p->remote_mac_address_str))) {
++ TRACE_MSG2(NTT,"bad size %s %s", p->local_mac_address_str, p->remote_mac_address_str);
++ otg_trace_invalidate_tag(NTT);
++ return -EINVAL;
++ }
++
++ set_address(p->local_mac_address_str, npd->local_dev_addr);
++ set_address(p->remote_mac_address_str, npd->remote_dev_addr);
++ npd->encapsulation = simple_crc;
++
++ if (make_crc_table() ||
++ NULL == (npd->function = usbd_register_function(npd->function_driver, "net-fd", NULL))) {
++ if (network_crc32_table) {
++ lkfree(network_crc32_table);
++ network_crc32_table = NULL;
++ }
++ otg_trace_invalidate_tag(NTT);
++ return -EINVAL;
++ }
++ npd->function->privdata = (void *) npd;
++
++ return 0;
++
++}
++
++//_____________________________________________________________________________
++
++/*! net_fd_term - driver exit
++ *
++ * Cleans up the module. Deregisters the function driver and destroys the network object.
++ */
++STATIC void net_fd_term(struct usb_network_private *npd)
++{
++ if (NULL != npd->function) {
++ usbd_deregister_function(npd->function);
++ npd->function = NULL;
++ }
++ if (network_crc32_table) {
++ lkfree(network_crc32_table);
++ network_crc32_table = NULL;
++ }
++ otg_trace_invalidate_tag(NTT);
++}
++
++//_________________________________________________________________________________________________
++
++
++/*! net_fd_usb_ops operations
++ */
++struct net_usb_services net_fd_usb_ops = {
++ .initialize_usb_part = net_fd_init,
++ .terminate_usb_part = net_fd_term,
++ .send_int_notification = net_fd_send_int_blan,
++ .start_xmit = net_fd_start_xmit,
++};
+diff -uNr linux/drivers/no-otg/functions/network/net-fd.h linux/drivers/otg/functions/network/net-fd.h
+--- linux/drivers/no-otg/functions/network/net-fd.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/net-fd.h 2006-09-01 21:41:30.000000000 +0200
+@@ -0,0 +1,48 @@
++/*
++ * otg/functions/network/net-fd.h - Network Function Driver
++ *
++ * Copyright (c) 2002, 2003, 2004 Belcarra
++ *
++ * By:
++ * Tom Rushworth <tbr@belcarra.com>
++ * 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.
++ *
++ */
++/*!
++ * @file otg/functions/network/net-fd.h
++ * @brief These are the functions exported by the USB specific parts
++ * (i.e. net-fd.c and net-cl.c) for use in the OS specific
++ * layers (e.g. net-l24-os.c).
++ *
++ *
++ * @ingroup NetworkFunction
++ */
++#ifndef NET_FD_H
++#define NET_FD_H 1
++
++struct net_usb_services {
++ int (*initialize_usb_part)(struct usb_network_private *npd, char *info_str);
++ void (*terminate_usb_part)(struct usb_network_private *npd);
++ void (*send_int_notification)(struct usb_network_private *npd, int connected, int data);
++ int (*start_xmit)(struct usb_network_private *npd, __u8 *buff, int len, void *buff_ctx);
++};
++
++extern struct net_usb_services net_fd_usb_ops;
++
++#endif
+diff -uNr linux/drivers/no-otg/functions/network/net-l24-os.c linux/drivers/otg/functions/network/net-l24-os.c
+--- linux/drivers/no-otg/functions/network/net-l24-os.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/net-l24-os.c 2006-09-01 21:41:30.000000000 +0200
+@@ -0,0 +1,1395 @@
++/*
++ * otg/functions/network/net-l24-os.c - Network Function Driver
++ *
++ * Copyright (c) 2002, 2003, 2004 Belcarra Technologies
++ *
++ * By:
++ * Tom Rushworth <tbr@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.
++ *
++ */
++/*!
++ * @file otg/functions/network/net-l24-os.c
++ * @brief The Linux 2.4 OS specific upper edge (network interface)
++ * implementation for the Network Function Driver.
++ *
++ * This file implements a standard Linux network driver interface and
++ * the standard Linux 2.4 module init and exit functions.
++ *
++ * 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.
++ *
++ *
++ * @ingroup NetworkFunction
++ */
++
++
++/* OS-specific #includes */
++#include <linux/config.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++#include <linux/init.h>
++#include <linux/list.h>
++#include <linux/smp_lock.h>
++#include <linux/ctype.h>
++#include <linux/time.h>
++#include <linux/timer.h>
++#include <linux/string.h>
++#include <linux/random.h>
++#include <linux/utsname.h>
++#include <linux/kmod.h>
++#include <asm/uaccess.h>
++#include <asm/system.h>
++
++/* Networking #includes from OS */
++#include <linux/netdevice.h>
++#include <linux/skbuff.h>
++#include <linux/etherdevice.h>
++#include <net/arp.h>
++#include <linux/rtnetlink.h>
++#include <linux/atmdev.h>
++#include <linux/pkt_sched.h>
++#include <linux/ip.h>
++#include <linux/if_ether.h>
++#include <linux/in.h>
++#include <linux/inetdevice.h>
++
++
++
++/* Belcarra public interfaces */
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++#include <otg/usbp-chap9.h>
++//#include <otg/usbd-mem.h>
++#include <otg/usbp-func.h>
++
++/* Belcarra private interfaces SUBJECT TO CHANGE WITHOUT NOTICE */
++#include "network.h"
++#include "net-os.h"
++#include "net-fd.h"
++
++MOD_AUTHOR ("sl@belcarra.com, tbr@belcarra.com, balden@belcarra.com");
++
++EMBED_LICENSE();
++
++MOD_DESCRIPTION ("USB Network Function");
++
++
++
++EMBED_USBD_INFO ("network_fd 2.0-beta");
++
++
++#define NTT network_fd_trace_tag
++
++wait_queue_head_t usb_netif_wq;
++#ifdef CONFIG_OTG_NET_NFS_SUPPORT
++int usb_is_configured;
++#endif
++
++/* Module Parameters ************************************************************************* */
++
++STATIC struct usb_network_params params;
++
++#ifdef CONFIG_OTG_NETWORK_ALLOW_SETID
++// override vendor ID
++static int vendor_id;
++MOD_PARM (vendor_id, "i");
++MOD_PARM_DESC (vendor_id, "vendor id");
++
++// override product ID
++static int product_id;
++MOD_PARM (product_id, "i");
++MOD_PARM_DESC (product_id, "product id");
++#endif
++
++// override local mac address
++static char *local_mac_address_str;
++MOD_PARM (local_mac_address_str, "s");
++MOD_PARM_DESC (local_mac_address_str, "Local MAC");
++
++// override remote mac address
++static char *remote_mac_address_str;
++MOD_PARM (remote_mac_address_str, "s");
++MOD_PARM_DESC (remote_mac_address_str, "Remote MAC");
++
++#ifdef CONFIG_OTG_NETWORK_EP0TEST
++static int ep0test;
++MOD_PARM (ep0test, "i");
++MOD_PARM_DESC (ep0test, "Test EP0 String Handling - set to ep0 packetsize [8,16,32,64]");
++#endif
++
++static int zeroconf;
++MOD_PARM (zeroconf, "i");
++MOD_PARM_DESC (zeroconf, "Use usbz%d for network name");
++
++#if defined(CONFIG_OTG_NETWORK_CDC)
++static int cdc;
++MOD_PARM (cdc, "i");
++MOD_PARM_DESC (cdc, "Enable CDC mode");
++#endif
++
++#ifdef CONFIG_OTG_NETWORK_BASIC
++static int basic;
++MOD_PARM (basic, "i");
++MOD_PARM_DESC (basic, "Enable BASIC mode");
++#endif
++
++#ifdef CONFIG_OTG_NETWORK_BASIC2
++static int basic2;
++MOD_PARM (basic2, "i");
++MOD_PARM_DESC (basic2, "Enable BASIC2 mode");
++#endif
++
++#ifdef CONFIG_OTG_NETWORK_SAFE
++static int safe;
++MOD_PARM (safe, "i");
++MOD_PARM_DESC (safe, "Enable SAFE mode");
++#endif
++
++#ifdef CONFIG_OTG_NETWORK_BLAN
++static int blan;
++MOD_PARM (blan, "i");
++MOD_PARM_DESC (blan, "Enable BLAN mode");
++#endif
++
++/* End of Module Parameters ****************************************************************** */
++
++
++u8 local_dev_addr[ETH_ALEN];
++
++u8 remote_dev_addr[ETH_ALEN];
++static u8 zeros[ETH_ALEN];
++
++extern u32 ip_addr;
++extern u32 router_ip;
++extern u32 network_mask;
++extern 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;
++
++void notification_schedule_bh (void);
++int network_urb_sent_bulk (struct usbd_urb *urb, int urb_rc);
++int network_urb_sent_int (struct usbd_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 usbd_function_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 usbd_urb *)
++ * int network_urb_sent (struct usbd_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 net_os_hotplug (void)
++ *
++ *
++ * Irq level functions:
++ *
++ * These are called at interrupt time do process or respond to USB setup
++ * commands.
++ *
++ * int network_device_request (struct usbd_device_request *)
++ * void network_event_handler (struct usbd_function_instance *function, usbd_device_event_t event, int data)
++ *
++ *
++ * Enable and disable functions:
++ *
++ * void network_function_enable (struct usbd_function_instance *, struct usbd_function_instance *)
++ * void network_function_disable (struct usbd_function_instance *function)
++ *
++ *
++ * Driver initialization and exit:
++ *
++ * static int network_create (struct usb_network_private *)
++ * static void network_destroy (struct usb_network_private *)
++ *
++ * int network_modinit (void)
++ * void network_modexit (void)
++ */
++
++
++//_______________________________USB part Functions_________________________________________
++
++/*
++ * net_os_mutex_enter - enter mutex region
++ */
++void net_os_mutex_enter(struct usb_network_private *npd)
++{
++ down(&usbd_network_sem);
++}
++
++/*
++ * net_os_mutex_exit - exit mutex region
++ */
++void net_os_mutex_exit(struct usb_network_private *npd)
++{
++ up(&usbd_network_sem);
++}
++
++/* 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)
++{
++ struct usb_network_private *npd = (struct usb_network_private *) data;
++ unsigned long flags;
++ local_irq_save(flags);
++ (*(npd->fd_ops->send_int_notification))(npd, npd->flags & NETWORK_OPEN, 0);
++ local_irq_restore(flags);
++ //_MOD_DEC_USE_COUNT;
++ TRACE_MSG1(NTT, "DEC: %d", MOD_IN_USE);
++}
++
++/* notification_schedule_bh - schedule a call for notification_bh
++ */
++void net_os_send_notification_later(struct usb_network_private *npd)
++{
++#ifdef LINUX24
++ //LINUX 2.4 is the only supported OS to need the USE_COUNT
++ //_MOD_INC_USE_COUNT;
++ TRACE_MSG1(NTT, "INC: %d", MOD_IN_USE);
++ if (!SCHEDULE_WORK(npd->notification_bh)) {
++ //_MOD_DEC_USE_COUNT;
++ TRACE_MSG1(NTT, "DEC: %d", MOD_IN_USE);
++ }
++#else
++ SCHEDULE_WORK(npd->notification_bh);
++ //XXX No provision for failure of schedule ....
++#endif
++}
++
++/*! net_os_xmit_done - called from USB part when a transmit completes, good or bad.
++ * tx_rc is SEND_FINISHED_ERROR, SEND_CANCELLED or...
++ * buff_ctx is the pointer passed to fd_ops->start_xmit().
++ * @return non-zero only if network does not exist, ow 0.
++ */
++int net_os_xmit_done(struct usbd_function_instance *function, void *buff_ctx, int tx_rc)
++{
++ struct sk_buff *skb = (struct sk_buff *) buff_ctx;
++ struct usb_network_private *npd;
++ struct net_device *net_device;
++ int rc = 0;
++
++ npd = (function ? (struct usb_network_private *) (function->privdata) : NULL);
++ if (skb) {
++ if (NULL != npd && 0 == (rc = !(npd->flags & NETWORK_CREATED))) {
++ switch (tx_rc) {
++ case SEND_FINISHED_ERROR:
++ npd->stats.tx_errors++;
++ npd->stats.tx_dropped++;
++ break;
++ case SEND_CANCELLED:
++ npd->stats.tx_errors++;
++ npd->stats.tx_carrier_errors++;
++ break;
++ default:
++ break;
++ }
++
++ npd->avg_queue_entries += npd->queued_entries;
++ npd->queued_entries--;
++ npd->samples++;
++ npd->jiffies += jiffies - *(time_t *) (&skb->cb);
++ npd->queued_bytes -= skb->len;
++ if (NULL != (net_device = npd->net_dev) &&
++ netif_queue_stopped(net_device)) {
++ netif_wake_queue(net_device);
++ npd->restarts++;
++ }
++ }
++ dev_kfree_skb_any(skb);
++ }
++ return rc;
++}
++
++/*! net_os_alloc_buf
++ */
++void *net_os_alloc_buff(struct usb_network_private *npd, u8 **cp, int n)
++{
++ struct sk_buff *skb;
++ // allocate skb of appropriate length, reserve 2 to align ip
++ if (!(skb = dev_alloc_skb(n+2))) {
++ *cp = NULL;
++ return(NULL);
++ }
++ skb_reserve(skb, 2);
++ *cp = skb_put(skb, n);
++ return((void*) skb);
++}
++
++/*! network_recv - function to process an received data URB
++ *
++ * Passes received data to the network layer. Passes skb to network layer.
++ *
++ * @return non-zero for failure.
++ */
++STATIC __inline__ int network_recv (struct usb_network_private *npd,
++ 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)) {
++ TRACE_MSG0(NTT,"device not present");
++ printk(KERN_INFO"%s: device not present\n", __FUNCTION__);
++ return -EINVAL;
++ }
++
++ // refuse if no carrier
++ if (!netif_carrier_ok (net_device)) {
++ TRACE_MSG0(NTT,"no carrier");
++ printk(KERN_INFO"%s: no carrier\n", __FUNCTION__);
++ return -EINVAL;
++ }
++
++ // refuse if the net device is down
++ if (!(net_device->flags & IFF_UP)) {
++ TRACE_MSG1(NTT,"not up net_dev->flags: %x", net_device->flags);
++ //printk(KERN_INFO"%s: not up net_dev->flags: %x\n", __FUNCTION__, net_device->flags);
++ //npd->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;
++
++ //TRACE_MSG4(NTT,"len: %x head: %p data: %p tail: %p",
++ // skb->len, skb->head, skb->data, skb->tail);
++
++
++ // pass it up to kernel networking layer
++ if ((rc = netif_rx (skb))) {
++ TRACE_MSG1(NTT,"netif_rx rc: %d", rc);
++ }
++ // QQSV - should be else case for stats?
++ npd->stats.rx_bytes += skb->len;
++ npd->stats.rx_packets++;
++
++ return 0;
++}
++
++/*! net_os_recv_buff - forward a received URB, or clean up after a bad one.
++ * buff_ctx == NULL --> just accumulate stats (count 1 bad buff)
++ * crc_bad != 0 --> count a crc error and free buff_ctx/skb
++ * trim --> amount to trim from valid skb
++ */
++void net_os_recv_buff(struct usb_network_private *npd, void *buff_ctx, int crc_bad, int trim)
++{
++ struct sk_buff *skb = (struct sk_buff *) buff_ctx;
++
++ if (NULL == skb) {
++ /* Lower layer never got around to allocating an skb, but
++ needs to count a packet it can't forward. */
++ npd->stats.rx_frame_errors++;
++ npd->stats.rx_errors++;
++ } else {
++ // There is an skb, either forward it or free it.
++ if (crc_bad) {
++ npd->stats.rx_crc_errors++;
++ npd->stats.rx_errors++;
++ } else if ((npd->flags & NETWORK_ATTACHED) && NULL != npd->net_dev) {
++ // All good, forward it.
++ if (trim) {
++ skb_trim(skb, skb->len - trim);
++ }
++ // all done if network_recv() == 0, ow fall through to error handling
++ RETURN_IF(!network_recv(npd, npd->net_dev, skb));
++ // Network layer wouldn't take it.
++ // rx_dropped gets counted below, any other counter we need?
++ }
++ // Something wrong, free the skb
++ dev_kfree_skb_any (skb);
++ }
++ // The received buffer didn't get forwarded, so...
++ npd->stats.rx_dropped++;
++}
++
++/*! net_os_enable
++ *
++ */
++void net_os_enable(struct usbd_function_instance *function)
++{
++ //struct usb_network_private *npd = &Usb_network_private;
++ struct usb_network_private *npd = (struct usb_network_private *) function->privdata;
++#if 0
++ /* This is the first time we've gotten access to the function instance,
++ and it's an allocated structure. Fill in the links to our private data. */
++ function->privdata = (void *) npd;
++ npd->function = function;
++#endif
++ TRACE_MSG3(NTT,"npd=%p function=%p, f->p=%p",npd,function,function->privdata);
++
++ // set the network device address from the local device address
++ memcpy(npd->net_dev->dev_addr, npd->local_dev_addr, ETH_ALEN);
++}
++
++/*! net_os_disable
++ *
++ */
++extern void net_os_disable(struct usbd_function_instance *function)
++{
++#if 0
++ struct usb_network_private *npd = (struct usb_network_private *) (function->privdata);
++ function->privdata = NULL;
++ npd->function = NULL;
++#endif
++}
++
++/*
++ *
++ */
++void net_os_carrier_on(struct usb_network_private *npd)
++{
++ netif_carrier_on(npd->net_dev);
++ netif_wake_queue(npd->net_dev);
++#ifdef CONFIG_OTG_NET_NFS_SUPPORT
++ if (!usb_is_configured) {
++ wake_up(&usb_netif_wq);
++ usb_is_configured = 1;
++ }
++#endif
++
++}
++
++/*
++ *
++ */
++void net_os_carrier_off(struct usb_network_private *npd)
++{
++ netif_stop_queue(npd->net_dev);
++ netif_carrier_off(npd->net_dev);
++}
++
++
++//_______________________________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)
++{
++ TRACE_MSG0(NTT,"no-op");
++ return 0;
++}
++
++
++/* network_uninit -
++ *
++ * Uninitializes the specified network device.
++ */
++STATIC void network_uninit (struct net_device *net_device)
++{
++ TRACE_MSG0(NTT,"no-op");
++ 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 *npd = (struct usb_network_private *)(net_device->priv);
++ unsigned long flags;
++
++ _MOD_INC_USE_COUNT;
++ TRACE_MSG1(NTT, "INC: %d", MOD_IN_USE);
++ npd->flags |= NETWORK_OPEN;
++ netif_wake_queue (net_device);
++
++ local_irq_save(flags);
++ (*(npd->fd_ops->send_int_notification))(npd, 1, 0);
++ local_irq_restore(flags);
++
++#ifdef CONFIG_OTG_NET_NFS_SUPPORT
++ if (!usb_is_configured) {
++ if (!in_interrupt()) {
++ TRACE_MSG0(NTT,"Please replug USB cable and then ifconfig host interface.\n");
++ printk(KERN_ERR"Please replug USB cable and then ifconfig host interface.\n");
++ interruptible_sleep_on(&usb_netif_wq);
++ }
++ else {
++ TRACE_MSG_0(NTT,"Warning! In interrupt\n");
++ printk(KERN_ERR"Warning! 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 *npd = (struct usb_network_private *)(net_device->priv);
++ unsigned long flags;
++
++ TRACE_MSG0(NTT,"-");
++
++ //netif_stop_queue (net_device);
++
++ npd->flags &= ~NETWORK_OPEN;
++
++ local_irq_save(flags);
++ (*(npd->fd_ops->send_int_notification))(npd, 0, 0);
++ local_irq_restore(flags);
++
++ _MOD_DEC_USE_COUNT;
++ TRACE_MSG1(NTT, "DEC: %d", MOD_IN_USE);
++ 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 *npd = (struct usb_network_private *)(net_device->priv);
++ return &npd->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 usb_network_private *npd = (struct usb_network_private *)(net_device->priv);
++ struct sockaddr *addr = p;
++ unsigned long flags;
++
++ TRACE_MSG0(NTT,"--");
++
++ RETURN_EBUSY_IF(netif_running (net_device));
++ local_irq_save(flags);
++ memcpy(net_device->dev_addr, addr->sa_data, net_device->addr_len);
++ memcpy(npd->local_dev_addr, npd->net_dev->dev_addr, ETH_ALEN);
++ 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 *npd = (struct usb_network_private *)(net_device->priv);
++#if 0
++ //printk(KERN_ERR"%s:\n", __FUNCTION__);
++ npd->stats.tx_errors++;
++ npd->stats.tx_dropped++;
++ usbd_cancel_urb_irq (npd->bus, NULL); // QQSV
++#endif
++#if 0
++ // XXX attempt to wakeup the host...
++ if ((npd->network_type == network_blan) && (npd->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 *npd = (struct usb_network_private *)(net_device->priv);
++
++ TRACE_MSG0(NTT,"-");
++
++ RETURN_EBUSY_IF(netif_running (net_device));
++ RETURN_EBUSY_IF(mtu > npd->mtu);
++
++ npd->mtu = mtu;
++ return 0;
++}
++
++//_________________________________________________________________________________________________
++// network_hard_start_xmit
++
++/*
++ * net_os_start_xmit - start sending an skb, with usbd_network_sem already held.
++ *
++ * Return non-zero (1) if busy. QQSV - this code always returns 0.
++ */
++STATIC __inline__ int net_os_start_xmit (struct sk_buff *skb, struct net_device *net_device)
++{
++ struct usb_network_private *npd = (struct usb_network_private *)(net_device->priv);
++ int rc;
++
++ if (!netif_carrier_ok(net_device)) {
++ dev_kfree_skb_any (skb);
++ npd->stats.tx_dropped++;
++ //netif_stop_queue(net_device); // XXX
++ // XXX this is what we should do, blows up on some 2.4.20 kernels
++ // return(NET_XMIT_DROP);
++ return(0);
++ }
++
++ // stop queue, it will be restarted only when we are ready for another skb
++ netif_stop_queue(net_device);
++ npd->stopped++;
++
++ // Set the timestamp for tx timeout
++ net_device->trans_start = jiffies;
++
++ // XXX request IN, should start a timer to resend this.
++ if (npd->data_notify)
++ (*(npd->fd_ops->send_int_notification))(npd, 0, 1);
++
++ rc = (*(npd->fd_ops->start_xmit))(npd,skb->data,skb->len,(void*)skb);
++ switch (rc) {
++ case 0:
++ TRACE_MSG1(NTT,"OK: %d", rc);
++ // update some stats
++ npd->queued_entries++;
++ npd->queued_bytes += skb->len;
++ npd->stats.tx_packets++;
++ npd->stats.tx_bytes += skb->len;
++
++ // Should we restart network queue
++ if ((npd->queued_entries < npd->max_queue_entries) &&
++ (npd->queued_bytes < npd->max_queue_bytes))
++ netif_wake_queue (net_device);
++
++ break;
++
++ case -EINVAL:
++ case -EUNATCH:
++ TRACE_MSG1(NTT,"not attached, send failed: %d", rc);
++ printk(KERN_ERR"%s: not attached, send failed: %d\n", __FUNCTION__, rc);
++ npd->stats.tx_errors++;
++ npd->stats.tx_carrier_errors++;
++ netif_wake_queue(net_device);
++ break;
++
++ case -ENOMEM:
++ TRACE_MSG1(NTT,"no mem, send failed: %d", rc);
++ printk(KERN_ERR"%s: no mem, send failed: %d\n", __FUNCTION__, rc);
++ npd->stats.tx_errors++;
++ npd->stats.tx_fifo_errors++;
++ netif_wake_queue(net_device);
++ break;
++
++ case -ECOMM:
++ TRACE_MSG2(NTT,"comm failure, send failed: %d %p", rc, net_device);
++ printk(KERN_ERR"%s: comm failure, send failed: %d %p\n", __FUNCTION__, rc, net_device);
++ // Leave the IF queue stopped.
++ npd->stats.tx_dropped++;
++ break;
++
++ }
++ if (0 != rc) {
++ dev_kfree_skb_any (skb);
++ // XXX this is what we should do, blows up on some 2.4.20 kernels
++ // return(NET_XMIT_DROP);
++ return(0);
++ }
++
++ return 0;
++}
++
++/*
++ * network_hard_start_xmit - start sending an skb. Called by the OS network layer.
++ *
++ * Return non-zero (1) if busy. QQSV - this code always returns 0.
++ */
++STATIC int network_hard_start_xmit (struct sk_buff *skb, struct net_device *net_device)
++{
++ int rc;
++ down(&usbd_network_sem);
++ rc = net_os_start_xmit(skb,net_device);
++ 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,
++};
++
++//_________________________________________________________________________________________________
++
++#ifdef CONFIG_OTG_NETWORK_BLAN_AUTO_CONFIG
++/* sock_ioctl - perform an ioctl call to inet device
++ */
++int sock_ioctl(u32 cmd, struct ifreq *ifreq)
++{
++ int rc = 0;
++ mm_segment_t save_get_fs = get_fs();
++ TRACE_MSG1(NTT, "cmd: %x", cmd);
++ set_fs(get_ds());
++ rc = devinet_ioctl(cmd, ifreq);
++ set_fs(save_get_fs);
++ return rc;
++}
++
++/* sock_addr - setup a socket address for specified interface
++ */
++static int sock_addr(char * ifname, u32 cmd, u32 s_addr)
++{
++ struct ifreq ifreq;
++ struct sockaddr_in *sin = (void *) &(ifreq.ifr_ifru.ifru_addr);
++
++ TRACE_MSG2(NTT, "ifname: %s addr: %x", ifname, ntohl(s_addr));
++
++ memset(&ifreq, 0, sizeof(ifreq));
++ strcpy(ifreq.ifr_ifrn.ifrn_name, ifname);
++
++ sin->sin_family = AF_INET;
++ sin->sin_addr.s_addr = s_addr;
++
++ return sock_ioctl(cmd, &ifreq);
++}
++
++
++/* sock_flags - set flags for specified interface
++ */
++static int sock_flags(char * ifname, u16 oflags, u16 sflags, u16 rflags)
++{
++ int rc = 0;
++ struct ifreq ifreq;
++
++ TRACE_MSG4(NTT, "ifname: %s oflags: %x s_flags: %x r_flags: %x", ifname, oflags, sflags, rflags);
++
++ memset(&ifreq, 0, sizeof(ifreq));
++ strcpy(ifreq.ifr_ifrn.ifrn_name, ifname);
++
++ oflags |= sflags;
++ oflags &= ~rflags;
++ ifreq.ifr_flags = oflags;
++
++ TRACE_MSG1(NTT, "-> ifr_flags: %x ", ifreq.ifr_flags);
++
++ THROW_IF ((rc = sock_ioctl(SIOCSIFFLAGS, &ifreq)), error);
++
++ TRACE_MSG1(NTT, "<- ifr_flags: %x ", ifreq.ifr_flags);
++
++ CATCH(error) {
++ TRACE_MSG1(NTT, "ifconfig: cannot get/set interface flags (%d)", rc);
++ return rc;
++ }
++ return rc;
++}
++
++/* network_attach - configure interface
++ *
++ * This will use socket calls to configure the interface to the supplied
++ * ip address and make it active.
++ */
++STATIC int network_attach(struct usb_network_private *npd, u32 ip, u32 mask, u32 router, int attach)
++{
++ int err = 0;
++
++ if (attach) {
++ TRACE_MSG5(NTT, "ATTACH npd: %x ip: %08x mask: %08x router: %08x attach: %d", npd, ip, mask, router, attach);
++ u16 oflags = (npd && npd->net_dev) ? npd->net_dev->flags : 0;
++
++ if (npd->net_dev)
++ memcpy(npd->net_dev->dev_addr, npd->local_dev_addr, ETH_ALEN);
++
++ /* setup ip address, netwask, and broadcast address */
++ if (ip) {
++ THROW_IF ((err = sock_addr("usbl0", SIOCSIFADDR, htonl(ip))), error);
++ if (mask) {
++ THROW_IF ((err = sock_addr("usbl0", SIOCSIFNETMASK, htonl(mask))), error);
++ THROW_IF ((err = sock_addr("usbl0", SIOCSIFBRDADDR, htonl(ip | ~mask))), error);
++ }
++ /* bring the interface up */
++ THROW_IF ((err = sock_flags("usbl0", oflags, IFF_UP, 0)), error);
++ }
++ }
++ else {
++ TRACE_MSG5(NTT, "DETACH npd: %x ip: %08x mask: %08x router: %08x attach: %d", npd, ip, mask, router, attach);
++ u16 oflags = (npd && npd->net_dev) ? npd->net_dev->flags : 0;
++ /* bring the interface down */
++ THROW_IF ((err = sock_flags("usbl0", oflags, 0, IFF_UP)), error);
++ }
++
++ CATCH(error) {
++ TRACE_MSG1(NTT, "ifconfig: cannot configure interface (%d)", err);
++ return err;
++ }
++ return 0;
++}
++
++/* network_config - configure network
++ *
++ * Check connected status and load/unload as appropriate.
++ *
++ */
++STATIC void config_bh (void *data)
++{
++ struct usb_network_private *npd = (struct usb_network_private *) data;
++ struct usbd_function_instance *function = npd->function;
++
++ TRACE_MSG5(NTT, "function: %x enabled: %x status: %x state: %x npd->config_status: %d",
++ function,
++ npd->flags & NETWORK_ENABLED,
++ usbd_get_device_status(function),
++ usbd_get_device_state(function),
++ npd->config_status);
++
++ if ((npd->flags & NETWORK_ENABLED ) && (function && (USBD_OK == usbd_get_device_status(function))
++ && (STATE_CONFIGURED == usbd_get_device_state(function))
++ && ip_addr
++ ))
++ {
++ TRACE_MSG2(NTT,"BUS state: %d status: %d", usbd_get_device_state(function), usbd_get_device_status(function));
++ if (config_attached != npd->config_status) {
++ TRACE_MSG0(NTT,"ATTACH");
++ npd->config_status = config_attached;
++ network_attach (npd, ip_addr, network_mask, router_ip, 1);
++ }
++ return;
++ }
++
++ if (config_detached != npd->config_status) {
++ TRACE_MSG0(NTT,"DETACH");
++ npd->config_status = config_detached;
++ network_attach (npd, ip_addr, network_mask, router_ip, 0);
++ }
++ //_MOD_DEC_USE_COUNT;
++ TRACE_MSG1(NTT, "DEC: %d", MOD_IN_USE);
++}
++
++/*
++ * net_os_config - schedule a call to config bottom half
++ */
++void net_os_config(struct usb_network_private *npd)
++{
++ //_MOD_INC_USE_COUNT;
++ TRACE_MSG1(NTT, "INC: %d", MOD_IN_USE);
++ if (!SCHEDULE_WORK(npd->config_bh)) {
++ //_MOD_DEC_USE_COUNT;
++ TRACE_MSG1(NTT, "DEC: %d", MOD_IN_USE);
++ }
++}
++#else /* CONFIG_OTG_NETWORK_BLAN_AUTO_CONFIG */
++void net_os_config(struct usb_network_private *npd)
++{
++ TRACE_MSG0(NTT, "NOT CONFIGURED");
++ // Do nothing, config not configured.
++}
++#endif /* CONFIG_OTG_NETWORK_BLAN_AUTO_CONFIG */
++//______________________________________ Hotplug Functions ________________________________________
++
++#ifdef CONFIG_OTG_NETWORK_HOTPLUG
++
++#define AGENT "network_fd"
++
++/* hotplug_attach - call hotplug
++ */
++STATIC int hotplug_attach(struct usb_network_private *npd, 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", npd->net_dev->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]);
++
++ //TRACE_MSG3(NTT, "attach %s %s %s", ifname, ip_str, count_str);
++
++ envp[i++] = "ACTION=attach";
++ envp[i++] = ip_str;
++ envp[i++] = mask_str;
++ envp[i++] = router_str;
++
++ TRACE_MSG3(NTT, "attach ip: %08x mask: %08x router: %08x", ip, mask, router);
++ }
++ else {
++ //TRACE_MSG2(NTT,"detach %s %s", ifname, count_str);
++ envp[i++] = "ACTION=detach";
++ TRACE_MSG3(NTT, "detach ip: %08x mask: %08x router: %08x", ip, mask, router);
++ }
++
++ 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_network_private *npd = (struct usb_network_private *) data;
++ struct usbd_function_instance *function = NULL;
++
++ UNLESS (npd) {
++ //_MOD_DEC_USE_COUNT;
++ TRACE_MSG1(NTT, "NPD NULL DEC: %d", MOD_IN_USE);
++ return;
++ }
++
++ function = npd->function;
++
++ TRACE_MSG2(NTT, "function: %x npd->hotplug_status: %d", function, npd->hotplug_status);
++
++
++ if ((npd->flags & NETWORK_ENABLED ) && (function && (USBD_OK == usbd_get_device_status(function))
++ && (STATE_CONFIGURED == usbd_get_device_state(function))))
++ {
++ TRACE_MSG2(NTT,"BUS state: %d status: %d", usbd_get_device_state(function), usbd_get_device_status(function));
++ if (hotplug_attached != npd->hotplug_status) {
++ TRACE_MSG0(NTT,"ATTACH");
++ npd->hotplug_status = hotplug_attached;
++ hotplug_attach (npd, ip_addr, network_mask, router_ip, 1);
++ }
++ return;
++ }
++
++ if (hotplug_detached != npd->hotplug_status) {
++ TRACE_MSG0(NTT,"DETACH");
++ npd->hotplug_status = hotplug_detached;
++ hotplug_attach (npd, ip_addr, network_mask, router_ip, 0);
++ }
++ //_MOD_DEC_USE_COUNT;
++ TRACE_MSG1(NTT, "DEC: %d", MOD_IN_USE);
++}
++
++/*
++ * net_os_hotplug - schedule a call to hotplug bottom half
++ */
++void net_os_hotplug(struct usb_network_private *npd)
++{
++ //_MOD_INC_USE_COUNT;
++ TRACE_MSG1(NTT, "INC: %d", MOD_IN_USE);
++ if (!SCHEDULE_WORK(npd->hotplug_bh)) {
++ //_MOD_DEC_USE_COUNT;
++ TRACE_MSG1(NTT, "DEC: %d", MOD_IN_USE);
++ }
++}
++#else
++void net_os_hotplug(struct usb_network_private *npd)
++{
++ TRACE_MSG0(NTT, "NOT CONFIGURED");
++ // Do nothing, hotplug not configured.
++}
++#endif /* CONFIG_OTG_NETWORK_HOTPLUG */
++
++//_________________________________________________________________________________________________
++
++/* network_create - create and initialize network private structure
++ *
++ * Returns non-zero for failure.
++ */
++STATIC int network_create(struct usb_network_private *npd)
++{
++ TRACE_MSG0(NTT,"entered");
++
++ // Set some fields to generic defaults and register the network device with the kernel networking code
++
++ memset(&npd->stats, 0, sizeof npd->stats);
++
++ ether_setup(npd->net_dev);
++ RETURN_EINVAL_IF (register_netdev(npd->net_dev));
++ npd->flags |= NETWORK_REGISTERED;
++
++ netif_stop_queue(npd->net_dev);
++ netif_carrier_off(npd->net_dev);
++ npd->net_dev->flags &= ~IFF_UP;
++
++ npd->flags |= NETWORK_CREATED;
++
++ npd->maxtransfer = MAXFRAMESIZE + 4 + 64;
++
++ TRACE_MSG0(NTT,"finis");
++ return 0;
++}
++
++/* network_destroy - destroy network private struture
++ *
++ * Destroys the network interface referenced by the global variable @c Network_net_device.
++ */
++STATIC void network_destroy(struct usb_network_private *npd)
++{
++ if (npd->flags & NETWORK_REGISTERED) {
++ netif_stop_queue(npd->net_dev);
++ netif_carrier_off(npd->net_dev);
++ unregister_netdev(npd->net_dev);
++ }
++ npd->flags = 0;
++}
++
++
++//______________________________________module_init and module_exit________________________________
++
++#ifdef CONFIG_OTG_NETWORK_BLAN_AUTO_CONFIG
++
++/*! network_proc_read_ip - implement proc file system read.
++ * Standard proc file system read function.
++ */
++static ssize_t network_proc_read_ip (struct file *file, char *buf, size_t count, loff_t * pos)
++{
++ unsigned long page;
++ int len = 0;
++ char *bp;
++ int index = (*pos)++;
++
++ RETURN_ZERO_IF(index);
++
++ // get a page, max 4095 bytes of data...
++ RETURN_ENOMEM_UNLESS ((page = GET_KERNEL_PAGE()));
++
++ bp = (char *) page;
++
++ len = sprintf(bp, "%d.%d.%d.%d\n",
++ (router_ip >> 24) & 0xff,
++ (router_ip >> 16) & 0xff,
++ (router_ip >> 8) & 0xff,
++ (router_ip) & 0xff
++ );
++
++ if (copy_to_user(buf, (char *) page, len))
++ len = -EFAULT;
++
++ free_page (page);
++ return len;
++}
++
++static struct file_operations otg_message_proc_switch_functions = {
++ read: network_proc_read_ip,
++};
++
++#endif
++
++
++/* network_modinit - driver intialization
++ *
++ * Returns non-zero for failure.
++ */
++STATIC int network_modinit (void)
++{
++ // Pickup and link together the various global structs.
++ struct usb_network_private *npd = &Usb_network_private;
++ #ifdef CONFIG_PROC_FS
++ struct proc_dir_entry *p;
++ #endif /* CONFIG_PROC_FS */
++ npd->fd_ops = &net_fd_usb_ops;
++ npd->params = &params;
++ npd->net_dev = &Network_net_device;
++ npd->net_dev->priv = (void *) npd;
++#ifdef CONFIG_OTG_NETWORK_ALLOW_SETID
++ params.vendor_id = vendor_id;
++ params.product_id = product_id;
++#endif
++ params.local_mac_address_str = local_mac_address_str;
++ params.remote_mac_address_str = remote_mac_address_str;
++#ifdef CONFIG_OTG_NETWORK_EP0TEST
++ params.ep0test = ep0test;
++#endif
++ params.zeroconf = zeroconf;
++#if defined(CONFIG_OTG_NETWORK_CDC)
++ params.cdc = cdc;
++#endif
++#ifdef CONFIG_OTG_NETWORK_BASIC
++ params.basic = basic;
++#endif
++#ifdef CONFIG_OTG_NETWORK_BASIC2
++ params.basic2 = basic2;
++#endif
++#ifdef CONFIG_OTG_NETWORK_SAFE
++ params.safe = safe;
++#endif
++#ifdef CONFIG_OTG_NETWORK_BLAN
++ params.blan = blan;
++#endif
++ // That should be it for reference to globals except for network_modexit().
++
++ init_waitqueue_head(&usb_netif_wq);
++ PREPARE_WORK_ITEM(npd->notification_bh, notification_bh,npd);
++#ifdef CONFIG_OTG_NETWORK_BLAN_AUTO_CONFIG
++ PREPARE_WORK_ITEM(npd->config_bh, config_bh, npd);
++ #ifdef CONFIG_PROC_FS
++ if ((p = create_proc_entry ("network_ip", 0666, 0)))
++ p->proc_fops = &otg_message_proc_switch_functions;
++ #endif /* CONFIG_PROC_FS */
++#endif /* CONFIG_OTG_NETWORK_BLAN_AUTO_CONFIG */
++#ifdef CONFIG_OTG_NETWORK_HOTPLUG
++ PREPARE_WORK_ITEM(npd->hotplug_bh, hotplug_bh, npd);
++#endif /* CONFIG_OTG_NETWORK_HOTPLUG */
++
++ if (0 != (*(npd->fd_ops->initialize_usb_part))(npd,"linux network_fd")) {
++ // If the usb part fails, there are no trace functions.
++ return -EINVAL;
++ }
++
++ memcpy(npd->net_dev->dev_addr, npd->local_dev_addr, ETH_ALEN);
++ /* QQSV - this is very strange, since npd->network type can have
++ a number of different values. setting zeroconf is not going to
++ be quite as obvious as it might at first seem. */
++ strncpy(npd->net_dev->name, ((npd->network_type == zeroconf) ? "usbz0" :
++ (network_blan ? "usbl0" : "usbb0")), 6);
++
++ if (network_create(npd)) {
++ (*(npd->fd_ops->terminate_usb_part))(npd);
++ return -EINVAL;
++ }
++
++ return 0;
++}
++
++//_____________________________________________________________________________
++
++/* network_modexit - driver exit
++ *
++ * Cleans up the module. Deregisters the function driver and destroys the network object.
++ */
++STATIC void network_modexit (void)
++{
++ struct usb_network_private *npd = &Usb_network_private;
++
++ #ifdef CONFIG_PROC_FS
++ remove_proc_entry("network_ip", NULL);
++ #endif /* CONFIG_PROC_FS */
++
++ while (PENDING_WORK_ITEM(npd->notification_bh)) {
++ // TRACE_MSG pointless here, module will be gon before we can look at it.
++ printk(KERN_ERR"%s: waiting for notificationhotplug bh\n", __FUNCTION__);
++ schedule_timeout(10 * HZ);
++ }
++#ifdef CONFIG_OTG_NETWORK_BLAN_AUTO_CONFIG
++ while (PENDING_WORK_ITEM(npd->config_bh)) {
++ printk(KERN_ERR"%s: waiting for config bh\n", __FUNCTION__);
++ schedule_timeout(10 * HZ);
++ }
++#endif /* CONFIG_OTG_NETWORK_BLAN_AUTO_CONFIG */
++
++#ifdef CONFIG_OTG_NETWORK_HOTPLUG
++ while (PENDING_WORK_ITEM(npd->hotplug_bh)) {
++ printk(KERN_ERR"%s: waiting for hotplug bh\n", __FUNCTION__);
++ schedule_timeout(10 * HZ);
++ }
++#endif
++ /* Which order to tear down the two parts? No matter which goes first,
++ the other could still try to send data through the now-torn-down part,
++ so go with usb last, because it has the otg_trace cleanup. */
++ network_destroy(npd);
++ if (npd->fd_ops)
++ (*(npd->fd_ops->terminate_usb_part))(npd);
++}
++
++//_________________________________________________________________________________________________
++
++module_init (network_modinit);
++module_exit (network_modexit);
++
+diff -uNr linux/drivers/no-otg/functions/network/net-os.h linux/drivers/otg/functions/network/net-os.h
+--- linux/drivers/no-otg/functions/network/net-os.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/net-os.h 2006-09-01 21:41:30.000000000 +0200
+@@ -0,0 +1,107 @@
++/*
++ * otg/functions/network/net-os.h
++ *
++ * Copyright (c) 2003, 2004 Belcarra
++ *
++ * By:
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ */
++
++/*!
++ * @file otg/functions/network/net-os.h
++ * @brief Structures and function definitions required for implementation
++ * of the OS specific upper edge (network interface) for the Network
++ * Function Driver.
++ *
++ * A USB network driver is composed of two pieces:
++ * 1) An OS specific piece that handles creating and operating
++ * a network device for the given OS.
++ * 2) A USB specific piece that interfaces either with the host
++ * usbcore layer, or with the device usbdcore layer.
++ *
++ * If the USB piece interfaces with the host usbcore layer you get
++ * a network class driver. If the USB piece interfaces with the usbdcore
++ * layer you get a network function driver.
++ *
++ * This file describes the functions exported by the various net-*-os.c
++ * files (implementing (1)) for use in net-fd.c (2).
++ *
++ *
++ * @ingroup NetworkFunction
++ */
++
++#ifndef NET_OS_H
++#define NET_OS_H 1
++
++/*
++ * net_os_mutex_enter - enter mutex region
++ */
++extern void net_os_mutex_enter(struct usb_network_private *npd);
++
++/*
++ * net_os_mutex_exit - exit mutex region
++ */
++extern void net_os_mutex_exit(struct usb_network_private *npd);
++
++/*
++ * net_os_send_notification_later - schedule a callback to the USB part to send
++ * an INT notification.
++ */
++extern void net_os_send_notification_later(struct usb_network_private *npd);
++
++/*
++ * net_os_xmit_done - called from USB part when a transmit completes, good or bad.
++ * tx_rc is SEND_FINISHED_ERROR, SEND_CANCELLED or...
++ * buff_ctx is the pointer passed to fd_ops->start_xmit().
++ * Return non-zero only if network does not exist, ow 0.
++ */
++extern int net_os_xmit_done(struct usbd_function_instance *function, void *buff_ctx, int tx_rc);
++
++/*
++ *
++ */
++extern void *net_os_alloc_buff(struct usb_network_private *npd, u8 **cp, int n);
++
++/*
++ * net_os_recv_buff - forward a received URB, or clean up after a bad one.
++ * buff_ctx == NULL --> just accumulate stats (count 1 bad buff)
++ * crc_bad != 0 --> count a crc error and free buff_ctx/skb
++ * trim --> amount to trim from valid buffer (i.e. shorten
++ * from amount requested in net_os_alloc_buff(..... n).
++ * This will be called from interrupt context.
++ */
++extern void net_os_recv_buff(struct usb_network_private *npd, void *buff_ctx, int crc_bad, int trim);
++
++/*
++ * net_os_config - schedule a network hotplug event if the OS supports hotplug.
++ */
++extern void net_os_config(struct usb_network_private *npd);
++
++/*
++ * net_os_hotplug - schedule a network hotplug event if the OS supports hotplug.
++ */
++extern void net_os_hotplug(struct usb_network_private *npd);
++
++/*
++ *
++ */
++extern void net_os_enable(struct usbd_function_instance *function);
++
++/*
++ *
++ */
++extern void net_os_disable(struct usbd_function_instance *function);
++
++/*
++ *
++ */
++extern void net_os_carrier_on(struct usb_network_private *npd);
++
++/*
++ *
++ */
++extern void net_os_carrier_off(struct usb_network_private *npd);
++
++#endif
+diff -uNr linux/drivers/no-otg/functions/network/network.h linux/drivers/otg/functions/network/network.h
+--- linux/drivers/no-otg/functions/network/network.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/network.h 2006-09-01 21:41:30.000000000 +0200
+@@ -0,0 +1,348 @@
++/*
++ * otg/functions/network/network.h - Network Function Driver
++ *
++ * Copyright (c) 2002, 2003, 2004 Belcarra
++ *
++ * By:
++ * Tom Rushworth <tbr@belcarra.com>
++ * 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.
++ */
++/*!
++ * @defgroup NetworkFunction Network
++ * @ingroup functiongroup
++ */
++/*!
++ * @file otg/functions/network/network.h
++ * @brief Network Function Driver private defines
++ *
++ * This defines the internal and private structures required
++ * by the Network Function Driver.
++ *
++ * @ingroup NetworkFunction
++ */
++
++/*! This is a test
++ */
++#ifndef NETWORK_FD_H
++#define NETWORK_FD_H 1
++
++#include <otg/otg-trace.h>
++
++extern otg_tag_t network_fd_trace_tag;
++
++// Some platforms need to get rid of "static" when using GDB or looking at ksyms
++//#define STATIC
++#define STATIC static
++
++typedef enum network_encapsulation {
++ simple_net, simple_crc,
++} network_encapsulation_t;
++
++typedef enum network_config_status {
++ config_unkown,
++ config_attached,
++ config_detached
++} network_config_status_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_eem,
++} network_type_t;
++
++struct usb_network_params {
++ // enabling switchs
++ u32 cdc;
++ u32 basic;
++ u32 basic2;
++ u32 safe;
++ u32 blan;
++ // capability flags
++ u32 cdc_capable;
++ u32 basic_capable;
++ u32 basic2_capable;
++ u32 safe_capable;
++ u32 blan_capable;
++ // overrides
++ u32 vendor_id;
++ u32 product_id;
++ char *local_mac_address_str;
++ char *remote_mac_address_str;
++ // other switches
++ u32 ep0test;
++ u32 zeroconf;
++};
++
++#define CONFIG_OTG_NETWORK_ALLOW_SETID 1
++
++#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
++
++
++// RFC868 - seconds from midnight on 1 Jan 1900 GMT to Midnight 1 Jan 1970 GMT
++#define RFC868_OFFSET_TO_EPOCH 0x83AA7E80
++
++struct usb_network_private {
++
++ struct net_device_stats stats; /* network device statistics */
++
++ int flags;
++ struct net_device *net_dev;
++ struct usbd_function_instance *function;
++ struct usbd_function_driver *function_driver;
++ struct usb_network_params *params;
++ struct net_usb_services *fd_ops;
++ unsigned int maxtransfer;
++ rwlock_t rwlock;
++
++ network_config_status_t config_status;
++ network_hotplug_status_t hotplug_status;
++ network_type_t network_type;
++
++ int state;
++
++ int mtu;
++ int crc;
++#if defined(CONFIG_OTG_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;
++
++ int data_notify;
++
++ struct usbd_urb *int_urb;
++
++ network_encapsulation_t encapsulation;
++
++ struct WORK_ITEM notification_bh;
++#ifdef CONFIG_OTG_NETWORK_BLAN_AUTO_CONFIG
++ struct WORK_ITEM config_bh;
++#endif /* CONFIG_OTG_NETWORK_BLAN_AUTO_CONFIG */
++#ifdef CONFIG_HOTPLUG
++ struct WORK_ITEM hotplug_bh;
++#endif /* CONFIG_HOTPLUG */
++ __u8 local_dev_addr[ETH_ALEN];
++ __u8 remote_dev_addr[ETH_ALEN];
++};
++
++// XXX this needs to be co-ordinated with rndis.c maximum's
++#define MAXFRAMESIZE 2000
++
++#if !defined(CONFIG_OTG_MANUFACTURER)
++ #define CONFIG_OTG_MANUFACTURER "Belcarra"
++#endif
++
++
++#if !defined(CONFIG_OTG_SERIAL_NUMBER_STR)
++ #define CONFIG_OTG_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_NONBRIDGED 0x02
++#define BMNETWORK_DATA_NOTIFY_OK 0x04
++
++
++/*
++ * BLAN Data Plane
++ */
++//#define CONFIG_OTG_NETWORK_PADBYTES 8
++//#define CONFIG_OTG_NETWORK_PADAFTER 1
++//#undef CONFIG_OTG_NETWORK_PADBEFORE
++//#define CONFIG_OTG_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 usbd_function_operations net_fd_function_ops;
++
++struct usbd_class_safe_networking_mdlm_descriptor {
++ __u8 bFunctionLength; // 0x06
++ __u8 bDescriptorType; // 0x24
++ __u8 bDescriptorSubtype; // 0x13
++ __u8 bGuidDescriptorType; // 0x00
++ __u8 bmNetworkCapabilities;
++ __u8 bmDataCapabilities;
++} __attribute__ ((packed));
++
++struct usbd_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));
++
++
++
++
++#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 BELCARRA_DATA_NOTIFY 0x0c
++
++#define RFC868_OFFSET_TO_EPOCH 0x83AA7E80 // RFC868 - seconds from midnight on 1 Jan 1900 GMT to Midnight 1 Jan 1970 GMT
++
++
++extern __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])
++
++
++#if 0
++#if !defined(CONFIG_OTG_NETWORK_CRC_DUFF4) && !defined(CONFIG_OTG_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;
++}
++
++#endif /* DUFFn */
++#endif
++
++
++
++
++#endif /* NETWORK_FD_H */
+diff -uNr linux/drivers/no-otg/functions/network/safe.c linux/drivers/otg/functions/network/safe.c
+--- linux/drivers/no-otg/functions/network/safe.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/functions/network/safe.c 2006-09-01 21:41:30.000000000 +0200
+@@ -0,0 +1,362 @@
++/*
++ * otg/functions/network/safe.c - Network Function Driver
++ *
++ * Copyright (c) 2002, 2003, 2004 Belcarra
++ *
++ * By:
++ * Thomas Rushworth <tbr @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.
++ *
++ *
++ * The SAFE network driver implements the SAFE protocol descriptors.
++ *
++ * The SAFE protocol is suitable for infrastructure devices that
++ * are implementing a bridged or routed connection betwen an
++ * external network and the USB Host.
++ *
++ *
++ */
++/*!
++ * @file otg/functions/network/safe.c
++ * @brief This file implements the required descriptors to implement
++ * a SAFE network device with one interface.
++ *
++ * @ingroup NetworkFunction
++ */
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++
++#include <linux/slab.h>
++#include <linux/interrupt.h>
++#include <linux/utsname.h>
++#include <linux/netdevice.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++
++#include "network.h"
++
++#define NTT network_fd_trace_tag
++
++#ifdef CONFIG_OTG_NETWORK_SAFE
++/* USB SAFE Configuration ********************************************************** */
++
++/*
++ * SAFE Ethernet Configuration
++ */
++
++/* Communication Interface Class descriptors
++ */
++
++/*! BULK OUT data endpoint descriptor
++ */
++static struct usbd_endpoint_descriptor safe_data_1 = {
++ bLength: 0x07,
++ bDescriptorType: USB_DT_ENDPOINT,
++ bEndpointAddress: USB_DIR_OUT,
++ bmAttributes: BULK,
++ wMaxPacketSize: __constant_cpu_to_le16(0),
++ bInterval: 0,
++};
++/*! BULK IN data endpoint descriptor
++ */
++static struct usbd_endpoint_descriptor safe_data_2 =
++{
++ bLength:sizeof(struct usbd_endpoint_descriptor),
++ bDescriptorType:USB_DT_ENDPOINT,
++ bEndpointAddress:USB_DIR_IN,
++ bmAttributes: BULK,
++ wMaxPacketSize: __constant_cpu_to_le16(0),
++ bInterval: 0x0,
++};
++
++/*! INTERRUPT IN data endpoint descriptor
++ */
++static struct usbd_endpoint_descriptor safe_comm_1 =
++{
++ bLength:sizeof(struct usbd_endpoint_descriptor),
++ bDescriptorType:USB_DT_ENDPOINT,
++ bEndpointAddress:USB_DIR_IN,
++ bmAttributes: INTERRUPT,
++ wMaxPacketSize: __constant_cpu_to_le16(0),
++ bInterval: 0xa,
++};
++
++#if 0
++static struct usbd_endpoint_descriptor *basic_default[] = { &basic_data_1,
++ &basic_data_2,
++ &basic_comm_1, };
++u8 basic_indexes[] = { BULK_OUT, BULK_IN, INT_IN, };
++#endif
++
++#if 0
++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 , };
++#else
++static struct usbd_class_header_function_descriptor safe_class_1 = {
++ bFunctionLength:0x05,
++ bDescriptorType: CS_INTERFACE,
++ bDescriptorSubtype: USB_ST_HEADER,
++ bcdCDC: __constant_cpu_to_le16(0x0110), //0x10, 0x01,
++};
++
++static struct usbd_class_mdlm_descriptor safe_class_2 = {
++ bFunctionLength: 0x15,
++ bDescriptorType: CS_INTERFACE,
++ bDescriptorSubtype: USB_ST_MDLM,
++ bcdVersion: __constant_cpu_to_le16( 0x0100), //0x00, 0x01,
++ bGUID: {
++ 0x5d, 0x34, 0xcf, 0x66, 0x11, 0x18, 0x11, 0xd6, /* bGUID */
++ 0xa2, 0x1a, 0x00, 0x01, 0x02, 0xca, 0x9a, 0x7f, /* bGUID */ },
++};
++
++static struct usbd_class_safe_descriptor safe_class_3 = {
++ bFunctionLength: 0x06,
++ bDescriptorType: CS_INTERFACE,
++ bDescriptorSubtype: USB_ST_MDLMD,
++ bGuidDescriptorType: 0x00,
++ bmNetworkCapabilities: 0x00,
++ bmDataCapabilities: 0x00, /* bDetailData */
++};
++
++static struct usbd_class_ethernet_networking_descriptor safe_class_4 = {
++ bFunctionLength: 0x0d,
++ bDescriptorType: CS_INTERFACE,
++ bDescriptorSubtype: USB_ST_ENF,
++ iMACAddress: 0x0,
++ bmEthernetStatistics: __constant_cpu_to_le32(0x00),
++ wMaxSegmentSize: __constant_cpu_to_le16(0x5ea),
++ wNumberMCFilters: __constant_cpu_to_le16(0x00),
++ bNumberPowerFilters: 0,
++};
++
++#endif
++
++/*! Endpoint descriptor list
++ */
++static struct usbd_endpoint_descriptor *safe_alt_endpoints[] = {
++ &safe_data_1, &safe_data_2, &safe_comm_1, };
++
++static struct usbd_generic_class_descriptor *safe_comm_class_descriptors[] = {
++ (struct usbd_generic_class_descriptor *) &safe_class_1,
++ (struct usbd_generic_class_descriptor *) &safe_class_2,
++ (struct usbd_generic_class_descriptor *) &safe_class_3,
++ (struct usbd_generic_class_descriptor *) &safe_class_4, };
++
++u8 safe_alt_indexes[] = { BULK_OUT, BULK_IN, INT_IN, };
++
++/*! Data Interface Descriptor
++ */
++static struct usbd_interface_descriptor safe_alternate_descriptor = {
++ bLength: 0x09,
++ bDescriptorType: USB_DT_INTERFACE,
++ bInterfaceNumber: 0x00,
++ bAlternateSetting: 0x00,
++ bNumEndpoints: sizeof(safe_alt_endpoints)/sizeof(struct usbd_endpoint_descriptor *),
++ bInterfaceClass: COMMUNICATIONS_INTERFACE_CLASS,
++ bInterfaceSubClass: COMMUNICATIONS_MDLM_SUBCLASS,
++ bInterfaceProtocol: COMMUNICATIONS_NO_PROTOCOL,
++ iInterface: 0x00,
++};
++
++/*! Data Alternate Interface Description List
++ */
++static struct usbd_alternate_description safe_alternate_descriptions[] = {
++ {
++ iInterface: CONFIG_OTG_NETWORK_SAFE_INTF,
++ interface_descriptor: &safe_alternate_descriptor,
++ classes: sizeof (safe_comm_class_descriptors) / sizeof (struct usbd_generic_class_descriptor *),
++ class_list: safe_comm_class_descriptors,
++ endpoints:sizeof (safe_alt_endpoints) / sizeof(struct usbd_endpoint_descriptor *),
++ endpoint_list: safe_alt_endpoints,
++ endpoint_indexes: safe_alt_indexes,
++ },
++};
++
++/* Interface descriptions and descriptors
++ */
++/*! Interface Description List
++ */
++static struct usbd_interface_description safe_interfaces[] = {
++ {
++ alternates:sizeof (safe_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ alternate_list:safe_alternate_descriptions, },
++};
++
++
++/* Configuration descriptions and descriptors
++ */
++
++/*! Configuration Descriptor
++ */
++static struct usbd_configuration_descriptor safe_configuration_descriptor = {
++ bLength: 0x09,
++ bDescriptorType: USB_DT_CONFIGURATION,
++ wTotalLength: __constant_cpu_to_le16(0x0000), //0x00, 0x00, // wLength
++ bNumInterfaces:sizeof (safe_interfaces) / sizeof (struct usbd_interface_description),
++ bConfigurationValue:0x01,
++ iConfiguration: 0x00, // bConfigurationValue, iConfiguration
++ bmAttributes: 0,
++ bMaxPower:0,
++};
++
++/*! Configuration Description List
++ */
++struct usbd_configuration_description safe_description[] = {
++ {
++ iConfiguration: CONFIG_OTG_NETWORK_SAFE_DESC,
++ configuration_descriptor: &safe_configuration_descriptor,
++ },
++};
++
++/* Device Description
++ */
++/*! Device Descriptor
++ */
++static struct usbd_device_descriptor safe_device_descriptor = {
++ bLength: sizeof(struct usbd_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_OTG_NETWORK_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_BCDDEVICE),
++};
++
++#ifdef CONFIG_OTG_HIGH_SPEED
++/*! High Speed Device Qualifier Descriptor
++ */
++static struct usbd_device_qualifier_descriptor safe_device_qualifier_descriptor = {
++ bLength: sizeof(struct usbd_device_qualifier_descriptor),
++ bDescriptorType: USB_DT_DEVICE_QUALIFIER,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: COMMUNICATIONS_DEVICE_CLASS,
++ bDeviceSubClass: 0x02,
++ bDeviceProtocol: 0x00,
++ bMaxPacketSize0: 0x00,
++};
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++/*! Endpoint Request List
++ */
++static struct usbd_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, },
++};
++
++/*! OTG Descriptor
++ */
++static struct usbd_otg_descriptor safe_otg_descriptor = {
++ bLength : sizeof(struct usbd_otg_descriptor),
++ bDescriptorType: USB_DT_OTG,
++ bmAttributes: 0,
++};
++
++/*! Device Description
++ */
++struct usbd_device_description safe_device_description = {
++ device_descriptor: &safe_device_descriptor,
++#ifdef CONFIG_OTG_HIGH_SPEED
++ device_qualifier_descriptor: &safe_device_qualifier_descriptor,
++#endif /* CONFIG_OTG_HIGH_SPEED */
++ otg_descriptor: &safe_otg_descriptor,
++ iManufacturer: CONFIG_OTG_NETWORK_MANUFACTURER,
++ iProduct: CONFIG_OTG_NETWORK_PRODUCT_NAME,
++#if !defined(CONFIG_OTG_NO_SERIAL_NUMBER) && defined(CONFIG_OTG_SERIAL_NUMBER_STR)
++ iSerialNumber:CONFIG_OTG_SERIAL_NUMBER_STR,
++#endif
++};
++
++/*! safe_init
++ * @param function The function instance
++ */
++void safe_init (struct usbd_function_instance *function)
++{
++ struct usbd_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 = &safe_class_4)) {
++ if (ethernet->iMACAddress) {
++ usbd_free_string_descriptor(ethernet->iMACAddress);
++ }
++ ethernet->iMACAddress = usbd_alloc_string(address_str);
++ }
++ }
++
++#ifdef CONFIG_OTG_NETWORK_SAFE_PADBEFORE
++ safe_class_3.bmNetworkCapabilities |= BMDATA_PADBEFORE;
++ len += sprintf(buf + len, "PADBEFORE: %02x ", safe_class_3.bmNetworkCapabilities);
++#endif
++#ifdef CONFIG_OTG_NETWORK_SAFE_CRC
++ safe_class_3.bmNetworkCapabilities |= BMDATA_CRC;
++ len += sprintf(buf + len, "CRC: %02x ", safe_class_3.bmNetworkCapabilities);
++#endif
++#ifdef CONFIG_OTG_NETWORK_SAFE_NONBRIDGED
++ safe_class_3.bmNetworkCapabilities |= BMNETWORK_NONBRIDGED;
++ len += sprintf(buf + len, "NONBRIDGE: %02x ",safe_class_3.bmDataCapabilities);
++#endif
++ if (strlen(buf))
++ TRACE_MSG1(NTT,"%s", buf);
++
++}
++
++/*! function driver description
++ */
++struct usbd_function_driver safe_function_driver = {
++ name: "network-SAFE",
++ fops: &net_fd_function_ops,
++ device_description: &safe_device_description,
++ bNumConfigurations: sizeof (safe_description) / sizeof (struct usbd_configuration_description),
++ configuration_description: safe_description,
++ idVendor: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_VENDORID),
++ idProduct: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_PRODUCTID),
++ bcdDevice: __constant_cpu_to_le16(CONFIG_OTG_NETWORK_BCDDEVICE),
++ bNumInterfaces:sizeof (safe_interfaces) / sizeof (struct usbd_interface_description),
++ interface_list:safe_interfaces,
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: safe_endpoint_requests,
++};
++#endif /* CONFIG_OTG_NETWORK_SAFE */
++
+diff -uNr linux/drivers/no-otg/ocd/Config.in linux/drivers/otg/ocd/Config.in
+--- linux/drivers/no-otg/ocd/Config.in 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/Config.in 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,15 @@
++
++#
++# Copyright (c) 2004 Belcarra
++#
++#
++
++ mainmenu_option next_comment
++ comment 'OTG Host Controller Driver (HCD)'
++ dep_tristate ' USB Host Controller Driver' CONFIG_OTG_HCD $CONFIG_OTG_HOSTCORE
++ hex 'VendorID (hex value)' CONFIG_OTG_ROOTHUB_VENDORID "15ec"
++ hex 'ProductID (hex value)' CONFIG_OTG_ROOTHUB_PRODUCTID "f010"
++ hex 'ProductID (hex value)' CONFIG_OTG_ROOTHUB_BCDDEVICE "0100"
++
++
++ endmenu
+diff -uNr linux/drivers/no-otg/ocd/Makefile linux/drivers/otg/ocd/Makefile
+--- linux/drivers/no-otg/ocd/Makefile 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/Makefile 2006-09-01 21:41:30.000000000 +0200
+@@ -0,0 +1,44 @@
++#
++# Belcarra OTG - On-The-Go
++#
++# Copyright (c) 2004 Belcarra Technologies Corp
++
++TOPDIR ?= ../../../..
++
++subdir-y :=
++subdir-m :=
++subdir-n :=
++subdir- :=
++
++# The target object and module list name.
++
++O_TARGET := ocd_target.o
++
++subdir-$(CONFIG_OTG_AU1550) += au1x00
++subdir-$(CONFIG_OTG_AU1X00) += au1x00
++subdir-$(CONFIG_OTG_ISP1301_OMAP_H2) += isp1301
++subdir-$(CONFIG_OTG_ISP1301_MAINSTONE) += isp1301
++
++subdir-$(CONFIG_OTG_MAX3353E_DB1550) += max3353e
++
++# Object file lists.
++
++obj-y :=
++obj-m :=
++obj-n :=
++obj- :=
++
++# Bus Interface Drivers
++ocd-obj-$(CONFIG_OTG_AU1550) += au1x00/au1x00_pcd_drv.o
++ocd-obj-$(CONFIG_OTG_AU1X00) += au1x00/au1x00_pcd_drv.o
++
++# Platform
++ocd-obj-$(CONFIG_OTG_ISP1301_OMAP_H2) += isp1301/isp1301_target.o
++ocd-obj-$(CONFIG_OTG_ISP1301_MAINSTONE) += isp1301/isp1301_target.o
++
++ocd-obj-$(CONFIG_OTG_MAX3353E_DB1550) += max3353e/max3353e_target.o
++
++obj-y += $(ocd-obj-y)
++
++include $(TOPDIR)/Rules.make
++EXTRA_CFLAGS += -Wno-format -Wall
+diff -uNr linux/drivers/no-otg/ocd/Makefile-l26 linux/drivers/otg/ocd/Makefile-l26
+--- linux/drivers/no-otg/ocd/Makefile-l26 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/Makefile-l26 2006-09-01 21:41:30.000000000 +0200
+@@ -0,0 +1,29 @@
++#
++# Belcarra OTG - On-The-Go
++#
++# Copyright (c) 2004 Belcarra Technologies Corp
++
++EXTRA_CFLAGS += -Wno-format -Wall
++
++# Bus Interface Drivers
++#subdir-$(CONFIG_OTG_AU1X00) += au1x00
++#subdir-$(CONFIG_OTG_LH7A400) += lh7a400
++#subdir-$(CONFIG_OTG_MX1) += mx1
++#subdir-$(CONFIG_OTG_MX2) += mx2
++#subdir-$(CONFIG_OTG_NC2280) += nc2280
++#subdir-$(CONFIG_OTG_PXA) += pxa
++#subdir-$(CONFIG_OTG_SA1100) += sa1100
++#subdir-$(CONFIG_OTG_SMDK2500) += smdk2500
++#subdir-$(CONFIG_OTG_SUPERH) += superh
++#subdir-$(CONFIG_OTG_SX2) += sx2
++#subdir-$(CONFIG_OTG_WMMX) += wmmx
++
++obj-m += scma11-evb/
++obj-m += omap/
++obj-m += isp1301/
++
++obj-y += scma11-evb/
++obj-y += omap/
++obj-y += isp1301/
++
++
+diff -uNr linux/drivers/no-otg/ocd/README linux/drivers/otg/ocd/README
+--- linux/drivers/no-otg/ocd/README 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/README 2006-09-01 21:41:30.000000000 +0200
+@@ -0,0 +1,54 @@
++otg/pcd
++
++
++Linux Build support:
++
++ Makefile
++ Makefile-l24
++ Makefile-l26
++
++ README
++
++PCD support files:
++
++ otg-pcd/pcd.c
++ otg-pcd/pcd-init-l24.c
++ otg-pcd/pcd-ocd-init-l24.c
++ otg-pcd/tr-init-l24.c
++
++TCD support files:
++
++ otg-tcd/tcd.c
++ otg-tcd/tcd-init-l24.c
++
++HCD support files;
++
++ otg-hcd/hcd-init-l24.c
++ otg-hcd/hcd-l26.c
++ otg-hcd/hcd-rh.c
++ otg-hcd/hcd.c
++
++Architecture Specific Drivers:
++
++ lh7a400
++ mx1
++ nc2280
++ pxa
++ sa1100
++ smdk2500
++ superh
++ sx2
++
++Device Specific Drivers:
++
++ atlas
++ isp1301
++ max3353e
++
++Platform Specific Drivers
++
++ au1x00
++ bvd
++ mx2
++ omap
++
+diff -uNr linux/drivers/no-otg/ocd/au1x00/Makefile linux/drivers/otg/ocd/au1x00/Makefile
+--- linux/drivers/no-otg/ocd/au1x00/Makefile 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/au1x00/Makefile 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,111 @@
++#
++# 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_pcd_drv.o
++
++# Objects that export symbols.
++
++export-objs :=
++
++# Multipart objects.
++
++#au1x00_otg-objs := au1x00.o usbd-bi.o trace.o
++db1550_tr-objs := tr-init-l24.o au1550.o pcd.o
++db1550_dr-objs := tr-init-l24.o au1550.o pcd.o
++#au1550_tr-objs := tr-init-l24.o au1550.o pcd.o
++au1x00_tr-objs := tr-init-l24.o au1x00.o pcd.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_OTG_AU1550_DB1500_TR) += db1550_tr.o
++obj-$(CONFIG_OTG_AU1550_DB1550_TR) += db1550_tr.o
++obj-$(CONFIG_OTG_AU1550_DB1500_DR) += db1550_dr.o
++
++#obj-$(CONFIG_OTG_AU1550) += au1550_tr.o
++obj-$(CONFIG_OTG_AU1X00) += au1x00_tr.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
++
++OTG=$(TOPDIR)/drivers/otg
++OCD_DIR=$(OTG)/ocd
++INCLUDE_DIRS = -I$(OTG)
++EXTRA_CFLAGS += -Wno-missing-prototypes -Wno-unused -Wno-format ${INCLUDE_DIRS}
++EXTRA_CFLAGS_nostdinc += -Wno-missing-prototypes -Wno-unused -Wno-format ${INCLUDE_DIRS}
++
++I2C=$(OTG)/ocd/otg-i2c
++PCD=$(OTG)/ocd/otg-pcd
++vpath %.c $(USBDCORE_DIR) $(OCD_DIR) $(PCD) $(I2C)
++
++
++# Link rules for multi-part drivers.
++
++db1550_tr.o: $(db1550_tr-objs)
++ $(LD) -r -o $@ $(db1550_tr-objs)
++
++db1550_dr.o: $(db1550_tr-objs)
++ $(LD) -r -o $@ $(au1550_tr-objs)
++
++#au1550_tr.o: $(au1550_tr-objs)
++# $(LD) -r -o $@ $(au1550_tr-objs)
++
++au1x00_tr.o: $(au1x00_tr-objs)
++ $(LD) -r -o $@ $(au1x00_tr-objs)
++
++# dependencies:
++
++# local
++
++
+diff -uNr linux/drivers/no-otg/ocd/au1x00/NOTES.txt linux/drivers/otg/ocd/au1x00/NOTES.txt
+--- linux/drivers/no-otg/ocd/au1x00/NOTES.txt 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/au1x00/NOTES.txt 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,62 @@
++
++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.
++
++10. The Au1x00 does not support REMOTE WAKEUP
++
+diff -uNr linux/drivers/no-otg/ocd/au1x00/au1550.c linux/drivers/otg/ocd/au1x00/au1550.c
+--- linux/drivers/no-otg/ocd/au1x00/au1550.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/au1x00/au1550.c 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,1451 @@
++/*
++ * otg/ocd/au1x00/au1x00.c -- USB Device Controller driver.
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ *
++ */
++/*!
++ * @file otg/ocd/au1x00/au1550.c
++ * @brief AU1X00 Header
++ *
++ * This file contains the private defines and structures for the AU1X00
++ * Drivers.
++ *
++ * @ingroup AU1X00
++ */
++
++
++#include <otg/pcd-include.h>
++#include "au1x00.h"
++
++#include <asm/io.h>
++#include <asm/au1000.h>
++#include <asm/au1000_dma.h>
++
++#if defined(CONFIG_SOC_AU1550)
++#include <asm/au1xxx_dbdma.h>
++#else
++#error "Wrong AU1X00_MDA"
++#endif
++
++#include <asm/mipsregs.h>
++
++#ifdef CONFIG_MIPS_FREEHAND
++#include <linux/i2c.h>
++#include <linux/sensors.h> /* for reading serial number */
++#endif
++
++
++#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_saw_bus_activity;
++int au_halt_dma_expired;
++u32 au1x00_inten;
++
++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: DSCR_CMD0_USBDEV_TX0, tx_str: "EP0 IN WR",},
++
++ { rds: 0, wrs: 0, indma: -1, outdma: -1, }, // ep0
++ { wr: NUSBD_EP1WR, wrs: NUSBD_EP1WRSTAT, tx_id: DSCR_CMD0_USBDEV_TX1, cs: NUSBD_EP1CS, tx_str: "EP1 IN WR",},
++ { wr: NUSBD_EP2WR, wrs: NUSBD_EP2WRSTAT, tx_id: DSCR_CMD0_USBDEV_TX2, cs: NUSBD_EP2CS, tx_str: "EP2 IN WR",},
++
++ { rd: NUSBD_EP3RD, rds: NUSBD_EP3RDSTAT, rx_id: DSCR_CMD0_USBDEV_RX3, cs: NUSBD_EP3CS, rx_str: "EP3 OUT RD",},
++ { rd: NUSBD_EP4RD, rds: NUSBD_EP4RDSTAT, rx_id: DSCR_CMD0_USBDEV_RX4, 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, char *msg)
++{
++ TRACE_MSG2(PCD, "%s %08x", msg, inten);
++ au1x00_inten = inten;
++ au_writel(au1x00_inten, USBD_INTEN);
++}
++
++void __inline__ au_epn_interrupt_enable(int epn)
++{
++ au_inten(au1x00_inten | (1 << epn), "epn enable");
++}
++
++void __inline__ au_epn_interrupt_disable(int epn)
++{
++ au_inten(au1x00_inten & ~(1 << epn), "epn disable");
++ 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
++
++#define DDMA_DESCCMD_ARB (1<<15)
++#define DDMA_DESCCMD_DW (16)
++#define DDMA_DESCCMD_DW_N(n) ((n&3)<<DDMA_DESCCMD_DW)
++ #define DDMA_DESCCMD_DW_BYTE DDMA_DESCCMD_DW_N(0)
++ #define DDMA_DESCCMD_DW_HWORD DDMA_DESCCMD_DW_N(1)
++ #define DDMA_DESCCMD_DW_WORD DDMA_DESCCMD_DW_N(2)
++#define DDMA_DESCCMD_SW (18)
++#define DDMA_DESCCMD_SW_N(n) ((n&3)<<DDMA_DESCCMD_SW)
++ #define DDMA_DESCCMD_SW_BYTE DDMA_DESCCMD_SW_N(0)
++ #define DDMA_DESCCMD_SW_HWORD DDMA_DESCCMD_SW_N(1)
++ #define DDMA_DESCCMD_SW_WORD DDMA_DESCCMD_SW_N(2)
++
++#define DDMA_DESCCMD_DID (20)
++#define DDMA_DESCCMD_DID_N(n) ((n&0x1F)<<DDMA_DESCCMD_DID)
++#define DDMA_DESCCMD_SID (25)
++#define DDMA_DESCCMD_SID_N(n) ((n&0x1F)<<DDMA_DESCCMD_SID)
++
++/*
++ * Bit definitions for source stride/block 1 dimensional
++ */
++#define DDMA_DESCSRC_STRIDE_SS (0)
++#define DDMA_DESCSRC_STRIDE_SS_N(n) ((n&0x3fff)<<DDMA_DESCSRC_STRIDE_SS)
++#define DDMA_DESCSRC_STRIDE_SB (14)
++#define DDMA_DESCSRC_STRIDE_SB_N(n) ((n&0x3Fff)<<DDMA_DESCSRC_STRIDE_SB)
++#define DDMA_DESCSRC_STRIDE_SAM (28)
++#define DDMA_DESCSRC_STRIDE_SAM_N(n) ((n&3)<<DDMA_DESCSRC_STRIDE_SAM)
++ #define DDMA_DESCSRC_STRIDE_SAM_INC DDMA_DESCSRC_STRIDE_SAM_N(0)
++ #define DDMA_DESCSRC_STRIDE_SAM_DEC DDMA_DESCSRC_STRIDE_SAM_N(1)
++ #define DDMA_DESCSRC_STRIDE_SAM_STATIC DDMA_DESCSRC_STRIDE_SAM_N(2)
++ #define DDMA_DESCSRC_STRIDE_SAM_BURST DDMA_DESCSRC_STRIDE_SAM_N(3)
++#define DDMA_DESCSRC_STRIDE_STS (30)
++#define DDMA_DESCSRC_STRIDE_STS_N(n) ((n&3)<<DDMA_DESCSRC_STRIDE_STS)
++ #define DDMA_DESCSRC_STRIDE_STS_1 DDMA_DESCSRC_STRIDE_STS_N(0)
++ #define DDMA_DESCSRC_STRIDE_STS_2 DDMA_DESCSRC_STRIDE_STS_N(1)
++ #define DDMA_DESCSRC_STRIDE_STS_4 DDMA_DESCSRC_STRIDE_STS_N(2)
++ #define DDMA_DESCSRC_STRIDE_STS_8 DDMA_DESCSRC_STRIDE_STS_N(3)
++
++
++/*
++ * Bit definitions for dest stride/block 1 dimensional
++ */
++#define DDMA_DESCDST_STRIDE_DS (0)
++#define DDMA_DESCDST_STRIDE_DS_N(n) ((n&0x3fff)<<DDMA_DESCDST_STRIDE_DS)
++#define DDMA_DESCDST_STRIDE_DB (14)
++#define DDMA_DESCDST_STRIDE_DB_N(n) ((n&0x3Fff)<<DDMA_DESCDST_STRIDE_DB)
++#define DDMA_DESCDST_STRIDE_DAM (28)
++#define DDMA_DESCDST_STRIDE_DAM_N(n) ((n&3)<<DDMA_DESCDST_STRIDE_DAM)
++ #define DDMA_DESCDST_STRIDE_DAM_INC DDMA_DESCDST_STRIDE_DAM_N(0)
++ #define DDMA_DESCDST_STRIDE_DAM_DEC DDMA_DESCDST_STRIDE_DAM_N(1) #define DDMA_DESCDST_STRIDE_DAM_STATIC DDMA_DESCDST_STRIDE_DAM_N(2)
++ #define DDMA_DESCDST_STRIDE_DAM_BURST DDMA_DESCDST_STRIDE_DAM_N(3)
++#define DDMA_DESCDST_STRIDE_DTS (30)
++#define DDMA_DESCDST_STRIDE_DTS_N(n) ((n&3)<<DDMA_DESCDST_STRIDE_DTS)
++ #define DDMA_DESCDST_STRIDE_DTS_1 DDMA_DESCDST_STRIDE_DTS_N(0)
++ #define DDMA_DESCDST_STRIDE_DTS_2 DDMA_DESCDST_STRIDE_DTS_N(1)
++ #define DDMA_DESCDST_STRIDE_DTS_4 DDMA_DESCDST_STRIDE_DTS_N(2)
++ #define DDMA_DESCDST_STRIDE_DTS_8 DDMA_DESCDST_STRIDE_DTS_N(3)
++
++#ifndef CONFIG_MIPS_MTX2
++typedef struct dbdma_device_table {
++ u32 dev_flags;
++ u32 dev_tsize;
++ u32 dev_devwidth;
++ u32 dev_physaddr; /* If FIFO */
++ u32 dev_intlevel;
++ u32 dev_intpolarity;
++} dbdev_tab_t;
++
++typedef struct dbdma_chan_config {
++ u32 chan_flags;
++ u32 chan_index;
++ dbdev_tab_t *chan_src;
++ dbdev_tab_t *chan_dest;
++ au1x_dma_chan_t *chan_ptr;
++ au1x_ddma_desc_t *chan_desc_base;
++ au1x_ddma_desc_t *get_ptr, *put_ptr, *cur_ptr;
++ void *chan_callparam;
++ void (*chan_callback)(int, void *, struct pt_regs *);
++} chan_tab_t;
++#endif
++static void __inline__ au_halt_dma(u32 chan)
++{
++ chan_tab_t *ctp = *((chan_tab_t **)chan);
++ volatile au1x_dma_chan_t *cp = ctp->chan_ptr;;
++ au1x_ddma_desc_t *dp;
++
++ au1xxx_dbdma_stop(chan);
++ au_halt_dma_expired++;
++
++ dp = ctp->cur_ptr; // ensure that descriptor is stopped
++ dp->dscr_cmd0 &= ~DSCR_CMD0_V;
++
++}
++
++static void __inline__ au_start_dma_in(int indma, u32 tx_id, __u8 *bp, int len)
++{
++ chan_tab_t *ctp = *((chan_tab_t **)indma);
++ au1x_ddma_desc_t *dp = ctp->cur_ptr;
++ volatile au1x_dma_chan_t *cp = ctp->chan_ptr;;
++
++ TRACE_MSG8(PCD, "%08x %08x cmd: %08x %04x src: %08x %08x dst: %08x %08x MEM2USB",
++ indma, dp, dp->dscr_cmd0, dp->dscr_cmd1,
++ dp->dscr_source0, dp->dscr_source1, dp->dscr_dest0, dp->dscr_dest1);
++
++ dp->dscr_source0 = virt_to_phys(bp);
++ dp->dscr_source1 = DDMA_DESCSRC_STRIDE_STS_4 | DDMA_DESCSRC_STRIDE_SAM_INC;
++
++ dp->dscr_cmd1 = len;
++ dp->dscr_cmd0 =
++ DSCR_CMD0_SID(DSCR_CMD0_ALWAYS) |
++ DSCR_CMD0_DID(indma)
++ ;
++ TRACE_MSG1(PCD, "cmd0: %08x SID/DID", dp->dscr_cmd0);
++
++ dp->dscr_cmd0 |=
++ DDMA_DESCCMD_SW_BYTE |
++ DDMA_DESCCMD_DW_BYTE
++ ;
++ TRACE_MSG1(PCD, "cmd0: %08x SW/DW", dp->dscr_cmd0);
++
++ dp->dscr_cmd0 = DSCR_CMD0_V |
++ DSCR_CMD0_SID(DSCR_CMD0_ALWAYS) |
++ DSCR_CMD0_DID(tx_id) |
++ DDMA_DESCCMD_SW_BYTE |
++ DDMA_DESCCMD_DW_BYTE |
++ DSCR_CMD0_ARB |
++ DSCR_CMD0_DN |
++ DSCR_CMD0_CV
++ ;
++
++ dp->dscr_dest1 = DDMA_DESCDST_STRIDE_DTS_4 | DDMA_DESCSRC_STRIDE_SAM_STATIC;
++
++ ctp->cur_ptr = dp;
++ cp->ddma_desptr = virt_to_phys(ctp->cur_ptr);
++ cp->ddma_cfg |= DDMA_CFG_EN; /* Enable channel */
++ au_sync();
++ cp->ddma_dbell = 0xffffffff; /* Make it go */
++ au_sync();
++
++ TRACE_MSG8(PCD, "%08x %08x cmd: %08x %04x src: %08x %08x dst: %08x %08x MEM2USB start",
++ indma, dp, dp->dscr_cmd0, dp->dscr_cmd1,
++ dp->dscr_source0, dp->dscr_source1, dp->dscr_dest0, dp->dscr_dest1);
++}
++
++static void __inline__ au_start_dma_out(unsigned int outdma, u32 rx_id, __u8 *bp, int wMaxPacketSize)
++{
++ chan_tab_t *ctp = *((chan_tab_t **)outdma);
++ au1x_ddma_desc_t *dp = ctp->cur_ptr;
++ volatile au1x_dma_chan_t *cp = ctp->chan_ptr;;
++
++
++ dma_cache_inv((unsigned long) bp, wMaxPacketSize);
++
++ TRACE_MSG8(PCD, "%08x %08x cmd: %08x %04x src: %08x %08x dst: %08x %08x USB2MEM",
++ outdma, dp, dp->dscr_cmd0, dp->dscr_cmd1,
++ dp->dscr_source0, dp->dscr_source1, dp->dscr_dest0, dp->dscr_dest1);
++
++ // if (!au1xxx_dbdma_put_dest(outdma, bp, wMaxPacketSize))
++
++ dp->dscr_dest0 = virt_to_phys(bp);
++ dp->dscr_dest1 = DDMA_DESCDST_STRIDE_DTS_4 | DDMA_DESCDST_STRIDE_DAM_INC;
++
++ dp->dscr_cmd1 = wMaxPacketSize;
++ dp->dscr_cmd0 = DSCR_CMD0_V |
++ DSCR_CMD0_SID(rx_id) |
++ DSCR_CMD0_DID(DSCR_CMD0_ALWAYS) |
++ DDMA_DESCCMD_SW_BYTE |
++ DDMA_DESCCMD_DW_BYTE |
++ DSCR_CMD0_ARB |
++ DSCR_CMD0_SN |
++ DSCR_CMD0_CV
++ ;
++
++ dp->dscr_source1 = DDMA_DESCSRC_STRIDE_STS_4 | DDMA_DESCSRC_STRIDE_SAM_STATIC;
++
++ ctp->cur_ptr = dp;
++ cp->ddma_desptr = virt_to_phys(ctp->cur_ptr);
++ cp->ddma_cfg |= DDMA_CFG_EN; /* Enable channel */
++ au_sync();
++ cp->ddma_dbell = 0xffffffff; /* Make it go */
++ au_sync();
++
++ TRACE_MSG8(PCD, "%08x %08x cmd: %08x %04x src: %08x %08x dst: %08x %08x USB2MEM start",
++ outdma, dp, dp->dscr_cmd0, dp->dscr_cmd1,
++ dp->dscr_source0, dp->dscr_source1, dp->dscr_dest0, dp->dscr_dest1);
++}
++
++/* ********************************************************************************************* */
++static struct usbd_urb *au_rcv_complete_ep0_irq(struct usbd_endpoint_instance *endpoint, int len, int urb_bad)
++{
++ struct usbd_urb *rcv_urb = endpoint->rcv_urb;
++ if (rcv_urb && !urb_bad) {
++ int i;
++ u8 *cp = rcv_urb->buffer + rcv_urb->actual_length;
++ for (i = 0 ; i < len; i+= 8)
++ TRACE_MSG8(PCD, "ARCV %02x %02x %02x %02x %02x %02x %02x %02x",
++ cp[i + 0], cp[i + 1], cp[i + 2], cp[i + 3],
++ cp[i + 4], cp[i + 5], cp[i + 6], cp[i + 7]
++ );
++
++ }
++ return pcd_rcv_complete_irq(endpoint, len, urb_bad);
++}
++
++/* au_start_in_ep0 - start transmit
++ */
++static void au_start_in_ep0 (struct usbd_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ struct usbd_urb *urb = endpoint->tx_urb;
++ int last = ep->last = endpoint->last = MIN (urb->actual_length - endpoint->sent, endpoint->wMaxPacketSize);
++ TRACE_MSG2(PCD, "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 usbd_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ u32 cs;
++ struct usbd_urb *tx_urb;
++ int last;
++ TRACE_MSG1(PCD, "EP0 IN: tx_urb: %p", (int)endpoint->tx_urb);
++ if ((cs = au_readl(ep->cs)) & USBDEV_CS_STALL) { // clear stall if present
++ TRACE_MSG1(PCD, "CLEAR STALL %d", 0);
++ cs &= ~USBDEV_CS_STALL;
++ au_writel(cs, ep->cs);
++ return;
++ }
++ if (!(tx_urb = pcd_tx_complete_irq(endpoint, 0))) { // wait for setup if no more data
++ endpoint->state = WAIT_FOR_SETUP;
++ return;
++ }
++ TRACE_MSG4(PCD, "EP0 IN actual: %d last: %d sent: %d flags: %x", endpoint->tx_urb->actual_length,
++ endpoint->last, endpoint->sent, endpoint->tx_urb->flags);
++ if (pcd_tx_sendzlp(endpoint)) { // check if tx_urb we have is finished
++ TRACE_MSG0(PCD, "EP0 IN BULK - sending ZLP");
++ tx_urb->flags &= ~USBD_URB_SENDZLP;
++ send_zlp(0);
++ pcd_tx_complete_irq(endpoint, 0);
++ return;
++ }
++ if (tx_urb->actual_length > endpoint->sent) {
++ if ((tx_urb->actual_length - endpoint->sent) < endpoint->wMaxPacketSize)
++ TRACE_MSG1(PCD, "EP0 IN starting short packet %d", tx_urb->actual_length - endpoint->sent);
++ else
++ TRACE_MSG1(PCD, "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 usbd_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ struct usbd_device_request request;
++ int i;
++ u32 cs;
++ u32 bytes;
++ TRACE_MSG0(PCD, "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 usbd_urb *rcv_urb = pcd_rcv_next_irq(endpoint);
++ TRACE_MSG1(PCD, "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_ep0_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;
++ }
++ pcd_tx_cancelled_irq(endpoint);
++ pcd_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_MSG1(PCD, "ERROR SETUP SET not eight bytes: %d", bytes);
++ au_writel(USBDEV_FSTAT_FLUSH | USBDEV_FSTAT_UF | USBDEV_FSTAT_OF, ep->wrs);
++ return;
++ }
++ TRACE_MSG4(PCD, "SETUP bmRequestType: %02x bRequest %02x state: %d status: %d", request.bmRequestType,
++ request.bRequest, pcd_instance->bus->device_state, pcd_instance->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 (pcd_instance->bus->device_state == STATE_DEFAULT);
++ udc_saw_bus_activity = 0;
++ usbd_bus_event_handler_irq (pcd_instance->bus, DEVICE_RESET, 0);
++ //usbd_bus_event_handler_irq (pcd_instance->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 != pcd_instance->bus->device_state);
++ udc_saw_bus_activity = 0;
++ usbd_bus_event_handler_irq (pcd_instance->bus, DEVICE_RESET, 0);
++ //usbd_bus_event_handler_irq (pcd_instance->bus, DEVICE_ADDRESS_ASSIGNED, 0);
++ break;
++ }
++ if (pcd_recv_setup_irq(pcd_instance, &request)) {
++ TRACE_MSG1(PCD, "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_MSG1(PCD, "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_MSG1(PCD, "ep0 Class H2D request %04x", le16_to_cpu(request.wLength));
++ if ((request.bmRequestType & ~USB_REQ_DIRECTION_MASK)) {
++ TRACE_MSG1(PCD, "ep0 Class or Vendor, send ZLP %d", cs);
++ send_zlp(0);
++ return;
++ }
++ }
++ TRACE_MSG1(PCD, "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 usbd_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ struct usbd_urb *urb = endpoint->tx_urb;
++ u8 *bp = urb->buffer + endpoint->sent;
++ int last;
++ int i;
++ u32 *lp;
++ TRACE_MSG1(PCD, "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_MSG2(PCD, "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_MSG0(PCD, "START IN BULK - zending ZLP");
++ send_zlp(epn);
++ endpoint->tx_urb->flags &= ~USBD_URB_SENDZLP;
++ }
++ return;
++ }
++ else if (8 >= last) {
++ au_writel(last << 1, ep->cs);
++ au_fifo_write(epn, bp, last);
++ return;
++ }
++
++ dma_cache_wback_inv((unsigned long) bp, last);
++ //au_writel(last << 1, ep->cs);
++ au_start_dma_in(ep->indma, ep->tx_id, bp, last);
++ au_writel(last << 1, ep->cs);
++}
++
++static void au_in_bulk(unsigned int epn, struct ep_regs *ep, struct usbd_endpoint_instance *endpoint)
++{
++ struct usbd_urb *tx_urb;
++ int rc = 0;
++ u32 cs = au_readl(ep->cs);
++ u32 wrs = au_readl(ep->wrs);
++ u32 residue = au1xxx_get_dma_residue(ep->indma);
++ TRACE_MSG3(PCD, "BULK IN EPN - cs: %x wrs: %x residue:%d", cs, wrs, residue);
++ if (wrs) { // check for underflow or overflow
++ rc = 1;
++ if (wrs & USBDEV_FSTAT_UF) {
++ TRACE_MSG2(PCD, "BULK IN EPN - UF epn %d wrs: %x", epn, wrs);
++ rc = 1; // set rc to indicate an error
++ }
++ if (wrs & USBDEV_FSTAT_OF)
++ TRACE_MSG2(PCD, "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_MSG1(PCD, "BULK IN EPN - CLEAR STALL %d", epn);
++ cs &= ~USBDEV_CS_STALL;
++ au_writel(cs, ep->cs);
++ return;
++ }
++ TRACE_MSG4(PCD, "BULK IN EPN epn: %d rc: %d last: %d sent: %d", epn, rc, endpoint->last, endpoint->sent);
++
++ if ((tx_urb = pcd_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);
++ TRACE_MSG1(PCD, "BULK IN EPN - LEFT TO SEND %d", tx_urb->actual_length - endpoint->sent);
++ return;
++ }
++ }
++ au_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 usbd_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ struct usbd_urb *urb = endpoint->tx_urb;
++ unsigned char *bp = urb->buffer + endpoint->sent;
++ int last;
++ TRACE_MSG2(PCD, "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_MSG2(PCD, "START IN ISO last: %d packetSize: %d", last, endpoint->wMaxPacketSize);
++ au_writel(USBDEV_FSTAT_FLUSH | USBDEV_FSTAT_UF | USBDEV_FSTAT_OF, ep->wrs); // XXX
++ au_epn_interrupt_enable (epn);
++ dma_cache_wback_inv((unsigned long) bp, last);
++ au_writel(last << 1, ep->cs);
++ au_start_dma_in(ep->indma, ep->tx_id, bp, last);
++}
++
++static void au_in_iso(unsigned int epn, struct ep_regs *ep, struct usbd_endpoint_instance *endpoint)
++{
++ struct usbd_urb *tx_urb = pcd_tx_complete_irq(endpoint, 0);
++ u32 cs = au_readl(ep->cs);
++ u32 wrs = au_readl(ep->wrs);
++ TRACE_MSG2(PCD, "ISO IN EPN - cs: %x wrs: %x", cs, wrs);
++ TRACE_MSG4(PCD, "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.
++ */
++ TRACE_MSG1(PCD, "ISO IN EPN - LEFT TO SEND %d", tx_urb->actual_length - endpoint->sent);
++ return;
++ }
++
++ TRACE_MSG0(PCD, "ISO IN EPN - nothing to send");
++ au_epn_interrupt_disable(epn); // disable interrupts
++}
++/* ********************************************************************************************* */
++
++static struct usbd_urb *au_rcv_complete_epn_irq(struct usbd_endpoint_instance *endpoint, int len, int urb_bad)
++{
++ return pcd_rcv_complete_irq(endpoint, len, urb_bad);
++}
++
++
++static void au_start_out_bulk(unsigned int epn, struct usbd_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ TRACE_MSG2(PCD, "START OUT BULK %d actual: %d pcktSize: %d", epn, endpoint->wMaxPacketSize);
++ if (!endpoint->rcv_urb) {
++ TRACE_MSG0(PCD, "START OUT BULK DISABLE");
++ au_epn_interrupt_disable(epn);
++ return;
++ }
++ if (endpoint->rcv_error) {
++ TRACE_MSG0(PCD, "START OUT BULK reseting rcv_error");
++ endpoint->rcv_error = 0;
++ }
++ au_start_dma_out(ep->outdma, ep->rx_id,
++ endpoint->rcv_urb->buffer + endpoint->rcv_urb->actual_length, endpoint->wMaxPacketSize);
++}
++
++static void au_out_bulk(unsigned int epn, struct ep_regs *ep, struct usbd_endpoint_instance *endpoint)
++{
++ int bytes = 0;
++ int residue = 0;
++ u32 *lp = NULL;
++
++ struct usbd_urb *urb;
++ struct usbd_urb *completed_urb = NULL;
++ u32 cs;
++ u32 rds;
++ u32 nrds;
++ int i;
++
++ cs = au_readl(ep->cs);
++ rds = au_readl(ep->rds);
++
++ // XXX it appears that this is zero if 64 bytes where received!!!
++
++ // get dest ring buffer
++ au1xxx_dbdma_get_dest(ep->outdma, (void **)&lp, &bytes);
++
++ au_halt_dma(ep->outdma);
++ residue = endpoint->wMaxPacketSize - au1xxx_get_dma_residue(ep->outdma);
++
++ TRACE_MSG5(PCD, "BULK OUT CS: %04x RD: %04x bytes: %d residue: %d DMA %s",
++ cs, rds, bytes, residue, lp ? "FINISHED" : "ACTIVE");
++
++ /* check for NAK
++ */
++ if (cs & USBDEV_CS_NAK) {
++ TRACE_MSG0(PCD, "NAK bytes: 0");
++ bytes = 0;
++ }
++
++ /* with dbdma residue will either be zero or non-zero and less than packetsize, if
++ * zero then a complete transfer of packetsize was performed.
++ */
++ else if (!residue && !rds) {
++ TRACE_MSG0(PCD, "BULK OUT CS: forcing bytes: 64");
++ bytes = endpoint->wMaxPacketSize;
++ }
++ else {
++ TRACE_MSG0(PCD, "BULK OUT CS: using residue bytes: 64");
++ bytes = residue;
++ }
++
++
++ if (!(urb = pcd_rcv_next_irq(endpoint))) {
++ TRACE_MSG0(PCD, "BULK OUT EPN - no rcv_urb");
++ au_epn_interrupt_disable(epn);
++ return;
++ }
++
++ TRACE_MSG4(PCD, "BULK OUT CS: %04x RD: %04x actual: %d DMA bytes: %d", cs, rds, urb->actual_length, bytes);
++
++ if (bytes)
++ dma_cache_inv((u32) urb->buffer + urb->actual_length, bytes);
++
++ /* 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)
++ *
++ * XXX The following needs to be tested and streamlined for au1550, much of the extra
++ * testing done for older silicon cab probably be eliminated. For example the extra read
++ * of nrds to check for overrun in the FIFO should not be required.
++ *
++ */
++ if (rds & (USBDEV_FSTAT_OF | USBDEV_FSTAT_UF)) {
++ TRACE_MSG2(PCD, "BULK OUT FLUSHING %d length: %d", bytes, urb->actual_length);
++ THROW(start_flushing);
++ }
++ rds = rds & USBDEV_FSTAT_FCNT_MASK;
++ nrds = au_readl(ep->rds);
++
++ /* 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->wMaxPacketSize == bytes) {
++ TRACE_MSG2(PCD, "BULK OUT 64 BYTES %d length: %d", bytes, urb->actual_length);
++ if (endpoint->rcv_error) {
++ TRACE_MSG4(PCD, "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_MSG4(PCD, "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_MSG4(PCD, "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_epn_irq(endpoint, endpoint->wMaxPacketSize, 0);
++ if (cs & USBDEV_CS_NAK)
++ if (nrds && (nrds < 8) ) {
++ TRACE_MSG4(PCD, "NAK bytes: %d rds: %d nrds: %d cp0: %d START FLUSHING CS_NAK",
++ bytes, rds, nrds, cp0_count);
++ THROW(start_flushing);
++ }
++ }
++ /* a nak'd packet may be ok to ignore IFF the FIFO is empty(?) or completely full.
++ */
++ else if ((cs & USBDEV_CS_NAK) && (!nrds || (nrds == 8)) ) {
++ TRACE_MSG2(PCD, "BULK OUT NAK BYTES %d length: %d", bytes, urb->actual_length);
++ if (endpoint->rcv_error) {
++ TRACE_MSG4(PCD, "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);
++ }
++ /* short packet by DMA, additional data for this packet in FIFO, more than 3
++ * bytes is probably an error.
++ */
++ else {
++ TRACE_MSG2(PCD, "BULK OUT < 64 BYTES %d length: %d", bytes, urb->actual_length);
++ if ((cs & USBDEV_CS_NAK) && nrds && (nrds < 8) ) {
++ TRACE_MSG4(PCD, "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_MSG4(PCD, "BULK OUT SHORT PACKET by DMA full FIFO bytes: %d rds: %d nrds: %d cp0: %d START FLUSH",
++ bytes, rds, nrds, cp0_count);
++ THROW(start_flushing);
++ }
++ TRACE_MSG4(PCD, "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_MSG1(PCD, "BULK OUT < 64 BYTES %d", bytes);
++ au_writel(USBDEV_FSTAT_FLUSH | USBDEV_FSTAT_UF | USBDEV_FSTAT_OF, ep->rds);
++ if (!endpoint->rcv_error) {
++ TRACE_MSG0(PCD, "BULK OUT COMPLETED URB");
++ au_rcv_complete_epn_irq(endpoint, bytes, 0);
++ }
++ else {
++ TRACE_MSG0(PCD, "BULK OUT - FLUSHING URB - reseting rcv_error");
++ endpoint->rcv_error = 0;
++ }
++ }
++ CATCH(start_flushing) {
++ TRACE_MSG0(PCD, "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_MSG0(PCD, "BULK OUT - RESTARTING");
++ au_start_out_bulk(epn, endpoint, ep);
++}
++
++static void au_start_out_iso(unsigned int epn, struct usbd_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ RETURN_IF(!endpoint->rcv_urb);
++ au_start_dma_out(ep->outdma, ep->rx_id,
++ endpoint->rcv_urb->buffer + endpoint->rcv_urb->actual_length, endpoint->wMaxPacketSize);
++}
++
++static void au_out_iso(unsigned int epn, struct ep_regs *ep, struct usbd_endpoint_instance *endpoint)
++{
++ int bytes = 0;
++ struct usbd_urb *urb;
++ u32 cs;
++ u32 rds;
++ au_halt_dma(ep->outdma);
++ 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_MSG2(PCD, "ISO OUT EPN - rcv_urb was NULL bytes: %d rds: %d", bytes, rds);
++ au_rcv_complete_epn_irq(endpoint, bytes, 1);
++ TRACE_MSG0(PCD, "ISO OUT setting rcv_error");
++ }
++ bytes = endpoint->wMaxPacketSize - au1xxx_get_dma_residue(ep->outdma);
++ 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_epn_irq(endpoint, bytes, 0);
++ au_start_out_iso(epn, endpoint, ep);
++}
++/* ********************************************************************************************* */
++/* au_tx_dma_done - TX DMA interrupt handler
++ */
++static void au_tx_dma_done(int irq, void *dev_id, struct pt_regs *regs)
++{
++ int epn = (int) dev_id;
++ struct usbd_endpoint_instance *endpoint = pcd_instance->bus->endpoint_array + epn;
++ struct ep_regs *ep = &ep_regs[epn];
++ int residue;
++ ocd_ops.interrupts++;
++ RETURN_IF (!epn);
++ au_halt_dma(ep->indma);
++ ep->last = 0;
++}
++
++/* au_int_req - usb interrupt handler
++ */
++static void au_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
++ ocd_ops.interrupts++;
++ TRACE_MSG2(PCD, "INT - device: %d status: %d", pcd_instance->bus->device_state, pcd_instance->bus->status);
++#if 0
++ if (ocd_ops.interrupts > 2000) {
++ TRACE_MSG0(PCD, "UDC_INT call udc_disable_interrupts");
++ au_inten(0, "DISABLING");
++ 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_MSG2(PCD, "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_handler_irq (pcd_instance->bus, DEVICE_BUS_ACTIVITY, 0);
++ au_inten(0x0033/*|USBDEV_INT_SOF*/, "int SOF");
++ }
++ ep = &ep_regs[epn];
++ switch(ep->eptype) {
++ case USB_DIR_IN | USB_ENDPOINT_BULK:
++ case USB_DIR_IN | USB_ENDPOINT_INTERRUPT:
++ //TRACE_MSG2(PCD, "BULK IN %d %02x", epn, ep->eptype);
++ au_in_bulk(epn, ep, pcd_instance->bus->endpoint_array + epn);
++ break;
++ case USB_DIR_IN | USB_ENDPOINT_ISOCHRONOUS:
++ //TRACE_MSG2(PCD, "ISO IN %d %02x", epn, ep->eptype);
++ au_in_iso(epn, ep, pcd_instance->bus->endpoint_array + epn);
++ break;
++ case USB_DIR_OUT | USB_ENDPOINT_BULK:
++ case USB_DIR_OUT | USB_ENDPOINT_INTERRUPT:
++ //TRACE_MSG2(PCD, "BULK OUT %d %02x", epn, ep->eptype);
++ au_out_bulk(epn, ep, pcd_instance->bus->endpoint_array + epn);
++ break;
++ case USB_DIR_OUT | USB_ENDPOINT_ISOCHRONOUS:
++ //TRACE_MSG2(PCD, "ISO OUT %d %04d", epn, au_readl(NUSBD_FRAMENUM));
++ au_out_iso(epn, ep, pcd_instance->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(pcd_instance->bus->endpoint_array + 0, &ep_regs[0]);
++ if (intstat & (1 << 1))
++ au_in_ep0(pcd_instance->bus->endpoint_array + 0, &ep_regs[0]);
++ if (intstat & USBDEV_INT_SOF)
++ if (USBD_SUSPENDED == pcd_instance->bus->status) {
++ TRACE_MSG0(PCD, "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_MSG1(PCD, "USB IRQ - %d", read_c0_count(CP0_COUNT) - cp0_count);
++#endif
++#if defined(RECORD_LATENCY)
++ cp0_record = read_c0_count(CP0_COUNT);
++#endif
++}
++
++/* au_int_sus -suspend interrupt handler
++ */
++static void au_int_sus (int irq, void *dev_id, struct pt_regs *regs)
++{
++ ocd_ops.interrupts++;
++ TRACE_MSG2(PCD, "SUS - INACTIVE device: %d status: %d", pcd_instance->bus->device_state, pcd_instance->bus->status);
++ switch(pcd_instance->bus->status) {
++ case USBD_OPENING:
++ case USBD_OK:
++ au_inten(0x0033, "suspend");
++ usbd_bus_event_handler_irq (pcd_instance->bus, DEVICE_BUS_INACTIVE, 0);
++ break;
++ default:
++ break;
++ }
++}
++/* ********************************************************************************************* */
++/*
++ * au_connect - enable pullup resistor
++ * Turn on the USB connection by enabling the pullup resistor.
++ *
++ * au_disconnect - disable pullup resistor
++ * Turn off the USB connection by disabling the pullup resistor.
++ */
++
++#if defined(CONFIG_MIPS_FREEHAND_NATIVE)
++#warning "Old code for Freehand"
++void au_connect (struct pcd_instance *pcd)
++{
++ au1000gpio_set(GPIO01);
++}
++
++void au_disconnect (struct pcd_instance *pcd)
++{
++ au1000gpio_clear(GPIO01);
++}
++#elif defined(CONFIG_AMX_MORDOR)
++void au_connect (struct pcd_instance *pcd)
++{
++ au_writel(0x00000008, SYS_OUTPUTSET);
++}
++
++void au_disconnect (struct pcd_instance *pcd)
++{
++ au_writel(0x00000008, SYS_OUTPUTCLR);
++}
++#elif defined(CONFIG_MIPS_DB1550) || defined(CONFIG_MIPS_MTX2)
++void au_connect (struct pcd_instance *pcd)
++{
++ au_writel(au_readl(GPIO2_DIR) | 0x100, GPIO2_DIR);
++ au_writel(0x01000100, GPIO2_OUTPUT);
++ au_sync();
++}
++void au_disconnect (struct pcd_instance *pcd)
++{
++ au_writel(au_readl(GPIO2_DIR) | 0x100, GPIO2_DIR);
++ au_writel(0x01000000, GPIO2_OUTPUT);
++ au_sync();
++}
++#else
++#warning "Please define au_connect / au_disconnect"
++void au_connect (struct pcd_instance *pcd)
++{
++}
++void au_disconnect (struct pcd_instance *pcd)
++{
++}
++#endif
++
++#undef read_c0_COUNT
++#ifndef read_c0_count
++#define read_c0_count() read_32bit_cp0_register(CP0_COUNT)
++#endif
++/* ********************************************************************************************* */
++/* au_ticks - get current ticks
++* */
++u64 au_ticks (void)
++{
++ return read_c0_count();
++}
++
++/* au_elapsed - return micro-seconds between two tick values
++ */
++u64 au_elapsed(u64 *t1, u64 *t2)
++{
++ u64 ticks = (*t1 > *t2) ? (*t1 - *t2) : (*t2 - *t1);
++ ticks = (u32)((u32) ticks / (u32) CONFIG_OTG_AU1X00_SCLOCK);
++ return ticks;
++}
++
++/* au_framenum - get current framenum
++ */
++u16 au_framenum (void)
++{
++ return au_readl(NUSBD_FRAMENUM);
++}
++
++
++/* ********************************************************************************************* */
++/* au_start_endpoint_in - start transmit
++ */
++void au_start_endpoint_in(struct pcd_instance *pcd, struct usbd_endpoint_instance *endpoint)
++{
++ int epn = epl2p[endpoint->bEndpointAddress&0xf];
++ struct ep_regs *ep = &ep_regs[epn];
++ switch(endpoint->bmAttributes & USB_ENDPOINT_MASK) {
++ case USB_ENDPOINT_CONTROL:
++ au_in_ep0(endpoint, ep);
++ break;
++ case USB_ENDPOINT_BULK:
++ case USB_ENDPOINT_INTERRUPT:
++ au_start_in_bulk(epn, endpoint, ep);
++ break;
++ case USB_ENDPOINT_ISOCHRONOUS:
++ au_start_in_iso(epn, endpoint, ep);
++ break;
++ }
++ au_epn_interrupt_enable(epn);
++}
++
++/* au_start_endpoint_out - start receive
++ */
++void au_start_endpoint_out(struct pcd_instance *pcd, struct usbd_endpoint_instance *endpoint)
++{
++ int epn = epl2p[endpoint->bEndpointAddress&0xf];
++ struct ep_regs *ep = &ep_regs[epn];
++ switch(endpoint->bmAttributes & USB_ENDPOINT_MASK) {
++ case USB_ENDPOINT_CONTROL:
++ break;
++ case USB_ENDPOINT_BULK:
++ case USB_ENDPOINT_INTERRUPT:
++ au_start_out_bulk(epn, endpoint, ep);
++ au_epn_interrupt_enable(epn);
++ break;
++ case USB_ENDPOINT_ISOCHRONOUS:
++ au_start_out_iso(epn, endpoint, ep);
++ break;
++ }
++}
++
++/*
++ * au_pcd_endpoint_halted() - is endpoint halted
++ */
++static int
++au_pcd_endpoint_halted (struct pcd_instance *pcd, struct usbd_endpoint_instance *endpoint)
++{
++int cs;
++ int epn = epl2p[endpoint->bEndpointAddress&0xf];
++ int dir = (endpoint->bEndpointAddress & 0x80) ? 1 : 0;
++ struct ep_regs *ep = &ep_regs[epn];
++
++ TRACE_MSG2(PCD, "epn: %02x dir: %x", epn, dir);
++ return ((cs = au_readl(ep->cs)) & USBDEV_CS_STALL) ? TRUE : FALSE;
++}
++
++/* au_pcd_halt_endpoint - halt endpoint
++ */
++int au_pcd_halt_endpoint(struct pcd_instance *pcd, struct usbd_endpoint_instance *endpoint, int flag)
++{
++ int epn = epl2p[endpoint->bEndpointAddress&0xf];
++ int dir = (endpoint->bEndpointAddress & 0x80) ? 1 : 0;
++ struct ep_regs *ep = &ep_regs[epn];
++
++ TRACE_MSG3(PCD, "epn: %02x dir: %x flag: %d", epn, dir, flag);
++
++ au_writel(au_readl(ep->cs) & USBDEV_CS_STALL, ep->cs);
++ return 0;
++}
++
++
++
++void au_cancel_in_irq(struct pcd_instance *pcd, struct usbd_urb *urb)
++{
++ int epn = epl2p[urb->endpoint->bEndpointAddress&0xf];
++ struct ep_regs *ep = &ep_regs[epn];
++ au_in_bulk(epn, ep, urb->endpoint);
++}
++
++void au_cancel_out_irq(struct pcd_instance *pcd, struct usbd_urb *urb)
++{
++ int epn = epl2p[urb->endpoint->bEndpointAddress&0xf];
++ struct ep_regs *ep = &ep_regs[epn];
++ au_out_bulk(epn, ep, urb->endpoint);
++}
++
++/* au_serial_init - set a serial number if available
++ */
++int au_serial_init (struct pcd_instance *pcd)
++{
++#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 au_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);
++ pcd_instance->bus->serial_number_str = lstrdup(chData);
++ return 0;
++#else
++ return -EINVAL;
++#endif
++}
++
++
++/* au_start - start session
++ */
++void au_start (struct pcd_instance *pcd)
++{
++ au_inten(0x0033/*|USBDEV_INT_SOF*/, "START"); // Only enable receive interrupts.
++}
++
++/* au_stop - stop session
++ */
++void au_stop (struct pcd_instance *pcd)
++{
++ //au_inten(0, "STOP");
++}
++
++int au_assign_endpoint( u8 physicalEndpoint, int used[6], struct usbd_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 au_request_endpoints(struct pcd_instance *pcd, struct usbd_endpoint_map *endpoint_map_array, int endpointsRequested,
++ struct usbd_endpoint_request *requestedEndpoints)
++{
++ struct usbd_device_description *device_description;
++ int i, j;
++ int used[UDC_MAX_ENDPOINTS];
++ memset(used, 0, sizeof(used));
++ for (j = 0, i = 0; i < endpointsRequested; i++, j++) {
++ struct usbd_endpoint_map *endpoint_map = endpoint_map_array + i;
++ u8 bmAttributes = requestedEndpoints[i].bmAttributes;
++ u16 transferSize = requestedEndpoints[i].fs_requestedTransferSize;
++ RETURN_EINVAL_UNLESS(j < UDC_MAX_ENDPOINTS);
++ 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(!au_assign_endpoint(4, used, endpoint_map, bmAttributes, 0x40, transferSize));
++ CONTINUE_IF(!au_assign_endpoint(5, used, endpoint_map, bmAttributes, 0x40, transferSize));
++ break;
++ case USB_DIR_OUT | USB_ENDPOINT_ISOCHRONOUS:
++ CONTINUE_IF(!au_assign_endpoint(4, used, endpoint_map, bmAttributes, transferSize, transferSize));
++ CONTINUE_IF(!au_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(!au_assign_endpoint(2, used, endpoint_map, bmAttributes, 0x40, transferSize));
++ CONTINUE_IF(!au_assign_endpoint(3, used, endpoint_map, bmAttributes, 0x40, transferSize));
++ break;
++ case USB_DIR_IN | USB_ENDPOINT_ISOCHRONOUS:
++ CONTINUE_IF(!au_assign_endpoint(2, used, endpoint_map, bmAttributes, transferSize, transferSize));
++ CONTINUE_IF(!au_assign_endpoint(3, used, endpoint_map, bmAttributes, transferSize, transferSize));
++ break;
++ }
++ CONTINUE_IF(bmAttributes & USB_ENDPOINT_OPT);
++ return -EINVAL;
++ }
++ return 0;
++}
++
++struct usbd_endpoint_map *au_endpoint_map_array;
++int au_endpointsRequested;
++
++int au_set_endpoints2(struct pcd_instance *pcd, int endpointsRequested, struct usbd_endpoint_map *endpoint_map_array);
++int au_set_endpoints(struct pcd_instance *pcd, int endpointsRequested, struct usbd_endpoint_map *endpoint_map_array)
++{
++ au_endpointsRequested = endpointsRequested;
++ au_endpoint_map_array = endpoint_map_array;
++ return au_set_endpoints2(pcd, au_endpointsRequested, au_endpoint_map_array);
++}
++
++int au_set_endpoints2(struct pcd_instance *pcd, int endpointsRequested, struct usbd_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 usbd_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;
++ }
++ TRACE_MSG0(PCD, "Disable interrupts");
++ au_inten(0, "SET ENDPOINTS"); // 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;
++}
++
++/* au_loc_conn - used to enable or disable peripheral connecting to bus
++ *
++ */
++void au_loc_conn(struct otg_instance *otg, u8 flag)
++{
++ struct pcd_instance *pcd = (struct pcd_instance *)otg->pcd;
++ TRACE_MSG0(PCD, "--");
++ TRACE_MSG1(PCD, "PCD: %x", (int)pcd);
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(PCD, "OUTPUT: OCD_LOC_CONN_SET - Enable DP PULLUP");
++ au_set_endpoints2(pcd, au_endpointsRequested, au_endpoint_map_array);
++ au_inten(0x0033/*|USBDEV_INT_SOF*/, "START"); // Only enable receive interrupts.
++ au_connect(pcd);
++ break;
++
++ case RESET:
++ TRACE_MSG0(PCD, "OUTPUT: OCD_LOC_CONN_RESET - Disable DP PULLUP");
++ au_disconnect(pcd);
++ au_inten(0, "RESET ENDPOINTS"); // disable interrupts
++ au_writel(0x0000, USBD_ENABLE); // reset controller
++ break;
++ }
++}
++
++
++/* ********************************************************************************************* */
++
++
++static u32 request_dma(int ep, int src, int dest, char *str, void dma_done(int , void *, struct pt_regs *))
++{
++ u32 dma;
++
++ chan_tab_t *ctp;
++ volatile au1x_dma_chan_t *cp;
++ au1x_ddma_desc_t *dp;
++
++
++ if ((dma = au1xxx_dbdma_chan_alloc(src, dest, dma_done, (void *)ep)) < 0) {
++ printk(KERN_INFO"request_io[%d] dma: %x src: %d dest: %d %s FAILED\n", ep, dma, src, dest, str);
++ return -1;
++ }
++
++ if(au1xxx_dbdma_ring_alloc(dma, 1) == 0) {
++ printk(KERN_INFO"request_io[%d] Ring Buffer Allocation for dma: %x src: %d dest: %d %s FAILED\n",
++ ep, dma, src, dest, str);
++ return -1;
++ }
++
++ ctp = *((chan_tab_t **)dma);
++ cp = ctp->chan_ptr;;
++ dp = ctp->put_ptr;
++ dp->dscr_cmd0 &= ~DSCR_CMD0_V;
++
++ TRACE_MSG8(PCD, "%08x %08x cmd: %08x %04x src: %08x %04x dst: %08x %08x DBDMA",
++ dma, dp, dp->dscr_cmd0, dp->dscr_cmd1,
++ dp->dscr_source0, dp->dscr_source1, dp->dscr_dest0, dp->dscr_dest1);
++
++#if 0
++ // XXX copy static components from au_start_out
++ // transmit - mem to usb
++ if (src == DBDMA_MEM_CHAN) {
++ TRACE_MSG8(PCD, "%08x %08x cmd: %08x %04x src: %08x %04x dst: %08x %08x MEM2USB",
++ dma, dp, dp->dscr_cmd0, dp->dscr_cmd1,
++ dp->dscr_source0, dp->dscr_source1, dp->dscr_dest0, dp->dscr_dest1);
++ }
++#endif
++#if 0
++ // XXX copy static components from au_start_in
++ // receive - usb to mem
++ if (dest == DBDMA_MEM_CHAN) {
++ TRACE_MSG8(PCD, "%08x %08x cmd: %08x %04x src: %08x %08x dst: %08x %08x USB2MEM",
++ dma, dp, dp->dscr_cmd0, dp->dscr_cmd1,
++ dp->dscr_source0, dp->dscr_source1, dp->dscr_dest0, dp->dscr_dest1);
++ }
++#endif
++ TRACE_MSG5(PCD, "request_io[%d] dma: %x src: %d dest: %d %s SUCCEDED", ep, dma, src, dest, str);
++ return dma;
++}
++
++/* au_mod_init
++ */
++int au_mod_init (void)
++{
++ int dev = request_irq (AU1000_USB_DEV_REQ_INT, au_int_req, SA_INTERRUPT, UDC_NAME "UDC Req", NULL);
++ int sus = request_irq (AU1000_USB_DEV_SUS_INT, au_int_sus, SA_INTERRUPT, UDC_NAME "UDC Sus", NULL);
++ u32 cp0_prid = read_c0_prid();
++ int i;
++
++
++ if (dev || sus) { // check if either request irq failed
++ if (!dev) free_irq (AU1000_USB_DEV_REQ_INT, NULL); // free irqs that might have
++ if (!sus) free_irq (AU1000_USB_DEV_SUS_INT, NULL); // been successfully allocated
++ return -EINVAL;
++ }
++ for (i = 0; i < 6; i++) {
++ ep_regs[i].indma = ep_regs[i].tx_id ?
++ request_dma(i, DBDMA_MEM_CHAN, ep_regs[i].tx_id, ep_regs[i].tx_str, au_tx_dma_done) : -1;
++ ep_regs[i].outdma = ep_regs[i].rx_id ?
++ request_dma(i, ep_regs[i].rx_id, DBDMA_MEM_CHAN, ep_regs[i].rx_str, NULL) : -1;
++ }
++ switch (cp0_prid & CP0_PRID_SOC_MASK) {
++ case CP0_PRID_AU1000:
++ case CP0_PRID_AU1100:
++ case CP0_PRID_AU1500:
++ return -EINVAL;
++ case CP0_PRID_AU1550:
++ TRACE_MSG1(PCD, "AU1550 cp0_prid: %08x\n", cp0_prid);
++ printk(KERN_INFO"%s: AU1550 cp0_prid: %08x\n", __FUNCTION__, cp0_prid);
++ break;
++ default:
++ printk(KERN_INFO"%s: UNKNOWN CPU cp0_prid: %08x UNKNOWN UDC\n", __FUNCTION__, cp0_prid);
++ break;
++ }
++ return 0;
++}
++
++/* au_mod_exit
++ */
++void au_mod_exit (void)
++{
++ int j;
++ au_writel(0x0000, USBD_ENABLE);
++ for (j = 0; j < 6; j++) {
++ struct ep_regs *ep = &ep_regs[j];
++ if (ep->indma != -1) {
++ au1xxx_dbdma_chan_free(ep->indma);
++ ep->indma = -1;
++ }
++ if (ep->outdma != -1) {
++ au1xxx_dbdma_chan_free(ep->outdma);
++ ep->outdma = -1;
++ }
++ }
++ 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
++}
++
++/* ********************************************************************************************* */
++struct usbd_pcd_ops usbd_pcd_ops = {
++ max_endpoints: UDC_MAX_ENDPOINTS,
++ ep0_packetsize: EP0_PACKETSIZE,
++ name: UDC_NAME,
++ start: au_start,
++ stop: au_stop,
++ start_endpoint_in: au_start_endpoint_in,
++ start_endpoint_out: au_start_endpoint_out,
++ request_endpoints: au_request_endpoints,
++ set_endpoints: au_set_endpoints,
++ cancel_in_irq: au_cancel_in_irq,
++ cancel_out_irq: au_cancel_out_irq,
++ serial_init: au_serial_init,
++ halt_endpoint: au_pcd_halt_endpoint,
++ endpoint_halted: au_pcd_endpoint_halted,
++};
++
++struct pcd_ops pcd_ops = {
++ pcd_en_func: pcd_en_func,
++ mod_init: au_mod_init,
++ mod_exit: au_mod_exit,
++ framenum: au_framenum,
++};
++
++struct ocd_ops ocd_ops = {
++ #if defined(CONFIG_OTG_TR_AUTO)
++ capabilities: OCD_CAPABILITIES_TR | OCD_CAPABILITIES_AUTO,
++ #else
++ capabilities: OCD_CAPABILITIES_TR,
++ #endif
++ ticks: au_ticks,
++ elapsed: au_elapsed,
++};
++
++struct tcd_ops tcd_ops = {
++ dp_pullup_func: au_loc_conn,
++};
++
+diff -uNr linux/drivers/no-otg/ocd/au1x00/au1x00.c linux/drivers/otg/ocd/au1x00/au1x00.c
+--- linux/drivers/no-otg/ocd/au1x00/au1x00.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/au1x00/au1x00.c 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,1293 @@
++/*
++ * otg/ocd/au1x00/au1x00.c -- USB Device Controller driver.
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ *
++ */
++/*!
++ * @file otg/ocd/au1x00/au1x00.c
++ * @brief AU1X00 Header
++ *
++ * This file contains the private defines and structures for the AU1X00
++ * Drivers.
++ *
++ * @ingroup AU1X00
++ */
++
++
++#include <otg/pcd-include.h>
++#include "au1x00.h"
++
++#include <asm/io.h>
++#include <asm/au1000.h>
++#include <asm/au1000_dma.h>
++
++#if defined(CONFIG_SOC_AU1550)
++#define DBDMA
++#endif
++#ifdef DBDMA
++#warning "Using AU1XXX_DBMDA"
++#include <asm/au1xxx_dbdma.h>
++#else /* DBDMA */
++#warning "Using AU1X00_MDA"
++#endif /* DBDMA */
++
++#include <asm/mipsregs.h>
++
++
++#ifdef CONFIG_MIPS_FREEHAND
++#include <linux/i2c.h>
++#include <linux/sensors.h> /* for reading serial number */
++#endif
++
++
++#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_saw_bus_activity;
++int au_halt_dma_expired;
++u32 au1x00_new_silicon;
++u32 au1x00_inten;
++
++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
++ */
++#ifdef DBDMA
++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: DSCR_CMD0_USBDEV_TX0, tx_str: "EP0 IN WR",},
++
++ { rds: 0, wrs: 0, indma: -1, outdma: -1, },
++ { wr: NUSBD_EP1WR, wrs: NUSBD_EP1WRSTAT, tx_id: DSCR_CMD0_USBDEV_TX1, cs: NUSBD_EP1CS, tx_str: "EP1 IN WR",},
++ { wr: NUSBD_EP2WR, wrs: NUSBD_EP2WRSTAT, tx_id: DSCR_CMD0_USBDEV_TX2, cs: NUSBD_EP2CS, tx_str: "EP2 IN WR",},
++
++ { rd: NUSBD_EP3RD, rds: NUSBD_EP3RDSTAT, rx_id: DSCR_CMD0_USBDEV_RX3, cs: NUSBD_EP3CS, rx_str: "EP3 OUT RD",},
++ { rd: NUSBD_EP4RD, rds: NUSBD_EP4RDSTAT, rx_id: DSCR_CMD0_USBDEV_RX4, cs: NUSBD_EP4CS, rx_str: "EP4 OUT RD",},
++};
++#else /*DBMA */
++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",},
++};
++#endif /*DBMA */
++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__ au_epn_interrupt_enable(int epn)
++{
++ au_inten(au1x00_inten | (1 << epn));
++}
++
++void __inline__ au_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
++#ifdef DBDMA
++static void __inline__ au_halt_dma(int chan)
++{
++ au1xxx_dbdma_stop(chan);
++ au_halt_dma_expired++;
++}
++
++static int __inline__ au_get_dma_residue(int chan)
++{
++ return au1xxx_get_dma_residue(chan);
++}
++
++static void __inline__ au_start_dma_in(int indma, __u8 *bp, int len)
++{
++ //printk("\n----------------------STARTING DMA IN dma:%X buffer:%p len:%d---------------\n", indma, bp, len);
++ // au1xxx_dbdma_stop(indma);
++ au1xxx_dbdma_put_source(indma, bp, len);
++ au1xxx_dbdma_start(indma);
++}
++
++static void __inline__ au_start_dma_out(unsigned int outdma, __u8 *bp, int packetSize)
++{
++ //printk("\n----------------------STARTING DMA OUT dma:%X buffer:%p len:%d---------------\n", outdma, bp, packetSize);
++ au1xxx_dbdma_put_dest(outdma, bp, packetSize);
++ au1xxx_dbdma_start(outdma);
++}
++
++static u32 __inline__ au_get_dma_chan(u32 dma)
++{
++ return dma;
++}
++#else /* DBDMA */
++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 __inline__ struct dma_chan * au_get_dma_chan(u32 dma)
++{
++ return get_dma_chan(dma);
++}
++#endif /* DBDMA */
++static struct usbd_urb *au_rcv_complete_irq(struct usbd_endpoint_instance *endpoint, int len, int urb_bad)
++{
++ return pcd_rcv_complete_irq(endpoint, len, urb_bad);
++}
++/* ********************************************************************************************* */
++/* au_start_in_ep0 - start transmit
++ */
++static void au_start_in_ep0 (struct usbd_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ struct usbd_urb *urb = endpoint->tx_urb;
++ int last = ep->last = endpoint->last = MIN (urb->actual_length - endpoint->sent, endpoint->wMaxPacketSize);
++ TRACE_MSG2(PCD, "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 usbd_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ u32 cs;
++ struct usbd_urb *tx_urb;
++ int last;
++ TRACE_MSG1(PCD, "EP0 IN: tx_urb: %p", (int)endpoint->tx_urb);
++ if ((cs = au_readl(ep->cs)) & USBDEV_CS_STALL) { // clear stall if present
++ TRACE_MSG1(PCD, "CLEAR STALL %d", 0);
++ cs &= ~USBDEV_CS_STALL;
++ au_writel(cs, ep->cs);
++ return;
++ }
++ if (!(tx_urb = pcd_tx_complete_irq(endpoint, 0))) { // wait for setup if no more data
++ endpoint->state = WAIT_FOR_SETUP;
++ return;
++ }
++ TRACE_MSG4(PCD, "EP0 IN actual: %d last: %d sent: %d flags: %x", endpoint->tx_urb->actual_length,
++ endpoint->last, endpoint->sent, endpoint->tx_urb->flags);
++ if (pcd_tx_sendzlp(endpoint)) { // check if tx_urb we have is finished
++ TRACE_MSG0(PCD, "EP0 IN BULK - sending ZLP");
++ tx_urb->flags &= ~USBD_URB_SENDZLP;
++ send_zlp(0);
++ pcd_tx_complete_irq(endpoint, 0);
++ return;
++ }
++ if (tx_urb->actual_length > endpoint->sent) {
++ if ((tx_urb->actual_length - endpoint->sent) < endpoint->wMaxPacketSize)
++ TRACE_MSG1(PCD, "EP0 IN starting short packet %d", tx_urb->actual_length - endpoint->sent);
++ else
++ TRACE_MSG1(PCD, "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 usbd_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ struct usbd_device_request request;
++ int i;
++ u32 cs;
++ u32 bytes;
++ TRACE_MSG0(PCD, "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 usbd_urb *rcv_urb = pcd_rcv_next_irq(endpoint);
++ TRACE_MSG1(PCD, "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;
++ }
++ pcd_tx_cancelled_irq(endpoint);
++ pcd_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_MSG1(PCD, "ERROR SETUP SET not eight bytes: %d", bytes);
++ au_writel(USBDEV_FSTAT_FLUSH | USBDEV_FSTAT_UF | USBDEV_FSTAT_OF, ep->wrs);
++ return;
++ }
++ TRACE_MSG4(PCD, "SETUP bmRequestType: %02x bRequest %02x state: %d status: %d", request.bmRequestType,
++ request.bRequest, pcd_instance->bus->device_state, pcd_instance->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 (pcd_instance->bus->device_state == STATE_DEFAULT);
++ udc_saw_bus_activity = 0;
++ usbd_bus_event_handler_irq (pcd_instance->bus, DEVICE_RESET, 0);
++ usbd_bus_event_handler_irq (pcd_instance->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 != pcd_instance->bus->device_state);
++ udc_saw_bus_activity = 0;
++ usbd_bus_event_handler_irq (pcd_instance->bus, DEVICE_RESET, 0);
++ usbd_bus_event_handler_irq (pcd_instance->bus, DEVICE_ADDRESS_ASSIGNED, 0);
++ break;
++ }
++ if (pcd_recv_setup_irq(pcd_instance, &request)) {
++ TRACE_MSG1(PCD, "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_MSG1(PCD, "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_MSG1(PCD, "ep0 Class H2D request %04x", le16_to_cpu(request.wLength));
++ if ((request.bmRequestType & ~USB_REQ_DIRECTION_MASK)) {
++ TRACE_MSG1(PCD, "ep0 Class or Vendor, send ZLP %d", cs);
++ send_zlp(0);
++ return;
++ }
++ }
++ TRACE_MSG1(PCD, "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 usbd_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ struct usbd_urb *urb = endpoint->tx_urb;
++ unsigned char *bp = urb->buffer + endpoint->sent;
++ int last;
++ TRACE_MSG1(PCD, "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_MSG2(PCD, "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_MSG0(PCD, "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)
++ au_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_bulk(unsigned int epn, struct ep_regs *ep, struct usbd_endpoint_instance *endpoint)
++{
++ struct usbd_urb *tx_urb;
++ int rc = 0;
++ u32 cs = au_readl(ep->cs);
++ u32 wrs = au_readl(ep->wrs);
++ TRACE_MSG2(PCD, "BULK IN EPN - cs: %x wrs: %x", cs, wrs);
++ if (!au1x00_new_silicon)
++ if (epn && (ep->last > 8)) {
++ TRACE_MSG2(PCD, "BULK IN EPN - DMA ACTIVE epn %d last %d", epn, ep->last);
++ au_epn_interrupt_disable(epn);
++ return;
++ }
++ if (wrs) { // check for underflow or overflow
++ rc = 1;
++ if (wrs & USBDEV_FSTAT_UF) {
++ TRACE_MSG2(PCD, "BULK IN EPN - UF epn %d wrs: %x", epn, wrs);
++ rc = 1; // set rc to indicate an error
++ }
++ if (wrs & USBDEV_FSTAT_OF)
++ TRACE_MSG2(PCD, "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_MSG1(PCD, "BULK IN EPN - CLEAR STALL %d", epn);
++ cs &= ~USBDEV_CS_STALL;
++ au_writel(cs, ep->cs);
++ return;
++ }
++ TRACE_MSG4(PCD, "BULK IN EPN epn: %d rc: %d last: %d sent: %d", epn, rc, endpoint->last, endpoint->sent);
++ if ((tx_urb = pcd_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_MSG1(PCD, "BULK IN EPN - LEFT TO SEND %d", tx_urb->actual_length - endpoint->sent);
++ return;
++ }
++ }
++ au_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 usbd_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ struct usbd_urb *urb = endpoint->tx_urb;
++ unsigned char *bp = urb->buffer + endpoint->sent;
++ int last;
++ TRACE_MSG2(PCD, "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_MSG2(PCD, "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 ? au_epn_interrupt_enable : au_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 usbd_endpoint_instance *endpoint)
++{
++ struct usbd_urb *tx_urb = pcd_tx_complete_irq(endpoint, 0);
++ u32 cs = au_readl(ep->cs);
++ u32 wrs = au_readl(ep->wrs);
++ TRACE_MSG2(PCD, "ISO IN EPN - cs: %x wrs: %x", cs, wrs);
++ if (!au1x00_new_silicon)
++ if (epn && (ep->last > 8)) {
++ au_epn_interrupt_disable(epn);
++ return;
++ }
++ TRACE_MSG4(PCD, "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_MSG1(PCD, "ISO IN EPN - LEFT TO SEND %d", tx_urb->actual_length - endpoint->sent);
++ return;
++ }
++ else
++ TRACE_MSG0(PCD, "ISO IN EPN - nothing to send");
++ au_epn_interrupt_disable(epn); // disable interrupts
++}
++/* ********************************************************************************************* */
++
++static void au_start_out_bulk(unsigned int epn, struct usbd_endpoint_instance *endpoint, struct ep_regs *ep)
++{
++ TRACE_MSG2(PCD, "START OUT BULK %d %d", epn, endpoint->wMaxPacketSize);
++ if (!endpoint->rcv_urb) {
++ TRACE_MSG0(PCD, "START OUT BULK DISABLE");
++ au_epn_interrupt_disable(epn);
++ return;
++ }
++ if (endpoint->rcv_error) {
++ TRACE_MSG0(PCD, "START OUT BULK reseting rcv_error");
++ endpoint->rcv_error = 0;
++ }
++ au_start_dma_out(ep->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 usbd_endpoint_instance *endpoint)
++{
++ int bytes = 0;
++ struct usbd_urb *urb;
++ struct usbd_urb *completed_urb = NULL;
++ u32 cs;
++ u32 rds;
++ u32 nrds;
++ au_halt_dma(au_get_dma_chan(ep->outdma));
++ cs = au_readl(ep->cs);
++ rds = au_readl(ep->rds);
++ TRACE_MSG2(PCD, "BULK OUT CS: %04x RD: %04x", cs, rds);
++ bytes = endpoint->wMaxPacketSize - au_get_dma_residue(au_get_dma_chan(ep->outdma));
++ if (!(urb = pcd_rcv_next_irq(endpoint))) {
++ TRACE_MSG0(PCD, "BULK OUT EPN - no rcv_urb");
++ au_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_MSG2(PCD, "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_MSG2(PCD, "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_MSG4(PCD, "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_MSG4(PCD, "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_MSG4(PCD, "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_MSG4(PCD, "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_MSG2(PCD, "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_MSG4(PCD, "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_MSG2(PCD, "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_MSG4(PCD, "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_MSG4(PCD, "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_MSG4(PCD, "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_MSG1(PCD, "BULK OUT < 64 BYTES %d", bytes);
++ au_writel(USBDEV_FSTAT_FLUSH | USBDEV_FSTAT_UF | USBDEV_FSTAT_OF, ep->rds);
++ if (!endpoint->rcv_error) {
++ TRACE_MSG0(PCD, "BULK OUT COMPLETED URB");
++ au_rcv_complete_irq(endpoint, bytes, 0);
++ }
++ else {
++ TRACE_MSG0(PCD, "BULK OUT - FLUSHING URB - reseting rcv_error");
++ endpoint->rcv_error = 0;
++ }
++ }
++ CATCH(start_flushing) {
++ TRACE_MSG0(PCD, "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_MSG0(PCD, "BULK OUT - RESTARTING");
++ au_start_out_bulk(epn, endpoint, ep);
++}
++
++static void au_start_out_iso(unsigned int epn, struct usbd_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 usbd_endpoint_instance *endpoint)
++{
++ int bytes = 0;
++ struct usbd_urb *urb;
++ u32 cs;
++ u32 rds;
++ au_halt_dma(au_get_dma_chan(ep->outdma));
++ 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_MSG2(PCD, "ISO OUT EPN - rcv_urb was NULL bytes: %d rds: %d", bytes, rds);
++ au_rcv_complete_irq(endpoint, bytes, 1);
++ TRACE_MSG0(PCD, "ISO OUT setting rcv_error");
++ }
++ bytes = endpoint->wMaxPacketSize - au_get_dma_residue(au_get_dma_chan(ep->outdma));
++ 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);
++}
++/* ********************************************************************************************* */
++/* au_tx_dma_done - TX DMA interrupt handler
++ */
++static void au_tx_dma_done(int irq, void *dev_id, struct pt_regs *regs)
++{
++ int epn = (int) dev_id;
++ struct usbd_endpoint_instance *endpoint = pcd_instance->bus->endpoint_array + epn;
++ struct ep_regs *ep = &ep_regs[epn];
++ int residue;
++#if 0
++ int indma = irq - 6;
++ struct dma_chan *chan = get_dma_chan(indma);
++#endif
++#ifdef DBDMA
++#else /* DBDMA */
++ struct dma_chan *chan = get_dma_chan(ep->indma);
++ u32 mode = au_readl(chan->io + DMA_MODE_READ);
++ TRACE_MSG1(PCD, "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);
++#endif /* DBDMA */
++ ocd_ops.interrupts++;
++ RETURN_IF (!epn);
++ au_halt_dma(au_get_dma_chan(ep->indma));
++ residue = au_get_dma_residue(au_get_dma_chan(ep->indma));
++ TRACE_MSG2(PCD, "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);
++ pcd_tx_complete_irq (endpoint, residue?1:0);
++ au_epn_interrupt_enable(epl2p[endpoint->bEndpointAddress&0xf]);
++ }
++ ep->last = 0;
++}
++
++/* au_int_req - usb interrupt handler
++ */
++static void au_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
++ ocd_ops.interrupts++;
++#if 0
++ if (ocd_ops.interrupts > 2000) {
++ TRACE_MSG0(PCD, "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_MSG2(PCD, "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_handler_irq (pcd_instance->bus, DEVICE_BUS_ACTIVITY, 0);
++ au_inten(0x0033|USBDEV_INT_SOF);
++ }
++ ep = &ep_regs[epn];
++ switch(ep->eptype) {
++ case USB_DIR_IN | USB_ENDPOINT_BULK:
++ case USB_DIR_IN | USB_ENDPOINT_INTERRUPT:
++ //TRACE_MSG2(PCD, "BULK IN %d %02x", epn, ep->eptype);
++ au_in_bulk(epn, ep, pcd_instance->bus->endpoint_array + epn);
++ break;
++ case USB_DIR_IN | USB_ENDPOINT_ISOCHRONOUS:
++ //TRACE_MSG2(PCD, "ISO IN %d %02x", epn, ep->eptype);
++ au_in_iso(epn, ep, pcd_instance->bus->endpoint_array + epn);
++ break;
++ case USB_DIR_OUT | USB_ENDPOINT_BULK:
++ case USB_DIR_OUT | USB_ENDPOINT_INTERRUPT:
++ //TRACE_MSG2(PCD, "BULK OUT %d %02x", epn, ep->eptype);
++ au_out_bulk(epn, ep, pcd_instance->bus->endpoint_array + epn);
++ break;
++ case USB_DIR_OUT | USB_ENDPOINT_ISOCHRONOUS:
++ //TRACE_MSG2(PCD, "ISO OUT %d %04d", epn, au_readl(NUSBD_FRAMENUM));
++ au_out_iso(epn, ep, pcd_instance->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(pcd_instance->bus->endpoint_array + 0, &ep_regs[0]);
++ if (intstat & (1 << 1))
++ au_in_ep0(pcd_instance->bus->endpoint_array + 0, &ep_regs[0]);
++ if (intstat & USBDEV_INT_SOF)
++ if (USBD_SUSPENDED == pcd_instance->bus->status) {
++ TRACE_MSG0(PCD, "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_MSG1(PCD, "USB IRQ - %d", read_c0_count(CP0_COUNT) - cp0_count);
++#endif
++#if defined(RECORD_LATENCY)
++ cp0_record = read_c0_count(CP0_COUNT);
++#endif
++}
++
++/* au_int_sus -suspend interrupt handler
++ */
++static void au_int_sus (int irq, void *dev_id, struct pt_regs *regs)
++{
++ ocd_ops.interrupts++;
++ TRACE_MSG2(PCD, "SUS - INACTIVE device: %d status: %d", pcd_instance->bus->device_state, pcd_instance->bus->status);
++ switch(pcd_instance->bus->status) {
++ case USBD_OPENING:
++ case USBD_OK:
++ au_inten(0x0033);
++ usbd_bus_event_handler_irq (pcd_instance->bus, DEVICE_BUS_INACTIVE, 0);
++ break;
++ default:
++ break;
++ }
++}
++/* ********************************************************************************************* */
++/*
++ * au_connect - enable pullup resistor
++ * Turn on the USB connection by enabling the pullup resistor.
++ *
++ * au_disconnect - disable pullup resistor
++ * Turn off the USB connection by disabling the pullup resistor.
++ */
++
++#if defined(CONFIG_MIPS_PICOENGINE_MVCI)
++void au_connect (struct pcd_instance *pcd)
++{
++ extern void pico_mvci_set_usb_pullup(int);
++ pico_mvci_set_usb_pullup(1);
++}
++
++void au_disconnect (struct pcd_instance *pcd)
++{
++ extern void pico_mvci_set_usb_pullup(int);
++ pico_mvci_set_usb_pullup(0);
++}
++
++#elif defined(CONFIG_MIPS_FREEHAND_NATIVE)
++void au_connect (struct pcd_instance *pcd)
++{
++ au1000gpio_set(GPIO01);
++}
++
++void au_disconnect (struct pcd_instance *pcd)
++{
++ au1000gpio_clear(GPIO01);
++}
++#elif defined(CONFIG_AMX_MORDOR)
++void au_connect (struct pcd_instance *pcd)
++{
++ au_writel(0x00000008, SYS_OUTPUTSET);
++}
++
++void au_disconnect (struct pcd_instance *pcd)
++{
++ au_writel(0x00000008, SYS_OUTPUTCLR);
++}
++#else
++void au_connect (struct pcd_instance *pcd)
++{
++}
++void au_disconnect (struct pcd_instance *pcd)
++{
++}
++#endif
++
++#if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19)
++#undef read_c0_prid
++#define read_c0_prid() read_32bit_cp0_register(CP0_PRID)
++#endif
++#undef read_c0_COUNT
++#ifndef read_c0_count
++#define read_c0_count() read_32bit_cp0_register(CP0_COUNT)
++#endif
++/* au_loc_conn - used to enable or disable peripheral connecting to bus
++ *
++ */
++void au_loc_conn(struct otg_instance *otg, u8 flag)
++{
++ struct pcd_instance *pcd = (struct pcd_instance *)otg->pcd;
++ TRACE_MSG0(PCD, "--");
++ TRACE_MSG1(PCD, "PCD: %x", (int)pcd);
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(PCD, "OUTPUT: OCD_LOC_CONN_SET");
++ TRACE_MSG0(PCD, "OUTPUT: OCD_LOC_CONN_RESET - Enable DP PULLUP");
++ au_connect(pcd);
++ break;
++
++ case RESET:
++ TRACE_MSG0(PCD, "OUTPUT: OCD_LOC_CONN_RESET");
++ TRACE_MSG0(PCD, "OUTPUT: OCD_LOC_CONN_RESET - Disable DP PULLUP");
++ au_disconnect(pcd);
++ break;
++
++ case PULSE:
++ TRACE_MSG0(PCD, "OUTPUT: OCD_LOC_CONN_PULSE");
++ break;
++ }
++}
++
++/* ********************************************************************************************* */
++/* au_ticks - get current ticks
++* */
++u64 au_ticks (void)
++{
++ return read_c0_count();
++}
++
++/* au_elapsed - return micro-seconds between two tick values
++ */
++u64 au_elapsed(u64 *t1, u64 *t2)
++{
++ u64 ticks = (*t1 > *t2) ? (*t1 - *t2) : (*t2 - *t1);
++ ticks = (u32)((u32) ticks / (u32) CONFIG_OTG_AU1X00_SCLOCK);
++ return ticks;
++}
++
++/* au_framenum - get current framenum
++ */
++u16 au_framenum (void)
++{
++ return au_readl(NUSBD_FRAMENUM);
++}
++
++
++/* ********************************************************************************************* */
++/* au_start_endpoint_in - start transmit
++ */
++void au_start_endpoint_in(struct pcd_instance *pcd, struct usbd_endpoint_instance *endpoint)
++{
++ int epn = epl2p[endpoint->bEndpointAddress&0xf];
++ struct ep_regs *ep = &ep_regs[epn];
++ switch(endpoint->bmAttributes & USB_ENDPOINT_MASK) {
++ case USB_ENDPOINT_CONTROL:
++ au_in_ep0(endpoint, ep);
++ break;
++ case USB_ENDPOINT_BULK:
++ case USB_ENDPOINT_INTERRUPT:
++ au_start_in_bulk(epn, endpoint, ep);
++ break;
++ case USB_ENDPOINT_ISOCHRONOUS:
++ au_start_in_iso(epn, endpoint, ep);
++ break;
++ }
++ if (au1x00_new_silicon)
++ au_epn_interrupt_enable(epn);
++}
++
++/* au_start_endpoint_out - start receive
++ */
++void au_start_endpoint_out(struct pcd_instance *pcd, struct usbd_endpoint_instance *endpoint)
++{
++ int epn = epl2p[endpoint->bEndpointAddress&0xf];
++ struct ep_regs *ep = &ep_regs[epn];
++ switch(endpoint->bmAttributes & USB_ENDPOINT_MASK) {
++ case USB_ENDPOINT_CONTROL:
++ break;
++ case USB_ENDPOINT_BULK:
++ case USB_ENDPOINT_INTERRUPT:
++ au_start_out_bulk(epn, endpoint, ep);
++ au_epn_interrupt_enable(epn);
++ break;
++ case USB_ENDPOINT_ISOCHRONOUS:
++ au_start_out_iso(epn, endpoint, ep);
++ break;
++ }
++}
++
++void au_cancel_in_irq(struct pcd_instance *pcd, struct usbd_urb *urb)
++{
++ int epn = epl2p[urb->endpoint->bEndpointAddress&0xf];
++ struct ep_regs *ep = &ep_regs[epn];
++ au_in_bulk(epn, ep, urb->endpoint);
++}
++
++void au_cancel_out_irq(struct pcd_instance *pcd, struct usbd_urb *urb)
++{
++ int epn = epl2p[urb->endpoint->bEndpointAddress&0xf];
++ struct ep_regs *ep = &ep_regs[epn];
++ au_out_bulk(epn, ep, urb->endpoint);
++}
++
++/* au_serial_init - set a serial number if available
++ */
++int au_serial_init (struct pcd_instance *pcd)
++{
++#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 au_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);
++ pcd_instance->bus->serial_number_str = lstrdup(chData);
++ return 0;
++#else
++ return -EINVAL;
++#endif
++}
++
++
++#ifdef DBDMA
++static int request_dma(int ep, int src, int dest, char *str, void dma_done(int , void *, struct pt_regs *))
++{
++ unsigned int dma;
++
++ if ((dma = au1xxx_dbdma_chan_alloc(src, dest, dma_done, (void *)ep)) < 0) {
++ printk(KERN_INFO"request_io[%d] dma: %X src: %x dest: %x %s FAILED\n", ep, dma, src, dest, str);
++ return -1;
++ }
++
++ au1xxx_dbdma_set_devwidth(dma, 16);
++
++ if(au1xxx_dbdma_ring_alloc(dma, 4) == 0) {
++ printk(KERN_INFO"Ring Buffer Allocation for dma: %X src: %x dest: %x %s FAILED\n", ep, dma, src, dest, str);
++ return -1;
++ }
++ printk(KERN_INFO"request_io[%d] dma: %X src: %x dest: %x %s SUCCEDED\n", ep, dma, src, dest, str);
++ return dma;
++}
++#else /* DBDMA */
++static int request_dma(int ep, int id, char *str, void dma_done(int , void *, struct pt_regs *))
++{
++ int dma = request_au1000_dma(id, str, dma_done, SA_INTERRUPT, (void *)ep);
++ if (dma >= 0) return dma;
++ printk(KERN_INFO"request_io[%d] dma: %d id: %x %s FAILED\n", ep, dma, id, str);
++ return -1;
++}
++#endif /* DBDMA */
++
++/* au_start - start session
++ */
++void au_start (struct pcd_instance *pcd)
++{
++ au_inten(0x0033|USBDEV_INT_SOF); // Only enable receive interrupts.
++}
++
++/* au_stop - stop session
++ */
++void au_stop (struct pcd_instance *pcd)
++{
++ au_inten(0);
++}
++
++int au_assign_endpoint( u8 physicalEndpoint, int used[6], struct usbd_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 au_request_endpoints(struct pcd_instance *pcd, struct usbd_endpoint_map *endpoint_map_array, int endpointsRequested,
++ struct usbd_endpoint_request *requestedEndpoints)
++{
++ struct usbd_device_description *device_description;
++ int i, j;
++ int used[UDC_MAX_ENDPOINTS];
++ memset(used, 0, sizeof(used));
++ for (j = 0, i = 0; i < endpointsRequested; i++, j++) {
++ struct usbd_endpoint_map *endpoint_map = endpoint_map_array + i;
++ u8 bmAttributes = requestedEndpoints[i].bmAttributes;
++ u16 transferSize = requestedEndpoints[i].fs_requestedTransferSize;
++ RETURN_EINVAL_UNLESS(j < UDC_MAX_ENDPOINTS);
++ 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(!au_assign_endpoint(4, used, endpoint_map, bmAttributes, 0x40, transferSize));
++ CONTINUE_IF(!au_assign_endpoint(5, used, endpoint_map, bmAttributes, 0x40, transferSize));
++ break;
++ case USB_DIR_OUT | USB_ENDPOINT_ISOCHRONOUS:
++ CONTINUE_IF(!au_assign_endpoint(4, used, endpoint_map, bmAttributes, transferSize, transferSize));
++ CONTINUE_IF(!au_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(!au_assign_endpoint(2, used, endpoint_map, bmAttributes, 0x40, transferSize));
++ CONTINUE_IF(!au_assign_endpoint(3, used, endpoint_map, bmAttributes, 0x40, transferSize));
++ break;
++ case USB_DIR_IN | USB_ENDPOINT_ISOCHRONOUS:
++ CONTINUE_IF(!au_assign_endpoint(2, used, endpoint_map, bmAttributes, transferSize, transferSize));
++ CONTINUE_IF(!au_assign_endpoint(3, used, endpoint_map, bmAttributes, transferSize, transferSize));
++ break;
++ }
++ CONTINUE_IF(bmAttributes & USB_ENDPOINT_OPT);
++ return -EINVAL;
++ }
++ return 0;
++}
++
++int au_set_endpoints(struct pcd_instance *pcd, int endpointsRequested, struct usbd_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 usbd_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;
++}
++/* ********************************************************************************************* */
++/* au_mod_init
++ */
++int au_mod_init (void)
++{
++ int dev = request_irq (AU1000_USB_DEV_REQ_INT, au_int_req, SA_INTERRUPT, UDC_NAME "UDC Req", NULL);
++ int sus = request_irq (AU1000_USB_DEV_SUS_INT, au_int_sus, SA_INTERRUPT, UDC_NAME "UDC Sus", NULL);
++ u32 cp0_prid = read_c0_prid();
++ int i;
++
++
++ if (dev || sus) { // check if either request irq failed
++ if (!dev) free_irq (AU1000_USB_DEV_REQ_INT, NULL); // free irqs that might have
++ if (!sus) free_irq (AU1000_USB_DEV_SUS_INT, NULL); // been successfully allocated
++ return -EINVAL;
++ }
++#ifdef DBDMA
++ for (i = 0; i < 6; i++) {
++ ep_regs[i].indma = ep_regs[i].tx_id ?
++ request_dma(i, DBDMA_MEM_CHAN, ep_regs[i].tx_id, ep_regs[i].tx_str, au_tx_dma_done) : -1;
++ ep_regs[i].outdma = ep_regs[i].rx_id ?
++ request_dma(i, ep_regs[i].rx_id, DBDMA_MEM_CHAN, ep_regs[i].rx_str, NULL) : -1;
++ }
++#else /*DBMA */
++ 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, au_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;
++ }
++#endif /*DBMA */
++ 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;
++ case CP0_PRID_AU1550:
++ au1x00_new_silicon = (cp0_prid & CP0_PRID_REV_MASK) >= 0;
++ printk(KERN_INFO"%s: AU1550 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);
++ break;
++ }
++ return 0;
++}
++
++/* au_mod_exit
++ */
++void au_mod_exit (void)
++{
++ int j;
++ au_writel(0x0000, USBD_ENABLE);
++ for (j = 0; j < 6; j++) {
++ struct ep_regs *ep = &ep_regs[j];
++#ifdef DBDMA
++ if (ep->indma != -1) {
++ au1xxx_dbdma_chan_free(ep->indma);
++ ep->indma = -1;
++ }
++ if (ep->outdma != -1) {
++ au1xxx_dbdma_chan_free(ep->outdma);
++ ep->outdma = -1;
++ }
++#else /*DBMA */
++ if (ep->indma != -1) {
++ free_au1000_dma(ep->indma);
++ ep->indma = -1;
++ }
++ if (ep->outdma != -1) {
++ free_au1000_dma(ep->outdma);
++ ep->outdma = -1;
++ }
++#endif /*DBMA */
++ }
++ 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
++}
++
++/* ********************************************************************************************* */
++struct usbd_pcd_ops usbd_pcd_ops = {
++ max_endpoints: UDC_MAX_ENDPOINTS,
++ ep0_packetsize: EP0_PACKETSIZE,
++ name: UDC_NAME,
++ start: au_start,
++ stop: au_stop,
++ start_endpoint_in: au_start_endpoint_in,
++ start_endpoint_out: au_start_endpoint_out,
++ request_endpoints: au_request_endpoints,
++ set_endpoints: au_set_endpoints,
++ cancel_in_irq: au_cancel_in_irq,
++ cancel_out_irq: au_cancel_out_irq,
++ serial_init: au_serial_init,
++};
++
++struct pcd_ops pcd_ops = {
++ pcd_en_func: pcd_en_func,
++ mod_init: au_mod_init,
++ mod_exit: au_mod_exit,
++};
++
++struct ocd_ops ocd_ops = {
++ #if defined(CONFIG_OTG_TR_AUTO)
++ capabilities: OCD_CAPABILITIES_TR | OCD_CAPABILITIES_AUTO,
++ #else
++ capabilities: OCD_CAPABILITIES_TR,
++ #endif
++ ticks: au_ticks,
++ elapsed: au_elapsed,
++};
++
++struct tcd_ops tcd_ops = {
++ dp_pullup_func: au_loc_conn,
++};
++
+diff -uNr linux/drivers/no-otg/ocd/au1x00/au1x00.h linux/drivers/otg/ocd/au1x00/au1x00.h
+--- linux/drivers/no-otg/ocd/au1x00/au1x00.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/au1x00/au1x00.h 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,112 @@
++/*
++ * otg/ocd/au1x00/au1100.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ */
++ /*!
++ * @defgroup AU1X00 AMD AU1X00
++ * @ingroup pcdgroup
++ */
++
++/*!
++ * @file otg/ocd/au1x00/au1x00.h
++ * @brief AU1X00 Header
++ *
++ * This file contains the private defines and structures for the AU1X00
++ * Drivers.
++ *
++ * @ingroup AU1X00
++ */
++
++
++
++/*
++ *
++ * 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;
++ u32 indma;
++ u32 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_AU1550 0x03000000 /* AMX */
++
++#define CP0_PRID_REV_MASK 0x000000ff
++
+diff -uNr linux/drivers/no-otg/ocd/fsotg/fs-hcd.c linux/drivers/otg/ocd/fsotg/fs-hcd.c
+--- linux/drivers/no-otg/ocd/fsotg/fs-hcd.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/fsotg/fs-hcd.c 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,1527 @@
++/*
++ * otg/hcd/fsotg/fs-hcd.c - Freescale USBOTG aware Host Controller Driver (HCD)
++ *
++ * Copyright (c) 2004 Belcarra Technologies
++ *
++ * By:
++ * Stuart Lynne <sl@belcara.com>,
++ * Tom Rushworth <tbr@belcara.com>,
++ * Bruce Balden <balden@belcara.com>
++ */
++/*!
++ * @file otg/ocd/fsotg/fs-hcd.c
++ * @brief Freescale USB Host Controller Driver
++ *
++ * This is the hardware specific component of the HCD. It knows nothing
++ * about URBs, and deals with "transfers". This is not because it shouldn't
++ * know about them, but because URBs are generic, and so it seems reasonable
++ * to keep as much generic code in the hardware independent portion as
++ * possible. As a result, the parameter list to hcd_hw_start_transfer()
++ * is really fat.
++ *
++ * This is not compiled as a self contained module, but is linked with
++ * the generic component hc_xfer.o.
++ *
++ * There is some processor specific code here to support the alternate processors
++ * that implement this type of USB support.
++ *
++ * There is no board or platform level code here.
++ *
++ * @ingroup FSOTG
++ * @{
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/pci.h> // For DMA directions
++//#include <linux/slab.h>
++#include <linux/errno.h>
++
++#include <linux/usb.h>
++#include <linux/delay.h>
++#include <asm/arch/mx2.h>
++
++#include <otg/otg-compat.h>
++
++#include "../core/hcd.h"
++
++#include <otg/usbp-chap9.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-utils.h>
++
++#include <otg/otg-hcd.h>
++#include <otg/hcd-l26.h>
++#include <otg/hcd-rh.h>
++#include <otg/hcd-hw.h>
++
++#include <otghw/fsotg-hardware.h>
++
++#ifndef CONFIG_OTG_ROOTHUB_VENDORID
++#define CONFIG_OTG_ROOTHUB_VENDORID 0x15ec
++#endif
++#ifndef CONFIG_OTG_ROOTHUB_PRODUCTID
++#define CONFIG_OTG_ROOTHUB_PRODUCTID 0xf010
++#endif
++#ifndef CONFIG_OTG_ROOTHUB_BCDDEVICE
++#define CONFIG_OTG_ROOTHUB_BCDDEVICE 0x0100
++#endif
++
++
++#define STATIC static
++extern void hcd_trace_mem(otg_tag_t tag, char *fn, char *msg, int len, volatile void *data);
++
++// Start of hardware specific components....
++
++/* ********************************************************************************************* */
++
++// Globals for debug
++static u32 monitoring_etd_mask = 0; // 0 == no monitoring
++static u32 monitoring_etd_num;
++#define MAX_ETD_FRAMES 3
++static u32 current_etd_frame;
++static u32 done_flags[1+MAX_ETD_FRAMES];
++static u32 done_status[1+MAX_ETD_FRAMES];
++static endpoint_transfer_descriptor mon_etd[1+MAX_ETD_FRAMES];
++
++
++
++/*!
++ * @struct cc_name
++ * @brief Map CC values to names
++ */
++static char *cc_name[] = {
++ "no error", "CRC error", "bitstuff error", "data toggle error",
++ "stall", "device not responding", "PID failure" "reserved",
++ "data overrun", "data underrun", "ACK", "NAK", "buffer overrun",
++ "buffer underrun", "schedule overrun" "not accessed"
++};
++
++
++/*!
++ * comp_code_to_status() - map condition cod3 to errno value
++ * @param cc condition code
++ * @return errno value
++ */
++STATIC int comp_code_to_status(int cc)
++{
++ //
++ if (cc)
++ TRACE_MSG2(HCD,"NON-ZERO CC=%d %s", cc,cc_name[cc]);
++
++ switch (cc) {
++ case ETD_CC_NOERROR: return 0;
++ case ETD_CC_CRCERR: return -EILSEQ;
++ case ETD_CC_BITSTUFFERR: return -EPROTO;
++ case ETD_CC_DATATOGERR: return -EPROTO; // I guess, nothing else looks better.
++ case ETD_CC_STALL: return -EPIPE;
++ case ETD_CC_DEVNOTRESPONDING: return -ETIMEDOUT;
++ case ETD_CC_PIDFAILURE: return -EPROTO;
++ case ETD_CC_DATAOVERRUN: return -EOVERFLOW;
++ case ETD_CC_DATAUNDERRUN: return -EREMOTEIO;
++ case ETD_CC_ACK: return -EPROTO; // For lack of anything better
++ case ETD_CC_NAK: return -EPROTO; // For lack of anything better
++ case ETD_CC_BUFFEROVERRUN: return -ECOMM;
++ case ETD_CC_BUFFERUNDERRUN: return -ENOSR;
++ case ETD_CC_SCHEDOVERRUN: return -ENOSPC;
++ case ETD_CC_NOTACCESSED: return -EPROTO; // For lack of anything better
++ default: return -EINVAL;
++ }
++}
++
++/*!
++ * rel_etd() - release etd
++ * {get,rel}_etd maintain a free list of ETDs by saving the index of the next free ETD in the
++ * etd->xbufsrtad field. The list is terminated by 0x0000ffff. List manipulation needs to be
++ * protected by irq_lock, since ETDs are released in the interrupt handler, but allocated at
++ * regular priority.
++ * @param fs_hcpriv
++ * @param etdn
++ */
++STATIC void rel_etd(fs_hcpriv *fs_hcpriv, int etdn)
++{
++ fs_wl(etd_word(etdn, 0), 0);
++ fs_wl(etd_word(etdn, 2), 0);
++ fs_wl(etd_word(etdn, 3), 0);
++ fs_wl(etd_word(etdn, 1), fs_hcpriv->free_etds);
++ fs_hcpriv->free_etds = etdn;
++}
++
++/*!
++ * get_etd() - get etd
++ * {get,rel}_etd maintain a free list of ETDs by saving the index of the next free ETD in the
++ * etd->xbufsrtad field. The list is terminated by 0x0000ffff. List manipulation needs to be
++ * protected by irq_lock, since ETDs are released in the interrupt handler, but allocated at
++ * regular priority.
++ * @param fs_hcpriv
++ * @return int
++ */
++STATIC int get_etd(fs_hcpriv *fs_hcpriv)
++{
++ // Return the index of an available ETD, or -1 if none are available.
++ unsigned long flags;
++ int etdn = -1;
++ local_irq_save(flags);
++ // Is list is empty?
++ if (0x0000ffff != (etdn = fs_hcpriv->free_etds))
++ fs_hcpriv->free_etds = fs_rl(etd_word(etdn, 1));
++ local_irq_restore(flags);
++ return etdn;
++}
++
++/* ********************************************************************************************* */
++/*
++ * For the generic transfer aware framework.
++ */
++
++// For debugging...
++static int num_urbs_started = 0;
++#define MAX_URBS_STARTED 0
++static char *dirpid_name[4] = {"SETUP","OUT","IN","WRONG"};
++//static char *direct_name[4] = {"TD00","OUT","IN","TD11"};
++static char *etd_urb_state_name[] = {"COMPLETED","SETUP_STATUS","SETUP_DATA","SETUP_PKT","BULK","INTERRUPT","ISOC","WRONG"};
++static char *format_name[4] = { "CONTROL", "ISO", "BULK", "INT", };
++
++
++/*!
++ * start_etd() - start an etd
++ * @param etdn
++ * @param len
++ * @param data
++ * @param out
++ */
++STATIC void start_etd(int etdn, int len, void *data, int out)
++{
++ if (len) {
++ consistent_sync(data,len, (out ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE));
++ fs_wl(OTG_DMA_ETD_MSA(etdn), virt_to_bus(data));
++ }
++ if (len || out)
++ fs_wl(OTG_DMA_ETD_EN, ETD_MASK(etdn));
++
++ fs_orl(OTG_HOST_IINT, ETD_MASK(etdn)); // Don't wait until SOF, interrupt ASAP.
++ fs_orl(OTG_HOST_ETD_DONE, ETD_MASK(etdn)); // Interrupt on ETD done (forget DMA interrupt).
++ fs_wl(OTG_HOST_ETD_EN, ETD_MASK(etdn));
++}
++
++/*!
++ * hcd_hw_start_transfer() - start a transfer
++ * Return 0..MAX_ACTIVE_XFERS-1 if the transfer is successfully started,
++ * -1 if there is something wrong with the requested transfer,
++ * -2 if there are no resources available at this time, but resubmission is OK.
++ *
++ * @param bus_hcpriv
++ * @param len length of data region
++ * @param data virtual address of data region
++ * @param toggle toggle value to start the xfer with
++ * @param maxps max packet size of endpoint
++ * @param slow 1 ==> slow speed, 0 ==> full speed QQSV verify: (((urb->pipe) >> 26) & 1)
++ * @param endpoint endpoint number
++ * @param address USB device address
++ * @param pid USB_PID_{OUT,IN,SETUP}
++ * @param format PIPE_{CONTROL,BULK,INTERRUPT,ISOCHRONOUS}
++ * @param other value depending on format
++ *
++ * PIPE_CONTROL: other == address of setup packet.
++ * PIPE_BULK: other == ZLP at end (T/F),
++ * PIPE_INTERRUPT: other == poll interval
++ */
++int hcd_hw_start_transfer(struct bus_hcpriv *bus_hcpriv, int len, void *data, int toggle, int maxps,
++ int slow, int endpoint, int address, int pid, int format, u32 other)
++{
++ fs_hcpriv *fs_hcpriv = (struct fs_hcpriv *) (bus_hcpriv->hw_hci);
++ fs_data_buff *x = NULL;
++ fs_data_buff *y = NULL;
++ int fmt = 0;
++ int out;
++ int etdn;
++ //int rc = 0;
++ int dir = 0;
++ endpoint_transfer_descriptor *sdp = NULL;
++ transfer_descriptor td;
++ int sdp_out = FALSE;
++
++ //TRACE_MSG8(HCD, "len: %d toggle: %d endpoint: %02x pid: %d format: %d address: %d %s %s",
++ // len, toggle, endpoint, pid, format, address, dirpid_name[pid], format_name[format]);
++
++ // data address needs to be on a 32-bit boundary.
++ if (0x3 & (u32)data) {
++ printk(KERN_ERR "%s: invalid data alignment for urb, urb rejected.\n",__FUNCTION__);
++ TRACE_MSG1(HCD, "invalid data alignment for urb (%08x), urb rejected.",(u32)data);
++ return -1;
++ }
++ num_urbs_started += 1;
++ if ((MAX_URBS_STARTED > 0) && (num_urbs_started > MAX_URBS_STARTED)) {
++ // Can the urb, don't touch the HW
++ printk(KERN_ERR "%s: ignoring urb %d\n",__FUNCTION__,num_urbs_started);
++ return -1;
++ }
++
++ /* Check pid, setup pid and out flags
++ */
++ switch (pid) {
++ case USB_PID_SETUP:
++ pid = ETD_DIRPID_SETUP;
++ out = TRUE;
++ break;
++ case USB_PID_OUT:
++ pid = ETD_DIRPID_OUT;
++ out = TRUE;
++ break;
++ case USB_PID_IN:
++ pid = ETD_DIRPID_IN;
++ out = FALSE;
++ break;
++ default:
++ TRACE_MSG1(HCD,"invalid PID %x",pid);
++ return -1;
++ }
++ switch (format) {
++ case PIPE_CONTROL:
++ case PIPE_BULK:
++ case PIPE_INTERRUPT:
++ td.w3.val = (ETD_SET_BUFSIZE(sizeof(fs_data_buff)-1) | ETD_SET_TOTBYECNT(len));
++ break;
++ default:
++ return -1;
++ }
++
++ /*
++ * 1. Allocate resources:
++ * a. X,Y buffers
++ * b. ETD (& matching DMA)
++ * 2. Set the registers
++ */
++ UNLESS ((x = get_data_buff(fs_hcpriv)) && (y = get_data_buff(fs_hcpriv)) && (0 <= (etdn = get_etd(fs_hcpriv)))) {
++ // Resource allocation failure, retry later is OK.
++ TRACE_MSG0(HCD,"resource allocation failure -> resubmit OK");
++ y = rel_data_buff(fs_hcpriv,y);
++ x = rel_data_buff(fs_hcpriv,x);
++ return -2;
++ }
++
++ // OK, we've got all we need.
++ td.w1.bufsrtad.y = data_buff_boff(y);
++ td.w1.bufsrtad.x = data_buff_boff(x);
++
++ switch (format) {
++ case PIPE_CONTROL:
++ fmt = ETD_FORMAT_CONTROL;
++ dir = ETD_DIRECT_TD00;
++
++ /* build setup data/status phase ETD for use after completion of 8 byte setup packet
++ */
++ fs_hcpriv->sdp_data[etdn] = data; // address of data phase buffer.
++ data = (void *) other; // address of setup packet.
++ sdp = &fs_hcpriv->sdp_etd[etdn];
++ memset((void*)sdp, 0, sizeof(endpoint_transfer_descriptor));
++
++ /* toggle is constant 0 for setup packet, and 1 for data and status phases,
++ * so toggle was overloaded to handle data phase direction. If len == 0, there
++ * is no data phase, so direction is IN.
++ */
++ sdp_out = (toggle && len > 0);
++ sdp->td.w1.val = td.w1.val;
++ sdp->td.w2.cb.flags = ETD_SET_DATATOGL((0x2|1)) | // toggle is always 1, for data or status phases.
++ ETD_SET_DELAYINT(0) | // when done, interrupt ASAP (wait for 0 frames)
++ ETD_SET_BUFROUND(1) | // Allow short recv xfers
++ ETD_SET_DIRPID((sdp_out?ETD_DIRPID_OUT:ETD_DIRPID_IN));
++ sdp->td.w2.cb.reserved = 0;
++ sdp->td.w2.cb.rtrydelay = 1; // Number of frames to wait before retry on failure.
++ sdp->td.w3.val = ETD_SET_BUFSIZE(sizeof(fs_data_buff)-1) | ETD_SET_TOTBYECNT(len);
++
++ /* build SETUP ETD for initial 8 byte setup packet
++ */
++ len = 8;
++ td.w2.cb.flags = ETD_SET_DATATOGL((0x2|0)) | // starting toggle is here, not TOGCRY, and is always 0.
++ ETD_SET_DELAYINT(0) | // when done, interrupt ASAP (wait for 0 frames)
++ ETD_SET_BUFROUND(1) | // Allow short recv xfers
++ ETD_SET_DIRPID(pid);
++ td.w2.cb.reserved = 0;
++ td.w2.cb.rtrydelay = 1; // Number of frames to wait before retry on failure.
++ td.w3.val = (ETD_SET_BUFSIZE(sizeof(fs_data_buff)-1) | ETD_SET_TOTBYECNT(len));
++
++ fs_hcpriv->etd_urb_state[etdn] = ETD_URB_SETUP_START;
++
++ //TRACE_MSG3(HCD,"SETUP pkt, len=%d : %08x : %08x",len,*((u32*)(void*)data),*(1+(u32*)(void*)data));
++
++ /* Complete the setup data phase ETD.
++ */
++ sdp->epd = ETD_SET_MAXPKTSIZ(maxps) |
++ ETD_SET_TOGCRY(0) |
++ ETD_SET_FORMAT(ETD_FORMAT_BULK) |
++ ETD_SET_SPEED((slow?ETD_SPEED_LOW:ETD_SPEED_FULL)) |
++ ETD_SET_DIRECT(ETD_DIRECT_TD00) |
++ ETD_SET_ENDPNT(endpoint) |
++ ETD_SET_ADDRESS(address);
++
++ break;
++
++ case PIPE_BULK:
++ fmt = ETD_FORMAT_BULK;
++ dir = ETD_DIRECT_TD00;
++
++ //TRACE_MSG1(HCD,"BULK, starting toggle %x",toggle);
++ td.w2.cb.flags = ETD_SET_DATATOGL((0x2|toggle)) | // starting toggle is here, not TOGCRY
++ ETD_SET_DELAYINT(0) | // when done, interrupt ASAP (wait for 0 frames)
++ ETD_SET_BUFROUND(1) | // Allow short recv xfers
++ ETD_SET_DIRPID(pid);
++ td.w2.cb.reserved = 0;
++ td.w2.cb.rtrydelay = 0; // Number of frames to wait before retry on failure.
++
++ /* Set the state to indicate if a trailing ZLP is required.
++ */
++ fs_hcpriv->etd_urb_state[etdn] = ((other && out && 0 ==
++ (len % maxps)) ? ETD_URB_BULKWZLP_START : ETD_URB_BULK_START);
++ break;
++
++ case PIPE_INTERRUPT:
++ fmt = ETD_FORMAT_INTERRUPT;
++ dir = ETD_DIRECT_TD00;
++
++ //TRACE_MSG1(HCD,"INTERRUPT, starting toggle %x",toggle);
++ td.w2.intr.flags = ETD_SET_DATATOGL((0x2|toggle)) | // starting toggle is here, not TOGCRY
++ ETD_SET_DELAYINT(0) | // when done, interrupt ASAP (wait for 0 frames)
++ ETD_SET_BUFROUND(1) | // Allow short recv xfers
++ ETD_SET_DIRPID(pid);
++
++ td.w2.intr.relpolpos = (fs_rl(OTG_HOST_FRM_NUM) + 1) & 0xff; // Start next frame
++
++ td.w2.intr.polinterv = other & 0xff;
++ fs_hcpriv->etd_urb_state[etdn] = ETD_URB_INTERRUPT_START;
++ break;
++
++ case PIPE_ISOCHRONOUS:
++ fmt = ETD_FORMAT_ISOC;
++ dir = out ? ETD_DIRECT_OUT : ETD_DIRECT_IN;
++ td.w2.isoc.startfrm = (fs_rl(OTG_HOST_FRM_NUM) + 1) & 0xffff; // next frame
++ if (len > 1023) {
++ // Two frames needed, send 1023 in the first, remainder in the second.
++ td.w2.isoc.flags = ETD_SET_DELAYINT(0) | ETD_SET_AUTOISO(0) | ETD_SET_FRAMECNT(1);
++ td.w3.isoc.pkt0 = ETD_SET_PKTLEN(1023);
++ td.w3.isoc.pkt1 = ETD_SET_PKTLEN(len-1023);
++ }
++ else {
++ // Only one frame needed, send it all at once.
++ td.w2.isoc.flags = ETD_SET_DELAYINT(0) | ETD_SET_AUTOISO(0) | ETD_SET_FRAMECNT(0);
++ td.w3.isoc.pkt0 = ETD_SET_PKTLEN(len);
++ td.w3.isoc.pkt1 = 0;
++ }
++ fs_hcpriv->etd_urb_state[etdn] = ETD_URB_ISOC_START;
++ break;
++ }
++
++ fs_wl(etd_word(etdn, 0), ETD_SET_MAXPKTSIZ(maxps) | ETD_SET_TOGCRY(0) | ETD_SET_FORMAT(fmt) |
++ ETD_SET_SPEED((slow ? ETD_SPEED_LOW : ETD_SPEED_FULL)) |
++ ETD_SET_DIRECT(dir) | ETD_SET_ENDPNT(endpoint) | ETD_SET_ADDRESS(address));
++
++ fs_wl(etd_word(etdn, 1), td.w1.val);
++ fs_wl(etd_word(etdn, 2), td.w2.val);
++ fs_wl(etd_word(etdn, 3), td.w3.val);
++
++ //TRACE_MSG5(HCD, "ETD[%02d] %08x %08x %08x %08x", etdn,
++ // fs_rl(etd_word(etdn, 0)), fs_rl(etd_word(etdn, 1)),
++ // fs_rl(etd_word(etdn, 2)), fs_rl(etd_word(etdn, 3)));
++
++ start_etd(etdn, len, data, out);
++ return etdn;
++}
++
++/*!
++ * finish_urb_irq() - called to complete transfer
++ * @param fs_hcpriv
++ * @param etdn
++ * @param killed
++ */
++STATIC void finish_urb_irq(fs_hcpriv *fs_hcpriv, int etdn, int killed)
++{
++ int cc = 0;
++ int next_toggle = 0;
++ int format = 0;
++ u32 remaining = 0;
++ fs_data_buff *x,*y;
++ endpoint_transfer_descriptor res;
++
++ TRACE_MSG5(HCD, "etdn=%d state=%d %s nus=%u %s", etdn, fs_hcpriv->etd_urb_state[etdn],
++ etd_urb_state_name[fs_hcpriv->etd_urb_state[etdn]], num_urbs_started, (killed?"KILLED":""));
++
++ if (monitoring_etd_mask == ETD_MASK(etdn))
++ monitoring_etd_mask = 0;
++
++
++ /* Disable/Abort DMA. R1: sec 23.13.16 pg 23-103
++ * (supposed to auto-clear on DMA completion, but this shouldn't hurt).
++ */
++ fs_wl(OTG_DMA_ETD_CH_CLR, ETD_MASK(etdn));
++
++ if (fs_rl(OTG_HOST_ETD_EN) & ETD_MASK(etdn))
++ fs_andl(OTG_HOST_ETD_EN, ~ETD_MASK(etdn)); // This register IS write 0 to disable. Really.
++
++ if ( fs_rl(OTG_HOST_ETD_DONE) & ETD_MASK(etdn))
++ fs_andl(OTG_HOST_ETD_DONE, ~ETD_MASK(etdn)); // This register IS write 0 to disable. Really.
++
++ // Hardware should have disabled ETD, but it doesn't hurt to check.
++ if (fs_rl(OTG_HOST_ETD_EN) & ETD_MASK(etdn))
++ fs_wl(OTG_HOST_ETD_EN, ETD_MASK(etdn)); // This register IS write 1 to clear. Really.
++
++ if (fs_rl(OTG_HOST_XINT_STAT) & ETD_MASK(etdn))
++ fs_wl(OTG_HOST_XINT_STAT, ETD_MASK(etdn)); // This register IS write 1 to clear. Really.
++
++ if (fs_rl(OTG_HOST_YINT_STAT) & ETD_MASK(etdn))
++ fs_wl(OTG_HOST_YINT_STAT, ETD_MASK(etdn)); // This register should be write 1 to clear.
++
++
++ if (fs_rl(OTG_HOST_XYINT_STEN) & ETD_MASK(etdn))
++ fs_andl(OTG_HOST_XYINT_STEN, ~ETD_MASK(etdn)); // This register should be write 0 to disable.
++
++ if (fs_rl(OTG_HOST_XFILL_STAT) & ETD_MASK(etdn))
++ fs_wl(OTG_HOST_XFILL_STAT, ETD_MASK(etdn)); // This register IS write 1 to clear. Really.
++
++ if (fs_rl(OTG_HOST_YFILL_STAT) & ETD_MASK(etdn))
++ fs_wl(OTG_HOST_YFILL_STAT, ETD_MASK(etdn)); // This register should be write 1 to clear.
++
++
++ // Extract results
++ res.epd = fs_rl(etd_word(etdn, 0));
++ res.td.w1.val = fs_rl(etd_word(etdn, 1));
++ res.td.w2.val = fs_rl(etd_word(etdn, 2));
++ res.td.w3.val = fs_rl(etd_word(etdn, 3));
++
++ fs_wl(OTG_HOST_EP_DSTAT, ETD_MASK(etdn));
++
++ //TRACE_MSG1(HCD,"OTG_HOST_ETD_DONE: %08x", fs_rl(OTG_HOST_ETD_DONE));
++
++ if ((ETD_URB_BULK_START == fs_hcpriv->etd_urb_state[etdn] ||
++ (ETD_URB_BULKWZLP_START == fs_hcpriv->etd_urb_state[etdn])) &&
++ (ETD_GET_DIRPID(res.td.w2.cb.flags) != ETD_DIRPID_IN)
++ )
++ TRACE_MSG4(HCD,"RES: epd: %08x w1: %08x w2: %08x w3: %08x", res.epd,res.td.w1.val,res.td.w2.val,res.td.w3.val);
++
++ if (ETD_GET_HALTED(res.epd))
++ TRACE_MSG0(HCD,"endpoint HALTED");
++
++ format = ETD_GET_FORMAT(res.epd);
++
++ switch (fs_hcpriv->etd_urb_state[etdn]) {
++ case ETD_URB_SETUP_START:
++ /* Just finished the setup packet.
++ * Go to data or status phase of setup packet while we still have the ETD and data buffers allocated.
++ */
++ if (!killed && ETD_CC_NOERROR == (cc = ETD_GET_COMPCODE(res.td.w2.cb.flags))) {
++
++ endpoint_transfer_descriptor *sdp = &fs_hcpriv->sdp_etd[etdn];
++ int len = ETD_GET_TOTBYECNT(sdp->td.w3.val);
++ void *data = fs_hcpriv->sdp_data[etdn];
++ fs_hcpriv->etd_urb_state[etdn] = ((len > 0) ? ETD_URB_SETUP_DATA : ETD_URB_SETUP_STATUS);
++
++ // Copy into the active ETD and start it.
++ fs_wl(etd_word(etdn, 0), sdp->epd);
++ fs_wl(etd_word(etdn, 1), sdp->td.w1.val);
++ fs_wl(etd_word(etdn, 2), sdp->td.w2.val);
++ fs_wl(etd_word(etdn, 3), sdp->td.w3.val);
++ // watch out for ETD_DIRPID_SETUP
++ start_etd(etdn, len,data,(ETD_GET_DIRPID(sdp->td.w2.cb.flags)!=ETD_DIRPID_IN));
++ TRACE_MSG1(HCD,"SETUP %s Phase started",((len > 0) ? "DATA" : "STATUS"));
++ return;
++ }
++ /* Something is wrong, finish the URB as is.
++ */
++ remaining = ETD_GET_TOTBYECNT(fs_rl(etd_word(etdn, 3)));
++ format = PIPE_CONTROL;
++ break;
++
++ case ETD_URB_SETUP_DATA:
++ /* Go to status phase of setup packet while we still have the ETD and data buffers allocated.
++ * Save the data phase length for after status.
++ */
++ if (!killed && ETD_CC_NOERROR == (cc = ETD_GET_COMPCODE(res.td.w2.cb.flags))) {
++ endpoint_transfer_descriptor *sdp = &fs_hcpriv->sdp_etd[etdn];
++ fs_hcpriv->sdp_data[etdn] = (void *) ETD_GET_TOTBYECNT(res.td.w3.val);
++ fs_hcpriv->etd_urb_state[etdn] = ETD_URB_SETUP_STATUS;
++
++ /* Rebuild data phase sdp for status phase with opposite direction, and 0 length.
++ */
++
++ sdp->td.w2.cb.flags = ETD_FLIP_DIRPID(sdp->td.w2.cb.flags);
++ sdp->td.w3.val = (ETD_SET_BUFSIZE(sizeof(fs_data_buff)-1) | ETD_SET_TOTBYECNT(0));
++
++ /* Copy into the active ETD and start it.
++ */
++ fs_wl(etd_word(etdn, 0), sdp->epd);
++ fs_wl(etd_word(etdn, 1), sdp->td.w1.val);
++ fs_wl(etd_word(etdn, 2), sdp->td.w2.val);
++ fs_wl(etd_word(etdn, 3), sdp->td.w3.val);
++ start_etd(etdn, 0,NULL,(ETD_GET_DIRPID(sdp->td.w2.cb.flags)!=ETD_DIRPID_IN));
++ TRACE_MSG0(HCD,"SETUP STATUS Phase started");
++ return;
++ }
++ // Something is wrong, finish the URB as is.
++ remaining = ETD_GET_TOTBYECNT(res.td.w3.val);
++ format = PIPE_CONTROL;
++ break;
++
++ case ETD_URB_SETUP_STATUS:
++ cc = ETD_GET_COMPCODE(res.td.w2.cb.flags);
++ // Fetch saved length.
++ remaining = (u32) fs_hcpriv->sdp_data[etdn];
++ format = PIPE_CONTROL;
++ break;
++
++ case ETD_URB_BULKWZLP_START:
++ // Need a trailing ZLP.
++ next_toggle = ETD_GET_TOGCRY(res.epd);
++ if (!killed && ETD_CC_NOERROR == ETD_GET_COMPCODE(res.td.w2.cb.flags)) {
++ // Since TOTBYECNT should be 0, re-enabling the same ETD ought to give a ZLP.
++ fs_hcpriv->etd_urb_state[etdn] = ETD_URB_BULKWZLP;
++ // Save the data phase length for after ZLP.
++ // fs_hcpriv->sdp_data[etdn] = (void *) ETD_GET_TOTBYECNT(res.td.w3.val);
++ // FIXME - verify toggle OK
++
++ start_etd(etdn, 0,NULL,TRUE/*always OUT*/);
++
++ TRACE_MSG0(HCD,"ZLP started");
++ return;
++ }
++ // Something is wrong, finish the URB as is.
++ remaining = ETD_GET_TOTBYECNT(res.td.w3.val);
++ format = PIPE_BULK;
++ break;
++
++ case ETD_URB_BULKWZLP:
++ // Trailing ZLP now finished.
++ cc = ETD_GET_COMPCODE(res.td.w2.cb.flags);
++ next_toggle = ETD_GET_TOGCRY(res.epd);
++ // Fetch saved length (it was zero, or we wouldn't be here).
++ remaining = 0;
++ format = PIPE_BULK;
++ break;
++
++ case ETD_URB_BULK_START:
++ cc = ETD_GET_COMPCODE(res.td.w2.cb.flags);
++ next_toggle = ETD_GET_TOGCRY(res.epd);
++ remaining = ETD_GET_TOTBYECNT(res.td.w3.val);
++ format = PIPE_BULK;
++ break;
++
++ case ETD_URB_INTERRUPT_START:
++ cc = ETD_GET_COMPCODE(res.td.w2.intr.flags);
++ remaining = ETD_GET_TOTBYECNT(res.td.w3.val);
++ format = PIPE_INTERRUPT;
++ break;
++
++ case ETD_URB_ISOC_START:
++ // This probably needs more work, best guess only here.
++ remaining = ETD_GET_PKTLEN(res.td.w3.isoc.pkt0);
++ cc = ETD_GET_COMPCODE(res.td.w3.isoc.pkt0);
++ if (ETD_GET_FRAMECNT(res.td.w2.isoc.flags)) {
++ // There were two packets in this transfer
++ remaining += ETD_GET_PKTLEN(res.td.w3.isoc.pkt1);
++ }
++ format = PIPE_ISOCHRONOUS;
++ }
++
++ fs_hcpriv->etd_urb_state[etdn] = ETD_URB_COMPLETED;
++
++ /* Convert completion code to HW independent value.
++ */
++ if (killed) {
++ cc = -ENOENT;
++ remaining = 0;
++ }
++ else
++ cc = comp_code_to_status(cc);
++
++ /* Return ETD and X,Y buffers to free list.
++ */
++ y = data_buff_addr(res.td.w1.bufsrtad.y);
++ x = data_buff_addr(res.td.w1.bufsrtad.x);
++ y = rel_data_buff(fs_hcpriv,y);
++ x = rel_data_buff(fs_hcpriv,x);
++ rel_etd(fs_hcpriv, etdn);
++
++ /* Forward results to the layers above.
++ */
++ //TRACE_MSG4(HCD,"completing urb on ETD %d cc=%d remaining=%d next_toggle=%d", etdn, cc, remaining,next_toggle);
++ hcd_transfer_complete(fs_hcpriv->bus_hcpriv, etdn, format, cc, remaining, next_toggle);
++}
++
++/*!
++ * hcd_hw_unlink_urb() - unlink urb
++ * Called in irq_lock
++ * @param bus_hcpriv
++ * @param u
++ */
++int hcd_hw_unlink_urb(struct bus_hcpriv *bus_hcpriv, int u)
++{
++ unsigned long flags;
++ struct fs_hcpriv *fs_hcpriv;
++ RETURN_EINVAL_UNLESS ((fs_hcpriv = (struct fs_hcpriv *) bus_hcpriv->hw_hci));
++ local_irq_save(flags);
++ finish_urb_irq(fs_hcpriv, u, TRUE);
++ local_irq_restore(flags);
++ return 0;
++}
++
++/*!
++ * hcd_hw_frame_number() - return current frame number
++ * @param bus_hcpriv
++ * @return u32 ???
++ */
++u32 hcd_hw_frame_number(struct bus_hcpriv *bus_hcpriv)
++{
++ return(fs_rl(OTG_HOST_FRM_NUM));
++}
++
++/* ********************************************************************************************* */
++
++/*!
++ * MX21_PORT_CHANGED() - send otg event information to state machine
++ * @param name
++ * @param cs
++ * @param changed
++ * @param status
++ * @param set
++ * @param reset
++ */
++void MX21_PORT_CHANGED(char *name, u32 cs, u32 changed, u32 status, u64 set, u64 reset)
++{
++ RETURN_UNLESS(cs & changed);
++ TRACE_MSG2(HCD, "%s%s", name, (cs & (1 << status)) ? "" : "/");
++ if (cs & (1 << status) && set)
++ otg_event(hcd_instance->otg, set, HCD, name);
++ if (!(cs & (1 << status)) && reset)
++ otg_event(hcd_instance->otg, reset, HCD, name);
++}
++
++/*!
++ * update_shadow_rh() - Update shadow _status_ info (change info already updated).
++ * @param bus_hcpriv
++ * @param port_num - 1-N based port number
++ * @param cs
++ *
++ */
++STATIC void update_shadow_rh(struct bus_hcpriv *bus_hcpriv, int port_num, u32 cs)
++{
++ u32 msk_and = 0; // bits to turn off
++ u32 msk_or = 0; // bits to turn on
++
++ TRACE_MSG2(HCD,"port: %d cs: %08x", port_num, cs);
++
++ /* PORT_STATUS_PRTRSTSC (20) - PORT_RESET (4) changed
++ * PORT_RESET (4) status change, end of reset, PORT_ENABLE may (should) be on.
++ */
++ MX21_PORT_CHANGED("PORT_RESET", cs, PORT_STATUS_PRTRSTSC, PORT_RESET,
++ BUS_RESET, BUS_RESET_);
++
++ if (cs & (1 << C_PORT_RESET)) {
++ TRACE_MSG1(HCD,"port: %d PORT_RESET complete (s.b. enabled)", port_num);
++ if (cs & (1 << PORT_ENABLE)) {
++ TRACE_MSG1(HCD,"port: %d enabled", port_num);
++ //otg_write_info_message("port update C_PORT_RESET");
++ msk_or |= (1 << PORT_ENABLE);
++ }
++ else {
++ TRACE_MSG1(HCD,"port: %d NOT enabled!!!", port_num);
++ //otg_write_info_message("update C_PORT_RESET/");
++ }
++
++ /* Clear the PORT_RESET bit too, since it's over.
++ */
++ msk_and |= (1 << PORT_RESET);
++ bus_hcpriv->rh_hcpriv->hub_port_change_status |= (1 << port_num);
++ }
++
++ /* PORT_OVER_CURRENT (3) bit has changed (either direction).
++ * PORT_STATUS_OVRCURIC (19) - PORT_OVER_CURRENT (3) changed
++ */
++ MX21_PORT_CHANGED("PORT_OVER_CURRENT", cs, PORT_STATUS_OVRCURIC, PORT_OVER_CURRENT, (u64) 0, (u64) 0);
++ if (cs & (1 << C_PORT_OVER_CURRENT)) {
++ /* OVER_CURRENT has come on.
++ */
++ if (cs & (1 << PORT_OVER_CURRENT)) {
++ TRACE_MSG1(HCD,"port: %d over current ON", port_num);
++ msk_or |= (1 << PORT_OVER_CURRENT);
++ }
++ /* OVER_CURRENT has gone away.
++ */
++ else {
++ TRACE_MSG1(HCD,"port: %d over current OFF", port_num);
++ msk_and |= (1 << PORT_OVER_CURRENT);
++ }
++ bus_hcpriv->rh_hcpriv->hub_port_change_status |= (1 << port_num);
++ }
++
++ /* PORT_SUSPEND (2) Resume sequence has completed....
++ * PORT_STATUS_PRTSTATSC (18) - PORT_SUSPEND (2) changed
++ */
++ MX21_PORT_CHANGED("PORT_SUSPEND", cs, PORT_STATUS_PRTSTATSC, PORT_SUSPEND,
++ BUS_SUSPENDED, BUS_SUSPENDED_);
++
++ if (cs & (1 << C_PORT_SUSPEND)) {
++ // FIXME - figure this out when we get to suspend/resume....
++
++ }
++
++
++ /* PORT_ENABLE (1) has been __cleared__ by some HW event
++ * PORT_STATUS_PRTENBLSC (17) - PORT_ENABLE (1) changed
++ */
++ MX21_PORT_CHANGED("PORT_ENABLE", cs, PORT_STATUS_PRTENBLSC, PORT_ENABLE, (u64) 0, (u64) 0);
++ if (cs & (1 << C_PORT_ENABLE)) {
++ //otg_write_info_message("update C_PORT_ENABLE");
++ TRACE_MSG1(HCD,"port: %d disabled (by HW)", port_num);
++ if (!(cs & (1 << PORT_ENABLE)))
++ msk_and |= ( 1 << PORT_ENABLE);
++ bus_hcpriv->rh_hcpriv->hub_port_change_status |= (1 << port_num);
++ }
++
++ /* PORT_CONNECTION (0) bit has changed (either direction).
++ * PORT_STATUS_CONNECTSC (16) - PORT_CONNECTION (0) changed
++ */
++ MX21_PORT_CHANGED("PORT_CONNECTION", cs, PORT_STATUS_CONNECTSC, PORT_CONNECTION,
++ HUB_PORT_CONNECT, HUB_PORT_CONNECT_ );
++
++ if (cs & (1 << C_PORT_CONNECTION)) {
++ /* CONNECT has come on.
++ */
++ if (cs & (1 << PORT_CONNECTION)) {
++ TRACE_MSG1(HCD,"port: %d new connection", port_num);
++ msk_or |= (1 << PORT_CONNECTION);
++ if (cs & (1 << PORT_LOW_SPEED)) {
++ TRACE_MSG1(HCD,"port: %d low speed device", port_num);
++ msk_or |= (1 << PORT_LOW_SPEED);
++ }
++ //otg_write_info_message("update PORT_CONNECTION");
++ //printk(KERN_INFO"%s: AAA\n", __FUNCTION__);
++ //otg_event(hcd_instance->otg, HUB_PORT_CONNECT, HCD, "HUB_PORT_CONNECT (mx21 hw)");
++ //printk(KERN_INFO"%s: BBB\n", __FUNCTION__);
++ }
++ /* CONNECT has gone away.
++ */
++ else {
++ TRACE_MSG1(HCD,"port: %d disconnection", port_num);
++ //otg_write_info_message("update PORT_CONNECTION/");
++ msk_and |= (1 << PORT_CONNECTION) | (1 << PORT_LOW_SPEED);
++ //otg_event(hcd_instance->otg, HUB_PORT_CONNECT_, HCD, "HUB_PORT_CONNECT/ (mx21 hw)");
++ }
++ bus_hcpriv->rh_hcpriv->hub_port_change_status |= (1 << port_num);
++ //printk(KERN_INFO"%s: CCC\n", __FUNCTION__);
++ }
++
++ TRACE_MSG5(HCD, "port: %d shadow port_change_status: ((%08x & ~%04x) | %04x) hpcs: %04x",
++ port_num, bus_hcpriv->rh_hcpriv->port_change_status[port_num - 1],
++ msk_and, msk_or, bus_hcpriv->rh_hcpriv->hub_port_change_status);
++}
++
++/* ********************************************************************************************* */
++static int num_host_interrupts = 0;
++#define MAX_HOST_INTERRUPTS 0
++static int num_psc_interrupts = 0;
++#define MAX_PSC_INTERRUPTS 0
++
++extern struct bus_hcpriv fs_bus_hcpriv;
++
++/*!
++ * hcd_hw_int_hndlr() - interrupt handler for hcd controller
++ * @param irq
++ * @param dev_id
++ * @param regs
++ */
++irqreturn_t hcd_hw_int_hndlr(int irq, void *dev_id, struct pt_regs *regs)
++{
++ struct bus_hcpriv *bus_hcpriv = (struct bus_hcpriv *) &fs_bus_hcpriv;
++ struct fs_hcpriv *fs_hcpriv = (struct fs_hcpriv *) bus_hcpriv->hw_hci;
++ u32 host_sint; // C.f. 23.11.11 Host Interrupt Register
++
++ if (OTG_USBDMA == irq) {
++ // HOST DMA error interrupt
++ u32 err_stat = fs_rl(OTG_DMA_ETD_ERR);
++ TRACE_MSG1(HCD,"host DMA interrupt, error status %08x",err_stat);
++ if (0 != err_stat) {
++ // Disable the matching DMA channels and clear the interrupt
++ fs_wl(OTG_DMA_ETD_CH_CLR, err_stat);
++ fs_wl(OTG_DMA_ETD_ERR, err_stat);
++ }
++ // local_irq_restore(flags);
++ return IRQ_HANDLED;
++ }
++
++ /* FIXME - should check fs_hcpriv->mm->otg.OTG_Module_Interrupt_Status & (0x1 << 3) | 0x1;
++ * for Host (async + regular) Interrupt - enable clock on async.
++ */
++
++ num_host_interrupts += 1;
++ if (MAX_HOST_INTERRUPTS > 0 && num_host_interrupts > MAX_HOST_INTERRUPTS) {
++ // Host (async + regular) Interrupt Disable
++
++ fs_wl(OTG_HOST_SINT_STEN, 0);
++ fs_andl(OTG_CORE_CINT_STEN, ~(/*(0x1 << 3) |*/ 0x1));
++ }
++
++ while ((host_sint = fs_rl(OTG_HOST_SINT_STAT))) {
++
++ while (HOST_DONEINT & host_sint) {
++ u32 etds_done;
++
++ TRACE_MSG1(HCD,"HOST_DONEINT: %08x", fs_rl(OTG_HOST_EP_DSTAT));
++ fs_wl(OTG_HOST_SINT_STAT, HOST_DONEINT);
++ host_sint = fs_rl(OTG_HOST_SINT_STAT);
++ while ((etds_done = fs_rl(OTG_HOST_EP_DSTAT)))
++ finish_urb_irq(fs_hcpriv, fls(etds_done) - 1, FALSE);
++ }
++
++ host_sint = fs_rl(OTG_HOST_SINT_STAT);
++
++ /* Start Of Frame.
++ * Note: this interrupt seems to happen even if disabled when there is a frame number overflow.
++ */
++ if (host_sint & HOST_SOFINT) {
++ if (0 == (fs_hcpriv->sof_count & (4096 - 1))) {
++ TRACE_MSG1(HCD,"SOF %08lx",fs_hcpriv->sof_count);
++ }
++ fs_hcpriv->sof_count += 1;
++ if (monitoring_etd_mask != 0) {
++ // This ETD needs to be watched....
++ current_etd_frame += 1;
++
++ done_flags[current_etd_frame] = fs_rl(OTG_HOST_ETD_EN);
++ done_status[current_etd_frame] = fs_rl(OTG_HOST_EP_DSTAT);
++
++ mon_etd[current_etd_frame].epd = fs_rl(etd_word(monitoring_etd_num, 0));
++ mon_etd[current_etd_frame].td.w1.val = fs_rl(etd_word(monitoring_etd_num, 1));
++ mon_etd[current_etd_frame].td.w2.val = fs_rl(etd_word(monitoring_etd_num, 2));
++ mon_etd[current_etd_frame].td.w3.val = fs_rl(etd_word(monitoring_etd_num, 3));
++
++ if (current_etd_frame >= MAX_ETD_FRAMES) {
++ // This has taken too long!
++ int i,u;
++ u = ((mon_etd[0].td.w3.val == mon_etd[1].td.w3.val) &&
++ (mon_etd[1].td.w3.val == mon_etd[2].td.w3.val) &&
++ (mon_etd[2].td.w3.val == mon_etd[3].td.w3.val));
++
++ TRACE_MSG5(HCD,"SOF: OUT urb TIMEOUT at %d/%d frames, mask: %08x num=%u u=%d",
++ current_etd_frame,MAX_ETD_FRAMES,monitoring_etd_mask,monitoring_etd_num,u);
++
++ for (i = 0; i <= MAX_ETD_FRAMES; i++)
++ TRACE_MSG7(HCD,"SOF: %d epd: %08x w1: %08x w2: %08x w3: %08x ef: %08x st: %08x",
++ i, mon_etd[i]. epd, mon_etd[i]. td.w1.val, mon_etd[i].td.w2.val,
++ mon_etd[i].td.w3.val, done_flags[i], done_status[i]);
++ // Disable monitoring by killing the urb. FUTURE, look into restarting it.
++ finish_urb_irq(fs_hcpriv, monitoring_etd_num,TRUE);
++ }
++ }
++ }
++
++ /* Frame Number Overflow.
++ */
++ if (host_sint & HOST_FMOFINT) {
++ //TRACE_MSG0(HCD,"Frame Number Overflow");
++ //printk(KERN_ERR "%s: Frame Number Overflow\n",__FUNCTION__);
++ }
++
++ /* Port Status Change.
++ */
++ if (host_sint & HOST_PSCINT) {
++ int port_num;
++ num_psc_interrupts += 1;
++
++ /* Clear the interrupt by clearing the port(s) in question.
++ * Reflect any changes in the shadow values.
++ */
++ for (port_num = 1; port_num <= bus_hcpriv->num_ports; port_num++) {
++
++ u32 cs = fs_rl(fs_host_port_stat(port_num));
++ u32 cm = cs & 0xFFFF0000;
++
++ CONTINUE_UNLESS (cm);
++ fs_wl(fs_host_port_stat(port_num), cm);
++ bus_hcpriv->rh_hcpriv->port_change_status[port_num - 1] |= cm;
++ update_shadow_rh(bus_hcpriv, port_num, cs);
++ }
++
++ /* Tell the RH to scan for changes in shadow data. (schedule bottom half handler)
++ */
++ hcd_rh_int_hndlr(irq,bus_hcpriv,NULL);
++ }
++
++ /* Overrun
++ */
++ if (host_sint & (HOST_SORINT | HOST_HERRINT)) {
++ if (host_sint & HOST_SORINT) {
++ TRACE_MSG0(HCD,"Scheduling Overrun");
++ printk(KERN_ERR "%s: Scheduling Overrun\n",__FUNCTION__);
++ }
++ if (host_sint & HOST_HERRINT) {
++ TRACE_MSG0(HCD,"Host Scheduling Error");
++ printk(KERN_ERR "%s: Host Scheduling Error\n",__FUNCTION__);
++ }
++ }
++ /* Resume Detected.
++ */
++ if (host_sint & HOST_RESDETINT) {
++ TRACE_MSG0(HCD,"Resume Detected");
++ }
++ /* Clear by writing back the ones we've checked for since the last read.
++ */
++ fs_wl(OTG_HOST_SINT_STAT, host_sint & (HOST_RESDETINT | HOST_FMOFINT | HOST_SORINT |
++ HOST_HERRINT | HOST_PSCINT | HOST_SOFINT));
++ }
++ return IRQ_HANDLED;
++}
++
++/* ********************************************************************************************* */
++
++
++/*!
++ * hcd_hw_rh_hub_attributes() - get root hub attributes
++ * These provide access to the real root hub.
++ * @param bus_hcpriv
++ */
++u16 hcd_hw_rh_hub_attributes(struct bus_hcpriv *bus_hcpriv)
++{
++ // R1: sec 23.11.27
++ return 0xFFFF & (fs_rl(OTG_HOST_ROOTHUB_DESCA) >> 8);
++}
++
++/*!
++ * hcd_hw_rh_power_delay() - get power delay attributes
++ * These provide access to the real root hub.
++ * @param bus_hcpriv
++ */
++u8 hcd_hw_rh_power_delay(struct bus_hcpriv *bus_hcpriv)
++{
++ // R1: sec 23.11.27
++ return fs_rl(OTG_HOST_ROOTHUB_DESCA) >> 24;
++}
++
++/*!
++ * hcd_hw_rh_contr_current() - get contr current attributes
++ * These provide access to the real root hub.
++ * @param bus_hcpriv
++ */
++u8 hcd_hw_rh_hub_contr_current(struct bus_hcpriv *bus_hcpriv)
++{
++ return 0x0;
++}
++
++/*!
++ * hcd_hw_rh_DeviceRemovalbe() - get DeviceRemovalbe attributes
++ * These provide access to the real root hub.
++ * @param bus_hcpriv
++ */
++u8 hcd_hw_rh_DeviceRemovable(struct bus_hcpriv *bus_hcpriv)
++{
++ // USB2.0 pg 418 ==> bit 0 reserved, 1..7 for ports
++ // R1: sec 23.11.28
++ return 0xFF & fs_rl(OTG_HOST_ROOTHUB_DESCB);
++}
++
++/*!
++ * hcd_hw_rh_PortPwrCtrlMask() - get DeviceRemovalbe attributes
++ * These provide access to the real root hub.
++ * @param bus_hcpriv
++ */
++u8 hcd_hw_rh_PortPwrCtrlMask(struct bus_hcpriv *bus_hcpriv)
++{
++ // USB2.0 pg 418 ==> all 1s??? QQSV
++ // R1: sec 23.11.28
++ return 0xFF & fs_rl(OTG_HOST_ROOTHUB_DESCB);
++}
++
++
++/*!
++ * hcd_hw_rh_get_hub_change_status() - get change status
++ * These provide access to the real root hub.
++ * @param bus_hcpriv
++ */
++u32 hcd_hw_rh_get_hub_change_status(struct bus_hcpriv *bus_hcpriv)
++{
++ // R1: sec 23.11.29 pg 23-62, USB2.0 11.24.2.6 pg 425
++ return fs_rl(OTG_HOST_ROOTHUB_STATUS & (ROOTHUB_STATUS_LOCPWRSC | ROOTHUB_STATUS_DEVCONWUE |
++ ROOTHUB_STATUS_OVRCURI | ROOTHUB_STATUS_LOCPWRS));
++}
++
++/*!
++ * hcd_hw_rh_hub_feature() - get hub feature
++ * These provide access to the real root hub.
++ * @param bus_hcpriv
++ * @param feat_selector
++ * @param set_flag
++ */
++void hcd_hw_rh_hub_feature(struct bus_hcpriv *bus_hcpriv, int feat_selector, int set_flag)
++{
++ if (set_flag) {
++ // SET feature USB2.0 11.24.2.12 pg 434 and USB2.0 11.24.2 tbl 11-17 pg 421
++ // R1: sec 23.11.29 pg 23-62
++ switch (feat_selector) {
++ // case C_HUB_OVER_CURRENT: MX21 doesn't support SW setting the over current feature
++ // case C_HUB_LOCAL_POWER: MX21 doesn't support local power
++ default:
++ // Error, but ignore.
++ TRACE_MSG1(HCD,"SET invalid feature %d",feat_selector);
++ break;
++ }
++ }
++ else {
++ // CLEAR feature USB2.0 11.24.2.1 pg 422 and USB2.0 11.24.2 tbl 11-17 pg 421
++ // R1: sec 23.11.29 pg 23-62
++ switch (feat_selector) {
++ case C_HUB_OVER_CURRENT:
++ fs_wl(OTG_HOST_ROOTHUB_STATUS, ROOTHUB_STATUS_OVRCURCHG);
++ break;
++
++ // case C_HUB_LOCAL_POWER: MX21 doesn't support local power
++ default:
++ // Error, but ignore.
++ TRACE_MSG1(HCD,"CLEAR invalid feature %d",feat_selector);
++ break;
++ }
++ }
++}
++
++/*!
++ * hcd_hw_rh_get_port_change_status() - get port change status
++ * R1: High 16 bits == change, low 16 == status
++ * Change & Status bits in register match USB2.0 spec on (read).
++ * @param bus_hcpriv
++ * @param wIndex is 1-origin
++ */
++u32 hcd_hw_rh_get_port_change_status(struct bus_hcpriv *bus_hcpriv, int wIndex)
++{
++ u32 port_status = fs_rl(fs_host_port_stat(wIndex));
++
++ TRACE_MSG8(HCD,"port %d cs: %08lx %s %s %s %s %s %s",
++ wIndex, port_status,
++ port_status & PORT_STATUS_CONNECTSC ? "CHANGE" : "",
++ port_status & PORT_STATUS_PRTPWRST ? "POWER" : "",
++ port_status & PORT_STATUS_PRTRSTST ? "RESET" : "",
++ port_status & PORT_STATUS_PRTSUSPST ? "SUSPEND" : "",
++ port_status & PORT_STATUS_PRTENABST ? "ENABLE" : "",
++ port_status & PORT_STATUS_CURCONST ? "CONNECT" : ""
++ );
++
++ return fs_rl(fs_host_port_stat(wIndex));
++}
++
++extern char *port_feature_name[];
++
++/*!
++ * hcd_hw_rh_port_feature() - get rh port feature
++ * @param bus_hcpriv
++ * @param wValue is feature selector
++ * @param wIndex is port number (1-N)
++ * @param set_flag
++ */
++void hcd_hw_rh_port_feature(struct bus_hcpriv *bus_hcpriv, u16 wValue, u16 wIndex, int set_flag)
++{
++ char buf[64];
++ sprintf(buf, "port feature %s %s", port_feature_name[wValue], set_flag ? "SET" : "RESET");
++ //otg_write_info_message(buf);
++
++ TRACE_MSG4(HCD, "mx21 %s (%d) %s port_stat: %8x", port_feature_name[wValue], wValue, set_flag ? "SET" : "RESET",
++ fs_rl(fs_host_port_stat(wIndex)));
++ if (set_flag) {
++ // SET feature
++ switch (wValue) {
++ case PORT_SUSPEND:
++ otg_event(hcd_instance->otg, BUS_SUSPENDED, HCD, "HUB_PORT_SUSPEND (mx21 hw)");
++ fs_wl(fs_host_port_stat(wIndex), 1 << wValue);
++ break;
++ case PORT_RESET:
++ case PORT_POWER:
++ fs_wl(fs_host_port_stat(wIndex), 1 << wValue);
++ break;
++ default:
++ // Error, but ignore.
++ TRACE_MSG2(HCD,"SET port %d invalid feature %d", wIndex, wValue);
++ break;
++ }
++ }
++ else {
++ // CLEAR feature (valid features from USB2.0 11.24.2.2 pg 423).
++ switch (wValue) {
++ case PORT_SUSPEND: // Cause a Host initiated resume, or no-op if already active.
++ wValue++; // yes, really. this clears PORT_SUSPEND
++ fs_wl(fs_host_port_stat(wIndex), 1 << wValue);
++ otg_event(hcd_instance->otg, BUS_SUSPENDED_, HCD, "HUB_PORT_SUSPEND/ (mx21 hw)");
++ break;
++
++ case PORT_POWER: // Put port in powered-off state.
++ wValue++; // yes, really. this clears PORT_POWER
++ fs_wl(fs_host_port_stat(wIndex), 1 << wValue);
++ break;
++
++ case PORT_ENABLE: // Disable port.
++ //wValue--;
++ break;
++ default:
++ break;
++ }
++ switch (wValue) {
++ case PORT_POWER: // Put port in powered-off state.
++ case PORT_SUSPEND: // Cause a Host initiated resume, or no-op if already active.
++ case PORT_ENABLE: // Disable port.
++ case PORT_INDICATOR: // ind_selector gives which indicator to clear
++ case C_PORT_SUSPEND: // clear the PORT_SUSPEND change bit
++ case C_PORT_CONNECTION: // clear the PORT_CONNECTION change bit
++ case C_PORT_RESET: // clear the PORT_RESET change bit
++ case C_PORT_ENABLE: // clear the PORT_ENABLE change bit
++ case C_PORT_OVER_CURRENT: // clear the PORT_OVERCURRENT change bit
++ fs_wl(fs_host_port_stat(wIndex), 1 << wValue);
++ break;
++ default:
++ // Error, but ignore.
++ TRACE_MSG2(HCD,"CLEAR port %d invalid feature %d", wIndex, wValue);
++ break;
++ }
++ }
++
++ TRACE_MSG3(HCD, "mx21 %s %s port_stat: %8x", port_feature_name[wValue], set_flag ? "SET" : "RESET",
++ fs_rl(fs_host_port_stat(wIndex)));
++}
++
++/* ********************************************************************************************* */
++/* Hardware Initialization - this is used by the OTG state machine to
++ * enable and disable the host controller hardware
++ */
++void rh_hcd_en_func(struct otg_instance *otg, u8 flag);
++
++extern void fs_host_clock_on(void);
++extern void fs_host_clock_off(void);
++
++/*!
++ * fs_hcd_en_func() - otg hcd enable output function
++ * @param otg
++ * @param flag
++ */
++void fs_hcd_en_func(struct otg_instance *otg, u8 flag)
++{
++ struct bus_hcpriv *bus_hcpriv = (struct bus_hcpriv *)(((struct hcd_instance *)(otg->hcd))->privdata);
++ fs_hcpriv *fs_hcpriv = bus_hcpriv->hw_hci;
++ int i;
++ u32 hwmode = fs_rl(OTG_CORE_HWMODE);
++ unsigned long flags;
++
++ /* puts OTG capable port into a state where host is enabled */
++
++ fs_andl(OTG_CORE_HWMODE, 0xffffff0f); // clear
++
++ switch (flag) {
++ case SET:
++ local_irq_save(flags);
++ printk(KERN_INFO"%s: SET\n", __FUNCTION__);
++ if (hwmode & MODULE_CRECFG_HOST) {
++ printk(KERN_INFO"%s: warning FUNC STILL SET\n", __FUNCTION__);
++ }
++ //printk(KERN_INFO"%s: SET\n", __FUNCTION__);
++ fs_orl(OTG_CORE_HWMODE, MODULE_CRECFG_HOST); // set to software hnp
++ local_irq_restore(flags);
++ break;
++ case RESET:
++ local_irq_save(flags);
++ printk(KERN_INFO"%s: RESET\n", __FUNCTION__);
++ fs_andl(OTG_CORE_HWMODE, ~MODULE_CRECFG_HOST); // set to software hnp
++ local_irq_restore(flags);
++ break;
++ }
++
++ TRACE_MSG1(HCD, "HWMODE: %08x", fs_rl(OTG_CORE_HWMODE));
++}
++
++
++void rh_loc_sof_func(struct otg_instance *otg, u8 flag);
++void rh_loc_suspend_func(struct otg_instance *otg, u8 flag);
++
++/*!
++ * fs_loc_suspend() - otg loc suspend output function
++ * @param otg
++ * @param flag
++ */
++void fs_loc_suspend_func(struct otg_instance *otg, u8 flag)
++{
++ unsigned long flags;
++ switch (flag) {
++ case SET:
++
++ fs_orl(OTG_HOST_CONTROL, HOST_CONTROL_HCUSBSTE_SUSPEND);
++ break;
++
++ case RESET:
++ break;
++ }
++
++ rh_loc_suspend_func(otg, flag);
++
++ switch (flag) {
++ case SET:
++ break;
++
++ case RESET:
++ local_irq_save(flags);
++ fs_andl(OTG_HOST_CONTROL, ~HOST_CONTROL_HCUSBSTE_SUSPEND);
++ fs_orl(OTG_HOST_CONTROL, HOST_CONTROL_HCUSBSTE_OPERATIONAL);
++ local_irq_restore(flags);
++ break;
++ }
++}
++
++/*!
++ * fs_loc_sof_func() - otg loc sof output function
++ * @param otg
++ * @param flag
++ */
++void fs_loc_sof_func(struct otg_instance *otg, u8 flag)
++{
++ struct bus_hcpriv *bus_hcpriv = (struct bus_hcpriv *)(((struct hcd_instance *)(otg->hcd))->privdata);
++ fs_hcpriv *fs_hcpriv = bus_hcpriv->hw_hci;
++ int i;
++ u32 mask;
++ unsigned long flags;
++
++ switch (flag) {
++ case SET:
++ //printk(KERN_INFO"%s: SET\n", __FUNCTION__);
++ //TRACE_MSG0(HCD, "-----------------------------------------");
++
++ local_irq_save(flags);
++
++ /* reset the host core
++ */
++ fs_wl_clr(HCD, OTG_CORE_RST_CTRL, MODULE_RSTRH | MODULE_RSTHSIE | MODULE_RSTHC);
++ while (fs_rl(OTG_CORE_RST_CTRL));
++
++ fs_host_clock_on();
++
++ for (i = 0; i < NUM_DATA_BUFFS; i++)
++ (void) rel_data_buff(fs_hcpriv, ((fs_data_buff *)OTG_DATA_BASE)+i);
++
++ for (i = 0; i < NUM_ETDS; i++)
++ rel_etd(fs_hcpriv,i);
++
++ fs_wl(OTG_HOST_CONTROL, HOST_CONTROL_HCRESET | HOST_CONTROL_RMTWUEN |
++ HOST_CONTROL_HCUSBSTE_RESET | HOST_CONTROL_CTLBLKSR_11);
++
++
++ //TRACE_MSG0(HCD, "HW HCD_ENABLE_SET");
++ fs_andl(OTG_CORE_HNP_CSTAT, ~(MODULE_MASTER | MODULE_SLAVE | MODULE_CMPEN |
++ MODULE_BGEN | MODULE_SWAUTORST | MODULE_ABBUSREQ));
++ fs_rl(OTG_CORE_HNP_CSTAT);
++
++ fs_orl(OTG_CORE_HNP_CSTAT, MODULE_MASTER | MODULE_CMPEN | MODULE_BGEN | MODULE_ABBUSREQ);
++ fs_orl(OTG_CORE_HNP_CSTAT, MODULE_ARMTHNPE | MODULE_BHNPEN); // XXX
++
++ fs_wl(OTG_HOST_CONTROL, HOST_CONTROL_HCUSBSTE_OPERATIONAL);
++
++ //hcd_hw_enable_interrupts(bus_hcpriv);
++
++ mask = (HOST_PSCINT_EN | HOST_FMOFINT_EN | HOST_HERRINT_EN |
++ HOST_RESDETINT_EN | /* HOST_SOFINT_EN | */ HOST_DONEINT_EN | HOST_SORINT_EN);
++
++ // R1: sec 23.11.15 pg 23-54
++ fs_rl(OTG_CORE_HNP_CSTAT);
++ fs_rl(OTG_HOST_CONTROL);
++ fs_rl(OTG_HOST_ROOTHUB_STATUS);
++ fs_rl(OTG_HOST_PORT_STATUS_1);
++ fs_rl(OTG_HOST_PORT_STATUS_2);
++ fs_rl(OTG_HOST_PORT_STATUS_3);
++
++ fs_wl(OTG_HOST_SINT_STEN, mask);
++ fs_rl(OTG_HOST_SINT_STEN);
++ local_irq_restore(flags);
++ }
++
++ rh_loc_sof_func(otg, flag);
++
++ switch (flag) {
++ case RESET:
++ local_irq_save(flags);
++
++ //printk(KERN_INFO"%s: RESET\n", __FUNCTION__);
++ //TRACE_MSG0(HCD, "HW HCD_ENABLE_RESET");
++
++ //hcd_hw_disable_interrupts(bus_hcpriv);
++ // R1: sec 23.11.15 pg 23-54
++ fs_wl(OTG_HOST_SINT_STAT, 0);
++
++ fs_andl(OTG_HOST_CONTROL, ~HOST_CONTROL_HCUSBSTE_OPERATIONAL);
++
++ // Shut down hardware if not already shut down....
++ //hcd_hw_disable_interrupts(bus_hcpriv);
++
++ fs_host_clock_off();
++ local_irq_restore(flags);
++ break;
++ }
++}
++/* ********************************************************************************************* */
++/* Module init
++ *
++ * Define the global data structures and call the initialization functions required
++ * to start the generic hcd layer and register with the otg core.
++ *
++ */
++
++void rh_suspend_func(struct otg_instance *otg, u8 on);
++void hcd_init_func (struct otg_instance *otg, u8 flag);
++int hcd_probe(struct usb_interface *intf, const struct usb_device_id *id);
++void hcd_disconnect(struct usb_interface *intf);
++
++int fs_mod_init(void);
++#ifdef MODULE
++void fs_mod_exit(void);
++#endif
++
++#if !defined(OTG_C99)
++
++static struct usb_driver mx2_usb_driver;
++fs_hcpriv priv_mx21;
++struct bus_hcpriv fs_bus_hcpriv;
++struct hcd_ops hcd_ops;
++
++
++/*!
++ * fs_hcd_global_init() - initialize global vars for non C99 systems
++ */
++void fs_hcd_global_init(void)
++{
++ ZERO(mx2_usb_driver);
++ mx2_usb_driver.owner = THIS_MODULE;
++ mx2_usb_driver.name = "MX21_HCD";
++ mx2_usb_driver.probe = hcd_probe;
++ mx2_usb_driver.disconnect = hcd_disconnect;
++
++ ZERO(priv_mx21);
++ priv_mx21.free_buffs = 0xffff;
++ priv_mx21.free_etds = 0x0000ffff;
++ priv_mx21.bus_hcpriv = &fs_bus_hcpriv;
++
++ ZERO(fs_bus_hcpriv);
++ fs_bus_hcpriv.hw_hci = &priv_mx21;
++ fs_bus_hcpriv.usb_driver = &mx2_usb_driver;
++ fs_bus_hcpriv.bus_device.driver = &mx2_usb_driver.driver;
++ fs_bus_hcpriv.bus_device.parent = NULL;
++ fs_bus_hcpriv.bus_device.bus = &usb_bus_type; // struct bus_type *
++#if 0
++ strncpy(fs_bus_hcpriv.bus_device.name, "MX21 HOST", sizeof(fs_bus_hcpriv.bus_device.name));
++#endif
++ fs_bus_hcpriv.num_ports = 1;
++ fs_bus_hcpriv.otg_port = 1;
++ fs_bus_hcpriv.otg_capable_mask = (1 << 1);
++ fs_bus_hcpriv.rh_serial = "000001";
++ fs_bus_hcpriv.rh_product = "Virtual Root Hub";
++ fs_bus_hcpriv.rh_manufacturer = "Belcarra Technologies";
++ fs_bus_hcpriv.rh_vendorid = CONFIG_OTG_ROOTHUB_VENDORID;
++ fs_bus_hcpriv.rh_productid = CONFIG_OTG_ROOTHUB_PRODUCTID;
++ fs_bus_hcpriv.rh_bcddevice = CONFIG_OTG_ROOTHUB_BCDDEVICE;
++ fs_bus_hcpriv.rh_bmAttributes = 0x0;
++ fs_bus_hcpriv.rh_bMaxPower = 0;
++
++ fs_bus_hcpriv.max_active_transfers = NUM_ETDS;
++ fs_bus_hcpriv.max_active_urbs = NUM_ETDS;
++
++ ZERO(hcd_ops);
++ hcd_ops.name = "MX21 HCD";
++ hcd_ops.max_ports = 1;
++ hcd_ops.capabilities = 0;
++ // module
++ hcd_ops.mod_init = fs_mod_init; // called for module init
++#ifdef MODULE
++ hcd_ops.mod_exit = fs_mod_exit; // called for module exit
++#endif
++ // otg state machine
++ hcd_ops.hcd_init_func = hcd_init_func; // initialize when otg enabled
++ hcd_ops.hcd_en_func = fs_hcd_en_func; // setup hardware as host
++ hcd_ops.loc_suspend_func = rh_loc_suspend_func; // enable port on hub
++ hcd_ops.loc_sof_func = fs_loc_sof_func; // enable port on hub
++};
++
++#else /* !defined(OTG_C99) */
++
++static struct usb_driver mx2_usb_driver = {
++ .owner = THIS_MODULE,
++ .name = "MX21_HCD",
++ .probe = hcd_probe,
++ .disconnect = hcd_disconnect,
++};
++
++extern struct bus_hcpriv fs_bus_hcpriv;
++fs_hcpriv priv_mx21 = {
++ .free_buffs = 0xffff,
++ .free_etds = 0x0000ffff,
++ .bus_hcpriv = &fs_bus_hcpriv,
++};
++
++struct bus_hcpriv fs_bus_hcpriv = {
++
++ .hw_hci = &priv_mx21,
++ .usb_driver = &mx2_usb_driver,
++ .bus_device.driver = &mx2_usb_driver.driver,
++ .bus_device.parent = NULL,
++ .bus_device.bus = &usb_bus_type, // struct bus_type *
++ .bus_device.name = "MX21 HOST",
++
++ .num_ports = 1,
++ .otg_port = 1,
++ .otg_capable_mask = (1 << 1),
++ .rh_serial = "000001",
++ .rh_product = "Virtual Root Hub",
++ .rh_manufacturer = "Belcarra Technologies",
++ .rh_vendorid = CONFIG_OTG_ROOTHUB_VENDORID,
++ .rh_productid = CONFIG_OTG_ROOTHUB_PRODUCTID,
++ .rh_bcddevice = CONFIG_OTG_ROOTHUB_BCDDEVICE,
++ .rh_bmAttributes = 0x0,
++ .rh_bMaxPower = 0,
++
++ .max_active_transfers = NUM_ETDS,
++ .max_active_urbs = NUM_ETDS,
++};
++
++struct hcd_ops hcd_ops = {
++
++ .name = "MX21 HCD",
++ .max_ports = 1,
++ .capabilities = 0,
++ // module
++ .mod_init = fs_mod_init, // called for module init
++#ifdef MODULE
++ .mod_exit = fs_mod_exit, // called for module exit
++#endif
++ .hcd_init_func = hcd_init_func, // initialize when otg enabled
++ .hcd_en_func = fs_hcd_en_func, // setup hardware as host
++ .loc_suspend_func = rh_loc_suspend_func, // enable port on hub
++ .loc_sof_func = fs_loc_sof_func, // enable port on hub
++};
++#endif /* !defined(OTG_C99) */
++
++
++extern int hcd_init(struct bus_hcpriv *bus_hcpriv, struct usb_driver *usb_driver);
++extern void hcd_exit(struct bus_hcpriv *bus_hcpriv, struct usb_driver *usb_driver);
++
++/*!
++ * fs_mod_init() - initialize mx2 hcd
++ *
++ * This calls hcd_init() with the mx2 data structures.
++ */
++int fs_mod_init(void)
++{
++ RETURN_ENOMEM_IF(hcd_init(&fs_bus_hcpriv, &mx2_usb_driver));
++
++ hcd_instance->privdata = &fs_bus_hcpriv;
++ return 0;
++}
++
++#ifdef MODULE
++/*!
++ * fs_mod_exit() - de-initialize mx2 hcd
++ *
++ * This calls hcd_exit() with the mx2 data structures.
++ */
++void fs_mod_exit(void)
++{
++ hcd_exit(&fs_bus_hcpriv, &mx2_usb_driver);
++}
++#endif
++
++/* @} */
++
+diff -uNr linux/drivers/no-otg/ocd/fsotg/fs-ocd.c linux/drivers/otg/ocd/fsotg/fs-ocd.c
+--- linux/drivers/no-otg/ocd/fsotg/fs-ocd.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/fsotg/fs-ocd.c 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,263 @@
++/*
++ * otg/ocd/fsotg/fs-ocd.c -- USB Device Controller driver
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/ocd/fsotg/fs-ocd.c
++ * @brief Freescale USB OTG Controller Driver
++ * This is the OTG Controller Driver.
++ *
++ * This implements overall configuration and control of the Freescale OTG hardware
++ * and implements the main interrupt handler.
++ *
++ * There is some processor specific code here to support the alternate processors
++ * that implement this type of USB support.
++ *
++ * There is no board or platform level code here.
++ *
++ * @ingroup FSOTG
++ *
++ * @{
++ */
++
++#include <otg/pcd-include.h>
++#include <linux/pci.h>
++#include <asm/arch/mx2.h>
++#undef GPT_BASE_ADDR
++#include <asm/arch/gpt.h>
++#include <asm/arch/clk.h>
++
++#include <otghw/fsotg-hardware.h>
++
++
++/* ********************************************************************************************* */
++#define TIMEOUT_VALUE 1000
++/*!
++ * fs_func_clock_on() - enable function controller clock
++ */
++void fs_func_clock_on(void)
++{
++ u32 timeout = TIMEOUT_VALUE;
++ //TRACE_MSG0(OCD, "FUNC CLOCK ON:");
++ fs_orl(OTG_CORE_CLK_CTRL, MODULE_FUNC_CLK);
++ while(!( fs_rl(OTG_CORE_CLK_CTRL) & MODULE_FUNC_CLK)) { timeout--; if (!timeout) break; }
++
++ //fs_orl(OTG_CORE_CINT_STEN, MODULE_ASFCINT_EN |MODULE_FCINT_EN);
++}
++
++/*!
++ * fs_host_clock_on() - enable host controller clock
++ */
++void fs_host_clock_on(void)
++{
++ u32 timeout = TIMEOUT_VALUE;
++ //TRACE_MSG0(OCD, "HOST CLOCK ON");
++ fs_orl(OTG_CORE_CLK_CTRL, MODULE_HOST_CLK);
++ while(!( fs_rl(OTG_CORE_CLK_CTRL) & MODULE_HOST_CLK)) { timeout--; if (!timeout) break; }
++}
++
++/*!
++ * fs_func_clock_off() - disable function controller clock
++ */
++void fs_func_clock_off(void)
++{
++ u32 timeout = TIMEOUT_VALUE;
++ //TRACE_MSG0(OCD, "FUNC CLOCK OFF");
++ fs_andl(OTG_CORE_CLK_CTRL, 0x0);
++ while((fs_rl(OTG_CORE_CLK_CTRL) & (MODULE_FUNC_CLK | MODULE_MAIN_CLK))) { timeout--; if (!timeout) break; }
++}
++
++/*!
++ * fs_host_clock_off() - disable host controller clock
++ */
++void fs_host_clock_off(void)
++{
++ u32 timeout = TIMEOUT_VALUE;
++ //TRACE_MSG0(OCD, "HOST CLOCK OFF");
++ fs_andl(OTG_CORE_CLK_CTRL, 0x0);
++ while((fs_rl(OTG_CORE_CLK_CTRL) & (MODULE_HOST_CLK | MODULE_MAIN_CLK))) { timeout--; if (!timeout) break; }
++}
++
++/*!
++ * fs_main_clock_on() - enable main clock
++ */
++void fs_main_clock_on(void)
++{
++ u32 timeout = TIMEOUT_VALUE;
++ //TRACE_MSG0(OCD, "MAINFUNC CLOCK ON");
++ fs_orl(OTG_CORE_CLK_CTRL, MODULE_MAIN_CLK);
++ while(!( fs_rl(OTG_CORE_CLK_CTRL) & MODULE_MAIN_CLK)) { timeout--; if (!timeout) break; }
++}
++
++/*!
++ * fs_main_clock_off() - disable main clock
++ */
++void fs_main_clock_off(void)
++{
++ u32 timeout = TIMEOUT_VALUE;
++ //TRACE_MSG0(OCD, "MAIN CLOCK OFF");
++ fs_wl_set(OCD, OTG_CORE_CLK_CTRL, 0);
++ while((fs_rl(OTG_CORE_CLK_CTRL) & MODULE_MAIN_CLK)) { timeout--; if (!timeout) break; }
++}
++
++/* ********************************************************************************************* */
++
++/*!
++ * fs_disable_interrupts() - disable interrupts
++ */
++void fs_disable_interrupts (void)
++{
++ fs_wl(OTG_CORE_CINT_STEN, 0 );
++ fs_wl(OTG_CORE_HINT_STEN, 0 );
++ fs_wl(OTG_HOST_SINT_STEN, 0 );
++ fs_wl(OTG_HOST_XYINT_STEN, 0 );
++ fs_wl(OTG_HOST_ETD_EN, 0);
++ fs_wl(OTG_HOST_ETD_DONE, 0 );
++ fs_wl(OTG_FUNC_SINT_STEN, 0 );
++ fs_wl(OTG_FUNC_XYINT_STEN, 0 );
++ fs_wl(OTG_FUNC_EP_EN, 0 );
++ fs_wl(OTG_FUNC_EP_DEN, 0 );
++}
++
++/* ********************************************************************************************* */
++
++/* ********************************************************************************************* */
++/*!
++ * fs_init() - initial tcd setup
++ * Allocate interrupts and setup hardware.
++ */
++void fs_init (void)
++{
++ int timeout;
++ unsigned long flags;
++
++ TRACE_MSG0(OCD, "MX2_MOD_OCD_INIT");
++ local_irq_save (flags);
++
++ fs_wl(OTG_SYS_CTRL, 0x0);
++
++ /* 2. Ensure hardware is reset and cleared
++ */
++ fs_clear_words((volatile u32 *)MX2_IO_ADDRESS(OTG_DMA_BASE), (32*16/4));
++ //fs_clear((void *)MX2_IO_ADDRESS(OTG_FUNC_BASE), 0x200);
++ fs_main_clock_off();
++
++ fs_wl_clr(OCD, OTG_CORE_RST_CTRL, MODULE_RSTI2C | 0x3f);
++ while (fs_rl(OTG_CORE_RST_CTRL));
++
++ /* 3. OTG Hardware Mode and clocks
++ * set to diff, diff and Configure the OTG to behave as function
++ */
++ TRACE_MSG0(OCD, "3. OTG Software Mode and clock");
++ fs_andl(OTG_CORE_HWMODE, 0xffffff0f); // clear
++ fs_orl(OTG_CORE_HWMODE, MODULE_CRECFG_SHNP); // set to software hnp
++ fs_rl(OTG_CORE_HWMODE);
++
++ fs_andl(OTG_CORE_HNP_CSTAT, ~0x00000800);
++ fs_rl(OTG_CORE_HNP_CSTAT);
++
++ fs_wl_set(OCD, OTG_CORE_HNP_T3PCR, 0x00000000);
++ fs_rl(OTG_CORE_HNP_T3PCR);
++
++ TRACE_MSG0(OCD, "6. Enable ");
++ TRACE_MSG0(OCD, "enable core interrupts");
++
++ fs_wl(OTG_CORE_CINT_STEN, 0);
++
++ fs_wl(OTG_CORE_CINT_STEN, MODULE_ASHNPINT_EN |
++ MODULE_ASHCINT_EN | MODULE_HNPINT_EN | MODULE_HCINT);
++
++
++ TRACE_MSG0(OCD, "enable host interrupts");
++ fs_wl(OTG_CORE_HINT_STEN, HNP_I2COTGINT_EN | HNP_AWAITBTO_EN |
++ HNP_AIDLEBDTO_EN | HNP_SRPSUCFAIL_EN | HNP_SRPINT_EN | HNP_VBUSERROR_EN |
++ HNP_ABSEVAILD_EN | HNP_ABUSVALID_EN | HNP_MASSLVCHG_EN | HNP_IDCHANGE_EN);
++
++ TRACE_MSG0(OCD, "disable various host interrupts");
++ fs_wl(OTG_HOST_XYINT_STEN, 0);
++ fs_wl(OTG_HOST_ETD_EN, 0);
++ fs_wl(OTG_HOST_ETD_DONE, 0);
++ fs_wl(OTG_HOST_SINT_STEN, 0);
++
++ TRACE_MSG0(OCD, "disable various function interrupts");
++ fs_wl(OTG_FUNC_XYINT_STEN, 0);
++ fs_wl(OTG_FUNC_EP_EN, 0);
++ fs_wl(OTG_FUNC_EP_DEN, 0);
++
++ fs_wl(OTG_DMA_DINT_STEN, 0x3);
++ //fs_wb(I2C_MASTER_INT_REG_ADD, 0xf0);
++ //fs_wb(I2C_MASTER_INT_REG_ADD, 0x00);
++
++ // XXX note that newer designs than the mx21 will also need to check
++ // and/or set OTG_CORE_INTERRUPT_STEN
++
++
++ TRACE_MSG0(OCD, "--");
++ TRACE_MSG0(OCD, "8. Ready ");
++ TRACE_MSG0(OCD, "--");
++
++ local_irq_restore (flags);
++}
++
++extern void fs_stop_ep(int epn, int dir);
++
++/*!
++ * fs_exit() - de-initialize
++ */
++void fs_exit(void)
++{
++ int i;
++ unsigned long flags;
++ TRACE_MSG0(OCD, "MX2_MOD_OCD_EXIT");
++
++ fs_disable_interrupts();
++ //_reg_CRM_PCCR1 &= ~(1<<27); // disable GPT3
++
++ local_irq_save (flags);
++ for (i = 0; i < 16; i++) {
++ fs_stop_ep(i, USB_DIR_IN);
++ fs_stop_ep(i, USB_DIR_OUT);
++ }
++ fs_clear_words((volatile u32 *)MX2_IO_ADDRESS(OTG_EP_BASE), (32*16/4));
++ //fs_clear((void *)MX2_IO_ADDRESS(OTG_EP_BASE), 0x200);
++ //fs_clear((volatile u32 *)MX2_IO_ADDRESS(OTG_DMA_BASE), 32*16);
++ //fs_clear((void *)MX2_IO_ADDRESS(OTG_FUNC_BASE), 0x200);
++ fs_wl( OTG_CORE_HWMODE, 0xa3);
++ fs_main_clock_off();
++ local_irq_restore (flags);
++}
++
++
++/*!
++ * fs_ocd_init() - used to initialize/enable or disable the tcd driver
++ * @param otg
++ * @param flag
++ */
++void fs_ocd_init(struct otg_instance *otg, u8 flag)
++{
++ TRACE_MSG0(OCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(OCD, "MX2_OCD_EN SET");
++ fs_init();
++ otg_event(otg, TCD_OK | ID_FLOAT, OCD, "OCD_OK");
++ break;
++ case RESET:
++ fs_exit();
++ TRACE_MSG0(OCD, "MX2_OCD_EN RESET");
++ otg_event(otg, TCD_OK | ID_FLOAT, OCD, "OCD_OK");
++ break;
++ }
++}
++
++/* ********************************************************************************************* */
++
++/* @} */
++
+diff -uNr linux/drivers/no-otg/ocd/fsotg/fs-pcd.c linux/drivers/otg/ocd/fsotg/fs-pcd.c
+--- linux/drivers/no-otg/ocd/fsotg/fs-pcd.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/fsotg/fs-pcd.c 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,793 @@
++/*
++ * otg/ocd/fsotg/fs-pcd.c -- Freescale USBOTG Peripheral Controller driver
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/ocd/fsotg/fs-pcd.c
++ * @brief Freescale USB Peripheral Controller Driver
++ * This implements the Freescale USBOTG Peripheral Controller Driver.
++ *
++ * There is some processor specific code here to support the alternate processors
++ * that implement this type of USB support.
++ *
++ * There is no board or platform level code here.
++ *
++ * @ingroup FSOTG
++ *
++ * @{
++ */
++
++#include <otg/pcd-include.h>
++#include <linux/pci.h>
++#include <asm/arch/mx2.h>
++
++#include <otghw/fsotg-hardware.h>
++
++void fs_func_clock_on(void); /* defined in mx2-ocd.c */
++void fs_func_clock_off(void); /* defined in mx2-ocd.c */
++
++u8 fs_new_address, fs_usb_address; /* used to save and set USB address */
++
++/* ********************************************************************************************* */
++/*!
++ * fs_ep_config() - configure and enable an endpoint to send or receive data
++ * First setup the endpoint descriptor words, and then enable the endpoint and done interrupt
++ * @param epn - endpoint number
++ * @param dir - direction IN or OUT
++ * @param ep_num -
++ * @param wMaxPacketSize
++ * @param format
++ * @param ttlbtecnt
++ * @param stall
++ */
++static void inline
++fs_ep_config(int epn, int dir, u32 ep_num, int wMaxPacketSize, int format, int ttlbtecnt, int stall)
++{
++ TRACE_MSG6(PCD, "epn: %02x dir: %02x sz: %d fmt: %x cnt: %d stall: %d",
++ epn, dir, wMaxPacketSize, format, ttlbtecnt, stall);
++
++ fs_wl(ep_word(epn, dir, 0), ((stall ? 1 : 0) << 31) | (wMaxPacketSize << 16) | ((format & 3) << 14));
++ fs_wl(ep_word(epn, dir, 1), ttlbtecnt ? (data_y_buf(epn, dir) << 16) | data_x_buf(epn, dir): 0);
++ fs_wl(ep_word(epn, dir, 3), ((wMaxPacketSize-1) << 21) | ttlbtecnt);
++ fs_orl(OTG_FUNC_IINT, ep_num); // issue done status interrupts immediately
++ fs_orl(OTG_FUNC_EP_DEN, ep_num); // enable endpoint done interrupt
++ fs_orl(OTG_FUNC_EP_EN, ep_num); // enable the interrupt
++}
++
++/*!
++ * fs_ep_config_dma() - configure and enable an endpoint to send or receive data
++ * Check the RDY bit and clear if necessary, setup dma, do common setup and then set RDY.
++ * @param epn - endpoint number
++ * @param dir - direction IN or OUT
++ * @param wMaxPacketSize
++ * @param format
++ * @param ttlbtecnt
++ * @param bp
++ */
++static void inline
++fs_ep_config_dma(int epn, int dir, int wMaxPacketSize, int format, int ttlbtecnt, u8 *bp)
++{
++ u32 ep_num = ep_num_dir(epn, dir);
++ u32 dma_num = dma_num_dir(epn, dir);
++ TRACE_MSG2(PCD, "EP CONFIG DMA: epn: %02x num: %02x", epn, ep_num);
++ if (fs_rl(OTG_FUNC_EP_RDY) & ep_num) fs_wl_set(PCD, OTG_FUNC_EP_RDY, ep_num);
++ fs_wl(OTG_DMA_EPN_MSA(dma_num), (int)bp);
++ fs_wl_set(PCD, OTG_DMA_EP_EN, ep_num);
++ fs_ep_config(epn, dir, ep_num, wMaxPacketSize, format, ttlbtecnt, 0);
++ fs_wl_set(PCD, OTG_FUNC_EP_RDY, ep_num); // toggle ready bit
++}
++
++/*!
++ * fs_ep_config_nodma() - configure and enable an endpoint to send or receive data
++ * Non-DMA setup, optional stall, ready etc.
++ * @param epn - endpoint number
++ * @param dir
++ * @param stall - stall endpoint
++ * @param wMaxPacketSize
++ * @param format
++ * @param ttlbtecnt
++ * @param rdy1
++ * @param rdy2
++ */
++static void
++fs_ep_config_nodma(int epn, int dir, int stall, int wMaxPacketSize, int format, int ttlbtecnt, int rdy1, int rdy2)
++{
++ u32 ep_num = ep_num_dir(epn, dir);
++ TRACE_MSG5(PCD, "EP CONFIG NODMA: epn: %02x num: %02x stall: %d r1: %d r2: %d", epn, ep_num, stall, rdy1, rdy2);
++ #if 1
++ // XXX This should work, but enumeratation fails after disable/enable
++ if (rdy1) {
++ TRACE_MSG3(PCD, "EP CONFIG NODMA: epn: %02x num: %02x checking RDY: %02x",
++ epn, ep_num, rdy1 && fs_rl(OTG_FUNC_EP_RDY) & ep_num);
++ RETURN_IF (rdy1 && (fs_rl(OTG_FUNC_EP_RDY) & ep_num));
++ }
++ #endif
++ UNLESS(epn)
++ fs_orl(OTG_FUNC_XYINT_STEN, ep_num); // enable x or y buffer interrupt
++
++ fs_ep_config(epn, dir, ep_num, wMaxPacketSize, format, ttlbtecnt, stall);
++ RETURN_UNLESS(rdy2);
++ UNLESS (fs_rl(OTG_FUNC_EP_RDY) & ep_num) fs_wl_set(PCD, OTG_FUNC_EP_RDY, ep_num); // toggle ready bit
++}
++
++/*!
++ * fs_sendzlp() - start sending a buffer on a specified endpoint
++ * Toggle XFILL_STAT or YFILL_STAT bit, then call fs_ep_config_nodma().
++ * @param epn - endpoint number
++ * @param endpoint - endpoint instance
++ * @param wMaxPacketSize
++ */
++static void inline
++fs_sendzlp (int epn, struct usbd_endpoint_instance *endpoint, int wMaxPacketSize)
++{
++ u32 ep_num_in = ep_num_in(epn);
++ TRACE_MSG0(PCD, "ZLP");
++ if (!(fs_rl(OTG_FUNC_XFILL_STAT) & ep_num_in)) {
++ //TRACE_MSG0(PCD, "EMPTY Y BUFFER: ZLP");
++ fs_wl_set(PCD, OTG_FUNC_XFILL_STAT, ep_num_in);
++ }
++ else if (!(fs_rl(OTG_FUNC_YFILL_STAT) & ep_num_in)) {
++ //TRACE_MSG0(PCD, "EMPTY Y BUFFER: ZLP");
++ fs_wl_set(PCD, OTG_FUNC_YFILL_STAT, ep_num_in);
++ }
++ fs_ep_config_nodma(epn, USB_DIR_IN, 0, endpoint->wMaxPacketSize, endpoint->bmAttributes & 0x3, 0, 1, 1);
++}
++
++/*!
++ * fs_stop_ep() - stop endpoint
++ * @param epn - endpoint number
++ * @param dir - direction IN or OUT
++ */
++static void fs_stop_ep(int epn, int dir)
++{
++ int ep_num = ep_num_dir(epn, dir);
++
++ TRACE_MSG3(PCD, "STOP EP: %08x dir: %02x [%08x]", ep_num, dir, fs_rl(ep_word(epn, dir, 0)));
++
++ //fs_wl(ep_word(epn, dir, 0), ((stall ? 1 : 0) << 31) | (wMaxPacketSize << 16) | ((format & 3) << 14));
++
++ if (fs_rl(OTG_FUNC_EP_RDY) & ep_num)
++ fs_wl_clr(PCD, OTG_FUNC_EP_RDY, ep_num);
++ fs_andl(OTG_FUNC_XYINT_STEN, ~ep_num);
++ fs_andl(OTG_FUNC_IINT, ~ep_num);
++ if (fs_rl(OTG_FUNC_XINT_STAT) & ep_num) {
++ fs_wl_clr(PCD, OTG_FUNC_XINT_STAT, ep_num);
++ fs_wl_clr(PCD, OTG_FUNC_XFILL_STAT, ep_num);
++ }
++ else if (fs_rl(OTG_FUNC_YINT_STAT) & ep_num) {
++ fs_wl_clr(PCD, OTG_FUNC_YINT_STAT, ep_num);
++ fs_wl_clr(PCD, OTG_FUNC_YFILL_STAT, ep_num);
++ }
++}
++
++/* ********************************************************************************************* */
++/*!
++ * fs_pcd_setup_ep() - setup endpoint
++ * @param pcd - pcd instance
++ * @param epn - endpoint number
++ * @param endpoint - endpoint instance
++ */
++static void inline
++fs_pcd_setup_ep (struct pcd_instance *pcd, unsigned int epn, struct usbd_endpoint_instance *endpoint)
++{
++ TRACE_MSG2(PCD, "START EPN: config %d %02x", epn, endpoint->bEndpointAddress);
++ if (epn && endpoint->bEndpointAddress)
++ fs_ep_config_nodma(endpoint->bEndpointAddress & 0x7f, endpoint->bEndpointAddress & USB_DIR_IN, 0,
++ endpoint->wMaxPacketSize, endpoint->bmAttributes&0x3, 0, 0, 0);
++}
++
++/*!
++ * fs_pcd_start_ep0_setup() - enable ep0 for receiving SETUP request
++ * Unless already ready, configure ep0 to receive.
++ * @param endpoint - endpoint instance
++ */
++static void inline
++fs_pcd_start_ep0_setup (struct usbd_endpoint_instance *endpoint)
++{
++ TRACE_MSG0(PCD, "START EP0: config");
++ fs_ep_config_nodma(0, USB_DIR_OUT, 0, endpoint->wMaxPacketSize, endpoint->bmAttributes&0x3,
++ endpoint->wMaxPacketSize, 0, 1); // XXX rdy1 must be zero
++}
++/* ********************************************************************************************* */
++/*!
++ * fs_pcd_start_endpoint_out() - start receive
++ * @param pcd - pcd instance
++ * @param endpoint - endpoint number
++ */
++static void
++fs_pcd_start_endpoint_out(struct pcd_instance *pcd, struct usbd_endpoint_instance *endpoint)
++{
++ struct usbd_urb *rcv_urb = pcd_rcv_next_irq(endpoint);
++ int epn = endpoint->bEndpointAddress & 0x7f;
++ UNLESS (rcv_urb) {
++ UNLESS (!epn) fs_pcd_start_ep0_setup(endpoint); // if EP0 then restart for receive setup
++ return;
++ }
++ rcv_urb->pcimap = (void *)pci_map_single (NULL, (void *) rcv_urb->buffer, rcv_urb->buffer_length, PCI_DMA_FROMDEVICE);
++ fs_ep_config_dma(epn, USB_DIR_OUT, endpoint->wMaxPacketSize, endpoint->bmAttributes & 0x3,
++ rcv_urb->buffer_length, rcv_urb->pcimap);
++ TRACE_MSG3(PCD, "START OUT: %02x rcv_urb: %x length: %d", endpoint->bEndpointAddress, rcv_urb, rcv_urb->actual_length);
++}
++
++/*!
++ * fs_pcd_stop_out() - process interrupt for received buffer
++ * @param pcd - pcd instance
++ * @param epn - endpoint number
++ * @param endpoint - endpoint instance
++ */
++static void
++fs_pcd_stop_out (struct pcd_instance *pcd, int epn, struct usbd_endpoint_instance *endpoint)
++{
++ struct usbd_urb *rcv_urb = pcd_rcv_next_irq(endpoint);
++ u32 ep3 = fs_rl(ep_word(epn, USB_DIR_OUT, 3));
++ u32 ep_num_out = ep_num_out(epn);
++ fs_stop_ep(epn, USB_DIR_OUT);
++ RETURN_UNLESS (rcv_urb);
++ pcd_rcv_finished_irq (endpoint,rcv_urb->buffer_length - (ep3 & 0xffff), 0); // XXX fix mask
++ if (!epn)
++ fs_sendzlp(epn, endpoint, endpoint->wMaxPacketSize); // ZLP
++ else
++ fs_pcd_start_endpoint_out(pcd, endpoint); // restart
++}
++/* fs_pcd_cancel_out_irq - cancel OUT urb
++ */
++static void
++fs_pcd_cancel_out_irq (struct pcd_instance *pcd,struct usbd_urb *urb)
++{
++ struct usbd_endpoint_instance *endpoint = urb->endpoint;
++ int epn = endpoint->bEndpointAddress & 0x7f;
++ TRACE_MSG3(PCD, "urb: %x endpoint: %x epn: %d", urb, endpoint, epn);
++ fs_pcd_stop_out (pcd, epn, endpoint);
++}
++/* ********************************************************************************************* */
++/*!
++ * fs_pcd_start_endpoint_in() - start transmit
++ * Get next tx_urb (completing old one if there is one) and start sending it.
++ * @param pcd - pcd instance
++ * @param endpoint - endpoint instance
++ */
++static void
++fs_pcd_start_endpoint_in(struct pcd_instance *pcd, struct usbd_endpoint_instance *endpoint)
++{
++ struct usbd_urb *tx_urb = pcd_tx_complete_irq(endpoint, 0);
++ int epn = endpoint->bEndpointAddress & 0x7f;
++
++ UNLESS (tx_urb) {
++ TRACE_MSG1(PCD, "START IN: %02x finished", endpoint->bEndpointAddress);
++ UNLESS (epn) { // if not EP0 we are done
++ if (fs_new_address != fs_usb_address) {
++ fs_usb_address = fs_new_address;
++ //TRACE_MSG1(PCD, "START IN: SETTING ADDRESS %x", fs_usb_address);
++ fs_wl(OTG_FUNC_DEV_ADDR, fs_usb_address);
++ }
++ fs_pcd_start_ep0_setup(endpoint); // if EP0 then restart for receive setup
++ }
++ return;
++ }
++
++ if (pcd_tx_sendzlp(endpoint)) { // check if we need to send ZLP
++ TRACE_MSG1(PCD, "START IN: ZLP tx_urb: %x", tx_urb);
++ fs_sendzlp(epn, endpoint, endpoint->wMaxPacketSize); // ZLP
++ return;
++ }
++ endpoint->last = tx_urb->actual_length;
++ consistent_sync (tx_urb->buffer, tx_urb->actual_length, PCI_DMA_BIDIRECTIONAL);
++ fs_ep_config_dma(epn, USB_DIR_IN, endpoint->wMaxPacketSize, endpoint->bmAttributes & 0x3,
++ tx_urb->actual_length, tx_urb->buffer);
++
++ TRACE_MSG4(PCD, "START IN: %02x tx_urb: %x length: %d %s",
++ endpoint->bEndpointAddress, tx_urb, tx_urb->actual_length,
++ (tx_urb->flags & USBD_URB_SENDZLP) ? "ZLP": "");
++}
++
++/*!
++ * fs_pcd_stop_in() - process interrupt for transmitted buffer
++ * @param pcd - pcd instance
++ * @param epn -endpoint number
++ * @param endpoint - endpoint instance
++ */
++static void inline
++fs_pcd_stop_in (struct pcd_instance *pcd, int epn, struct usbd_endpoint_instance *endpoint)
++{
++ fs_stop_ep(epn, USB_DIR_IN);
++ fs_pcd_start_endpoint_in(pcd, endpoint);
++}
++/*!
++ * fs_pcd_cancel_in_irq() - cancel IN urb
++ */
++static void inline
++fs_pcd_cancel_in_irq (struct pcd_instance *pcd,struct usbd_urb *urb)
++{
++ struct usbd_endpoint_instance *endpoint = urb->endpoint;
++ int epn = endpoint->bEndpointAddress & 0x7f;
++ TRACE_MSG3(PCD, "urb: %x endpoint: %x epn: %d", urb, endpoint, epn);
++ fs_pcd_stop_in (pcd, epn, endpoint);
++}
++
++/* ********************************************************************************************* */
++/*!
++ * fs_pcd_stop_ep0_setup() - setup endpoint zero
++ * @param pcd - pcd instance
++ * @param endpoint - endpoint instance
++ */
++static void
++fs_pcd_stop_ep0_setup (struct pcd_instance *pcd, struct usbd_endpoint_instance *endpoint)
++{
++ static struct usbd_device_request request;
++ u8 *cp = (u8 *) &request;
++ u32 ep0 = fs_rl(ep_word(0, USB_DIR_OUT, 0));
++ u32 ep3 = fs_rl(ep_word(0, USB_DIR_OUT, 3));
++
++ fs_andl(OTG_FUNC_XYINT_STEN, ~ep_num_both(0));
++ fs_andl(OTG_FUNC_IINT, ~ep_num_both(0));
++ UNLESS (ep0 & EP0_SETUP) { // check if SETUP flag set
++ fs_pcd_stop_out(pcd, 0, endpoint);
++ return;
++ }
++ TRACE_MSG1(PCD, "EP0 - SETUP: size: %x", ep3 & 0xffff);
++ pcd_tx_cancelled_irq(endpoint);
++ pcd_rcv_cancelled_irq(endpoint);
++ fs_orl(OTG_FUNC_EP_TOGGLE, 0x2); // XXX is this required?
++
++ /* get request from x or y buffer
++ */
++ if (fs_rl(OTG_FUNC_XINT_STAT) & ep_num_out(0)) {
++ TRACE_MSG0(PCD, "READ X SETUP");
++ fs_memcpy((u8 *)&request, (u8 *)data_x_address(0, USB_DIR_OUT), 8);
++ fs_wl_clr(PCD, OTG_FUNC_XINT_STAT, ep_num_out(0));
++ fs_wl_clr(PCD, OTG_FUNC_XFILL_STAT, ep_num_out(0));
++ fs_rl(OTG_FUNC_XFILL_STAT);
++ }
++ else if (fs_rl(OTG_FUNC_YINT_STAT) & ep_num_out(0)) {
++ TRACE_MSG0(PCD, "READ Y SETUP");
++ fs_memcpy((u8 *)&request, (u8 *)data_y_address(0, USB_DIR_OUT), 8);
++ fs_wl_clr(PCD, OTG_FUNC_YINT_STAT, ep_num_out(0));
++ fs_wl_clr(PCD, OTG_FUNC_YFILL_STAT, ep_num_out(0));
++ fs_rl(OTG_FUNC_YFILL_STAT);
++ }
++ else
++ TRACE_MSG0(PCD, "READ NO SETUP"); // XXX what should we do here?
++ if (pcd_recv_setup_irq(pcd, &request)) { // process setup packet
++ TRACE_MSG0(PCD, "pcd_ep0: STALLING");
++ fs_rl(OTG_FUNC_XINT_STAT);
++ fs_ep_config_nodma(0, USB_DIR_IN, 1, endpoint->wMaxPacketSize, endpoint->bmAttributes & 0x3, 0, 1, 1);
++ return;
++ }
++ RETURN_IF (request.wLength); // fs_pcd_start_endpoint_in() will start xfer
++ if ((request.bmRequestType & USB_REQ_DIRECTION_MASK) == USB_REQ_HOST2DEVICE) {
++ //RETURN_IF (request.wLength); // fs_pcd_start_endpoint_in() will start xfer
++ fs_sendzlp(0, endpoint, endpoint->wMaxPacketSize); // wLength zero, so send ZLP
++ return;
++ }
++ fs_pcd_start_ep0_setup(endpoint); // restart endpoint
++}
++/* ********************************************************************************************* */
++static int pcd_resetdet_count;
++/*!
++ * fs_pcd_int_hndlr() - interrupt handler
++ * @param irq
++ * @param dev_id
++ * @param regs
++ * @return interrupt handled status
++ */
++static irqreturn_t
++fs_pcd_int_hndlr (int irq, void *dev_id, struct pt_regs *regs)
++{
++ struct pcd_instance *pcd = pcd_instance;
++ u32 cmd_stat, sint_stat, ep_dstat, ep_stats, mask;
++
++ /* Reset and process any System interrupts
++ */
++ if ((sint_stat = fs_rl(OTG_FUNC_SINT_STAT)))
++ fs_wl_clr(PCD, OTG_FUNC_SINT_STAT, sint_stat);
++
++ cmd_stat = fs_rl(OTG_FUNC_CMD_STAT);
++
++ TRACE_MSG2(PCD, "FUNC INT sint: %08x cmd: %08x", sint_stat, cmd_stat);
++
++ if ((cmd_stat & COMMAND_RESETDET) || (sint_stat & SYSTEM_RESETINT)) {
++ TRACE_MSG1(PCD, "RESETDET: %08x", sint_stat);
++ usbd_bus_event_handler_irq (pcd->bus, DEVICE_RESET, 0);
++ fs_wl(OTG_FUNC_DEV_ADDR, 0);
++ fs_new_address = fs_usb_address = 0;
++ fs_wl(OTG_FUNC_XYINT_STEN, 0);
++ fs_wl(OTG_FUNC_IINT, 0);
++ //fs_wl(OTG_FUNC_EP_DEN, 0); // XXX this fails,
++ fs_wl(OTG_FUNC_EP_TOGGLE, 0);
++ fs_wl_clr(PCD, OTG_FUNC_EP_RDY, fs_rl(OTG_FUNC_EP_RDY));
++ fs_wl_clr(PCD, OTG_FUNC_EP_DSTAT, fs_rl(OTG_FUNC_EP_DSTAT));
++ fs_wl_clr(PCD, OTG_FUNC_XINT_STAT, fs_rl(OTG_FUNC_XINT_STAT));
++ fs_wl_clr(PCD, OTG_FUNC_YINT_STAT, fs_rl(OTG_FUNC_YINT_STAT));
++ if (pcd_resetdet_count++ > 10) {
++
++ //printk(KERN_INFO"%s: SINT: %08x %08x CINT: %08x\n", __FUNCTION__,
++ // sint_stat, fs_rl(OTG_FUNC_SINT_STEN), fs_rl(OTG_CORE_CINT_STEN));
++ fs_func_clock_on();
++ fs_wl(OTG_FUNC_SINT_STEN, 0);
++ fs_wl(OTG_CORE_CINT_STEN, 0);
++ fs_wl(OTG_FUNC_XYINT_STEN, 0);
++ fs_wl(OTG_FUNC_EP_EN, 0);
++ fs_wl(OTG_FUNC_EP_DEN, 0);
++ fs_func_clock_off();
++ //printk(KERN_INFO"%s: SINT: %08x %08x CINT: %08x RESET\n", __FUNCTION__,
++ // sint_stat, fs_rl(OTG_FUNC_SINT_STEN), fs_rl(OTG_CORE_CINT_STEN));
++ }
++ }
++ if ((cmd_stat & COMMAND_RSMINPROG) || (sint_stat & SYSTEM_RSMFININT)) {
++ TRACE_MSG1(PCD, "RSMINPRO: %08x", sint_stat);
++ fs_wl_set(PCD, OTG_FUNC_SINT_STAT,SYSTEM_RSMFININT);
++ fs_func_clock_on();
++ usbd_bus_event_handler_irq (pcd->bus, DEVICE_BUS_ACTIVITY, 0);
++ }
++ if ((cmd_stat & COMMAND_SUPDET) || (sint_stat & SYSTEM_SUSPDETINT)) {
++ int timeout = 0;
++ TRACE_MSG1(PCD, "SUSPENDDET: %08x", sint_stat);
++ fs_wl_set(PCD, OTG_FUNC_SINT_STAT,SYSTEM_SUSPDETINT);
++ fs_func_clock_off();
++ usbd_bus_event_handler_irq (pcd->bus, DEVICE_BUS_INACTIVE, 0);
++ }
++ ep_dstat = fs_rl(OTG_FUNC_EP_DSTAT);
++ ep_stats = ep_dstat | fs_rl(OTG_FUNC_XINT_STAT) | fs_rl(OTG_FUNC_YINT_STAT);
++ if (ep_stats) {
++ int i;
++
++ pcd_resetdet_count = 0;
++
++ /* clear the done status flags
++ */
++ TRACE_MSG1(PCD, "EP STATS: %08x", ep_stats);
++ fs_wl_clr(PCD, OTG_FUNC_EP_DSTAT, ep_dstat);
++
++ /* check ep0 first - special handling for control endpoint, need to check dstat, y/x stats
++ */
++ if (ep_stats & EP_OUT) fs_pcd_stop_ep0_setup(pcd, pcd->bus->endpoint_array);
++ if (ep_stats & EP_IN) fs_pcd_stop_in(pcd, 0, pcd->bus->endpoint_array);
++
++ /* now check all of the data endpoints, only if in dstat
++ */
++ for (i = 1, ep_dstat >>= 2; ep_dstat && (i < 16); i++, ep_dstat >>= 2) {
++ if (ep_dstat & EP_OUT) fs_pcd_stop_out(pcd, i, pcd->bus->endpoint_array + (2 * i));
++ if (ep_dstat & EP_IN) fs_pcd_stop_in(pcd, i, pcd->bus->endpoint_array + (2 * i) + 1);
++ }
++ }
++ return IRQ_HANDLED;
++}
++
++/* ********************************************************************************************* */
++/*!
++ * fs_pcd_set_address() - set the USB address for this device
++ * @param pcd
++ * @param address
++ */
++static void inline
++fs_pcd_set_address (struct pcd_instance *pcd, u8 address)
++{
++ fs_usb_address = 0;
++ fs_new_address = address; /* this will be used in the interrupt handler */
++}
++
++/* ********************************************************************************************* */
++/*!
++ * fs_pcd_en_func() - enable
++ * This is called to enable / disable the PCD and USBD stack.
++ * @param otg - otg instance
++ * @param flag - SET or RESET
++ */
++static void
++fs_pcd_en_func (struct otg_instance *otg, u8 flag)
++{
++ unsigned long flags;
++ struct pcd_instance *pcd = otg->pcd;
++ struct usbd_bus_instance *bus = pcd->bus;
++ u32 hwmode = fs_rl(OTG_CORE_HWMODE);
++
++
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(PCD, "PCD_EN: SET");
++ local_irq_save (flags);
++ fs_andl(OTG_CORE_HWMODE, 0xffffff0f); // clear
++
++ //printk(KERN_INFO"%s: SET\n", __FUNCTION__);
++ if (hwmode & MODULE_CRECFG_HOST) {
++ printk(KERN_INFO"%s: warning HOST STILL SET\n", __FUNCTION__);
++ }
++ fs_orl(OTG_CORE_HWMODE, MODULE_CRECFG_FUNC); // set to software hnp
++
++ /* reset the function core
++ */
++ //fs_wl_clr(PCD, OTG_CORE_RST_CTRL, MODULE_RSTFSIE | MODULE_RSTFC);
++ //while (fs_rl(OTG_CORE_RST_CTRL));
++
++ fs_func_clock_on();
++
++ fs_pcd_start_ep0_setup(pcd->bus->endpoint_array);
++
++ /* C.f. L3 12.1 - enable Slave, Band Gap enable, and Comparator enable.
++ * C.f. SCM-11 version of the USBOTG specification, ABBusReq enables the charge pump
++ */
++ fs_andl(OTG_CORE_HNP_CSTAT, ~(MODULE_MASTER | MODULE_SLAVE |
++ MODULE_CMPEN | MODULE_BGEN | MODULE_SWAUTORST | MODULE_ABBUSREQ));
++
++ fs_orl(OTG_CORE_HNP_CSTAT, MODULE_SLAVE | MODULE_CMPEN | MODULE_BGEN | MODULE_SWAUTORST | MODULE_ABBUSREQ);
++ fs_rl(OTG_CORE_HNP_CSTAT);
++
++ fs_orl(OTG_FUNC_SINT_STEN, ( /*SYSTEM_DONEREGINTDS_EN | *//*SYSTEM_SOFDETINT_EN |*/ SYSTEM_DONEREGINT_EN |
++ SYSTEM_SUSPDETINT_EN | SYSTEM_RSMFININT_EN | SYSTEM_RESETINT_EN));
++
++ fs_orl(OTG_CORE_CINT_STEN, MODULE_FCINT_EN | MODULE_ASFCINT_EN);
++ //printk(KERN_INFO"%s: SINT: %08x CINT: %08x SET\n", __FUNCTION__,
++ // fs_rl(OTG_FUNC_SINT_STEN), fs_rl(OTG_CORE_CINT_STEN));
++ local_irq_restore (flags);
++
++ break;
++
++ case RESET:
++ TRACE_MSG0(PCD, "PCD_EN: RESET");
++ //printk(KERN_INFO"%s: RESET\n", __FUNCTION__);
++
++ //fs_andl(OTG_FUNC_SINT_STEN, ~( /*SYSTEM_DONEREGINTDS_EN | *//*SYSTEM_SOFDETINT_EN |*/ SYSTEM_DONEREGINT_EN |
++ // SYSTEM_SUSPDETINT_EN | SYSTEM_RSMFININT_EN | SYSTEM_RESETINT_EN));
++
++ local_irq_save (flags);
++ fs_func_clock_on();
++ fs_andl(OTG_FUNC_SINT_STEN, 0);
++ fs_andl(OTG_CORE_CINT_STEN, ~(MODULE_FCINT_EN | MODULE_ASFCINT_EN));
++
++ fs_func_clock_off();
++ //printk(KERN_INFO"%s: SINT: %08x CINT: %08x RESET\n", __FUNCTION__,
++ // fs_rl(OTG_FUNC_SINT_STEN), fs_rl(OTG_CORE_CINT_STEN));
++
++ /* reset the function core
++ */
++ fs_wl_clr(PCD, OTG_CORE_RST_CTRL, MODULE_RSTFSIE | MODULE_RSTFC);
++ while (fs_rl(OTG_CORE_RST_CTRL));
++ fs_andl(OTG_CORE_HWMODE, ~MODULE_CRECFG_FUNC); // set to software hnp
++ local_irq_restore (flags);
++
++ usbd_bus_event_handler_irq (bus, DEVICE_RESET, 0);
++ usbd_bus_event_handler_irq (bus, DEVICE_DESTROY, 0);
++
++ break;
++ }
++ TRACE_MSG1(PCD, "HWMODE: %08x", fs_rl(OTG_CORE_HWMODE));
++}
++
++/*!
++ * fs_remote_wakeup() - perform remote wakeup.
++ * Initiate a remote wakeup to the host.
++ * @param otg - otg instance
++ * @param flag - SET or RESET
++ */
++static void
++fs_remote_wakeup(struct otg_instance *otg, u8 flag)
++{
++ unsigned long flags;
++ TRACE_MSG0(PCD, "MX2_REMOTE_WAKEUP: ");
++ local_irq_save (flags);
++ fs_wl_set(PCD, OTG_FUNC_CMD_STAT, COMMAND_RSMINPROG);
++ fs_wl(OTG_FUNC_CMD_STAT, COMMAND_RSMINPROG);
++ local_irq_restore (flags);
++}
++
++/* ********************************************************************************************* */
++/*!
++ * fs_pcd_start() - start the UDC
++ * @param pcd
++ */
++static void
++fs_pcd_start (struct pcd_instance *pcd)
++{
++ //TRACE_MSG0(PCD, "UDC START");
++ fs_rl(OTG_FUNC_SINT_STEN);
++ //fs_pcd_start_ep0_setup(pcd_instance->bus->endpoint_array);
++}
++
++/*!
++ * fs_pcd_stop() - stop the UDC
++ * @param pcd
++ */
++static void
++fs_pcd_stop (struct pcd_instance *pcd)
++{
++ TRACE_MSG0(PCD, "UDC STOP");
++}
++
++/*!
++ * pcd_assign_endpoint()
++ */
++static int
++pcd_assign_endpoint(u8 physicalEndpoint, int used[UDC_MAX_ENDPOINTS],
++ struct usbd_endpoint_map *endpoint_map, u8 bmAttributes, u16 wMaxPacketSize, u16 transferSize)
++{
++ RETURN_EINVAL_IF( used[physicalEndpoint] );
++ endpoint_map->bEndpointAddress[0] = physicalEndpoint | (USB_DIR_IN & bmAttributes);
++ endpoint_map->physicalEndpoint[0] = (physicalEndpoint * 2) + ((USB_DIR_IN & bmAttributes) ? 1 : 0);
++ endpoint_map->wMaxPacketSize[0] = wMaxPacketSize;
++ endpoint_map->transferSize[0] = transferSize;
++ endpoint_map->bmAttributes[0] = bmAttributes;
++ used[physicalEndpoint]++;
++ TRACE_MSG4(PCD, "ASSIGN: index: %02x phys: %02x addr: %02x", physicalEndpoint,
++ endpoint_map->physicalEndpoint[0], endpoint_map->bEndpointAddress[0], 0);
++ return 0;
++}
++
++/*!
++ * fs_pcd_request_endpoints()
++ * @param pcd
++ * @param endpoint_map_array
++ * @param endpointsRequested
++ * @param requestedEndpoints
++ */
++static int
++fs_pcd_request_endpoints(struct pcd_instance *pcd, struct usbd_endpoint_map *endpoint_map_array, int endpointsRequested,
++ struct usbd_endpoint_request *requestedEndpoints)
++{
++ struct usbd_device_description *device_description;
++ int i, in, out;
++ int in_used[UDC_MAX_ENDPOINTS];
++ int out_used[UDC_MAX_ENDPOINTS];
++ memset(in_used, 0, sizeof(in_used));
++ memset(out_used, 0, sizeof(out_used));
++ TRACE_MSG1(PCD, "REQUEST ENDPOINTS: %d", endpointsRequested);
++ for (in = out = 1, i = 0; i < endpointsRequested; i++) {
++ struct usbd_endpoint_map *endpoint_map = endpoint_map_array + i;
++ u8 bmAttributes = requestedEndpoints[i].bmAttributes;
++ u16 transferSize = requestedEndpoints[i].fs_requestedTransferSize;
++ switch(bmAttributes) {
++ case USB_DIR_IN | USB_ENDPOINT_INTERRUPT:
++ case USB_DIR_IN | USB_ENDPOINT_INTERRUPT | USB_ENDPOINT_OPT:
++ case USB_DIR_IN | USB_ENDPOINT_BULK:
++ CONTINUE_IF(!pcd_assign_endpoint(in++, in_used, endpoint_map, bmAttributes, 0x40, transferSize));
++ THROW(error);
++
++ 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(!pcd_assign_endpoint(out++, out_used, endpoint_map, bmAttributes, 0x40, transferSize));
++ //CONTINUE_IF(!pcd_assign_endpoint(in++, out_used, endpoint_map, bmAttributes, 0x40, transferSize));
++ THROW(error);
++
++ case USB_ENDPOINT_CONTROL:
++ continue;
++ case USB_DIR_IN | USB_ENDPOINT_ISOCHRONOUS:
++ case USB_DIR_OUT | USB_ENDPOINT_ISOCHRONOUS:
++ THROW(error);
++ }
++ THROW(error);
++ CATCH(error) {
++ printk(KERN_ERR"%s: FAILED num: %d bmAttributes: %02x transferSize: %02x\n",
++ __FUNCTION__, i, bmAttributes, transferSize);
++ return -EINVAL;
++ }
++ }
++ return 0;
++}
++
++/*!
++ * fs_pcd_set_endpoints() - setup the physical endpoints for the endpoint map
++ * @param pcd
++ * @param endpointsRequested
++ * @param endpoint_map_array
++ */
++static int
++fs_pcd_set_endpoints (struct pcd_instance *pcd, int endpointsRequested, struct usbd_endpoint_map *endpoint_map_array)
++{
++ fs_clear_words((volatile u32 *)MX2_IO_ADDRESS(OTG_EP_BASE), (32*16/4));
++ //fs_clear((void *)MX2_IO_ADDRESS(OTG_EP_BASE), 0x200);
++ TRACE_MSG0(PCD, "Enable system control interrupts");
++ fs_wl(OTG_SYS_CTRL, SYS_CTRL_I2C_WU_INT_EN | SYS_CTRL_OTG_WU_INT_EN | SYS_CTRL_HOST_WU_INT_EN | SYS_CTRL_FNT_WU_INT_EN);
++ return 0;
++}
++
++/*!
++ * fs_pcd_framenum() - get current framenum
++ */
++static u16
++fs_pcd_framenum (void)
++{
++ return fs_rl(OTG_FUNC_FRM_NUM);
++}
++
++/*
++ * fs_endpoint_halted() - is endpoint halted
++ */
++static int
++fs_endpoint_halted (struct pcd_instance *pcd, struct usbd_endpoint_instance *endpoint)
++{
++ int epn = endpoint->bEndpointAddress & 0x7f;
++ int dir = (endpoint->bEndpointAddress & 0x80) ? 1 : 0;
++
++ TRACE_MSG2(PCD, "epn: %02x dir: %x", epn, dir);
++ return fs_rl(ep_word(epn, dir, 0)) & (1 << 31) ? TRUE : FALSE;
++}
++
++/* fs_halt_endpoint - halt endpoint
++ */
++int fs_halt_endpoint(struct pcd_instance *pcd, struct usbd_endpoint_instance *endpoint, int flag)
++{
++ int epn = endpoint->bEndpointAddress & 0x7f;
++ int dir = (endpoint->bEndpointAddress & 0x80) ? 1 : 0;
++ TRACE_MSG3(PCD, "epn: %02x dir: %x flag: %d", epn, dir, flag);
++ fs_ep_config_nodma(epn, USB_DIR_IN, flag, endpoint->wMaxPacketSize, endpoint->bmAttributes & 0x3, 0, 0, 1);
++ return 0;
++}
++
++/* ********************************************************************************************* */
++
++#if !defined(OTG_C99)
++struct usbd_pcd_ops usbd_pcd_ops;
++struct pcd_ops pcd_ops;
++
++/*!
++ * fs_pcd_global_init() - initialize globals
++ */
++static void
++fs_pcd_global_init(void)
++{
++ ZERO(usbd_pcd_ops);
++ usbd_pcd_ops.bmAttributes = USB_OTG_HNP_SUPPORTED | USB_OTG_SRP_SUPPORTED;
++ usbd_pcd_ops.max_endpoints = UDC_MAX_ENDPOINTS;
++ usbd_pcd_ops.ep0_packetsize = EP0_PACKETSIZE;
++ usbd_pcd_ops.capabilities = REMOTE_WAKEUP_SUPPORTED;
++ usbd_pcd_ops.name = UDC_NAME;
++ usbd_pcd_ops.start = fs_pcd_start;
++ usbd_pcd_ops.stop = fs_pcd_stop;
++ usbd_pcd_ops.start_endpoint_in = fs_pcd_start_endpoint_in;
++ usbd_pcd_ops.start_endpoint_out = fs_pcd_start_endpoint_out;
++ usbd_pcd_ops.request_endpoints = fs_pcd_request_endpoints;
++ usbd_pcd_ops.set_endpoints = fs_pcd_set_endpoints;
++ usbd_pcd_ops.set_address = fs_pcd_set_address;
++ usbd_pcd_ops.setup_ep = fs_pcd_setup_ep;
++ usbd_pcd_ops.halt_endpoint = fs_halt_endpoint;
++ usbd_pcd_ops.endpoint_halted = fs_endpoint_halted;
++
++ usbd_pcd_ops.cancel_in_irq = fs_pcd_cancel_in_irq;
++ usbd_pcd_ops.cancel_out_irq = fs_pcd_cancel_out_irq;
++
++ ZERO(pcd_ops);
++ pcd_ops.pcd_en_func = fs_pcd_en_func;
++ pcd_ops.pcd_init_func = pcd_init_func;
++ pcd_ops.remote_wakeup_func = fs_remote_wakeup;
++ pcd_ops.framenum = fs_pcd_framenum;
++}
++#else /* !defined(OTG_C99) */
++static struct
++usbd_pcd_ops usbd_pcd_ops = {
++ .bmAttributes = USB_OTG_HNP_SUPPORTED | USB_OTG_SRP_SUPPORTED,
++ .max_endpoints = UDC_MAX_ENDPOINTS,
++ .ep0_packetsize = EP0_PACKETSIZE,
++ .capabilities = REMOTE_WAKEUP_SUPPORTED,
++ .name = UDC_NAME,
++ .start = fs_pcd_start,
++ .stop = fs_pcd_stop,
++ .start_endpoint_in = fs_pcd_start_endpoint_in,
++ .start_endpoint_out = fs_pcd_start_endpoint_out,
++ .request_endpoints = fs_pcd_request_endpoints,
++ .set_endpoints = fs_pcd_set_endpoints,
++ .set_address = fs_pcd_set_address,
++ .setup_ep = fs_pcd_setup_ep,
++ .halt_endpoint = fs_halt_endpoint,
++ .endpoint_halted = fs_endpoint_halted,
++
++ .cancel_in_irq = fs_pcd_cancel_in_irq,
++ .cancel_out_irq = fs_pcd_cancel_out_irq,
++};
++
++struct pcd_ops pcd_ops = {
++ .pcd_en_func = fs_pcd_en_func,
++ .pcd_init_func = pcd_init_func,
++ .remote_wakeup_func = fs_remote_wakeup,
++ .framenum = fs_pcd_framenum,
++};
++#endif /* !defined(OTG_C99) */
++
++/* @} */
++
+diff -uNr linux/drivers/no-otg/ocd/gen/gen.c linux/drivers/otg/ocd/gen/gen.c
+--- linux/drivers/no-otg/ocd/gen/gen.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/gen/gen.c 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,268 @@
++/*
++ * otg/ocd/gen/gen.c -- USB Device Controller driver
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/ocd/gen/gen.c
++ * @brief Sample driver
++ *
++ *
++ * @ingroup USBP
++ */
++
++#include <udc.h>
++#include <asm/hardware.h>
++#include "gen.h"
++
++
++static unsigned char usb_address;
++
++/* ********************************************************************************************* */
++/* udc_write_buffer - write a buffer to the udc fifo
++ */
++static void udc_write_buffer (unsigned char ep, unsigned char *b, unsigned char size)
++{
++}
++
++/* udc_read_buffer - fill a buffer from the udc fifo
++ */
++static void udc_read_buffer (unsigned char ep, unsigned char *b, unsigned char size)
++{
++}
++
++/* udc_out - process an OUT interrupt
++ */
++static void udc_out (struct usbd_endpoint_instance *endpoint)
++{
++}
++
++/* udc_in - process an IN interrupt
++ */
++static void udc_in (struct usbd_endpoint_instance *endpoint)
++{
++}
++
++/* ********************************************************************************************* */
++/* udc_in_ep0 - start transmit of ep0 Control Read data
++ */
++static void udc_in_ep0 (struct usbd_endpoint_instance *endpoint)
++{
++ struct usbd_urb *tx_urb = pcd_tx_complete_irq (endpoint, 0);
++ if (!tx_urb || pcd_tx_sendzlp (endpoint)) {
++ udc_write_buffer (0, NULL, 0);
++ return;
++ }
++ TRACE_MSG16("EP0 IN: actual: %d sent: %d", endpoint->tx_urb->actual_length, endpoint->sent);
++ endpoint->last = MIN (tx_urb->actual_length - endpoint->sent, endpoint->wMaxPacketSize);
++ udc_write_buffer (0, tx_urb->buffer + endpoint->sent, endpoint->last);
++}
++
++/* udc_out_ep0 - start receive of ep0 Control Write data
++ */
++static void udc_out_ep0 (struct usbd_endpoint_instance *endpoint)
++{
++ struct usbd_urb *rcv_urb = pcd_rcv_next_irq (endpoint);
++ int size = 0;
++ RETURN_IF(!rcv_urb);
++ TRACE_MSG8("OUT EP0: actual: %d buffer_length: %d size: %d", rcv_urb->actual_length, rcv_urb->buffer_length, size, 0);
++ udc_read_buffer (0, rcv_urb->buffer + rcv_urb->actual_length, size);
++ if (!pcd_rcv_complete_irq (endpoint, size, 0))
++ endpoint->state = WAIT_FOR_SETUP;
++}
++
++/* udc_ep0_setup - process a Control Setup command
++ */
++static void udc_ep0_setup (struct usbd_endpoint_instance *endpoint)
++{
++ static struct usbd_device_request request;
++ u8 *cp = (u8 *) &request;
++ int i;
++ TRACE_MSG32("EP0 SETUP: tx_urb: %p", (int)endpoint->tx_urb);
++ pcd_tx_cancelled_irq (endpoint);
++ pcd_rcv_cancelled_irq (endpoint);
++ if (pcd_recv_setup_irq (&request)) { // process setup packet
++ TRACE_MSG("udc_ep0: setup failed");
++ //udc_stall_ep (0);
++ endpoint->state = WAIT_FOR_SETUP;
++ return;
++ }
++ if ((request.bmRequestType & USB_REQ_DIRECTION_MASK) == USB_REQ_HOST2DEVICE) {
++ TRACE_MSG32("udc_ep0: send zlp %d", le16_to_cpu (request.wLength)); // XXX
++ //ctrl_outb (EP0s_RDFN, USBTRG);
++ RETURN_IF(pcd_rcv_next_irq (endpoint));
++ //and_b (~EP0o_TS, USBIER0);
++ return;
++ }
++}
++/* ********************************************************************************************* */
++/* udc_int_hndlr - interrupt handler
++ */
++static void udc_int_hndlr (int irq, void *dev_id, struct pt_regs *regs)
++{
++ trace_ops.interrupts++;
++#if 0
++ if (trace_ops.interrupts > 1000) { udc_disable_interrupts (); udc_disable (); TRACE_MSG("UDC DISABLE"); return; }
++#endif
++}
++/* ********************************************************************************************* */
++/* udc_start_endpoint_in - start transmit
++ */
++void udc_start_endpoint_in (struct usbd_endpoint_instance *endpoint)
++{
++}
++
++/* udc_start_endpoint_out - start receive
++ */
++void udc_start_endpoint_out (struct usbd_endpoint_instance *endpoint)
++{
++}
++/* ********************************************************************************************* */
++/* udc_attached - is the USB cable attached
++ * Return non-zero if cable is attached.
++ */
++int udc_attached (void)
++{
++ return 0;
++}
++
++static int udc_connect_status;
++
++/* udc_connected - is the USB pullup enabled
++ * Return non-zero if pullup is enabled.
++ */
++int udc_connected (void)
++{
++ return udc_connect_status;
++}
++
++/* udc_connect - enable pullup resistor
++ */
++void udc_connect (void)
++{
++ udc_connect_status = 1;
++}
++
++/* udc_disconnect - disable pullup resistor
++ */
++void udc_disconnect (void)
++{
++ udc_connect_status = 0;
++}
++
++/* udc_start - start session
++ */
++void udc_start (void)
++{
++ // udc_enable_interrupts ();
++}
++
++/* udc_stop - stop session
++ */
++void udc_stop (void)
++{
++ // udc_disable_interrupts ();
++}
++
++/* udc_enable - enable the UDC
++ */
++void udc_enable (void)
++{
++}
++
++/* udc_disable - disable the UDC
++ */
++void udc_disable (void)
++{
++}
++
++/* udc_init - initialize
++ * Return non-zero if we cannot see device.
++ */
++int udc_init (void)
++{
++ return 0;
++}
++
++/* udc_exit - disable the UDC
++ */
++void udc_exit (void)
++{
++}
++
++/* ********************************************************************************************* */
++/* udc_assign_endpoint
++ */
++int udc_assign_endpoint (u8 physicalEndpoint, int used[6], struct usbd_endpoint_map *endpoint_map, u8 bmAttributes,
++ u16 wMaxPacketSize, u16 transferSize)
++{
++ RETURN_EINVAL_IF(used[physicalEndpoint]);
++ endpoint_map->bEndpointAddress[0] = physicalEndpoint | (bmAttributes & USB_IN_DIR);
++ endpoint_map->physicalEndpoint[0] = physicalEndpoint;
++ endpoint_map->wMaxPacketSize[0] = wMaxPacketSize;
++ endpoint_map->transferSize[0] = transferSize;
++ endpoint_map->bmAttributes[0] = bmAttributes;
++ used[physicalEndpoint]++;
++ return 0;
++}
++
++/* udc_request_endpoints - process endpoint request list
++ */
++int udc_request_endpoints (struct usbd_endpoint_map *endpoint_map_array, int endpointsRequested,
++ struct usbd_endpoint_request *requestedEndpoints)
++{
++ struct usbd_device_description *device_description;
++ int i, j;
++ int used[UDC_MAX_ENDPOINTS];
++ memset (used, 0, sizeof (used));
++ for (j = 0, i = 0; i < endpointsRequested; i++) {
++ struct usbd_endpoint_map *endpoint_map = endpoint_map_array + i;
++ u8 bmAttributes = requestedEndpoints[i].bmAttributes;
++ u16 transferSize = requestedEndpoints[i].fs_requestedTransferSize;
++ switch (bmAttributes) {
++ case USB_DIR_IN | USB_ENDPOINT_INTERRUPT:
++ case USB_DIR_IN | USB_ENDPOINT_INTERRUPT | USB_ENDPOINT_OPT:
++ case USB_DIR_IN | USB_ENDPOINT_BULK:
++ case USB_DIR_OUT | USB_ENDPOINT_BULK:
++ BREAK_IF(!udc_assign_endpoint (j++, used, endpoint_map, bmAttributes, 0x40, transferSize));
++ return -EINVAL;
++ case USB_ENDPOINT_CONTROL:
++ continue;
++ case USB_DIR_OUT | USB_ENDPOINT_INTERRUPT:
++ case USB_DIR_OUT | USB_ENDPOINT_INTERRUPT | USB_ENDPOINT_OPT:
++ case USB_DIR_IN | USB_ENDPOINT_ISOCHRONOUS:
++ case USB_DIR_OUT | USB_ENDPOINT_ISOCHRONOUS:
++ return -EINVAL;
++ }
++ return -EINVAL;
++ }
++ RETURN_EINVAL_UNLESS (j < UDC_MAX_ENDPOINTS);
++ }
++ return 0;
++}
++/* ********************************************************************************************* */
++struct udc_ops udc_ops = {
++ max_endpoints: UDC_MAX_ENDPOINTS,
++ ep0_packetsize: EP0_PACKETSIZE,
++ name: UDC_NAME,
++ init: udc_init,
++ exit: udc_exit,
++ enable: udc_enable,
++ disable: udc_disable,
++ start: udc_start,
++ stop: udc_stop,
++ start_endpoint_in: udc_start_endpoint_in,
++ start_endpoint_out: udc_start_endpoint_out,
++ request_endpoints: udc_request_endpoints,
++ attached: udc_attached,
++ connected: udc_connected,
++ connect: udc_connect,
++ disconnect: udc_disconnect,
++};
++
+diff -uNr linux/drivers/no-otg/ocd/gen/gen.h linux/drivers/otg/ocd/gen/gen.h
+--- linux/drivers/no-otg/ocd/gen/gen.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/gen/gen.h 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,29 @@
++/*
++ * otg/ocd/gen/gen.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++
++/*!
++ * @file otg/ocd/gen/gen.h
++ * @brief Private structures and defines for Intel PXA-270
++ *
++ * Notes
++ *
++ * 1. This is a minmal outline for a simple UDC driver.
++ *
++ *
++ * @ingroup BVD
++ */
++
++
++#define UDC_NAME "GEN"
++#define UDC_MAX_ENDPOINTS 3
++#define EP0_PACKETSIZE 8
++
+diff -uNr linux/drivers/no-otg/ocd/isp1301/Config.in linux/drivers/otg/ocd/isp1301/Config.in
+--- linux/drivers/no-otg/ocd/isp1301/Config.in 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/isp1301/Config.in 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,17 @@
++
++#
++# Copyright (c) 2004 Belcarra
++#
++# ISP 1301 TCD
++
++if [ "$CONFIG_OTG_ISP1301" = "y" ]; then
++ mainmenu_option next_comment
++
++ comment 'ISP 1301 (i2c)'
++
++ dep_bool 'Proc FS debug' CONFIG_OTG_ISP1301_PROCFS $CONFIG_OTG_ISP1301
++
++ endmenu
++else
++ define_bool CONFIG_OTG_ISP1301_PROCFS n
++fi
+diff -uNr linux/drivers/no-otg/ocd/isp1301/Kconfig linux/drivers/otg/ocd/isp1301/Kconfig
+--- linux/drivers/no-otg/ocd/isp1301/Kconfig 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/isp1301/Kconfig 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,15 @@
++
++#
++# Copyright (c) 2004 Belcarra
++#
++
++# OMAP 1610 H2 development board
++#
++config OTG_ISP1301_OMAP_H2
++ tristate "OMAP 1610 H2 Development board - ISP 1301 (i2c)"
++ depends on I2C && OTG && ARCH_OMAP && OMAP_H2
++
++config OTG_ISP1301_MX2ADS
++ tristate "MX2ADS Development board - ISP 1301 (i2c)"
++ depends on I2C && OTG && ARCH_MX2ADS
++
+diff -uNr linux/drivers/no-otg/ocd/isp1301/Makefile linux/drivers/otg/ocd/isp1301/Makefile
+--- linux/drivers/no-otg/ocd/isp1301/Makefile 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/isp1301/Makefile 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,96 @@
++#
++# Makefile for the kernel USBD (device not host) drivers.
++#
++# Copyright (c) 2004 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 := isp1301_target.o
++list-multi := isp1301_tcd.o
++
++# Objects that export symbols.
++
++# Multipart objects.
++
++omap_h2_tcd-objs := tcd-init-l24.o tcd-omap-h2.o isp1301.o i2c-l26.o tcd.o isp1301-procfs.o
++mainstone_tcd-objs := tcd-init-l24.o tcd-mainstone.o tcd.o i2c-l26.o isp1301.o isp1301-procfs.o thread-l24.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_OTG_ISP1301_OMAP_H2) += omap_h2_tcd.o
++obj-$(CONFIG_OTG_ISP1301_MAINSTONE) += mainstone_tcd.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.
++
++DOT_DIR=$(TCD_DIR)/isp1301
++
++include $(TOPDIR)/Rules.make
++OTG=$(TOPDIR)/drivers/otg
++OCD_DIR=$(OTG)/ocd
++INCLUDE_DIRS = -I$(OTG)
++EXTRA_CFLAGS += -Wno-missing-prototypes -Wno-unused -Wno-format ${INCLUDE_DIRS}
++EXTRA_CFLAGS_nostdinc += -Wno-missing-prototypes -Wno-unused -Wno-format ${INCLUDE_DIRS}
++
++PCD=$(OTG)/ocd/otg-pcd
++vpath %.c $(USBDCORE_DIR) $(OCD_DIR) $(PCD)
++
++
++# Link rules for multi-part drivers.
++
++omap_h2_tcd.o: $(omap_h2_tcd-objs)
++ $(LD) -r -o $@ $(iomap_h2_tcd-objs)
++
++mainstone_tcd.o: $(mainstone_tcd-objs)
++ $(LD) -r -o $@ $(mainstone_tcd-objs)
++
++# dependencies:
++
++# local
++
++
+diff -uNr linux/drivers/no-otg/ocd/isp1301/Makefile-l26 linux/drivers/otg/ocd/isp1301/Makefile-l26
+--- linux/drivers/no-otg/ocd/isp1301/Makefile-l26 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/isp1301/Makefile-l26 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,26 @@
++#
++# Makefile for the kernel USBD (device not host) drivers.
++#
++# Copyright (c) 2004 Belcarra Technologies Corp
++
++DOT_DIR=$(TCD_DIR)/isp1301
++
++OTG=$(TOPDIR)/drivers/otg
++HCD_DIR=$(OTG)/hcd
++TCD_DIR=$(OTG)/tcd
++USBDCORE_DIR=$(OTG)/usbdcore
++OTGCORE_DIR=$(OTG)/otgcore
++INCLUDE_DIRS = -I$(OTG)
++EXTRA_CFLAGS += -Wno-missing-prototypes -Wno-unused -Wno-format ${INCLUDE_DIRS}
++EXTRA_CFLAGS_nostdinc += -Wno-missing-prototypes -Wno-unused -Wno-format ${INCLUDE_DIRS}
++
++vpath %.c $(USBDCORE_DIR) $(OCD_DIR)
++
++
++# Link rules for multi-part drivers.
++
++omap_h2_tcd-objs := ../tcd-init-l24.o tcd-omap-h2.o isp1301.o i2c-l26.o ../tcd.o
++obj-$(CONFIG_OTG_ISP1301_OMAP_H2) += omap_h2_tcd.o
++
++
++
+diff -uNr linux/drivers/no-otg/ocd/isp1301/isp1301-procfs.c linux/drivers/otg/ocd/isp1301/isp1301-procfs.c
+--- linux/drivers/no-otg/ocd/isp1301/isp1301-procfs.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/isp1301/isp1301-procfs.c 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,385 @@
++/*
++ * otg/ocd/isp1301/isp1301-procfs.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>
++ *
++ *
++ */
++/*!
++ * @file otg/ocd/isp1301/isp1301-procfs.c
++ * @brief Implement /proc/isp1301 to dump ISP1301 registers.
++ *
++ *
++ * @ingroup ISP1301TCD
++ */
++
++
++#include <otg/pcd-include.h>
++#include "otghw/isp1301-hardware.h"
++#include <otghw/isp1301.h>
++
++#ifdef CONFIG_ARCH_MX2ADS
++#include <asm/arch/mx2.h>
++#define MX2_OTG_XCVR_DEVAD 0x18
++#define MX2_SEQ_OP_REG 0x19
++#define MX2_SEQ_RD_STARTAD 0x1a
++#define MX2_I2C_OP_CTRL_REG 0x1b
++#define MX2_SCLK_TO_SCL_HPER 0x1e
++#define MX2_I2C_INTERRUPT_AND_CTRL 0x1f
++
++#define OTG_BASE_ADDR 0x10024000
++//#define OTG_I2C_BASE (OTG_BASE_ADDR+0x100)
++
++#endif /* CONFIG_ARCH_MX2ADS */
++
++#ifdef CONFIG_OTG_ISP1301_PROCFS
++/* Proc Filesystem *************************************************************************** */
++
++extern struct isp1301_private isp1301_private;
++
++#define MAX_HISTORY 6
++struct reg_list {
++ u8 reg;
++ u8 size;
++ char *name;
++ u32 values[MAX_HISTORY];
++};
++
++#define REG(r, s) {r, s, #r, }
++
++struct reg_list isp1301_prod_list[] = {
++ REG(ISP1301_VENDOR_ID, 2),
++ REG(ISP1301_PRODUCT_ID, 2),
++ REG(ISP1301_VERSION_ID, 2),
++ { 0, 1, NULL,},
++};
++struct reg_list isp1301_reg_list[] = {
++ REG(ISP1301_OTG_CONTROL_SET, 1),
++ REG(ISP1301_INTERRUPT_SOURCE, 1),
++ REG(ISP1301_INTERRUPT_LATCH_SET, 1),
++ REG(ISP1301_INTERRUPT_ENABLE_LOW_SET, 1),
++ REG(ISP1301_INTERRUPT_ENABLE_HIGH_SET, 1),
++ REG(ISP1301_MODE_CONTROL_1_SET, 1),
++ { 0, 1, NULL,},
++};
++struct reg_list isp1301_spec_list[] = {
++ REG(ISP1301_MODE_CONTROL_2_SET, 1),
++ REG(ISP1301_OTG_STATUS, 1),
++ { 0, 1, NULL,},
++};
++struct reg_list max3301e_spec_list[] = {
++ REG(MAX3301E_SPECIAL_FUNCTION_1_SET, 1),
++ REG(MAX3301E_SPECIAL_FUNCTION_2_SET, 1),
++ { 0, 1, NULL,},
++};
++#ifdef CONFIG_ARCH_MX2ADS
++struct reg_list mx21_spec_list[] = {
++ REG(MX2_OTG_XCVR_DEVAD, 1),
++ REG(MX2_SEQ_OP_REG, 1),
++ REG(MX2_SEQ_RD_STARTAD, 1),
++ REG(MX2_I2C_OP_CTRL_REG, 1),
++ REG(MX2_SCLK_TO_SCL_HPER, 1),
++ REG(MX2_I2C_INTERRUPT_AND_CTRL, 1),
++ { 0, 1, NULL,},
++};
++#endif /* CONFIG_ARCH_MX2ADS */
++
++void isp1301_update(struct reg_list *list)
++{
++ for (; list && list->name; list++) {
++ TRACE_MSG1(TCD, "list: %s", list->name);
++ memmove(list->values + 1, list->values, sizeof(list->values) - sizeof(u32));
++ switch(list->size) {
++ case 1:
++ list->values[0] = i2c_readb(list->reg);
++ break;
++ case 2:
++ list->values[0] = i2c_readw(list->reg);
++ break;
++ case 4:
++ list->values[0] = i2c_readl(list->reg);
++ break;
++ }
++ }
++}
++
++#ifdef CONFIG_ARCH_MX2ADS
++static u8 __inline__ mx2_rb(u32 port)
++{
++ return *(volatile u8 *) (MX2_IO_ADDRESS(port + OTG_I2C_BASE));
++}
++
++
++void mx21_update(struct reg_list *list)
++{
++ for (; list && list->name; list++) {
++ memmove(list->values + 1, list->values, sizeof(list->values) - sizeof(u32));
++ list->values[0] = mx2_rb(list->reg);
++ }
++}
++
++#endif /* CONFIG_ARCH_MX2ADS */
++
++void isp1301_update_all(void)
++{
++ isp1301_update(isp1301_reg_list);
++ switch (isp1301_private.transceiver_map->transceiver_type) {
++ case isp1301:
++ isp1301_update(isp1301_spec_list);
++ break;
++ case max3301e:
++ isp1301_update(max3301e_spec_list);
++ break;
++ default:
++ break;
++ }
++#ifdef CONFIG_ARCH_MX2ADS
++ mx21_update(mx21_spec_list);
++#endif /* CONFIG_ARCH_MX2ADS */
++
++}
++
++
++
++/*
++ * 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);
++}
++
++int isp1301_dump(char *buf, char *name, char *fmt, struct reg_list *reg)
++{
++ int len = 0, i;
++ len += sprintf (buf + len, "%-20s %-34s [%03x]: ", name, reg->name, reg->reg);
++ len += sprintf (buf + len, fmt, reg->values[0]);
++ for (i = 1; i < MAX_HISTORY; i++)
++ if (reg->values[i - 1] == reg->values[i])
++ len += sprintf (buf + len, " ");
++ else
++ len += sprintf (buf + len, fmt, reg->values[i]);
++ len += sprintf (buf + len, "\n");
++ return len;
++}
++
++int isp1301_dump_list(char * buf, char *name, struct reg_list *list)
++{
++ int len = 0;
++ for (; list && list->name; list++)
++ switch(list->size) {
++ case 1: len += isp1301_dump(buf + len, name, " %02x", list); break;
++ case 2: len += isp1301_dump(buf + len, name, " %04x", list); break;
++ case 4: len += isp1301_dump(buf + len, name, " %08x", list); break;
++ }
++ return len;
++}
++
++char *isp1301_otg_control[8] = {
++ "DP_PULLUP",
++ "DM_PULLUP",
++ "DP_PULLDOWN",
++ "DM_PULLDOWN",
++ "ID_PULLDOWN",
++ "VBUS_DRV",
++ "VBUS_DISCHRG",
++ "VBUS_CHRG",
++};
++char *isp1301_interrupt_source[8] = {
++ "VBUS_VLD",
++ "SESS_VLD",
++ "DP_HI",
++ "ID_GND",
++ "DM_HI",
++ "ID_FLOAT",
++ "BDIS_ACON",
++ "CR_INT",
++};
++
++char *isp1301_mode_control_1[8] = {
++ "SPEED_REG",
++ "SUSPEND_REG",
++ "DAT_SE0",
++ "TRANSP_EN",
++ "BDIS_ACON_EN",
++ "OE_INT_EN",
++ "UART_EN",
++ NULL,
++};
++
++char *isp1301_otg_status[8] = {
++ NULL, NULL, NULL, NULL, NULL, NULL,
++ "B_SESS_END",
++ "B_SESS_VLD",
++};
++
++int isp1301_detailed(char *buf, char *name, u8 reg, char **detail)
++{
++ u8 val;
++ int i;
++ int len = 0;
++
++ val = i2c_readb(reg);
++ for (i = 7; i >= 0; i--) {
++
++ if (3 == (i % 4))
++ len += sprintf (buf + len, "\n%-20s [%02d] ", name, reg);
++
++ if (detail[i])
++ len += sprintf (buf + len, "%14s%s ", detail[i], (val & (1 << i)) ? " " : "/");
++ else
++ len += sprintf (buf + len, "%14s%s ", "", " ");
++ }
++ len += sprintf (buf + len, "\n", name);
++
++ return len;
++}
++
++int isp1301_dump_all(char *buf)
++{
++ int len = 0;
++ len += isp1301_dump_list(buf + len, "ISP1301 Standard", isp1301_reg_list);
++ switch (isp1301_private.transceiver_map->transceiver_type) {
++ case isp1301:
++ len += isp1301_dump_list(buf + len, "ISP1301 Extra", isp1301_spec_list);
++ break;
++ case max3301e:
++ len += isp1301_dump_list(buf + len, "MAX3301E Extra", max3301e_spec_list);
++ break;
++ default:
++ break;
++ }
++#ifdef CONFIG_ARCH_MX2ADS
++ len += isp1301_dump_list(buf + len, "MX21 ADS Extra", mx21_spec_list);
++#endif /* CONFIG_ARCH_MX2ADS */
++ return len;
++}
++
++int isp1301_dump_detail(char *buf)
++{
++ int len = 0;
++
++ len += isp1301_detailed(buf + len, "MODE CONTROL 1", ISP1301_MODE_CONTROL_1, isp1301_mode_control_1);
++ len += isp1301_detailed(buf + len, "INTERRUPT ENABLE", ISP1301_INTERRUPT_ENABLE_HIGH, isp1301_interrupt_source);
++
++ len += isp1301_detailed(buf + len, "OTG CONTROL", ISP1301_OTG_CONTROL_SET, isp1301_otg_control);
++ len += isp1301_detailed(buf + len, "INTERRUPT SOURCE", ISP1301_INTERRUPT_SOURCE, isp1301_interrupt_source);
++ len += isp1301_detailed(buf + len, "OTG STATUS", ISP1301_OTG_STATUS, isp1301_otg_status);
++ return len;
++}
++
++
++/*!
++ * isp1301_device_proc_read - implement proc file system read.
++ *
++ * 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 isp1301_device_proc_read_functions (struct file *file, char *buf, size_t count, loff_t * pos)
++{
++ unsigned long page;
++ int len = 0;
++ int index;
++ int i;
++ u32 r;
++
++ int config_size;
++
++ // get a page, max 4095 bytes of data...
++ RETURN_EINVAL_UNLESS ((page = get_free_page (GFP_KERNEL)));
++
++ len = 0;
++ index = (*pos)++;
++
++ //printk(KERN_INFO"%s: index: %d\n", __FUNCTION__, index);
++ switch(index) {
++ case 0:
++ len += sprintf ((char *) page + len, "ISP1301 Transceiver Registers\n");
++
++ TRACE_MSG0(TCD, "UPDATING");
++ isp1301_update_all();
++ TRACE_MSG0(TCD, "UPDATE FINISHED");
++ len += sprintf ((char *) page + len , "Vendor: %04x Product: %04x Revision: %04x %s\n",
++ isp1301_private.vendor, isp1301_private.product,
++ isp1301_private.revision, isp1301_private.transceiver_map->name
++ );
++
++ len += isp1301_dump_all((char *) page + len);
++ len += sprintf ((char *) page + len, "\n");
++
++ break;
++
++ case 1:
++ len += sprintf ((char *) page + len, "\n--\n");
++ len += isp1301_dump_detail((char *) page + len);
++ len += sprintf ((char *) page + len, "\n");
++ break;
++
++ default:
++ break;
++
++ }
++
++ //printk(KERN_INFO"%s: len: %d\n", __FUNCTION__, len);
++
++ if (len > count)
++ len = -EINVAL;
++
++ else if ((len > 0) && copy_to_user (buf, (char *) page, len))
++ len = -EFAULT;
++
++ //printk(KERN_INFO"%s: len: %d\n", __FUNCTION__, len);
++ free_page (page);
++ return len;
++}
++
++static struct file_operations isp1301_device_proc_operations_functions = {
++ read:isp1301_device_proc_read_functions,
++};
++
++/* Module init ******************************************************************************* */
++
++static int isp1301_procfs_init (void)
++{
++ struct proc_dir_entry *p;
++
++ // create proc filesystem entries
++ if ((p = create_proc_entry ("isp1301", 0, 0)) == NULL)
++ return -ENOMEM;
++
++ p->proc_fops = &isp1301_device_proc_operations_functions;
++
++ isp1301_update_all();
++
++ return 0;
++}
++static void isp1301_procfs_exit (void)
++{
++ remove_proc_entry ("isp1301", NULL);
++}
++#else
++static int isp1301_procfs_init (void) { return 0;
++}
++static void isp1301_procfs_exit (void) { }
++#endif
+diff -uNr linux/drivers/no-otg/ocd/isp1301/isp1301.c linux/drivers/otg/ocd/isp1301/isp1301.c
+--- linux/drivers/no-otg/ocd/isp1301/isp1301.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/isp1301/isp1301.c 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,923 @@
++/*
++ * otg/ocd/isp1301/isp1301.c -- USB Transceiver Controller driver
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/ocd/isp1301/isp1301.c
++ * @brief ISP1301 OTG Transceiver Driver.
++ *
++ * This is the generic ISP1301 TCD core support.
++ *
++ * Notes:
++ *
++ * 1. The ISP1301 can control the speed and suspend directly, would it be
++ * appropriate to allow state machine to control this.
++ *
++ * 2. The ISP1301 has auto connect feature, can this be used without change
++ * to state machine.
++ *
++ * 3. The ISP1301 can control the ADR/PSW pin to enable / disable external
++ * charge pump.
++ *
++ * @ingroup ISP1301TCD
++ */
++
++#include <otg/otg-compat.h>
++
++#include <asm/irq.h>
++#include <asm/system.h>
++#include <asm/io.h>
++#include <linux/i2c.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-bus.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-hcd.h>
++#include <otg/otg-tcd.h>
++#include <otg/otg-ocd.h>
++#include <otg/otg-pcd.h>
++
++#include <otghw/isp1301-hardware.h>
++#include <otghw/isp1301.h>
++
++#ifdef CONFIG_OMAP_H2
++#include <asm/arch/gpio.h>
++#include <asm/arch/mux.h>
++#endif /* CONFIG_OMAP_H2 */
++
++struct otg_transceiver_map isp1301_transceiver_map[] = {
++ { isp1301, 0x4cc, 0x1301, 0x00, "Phillips ISP1301", },
++ { max3301e, 0x6a0b, 0x0133, 0x00, "Maxim MAX3301E", },
++ { 0, 0, 0, 0, "Unknown Transceiver", },
++};
++
++struct isp1301_private isp1301_private;
++
++
++
++/* ********************************************************************************************* */
++#define TRACE_I2CB(t,r) TRACE_MSG3(t, "%-40s[%02x] %02x", #r, r, i2c_readb(r))
++#define TRACE_I2CW(t,r) TRACE_MSG3(t, "%-40s[%02x] %04x", #r, r, i2c_readw(r))
++#define TRACE_GPIO(t,b,r) TRACE_MSG2(t, "%-40s %04x", #r, readw(b + r))
++#define TRACE_REGL(t,r) TRACE_MSG2(t, "%-40s %08x", #r, readl(r))
++
++
++
++/*! isp1301_int_src - update interrupt source test mask
++ *
++ * This sets the current mask and updates the interrupt registers to match.
++ */
++void isp1301_int_src(u8 int_src)
++{
++ TRACE_MSG1(TCD, "setting int_src %02x", int_src);
++ isp1301_private.int_src = int_src;
++ i2c_writeb(ISP1301_INTERRUPT_ENABLE_LOW_CLR, ~int_src);
++ i2c_writeb(ISP1301_INTERRUPT_ENABLE_HIGH_CLR, ~int_src);
++ i2c_writeb(ISP1301_INTERRUPT_ENABLE_LOW_SET, int_src);
++ i2c_writeb(ISP1301_INTERRUPT_ENABLE_HIGH_SET, int_src);
++ i2c_writeb(ISP1301_INTERRUPT_LATCH_CLR, int_src);
++}
++
++/*! isp1301_int_src_set - add to the interrupt source mask
++ *
++ */
++void isp1301_int_src_set(u8 int_src)
++{
++ isp1301_int_src(int_src |= isp1301_private.int_src);
++}
++
++/*! isp1301_int_src_clr - remove from the interrup source mask
++ */
++void isp1301_int_src_clr(u8 int_src)
++{
++ isp1301_int_src(int_src = isp1301_private.int_src & ~int_src);
++}
++
++/* ********************************************************************************************* */
++
++typedef struct isp1301_test {
++ u32 input;
++ char *name;
++ u8 mask;
++} isp1301_test_t;
++
++#define OV(i, m) {i, #i, m}
++
++struct isp1301_test isp1301_int_src_tests[9] = {
++
++ OV(VBUS_VLD, ISP1301_VBUS_VLD),
++ OV(A_SESS_VLD, ISP1301_SESS_VLD),
++ OV(DP_HIGH, ISP1301_DP_HI),
++ OV(ID_GND, ISP1301_ID_GND),
++ OV(DM_HIGH, ISP1301_DM_HI),
++ OV(ID_FLOAT, ISP1301_ID_FLOAT),
++ OV(BDIS_ACON, ISP1301_BDIS_ACON),
++ OV(CR_INT_DET, ISP1301_CR_INT),
++ {0, NULL, 0},
++};
++
++struct isp1301_test isp1301_otg_status_tests[3] = {
++
++ OV(B_SESS_END, ISP1301_B_SESS_END),
++ OV(B_SESS_VLD, ISP1301_B_SESS_VLD),
++ {0, NULL, 0},
++};
++
++/*! isp1301_event() - set input bit based on current settings and interrupt mask
++ */
++u64 isp1301_event(struct otg_instance *otg, struct isp1301_test *tests, int val, int testmask, char *msg)
++{
++ int i;
++ u64 inputs = 0;
++ TRACE_MSG3(TCD, "val: %02x mask: %02x %s", val, testmask, msg);
++ for (i = 0; tests[i].mask; i++) {
++ u64 input = tests[i].input;
++ u8 mask = tests[i].mask;
++ CONTINUE_UNLESS(mask & testmask);
++ inputs |= (val & mask) ? input : _NOT(input);
++ TRACE_MSG6(TCD, "%s%s %02x %08x inputs: %08x %08x",
++ tests[i].name, (val & mask) ? "" : "/", tests[i].mask, tests[i].input,
++ (u32) (inputs >> 32), (u32)(inputs & 0xffffffff)
++ );
++ }
++ return inputs;
++}
++
++
++
++int isp1301_bh_first;
++int isp1301_debounce;
++u64 isp1301_ticks;
++
++void isp1301_info(char *msg, u8 value)
++{
++ u64 new_ticks = otg_tmr_ticks();
++ u64 ticks = otg_tmr_elapsed(&new_ticks, &isp1301_ticks);
++
++ if (ticks < 10000)
++ TRACE_MSG3(PCD, "ISP1301 %d uS %s: %02x", (u32)(ticks & 0xffffffff), msg, value);
++ else if (ticks < 10000000)
++ TRACE_MSG3(PCD, "ISP1301 %d mS %s: %02x", (u32)((ticks >> 10) & 0xffffffff), msg, value);
++ else
++ TRACE_MSG3(PCD, "ISP1301 %d S %s: %02x", (u32)((ticks >> 20) & 0xffffffff), msg, value);
++
++ isp1301_ticks = new_ticks;
++}
++
++
++void isp1301_trace(u8 int_src, u8 int_changed, char *msg)
++{
++
++ u64 new_ticks = otg_tmr_ticks();
++ u64 ticks = otg_tmr_elapsed(&new_ticks, &isp1301_ticks);
++
++ if (ticks < 10000)
++ TRACE_MSG4(PCD, "ISP1301 %d uS %s: src: %02x chng: %02x",
++ (u32)(ticks & 0xffffffff), msg, int_src, int_changed);
++ else if (ticks < 10000000)
++ TRACE_MSG4(PCD, "ISP1301 %d mS %s src: %02x chng: %02x",
++ (u32)((ticks >> 10) & 0xffffffff), msg, int_src, int_changed);
++ else
++ TRACE_MSG4(PCD, "ISP1301 %d S %s src: %02x chng: %02x ",
++ (u32)((ticks >> 20) & 0xffffffff), msg, int_src, int_changed);
++
++ isp1301_ticks = new_ticks;
++}
++
++/*! isp1301_bh
++ */
++void isp1301_bh(void *arg)
++{
++ u64 inputs = 0;
++ u8 int_lat, int_src1 = 0, int_src2 = 0, otg_status = 0, special_function_22 = 0;
++ static u8 int_src_saved, otg_status_saved, special_function_22_saved;
++
++ //TRACE_MSG0(TCD, "--");
++ /* read the interrupt latch and and clear latch and update otg
++ */
++ if ((int_lat = i2c_readb(ISP1301_INTERRUPT_LATCH_SET))) {
++ //TRACE_MSG1(TCD, "CLEARING INT LAT: %02x", int_lat);
++ isp1301_info("INT LAT", int_lat);
++ i2c_writeb(ISP1301_INTERRUPT_LATCH_CLR, int_lat);
++ }
++
++ isp1301_info("INT_LAT", int_lat);
++
++ /* If int_lat shows a change or we are forcing an update, read interrupt source.
++ * Note that we mask DP_HI and DM_HI when LOC_CONN is set, we don't want them
++ * when USB Bus is in use.
++ *
++ * Mask with bits we are currently interested in.
++ *
++ * Ensure that we have two matching reads to ensure that value is stable.
++ * Also ensure that interrupt source is non-zero.
++ */
++
++ int_src1 = i2c_readb(ISP1301_INTERRUPT_SOURCE);
++ isp1301_trace(int_src1, int_src_saved ^ int_src1, "INT_SRC_1");
++
++ do {
++ int_src2 = i2c_readb(ISP1301_INTERRUPT_SOURCE); // re-read interrupt source
++ BREAK_IF(int_src1 && (int_src1 & (ISP1301_ID_GND | ISP1301_ID_FLOAT)) &&
++ (int_src1 == int_src2)); // finished if non-zero and same
++ isp1301_trace(int_src2, int_src_saved ^ int_src2, "INT_SRC_2");
++ int_src1 = int_src2; // save most recent read value
++ } while (1);
++
++
++ #if 0
++ while ( (int_src1 != (int_src2 = i2c_readb(ISP1301_INTERRUPT_SOURCE) & isp1301_private.int_src))) {
++ isp1301_trace(int_src2, int_src_saved ^ int_src2, "INT_SRC_2");
++ int_src1 = int_src2;
++ }
++ #endif
++
++ if (isp1301_bh_first || int_src_saved ^ (int_src1 & isp1301_private.int_src)) {
++ int_src_saved = int_src1;
++ inputs |= isp1301_event(tcd_instance->otg, isp1301_int_src_tests, int_src1,
++ isp1301_private.int_src, "ISP1301 INT SRC");
++ if (int_src1 & ISP1301_VBUS_VLD) {
++ TRACE_MSG0(TCD, "VBUS_VLD, setting B_SESS_VLD");
++ inputs |= B_SESS_VLD;
++ }
++ else if (!(int_src1 & ISP1301_SESS_VLD)) {
++ TRACE_MSG0(TCD, "A_SESS_VLD/, setting B_SESS_VLD/");
++ inputs |= B_SESS_VLD_;
++ }
++ }
++
++ /* further work if B-Device
++ */
++ if ( !(int_src1 & ISP1301_ID_GND) || !(int_src_saved & ISP1301_ID_GND) ) {
++ /* read the otg_status register and update otg state machine
++ *
++ * XXX this needs to be conditional on Transceiver type. The
++ * MAX3301E for example supports sess_end in a separate register.
++ */
++ switch (isp1301_private.transceiver_map->transceiver_type) {
++ case isp1301:
++ otg_status = i2c_readb(ISP1301_OTG_STATUS);
++ isp1301_trace(otg_status, int_src_saved ^ int_src1, "OTG_STATUS");
++ TRACE_MSG3(TCD, "otg_status_saved: %02x otg_status: %02x chng: %02x",
++ otg_status_saved, otg_status, otg_status_saved ^ otg_status);
++
++ if (isp1301_bh_first || (otg_status_saved ^ otg_status)) {
++ inputs |= isp1301_event(tcd_instance->otg, isp1301_otg_status_tests, otg_status, 0xff,
++ "ISP1301 OTG STATUS");
++ otg_status_saved = otg_status;
++ }
++
++ #if 0
++ isp1301_info("OTG STATUS", otg_status);
++ if (isp1301_bh_first)
++ otg_status_saved = ~otg_status;
++
++ otg_status_saved = isp1301_update_otg_status( tcd_instance->otg, otg_status,
++ otg_status_saved ^ otg_status);
++ #endif
++ break;
++
++ // XXX
++ case max3301e:
++ special_function_22 = i2c_readb(MAX3301E_SPECIAL_FUNCTION_2_SET);
++ break;
++ case unknown_transceiver:
++ break;
++ }
++ }
++ if (inputs) otg_event(tcd_instance->otg, inputs, TCD, "ISP1301");
++ isp1301_bh_first = 0;
++}
++
++
++/*! isp1301_bh_wakeup - wakeup the isp1301 bottom half
++ */
++void isp1301_bh_wakeup(int first)
++{
++ //TRACE_MSG0(TCD, "--");
++ isp1301_bh_first |= first;
++ SCHEDULE_WORK(isp1301_private.bh);
++}
++
++
++/* ********************************************************************************************** */
++/*! isp1301_vbus - Do we have Vbus (cable attached?)
++ * Return non-zero if Vbus is detected.
++ *
++ */
++int isp1301_vbus (struct otg_instance *otg)
++{
++ return 0;
++}
++
++/*! isp1301_id - Do we have Vbus (cable attached?)
++ * Return non-zero if Vbus is detected.
++ *
++ */
++int isp1301_idvbus (struct otg_instance *otg)
++{
++ return 0;
++}
++
++
++/* ********************************************************************************************* */
++/*! isp1301_tcd_en() - used to enable
++ *
++ */
++void isp1301_tcd_en(struct otg_instance *otg, u8 flag)
++{
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "SET");
++ break;
++ case PULSE:
++ TRACE_MSG0(TCD, "PULSE");
++ break;
++ case RESET:
++ TRACE_MSG0(TCD, "RESET");
++ break;
++ }
++ isp1301_bh_wakeup(TRUE);
++}
++
++
++/*! isp1301_chrg_vbus - used to enable or disable B-device Vbus charging
++ */
++void isp1301_chrg_vbus(struct otg_instance *otg, u8 flag)
++{
++ //TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "CHRG_VBUS_SET");
++ i2c_writeb(ISP1301_OTG_CONTROL_SET, ISP1301_VBUS_CHRG);
++ break;
++ case RESET:
++ TRACE_MSG0(TCD, "CHRG_VBUS_RESET");
++ i2c_writeb(ISP1301_OTG_CONTROL_CLR, ISP1301_VBUS_RESET);
++ break;
++ case PULSE:
++ break;
++ }
++}
++
++/*! isp1301_drv_vbus - used to enable or disable A-device driving Vbus
++ */
++void isp1301_drv_vbus(struct otg_instance *otg, u8 flag)
++{
++ //TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "DRV_VBUS_SET");
++ i2c_writeb(ISP1301_OTG_CONTROL_SET, ISP1301_VBUS_DRV);
++ break;
++ case RESET:
++ TRACE_MSG0(TCD, "DRV_VBUS_RESET");
++ i2c_writeb(ISP1301_OTG_CONTROL_CLR, ISP1301_VBUS_RESET);
++ break;
++ }
++}
++
++/*! isp1301_dischrg_vbus - used to enable Vbus discharge
++ */
++void isp1301_dischrg_vbus(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = otg->tcd;
++ //TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "OUTPUT: TCD_DISCHRG_VBUS_SET");
++ i2c_writeb(ISP1301_OTG_CONTROL_SET, ISP1301_VBUS_DISCHRG);
++ break;
++ case RESET:
++ TRACE_MSG0(TCD, "OUTPUT: TCD_DISCHRG_VBUS_RESET");
++ i2c_writeb(ISP1301_OTG_CONTROL_CLR, ISP1301_VBUS_RESET);
++ break;
++ }
++}
++
++/*! isp1301_mx21_vbus_drain - used to enable Vbus discharge
++ */
++void isp1301_mx21_vbus_drain_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = otg->tcd;
++ //TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "OUTPUT: TCD_DISCHRG_VBUS_SET");
++ i2c_writeb(ISP1301_OTG_CONTROL_SET, ISP1301_VBUS_DISCHRG);
++ break;
++ case RESET:
++ TRACE_MSG0(TCD, "OUTPUT: TCD_DISCHRG_VBUS_RESET");
++ i2c_writeb(ISP1301_OTG_CONTROL_CLR, ISP1301_VBUS_RESET);
++ break;
++ }
++}
++
++/*! isp1301_dp_pullup_func - used to enable or disable peripheral connecting to bus
++ *
++ * C.f. 5.1.6, 5.1.7, 5.2.4 and 5.2.5
++ *
++ * host peripheral
++ * d+ pull-up clr set
++ * d+ pull-down set clr
++ *
++ * d- pull-up clr clr
++ * d- pull-down set set
++ *
++ */
++void isp1301_dp_pullup_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ //TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ isp1301_private.flags |= ISP1301_LOC_CONN;
++ TRACE_MSG0(TCD, "ISP1301_LOC_CONN SET - Set DP PULLUP");
++ i2c_writeb(ISP1301_OTG_CONTROL_SET, ISP1301_DP_PULLUP);
++ break;
++
++ case RESET:
++ isp1301_private.flags &= ~ISP1301_LOC_CONN;
++ TRACE_MSG0(TCD, "ISP1301_LOC_CONN RESET - Clr DP PULLUP");
++ i2c_writeb(ISP1301_OTG_CONTROL_CLR, ISP1301_DP_PULLUP);
++ break;
++ }
++}
++
++/*! isp1301_dm_pullup_func - used to enable or disable peripheral connecting to bus
++ *
++ */
++void isp1301_dm_pullup_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ //TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ isp1301_private.flags |= ISP1301_LOC_CONN;
++ TRACE_MSG0(TCD, "ISP1301_LOC_CONN SET - Set DM PULLUP");
++ i2c_writeb(ISP1301_OTG_CONTROL_SET, ISP1301_DM_PULLUP);
++ break;
++
++ case RESET:
++ isp1301_private.flags &= ~ISP1301_LOC_CONN;
++ TRACE_MSG0(TCD, "ISP1301_LOC_CONN RESET - Clr DM PULLUP");
++ i2c_writeb(ISP1301_OTG_CONTROL_CLR, ISP1301_DM_PULLUP);
++ break;
++ }
++}
++
++/*! isp1301_dp_pulldown_func - used to enable or disable peripheral connecting to bus
++ *
++ * C.f. 5.1.6, 5.1.7, 5.2.4 and 5.2.5
++ *
++ * host peripheral
++ * d+ pull-up clr set
++ * d+ pull-down set clr
++ *
++ * d- pull-up clr clr
++ * d- pull-down set set
++ *
++ */
++void isp1301_dp_pulldown_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ //TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ isp1301_private.flags |= ISP1301_LOC_CONN;
++ TRACE_MSG0(TCD, "ISP1301_LOC_CONN SET - Set DP PULLUP");
++ i2c_writeb(ISP1301_OTG_CONTROL_SET, ISP1301_DP_PULLDOWN);
++ break;
++
++ case RESET:
++ isp1301_private.flags &= ~ISP1301_LOC_CONN;
++ TRACE_MSG0(TCD, "ISP1301_LOC_CONN RESET - Clr DP PULLUP");
++ i2c_writeb(ISP1301_OTG_CONTROL_CLR, ISP1301_DP_PULLDOWN);
++ break;
++ }
++}
++
++/*! isp1301_dm_pulldown_func - used to enable or disable peripheral connecting to bus
++ *
++ */
++void isp1301_dm_pulldown_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ //TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ isp1301_private.flags |= ISP1301_LOC_CONN;
++ TRACE_MSG0(TCD, "ISP1301_LOC_CONN SET - Set DM PULLUP");
++ i2c_writeb(ISP1301_OTG_CONTROL_SET, ISP1301_DM_PULLDOWN);
++ break;
++
++ case RESET:
++ isp1301_private.flags &= ~ISP1301_LOC_CONN;
++ TRACE_MSG0(TCD, "ISP1301_LOC_CONN RESET - Clr DM PULLUP");
++ i2c_writeb(ISP1301_OTG_CONTROL_CLR, ISP1301_DM_PULLDOWN);
++ break;
++ }
++}
++
++/*! isp1301_peripheral_host_func - used to enable or disable peripheral connecting to bus
++ *
++ * A-Device D+ pulldown D- pulldown
++ * idle set set
++ * host set set
++ * peripheral reset set
++ *
++ * B-Device
++ * idle set set
++ * host set set
++ * peripheral reset set
++ */
++void isp1301_peripheral_host_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ //TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET: // peripheral
++ TRACE_MSG0(TCD, "SET - CLR DP PULLDOWN");
++ i2c_writeb(ISP1301_OTG_CONTROL_CLR, ISP1301_DP_PULLDOWN);
++ break;
++
++ case RESET: // host
++ TRACE_MSG0(TCD, "RESET - SET DM PULLDOWN");
++ i2c_writeb(ISP1301_OTG_CONTROL_SET, ISP1301_DP_PULLDOWN);
++ break;
++ }
++}
++
++/*! isp1301_dm_det_func - used to enable or disable D- detect
++ *
++ */
++void isp1301_dm_det_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ //TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "setting DM_HI detect");
++ isp1301_int_src_set(ISP1301_DM_HI);
++ isp1301_bh_wakeup(TRUE);
++ isp1301_debounce = 0;
++ break;
++
++ case RESET:
++ TRACE_MSG0(TCD, "reseting DM_HI detect");
++ isp1301_int_src_clr(ISP1301_DM_HI);
++ isp1301_bh_wakeup(TRUE);
++ isp1301_debounce = 1;
++ break;
++ }
++}
++
++/*! isp1301_dp_det_func - used to enable or disable D+ detect
++ *
++ */
++void isp1301_dp_det_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ //TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "setting DP_HI detect");
++ isp1301_int_src_set(ISP1301_DP_HI);
++ isp1301_bh_wakeup(TRUE);
++ break;
++
++ case RESET:
++ TRACE_MSG0(TCD, "reseting DP_HI detect");
++ isp1301_int_src_clr(ISP1301_DP_HI);
++ isp1301_bh_wakeup(TRUE);
++ break;
++ }
++}
++
++/*! isp1301_cr_det_func - used to enable or disable D+ detect
++ *
++ */
++void isp1301_cr_det_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ //TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "setting CR_INT detect");
++ isp1301_int_src_set(ISP1301_CR_INT);
++ isp1301_bh_wakeup(TRUE);
++ break;
++
++ case RESET:
++ TRACE_MSG0(TCD, "reseting CR_INT detect");
++ isp1301_int_src_clr(ISP1301_CR_INT);
++ isp1301_bh_wakeup(TRUE);
++ break;
++ }
++}
++
++/*! isp1301_bdis_acon_func - used to enable or disable auto a-connect
++ *
++ */
++void isp1301_bdis_acon_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ //TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "setting BDIS ACON");
++ isp1301_int_src_set(ISP1301_BDIS_ACON);
++ i2c_writeb(ISP1301_MODE_CONTROL_1_SET, ISP1301_BDIS_ACON_EN);
++ break;
++
++ case RESET:
++ TRACE_MSG0(TCD, "reseting BDIS ACON");
++ i2c_writeb(ISP1301_MODE_CONTROL_1_CLR, ISP1301_BDIS_ACON_EN);
++ isp1301_int_src_clr(ISP1301_BDIS_ACON);
++ break;
++ }
++}
++
++/*! isp1301_id_pulldown_func - used to enable or disable ID pulldown
++ *
++ */
++void isp1301_id_pulldown_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ //TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "setting ID PULLDOWN");
++ i2c_writeb(ISP1301_OTG_CONTROL_SET, ISP1301_ID_PULLDOWN);
++ break;
++
++ case RESET:
++ TRACE_MSG0(TCD, "reseting ID PULLDOWN");
++ i2c_writeb(ISP1301_OTG_CONTROL_CLR, ISP1301_ID_PULLDOWN);
++ break;
++ }
++}
++
++/*! isp1301_audio_func - used to enable or disable Carkit Interrupt
++ *
++ */
++void isp1301_audio_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ //TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "SET AUDIO_EN");
++ //isp1301_int_src_set(ISP1301_CR_INT);
++ i2c_writeb(ISP1301_MODE_CONTROL_2_SET, ISP1301_AUDIO_EN);
++ break;
++
++ case RESET:
++ TRACE_MSG0(TCD, "RESET AUDIO_EN");
++ i2c_writeb(ISP1301_MODE_CONTROL_2_CLR, ISP1301_AUDIO_EN);
++ //isp1301_int_src_clr(ISP1301_CR_INT);
++ break;
++ }
++}
++
++/*! isp1301_uart_func - used to enable or disable transparent uart mode
++ *
++ */
++void isp1301_uart_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ //TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "setting UART_EN");
++ i2c_writeb(ISP1301_MODE_CONTROL_1_SET, ISP1301_UART_EN);
++ /* XXX enable uart */
++ break;
++
++ case RESET:
++ TRACE_MSG0(TCD, "reseting UART_EN");
++ i2c_writeb(ISP1301_MODE_CONTROL_1_CLR, ISP1301_UART_EN);
++ /* XXX disable uart */
++ break;
++ }
++}
++
++/*! isp1301_mono_func - used to enable or disable mono audio connection
++ *
++ */
++void isp1301_mono_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ //TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "setting MONO");
++ /* XXX enable mono output */
++ break;
++
++ case RESET:
++ TRACE_MSG0(TCD, "reseting MONO");
++ /* XXX disable mono output */
++ break;
++ }
++}
++
++
++/* ********************************************************************************************* */
++extern int isp1301_procfs_init (void);
++extern void isp1301_procfs_exit (void);
++
++extern void mx2_isp1301_bh(void *arg);
++
++/*! isp1301_mod_init
++ */
++int isp1301_mod_init(WORK_PROC bh_proc)
++//int isp1301_mod_init(void)
++{
++ /* for interrupt bottom half handler
++ */
++ //PREPARE_WORK_ITEM(isp1301_private.bh, &isp1301_bh, NULL);
++
++ UNLESS(bh_proc)
++ bh_proc = &isp1301_bh;
++
++ PREPARE_WORK_ITEM(isp1301_private.bh, bh_proc, NULL);
++
++ //else
++ // PREPARE_WORK_ITEM(isp1301_private.bh, &isp1301_bh, NULL);
++
++ /* setup isp1301, enable interrupts, clear latch
++ * XXX when and how do we do DM_HI and DP_HI, when ID is present?
++ */
++
++ isp1301_int_src(ISP1301_ID_FLOAT | ISP1301_DM_HI | ISP1301_ID_GND | ISP1301_DP_HI | ISP1301_SESS_VLD | ISP1301_VBUS_VLD);
++
++ //isp1301_int_src(ISP1301_INT_SRC);
++ //isp1301_int_src(ISP1301_NO_SE1_INT);
++ //isp1301_int_src_clr(ISP1301_CR_INT);
++
++ //i2c_writeb(ISP1301_OTG_CONTROL_SET, ISP1301_DM_PULLDOWN | ISP1301_DP_PULLDOWN);
++
++#ifdef CONFIG_OTG_ISP1301_PROCFS
++ isp1301_procfs_init ();
++#endif /* CONFIG_OTG_ISP1301_PROCFS */
++
++ return 0;
++}
++
++/*! isp1301_mod_exit
++ */
++void isp1301_mod_exit(void)
++{
++ i2c_writeb(ISP1301_INTERRUPT_ENABLE_LOW_CLR, 0xff);
++ i2c_writeb(ISP1301_INTERRUPT_ENABLE_HIGH_CLR, 0xff);
++ //i2c_close();
++#ifdef CONFIG_OTG_ISP1301_PROCFS
++ isp1301_procfs_exit ();
++#endif /* CONFIG_OTG_ISP1301_PROCFS */
++
++ while (PENDING_WORK_ITEM(isp1301_private.bh)) {
++ printk(KERN_ERR"%s: waiting for bh\n", __FUNCTION__);
++ schedule_timeout(10 * HZ);
++ }
++
++}
++
++/* ********************************************************************************************* */
++/*! isp1301_configure - configure the ISP1301 for this host
++ * @param tx_mode - the type of connection between the host USB and the ISP1301
++ * @param spd_ctrl - suspend control method
++ */
++void isp1301_configure(tx_mode_t tx_mode, spd_ctrl_t spd_ctrl)
++{
++ u16 vendor = 0, product = 0, revision = 0;
++ u8 mode1, mode2, control;
++
++ struct otg_transceiver_map *map = isp1301_transceiver_map;
++
++
++#if defined(CONFIG_OTG_ISP1301_MX2ADS) || defined(CONFIG_OTG_ISP1301_MX2ADS_MODULE)
++ u32 vp;
++ TRACE_MSG0(TCD, "1. Read Transceiver ID's with long read");
++ vp = i2c_readl(ISP1301_VENDOR_ID);
++ isp1301_private.vendor = vp & 0xffff;
++ isp1301_private.product = vp >> 16;
++ isp1301_private.revision = i2c_readw(ISP1301_VERSION_ID);
++ mode1 = i2c_readb(ISP1301_MODE_CONTROL_1_SET);
++ mode2 = i2c_readb(ISP1301_MODE_CONTROL_2_SET);
++
++ TRACE_MSG5(TCD, "2. OTG Transceiver: vendor: %04x product: %04x revision: %04x mode1: %02x mode2: %02x",
++ vendor, product, revision, mode1, mode2);
++
++#else /* defined(CONFIG_OTG_ISP1301_MX2ADS) */
++
++ isp1301_private.vendor = i2c_readw(ISP1301_VENDOR_ID);
++ isp1301_private.product = i2c_readw(ISP1301_PRODUCT_ID);
++ isp1301_private.revision = i2c_readw(ISP1301_VERSION_ID);
++ mode1 = i2c_readb(ISP1301_MODE_CONTROL_1_SET);
++ mode2 = i2c_readb(ISP1301_MODE_CONTROL_2_SET);
++
++ TRACE_MSG5(TCD, "2. OTG Transceiver: vendor: %04x product: %04x revision: %04x mode1: %02x mode2: %02x",
++ isp1301_private.vendor, isp1301_private.product, isp1301_private.revision, mode1, mode2);
++
++#endif /* defined(CONFIG_OTG_ISP1301_MX2ADS) */
++
++ for ( ; map && map->transceiver_type != unknown_transceiver; map++) {
++ CONTINUE_UNLESS ((isp1301_private.vendor == map->vendor) && (isp1301_private.product == map->product));
++ TRACE_MSG1(TCD, "Found Transceiver: %s", map->name);
++ isp1301_private.transceiver_map = map;
++ break;
++ }
++ UNLESS (isp1301_private.transceiver_map)
++ isp1301_private.transceiver_map = isp1301_transceiver_map;
++
++ TRACE_MSG0(TCD, "3. Disable All Transceiver Control Register 1 ");
++ i2c_writeb(ISP1301_OTG_CONTROL_CLR, 0xff); // clear
++
++ TRACE_MSG0(TCD, "4. Enable D-/D+ Pulldowns in Transceiver Control Register 1 ");
++
++ i2c_writeb(ISP1301_OTG_CONTROL_SET, ISP1301_DM_PULLDOWN | ISP1301_DP_PULLDOWN);
++ i2c_writeb(ISP1301_OTG_CONTROL_CLR, (u8) ISP1301_DM_PULLUP | ISP1301_DP_PULLUP);
++
++
++ TRACE_MSG0(TCD, "5. Clear latch and enable interrupts");
++ i2c_writeb(ISP1301_INTERRUPT_LATCH_CLR, 0xff);
++ //i2c_writeb(ISP1301_INTERRUPT_ENABLE_LOW_CLR, 0xeb);
++ //i2c_writeb(ISP1301_INTERRUPT_ENABLE_HIGH_CLR, 0xeb);
++ isp1301_int_src_set(0xeb);
++
++ /* The PSW_OE enables the ADR/PSW pin for output driving either high
++ * or low depending on the address.
++ *
++ * ADR ADR_REG Address PSW_OE=0 PSW_OE=1
++ *
++ * low 0 0x2c LOW HIGH
++ *
++ * high 1 0x2d HIGH LOW
++ *
++ *
++ * The i2c address by tying the ADR/PSW pin either high or low.
++ * Setting the PSW_OE drives the ADR/PSW into the opposite of the
++ * default wiring.
++ *
++ * On the MX21ADS the ADR/PSW pin is wired high which enables the
++ * charge pump. So enabling the PSW_OE is required to disable Vbus
++ * generation on the Charge Pump.
++ *
++ * The MAX3355E will only enable Vbus when this signal is high AND
++ * the ID signal is low. So it may be safe to leave enabled when
++ * operating as a B-device (ID floating.)
++ */
++
++ //i2c_writeb(ISP1301_MODE_CONTROL_2_SET, ISP1301_PSW_OE); // PSW_OE - OFFVBUS low
++
++
++ TRACE_MSG1(TCD, "6. tx_mode: %02x", tx_mode);
++ switch (tx_mode) {
++ case vp_vm_bidirectional:
++ break;
++ case dat_se0_unidirectional:
++ i2c_writeb(ISP1301_MODE_CONTROL_2_CLR, ISP1301_BI_DI);
++ case dat_se0_bidirectional:
++ i2c_writeb(ISP1301_MODE_CONTROL_1_SET, ISP1301_DAT_SE0);
++ break;
++ }
++ TRACE_MSG0(TCD, "6. tx_mode done");
++
++ TRACE_MSG1(TCD, "7. spd_ctrl: %02x", spd_ctrl);
++ switch (spd_ctrl) {
++ case spd_susp_pins:
++ i2c_writeb(ISP1301_MODE_CONTROL_2_CLR, ISP1301_SPD_SUSP_CTRL);
++ break;
++ case spd_susp_reg:
++ i2c_writeb(ISP1301_MODE_CONTROL_2_SET, ISP1301_SPD_SUSP_CTRL);
++ break;
++ }
++
++ //i2c_writeb(ISP1301_MODE_CONTROL_2_SET, ISP1301_PSW_OE); // PSW_OE - OFFVBUS low
++
++ TRACE_MSG0(TCD, "7. spd_ctrl done");
++
++ TRACE_MSG1(TCD, "8. transceiver_type: %02x", isp1301_private.transceiver_map);
++
++ TRACE_MSG1(TCD, "8. transceiver_type: %02x", isp1301_private.transceiver_map->transceiver_type);
++ switch (isp1301_private.transceiver_map->transceiver_type) {
++ case isp1301:
++ break;
++ case max3301e:
++ i2c_writeb(MAX3301E_SPECIAL_FUNCTION_1_SET, MAX3301E_SESS_END);
++ break;
++ case unknown_transceiver:
++ break;
++ }
++ TRACE_MSG0(TCD, "8. transceiver_type done");
++}
++
+diff -uNr linux/drivers/no-otg/ocd/isp1301/tcd-mainstone.c linux/drivers/otg/ocd/isp1301/tcd-mainstone.c
+--- linux/drivers/no-otg/ocd/isp1301/tcd-mainstone.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/isp1301/tcd-mainstone.c 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,177 @@
++/*
++ * otg/ocd/mx2/tcd-mainstone.c -- Mainstone ISP1301 Transceiver Controller driver
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/ocd/isp1301/tcd-mainstone.c
++ * @brief Mainstone ISP1301 driver.
++ *
++ * This implements the ISP1301 Transceiver Controller Driver for the Mainstone
++ * using the USBOTG I2C controller for access.
++ *
++ * Notes
++ *
++ * 1. The interrupt source is handled by the OCD driver so we just publish
++ * an interrupt handler for it to call.
++ *
++ *
++ * @ingroup ISP1301TCD
++ */
++
++#include <otg/pcd-include.h>
++#include <linux/pci.h>
++#include <asm/arch/irq.h>
++#include <asm/arch/irqs.h>
++#include <otghw/isp1301-hardware.h>
++#include "mx2.h"
++#include "otghw/bvd-hardware.h"
++#include <otghw/isp1301.h>
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++
++
++/* ********************************************************************************************* */
++
++
++/*! isp1301_int_hndlr
++ */
++static irqreturn_t isp1301_int_hndlr (int irq, void *dev_id, struct pt_regs *regs)
++{
++ TRACE_MSG0(TCD, "--");
++
++ SCHEDULE_WORK(isp1301_private.bh);
++
++ return IRQ_HANDLED;
++}
++
++
++/* ********************************************************************************************* */
++
++/*! mainstone_tcd_init - used to initialize/enable or disable the tcd driver
++ */
++void mainstone_tcd_init(struct otg_instance *otg, u8 flag)
++{
++ TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "MAINSTONE_TCD_EN SET");
++ otg_event(otg, TCD_OK, TCD, "TCD_OK");
++ isp1301_thread_wakeup(1, 1);
++ break;
++ case RESET:
++ TRACE_MSG0(TCD, "MAINSTONE_TCD_EN RESET");
++ isp1301_thread_wakeup(0, 0);
++ otg_event(otg, TCD_OK, TCD, "TCD_OK");
++ break;
++ }
++}
++
++
++struct tcd_ops tcd_ops;
++struct tcd_instance *mainstone_tcd_instance;
++//wait_queue_head_t mx2_i2c_wait; // wait structure for i2c i/o interrupt
++
++#define ADAPTOR_NAME "PXA-I2C-Adapter"
++
++/*! mainstone_mod_init
++ */
++int mainstone_mod_init(void)
++{
++ struct otg_instance *otg;
++ int i2c = i2c_configure(ADAPTOR_NAME, ISP1301_I2C_ADDR_HIGH);
++ int irq = request_irq (GPIOX_TO_IRQ(35), isp1301_int_hndlr, SA_INTERRUPT, "ISP1301", NULL);
++
++ TRACE_MSG0(TCD, "--");
++
++ THROW_IF(i2c, error);
++
++ TRACE_MSG0(TCD, "1. Enable Mainstone external OTG Transceiver!");
++
++ TRACE_MSG1(TCD, "MST_MSCWR2: %08x", MST_MSCWR2);
++ MST_MSCWR2 |= MSCWR2_USB_OTG_SEL | MSCWR2_USB_OTG_RST;
++ TRACE_MSG1(TCD, "MST_MSCWR2: %08x", MST_MSCWR2);
++
++
++ TRACE_MSG0(TCD, "2. configure i2c driver!");
++ isp1301_configure(dat_se0_bidirectional, spd_susp_reg);
++
++ TRACE_MSG0(TCD, "3. configure isp1301!");
++ isp1301_mod_init();
++
++ TRACE_MSG0(TCD, "4. set ops");
++ THROW_UNLESS(ocd_instance && (otg = ocd_instance->otg), error);
++ THROW_UNLESS(mainstone_tcd_instance = otg_set_tcd_ops(&tcd_ops), error);
++
++ /* Success!
++ */
++ TRACE_MSG0(TCD, "5. Success!");
++
++ otg_init(otg);
++ //otg_start(otg, ocd_ops.capabilities & OCD_CAPABILITIES_AUTO);
++
++ // XXX TESTING
++ //isp1301_dp_pullup_func(otg, 1);
++
++ /* XXX start thread to monitor for changes - not needed once gpio interrupt implmented
++ */
++ isp1301_thread_init(isp1301_bh);
++
++ /* error handling
++ */
++ CATCH(error) {
++ //if (irq) free_irq(GPIO_2_80_TO_IRQ(35), NULL);
++ if (irq) free_irq(GPIOX_TO_IRQ(35), NULL);
++ if (i2c) i2c_close();
++ }
++ return 0;
++}
++
++/*! mainstone_mod_exit
++ */
++void mainstone_mod_exit(void)
++{
++ //free_irq(GPIO_2_80_TO_IRQ(35), NULL);
++ free_irq(GPIOX_TO_IRQ(35), NULL);
++
++ /* XXX stop thread - not needed once gpio interrupt implmented
++ */
++ isp1301_thread_exit(NULL);
++
++ isp1301_mod_exit();
++ TRACE_MSG1(TCD, "MST_MSCWR2: %08x", MST_MSCWR2);
++ MST_MSCWR2 &= ~(MSCWR2_USB_OTG_SEL | MSCWR2_USB_OTG_RST);
++ TRACE_MSG1(TCD, "MST_MSCWR2: %08x", MST_MSCWR2);
++ //isp1301_thread_exit();
++ i2c_close();
++
++}
++
++/* ********************************************************************************************* */
++
++struct tcd_ops tcd_ops = {
++
++ vbus: isp1301_vbus,
++
++ mod_init: mainstone_mod_init,
++ mod_exit: mainstone_mod_exit,
++
++ tcd_init_func: mainstone_tcd_init,
++
++ dischrg_vbus_func: isp1301_dischrg_vbus,
++ chrg_vbus_func: isp1301_chrg_vbus,
++ drv_vbus_func: isp1301_drv_vbus,
++ dp_pullup_func: isp1301_dp_pullup_func,
++ dm_pullup_func: isp1301_dm_pullup_func,
++ dm_det_func: isp1301_dm_det_func,
++ dp_det_func: isp1301_dp_det_func,
++
++};
++
+diff -uNr linux/drivers/no-otg/ocd/isp1301/tcd-omap-h2.c linux/drivers/otg/ocd/isp1301/tcd-omap-h2.c
+--- linux/drivers/no-otg/ocd/isp1301/tcd-omap-h2.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/isp1301/tcd-omap-h2.c 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,180 @@
++/*
++ * otg/ocd/isp1301/tcd-omap-h2.c -- USB Transceiver Controller driver
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/ocd/isp1301/tcd-omap-h2.c
++ * @brief OMAP H2 ISP1301 driver.
++ *
++ *
++ * @ingroup ISP1301TCD
++ */
++
++#include <otg/pcd-include.h>
++#include <linux/pci.h>
++#include <asm/arch/irq.h>
++#include <asm/arch/irqs.h>
++#include <otghw/isp1301-hardware.h>
++#include "otghw/bvd-hardware.h"
++#include <otghw/isp1301.h>
++
++#include <asm/irq.h>
++#include <asm/system.h>
++#include <asm/io.h>
++#include <linux/i2c.h>
++
++#include <asm/arch/gpio.h>
++#include <asm/arch/mux.h>
++//struct isp1301_private isp1301_private;
++
++/* ********************************************************************************************* */
++
++
++static irqreturn_t isp1301_int_hndlr (int irq, void *dev_id, struct pt_regs *regs)
++{
++ TRACE_MSG0(TCD, "--");
++
++ SCHEDULE_WORK(isp1301_private.bh);
++
++ return IRQ_HANDLED;
++}
++
++
++/* ********************************************************************************************* */
++
++struct tcd_ops tcd_ops;
++
++#define ADAPTOR_NAME "OMAP I2C"
++
++/*! omap_mod_init
++ */
++int omap_mod_init(void)
++{
++ int i2c = i2c_configure(ADAPTOR_NAME, ISP1301_I2C_ADDR_HIGH);
++
++ int gpio = omap_request_gpio (ISP1301_GPIO);
++ int irq = 0;
++
++ TRACE_MSG0(TCD, "--");
++
++ /* did we get gpio and i2c?
++ */
++ THROW_IF(gpio || i2c, error);
++
++ /* for interrupt bottom half handler
++ */
++ // moved isp1301.c - PREPARE_WORK_ITEM(isp1301_private.bh, &isp1301_bh, NULL);
++
++ /*
++ * See H2 C.f. Figure 17 USBOTG Interface Connection
++ * GPIO2 M14
++ * setup gpio 2 and request interrupt for it
++ */
++ omap_set_gpio_direction(ISP1301_GPIO, 1);
++ //omap_cfg_reg(M14_1510_GPIO2);
++ omap_set_gpio_edge_ctrl(ISP1301_GPIO, OMAP_GPIO_FALLING_EDGE);
++ irq = request_irq (OMAP_GPIO_IRQ(ISP1301_GPIO), isp1301_int_hndlr, SA_INTERRUPT, "ISP1301", NULL);
++ THROW_IF(irq, error);
++
++ #ifdef CONFIG_OTG_OMAP_H2_3_WIRE
++
++ /* OTG on Pin Group 1 Using 3-Wire OTG Transceiver C.f. Figure 15-59
++ * See also H2 C.f. Figure 17 USBOTG Interface Connection
++ * DAT_SE0 mode
++ * Set DAT_SE0, SUSPEND_REG and BI_DI
++ */
++ //i2c_writeb(ISP1301_MODE_CONTROL_1_SET, ISP1301_DAT_SE0 | ISP1301_SUSPEND_REG);
++ //i2c_writeb(ISP1301_MODE_CONTROL_1_CLR, ~(ISP1301_DAT_SE0 | ISP1301_SUSPEND_REG));
++ //i2c_writeb(ISP1301_MODE_CONTROL_2_SET, ISP1301_BI_DI);
++ //i2c_writeb(ISP1301_MODE_CONTROL_2_CLR, ~ISP1301_BI_DI);
++
++ isp1301_configure(dat_se0_bidirectional, spd_susp_pins);
++
++ #elif CONFIG_OTG_OMAP_H2_4_WIRE
++
++ /* OTG on Pin Group 1 Using 4-Wire OTG Transceiver C.f. Figure 15-60
++ * See also H2 C.f. Figure 17 USBOTG Interface Connection
++ * VP_VM mode
++ * Reset DAT_SE0
++ * Set SUSPEND_REG and BI_DI
++ */
++ //i2c_writeb(ISP1301_MODE_CONTROL_1_SET, ISP1301_SUSPEND_REG);
++ //i2c_writeb(ISP1301_MODE_CONTROL_1_CLR, ~ISP1301_SUSPEND_REG);
++ //i2c_writeb(ISP1301_MODE_CONTROL_2_SET, ISP1301_BI_DI);
++ //i2c_writeb(ISP1301_MODE_CONTROL_2_CLR, ~ISP1301_BI_DI);
++
++ isp1301_configure(vp_vm_bidirectional);
++
++ #else
++ #error "ISP1301 Connection style not selected!"
++ #endif /* CONFIG_OTG_OMAP_H2_4_WIRE */
++
++ isp1301_mod_init();
++
++ i2c_writeb(ISP1301_OTG_CONTROL_SET, ISP1301_DM_PULLDOWN | ISP1301_DP_PULLDOWN);
++
++ /* Success!
++ */
++
++ TRACE_MSG0(TCD, "5. Success!");
++
++ otg_init(otg);
++
++ /* error handling
++ */
++ CATCH(error) {
++ if (irq) free_irq(OMAP_GPIO_IRQ(ISP1301_GPIO), NULL);
++ if (gpio) omap_free_gpio(ISP1301_GPIO);
++ if (i2c) i2c_close();
++ }
++ return 0;
++}
++
++/*! omap_mod_exit
++ */
++void omap_mod_exit(void)
++{
++ #if 0
++ // moved to isp1301.c
++ while (PENDING_WORK_ITEM(isp1301_private.bh)) {
++ printk(KERN_ERR"%s: waiting for bh\n", __FUNCTION__);
++ schedule_timeout(10 * HZ);
++ }
++ #endif
++
++ isp1301_mod_exit();
++
++ i2c_writeb(ISP1301_INTERRUPT_ENABLE_LOW_CLR, 0xff);
++ i2c_writeb(ISP1301_INTERRUPT_ENABLE_HIGH_CLR, 0xff);
++ i2c_close();
++ free_irq(OMAP_GPIO_IRQ(ISP1301_GPIO), NULL);
++ omap_free_gpio(ISP1301_GPIO);
++}
++
++/* ********************************************************************************************* */
++
++struct tcd_ops tcd_ops = {
++
++ //initial_state: tr_init,
++ vbus: isp1301_vbus,
++
++ mod_init: omap_mod_init,
++ mod_exit: omap_mod_exit,
++
++ dischrg_vbus_func: isp1301_dischrg_vbus,
++ chrg_vbus_func: isp1301_chrg_vbus,
++ drv_vbus_func: isp1301_drv_vbus,
++ dp_pullup_func: isp1301_dp_pullup_func,
++ dm_pullup_func: isp1301_dm_pullup_func,
++ dm_det_func: isp1301_dm_det_func,
++ dp_det_func: isp1301_dp_det_func,
++
++};
++
+diff -uNr linux/drivers/no-otg/ocd/isp1301/thread-l24.c linux/drivers/otg/ocd/isp1301/thread-l24.c
+--- linux/drivers/no-otg/ocd/isp1301/thread-l24.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/isp1301/thread-l24.c 2006-09-01 21:41:31.000000000 +0200
+@@ -0,0 +1,144 @@
++/*
++ * otg/ocd/isp1301/thread-l24.c -- MX21ADS ISP1301 Transceiver Controller driver
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/ocd/isp1301/thread-l24.c
++ * @brief Implement a kernel thread for checking ISP1301.
++ *
++ *
++ * @ingroup ISP1301TCD
++ */
++
++#include <otg/pcd-include.h>
++#include <otg/otg-module.h>
++#include <linux/pci.h>
++//#include <asm/arch/mx2.h>
++#include <otghw/isp1301-hardware.h>
++//#include "mx2.h"
++//#include "otghw/mx2-hardware.h"
++
++
++/* isp1301_bh
++ */
++extern void isp1301_bh(void *arg);
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++
++/* I2C Thread
++ * The mx21 USBOTG module does not seem to be able to keep uptodate with the OTG Transceiver
++ * registers. This kernel thread will iterated endlessly reading the appropriate registers.
++ *
++ * If this is successful we can assume that the USBOTG module will correctly monitor the appropriate
++ * registers and allow us to follow them via the normal USBOTG interrupts and registers.
++ *
++ * Otherwise we can monitor here and issue the otg events directly.
++ */
++//#define ISP1301_THREAD_TIMEOUT_EN (10)
++#define ISP1301_THREAD_TIMEOUT_EN (1*HZ)
++#define ISP1301_THREAD_TIMEOUT_DIS (1*HZ)
++
++int isp1301_terminate;
++int mx2_pid;
++wait_queue_head_t isp1301_wait;
++static DECLARE_COMPLETION(mx2_exited);
++int isp1301_en;
++
++void (*isp1301_bh_proc)(void *);
++
++/*! isp1301_thread - implement a kernel task to monitor isp1301 for changes
++ */
++int isp1301_thread(void *data)
++{
++ u8 int_src_saved = 0, otg_status_saved = 0, int_src, otg_status;
++ TRACE_MSG0(TCD, "--");
++ daemonize();
++ reparent_to_init();
++ sprintf(current->comm, "isp1301_thread");
++
++ /* loop until told to terminate
++ */
++ while (!isp1301_terminate) {
++
++ #if 0
++ // XXX TESTING
++ static int count = 0;
++ count++;
++ if (!(count % 5))
++ isp1301_dp_pullup_func(tcd_instance->otg, !(count % 10)? 1 : 2);
++ #endif
++
++ /* sleep for a while if not enabled
++ */
++ if (!isp1301_en) {
++ TRACE_MSG1(TCD, "WAITING: %d", ISP1301_THREAD_TIMEOUT_DIS);
++ interruptible_sleep_on_timeout(&isp1301_wait, ISP1301_THREAD_TIMEOUT_DIS);
++ continue;
++ }
++
++ /* update 1301
++ */
++ if (isp1301_bh_proc)
++ isp1301_bh_proc(NULL);
++
++ //TRACE_MSG1(TCD, "SLEEPING: %d", ISP1301_THREAD_TIMEOUT_EN);
++ interruptible_sleep_on_timeout(&isp1301_wait, ISP1301_THREAD_TIMEOUT_EN);
++ //TRACE_MSG0(TCD, "RUNNING");
++ }
++ TRACE_MSG0(TCD, "Exiting");
++ complete_and_exit(&mx2_exited, 0);
++}
++
++extern int isp1301_bh_first;
++/*! isp1301_thread_wakeup - wakeup the isp1301 task
++ */
++void isp1301_thread_wakeup(int enabled, int first)
++{
++ TRACE_MSG0(TCD, "--");
++ isp1301_bh_first |= first;
++ isp1301_en = enabled;
++ wake_up(&isp1301_wait);
++}
++
++/* ********************************************************************************************* */
++
++/*! isp1301_thread_init - initial tcd setup
++ * Allocate interrupts and setup hardware.
++ */
++int isp1301_thread_init (void (bh_proc)(void *))
++{
++ isp1301_terminate = 0;
++ TRACE_MSG0(TCD, "--");
++ isp1301_bh_proc = bh_proc;
++ init_waitqueue_head(&isp1301_wait);
++ THROW_IF((mx2_pid = kernel_thread(&isp1301_thread, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGHAND)) < 0, error);
++ isp1301_thread_wakeup(0, 0);
++
++ CATCH(error) {
++ return -EINVAL;
++ }
++ return 0;
++}
++
++/*! isp1301_thread_exit - de-initialize
++ */
++void isp1301_thread_exit (wait_queue_head_t *wait_queue)
++{
++ TRACE_MSG0(TCD, "MX2_MOD_TCD_EXIT - terminating");
++ isp1301_bh_proc = NULL;
++ isp1301_terminate = 1;
++ if (wait_queue)
++ wake_up_interruptible(wait_queue); // wakeup waiting bottom half handler
++ isp1301_thread_wakeup(0, 0);
++ wait_for_completion(&mx2_exited);
++ TRACE_MSG0(TCD, "MX2_MOD_TCD_EXIT - terminated");
++}
++
+diff -uNr linux/drivers/no-otg/ocd/max3353e/Config.in linux/drivers/otg/ocd/max3353e/Config.in
+--- linux/drivers/no-otg/ocd/max3353e/Config.in 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/max3353e/Config.in 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,19 @@
++
++#
++# @(#) balden@belcarra.com|otg/ocd/max3353e/Config.in|20060831021117|26677
++# Copyright (c) 2004 Belcarra
++# Copyright (c) 2005-2006 Belcarra Technologies 2005 Corp
++#
++# MAX 3353E TCD
++
++if [ "$CONFIG_OTG_MAX3353E" = "y" ]; then
++ mainmenu_option next_comment
++
++ comment 'MAX 3353E (i2c)'
++
++ dep_bool 'Proc FS debug' CONFIG_OTG_MAX3353E_PROCFS $CONFIG_OTG_MAX3353E
++
++ endmenu
++else
++ define_bool CONFIG_OTG_MAX3353E_PROCFS n
++fi
+diff -uNr linux/drivers/no-otg/ocd/max3353e/Makefile linux/drivers/otg/ocd/max3353e/Makefile
+--- linux/drivers/no-otg/ocd/max3353e/Makefile 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/max3353e/Makefile 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,100 @@
++#
++# Makefile for the kernel USBD (device not host) drivers.
++# @(#) balden@belcarra.com|otg/ocd/max3353e/Makefile-l24|20060831021117|12633
++#
++# Copyright (c) 2004 Belcarra
++# Copyright (c) 2005-2006 Belcarra Technologies 2005 Corp
++
++# 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 := max3353e_target.o
++list-multi := max3353e_tcd.o
++
++# Objects that export symbols.
++
++export-objs := i2c-max3353e.o max3353e.o
++
++# Multipart objects.
++
++#db1550_tcd-objs := tcd-init-l24.o tcd-omap-h2.o max3353e.o i2c-l26.o tcd.o max3353e-procfs.o
++#db1550_tcd-objs := tcd-init-l24.o tcd-db1550.o tcd-mx2ads.o max3353e.o i2c-l26.o tcd.o max3353e-procfs.o
++db1550_tcd-objs := tcd-init-l24.o max3353e.o tcd-db1550.o i2c-max3353e.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_OTG_MAX3353E_DB1550) += db1550_tcd.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.
++
++DOT_DIR=$(TCD_DIR)/max3353e
++
++include $(TOPDIR)/Rules.make
++OTG=$(TOPDIR)/drivers/otg
++OCD_DIR=$(OTG)ocd/
++OTGLIB=$(OTG)/ocd/otglib
++INCLUDE_DIRS = -I$(OTG)
++EXTRA_CFLAGS += -Wno-missing-prototypes -Wno-unused -Wno-format ${INCLUDE_DIRS}
++EXTRA_CFLAGS_nostdinc += -Wno-missing-prototypes -Wno-unused -Wno-format ${INCLUDE_DIRS}
++
++I2C=$(OTG)/ocd/otg-i2c
++PCD=$(OTG)/ocd/otg-pcd
++TCD=$(OTG)/ocd/otg-tcd
++vpath %.c $(USBDCORE_DIR) $(OCD_DIR) $(PCD) $(TCD) $(OTGLIB)
++
++
++# Link rules for multi-part drivers.
++
++db1550_tcd.o: $(db1550_tcd-objs)
++ $(LD) -r -o $@ $(db1550_tcd-objs)
++
++# dependencies:
++
++# local
++
++
+diff -uNr linux/drivers/no-otg/ocd/max3353e/Makefile-l26 linux/drivers/otg/ocd/max3353e/Makefile-l26
+--- linux/drivers/no-otg/ocd/max3353e/Makefile-l26 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/max3353e/Makefile-l26 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,28 @@
++#
++# Makefile for the kernel USBD (device not host) drivers.
++# @(#) balden@belcarra.com|otg/ocd/max3353e/Makefile-l26|20060831021117|56045
++#
++# Copyright (c) 2004 Belcarra Technologies Corp
++# Copyright (c) 2005-2006 Belcarra Technologies 2005 Corp
++
++DOT_DIR=$(TCD_DIR)/max3353e
++
++OTG=$(TOPDIR)/drivers/otg
++HCD_DIR=$(OTG)/hcd
++TCD_DIR=$(OTG)/tcd
++USBDCORE_DIR=$(OTG)/usbdcore
++OTGCORE_DIR=$(OTG)/otgcore
++INCLUDE_DIRS = -I$(OTG)
++EXTRA_CFLAGS += -Wno-missing-prototypes -Wno-unused -Wno-format ${INCLUDE_DIRS}
++EXTRA_CFLAGS_nostdinc += -Wno-missing-prototypes -Wno-unused -Wno-format ${INCLUDE_DIRS}
++
++vpath %.c $(USBDCORE_DIR) $(OCD_DIR)
++
++
++# Link rules for multi-part drivers.
++
++db1550_tcd-objs := ../tcd-init-l24.o max3353e.o i2c-l26.o ../tcd.o
++obj-$(CONFIG_OTG_MAX3353E_DB1550) += db1550_tcd.o
++
++
++
+diff -uNr linux/drivers/no-otg/ocd/max3353e/README linux/drivers/otg/ocd/max3353e/README
+--- linux/drivers/no-otg/ocd/max3353e/README 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/max3353e/README 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,9 @@
++Some notes for using max3353 tranciever in DB1550 development board
++1- Patch kernel with AMD DB1550 i2c driver.
++2- Patch arch/mips/au1000/db1x00/irqmap.c
++#if defined(CONFIG_MIPS_DB1550) || defined(CONFIG_MIPS_MTX2)
++ { AU1000_GPIO_3, INTC_INT_LOW_LEVEL, 0 }, // PCMCIA Card 0 IRQ#
++ { AU1000_GPIO_5, INTC_INT_LOW_LEVEL, 0 }, // PCMCIA Card 1 IRQ#
++ { AU1500_GPIO_207, INTC_INT_FALL_EDGE, 0 }, // OTG tranciever
++#else
++
+diff -uNr linux/drivers/no-otg/ocd/max3353e/i2c-max3353e.c linux/drivers/otg/ocd/max3353e/i2c-max3353e.c
+--- linux/drivers/no-otg/ocd/max3353e/i2c-max3353e.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/max3353e/i2c-max3353e.c 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,178 @@
++/* @(#) balden@belcarra.com|otg/ocd/max3353e/i2c-max3353e.c|20060831021117|42179
++ * Copyright (c) 2005-2006 Belcarra Technologies 2005 Corp
++ */
++#include <otg/otg-compat.h>
++
++#include <asm/irq.h>
++#include <asm/system.h>
++#include <asm/io.h>
++#include <linux/i2c.h>
++
++#include <otg/pcd-include.h>
++#include <linux/pci.h>
++#include <otghw/max3353e-hardware.h>
++//#include "isp1301.h"
++
++/*
++ * N.B. i2c functions must not be called from interrupt handlers
++ */
++
++static struct file *i2c_file;
++static struct i2c_client *db1550_i2c_client;
++static int initstate_i2c;
++static int initstate_region;
++#define MAX_I2C 16
++
++#ifdef CONFIG_OMAP_H2
++#define ADAPTOR_NAME "OMAP I2C"
++#endif /* CONFIG_OMAP_H2 */
++#ifdef CONFIG_ARCH_MAINSTONE
++#define ADAPTOR_NAME "PXA-I2C-Adapter"
++#endif /* CONFIG_ARCH_MAINSTONE */
++#ifdef CONFIG_OTG_DB1550_J15
++#define ADAPTOR_NAME "pb1550 adapter"
++#endif /* CONFIG_OTG_DB1550_J15 */
++
++void i2c_writeb(u8 subaddr, u8 buf)
++{
++ char tmpbuf[2];
++ int ret;
++
++ tmpbuf[0] = subaddr; /*register number */
++ tmpbuf[1] = buf; /*register data */
++
++ ret = i2c_master_send(db1550_i2c_client, &tmpbuf[0], 2);
++ while (ret != 2){
++ ret = i2c_master_send(db1550_i2c_client, &tmpbuf[0], 2);
++ }
++ TRACE_MSG1(TCD, "I2C write %d\n", ret);
++
++}
++
++void i2c_close()
++{
++ if (initstate_i2c)
++ filp_close(i2c_file, NULL);
++ initstate_i2c = 0;
++
++}
++
++int i2c_configure (char *name, int addr)
++{
++ char filename[20];
++ int tmp;
++
++ RETURN_ZERO_IF(initstate_i2c);
++
++ /*find the I2C driver we need
++ */
++ for (tmp = 0; tmp < MAX_I2C; tmp++) {
++
++ sprintf(filename, "/dev/i2c-%d", tmp);
++
++ printk(KERN_INFO"%s: %s\n", __FUNCTION__, filename);
++
++ UNLESS (IS_ERR(i2c_file = filp_open(filename, O_RDWR, 0))) {
++
++ //printk(KERN_INFO"%s: %s found\n", __FUNCTION__, filename);
++
++ /*found some driver */
++ db1550_i2c_client = (struct i2c_client *)i2c_file->private_data;
++
++ printk(KERN_INFO"%s: found %s\n", __FUNCTION__, db1550_i2c_client->adapter->name);
++ if (strlen(db1550_i2c_client->adapter->name) >= 8) {
++ if (!strncmp(db1550_i2c_client->adapter->name, name, strlen(name)))
++ break; /*we found our driver! */
++ }
++ db1550_i2c_client = NULL;
++ filp_close(i2c_file, NULL);
++ }
++ printk(KERN_INFO"%s: %s %d\n", __FUNCTION__, filename, i2c_file);
++ }
++ if (tmp == MAX_I2C) { // Nothing found
++ printk(KERN_ERR"%s: cannot find I2C driver", __FUNCTION__);
++ return -ENODEV;
++ }
++ db1550_i2c_client->addr = addr;
++ initstate_i2c = 1;
++ return 0;
++}
++
++/*! i2c_readb
++ * Read byte from i2c device
++ * @param subaddr
++ */
++u8 i2c_readb(u8 subaddr)
++{
++int ret;
++
++ u8 buf = 0;
++ ret = i2c_master_send(db1550_i2c_client, &subaddr, 1);
++ while (ret != 1){
++// printk(KERN_INFO"send return %d\n", ret);
++ ret = i2c_master_send(db1550_i2c_client, &subaddr, 1);
++ }
++ // printk(KERN_INFO"send return %d\n", ret);
++ ret = i2c_master_recv(db1550_i2c_client, &buf, 1);
++ while (ret != 1){
++ // printk(KERN_INFO"rec return %d with %02x\n", ret, buf);
++ ret = i2c_master_send(db1550_i2c_client, &subaddr, 1);
++ while (ret != 1){
++ // printk(KERN_INFO"send return %d\n", ret);
++ ret = i2c_master_send(db1550_i2c_client, &subaddr, 1);
++ }
++ ret = i2c_master_recv(db1550_i2c_client, &buf, 1);
++ }
++ // printk(KERN_INFO"rec return %d with %02x\n", ret, buf);
++ TRACE_MSG2(TCD, "addr: %02x buf: %02x", subaddr, buf);
++ return buf;
++}
++
++
++/*! i2c_readl
++ * Read long from i2c device
++ * @param subaddr
++ */
++u32 i2c_readl(u8 subaddr)
++{
++ int ret;
++ // u32 buf = 0;
++ u8 buf[5];
++ ret = i2c_master_send(db1550_i2c_client, &subaddr, 1);
++ while (ret != 1){
++ printk(KERN_INFO"send return %d\n", ret);
++ ret = i2c_master_send(db1550_i2c_client, &subaddr, 1);
++ }
++ printk(KERN_INFO"send return %d\n", ret);
++ ret = i2c_master_recv(db1550_i2c_client, buf, 4);
++ while (ret != 4){
++ printk(KERN_INFO"rec return %d with %02x\n", ret, buf);
++ ret = i2c_master_send(db1550_i2c_client, &subaddr, 1);
++ while (ret != 1){
++ printk(KERN_INFO"send return %d\n", ret);
++ ret = i2c_master_send(db1550_i2c_client, &subaddr, 1);
++ }
++ ret = i2c_master_recv(db1550_i2c_client, buf, 4);
++ }
++ printk(KERN_INFO"rec return %d with %02x %02x %02x %02x\n", ret, buf[0], buf[1], buf[2], buf[3]);
++ TRACE_MSG2(TCD, "addr: %02x buf: %08x", subaddr, buf);
++ return buf;
++}
++
++int i2c_readw (int addr)
++{
++ int data;
++
++ data = 0;
++
++ return data;
++}
++
++
++EXPORT_SYMBOL(i2c_writeb);
++EXPORT_SYMBOL(i2c_readw);
++EXPORT_SYMBOL(i2c_readb);
++EXPORT_SYMBOL(i2c_readl);
++EXPORT_SYMBOL(i2c_configure);
++EXPORT_SYMBOL(i2c_close);
++
+diff -uNr linux/drivers/no-otg/ocd/max3353e/max3353-procfs.c linux/drivers/otg/ocd/max3353e/max3353-procfs.c
+--- linux/drivers/no-otg/ocd/max3353e/max3353-procfs.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/max3353e/max3353-procfs.c 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,303 @@
++/*
++ * otg/ocd/max3353e/max3353-procfs.c - USB Device Core Layer
++ * @(#) balden@belcarra.com|otg/ocd/max3353e/max3353-procfs.c|20060831021117|57336
++ *
++ * Copyright (c) 2004-2005 Belcarra
++ * Copyright (c) 2005-2006 Belcarra Technologies 2005 Corp
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Shahrad Payandeh <sp@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ *
++ */
++/*!
++ * @file otg/ocd/max3353e/max3353-procfs.c
++ * @brief Implement /proc/max3353 to dump MAX3353 registers.
++ *
++ *
++ * @ingroup MAX3353TCD
++ */
++
++
++#include <otg/pcd-include.h>
++#include "otghw/max3353-hardware.h"
++#include "max3353.h"
++
++#ifdef CONFIG_ARCH_MX2ADS
++#include <asm/arch/mx2.h>
++#define MX2_OTG_XCVR_DEVAD 0x18
++#define MX2_SEQ_OP_REG 0x19
++#define MX2_SEQ_RD_STARTAD 0x1a
++#define MX2_I2C_OP_CTRL_REG 0x1b
++#define MX2_SCLK_TO_SCL_HPER 0x1e
++#define MX2_I2C_INTERRUPT_AND_CTRL 0x1f
++
++#define OTG_BASE_ADDR 0x10024000
++//#define OTG_I2C_BASE (OTG_BASE_ADDR+0x100)
++
++#endif /* CONFIG_ARCH_MX2ADS */
++
++#ifdef CONFIG_OTG_MAX3353_PROCFS
++/* Proc Filesystem *************************************************************************** */
++
++extern struct max3353_private max3353_private;
++
++#define MAX_HISTORY 6
++struct reg_list {
++ u8 reg;
++ u8 size;
++ char *name;
++ u32 values[MAX_HISTORY];
++};
++
++#define REG(r, s) {r, s, #r, }
++
++struct reg_list max3353_prod_list[] = {
++ REG(MAX3353_VENDOR_ID, 2),
++ REG(MAX3353_PRODUCT_ID, 2),
++ REG(MAX3353_VERSION_ID, 2),
++ { 0, 1, NULL,},
++};
++struct reg_list max3353_reg_list[] = {
++ REG(MAX3353_OTG_CONTROL_SET, 1),
++ REG(MAX3353_INTERRUPT_SOURCE, 1),
++ REG(MAX3353_INTERRUPT_LATCH_SET, 1),
++ REG(MAX3353_INTERRUPT_ENABLE_LOW_SET, 1),
++ REG(MAX3353_INTERRUPT_ENABLE_HIGH_SET, 1),
++ REG(MAX3353_MODE_CONTROL_1_SET, 1),
++ { 0, 1, NULL,},
++};
++struct reg_list max3353_spec_list[] = {
++ REG(MAX3353_MODE_CONTROL_2_SET, 1),
++ REG(MAX3353_OTG_STATUS, 1),
++ { 0, 1, NULL,},
++};
++struct reg_list max3301e_spec_list[] = {
++ REG(MAX3301E_SPECIAL_FUNCTION_1_SET, 1),
++ REG(MAX3301E_SPECIAL_FUNCTION_2_SET, 1),
++ { 0, 1, NULL,},
++};
++#ifdef CONFIG_ARCH_MX2ADS
++struct reg_list mx21_spec_list[] = {
++ REG(MX2_OTG_XCVR_DEVAD, 1),
++ REG(MX2_SEQ_OP_REG, 1),
++ REG(MX2_SEQ_RD_STARTAD, 1),
++ REG(MX2_I2C_OP_CTRL_REG, 1),
++ REG(MX2_SCLK_TO_SCL_HPER, 1),
++ REG(MX2_I2C_INTERRUPT_AND_CTRL, 1),
++ { 0, 1, NULL,},
++};
++#endif /* CONFIG_ARCH_MX2ADS */
++
++void max3353_update(struct reg_list *list)
++{
++ for (; list && list->name; list++) {
++ memmove(list->values + 1, list->values, sizeof(list->values) - sizeof(u32));
++ switch(list->size) {
++ case 1:
++ list->values[0] = i2c_readb(list->reg);
++ break;
++ case 2:
++ list->values[0] = i2c_readw(list->reg);
++ break;
++ case 4:
++ list->values[0] = i2c_readl(list->reg);
++ break;
++ }
++ }
++}
++
++#ifdef CONFIG_ARCH_MX2ADS
++static u8 __inline__ mx2_rb(u32 port)
++{
++ return *(volatile u8 *) (MX2_IO_ADDRESS(port + OTG_I2C_BASE));
++}
++
++
++void mx21_update(struct reg_list *list)
++{
++ for (; list && list->name; list++) {
++ memmove(list->values + 1, list->values, sizeof(list->values) - sizeof(u32));
++ list->values[0] = mx2_rb(list->reg);
++ }
++}
++
++#endif /* CONFIG_ARCH_MX2ADS */
++
++void max3353_update_all(void)
++{
++ max3353_update(max3353_reg_list);
++ switch (max3353_private.transceiver_map->transceiver_type) {
++ case max3353:
++ max3353_update(max3353_spec_list);
++ break;
++ case max3301e:
++ max3353_update(max3301e_spec_list);
++ break;
++ default:
++ break;
++ }
++#ifdef CONFIG_ARCH_MX2ADS
++ mx21_update(mx21_spec_list);
++#endif /* CONFIG_ARCH_MX2ADS */
++}
++
++
++
++/*
++ * 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);
++}
++
++int max3353_dump(char *buf, char *name, char *fmt, struct reg_list *reg)
++{
++ int len = 0, i;
++ len += sprintf (buf + len, "%-20s %-34s [%03x]: ", name, reg->name, reg->reg);
++ len += sprintf (buf + len, fmt, reg->values[0]);
++ for (i = 1; i < MAX_HISTORY; i++)
++ if (reg->values[i - 1] == reg->values[i])
++ len += sprintf (buf + len, " ");
++ else
++ len += sprintf (buf + len, fmt, reg->values[i]);
++ len += sprintf (buf + len, "\n");
++ return len;
++}
++
++int max3353_dump_list(char * buf, char *name, struct reg_list *list)
++{
++ int len = 0;
++ for (; list && list->name; list++)
++ switch(list->size) {
++ case 1: len += max3353_dump(buf + len, name, " %02x", list); break;
++ case 2: len += max3353_dump(buf + len, name, " %04x", list); break;
++ case 4: len += max3353_dump(buf + len, name, " %08x", list); break;
++ }
++ return len;
++}
++
++int max3353_dump_all(char *buf)
++{
++ int len = 0;
++ len += max3353_dump_list(buf + len, "MAX3353 Standard", max3353_reg_list);
++ switch (max3353_private.transceiver_map->transceiver_type) {
++ case max3353:
++ len += max3353_dump_list(buf + len, "MAX3353 Extra", max3353_spec_list);
++ break;
++ case max3301e:
++ len += max3353_dump_list(buf + len, "MAX3301E Extra", max3301e_spec_list);
++ break;
++ default:
++ break;
++ }
++#ifdef CONFIG_ARCH_MX2ADS
++ len += max3353_dump_list(buf + len, "MX21 ADS Extra", mx21_spec_list);
++#endif /* CONFIG_ARCH_MX2ADS */
++ return len;
++}
++
++
++
++/*!
++ * max3353_device_proc_read - implement proc file system read.
++ *
++ * 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 max3353_device_proc_read_functions (struct file *file, char *buf, size_t count, loff_t * pos)
++{
++ unsigned long page;
++ int len = 0;
++ int index;
++ int i;
++ u32 r;
++
++ int config_size;
++
++ // get a page, max 4095 bytes of data...
++ RETURN_EINVAL_UNLESS ((page = get_free_page (GFP_KERNEL)));
++
++ len = 0;
++ index = (*pos)++;
++
++ switch(index) {
++ case 0:
++ len += sprintf ((char *) page + len, "MAX3353 Transceiver Registers\n");
++
++ max3353_update_all();
++ len += sprintf ((char *) page + len , "Vendor: %04x Product: %04x Revision: %04x %s\n",
++ max3353_private.vendor, max3353_private.product,
++ max3353_private.revision, max3353_private.transceiver_map->name
++ );
++
++ len += max3353_dump_all((char *) page + len);
++ len += sprintf ((char *) page + len, "\n");
++
++ break;
++
++ case 1:
++ break;
++
++ }
++
++ if (len > count) {
++ len = -EINVAL;
++ }
++ else if ((len > 0) && copy_to_user (buf, (char *) page, len)) {
++ len = -EFAULT;
++ }
++ else {
++ }
++ free_page (page);
++ return len;
++}
++
++static struct file_operations max3353_device_proc_operations_functions = {
++ read:max3353_device_proc_read_functions,
++};
++
++/* Module init ******************************************************************************* */
++
++static int max3353_procfs_init (void)
++{
++ struct proc_dir_entry *p;
++
++ // create proc filesystem entries
++ if ((p = create_proc_entry ("max3353", 0, 0)) == NULL)
++ return -ENOMEM;
++
++ p->proc_fops = &max3353_device_proc_operations_functions;
++
++ max3353_update_all();
++
++ return 0;
++}
++static void max3353_procfs_exit (void)
++{
++ remove_proc_entry ("max3353", NULL);
++}
++#else
++static int max3353_procfs_init (void) { return 0;
++}
++static void max3353_procfs_exit (void) { }
++#endif
+diff -uNr linux/drivers/no-otg/ocd/max3353e/max3353.c linux/drivers/otg/ocd/max3353e/max3353.c
+--- linux/drivers/no-otg/ocd/max3353e/max3353.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/max3353e/max3353.c 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,706 @@
++/*
++ * otg/ocd/max3353e/max3353.c -- USB Transceiver Controller driver
++ * @(#) balden@belcarra.com|otg/ocd/max3353e/max3353.c|20060831021117|27226
++ *
++ * Copyright (c) 2003-2005 Belcarra
++ * Copyright (c) 2005-2006 Belcarra Technologies 2005 Corp
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Shahrad Payandeh <sp@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/ocd/max3353e/max3353.c
++ * @brief MAX3353 OTG Transceiver Driver.
++ *
++ * This is the generic MAX3353 TCD core support.
++ *
++ * Notes:
++ *
++ * 1. The MAX3353 can control the speed and suspend directly, would it be
++ * appropriate to allow state machine to control this.
++ *
++ * 2. The MAX3353 has auto connect feature, can this be used without change
++ * to state machine.
++ *
++ * 3. The MAX3353 can control the ADR/PSW pin to enable / disable external
++ * charge pump.
++ *
++ * @ingroup MAX3353TCD
++ */
++
++#include <otg/otg-compat.h>
++
++#include <asm/irq.h>
++#include <asm/system.h>
++#include <asm/io.h>
++#include <linux/i2c.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-bus.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-hcd.h>
++#include <otg/otg-tcd.h>
++#include <otg/otg-ocd.h>
++#include <otg/otg-pcd.h>
++
++#include <otghw/max3353-hardware.h>
++#include "max3353.h"
++
++
++struct otg_transceiver_map max3353_transceiver_map[] = {
++ { max3353, 0x4cc, 0x1301, 0x00, "Phillips MAX3353", },
++ { max3301e, 0x6a0b, 0x0133, 0x00, "Maxim MAX3301E", },
++ { 0, 0, 0, 0, "Unknown Transceiver", },
++};
++
++struct max3353_private max3353_private;
++
++
++
++/* ********************************************************************************************* */
++#define TRACE_I2CB(t,r) TRACE_MSG3(t, "%-40s[%02x] %02x", #r, r, i2c_readb(r))
++#define TRACE_I2CW(t,r) TRACE_MSG3(t, "%-40s[%02x] %04x", #r, r, i2c_readw(r))
++#define TRACE_GPIO(t,b,r) TRACE_MSG2(t, "%-40s %04x", #r, readw(b + r))
++#define TRACE_REGL(t,r) TRACE_MSG2(t, "%-40s %08x", #r, readl(r))
++
++
++
++/*! max3353_int_src - update interrupt source test mask
++ *
++ * This sets the current mask and updates the interrupt registers to match.
++ */
++void max3353_int_src(u8 int_src)
++{
++ TRACE_MSG1(TCD, "setting int_src %02x", int_src);
++ max3353_private.int_src = int_src;
++ i2c_writeb(MAX3353_INTERRUPT_ENABLE_LOW_CLR, ~int_src);
++ i2c_writeb(MAX3353_INTERRUPT_ENABLE_HIGH_CLR, ~int_src);
++ i2c_writeb(MAX3353_INTERRUPT_ENABLE_LOW_SET, int_src);
++ i2c_writeb(MAX3353_INTERRUPT_ENABLE_HIGH_SET, int_src);
++ i2c_writeb(MAX3353_INTERRUPT_LATCH_CLR, int_src);
++}
++
++/*! max3353_int_src_set - add to the interrupt source mask
++ *
++ */
++void max3353_int_src_set(u8 int_src)
++{
++ max3353_int_src(int_src |= max3353_private.int_src);
++}
++
++/*! max3353_int_src_clr - remove from the interrup source mask
++ */
++void max3353_int_src_clr(u8 int_src)
++{
++ max3353_int_src(int_src = max3353_private.int_src & ~int_src);
++}
++
++/* ********************************************************************************************* */
++
++
++/*! max3353_event_set_irq
++ */
++void max3353_event_set_irq(struct otg_instance *otg, int changed, int flag, u32 input, otg_tag_t tag, char *mset, char *mreset)
++{
++ TRACE_MSG5(TCD, "changed: %x flag: %x input: %08x %s %s", changed, flag, input,
++ flag ? mset: mreset,
++ changed ? "": "(ignored)");
++
++ otg_event_set_irq(otg, changed, flag, input, tag, flag ? mset : mreset);
++}
++
++/*! max3353_update - called from mx2_i2c_xcvr_bh to find changes in the max3353 Interrupt Source Register
++ */
++u8 max3353_update_int_src(struct otg_instance *otg, u8 int_src, u8 changed)
++{
++ UNLESS (changed) return int_src;
++ TRACE_MSG2(TCD, "CHANGED INTERRUPT_SOURCE: %02x (%02x) ", int_src, changed);
++
++ /* Core events
++ */
++ max3353_event_set_irq(otg, MAX3353_ID_GND & changed, MAX3353_ID_GND & int_src,
++ ID_GND, TCD, "ID_GND", "ID_GND/");
++ max3353_event_set_irq(otg, MAX3353_ID_FLOAT & changed, MAX3353_ID_FLOAT & int_src,
++ ID_FLOAT, TCD, "ID_FLOAT", "ID_FLOAT/");
++ max3353_event_set_irq(otg, MAX3353_VBUS_VLD & changed, MAX3353_VBUS_VLD & int_src,
++ VBUS_VLD, TCD, "VBUS_VLD", "VBUS_VLD/");
++ max3353_event_set_irq(otg, MAX3353_SESS_VLD & changed, MAX3353_SESS_VLD & int_src,
++ A_SESS_VLD, TCD, "A_SESS_VLD", "A_SESS_VLD/");
++
++ max3353_event_set_irq(otg, MAX3353_DM_HI & changed, MAX3353_DM_HI & int_src,
++ DM_HIGH, TCD, "DM_HIGH", "DM_HIGH/");
++
++ max3353_event_set_irq(otg, MAX3353_DP_HI & changed, MAX3353_DP_HI & int_src,
++ DP_HIGH, TCD, "DP_HIGH", "DP_HIGH/");
++
++ //max3353_event_set_irq(otg, MAX3353_SE1 & changed, ((MAX3353_SE1 & int_src) == 0), SE0_DET, TCD, "SE0", "SE0/");
++
++ /* carkit
++ */
++ max3353_event_set_irq(otg, MAX3353_CR_INT & changed, !(MAX3353_CR_INT & int_src),
++ CR_INT_DET, TCD, "CR_INT", "CR_INT/");
++
++ //TRACE_MSG3(TCD, "MAX3353_SE1: %02x & int_src: %02x = %02x", MAX3353_SE1, int_src, MAX3353_SE1 & int_src);
++ //max3353_event_set_irq(otg, MAX3353_SE1 & changed, ((MAX3353_SE1 & int_src) == MAX3353_SE1),
++ // SE1_DET, TCD, "SE1", "SE1/");
++
++
++ /* A-Device
++ */
++ max3353_event_set_irq(otg, MAX3353_BDIS_ACON & changed, !(MAX3353_BDIS_ACON & int_src),
++ BDIS_ACON, TCD, "BDIS_ACON", "BDIS_ACON/" );
++
++ return int_src;
++}
++
++/*! max3353_update - called from mx2_i2c_xcvr_bh to find changes in the max3353 OTG Status Register
++ */
++u8 max3353_update_otg_status(struct otg_instance *otg, u8 otg_status, u8 changed)
++{
++ UNLESS (changed) return otg_status;
++ TRACE_MSG2(TCD, "CHANGED OTG_STATUS_REG: %02x (%02x) ", otg_status, changed);
++
++ max3353_event_set_irq(otg, MAX3353_B_SESS_VLD & changed, MAX3353_B_SESS_VLD & otg_status,
++ B_SESS_VLD, TCD, "B_SESS_VLD", "B_SESS_VLD/");
++ max3353_event_set_irq(otg, MAX3353_B_SESS_END & changed, MAX3353_B_SESS_END & otg_status,
++ B_SESS_END, TCD, "B_SESS_END", "B_SESS_END/");
++
++ //otg_b_sess_vld(otg, first || (MAX3353_B_SESS_VLD & changed), MAX3353_B_SESS_VLD & otg_status, MAX3353_NAME );
++ return otg_status;
++}
++
++int max3353_bh_first;
++
++
++/*! max3353_bh
++ */
++void max3353_bh(void *arg)
++{
++ u8 int_lat, int_src = 0, otg_status = 0, special_function_22 = 0;
++ static u8 int_src_saved, otg_status_saved, special_function_22_saved;
++
++ //TRACE_MSG0(TCD, "--");
++ /* read the interrupt latch and and clear latch and update otg
++ */
++ if ((int_lat = i2c_readb(MAX3353_INTERRUPT_LATCH_SET))) {
++ //TRACE_MSG1(TCD, "CLEARING INT LAT: %02x", int_lat);
++ i2c_writeb(MAX3353_INTERRUPT_LATCH_CLR, int_lat);
++ }
++
++ /* If int_lat shows a change or we are forcing an update, read interrupt source.
++ * Note that we mask DP_HI and DM_HI when LOC_CONN is set, we don't want them
++ * when USB Bus is in use.
++ *
++ * Mask with bits we are currently interested in.
++ */
++ int_src = i2c_readb(MAX3353_INTERRUPT_SOURCE) & max3353_private.int_src;
++
++ UNLESS ( max3353_private.flags & MAX3353_LOC_CONN) {
++ }
++
++
++ /* further work if B-Device and VBUS_VLD
++ */
++ if ( (!(int_src & MAX3353_ID_GND) && (int_src & MAX3353_VBUS_VLD)) ||
++ (!(int_src_saved & MAX3353_ID_GND) && (int_src_saved & MAX3353_VBUS_VLD)) )
++ {
++ /* read the otg_status register and update otg state machine
++ *
++ * XXX this needs to be conditional on Transceiver type. The
++ * MAX3301E for example supports sess_end in a separate register.
++ */
++ switch (max3353_private.transceiver_map->transceiver_type) {
++ case max3353:
++ otg_status = i2c_readb(MAX3353_OTG_STATUS);
++ if (max3353_bh_first)
++ otg_status_saved = ~otg_status;
++ otg_status_saved = max3353_update_otg_status(tcd_instance->otg, otg_status,
++ otg_status_saved ^ otg_status);
++ break;
++ case max3301e:
++ // XXX
++ special_function_22 = i2c_readb(MAX3301E_SPECIAL_FUNCTION_2_SET);
++ break;
++ case unknown_transceiver:
++ break;
++ }
++ }
++ if (max3353_bh_first)
++ int_src_saved = ~int_src;
++
++ int_src_saved = max3353_update_int_src(tcd_instance->otg, int_src, int_src_saved ^ int_src);
++
++ max3353_bh_first = 0;
++}
++
++/* ********************************************************************************************** */
++/*! max3353_vbus - Do we have Vbus (cable attached?)
++ * Return non-zero if Vbus is detected.
++ *
++ */
++int max3353_vbus (struct otg_instance *otg)
++{
++ return 0;
++}
++
++/*! max3353_id - Do we have Vbus (cable attached?)
++ * Return non-zero if Vbus is detected.
++ *
++ */
++int max3353_idvbus (struct otg_instance *otg)
++{
++ return 0;
++}
++
++
++/* ********************************************************************************************* */
++
++/*! max3353_chrg_vbus - used to enable or disable B-device Vbus charging
++ */
++void max3353_chrg_vbus(struct otg_instance *otg, u8 flag)
++{
++ TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "CHRG_VBUS_SET");
++ i2c_writeb(MAX3353_OTG_CONTROL_SET, (u8) MAX3353_VBUS_CHRG);
++ break;
++ case RESET:
++ TRACE_MSG0(TCD, "CHRG_VBUS_RESET");
++ i2c_writeb(MAX3353_OTG_CONTROL_CLR, (u8) MAX3353_VBUS_CHRG);
++ break;
++ case PULSE:
++ break;
++ }
++}
++
++/*! max3353_drv_vbus - used to enable or disable A-device driving Vbus
++ */
++void max3353_drv_vbus(struct otg_instance *otg, u8 flag)
++{
++ TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "DRV_VBUS_SET");
++ i2c_writeb(MAX3353_OTG_CONTROL_SET, (u8) MAX3353_VBUS_DRV);
++ break;
++ case RESET:
++ TRACE_MSG0(TCD, "DRV_VBUS_RESET");
++ i2c_writeb(MAX3353_OTG_CONTROL_CLR, (u8) MAX3353_VBUS_DRV);
++ break;
++ }
++}
++
++/*! max3353_dischrg_vbus - used to enable Vbus discharge
++ */
++void max3353_dischrg_vbus(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = otg->tcd;
++ TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "OUTPUT: TCD_DISCHRG_VBUS_SET");
++ i2c_writeb(MAX3353_OTG_CONTROL_SET, MAX3353_VBUS_DISCHRG);
++ break;
++ case RESET:
++ TRACE_MSG0(TCD, "OUTPUT: TCD_DISCHRG_VBUS_RESET");
++ i2c_writeb(MAX3353_OTG_CONTROL_CLR, MAX3353_VBUS_DISCHRG);
++ break;
++ }
++}
++
++/*! max3353_dp_pullup_func - used to enable or disable peripheral connecting to bus
++ *
++ * C.f. 5.1.6, 5.1.7, 5.2.4 and 5.2.5
++ *
++ * host peripheral
++ * d+ pull-up clr set
++ * d+ pull-down set clr
++ *
++ * d- pull-up clr clr
++ * d- pull-down set set
++ *
++ */
++void max3353_dp_pullup_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ printk(KERN_INFO"%s: --\n", __FUNCTION__);
++ max3353_private.flags |= MAX3353_LOC_CONN;
++ TRACE_MSG0(TCD, "MAX3353_LOC_CONN SET - Clr DP PULLDOWN");
++ //i2c_writeb(MAX3353_OTG_CONTROL_CLR, (u8) MAX3353_DP_PULLDOWN);
++ //i2c_writeb(MAX3353_OTG_CONTROL_CLR, (u8) (MAX3353_DP_PULLDOWN | MAX3353_DM_PULLDOWN) );
++ TRACE_MSG0(TCD, "MAX3353_LOC_CONN SET - Set DP PULLUP");
++ i2c_writeb(MAX3353_OTG_CONTROL_SET, (u8) MAX3353_DP_PULLUP);
++ break;
++
++ case RESET:
++ max3353_private.flags &= ~MAX3353_LOC_CONN;
++ TRACE_MSG0(TCD, "MAX3353_LOC_CONN RESET - Clr DP PULLUP");
++ i2c_writeb(MAX3353_OTG_CONTROL_CLR, (u8)MAX3353_DP_PULLUP);
++ TRACE_MSG0(TCD, "MAX3353_LOC_CONN SET - Set DP PULLDOWN");
++ //i2c_writeb(MAX3353_OTG_CONTROL_SET, (u8)MAX3353_DP_PULLDOWN);
++ //i2c_writeb(MAX3353_OTG_CONTROL_SET, (u8) (MAX3353_DP_PULLDOWN | MAX3353_DM_PULLDOWN) );
++ break;
++
++ case PULSE:
++ TRACE_MSG0(TCD, "MAX3353_LOC_CONN PULSE");
++ break;
++ }
++}
++
++/*! max3353_dm_pullup_func - used to enable or disable peripheral connecting to bus
++ *
++ */
++void max3353_dm_pullup_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ max3353_private.flags |= MAX3353_LOC_CONN;
++ TRACE_MSG0(TCD, "MAX3353_LOC_CONN SET - Clr DM PULLDOWN");
++ //i2c_writeb(MAX3353_OTG_CONTROL_CLR, (u8) MAX3353_DM_PULLDOWN);
++ TRACE_MSG0(TCD, "MAX3353_LOC_CONN SET - Set DM PULLUP");
++ i2c_writeb(MAX3353_OTG_CONTROL_SET, (u8) MAX3353_DM_PULLUP);
++ break;
++
++ case RESET:
++ max3353_private.flags &= ~MAX3353_LOC_CONN;
++ TRACE_MSG0(TCD, "MAX3353_LOC_CONN RESET - Clr DM PULLUP");
++ i2c_writeb(MAX3353_OTG_CONTROL_CLR, (u8)MAX3353_DM_PULLUP);
++ TRACE_MSG0(TCD, "MAX3353_LOC_CONN SET - Set DM PULLDOWN");
++ //i2c_writeb(MAX3353_OTG_CONTROL_SET, (u8)MAX3353_DM_PULLDOWN);
++ break;
++
++ case PULSE:
++ TRACE_MSG0(TCD, "MAX3353_LOC_CONN PULSE");
++ break;
++ }
++}
++
++/*! max3353_dm_det_func - used to enable or disable D- detect
++ *
++ */
++void max3353_dm_det_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "setting DM_HI detect");
++ max3353_int_src_set(MAX3353_DM_HI);
++ max3353_bh_first = 1;
++ break;
++
++ case RESET:
++ TRACE_MSG0(TCD, "reseting DM_HI detect");
++ max3353_int_src_clr(MAX3353_DM_HI);
++ break;
++ }
++}
++
++/*! max3353_dp_det_func - used to enable or disable D+ detect
++ *
++ */
++void max3353_dp_det_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "setting DP_HI detect");
++ max3353_int_src_set(MAX3353_DP_HI);
++ max3353_bh_first = 1;
++ break;
++
++ case RESET:
++ TRACE_MSG0(TCD, "reseting DP_HI detect");
++ max3353_int_src_clr(MAX3353_DP_HI);
++ break;
++ }
++}
++
++/*! max3353_bdis_acon_func - used to enable or disable auto a-connect
++ *
++ */
++void max3353_bdis_acon_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "setting BDIS ACON");
++ i2c_writeb(MAX3353_OTG_CONTROL_SET, MAX3353_ID_PULLDOWN);
++ break;
++
++ case RESET:
++ TRACE_MSG0(TCD, "reseting BDIS ACON");
++ i2c_writeb(MAX3353_OTG_CONTROL_CLR, MAX3353_ID_PULLDOWN);
++ break;
++ }
++}
++
++/*! max3353_id_pulldown_func - used to enable or disable ID pulldown
++ *
++ */
++void max3353_id_pulldown_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "setting ID PULLDOWN");
++ i2c_writeb(MAX3353_MODE_CONTROL_1_SET, MAX3353_BDIS_ACON_EN);
++ break;
++
++ case RESET:
++ TRACE_MSG0(TCD, "reseting ID PULLDOWN");
++ i2c_writeb(MAX3353_MODE_CONTROL_1_CLR, MAX3353_BDIS_ACON_EN);
++ break;
++ }
++}
++
++/*! max3353_audio_func - used to enable or disable Carkit Interrupt
++ *
++ */
++void max3353_audio_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "setting CARKIT INT");
++ i2c_writeb(MAX3353_MODE_CONTROL_2_SET, MAX3353_AUDIO_EN);
++ break;
++
++ case RESET:
++ TRACE_MSG0(TCD, "reseting CARKIT INT");
++ i2c_writeb(MAX3353_MODE_CONTROL_2_CLR, MAX3353_AUDIO_EN);
++ break;
++ }
++}
++
++/*! max3353_uart_func - used to enable or disable transparent uart mode
++ *
++ */
++void max3353_uart_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "setting UART");
++ i2c_writeb(MAX3353_MODE_CONTROL_1_SET, MAX3353_UART_EN);
++ /* XXX enable uart */
++ break;
++
++ case RESET:
++ MAX3353SG0(TCD, "reseting UART");
++ i2c_writeb(MAX3353_MODE_CONTROL_1_CLR, MAX3353_UART_EN);
++ /* XXX disable uart */
++ break;
++ }
++}
++
++/*! max3353_mono_func - used to enable or disable mono audio connection
++ *
++ */
++void max3353_mono_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "setting MONO");
++ /* XXX enable mono output */
++ break;
++
++ case RESET:
++ TRACE_MSG0(TCD, "reseting MONO");
++ /* XXX disable mono output */
++ break;
++ }
++}
++
++
++/* ********************************************************************************************* */
++extern int max3353_procfs_init (void);
++extern void max3353_procfs_exit (void);
++
++/*! max3353_mod_init
++ */
++int max3353_mod_init(void)
++{
++ /* for interrupt bottom half handler
++ */
++ PREPARE_WORK_ITEM(max3353_private.bh, &max3353_bh, NULL);
++
++ /* setup max3353, enable interrupts, clear latch
++ * XXX when and how do we do DM_HI and DP_HI, when ID is present?
++ */
++ max3353_int_src(MAX3353_INT_SRC);
++ //max3353_int_src(MAX3353_NO_SE1_INT);
++
++ i2c_writeb(MAX3353_OTG_CONTROL_SET, MAX3353_DM_PULLDOWN | MAX3353_DP_PULLDOWN);
++
++#ifdef CONFIG_OTG_MAX3353_PROCFS
++ max3353_procfs_init ();
++#endif /* CONFIG_OTG_MAX3353_PROCFS */
++
++ return 0;
++}
++
++/*! max3353_mod_exit
++ */
++void max3353_mod_exit(void)
++{
++ i2c_writeb(MAX3353_INTERRUPT_ENABLE_LOW_CLR, 0xff);
++ i2c_writeb(MAX3353_INTERRUPT_ENABLE_HIGH_CLR, 0xff);
++ //i2c_close();
++#ifdef CONFIG_OTG_MAX3353_PROCFS
++ max3353_procfs_exit ();
++#endif /* CONFIG_OTG_MAX3353_PROCFS */
++
++ while (PENDING_WORK_ITEM(max3353_private.bh)) {
++ printk(KERN_ERR"%s: waiting for bh\n", __FUNCTION__);
++ schedule_timeout(10 * HZ);
++ }
++
++}
++
++/* ********************************************************************************************* */
++/*! max3353_configure - configure the MAX3353 for this host
++ * @param tx_mode - the type of connection between the host USB and the MAX3353
++ * @param spd_ctrl - suspend control method
++ */
++void max3353_configure(tx_mode_t tx_mode, spd_ctrl_t spd_ctrl)
++{
++ u16 vendor = 0, product = 0, revision = 0;
++ u8 mode1, mode2, control;
++
++ struct otg_transceiver_map *map = max3353_transceiver_map;
++
++
++#if defined(CONFIG_OTG_MAX3353_MX2ADS) || defined(CONFIG_OTG_MAX3353_MX2ADS_MODULE)
++ u32 vp;
++ MAX3353SG0(TCD, "1. Read Transceiver ID's with long read");
++ vp = i2c_readl(MAX3353_VENDOR_ID);
++ max3353_private.vendor = vp & 0xffff;
++ max3353_private.product = vp >> 16;
++ max3353_private.revision = i2c_readw(MAX3353_VERSION_ID);
++ mode1 = i2c_readb(MAX3353_MODE_CONTROL_1_SET);
++ mode2 = i2c_readb(MAX3353_MODE_CONTROL_2_SET);
++
++ TRACE_MSG5(TCD, "2. OTG Transceiver: vendor: %04x product: %04x revision: %04x mode1: %02x mode2: %02x",
++ vendor, product, revision, mode1, mode2);
++
++#else /* defined(CONFIG_OTG_MAX3353_MX2ADS) */
++
++ max3353_private.vendor = i2c_readw(MAX3353_VENDOR_ID);
++ max3353_private.product = i2c_readw(MAX3353_PRODUCT_ID);
++ max3353_private.revision = i2c_readw(MAX3353_VERSION_ID);
++ mode1 = i2c_readb(MAX3353_MODE_CONTROL_1_SET);
++ mode2 = i2c_readb(MAX3353_MODE_CONTROL_2_SET);
++
++ TRACE_MSG5(TCD, "2. OTG Transceiver: vendor: %04x product: %04x revision: %04x mode1: %02x mode2: %02x",
++ max3353_private.vendor, max3353_private.product, max3353_private.revision, mode1, mode2);
++
++#endif /* defined(CONFIG_OTG_MAX3353_MX2ADS) */
++
++ for ( ; map && map->transceiver_type != unknown_transceiver; map++) {
++ CONTINUE_UNLESS ((max3353_private.vendor == map->vendor) && (max3353_private.product == map->product));
++ TRACE_MSG1(TCD, "Found Transceiver: %s", map->name);
++ max3353_private.transceiver_map = map;
++ break;
++ }
++ UNLESS (max3353_private.transceiver_map)
++ max3353_private.transceiver_map = max3353_transceiver_map;
++
++ TRACE_MSG0(TCD, "3. Disable All Transceiver Control Register 1 ");
++ i2c_writeb(MAX3353_OTG_CONTROL_CLR, 0xff); // clear
++
++ TRACE_MSG0(TCD, "4. Enable D-/D+ Pulldowns in Transceiver Control Register 1 ");
++
++ i2c_writeb(MAX3353_OTG_CONTROL_SET, MAX3353_DM_PULLDOWN | MAX3353_DP_PULLDOWN);
++ i2c_writeb(MAX3353_OTG_CONTROL_CLR, (u8) MAX3353_DM_PULLUP | MAX3353_DP_PULLUP);
++
++
++ TRACE_MSG0(TCD, "5. Clear latch and enable interrupts");
++ i2c_writeb(MAX3353_INTERRUPT_LATCH_CLR, 0xff);
++ i2c_writeb(MAX3353_INTERRUPT_ENABLE_LOW_CLR, 0xeb);
++ i2c_writeb(MAX3353_INTERRUPT_ENABLE_HIGH_CLR, 0xeb);
++
++ /* The PSW_OE enables the ADR/PSW pin for output driving either high
++ * or low depending on the address.
++ *
++ * ADR ADR_REG Address PSW_OE=0 PSW_OE=1
++ *
++ * low 0 0x2c LOW HIGH
++ *
++ * high 1 0x2d HIGH LOW
++ *
++ *
++ * The i2c address by tying the ADR/PSW pin either high or low.
++ * Setting the PSW_OE drives the ADR/PSW into the opposite of the
++ * default wiring.
++ *
++ * On the MX21ADS the ADR/PSW pin is wired high which enables the
++ * charge pump. So enabling the PSW_OE is required to disable Vbus
++ * generation on the Charge Pump.
++ *
++ * The MAX3355E will only enable Vbus when this signal is high AND
++ * the ID signal is low. So it may be safe to leave enabled when
++ * operating as a B-device (ID floating.)
++ */
++
++ //i2c_writeb(MAX3353_MODE_CONTROL_2_SET, MAX3353_PSW_OE); // PSW_OE - OFFVBUS low
++
++
++ TRACE_MSG1(TCD, "6. tx_mode: %02x", tx_mode);
++ switch (tx_mode) {
++ case vp_vm_bidirectional:
++ break;
++ case dat_se0_unidirectional:
++ i2c_writeb(MAX3353_MODE_CONTROL_2_CLR, MAX3353_BI_DI);
++ MAX3353t_se0_bidirectional:
++ i2c_writeb(MAX3353_MODE_CONTROL_1_SET, MAX3353_DAT_SE0);
++ break;
++ }
++ TRACE_MSG0(TCD, "6. tx_mode done");
++
++ TRACE_MSG1(TCD, "7. spd_ctrl: %02x", spd_ctrl);
++ switch (spd_ctrl) {
++ case spd_susp_pins:
++ i2c_writeb(MAX3353_MODE_CONTROL_2_CLR, MAX3353_SPD_SUSP_CTRL);
++ break;
++ case spd_susp_reg:
++ i2c_writeb(MAX3353_MODE_CONTROL_2_SET, MAX3353_SPD_SUSP_CTRL);
++ break;
++ }
++
++ //i2c_writeb(MAX3353_MODE_CONTROL_2_SET, MAX3353_PSW_OE); // PSW_OE - OFFVBUS low
++
++ TRACE_MSG0(TCD, "7. spd_ctrl done");
++
++ TRACE_MSG1(TCD, "8. transceiver_type: %02x", max3353_private.transceiver_map);
++
++ TRACE_MSG1(TCD, "8. transceiver_type: %02x", max3353_private.transceiver_map->transceiver_type);
++ switch (max3353_private.transceiver_map->transceiver_type) {
++ case max3353:
++ break;
++ case max3301e:
++ i2c_writeb(MAX3301E_SPECIAL_FUNCTION_1_SET, MAX3301E_SESS_END);
++ break;
++ case unknown_transceiver:
++ break;
++ }
++ TRACE_MSG0(TCD, "8. transceiver_type done");
++}
++
+diff -uNr linux/drivers/no-otg/ocd/max3353e/max3353.h linux/drivers/otg/ocd/max3353e/max3353.h
+--- linux/drivers/no-otg/ocd/max3353e/max3353.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/max3353e/max3353.h 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,132 @@
++/*
++ * otg/ocd/max3353/max3353.h -- USB Transceiver Controller driver
++ * @(#) balden@belcarra.com|otg/ocd/max3353e/max3353.h|20060831021117|56821
++ *
++ * Copyright (c) 2004-2005 Belcarra
++ * Copyright (c) 2005-2006 Belcarra Technologies 2005 Corp
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++
++
++/*!
++ * @file otg/ocd/max3353e/max3353.h
++ * @brief Private structures and defines for MAX3353 Transciever Controller Driver.
++ *
++ * This file contains the private defines and structures for the MAX3353 Transceiver
++ * Driver.
++ *
++ * @ingroup MAX3353TCD
++ */
++
++
++#ifdef CONFIG_XXXXX
++#define MAX3353_GPIO (2)
++#define TCD_MAX3353_I2C_ADDR MAX3353_I2C_ADDR_HIGH;
++#endif
++
++#define MAX3353_NAME "max3353"
++
++#define MAX3353_LOC_CONN 0x01
++
++#define MAX3353_INT_SRC 0xeb
++
++//#define MAX3353_ALL_INT_SRC 0xff
++//#define MAX3353_NO_SE1_INT 0xeb
++//#define MAX3353_NO_SE1_INT 0xfb /* do not pay attention to DP_HI */
++
++typedef enum otg_transceiver {
++ unknown_transceiver,
++ max3353,
++ max3301e
++} otg_transceiver_t;
++
++struct otg_transceiver_map {
++ otg_transceiver_t transceiver_type;
++ u16 vendor;
++ u16 product;
++ u16 revision;
++ char *name;
++};
++
++struct max3353_private {
++ WORK_STRUCT bh;
++ u16 vendor;
++ u16 product;
++ u16 revision;
++ u32 flags;
++ u8 int_src;
++ struct otg_transceiver_map *transceiver_map;
++};
++
++/*! tx_mode
++ * This defines the various ways that the MAX3353 can be
++ * wired into the host USB.
++ */
++typedef enum tx_mode {
++ dat_se0_bidirectional, /*!< 3-Wire */
++ vp_vm_bidirectional, /*!< 4-Wire */
++ dat_se0_unidirectional /*!< 6-Wire */
++} tx_mode_t;
++
++/*! spd_ctrl
++ * This defines how the speed and suspend pins are controlled
++ * for this host.
++ */
++typedef enum spd_ctrl {
++ spd_susp_pins, /*!< controlled by SPEED and SUSPEND pins */
++ spd_susp_reg, /*!< controled by SPEED_REG and SUSPEND_REG in Mode Control 1 register */
++} spd_ctrl_t;
++
++
++extern struct tcd_ops tcd_ops;
++extern struct max3353_private max3353_private;
++extern struct tcd_instance *tcd_instance;
++
++/* max3353.c */
++extern int max3353_mod_init(void);
++extern void max3353_mod_exit(void);
++extern void max3353_chrg_vbus(struct otg_instance *, u8 );
++extern void max3353_drv_vbus(struct otg_instance *, u8 );
++extern void max3353_dischrg_vbus(struct otg_instance *, u8 );
++extern void max3353_dp_pullup_func(struct otg_instance *, u8 );
++extern void max3353_dm_pullup_func(struct otg_instance *, u8 );
++extern void max3353_dm_det_func(struct otg_instance *, u8 );
++extern void max3353_dp_det_func(struct otg_instance *, u8 );
++extern void max3353_bdis_acon_func(struct otg_instance *otg, u8 flag);
++extern void max3353_id_pulldown_func(struct otg_instance *otg, u8 flag);
++extern void max3353_audio_func(struct otg_instance *otg, u8 flag);
++extern void max3353_uart_func(struct otg_instance *otg, u8 flag);
++extern void max3353_mono_func(struct otg_instance *otg, u8 flag);
++
++extern void max3353_otg_timer(struct otg_instance *, u8 );
++extern void max3353_bh(void *);
++extern int max3353_id (struct otg_instance *);
++extern int max3353_vbus (struct otg_instance *);
++extern void max3353_configure(tx_mode_t, spd_ctrl_t );
++
++/* thread */
++extern int max3353_thread_init (void (bh_proc)(void *));
++extern void max3353_thread_exit (wait_queue_head_t *);
++extern void max3353_thread_wakeup(int enabled, int first);
++
++
++
++/* i2c-xxx.c */
++int i2c_configure(char *name, int addr);
++extern void i2c_close(void);
++extern u8 i2c_readb(u8 );
++extern u16 i2c_readw(u8 );
++extern u32 i2c_readl(u8 );
++extern int i2c_writeb(u8 , u8 );
++
++
++/* ********************************************************************************************* */
++#define TRACE_I2CB(t,r) TRACE_MSG3(t, "%-40s[%02x] %02x", #r, r, i2c_readb(r))
++#define TRACE_I2CW(t,r) TRACE_MSG3(t, "%-40s[%02x] %04x", #r, r, i2c_readw(r))
++#define TRACE_GPIO(t,b,r) TRACE_MSG2(t, "%-40s %04x", #r, readw(b + r))
++#define TRACE_REGL(t,r) TRACE_MSG2(t, "%-40s %08x", #r, readl(r))
++
+diff -uNr linux/drivers/no-otg/ocd/max3353e/max3353e-procfs.c linux/drivers/otg/ocd/max3353e/max3353e-procfs.c
+--- linux/drivers/no-otg/ocd/max3353e/max3353e-procfs.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/max3353e/max3353e-procfs.c 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,303 @@
++/*
++ * otg/ocd/max3353/max3353-procfs.c - USB Device Core Layer
++ * @(#) balden@belcarra.com|otg/ocd/max3353e/max3353e-procfs.c|20060831021117|57336
++ *
++ * Copyright (c) 2004-2005 Belcarra
++ * Copyright (c) 2005-2006 Belcarra Technologies 2005 Corp
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Shahrad Payandeh <sp@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ *
++ */
++/*!
++ * @file otg/ocd/max3353e/max3353e-procfs.c
++ * @brief Implement /proc/max3353 to dump MAX3353 registers.
++ *
++ *
++ * @ingroup MAX3353TCD
++ */
++
++
++#include <otg/pcd-include.h>
++#include "otghw/max3353-hardware.h"
++#include "max3353.h"
++
++#ifdef CONFIG_ARCH_MX2ADS
++#include <asm/arch/mx2.h>
++#define MX2_OTG_XCVR_DEVAD 0x18
++#define MX2_SEQ_OP_REG 0x19
++#define MX2_SEQ_RD_STARTAD 0x1a
++#define MX2_I2C_OP_CTRL_REG 0x1b
++#define MX2_SCLK_TO_SCL_HPER 0x1e
++#define MX2_I2C_INTERRUPT_AND_CTRL 0x1f
++
++#define OTG_BASE_ADDR 0x10024000
++//#define OTG_I2C_BASE (OTG_BASE_ADDR+0x100)
++
++#endif /* CONFIG_ARCH_MX2ADS */
++
++#ifdef CONFIG_OTG_MAX3353_PROCFS
++/* Proc Filesystem *************************************************************************** */
++
++extern struct max3353_private max3353_private;
++
++#define MAX_HISTORY 6
++struct reg_list {
++ u8 reg;
++ u8 size;
++ char *name;
++ u32 values[MAX_HISTORY];
++};
++
++#define REG(r, s) {r, s, #r, }
++
++struct reg_list max3353_prod_list[] = {
++ REG(MAX3353_VENDOR_ID, 2),
++ REG(MAX3353_PRODUCT_ID, 2),
++ REG(MAX3353_VERSION_ID, 2),
++ { 0, 1, NULL,},
++};
++struct reg_list max3353_reg_list[] = {
++ REG(MAX3353_OTG_CONTROL_SET, 1),
++ REG(MAX3353_INTERRUPT_SOURCE, 1),
++ REG(MAX3353_INTERRUPT_LATCH_SET, 1),
++ REG(MAX3353_INTERRUPT_ENABLE_LOW_SET, 1),
++ REG(MAX3353_INTERRUPT_ENABLE_HIGH_SET, 1),
++ REG(MAX3353_MODE_CONTROL_1_SET, 1),
++ { 0, 1, NULL,},
++};
++struct reg_list max3353_spec_list[] = {
++ REG(MAX3353_MODE_CONTROL_2_SET, 1),
++ REG(MAX3353_OTG_STATUS, 1),
++ { 0, 1, NULL,},
++};
++struct reg_list max3301e_spec_list[] = {
++ REG(MAX3301E_SPECIAL_FUNCTION_1_SET, 1),
++ REG(MAX3301E_SPECIAL_FUNCTION_2_SET, 1),
++ { 0, 1, NULL,},
++};
++#ifdef CONFIG_ARCH_MX2ADS
++struct reg_list mx21_spec_list[] = {
++ REG(MX2_OTG_XCVR_DEVAD, 1),
++ REG(MX2_SEQ_OP_REG, 1),
++ REG(MX2_SEQ_RD_STARTAD, 1),
++ REG(MX2_I2C_OP_CTRL_REG, 1),
++ REG(MX2_SCLK_TO_SCL_HPER, 1),
++ REG(MX2_I2C_INTERRUPT_AND_CTRL, 1),
++ { 0, 1, NULL,},
++};
++#endif /* CONFIG_ARCH_MX2ADS */
++
++void max3353_update(struct reg_list *list)
++{
++ for (; list && list->name; list++) {
++ memmove(list->values + 1, list->values, sizeof(list->values) - sizeof(u32));
++ switch(list->size) {
++ case 1:
++ list->values[0] = i2c_readb(list->reg);
++ break;
++ case 2:
++ list->values[0] = i2c_readw(list->reg);
++ break;
++ case 4:
++ list->values[0] = i2c_readl(list->reg);
++ break;
++ }
++ }
++}
++
++#ifdef CONFIG_ARCH_MX2ADS
++static u8 __inline__ mx2_rb(u32 port)
++{
++ return *(volatile u8 *) (MX2_IO_ADDRESS(port + OTG_I2C_BASE));
++}
++
++
++void mx21_update(struct reg_list *list)
++{
++ for (; list && list->name; list++) {
++ memmove(list->values + 1, list->values, sizeof(list->values) - sizeof(u32));
++ list->values[0] = mx2_rb(list->reg);
++ }
++}
++
++#endif /* CONFIG_ARCH_MX2ADS */
++
++void max3353_update_all(void)
++{
++ max3353_update(max3353_reg_list);
++ switch (max3353_private.transceiver_map->transceiver_type) {
++ case max3353:
++ max3353_update(max3353_spec_list);
++ break;
++ case max3301e:
++ max3353_update(max3301e_spec_list);
++ break;
++ default:
++ break;
++ }
++#ifdef CONFIG_ARCH_MX2ADS
++ mx21_update(mx21_spec_list);
++#endif /* CONFIG_ARCH_MX2ADS */
++}
++
++
++
++/*
++ * 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);
++}
++
++int max3353_dump(char *buf, char *name, char *fmt, struct reg_list *reg)
++{
++ int len = 0, i;
++ len += sprintf (buf + len, "%-20s %-34s [%03x]: ", name, reg->name, reg->reg);
++ len += sprintf (buf + len, fmt, reg->values[0]);
++ for (i = 1; i < MAX_HISTORY; i++)
++ if (reg->values[i - 1] == reg->values[i])
++ len += sprintf (buf + len, " ");
++ else
++ len += sprintf (buf + len, fmt, reg->values[i]);
++ len += sprintf (buf + len, "\n");
++ return len;
++}
++
++int max3353_dump_list(char * buf, char *name, struct reg_list *list)
++{
++ int len = 0;
++ for (; list && list->name; list++)
++ switch(list->size) {
++ case 1: len += max3353_dump(buf + len, name, " %02x", list); break;
++ case 2: len += max3353_dump(buf + len, name, " %04x", list); break;
++ case 4: len += max3353_dump(buf + len, name, " %08x", list); break;
++ }
++ return len;
++}
++
++int max3353_dump_all(char *buf)
++{
++ int len = 0;
++ len += max3353_dump_list(buf + len, "MAX3353 Standard", max3353_reg_list);
++ switch (max3353_private.transceiver_map->transceiver_type) {
++ case max3353:
++ len += max3353_dump_list(buf + len, "MAX3353 Extra", max3353_spec_list);
++ break;
++ case max3301e:
++ len += max3353_dump_list(buf + len, "MAX3301E Extra", max3301e_spec_list);
++ break;
++ default:
++ break;
++ }
++#ifdef CONFIG_ARCH_MX2ADS
++ len += max3353_dump_list(buf + len, "MX21 ADS Extra", mx21_spec_list);
++#endif /* CONFIG_ARCH_MX2ADS */
++ return len;
++}
++
++
++
++/*!
++ * max3353_device_proc_read - implement proc file system read.
++ *
++ * 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 max3353_device_proc_read_functions (struct file *file, char *buf, size_t count, loff_t * pos)
++{
++ unsigned long page;
++ int len = 0;
++ int index;
++ int i;
++ u32 r;
++
++ int config_size;
++
++ // get a page, max 4095 bytes of data...
++ RETURN_EINVAL_UNLESS ((page = get_free_page (GFP_KERNEL)));
++
++ len = 0;
++ index = (*pos)++;
++
++ switch(index) {
++ case 0:
++ len += sprintf ((char *) page + len, "MAX3353 Transceiver Registers\n");
++
++ max3353_update_all();
++ len += sprintf ((char *) page + len , "Vendor: %04x Product: %04x Revision: %04x %s\n",
++ max3353_private.vendor, max3353_private.product,
++ max3353_private.revision, max3353_private.transceiver_map->name
++ );
++
++ len += max3353_dump_all((char *) page + len);
++ len += sprintf ((char *) page + len, "\n");
++
++ break;
++
++ case 1:
++ break;
++
++ }
++
++ if (len > count) {
++ len = -EINVAL;
++ }
++ else if ((len > 0) && copy_to_user (buf, (char *) page, len)) {
++ len = -EFAULT;
++ }
++ else {
++ }
++ free_page (page);
++ return len;
++}
++
++static struct file_operations max3353_device_proc_operations_functions = {
++ read:max3353_device_proc_read_functions,
++};
++
++/* Module init ******************************************************************************* */
++
++static int max3353_procfs_init (void)
++{
++ struct proc_dir_entry *p;
++
++ // create proc filesystem entries
++ if ((p = create_proc_entry ("max3353", 0, 0)) == NULL)
++ return -ENOMEM;
++
++ p->proc_fops = &max3353_device_proc_operations_functions;
++
++ max3353_update_all();
++
++ return 0;
++}
++static void max3353_procfs_exit (void)
++{
++ remove_proc_entry ("max3353", NULL);
++}
++#else
++static int max3353_procfs_init (void) { return 0;
++}
++static void max3353_procfs_exit (void) { }
++#endif
+diff -uNr linux/drivers/no-otg/ocd/max3353e/max3353e.c linux/drivers/otg/ocd/max3353e/max3353e.c
+--- linux/drivers/no-otg/ocd/max3353e/max3353e.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/max3353e/max3353e.c 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,657 @@
++/*
++ * otg/ocd/max3353/max3353.c -- USB Transceiver Controller driver
++ * @(#) balden@belcarra.com|otg/ocd/max3353e/max3353e.c|20060831021117|08740
++ *
++ * Copyright (c) 2004-2005 Belcarra
++ * Copyright (c) 2005-2006 Belcarra Technologies 2005 Corp
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Shahrad Payandeh <sp@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/ocd/max3353e/max3353e.c
++ * @brief MAX3353 OTG Transceiver Driver.
++ *
++ * This is the generic MAX3353 TCD core support.
++ *
++ * Notes:
++ *
++ * 1. The MAX3353 can control the speed and suspend directly, would it be
++ * appropriate to allow state machine to control this.
++ *
++ * 2. The MAX3353 has auto connect feature, can this be used without change
++ * to state machine.
++ *
++ * 3. The MAX3353 can control the ADR/PSW pin to enable / disable external
++ * charge pump.
++ *
++ * @ingroup MAX3353TCD
++ */
++
++#include <otg/otg-compat.h>
++
++#include <asm/irq.h>
++#include <asm/system.h>
++#include <asm/io.h>
++#include <asm/au1000.h>
++#include <linux/i2c.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/usbp-bus.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-hcd.h>
++#include <otg/otg-tcd.h>
++#include <otg/otg-ocd.h>
++#include <otg/otg-pcd.h>
++
++#include <otghw/max3353e-hardware.h>
++#include "max3353e.h"
++
++
++struct otg_transceiver_map max3353_transceiver_map[] = {
++ { max3353, 0x4cc, 0x1301, 0x00, "Phillips MAX3353", },
++ { max3301e, 0x6a0b, 0x0133, 0x00, "Maxim MAX3301E", },
++ { 0, 0, 0, 0, "Unknown Transceiver", },
++};
++
++struct max3353_private max3353_private;
++
++
++
++/* ********************************************************************************************* */
++#define TRACE_I2CB(t,r) TRACE_MSG3(t, "%-40s[%02x] %02x", #r, r, i2c_readb(r))
++#define TRACE_I2CW(t,r) TRACE_MSG3(t, "%-40s[%02x] %04x", #r, r, i2c_readw(r))
++#define TRACE_GPIO(t,b,r) TRACE_MSG2(t, "%-40s %04x", #r, readw(b + r))
++#define TRACE_REGL(t,r) TRACE_MSG2(t, "%-40s %08x", #r, readl(r))
++
++
++
++/*! max3353_int_src - update interrupt source test mask
++ *
++ * This sets the current mask and updates the interrupt registers to match.
++ */
++void max3353_int_src(u8 int_src)
++{
++ TRACE_MSG1(TCD, "setting int_src %02x", int_src);
++ max3353_private.int_src = int_src;
++ i2c_writeb(MAX3353E_INTERRUPT_MASK, int_src);
++ i2c_writeb(MAX3353E_INTERRUPT_EDGE, 3); //detect on positive edge
++ i2c_writeb(MAX3353E_INTERRUPT_LATCH, 0);
++}
++
++/*! max3353_int_src_set - add to the interrupt source mask
++ *
++ */
++void max3353_int_src_set(u8 int_src)
++{
++ max3353_int_src(int_src |= max3353_private.int_src);
++}
++
++/*! max3353_int_src_clr - remove from the interrup source mask
++ */
++void max3353_int_src_clr(u8 int_src)
++{
++ max3353_int_src(int_src = max3353_private.int_src & ~int_src);
++}
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++
++
++
++typedef struct max3353_test {
++ u32 input;
++ char *name;
++ u8 mask;
++} max3353_test_t;
++
++#define OV(i, m) {i, #i, m}
++#define MAX3353E_B_SESS_END 1<<4
++#define MAX3353E_B_SESS_VLD 1<<6
++#define MAX3353E_A_SESS_VLD 1<<5
++
++
++struct max3353_test max3353_int_src_tests[5] = {
++ OV(VBUS_VLD, MAX3353E_VBUS_VALID),
++ OV(ID_GND, MAX3353E_ID_GND),
++ OV(ID_FLOAT, MAX3353E_ID_FLOAT),
++ OV(BDIS_ACON, MAX3353E_A_HNP),
++ {0, NULL, 0},
++};
++
++struct max3353_test max3353_otg_status_tests[4] = {
++ OV(B_SESS_END, MAX3353E_B_SESS_END),
++ OV(B_SESS_VLD, MAX3353E_B_SESS_VLD),
++ OV(A_SESS_VLD, MAX3353E_A_SESS_VLD),
++ {0, NULL, 0},
++};
++
++u64 max3353_event(struct otg_instance *otg, struct max3353_test *tests, int val, char *msg)
++{
++ int i;
++ u64 inputs = 0;
++ TRACE_MSG2(TCD, "%02x %s", val, msg);
++ for (i = 0; tests[i].mask; i++) {
++ u64 input = tests[i].input;
++ u8 mask = tests[i].mask;
++ inputs |= (val & mask) ? input : _NOT(input);
++ TRACE_MSG5(TCD, "%d - %s%s %02x %08x", i, tests[i].name, (val & mask) ? "" : "/", tests[i].mask, tests[i].input);
++ }
++ return inputs;
++}
++
++/*! max3353_event_set_irq
++ */
++void max3353_event_set_irq(struct otg_instance *otg, int changed, int flag, u32 input, otg_tag_t tag, char *mset, char *mreset)
++{
++ TRACE_MSG5(TCD, "changed: %x flag: %x input: %08x %s %s", changed, flag, input,
++ flag ? mset: mreset,
++ changed ? "": "(ignored)");
++
++ otg_event_set_irq(otg, changed, flag, input, tag, flag ? mset : mreset);
++}
++
++/*! max3353_update - called from mx2_i2c_xcvr_bh to find changes in the max3353 Interrupt Source Register
++ */
++u8 max3353_update_int_src(struct otg_instance *otg, u8 int_src, u8 changed)
++{
++ UNLESS (changed) return int_src;
++ TRACE_MSG2(TCD, "CHANGED INTERRUPT_SOURCE: %02x (%02x) ", int_src, changed);
++
++ /* Core events
++ */
++ max3353_event_set_irq(otg, MAX3353E_ID_GND & changed, MAX3353E_ID_GND & int_src,
++ ID_GND, TCD, "ID_GND", "ID_GND/");
++ max3353_event_set_irq(otg, MAX3353E_ID_FLOAT & changed, MAX3353E_ID_FLOAT & int_src,
++ ID_FLOAT, TCD, "ID_FLOAT", "ID_FLOAT/");
++ max3353_event_set_irq(otg, MAX3353E_VBUS_VALID & changed, MAX3353E_VBUS_VALID & int_src,
++ VBUS_VLD, TCD, "VBUS_VLD", "VBUS_VLD/");
++ max3353_event_set_irq(otg, MAX3353E_SESSION_END & changed, MAX3353E_SESSION_END & int_src,
++ A_SESS_VLD, TCD, "A_SESS_VLD", "A_SESS_VLD/");
++
++
++ return int_src;
++}
++
++/*! max3353_update - called from mx2_i2c_xcvr_bh to find changes in the max3353 OTG Status Register
++ */
++u8 max3353_update_otg_status(struct otg_instance *otg, u8 otg_status, u8 changed)
++{
++ UNLESS (changed) return otg_status;
++ TRACE_MSG2(TCD, "CHANGED OTG_STATUS_REG: %02x (%02x) ", otg_status, changed);
++
++ max3353_event_set_irq(otg, MAX3353E_SESSION_VALID_EN & changed, MAX3353E_SESSION_VALID_EN & otg_status,
++ B_SESS_VLD, TCD, "B_SESS_VLD", "B_SESS_VLD/");
++ max3353_event_set_irq(otg, MAX3353E_SESSION_END & changed, MAX3353E_SESSION_END & otg_status,
++ B_SESS_END, TCD, "B_SESS_END", "B_SESS_END/");
++
++ return otg_status;
++}
++
++
++int max3353_bh_first;
++
++/*! max3353_bh
++ */
++void max3353_bh(void *arg)
++{
++
++ u64 inputs = 0;
++ u8 int_lat,status_reg,otg_reg;
++ u8 reg1,reg2;
++
++ au_writel(0x40000000, IC1_MASKCLR); //disable interrupt
++ au_writel(0x40000000, IC1_FALLINGCLR);
++ au_writel(0x40000000, IC1_RISINGCLR);
++ TRACE_MSG0(TCD, "--MAX3353 ISR start");
++// printk(KERN_INFO"ISR Start .......\n");
++
++ /* read the interrupt latch and and clear latch and update otg
++ */
++ if ((int_lat = i2c_readb(MAX3353E_INTERRUPT_LATCH))) {
++ TRACE_MSG1(TCD, "INT LAT: %02x", int_lat);
++ i2c_writeb(MAX3353E_INTERRUPT_LATCH, 0);
++ }
++
++ status_reg = i2c_readb(MAX3353E_STATUS_REGISTER);
++ inputs |= max3353_event(tcd_instance->otg, max3353_int_src_tests, status_reg, "MAX3353 STAT SRC");
++ TRACE_MSG1(TCD, "inputs after applying status register %02x\n", inputs);
++
++
++ otg_reg = 0;
++
++ if (status_reg & MAX3353E_SESSION_VALID_EN) { //1.4,,4.5
++ TRACE_MSG0(TCD, "Setting B_SESS_VLD");
++ otg_reg |= MAX3353E_B_SESS_VLD;
++ }
++ if (status_reg & MAX3353E_SESSION_END) {
++ TRACE_MSG0(TCD, "Setting B_SESS_END");
++ otg_reg |= MAX3353E_B_SESS_END;
++ }
++ if (!(status_reg & MAX3353E_SESSION_END)) { //0.8<<1.4
++ if (!(status_reg & MAX3353E_SESSION_VALID_EN)){
++ TRACE_MSG0(TCD, "Setting A_SESS_VLD");
++ otg_reg |= MAX3353E_A_SESS_VLD;
++ }
++ }
++
++
++
++ inputs |= max3353_event(tcd_instance->otg, max3353_otg_status_tests, otg_reg, "MAX3353 OTG SRC");
++ TRACE_MSG1(TCD, "inputs after applying otg register %02x\n", inputs);
++
++
++
++ TRACE_MSG0(TCD, "--MAX3353 ISR end");
++ if (inputs) otg_event(tcd_instance->otg, inputs, TCD, "MAX3353");
++ au_writel(0x40000000, IC1_MASKSET); //enable interrupt
++}
++
++
++
++/* ********************************************************************************************** */
++/*! max3353_vbus - Do we have Vbus (cable attached?)
++ * Return non-zero if Vbus is detected.
++ *
++ */
++int max3353_vbus (struct otg_instance *otg)
++{
++ return 0;
++}
++
++/*! max3353_id - Do we have Vbus (cable attached?)
++ * Return non-zero if Vbus is detected.
++ *
++ */
++int max3353_idvbus (struct otg_instance *otg)
++{
++ return 0;
++}
++
++
++/* ********************************************************************************************* */
++
++/*! max3353_chrg_vbus - used to enable or disable B-device Vbus charging
++ */
++void max3353_chrg_vbus(struct otg_instance *otg, u8 flag)
++{
++ u8 reg2;
++
++ TRACE_MSG0(TCD, "--");
++ reg2 = i2c_readb(MAX3353E_CONTROL_REGISTER_2);
++ TRACE_MSG1(TCD, "Control 2 - Begin = %02x", reg2);
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "CHRG_VBUS_SET");
++ reg2 |= MAX3353E_VBUS_CHG2;
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_2, (u8) reg2);
++ break;
++ case RESET:
++ TRACE_MSG0(TCD, "CHRG_VBUS_RESET");
++ reg2 &= (~MAX3353E_VBUS_CHG2);
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_2, (u8) reg2);
++ break;
++ case PULSE:
++ break;
++ }
++ TRACE_MSG1(TCD, "Control 2 - End = %02x", reg2);
++}
++
++/*! max3353_drv_vbus - used to enable or disable A-device driving Vbus
++ */
++void max3353_drv_vbus(struct otg_instance *otg, u8 flag)
++{
++u8 reg2;
++
++ TRACE_MSG0(TCD, "--");
++ reg2 = i2c_readb(MAX3353E_CONTROL_REGISTER_2);
++ TRACE_MSG1(TCD, "Control 2 - Begin = %02x", reg2);
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "DRV_VBUS_SET");
++ reg2 |= MAX3353E_VBUS_DRV;
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_2, (u8) reg2);
++ break;
++ case RESET:
++ TRACE_MSG0(TCD, "DRV_VBUS_RESET");
++ reg2 &= (~MAX3353E_VBUS_DRV);
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_2, (u8) reg2);
++ break;
++ case PULSE:
++ break;
++ }
++ TRACE_MSG1(TCD, "Control 2 - End = %02x", reg2);
++}
++
++/*! max3353_dischrg_vbus - used to enable Vbus discharge
++ */
++void max3353_dischrg_vbus(struct otg_instance *otg, u8 flag)
++{
++ u8 reg2;
++
++ TRACE_MSG0(TCD, "--");
++ reg2 = i2c_readb(MAX3353E_CONTROL_REGISTER_2);
++ TRACE_MSG1(TCD, "Control 2 - Begin = %02x", reg2);
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "DISCHG_VBUS_SET");
++ reg2 |= MAX3353E_VBUS_DISCHG;
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_2, (u8) reg2);
++ break;
++ case RESET:
++ TRACE_MSG0(TCD, "DISCHG_VBUS_RESET");
++ reg2 &= (~MAX3353E_VBUS_DISCHG);
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_2, (u8) reg2);
++ break;
++ case PULSE:
++ break;
++ }
++ TRACE_MSG1(TCD, "Control 2 - End = %02x", reg2);
++}
++
++/*! max3353_dp_pullup_func - used to enable or disable peripheral connecting to bus
++ *
++ * C.f. 5.1.6, 5.1.7, 5.2.4 and 5.2.5
++ *
++ * host peripheral
++ * d+ pull-up clr set
++ * d+ pull-down set clr
++ *
++ * d- pull-up clr clr
++ * d- pull-down set set
++ *
++ */
++void max3353_dp_pullup_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ TRACE_MSG0(TCD, "-- ");
++ switch (flag) {
++ case SET:
++ printk(KERN_INFO"%s: --\n", __FUNCTION__);
++ max3353_private.flags = i2c_readb(MAX3353E_CONTROL_REGISTER_1);
++ TRACE_MSG0(TCD, "Clr DP PULLDOWN");
++ max3353_private.flags &= (~MAX3353E_DP_PULLDOWN);
++ TRACE_MSG0(TCD, "Set DP PULLUP");
++ max3353_private.flags |= (MAX3353E_DP_PULLUP);
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_1, (u8) max3353_private.flags);
++ break;
++
++ case RESET:
++ max3353_private.flags = i2c_readb(MAX3353E_CONTROL_REGISTER_1);
++ TRACE_MSG0(TCD, "Clr DP PULLUP");
++ max3353_private.flags &= (~MAX3353E_DP_PULLUP);
++ TRACE_MSG0(TCD, "Set DP PULLDOWN");
++ max3353_private.flags |= (MAX3353E_DP_PULLDOWN);
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_1, (u8) max3353_private.flags);
++ break;
++
++ case PULSE:
++ TRACE_MSG0(TCD, "MAX3353_LOC_CONN PULSE");
++ break;
++ }
++ int temp = 0;
++ temp = i2c_readb(MAX3353E_CONTROL_REGISTER_1);
++ TRACE_MSG1(TCD, "Control Register 1: %02x", temp);
++
++}
++
++/*! max3353_dm_pullup_func - used to enable or disable peripheral connecting to bus
++ *
++ */
++void max3353_dm_pullup_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ max3353_private.flags = i2c_readb(MAX3353E_CONTROL_REGISTER_1);
++ TRACE_MSG0(TCD, "Clr DM PULLDOWN");
++ max3353_private.flags &= (~MAX3353E_DM_PULLDOWN);
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_1, (u8) max3353_private.flags);
++ TRACE_MSG0(TCD, "Set DM PULLUP");
++ max3353_private.flags |= (MAX3353E_DM_PULLUP);
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_1, (u8) max3353_private.flags);
++ break;
++
++ case RESET:
++ max3353_private.flags = i2c_readb(MAX3353E_CONTROL_REGISTER_1);
++ TRACE_MSG0(TCD, "Clr DM PULLUP");
++ max3353_private.flags &= (~MAX3353E_DM_PULLUP);
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_1, (u8) max3353_private.flags);
++ TRACE_MSG0(TCD, "Set DM PULLDOWN");
++ max3353_private.flags |= (MAX3353E_DM_PULLDOWN);
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_1, (u8) max3353_private.flags);
++ break;
++
++ case PULSE:
++ TRACE_MSG0(TCD, "MAX3353_LOC_CONN PULSE");
++ break;
++ }
++ int temp = 0;
++ temp = i2c_readb(MAX3353E_CONTROL_REGISTER_1);
++ TRACE_MSG1(TCD, "Control Register 1 %02x", temp);
++}
++
++/*! max3353_dm_det_func - used to enable or disable D- detect
++ *
++ */
++void max3353_dm_det_func(struct otg_instance *otg, u8 flag)
++{
++ return;
++}
++
++/*! max3353_dp_det_func - used to enable or disable D+ detect
++ *
++ */
++void max3353_dp_det_func(struct otg_instance *otg, u8 flag)
++{
++ return;
++}
++
++/*! max3353_bdis_acon_func - used to enable or disable auto a-connect
++ *
++ */
++void max3353_bdis_acon_func(struct otg_instance *otg, u8 flag)
++{
++ return;
++}
++
++/*! max3353_id_pulldown_func - used to enable or disable ID pulldown
++ *
++ */
++void max3353_id_pulldown_func(struct otg_instance *otg, u8 flag)
++{
++ return;
++}
++
++/*! max3353_audio_func - used to enable or disable Carkit Interrupt
++ *
++ */
++void max3353_audio_func(struct otg_instance *otg, u8 flag)
++{
++ return;
++}
++
++/*! max3353_uart_func - used to enable or disable transparent uart mode
++ *
++ */
++void max3353_uart_func(struct otg_instance *otg, u8 flag)
++{
++ return;
++}
++
++/*! max3353_mono_func - used to enable or disable mono audio connection
++ *
++ */
++void max3353_mono_func(struct otg_instance *otg, u8 flag)
++{
++ return;
++}
++
++
++/* ********************************************************************************************* */
++extern int max3353_procfs_init (void);
++extern void max3353_procfs_exit (void);
++
++/*! max3353_mod_init
++ */
++int max3353_mod_init(void)
++{
++ int ret;
++
++ TRACE_MSG0(TCD, "Initilize");
++ /* for interrupt bottom half handler
++ */
++ PREPARE_WORK_ITEM(max3353_private.bh, &max3353_bh, NULL);
++
++ /* setup max3353, enable interrupts, clear latch
++ * XXX when and how do we do DM_HI and DP_HI, when ID is present?
++ */
++ max3353_int_src_set(0x1f);
++ //max3353_int_src(MAX3353_NO_SE1_INT);
++ /*Turn on the max3353 and discharge the bus*/
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_2, 0x0);
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_1, 0x0);
++ int status = i2c_readb(MAX3353E_STATUS_REGISTER);
++ if ((status & 0x1) == 0){
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_2, 0x10);
++ }
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_2, 0x0);
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_1, MAX3353E_DM_PULLDOWN | MAX3353E_DP_PULLDOWN);
++
++#ifdef CONFIG_OTG_MAX3353_PROCFS
++ TRACE_MSG0(TCD, "MAX3353 Procfs");
++ max3353_procfs_init ();
++#endif /* CONFIG_OTG_MAX3353_PROCFS */
++
++ au_sync();
++
++ // au_writel(0x1, IC1_TESTBIT); //disable test bit for low leve interrupt
++ //All this done when define type of interrupt in irqmap.c
++ /*au_writel(0x40000000, IC1_CFG0CLR); //low level activation
++ au_writel(0x40000000, IC1_CFG1SET);
++ au_writel(0x40000000, IC1_CFG2CLR);
++ au_writel(0x40000000, IC1_MASKSET);//enable interrupt
++ */
++ //au_writel(0x40000000, IC1_SRCCLR);//set test bit as a source
++ au_writel(0x40000000, IC1_SRCSET);//set source to original
++ //au_writel(0x0, IC1_TESTBIT);
++ //au_writel(0x1, IC1_TESTBIT);
++
++#if 0
++ ret = au_readl(IC0_CFG0RD);
++ printk (KERN_INFO"IC0 Reg 0 : %08x\n", ret);
++ ret = au_readl(IC0_CFG1RD);
++ printk (KERN_INFO"IC0 Reg 1 : %08x\n", ret);
++ ret = au_readl(IC0_CFG2RD);
++ printk (KERN_INFO"IC0 Reg 2 : %08x\n", ret);
++ ret = au_readl(IC0_SRCRD);
++ printk (KERN_INFO"IC0 Source : %08x\n", ret);
++ ret = au_readl(IC0_ASSIGNRD);
++ printk (KERN_INFO"IC0 Assign : %08x\n", ret);
++ ret = au_readl(IC0_WAKERD);
++ printk (KERN_INFO"IC0 Wakeup : %08x\n", ret);
++ ret = au_readl(IC0_MASKRD);
++ printk (KERN_INFO"IC0 Mask : %08x\n", ret);
++
++ ret = au_readl(IC1_CFG0RD);
++ printk (KERN_INFO"IC1 Reg 0 : %08x\n", ret);
++ ret = au_readl(IC1_CFG1RD);
++ printk (KERN_INFO"IC1 Reg 1 : %08x\n", ret);
++ ret = au_readl(IC1_CFG2RD);
++ printk (KERN_INFO"IC1 Reg 2 : %08x\n", ret);
++ ret = au_readl(IC1_SRCRD);
++ printk (KERN_INFO"IC1 Source : %08x\n", ret);
++ ret = au_readl(IC1_ASSIGNRD);
++ printk (KERN_INFO"IC1 Assign : %08x\n", ret);
++ ret = au_readl(IC1_WAKERD);
++ printk (KERN_INFO"IC1 Wakeup : %08x\n", ret);
++ ret = au_readl(IC1_MASKRD);
++ printk (KERN_INFO"IC1 Mask : %08x\n", ret);
++
++#endif
++
++ return 0;
++}
++
++/*! max3353_mod_exit
++ */
++void max3353_mod_exit(void)
++{
++ i2c_writeb(MAX3353E_INTERRUPT_MASK, 0x0);
++ //i2c_close();
++#ifdef CONFIG_OTG_MAX3353_PROCFS
++ max3353_procfs_exit ();
++#endif /* CONFIG_OTG_MAX3353_PROCFS */
++
++ while (PENDING_WORK_ITEM(max3353_private.bh)) {
++ printk(KERN_ERR"%s: waiting for bh\n", __FUNCTION__);
++ schedule_timeout(10 * HZ);
++ }
++
++}
++
++/* ********************************************************************************************* */
++/*! max3353_configure - configure the MAX3353 for this host
++ * @param tx_mode - the type of connection between the host USB and the MAX3353
++ * @param spd_ctrl - suspend control method
++ */
++void max3353_configure(tx_mode_t tx_mode, spd_ctrl_t spd_ctrl)
++{
++ u16 vendor = 0, product = 0, revision = 0;
++ u8 mode1, mode2, control;
++
++ struct otg_transceiver_map *map = max3353_transceiver_map;
++ TRACE_MSG0(TCD, "Configure");
++
++ //#if defined(CONFIG_OTG_MAX3353_MX2ADS) || defined(CONFIG_OTG_MAX3353_MX2ADS_MODULE)
++ u32 vp;
++ u8 vb=0;
++ TRACE_MSG0(TCD, "1. Read Transceiver ID's with long read");
++ vb = i2c_readb(MAX3353E_MANUFACTURER_REGISTER_0);
++ max3353_private.vendor = vb;
++ vb = i2c_readb(MAX3353E_MANUFACTURER_REGISTER_1);
++ max3353_private.vendor += vb<<8;
++ vb = i2c_readb(MAX3353E_MANUFACTURER_REGISTER_2);
++ max3353_private.vendor += vb<<16;
++ vb = i2c_readb(MAX3353E_MANUFACTURER_REGISTER_3);
++ max3353_private.vendor += vb<<24;
++
++ vb = i2c_readb(MAX3353E_PRODUCT_ID_REGISTER_0);
++ max3353_private.product = vb;
++ vb = i2c_readb(MAX3353E_PRODUCT_ID_REGISTER_1);
++ max3353_private.product += vb<<8;
++ vb = i2c_readb(MAX3353E_PRODUCT_ID_REGISTER_2);
++ max3353_private.product += vb<<16;
++ vb = i2c_readb(MAX3353E_PRODUCT_ID_REGISTER_3);
++ max3353_private.product += vb<<24;
++
++ mode1 = i2c_readb(MAX3353E_CONTROL_REGISTER_1);
++ mode2 = i2c_readb(MAX3353E_CONTROL_REGISTER_2);
++
++ TRACE_MSG4(TCD, "2. OTG Transceiver: vendor: %08x product: %08x mode1: %02x mode2: %02x",
++ max3353_private.vendor, max3353_private.product, mode1, mode2);
++
++ TRACE_MSG0(TCD, "3. Disable All Transceiver Control Register 1 ");
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_1, 0x0); // clear
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_2, 0x0); // clear
++
++ TRACE_MSG0(TCD, "4. Enable D-/D+ Pulldowns in Transceiver Control Register 1 ");
++
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_1, MAX3353E_DM_PULLDOWN | MAX3353E_DP_PULLDOWN);
++ max3353_private.flags = MAX3353E_DM_PULLDOWN | MAX3353E_DP_PULLDOWN;
++
++ TRACE_MSG0(TCD, "5. Clear latch and enable interrupts");
++ i2c_writeb(MAX3353E_INTERRUPT_LATCH, 0x0);
++ max3353_int_src_set(0x1f);
++
++
++
++}
++
++
+diff -uNr linux/drivers/no-otg/ocd/max3353e/max3353e.h linux/drivers/otg/ocd/max3353e/max3353e.h
+--- linux/drivers/no-otg/ocd/max3353e/max3353e.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/max3353e/max3353e.h 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,134 @@
++/*
++ * otg/ocd/max3353/max3353.h -- USB Transceiver Controller driver
++ * @(#) balden@belcarra.com|otg/ocd/max3353e/max3353e.h|20060831021118|62926
++ *
++ * Copyright (c) 2004-2005 Belcarra
++ * Copyright (c) 2005-2006 Belcarra Technologies 2005 Corp
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @defgroup MAX3353TCD TCD - Maxim MAX3353
++ * @ingroup platformgroup
++ */
++/*!
++ * @file otg/ocd/max3353e/max3353e.h
++ * @brief Private structures and defines for MAX3353 Transciever Controller Driver.
++ *
++ * This file contains the private defines and structures for the MAX3353 Transceiver
++ * Driver.
++ *
++ * @ingroup MAX3353TCD
++ */
++
++
++#ifdef CONFIG_XXXXX
++#define MAX3353_GPIO (2)
++#define TCD_MAX3353_I2C_ADDR MAX3353_I2C_ADDR_HIGH;
++#endif
++
++#define MAX3353_NAME "max3353"
++
++#define MAX3353_LOC_CONN 0x01
++
++#define MAX3353_INT_SRC 0xeb
++
++//#define MAX3353_ALL_INT_SRC 0xff
++//#define MAX3353_NO_SE1_INT 0xeb
++//#define MAX3353_NO_SE1_INT 0xfb /* do not pay attention to DP_HI */
++
++typedef enum otg_transceiver {
++ unknown_transceiver,
++ max3353,
++ max3301e
++} otg_transceiver_t;
++
++struct otg_transceiver_map {
++ otg_transceiver_t transceiver_type;
++ u16 vendor;
++ u16 product;
++ u16 revision;
++ char *name;
++};
++
++struct max3353_private {
++ WORK_STRUCT bh;
++ u16 vendor;
++ u16 product;
++ u16 revision;
++ u32 flags;
++ u8 int_src;
++ struct otg_transceiver_map *transceiver_map;
++};
++
++/*! tx_mode
++ * This defines the various ways that the MAX3353 can be
++ * wired into the host USB.
++ */
++typedef enum tx_mode {
++ dat_se0_bidirectional, /*!< 3-Wire */
++ vp_vm_bidirectional, /*!< 4-Wire */
++ dat_se0_unidirectional /*!< 6-Wire */
++} tx_mode_t;
++
++/*! spd_ctrl
++ * This defines how the speed and suspend pins are controlled
++ * for this host.
++ */
++typedef enum spd_ctrl {
++ spd_susp_pins, /*!< controlled by SPEED and SUSPEND pins */
++ spd_susp_reg, /*!< controled by SPEED_REG and SUSPEND_REG in Mode Control 1 register */
++} spd_ctrl_t;
++
++
++extern struct tcd_ops tcd_ops;
++extern struct max3353_private max3353_private;
++extern struct tcd_instance *tcd_instance;
++
++/* max3353.c */
++extern int max3353_mod_init(void);
++extern void max3353_mod_exit(void);
++extern void max3353_chrg_vbus(struct otg_instance *, u8 );
++extern void max3353_drv_vbus(struct otg_instance *, u8 );
++extern void max3353_dischrg_vbus(struct otg_instance *, u8 );
++extern void max3353_dp_pullup_func(struct otg_instance *, u8 );
++extern void max3353_dm_pullup_func(struct otg_instance *, u8 );
++extern void max3353_dm_det_func(struct otg_instance *, u8 );
++extern void max3353_dp_det_func(struct otg_instance *, u8 );
++extern void max3353_bdis_acon_func(struct otg_instance *otg, u8 flag);
++extern void max3353_id_pulldown_func(struct otg_instance *otg, u8 flag);
++extern void max3353_audio_func(struct otg_instance *otg, u8 flag);
++extern void max3353_uart_func(struct otg_instance *otg, u8 flag);
++extern void max3353_mono_func(struct otg_instance *otg, u8 flag);
++
++extern void max3353_otg_timer(struct otg_instance *, u8 );
++extern void max3353_bh(void *);
++extern int max3353_id (struct otg_instance *);
++extern int max3353_vbus (struct otg_instance *);
++extern void max3353_configure(tx_mode_t, spd_ctrl_t );
++
++/* thread */
++extern int max3353_thread_init (void (bh_proc)(void *));
++extern void max3353_thread_exit (wait_queue_head_t *);
++extern void max3353_thread_wakeup(int enabled, int first);
++
++
++
++/* i2c-xxx.c */
++int i2c_configure(char *name, int addr);
++extern void i2c_close(void);
++extern u8 i2c_readb(u8 );
++extern u16 i2c_readw(u8 );
++extern u32 i2c_readl(u8 );
++extern int i2c_writeb(u8 , u8 );
++
++
++/* ********************************************************************************************* */
++#define TRACE_I2CB(t,r) TRACE_MSG3(t, "%-40s[%02x] %02x", #r, r, i2c_readb(r))
++#define TRACE_I2CW(t,r) TRACE_MSG3(t, "%-40s[%02x] %04x", #r, r, i2c_readw(r))
++#define TRACE_GPIO(t,b,r) TRACE_MSG2(t, "%-40s %04x", #r, readw(b + r))
++#define TRACE_REGL(t,r) TRACE_MSG2(t, "%-40s %08x", #r, readl(r))
++
+diff -uNr linux/drivers/no-otg/ocd/max3353e/tcd-db1550.c linux/drivers/otg/ocd/max3353e/tcd-db1550.c
+--- linux/drivers/no-otg/ocd/max3353e/tcd-db1550.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/max3353e/tcd-db1550.c 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,227 @@
++/*
++ * otg/ocd/max3353e/tcd-db1550.c -- USB Transceiver Controller driver
++ * @(#) balden@belcarra.com|otg/ocd/max3353e/tcd-db1550.c|20060831021118|37213
++ *
++ * Copyright (c) 2004-2005 Belcarra
++ * Copyright (c) 2005-2006 Belcarra Technologies 2005 Corp
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Shahrad Payandeh <sp@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/ocd/max3353e/tcd-db1550.c
++ * @brief DB1550 MAX3353 driver.
++ *
++ *
++ * @ingroup MAX3353TCD
++ */
++
++#include <otg/pcd-include.h>
++#include <linux/pci.h>
++#include <otghw/max3353e-hardware.h>
++#include "otghw/bvd-hardware.h"
++#include "max3353e.h"
++#include <asm/au1000.h>
++#include <linux/i2c.h>
++#include <linux/i2c-dev.h>
++
++struct ocd_instance *ocd_instance;
++otg_tag_t OCD;
++
++#if 0
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/usbp-bus.h>
++#include <otg/otg-trace.h>
++#include <otg/hcd.h>
++#include <otg/tcd.h>
++#include <otg/ocd.h>
++#include <otg/pcd.h>
++
++#include <otghw/isp1301-hardware.h>
++#include "isp1301.h"
++
++#endif
++/*SP
++#include <asm/arch/gpio.h>
++#include <asm/arch/mux.h>
++*/
++//struct isp1301_private isp1301_private;
++
++#ifdef CONFIG_OMAP_H2
++#define ADAPTOR_NAME "OMAP I2C"
++#endif /* CONFIG_OMAP_H2 */
++#ifdef CONFIG_ARCH_MAINSTONE
++#define ADAPTOR_NAME "PXA-I2C-Adapter"
++#endif /* CONFIG_ARCH_MAINSTONE */
++#ifdef CONFIG_OTG_DB1550_J15
++#define ADAPTOR_NAME "pb1550 adapter"
++#endif /* CONFIG_OTG_DB1550_J15 */
++
++/* ********************************************************************************************* */
++
++
++static irqreturn_t max3353_int_hndlr (int irq, void *dev_id, struct pt_regs *regs)
++{
++ TRACE_MSG0(TCD, "--");
++
++ SCHEDULE_WORK(max3353_private.bh);
++
++ return IRQ_HANDLED;
++}
++
++
++/* ********************************************************************************************* */
++
++struct ocd_ops ocd_ops;
++struct tcd_instance *db1550_tcd_instance;
++
++//#define ADAPTOR_NAME "pb1550 adapter"
++
++/*! tcd_mod_init
++ */
++int tcd_mod_init(void)
++{
++
++ struct otg_instance *otg;
++
++ int i2c = i2c_configure(ADAPTOR_NAME, MAX3353E_I2C_ADDR_HIGH);
++ int irq = request_irq (AU1500_GPIO_207, max3353_int_hndlr, SA_INTERRUPT, "MAX3353", NULL);
++ THROW_IF(irq, error);
++
++ TRACE_MSG0(TCD, "--");
++
++ THROW_IF(i2c, error);
++
++ TRACE_MSG0(TCD, "1. Enable db1550 external OTG Transceiver!");
++
++
++ TRACE_MSG0(TCD, "2. configure i2c driver!");
++ max3353_configure(dat_se0_bidirectional, spd_susp_reg);
++
++ TRACE_MSG0(TCD, "3. configure max3353!");
++ max3353_mod_init();
++
++ TRACE_MSG0(TCD, "4. set ops");
++ THROW_UNLESS(ocd_instance = otg_set_ocd_ops(&ocd_ops), error);
++ THROW_UNLESS(ocd_instance && (otg = ocd_instance->otg), error);
++ THROW_UNLESS(db1550_tcd_instance = otg_set_tcd_ops(&tcd_ops), error);
++
++#if 0 //test for making pulse on DP
++ for (;;){
++ max3353_private.flags = i2c_readb(MAX3353E_CONTROL_REGISTER_1);
++ TRACE_MSG0(TCD, "Clr DP PULLDOWN");
++ max3353_private.flags &= (~MAX3353E_DP_PULLDOWN);
++ TRACE_MSG0(TCD, "Set DP PULLUP");
++ max3353_private.flags |= (MAX3353E_DP_PULLUP);
++ i2c_writeb(MAX3353E_CONTROL_REGISTER_1, (u8) max3353_private.flags);
++ }
++#endif
++
++
++ /* Success!
++ */
++
++ TRACE_MSG0(TCD, "5. Success!");
++
++ otg_init(otg);
++
++ //In device mode only this part makes a virtual interrupt, while the cable is
++ //and modules are loaded.
++ au_writel (0x40000000, IC1_SRCCLR);
++ au_writel (0x0, IC1_TESTBIT);
++ au_writel (0x1, IC1_TESTBIT);
++ au_writel (0x0, IC1_TESTBIT);
++ au_writel (0x40000000, IC1_SRCSET);
++
++
++ /* error handling
++ */
++ CATCH(error) {
++ printk(KERN_INFO"Error in tcd initilization\n");
++ if (irq) free_irq(AU1500_GPIO_207, NULL);
++ if (i2c) i2c_close();
++ return -EINVAL;
++ }
++ return 0;
++}
++
++/*! tcd_mod_exit
++ */
++void tcd_mod_exit(void)
++{
++ struct otg_instance *otg = tcd_instance->otg;
++ TRACE_MSG0(TCD, "Exit.");
++
++ otg_event(otg, enable_otg_, OCD, "enable_otg_");
++ //if (otg)
++ // otg_exit(otg);
++
++ db1550_tcd_instance = otg_set_tcd_ops(NULL);
++ free_irq(AU1500_GPIO_207, NULL);
++ max3353_mod_exit();
++
++ i2c_writeb(MAX3353E_INTERRUPT_MASK, 0xff);
++ i2c_close();
++
++ if (otg)
++ otg_exit(otg);
++}
++/* ********************************************************************************************* */
++struct tcd_ops tcd_ops = {
++
++// vbus: max3353_vbus,
++
++ mod_init: tcd_mod_init,
++ mod_exit: tcd_mod_exit,
++
++ dischrg_vbus_func: max3353_dischrg_vbus,
++ chrg_vbus_func: max3353_chrg_vbus,
++ drv_vbus_func: max3353_drv_vbus,
++ dp_pullup_func: max3353_dp_pullup_func,
++ dm_pullup_func: max3353_dm_pullup_func,
++
++};
++
++#if 0
++
++struct tcd_ops tcd_ops;
++
++
++void db1550_tcd_global_init(void)
++{
++ ZERO(tcd_ops);
++
++ tcd_ops.id = max3353_id;
++ tcd_ops.vbus = max3353_vbus;
++ tcd_ops.chrg_vbus_func = max3353_chrg_vbus;
++ tcd_ops.dischrg_vbus_func = max3353_dischrg_vbus;
++ tcd_ops.dp_pullup_func = max3353_dp_pullup_func;
++ tcd_ops.dm_pullup_func = max3353_dm_pullup_func;
++ tcd_ops.dp_pulldown_func = max3353_dp_pulldown_func;
++ tcd_ops.dm_pulldown_func = max3353_dm_pulldown_func;
++ tcd_ops.overcurrent_func = NULL;
++ tcd_ops.dm_det_func = max3353_dm_det_func;
++ tcd_ops.dp_det_func = max3353_dp_det_func;
++ tcd_ops.cr_det_func = max3353_cr_det_func;
++
++ tcd_ops.peripheral_host_func = max3353_peripheral_host_func;
++
++ tcd_ops.id_pulldown_func = max3353_id_pulldown_func;
++ tcd_ops.audio_func = max3353_audio_func;
++ tcd_ops.uart_func = max3353_uart_func;
++ tcd_ops.mono_func = max3353_mono_func;
++
++ tcd_ops.mod_init = tcd_mod_init;
++ tcd_ops.mod_exit = tcd_mod_exit;
++}
++
++
++#endif
++
++
++
++
+diff -uNr linux/drivers/no-otg/ocd/max3353e/tcd-mx2ads.c linux/drivers/otg/ocd/max3353e/tcd-mx2ads.c
+--- linux/drivers/no-otg/ocd/max3353e/tcd-mx2ads.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/max3353e/tcd-mx2ads.c 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,541 @@
++/*
++ * otg/ocd/max3353e/tcd-mx2ads.c -- MX21ADS ISP1301 Transceiver Controller driver
++ * @(#) balden@belcarra.com|otg/ocd/max3353e/tcd-mx2ads.c|20060831021118|46922
++ *
++ * Copyright (c) 2004-2005 Belcarra
++ * Copyright (c) 2005-2006 Belcarra Technologies 2005 Corp
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Shahrad Payandeh <sp@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/ocd/max3353e/tcd-mx2ads.c
++
++ * @brief MX2ADS ISP1301 driver.
++ *
++ * This implements the ISP1301 Transceiver Controller Driver for the mx21
++ * using the USBOTG I2C controller for access.
++ *
++ * Notes
++ *
++ * 1. There are two interrupt sources, the I2C IO completion type generated when either of NOACK
++ * or RWREADY is set and the XCVR activity type generated when there is a OTG transceiver
++ * generated interrupt.
++ *
++ * It is important to only enable a single source at a time. By default we leave the XCVR
++ * interrupt enabled for normal operation and only enable the I2C IO type when we are actively
++ * waiting for an I2C IO operation to complete.
++ *
++ * 2. The USBOTG module can also interact with the OTG Transceiver, attempting to do register
++ * reads for various conditions (such as XCVR interrupts.) These interfere and cause problems so
++ * we keep the the I2C Controller interface in software mode at all times.
++ *
++ * 3. Because we must wait several hundred micro-seconds for I/O operations to complete, the i2c
++ * implementation is only usable from non-interrupt contexts. This means that all work that
++ * needs to be done needs to be pushed to a bottom half handler. A generic i2cWrite_irq() is
++ * provided where simple writes are all that are required.
++ *
++ * 4. The handling of the ISC_INTERRUPT_AND_CTRL register is complicated because the top nibble
++ * is r/w controlling the interrupt source enables while the bottom nibble is write 1 to clear
++ * to reset two of the three interrupt source bits (NOACK and RWREADY).
++ *
++ *
++ * TODO
++ *
++ * 1. The MX2ADS seems to have a hardware problem, when operating as a B-Device, Vbus does not
++ * drop to zero when disconnected (unplugged.) A 22kohm resister across C133 is suggested.
++ * Alternately I am just enabling VBUS_DISCHRG in LOC_CONN when we enable DP_PULLUP. Hopefully
++ * this will not be required in production code.
++ *
++ * @ingroup ISP1301TCD
++ */
++
++#include <otg/pcd-include.h>
++#include <linux/pci.h>
++#include <asm/arch/mx2.h>
++#include <otghw/isp1301-hardware.h>
++#include "mx2.h"
++#include <otghw/mx2-hardware.h>
++#include "isp1301.h"
++//#include <otg/otg-ops.h>
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++
++/*! mx2_urb
++ */
++u8 mx2_urbv(u32 port)
++{
++ u8 val = mx2_rb(port);
++ TRACE_MSG2(TCD, "PORT: %08x %02x", port, val);
++ return val;
++}
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++/* I2C Bottom Half I/O
++ *
++ * These are the I2C I/O routines that can be used from any non-interrupt
++ * context, typically from a bottom half handler.
++ *
++ * There is an interrupt safe, delayed i2cWrite function, it queues the
++ * writes and schedules work via a bottom half handler that can safely call
++ * the i2cWrite function.
++ */
++#define MX2_I2C_TIMEOUT 1
++#define I2C_READ_MASK 0x80
++#define I2C_MAX_WRITE 100
++
++DECLARE_MUTEX(i2c_sem); // semaphore to prevent overlapped i2c i/o
++wait_queue_head_t mx2_i2c_wait; // wait structure for i2c i/o interrupt
++struct WORK_STRUCT mx2_i2c_io_work_struct; // work structure for queued i2c writes
++
++int i2c_Write_Queued;
++u8 i2c_Write_Data[I2C_MAX_WRITE];
++u32 i2c_Write_Addr[I2C_MAX_WRITE];
++char * i2c_Write_Msg[I2C_MAX_WRITE];
++
++/*! i2c_read - read from otg transceiver
++ * This programs the I2C controller to do a read, waits for the completion
++ * interrupt, cleans up and returns the value for the specified register.
++ */
++void i2c_read(u32 port, int ops)
++{
++ u8 i2c_interrupt_and_ctrl;
++ u8 ctrl_reg;
++ int count;
++ RETURN_IF(i2c_Write_Queued < 0);
++ down(&i2c_sem); // pass through semaphore
++#if 1
++ if ((ctrl_reg = mx2_rb(MX2_I2C_OP_CTRL_REG)) & 0x4) {
++ TRACE_MSG1(TCD, "bad ctrl_reg: %02x", ctrl_reg);
++ }
++ for (count = 0; (count < 100) && (ctrl_reg = mx2_rb(MX2_I2C_OP_CTRL_REG)) & 0x80; count++) {
++ TRACE_MSG1(TCD, "busy ctrl_reg: %02x", ctrl_reg);
++ }
++#endif
++ mx2_orb(MX2_I2C_INTERRUPT_AND_CTRL, 0x6); // reset and disable interrupts
++ mx2_wb(MX2_SEQ_OP_REG, ops); // set number of sequential operations to 1
++ mx2_wb(MX2_SEQ_RD_STARTAD, port); // sequential read start address
++ mx2_wb(MX2_OTG_XCVR_DEVAD, I2C_READ_MASK | MX2_I2C_DEV_ADDR); // receiver address
++ mx2_orb(MX2_I2C_INTERRUPT_AND_CTRL, I2C_NOACK_EN | I2C_RWREADY_EN); // enable i2x I/O interrupt
++ interruptible_sleep_on_timeout(&mx2_i2c_wait, MX2_I2C_TIMEOUT); // wait for signal from i2c io interrupt handler
++ up(&i2c_sem);
++}
++
++/*! i2c_readb - read a byte from otg transceiver
++ * This programs the I2C controller to do a single byte read, waits for the
++ * completion interrupt, cleans up and returns the value for the specified
++ * register.
++ */
++u8 i2c_readb(u8 port)
++{
++ u8 data;
++ u32 addr = OTG_I2C_BASE + port;
++ i2c_read(addr, 1);
++ data = mx2_rb(addr); // read the register
++ //TRACE_MSG2(TCD, "port: %08x data: %02x", port, data);
++ return data;
++}
++
++/*! i2c_readw - read two bytes from otg transceiver
++ * This programs the I2C controller to do a two byte read, waits for the
++ * completion interrupt, cleans up and returns the value for the specified
++ * registers.
++ */
++u16 i2c_readw(u8 port)
++{
++ u16 data;
++ u32 addr = OTG_I2C_BASE + port;
++ i2c_read(addr, 2);
++ data = mx2_rb(addr) | (mx2_rb(addr + 1) << 8); // read the register
++ //TRACE_MSG2(TCD, "port: %08x data: %04x", port, data);
++ return data;
++}
++
++/*! i2c_readl - read two bytes from otg transceiver
++ * This programs the I2C controller to do a two byte read, waits for the
++ * completion interrupt, cleans up and returns the value for the specified
++ * registers.
++ */
++u32 i2c_readl(u8 port)
++{
++ u32 data;
++ u32 addr = OTG_I2C_BASE + port;
++ i2c_read(addr, 2);
++ data = mx2_rb(addr) | (mx2_rb(addr + 1) << 8) | (mx2_rb(addr + 2) << 16) | (mx2_rb(addr + 3) << 24);
++ //TRACE_MSG2(TCD, "port: %08x data: %04x", port, data);
++ return data;
++}
++
++/*! i2cWrite - write a byte to otg transceiver
++ * This writes the data to the shadow register, programs the I2C controller
++ * to do a single byte write, waits for the completion interrupt, cleans up
++ * and exits.
++ */
++void i2cWrite(u32 port, u8 data, char *msg)
++{
++ u8 i2c_interrupt_and_ctrl;
++ u8 test;
++ u8 ctrl_reg;
++ int count;
++ //TRACE_FMSG3(TCD, msg, "i2cWrite: port: %s (%08x) data: %02x", mx2_ureg_name(port), port, data);
++ TRACE_FMSG2(TCD, msg, "i2cWrite: (%08x) data: %02x", port, data);
++
++ //test = i2c_readb(port & 0xfffffffe);
++ //TRACE_MSG2(TCD, "i2cWrite: %02x before %02x", port, test);
++
++ down(&i2c_sem); // pass through semaphore
++
++#if 1
++ if ((ctrl_reg = mx2_rb(MX2_I2C_OP_CTRL_REG)) & 0x4) {
++ TRACE_MSG1(TCD, "bad ctrl_reg: %02x", ctrl_reg);
++ }
++ for (count = 0; (count < 10) && (ctrl_reg = mx2_rb(MX2_I2C_OP_CTRL_REG)) & 0x80; count++) {
++ TRACE_MSG1(TCD, "busy ctrl_reg: %02x", ctrl_reg);
++ }
++#endif
++ mx2_orb(MX2_I2C_INTERRUPT_AND_CTRL, 0x6); // reset and disable interrupts
++ mx2_wb(port, data); // write the register
++ mx2_wb(MX2_SEQ_OP_REG, 1); // set number of sequential operations to 1
++ mx2_wb(MX2_SEQ_RD_STARTAD, port); // sequential read start address
++ mx2_wb(MX2_OTG_XCVR_DEVAD, MX2_I2C_DEV_ADDR); // receiver address
++ mx2_orb(MX2_I2C_INTERRUPT_AND_CTRL, I2C_NOACK_EN | I2C_RWREADY_EN); // enable i2x I/O interrupt
++ interruptible_sleep_on_timeout(&mx2_i2c_wait, MX2_I2C_TIMEOUT); // wait for signal from i2c io interrupt handler
++ up(&i2c_sem);
++
++ //test = i2c_readb(port & 0xfffffffe);
++ //TRACE_MSG2(TCD, "i2cWrite: %02x after %02x", port, test);
++}
++
++/*! mx2_i2c_io_bh - bottom half handler to use i2cWrite on queued data
++ */
++void mx2_i2c_io_bh(void *arg)
++{
++ while (i2c_Write_Queued > 0) {
++ u8 write = i2c_Write_Data[0];
++ u32 port = i2c_Write_Addr[0];
++ char *msg = i2c_Write_Msg[0];
++ u8 data;
++ unsigned long flags; // atomic update of counter and saved values
++ local_irq_save (flags);
++ i2c_Write_Queued--;
++ memcpy(i2c_Write_Data, i2c_Write_Data + 1, sizeof(i2c_Write_Data) - 1);
++ memcpy(i2c_Write_Addr, i2c_Write_Addr + 1, sizeof(i2c_Write_Addr) - 4);
++ memcpy(i2c_Write_Msg, i2c_Write_Msg + 1, sizeof(i2c_Write_Msg) - 4);
++ local_irq_restore (flags);
++ i2cWrite(port, write, msg); // perform write
++ }
++}
++
++/*! i2cWrite_irq - queue data for i2cWrite bottom half handler
++ */
++void i2cWrite_irq(u32 port, u8 data, char *msg)
++{
++ RETURN_IF(i2c_Write_Queued < 0);
++ if ((i2c_Write_Queued == I2C_MAX_WRITE)) {
++ TRACE_MSG3(TCD, "TOO MANY QUEUED CANNOT WRITE port: %08x data: %02x active: %d", port, data, i2c_Write_Queued);
++ return;
++ }
++ i2c_Write_Addr[i2c_Write_Queued] = port;
++ i2c_Write_Data[i2c_Write_Queued] = data;
++ i2c_Write_Msg[i2c_Write_Queued] = msg;
++ i2c_Write_Queued++;
++ TRACE_FMSG3(TCD, msg, "i2cWrite_irq: port: %08x data: %02x active: %d", port, data, i2c_Write_Queued);
++ SCHEDULE_WORK(mx2_i2c_io_work_struct);
++}
++
++/*! i2c_writeb
++ */
++int i2c_writeb(u8 subaddr, u8 buf)
++{
++ i2cWrite_irq(OTG_I2C_BASE + subaddr, buf, "i2c_writeb");
++ return 0;
++}
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++/*! mx2ads_bh
++ */
++void mx2ads_bh(void *arg)
++{
++ isp1301_bh(NULL);
++ //mx2_bh(NULL);
++
++ /* re-enable the OTG XCVRINT
++ */
++ mx2_orb(MX2_I2C_INTERRUPT_AND_CTRL, I2C_OTGXCVRINT_EN);
++}
++
++
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++/* I2C I/O and XCVR Interrupt Handler
++ */
++
++/*! mx2_i2c_int_hndlr
++ * This is called from the main mx21ads interrupt handler to handle the
++ * i2c i/o interrupt. There are two main interrupt sources:
++ *
++ */
++irqreturn_t mx2_i2c_int_hndlr (int irq, void *dev_id, struct pt_regs *regs)
++{
++ //TRACE_MSG0(TCD, "MX2ADS I2C INTERRUPT: WAKEUP");
++ wake_up_interruptible(&mx2_i2c_wait); // wakeup waiting bottom half handler
++ return IRQ_HANDLED;
++}
++
++/*! mx2_tcd_int_hndlr
++ * This is called from the main mx21ads interrupt handler to handle the
++ * i2c i/o interrupt. There are two main interrupt sources:
++ */
++irqreturn_t mx2_tcd_int_hndlr (int irq, void *dev_id, struct pt_regs *regs)
++{
++ //TRACE_MSG0(TCD, "MX2ADS TCD INTERRUPT: SCHEDULE WORK");
++ isp1301_thread_wakeup(1, 0); // wakeup kernel thread
++ return IRQ_HANDLED;
++}
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++
++/*! mx2_tcd_init - used to initialize/enable or disable the tcd driver
++ */
++void mx2_tcd_init(struct otg_instance *otg, u8 flag)
++{
++ TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "MX2_TCD_EN SET");
++ otg_event(otg, TCD_OK | ID_FLOAT, TCD, "TCD_OK");
++ //mx2_i2c_xcvr_schedule(1);
++ isp1301_thread_wakeup(1, 1);
++ break;
++ case RESET:
++ TRACE_MSG0(TCD, "MX2_TCD_EN RESET");
++ isp1301_thread_wakeup(0, 0);
++ otg_event(otg, TCD_OK, TCD, "TCD_OK");
++ break;
++ }
++}
++
++/*! mx2_dp_pullup_func - used to enable or disable peripheral connecting to bus
++ */
++void mx2_dp_pullup_func(struct otg_instance *otg, u8 flag)
++{
++ struct tcd_instance *tcd = (struct tcd_instance *)otg->tcd;
++ TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "MX2_LOC_CONN SET");
++
++ TRACE_MSG0(TCD, "MX2_LOC_CONN SET - enable function interrupts");
++ mx2_wl(OTG_FUNC_SINT_STEN, /*SYSTEM_DONEREGINTDS_EN | *//*SYSTEM_SOFDETINT_EN |*/ SYSTEM_DONEREGINT_EN |
++ SYSTEM_SUSPDETINT_EN | SYSTEM_RSMFININT_EN | SYSTEM_RESETINT_EN);
++
++ TRACE_MSG0(TCD, "MX2_LOC_CONN SET - Set VBUS_DISCHRG");
++ i2c_writeb(ISP1301_OTG_CONTROL_SET, (u8) ISP1301_VBUS_DISCHRG);
++ break;
++ }
++
++ /* call generic dp pullup function
++ */
++ isp1301_dp_pullup_func(otg, flag);
++
++ switch (flag) {
++ case RESET:
++ TRACE_MSG0(TCD, "MX2_LOC_CONN SET - Clr VBUS_DISCHRG");
++ i2c_writeb(ISP1301_OTG_CONTROL_CLR, (u8) ISP1301_VBUS_DISCHRG);
++ break;
++ }
++
++}
++
++/*! mx2_drv_vbus - used to enable or disable A-device driving Vbus
++ */
++void mx2_drv_vbus(struct otg_instance *otg, u8 flag)
++{
++ TRACE_MSG0(TCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(TCD, "DRV_VBUS_SET");
++ i2c_writeb(ISP1301_OTG_CONTROL_CLR, (u8) ISP1301_VBUS_DRV);
++ break;
++ }
++
++ /* call generic drv vbus function
++ */
++ isp1301_drv_vbus(otg, flag);
++
++ switch (flag) {
++ case RESET:
++ TRACE_MSG0(TCD, "DRV_VBUS_RESET");
++ i2c_writeb(ISP1301_OTG_CONTROL_SET, (u8) ISP1301_VBUS_DRV);
++ break;
++ }
++}
++
++
++
++/*! mx2_id - return true if id is present
++ */
++int mx2_id(struct otg_instance *otg)
++{
++ /* this will force the bottom half handler to read the interrupt
++ * source register and generate an otg event
++ */
++ TRACE_MSG0(TCD, "ID: 0");
++ //mx2_i2c_xcvr_schedule(1);
++ isp1301_thread_wakeup(1, 1);
++ return 0;
++}
++
++/*! mx2_vbus - return true if Vbus is present
++ */
++int mx2_vbus(struct otg_instance *otg)
++{
++ /* this will force the bottom half handler to read the interrupt
++ * source register and generate an otg event
++ */
++ TRACE_MSG0(TCD, "VBUS: 0");
++ //mx2_i2c_xcvr_schedule(1);
++ isp1301_thread_wakeup(1, 1);
++ return 0;
++}
++
++/* ********************************************************************************************* */
++struct tcd_ops *otg_tcd_ops;
++struct tcd_instance *mx2ads_tcd_instance;
++
++/*! mx2_tcd_mod_init - initial tcd setup
++ * Allocate interrupts and setup hardware.
++ * This is called from mx2-ocd.c
++ */
++int mx2_tcd_mod_init (void)
++{
++ struct otg_instance *otg;
++
++ printk(KERN_INFO"%s\n", __FUNCTION__);
++
++ TRACE_MSG0(TCD, "0. Basic Setup");
++
++
++ init_waitqueue_head(&mx2_i2c_wait);
++ PREPARE_WORK_ITEM(mx2_i2c_io_work_struct, &mx2_i2c_io_bh, NULL);
++ //PREPARE_WORK_ITEM(mx2_i2c_xcvr_work_struct, &mx2_i2c_xcvr_bh, NULL);
++
++ isp1301_thread_init(mx2ads_bh);
++
++
++ TRACE_MSG1(TCD, "i2c_int_hndlr: %x", otg_tcd_ops);
++ TRACE_MSG2(TCD, "i2c_int_hndlr: %x %x", &tcd_ops, tcd_ops.i2c_int_hndlr);
++ TRACE_MSG2(TCD, "tcd_int_hndlr: %x %x", &tcd_ops, tcd_ops.tcd_int_hndlr);
++
++ TRACE_MSG0(TCD, "4. Enable Interrupts");
++
++ mx2_wb(MX2_I2C_OP_CTRL_REG, 0x04); // Software mode, output enabled
++
++ mx2_urbv(MX2_OTG_XCVR_DEVAD);
++ mx2_urbv(MX2_SEQ_OP_REG);
++ mx2_urbv(MX2_SEQ_RD_STARTAD);
++ mx2_urbv(MX2_I2C_OP_CTRL_REG);
++ mx2_urbv(MX2_SCLK_TO_SCL_HPER);
++ mx2_urbv(MX2_I2C_INTERRUPT_AND_CTRL);
++
++ mx2_wb(MX2_I2C_OP_CTRL_REG, 0x01); // Software mode, output enabled
++
++
++
++ mx2_wb(MX2_I2C_INTERRUPT_AND_CTRL, I2C_OTGXCVRINT_EN | I2C_NOACK_EN | I2C_RWREADY_EN);
++
++ isp1301_configure(vp_vm_bidirectional, spd_susp_pins);
++ isp1301_mod_init();
++
++ THROW_UNLESS(tcd_instance && (otg = tcd_instance->otg), error);
++ THROW_UNLESS(mx2ads_tcd_instance = otg_set_tcd_ops(&tcd_ops), error);
++
++ /* Success!
++ */
++
++ TRACE_MSG0(TCD, "5. Success!");
++
++ otg_init(otg);
++ //otg_start(otg, ocd_ops.capabilities & OCD_CAPABILITIES_AUTO);
++
++ /*
++ if ((ocd_ops.capabilities & OCD_CAPABILITIES_TR) && (ocd_ops.capabilities & OCD_CAPABILITIES_AUTO)) {
++ otg_event_irq(otg, enable_otg, TCD, "enable_otg");
++ otg_event_irq(otg, bus_req, TCD, "bus_req");
++ }
++ */
++
++ CATCH(error) {
++ printk(KERN_INFO"%s: failed\n", __FUNCTION__);
++ return -EINVAL;
++ }
++
++ TRACE_MSG0(TCD, "MX2_MOD_TCD_INIT FINISHED");
++ return 0;
++}
++
++/*! mx2_tcd_mod_exit - de-initialize
++ * This is called from mx2-ocd.c
++ */
++void mx2_tcd_mod_exit (void)
++{
++ struct otg_instance *otg = tcd_instance->otg;
++ TRACE_MSG0(TCD, "MX2_MOD_TCD_EXIT");
++
++ otg_event(otg, enable_otg_, OCD, "enable_otg_");
++ //if (otg)
++ // otg_exit(otg);
++
++ mx2ads_tcd_instance = otg_set_tcd_ops(NULL);
++
++ i2c_Write_Queued = -1;
++ wake_up_interruptible(&mx2_i2c_wait); // wakeup waiting bottom half handler
++
++ while (PENDING_WORK_ITEM(mx2_i2c_io_work_struct) /*|| PENDING_WORK_ITEM(mx2_i2c_xcvr_work_struct)*/ ) {
++ printk(KERN_ERR"%s: waiting for bh\n", __FUNCTION__);
++ schedule_timeout(10 * HZ);
++ }
++ isp1301_thread_exit(&mx2_i2c_wait);
++ isp1301_mod_exit();
++
++ if (otg)
++ otg_exit(otg);
++}
++
++/* ********************************************************************************************* */
++struct tcd_ops tcd_ops = {
++ id: mx2_id,
++ vbus: mx2_vbus,
++
++ tcd_init_func: mx2_tcd_init,
++ tcd_en_func: NULL,
++ chrg_vbus_func: isp1301_chrg_vbus,
++ drv_vbus_func: isp1301_drv_vbus,
++ dischrg_vbus_func: isp1301_dischrg_vbus,
++ dp_pullup_func: mx2_dp_pullup_func,
++ dm_pullup_func: isp1301_dm_pullup_func,
++
++ overcurrent_func: NULL,
++ dm_det_func: isp1301_dm_det_func,
++ dp_det_func: isp1301_dp_det_func,
++ charge_pump_func: NULL,
++ bdis_acon_func: isp1301_bdis_acon_func,
++ id_pulldown_func: isp1301_id_pulldown_func,
++ audio_func: isp1301_audio_func,
++ uart_func: isp1301_uart_func,
++ mono_func: isp1301_mono_func,
++
++ i2c_int_hndlr: mx2_i2c_int_hndlr,
++ tcd_int_hndlr: mx2_tcd_int_hndlr,
++ mod_init: mx2_tcd_mod_init,
++ mod_exit: mx2_tcd_mod_exit,
++};
++
+diff -uNr linux/drivers/no-otg/ocd/otg-hcd/hcd-init-l24.c linux/drivers/otg/ocd/otg-hcd/hcd-init-l24.c
+--- linux/drivers/no-otg/ocd/otg-hcd/hcd-init-l24.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/otg-hcd/hcd-init-l24.c 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,89 @@
++/*
++ * otg/ocd/otg-hcd/hcd-l24-init.c - OTG Host Controller Driver Module Initialization
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcara.com>,
++ * Tom Rushworth <tbr@belcara.com>,
++ * Bruce Balden <balden@belcara.com>
++ *
++ */
++/*!
++ * @file otg/ocd/otg-hcd/hcd-init-l24.c
++ * @brief
++ *
++ * This file initializes the low level hardware drivers.
++ *
++ * This is the linux 2.4 version.
++ *
++ * @ingroup OTGHCD
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++
++#include <otg/otg-compat.h>
++
++#include <otg/otg-compat.h>
++#include <otg/usbp-chap9.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-utils.h>
++#include <otg/otg-hcd.h>
++
++#ifdef MODULE
++#if LINUX_VERSION_CODE >= KERNEL_VERSION (2,4,17)
++MODULE_LICENSE ("GPL");
++#endif
++MODULE_PARM (serial_number_str, "s");
++MODULE_PARM_DESC (serial_number_str, "Serial Number");
++MODULE_AUTHOR ("sl@belcarra.com, tbr@belcarra.com");
++MODULE_DESCRIPTION ("USB On-The-Go HCD");
++#endif
++char *serial_number_str;
++
++otg_tag_t HCD;
++extern struct hcd_ops hcd_ops;
++struct hcd_instance *hcd_instance;
++
++/* ************************************************************************************* */
++
++/* hcd_modexit - This is *only* used for drivers compiled and used as a module.
++ */
++static void hcd_modexit (void)
++{
++ printk(KERN_INFO"%s\n", __FUNCTION__);
++ if (hcd_ops.mod_exit) hcd_ops.mod_exit();
++ hcd_instance = otg_set_hcd_ops(NULL);
++ otg_trace_invalidate_tag(HCD);
++}
++
++/* otg_modinit - linux module initialization
++ *
++ * This needs to initialize the hcd, pcd and tcd drivers. This includes tcd and possibly hcd
++ * for some architectures.
++ *
++ */
++static int hcd_modinit (void)
++{
++ printk(KERN_INFO"%s\n", __FUNCTION__);
++ HCD = otg_trace_obtain_tag();
++
++ THROW_UNLESS(hcd_instance = otg_set_hcd_ops(&hcd_ops), error);
++ THROW_IF((hcd_ops.mod_init) ? hcd_ops.mod_init() : 0, error);
++
++ CATCH(error) {
++ hcd_modexit();
++ return -EINVAL;
++ }
++ return 0;
++}
++
++module_init (hcd_modinit);
++#ifdef MODULE
++module_exit (hcd_modexit);
++#endif
++
++
++
+diff -uNr linux/drivers/no-otg/ocd/otg-hcd/hcd-l26.c linux/drivers/otg/ocd/otg-hcd/hcd-l26.c
+--- linux/drivers/no-otg/ocd/otg-hcd/hcd-l26.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/otg-hcd/hcd-l26.c 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,806 @@
++/*
++ * otg/ocd/otg-hcd/hcd-l26.c - Generic transfer level USBOTG aware Host Controller Driver (HCD)
++ *
++ * Copyright (c) 2004 Belcarra Technologies
++ *
++ * By:
++ * Tom Rushworth <tbr@belcara.com>,
++ * Stuart Lynne <sl@belcara.com>,
++ * Bruce Balden <balden@belcara.com>
++ *
++ */
++/*!
++ * @file otg/ocd/otg-hcd/hcd-l26.c
++ * @brief Linux Generic Host Controller Driver
++ *
++ * @ingroup OTGHCD
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/slab.h>
++#include <linux/init.h>
++#include <linux/usb.h>
++#include <asm/io.h>
++
++
++#include <otg/otg-compat.h>
++
++#include "../core/hcd.h"
++
++#include <otg/usbp-chap9.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-hcd.h>
++
++#include <otg/hcd-l26.h>
++#include <otg/hcd-rh.h>
++#include <otg/hcd-hw.h>
++
++int hcd_probe(struct usb_interface *intf, const struct usb_device_id *id)
++{
++ return 0;
++}
++
++void hcd_disconnect(struct usb_interface *intf)
++{
++}
++
++#define STATIC static
++
++STATIC __inline__ struct urb *grab_active_urb(struct bus_hcpriv *bus_hcpriv, int u)
++{
++ unsigned long flags;
++ struct urb *urb;
++ // Paranoia.
++ RETURN_NULL_UNLESS(bus_hcpriv && bus_hcpriv->active_urbs && (u < bus_hcpriv->max_active_urbs));
++ local_irq_save(flags);
++ urb = bus_hcpriv->active_urbs[u];
++ bus_hcpriv->active_urbs[u] = NULL;
++ local_irq_restore(flags);
++ return urb;
++}
++
++#define OUT(o,e)((o && e) ? 1 : 0)
++
++STATIC void hcd_queue_urb(struct dev_hcpriv *dev_hcpriv, struct urb *urb, int endpoint, int out)
++{
++ unsigned long flags;
++ // Paranoia.
++ RETURN_UNLESS(dev_hcpriv && urb && (endpoint < 16));
++ local_irq_save(flags);
++ dev_hcpriv->num_urbs_both[OUT(out, endpoint)][endpoint] += 1;
++ list_add_tail(&urb->urb_list, &dev_hcpriv->queued_urbs_both[OUT(out, endpoint)][endpoint]);
++ TRACE_MSG4(HCD,"urb: %08x ep: %d n: %u %s", (u32)(void*)urb,
++ endpoint, dev_hcpriv->num_urbs_both[OUT(out, endpoint)][endpoint], "IN");
++ local_irq_restore(flags);
++}
++
++STATIC struct urb *hcd_next_urb(struct dev_hcpriv *dev_hcpriv, int endpoint, int out)
++{
++ // MUST BE CALLED in_irq()!!
++ struct urb *urb;
++ struct list_head *epq;
++ // Paranoia.
++ RETURN_NULL_UNLESS(dev_hcpriv && (endpoint < 16));
++ epq = &dev_hcpriv->queued_urbs_both[OUT(out, endpoint)][endpoint];
++ RETURN_NULL_IF(list_empty(epq));
++ urb = list_entry(epq->next, struct urb, urb_list);
++ list_del_init(&urb->urb_list);
++ dev_hcpriv->num_urbs_both[OUT(out, endpoint)][endpoint] -= 1;
++ return urb;
++}
++
++STATIC void hcd_finish_urb(struct urb *urb, int reason)
++{
++ /* Call the upper layer completion routine. Decrement the ref count
++ * (release our interest in this urb).
++ */
++ urb->status = reason;
++ if (urb->complete)
++ urb->complete(urb, NULL);
++ usb_put_urb(urb);
++}
++
++STATIC int hcd_submit_to_hw(struct bus_hcpriv *bus_hcpriv, struct urb *urb, int out)
++{
++ // Pass the urb down to the hardware.
++ int rc;
++ void *data;
++ int dev_addr;
++ int endpoint;
++ int format;
++ int len;
++ int pid;
++ int toggle;
++ u32 other;
++ unsigned long flags;
++
++ struct usb_device *dev;
++ struct usb_bus *bus;
++ struct dev_hcpriv *dev_hcpriv;
++ u8 *cp;
++
++ RETURN_EINVAL_UNLESS((dev = urb->dev));
++ RETURN_EINVAL_UNLESS((bus = dev->bus));
++ RETURN_EINVAL_UNLESS((dev_hcpriv = (struct dev_hcpriv *) (dev->hcpriv)));
++
++ dev_addr = usb_pipedevice(urb->pipe);
++ endpoint = usb_pipeendpoint(urb->pipe);
++
++ TRACE_MSG4(HCD,"urb: %08lx ep: %d %s len: %d", (u32)(void*)urb, endpoint, (out?"OUT":"IN"), urb->actual_length);
++
++ if (out) {
++#if 0
++ int i;
++ u8 *cp = urb->transfer_buffer;
++
++ TRACE_MSG1(HCD, "NEXT TX: length: %d", urb->actual_length);
++
++ for (i = 0; i < urb->actual_length; i+= 8)
++
++ TRACE_MSG8(HCD, "SENT %02x %02x %02x %02x %02x %02x %02x %02x",
++ cp[i + 0], cp[i + 1], cp[i + 2], cp[i + 3],
++ cp[i + 4], cp[i + 5], cp[i + 6], cp[i + 7]
++ );
++#endif
++ }
++
++ if (usb_endpoint_halted(urb->dev, endpoint, out)) {
++ TRACE_MSG4(HCD,"urb for halted endpoint urb: %08lx dev: %d ep: %d dir: %c",
++ urb, dev_addr, endpoint, (out?'O':'I'));
++ urb->actual_length = 0;
++ hcd_finish_urb(urb,-EPIPE);
++ return -EINVAL;
++ }
++
++ data = urb->transfer_buffer;
++ len = urb->transfer_buffer_length;
++ format = usb_pipetype(urb->pipe);
++ other = 0;
++
++ switch (format) {
++ case PIPE_CONTROL:
++ pid = USB_PID_SETUP;
++ // overload toggle with data phase direction (setup is always toggle 0)
++ // toggle == TRUE --> OUT (HOST2DEVICE --> OUT)
++
++ toggle = ((((struct usbd_device_request *) urb->setup_packet)->bmRequestType & USB_REQ_DIRECTION_MASK) ==
++ USB_REQ_HOST2DEVICE);
++
++ other = (u32) (void *) urb->setup_packet;
++
++ // XXX send set feature otg enable IFF set configuration and
++ // to first device and previously otg descriptor was seen.
++ break;
++
++ case PIPE_BULK:
++ pid = (out ? USB_PID_OUT : USB_PID_IN);
++ toggle = usb_gettoggle(urb->dev,endpoint,out);
++ other = (urb->transfer_flags & URB_ZERO_PACKET);
++ break;
++
++ case PIPE_INTERRUPT:
++ pid = (out ? USB_PID_OUT : USB_PID_IN);
++ toggle = usb_gettoggle(urb->dev,endpoint,out);
++ other = urb->interval;
++ break;
++
++ case PIPE_ISOCHRONOUS:
++ pid = (out ? USB_PID_OUT : USB_PID_IN);
++ toggle = 0;
++ other = urb->interval;
++ break;
++
++ default:
++ pid = 0;
++ toggle = 0;
++ break;
++ }
++
++ /* We need an irq lock here in order to make sure the urb gets saved in
++ bus_hcpriv->active_urbs[] before any possible completion interrupt. */
++ local_irq_save(flags);
++ rc = hcd_hw_start_transfer(bus_hcpriv, len, data, toggle, usb_maxpacket(urb->dev, urb->pipe, out),
++ (((urb->pipe) >> 26) & 1), endpoint,dev_addr, pid, format,other);
++
++ if (rc >= 0 && rc < bus_hcpriv->max_active_urbs) {
++
++ if (!bus_hcpriv->active_urbs[rc])
++ bus_hcpriv->active_urbs[rc] = urb;
++
++ /* Oops, total screw up, we shouldn't ever see this.
++ * (The lower layer just told us it started a second urb in
++ * an already busy slot.)
++ */
++ else
++ TRACE_MSG3(HCD,"ERROR - act: %08x urb: %08x slot: %d",
++ (u32)(void*)(bus_hcpriv->active_urbs[rc]), (u32)(void*)urb, rc);
++ }
++ local_irq_restore(flags);
++ if (rc < 0) {
++ // Resubmit is OK...
++ if (rc == -2) {
++ TRACE_MSG1(HCD,"no ETDs for urb: %08lx",urb);
++ return 1;
++ }
++
++ // Complete the urb as invalid.
++ urb->actual_length = 0;
++ hcd_finish_urb(urb,-EINVAL);
++ // And signal to try again.
++ return -1;
++ }
++ return 0;
++}
++
++STATIC void hcd_queue_start(struct bus_hcpriv *bus_hcpriv, struct dev_hcpriv *dev_hcpriv, int endpoint, int out)
++{
++ unsigned long flags;
++ struct urb *urb = NULL;
++ int rc;
++
++ TRACE_MSG2(HCD, "endpoint: %2x %s", endpoint, out ? "OUT" : "IN");
++
++ // Paranoia.
++ RETURN_UNLESS(dev_hcpriv && endpoint < 16);
++ do {
++ local_irq_save(flags);
++ if (dev_hcpriv->epq_state_both[OUT(out, endpoint)][endpoint] == EPQ_RUNNING) {
++ // There's already an urb for this device/endpoint in the HW, don't start another.
++ urb = NULL;
++ }
++ else if (!(urb = hcd_next_urb(dev_hcpriv, endpoint, out))) {
++ dev_hcpriv->epq_state_both[OUT(out, endpoint)][endpoint] = EPQ_EMPTY;
++ }
++ else {
++ // There is an urb to go, set the state to show the HW is (will be) busy.
++ dev_hcpriv->epq_state_both[OUT(out, endpoint)][endpoint] = EPQ_RUNNING;
++ }
++ local_irq_restore(flags);
++ if (!urb) {
++ // This endpoint is already active in the HW, or doesn't need to be.
++ rc = 0;
++ }
++ else {
++ // Try to pass the urb down to the HW.
++ rc = hcd_submit_to_hw(bus_hcpriv, urb, out);
++ }
++ } while (rc < 0);
++ if (rc > 0) {
++ // We've run out of HW resources, try again later.
++ local_irq_save(flags);
++ list_add(&urb->urb_list, &dev_hcpriv->queued_urbs_both[OUT(out, endpoint)][endpoint]);
++ dev_hcpriv->num_urbs_both[OUT(out, endpoint)][endpoint] += 1;
++ dev_hcpriv->epq_state_both[OUT(out, endpoint)][endpoint] = EPQ_WAITING;
++ TRACE_MSG3(HCD,"urb: %08x ep: %d n: %u WAITING IN",
++ (u32)(void*)urb, endpoint, dev_hcpriv->num_urbs_both[OUT(out, endpoint)][endpoint]);
++ local_irq_restore(flags);
++ /* There should be no need to queue a task to try later, as the HW
++ * should have lots of pending urbs, and urb completion will lead
++ * to a search for new work. There is a small chance that _all_ the
++ * pending urbs will complete between the call to hcd_submit_to_hw(),
++ * but it's unlikely.
++ */
++ }
++}
++
++
++/* ********************************************************************************************** */
++/* Functions provided to the HW dependent layer (below this one).
++ */
++void hcd_transfer_complete(struct bus_hcpriv *bus_hcpriv, int transfer_id, int format, int cc, u32 remaining, int next_toggle)
++{
++ struct urb *urb = grab_active_urb(bus_hcpriv, transfer_id);
++ struct usb_device *dev;
++ struct usb_bus *bus;
++ struct dev_hcpriv *dev_hcpriv;
++ int out;
++
++ int endpoint;
++ u8 *cp;
++
++ UNLESS (urb) {
++ TRACE_MSG1(HCD,"active_urb[%d] NULL",transfer_id);
++ return;
++ }
++
++ RETURN_UNLESS((dev = urb->dev));
++ RETURN_UNLESS((bus = dev->bus));
++ RETURN_UNLESS((dev_hcpriv = (struct dev_hcpriv *) (dev->hcpriv)));
++
++ out = usb_pipeout(urb->pipe);
++
++ TRACE_MSG5(HCD,"id: %d status: %d tlen: %d rem: %d buffer: %p",
++ transfer_id, cc, urb->transfer_buffer_length, remaining, urb->transfer_buffer);
++ //if (out)
++ if (urb->transfer_buffer) {
++#if 0
++ int i;
++ u8 *cp = urb->transfer_buffer;
++
++ TRACE_MSG1(HCD, "NEXT TX: length: %d", urb->actual_length);
++
++ for (i = 0; i < urb->actual_length; i+= 8)
++
++ TRACE_MSG8(HCD, "RECV %02x %02x %02x %02x %02x %02x %02x %02x",
++ cp[i + 0], cp[i + 1], cp[i + 2], cp[i + 3],
++ cp[i + 4], cp[i + 5], cp[i + 6], cp[i + 7]
++ );
++#endif
++ }
++
++ if (-ENOENT == cc) {
++ // Cancelled.
++ urb->actual_length = 0;
++ }
++ else {
++ switch (format) {
++ case PIPE_CONTROL:
++ urb->actual_length = urb->transfer_buffer_length - remaining;
++
++ if ((cp = urb->setup_packet))
++ TRACE_MSG8(HCD, "SETUP %02x %02x %02x %02x %02x %02x %02x %02x",
++ cp[0], cp[1], cp[2], cp[3], cp[4], cp[5], cp[6], cp[7]);
++
++ if ((dev == bus_hcpriv->first_dev) && !cc && urb->setup_packet) {
++ struct usb_ctrlrequest *request = (struct usb_ctrlrequest*) urb->setup_packet;
++ switch (request->bRequest) {
++ case USB_REQ_SET_ADDRESS:
++ otg_event(hcd_instance->otg, ADDRESSED, HCD, "HCD COMPLETE ADDRESSED");
++ break;
++ case USB_REQ_SET_CONFIGURATION:
++ otg_event(hcd_instance->otg, CONFIGURED, HCD, "HCD COMPLETE CONFIGURED");
++ break;
++ // XXX check for GET_CONFIGURATION and otg descriptor here
++ }
++ }
++ break;
++
++ case PIPE_BULK:
++ case PIPE_INTERRUPT:
++ if (0 == cc) {
++ // QQSV needed for BULK, what about interrupt?
++ TRACE_MSG4(HCD,"dev: %d ep: %d dir: %d TOGGLE: %d",urb->dev->devnum,
++ usb_pipeendpoint(urb->pipe),usb_pipeout(urb->pipe),next_toggle);
++ usb_settoggle(urb->dev,usb_pipeendpoint(urb->pipe),usb_pipeout(urb->pipe),next_toggle);
++ }
++ urb->actual_length = urb->transfer_buffer_length - remaining;
++ //hcd_trace_mem(HCD,__FUNCTION__,"BULK/INTERRUPT urb",urb->actual_length,urb->transfer_buffer);
++ break;
++
++ case PIPE_ISOCHRONOUS:
++ urb->actual_length = urb->transfer_buffer_length - remaining; // QQSV
++ break;
++
++ default: // Paranoia.
++ urb->actual_length = 0;
++ break;
++ }
++ }
++ endpoint = usb_pipeendpoint(urb->pipe);
++ hcd_finish_urb(urb, cc);
++
++ // Start the next urb in the queue for this device/endpoint.
++ dev_hcpriv->epq_state_both[OUT(out, endpoint)][endpoint] = EPQ_WAITING;
++
++ TRACE_MSG2(HCD,"queue_start ep: %d %s >>>", endpoint, out ? "OUT" : "IN");
++ hcd_queue_start(bus_hcpriv, dev_hcpriv, endpoint, out);
++
++ //TRACE_MSG1(HCD,"queue_start ep: %d <<<",endpoint);
++ // FIXME - in the future, need to kick off a BH to search other EPs/devs for waiting urbs
++ // if (dev_hcpriv->epq_state[endpoint] == EPQ_EMPTY) {
++ // /* This queue is empty, so its HW resources are now available,
++ // kick off BH to search for other EP's and other devs that are waiting. */
++ // _________
++ // }
++}
++
++/* ********************************************************************************************** */
++/* Functions provided to the USB core layer (above this one).
++ */
++
++/* Allocate space for some USB function plugged into this HC or any hub below it.
++ * Return 0 on success, error code (e.g. -ENOMEM) on failure.
++ */
++STATIC int hcd_allocate(struct usb_device *dev)
++{
++ struct usb_bus *bus;
++ struct bus_hcpriv *bus_hcpriv;
++ struct dev_hcpriv *dev_hcpriv;
++ int endpoint;
++
++ TRACE_MSG1(HCD,"entered devnum: %d", dev->devnum);
++
++ RETURN_ENOMEM_UNLESS((bus = dev->bus));
++ RETURN_ENOMEM_UNLESS((bus_hcpriv = (struct bus_hcpriv *) bus->hcpriv));
++
++ RETURN_ENOMEM_UNLESS(dev_hcpriv = (struct dev_hcpriv *) kmalloc(sizeof(struct dev_hcpriv), GFP_KERNEL));
++
++ memset(dev_hcpriv, 0, sizeof(struct dev_hcpriv));
++ for (endpoint = 0; endpoint < 16; endpoint++) {
++ INIT_LIST_HEAD(&dev_hcpriv->queued_urbs_both[0][endpoint]);
++ INIT_LIST_HEAD(&dev_hcpriv->queued_urbs_both[1][endpoint]);
++ }
++
++ dev->hcpriv = dev_hcpriv;
++ dev_hcpriv->dev = dev;
++
++ UNLESS (bus_hcpriv->roothub_dev)
++ bus_hcpriv->roothub_dev = dev;
++
++ else UNLESS (bus_hcpriv->first_dev)
++ bus_hcpriv->first_dev = dev;
++
++ return 0;
++}
++
++
++STATIC int hcd_deallocate(struct usb_device *dev)
++{
++ struct usb_bus *bus = dev->bus;
++ struct bus_hcpriv *bus_hcpriv = (struct bus_hcpriv *) bus->hcpriv;
++ struct dev_hcpriv *dev_hcpriv;
++
++ if (dev == bus_hcpriv->first_dev)
++ bus_hcpriv->first_dev = NULL;
++
++ if (dev == bus_hcpriv->roothub_dev)
++ bus_hcpriv->roothub_dev = NULL;
++
++ if ((dev_hcpriv = (struct dev_hcpriv *) (dev->hcpriv))) {
++ dev_hcpriv->dev = NULL;
++ kfree(dev_hcpriv);
++ dev->hcpriv = NULL;
++ }
++ return 0;
++}
++
++
++STATIC void *hcd_buffer_alloc(struct usb_bus *usb_bus, size_t size, int mem_flags, dma_addr_t *dma)
++{
++ return consistent_alloc(0, size, dma);
++}
++
++STATIC void hcd_buffer_free(struct usb_bus *usb_bus, size_t size, void *addr, dma_addr_t dma)
++{
++ RETURN_UNLESS(addr);
++ consistent_free(addr,size,dma);
++}
++
++STATIC int frame_number(struct usb_device *usb_dev)
++{
++ u32 n = hcd_hw_frame_number((struct bus_hcpriv *)(usb_dev->bus->hcpriv));
++ TRACE_MSG1(HCD,"-->: %08lx",n);
++ return n;
++}
++
++STATIC int submit_urb(struct urb *urb, int mem_flags)
++{
++ struct bus_hcpriv *bus_hcpriv;
++ struct dev_hcpriv *dev_hcpriv;
++ int dev_addr;
++ int endpoint;
++ int out;
++
++ RETURN_EINVAL_UNLESS (urb && urb->dev && urb->dev->bus);
++ RETURN_EINVAL_UNLESS ((bus_hcpriv = (struct bus_hcpriv *) (urb->dev->bus->hcpriv)));
++ RETURN_EINVAL_UNLESS ((dev_hcpriv = (struct dev_hcpriv *) (urb->dev->hcpriv)));
++ RETURN_EINVAL_IF (bus_hcpriv->terminating);
++
++ dev_addr = usb_pipedevice(urb->pipe);
++ endpoint = usb_pipeendpoint(urb->pipe);
++ out = usb_pipeout(urb->pipe);
++
++ RETURN_EPIPE_IF (usb_endpoint_halted(urb->dev, endpoint, out));
++
++ /* Divert to root hub if appropriate, (note: NO ref count change).
++ */
++ if (urb->dev == bus_hcpriv->roothub_dev) {
++ TRACE_MSG4(HCD,"root hub --> urb: %08lx dev: %d ep: %d dir: %s", urb, dev_addr, endpoint, (out ? "OUT" : "IN"));
++ return hcd_rh_submit_urb(bus_hcpriv, urb, mem_flags);
++ }
++
++ /* Increase ref count so we own a piece of the URB. Queue the urb,
++ * then make sure the queue is running.
++ */
++ TRACE_MSG4(HCD,"device --> urb: %08lx dev: %d ep: %d dir: %S", urb, dev_addr, endpoint, (out ? "OUT" : "IN"));
++ hcd_queue_urb(dev_hcpriv, usb_get_urb(urb), endpoint, out);
++ hcd_queue_start(bus_hcpriv, dev_hcpriv, endpoint, out);
++ return 0;
++}
++
++STATIC int unlink_urb(struct urb *urb)
++{
++ int u;
++ unsigned long flags;
++ struct bus_hcpriv *bus_hcpriv = NULL;
++ struct dev_hcpriv *dev_hcpriv = NULL;
++ int dev_addr;
++ int endpoint;
++ struct list_head *epq;
++ int out;
++
++ RETURN_EINVAL_UNLESS (urb && urb->dev && urb->dev->bus);
++ RETURN_EINVAL_UNLESS ((dev_hcpriv = (struct dev_hcpriv *) (urb->dev->hcpriv)));
++ RETURN_EINVAL_UNLESS ((bus_hcpriv = (struct bus_hcpriv *) (urb->dev->bus->hcpriv)));
++
++ out = usb_pipeout(urb->pipe);
++
++ dev_addr = usb_pipedevice(urb->pipe);
++
++ /* Does it belong to the root hub?
++ */
++ if (urb->dev == bus_hcpriv->roothub_dev) {
++ TRACE_MSG1(HCD,"root hub --> urb: %08lx",urb);
++ return hcd_rh_unlink_urb(bus_hcpriv,urb);
++ }
++
++ /* Look to see if it is in a device/endpoint queue.
++ */
++ endpoint = usb_pipeendpoint(urb->pipe);
++
++ epq = &dev_hcpriv->queued_urbs_both[OUT(out, endpoint)][endpoint];
++
++ /* Searching a list while in_irq - yuck. For the time being,
++ * this just assumes that the list is short. In the future,
++ * it may be possible to keep a small amount of state in the
++ * urb itself to indicate if it is in this list, so that all
++ * we need to do in_irq is check the state and delete from the
++ * list if the state indicates we should. The state info will
++ * only needed while this HC "owns" the urb.
++ */
++ local_irq_save(flags);
++
++ if (EPQ_EMPTY != dev_hcpriv->epq_state_both[OUT(out, endpoint)][endpoint]) {
++ // There are queued urbs, search to see if this is one of them.
++ struct urb *qe;
++ list_for_each_entry(qe, epq, urb_list) {
++ if (qe == urb) {
++ // Found it. It hasn't been sent to the HW yet, so it can be finished here.
++ list_del_init(&urb->urb_list);
++ dev_hcpriv->num_urbs_both[OUT(out, endpoint)][endpoint] -= 1;
++ if (list_empty(epq))
++ dev_hcpriv->epq_state_both[OUT(out, endpoint)][endpoint] = EPQ_EMPTY;
++
++ TRACE_MSG3(HCD,"urb: %08x ep: %d n: %u UNLINKED IN",
++ (u32)(void*)urb, endpoint,
++ dev_hcpriv->num_urbs_both[OUT(out, endpoint)][endpoint]);
++ hcd_finish_urb(urb,-ENOENT);
++ local_irq_restore(flags);
++ return 0;
++ }
++ }
++ }
++
++ local_irq_restore(flags);
++
++ /* Look to see if this is one of the active urbs.
++ */
++ if (bus_hcpriv->active_urbs) {
++
++ for (u = 0; u < bus_hcpriv->max_active_urbs; u++) {
++ local_irq_save(flags);
++ /* This is the one we want, unlink from the HW.
++ * HW layer does the completion through hcd_transfer_complete()
++ * in this file, which releases bus_hcpriv->active_urbs[u].
++ */
++ if (urb == bus_hcpriv->active_urbs[u]) {
++ int out;
++ out = usb_pipeout(urb->pipe);
++ u = hcd_hw_unlink_urb(bus_hcpriv, u);
++
++ TRACE_MSG4(HCD,"urb: %08x ep: %d n: %u UNLINKED from HW %s", (u32)(void*)urb, endpoint,
++ dev_hcpriv->num_urbs_both[OUT(out, endpoint)][endpoint], out ? "OUT" : "IN");
++
++ local_irq_restore(flags);
++ // FUTURE - think about starting a search for new work for the released HW slot.
++ return u;
++ }
++ local_irq_restore(flags);
++ }
++ }
++ // The urb isn't ours, or completed while we were looking for it.
++ TRACE_MSG1(HCD,"Already completed, or someone else's urb: %08lx", urb);
++ return -EINVAL;
++}
++
++/* ********************************************************************************************** */
++
++// void disable(struct usb_device *dev, int bEndpointAddress);
++
++static struct usb_operations operations = {
++ .allocate = hcd_allocate,
++ .deallocate = hcd_deallocate,
++ .get_frame_number = frame_number,
++ .submit_urb = submit_urb,
++ .unlink_urb = unlink_urb,
++ .buffer_alloc = hcd_buffer_alloc, /* allocate dma-consistent buffer for URB_DMA_NOMAPPING */
++ .buffer_free = hcd_buffer_free,
++ .disable = NULL
++};
++
++
++/* ********************************************************************************************** */
++
++/* Called as a "bottom-half" to do usbcore registration once all the HW is usable.
++ */
++STATIC void hcd_bh_init(void *arg)
++{
++ struct hcd_instance *hcd = (struct hcd_instance *) arg;
++ otg_event(hcd->otg, HCD_OK, HCD, "HCD_INIT SET HCD_OK");
++ TRACE_MSG0(HCD,"finished");
++}
++
++STATIC void hcd_bh_exit(void *arg)
++{
++ struct hcd_instance *hcd = (struct hcd_instance *) arg;
++ otg_event(hcd->otg, HCD_OK, HCD, "HCD_INIT RESET (EXIT) HCD_OK");
++}
++
++
++/*! hcd_init_func - per host controller common initialization
++ *
++ * This is called to initialize / de-initialize the HCD, all except the last
++ * stage of registering the root hub, because that needs to wait until rh_hcd_en_func()
++ *
++ * We start work items to do this.
++ *
++ */
++void hcd_init_func (struct otg_instance *otg, u8 flag)
++{
++ struct hcd_instance *hcd = otg->hcd;
++
++ switch (flag) {
++ case SET:
++ // Schedule BH for hcd_bh_init...
++ TRACE_MSG0(HCD, "HCD_INIT: SET");
++ PREPARE_WORK_ITEM(hcd->bh, hcd_bh_init, hcd);
++ SCHEDULE_WORK(hcd->bh);
++ TRACE_MSG0(HCD, "hcd_bh_init() schedule finished");
++ break;
++
++ case RESET:
++ TRACE_MSG0(HCD, "HCD_INIT: RESET");
++ PREPARE_WORK_ITEM(hcd->bh, hcd_bh_exit, hcd);
++ SCHEDULE_WORK(hcd->bh);
++ break;
++ }
++}
++
++
++/* ********************************************************************************************** */
++
++STATIC void release_hw_rh(struct bus_hcpriv *bus_hcpriv)
++{
++ RETURN_UNLESS (bus_hcpriv);
++
++ hcd_rh_exit(bus_hcpriv);
++
++ // Complete (cancel) any active urbs.
++ if (bus_hcpriv->active_urbs) {
++ int u;
++ for (u = 0; u < bus_hcpriv->max_active_urbs; u++) {
++ struct urb *urb;
++ if ((urb = grab_active_urb(bus_hcpriv,u))) {
++ urb->actual_length = 0;
++ hcd_finish_urb(urb,-ENOENT); // USB_ST_URB_KILLED
++ }
++ }
++ }
++
++ // Release any resources from the layer above.
++ if (bus_hcpriv->usb_bus) {
++ usb_deregister_bus(bus_hcpriv->usb_bus);
++ bus_hcpriv->usb_bus = NULL;
++ }
++
++ // Lastly, release this layer's info.
++ if (bus_hcpriv->active_urbs) {
++ kfree(bus_hcpriv->active_urbs);
++ bus_hcpriv->active_urbs = NULL;
++ }
++}
++
++/* ********************************************************************************************** */
++/*
++ * Note that initialization and cleanup happen in two stages:
++ * 1. Allocation of the basic struct bus_hcpriv, the first level of LDM/USB driver registration, and OTG operations
++ * 2. Everything else - completion of data allocation, USBcore registration, HC HW init, root hub enumeration - when
++ * called back by OTG (after any magic required to access the HCD hardware.)
++ * Only stage 1 is done on module entry.
++ */
++
++int __init hcd_init(struct bus_hcpriv *bus_hcpriv, struct usb_driver *usb_driver)
++{
++ struct usb_bus *usb_bus = NULL;
++ int usb_registered = 0;
++ int device_registered = 0;
++ int bus_registered = 0;
++ int rc = 0;
++ struct urb **active_urbs = NULL;
++
++ /* fixup bus_hcpriv structure
++ */
++ bus_hcpriv->usb_driver = usb_driver;
++ bus_hcpriv->bus_device.driver = &usb_driver->driver;
++ bus_hcpriv->max_active_urbs = bus_hcpriv->max_active_transfers;
++ usb_driver->probe = hcd_probe;
++
++ UNLESS (hcd_ops.hcd_init_func) hcd_ops.hcd_init_func = hcd_init_func;
++
++ /* allocate urb array
++ */
++ THROW_UNLESS ((active_urbs = (struct urb **) kmalloc(bus_hcpriv->max_active_urbs*sizeof(struct urb *),GFP_KERNEL)),
++ error);
++
++ bus_hcpriv->active_urbs = active_urbs;
++ memset(bus_hcpriv->active_urbs,0,bus_hcpriv->max_active_urbs*sizeof(struct urb *));
++ TRACE_MSG1(HCD,"active_urbs ok, max active URBs: %d",bus_hcpriv->max_active_urbs);
++
++ /* register with usb core
++ */
++ THROW_UNLESS(usb_registered = usb_register(usb_driver) ? 0 : 1, error);
++ TRACE_MSG0(HCD,"usb_register ok");
++
++ /* We need a bus before we can initialize the root hub.
++ */
++ THROW_UNLESS ((usb_bus = usb_alloc_bus(&operations)), error);
++ bus_hcpriv->usb_bus = usb_bus;
++ TRACE_MSG0(HCD,"usb bus allocated");
++
++ /* register bus
++ */
++ snprintf(bus_hcpriv->bus_device.bus_id, BUS_ID_SIZE, "bus_hcpriv%d", usb_bus->busnum);
++ snprintf(bus_hcpriv->bus_device.name, DEVICE_NAME_SIZE,"%s%d", bus_hcpriv->usb_driver->name, usb_bus->busnum);
++ usb_bus->hcpriv = (void *) bus_hcpriv;
++ usb_bus->controller = &bus_hcpriv->bus_device;
++ THROW_UNLESS ((bus_registered = usb_register_bus(usb_bus)) ? 0 : 1, error);
++ TRACE_MSG0(HCD,"usb bus registered");
++
++ /* All set for the host controller, initialize the virtual root hub.
++ */
++ THROW_IF (hcd_rh_init(bus_hcpriv), error);
++ TRACE_MSG0(HCD,"root hub initialized");
++
++ /* register device
++ */
++ //THROW_IF ((device_registered = device_register(&bus_hcpriv->bus_device) ? 0 : 1), error);
++ if (device_register(&bus_hcpriv->bus_device)) {
++ printk(KERN_ERR"%s: device_register not ok\n", __FUNCTION__);
++ }
++
++ /* Everybody's ready, enable the interrupts.
++ */
++
++ /* Kick off the root hub.
++ */
++ THROW_IF ((rc = usb_register_root_hub(bus_hcpriv->rh_hcpriv->dev, &(bus_hcpriv->bus_device))), error);
++
++ return 0;
++
++ CATCH(error) {
++
++ if (device_registered) device_unregister(&bus_hcpriv->bus_device);
++ if (usb_bus) {
++ if (bus_registered && usb_bus) usb_deregister_bus(usb_bus);
++ kfree(usb_bus);
++ }
++ if (usb_registered) usb_deregister(usb_driver);
++ if (active_urbs) kfree(active_urbs);
++ return -EINVAL;
++ }
++}
++
++#ifdef MODULE
++void hcd_exit(struct bus_hcpriv *bus_hcpriv, struct usb_driver *usb_driver)
++{
++ release_hw_rh(bus_hcpriv);
++
++ usb_deregister_bus(bus_hcpriv->usb_bus);
++ device_unregister(&bus_hcpriv->bus_device);
++ usb_deregister(usb_driver);
++}
++#endif
++
+diff -uNr linux/drivers/no-otg/ocd/otg-hcd/hcd-rh.c linux/drivers/otg/ocd/otg-hcd/hcd-rh.c
+--- linux/drivers/no-otg/ocd/otg-hcd/hcd-rh.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/otg-hcd/hcd-rh.c 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,1068 @@
++/*
++ * otg/ocd/otg-hcd/hcd-rh.c - Generic transfer level USBOTG aware
++ * virtual root hub _FUNCTION_ driver.
++ *
++ * Copyright (c) 2004 Belcarra Technologies
++ *
++ * By:
++ * Tom Rushworth <tbr@belcara.com>,
++ * Stuart Lynne <sl@belcara.com>,
++ * Bruce Balden <balden@belcara.com>
++ */
++/*!
++ * @file otg/ocd/otg-hcd/hcd-rh.c
++ * @brief Root Hub for Generic Host Controller Driver
++ *
++ *
++ *
++ * @ingroup OTGHCD
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/slab.h>
++#include <linux/errno.h>
++#include <linux/usb.h>
++
++#include <otg/otg-compat.h>
++#include "../core/hcd.h"
++
++#include <otg/usbp-chap9.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-utils.h>
++#include <otg/otg-hcd.h>
++
++#include <otg/hcd-l26.h>
++#include <otg/hcd-rh.h>
++#include <otg/hcd-hw.h>
++
++#define STATIC static
++
++/* NOTE: This code assumes the root hub has < 8 ports. If it has
++ more some of the descriptors and other structures will have to
++ be re-sized. */
++
++STATIC u8 prepare_str(char *ascii, u8 *str, int str_size)
++{
++ int c;
++ u8 *up = str;
++ u8 *ep = (up + str_size) - 1;
++ while ((c = *ascii++) && up < ep) {
++ *up++ = (c & 0x7F);
++ *up++ = 0;
++ }
++ return (u8)(up - str);
++}
++
++STATIC int hcd_rh_string(struct bus_hcpriv *bus_hcpriv, int strno, u8 *buff, int buff_len)
++{
++ // Provide default strings, but let the HW component override them.
++ char *str;
++ switch (strno) {
++ case 0: // Language ID
++ *buff++ = 4;
++ *buff++ = USB_DT_STRING;
++ *buff++ = 0;
++ *buff++ = 0;
++ return 4;
++ case XHC_RH_STRING_CONFIGURATION:
++ str = "Root hub";
++ break;
++ case XHC_RH_STRING_INTERFACE:
++ str = "Root hub - Status";
++ break;
++ case XHC_RH_STRING_SERIAL:
++ str = bus_hcpriv->rh_serial ? bus_hcpriv->rh_serial : "000001";
++ break;
++ case XHC_RH_STRING_PRODUCT:
++ str = bus_hcpriv->rh_product ? bus_hcpriv->rh_product : "Virtual Root Hub";
++ break;
++ case XHC_RH_STRING_MANUFACTURER:
++ str = bus_hcpriv->rh_manufacturer ? bus_hcpriv->rh_manufacturer : "Belcarra Technologies";
++ break;
++ default:
++ str = "????";
++ }
++
++ buff[0] = 2 + prepare_str(str,buff+2,buff_len-2);
++ buff[1] = USB_DT_STRING;
++ return buff[0];
++}
++
++
++/* ********************************************************************************************** */
++
++
++static char *hub_feature_name[] = {
++ "C_HUB_LOCAL_POWER",
++ "C_HUB_OVER_POWER",
++};
++
++STATIC void hcd_rh_hub_feature(struct bus_hcpriv *bus_hcpriv, u16 wValue, int set_flag)
++{
++ unsigned long flags;
++ TRACE_MSG3(HCD,"%s feature %d %s",(set_flag?"SET":"CLR"), wValue, hub_feature_name[wValue]);
++ local_irq_save(flags);
++ if (set_flag) {
++ // SET feature USB2.0 11.24.2.12 pg 434 and USB2.0 11.24.2 tbl 11-17 pg 421
++ // R1: sec 23.11.29 pg 23-62
++ switch (wValue) {
++ // case C_HUB_OVER_CURRENT: ____ FIXME ----
++ // case C_HUB_LOCAL_POWER: ____ FIXME ----
++ default:
++ // Error, but ignore.
++ TRACE_MSG1(HCD,"SET invalid FEATURE %d", wValue);
++ break;
++ }
++ }
++ else {
++ // CLEAR feature USB2.0 11.24.2.1 pg 422 and USB2.0 11.24.2 tbl 11-17 pg 421
++ // R1: sec 23.11.29 pg 23-62
++ switch (wValue) {
++ case C_HUB_OVER_CURRENT:
++ bus_hcpriv->rh_hcpriv->hub_change_status &= ~(1 << wValue);
++ TRACE_MSG1(HCD,"CLR C_HUB_OVER_CURRENT hub_change_status: %08x", bus_hcpriv->rh_hcpriv->hub_change_status);
++ break;
++ // case C_HUB_LOCAL_POWER: ____ FIXME ----
++ default:
++ // Error, but ignore.
++ TRACE_MSG1(HCD,"CLR invalid FEATURE %d", wValue);
++ break;
++ }
++ }
++ local_irq_restore(flags);
++ hcd_hw_rh_hub_feature(bus_hcpriv, wValue, set_flag);
++}
++
++/* ********************************************************************************************** */
++
++char *port_feature_name[] = {
++ "PORT_CONNECTION", "PORT_ENABLE", "PORT_SUSPEND", "FEATURE 0x03",
++ "PORT_RESET", "FEATURE 0x05", "FEATURE 0x06", "FEATURE 0x07",
++ "PORT_POWER", "PORT_LOW_SPEED", "FEATURE 0x0a", "FEATURE 0x0b",
++ "FEATURE 0x0c", "FEATURE 0x0d", "FEATURE 0x0e", "FEATURE 0x0f",
++ "C_PORT_CONNECTION", "C_PORT_ENABLE", "C_PORT_SUSPEND", "C_PORT_OVER_CURRENT",
++ "C_PORT_RESET", "PORT_TEST",
++};
++
++void check_port_status_(int feature, u32 change_status, u32 hw_change_status)
++{
++ int mask = (1 << feature);
++ if ((change_status & mask) != (hw_change_status & mask))
++ TRACE_MSG4(HCD, "%-20s %2d %6s %6s MISMATCH", port_feature_name[feature], feature,
++ change_status & mask ? "SET" : "RESET", hw_change_status & mask ? "SET" : "RESET" );
++}
++
++void check_port_status(struct bus_hcpriv *bus_hcpriv, u16 wIndex, char *msg)
++{
++ struct rh_hcpriv *rh_hcpriv = bus_hcpriv->rh_hcpriv;
++ u32 change_status = ((wIndex -1) < bus_hcpriv->num_ports) ? bus_hcpriv->rh_hcpriv->port_change_status[wIndex-1] : 0;
++ u32 hw_change_status = hcd_hw_rh_get_port_change_status(bus_hcpriv, wIndex);
++
++ TRACE_MSG4(HCD,"PORT_STATUS[%2d] %08x %08x %s", wIndex,
++ change_status, hcd_hw_rh_get_port_change_status(bus_hcpriv, wIndex), msg);
++
++ UNLESS(rh_hcpriv->suspended) {
++ // XXX
++ }
++
++ check_port_status_(PORT_CONNECTION, change_status, hw_change_status);
++ check_port_status_(PORT_ENABLE, change_status, hw_change_status);
++ check_port_status_(PORT_RESET, change_status, hw_change_status);
++ check_port_status_(PORT_POWER, change_status, hw_change_status);
++ check_port_status_(C_PORT_CONNECTION, change_status, hw_change_status);
++ check_port_status_(C_PORT_ENABLE, change_status, hw_change_status);
++ check_port_status_(C_PORT_RESET, change_status, hw_change_status);
++}
++/* ********************************************************************************************** */
++/*
++ * wIndex is port number (1-N)
++ * wValue is feature selector
++ */
++STATIC void hcd_rh_port_feature(struct bus_hcpriv *bus_hcpriv, u16 wValue, u16 wIndex, int set_flag)
++{
++ TRACE_MSG4(HCD,"%s port %d FEATURE %02x %s", (set_flag?"SET":"CLR"), wIndex,
++ wValue, port_feature_name[wValue]);
++ /* Not a valid port number
++ */
++ if (wIndex > bus_hcpriv->num_ports) {
++ TRACE_MSG1(HCD, "invalid port: %d", wIndex);
++ return;
++ }
++ /* Feature selector is wValue
++ * wIndex is 1-origin
++ */
++ TRACE_MSG2(HCD, "port_change_status[%d]: -> %08x", wIndex, bus_hcpriv->rh_hcpriv->port_change_status[wIndex -1]);
++ if (set_flag) {
++ // SET feature
++ switch (wValue) {
++ case PORT_SUSPEND:
++ case PORT_RESET:
++ case PORT_POWER:
++ bus_hcpriv->rh_hcpriv->port_change_status[wIndex - 1] |= (1 << wValue);
++ break;
++ }
++ }
++ else {
++ // CLEAR feature (valid features from USB2.0 11.24.2.2 pg 423).
++ switch (wValue) {
++ case PORT_ENABLE: // Disable port.
++ case PORT_SUSPEND: // Cause a Host initiated resume, or no-op if already active.
++ case PORT_POWER: // Put port in powered-off state.
++ case C_PORT_CONNECTION: // clear the PORT_CONNECTION change bit
++ case C_PORT_RESET: // clear the PORT_RESET change bit
++ case C_PORT_ENABLE: // clear the PORT_ENABLE change bit
++ case C_PORT_SUSPEND: // clear the PORT_SUSPEND change bit
++ case C_PORT_OVER_CURRENT: // clear the PORT_OVERCURRENT change bit
++ bus_hcpriv->rh_hcpriv->port_change_status[wIndex - 1] &= ~(1 << wValue);
++ break;
++ }
++ }
++ /* update hardware?
++ */
++
++ RETURN_UNLESS (wIndex == bus_hcpriv->otg_port);
++ RETURN_IF (bus_hcpriv->rh_hcpriv->otg_device_mask & (1 << wIndex));
++
++ hcd_hw_rh_port_feature(bus_hcpriv, wValue, wIndex, set_flag);
++
++ TRACE_MSG4(HCD, "OTG Port wValue: %x wIndex: %d %d set: %d", wValue, wIndex, bus_hcpriv->otg_port, set_flag);
++ if (set_flag) {
++ // SET feature
++ switch (wValue) {
++ case PORT_RESET:
++ TRACE_MSG0(HCD, "OTG Port - HUB_PORT_ENABLED - PORT_RESET");
++ //otg_event(bus_hcpriv->hcd->otg, HUB_PORT_ENABLED, HCD, "Hub Port Enable (PORT_RESET)");
++ otg_event(hcd_instance->otg, BUS_RESET, HCD, "PORT_RESET (SET Feature)");
++ break;
++ case PORT_SUSPEND:
++ case PORT_POWER:
++ break;
++ }
++ check_port_status(bus_hcpriv, wIndex, "PORT SET");
++ }
++ else {
++ // CLEAR feature (valid features from USB2.0 11.24.2.2 pg 423).
++ switch (wValue) {
++ case C_PORT_CONNECTION: // clear the PORT_CONNECTION change bit
++ TRACE_MSG0(HCD, "OTG Port - HUB_PORT_ENABLED/ - C_PORT_CONNECTION");
++ break;
++ case C_PORT_ENABLE: // clear the PORT_ENABLE change bit
++ TRACE_MSG0(HCD, "OTG Port - HUB_PORT_ENABLED/ - C_PORT_ENABLE");
++ break;
++ case PORT_ENABLE: // Disable port.
++ case PORT_SUSPEND: // Cause a Host initiated resume, or no-op if already active.
++ case PORT_POWER: // Put port in powered-off state.
++ case C_PORT_RESET: // clear the PORT_RESET change bit
++ case C_PORT_SUSPEND: // clear the PORT_SUSPEND change bit
++ case C_PORT_OVER_CURRENT: // clear the PORT_OVERCURRENT change bit
++ break;
++ }
++ check_port_status(bus_hcpriv, wIndex, "PORT CLR");
++ }
++}
++
++/* ********************************************************************************************** */
++/*
++ * Functions for periodic response to the INT URB.
++ * Note that the USB2.0 spec says (sec 11.12.2 pg 337) that a hub controller
++ * will respond to an INT poll as long as the change bits remain set. This
++ * means we have to record them and continue responding periodically (hence
++ * the timer) until the class driver clears them.
++ *
++ */
++
++void hcd_rh_urb_complete(struct bus_hcpriv *bus_hcpriv, struct urb *urb)
++{
++ // Almost not needed (vrh could do this directly), except for tracing.
++ TRACE_MSG1(HCD,"urb %p",urb);
++
++ /* Call the upper layer completion routine.
++ */
++ if (urb->complete)
++ urb->complete(urb,NULL);
++
++ // XXX should we do this here
++ // usb_put_urb(int_urb);
++}
++/* ********************************************************************************************** */
++/*
++ * Some sort of change may have happened on the root hub or one of the ports,
++ * scan for changes in the shadow data, and notify usbcore if there is an
++ * INT URB available to do so with.
++ */
++STATIC void hcd_rh_portstatus_bh(void *data)
++{
++ struct bus_hcpriv *bus_hcpriv = (struct bus_hcpriv *) data;
++ struct rh_hcpriv *rh_hcpriv = bus_hcpriv->rh_hcpriv;
++ u8 change_data;
++ struct urb *int_urb;
++
++ u32 hub_port_change_status;
++ unsigned long flags;
++
++ TRACE_MSG1(HCD, "suspended: %d", rh_hcpriv->suspended);
++ RETURN_IF(rh_hcpriv->suspended);
++
++ //printk(KERN_INFO"%s:\n", __FUNCTION__);
++
++ local_irq_save(flags);
++ hub_port_change_status = bus_hcpriv->rh_hcpriv->hub_port_change_status;
++ bus_hcpriv->rh_hcpriv->hub_port_change_status = 0;
++ local_irq_restore(flags);
++
++
++ change_data = (u8) hub_port_change_status & 0xff;
++ //change_data ~= ~bus_hcpriv->rh_hcpriv->otg_device_mask;
++
++ RETURN_UNLESS (change_data && (int_urb = rh_hcpriv->int_urb));
++
++ TRACE_MSG1(HCD,"non-zero change_data: %02x", change_data);
++
++ change_data |= 1; // set hub change bit XXX check
++
++ // Completing the urb will "use it up", so remove the link to it.
++
++ del_timer(&rh_hcpriv->poll_timer);
++ rh_hcpriv->int_urb = NULL;
++
++ *((u8 *)(int_urb->transfer_buffer)) = change_data;
++ int_urb->actual_length = 1;
++
++ /* Completing an INT urb will cause it to be immediately re-submitted, so this will call submit_urb()
++ */
++ hcd_rh_urb_complete(bus_hcpriv, int_urb);
++ usb_put_urb(int_urb);
++}
++/* ********************************************************************************************** */
++STATIC void poll_int_urb(unsigned long data)
++{
++ struct bus_hcpriv *bus_hcpriv = (struct bus_hcpriv *) (void *) data;
++ unsigned long flags;
++
++ RETURN_UNLESS (bus_hcpriv && bus_hcpriv->rh_hcpriv);
++
++ local_irq_save(flags);
++ PREPARE_WORK_ITEM(bus_hcpriv->rh_hcpriv->psc_bh, hcd_rh_portstatus_bh, bus_hcpriv);
++ SCHEDULE_WORK(bus_hcpriv->rh_hcpriv->psc_bh);
++ local_irq_restore(flags);
++}
++/* ********************************************************************************************** */
++STATIC u32 rh_get_port_change_status(struct bus_hcpriv *bus_hcpriv, u16 wIndex)
++{
++ if ((wIndex != bus_hcpriv->otg_port) || !(bus_hcpriv->rh_hcpriv->otg_device_mask))
++ return hcd_hw_rh_get_port_change_status(bus_hcpriv, wIndex);
++
++ TRACE_MSG0(HCD, "USING SHADOW INFORMATION");
++ return bus_hcpriv->rh_hcpriv->port_change_status[wIndex-1];
++}
++
++/*
++ * hcd_rh_submit_urb()
++ * Returns: values as for the generic submit_urb() function, see comp_code_to_status(int cc).
++ */
++int hcd_rh_submit_urb(struct bus_hcpriv *bus_hcpriv, struct urb *urb, int mem_flags)
++{
++ struct rh_hcpriv *rh_hcpriv;
++ unsigned int pipe = urb->pipe;
++ struct usbd_device_request *req;
++ u8 bRequest;
++ u8 bmRequestType;
++ u16 wValue;
++ u16 wIndex;
++ u16 wLength;
++ u8 direction;
++ u8 recipient;
++ u8 type;
++ int rc = 0;
++ int rc_stall = -EPIPE;
++ void *reply = NULL;
++ int rlen = 0;
++ u16 status[2];
++
++ static rh_urb;
++
++ TRACE_MSG1(HCD,"pipe: %08x", pipe);
++
++
++ //printk(KERN_INFO"%s: rh_urb: %d\n", __FUNCTION__);
++ TRACE_MSG1(HCD, "rh_urb: %d", rh_urb++);
++
++ RETURN_ETIMEDOUT_UNLESS(bus_hcpriv && bus_hcpriv->rh_hcpriv);
++
++ rh_hcpriv = bus_hcpriv->rh_hcpriv;
++
++ if (usb_pipeint(pipe)) {
++ // This must be our interrupt endpoint poll.
++ TRACE_MSG1(HCD,"interrupt polling urb: %08lx",urb);
++ urb->status = 0;
++
++ // Increment the ref count, we're keeping this for a while.
++ usb_get_urb(urb);
++ if (rh_hcpriv->int_urb) {
++ // Hmm, a new one while we still have the old...Shouldn't happen, and doesn't work if it does :(.
++ //printk(KERN_INFO "%s: releasing old: %08x\n",__FUNCTION__,(u32)(void*)rh_hcpriv->int_urb);
++ del_timer(&rh_hcpriv->poll_timer);
++ usb_put_urb(rh_hcpriv->int_urb);
++ }
++
++ rh_hcpriv->int_urb = urb;
++ /* Schedule a scan for changes in case anything happened while there was no urb.
++ * This has to be slightly delayed, in case this urb is a response to a completed
++ * scan - usbcore submits a new int urb before clearing the hub/port change status,
++ * relying on the int urb polling delay to give it time to do the clearing.
++ */
++ //printk(KERN_INFO "%s: scheduling PSC poll\n",__FUNCTION__);
++ //init_poll_timer(bus_hcpriv);
++ init_timer(&rh_hcpriv->poll_timer);
++ rh_hcpriv->poll_timer.function = poll_int_urb;
++ rh_hcpriv->poll_timer.data = (unsigned long) (void *) bus_hcpriv;
++ rh_hcpriv->poll_timer.expires = jiffies +
++ ((((rh_hcpriv->int_urb->interval < 10) ? 10 : rh_hcpriv->int_urb->interval) * HZ) / 1000);
++ add_timer(&rh_hcpriv->poll_timer);
++ return rc;
++ }
++
++ TRACE_MSG1(HCD,"req: %08x",(u32)(void*)urb->setup_packet);
++ RETURN_EINVAL_UNLESS((req = (struct usbd_device_request *) urb->setup_packet))
++
++ bRequest = req->bRequest;
++ bmRequestType = req->bmRequestType;
++ wValue = le16_to_cpu(req->wValue);
++ wIndex = le16_to_cpu(req->wIndex);
++ wLength = le16_to_cpu(req->wLength);
++ direction = bmRequestType & USB_REQ_DIRECTION_MASK;
++ recipient = bmRequestType & USB_REQ_RECIPIENT_MASK;
++ type = bmRequestType & USB_REQ_TYPE_MASK;
++
++ TRACE_MSG8(HCD,"urb: %08lx req: %02x reqType: %02x val=%u ndx=%u len=%u dir: %02x recip: %02x",
++ urb,bRequest,bmRequestType, wValue,wIndex,wLength,direction,recipient);
++
++ if (USB_REQ_HOST2DEVICE == direction) {
++ /* these do not require a reply */
++ int set_flag = (USB_REQ_SET_FEATURE == bRequest);
++ TRACE_MSG0(HCD,"H->D");
++ //printk(KERN_INFO "%s: H->D\n",__FUNCTION__);
++ urb->actual_length = 0;
++ switch (recipient) {
++ case USB_RECIP_HUB:
++ switch (bRequest) {
++ case USB_REQ_CLEAR_FEATURE:
++ case USB_REQ_SET_FEATURE:
++ if (USB_REQ_TYPE_CLASS == type) {
++ TRACE_MSG2(HCD,"%s hub feature: %04x",(set_flag?"set":"clear"),wValue);
++ //printk(KERN_INFO "%s hub feature: %04x\n",(set_flag?"set":"clear"),wValue);
++ hcd_rh_hub_feature(bus_hcpriv, wValue, set_flag);
++ }
++ else {
++ TRACE_MSG2(HCD,"HUB C/S feature invalid type r: %02x t: %02x",bRequest,bmRequestType);
++ rc = rc_stall;
++ }
++ break;
++ case USB_REQ_SET_ADDRESS:
++ if (USB_REQ_TYPE_STANDARD == type) {
++ TRACE_MSG1(HCD,"set address %u",wValue);
++ //printk(KERN_INFO "set address %u\n",wValue);
++ bus_hcpriv->root_hub_addr = wValue;
++ }
++ else {
++ TRACE_MSG2(HCD,"HUB SETADDRESS invalid type r: %02x t: %02x",bRequest,bmRequestType);
++ rc = rc_stall;
++ }
++ break;
++ case USB_REQ_SET_CONFIGURATION:
++ if (USB_REQ_TYPE_STANDARD == type) {
++ TRACE_MSG1(HCD,"set configuration: %02x",wValue);
++ //printk(KERN_INFO "set configuration: %02x\n",wValue);
++ rh_hcpriv->curr_cfg = (u8) (0xFF & wValue);
++ }
++ else {
++ TRACE_MSG2(HCD,"HUB SETCONFIG invalid type r: %02x t: %02x",bRequest,bmRequestType);
++ rc = rc_stall;
++ }
++ break;
++ case USB_REQ_SET_INTERFACE:
++ // wIndex is interface number
++ if (USB_REQ_TYPE_STANDARD == type) {
++ TRACE_MSG2(HCD,"set interface: %02x to : %02x",wIndex,wValue);
++ //printk(KERN_INFO "set interface: %02x to : %02x\n",wIndex,wValue);
++ rh_hcpriv->curr_itf = (u8) (0xFF & wValue);
++ }
++ else {
++ TRACE_MSG2(HCD,"HUB SETINTERFACE invalid type r: %02x t: %02x",bRequest,bmRequestType);
++ rc = rc_stall;
++ }
++ break;
++ default:
++ TRACE_MSG2(HCD,"HUB invalid request r: %02x t: %02x",bRequest,bmRequestType);
++ rc = rc_stall;
++ }
++ break;
++ case USB_RECIP_PORT:
++ switch (bRequest) {
++ case USB_REQ_CLEAR_FEATURE:
++ case USB_REQ_SET_FEATURE:
++ // At this point wIndex == port_num is 1-origin.
++ if (USB_REQ_TYPE_CLASS == type && wIndex <= bus_hcpriv->num_ports && wIndex > 0) {
++ TRACE_MSG3(HCD,"%s port %u FEATURE: %04x",(set_flag?"set":"clear"),wIndex,wValue);
++ hcd_rh_port_feature(bus_hcpriv, wValue, wIndex, set_flag);
++ }
++ else {
++ TRACE_MSG2(HCD,"PORT C/S FEATURE invalid type r: %02x t: %02x",bRequest,bmRequestType);
++ rc = rc_stall;
++ }
++ break;
++ default:
++ TRACE_MSG2(HCD,"PORT invalid request r: %02x t: %02x",bRequest,bmRequestType);
++ rc = rc_stall;
++ }
++ break;
++ case USB_REQ_RECIPIENT_ENDPOINT:
++ // Clear stalled endpoint
++ if (USB_REQ_CLEAR_FEATURE != bRequest || 1 != wValue ||
++ USB_REQ_TYPE_STANDARD != type) { // QQSV verify type correct
++ TRACE_MSG3(HCD,"ENDPOINT invalid request,val,type r: %02x t: %02x val=%u",
++ bRequest,bmRequestType,wValue);
++ rc = rc_stall;
++ }
++ // Nothing to really do to "clear" the stalled EP.
++ TRACE_MSG2(HCD,"clear endpoint ndx: %02x val: %02x",wIndex,wValue);
++ //printk(KERN_INFO "clear endpoint ndx: %02x val: %02x\n",wIndex,wValue);
++ break;
++ case USB_REQ_RECIPIENT_INTERFACE:
++ default:
++ TRACE_MSG2(HCD,"H->D invalid recipient r: %02x t: %02x",bRequest,bmRequestType);
++ rc = rc_stall;
++ }
++ }
++ else {
++ /* these do require a reply */
++ TRACE_MSG0(HCD,"H<-D");
++ //printk(KERN_INFO "%s: H<-D\n",__FUNCTION__);
++ switch (recipient) {
++ case USB_RECIP_HUB:
++ switch (bRequest) {
++ case USB_REQ_GET_DESCRIPTOR:
++ if (USB_REQ_TYPE_CLASS == type) {
++ // Return the hub class descriptor
++ TRACE_MSG0(HCD,"get hub class descriptor");
++ //printk(KERN_INFO "get hub class descriptor\n");
++ reply = (void *) rh_hcpriv->hd;
++ rlen = rh_hcpriv->hd->bDescLength;
++ }
++ else if (USB_REQ_TYPE_STANDARD != type) {
++ TRACE_MSG2(HCD,"HUB GETDESCRIPTOR invalid type r: %02x t: %02x",bRequest,bmRequestType);
++ rc = rc_stall;
++ }
++ else {
++ // Return one of the other descriptors
++ switch (wValue >> 8) {
++ case USB_DT_DEVICE:
++ TRACE_MSG0(HCD,"get device descriptor");
++ //printk(KERN_INFO "get device descriptor\n");
++ reply = (void *) rh_hcpriv->dd;
++ rlen = rh_hcpriv->dd->bLength;
++ break;
++ case USB_DT_CONFIGURATION:
++ TRACE_MSG0(HCD,"get configuration descriptor");
++ reply = (void *) rh_hcpriv->cd;
++ rlen = USB_DT_CONFIG_SIZE+USB_DT_INTERFACE_SIZE+USB_DT_ENDPOINT_SIZE;
++ break;
++ case USB_DT_STRING:
++ TRACE_MSG1(HCD,"get string descriptor %u",wValue);
++ reply = urb->transfer_buffer;
++ rlen = hcd_rh_string(bus_hcpriv,(wValue & 0xFF),reply,wLength);
++ break;
++ default:
++ TRACE_MSG1(HCD,"HUB GETDESCRIPTOR invalid wValue: %04x",wValue);
++ rc = rc_stall;
++ }
++ }
++ break;
++ case USB_REQ_GET_STATUS:
++ if (USB_REQ_TYPE_CLASS == type) {
++ u32 change_status = bus_hcpriv->rh_hcpriv->hub_change_status;
++ status[0] = cpu_to_le16(change_status & 0xFFFF);
++ status[1] = cpu_to_le16(change_status >> 16);
++ reply = (void *) &status[0];
++ rlen = 4;
++ TRACE_MSG1(HCD,"GET HUB_CHANGE_STATUS: %08x", bus_hcpriv->rh_hcpriv->hub_change_status);
++ }
++ else {
++ TRACE_MSG2(HCD,"HUB GETSTATUS invalid type r: %02x t: %02x",bRequest,bmRequestType);
++ rc = rc_stall;
++ }
++ break;
++ case USB_REQ_GET_INTERFACE:
++ // FIXME Verify type and interface number (wIndex)
++ TRACE_MSG1(HCD,"get interface %u",wIndex);
++ reply = (void *) &rh_hcpriv->curr_itf;
++ rlen = 1;
++ break;
++ case USB_REQ_GET_CONFIGURATION:
++ // FIXME Verify type
++ TRACE_MSG0(HCD,"get configuration");
++ // Return a single byte value
++ reply = (void *) &rh_hcpriv->curr_cfg;
++ rlen = 1;
++ break;
++ default:
++ TRACE_MSG2(HCD,"H<-D HUB invalid request r: %02x t: %02x",bRequest,bmRequestType);
++ rc = rc_stall;
++ }
++ break;
++ case USB_RECIP_PORT:
++ switch (bRequest) {
++ case USB_REQ_GET_STATUS:
++ if (USB_REQ_TYPE_CLASS == type) {
++ /* USB2.0 11.24.2.7 pg 426 says first hword of reply are status (Tbl 11-21),
++ second hword is change (Tbl 11-22). */
++ u32 change_status = ((wIndex -1) < bus_hcpriv->num_ports) ?
++ bus_hcpriv->rh_hcpriv->port_change_status[wIndex-1] : 0;
++ u32 hw_change_status = ((wIndex -1) < bus_hcpriv->num_ports) ?
++ rh_get_port_change_status(bus_hcpriv, wIndex) : 0;
++
++ check_port_status(bus_hcpriv, wIndex, "HOST POLL");
++
++ status[0] = cpu_to_le16(hw_change_status & 0xFFFF);
++ status[1] = cpu_to_le16(change_status >> 16);
++ reply = (void *) &status[0];
++ rlen = 4;
++
++ TRACE_MSG3(HCD,"GET PORT_CHANGE_STATUS[%2d] %04x %04x", wIndex, status[0], status[1]);
++ }
++ else {
++ TRACE_MSG2(HCD,"PORT GETSTATUS invalid type r: %02x t: %02x",bRequest,bmRequestType);
++ rc = rc_stall;
++ }
++ break;
++ default:
++ TRACE_MSG2(HCD,"H<-D PORT invalid request r: %02x t: %02x",bRequest,bmRequestType);
++ rc = rc_stall;
++ }
++ break;
++ case USB_REQ_RECIPIENT_INTERFACE:
++ case USB_REQ_RECIPIENT_ENDPOINT:
++ default:
++ TRACE_MSG2(HCD,"H<-D invalid recipient r: %02x t: %02x",bRequest,bmRequestType);
++ rc = rc_stall;
++ }
++ if (!rc && reply) {
++ // There is a reply to copy into place.
++ if (rlen > wLength) {
++ // Truncate the reply (used to get part of a descriptor).
++ rlen = wLength;
++ }
++ if (rlen > 0 && reply != urb->transfer_buffer) {
++ memcpy(urb->transfer_buffer,reply,rlen);
++ }
++ urb->actual_length = rlen;
++ }
++ }
++ // All done, "complete" it.
++ urb->status = rc;
++ TRACE_MSG3(HCD,"urb: %08lx completing status=%d len=%d",urb,urb->status,urb->actual_length);
++ hcd_rh_urb_complete(bus_hcpriv,urb);
++ TRACE_MSG2(HCD,"urb: %08lx completed->%d",urb,rc);
++ return rc;
++}
++
++/*
++ * hcd_rh_unlink_urb()
++ */
++int hcd_rh_unlink_urb(struct bus_hcpriv *bus_hcpriv, struct urb *urb)
++{
++ struct rh_hcpriv *rh_hcpriv = bus_hcpriv->rh_hcpriv;
++ RETURN_EINVAL_UNLESS(urb && (urb == rh_hcpriv->int_urb));
++ del_timer(&rh_hcpriv->poll_timer);
++ rh_hcpriv->int_urb = NULL;
++ urb->status = -ENOENT; // Cancelled
++ hcd_rh_urb_complete(bus_hcpriv,urb);
++ usb_put_urb(urb);
++ return 0;
++}
++/* ********************************************************************************************** */
++/*
++ * For the hardware specific root hub component.
++ */
++irqreturn_t hcd_rh_int_hndlr(int irq, void *dev_id, struct pt_regs *regs)
++{
++ struct bus_hcpriv *bus_hcpriv = (struct bus_hcpriv *) dev_id;
++
++ // Assume port status change.
++ //printk(KERN_INFO "%s: scheduling hcd_rh_portstatus_bh\n",__FUNCTION__);
++
++ PREPARE_WORK_ITEM(bus_hcpriv->rh_hcpriv->psc_bh, hcd_rh_portstatus_bh, bus_hcpriv);
++ SCHEDULE_WORK(bus_hcpriv->rh_hcpriv->psc_bh);
++ return IRQ_HANDLED;
++}
++/* ********************************************************************************************** */
++#if !defined(OTG_C99)
++struct usbd_device_descriptor rh_device_descriptor;
++struct usbd_configuration_descriptor rh_configuration_descriptor;
++struct usbd_interface_descriptor rh_interface_descriptor;
++struct usbd_endpoint_descriptor rh_endpoint_descriptor;
++struct hub_descriptor rh_hub_descriptor;
++
++void rh_global_init(void)
++{
++ ZERO(rh_device_descriptor);
++ rh_device_descriptor.bLength = USB_DT_DEVICE_SIZE;
++ rh_device_descriptor.bDescriptorType = USB_DT_DEVICE;
++ rh_device_descriptor.bcdUSB = __constant_cpu_to_le16(USB_BCD_VERSION);
++ rh_device_descriptor.bDeviceClass = USB_CLASS_HUB;
++ rh_device_descriptor.bDeviceSubClass = 0;
++ rh_device_descriptor.bDeviceProtocol = 0;
++ rh_device_descriptor.bMaxPacketSize0 = 8;
++ rh_device_descriptor.iManufacturer = XHC_RH_STRING_MANUFACTURER;
++ rh_device_descriptor.iProduct = XHC_RH_STRING_PRODUCT;
++ rh_device_descriptor.iSerialNumber = XHC_RH_STRING_SERIAL;
++ rh_device_descriptor.bNumConfigurations = 1;
++
++ ZERO(rh_configuration_descriptor);
++ rh_configuration_descriptor.bLength = USB_DT_CONFIG_SIZE;
++ rh_configuration_descriptor.bDescriptorType = USB_DT_CONFIGURATION;
++ rh_configuration_descriptor.wTotalLength = __constant_cpu_to_le16(USB_DT_CONFIG_SIZE+USB_DT_INTERFACE_SIZE
++ + USB_DT_ENDPOINT_SIZE);
++ rh_configuration_descriptor.bNumInterfaces = 1;
++ rh_configuration_descriptor.bConfigurationValue = 1;
++ rh_configuration_descriptor.iConfiguration = XHC_RH_STRING_CONFIGURATION;
++
++ ZERO(rh_interface_descriptor);
++ rh_interface_descriptor.bLength = USB_DT_INTERFACE_SIZE;
++ rh_interface_descriptor.bDescriptorType = USB_DT_INTERFACE;
++ rh_interface_descriptor.bInterfaceNumber = 0;
++ rh_interface_descriptor.bAlternateSetting = 0;
++ rh_interface_descriptor.bNumEndpoints = 1;
++ rh_interface_descriptor.bInterfaceClass = USB_CLASS_HUB;
++ rh_interface_descriptor.bInterfaceSubClass = 0;
++ rh_interface_descriptor.bInterfaceProtocol = 0;
++ rh_interface_descriptor.iInterface = XHC_RH_STRING_INTERFACE;
++
++ ZERO(rh_endpoint_descriptor);
++ rh_endpoint_descriptor.bLength = USB_DT_ENDPOINT_SIZE;
++ rh_endpoint_descriptor.bDescriptorType = USB_DT_ENDPOINT;
++ rh_endpoint_descriptor.bEndpointAddress = USB_DIR_IN | 1; // Fixed EP 1
++ rh_endpoint_descriptor.bmAttributes = INTERRUPT;
++ rh_endpoint_descriptor.wMaxPacketSize = __constant_cpu_to_le16(4);
++ rh_endpoint_descriptor.bInterval = 0xFF;
++
++ ZERO(rh_hub_descriptor);
++ rh_hub_descriptor.bDescLength = USB_DT_HUB_NONVAR_SIZE+2;
++ rh_hub_descriptor.bDescriptorType = USB_DT_HUB;
++};
++
++#else /* !defined(OTG_C99) */
++struct usbd_device_descriptor rh_device_descriptor = {
++ .bLength = USB_DT_DEVICE_SIZE,
++ .bDescriptorType = USB_DT_DEVICE,
++ .bcdUSB = __constant_cpu_to_le16(USB_BCD_VERSION),
++ .bDeviceClass = USB_CLASS_HUB,
++ .bDeviceSubClass = 0,
++ .bDeviceProtocol = 0,
++ .bMaxPacketSize0 = 8,
++ .iManufacturer = XHC_RH_STRING_MANUFACTURER,
++ .iProduct = XHC_RH_STRING_PRODUCT,
++ .iSerialNumber = XHC_RH_STRING_SERIAL,
++ .bNumConfigurations = 1,
++};
++
++struct usbd_configuration_descriptor rh_configuration_descriptor = {
++ .bLength = USB_DT_CONFIG_SIZE,
++ .bDescriptorType = USB_DT_CONFIGURATION,
++ .wTotalLength = __constant_cpu_to_le16(USB_DT_CONFIG_SIZE+USB_DT_INTERFACE_SIZE+USB_DT_ENDPOINT_SIZE),
++ .bNumInterfaces = 1,
++ .bConfigurationValue = 1,
++ .iConfiguration = XHC_RH_STRING_CONFIGURATION,
++};
++
++struct usbd_interface_descriptor rh_interface_descriptor = {
++ .bLength = USB_DT_INTERFACE_SIZE,
++ .bDescriptorType = USB_DT_INTERFACE,
++ .bInterfaceNumber = 0,
++ .bAlternateSetting = 0,
++ .bNumEndpoints = 1,
++ .bInterfaceClass = USB_CLASS_HUB,
++ .bInterfaceSubClass = 0,
++ .bInterfaceProtocol = 0,
++ .iInterface = XHC_RH_STRING_INTERFACE,
++};
++
++struct usbd_endpoint_descriptor rh_endpoint_descriptor = {
++ .bLength = USB_DT_ENDPOINT_SIZE,
++ .bDescriptorType = USB_DT_ENDPOINT,
++ .bEndpointAddress = USB_DIR_IN | 1, // Fixed EP 1
++ .bmAttributes = INTERRUPT,
++ .wMaxPacketSize = __constant_cpu_to_le16(4),
++ .bInterval = 0xFF,
++};
++
++/* This assumes 1-8 ports.
++ * If ports > 8, then DeviceRemovable and PortPwrCtrlMask need to be sized accordingly.
++ */
++struct hub_descriptor rh_hub_descriptor = {
++ .bDescLength = USB_DT_HUB_NONVAR_SIZE+2,
++ .bDescriptorType = USB_DT_HUB,
++};
++#endif /* !defined(OTG_C99) */
++
++/* ********************************************************************************************** */
++/*
++ * Copy static descriptors to buffer to allow modification for actual
++ * configuration and provide full configuration descriptor.
++ */
++STATIC void build_descriptors(struct bus_hcpriv *bus_hcpriv)
++{
++ struct rh_hcpriv *rh_hcpriv = bus_hcpriv->rh_hcpriv;
++ void *bp = rh_hcpriv->descriptors;
++
++
++ rh_hcpriv->dd = (struct usbd_device_descriptor *) bp;
++ memcpy(bp, &rh_device_descriptor, sizeof(rh_device_descriptor));
++ rh_hcpriv->cd = (struct usbd_configuration_descriptor *) bp = bp + USB_DT_DEVICE_SIZE;
++ memcpy(bp, &rh_configuration_descriptor, sizeof(rh_configuration_descriptor));
++ rh_hcpriv->id = (struct usbd_interface_descriptor *) bp = bp + USB_DT_CONFIG_SIZE;
++ memcpy(bp, &rh_interface_descriptor, sizeof(rh_interface_descriptor));
++ rh_hcpriv->ed = (struct usbd_endpoint_descriptor *) bp = bp + USB_DT_INTERFACE_SIZE;
++ memcpy(bp, &rh_endpoint_descriptor, sizeof(rh_endpoint_descriptor));
++ rh_hcpriv->hd = (struct hub_descriptor *) bp = bp + USB_DT_ENDPOINT_SIZE;
++ memcpy(bp, &rh_hub_descriptor, sizeof(rh_hub_descriptor));
++
++ rh_hcpriv->dd->idVendor = cpu_to_le16(bus_hcpriv->rh_vendorid);
++ rh_hcpriv->dd->idProduct = cpu_to_le16(bus_hcpriv->rh_productid);
++ rh_hcpriv->dd->bcdDevice = cpu_to_le16(bus_hcpriv->rh_bcddevice);
++ rh_hcpriv->cd->bmAttributes = bus_hcpriv->rh_bmAttributes;
++ rh_hcpriv->cd->bMaxPower = bus_hcpriv->rh_bMaxPower;
++ rh_hcpriv->hd->bNbrPorts = bus_hcpriv->num_ports,
++ rh_hcpriv->hd->wHubCharacteristics = cpu_to_le16(hcd_hw_rh_hub_attributes(bus_hcpriv));
++ rh_hcpriv->hd->bPwrOn2PwrGood = hcd_hw_rh_power_delay(bus_hcpriv);
++ rh_hcpriv->hd->bHubContrCurrent = hcd_hw_rh_hub_contr_current(bus_hcpriv);
++ rh_hcpriv->hd->DeviceRemovable = hcd_hw_rh_DeviceRemovable(bus_hcpriv);
++ rh_hcpriv->hd->PortPwrCtrlMask = hcd_hw_rh_PortPwrCtrlMask(bus_hcpriv);
++}
++
++/* ********************************************************************************************** */
++
++#define PORT_SYNC_MASK ( (1 << PORT_POWER) | (1 << PORT_SUSPEND) | (1 << PORT_RESET) )
++
++/* puts OTG capable port into a_host or b_host state - attempt to use port */
++void rh_loc_sof_func(struct otg_instance *otg, u8 on)
++{
++ struct bus_hcpriv *bus_hcpriv = (struct bus_hcpriv *)(((struct hcd_instance *)(otg->hcd))->privdata);
++ int i;
++ unsigned long flags;
++
++ RETURN_UNLESS (bus_hcpriv && bus_hcpriv->rh_hcpriv && bus_hcpriv->rh_hcpriv->port_change_status);
++
++ local_irq_save(flags);
++ switch (on) {
++ case SET:
++ //printk(KERN_INFO"%s: SET\n", __FUNCTION__);
++ TRACE_MSG0(HCD, "RH LOC_SOF SET");
++
++ // Stop treating otg capable port as a device
++ bus_hcpriv->rh_hcpriv->otg_device_mask &= ~(0x1 << (bus_hcpriv->otg_port));
++
++ /* Sync the state of the HW to the shadow values, because
++ * the root hub was registered with usbcore a while back, and
++ * at the very least it probably tried to turn on the power,
++ * and until now, the otg_device_mask was preventing that.
++ */
++ for (i = 0; i < 16; i++) {
++
++ if (PORT_SYNC_MASK & (0x1 << i) & bus_hcpriv->rh_hcpriv->port_change_status[bus_hcpriv->otg_port - 1]) {
++ hcd_hw_rh_port_feature(bus_hcpriv, i, bus_hcpriv->otg_port, TRUE);
++ check_port_status(bus_hcpriv, bus_hcpriv->otg_port, "OTG EN");
++ }
++ }
++
++ /* "Connect" on OTG port and simulate a port status change interrupt
++ */
++ bus_hcpriv->rh_hcpriv->port_change_status[bus_hcpriv->otg_port - 1] |= 0x00010001;
++ TRACE_MSG2(HCD, "OUTPUT: RH LOC_SOF_SET port_change_status[%d]: %08x",
++ bus_hcpriv->otg_port, bus_hcpriv->rh_hcpriv->port_change_status[bus_hcpriv->otg_port - 1]);
++ check_port_status(bus_hcpriv, bus_hcpriv->otg_port, "SOF SET");
++ break;
++
++ case RESET:
++ //printk(KERN_INFO"%s: RESET\n", __FUNCTION__);
++ TRACE_MSG0(HCD, "RH LOC_SOF RESET");
++
++ check_port_status(bus_hcpriv, bus_hcpriv->otg_port, "SOF RESET - BEFORE");
++
++ // "Disconnect" on OTG port and simulate a port status change interrupt
++ bus_hcpriv->rh_hcpriv->port_change_status[bus_hcpriv->otg_port - 1] &= ~0x00000001;
++ bus_hcpriv->rh_hcpriv->port_change_status[bus_hcpriv->otg_port - 1] |= 0x00010000;
++ TRACE_MSG2(HCD, "OUTPUT: RH LOC_SOF_RESET port_change_status[%d]: %08x",
++ bus_hcpriv->otg_port, bus_hcpriv->rh_hcpriv->port_change_status[bus_hcpriv->otg_port - 1]);
++
++
++ // Turn off port power.
++ hcd_hw_rh_port_feature(bus_hcpriv, PORT_POWER, bus_hcpriv->otg_port, FALSE);
++ //hcd_hw_rh_port_feature(bus_hcpriv, PORT_ENABLE, bus_hcpriv->otg_port, FALSE);
++
++ check_port_status(bus_hcpriv, bus_hcpriv->otg_port, "SOF RESET - AFTER");
++
++ // Start treating otg capable port as a device
++ bus_hcpriv->rh_hcpriv->otg_device_mask |= (0x1 << (bus_hcpriv->otg_port));
++ break;
++ }
++
++ bus_hcpriv->rh_hcpriv->hub_port_change_status |= (1 << bus_hcpriv->otg_port);
++ TRACE_MSG0(HCD, "Schedule hcd_rh_portstatus_bh");
++ PREPARE_WORK_ITEM(bus_hcpriv->rh_hcpriv->psc_bh, hcd_rh_portstatus_bh, bus_hcpriv);
++ SCHEDULE_WORK(bus_hcpriv->rh_hcpriv->psc_bh);
++ local_irq_restore(flags);
++}
++
++/* puts OTG capable port into a_host or b_host state - attempt to use port */
++void rh_loc_suspend_func(struct otg_instance *otg, u8 on)
++{
++ struct bus_hcpriv *bus_hcpriv = (struct bus_hcpriv *)(((struct hcd_instance *)(otg->hcd))->privdata);
++ struct rh_hcpriv *rh_hcpriv = bus_hcpriv->rh_hcpriv;
++ int i;
++ unsigned long flags;
++
++ //printk(KERN_INFO"%s: \n", __FUNCTION__);
++ RETURN_UNLESS (bus_hcpriv && bus_hcpriv->rh_hcpriv && bus_hcpriv->rh_hcpriv->port_change_status);
++
++ local_irq_save(flags);
++ switch (on) {
++ case SET:
++ TRACE_MSG0(HCD, "OUTPUT: RH LOC_SUSPEND SET");
++
++ rh_hcpriv->suspended = 1;
++
++ // suspend
++ hcd_hw_rh_port_feature(bus_hcpriv, PORT_SUSPEND, bus_hcpriv->otg_port, TRUE);
++
++ // "Connect" on OTG port and simulate a port status change interrupt
++ bus_hcpriv->rh_hcpriv->port_change_status[bus_hcpriv->otg_port - 1] |= 0x00040004;
++ TRACE_MSG2(HCD, "OUTPUT: RH LOC_SUSPNED_SET port_change_status[%d]: %08x",
++ bus_hcpriv->otg_port, bus_hcpriv->rh_hcpriv->port_change_status[bus_hcpriv->otg_port - 1]);
++ check_port_status(bus_hcpriv, bus_hcpriv->otg_port, "LOC_SUSPEND SET");
++ break;
++
++ case RESET:
++
++ TRACE_MSG0(HCD, "OUTPUT: RH LOC_SUSPEND RESET");
++ check_port_status(bus_hcpriv, bus_hcpriv->otg_port, "LOC_SUSPEND RESET - BEFORE");
++
++ // "Disconnect" on OTG port and simulate a port status change interrupt
++ bus_hcpriv->rh_hcpriv->port_change_status[bus_hcpriv->otg_port - 1] &= ~0x00000004;
++ bus_hcpriv->rh_hcpriv->port_change_status[bus_hcpriv->otg_port - 1] |= 0x00040000;
++ TRACE_MSG2(HCD, "OUTPUT: RH LOC_SUSPEND port_change_status[%d]: %08x",
++ bus_hcpriv->otg_port, bus_hcpriv->rh_hcpriv->port_change_status[bus_hcpriv->otg_port - 1]);
++
++
++ // suspend
++ hcd_hw_rh_port_feature(bus_hcpriv, PORT_SUSPEND, bus_hcpriv->otg_port, FALSE);
++ check_port_status(bus_hcpriv, bus_hcpriv->otg_port, "SOF RESET - AFTER");
++
++ rh_hcpriv->suspended = 0;
++
++ break;
++ }
++
++ bus_hcpriv->rh_hcpriv->hub_port_change_status |= (1 << bus_hcpriv->otg_port);
++ TRACE_MSG0(HCD, "Schedule hcd_rh_portstatus_bh");
++ PREPARE_WORK_ITEM(bus_hcpriv->rh_hcpriv->psc_bh, hcd_rh_portstatus_bh, bus_hcpriv);
++ SCHEDULE_WORK(bus_hcpriv->rh_hcpriv->psc_bh);
++ local_irq_restore(flags);
++}
++
++void rh_suspend_func(struct otg_instance *otg, u8 flag)
++{
++ /* suspends the OTG capable port */
++ //TRACE_MSG0(HCD, "--");
++ switch (flag) {
++ case SET:
++ //printk(KERN_INFO"%s: SET\n", __FUNCTION__);
++ TRACE_MSG0(HCD, "OUTPUT: RH SUSPEND_SET");
++ break;
++ case RESET:
++ //printk(KERN_INFO"%s: RESET\n", __FUNCTION__);
++ TRACE_MSG0(HCD, "OUTPUT: RH SUSPEND_RESET");
++ break;
++ }
++}
++
++/* ********************************************************************************************* */
++
++int hcd_rh_init(struct bus_hcpriv *bus_hcpriv)
++{
++ struct rh_hcpriv *rh_hcpriv;
++ int wIndex;
++ int port_mask;
++
++ #if !defined(OTG_C99)
++ rh_global_init();
++ #endif /* !defined(OTG_C99) */
++
++ //printk(KERN_INFO"%s: \n", __FUNCTION__);
++ RETURN_ZERO_UNLESS (bus_hcpriv);
++ RETURN_ENOMEM_UNLESS ((rh_hcpriv = bus_hcpriv->rh_hcpriv =
++ (struct rh_hcpriv *) kmalloc(sizeof(struct rh_hcpriv),GFP_KERNEL)));
++ memset(rh_hcpriv, 0, sizeof(struct rh_hcpriv));
++
++ //printk(KERN_INFO "%s: rh_hcpriv: %08x\n",__FUNCTION__,(u32)(void*)rh_hcpriv);
++ //init_timer(&rh_hcpriv->poll_timer);
++ // Get the number of ports, and which port is OTG capable.
++
++ //rh_hcpriv->num_ports = hcd_hw_rh_num_ports(bus_hcpriv);
++
++ // Allocate the shadow port_change_status array.
++ UNLESS ((rh_hcpriv->port_change_status = (u32 *) kmalloc((bus_hcpriv->num_ports*sizeof(u32)),GFP_KERNEL))) {
++ //printk(KERN_ERR "%s: allocation of root hub shadow port data fails\n",__FUNCTION__);
++ kfree(rh_hcpriv);
++ bus_hcpriv->rh_hcpriv = rh_hcpriv = NULL;
++ return -ENOMEM;
++ }
++ memset(rh_hcpriv->port_change_status,0,(bus_hcpriv->num_ports*sizeof(u32)));
++ UNLESS ((rh_hcpriv->dev = usb_alloc_dev(NULL, bus_hcpriv->usb_bus, 0))) {
++ //printk(KERN_ERR "%s: allocation of root hub dev fails\n",__FUNCTION__);
++ kfree(rh_hcpriv->port_change_status);
++ rh_hcpriv->port_change_status = NULL;
++ kfree(rh_hcpriv);
++ bus_hcpriv->rh_hcpriv = rh_hcpriv = NULL;
++ return -ENOMEM;
++ }
++ rh_hcpriv->dev->speed = USB_SPEED_FULL; // QQSV --- this belongs in the HW dependent portion...
++
++ // Build up USB descriptors
++ build_descriptors(bus_hcpriv);
++
++ // Leave OTG capable port as disabled as possible until OTG core enables it.
++ rh_hcpriv->otg_device_mask = bus_hcpriv->otg_capable_mask;
++
++ for (wIndex = 1; wIndex <= bus_hcpriv->num_ports; wIndex++) {
++ port_mask = (1 << (wIndex - 1));
++ if (port_mask & bus_hcpriv->otg_capable_mask)
++ TRACE_MSG1(HCD,"OTG capable port %d", wIndex);
++ else
++ TRACE_MSG1(HCD,"Standard port %d", wIndex);
++ }
++ return 0;
++}
++
++void hcd_rh_exit(struct bus_hcpriv *bus_hcpriv)
++{
++ struct rh_hcpriv *rh_hcpriv;
++ RETURN_UNLESS(bus_hcpriv && (rh_hcpriv = bus_hcpriv->rh_hcpriv));
++
++ (void *) hcd_rh_unlink_urb(bus_hcpriv,rh_hcpriv->int_urb);
++
++ if (rh_hcpriv->dev) {
++ usb_put_dev(rh_hcpriv->dev);
++ rh_hcpriv->dev = NULL;
++ }
++ if (rh_hcpriv->port_change_status) {
++ kfree(rh_hcpriv->port_change_status);
++ rh_hcpriv->port_change_status = NULL;
++ }
++ kfree(rh_hcpriv);
++ bus_hcpriv->rh_hcpriv = rh_hcpriv = NULL;
++}
++
+diff -uNr linux/drivers/no-otg/ocd/otg-hcd/hcd.c linux/drivers/otg/ocd/otg-hcd/hcd.c
+--- linux/drivers/no-otg/ocd/otg-hcd/hcd.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/otg-hcd/hcd.c 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,139 @@
++/*
++ * otg/ocd/otg-hcd/hcd.c - OTG Host Controller Driver
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcara.com>,
++ * Tom Rushworth <tbr@belcara.com>,
++ * Bruce Balden <balden@belcara.com>
++ *
++ * 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.
++ *
++ */
++/*!
++ * @file otg/ocd/otg-hcd/hcd.c
++ * @brief Root Hub for Generic Host Controller Driver
++ *
++ *
++ * This file initializes the low level hardware drivers.
++ *
++ * This is the linux 2.4 version.
++ *
++ * @ingroup OTGHCD
++ */
++
++#include <otg/otg-compat.h>
++
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-bus.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-tcd.h>
++#include <otg/otg-hcd.h>
++#include <otg/otg-pcd.h>
++
++/* ************************************************************************************* */
++
++void hcd_en_func (struct otg_instance *otg, u8 flag)
++{
++ //struct hcd_instance *hcd = otg->hcd;
++ TRACE_MSG0(HCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(HCD, "OUTPUT: HCD_EN_SET");
++ break;
++ case RESET:
++ TRACE_MSG0(HCD, "OUTPUT: HCD_EN_RESET");
++ break;
++ }
++}
++
++void hcd_init_func (struct otg_instance *otg, u8 flag)
++{
++ struct hcd_instance *hcd = otg->hcd;
++
++ TRACE_MSG0(HCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(HCD, "OUTPUT: HCD_INIT_SET");
++ otg_event(hcd->otg, HCD_OK, HCD, "HCD_INIT SET HCD_OK");
++ break;
++ case RESET:
++ TRACE_MSG0(HCD, "OUTPUT: HCD_INIT_RESET");
++ otg_event(hcd->otg, HCD_OK, HCD, "HCD_INIT SET HCD_OK");
++ break;
++ }
++}
++
++/* ************************************************************************************* */
++
++void hcd_loc_sof_func (struct otg_instance *otg, u8 flag)
++{
++ //struct hcd_instance *hcd = otg->hcd;
++ TRACE_MSG0(HCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(HCD, "OUTPUT: HCD_LOC_SOF_SET");
++ break;
++ case RESET:
++ TRACE_MSG0(HCD, "OUTPUT: HCD_LOC_SOF_RESET");
++ break;
++ }
++}
++
++void hcd_suspend_func (struct otg_instance *otg, u8 flag)
++{
++ //struct hcd_instance *hcd = otg->hcd;
++ TRACE_MSG0(HCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(HCD, "OUTPUT: HCD_SUSPEND_EN_SET");
++ break;
++ case RESET:
++ TRACE_MSG0(HCD, "OUTPUT: HCD_SUSPEND_EN_RESET");
++ break;
++ }
++}
++
++void hcd_remote_wakeup_en_func (struct otg_instance *otg, u8 flag)
++{
++ //struct hcd_instance *hcd = otg->hcd;
++ TRACE_MSG0(HCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(HCD, "OUTPUT: HCD_REMOTE_WAKEUP_EN_SET");
++ break;
++ case RESET:
++ TRACE_MSG0(HCD, "OUTPUT: HCD_REMOTE_WAKEUP_EN_RESET");
++ break;
++ }
++}
++
++void hcd_hnp_en_func (struct otg_instance *otg, u8 flag)
++{
++ //struct hcd_instance *hcd = otg->hcd;
++ TRACE_MSG0(HCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(HCD, "OUTPUT: HCD_HNP_EN_SET");
++ break;
++ case RESET:
++ TRACE_MSG0(HCD, "OUTPUT: HCD_HNP_EN_RESET");
++ break;
++ }
++}
++
++
+diff -uNr linux/drivers/no-otg/ocd/otg-i2c/i2c-l26.c linux/drivers/otg/ocd/otg-i2c/i2c-l26.c
+--- linux/drivers/no-otg/ocd/otg-i2c/i2c-l26.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/otg-i2c/i2c-l26.c 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,160 @@
++/*
++ * otg/ocd/otg-i2c/i2c-l26.c -- Linux 2.6 I2C access
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/ocd/otg-i2c/i2c-l26.c
++ * @brief Linux I2C I/O via generic i2c device.
++ *
++ * @ingroup ISP1301TCD
++ */
++
++#include <otg/otg-compat.h>
++
++#include <asm/irq.h>
++#include <asm/system.h>
++#include <asm/io.h>
++#include <linux/i2c.h>
++
++#include <otg/pcd-include.h>
++#include <linux/pci.h>
++#include <otghw/isp1301-hardware.h>
++#include "isp1301.h"
++
++/* ********************************************************************************************* */
++
++/*
++ * N.B. i2c functions must not be called from interrupt handlers
++ */
++
++static struct file *i2c_file;
++static struct i2c_client *omap_i2c_client;
++static int initstate_i2c;
++static int initstate_region;
++#define MAX_I2C 16
++
++#ifdef CONFIG_OMAP_H2
++#define ADAPTOR_NAME "OMAP I2C"
++#endif /* CONFIG_OMAP_H2 */
++#ifdef CONFIG_ARCH_MAINSTONE
++#define ADAPTOR_NAME "PXA-I2C-Adapter"
++#endif /* CONFIG_ARCH_MAINSTONE */
++
++/*! i2c_configure
++ * Attempt to find and open generic i2c device
++ * @return - non-zero for failure
++ */
++int i2c_configure(char *name, int addr)
++{
++ char filename[20];
++ int tmp;
++
++ RETURN_ZERO_IF(initstate_i2c);
++
++ /*find the I2C driver we need
++ */
++ for (tmp = 0; tmp < MAX_I2C; tmp++) {
++
++ sprintf(filename, "/dev/i2c/%d", tmp);
++
++ printk(KERN_INFO"%s: %s\n", __FUNCTION__, filename);
++
++ UNLESS (IS_ERR(i2c_file = filp_open(filename, O_RDWR, 0))) {
++
++ //printk(KERN_INFO"%s: %s found\n", __FUNCTION__, filename);
++
++ /*found some driver */
++ omap_i2c_client = (struct i2c_client *)i2c_file->private_data;
++
++ printk(KERN_INFO"%s: found %s\n", __FUNCTION__, omap_i2c_client->adapter->name);
++ if (strlen(omap_i2c_client->adapter->name) >= 8) {
++ if (!strncmp(omap_i2c_client->adapter->name, name, strlen(name)))
++ break; /*we found our driver! */
++ }
++ omap_i2c_client = NULL;
++ filp_close(i2c_file, NULL);
++ }
++ printk(KERN_INFO"%s: %s %d\n", __FUNCTION__, filename, i2c_file);
++ }
++ if (tmp == MAX_I2C) { // Nothing found
++ printk(KERN_ERR"%s: cannot find I2C driver", __FUNCTION__);
++ return -ENODEV;
++ }
++ omap_i2c_client->addr = addr;
++ initstate_i2c = 1;
++ return 0;
++}
++
++/*! i2c_close
++ * Close i2c device fd.
++ */
++void i2c_close(void)
++{
++ if (initstate_i2c)
++ filp_close(i2c_file, NULL);
++ initstate_i2c = 0;
++}
++
++/*! i2c_readb
++ * Read byte from i2c device
++ * @param subaddr
++ */
++u8 i2c_readb(u8 subaddr)
++{
++ u8 buf = 0;
++ i2c_master_send(omap_i2c_client, &subaddr, 1);
++ i2c_master_recv(omap_i2c_client, &buf, 1);
++ TRACE_MSG2(TCD, "addr: %02x buf: %02x", subaddr, buf);
++ return buf;
++}
++
++/*! i2c_readw
++ * Read word from i2c device
++ * @param subaddr
++ */
++u16 i2c_readw(u8 subaddr)
++{
++ u16 buf = 0;
++ i2c_master_send(omap_i2c_client, &subaddr, 1);
++ i2c_master_recv(omap_i2c_client, (u8 *)&buf, 2);
++ TRACE_MSG2(TCD, "addr: %02x buf: %04x", subaddr, buf);
++ return buf;
++}
++
++/*! i2c_readl
++ * Read long from i2c device
++ * @param subaddr
++ */
++u32 i2c_readl(u8 subaddr)
++{
++ u32 buf = 0;
++ i2c_master_send(omap_i2c_client, &subaddr, 1);
++ i2c_master_recv(omap_i2c_client, (u8 *)&buf, 4);
++ TRACE_MSG2(TCD, "addr: %02x buf: %08x", subaddr, buf);
++ return buf;
++}
++
++
++/*! i2c_writeb
++ * Writw byte to i2c device
++ * @param subaddr
++ * @param buf
++ */
++int i2c_writeb(u8 subaddr, u8 buf)
++{
++ char tmpbuf[2];
++
++ tmpbuf[0] = subaddr; /*register number */
++ tmpbuf[1] = buf; /*register data */
++ i2c_master_send(omap_i2c_client, &tmpbuf[0], 2);
++
++ return 0;
++}
++
+diff -uNr linux/drivers/no-otg/ocd/otg-pcd/pcd-init-l24.c linux/drivers/otg/ocd/otg-pcd/pcd-init-l24.c
+--- linux/drivers/no-otg/ocd/otg-pcd/pcd-init-l24.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/otg-pcd/pcd-init-l24.c 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,119 @@
++/*
++ * otg/ocd/otg-pcd/pcd-init-l24.c - OTG Peripheral Controller Driver Module Initialization
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/ocd/otg-pcd/pcd-init-l24.c
++ * @brief PCD only driver init.
++ *
++ *
++ * PCD Initialization
++ *
++ * This file initializes all of the low level hardware drivers for a PCD.
++ *
++ * The Peripheral Controller Driver (pcd) implements the lowest layer of the
++ * USBD stack to send and receive data from the USB actings as a USB
++ * peripheral.
++ *
++ * Notes
++ *
++ * 1. This is the linux 2.4 version.
++ *
++ * TODO
++ *
++ * 1. hook up serial_number_str to pcd.c for use with bus interface layer.
++ *
++ *
++ * @ingroup OTGPCD
++ */
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/otg-module.h>
++#include <otg/usbp-bus.h>
++
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-tcd.h>
++#include <otg/otg-hcd.h>
++#include <otg/otg-pcd.h>
++
++#ifdef MODULE
++#if LINUX_VERSION_CODE >= KERNEL_VERSION (2,4,17)
++MODULE_LICENSE ("GPL");
++#endif
++MODULE_PARM (serial_number_str, "s");
++MODULE_PARM_DESC (serial_number_str, "Serial Number");
++MODULE_AUTHOR ("sl@belcarra.com, tbr@belcarra.com");
++MODULE_DESCRIPTION ("USB On-The-Go PCD");
++#endif
++char *serial_number_str;
++
++otg_tag_t PCD;
++struct pcd_instance *pcd_instance;
++
++/* ************************************************************************************* */
++
++/* pcd_modexit - module exit or init failure cleanup
++ *
++ * Specifically for each driver:
++ *
++ * call ops.mod_exit
++ * reset instance address and ops table address in state machine to NULL
++ * invalidate tag
++ */
++static void pcd_modexit (void)
++{
++ struct otg_instance *otg = ocd_instance->otg;
++ printk(KERN_INFO"%s\n", __FUNCTION__);
++ if (otg)
++ otg_exit(otg);
++ if (pcd_ops.mod_exit) pcd_ops.mod_exit();
++ pcd_instance = otg_set_pcd_ops(NULL);
++ PCD = otg_trace_invalidate_tag(PCD);
++}
++
++/* pcd_modinit - linux module initialization
++ *
++ * This needs to initialize the ocd, pcd and tcd drivers.
++ *
++ * Specifically for each driver:
++ *
++ * obtain tag
++ * pass ops table address to state machine and get instance address
++ * call ops.mod_init
++ *
++ * Note that we automatically provide a default tcd_init if
++ * none is set.
++ */
++static int pcd_modinit (void)
++{
++ printk(KERN_INFO"%s\n", __FUNCTION__);
++
++ #if !defined(OTG_C99)
++ pcd_global_init();
++ #endif /* !defined(OTG_C99) */
++
++ PCD = otg_trace_obtain_tag();
++
++ UNLESS(pcd_ops.pcd_init_func) pcd_ops.pcd_init_func = pcd_init_func;
++ THROW_UNLESS(pcd_instance = otg_set_pcd_ops(&pcd_ops), error);
++ THROW_IF((pcd_ops.mod_init) ? pcd_ops.mod_init() : 0, error);
++
++ CATCH(error) {
++ pcd_modexit();
++ return -EINVAL;
++ }
++ return 0;
++}
++MOD_EXIT(pcd_modexit);
++MOD_INIT(pcd_modinit);
+diff -uNr linux/drivers/no-otg/ocd/otg-pcd/pcd-ocd-init-l24.c linux/drivers/otg/ocd/otg-pcd/pcd-ocd-init-l24.c
+--- linux/drivers/no-otg/ocd/otg-pcd/pcd-ocd-init-l24.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/otg-pcd/pcd-ocd-init-l24.c 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,141 @@
++/*
++ * otg/pcd/pcd-ocd-init-l24.c - OTG Peripheral and OTG Controller Drivers Module Initialization
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/ocd/otg-pcd/pcd-ocd-init-l24.c
++ * @brief PCD only driver init.
++ *
++ *
++ * PCD/OCD Initialization
++ *
++ * This file initializes all of the low level hardware drivers for a combined
++ * PCD/OCD module. It does not initialize the TCD module.
++ *
++ * USB Periphirals using this must implement the following:
++ *
++ * ocd_ops operations from ocd driver
++ * pcd_ops operations from pcd driver
++ *
++ * The OTG Controller driver (ocd) implements any required OTG timers and if
++ * necessary mediates access to and initializes the OTG and/or USB hardware.
++ *
++ * The Peripheral Controller Driver (pcd) implements the lowest layer of the
++ * USBD stack to send and receive data from the USB actings as a USB
++ * peripheral.
++ *
++ * Notes
++ *
++ * 1. This is the linux 2.4 version.
++ *
++ * TODO
++ *
++ * 1. hook up serial_number_str to pcd.c for use with bus interface layer.
++ *
++ * @ingroup OTGPCD
++ */
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-bus.h>
++
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-tcd.h>
++#include <otg/otg-hcd.h>
++#include <otg/otg-pcd.h>
++#include <otg/otg-ocd.h>
++
++#ifdef MODULE
++#if LINUX_VERSION_CODE >= KERNEL_VERSION (2,4,17)
++MODULE_LICENSE ("GPL");
++#endif
++MODULE_PARM (serial_number_str, "s");
++MODULE_PARM_DESC (serial_number_str, "Serial Number");
++MODULE_AUTHOR ("sl@belcarra.com, tbr@belcarra.com");
++MODULE_DESCRIPTION ("USB On-The-Go PCD");
++#endif
++char *serial_number_str;
++
++otg_tag_t PCD;
++struct pcd_instance *pcd_instance;
++otg_tag_t OCD;
++struct ocd_instance *ocd_instance;
++
++
++/* ************************************************************************************* */
++
++/* pcd_ocd_modexit - module exit or init failure cleanup
++ *
++ * Specifically for each driver:
++ *
++ * call ops.mod_exit
++ * reset instance address and ops table address in state machine to NULL
++ * invalidate tag
++ */
++static void pcd_ocd_modexit (void)
++{
++ struct otg_instance *otg = ocd_instance->otg;
++ printk(KERN_INFO"%s\n", __FUNCTION__);
++ if (otg)
++ otg_exit(otg);
++
++ if (pcd_ops.mod_exit) pcd_ops.mod_exit();
++ pcd_instance = otg_set_pcd_ops(NULL);
++ PCD = otg_trace_invalidate_tag(PCD);
++
++ if (ocd_ops.mod_exit) ocd_ops.mod_exit();
++ ocd_instance = otg_set_ocd_ops(NULL);
++ OCD = otg_trace_invalidate_tag(OCD);
++}
++
++/* pcd_ocd_modinit - linux module initialization
++ *
++ * This needs to initialize the ocd, pcd and tcd drivers.
++ *
++ * Specifically for each driver:
++ *
++ * obtain tag
++ * pass ops table address to state machine and get instance address
++ * call ops.mod_init
++ *
++ * Note that we automatically provide a default tcd_init if
++ * none is set.
++ */
++static int pcd_ocd_modinit (void)
++{
++ printk(KERN_INFO"%s\n", __FUNCTION__);
++
++ #if !defined(OTG_C99)
++ pcd_global_init();
++ #endif /* !defined(OTG_C99) */
++
++ UNLESS(pcd_ops.pcd_init_func) pcd_ops.pcd_init_func = pcd_init_func;
++ PCD = otg_trace_obtain_tag();
++ THROW_UNLESS(pcd_instance = otg_set_pcd_ops(&pcd_ops), error);
++ THROW_IF((pcd_ops.mod_init) ? pcd_ops.mod_init() : 0, error);
++
++ OCD = otg_trace_obtain_tag();
++ THROW_UNLESS(ocd_instance = otg_set_ocd_ops(&ocd_ops), error);
++ THROW_IF((ocd_ops.mod_init) ? ocd_ops.mod_init() : 0, error);
++
++ CATCH(error) {
++ pcd_ocd_modexit();
++ return -EINVAL;
++ }
++ return 0;
++}
++
++MOD_EXIT (pcd_ocd_modexit);
++MOD_INIT (pcd_ocd_modinit);
++
++
+diff -uNr linux/drivers/no-otg/ocd/otg-pcd/pcd.c linux/drivers/otg/ocd/otg-pcd/pcd.c
+--- linux/drivers/no-otg/ocd/otg-pcd/pcd.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/otg-pcd/pcd.c 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,845 @@
++/*
++ * otg/ocd/otg-pcd/pcd.c - OTG Peripheral Controller Driver
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/ocd/otg-pcd/pcd.c
++ * @brief PCD only driver init.
++ * Notes
++ *
++ * 1. The pcd file abstracts much of the UDC complexity as possible and
++ * provides a common implementation that is shared to various extents by the
++ * various pcd drivers.
++ *
++ * @ingroup OTGPCD
++ */
++
++#include <otg/pcd-include.h>
++#include <asm/au1000.h>
++
++
++extern char *serial_number_str;
++
++/* ******************************************************************************************* */
++/*! bus_request_endpoints
++ */
++int bus_request_endpoints(struct usbd_bus_instance *bus, struct usbd_endpoint_map *endpoint_map_array, int endpointsRequested,
++ struct usbd_endpoint_request *requestedEndpoints)
++{
++ struct pcd_instance *pcd = (struct pcd_instance *)bus->privdata;
++ int i;
++ TRACE_MSG0(PCD, "BUS_REQUEST ENDPOINTS:");
++ if (usbd_pcd_ops.request_endpoints(pcd, endpoint_map_array, endpointsRequested, requestedEndpoints)) {
++ printk(KERN_INFO"%s: failed\n", __FUNCTION__);
++ return -EINVAL;
++ }
++ for (i = 0; i < endpointsRequested; i++) {
++ struct usbd_endpoint_map *endpoint_map = endpoint_map_array + i;
++ TRACE_MSG4(PCD, "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;
++}
++
++/*! bus_set_endpoints
++ */
++int bus_set_endpoints(struct usbd_bus_instance *bus, int endpointsRequested, struct usbd_endpoint_map *endpoint_map_array)
++{
++ struct pcd_instance *pcd = (struct pcd_instance *)bus->privdata;
++ TRACE_MSG0(PCD, "SET ENDPOINTS");
++ return usbd_pcd_ops.set_endpoints ? usbd_pcd_ops.set_endpoints(pcd, endpointsRequested, endpoint_map_array) : 0;
++}
++
++/*! bus_set_address
++ */
++int bus_set_address(struct usbd_bus_instance *bus, int address)
++{
++ struct pcd_instance *pcd = (struct pcd_instance *)bus->privdata;
++ if (usbd_pcd_ops.set_address) usbd_pcd_ops.set_address (pcd, address);
++ return 0;
++}
++
++/* ******************************************************************************************* */
++
++/*! pcd_search_endpoint_index - find endpoint map index given endpoint address
++ */
++int pcd_search_endpoint_index(struct usbd_bus_instance *bus, int bEndpointAddress)
++{
++ int i;
++ for (i = 0; i < bus->endpoints; i++)
++ BREAK_IF (bus->endpoint_array[i].bEndpointAddress == bEndpointAddress);
++ return i;
++}
++
++/*! pcd_search_endpoint - find endpoint given endpoint address
++ */
++struct usbd_endpoint_instance * pcd_search_endpoint(struct usbd_bus_instance *bus, int bEndpointAddress)
++{
++ int i = pcd_search_endpoint_index(bus, bEndpointAddress);
++ TRACE_MSG2(PCD, "BUS_SEARCH ENDPOINT: addr: %02x index: %d", bEndpointAddress, i);
++ RETURN_NULL_UNLESS(i < bus->endpoints);
++ return &(bus->endpoint_array[i]);
++}
++
++/*! bus_endpoint_halted - check if endpoint halted
++ * Used by the USB Device Core to check endpoint halt status.
++ *
++ * Return actual halted status if available or'd with endpoint->feature_setting set value.
++ * Assume not halted if udc driver does not provide an endpoint halted function.
++ */
++int bus_endpoint_halted (struct usbd_bus_instance *bus, int bEndpointAddress)
++{
++ struct pcd_instance *pcd = (struct pcd_instance *)bus->privdata;
++ int endpoint_index = pcd_search_endpoint_index(bus, bEndpointAddress);
++ struct usbd_endpoint_instance *endpoint = pcd_search_endpoint(bus, bEndpointAddress);
++ int halted;
++
++ TRACE_MSG1(PCD, "BUS_ENDPOINT HALTED: endpoint: %p", (int) endpoint);
++ RETURN_EINVAL_UNLESS(endpoint);
++
++ //halted = usbd_pcd_ops.endpoint_halted ? usbd_pcd_ops.endpoint_halted(pcd, endpoint_index) : 0;
++ halted = usbd_pcd_ops.endpoint_halted ? usbd_pcd_ops.endpoint_halted(pcd, endpoint) : 0;
++ TRACE_MSG1(PCD, "BUS_ENDPOINT HALTED: %08x", bus->endpoint_array[endpoint_index].feature_setting);
++
++ return halted || (endpoint->feature_setting & FEATURE(USB_ENDPOINT_HALT)? 1 : 0);
++}
++
++/*! bus_halt_endpoint - handle set/clear feature requests
++ * Used by the USB Device Core to set/clear endpoint halt status.
++ *
++ * We assume that if the udc driver does not implement anything then
++ * we should just return zero for ok.
++ */
++int bus_halt_endpoint (struct usbd_bus_instance *bus, int bEndpointAddress, int flag)
++{
++ struct pcd_instance *pcd = (struct pcd_instance *)bus->privdata;
++ int endpoint_index = pcd_search_endpoint_index(bus, bEndpointAddress);
++ struct usbd_endpoint_instance *endpoint = pcd_search_endpoint(bus, bEndpointAddress);
++
++ TRACE_MSG1(PCD, "BUS_ENDPOINT HALT: endpoint: %p", (int) endpoint);
++ RETURN_EINVAL_UNLESS(endpoint);
++ endpoint->feature_setting = flag;
++ return usbd_pcd_ops.halt_endpoint ? usbd_pcd_ops.halt_endpoint(pcd, endpoint, flag) : 0;
++}
++
++/*! pcd_disable_endpoints - disable udc and all endpoints
++ */
++static void pcd_disable_endpoints (struct usbd_bus_instance *bus)
++{
++ struct pcd_instance *pcd = (struct pcd_instance *)bus->privdata;
++ int i;
++ RETURN_IF (!bus || !bus->endpoint_array);
++ for (i = 1; i < usbd_pcd_ops.max_endpoints; i++) {
++ struct usbd_endpoint_instance *endpoint = (bus->endpoint_array + i);
++ CONTINUE_IF (!endpoint);
++ usbd_flush_endpoint (endpoint);
++ }
++}
++
++
++/*! bus_event_handler - handle generic bus event
++ * Called by usb core layer to inform bus of an event.
++ */
++int bus_event_handler (struct usbd_bus_instance *bus, usbd_device_event_t event, int data)
++{
++ struct pcd_instance *pcd = (struct pcd_instance *)bus->privdata;
++ int epn;
++ //struct usbd_endpoint_map *endpoint_map_array = bus->function_instance->endpoint_map_array;
++
++ //TRACE_MSG1(PCD, "BUS_EVENT %x", event);
++ switch (event) {
++ case DEVICE_UNKNOWN:
++ break;
++
++ case DEVICE_INIT:
++ TRACE_MSG0(PCD, "EVENT INIT");
++ break;
++
++ case DEVICE_CREATE:
++ TRACE_MSG0(PCD, "EVENT CREATE");
++ pcd_disable_endpoints (bus);
++ if (usbd_pcd_ops.start) usbd_pcd_ops.start (pcd);
++ break;
++
++ case DEVICE_HUB_CONFIGURED:
++ TRACE_MSG0(PCD, "EVENT HUB_CONFIGURED");
++ //bi_connect (bus, NULL);
++ break;
++
++ case DEVICE_RESET:
++ TRACE_MSG0(PCD, "EVENT RESET");
++
++ if (usbd_pcd_ops.set_address) usbd_pcd_ops.set_address (pcd, 0);
++
++ if (usbd_pcd_ops.reset_ep) usbd_pcd_ops.reset_ep (pcd, 0);
++
++ pcd_disable_endpoints (bus);
++ otg_event_irq(pcd->otg, BUS_RESET | BUS_SUSPENDED_, PCD, "DEVICE_RESET");
++
++ break;
++
++ case DEVICE_ADDRESS_ASSIGNED:
++ TRACE_MSG1(PCD, "EVENT ADDRESSED: %d", data);
++
++ otg_event_irq(pcd->otg, ADDRESSED, PCD, "ADDRESSED");
++
++ break;
++
++ case DEVICE_CONFIGURED:
++ TRACE_MSG0(PCD, "EVENT CONFIGURED");
++ otg_event_irq(pcd->otg, CONFIGURED, PCD, "CONFIGURED");
++ // iterate across the physical endpoint instance array to enable the endpoints
++ if (usbd_pcd_ops.setup_ep)
++ for (epn = 1; epn < bus->endpoints; epn++)
++ usbd_pcd_ops.setup_ep (pcd, epn, bus->endpoint_array + epn);
++ break;
++
++ case DEVICE_DE_CONFIGURED:
++ TRACE_MSG0(PCD, "EVENT DE-CONFIGURED");
++ break;
++
++ case DEVICE_SET_INTERFACE:
++ TRACE_MSG0(PCD, "EVENT SET INTERFACE");
++ break;
++
++ case DEVICE_SET_FEATURE:
++ TRACE_MSG0(PCD, "EVENT SET FEATURE");
++ break;
++
++ case DEVICE_CLEAR_FEATURE:
++ TRACE_MSG0(PCD, "EVENT CLEAR FEATURE");
++ break;
++
++ case DEVICE_BUS_INACTIVE:
++ TRACE_MSG0(PCD, "EVENT INACTIVE");
++ TRACE_MSG1(PCD, "EVENT INACTIVE: state: %x", bus->device_state);
++ otg_event_irq(pcd->otg, BUS_SUSPENDED, PCD, "DEVICE_BUS_INACTIVE");
++ break;
++
++ case DEVICE_BUS_ACTIVITY:
++ TRACE_MSG0(PCD, "EVENT ACTIVITY");
++ otg_event_irq(pcd->otg, BUS_SUSPENDED_, PCD, "DEVICE_BUS_ACTIVITY");
++ break;
++
++ case DEVICE_POWER_INTERRUPTION:
++ TRACE_MSG0(PCD, "POWER INTERRUPTION");
++ break;
++
++ case DEVICE_HUB_RESET:
++ TRACE_MSG0(PCD, "HUB RESET");
++ break;
++
++ case DEVICE_DESTROY:
++ TRACE_MSG0(PCD, "DEVICE DESTROY");
++ //bi_disconnect (bus, NULL);
++ pcd_disable_endpoints (bus);
++ if (usbd_pcd_ops.stop) usbd_pcd_ops.stop (pcd);
++ break;
++
++ case DEVICE_CLOSE:
++ TRACE_MSG0(PCD, "DEVICE CLOSE");
++ break;
++ default:
++ TRACE_MSG1(PCD, "DEVICE UNKNOWN: %d", event);
++ break;
++ }
++ TRACE_MSG2(PCD, "EVENT bNumInterfaces: %x alternates: %x", bus->bNumInterfaces, bus->alternates);
++ return 0;
++}
++
++
++/*! bus_start_endpoint_in
++ */
++int bus_start_endpoint_in (struct usbd_bus_instance *bus, struct usbd_endpoint_instance *endpoint)
++{
++ struct pcd_instance *pcd = (struct pcd_instance *)bus->privdata;
++ unsigned long flags;
++
++ RETURN_ZERO_IF (!endpoint);
++ ocd_ops.interrupts++;
++
++ local_irq_save (flags);
++
++ // call pcd_start_endpoint_in IFF we didn't previously have a tx urb
++ if (!endpoint->tx_urb && pcd_tx_next_irq (endpoint)) {
++ usbd_pcd_ops.start_endpoint_in (pcd, endpoint);
++ }
++ local_irq_restore (flags);
++ return 0;
++}
++
++/*! bus_start_endpoint_out
++ */
++int bus_start_endpoint_out (struct usbd_bus_instance *bus, struct usbd_endpoint_instance *endpoint)
++{
++ struct pcd_instance *pcd = (struct pcd_instance *)bus->privdata;
++ unsigned long flags;
++
++ RETURN_ZERO_IF (!endpoint);
++ ocd_ops.interrupts++;
++ local_irq_save (flags);
++ // call pcd_start_endpoint_OUT IFF we didn't previously have a rcv urb
++ if (!endpoint->rcv_urb && pcd_rcv_next_irq (endpoint)) {
++ usbd_pcd_ops.start_endpoint_out (pcd, endpoint);
++ }
++ local_irq_restore (flags);
++ return 0;
++}
++
++
++/*! bus_cancel_urb_irq - cancel sending an urb
++ * Used by the USB Device Core to cancel an urb.
++ */
++int bus_cancel_urb_irq (struct usbd_urb *urb)
++{
++ struct usbd_bus_instance *bus = urb->bus;
++ struct pcd_instance *pcd = (struct pcd_instance *)bus->privdata;
++ RETURN_EINVAL_IF (!urb);
++ TRACE_MSG1(PCD, "BUS_CANCEL URB: %x", (int)urb);
++ switch (urb->endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) {
++ case USB_DIR_IN:
++ // is this the active urb?
++ if (urb->endpoint->tx_urb == urb) {
++ urb->endpoint->tx_urb = NULL;
++ TRACE_MSG1(PCD, "CANCEL IN URB: %02x", urb->endpoint->bEndpointAddress);
++ if (usbd_pcd_ops.cancel_in_irq) usbd_pcd_ops.cancel_in_irq (pcd, urb);
++ }
++ usbd_urb_finished_irq (urb, SEND_CANCELLED);
++ break;
++
++ case USB_DIR_OUT:
++ // is this the active urb?
++ if (urb->endpoint->rcv_urb == urb) {
++ urb->endpoint->rcv_urb = NULL;
++ TRACE_MSG1(PCD, "CANCEL OUT URB: %02x", urb->endpoint->bEndpointAddress);
++ if (usbd_pcd_ops.cancel_out_irq) usbd_pcd_ops.cancel_out_irq (pcd, urb);
++ }
++ TRACE_MSG0(PCD, "CANCEL RECV URB");
++ usbd_urb_finished_irq (urb, RECV_CANCELLED);
++ break;
++ }
++ urb->endpoint->last = urb->endpoint->sent = 0;
++ return 0;
++}
++
++/*! pcd_rcv_finished_irq
++ */
++struct usbd_urb * pcd_rcv_finished_irq (struct usbd_endpoint_instance *endpoint, int len, int urb_bad)
++{
++ struct usbd_urb *rcv_urb;
++
++ // if we had an urb then update actual_length, dispatch if neccessary
++ if (likely ( (int) (rcv_urb = endpoint->rcv_urb))) {
++ struct usbd_bus_instance *bus = rcv_urb->bus;
++ struct pcd_instance *pcd = (struct pcd_instance *)bus->privdata;
++
++ //TRACE_MSG5(PCD, "BUS_RCV COMPLETE: finished buffer: %x actual: %d len: %d bad: %d: status: %d",
++ // rcv_urb->buffer, rcv_urb->actual_length, len, urb_bad, rcv_urb->status);
++
++ if (!urb_bad && !endpoint->rcv_error && (rcv_urb->bus->status == USBD_OK)) {
++
++#if 0
++ int i;
++ u8 *cp = rcv_urb->buffer;
++ for (i = 0; i < rcv_urb->actual_length + len; i+= 8) {
++
++ TRACE_MSG8(PCD, "RECV %02x %02x %02x %02x %02x %02x %02x %02x",
++ cp[i + 0], cp[i + 1], cp[i + 2], cp[i + 3],
++ cp[i + 4], cp[i + 5], cp[i + 6], cp[i + 7]
++ );
++ }
++#endif
++ // increment the received data size
++ rcv_urb->actual_length += len;
++
++ endpoint->rcv_urb = NULL;
++ rcv_urb->jiffies = jiffies;
++ rcv_urb->framenum = pcd_ops.framenum ? pcd_ops.framenum () : 0;
++ //TRACE_MSG1(PCD, "BUS_RCV COMPLETE: framenum: %x", (int) rcv_urb->framenum);
++ usbd_urb_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 pcd_rcv_next_irq (endpoint);
++}
++
++/*! pcd_rcv_complete_irq
++ */
++struct usbd_urb * pcd_rcv_complete_irq (struct usbd_endpoint_instance *endpoint, int len, int urb_bad)
++{
++ struct usbd_urb *rcv_urb;
++
++ // if we had an urb then update actual_length, dispatch if neccessary
++ if (likely ( (int) (rcv_urb = endpoint->rcv_urb))) {
++ struct usbd_bus_instance *bus = rcv_urb->bus;
++ struct pcd_instance *pcd = (struct pcd_instance *)bus->privdata;
++
++ TRACE_MSG4(PCD, "BUS_RCV COMPLETE: actual: %d len: %d bad: %d: status: %d",
++ rcv_urb->actual_length, len, urb_bad, rcv_urb->status);
++
++ //TRACE_MSG4(PCD, "BUS_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;
++ u8 *cp = rcv_urb->buffer;
++ for (i = 0; i < rcv_urb->actual_length; i+= 8)
++ TRACE_MSG8(PCD, "RECV %02x %02x %02x %02x %02x %02x %02x %02x",
++ cp[i + 0], cp[i + 1], cp[i + 2], cp[i + 3],
++ cp[i + 4], cp[i + 5], cp[i + 6], cp[i + 7]
++ );
++#endif
++ endpoint->rcv_urb = NULL;
++ rcv_urb->jiffies = jiffies;
++ rcv_urb->framenum = pcd_ops.framenum ? pcd_ops.framenum () : 0;
++ TRACE_MSG2(PCD, "BUS_RCV COMPLETE: finished length: %d framenum: %x",
++ rcv_urb->actual_length, (int) rcv_urb->framenum);
++ usbd_urb_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 pcd_rcv_next_irq (endpoint);
++}
++
++/*! pcd_tx_complete_irq
++ */
++struct usbd_urb * pcd_tx_complete_irq (struct usbd_endpoint_instance *endpoint, int restart)
++{
++ struct usbd_urb *tx_urb;
++
++ TRACE_MSG2(PCD, "tx_urb: %x restart: %d", endpoint->tx_urb, restart);
++
++ // if we have a tx_urb advance or reset, finish if complete
++ if ( (tx_urb = endpoint->tx_urb)) {
++
++ struct usbd_bus_instance *bus = tx_urb->bus;
++ struct pcd_instance *pcd = (struct pcd_instance *)bus->privdata;
++
++ TRACE_MSG5(PCD, "BUS_TX CURRENT TX_URB: %p actual: %d sent: %d last: %d: flags: %d",
++ (int)endpoint->tx_urb, tx_urb->actual_length, endpoint->sent,
++ endpoint->last, tx_urb->flags);
++
++ if (likely (!restart)) {
++ int sent = endpoint->last;
++ endpoint->sent += sent;
++ endpoint->last -= sent;
++ }
++ else {
++ TRACE_MSG0(PCD, "RESTARTING");
++ endpoint->last = 0;
++ }
++
++ //if ( ( (tx_urb->actual_length - endpoint->sent) <= 0) && ! (tx_urb->flags & USBD_URB_SENDZLP) ) {
++
++ if ( (endpoint->sent >= tx_urb->actual_length) && ! (tx_urb->flags & USBD_URB_SENDZLP) ) {
++ tx_urb->jiffies = jiffies;
++ tx_urb->framenum = pcd_ops.framenum ? pcd_ops.framenum () : 0;
++ TRACE_MSG2(PCD, "BUS_TX COMPLETE: finished tx_urb: %p framenum: %x",
++ (int)tx_urb, (int)tx_urb->framenum);
++ usbd_urb_finished_irq (tx_urb, SEND_FINISHED_OK);
++ endpoint->tx_urb = NULL;
++ endpoint->last = endpoint->sent = 0;
++ }
++ }
++ return pcd_tx_next_irq (endpoint);
++}
++
++/* ******************************************************************************************* */
++
++/*! pcd_disable - Stop using the USB Device Controller
++ * Stop using the USB Device Controller.
++ * Shutdown and free dma channels, de-register the interrupt handler.
++ */
++void pcd_disable (struct usbd_bus_instance *bus)
++{
++ struct pcd_instance *pcd = (struct pcd_instance *)bus->privdata;
++ TRACE_MSG0(PCD, "BUS_UDC DISABLE");
++ if (usbd_pcd_ops.disable_ep) usbd_pcd_ops.disable_ep (pcd, 0);
++ pcd_disable_endpoints (bus);
++
++ if (usbd_pcd_ops.disable) usbd_pcd_ops.disable (pcd);
++}
++
++/* ************************************************************************************* */
++/*! bus_framenum
++ */
++int bus_framenum (void)
++{
++ return (pcd_ops.framenum) ? pcd_ops.framenum () : 0;
++}
++
++/*! bus_interrupts
++ */
++u64 bus_interrupts (void)
++{
++ return ocd_ops.interrupts;
++}
++
++/*! bus_ticks
++ */
++u64 bus_ticks (void)
++{
++ return (ocd_ops.ticks) ? ocd_ops.ticks () : 0;
++}
++
++/*! bus_elapsed
++ */
++u64 bus_elapsed (u64 *t1, u64 *t2)
++{
++ return (ocd_ops.elapsed) ? (ocd_ops.elapsed (t1, t2)) : 0;
++}
++
++/*! pcd_recv_setup_emulate_irq - emulate a device request
++ */
++int pcd_recv_setup_emulate_irq(struct usbd_bus_instance *bus, u8 bmRequestType, u8 bRequest, u16 wValue, u16 wIndex, u16 wLength)
++{
++ struct pcd_instance *pcd = (struct pcd_instance *)bus->privdata;
++ struct usbd_device_request request;
++
++ TRACE_MSG4(PCD, "bmRequestType: %02x bRequest: %02x wValue: %04x wIndex: %04x", bmRequestType, bRequest, wValue, wIndex);
++ request.bmRequestType = bmRequestType;
++ request.bRequest = bRequest;
++ request.wValue = cpu_to_le16(wValue);
++ request.wIndex = cpu_to_le16(wIndex);
++ request.wLength = cpu_to_le16(wLength);
++ return pcd_recv_setup_irq(pcd, &request);
++}
++
++/*! pcd_check_device_feature - verify that feature is set or clear
++ * Check current feature setting and emulate SETUP Request to set or clear
++ * if required.
++ */
++void pcd_check_device_feature(struct usbd_bus_instance *bus, int feature, int flag)
++{
++ int status = bus->device_feature_settings & (1 << feature);
++ TRACE_MSG2(PCD, "BUS_CHECK FEATURE: feature: %x flag: %x", feature, flag);
++ if (!status && flag)
++ pcd_recv_setup_emulate_irq(bus, USB_REQ_HOST2DEVICE, USB_REQ_SET_FEATURE, feature, 0, 0);
++ else if (status && !flag)
++ pcd_recv_setup_emulate_irq(bus, USB_REQ_HOST2DEVICE, USB_REQ_CLEAR_FEATURE, feature, 0, 0);
++ TRACE_MSG1(PCD, "BUS_CHECK FEATURE: features; %08x", bus->device_feature_settings);
++}
++
++/* ******************************************************************************************* */
++#if !defined(OTG_C99)
++struct usbd_bus_operations bus_ops;
++
++void pcd_global_init(void)
++{
++ ZERO(bus_ops);
++ bus_ops.start_endpoint_in = bus_start_endpoint_in;
++ bus_ops.start_endpoint_out = bus_start_endpoint_out;
++ bus_ops.cancel_urb_irq = bus_cancel_urb_irq;
++ bus_ops.endpoint_halted = bus_endpoint_halted;
++ bus_ops.halt_endpoint = bus_halt_endpoint;
++ bus_ops.set_address = bus_set_address;
++ bus_ops.event_handler = bus_event_handler;
++ bus_ops.request_endpoints = bus_request_endpoints;
++ bus_ops.set_endpoints = bus_set_endpoints;
++ bus_ops.framenum = bus_framenum;
++ bus_ops.ticks = bus_ticks;
++ bus_ops.elapsed = bus_elapsed;
++ bus_ops.interrupts = bus_interrupts;
++ //bus_ops.device_feature = bus_device_feature;
++}
++
++#else /* !defined(OTG_C99) */
++struct usbd_bus_operations bus_ops = {
++ .start_endpoint_in = bus_start_endpoint_in,
++ .start_endpoint_out = bus_start_endpoint_out,
++ .cancel_urb_irq = bus_cancel_urb_irq,
++ .endpoint_halted = bus_endpoint_halted,
++ .halt_endpoint = bus_halt_endpoint,
++ .set_address = bus_set_address,
++ .event_handler = bus_event_handler,
++ .request_endpoints = bus_request_endpoints,
++ .set_endpoints = bus_set_endpoints,
++ .framenum = bus_framenum,
++ .ticks = bus_ticks,
++ .elapsed = bus_elapsed,
++ .interrupts = bus_interrupts,
++ //.device_feature = bus_device_feature,
++};
++#endif /* !defined(OTG_C99) */
++
++
++struct usbd_bus_driver bus_driver = {
++ bops: &bus_ops,
++};
++
++
++
++/* ******************************************************************************************* */
++/* Prevent overlapp of bi administrative functions mainly:
++ * bus_register_bh
++ * bus_deregister_bh
++ */
++//DECLARE_MUTEX (usbd_bi_sem);
++struct usbd_bus_instance *usbd_bus;
++
++/*! pcd_startup_events
++ */
++void pcd_startup_events(struct usbd_bus_instance *bus)
++{
++ struct pcd_instance *pcd = (struct pcd_instance *)bus->privdata;
++ //TRACE_MSG0(PCD, "BI_STARTUP");
++ if (usbd_pcd_ops.startup_events) {
++ TRACE_MSG0(PCD, "BI_STARTUP_EVENTS - udc");
++ usbd_pcd_ops.startup_events(pcd);
++ }
++ else {
++ TRACE_MSG0(PCD, "BI_STARTUP_EVENTS - default");
++ usbd_bus_event_handler_irq (bus, DEVICE_INIT, 0);
++ usbd_bus_event_handler_irq (bus, DEVICE_CREATE, 0);
++ usbd_bus_event_handler_irq (bus, DEVICE_HUB_CONFIGURED, 0);
++ usbd_bus_event_handler_irq (bus, DEVICE_RESET, 0);
++ }
++ //TRACE_MSG0(PCD, "BI_STARTUP: FINISHED");
++}
++
++/*! bus_register_bh
++ */
++void bus_register_bh(void *arg)
++{
++ struct pcd_instance *pcd = arg;
++ struct otg_instance *otg = pcd->otg;
++ struct usbd_bus_instance *bus;
++ struct usbd_endpoint_instance *endpoint;
++ unsigned long flags;
++
++ TRACE_MSG1(PCD, "BUS_REGISTER_BH: pcd: %p", (int)arg);
++ RETURN_UNLESS(pcd);
++
++ TRACE_MSG0(PCD, "BUS_REGISTER_BH");
++
++ bus_driver.name = usbd_pcd_ops.name;
++ bus_driver.max_endpoints = usbd_pcd_ops.max_endpoints;
++ bus_driver.maxpacketsize = usbd_pcd_ops.ep0_packetsize;
++ bus_driver.capabilities = usbd_pcd_ops.capabilities;
++ bus_driver.bMaxPower = usbd_pcd_ops.bMaxPower;
++ bus_driver.ports = usbd_pcd_ops.ports;
++ // XXX bus_driver.otg_bmAttributes = tcd_ops.bmAttributes;
++ bus_driver.otg_bmAttributes = usbd_pcd_ops.bmAttributes;
++
++ TRACE_MSG1(PCD, "BUS_REGISTER_BH UDC Capabilities: %x", bus_driver.capabilities);
++ // XXX TRACE_MSG1(PCD, "BUS_REGISTER_BH UDC OTG Attributes: %x\n", tcd_ops.bmAttributes);
++ TRACE_MSG1(PCD, "BUS_REGISTER_BH UDC OTG Attributes: %x\n", usbd_pcd_ops.bmAttributes);
++
++ // register this bus interface driver and create the device driver instance
++ if (! (bus = usbd_register_bus (&bus_driver, usbd_pcd_ops.ep0_packetsize))) {
++ TRACE_MSG0(PCD, "BUS_REGISTER_BH: register failed");
++ printk (KERN_INFO "%s: failed\n", __FUNCTION__);
++ pcd_disable (NULL);
++ otg_event(pcd->otg, enable_otg_ | PCD_OK, PCD, "BUS_REGISTER_BH");
++ return;
++ }
++
++ bus->privdata = (void *) pcd;
++ pcd->bus = bus;
++
++ //if (usbd_pcd_ops.serial_init ? usbd_pcd_ops.serial_init (pcd) : -EINVAL) {
++ //
++ //}
++
++ if (serial_number_str && strlen(serial_number_str)) {
++ char *sp, *dp;
++ int i;
++ printk(KERN_INFO"%s:\n", __FUNCTION__);
++ printk(KERN_INFO"%s: serial_number_str: %s\n", __FUNCTION__, serial_number_str);
++ TRACE_MSG1(PCD, "prm serial_number_str: %s", serial_number_str);
++ for (sp = serial_number_str, dp = otg->serial_number, i = 0;
++ *sp && (i < (sizeof(otg->serial_number) - 1)); i++, sp++)
++ if (isxdigit(*sp)) *dp++ = toupper(*sp);
++ }
++
++
++ TRACE_MSG1(PCD, "otg serial_number_str: %s", pcd->otg->serial_number);
++ TRACE_MSG0(PCD, "BUS_REGISTER_BH: usbd_enable_function_irq");
++
++ if (usbd_enable_function_irq (bus, pcd->otg->function_name, pcd->otg->serial_number)) {
++ TRACE_MSG0(PCD, "BUS_REGISTER_BH: enable function failed");
++ printk (KERN_INFO "%s: failed\n", __FUNCTION__);
++ pcd_disable (NULL);
++ otg_event(pcd->otg, enable_otg_ | PCD_OK, PCD, "BUS_REGISTER_BH");
++ return;
++ }
++
++ // setup endpoint zero
++ endpoint = bus->endpoint_array + 0;
++ endpoint->bEndpointAddress = 0;
++
++ //endpoint->tx_attributes = 0;
++ //
++
++ endpoint->wMaxPacketSize = usbd_pcd_ops.ep0_packetsize;
++ endpoint->rcv_transferSize = 4096; // XXX should this be higher
++ endpoint->wMaxPacketSize = usbd_pcd_ops.ep0_packetsize;
++ if (usbd_pcd_ops.setup_ep) usbd_pcd_ops.setup_ep (pcd, 0, endpoint);
++
++ TRACE_MSG0(PCD, "BUS_REGISTER_BH: startup");
++
++ // hopefully device enumeration will finish this process
++ // XXX should this move to pcd_en?
++ pcd_startup_events (bus);
++ TRACE_MSG0(PCD, "BUS_REGISTER_BH: FINISHED - sending PCD_OK");
++ //MOD_INC_USE_COUNT;
++ otg_event(pcd->otg, PCD_OK, PCD, "BUS_REGISTER_BH PCD_OK");
++}
++
++/*! bus_deregister_bh
++ */
++void bus_deregister_bh(void *arg)
++{
++ struct pcd_instance *pcd = arg;
++ struct usbd_bus_instance *bus;
++ struct bus_data *data;
++ unsigned long flags;
++
++ //TRACE_MSG1(PCD, "BUS_DEREGISTER_BH: pcd: %x", pcd);
++ if (pcd && (bus = pcd->bus) && (usbd_bus_state_enabled == bus->bus_state)) {
++
++ if (usbd_pcd_ops.disable) usbd_pcd_ops.disable (pcd);
++
++ if (bus->device_state != STATE_ATTACHED) {
++ usbd_bus_event_handler_irq (bus, DEVICE_RESET, 0);
++ usbd_bus_event_handler_irq (bus, DEVICE_POWER_INTERRUPTION, 0);
++ usbd_bus_event_handler_irq (bus, DEVICE_HUB_RESET, 0);
++ }
++ usbd_bus_event_handler_irq (bus, DEVICE_DESTROY, 0);
++ pcd_disable_endpoints (bus);
++ pcd_disable (bus);
++
++ usbd_disable_function (bus);
++ bus->bus_state = usbd_bus_state_disabled;
++
++ //TRACE_MSG1(PCD, "%s: BI_SEM UP", (int)__FUNCTION__);
++ //otg_event(pcd->otg, exit_ok, "BUS_DISABLE EXIT_OK");
++
++ //if (bus->serial_number_str)
++ // lkfree (pcd->bus->serial_number_str);
++
++ usbd_deregister_bus (bus);
++ pcd->bus = NULL;
++
++ TRACE_MSG0(PCD, "BUS_DEREGISTER_BH: FINISHED - sending PCD_OK");
++ //MOD_DEC_USE_COUNT;
++ }
++ otg_event(pcd->otg, PCD_OK, PCD, "BUS_DEREGISTER_BH PCD_OK");
++}
++
++/* ************************************************************************************* */
++
++
++/*! pcd_en_func - enable
++ *
++ * This is called to enable / disable the PCD and USBD stack.
++ */
++void pcd_en_func (struct otg_instance *otg, u8 flag)
++{
++ struct pcd_instance *pcd = otg->pcd;
++ struct usbd_bus_instance *bus = pcd->bus;
++
++ //TRACE_MSG0(PCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(PCD, "PCD_EN: SET");
++#ifdef CONFIG_OTG_DB1550_J15
++ int ret = au_readl(SYS_PINFUNC);
++ au_writel((ret | 0x8000),SYS_PINFUNC);
++ ret = au_readl(SYS_PINFUNC);
++ TRACE_MSG1(PCD, "Set the OTG for device mode (sys_pfunc = %04x)", ret);
++#endif
++ // check if we can see the UDC and register, then enable the function
++ if (usbd_pcd_ops.enable) usbd_pcd_ops.enable (pcd);
++ //BREAK_IF (pcd_enable_irq (bus));
++ //BREAK_IF (usbd_enable_function_irq (bus, otg->function_name));
++
++ // XXX should this move to here
++ // pcd_startup_events (bus);
++ break;
++
++ case RESET:
++ TRACE_MSG0(PCD, "PCD_EN: RESET");
++ usbd_bus_event_handler_irq (bus, DEVICE_RESET, 0);
++ TRACE_MSG0(PCD, "PCD_EN: DESTROY");
++ usbd_bus_event_handler_irq (bus, DEVICE_DESTROY, 0);
++ TRACE_MSG0(PCD, "PCD_EN: FINISHED");
++ // XXX need to set a flag here
++ break;
++ }
++}
++
++/*! pcd_init_func - per peripheral controller common initialization
++ *
++ * This is called to initialize / de-initialize the PCD and USBD stack.
++ *
++ * We start work items to do this.
++ *
++ */
++void pcd_init_func (struct otg_instance *otg, u8 flag)
++{
++ struct pcd_instance *pcd = otg->pcd;
++ struct usbd_bus_instance *bus = pcd->bus;
++ //struct bus_data *data = NULL;
++
++ //printk(KERN_INFO"%s:\n", __FUNCTION__);
++
++ //TRACE_MSG0(PCD, "--");
++ switch (flag) {
++ case SET:
++ TRACE_MSG0(PCD, "PCD_INIT: SET");
++ PREPARE_WORK_ITEM(pcd->bh, bus_register_bh, pcd);
++ SCHEDULE_WORK(pcd->bh);
++ TRACE_MSG0(PCD, "BUS_REGISTER_SCHEDULE: finished");
++ break;
++
++ case RESET:
++ TRACE_MSG0(PCD, "PCD_INIT: RESET");
++ PREPARE_WORK_ITEM(pcd->bh, bus_deregister_bh, pcd);
++ SCHEDULE_WORK(pcd->bh);
++ }
++}
++
+diff -uNr linux/drivers/no-otg/ocd/otg-pcd/tr-init-l24.c linux/drivers/otg/ocd/otg-pcd/tr-init-l24.c
+--- linux/drivers/no-otg/ocd/otg-pcd/tr-init-l24.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/otg-pcd/tr-init-l24.c 2006-09-01 21:41:32.000000000 +0200
+@@ -0,0 +1,234 @@
++/*
++ * otg/ocd/otg-pcd/tr-init-l24.c - Traditional Device Peripheral and OTG Controller Drivers Module Initialization
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/ocd/otg-pcd/tr-init-l24.c
++ * @brief Traditional device driver init.
++ *
++ * TR OTG PCD/OCD/TCD Initialization
++ *
++ * This file initializes all of the low level hardware drivers for a traditional device.
++ *
++ * Traditional USB Devices must implement the following:
++ *
++ * ocd_ops operations from ocd driver
++ * pcd_ops operations from pcd driver
++ * tcd_ops operations from tcd driver
++ *
++ * The OTG Controller driver (ocd) implements any required OTG timers and if
++ * necessary mediates access to and initializes the OTG and/or USB hardware.
++ *
++ * The Peripheral Controller Driver (pcd) implements the lowest layer of the
++ * USBD stack to send and receive data from the USB actings as a USB
++ * peripheral.
++ *
++ * The Transceiver Controller Driver (tcd) implements control of the OTG or
++ * USB transceiver. At a minimum for a traditional device this should
++ * implement VBUS sensing (sometimes known as cable detect) and where
++ * possible control over the DP+ pullup resistor.
++ *
++ *
++ * Notes
++ *
++ * 1. This is the linux 2.4 version.
++ *
++ * 2. This will optionally do an auto start with TR_INIT if the OCD_CAPBILITIES_AUTO
++ * flag is set.
++ *
++ * TODO
++ *
++ * 1. hook up serial_number_str to pcd.c for use with bus interface layer.
++ *
++ * @ingroup OTGPCD
++ */
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-bus.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-tcd.h>
++#include <otg/otg-hcd.h>
++#include <otg/otg-pcd.h>
++#include <otg/otg-ocd.h>
++
++EMBED_LICENSE();
++
++MOD_PARM (serial_number_str, "s");
++MOD_PARM_DESC (serial_number_str, "Serial Number");
++MOD_AUTHOR ("sl@belcarra.com, tbr@belcarra.com");
++MOD_DESCRIPTION ("Traditional USB Device");
++
++char *serial_number_str;
++
++otg_tag_t OCD;
++struct ocd_instance *ocd_instance;
++
++otg_tag_t PCD;
++struct pcd_instance *pcd_instance;
++
++otg_tag_t TCD;
++struct tcd_instance *tcd_instance;
++
++
++/* ************************************************************************************* */
++
++/* tr_ocd_start_timer
++ * Fake - Set or reset timer to interrupt in number of uS (micro-seconds).
++ * This is only suitable for MN or TR firmware.
++ */
++int tr_ocd_start_timer(struct otg_instance *otg, int usec)
++{
++ otg_event(otg, TMOUT, OCD, "FAKE TMOUT");
++ return 0;
++}
++
++/* ************************************************************************** */
++/* tr_tcd_en_func - used to enable or disable transciever
++ *
++ */
++void tr_tcd_en_func(struct otg_instance *otg, u8 flag)
++{
++ struct pcd_instance *pcd = (struct pcd_instance *) otg->pcd;
++ struct usbd_bus_instance *bus = pcd->bus;
++
++ //printk(KERN_INFO"%s: start\n", __FUNCTION__);
++ TRACE_MSG0(TCD, "--");
++ TRACE_MSG2(TCD, "pcd: %x bus: %x", pcd, pcd->bus);
++
++ switch (flag) {
++ case PULSE:
++ case SET:
++ TRACE_MSG0(TCD, "TR_TCD_EN SET");
++ /* enable clock interrupt */
++ otg_event_set_irq(tcd_instance->otg, 1, 1, B_SESS_VLD, TCD, "B_SESS_VLD");
++ break;
++ case RESET:
++ TRACE_MSG0(TCD, "TR_TCD_EN RESET");
++ /* disable clock interrupt */
++ break;
++ }
++// TRACE_MSG2(TCD, "ep0 endpoint: %x bEndpointAddress: %02x BBB", bus->ep0->endpoint_map_array->endpoint,
++ // bus->ep0->endpoint_map_array->endpoint->bEndpointAddress);
++}
++
++
++/* ************************************************************************** */
++
++/* tr_modexit - This is used as module exit, and as cleanup if modinit fails.
++ *
++ * Specifically for each driver:
++ *
++ * call ops.mod_exit
++ * reset instance address and ops table address in state machine to NULL
++ * invalidate tag
++ */
++static void tr_modexit (void)
++{
++ struct otg_instance *otg = ocd_instance->otg;
++ printk(KERN_INFO"%s\n", __FUNCTION__);
++
++ TRACE_MSG1(TCD, "otg: %x", otg);
++ if (otg) {
++ TRACE_MSG0(TCD, "Calling otg_exit()");
++ otg_exit(otg);
++ TRACE_MSG0(TCD, "back from otg_exit()");
++ }
++ else
++ TRACE_MSG0(TCD, "did not call otg_exit()");
++
++#if 0
++ if ((ocd_ops.capabilities & OCD_CAPABILITIES_TR) && (ocd_ops.capabilities & OCD_CAPABILITIES_AUTO)) {
++ printk(KERN_INFO"%s calling otg_admin\n",__FUNCTION__);
++ otg_admin("exit_all", "Traditional Device Auto TR_INIT");
++ }
++#endif
++
++ if (tcd_ops.mod_exit) tcd_ops.mod_exit();
++ if (ocd_ops.mod_exit) ocd_ops.mod_exit();
++ if (pcd_ops.mod_exit) pcd_ops.mod_exit();
++
++ tcd_instance = otg_set_tcd_ops(NULL);
++ ocd_instance = otg_set_ocd_ops(NULL);
++ pcd_instance = otg_set_pcd_ops(NULL);
++
++ TCD = otg_trace_invalidate_tag(TCD);
++ OCD = otg_trace_invalidate_tag(OCD);
++ PCD = otg_trace_invalidate_tag(PCD);
++ printk(KERN_INFO"%s finished\n", __FUNCTION__);
++}
++
++
++/* tr_modinit - linux module initialization
++ *
++ * This needs to initialize the ocd, pcd and tcd drivers.
++ *
++ * Specifically for each driver:
++ *
++ * obtain tag
++ * pass ops table address to state machine and get instance address
++ * call ops.mod_init
++ *
++ */
++static int tr_modinit (void)
++{
++ struct otg_instance *otg;
++ printk(KERN_INFO"%s\n", __FUNCTION__);
++
++ #if !defined(OTG_C99)
++ pcd_global_init();
++ #endif /* !defined(OTG_C99) */
++
++ /* For each of ocd, pcd and tcd do:
++ *
++ * get tag
++ * update ops table with default functions where possible
++ * do otg_set_xxx_ops() as appropriate
++ * call xxx_ops.mod_init as appropriate
++ */
++
++ OCD = otg_trace_obtain_tag();
++ PCD = otg_trace_obtain_tag();
++ TCD = otg_trace_obtain_tag();
++
++ UNLESS(ocd_ops.start_timer) ocd_ops.start_timer = tr_ocd_start_timer;
++ UNLESS(pcd_ops.pcd_init_func) pcd_ops.pcd_init_func = pcd_init_func;
++ UNLESS(pcd_ops.pcd_en_func) pcd_ops.pcd_en_func = pcd_en_func;
++ UNLESS(tcd_ops.tcd_en_func) tcd_ops.tcd_en_func = tr_tcd_en_func;
++
++ THROW_IF((ocd_ops.mod_init) ? ocd_ops.mod_init() : 0, error);
++ THROW_IF((pcd_ops.mod_init) ? pcd_ops.mod_init() : 0, error);
++ THROW_IF((tcd_ops.mod_init) ? tcd_ops.mod_init() : 0, error);
++
++ THROW_UNLESS(ocd_instance = otg_set_ocd_ops(&ocd_ops), error);
++ THROW_UNLESS(pcd_instance = otg_set_pcd_ops(&pcd_ops), error);
++ THROW_UNLESS(tcd_instance = otg_set_tcd_ops(&tcd_ops), error);
++
++ THROW_UNLESS(ocd_instance && (otg = ocd_instance->otg), error);
++
++ CATCH(error) {
++ tr_modexit();
++ return -EINVAL;
++ }
++ /* Success!
++ */
++ otg_init(otg);
++#if 0
++ otg_start(otg, ocd_ops.capabilities & OCD_CAPABILITIES_TR);
++#endif
++ return 0;
++}
++
++module_init(tr_modinit);
++MOD_EXIT (tr_modexit);
++
+diff -uNr linux/drivers/no-otg/ocd/otg-tcd/tcd-init-l24.c linux/drivers/otg/ocd/otg-tcd/tcd-init-l24.c
+--- linux/drivers/no-otg/ocd/otg-tcd/tcd-init-l24.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/otg-tcd/tcd-init-l24.c 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,95 @@
++/*
++ * otg/ocd/otg-tcd/tcd-init-l24.c - OTG Transceiver Controller Driver Module Initialization
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcara.com>,
++ * Tom Rushworth <tbr@belcara.com>,
++ * Bruce Balden <balden@belcara.com>
++ *
++ */
++/*!
++ * @file otg/ocd/otg-tcd/tcd-init-l24.c
++ * @brief PCD only driver init.
++ *
++ * OTG TCD Initialization
++ *
++ * This file initializes the low level hardware drivers.
++ *
++ * This is the linux 2.4 version.
++ *
++ * @ingroup OTGTCD
++ */
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-bus.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-tcd.h>
++#include <otg/otg-hcd.h>
++#include <otg/otg-pcd.h>
++
++
++#ifdef MODULE
++#if LINUX_VERSION_CODE >= KERNEL_VERSION (2,4,17)
++MODULE_LICENSE ("GPL");
++#endif
++MODULE_AUTHOR ("sl@belcarra.com, tbr@belcarra.com");
++MODULE_DESCRIPTION ("USB On-The-Go TCD");
++#endif
++
++otg_tag_t TCD;
++
++extern struct tcd_ops tcd_ops;
++struct tcd_instance *tcd_instance;
++
++//extern void db1550_tcd_global_init(void);
++
++/* ************************************************************************************* */
++
++/* tcd_modexit - This is *only* used for drivers compiled and used as a module.
++ */
++static void tcd_modexit (void)
++{
++ struct otg_instance *otg = tcd_instance->otg;
++ //printk(KERN_INFO"%s\n", __FUNCTION__);
++
++ if (otg)
++ otg_exit(otg);
++
++ if (tcd_ops.mod_exit) tcd_ops.mod_exit();
++ tcd_instance = otg_set_tcd_ops(NULL);
++ otg_trace_invalidate_tag(TCD);
++}
++
++/* otg_modinit - linux module initialization
++ *
++ * This needs to initialize the hcd, pcd and tcd drivers. This includes tcd and possibly hcd
++ * for some architectures.
++ *
++ */
++static int tcd_modinit (void)
++{
++ printk(KERN_INFO"Initilize the tcd structure\n");
++// db1550_tcd_global_init();
++ TCD = otg_trace_obtain_tag();
++ THROW_UNLESS(tcd_instance = otg_set_tcd_ops(&tcd_ops), error);
++ THROW_IF((tcd_ops.mod_init) ? tcd_ops.mod_init() : 0, error);
++ //printk(KERN_INFO"%s finish\n", __FUNCTION__);
++
++ TRACE_MSG0(TCD, "--");
++
++ CATCH(error) {
++ tcd_modexit();
++ return -EINVAL;
++ }
++ return 0;
++}
++
++module_init (tcd_modinit);
++module_exit (tcd_modexit);
++
+diff -uNr linux/drivers/no-otg/ocd/otg-tcd/tcd.c linux/drivers/otg/ocd/otg-tcd/tcd.c
+--- linux/drivers/no-otg/ocd/otg-tcd/tcd.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/ocd/otg-tcd/tcd.c 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,55 @@
++/*
++ * otg/ocd/otg-tcd/tcd.c - OTG Transceiver Controller Driver
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcara.com>,
++ * Tom Rushworth <tbr@belcara.com>,
++ * Bruce Balden <balden@belcara.com>
++ *
++ */
++/*!
++ * @file otg/ocd/otg-tcd/tcd.c
++ * @brief TCD Support
++ * Notes
++ *
++ * @ingroup OTGTCD
++ */
++
++#include <otg/otg-compat.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-bus.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-tcd.h>
++#include <otg/otg-hcd.h>
++#include <otg/otg-pcd.h>
++
++extern struct tcd_ops tcd_ops;
++
++/* ************************************************************************************* */
++void tcd_cable_event_irq (struct otg_instance *otg)
++{
++ TRACE_MSG1(TCD, "TCD_CABLE_EVENT: vbus: %d", tcd_vbus(otg));
++ otg_event(otg, VBUS_VLD, TCD, "CABLE");
++ //otg_b_sess_vld(otg, 1, tcd_vbus (otg), "Cable Event");
++}
++
++void tcd_cable_event (struct otg_instance *otg)
++{
++ unsigned long flags;
++ local_irq_save (flags);
++ tcd_cable_event_irq (otg);
++ local_irq_restore (flags);
++}
++
++/* ************************************************************************************* */
++int tcd_vbus (struct otg_instance *otg)
++{
++ TRACE_MSG0(TCD, "OCD VBUS");
++ return tcd_ops.vbus ? tcd_ops.vbus (otg) : 1;
++}
++
++
+diff -uNr linux/drivers/no-otg/otg/hcd-hw.h linux/drivers/otg/otg/hcd-hw.h
+--- linux/drivers/no-otg/otg/hcd-hw.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/hcd-hw.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,101 @@
++/*
++ * otg/hcd/hc_xfer_hw.h - Generic transfer level USBOTG aware Host Controller Driver (HCD)
++ *
++ * Copyright (c) 2004 Belcarra Technologies
++ *
++ * By:
++ * Tom Rushworth <tbr@belcara.com>,
++ * Stuart Lynne <sl@belcara.com>,
++ * Bruce Balden <balden@belcara.com>
++ *
++ */
++/*!
++ * @file otg/otg/hcd-hw.h
++ * @brief Implements Generic Host Controller Driver
++ *
++ * @ingroup OTGHCD
++ */
++#ifndef HC_XFER_HW_H
++#define HC_XFER_HW_H 1
++
++/*===========================================================================*
++ * Functions provided by the hardware specific component (whatever HW it is).
++ * Each HW specific component provides these functions.
++ *===========================================================================*/
++
++/*===========================================================================*
++ * For the generic transfer aware framework.
++ *===========================================================================*/
++
++/*
++ * hcd_hw_max_active_transfers()
++ * Returns: the (constant) maximum number of concurrently active transfers the HW will handle.
++ */
++extern int hcd_hw_max_active_transfers(struct bus_hcpriv *bus_hcpriv);
++
++/*
++ * hcd_hw_start_transfer()
++ * Returns: tid >= 0 when the transfer starts - this is an index in [0..hcd_hw_max_active_transfers]
++ * -1 when the transfer is invalid,
++ * -2 when there are no resources for the transfer currently available.
++ */
++extern int hcd_hw_start_transfer(struct bus_hcpriv *bus_hcpriv,
++ int len, // length of data region
++ void *data, // virtual address of data region
++ int toggle, // toggle value to start the xfer with
++ int maxps, // max packet size of endpoint
++ int slow, // 1 ==> slow speed, 0 ==> full speed QQSV verify: (((urb->pipe) >> 26) & 1)
++ int endpoint, // endpoint number
++ int address, // USB device address
++ int pid, // {PID_OUT, PID_IN, PID_SETUP}
++ int format, // PIPE_{CONTROL,BULK,INTERRUPT,ISOCHRONOUS}
++ u32 other); // Values depending on format
++
++/*
++ * hcd_hw_unlink_urb()
++ * Called in irq_lock, calls back to xhc_transfer_complete().
++ * Returns: 0 when transfer is unlinked, non-zero otherwise.
++ */
++extern int hcd_hw_unlink_urb(struct bus_hcpriv *bus_hcpriv, int tid); // tid is value returned by hcd_hw_start_transfer()
++
++extern u32 hcd_hw_frame_number(struct bus_hcpriv *bus_hcpriv);
++
++extern void hcd_hw_enable_interrupts(struct bus_hcpriv *bus_hcpriv);
++extern void hcd_hw_disable_interrupts(struct bus_hcpriv *bus_hcpriv);
++
++extern void hcd_hw_get_ops(struct bus_hcpriv *bus_hcpriv);
++
++extern int hcd_hw_init(struct bus_hcpriv *bus_hcpriv);
++
++extern void hcd_hw_exit(struct bus_hcpriv *bus_hcpriv);
++
++/*===========================================================================*
++ * For the virtual root hub.
++ *===========================================================================*/
++
++extern int hcd_hw_rh_num_ports(struct bus_hcpriv *bus_hcpriv);
++extern u8 hcd_hw_rh_otg_capable_mask(struct bus_hcpriv *bus_hcpriv);
++
++extern char *hcd_hw_rh_string(struct bus_hcpriv *bus_hcpriv, int strno);
++extern u16 hcd_hw_rh_idVendor(struct bus_hcpriv *bus_hcpriv);
++extern u16 hcd_hw_rh_idProduct(struct bus_hcpriv *bus_hcpriv);
++extern u16 hcd_hw_rh_bcdDevice(struct bus_hcpriv *bus_hcpriv);
++extern u8 hcd_hw_rh_cfg_bmAttributes(struct bus_hcpriv *bus_hcpriv);
++extern u8 hcd_hw_rh_cfg_MaxPower(struct bus_hcpriv *bus_hcpriv);
++extern u16 hcd_hw_rh_hub_attributes(struct bus_hcpriv *bus_hcpriv);
++extern u8 hcd_hw_rh_power_delay(struct bus_hcpriv *bus_hcpriv);
++extern u8 hcd_hw_rh_hub_contr_current(struct bus_hcpriv *bus_hcpriv);
++extern u8 hcd_hw_rh_DeviceRemovable(struct bus_hcpriv *bus_hcpriv);
++extern u8 hcd_hw_rh_PortPwrCtrlMask(struct bus_hcpriv *bus_hcpriv);
++extern u32 hcd_hw_rh_get_hub_change_status(struct bus_hcpriv *bus_hcpriv);
++extern void hcd_hw_rh_hub_feature(struct bus_hcpriv *bus_hcpriv, int feat_selector, int set_flag);
++extern void hcd_hw_hcd_en_func(struct otg_instance *oi, u8 on);
++/*
++ * Note: in the following functions, portnum is 0-origin.
++ * (I.e., valid range is [0..(hcd_hw_rh_num_ports-1)].)
++ */
++extern u32 hcd_hw_rh_get_port_change_status(struct bus_hcpriv *bus_hcpriv, int portnum);
++extern void hcd_hw_rh_port_feature(struct bus_hcpriv *bus_hcpriv, u16 wValue, u16 wIndex, int set_flag);
++
++
++#endif
+diff -uNr linux/drivers/no-otg/otg/hcd-l26.h linux/drivers/otg/otg/hcd-l26.h
+--- linux/drivers/no-otg/otg/hcd-l26.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/hcd-l26.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,119 @@
++/*
++ * otg/hcd/hc_xfer.h - Generic transfer level USBOTG aware Host Controller Driver (HCD)
++ *
++ * Copyright (c) 2004 Belcarra Technologies
++ *
++ * By:
++ * Stuart Lynne <sl@belcara.com>,
++ * Tom Rushworth <tbr@belcara.com>,
++ * Bruce Balden <balden@belcara.com>
++ *
++ */
++/*!
++ * @file otg/otg/hcd-l26.h
++ * @brief Implements Linux version of Generic Host Controller driver
++ *
++ * @ingroup OTGHCD
++ */
++#ifndef HC_XFER_H
++#define HC_XFER_H 1
++
++/*===========================================================================*
++ * Data structures and functions provided by the generic transfer aware
++ * host controller framework.
++ *
++ * The generic framework must be linked with a hardware specific component,
++ * whose functions are specified in hc_xfer_hw.h, and a generic root hub
++ * component, whose functions are specified in hc_xfer_rh.h.
++ *
++ * The resulting module provides a table of operations to the usb core layer,
++ * passed to the core layer by a call to usb_alloc_bus().
++ *===========================================================================*/
++
++#define XHC_RH_DESCRIPTORS_SIZE (USB_DT_DEVICE_SIZE+USB_DT_CONFIG_SIZE+USB_DT_INTERFACE_SIZE+USB_DT_ENDPOINT_SIZE+USB_DT_HUB_NONVAR_SIZE+2)
++
++typedef struct rh_hcpriv {
++ struct urb *int_urb;
++ struct usbd_device_descriptor *dd;
++ struct usbd_configuration_descriptor *cd;
++ struct usbd_interface_descriptor *id;
++ struct usbd_endpoint_descriptor *ed;
++ struct hub_descriptor *hd;
++ struct timer_list poll_timer;
++ //int poll_jiffies;
++ struct usb_device *dev;
++ int dev_registered;
++ u32 hub_change_status; // For shadowing the HW
++ u32 *port_change_status; // An array of [num_ports] values for shadowing the HW
++ u32 hub_port_change_status;
++ struct WORK_STRUCT psc_bh;
++ u8 curr_cfg;
++ u8 curr_itf;
++ //u8 num_ports;
++ u8 otg_device_mask; // (1 << port_num) bit set iff port_num is acting as a device, not host, and so not usable
++ u8 descriptors[XHC_RH_DESCRIPTORS_SIZE];
++ int suspended;
++} rh_hcpriv_t;
++
++typedef struct bus_hcpriv { // XFER level Host Controller Info
++ struct usb_bus *usb_bus;
++ void *hw_hci; // HW specific information for this HC
++ int root_hub_addr; // Initially 0, set by the virtual root hub when addressed.
++ struct rh_hcpriv *rh_hcpriv; // Generic root hub info (see hc_xfer_rh.[hc])
++ int terminating; // Boolean, TRUE if shutting down.
++ //struct hcd_instance *hcd; // OTG Controller Info
++ int max_active_urbs;
++ struct urb **active_urbs;
++ int device_registered; // bus_device status
++ struct device bus_device; // Linux Driver Model info.
++ //struct hcd_ops otg_ops; // operations for OTG component.
++ struct usb_driver *usb_driver;
++
++ u8 num_ports;
++ u8 otg_port;
++ u8 otg_capable_mask;
++ u16 rh_vendorid;
++ u16 rh_productid;
++ u16 rh_bcddevice;
++ char *rh_serial;
++ char *rh_product;
++ char *rh_manufacturer;
++ u8 rh_bmAttributes;
++ u8 rh_bMaxPower;
++
++ struct usb_device *roothub_dev;
++ struct usb_device *first_dev;
++
++ int max_active_transfers;
++
++} bus_hcpriv_t;
++
++typedef struct dev_hcpriv { // XFER level HCI per attached device info
++ struct usb_device *dev;
++ struct list_head queued_urbs_both[2][16];
++ u32 num_urbs_both[2][16];
++ u8 epq_state_both[2][16];
++} dev_hcpriv_t;
++
++#define EPQ_EMPTY 0
++#define EPQ_RUNNING 1
++#define EPQ_WAITING 2
++
++/*===========================================================================*
++ * For the hardware specific component.
++ *===========================================================================*/
++
++extern void hcd_transfer_complete(struct bus_hcpriv *bus_hcpriv, int transfer_id, int format,
++ int cc, u32 remaining, int next_toggle);
++
++/*===========================================================================*
++ * For the virtual root hub.
++ *===========================================================================*/
++
++extern void hcd_rh_urb_complete(struct bus_hcpriv *bus_hcpriv, struct urb *urb);
++
++#include "../otg/otg-trace.h"
++extern otg_tag_t xfer_hci_trace_tag;
++
++
++#endif
+diff -uNr linux/drivers/no-otg/otg/hcd-rh.h linux/drivers/otg/otg/hcd-rh.h
+--- linux/drivers/no-otg/otg/hcd-rh.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/hcd-rh.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,55 @@
++/*
++ * otg/hcd/hc_xfer_rh.h - Generic transfer level USBOTG aware Host Controller Driver (HCD)
++ *
++ * Copyright (c) 2004 Belcarra Technologies
++ *
++ * By:
++ * Stuart Lynne <sl@belcara.com>,
++ * Tom Rushworth <tbr@belcara.com>,
++ * Bruce Balden <balden@belcara.com>
++ *
++ */
++/*!
++ * @file otg/otg/hcd-rh.h
++ * @brief Implements Generic Root Hub function for Generic Host Controller Driver.
++ *
++ * @ingroup OTGHCD
++ */
++#ifndef HC_XFER_RH_H
++#define HC_XFER_RH_H 1
++
++#define XHC_RH_STRING_CONFIGURATION 1
++#define XHC_RH_STRING_INTERFACE 2
++#define XHC_RH_STRING_SERIAL 3
++#define XHC_RH_STRING_PRODUCT 4
++#define XHC_RH_STRING_MANUFACTURER 5
++
++/*===========================================================================*
++ * Functions provided by the generic virtual root hub.
++ *===========================================================================*/
++
++/*===========================================================================*
++ * For the generic transfer aware framework.
++ *===========================================================================*/
++
++/*
++ * hcd_rh_submit_urb()
++ * Returns: values as for the generic submit_urb() function.
++ */
++extern int hcd_rh_submit_urb(struct bus_hcpriv *bus_hcpriv, struct urb *urb, int mem_flags);
++
++extern int hcd_rh_unlink_urb(struct bus_hcpriv *bus_hcpriv, struct urb *urb);
++
++extern void hcd_rh_get_ops(struct bus_hcpriv *bus_hcpriv);
++
++extern int hcd_rh_init(struct bus_hcpriv *bus_hcpriv);
++
++extern void hcd_rh_exit(struct bus_hcpriv *bus_hcpriv);
++
++/*===========================================================================*
++ * For the hardware specific root hub component.
++ *===========================================================================*/
++
++extern irqreturn_t hcd_rh_int_hndlr(int irq, void *dev_id, struct pt_regs *regs);
++
++#endif
+diff -uNr linux/drivers/no-otg/otg/otg-api.h linux/drivers/otg/otg/otg-api.h
+--- linux/drivers/no-otg/otg/otg-api.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/otg-api.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,233 @@
++/*
++ * otg/otg-api.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*
++ * Doxygen group definitions - N.B. These much each be in
++ * their own separate comment...
++ */
++/*!
++ * @defgroup onthegogroup On-The-Go
++ */
++/*!
++ * @defgroup functiongroup Function Drivers
++ */
++/*!
++ * @defgroup tcdgroup Transceiver Controller Drivers
++ */
++/*!
++ * @defgroup pcdgroup Peripheral Controller Drivers
++ */
++/*!
++ * @defgroup libgroup Architecture Libraries
++ */
++/*!
++ * @defgroup platformgroup Platform Drivers
++ */
++
++
++/*!
++ * @defgroup OTGCore Core
++ * @ingroup onthegogroup
++ */
++
++/*!
++ * @file otg/otg/otg-api.h
++ * @brief Core Defines for USB OTG Core Layaer
++ *
++ * @ingroup OTGCore
++ */
++
++/*!
++ * @name OTGCORE OTG API Definitions
++ * This contains the OTG API structures and definitions.
++ * @{
++ */
++
++#include <otg/otg-fw.h>
++
++#ifdef CONFIG_OTG_FW_MN
++#include <otg/otg-fw-mn.h>
++#else /* CONFIG_OTG_FW_MN */
++#include <otg/otg-fw-df.h>
++#endif /* CONFIG_OTG_FW_MN */
++
++
++struct otg_instance;
++typedef void (*otg_output_proc_t) (struct otg_instance *, u8);
++
++extern struct otg_firmware *otg_firmware_loaded;
++extern struct otg_firmware *otg_firmware_orig;
++extern struct otg_firmware *otg_firmware_loading;
++
++
++char * otg_get_state_name(int state);
++
++/*!
++ * @struct otg_instance
++ *
++ * This tracks the current OTG configuration and state
++ */
++struct otg_instance {
++
++ u16 state; /*!< current state */
++ int previous; /*!< previous state */
++
++ int active; /*!< used as semaphore */
++
++ u32 current_inputs; /*!< input settings */
++ u64 outputs; /*!< output settings */
++
++ u64 tickcount; /*!< when we transitioned to current state */
++ u64 bconn; /*!< when b_conn was set */
++
++ struct otg_state *current_outputs; /*!< output table entry for current state */
++ struct otg_state *previous_outputs; /*!< output table entry for current state */
++
++ otg_output_proc_t otg_output_ops[MAX_OUTPUTS]; /*!< array of functions mapped to output numbers */
++
++ int (*start_timer) (struct otg_instance *, int); /*!< OCD function to start timer */
++ u64 (*ticks) (void); /*!< OCD function to return ticks */
++ u64 (*elapsed) ( u64 *, u64 *); /*!< OCD function to return elapsed ticks */
++
++ void * hcd; /*!< pointer to hcd instance */
++ void * ocd; /*!< pointer to ocd instance */
++ void * pcd; /*!< pointer to pcd instance */
++ void * tcd; /*!< pointer to tcd instance */
++
++ char function_name[OTGADMIN_MAXSTR]; /*!< current function */
++ char serial_number[OTGADMIN_MAXSTR]; /*!< current serial number */
++};
++
++typedef int (*otg_event_t) (struct otg_instance *, int, char *);
++
++struct otg_event_info {
++ char *name;
++ otg_event_t event;
++};
++
++
++/* 1 - used by external functions to pass in administrative commands as simple strings
++ */
++extern int otg_status(int, u32, u32, char *, int);
++extern void otg_message(char *);
++
++/* 2 - used internally by any OTG stack component to single event from interrupt context
++ */
++extern int otg_event_irq(struct otg_instance *, u64, otg_tag_t, char *);
++
++/* 3 - used internally by any OTG stack component to single event from non-interrupt context,
++ */
++extern int otg_event(struct otg_instance *, u64, otg_tag_t, char *);
++
++/* 5 - used by PCD/TCD drivers to signal various OTG Transceiver events
++ */
++int otg_event_set_irq(struct otg_instance *, int, int, u32, otg_tag_t, char *);
++
++
++extern void otg_init (struct otg_instance *otg);
++extern void otg_exit (struct otg_instance *otg);
++
++/* message
++ */
++#if defined(OTG_LINUX)
++extern int otg_message_init_l24(struct otg_instance *);
++extern void otg_message_exit_l24(void);
++#endif /* defined(OTG_LINUX) */
++
++#if defined(OTG_WINCE)
++extern int otg_message_init_w42(struct otg_instance *);
++extern void otg_message_exit_w42(void);
++#endif /* defined(OTG_WINCE) */
++
++extern int otg_message_init(struct otg_instance *);
++extern void otg_message_exit(void);
++
++extern int otg_write_message_irq(char *buf, int size);
++extern int otg_write_message(char *buf, int size);
++extern int otg_read_message(char *buf, int size);
++extern int otg_data_queued(void);
++extern unsigned int otg_message_block(void);
++extern unsigned int otg_message_poll(struct file *, struct poll_table_struct *);
++
++
++/* trace
++ */
++extern int otg_trace_init (void);
++extern void otg_trace_exit (void);
++#if defined(OTG_LINUX)
++extern int otg_trace_init_l24(void);
++extern void otg_trace_exit_l24(void);
++#endif /* defined(OTG_LINUX) */
++
++#if defined(OTG_WINCE)
++extern int otg_trace_init_w42(void);
++extern void otg_trace_exit_w42(void);
++#endif /* defined(OTG_WINCE) */
++
++extern int otgtrace_init (void);
++extern void otgtrace_exit (void);
++extern int otg_trace_proc_read (char *page, int count, int * pos);
++extern int otg_trace_proc_write (const char *buf, int count, int * pos);
++
++/* usbp
++ */
++extern int usbd_device_init (void);
++extern void usbd_device_exit (void);
++
++
++/*
++ * otgcore/otg-mesg.c
++ */
++
++extern void otg_message(char *buf);
++extern void otg_mesg_get_status_update(struct otg_status_update *status_update);
++extern void otg_mesg_get_firmware_info(struct otg_firmware_info *firmware_info);
++extern int otg_mesg_set_firmware_info(struct otg_firmware_info *firmware_info);
++extern struct otg_instance * mesg_otg_instance;
++
++
++
++/*
++ * otgcore/otg.c
++ */
++extern char * otg_get_state_names(int i);
++
++/*
++ * ops
++ */
++
++extern struct hcd_ops *otg_hcd_ops;
++extern struct ocd_ops *otg_ocd_ops;
++extern struct pcd_ops *otg_pcd_ops;
++extern struct tcd_ops *otg_tcd_ops;
++extern struct usbd_ops *otg_usbd_ops;
++
++#define CORE core_trace_tag
++extern otg_tag_t CORE;
++
++extern struct hcd_instance * otg_set_hcd_ops(struct hcd_ops *);
++extern struct ocd_instance * otg_set_ocd_ops(struct ocd_ops *);
++extern struct pcd_instance * otg_set_pcd_ops(struct pcd_ops *);
++extern struct tcd_instance * otg_set_tcd_ops(struct tcd_ops *);
++extern int otg_set_usbd_ops(struct usbd_ops *);
++
++extern void otg_get_trace_info(otg_trace_t *p);
++extern int otg_tmr_id_gnd(void);
++extern u64 otg_tmr_ticks(void);
++extern u64 otg_tmr_elapsed(u64 *t1, u64 *t2);
++extern u16 otg_tmr_framenum(void);
++extern u32 otg_tmr_interrupts(void);
++
++extern void otg_write_info_message(char *msg);
++
++/* @} */
++
++
+diff -uNr linux/drivers/no-otg/otg/otg-compat.h linux/drivers/otg/otg/otg-compat.h
+--- linux/drivers/no-otg/otg/otg-compat.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/otg-compat.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,73 @@
++/*
++ * otg/otgcore/otg-compat.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ */
++/*!
++ * @file otg/otg/otg-compat.h
++ * @brief Common include file to determine and include appropriate OS compatibility file.
++ *
++ *
++ * @ingroup OTGCore
++ */
++#ifndef _OTG_COMPAT_H
++#define _OTG_COMPAT_H 1
++
++#if defined(_WIN32_WCE)
++#define OTG_WINCE _WIN32_WCE
++#endif /* defined(_WIN32_WCE) */
++
++ /* What operating system are we running under? */
++
++ /* Recursively include enough information to determine which release */
++
++ #if (__GNUC__ >=3)
++ #define GCC3
++ #else
++ #define GCC2
++ #endif
++ #include <linux/config.h>
++ #include <linux/kernel.h>
++ #include <linux/version.h>
++
++#if defined(__GNUC__)
++ #define OTG_LINUX
++ #ifndef CONFIG_OTG_NOC99
++ #define OTG_C99
++ #else
++ #endif
++
++ #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,2)
++ #define LINUX26
++ #elif LINUX_VERSION_CODE > KERNEL_VERSION(2,4,5)
++ #define LINUX24
++ #else /* LINUX_VERSION_CODE > KERNEL_VERSION(2,4,5) */
++ #define LINUX24
++ #define LINUX_OLD
++ #warning "Early unsupported release of Linux kernel"
++ #endif /* LINUX_VERSION_CODE > KERNEL_VERSION(2,4,5) */
++
++ /* We are running under a supported version of Linux */
++ #include <otg/otg-linux.h>
++
++#elif defined(OTG_WINCE)
++
++ /* We are running under a supported version of WinCE */
++ #include <otg/otg-wince.h>
++ #include <otg/otg-wince-ex.h>
++
++#else /* defined(OTG_WINCE) */
++
++ #error "Operating system not recognized"
++
++#endif /* defined(OTG_WINCE) */
++
++#include <otg/otg-utils.h>
++
++#if !defined(OTG_C99)
++#else /* !defined(OTG_C99) */
++#endif /* !defined(OTG_C99) */
++
++
++#endif /* _OTG_COMPAT_H */
+diff -uNr linux/drivers/no-otg/otg/otg-fw-df.h linux/drivers/otg/otg/otg-fw-df.h
+--- linux/drivers/no-otg/otg/otg-fw-df.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/otg-fw-df.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,53 @@
++
++/* Generated by otg-states-h.awk
++ *
++ * Do not Edit thie file
++ */
++
++/*!
++* @file otg/otg/otg-fw-df.h
++* @brief OTG Firmware - Firmware for df
++*
++* This file defines the OTG State Machine tests.
++*
++* @ingroup OTGFW
++*/
++
++
++/*!
++* @page OTGFW
++* @section OTGFW - otg-fw-df.h
++* This contains the input, output and timout definitions for the OTG state machine firmware
++*/
++extern char otg_fw_name_df[];
++extern int otg_test_max_df;
++extern struct otg_test otg_tests_df[];
++extern struct otg_output otg_outputs_df[];
++
++ /*
++ * Copyright (c) 2004 Belcarra
++ *
++ */
++ /*!
++ * This is the default Firmware. It is included in the
++ * compiled modules and supports the auto Traditional USB
++ * mode. No user inputs are implemented.
++ */
++
++#define invalid_state 0 /* State machine has been initialized. */
++
++#define otg_disabled 1 /* State machine has been initialized. */
++
++#define terminator_state 2 /* terminator */
++ /*
++ * This is not an OTG State. It is used internally to mark the end of the
++ * list of states and inputs.
++ */
++
++#define OTG_STATES_DF 3
++
++extern struct otg_state otg_states_df[OTG_STATES_DF + 1];
++
++extern char *otg_get_state_name_df(int);
++
++extern struct otg_firmware otg_firmware_df;
+diff -uNr linux/drivers/no-otg/otg/otg-fw-mn.h linux/drivers/otg/otg/otg-fw-mn.h
+--- linux/drivers/no-otg/otg/otg-fw-mn.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/otg-fw-mn.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,201 @@
++
++/* Generated by otg-states-h.awk
++ *
++ * Do not Edit thie file
++ */
++
++/*!
++* @file otg/otg/otg-fw-mn.h
++* @brief OTG Firmware - Firmware for mn
++*
++* This file defines the OTG State Machine tests.
++*
++* @ingroup OTGFW
++*/
++
++
++/*!
++* @page OTGFW
++* @section OTGFW - otg-fw-mn.h
++* This contains the input, output and timout definitions for the OTG state machine firmware
++*/
++extern char otg_fw_name_mn[];
++extern int otg_test_max_mn;
++extern struct otg_test otg_tests_mn[];
++extern struct otg_output otg_outputs_mn[];
++
++ /*
++ * Copyright (c) 2004 Belcarra
++ */
++ /*!
++ * This is the initialization set for pcd and tcd.
++ */
++
++#define invalid_state 0 /* Un-initialized state. */
++ /*
++ * This the initial state of the software when first loaded.
++ * It is not possible to return to this state.
++ */
++
++#define otg_disabled 1 /* State Machine ready but disabled. */
++ /*
++ * The USBOTG State Machine has been initialized but is inactive.
++ * This state may have arrived at from either the invalid_state or
++ * from the otg_disable state.
++ */
++
++#define otg_disable_tcd 2 /* State Machine waiting for driver de-initialization. */
++ /*
++ * The State Machine stops the device drivers and waits for them
++ * to signal that they have finished de-initializing.
++ *
++ * This state disables the TCD driver and waits for TCD ok.
++ */
++
++#define otg_disable_pcd 3 /* State Machine waiting for driver de-initialization. */
++ /*
++ * The State Machine stops the device drivers and waits for them
++ * to signal that they have finished de-initializing.
++ *
++ * This state disables the PCD driver and waits for PCD ok.
++ */
++
++#define otg_enable_pcd 4 /* State Machine waiting for driver initialization. */
++ /*
++ * The State Machine starts the device drivers and waits for them
++ * to signal that they have finished initializing.
++ *
++ * This state enables the PCD driver and waits for PCD ok.
++ */
++
++#define otg_enable_tcd 5 /* State Machine waiting for driver initialization. */
++ /*
++ * The State Machine starts the device drivers and waits for them
++ * to signal that they have finished initializing.
++ *
++ * This state enables the PCD driver and waits for PCD ok.
++ */
++ /*
++ * Copyright (c) 2004 Belcarra
++ *
++ */
++ /*!
++ * This is the minimal firmware. It can be included in the
++ * compiled modules and supports the auto Traditional USB
++ * mode. No user inputs are required for normal operation.
++ *
++ * The b_bus_drop input can be optionally used to disconnect and re-connect.
++ *
++ * The enable_otg input can be optionally used to disable and re-enable.
++ * Note that disable/enable will reset b_bus_drop.
++ *
++ */
++ /*!
++ * @name Meta State - otg_init
++ * @{
++ */
++
++#define otg_enabled 6 /* State machine has been initialized. */
++ /*!
++ * The State Machine has successfully started the device drivers and
++ * is waiting for an input event. Typically it will move from here to
++ * an idle state specific to the current conditions (a_idle, b_idle, mn_idle etc.)
++ * based on user request b_bus_drop.
++ *
++ */
++ /* @} */
++ /*!
++ * @name Meta State - b_idle
++ * @{
++ */
++
++#define mn_idle 7 /* In idle mode with bus_drop reset. */
++ /*!
++ * The State Machine is in the idle state for a Traditional USB Device.
++ * It is waiting for Vbus to indicate that it has been plugged into a USB Host.
++ *
++ */
++
++#define mn_bus_drop 8 /* In idle mode with bus_drop set. */
++ /*!
++ * The State Machine is in the idle state for a Traditional USB Device.
++ * The B-Device applications has requested that the bus connection be dropped.
++ * Wait for either enable_otg reset or b_bus_drop reset.
++ */
++ /* @} */
++ /*!
++ * @name Meta State - b_peripheral
++ * @{
++ */
++
++#define mn_peripheral 9 /* Signal a connection and wait for packet traffic. */
++ /*!
++ * The State Machine in the peripheral state for a Traditional USB Device.
++ * The D+ pullup is enabled and we are waiting for a BUS_RESET to
++ * indicate that the USB Host has recognized that a USB Device is attached.
++ */
++
++#define mn_bus_reset 10 /* The bus has been reset. */
++ /*!
++ * The State Machine in the bus_reset state for a Traditional USB Device.
++ * It is waiting to be enumerated and configured by the USB Host.
++ */
++
++#define mn_addressed 11 /* The device has been addressed. */
++ /*!
++ * The State Machine in the configured state for a Traditional USB Device.
++ * This means that there is an active session, there is packet traffic
++ * with this device.
++ */
++
++#define mn_configured 12 /* The device has been configured. */
++ /*!
++ * The State Machine in the configured state for a Traditional USB Device.
++ * This means that there is an active session, there is packet traffic
++ * with this device.
++ */
++
++#define mn_discharge 13 /* Discharging Vbus */
++ /*!
++ * The State Machine in the discharge state for a Traditional USB Device.
++ * The device has been unplugged. The Vbus discharge resistor will be enabled
++ * for the TLDISC_DSCHRG time period.
++ */
++ /* @} */
++ /*!
++ * @name Meta State - b_suspended
++ * @{
++ */
++
++#define mn_suspended 14 /* The bus has been suspended */
++ /*!
++ * The State Machine in the suspend state for a Traditional USB Device.
++ */
++
++#define mn_wakeup_enabled 15 /* Suspended with REMOTE WAKEUP enabled. */
++ /*!
++ * The State Machine in the suspend state for a Traditional USB Device,
++ * prior to suspended the USB Host enabled Remote Wakeup by sending a
++ * set REMOTE WAKUP request.
++ */
++
++#define mn_wakeup 16 /* Perform REMOTE WAKEUP procedure. */
++ /*!
++ * The State Machine in the wakeup state for a Traditional USB Device,
++ * The REMOTE WAKEUP procedure will be performed.
++ */
++ /* @} */
++
++#define terminator_state 17 /* terminator */
++ /*!
++ * This is not an OTG State. It is used internally to mark the end of the
++ * list of states and inputs.
++ */
++
++#define OTG_STATES_MN 18
++
++extern struct otg_state otg_states_mn[OTG_STATES_MN + 1];
++
++extern char *otg_get_state_name_mn(int);
++
++extern struct otg_firmware otg_firmware_mn;
+diff -uNr linux/drivers/no-otg/otg/otg-fw.h linux/drivers/otg/otg/otg-fw.h
+--- linux/drivers/no-otg/otg/otg-fw.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/otg-fw.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,1309 @@
++
++/* Generated by otg-h.awk
++ *
++ * Do not Edit, see otg-state.awk
++ */
++
++
++/*!
++* @defgroup OTGFW Firmware
++* @ingroup onthegogroup
++*/
++
++/*!
++* @file otg/otg/otg-fw.h
++* @brief OTG Firmware - Input, Output and Timeout definitions
++* This file defines the OTG State Machine input, output and timeout constants.
++*
++*
++* @ingroup OTGFW
++*/
++
++/*!
++* @name OTGFW
++* @section OTGFW - otg-fw.h
++*/
++
++/*!
++* @name OTGVERSION OTG Version
++* Version information
++* @{
++*/
++
++#define OTG_VERSION_FW 200502152159L
++
++/*! @} */
++
++/*!
++* @name BASIC
++* These are the provided for application layer compatibility.
++* @{
++*/
++#ifdef OTG_APPLICATION
++typedef unsigned char u8;
++typedef unsigned short u16;
++typedef unsigned long u32;
++typedef unsigned long long u64;
++#include <stdio.h>
++#include <sys/ioctl.h>
++#endif /* OTG_APPLICATION/ */
++
++/*! @} */
++
++/*!
++* @name OTGSTRUCT OTG Structures
++* Basic OTG Structures
++*/
++#define OTGADMIN_MAXSTR 48
++
++/*!
++ * @struct otg_test
++ *
++ * This defines the tests that allow the state machine to move
++ * from state to state based on input events.
++ *
++ * Goto target: if (
++ * (!test1 || (test1 & inputs)) &&
++ * (!test2 || (test2 & inputs)) &&
++ *
++ */
++typedef struct otg_test {
++ u16 test; /*!< Test number */
++ u16 state; /*!< State Machine State */
++ u32 target; /*!< Goto this target if */
++ u64 test1; /*!< (!test1 || (test1 & inputs)) && */
++ u64 test2; /*!< (!test2 || (test2 & inputs)) && */
++ u64 test3; /*!< (!test3 || (test3 & inputs)) && */
++ /* N.B. An empty test is ignored. */
++} otg_test_t; /*!< */
++
++
++/*!
++ * @struct otg_input_name
++ * This structure simply allows for a table of input names that can
++ * searched for by input mask
++ */
++typedef struct otg_input_name {
++ u32 value; /*!< Bit value */
++ char name[OTGADMIN_MAXSTR]; /*!< Name of state. */
++} otg_input_name_t;
++
++
++/*!
++ * @struct otg_state
++ * This defines an OTG State. Each state has a name, meta state,
++ * timeout, reset and outputs
++ *
++ * On entry to the state the reset mask is or'd into the current
++ * input mask, the settings defined in the output mask are used to.
++ * call the required output functions and then if present the timer
++ * is started with the timeout value (in uSec).
++ *
++ */
++typedef struct otg_state {
++ u16 state; /*!< State Machine State */
++ u16 meta; /*!< Meta Machine State */
++ char name[OTGADMIN_MAXSTR]; /*!< Name of state. */
++ u32 tmout; /*!< Start timeout if non-zero */
++ u64 reset; /*!< Or these inputs on entry to state */
++ u64 outputs; /*!< Or these outputs on entry to state */
++} otg_state_t;
++
++
++/*!
++ * @struct otg_ioctl_name
++ * This structure allows a table for a table of IOCTL event names that can be
++ * searched for by the ioctl command value. It also stores the actual
++ * input mask to set or reset when according to the ioctl arguement.
++ */
++typedef struct otg_ioctl_name {
++ u32 cmd; /*!< Ioctl cmd */
++ u32 set; /*!< Signal to set/reset */
++ char *name; /*!< Name of ioctl. */
++} otg_ioctl_name_t;
++
++
++/*!
++ * @struct otg_admin_command
++ * This allows for a table of IOCTL admin commands.
++ */
++typedef struct otg_admin_command {
++ int n; /*!< Ioctl cmd */
++ char string[OTGADMIN_MAXSTR]; /*!< Signal to set/reset */
++} otg_admin_command_t;
++
++
++/*!
++ * @struct otg_status_update
++ * This is used by the OTG administrative programs to pass data to and received
++ * data from the OTG State Machine driver.
++ */
++typedef struct otg_status_update {
++ u16 state; /*!< current state */
++ u16 meta; /*!< current meta state */
++ u32 inputs; /*!< current inputs */
++ u64 outputs; /*!< current outputs */
++ u32 capabilities; /*!< */
++ char fw_name[OTGADMIN_MAXSTR]; /*!< name of firmware */
++ char state_name[OTGADMIN_MAXSTR]; /*!< name of current state */
++ char meta_name[OTGADMIN_MAXSTR]; /*!< name of current meta-state */
++ char function_name[OTGADMIN_MAXSTR]; /*!< currently selected function */
++} otg_status_update_t;
++
++
++/*!
++ * @struct otg_firmware_info
++ * This is used by the OTG Administrative program to pass firmware information
++ * to the OTG State Machine./
++ */
++typedef struct otg_firmware_info {
++ int number_of_states; /*!< number of states */
++ int number_of_tests; /*!< number of tests */
++ char fw_name[OTGADMIN_MAXSTR]; /*!< name of firmware */
++} otg_firmware_info_t;
++
++
++/*!
++ * @struct otg_firmware
++ * This is used by the OTG Administrative program to pass firmware
++ * to the OTG State Machine./
++ */
++typedef struct otg_firmware {
++ int number_of_states; /*!< number of states */
++ int number_of_tests; /*!< number of tests */
++ char fw_name[OTGADMIN_MAXSTR]; /*!< name of firmware */
++ struct otg_state *otg_states; /*!< output information */
++ struct otg_test *otg_tests; /*!< test information */
++} otg_firmware_t;
++
++/*! @} */
++
++/*!
++* @name OTGTIME Time Macros
++* Basic OTG Time Macros
++*/
++
++#define US(n) (n) /*!< micro-seconds */
++
++#define MS(n) (1000 * US(n)) /*!< milli-seconds */
++
++#define SEC(n) (1000 * MS(n)) /*!< seconds */
++
++/*! @} */
++
++/*!
++* @name OTGOUTPUTM Output Macros
++* OTG Output Macros
++*/
++
++/* OTG State Outputs
++ *
++ * Each state that we transition to defines new settings for each of the defined
++ * outputs. Each output setting can have four settings:
++ *
++ *
++ *
++ *
++ *
++ */
++#define NC ((u64)0x0) /*!< NC no change */
++#define SET ((u64)0x1) /*!< SET the output should be set (i.e. enabled) */
++#define RESET ((u64)0x2) /*!< RESET the output should be reset (i.e. disabled) */
++#define PULSE ((u64)0x3) /*!< OTHER special setting, for example used for pulse vbus */
++#define POWER ((u64)0x3) /*!< POWER */
++
++#define _MASK(n) (((u64) 1) << n) /*!< Set nth bit in 64 bit mask */
++#define _NOT(n) (((u64) n) << 32) /*!< Set nth+32 bit in 64 bit mask */
++#define _ncmask(n) (NC) /*!< No output change mask */
++#define _setmask(n) (SET << (n*2)) /*!< Output set mask */
++#define _resetmask(n) (RESET << (n*2)) /*!< Output reset mask */
++#define _pulsemask(n) (PULSE << (n*2)) /*!< Output pulse mask */
++#define _powermask(n) (POWER << (n*2)) /*!< Output poser mask */
++
++/*! @} */
++
++/*!
++* @name OTGNAMES OTG Names
++* Basic OTG Name Tables
++*/
++
++extern struct otg_input_name otg_input_names[];
++extern struct otg_ioctl_name otg_ioctl_names[];
++extern struct otg_timeouts otg_timeouts[];
++extern struct otg_firmware *otg_firmware_loaded;
++extern char *otg_output_names[];
++
++
++/*! @} */
++
++/* Generated by otg-inputs-h.awk
++ *
++ * Do not Edit this file.
++ */
++
++
++ /*!
++ * N.B. The OTG State Machine Documentation uses the syntax A and A/
++ * to indicate an event being true or not true. Because a trailing
++ * slash is not legal in C we use A and A_ to indicate true and not true.
++ */
++
++ /*!
++ * @name OTG Transceiver Inputs
++ * These inputs reflect changes seen in the OTG Transceiver. These
++ * what are available in most common OTG transceivers, for example
++ * the ISP1301 or MAX3353.
++ *
++ * The following are typical Vbus comparators.
++ *
++ * ISP1301 MAX3353E
++ * B-Session end threshold 0.2V-0.8V 0.5V
++ * Session Valid Comparator 0.8V-2.0V 1.4V
++ * B-Session Valid 2.0V-4.0V N/A
++ * A-Device Vbus Valid Comparator 4.4V 4.6V
++ *
++ * @{
++ */
++#define ID_GND _MASK( 0) /*!< otg_ok - ID is grounded */
++#define ID_GND_ _NOT(ID_GND)
++#define ID_FLOAT _MASK( 1) /*!< otg_ok - ID is floating */
++#define ID_FLOAT_ _NOT(ID_FLOAT)
++#define DP_HIGH _MASK( 2) /*!< otg_ok - DP is pulled high */
++#define DP_HIGH_ _NOT(DP_HIGH)
++#define DM_HIGH _MASK( 3) /*!< otg_ok - DM pullup is pulled high */
++#define DM_HIGH_ _NOT(DM_HIGH)
++#define B_SESS_END _MASK( 4) /*!< otg_ok - Vbus less than B-Session end thresshold */
++#define B_SESS_END_ _NOT(B_SESS_END)
++#define A_SESS_VLD _MASK( 5) /*!< otg_ok - Vbus greater than Session valid threshold */
++#define A_SESS_VLD_ _NOT(A_SESS_VLD)
++#define B_SESS_VLD _MASK( 6) /*!< otg_ok - Vbus greater than B-Session Valid threshold */
++#define B_SESS_VLD_ _NOT(B_SESS_VLD)
++#define VBUS_VLD _MASK( 7) /*!< otg_ok - Vbus greater than A-Device Vbus Valid threshold */
++#define VBUS_VLD_ _NOT(VBUS_VLD)
++#define SRP_DET _MASK( 8) /*!< a_idle - SRP Detected (Vbus pulsed) */
++#define SRP_DET_ _NOT(SRP_DET)
++#define SE0_DET _MASK( 9) /*!< b_idle - SE0 Detected (Single Ended Zeros, DM and DP both low) */
++#define SE0_DET_ _NOT(SE0_DET)
++#define SE1_DET _MASK(10) /*!< b_idle - SE1 Detected (Single Ended Ones, DM and DP both high) */
++#define SE1_DET_ _NOT(SE1_DET)
++#define BDIS_ACON _MASK(10) /*!< a_hnp_wait - Auto DP pullup high after B-disconnect */
++#define BDIS_ACON_ _NOT(BDIS_ACON)
++#define CR_INT_DET _MASK(10) /*!< ph_audio - 0.4V < DP < 0.6V */
++#define CR_INT_DET_ _NOT(CR_INT_DET)
++ /* @} */
++ /*!
++ * @name Peripheral and Host driver signals.
++ *
++ *
++ * @{
++ */
++#define HUB_PORT_CONNECT _MASK(12) /*!< otg_both - Port Connection */
++#define HUB_PORT_CONNECT_ _NOT(HUB_PORT_CONNECT)
++#define BUS_RESET _MASK(13) /*!< otg_both - Bus has reset. */
++#define BUS_RESET_ _NOT(BUS_RESET)
++#define ADDRESSED _MASK(14) /*!< otg_both - Device has been addressed (received SET ADDRESS request.) */
++#define ADDRESSED_ _NOT(ADDRESSED)
++#define CONFIGURED _MASK(15) /*!< otg_both - Device has been configured (received SET CONFIG request.) */
++#define CONFIGURED_ _NOT(CONFIGURED)
++#define NOT_SUPPORTED _MASK(16) /*!< otg_both - Peripheral not supported (no class driver.) */
++#define NOT_SUPPORTED_ _NOT(NOT_SUPPORTED)
++#define BUS_SUSPENDED _MASK(17) /*!< otg_both - Bus has been suspended. */
++#define BUS_SUSPENDED_ _NOT(BUS_SUSPENDED)
++ /* @} */
++
++ /*!
++ * @name Administrative Policy Inputs
++ * These are only valid in the state indicated and
++ * can be enabled or disabled.
++ *
++ * @{
++ */
++#define a_bcon_no_tmout_req _MASK(18) /*!< otg_host - Application on A-host wants Ta_wait_bcon timeout disabled (non-OTG mode). */
++#define a_bcon_no_tmout_req_ _NOT(a_bcon_no_tmout_req)
++#define a_hpwr_req _MASK(19) /*!< otg_host - Application on A-host wants external charge pump enabled. */
++#define a_hpwr_req_ _NOT(a_hpwr_req)
++#define bus_drop _MASK(20) /*!< otg_ok - Application on Device needs to power down bus. */
++#define bus_drop_ _NOT(bus_drop)
++#define a_bus_drop _MASK(20) /*!< otg_ok - Application on A-Device needs to power down bus. */
++#define a_bus_drop_ _NOT(a_bus_drop)
++#define b_bus_drop _MASK(20) /*!< otg_ok - Application on B-Device needs to disconnect from bus. */
++#define b_bus_drop_ _NOT(b_bus_drop)
++#define bus_req _MASK(21) /*!< otg_ok - Application on Device wants to use the bus. */
++#define bus_req_ _NOT(bus_req)
++#define a_bus_req _MASK(21) /*!< otg_ok - Application on A-Device wants to act as host */
++#define a_bus_req_ _NOT(a_bus_req)
++#define b_bus_req _MASK(21) /*!< otg_ok - Application on B-Device wants to act as host */
++#define b_bus_req_ _NOT(b_bus_req)
++#define b_sess_req _MASK(21) /*!< otg_ok - Application on B-Device to perform SRP (alias for b_srp_req.) */
++#define b_sess_req_ _NOT(b_sess_req)
++#define suspend_req _MASK(22) /*!< otg_host - Application on Device requests bus be suspended (alias for a_bus_req/.) */
++#define suspend_req_ _NOT(suspend_req)
++#define a_suspend_req _MASK(22) /*!< otg_host - Application on A-host requests bus be suspended (alias for a_bus_req/.) */
++#define a_suspend_req_ _NOT(a_suspend_req)
++#define b_suspend_req _MASK(22) /*!< otg_host - Application on B-host requests bus be suspended (alias for b_bus_req/.) */
++#define b_suspend_req_ _NOT(b_suspend_req)
++ /* @} */
++
++ /*!
++ * @name Administrative Action Inputs
++ * These are only valid in state indicated. The
++ * state machine tests must reset in states
++ * prior and after use.
++ * @{
++ */
++#define set_remote_wakeup_cmd _MASK(24) /*!< a_host - A-Device will send Remote Wakeup Enable Request */
++#define set_remote_wakeup_cmd_ _NOT(set_remote_wakeup_cmd)
++#define remote_wakeup_cmd _MASK(24) /*!< tr_configured - B-Device will perform Remote Wakeup. */
++#define remote_wakeup_cmd_ _NOT(remote_wakeup_cmd)
++#define reset_remote_wakeup_cmd _MASK(25) /*!< a_host - A-Device will send Remote Wakeup Disable Request */
++#define reset_remote_wakeup_cmd_ _NOT(reset_remote_wakeup_cmd)
++#define clr_err_cmd _MASK(25) /*!< a_vbus_err - A-Device ill clears Vbus overcurrent error. */
++#define clr_err_cmd_ _NOT(clr_err_cmd)
++#define b_hnp_cmd _MASK(25) /*!< b_configured - B-Device will attempt HNP */
++#define b_hnp_cmd_ _NOT(b_hnp_cmd)
++#define ph_int_cmd _MASK(25) /*!< ph_audio - B-Device will request Carkit interrupt */
++#define ph_int_cmd_ _NOT(ph_int_cmd)
++#define ph_audio_cmd _MASK(25) /*!< ph_uart - Application on B-Device connected to Carkit requests audio mode. */
++#define ph_audio_cmd_ _NOT(ph_audio_cmd)
++#define cr_int_cmd _MASK(25) /*!< cr_aud - Application on A-Device wants to emulate Carkit */
++#define cr_int_cmd_ _NOT(cr_int_cmd)
++#define led_on_cmd _MASK(26) /*!< ph_uart - B-Device will enable Carkit LED */
++#define led_on_cmd_ _NOT(led_on_cmd)
++#define led_off_cmd _MASK(27) /*!< ph_uart - B-Device will disable Carkit LED */
++#define led_off_cmd_ _NOT(led_off_cmd)
++ /* @} */
++
++ /*!
++ * @name Internal State
++ * Used to track status changes.
++ * @{
++ */
++#define HNP_ENABLED _MASK(27) /*!< b_configured - B-HNP Enable Request sent (a-host) or received (b-peripheral). */
++#define HNP_ENABLED_ _NOT(HNP_ENABLED)
++#define HNP_CAPABLE _MASK(28) /*!< otg_both - B-host Peripheral may do HNP */
++#define HNP_CAPABLE_ _NOT(HNP_CAPABLE)
++#define HNP_SUPPORTED _MASK(28) /*!< otg_both - B-host can do HNP (A-Host Received HNP Supported SET FEATURE) */
++#define HNP_SUPPORTED_ _NOT(HNP_SUPPORTED)
++#define REMOTE_WAKEUP_ENABLED _MASK(29) /*!< otg_configured - Remote Wakeup Enable Request received. */
++#define REMOTE_WAKEUP_ENABLED_ _NOT(REMOTE_WAKEUP_ENABLED)
++#define REMOTE_CAPABLE _MASK(29) /*!< otg_both - Peripheral can do remote wakeup */
++#define REMOTE_CAPABLE_ _NOT(REMOTE_CAPABLE)
++ /* @} */
++
++ /*!
++ * @name Global Administration
++ * @{
++ */
++ /* @} */
++
++ /*!
++ * @name Driver Initialization Finished signals
++ * @{
++ */
++#define PCD_OK _MASK(30) /*!< otg_driver - PCD Driver Initialization Finished. */
++#define PCD_OK_ _NOT(PCD_OK)
++#define TCD_OK _MASK(30) /*!< otg_driver - TCD Driver Initialization Finished. */
++#define TCD_OK_ _NOT(TCD_OK)
++#define HCD_OK _MASK(30) /*!< otg_driver - HCD Driver Initialization Finished. */
++#define HCD_OK_ _NOT(HCD_OK)
++#define OCD_OK _MASK(30) /*!< otg_driver - OCD Driver Initialization Finished. */
++#define OCD_OK_ _NOT(OCD_OK)
++ /* @} */
++
++ /*!
++ * @name Timeout and enable
++ * @{
++ */
++#define TMOUT _MASK(30) /*!< otg_all - Generic Timeout */
++#define TMOUT_ _NOT(TMOUT)
++#define enable_otg _MASK(31) /*!< otg_all - Move State Machine otg_disabled state. */
++#define enable_otg_ _NOT(enable_otg)
++#define AUTO _MASK(31) /*!< otg_all - Auto Return (enable_otg only true when active) */
++#define AUTO_ _NOT(AUTO)
++ /* @} */
++
++ /*! @name Timeouts C.f. OTG Table 5-2 A-Device Timing
++ * @{
++ */
++#define Ta_wait_vrise _MASK(30) /*!< a_wait_vrise - Wait for Vbus Rise */
++#define Ta_wait_vrise_ _NOT(Ta_wait_vrise)
++#define TA_WAIT_VRISE MS(100)
++#define Ta_wait_vrise_200 _MASK(30) /*!< a_wait_vrise - Wait for Vbus Rise */
++#define Ta_wait_vrise_200_ _NOT(Ta_wait_vrise_200)
++#define TA_WAIT_VRISE_200 MS(200)
++#define Ta_wait_vrise_400 _MASK(30) /*!< a_wait_vrise - Wait for Vbus Rise */
++#define Ta_wait_vrise_400_ _NOT(Ta_wait_vrise_400)
++#define TA_WAIT_VRISE_400 MS(400)
++#define Ta_wait_vrise_500 _MASK(30) /*!< a_wait_vrise - Wait for Vbus Rise */
++#define Ta_wait_vrise_500_ _NOT(Ta_wait_vrise_500)
++#define TA_WAIT_VRISE_500 MS(500)
++#define Ta_wait_vrise_800 _MASK(30) /*!< a_wait_vrise - Wait for Vbus Rise */
++#define Ta_wait_vrise_800_ _NOT(Ta_wait_vrise_800)
++#define TA_WAIT_VRISE_800 MS(800)
++#define Ta_bcon_ldb _MASK(30) /*!< a_bcon_ldb - B-Connect Long Debounce */
++#define Ta_bcon_ldb_ _NOT(Ta_bcon_ldb)
++#define TA_BCON_LDB MS(100)
++#define Ta_wait_bcon _MASK(30) /*!< a_wait_bcon - Wait for 1 second for B-Connect */
++#define Ta_wait_bcon_ _NOT(Ta_wait_bcon)
++#define TA_WAIT_BCON SEC(1)
++#define Ta_wait_bcon_5 _MASK(30) /*!< a_wait_bcon - Wait for 5 second for B-Connect */
++#define Ta_wait_bcon_5_ _NOT(Ta_wait_bcon_5)
++#define TA_WAIT_BCON_5 SEC(5)
++#define Ta_wait_bcon_10 _MASK(30) /*!< a_wait_bcon - Wait for 10 second for B-Connect */
++#define Ta_wait_bcon_10_ _NOT(Ta_wait_bcon_10)
++#define TA_WAIT_BCON_10 SEC(10)
++#define Ta_aidl_bdis _MASK(30) /*!< a_hnp_wait - A-Idle to B-Disconnect */
++#define Ta_aidl_bdis_ _NOT(Ta_aidl_bdis)
++#define TA_AIDL_BDIS MS(200)
++#define Ta_bdis_acon _MASK(30) /*!< a_suspend - B-disconnect to A-Connect */
++#define Ta_bdis_acon_ _NOT(Ta_bdis_acon)
++#define TA_BDIS_ACON MS(3)
++#define Ta_bidl_adis_min _MASK(30) /*!< a_peripheral - B-Idle to A-Disconnect minimum (TODO) */
++#define Ta_bidl_adis_min_ _NOT(Ta_bidl_adis_min)
++#define TA_BIDL_ADIS_MIN MS(3)
++#define Ta_bcon_sdb _MASK(30) /*!< a_bcon_sdb - B-Connect Short Debounce */
++#define Ta_bcon_sdb_ _NOT(Ta_bcon_sdb)
++#define TA_BCON_SDB US(2)
++#define Ta_bcon_sdb_win _MASK(30) /*!< a_bcon_win - B-Connect Short Debounce Window */
++#define Ta_bcon_sdb_win_ _NOT(Ta_bcon_sdb_win)
++#define TA_BCON_SDB_WIN MS(100)
++ /* @} */
++
++ /*! @name Timeouts C.f. OTG Table 5-3 B-Device Timing
++ * @{
++ */
++#define Tb_se0_srp _MASK(30) /*!< b_srp_se0 - SE0 Time Before SRP */
++#define Tb_se0_srp_ _NOT(Tb_se0_srp)
++#define TB_SE0_SRP MS(2)
++#define Tb_data_pls _MASK(30) /*!< b_srp_init - Data-Line Pulse Time */
++#define Tb_data_pls_ _NOT(Tb_data_pls)
++#define TB_DATA_PLS MS(7)
++#define Tb_data_pls_min _MASK(30) /*!< a_srp_min - Data-Line Pulse minimum time */
++#define Tb_data_pls_min_ _NOT(Tb_data_pls_min)
++#define TB_DATA_PLS_MIN MS(5)
++#define Tb_data_pls_max _MASK(30) /*!< a_srp_wait - Data-Line Pulse maximum time */
++#define Tb_data_pls_max_ _NOT(Tb_data_pls_max)
++#define TB_DATA_PLS_MAX MS(10)
++#define Tb_srp_init _MASK(30) /*!< b_srp_init - SRP Initiate Time (TODO multi-state? Not-needed?) */
++#define Tb_srp_init_ _NOT(Tb_srp_init)
++#define TB_SRP_INIT MS(100)
++#define Tb_srp_fail_min _MASK(30) /*!< b_srp_wait - SRP Fail Time minimum (TODO) */
++#define Tb_srp_fail_min_ _NOT(Tb_srp_fail_min)
++#define TB_SRP_FAIL_MIN SEC(5)
++#define Tb_aidl_bdis_min _MASK(30) /*!< b_peripheral - A-idle to B-Disconnect minimum (TODO) */
++#define Tb_aidl_bdis_min_ _NOT(Tb_aidl_bdis_min)
++#define TB_AIDL_BDIS_MIN MS(5)
++#define Tb_aidl_bdis_max _MASK(30) /*!< b_peripheral - A-idle to B-Disconnect maximum (TODO) */
++#define Tb_aidl_bdis_max_ _NOT(Tb_aidl_bdis_max)
++#define TB_AIDL_BDIS_MAX MS(150)
++#define Tldisc_dschrg _MASK(30) /*!< b_dischrg - Local Disconnect to Data Line Discharge (TODO) */
++#define Tldisc_dschrg_ _NOT(Tldisc_dschrg)
++#define TLDISC_DSCHRG US(25)
++#define Tb_ase0_brst_min _MASK(30) /*!< b_wait_acon - A-SE0 to B-Reset minimum */
++#define Tb_ase0_brst_min_ _NOT(Tb_ase0_brst_min)
++#define TB_ASE0_BRST_MIN US(3125)
++#define Tb_acon_dbnc _MASK(30) /*!< b_acon_dbnc - A-Connect Debounce */
++#define Tb_acon_dbnc_ _NOT(Tb_acon_dbnc)
++#define TB_ACON_DBNC US(2)
++#define Tb_acon_bse0 _MASK(30) /*!< b_host_se0 - A-Connect to B-SE0 */
++#define Tb_acon_bse0_ _NOT(Tb_acon_bse0)
++#define TB_ACON_BSE0 MS(1)
++#define Tid_ldb _MASK(30) /*!< otg_enable - ID changes debounce */
++#define Tid_ldb_ _NOT(Tid_ldb)
++#define TID_LDB MS(100)
++ /* @} */
++
++ /*! @name Timeouts for Carkit
++ * @{
++ */
++#define Tph_bcon_ldb _MASK(30) /*!< ph_init - B-Connect Long Debounce */
++#define Tph_bcon_ldb_ _NOT(Tph_bcon_ldb)
++#define TPH_BCON_LDB MS(100)
++#define Tph_init_pls _MASK(30) /*!< ph_int - Timeout for Carkit interrupt. */
++#define Tph_init_pls_ _NOT(Tph_init_pls)
++#define TPH_INIT_PLS US(500)
++#define Tcr_uart_rsp _MASK(30) /*!< ph_int - Timeout for Carkit UART */
++#define Tcr_uart_rsp_ _NOT(Tcr_uart_rsp)
++#define TCR_UART_RSP MS(30)
++#define Tcr_aud_det _MASK(30) /*!< ph_audio_wait - Timeout waiting for Carkit Audio ack */
++#define Tcr_aud_det_ _NOT(Tcr_aud_det)
++#define TCR_AUD_DET US(1000)
++#define Tph_led_off _MASK(30) /*!< ph_uart - Timeout for LED off pulse */
++#define Tph_led_off_ _NOT(Tph_led_off)
++#define TPH_LED_OFF US(10)
++#define Tph_led_on _MASK(30) /*!< ph_uart - Timeout for LED on pulse */
++#define Tph_led_on_ _NOT(Tph_led_on)
++#define TPH_LED_ON MS(4)
++#define Tcr_led_off _MASK(30) /*!< ph_uart - Timeout for LED off pulse */
++#define Tcr_led_off_ _NOT(Tcr_led_off)
++#define TCR_LED_OFF MS(4)
++#define Tcr_led_on _MASK(30) /*!< ph_uart - Timeout for LED on pulse */
++#define Tcr_led_on_ _NOT(Tcr_led_on)
++#define TCR_LED_ON MS(8)
++#define Tcr_dm_disc _MASK(30) /*!< cr_aud - Timeout for DM disconnect */
++#define Tcr_dm_disc_ _NOT(Tcr_dm_disc)
++#define TCR_DM_DISC MS(50)
++#define Tph_mono_ack _MASK(30) /*!< cr_wait - Timeout for CR INT */
++#define Tph_mono_ack_ _NOT(Tph_mono_ack)
++#define TPH_MONO_ACK MS(1)
++#define Tph_aud_det _MASK(30) /*!< cr_ack - Timeout for CR ACK */
++#define Tph_aud_det_ _NOT(Tph_aud_det)
++#define TPH_AUD_DET MS(100)
++ /* @} */
++
++ /*! @name Timeouts for timer test
++ * @{
++ */
++#define Tzero _MASK(30) /*!< otg_enabled - Startup */
++#define Tzero_ _NOT(Tzero)
++#define TZERO MS(2)
++#define Tst_one_ms _MASK(30) /*!< tm_start - Timer test */
++#define Tst_one_ms_ _NOT(Tst_one_ms)
++#define TST_ONE_MS MS(1)
++#define Tst_ten_ms _MASK(30) /*!< tm_start - Timer test */
++#define Tst_ten_ms_ _NOT(Tst_ten_ms)
++#define TST_TEN_MS MS(10)
++#define Tst_one_second _MASK(30) /*!< tm_start - Timer test */
++#define Tst_one_second_ _NOT(Tst_one_second)
++#define TST_ONE_SECOND SEC(1)
++#define Tst_two_second _MASK(30) /*!< tm_start - Timer test */
++#define Tst_two_second_ _NOT(Tst_two_second)
++#define TST_TWO_SECOND SEC(2)
++#define Tst_four_second _MASK(30) /*!< tm_start - Timer test */
++#define Tst_four_second_ _NOT(Tst_four_second)
++#define TST_FOUR_SECOND SEC(4)
++#define Tst_eight_second _MASK(30) /*!< tm_start - Timer test */
++#define Tst_eight_second_ _NOT(Tst_eight_second)
++#define TST_EIGHT_SECOND SEC(8)
++#define Tst_ten_second _MASK(30) /*!< tm_start - Timer test */
++#define Tst_ten_second_ _NOT(Tst_ten_second)
++#define TST_TEN_SECOND SEC(10)
++ /* @} */
++
++/* Generated by otg-outputs-h.awk
++ *
++ * Do not Edit this file.
++ */
++
++
++
++ /* State Machine Outputs
++ */
++
++ /*! @name Driver Initialization Outputs
++ * N.B. tcd_en is used for older devices, to check if Vbus
++ * already enabled.
++ * @{
++ */
++
++#define TCD_INIT_OUT 0 /*!< Initiate Transceiver Controller Driver Initialization (or De-initialization.) */
++#define tcd_init_out _setmask(TCD_INIT_OUT)
++#define tcd_init_out_ _resetmask(TCD_INIT_OUT)
++#define tcd_init_out_set _setmask(TCD_INIT_OUT)
++#define tcd_init_out_reset _resetmask(TCD_INIT_OUT)
++#define tcd_init_out_power _powermask(TCD_INIT_OUT)
++
++#define PCD_INIT_OUT 1 /*!< Initiate Peripheral Controller Driver Initialization (or De-initialization.) */
++#define pcd_init_out _setmask(PCD_INIT_OUT)
++#define pcd_init_out_ _resetmask(PCD_INIT_OUT)
++#define pcd_init_out_set _setmask(PCD_INIT_OUT)
++#define pcd_init_out_reset _resetmask(PCD_INIT_OUT)
++#define pcd_init_out_power _powermask(PCD_INIT_OUT)
++
++#define HCD_INIT_OUT 2 /*!< Initiate Host Controller Driver Initialization (or De-initialization). */
++#define hcd_init_out _setmask(HCD_INIT_OUT)
++#define hcd_init_out_ _resetmask(HCD_INIT_OUT)
++#define hcd_init_out_set _setmask(HCD_INIT_OUT)
++#define hcd_init_out_reset _resetmask(HCD_INIT_OUT)
++#define hcd_init_out_power _powermask(HCD_INIT_OUT)
++
++#define OCD_INIT_OUT 3 /*!< Initiate OTG Controller Driver Initialization (or De-initialization). */
++#define ocd_init_out _setmask(OCD_INIT_OUT)
++#define ocd_init_out_ _resetmask(OCD_INIT_OUT)
++#define ocd_init_out_set _setmask(OCD_INIT_OUT)
++#define ocd_init_out_reset _resetmask(OCD_INIT_OUT)
++#define ocd_init_out_power _powermask(OCD_INIT_OUT)
++
++#define TCD_EN_OUT 4 /*!< Enable Transceiver Controller Driver */
++#define tcd_en_out _setmask(TCD_EN_OUT)
++#define tcd_en_out_ _resetmask(TCD_EN_OUT)
++#define tcd_en_out_set _setmask(TCD_EN_OUT)
++#define tcd_en_out_reset _resetmask(TCD_EN_OUT)
++#define tcd_en_out_power _powermask(TCD_EN_OUT)
++
++#define PCD_EN_OUT 5 /*!< Enable Peripheral Controller Driver */
++#define pcd_en_out _setmask(PCD_EN_OUT)
++#define pcd_en_out_ _resetmask(PCD_EN_OUT)
++#define pcd_en_out_set _setmask(PCD_EN_OUT)
++#define pcd_en_out_reset _resetmask(PCD_EN_OUT)
++#define pcd_en_out_power _powermask(PCD_EN_OUT)
++
++#define HCD_EN_OUT 6 /*!< Enable Host Controller Driver */
++#define hcd_en_out _setmask(HCD_EN_OUT)
++#define hcd_en_out_ _resetmask(HCD_EN_OUT)
++#define hcd_en_out_set _setmask(HCD_EN_OUT)
++#define hcd_en_out_reset _resetmask(HCD_EN_OUT)
++#define hcd_en_out_power _powermask(HCD_EN_OUT)
++ /* @) */
++
++ /*! @name Transceiver Controller Driver Outputs
++ * @{
++ */
++
++#define DRV_VBUS_OUT 7 /*!< A-Device will Drive Vbus to 5V through charge pump. */
++#define drv_vbus_out _setmask(DRV_VBUS_OUT)
++#define drv_vbus_out_ _resetmask(DRV_VBUS_OUT)
++#define drv_vbus_out_set _setmask(DRV_VBUS_OUT)
++#define drv_vbus_out_reset _resetmask(DRV_VBUS_OUT)
++#define drv_vbus_out_power _powermask(DRV_VBUS_OUT)
++
++#define CHRG_VBUS_OUT 8 /*!< B-Device will charge Vbus to 3.3V through resistor (SRP.) */
++#define chrg_vbus_out _setmask(CHRG_VBUS_OUT)
++#define chrg_vbus_out_ _resetmask(CHRG_VBUS_OUT)
++#define chrg_vbus_out_set _setmask(CHRG_VBUS_OUT)
++#define chrg_vbus_out_reset _resetmask(CHRG_VBUS_OUT)
++#define chrg_vbus_out_power _powermask(CHRG_VBUS_OUT)
++
++#define DISCHRG_VBUS_OUT 9 /*!< B-Device will discharge Vbus (enable dischage resistor.) */
++#define dischrg_vbus_out _setmask(DISCHRG_VBUS_OUT)
++#define dischrg_vbus_out_ _resetmask(DISCHRG_VBUS_OUT)
++#define dischrg_vbus_out_set _setmask(DISCHRG_VBUS_OUT)
++#define dischrg_vbus_out_reset _resetmask(DISCHRG_VBUS_OUT)
++#define dischrg_vbus_out_power _powermask(DISCHRG_VBUS_OUT)
++
++#define DM_PULLUP_OUT 10 /*!< DM pullup control - aka loc_carkit */
++#define dm_pullup_out _setmask(DM_PULLUP_OUT)
++#define dm_pullup_out_ _resetmask(DM_PULLUP_OUT)
++#define dm_pullup_out_set _setmask(DM_PULLUP_OUT)
++#define dm_pullup_out_reset _resetmask(DM_PULLUP_OUT)
++#define dm_pullup_out_power _powermask(DM_PULLUP_OUT)
++
++#define DM_PULLDOWN_OUT 11 /*!< DM pulldown control */
++#define dm_pulldown_out _setmask(DM_PULLDOWN_OUT)
++#define dm_pulldown_out_ _resetmask(DM_PULLDOWN_OUT)
++#define dm_pulldown_out_set _setmask(DM_PULLDOWN_OUT)
++#define dm_pulldown_out_reset _resetmask(DM_PULLDOWN_OUT)
++#define dm_pulldown_out_power _powermask(DM_PULLDOWN_OUT)
++
++#define DP_PULLUP_OUT 12 /*!< DP pullup control - aka loc_conn */
++#define dp_pullup_out _setmask(DP_PULLUP_OUT)
++#define dp_pullup_out_ _resetmask(DP_PULLUP_OUT)
++#define dp_pullup_out_set _setmask(DP_PULLUP_OUT)
++#define dp_pullup_out_reset _resetmask(DP_PULLUP_OUT)
++#define dp_pullup_out_power _powermask(DP_PULLUP_OUT)
++
++#define DP_PULLDOWN_OUT 13 /*!< DP pulldown control */
++#define dp_pulldown_out _setmask(DP_PULLDOWN_OUT)
++#define dp_pulldown_out_ _resetmask(DP_PULLDOWN_OUT)
++#define dp_pulldown_out_set _setmask(DP_PULLDOWN_OUT)
++#define dp_pulldown_out_reset _resetmask(DP_PULLDOWN_OUT)
++#define dp_pulldown_out_power _powermask(DP_PULLDOWN_OUT)
++
++#define CLR_OVERCURRENT_OUT 14 /*!< Clear overcurrent indication */
++#define clr_overcurrent_out _setmask(CLR_OVERCURRENT_OUT)
++#define clr_overcurrent_out_ _resetmask(CLR_OVERCURRENT_OUT)
++#define clr_overcurrent_out_set _setmask(CLR_OVERCURRENT_OUT)
++#define clr_overcurrent_out_reset _resetmask(CLR_OVERCURRENT_OUT)
++#define clr_overcurrent_out_power _powermask(CLR_OVERCURRENT_OUT)
++
++#define DM_DET_OUT 15 /*!< Enable B-Device D- High detect */
++#define dm_det_out _setmask(DM_DET_OUT)
++#define dm_det_out_ _resetmask(DM_DET_OUT)
++#define dm_det_out_set _setmask(DM_DET_OUT)
++#define dm_det_out_reset _resetmask(DM_DET_OUT)
++#define dm_det_out_power _powermask(DM_DET_OUT)
++
++#define DP_DET_OUT 16 /*!< Enable B-Device D+ High detect */
++#define dp_det_out _setmask(DP_DET_OUT)
++#define dp_det_out_ _resetmask(DP_DET_OUT)
++#define dp_det_out_set _setmask(DP_DET_OUT)
++#define dp_det_out_reset _resetmask(DP_DET_OUT)
++#define dp_det_out_power _powermask(DP_DET_OUT)
++
++#define CR_DET_OUT 17 /*!< Enable D+ CR detect */
++#define cr_det_out _setmask(CR_DET_OUT)
++#define cr_det_out_ _resetmask(CR_DET_OUT)
++#define cr_det_out_set _setmask(CR_DET_OUT)
++#define cr_det_out_reset _resetmask(CR_DET_OUT)
++#define cr_det_out_power _powermask(CR_DET_OUT)
++
++#define CHARGE_PUMP_OUT 18 /*!< Enable external charge pump. */
++#define charge_pump_out _setmask(CHARGE_PUMP_OUT)
++#define charge_pump_out_ _resetmask(CHARGE_PUMP_OUT)
++#define charge_pump_out_set _setmask(CHARGE_PUMP_OUT)
++#define charge_pump_out_reset _resetmask(CHARGE_PUMP_OUT)
++#define charge_pump_out_power _powermask(CHARGE_PUMP_OUT)
++
++#define BDIS_ACON_OUT 19 /*!< Enable auto A-connect after B-disconnect. */
++#define bdis_acon_out _setmask(BDIS_ACON_OUT)
++#define bdis_acon_out_ _resetmask(BDIS_ACON_OUT)
++#define bdis_acon_out_set _setmask(BDIS_ACON_OUT)
++#define bdis_acon_out_reset _resetmask(BDIS_ACON_OUT)
++#define bdis_acon_out_power _powermask(BDIS_ACON_OUT)
++
++#define MX21_VBUS_DRAIN 20 /*!< MX21 hack */
++#define mx21_vbus_drain _setmask(MX21_VBUS_DRAIN)
++#define mx21_vbus_drain_ _resetmask(MX21_VBUS_DRAIN)
++#define mx21_vbus_drain_set _setmask(MX21_VBUS_DRAIN)
++#define mx21_vbus_drain_reset _resetmask(MX21_VBUS_DRAIN)
++#define mx21_vbus_drain_power _powermask(MX21_VBUS_DRAIN)
++
++#define ID_PULLDOWN_OUT 21 /*!< Enable the ID to ground pulldown ( (CEA-936 - 5 wire carkit.) */
++#define id_pulldown_out _setmask(ID_PULLDOWN_OUT)
++#define id_pulldown_out_ _resetmask(ID_PULLDOWN_OUT)
++#define id_pulldown_out_set _setmask(ID_PULLDOWN_OUT)
++#define id_pulldown_out_reset _resetmask(ID_PULLDOWN_OUT)
++#define id_pulldown_out_power _powermask(ID_PULLDOWN_OUT)
++
++#define UART_OUT 22 /*!< Enable Transparent UART mode (CEA-936.) */
++#define uart_out _setmask(UART_OUT)
++#define uart_out_ _resetmask(UART_OUT)
++#define uart_out_set _setmask(UART_OUT)
++#define uart_out_reset _resetmask(UART_OUT)
++#define uart_out_power _powermask(UART_OUT)
++
++#define AUDIO_OUT 23 /*!< Enable Audio mode (CEA-936 CarKit interrupt detector.) */
++#define audio_out _setmask(AUDIO_OUT)
++#define audio_out_ _resetmask(AUDIO_OUT)
++#define audio_out_set _setmask(AUDIO_OUT)
++#define audio_out_reset _resetmask(AUDIO_OUT)
++#define audio_out_power _powermask(AUDIO_OUT)
++
++#define MONO_OUT 24 /*!< Enable Mono-Audio mode (CEA-936.) */
++#define mono_out _setmask(MONO_OUT)
++#define mono_out_ _resetmask(MONO_OUT)
++#define mono_out_set _setmask(MONO_OUT)
++#define mono_out_reset _resetmask(MONO_OUT)
++#define mono_out_power _powermask(MONO_OUT)
++ /* @) */
++
++ /*! @name Peripheral Controller Driver Outputs
++ * @{
++ */
++
++#define REMOTE_WAKEUP_OUT 25 /*!< Peripheral will perform remote wakeup. */
++#define remote_wakeup_out _setmask(REMOTE_WAKEUP_OUT)
++#define remote_wakeup_out_ _resetmask(REMOTE_WAKEUP_OUT)
++#define remote_wakeup_out_set _setmask(REMOTE_WAKEUP_OUT)
++#define remote_wakeup_out_reset _resetmask(REMOTE_WAKEUP_OUT)
++#define remote_wakeup_out_power _powermask(REMOTE_WAKEUP_OUT)
++ /* @) */
++
++ /*! @name Host Controller Driver Outputs
++ * @{
++ */
++
++#define LOC_SOF_OUT 26 /*!< Host will enable packet traffic. */
++#define loc_sof_out _setmask(LOC_SOF_OUT)
++#define loc_sof_out_ _resetmask(LOC_SOF_OUT)
++#define loc_sof_out_set _setmask(LOC_SOF_OUT)
++#define loc_sof_out_reset _resetmask(LOC_SOF_OUT)
++#define loc_sof_out_power _powermask(LOC_SOF_OUT)
++
++#define LOC_SUSPEND_OUT 27 /*!< Host will suspend bus. */
++#define loc_suspend_out _setmask(LOC_SUSPEND_OUT)
++#define loc_suspend_out_ _resetmask(LOC_SUSPEND_OUT)
++#define loc_suspend_out_set _setmask(LOC_SUSPEND_OUT)
++#define loc_suspend_out_reset _resetmask(LOC_SUSPEND_OUT)
++#define loc_suspend_out_power _powermask(LOC_SUSPEND_OUT)
++
++#define REMOTE_WAKEUP_EN_OUT 28 /*!< Host will send remote wakeup enable or disable request. */
++#define remote_wakeup_en_out _setmask(REMOTE_WAKEUP_EN_OUT)
++#define remote_wakeup_en_out_ _resetmask(REMOTE_WAKEUP_EN_OUT)
++#define remote_wakeup_en_out_set _setmask(REMOTE_WAKEUP_EN_OUT)
++#define remote_wakeup_en_out_reset _resetmask(REMOTE_WAKEUP_EN_OUT)
++#define remote_wakeup_en_out_power _powermask(REMOTE_WAKEUP_EN_OUT)
++
++#define HNP_EN_OUT 29 /*!< Host will send HNP enable request. */
++#define hnp_en_out _setmask(HNP_EN_OUT)
++#define hnp_en_out_ _resetmask(HNP_EN_OUT)
++#define hnp_en_out_set _setmask(HNP_EN_OUT)
++#define hnp_en_out_reset _resetmask(HNP_EN_OUT)
++#define hnp_en_out_power _powermask(HNP_EN_OUT)
++
++#define HPWR_OUT 30 /*!< Host will enable high power (external charge pump.) */
++#define hpwr_out _setmask(HPWR_OUT)
++#define hpwr_out_ _resetmask(HPWR_OUT)
++#define hpwr_out_set _setmask(HPWR_OUT)
++#define hpwr_out_reset _resetmask(HPWR_OUT)
++#define hpwr_out_power _powermask(HPWR_OUT)
++ /* @) */
++#define MAX_OUTPUTS 31
++
++/* Generated by otg-ioctls-h.awk
++ *
++ * Do not Edit this file,
++ */
++
++
++#if defined(OTG_LINUX)
++
++#define OTGADMIN_MAGIC 'O'
++#define OTGADMIN_VERSION _IOR(OTGADMIN_MAGIC, 1, u64)
++#define OTGADMIN_STATUS _IOR(OTGADMIN_MAGIC, 3, struct otg_status_update)
++#define OTGADMIN_SET_FUNCTION _IOW(OTGADMIN_MAGIC, 4, struct otg_admin_command)
++#define OTGADMIN_GET_FUNCTION _IOR(OTGADMIN_MAGIC, 4, struct otg_admin_command)
++#define OTGADMIN_SET_INFO _IOW(OTGADMIN_MAGIC, 5, struct otg_firmware_info)
++#define OTGADMIN_GET_INFO _IOR(OTGADMIN_MAGIC, 5, struct otg_firmware_info)
++#define OTGADMIN_SET_STATE _IOW(OTGADMIN_MAGIC, 6, struct otg_state)
++#define OTGADMIN_GET_STATE _IOR(OTGADMIN_MAGIC, 6, struct otg_state)
++#define OTGADMIN_SET_TEST _IOW(OTGADMIN_MAGIC, 7, struct otg_test)
++#define OTGADMIN_GET_TEST _IOR(OTGADMIN_MAGIC, 7, struct otg_test)
++#define OTGADMIN_SET_SERIAL _IOW(OTGADMIN_MAGIC, 8, struct otg_admin_command)
++#define OTGADMIN_GET_SERIAL _IOR(OTGADMIN_MAGIC, 8, struct otg_admin_command)
++
++
++
++ /*!
++ * Signal Sent: a_bcon_no_tmout_req
++ * State Valid: otg_host
++ * Application on A-host wants Ta_wait_bcon timeout disabled (non-OTG mode).
++ */
++#define OTGADMIN_A_BCON_NO_TMOUT_REQ _IOW(OTGADMIN_MAGIC, 10, int)
++
++ /*!
++ * Signal Sent: a_hpwr_req
++ * State Valid: otg_host
++ * Application on A-host wants external charge pump enabled.
++ */
++#define OTGADMIN_A_HPWR_REQ _IOW(OTGADMIN_MAGIC, 11, int)
++
++ /*!
++ * Signal Sent: bus_drop
++ * State Valid: otg_ok
++ * Application on Device needs to power down bus.
++ */
++#define OTGADMIN_BUS_DROP _IOW(OTGADMIN_MAGIC, 12, int)
++
++ /*!
++ * Signal Sent: a_bus_drop
++ * State Valid: otg_ok
++ * Application on A-Device needs to power down bus.
++ */
++#define OTGADMIN_A_BUS_DROP _IOW(OTGADMIN_MAGIC, 13, int)
++
++ /*!
++ * Signal Sent: b_bus_drop
++ * State Valid: otg_ok
++ * Application on B-Device needs to disconnect from bus.
++ */
++#define OTGADMIN_B_BUS_DROP _IOW(OTGADMIN_MAGIC, 14, int)
++
++ /*!
++ * Signal Sent: bus_req
++ * State Valid: otg_ok
++ * Application on Device wants to use the bus.
++ */
++#define OTGADMIN_BUS_REQ _IOW(OTGADMIN_MAGIC, 15, int)
++
++ /*!
++ * Signal Sent: a_bus_req
++ * State Valid: otg_ok
++ * Application on A-Device wants to act as host
++ */
++#define OTGADMIN_A_BUS_REQ _IOW(OTGADMIN_MAGIC, 16, int)
++
++ /*!
++ * Signal Sent: b_bus_req
++ * State Valid: otg_ok
++ * Application on B-Device wants to act as host
++ */
++#define OTGADMIN_B_BUS_REQ _IOW(OTGADMIN_MAGIC, 17, int)
++
++ /*!
++ * Signal Sent: b_sess_req
++ * State Valid: otg_ok
++ * Application on B-Device to perform SRP (alias for b_srp_req.)
++ */
++#define OTGADMIN_B_SESS_REQ _IOW(OTGADMIN_MAGIC, 18, int)
++
++ /*!
++ * Signal Sent: suspend_req
++ * State Valid: otg_host
++ * Application on Device requests bus be suspended (alias for a_bus_req/.)
++ */
++#define OTGADMIN_SUSPEND_REQ _IOW(OTGADMIN_MAGIC, 19, int)
++
++ /*!
++ * Signal Sent: a_suspend_req
++ * State Valid: otg_host
++ * Application on A-host requests bus be suspended (alias for a_bus_req/.)
++ */
++#define OTGADMIN_A_SUSPEND_REQ _IOW(OTGADMIN_MAGIC, 20, int)
++
++ /*!
++ * Signal Sent: b_suspend_req
++ * State Valid: otg_host
++ * Application on B-host requests bus be suspended (alias for b_bus_req/.)
++ */
++#define OTGADMIN_B_SUSPEND_REQ _IOW(OTGADMIN_MAGIC, 21, int)
++
++ /*!
++ * Signal Sent: set_remote_wakeup_cmd
++ * State Valid: a_host
++ * A-Device will send Remote Wakeup Enable Request
++ */
++#define OTGADMIN_SET_REMOTE_WAKEUP_CMD _IOW(OTGADMIN_MAGIC, 22, int)
++
++ /*!
++ * Signal Sent: remote_wakeup_cmd
++ * State Valid: tr_configured
++ * B-Device will perform Remote Wakeup.
++ */
++#define OTGADMIN_REMOTE_WAKEUP_CMD _IOW(OTGADMIN_MAGIC, 23, int)
++
++ /*!
++ * Signal Sent: reset_remote_wakeup_cmd
++ * State Valid: a_host
++ * A-Device will send Remote Wakeup Disable Request
++ */
++#define OTGADMIN_RESET_REMOTE_WAKEUP_CMD _IOW(OTGADMIN_MAGIC, 24, int)
++
++ /*!
++ * Signal Sent: clr_err_cmd
++ * State Valid: a_vbus_err
++ * A-Device ill clears Vbus overcurrent error.
++ */
++#define OTGADMIN_CLR_ERR_CMD _IOW(OTGADMIN_MAGIC, 25, int)
++
++ /*!
++ * Signal Sent: b_hnp_cmd
++ * State Valid: b_configured
++ * B-Device will attempt HNP
++ */
++#define OTGADMIN_B_HNP_CMD _IOW(OTGADMIN_MAGIC, 26, int)
++
++ /*!
++ * Signal Sent: ph_int_cmd
++ * State Valid: ph_audio
++ * B-Device will request Carkit interrupt
++ */
++#define OTGADMIN_PH_INT_CMD _IOW(OTGADMIN_MAGIC, 27, int)
++
++ /*!
++ * Signal Sent: ph_audio_cmd
++ * State Valid: ph_uart
++ * Application on B-Device connected to Carkit requests audio mode.
++ */
++#define OTGADMIN_PH_AUDIO_CMD _IOW(OTGADMIN_MAGIC, 28, int)
++
++ /*!
++ * Signal Sent: cr_int_cmd
++ * State Valid: cr_aud
++ * Application on A-Device wants to emulate Carkit
++ */
++#define OTGADMIN_CR_INT_CMD _IOW(OTGADMIN_MAGIC, 29, int)
++
++ /*!
++ * Signal Sent: led_on_cmd
++ * State Valid: ph_uart
++ * B-Device will enable Carkit LED
++ */
++#define OTGADMIN_LED_ON_CMD _IOW(OTGADMIN_MAGIC, 30, int)
++
++ /*!
++ * Signal Sent: led_off_cmd
++ * State Valid: ph_uart
++ * B-Device will disable Carkit LED
++ */
++#define OTGADMIN_LED_OFF_CMD _IOW(OTGADMIN_MAGIC, 31, int)
++
++ /*!
++ * Signal Sent: enable_otg
++ * State Valid: otg_all
++ * Move State Machine otg_disabled state.
++ */
++#define OTGADMIN_ENABLE_OTG _IOW(OTGADMIN_MAGIC, 32, int)
++
++#define OTGADMIN_MAXNR 33
++
++
++#endif /* defined(OTG_LINUX) */
++
++/* Generated by otg-iocontrol-h.awk
++ *
++ * Do not Edit this file,
++ */
++
++
++#if defined(OTG_WINCE)
++
++#define OTGADMIN_BASE$ 0x401
++#define _USBLAN_CTL_CODE(_Function, _Method, _Access) \
++ CTL_CODE(OTGADMIN_BASE, _Function, _Method, _Access)
++
++#define OTGADMIN_VERSION OTGADMIN_CTL_CODE(0x401, METHOD_BUFFERRED, FILE_READ_ACCESS)
++#define OTGADMIN_STATUS OTGADMIN_CTL_CODE(0x403, METHOD_BUFFERRED, FILE_READ_ACCESS)
++#define OTGADMIN_SET_FUNCTION OTGADMIN_CTL_CODE(0x404, METHOD_BUFFERRED, FILE_WRITE_ACCESS)
++#define OTGADMIN_GET_FUNCTION OTGADMIN_CTL_CODE(0x404, METHOD_BUFFERRED, FILE_READ_ACCESS)
++#define OTGADMIN_SET_INFO OTGADMIN_CTL_CODE(0x405, METHOD_BUFFERRED, FILE_WRITE_ACCESS)
++#define OTGADMIN_GET_INFO OTGADMIN_CTL_CODE(0x405, METHOD_BUFFERRED, FILE_READ_ACCESS)
++#define OTGADMIN_SET_STATE OTGADMIN_CTL_CODE(0x406, METHOD_BUFFERRED, FILE_WRITE_ACCESS)
++#define OTGADMIN_GET_STATE OTGADMIN_CTL_CODE(0x406, METHOD_BUFFERRED, FILE_READ_ACCESS)
++#define OTGADMIN_SET_TEST OTGADMIN_CTL_CODE(0x407, METHOD_BUFFERRED, FILE_WRITE_ACCESS)
++#define OTGADMIN_GET_TEST OTGADMIN_CTL_CODE(0x407, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++
++
++ /*!
++ * Signal Sent: a_bcon_no_tmout_req
++ * State Valid: otg_host
++ * Application on A-host wants Ta_wait_bcon timeout disabled (non-OTG mode).
++ */
++#define OTGADMIN_A_BCON_NO_TMOUT_REQ OTGADMIN_CTL_CODE(, 0x40a, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: a_hpwr_req
++ * State Valid: otg_host
++ * Application on A-host wants external charge pump enabled.
++ */
++#define OTGADMIN_A_HPWR_REQ OTGADMIN_CTL_CODE(, 0x40b, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: bus_drop
++ * State Valid: otg_ok
++ * Application on Device needs to power down bus.
++ */
++#define OTGADMIN_BUS_DROP OTGADMIN_CTL_CODE(, 0x40c, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: a_bus_drop
++ * State Valid: otg_ok
++ * Application on A-Device needs to power down bus.
++ */
++#define OTGADMIN_A_BUS_DROP OTGADMIN_CTL_CODE(, 0x40d, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: b_bus_drop
++ * State Valid: otg_ok
++ * Application on B-Device needs to disconnect from bus.
++ */
++#define OTGADMIN_B_BUS_DROP OTGADMIN_CTL_CODE(, 0x40e, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: bus_req
++ * State Valid: otg_ok
++ * Application on Device wants to use the bus.
++ */
++#define OTGADMIN_BUS_REQ OTGADMIN_CTL_CODE(, 0x40f, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: a_bus_req
++ * State Valid: otg_ok
++ * Application on A-Device wants to act as host
++ */
++#define OTGADMIN_A_BUS_REQ OTGADMIN_CTL_CODE(, 0x410, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: b_bus_req
++ * State Valid: otg_ok
++ * Application on B-Device wants to act as host
++ */
++#define OTGADMIN_B_BUS_REQ OTGADMIN_CTL_CODE(, 0x411, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: b_sess_req
++ * State Valid: otg_ok
++ * Application on B-Device to perform SRP (alias for b_srp_req.)
++ */
++#define OTGADMIN_B_SESS_REQ OTGADMIN_CTL_CODE(, 0x412, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: suspend_req
++ * State Valid: otg_host
++ * Application on Device requests bus be suspended (alias for a_bus_req/.)
++ */
++#define OTGADMIN_SUSPEND_REQ OTGADMIN_CTL_CODE(, 0x413, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: a_suspend_req
++ * State Valid: otg_host
++ * Application on A-host requests bus be suspended (alias for a_bus_req/.)
++ */
++#define OTGADMIN_A_SUSPEND_REQ OTGADMIN_CTL_CODE(, 0x414, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: b_suspend_req
++ * State Valid: otg_host
++ * Application on B-host requests bus be suspended (alias for b_bus_req/.)
++ */
++#define OTGADMIN_B_SUSPEND_REQ OTGADMIN_CTL_CODE(, 0x415, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: set_remote_wakeup_cmd
++ * State Valid: a_host
++ * A-Device will send Remote Wakeup Enable Request
++ */
++#define OTGADMIN_SET_REMOTE_WAKEUP_CMD OTGADMIN_CTL_CODE(, 0x416, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: remote_wakeup_cmd
++ * State Valid: tr_configured
++ * B-Device will perform Remote Wakeup.
++ */
++#define OTGADMIN_REMOTE_WAKEUP_CMD OTGADMIN_CTL_CODE(, 0x417, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: reset_remote_wakeup_cmd
++ * State Valid: a_host
++ * A-Device will send Remote Wakeup Disable Request
++ */
++#define OTGADMIN_RESET_REMOTE_WAKEUP_CMD OTGADMIN_CTL_CODE(, 0x418, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: clr_err_cmd
++ * State Valid: a_vbus_err
++ * A-Device ill clears Vbus overcurrent error.
++ */
++#define OTGADMIN_CLR_ERR_CMD OTGADMIN_CTL_CODE(, 0x419, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: b_hnp_cmd
++ * State Valid: b_configured
++ * B-Device will attempt HNP
++ */
++#define OTGADMIN_B_HNP_CMD OTGADMIN_CTL_CODE(, 0x41a, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: ph_int_cmd
++ * State Valid: ph_audio
++ * B-Device will request Carkit interrupt
++ */
++#define OTGADMIN_PH_INT_CMD OTGADMIN_CTL_CODE(, 0x41b, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: ph_audio_cmd
++ * State Valid: ph_uart
++ * Application on B-Device connected to Carkit requests audio mode.
++ */
++#define OTGADMIN_PH_AUDIO_CMD OTGADMIN_CTL_CODE(, 0x41c, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: cr_int_cmd
++ * State Valid: cr_aud
++ * Application on A-Device wants to emulate Carkit
++ */
++#define OTGADMIN_CR_INT_CMD OTGADMIN_CTL_CODE(, 0x41d, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: led_on_cmd
++ * State Valid: ph_uart
++ * B-Device will enable Carkit LED
++ */
++#define OTGADMIN_LED_ON_CMD OTGADMIN_CTL_CODE(, 0x41e, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: led_off_cmd
++ * State Valid: ph_uart
++ * B-Device will disable Carkit LED
++ */
++#define OTGADMIN_LED_OFF_CMD OTGADMIN_CTL_CODE(, 0x41f, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++ /*!
++ * Signal Sent: enable_otg
++ * State Valid: otg_all
++ * Move State Machine otg_disabled state.
++ */
++#define OTGADMIN_ENABLE_OTG OTGADMIN_CTL_CODE(, 0x420, METHOD_BUFFERRED, FILE_READ_ACCESS)
++
++#define OTGADMIN_MAXNR 33
++
++
++#endif /* defined(OTG_WINCE) */
++
++/* Generated by otg-metas-h.awk
++ *
++ * Do not Edit thie file
++ */
++
++
++ /*! @name OTG Figure 6-2 Meta States
++ *
++ * These are the Meta States defined in the 2.0 OTG Specification
++ * Figure 6.2 - Dual-Role A-Device.
++ * @{
++ */
++
++#define m_a_idle 0 /* */
++
++#define m_a_wait_vrise 1 /* */
++
++#define m_a_wait_bcon 2 /* */
++
++#define m_a_host 3 /* */
++
++#define m_a_suspend 4 /* */
++
++#define m_a_peripheral 5 /* */
++
++#define m_a_wait_vfall 6 /* */
++
++#define m_a_vbus_err 7 /* */
++ /* @} */
++ /*! @name OTG Figure 6-3 Meta States
++ *
++ * These are the Meta States defined in the 2.0 OTG Specification
++ * Figure 6.3 - Dual-Role B-Device.
++ * @{
++ */
++
++#define m_b_idle 8 /* */
++
++#define m_b_srp_init 9 /* */
++
++#define m_b_peripheral 10 /* */
++
++#define m_b_suspend 11 /* */
++
++#define m_b_wait_acon 12 /* */
++
++#define m_b_host 13 /* */
++
++#define m_b_suspended 14 /* */
++ /* @} */
++ /*! @name Carkit Meta States Figure 7-7
++ *
++ * @{
++ */
++
++#define m_ph_disc 15 /* Equivalent to b_peripheral */
++
++#define m_ph_init 16 /* */
++
++#define m_ph_uart 17 /* */
++
++#define m_ph_aud 18 /* */
++
++#define m_ph_wait 19 /* */
++
++#define m_ph_exit 20 /* */
++
++#define m_cr_init 21 /* */
++
++#define m_cr_uart 22 /* */
++
++#define m_cr_aud 23 /* */
++
++#define m_cr_ack 24 /* */
++
++#define m_cr_wait 25 /* */
++
++#define m_cr_disc 26 /* */
++ /* @} */
++ /*! @name Additional states used locally.
++ *
++ * @{
++ */
++
++#define m_otg_init 27 /* */
++
++#define m_usb_accessory 28 /* */
++
++#define m_usb_factory 29 /* */
++
++#define m_unknown 30 /* */
++ /* @} */
++
++#define OTG_METAS_FW 31
++
++extern char *otg_meta_names[];
+diff -uNr linux/drivers/no-otg/otg/otg-hcd.h linux/drivers/otg/otg/otg-hcd.h
+--- linux/drivers/no-otg/otg/otg-hcd.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/otg-hcd.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,85 @@
++/*
++ * otg/otg-hcd.h - OTG Host Controller Driver
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ *
++ */
++/*!
++ * @defgroup OTGHCD Host Controller Driver Support
++ * @ingroup onthegogroup
++ */
++/*!
++ * @file otg/otg/otg-hcd.h
++ * @brief Defines common to On-The-Go Host Controller Support
++ *
++ * This file defines the hcd_ops and hcd_instance structures.
++ *
++ * The hcd_ops structure contains all of the output functions that will
++ * be called as required by the OTG event handler when changing states.
++ *
++ * The hcd_instance structure is used to maintain the global data
++ * required by the host controller drivers.
++ *
++ * @ingroup OTGHCD
++ */
++
++/*!
++ * @name HCD Host Controller Driver
++ * @{
++ */
++struct hcd_instance;
++
++/*!
++ * @struct hcd_ops
++ * The pcd_ops structure contains pointers to all of the functions implemented for the
++ * linked in driver. Having them in this structure allows us to easily determine what
++ * functions are available without resorting to ugly compile time macros or ifdefs
++ *
++ * There is only one instance of this, defined in the device specific lower layer.
++ */
++struct hcd_ops {
++
++ /* mandatory */
++ int max_ports; /*!< maximum number of ports available */
++ u32 capabilities; /*!< UDC Capabilities - see usbd-bus.h for details */
++ char *name; /*!< name of controller */
++
++ /* Driver Initialization - by degrees
++ */
++ int (*mod_init) (void); /*!< HCD Module Initialization */
++ void (*mod_exit) (void); /*!< HCD Module Exit */
++
++
++ otg_output_proc_t hcd_init_func; /*!< OTG calls to initialize or de-initialize the HCD */
++ otg_output_proc_t hcd_en_func; /*!< OTG calls to enable or disable the HCD */
++ otg_output_proc_t loc_sof_func; /*!< OTG calls to into a_host or b_host state - attempt to use port */
++ otg_output_proc_t loc_suspend_func; /*!< OTG calls to suspend bus */
++ otg_output_proc_t remote_wakeup_en_func; /*!< OTG calls to issue SET FEATURE REMOTE WAKEUP */
++ otg_output_proc_t hnp_en_func; /*!< OTG calls to issues SET FEATURE B_HNP_ENABLE */
++};
++
++/*!
++ * @struct hcd_instance
++ */
++struct hcd_instance {
++ struct otg_instance *otg; /*!< pointer to OTG Instance */
++ void * privdata; /*!< pointer to private data for PCD */
++ struct WORK_STRUCT bh; /*!< work structure for bottom half handler */
++};
++
++#define HCD hcd_trace_tag
++extern otg_tag_t HCD;
++extern struct hcd_ops hcd_ops;
++extern struct hcd_instance *hcd_instance;
++
++extern void hcd_init_func(struct otg_instance *, u8 );
++extern void hcd_en_func(struct otg_instance *, u8 );
++
++/* @} */
++
+diff -uNr linux/drivers/no-otg/otg/otg-linux.h linux/drivers/otg/otg/otg-linux.h
+--- linux/drivers/no-otg/otg/otg-linux.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/otg-linux.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,284 @@
++/*
++ * otg/otg/otg-linux.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ */
++
++/*!
++ * @file otg/otg/otg-linux.h
++ * @brief Linux OS Compatibility defines
++ *
++ * @ingroup OTGCore
++ */
++#ifndef _OTG_LINUX_H
++#define _OTG_LINUX_H 1
++
++
++
++#include <linux/config.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++#include <linux/init.h>
++#include <linux/ctype.h>
++#include <linux/slab.h>
++#include <asm/types.h>
++#include <asm/uaccess.h>
++#include <asm/semaphore.h>
++#include <asm/atomic.h>
++#include <linux/proc_fs.h>
++#include <linux/interrupt.h>
++#include <linux/random.h>
++#include <linux/sched.h>
++
++/*! @name Compilation Related
++ */
++
++/*! @{ */
++#undef PRAGMAPACK
++#define PACKED __attribute__((packed))
++#define INLINE __inline__
++
++/*! @} */
++
++/*! @name Memory Allocation Primitives
++ *
++ * CKMALLOC()
++ * LSTRDUP()
++ * LKFREE()
++ * LIST_ENTRY()
++ * LIST_FOR_EACH()
++ */
++
++ /*! @{ */
++
++#if defined(LINUX26)
++ #include <linux/gfp.h>
++#define GET_KERNEL_PAGE() __get_free_page(GFP_KERNEL)
++
++#else /* LINUX26 */
++
++ #include <linux/mm.h>
++ #define GET_KERNEL_PAGE() get_free_page(GFP_KERNEL)
++#endif /* LINUX26 */
++
++
++
++// Common to all supported versions of Linux ??
++
++#define CKMALLOC(n,f) _ckmalloc(__FUNCTION__, __LINE__, n, f)
++#define LSTRDUP(str) _lstrdup(__FUNCTION__, __LINE__, str)
++#define LKFREE(p) _lkfree(__FUNCTION__, __LINE__, p)
++
++#define ckmalloc(n,f) _ckmalloc(__FUNCTION__, __LINE__, n, f)
++#define lstrdup(str) _lstrdup(__FUNCTION__, __LINE__, str)
++#define lkfree(p) _lkfree(__FUNCTION__, __LINE__, p)
++
++#define OTG_MALLOC_TEST
++#undef OTG_MALLOC_DEBUG
++
++#ifdef OTG_MALLOC_TEST
++ extern int otg_mallocs;
++#endif
++
++
++static INLINE void *_ckmalloc (const char *func, int line, int n, int f)
++{
++ void *p;
++ if ((p = kmalloc (n, f)) == NULL) {
++ return NULL;
++ }
++ memset (p, 0, n);
++ #ifdef OTG_MALLOC_TEST
++ ++otg_mallocs;
++ #endif
++ #ifdef OTG_MALLOC_DEBUG
++ printk(KERN_INFO"%s: %p %s %d %d\n", __FUNCTION__, p, func, line, otg_mallocs);
++ #endif
++ return p;
++}
++
++static INLINE char *_lstrdup (const char *func, int line, char *str)
++{
++ int n;
++ char *s;
++ if (str && (n = strlen (str) + 1) && (s = kmalloc (n, GFP_ATOMIC))) {
++#ifdef OTG_MALLOC_TEST
++ ++otg_mallocs;
++#endif
++#ifdef OTG_MALLOC_DEBUG
++ printk(KERN_INFO"%s: %p %s %d %d\n", __FUNCTION__, s, func, line, otg_mallocs);
++#endif
++ return strcpy (s, str);
++ }
++ return NULL;
++}
++
++static INLINE void _lkfree (const char *func, int line, void *p)
++{
++ if (p) {
++#ifdef OTG_MALLOC_TEST
++ --otg_mallocs;
++#endif
++#ifdef OTG_MALLOC_DEBUG
++ printk(KERN_INFO"%s: %p %s %d %d\n", __FUNCTION__, p, func, line, otg_mallocs);
++#endif
++ kfree (p);
++#ifdef MALLOC_TEST
++ if (otg_mallocs < 0) {
++ printk(KERN_INFO"%s: %p %s %d %d otg_mallocs less zero!\n", __FUNCTION__, p, func, line, otg_mallocs);
++ }
++#endif
++#ifdef OTG_MALLOC_DEBUG
++ else {
++ printk(KERN_INFO"%s: %s %d NULL\n", __FUNCTION__, func, line);
++ }
++#endif
++ }
++}
++
++#if 1
++#include <linux/list.h>
++#define LIST_NODE struct list_head
++#define LIST_NODE_INIT(name) struct list_head name = {&name, &name}
++#define LIST_ENTRY(pointer, type, member) list_entry(pointer, type, member)
++#define LIST_FOR_EACH(cursor, head) list_for_each(cursor, head)
++#define LIST_ADD_TAIL(n,h) list_add_tail(n,h)
++#define LIST_DEL(h) list_del(&(h))
++#else
++#include <otg/otg-list.h>
++#endif
++
++/*! @} */
++
++
++/*! @name Atomic Operations
++ *
++ * atomic_post_inc()
++ * atomic_pre_dec()
++ */
++/*! @{ */
++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);
++}
++/*! @} */
++
++
++
++/*!@name Scheduling Primitives
++ *
++ * WORK_STRUCT
++ * WORK_ITEM
++ *
++ * SCHEDULE_TIMEOUT()\n
++ * SET_WORK_ARG()\n
++ * SCHEDULE_WORK()\n
++ * SCHEDULE_IMMEDIATE_WORK()\n
++ * NO_WORK_DATA()\n
++ * MOD_DEC_USE_COUNT\n
++ * MOD_INC_USE_COUNT\n
++ */
++
++/*! @{ */
++
++static void inline SCHEDULE_TIMEOUT(int seconds){
++ schedule_timeout( seconds * HZ );
++}
++
++
++/* Separate Linux 2.4 and 2.6 versions of scheduling primitives */
++#if defined(LINUX26)
++ #include <linux/workqueue.h>
++
++ #define WORK_STRUCT work_struct
++ #define WORK_ITEM work_struct
++ typedef struct WORK_ITEM WORK_ITEM;
++ #if 0
++ #define PREPARE_WORK_ITEM(__item,__routine,__data) INIT_WORK((__item),(__routine),(__data))
++ #else
++ #include <linux/interrupt.h>
++ #define PREPARE_WORK_ITEM(__item,__routine,__data) __prepare_work(&(__item),(__routine),(__data))
++ static inline void __prepare_work(struct work_struct *_work,
++ void (*_routine),
++ void * _data){
++ INIT_LIST_HEAD(&_work->entry);
++ _work->pending = 0;
++ _work->func = _routine;
++ _work->data = _data;
++ init_timer(&_work->timer);
++ }
++ #endif
++ #undef PREPARE_WORK
++ typedef void (* WORK_PROC)(void *);
++
++ #define SET_WORK_ARG(__item, __data) (__item).data = __data
++
++ #define SCHEDULE_WORK(item) schedule_work(&item)
++ #define SCHEDULE_IMMEDIATE_WORK(item) SCHEDULE_WORK((item))
++ #define PENDING_WORK_ITEM(item) (item.pending != 0)
++ #define NO_WORK_DATA(item) (!item.data)
++ #define _MOD_DEC_USE_COUNT //Not used in 2.6
++ #define _MOD_INC_USE_COUNT //Not used in 2.6
++
++#else /* LINUX26 */
++
++ #define WORK_STRUCT tq_struct
++ #define WORK_ITEM tq_struct
++ typedef struct WORK_ITEM WORK_ITEM;
++ #define PREPARE_WORK_ITEM(item,work_routine,work_data) { item.routine = work_routine; item.data = work_data; }
++ #define SET_WORK_ARG(__item, __data) (__item).data = __data
++ #define NO_WORK_DATA(item) (!(item).data)
++ #define SCHEDULE_WORK(item) schedule_task(&item)
++ #define PENDING_WORK_ITEM(item) (item.sync != 0)
++ #define _MOD_DEC_USE_COUNT MOD_DEC_USE_COUNT
++ #define _MOD_INC_USE_COUNT MOD_INC_USE_COUNT
++
++ typedef void (* WORK_PROC)(void *);
++
++ #if !defined(IRQ_HANDLED)
++ // Irq's
++ typedef void irqreturn_t;
++ #define IRQ_NONE
++ #define IRQ_HANDLED
++ #define IRQ_RETVAL(x)
++ #endif
++#endif /* LINUX26 */
++
++/*! @} */
++
++/*!@name Semaphores
++ *
++ * up()
++ * down()
++ */
++/*! @{ */
++#define UP(s) up(s)
++#define DOWN(s) down(s)
++/*! @} */
++
++/*! @name Printk
++ *
++ * PRINTK()
++ */
++/*! @{ */
++#define PRINTK(s) printk(s)
++/*! @} */
++
++
++#endif /* _OTG_LINUX_H */
+diff -uNr linux/drivers/no-otg/otg/otg-list.h linux/drivers/otg/otg/otg-list.h
+--- linux/drivers/no-otg/otg/otg-list.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/otg-list.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,69 @@
++#ifndef _OTG_LIST_H
++#define _OTG_LIST_H 1
++
++/*
++ This file defines doubly linked list capabilities
++ needed. Many operating systems have built in capabilities
++ which match and may possibly be borrowed.
++
++
++ Here is a typical implementation
++*/
++
++struct otg_list_node {
++ struct otg_list_node *previous, *next;
++};
++typedef struct otg_list_node otg_list_node_t, *otg_list_node_ptr;
++
++//A macro to define an list node within a structure
++#define OTG_LIST_HEAD struct otg_list_node
++#define OTG_LIST_HEAD_INIT(name) struct otg_list_node name = {&name, &name};
++//Assume that an OTG_LIST_HEAD pointer is embedded as structure
++// Recover numerical offset of member "member" within a pointer to a "type"
++#define __OTG_PTR_OFFSET(type, member) (u32) ( &(((type *) 0)->member) )
++//Recover typed pointer from pointer to interior of type at the given offset
++#define __OTG_PTR_CONTAINER(ptr, type, member) (type *) ((char *) ptr - __OTG_PTR_OFFSET(type,member))
++// member "member" of type "type". Recover a pointer to the beginning of the structure
++
++#define OTG_LIST_ENTRY(pointer, type, member) __OTG_PTR_CONTAINER(pointer, type, member)
++
++//Recover list header embedded in structure which is a member of a list
++#define OTG_LIST_MEMBER(pointer, member) &(ptr->member)
++//Add an entry at the logical end of the list
++
++//#define INLINE inline
++#define OTG_LIST_ADD_TAIL(new_entry, list_head) __otg_list_add_tail(new_entry, list_head)
++static INLINE void __otg_list_add_tail(struct otg_list_node *new_entry, struct otg_list_node *list_head)
++{
++ struct otg_list_node *old_previous = list_head->previous;
++ old_previous->next = new_entry;
++ new_entry->next = list_head;
++ new_entry->previous = old_previous;
++ list_head -> previous = new_entry;
++
++}
++
++//Delete an entry from the surrounding list
++#define OTG_LIST_DEL_ENTRY(del_entry) __otg_list_del_entry(&(del_entry))
++
++static void INLINE __otg_list_del_entry(struct otg_list_node *del_entry){
++ //Remove from list
++ del_entry->previous->next = del_entry->next;
++ del_entry->next->previous = del_entry->previous;
++ //Invalidate the entry
++ del_entry->previous = NULL;
++ del_entry->next = NULL;
++}
++
++#define OTG_LIST_FOR_EACH(cursor, list) for(cursor=(list)->next; cursor != (list); cursor=cursor->next)
++
++#undef LIST_HEAD
++#define LIST_HEAD OTG_LIST_HEAD
++#undef LIST_HEAD_INIT
++#define LIST_HEAD_INIT(name) OTG_LIST_HEAD_INIT(name)
++#define LIST_ENTRY(pointer,type,member) OTG_LIST_ENTRY(pointer,type,member)
++#define LIST_ADD_TAIL(new_entry, list_head) OTG_LIST_ADD_TAIL(new_entry, list_head)
++#define LIST_DEL_ENTRY(del_entry) OTG_LIST_DEL_ENTRY(del_entry)
++#define LIST_FOR_EACH(cursor, list) OTG_LIST_FOR_EACH(cursor, list)
++
++#endif /*_OTG_LIST_H */
+diff -uNr linux/drivers/no-otg/otg/otg-module.h linux/drivers/otg/otg/otg-module.h
+--- linux/drivers/no-otg/otg/otg-module.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/otg-module.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,71 @@
++/*
++ * otg/otg/otg-module.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ */
++/*!
++ * @file otg/otg/otg-module.h
++ * @brief Linux Module OS Compatibility defines
++ *
++ *
++ * @ingroup OTGCore
++ */
++#ifndef _OTG_MODULE_H
++#define _OTG_MODULE_H 1
++
++#if defined(OTG_LINUX)
++ #if !defined(_LINUX_MODULE_H)
++ #include <linux/module.h>
++ #endif /* _LINUX_MODULE_H */
++
++ #if defined(MODULE)
++
++ #define MOD_EXIT(exit_routine) module_exit(exit_routine)
++ #define MOD_INIT(init_routine) module_init(init_routine)
++ #define MOD_PROC(proc) (proc)
++ #define MOD_AUTHOR(string) MODULE_AUTHOR(string)
++ #define MOD_PARM(param, type) MODULE_PARM(param, type)
++ #define MOD_PARM_DESC(param,desc) MODULE_PARM_DESC(param, desc)
++ #define MOD_DESCRIPTION(description) MODULE_DESCRIPTION(description)
++ #define OTG_EXPORT_SYMBOL(symbol) EXPORT_SYMBOL(symbol)
++ #define OTG_EPILOGUE 1 /* EPILOGUE ROUTINE NEEDED */
++
++ #else /* defined(MODULE) */
++
++ #define MOD_EXIT(exit_routine)
++ #define MOD_INIT(init_routine) module_init(init_routine)
++ #define MOD_PROC(proc) NULL
++ #define MOD_AUTHOR(string)
++ #define MOD_PARM(param, type)
++ #define MOD_PARM_DESC(param,desc)
++ #define MOD_DESCRIPTION(description)
++ #define OTG_EXPORT_SYMBOL(symbol) //EXPORT_SYMBOL(symbol)
++ #undef EXPORT_SYMBOL
++ #define OTG_EPILOGUE 0 /* EPILOGUE ROUTINE NOT NEEDED */
++
++ #endif /* defined(MODULE) */
++
++ //#undef MODULE_AUTHOR
++ //#undef MODULE_DESCRIPTION
++ //#undef MODULE_PARM_DESC
++ //#undef MODULE_PARM
++ #if defined(LINUX24) || defined(LINUX26)
++ #include <linux/version.h>
++ #if defined(MODULE) && (LINUX_VERSION_CODE >= KERNEL_VERSION (2,4,17))
++ //"GPL License applies under certain cirumstances; consult your vendor for details"
++ #define EMBED_LICENSE() MODULE_LICENSE ("GPL")
++ #else
++ #define EMBED_LICENSE() //Operation not supported for earlier Linux kernels
++ #endif
++
++ #else /* defined(LINUX24) || defined(LINUX26) */
++ #error "Need to define EMBED_LICENSE for the current operating system"
++ #endif /* defined(LINUX24) || defined(LINUX26) */
++ #define EMBED_MODULE_INFO(section,moduleinfo) static char __##section##_module_info[] = moduleinfo "balden@belcarra.com"
++ #define EMBED_USBD_INFO(moduleinfo) EMBED_MODULE_INFO(usbd,moduleinfo)
++ #define GET_MODULE_INFO(section) __##section##_module_info
++#endif /* defined(OTG_LINUX) */
++
++
++#endif
+diff -uNr linux/drivers/no-otg/otg/otg-ocd.h linux/drivers/otg/otg/otg-ocd.h
+--- linux/drivers/no-otg/otg/otg-ocd.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/otg-ocd.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,94 @@
++/*
++ * otg/otg-ocd.h - OTG Controller Driver
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ *
++ */
++/*!
++ * @defgroup OTGOCD OTG Controller Driver Support
++ * @ingroup onthegogroup
++ */
++/*!
++ * @file otg/otg/otg-ocd.h
++ * @brief Defines common to On-The-Go OTG Controller Support
++ *
++ * This file defines the ocd_ops and ocd_instance structures.
++ *
++ * The ocd_ops structure contains all of the output functions that will
++ * be called as required by the OTG event handler when changing states.
++ *
++ * The ocd_instance structure is used to maintain the global data
++ * required by the OTG controller drivers.
++ *
++ * @ingroup OTGOCD
++ */
++
++/*!
++ * @name OCD OTG Controller Driver
++ * @{
++ */
++//struct ocd_instance;
++
++struct ocd_instance {
++ struct otg_instance *otg;
++ void * privdata;
++};
++
++
++typedef int (*otg_timer_callback_proc_t) (void *);
++
++#define OCD_CAPABILITIES_DR 1 << 0
++#define OCD_CAPABILITIES_PO 1 << 1
++#define OCD_CAPABILITIES_TR 1 << 2
++#define OCD_CAPABILITIES_HOST 1 << 3
++
++#define OCD_CAPABILITIES_AUTO 1 << 4
++
++
++/*!
++ * @struct ocd_ops
++ * The ocd_ops structure contains pointers to all of the functions implemented for the
++ * linked in driver. Having them in this structure allows us to easily determine what
++ * functions are available without resorting to ugly compile time macros or ifdefs
++ *
++ * There is only one instance of this, defined in the device specific lower layer.
++ */
++struct ocd_ops {
++
++ u32 capabilities; /* OCD Capabilities */
++
++ /* Driver Initialization - by degrees
++ */
++ int (*mod_init) (void); /*!< OCD Module Initialization */
++ void (*mod_exit) (void); /*!< OCD Module Exit */
++
++ otg_output_proc_t ocd_init_func; /*!< OTG calls to initialize or de-initialize the OCD */
++
++ int (*start_timer) (struct otg_instance *, int);/*!< called by OTG to start timer */
++ u64 (*ticks) (void); /*!< called by OTG to fetch current ticks, typically micro-seconds when available */
++ u64 (*elapsed) ( u64 *, u64 *); /*!< called by OTG to get micro-seconds elapsed between two ticks */
++ u32 interrupts; /*!< called by OTG to get number of interrupts */
++};
++
++
++#if 0
++struct ocd_instance {
++ struct otg_instance *otg;
++ void * privdata;
++};
++#endif
++
++#ifndef OTG_APPLICATION
++
++//#define OCD ocd_trace_tag
++extern otg_tag_t OCD;
++extern struct ocd_ops ocd_ops;
++extern struct ocd_instance *ocd_instance;
++#endif
++/* @} */
+diff -uNr linux/drivers/no-otg/otg/otg-p2k.h linux/drivers/otg/otg/otg-p2k.h
+--- linux/drivers/no-otg/otg/otg-p2k.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/otg-p2k.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,208 @@
++/*
++ * otg/otg/otg-p2k.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ */
++/*!
++ * @file otg/otg/otg-p2k.h
++ * @brief Linux OS Compatibility defines
++ *
++ * @ingroup OTGCore
++ */
++
++#ifndef _OTG_P2K_H 1
++#define _OTG_P2K_H 1
++
++/*!@name Common Platform 2000 includes
++ */
++/*! * @{ */
++
++/* UNKNOWN SO FAR */
++/*! @} */
++
++/*!@name Compilation Related
++ */
++
++/*! @{ */
++#define PRAGMAPACK
++#define PACKED
++#define INLINE __inline
++
++/*! @} */
++
++/*!@name OTG int typedefs
++ */
++/*! * @{ */
++typedef unsigned short u16;
++typedef unsigned char u8;
++typedef unsigned long int u32;
++typedef __int64 u64;
++typedef unsigned char __u8;
++typedef unsigned short __u16;
++typedef unsigned long int __u32;
++typedef __int64 __u64;
++
++/*! @} */
++
++/*!@name Memory Allocation Primitives
++ *
++ * CKMALLOC()
++ * LSTRDUP()
++ * LKFREE()
++ * LIST_ENTRY()
++ */
++/*! @{ */
++
++#define GFP_KERNEL 0
++#define GFP_ATOMIC 0
++
++#define CKMALLOC(n,f) _ckmalloc(__FILE__, __LINE__, n, f)
++#define LSTRDUP(str) _lstrdup(__FILE__, __LINE__, str)
++#define LKFREE(p) _lkfree(__FILE__, __LINE__, p)
++
++#define OTG_MALLOC_TEST
++#undef OTG_MALLOC_DEBUG
++
++#ifdef OTG_MALLOC_TEST
++ extern int otg_mallocs;
++#endif
++
++static INLINE void *_ckmalloc (const char *func, int line, int n, int f)
++{
++
++ return 0;
++}
++static INLINE char *_lstrdup (const char *func, int line, char *str)
++{
++
++ return 0;
++}
++static INLINE void _lkfree (const char *func, int line, void *p)
++{
++}
++
++// XXX
++#define LIST_ENTRY(p, t, m) \
++ ((t *)((char *)(p)-(unsigned long)(&((t *)0)->m)))
++
++// XXX
++#define LIST_FOR_EACH(p, h) \
++ for (p = (h)->next, (p->next); p != (h); \
++ p = p->next, (p->next))
++
++#define LIST_ADD_TAIL(n,h) (0)
++#define LIST_ADD_TAIL(n,h) (0)
++#define LIST_DEL(h) (0)
++
++
++/*! @} */
++
++
++/*! @name Atomic Operations
++ *
++ * atomic_post_inc()
++ * atomic_pre_dec()
++ */
++/*! @{ */
++
++/* @} */
++
++
++
++/*! @name Scheduling Primitives
++ *
++ * WORK_STRUCT
++ * WORK_ITEM
++ *
++ * SCHEDULE_TIMEOUT()
++ * SET_WORK_ARG()
++ * SCHEDULE_WORK()
++ * SCHEDULE_IMMEDIATE_WORK()
++ * NO_WORK_DATA()
++ * MOD_DEC_USE_COUNT
++ * MOD_INC_USE_COUNT
++ */
++/*! @{ */
++#define HZ 60
++#define SCHEDULE_TIMEOUT(seconds)
++
++ #define SCHEDULE_WORK(item) (0)
++#define PENDING_WORK_ITEM(item) (0)
++#define PREPARE_WORK_ITEM(__item,__routine,__data) (0)
++
++/*! @} */
++
++
++/*! @name Semaphores
++ *
++ * up()
++ * down()
++ */
++/*! @{ */
++#define UP(s)
++#define DOWN(s)
++/*! @} */
++
++
++/*!@name Printk
++ *
++ * PRINTK()
++ */
++/*! @{ */
++//#define PRINTK(s) printk(s)
++// DEBUGMSG(ZONE_INIT,(_T("OTGCORE - CORE - %s"), _T(msg)));
++
++/*! @} */
++
++/*! @name Little Endian Macros
++ * /
++ *! @{
++ */
++
++__inline u16 cpu_to_le16 ( u16 x )
++{
++ return (x<<8) | (x>>8);
++}
++
++__inline u16 le16_to_cpu ( u16 val )
++{
++ return ((((val) >> 8) & 0xff) | (((val) & 0xff) << 8));
++}
++
++__inline u32 le32_to_cpu (u32 val)
++{
++ return (((val) & 0xff000000) >> 24) | (((val) & 0x00ff0000) >> 8) |
++ (((val) & 0x0000ff00) << 8) | (((val) & 0x000000ff) << 24);
++}
++/*! @} */
++
++/*! @name little endian macros
++ */
++/*! @{ */
++#define local_irq_save(f) f = 0; __asm cli
++#define local_irq_restore(f) __asm sti
++
++/*! @} */
++
++/*! @name Ioctl
++ */
++/*! @{ */
++#define _IOR(m,n,s) ((m)|(n))
++#define _IOW(m,n,s) ((m)|(n))
++#define _IOCSIZE(a) (sizeof(a))
++#define copy_from_user(d,s,n) memcpy(d,s,n)
++#define copy_to_user(d,s,n) memcpy(d,s,n)
++
++/*! @} */
++
++/*! @name ERRNO
++ */
++/*! @{ */
++#define EINVAL WSAEINVAL
++
++/*! @} */
++
++
++
++#endif /* _OTG_P2K_H */
+diff -uNr linux/drivers/no-otg/otg/otg-pcd.h linux/drivers/otg/otg/otg-pcd.h
+--- linux/drivers/no-otg/otg/otg-pcd.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/otg-pcd.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,84 @@
++/*
++ * otg/otg-pcd.h - OTG Peripheral Controller Driver
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++
++/*!
++ * @defgroup OTGPCD Peripheral Controller Driver Support
++ * @ingroup onthegogroup
++ */
++/*!
++ * @file otg/otg/otg-pcd.h
++ * @brief Defines common to On-The-Go Peripheral Controller Support
++ *
++ * This file defines the pcd_ops and pcd_instance structures.
++ *
++ * The pcd_ops structure contains all of the output functions that will
++ * be called as required by the OTG event handler when changing states.
++ *
++ * The pcd_instance structure is used to maintain the global data
++ * required by the peripheral controller drivers.
++ *
++ * @ingroup OTGPCD
++ */
++
++/*!
++ * @name PCD Peripheral Controller Driver
++ * @{
++ */
++typedef u16 (*framenum_t)(void);
++
++/*!
++ * @struct pcd_ops
++ *
++ * The pcd_ops structure contains pointers to all of the functions implemented for the
++ * linked in driver. Having them in this structure allows us to easily determine what
++ * functions are available without resorting to ugly compile time macros or ifdefs
++ *
++ * There is only one instance of this, defined in the device specific lower layer.
++ */
++struct pcd_ops {
++
++ int (*mod_init) (void); /*!< PCD Module Initialization */
++ void (*mod_exit) (void); /*!< PCD Module Exit */
++
++ otg_output_proc_t pcd_init_func; /*!< OTG calls to initialize or de-initialize the PCD */
++ otg_output_proc_t pcd_en_func; /*!< OTG calls to enable or disable the PCD */
++ otg_output_proc_t remote_wakeup_func; /*!< OTG calls to have PCD perform remote wakeup */
++
++ framenum_t framenum; /*!< OTG calls to get current USB Frame number */
++};
++
++#define PCD pcd_trace_tag
++extern otg_tag_t PCD;
++extern struct pcd_ops pcd_ops;
++extern struct pcd_instance *pcd_instance;
++
++/*!
++ * @struct pcd_instance
++ */
++struct pcd_instance {
++ struct otg_instance *otg; /*!< pointer to OTG Instance */
++ struct usbd_bus_instance *bus; /*!< pointer to usb bus instance */
++ void * privdata; /*!< pointer to private data for PCD */
++ int pcd_exiting; /*!< non-zero if OTG is unloading */
++ struct WORK_STRUCT bh; /*!< work structure for bottom half handler */
++
++};
++
++
++#if !defined(OTG_C99)
++extern void pcd_global_init(void);
++#endif /* !defined(OTG_C99) */
++extern void pcd_init_func(struct otg_instance *, u8 );
++extern void pcd_en_func(struct otg_instance *, u8 );
++
++/* @} */
++
+diff -uNr linux/drivers/no-otg/otg/otg-tcd.h linux/drivers/otg/otg/otg-tcd.h
+--- linux/drivers/no-otg/otg/otg-tcd.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/otg-tcd.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,114 @@
++/*
++ * otg/otg-tcd.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++
++/*!
++ * @defgroup OTGTCD Transceiver Controller Driver Support
++ * @ingroup onthegogroup
++ */
++/*!
++ * @file otg/otg/otg-tcd.h
++ * @brief Defines common to On-The-Go Transceiver Controller Support
++ *
++ * This file defines the tcd_ops and tcd_instance structures.
++ *
++ * The tcd_ops structure contains all of the output functions that will
++ * be called as required by the OTG event handler when changing states.
++ *
++ * The tcd_instance structure is used to maintain the global data
++ * required by the transceiver controller drivers.
++ *
++ * @ingroup OTGTCD
++ */
++
++/*!
++ * @name TCD Transceiver Controller Driver
++ * @{
++ */
++
++
++/*!
++ * @struct tcd_ops
++ * The pcd_ops structure contains pointers to all of the functions implemented for the
++ * linked in driver. Having them in this structure allows us to easily determine what
++ * functions are available without resorting to ugly compile time macros or ifdefs
++ *
++ * There is only one instance of this, defined in the device specific lower layer.
++ */
++struct tcd_ops {
++ u64 initial_state;
++
++ void * privdata;
++
++ /* Driver Initialization - by degrees
++ */
++ int (*mod_init) (void); /*!< TCD Module Initialization */
++ void (*mod_exit) (void); /*!< TCD Module Exit */
++
++
++ /* 3. called for usbd_vbus() if defined */
++ int (*vbus) (struct otg_instance *); /* return non-zero if the Vbus valid */
++ int (*id) (struct otg_instance *); /* return non-zero if the ID valid */
++
++ /* 4. called by otg event to control outputs
++ */
++
++ otg_output_proc_t tcd_init_func; /*!< OTG calls to initialize or de-initialize the HCD */
++ otg_output_proc_t tcd_en_func; /*!< OTG calls to enable or disable the TCD */
++ otg_output_proc_t chrg_vbus_func; /*!< OTG calls to enable or disable charging Vbus */
++ otg_output_proc_t drv_vbus_func; /*!< OTG calls to enable or disable Vbus */
++ otg_output_proc_t dischrg_vbus_func; /*!< OTG calls to enable or disable discharging Vbus */
++ otg_output_proc_t dp_pullup_func; /*!< OTG calls to enable or disable D+ pullup (aka loc_conn) */
++ otg_output_proc_t dm_pullup_func; /*!< OTG calls to enable or disable D- pullup (aka loc_carkit) */
++ otg_output_proc_t dp_pulldown_func; /*!< OTG calls to enable or disable D+ pulldown (aka loc_conn) */
++ otg_output_proc_t dm_pulldown_func; /*!< OTG calls to enable or disable D- pulldown (aka loc_carkit) */
++ otg_output_proc_t peripheral_host_func; /*!< OTG calls to enable or disable D- pulldown (aka loc_carkit) */
++ otg_output_proc_t overcurrent_func; /*!< OTG calls to clear overcurrent indication */
++ otg_output_proc_t dm_det_func; /*!< OTG calls to enable or disable D+ pullup detection */
++ otg_output_proc_t dp_det_func; /*!< OTG calls to enable or disable D- pullup detection */
++ otg_output_proc_t cr_det_func; /*!< OTG calls to enable or disable D+ CRINT detection */
++ otg_output_proc_t charge_pump_func; /*!< OTG calls to enable or disable external charge pump */
++ otg_output_proc_t bdis_acon_func; /*!< OTG calls to enable or disable the BDIS ACON feature */
++ otg_output_proc_t mx21_vbus_drain_func; /*!< OTG calls to enable or disable the mx21 vbus drain feature */
++ otg_output_proc_t id_pulldown_func; /*!< OTG calls to enable or disable ID pulldown to ground */
++ otg_output_proc_t audio_func; /*!< OTG calls to enable or disable audio function */
++ otg_output_proc_t uart_func; /*!< OTG calls to enable or disable uart function */
++ otg_output_proc_t mono_func; /*!< OTG calls to enable or disable mono function */
++};
++
++/*!
++ * @struct hcd_instance
++ */
++struct tcd_instance {
++ struct otg_instance *otg; /*!< pointer to OTG Instance */
++ struct WORK_STRUCT bh; /*!< work structure for bottom half handler */
++};
++
++
++extern struct trace_ops trace_ops;
++extern struct tcd_ops tcd_ops;
++
++
++extern struct tcd_instance *tcd_instance;
++extern int tcd_vbus (struct otg_instance *otg);
++
++/* pcd_cable_event[_irq] - these can be called in a traditional PCD implementation
++ * to set b_sess_vld appropriately when vbus is sensed (pcd must implement ocd_ops.vbus)
++ */
++extern void tcd_cable_event_irq (struct otg_instance *);
++extern void tcd_cable_event (struct otg_instance *);
++
++//extern void tcd_init(struct otg_instance *, u8 );
++
++#define TCD tcd_trace_tag
++extern otg_tag_t TCD;
++
++/* @} */
+diff -uNr linux/drivers/no-otg/otg/otg-trace.h linux/drivers/otg/otg/otg-trace.h
+--- linux/drivers/no-otg/otg/otg-trace.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/otg-trace.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,404 @@
++/*
++ * otg/otgcore/otg-trace.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ *
++ */
++/*!
++ * @file otg/otg/otg-trace.h
++ * @brief Core Defines for USB OTG Core Layaer
++ *
++ * 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 up to 9 arguments are now supported, but you have to supply the number
++ * of args, since examining the format string for the number at trace event time
++ * was deemed too expensive time-wise.
++ *
++ *
++ * @ingroup OTGCore
++ */
++
++#ifndef OTG_TRACE_H
++#define OTG_TRACE_H 1
++
++//#include <linux/interrupt.h>
++
++
++
++typedef u8 otg_tag_t; // 1-origin tags (0 ==> invalid/unused trace entry. Max is 32.
++
++#ifdef PRAGMAPACK
++#pragma pack(push,1)
++#endif /* PRAGMAPACK */
++typedef enum otg_trace_types {
++ otg_trace_msg_invalid_n,
++ otg_trace_msg_va_start_n,
++ otg_trace_msg_va_list_n,
++ otg_trace_setup_n,
++ otg_trace_msg_n,
++ otg_trace_msg32_n,
++ otg_trace_msg16_n,
++ otg_trace_msg8_n
++} PACKED otg_trace_types_t;
++#ifdef PRAGMAPACK
++#pragma pack(pop)
++#endif /* PRAGMAPACK */
++
++typedef struct otg_trace_msg {
++ char *msg;
++} otg_trace_msg_t;
++
++typedef struct otg_trace_msg32 {
++ char *msg;
++ u32 val;
++} otg_trace_msg32_t;
++
++typedef struct otg_trace_msg16 {
++ char *msg;
++ u16 val0;
++ u16 val1;
++} otg_trace_msg16_t;
++
++typedef struct otg_trace_msg8 {
++ char *msg;
++ u8 val0;
++ u8 val1;
++ u8 val2;
++ u8 val3;
++} otg_trace_msg8_t;
++
++#define OTG_TRACE_MAX_IN_VA 7
++typedef struct otg_trace_msg_va_list {
++ u32 val[OTG_TRACE_MAX_IN_VA];
++} otg_trace_msg_va_list_t;
++
++typedef struct otg_trace_msg_va_start {
++ const char *function;
++ u32 interrupts;
++ u64 ticks;
++ u16 framenum;
++ u16 dummy;
++
++ union {
++ otg_trace_msg_t msg;
++ otg_trace_msg8_t msg8;
++ otg_trace_msg16_t msg16;
++ otg_trace_msg32_t msg32;
++
++#if !defined(BELCARRA_DEBUG)
++ struct usbd_device_request setup;
++#else
++ unsigned char setup[8];
++#endif /* !defined(BELCARRA_DEBUG) */
++
++ } trace;
++} PACKED otg_trace_msg_va_start_t;
++
++typedef struct trace {
++ otg_trace_types_t otg_trace_type;
++ otg_tag_t tag;
++ u8 va_num_args;
++ u8 in_interrupt:1;
++ u8 id_gnd:1;
++ union {
++ otg_trace_msg_va_start_t s;
++ otg_trace_msg_va_list_t l;
++ } va;
++} PACKED otg_trace_t;
++
++#define TRACE_MAX_IS_2N 1
++#define TRACE_MAX 0x00008000
++#define TRACE_MASK 0x00007FFF
++//#define TRACE_MAX 0x000080
++//#define TRACE_MASK 0x00007F
++
++
++#if defined(CONFIG_OTG_TRACE) || defined(CONFIG_OTG_TRACE_MODULE)
++
++#if !defined(OLD_TRACE_API)
++
++// The new API hides otg_trace_get_next(), and adds otg_trace_setup() as part of the core.
++
++#if !defined(BELCARRA_DEBUG)
++extern void otg_trace_setup(otg_tag_t tag, const char *fn, void *setup);
++#define TRACE_SETUP(tag,setup) otg_trace_setup(tag,__FUNCTION__,setup)
++#endif
++#define TRACE_MSG0(tag, msg) otg_trace_msg(tag, __FUNCTION__, 0, msg, 0)
++#define TRACE_FMSG0(tag, f, msg) otg_trace_msg(tag, f, 0, msg, 0)
++
++#else
++
++extern int otg_trace_first;
++extern int otg_trace_last_read;
++extern int otg_trace_next;
++
++#if 0
++
++extern otg_trace_t *otg_traces;
++
++
++otg_trace_t *otg_trace_get_next(otg_tag_t tag, const char *fn, otg_trace_types_t otg_trace_type, int n);
++
++#if !defined(BELCARRA_DEBUG)
++/*
++ * Trace a setup packet.
++ * The BELCARRA_DEBUG guard is so the rest of these functions can be used
++ * outside of a USB context, such as debugging TTY flow control.
++ */
++static __inline__ void otg_trace_setup(otg_tag_t tag, const char *fn, struct usbd_device_request *setup)
++{
++ if (otg_traces) {
++ otg_trace_t *p = otg_trace_get_next(tag,fn,otg_trace_setup_n,1);
++ memcpy(&p->va.s.trace.setup, setup, sizeof(struct usbd_device_request));
++ }
++}
++#define TRACE_SETUP(tag,setup) otg_trace_setup(tag,__FUNCTION__,setup)
++#endif /* !defined(BELCARRA_DEBUG) */
++
++/*
++ * Trace a single non-parameterized message.
++ */
++static __inline__ void otg_trace_msg_0(otg_tag_t tag, const char *fn, char *msg)
++{
++ if (otg_traces) {
++ otg_trace_t *p = otg_trace_get_next(tag,fn,otg_trace_msg_n,1);
++ p->va.s.trace.msg.msg = msg;
++ }
++}
++#define TRACE_MSG0(tag, msg) otg_trace_msg_0(tag, __FUNCTION__, msg)
++#define TRACE_FMSG0(tag, f, msg) otg_trace_msg_0(tag, f, msg)
++
++/*
++ * Trace a message with a single 32-bit value.
++ */
++static __inline__ void otg_trace_msg_1xU32(otg_tag_t tag, const char *fn, char *fmt, u32 val)
++{
++ if (otg_traces) {
++ otg_trace_t *p = otg_trace_get_next(tag,fn,otg_trace_msg32_n,1);
++ p->va.s.trace.msg32.val = val;
++ p->va.s.trace.msg32.msg = fmt;
++ }
++}
++#define OTRACE_MSG1(tag,fmt,val) otg_trace_msg_1xU32(tag,__FUNCTION__,fmt,(u32)val)
++
++/*
++ * Trace a message with two 16-bit values.
++ */
++static __inline__ void otg_trace_msg_2xU16(otg_tag_t tag, const char *fn, char *fmt, u16 val0, u16 val1)
++{
++ if (otg_traces) {
++ otg_trace_t *p = otg_trace_get_next(tag,fn,otg_trace_msg16_n,1);
++ p->va.s.trace.msg16.val0 = val0;
++ p->va.s.trace.msg16.val1 = val1;
++ p->va.s.trace.msg16.msg = fmt;
++ }
++}
++#define OTRACE_MSG2(tag,fmt,val0,val1) otg_trace_msg_2xU16(tag,__FUNCTION__,fmt,(u16)val0,(u16)val1)
++
++/*
++ * Trace a message with four 8-bit values.
++ */
++static __inline__ void otg_trace_msg_4xU8(otg_tag_t tag, const char *fn, char *fmt, u8 val0, u8 val1, u8 val2, u8 val3)
++{
++ if (otg_traces) {
++ otg_trace_t *p = otg_trace_get_next(tag,fn,otg_trace_msg8_n,1);
++ p->va.s.trace.msg8.val0 = val0;
++ p->va.s.trace.msg8.val1 = val1;
++ p->va.s.trace.msg8.val2 = val2;
++ p->va.s.trace.msg8.val3 = val3;
++ p->va.s.trace.msg8.msg = fmt;
++ }
++}
++#define OTRACE_MSG4(tag,fmt,val0,val1,val2,val3) otg_trace_msg_4xU8(tag,__FUNCTION__,fmt,(u8)val0,(u8)val1,(u8)val2,(u8)val3)
++#endif
++
++#endif
++
++extern void otg_trace_msg(otg_tag_t tag, const char *fn, u8 nargs, char *fmt, ...);
++
++#define eprintf(format, args...) printk (KERN_INFO format , ## args)
++
++#define TRACE_MSG(tag, nargs, fmt, args...) otg_trace_msg(tag, __FUNCTION__, nargs, fmt, ## args)
++
++#define TRACE_MSG1(tag, fmt, a1) \
++ otg_trace_msg(tag, __FUNCTION__, 1, fmt, a1)
++#define TRACE_MSG2(tag, fmt, a1, a2) \
++ otg_trace_msg(tag, __FUNCTION__, 2, fmt, a1, a2)
++#define TRACE_MSG3(tag, fmt, a1, a2, a3) \
++ otg_trace_msg(tag, __FUNCTION__, 3, fmt, a1, a2, a3)
++#define TRACE_MSG4(tag, fmt, a1, a2, a3, a4) \
++ otg_trace_msg(tag, __FUNCTION__, 4, fmt, a1, a2, a3, a4)
++#define TRACE_MSG5(tag, fmt, a1, a2, a3, a4, a5) \
++ otg_trace_msg(tag, __FUNCTION__, 5, fmt, a1, a2, a3, a4, a5)
++#define TRACE_MSG6(tag, fmt, a1, a2, a3, a4, a5, a6) \
++ otg_trace_msg(tag, __FUNCTION__, 6, fmt, a1, a2, a3, a4, a5, a6)
++#define TRACE_MSG7(tag, fmt, a1, a2, a3, a4, a5, a6, a7) \
++ otg_trace_msg(tag, __FUNCTION__, 7, fmt, a1, a2, a3, a4, a5, a6, a7)
++#define TRACE_MSG8(tag, fmt, a1, a2, a3, a4, a5, a6, a7, a8) \
++ otg_trace_msg(tag, __FUNCTION__, 8, fmt, a1, a2, a3, a4, a5, a6, a7, a8)
++#if 0
++#define TRACE_MSG9(tag, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9) \
++ otg_trace_msg(tag, __FUNCTION__, 9, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9)
++#endif
++#define TRACE_FMSG1(tag, f, fmt, a1) \
++ otg_trace_msg(tag, f, 1, fmt, a1)
++#define TRACE_FMSG2(tag, f, fmt, a1, a2) \
++ otg_trace_msg(tag, f, 2, fmt, a1, a2)
++#define TRACE_FMSG3(tag, f, fmt, a1, a2, a3) \
++ otg_trace_msg(tag, f, 3, fmt, a1, a2, a3)
++#define TRACE_FMSG4(tag, f, fmt, a1, a2, a3, a4) \
++ otg_trace_msg(tag, f, 4, fmt, a1, a2, a3, a4)
++#define TRACE_FMSG5(tag, f, fmt, a1, a2, a3, a4, a5) \
++ otg_trace_msg(tag, f, 5, fmt, a1, a2, a3, a4, a5)
++#define TRACE_FMSG6(tag, f, fmt, a1, a2, a3, a4, a5, a6) \
++ otg_trace_msg(tag, f, 6, fmt, a1, a2, a3, a4, a5, a6)
++#define TRACE_FMSG7(tag, f, fmt, a1, a2, a3, a4, a5, a6, a7) \
++ otg_trace_msg(tag, f, 7, fmt, a1, a2, a3, a4, a5, a6, a7)
++#define TRACE_FMSG8(tag, f, fmt, a1, a2, a3, a4, a5, a6, a7, a8) \
++ otg_trace_msg(tag, f, 8, fmt, a1, a2, a3, a4, a5, a6, a7, a8)
++#if 0
++#define TRACE_FMSG9(tag, f, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9) \
++ otg_trace_msg(tag, f, 9, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9)
++#endif
++extern otg_tag_t otg_trace_obtain_tag(void);
++extern otg_tag_t otg_trace_invalidate_tag(otg_tag_t tag);
++
++#elif defined(OTG_WINCE)
++
++#define TRACE_MSG0(tag, msg) \
++ DEBUGMSG(ZONE_INIT,(_T("OTGCORE - CORE - %s"), _T(msg)))
++
++#define TRACE_MSG1(tag, fmt, a1) \
++ DEBUGMSG(ZONE_INIT,(_T("OTGCORE - CORE - %s %d"), _T(fmt), a1))
++
++#define TRACE_MSG2(tag, fmt, a1, a2) \
++ DEBUGMSG(ZONE_INIT,(_T("OTGCORE - CORE - %s %d %d"), _T(fmt), a1, a2))
++
++#define TRACE_MSG3(tag, fmt, a1, a2, a3) \
++ DEBUGMSG(ZONE_INIT,(_T("OTGCORE - CORE - %s %d %d"), _T(fmt), a1, a2, a3));
++
++#define TRACE_MSG4(tag, fmt, a1, a2, a3, a4) \
++ DEBUGMSG(ZONE_INIT,(_T("OTGCORE - CORE - %s %d %d %d %d"), _T(fmt), a1, a2, a3, a4));
++
++#define TRACE_MSG5(tag, fmt, a1, a2, a3, a4, a5) \
++ DEBUGMSG(ZONE_INIT,(_T("OTGCORE - CORE - %s %d %d %d %d %d"), _T(fmt), a1, a2, a3, a4, a5));
++
++#define TRACE_MSG6(tag, fmt, a1, a2, a3, a4, a5, a6) \
++ DEBUGMSG(ZONE_INIT,(_T("OTGCORE - CORE - %s %d %d %d %d %d %d %d"), _T(fmt), a1, a2, a3, a4, a5, a6));
++
++#define TRACE_MSG7(tag, fmt, a1, a2, a3, a4, a5, a6, a7) \
++ DEBUGMSG(ZONE_INIT,(_T("OTGCORE - CORE - %s %d %d %d %d %d %d %d %d"), _T(fmt), a1, a2, a3, a4, a5, a6, a7));
++
++#define TRACE_MSG8(tag, fmt, a1, a2, a3, a4, a5, a6, a7, a8) \
++ DEBUGMSG(ZONE_INIT,(_T("OTGCORE - CORE - %s %d %d %d %d %d %d %d %d %d"), _T(fmt), a1, a2, a3, a4, a5, a6, a7, a8));
++
++extern otg_tag_t otg_trace_obtain_tag(void);
++extern otg_tag_t otg_trace_invalidate_tag(otg_tag_t tag);
++
++/*
++#define TRACE_OTG_CURRENT(o) \
++ DEBUGMSG(ZONE_INIT,(_T("OTGCORE - CURRENT - %s (%s) RESET: %08x SET: %08x"),\
++ otg_state_names[o->state], \
++ otg_state_names[o->previous], \
++ (u32)(~o->current_inputs), \
++ (u32)(o->current_inputs))\
++ );
++
++#define TRACE_OTG_CHANGE(o) \
++ DEBUGMSG(ZONE_INIT,(_T("OTGCORE - CHANGE - %s (%s) RESET: %08x SET: %08x"),\
++ otg_state_names[o->state], \
++ otg_state_names[o->previous], \
++ (u32)(~o->current_inputs), \
++ (u32)(o->current_inputs))\
++ );
++
++#define TRACE_OTG_NEW(o) \
++ DEBUGMSG(ZONE_INIT,(_T("OTGCORE - NEW - %s (%s) RESET: %08x SET: %08x"),\
++ otg_state_names[o->state], \
++ otg_state_names[o->previous], \
++ (u32)(~o->current_inputs), \
++ (u32)(o->current_inputs))\
++ );
++
++#define TRACE_OTG_INPUTS(u) \
++ DEBUGMSG(ZONE_INIT,(_T("OTGCORE - INPUTS - RESET: %08x SET: %08x"),\
++ (u32)(u >> 32), \
++ (u32)(u & 0xffffffff))\
++ );
++*/
++
++extern otg_tag_t otg_trace_obtain_tag(void);
++extern otg_tag_t otg_trace_invalidate_tag(otg_tag_t tag);
++
++#else /* defined(CONFIG_OTG_TRACE) || defined(CONFIG_OTG_TRACE_MODULE) */
++
++#define TRACE_SETUP(tag,setup)
++
++//#define TRACE_MSG(tag,nargs,fmt,...)
++//#define TRACE_FMSG(tag, nargs,fmt,...)
++
++#define TRACE_MSG0(tag, fmt)
++#define TRACE_MSG1(tag, fmt, a1)
++#define TRACE_MSG2(tag, fmt, a1, a2)
++#define TRACE_MSG3(tag, fmt, a1, a2, a3)
++#define TRACE_MSG4(tag, fmt, a1, a2, a3, a4)
++#define TRACE_MSG5(tag, fmt, a1, a2, a3, a4, a5)
++#define TRACE_MSG6(tag, fmt, a1, a2, a3, a4, a5, a6)
++#define TRACE_MSG7(tag, fmt, a1, a2, a3, a4, a5, a6, a7)
++#define TRACE_MSG8(tag, fmt, a1, a2, a3, a4, a5, a6, a7, a8)
++//#define TRACE_MSG9(tag, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9)
++
++#define TRACE_FMSG0(tag, f, fmt)
++#define TRACE_FMSG1(tag, f, fmt, a1)
++#define TRACE_FMSG2(tag, f, fmt, a1, a2)
++#define TRACE_FMSG3(tag, f, fmt, a1, a2, a3)
++#define TRACE_FMSG4(tag, f, fmt, a1, a2, a3, a4)
++#define TRACE_FMSG5(tag, f, fmt, a1, a2, a3, a4, a5)
++#define TRACE_FMSG6(tag, f, fmt, a1, a2, a3, a4, a5, a6)
++#define TRACE_FMSG7(tag, f, fmt, a1, a2, a3, a4, a5, a6, a7)
++#define TRACE_FMSG8(tag, f, fmt, a1, a2, a3, a4, a5, a6, a7, a8)
++//#define TRACE_FMSG9(tag, f, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9)
++
++//static inline otg_tag_t otg_trace_obtain_tag(void)
++//{
++// return 0;
++//}
++
++//static inline otg_tag_t otg_trace_invalidate_tag(otg_tag_t tag)
++//{
++// return 0;
++//}
++
++extern otg_tag_t otg_trace_obtain_tag(void);
++extern otg_tag_t otg_trace_invalidate_tag(otg_tag_t tag);
++
++#endif /* defined(CONFIG_OTG_TRACE) || defined(CONFIG_OTG_TRACE_MODULE) */
++
++#define USBD usbd_trace_tag
++extern otg_tag_t USBD;
++
++//#define ACM acm_trace_tag
++//extern otg_tag_t ACM;
++
++//#define NETWORK network_trace_tag
++//extern otg_tag_t NETWORK;
++
++#endif /* OTG_TRACE_H */
+diff -uNr linux/drivers/no-otg/otg/otg-utils.h linux/drivers/otg/otg/otg-utils.h
+--- linux/drivers/no-otg/otg/otg-utils.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/otg-utils.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,151 @@
++/*
++ * otg/otg/otg-utils.h
++ *
++ * Basic utilities for OTG package
++ * Copyright (c) 2004 Belcarra
++ */
++/*!
++ * @file otg/otg/otg-utils.h
++ * @brief Useful macros.
++ *
++ *
++ * @ingroup OTGCore
++ */
++
++
++#if !defined(_OTG_UTILS_H)
++#define _OTG_UTILS_H 1
++
++/*! @name Min, Max and zero
++ * @{
++ */
++#ifndef MIN
++#define MIN(a,b) ((a) < (b) ? (a) : (b))
++#endif
++#ifndef MAX
++#define MAX(a,b) ((a) > (b) ? (a) : (b))
++#endif
++
++#define ZERO(a) memset(&a, 0, sizeof(a))
++
++/* @} */
++
++/*! @name TRUE and FALSE
++ *
++ * @{
++ */
++#if !defined(TRUE)
++#define TRUE 1
++#endif
++
++#if !defined(FALSE)
++#define FALSE 0
++#endif
++/* @} */
++
++
++/*! @name CATCH and THROW
++ *
++ * These macros implement a conceptually clean way to use
++ * C's goto to implement a standard error handler. The typical forms are:
++ *
++ * THROW(error); // continue execution in CATCH statement
++ * THROW_IF(test, error); // continue execution in CATCH statement if test true
++ * THROW_UNLESS(test, error); // continue execution in CATCH statement if test false
++ *
++ * // program execution will continue after the CATCH statement;
++ * CATCH(error) {
++ * // handle error here
++ * }
++ *
++ * @{
++ */
++#define CATCH(x) while(0) x:
++#define THROW(x) goto x
++#define THROW_IF(e, x) if (e) goto x;
++#define THROW_UNLESS(e, x) UNLESS (e) goto x;
++/* @} */
++
++
++/*! @name UNLESS
++ *
++ * This implements a simple equivalent to negated if (expression).
++ *
++ * Unless expression then statement else statement.
++ *
++ * @{
++ */
++#define unless(x) if(!(x))
++#define UNLESS(x) if(!(x))
++/* @} */
++
++/*! @name BREAK_ and CONTINUE_
++ *
++ * These implement a conditional break and continue statement.
++ *
++ * @{
++ */
++#define BREAK_UNLESS(x) UNLESS (x) break;
++#define BREAK_IF(x) if (x) break;
++#define CONTINUE_IF(x) if (x) continue;
++#define CONTINUE_UNLESS(x) UNLESS (x) continue;
++
++/* @} */
++
++
++/*! @name RETURN_
++ *
++ * These implement conditional return statement.
++ * @{
++ */
++#define RETURN_IF(x) if (x) return;
++#define RETURN_ZERO_IF(x) if (x) return 0;
++#define RETURN_NULL_IF(x) if (x) return NULL;
++#define RETURN_EBUSY_IF(x) if (x) return -EBUSY;
++#define RETURN_EFAULT_IF(x) if (x) return -EFAULT;
++#define RETURN_EINVAL_IF(x) if (x) return -EINVAL;
++#define RETURN_ENOMEM_IF(x) if (x) return -ENOMEM;
++#define RETURN_EAGAIN_IF(x) if (x) return -EAGAIN;
++#define RETURN_ETIMEDOUT_IF(x) if (x) return -ETIMEDOUT;
++#define RETURN_EPIPE_IF(x) if (x) return -EPIPE;
++#define RETURN_IRQ_HANDLED_IF(x) if (x) return IRQ_HANDLED;
++#define RETURN_TRUE_IF(x) if (x) return TRUE;
++#define RETURN_FALSE_IF(x) if (x) return FALSE;
++
++#define RETURN_UNLESS(x) UNLESS (x) return;
++#define RETURN_NULL_UNLESS(x) UNLESS (x) return NULL;
++#define RETURN_ZERO_UNLESS(x) UNLESS (x) return 0;
++#define RETURN_EBUSY_UNLESS(x) UNLESS (x) return -EBUSY;
++#define RETURN_EFAULT_UNLESS(x) UNLESS (x) return -EFAULT;
++#define RETURN_EINVAL_UNLESS(x) UNLESS (x) return -EINVAL;
++#define RETURN_ENOMEM_UNLESS(x) UNLESS (x) return -ENOMEM;
++#define RETURN_EAGAIN_UNLESS(x) UNLESS (x) return -EAGAIN;
++#define RETURN_ETIMEDOUT_UNLESS(x) UNLESS (x) return -ETIMEDOUT;
++#define RETURN_EPIPE_UNLESS(x) UNLESS (x) return -EPIPE;
++#define RETURN_IRQ_HANDLED_UNLESS(x) UNLESS (x) return IRQ_HANDLED;
++#define RETURN_TRUE_UNLESS(x) UNLESS (x) return TRUE;
++#define RETURN_FALSE_UNLESS(x) UNLESS (x) return FALSE;
++
++/* @} */
++
++
++/*! @name likely and unlikely
++ *
++ * Under linux these can be used to provide a hint to GCC that
++ * the expression being evaluated is probably going to evaluate
++ * to true (likely) or false (unlikely). The intention is that
++ * GCC can then provide optimal code for that.
++ * @{
++ */
++#ifndef likely
++#define likely(x) x
++#endif
++
++#ifndef unlikely
++#define unlikely(x) x
++#endif
++/* @} */
++
++
++#endif /* _OTG_UTILS_H */
++
+diff -uNr linux/drivers/no-otg/otg/pcd-include.h linux/drivers/otg/otg/pcd-include.h
+--- linux/drivers/no-otg/otg/pcd-include.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/pcd-include.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,36 @@
++/*
++ * otg/udc.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/otg/pcd-include.h
++ * @brief Linux OS Precompiled Headers
++ *
++ * @ingroup OTGCore
++ */
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#include <asm/irq.h>
++#include <asm/system.h>
++#include <asm/io.h>
++
++#include <otg/usbp-chap9.h>
++//#include <otg/usbp-func.h>
++#include <otg/usbp-bus.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-tcd.h>
++#include <otg/otg-hcd.h>
++#include <otg/otg-pcd.h>
++#include <otg/otg-ocd.h>
++#include <otg/usbp-pcd.h>
++
+diff -uNr linux/drivers/no-otg/otg/usbp-bus.h linux/drivers/otg/otg/usbp-bus.h
+--- linux/drivers/no-otg/otg/usbp-bus.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/usbp-bus.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,354 @@
++/*
++ * otg/otg/usbp-bus.h - USB Device Bus Interface Driver Interface
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++
++/*!
++ * @file otg/otg/usbp-bus.h
++ * @brief Bus interface Defines for USB Device Core Layaer
++ *
++ * This file contains the USB Peripheral Driver definitions.
++ *
++ * The
++ *
++ * 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 Peripheral Controller Drivers are structured such that the upper edge
++ * implements interfaces to the USB Peripheral 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.)
++ *
++ * The peripheral controller layer primarily deals with endpoints.
++ * There is one control endpoint and one or more data endpoints.
++ *
++ * The control endpoint is special, with received data processed with
++ * the built in EP0 function. Which in turn will pass requests to
++ * interface functions as appropriate.
++ *
++ * Data endpoints are controlled by interface driver and have a
++ * function callback specified by the interface driver to perform
++ * whatever needs to be done when data is sent or received.
++ *
++ *
++ *
++ * @ingroup USBP
++ */
++
++struct usbd_endpoint_map;
++struct usbd_endpoint_instance;
++struct usbd_bus_instance;
++struct usbd_urb;
++
++/*!
++ * USB Bus Interface Driver structures
++ *
++ * Driver description:
++ *
++ * struct usbd_bus_operations
++ * struct usbd_bus_driver
++ *
++ */
++
++extern int usbd_maxstrings;
++
++
++/*!
++ * exported to otg
++ */
++struct usbd_ops {
++ int (*admin) (char *);
++ char * (*function_name) (int);
++};
++
++
++
++/*! 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 endpoint_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 usbd_bus_operations {
++ //int (*xbus_serial_number) (struct usbd_bus_instance *, char *);
++
++ int (*start_endpoint_in) (struct usbd_bus_instance *, struct usbd_endpoint_instance *);
++ int (*start_endpoint_out) (struct usbd_bus_instance *, struct usbd_endpoint_instance *);
++ int (*cancel_urb_irq) (struct usbd_urb *);
++ //int (*device_feature) (struct usbd_bus_instance *, int, int);
++ int (*endpoint_halted) (struct usbd_bus_instance *, int, int);
++ int (*halt_endpoint) (struct usbd_bus_instance *, int, int, int);
++ int (*set_address) (struct usbd_bus_instance *, int);
++ int (*event_handler) (struct usbd_bus_instance *, usbd_device_event_t, int);
++ int (*request_endpoints) (struct usbd_bus_instance *, struct usbd_endpoint_map *,
++ int, struct usbd_endpoint_request *);
++ int (*set_endpoints) (struct usbd_bus_instance *, int , struct usbd_endpoint_map *);
++ int (*framenum) (void);
++ u64 (*ticks) (void);
++ u64 (*elapsed) (u64 *, u64 *);
++ u64 (*interrupts) (void);
++};
++
++/*! 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.
++ *
++ * This is the logical array of endpoints that are indexed into by the
++ * function layer using the logical endpoint numbers defined by the function
++ * drivers. It maps these numbers into a real physical endpoint.
++ *
++ * Fields that can be different for Full speed versus High speed are
++ * represented with an array both values are available.
++ *
++ * For interfaces with multiple alternate settings, each separate
++ * combinantion of interface_num/altsetting/endpoint must be specified.
++ * It is up to the lower layers to determine if / when overlapped
++ * endpoints can be re-used.
++ *
++ */
++struct usbd_endpoint_map {
++ u8 configuration;
++ u8 interface_num;
++ 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 usbd_endpoint_instance *endpoint;
++};
++
++
++/*! Endpoint configuration
++ *
++ * Per endpoint configuration data. Used to track which actual physical
++ * endpoints.
++ *
++ * The bus layer maintains an array of these to represent all physical
++ * endpoints.
++ *
++ */
++struct usbd_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
++ u32 feature_setting; // save set feature information
++
++ // control
++ int state; // available for use by bus interface driver
++
++ // receive side
++ struct urb_link rdy; // empty urbs ready to receive
++ struct usbd_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 usbd_urb *tx_urb; // active urb
++ u32 tx_transferSize; // maximum transfer size from function driver
++
++ u32 sent; // data already sent
++ u32 last; // data sent in last packet XXX do we need this
++
++ void *privdata;
++
++};
++
++/*! @name 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
++#define WAIT_FOR_IN_STATUS 6
++/*! @} */
++
++/*! 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 usbd_bus_driver {
++ char *name;
++ u8 max_endpoints; // maximimum number of rx enpoints
++ u8 otg_bmAttributes;
++ u8 maxpacketsize;
++ u8 HighSpeedCapable;
++ struct usbd_device_description *device_description;
++ struct usbd_bus_operations *bops;
++ void *privdata;
++ u32 capabilities;
++ u8 bMaxPower;
++ u8 ports;
++};
++
++/*!
++ * 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;
++
++
++/*!
++ * @name UDC Capabilities
++ * @{
++ */
++#define HAVE_CABLE_IRQ 0x0001
++#define REMOTE_WAKEUP_SUPPORTED 0x0002
++#define ROOT_HUB 0x0004
++/*! @} */
++
++/*! 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 usbd_bus_instance {
++
++ struct usbd_bus_driver *driver;
++
++ int endpoints;
++ struct usbd_endpoint_instance *endpoint_array; // array of available configured endpoints
++
++ struct urb_link finished; // processed urbs
++
++ //char *serial_number_str;
++
++ usbd_device_status_t status; // device status
++ usbd_bus_state_t bus_state;
++ usbd_device_state_t device_state; // current USB Device state
++ usbd_device_state_t suspended_state; // previous USB Device state
++
++ struct usbd_function_instance *ep0; // ep0 configuration
++ struct usbd_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
++
++ u32 device_feature_settings;// save set feature information
++ u8 otg_bmAttributes;
++
++ struct WORK_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 usbd_bus_instance *usbd_register_bus (struct usbd_bus_driver *, int);
++void usbd_deregister_bus (struct usbd_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 usbd_bus_instance *, char *, char *);
++void usbd_disable_function (struct usbd_bus_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_handler (struct usbd_bus_instance *, usbd_device_event_t, int);
++void usbd_bus_event_handler_irq (struct usbd_bus_instance *, usbd_device_event_t, int);
++
++
++/*!
++ * usbd_device_request - 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_device_request (struct usbd_bus_instance*, struct usbd_device_request *);
++
++/*!
++ * Device I/O
++ */
++void usbd_urb_finished (struct usbd_urb *, int );
++void usbd_urb_finished_irq (struct usbd_urb *, int );
++struct usbd_urb *usbd_first_urb_detached_irq (urb_link * hd);
++
++/*! flush endpoint
++ */
++void usbd_flush_endpoint_irq (struct usbd_endpoint_instance *);
++void usbd_flush_endpoint (struct usbd_endpoint_instance *);
++int usbd_find_endpoint_index(struct usbd_bus_instance *bus, int bEndpointAddress);
++
++
++
+diff -uNr linux/drivers/no-otg/otg/usbp-chap9.h linux/drivers/otg/otg/usbp-chap9.h
+--- linux/drivers/no-otg/otg/usbp-chap9.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/usbp-chap9.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,1577 @@
++/*
++ * otg/otg/usbp-chap9.h
++ *
++ * Copyright (c) 2004 Belcarra
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @defgroup USBP USB Peripheral Support
++ * @ingroup onthegogroup
++ */
++
++
++/*!
++ * @file otg/otg/usbp-chap9.h
++ * @brief Chapter 9 and other class descriptor structure definitions.
++ *
++ * USB Descriptors are used to build a configuration database for each USB
++ * Function driver.
++ *
++ * @ingroup USBP
++ */
++
++/*!
++ * @name 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
++/*! @} */
++
++
++/*! @name 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_RECIP_HUB 0x00
++#define USB_RECIP_PORT 0x03
++
++#define USB_DIR_OUT 0
++#define USB_DIR_IN 0x80
++#define USB_ENDPOINT_OPT 0x40
++/*! @} */
++
++/*! @name Descriptor types
++ * C.f. USB Table 9-5
++ */
++
++/*! @{ */
++
++#define USB_DT_DEVICE 0x01
++#define USB_DT_CONFIGURATION 0x02
++#define USB_DT_STRING 0x03
++#define USB_DT_INTERFACE 0x04
++#define USB_DT_ENDPOINT 0x05
++#define USB_DT_DEVICE_QUALIFIER 0x06
++#define USB_DT_OTHER_SPEED_CONFIGURATION 0x07
++#define USB_DT_INTERFACE_POWER 0x08
++#define USB_DT_OTG 0x09
++
++
++#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)
++/*! @} */
++
++/*! @name 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
++/*! @} */
++
++/*! @name 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
++/*! @} */
++
++/*!
++ * @name 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 */
++/*! @} */
++
++/*! * @name 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
++/*! @} */
++
++/*!
++ * @name Hub requests
++ */
++ /*! @{ */
++#define USB_REQ_CLEAR_TT_BUFFER 0x08
++#define USB_REQ_RESET_TT 0x09
++#define USB_REQ_GET_TT_STATE 0x0A
++#define USB_REQ_STOP_TT 0x0B
++/*! @} */
++
++/*!
++ * @name 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
++/*! @} */
++
++
++/*!
++ * @name USB Spec Release number
++ */
++ /*! @{ */
++
++#define USB_BCD_VERSION 0x0200
++/*! @} */
++
++/*!
++ * @name 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
++/*! @} */
++
++
++/*!
++ * @name 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
++/*! @} */
++
++/*!
++ * @name Hub Recipients
++ */
++ /*! @{ */
++#define USB_REQ_RECIPIENT_HUB 0x00
++#define USB_REQ_RECIPIENT_PORT 0x03
++/*! @} */
++
++/*!
++ * @name get status bits
++ */
++ /*! @{ */
++
++#define USB_STATUS_SELFPOWERED 0x01
++#define USB_STATUS_REMOTEWAKEUP 0x02
++
++#define USB_STATUS_HALT 0x01
++/*! @} */
++
++/*!
++ * @name Convert Feature Selector to a Status Flag Setting
++ */
++ /*! @{ */
++#define FEATURE(f) (1 << f)
++/*! @} */
++
++/*!
++ * @name standard feature selectors
++ */
++ /*! @{ */
++#define USB_ENDPOINT_HALT 0x00
++#define USB_DEVICE_REMOTE_WAKEUP 0x01
++#define USB_TEST_MODE 0x02
++/*! @} */
++
++/*!
++ * @name Hub Feature Selectors C.f. Table 11-17
++ */
++ /*! @{ */
++#if !defined(C_HUB_LOCAL_POWER)
++#define C_HUB_LOCAL_POWER 0x0
++#endif
++#if !defined(C_HUB_OVER_CURRENT)
++#define C_HUB_OVER_CURRENT 0x1
++#endif
++
++#define PORT_CONNECTION 0
++#define PORT_ENABLE 1
++#define PORT_SUSPEND 2
++#define PORT_OVER_CURRENT 3
++#define PORT_RESET 4
++
++#define PORT_POWER 8
++#define PORT_LOW_SPEED 9
++#define PORT_HIGH_SPEED 10
++
++#define C_PORT_CONNECTION 16
++#define C_PORT_ENABLE 17
++#define C_PORT_SUSPEND 18
++#define C_PORT_OVER_CURRENT 19
++#define C_PORT_RESET 20
++
++#define PORT_TEST 21
++#define PORT_INDICATOR 22
++
++/*! @} */
++
++#ifdef PRAGMAPACK
++#pragma pack(push,1)
++#endif
++
++
++struct usbd_device_request {
++ u8 bmRequestType;
++ u8 bRequest;
++ u16 wValue;
++ u16 wIndex;
++ u16 wLength;
++} PACKED;
++
++
++
++struct usbd_otg_descriptor {
++ u8 bLength;
++ u8 bDescriptorType;
++ u8 bmAttributes;
++} PACKED;
++
++/*!
++ * @name OTG
++ */
++ /*! @{ */
++#define USB_OTG_HNP_SUPPORTED 0x02
++#define USB_OTG_SRP_SUPPORTED 0x01
++/*! @} */
++
++/*!
++ * @name OTG Feature selectors
++ */
++ /*! @{ */
++#define USB_OTG_B_HNP_ENABLE 0x03
++#define USB_OTG_A_HNP_SUPPORT 0x04
++#define USB_OTG_A_ALT_HNP_ENABLE 0x05
++/*! @} */
++
++/*!
++ * @name 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_LINE_STATE 0x22
++#define CDC_CLASS_REQUEST_SEND_BREAK 0x23
++/*! @} */
++
++/*!
++ * @name 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
++/*! @} */
++
++struct hub_descriptor {
++ u8 bDescLength;
++ u8 bDescriptorType;
++ u8 bNbrPorts;
++ u16 wHubCharacteristics;
++ u8 bPwrOn2PwrGood;
++ u8 bHubContrCurrent;
++ u8 DeviceRemovable;
++ u8 PortPwrCtrlMask;
++} PACKED;
++
++/*!
++ * @name Hub Descriptor C.f. 11.23.2.1 Table 11-13
++ * N.B. This assumes 1-8 ports, DeviceRemovable and PortPwrCtrlMask
++ * must be sized for the number of if ports > 8.
++ */
++ /*! @{ */
++
++
++#define HUB_GANGED_POWER 0x00
++#define HUB_INDIVIDUAL_POWER 0x01
++#define HUB_COMPOUND_DEVICE 0x04
++#define HUB_GLOBAL_OVERCURRENT 0x00
++#define HUB_INDIVIDUAL_OVERCURRENT 0x08
++#define HUB_NO_OVERCURRENT 0x10
++#define HUB_TT_8 0x00
++#define HUB_TT_16 0x20
++#define HUB_TT_24 0x40
++#define HUB_TT_32 0x60
++#define HUB_INDICATORS_SUPPORTED 0x80
++/*! @} */
++
++/*!
++ * @name HID - Class Descriptors
++ * C.f. 7.1.1
++ */
++ /*! @{ */
++
++#define HID 0x21
++#define HID_REPORT 0x22
++#define HID_PHYSICAL 0x23
++/*! @} */
++
++/*!
++ * name HID Descriptor
++ * C.f. E.8
++ */
++ /*! @{ */
++
++
++struct hid_descriptor {
++ u8 bLength;
++ u8 bDescriptorType;
++ u16 bcdHID;
++ u8 bCountryCode;
++ u8 bNumDescriptors;
++ u8 bReportType;
++ u16 wItemLength;
++} PACKED;
++
++/*! @} */
++
++/*!
++ * name ACM - Line Coding structure
++ * C.f. CDC Table 50
++ */
++ /*! @{ */
++
++
++struct cdc_acm_line_coding {
++ u32 dwDTERate;
++ u8 bCharFormat;
++ u8 bParityType;
++ u8 bDataBits;
++} PACKED;
++
++ /*!@} */
++
++/*!
++ * @name ACM - Line State
++ * C.f. CDC Table 51
++ */
++ /*! @{ */
++typedef u16 cdc_acm_bmLineState;
++#define CDC_LINESTATE_D1_RTS (1 << 1)
++#define CDC_LINESTATE_D0_DTR (1 << 0)
++/*! @} */
++
++/*!
++ * Serial State - C.f. 6.3.5
++ */
++struct acm_serial_state {
++ u16 uart_state_bitmap;
++};
++
++
++/*! @name ACM - UART State
++ * C.f. Table 69 - UART State Bitmap Values
++ */
++/*! @{ */
++typedef u16 cdc_acm_bmUARTState;
++#define CDC_UARTSTATE_BOVERRUN (1 << 6)
++#define CDC_UARTSTATE_BPARITY (1 << 5)
++#define CDC_UARTSTATE_BFRAMING (1 << 4)
++#define CDC_UARTSTATE_BRINGSIGNAL (1 << 3)
++#define CDC_UARTSTATE_BBREAK (1 << 2)
++#define CDC_UARTSTATE_BTXCARRIER_DSR (1 << 1)
++#define CDC_UARTSTATE_BRXCARRIER_DCD (1 << 0)
++/*! @} */
++
++/* !USB Notification
++ *
++ */
++
++struct cdc_notification_descriptor {
++ u8 bmRequestType;
++ u8 bNotification;
++ u16 wValue;
++ u16 wIndex;
++ u16 wLength;
++ u8 data[2];
++} PACKED;
++
++
++
++
++/*!
++ * @name 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
++/*! @} */
++
++/*! @name c.f. CDC 4.1 Table 14 */
++
++/*! @{ */
++
++#define AUDIO_CLASS 0x01
++#define COMMUNICATIONS_DEVICE_CLASS 0x02
++/*! @} */
++
++/*! @name c.f. CDC 4.2 Table 15
++ */
++ /*! @{ */
++#define COMMUNICATIONS_INTERFACE_CLASS 0x02
++/*! @} */
++
++/*! @name 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
++/*! @} */
++
++/*! @name 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
++/*! @} */
++
++/*! @name c.f. CDC 4.6 Table 18
++ */
++ /*! @{ */
++#define DATA_INTERFACE_CLASS 0x0a
++/*! @} */
++
++/*! @name c.f. CDC 4.7 Table 19
++ */
++ /*! @{ */
++#define COMMUNICATIONS_NO_PROTOCOL 0x00
++/*! @} */
++
++
++/*! @name 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
++/*! @} */
++
++/*!
++ * @name Audio Interface Class - c.f Appendix A.1
++ */
++ /*! @{ */
++#define AUDIO_INTERFACE_CLASS 0x01
++/*! @} */
++
++/*! @name 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
++/*! @} */
++
++/*! @name Audio Interface Proctol - c.f. Appendix A.3
++ */
++ /*! @{ */
++#define AUDIO_PR_PROTOCOL_UNDEFINED 0x00
++/*! @} */
++
++/*! @name 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
++/*! @} */
++
++/*! @name 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
++/*! @} */
++
++/*! @name 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
++/*! @} */
++
++/*! @name Audio Class-Specific Endpoint Descriptor Subtypes - c.f. A.8
++ */
++ /*! @{ */
++#define AUDIO_DESCRIPTOR_UNDEFINED 0x00
++#define AUDIO_EP_GENERAL 0x01
++/*! @} */
++
++/*! @name 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
++/*! @} */
++
++/*!
++ * @name 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
++/*! @} */
++
++/*!
++ * @name Class Descriptor Description Structures...
++ * c.f. CDC 5.1
++ * c.f. WCMC 6.7.2
++ *
++ * XXX add the other dozen class descriptor description structures....
++ *
++ */
++ /*! @{ */
++struct usbd_header_functional_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype;
++ u16 bcdCDC;
++};
++
++struct usbd_call_management_functional_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype;
++ u8 bmCapabilities;
++ u8 bDataInterface;
++};
++
++struct usbd_abstract_control_functional_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype;
++ u8 bmCapabilities;
++};
++
++struct usbd_union_functional_functor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype;
++ u8 bMasterInterface;
++ u8 bSlaveInterface[1];
++ //u8 bSlaveInterface[0]; // XXX FIXME
++};
++
++struct usbd_ethernet_networking_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype;
++ char *iMACAddress;
++ u8 bmEthernetStatistics;
++ u16 wMaxSegmentSize;
++ u16 wNumberMCFilters;
++ u8 bNumberPowerFilters;
++};
++
++struct usbd_mobile_direct_line_model_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype;
++ u16 bcdVersion;
++ u8 bGUID[16];
++};
++
++struct usbd_mobile_direct_line_model_detail_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype;
++ u8 bGuidDescriptorType;
++ u8 bDetailData[2];
++ //u8 bDetailData[0]; // XXX FIXME
++};
++#if 0
++struct usbd_header_description {
++ u8 bDescriptorSubtype;
++ u16 bcdCDC;
++};
++
++struct usbd_call_management_description {
++ u8 bmCapabilities;
++ u8 bDataInterface;
++};
++
++struct usbd_abstract_control_description {
++ u8 bmCapabilities;
++};
++
++struct usbd_union_function_description {
++ u8 bMasterInterface;
++ u8 bSlaveInterface[1];
++ //u8 bSlaveInterface[0]; // XXX FIXME
++};
++
++struct usbd_ethernet_networking_description {
++ char *iMACAddress;
++ u8 bmEthernetStatistics;
++ u16 wMaxSegmentSize;
++ u16 wNumberMCFilters;
++ u8 bNumberPowerFilters;
++};
++
++struct usbd_mobile_direct_line_model_description {
++ u16 bcdVersion;
++ u8 bGUID[16];
++};
++
++struct usbd_mobile_direct_line_model_detail_description {
++ u8 bGuidDescriptorType;
++ u8 bDetailData[2];
++ //u8 bDetailData[0]; // XXX FIXME
++};
++
++struct usbd_class_description {
++ u8 bDescriptorSubtype;
++ u8 elements;
++ union {
++ struct usbd_header_description header;
++ struct usbd_call_management_description call_management;
++ struct usbd_abstract_control_description abstract_control;
++ struct usbd_union_function_description union_function;
++ struct usbd_ethernet_networking_description ethernet_networking;
++ struct usbd_mobile_direct_line_model_description mobile_direct;
++ struct usbd_mobile_direct_line_model_detail_description mobile_direct_detail;
++ } description;
++};
++#endif
++/*! @} */
++
++/*!
++ * @name Endpoint Modifiers
++ * static struct usbd_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 CONTROL 0x00
++#define ISOCHRONOUS 0x01
++#define BULK 0x02
++#define INTERRUPT 0x03
++/*! @} */
++
++
++/*! @name configuration modifiers
++ */
++
++/* @{ */
++#define BMATTRIBUTE_RESERVED 0x80
++#define BMATTRIBUTE_SELF_POWERED 0x40
++#define BMATTRIBUTE_REMOTE_WAKEUP 0x20
++
++#if 0
++/*
++ * The UUT tester specifically tests for MaxPower to be non-zero (> 0).
++ */
++#if !defined(CONFIG_OTG_MAXPOWER) || (CONFIG_OTG_MAXPOWER == 0)
++ #define BMATTRIBUTE BMATTRIBUTE_RESERVED | BMATTRIBUTE_SELF_POWERED
++ #define BMAXPOWER 1
++#else
++ #define BMATTRIBUTE BMATTRIBUTE_RESERVED
++ #define BMAXPOWER CONFIG_USBD_MAXPOWER
++#endif
++#endif
++/*! @} */
++
++
++
++/*!
++ * @name Standard Usb Descriptor Structures
++ */
++ /*! @{ */
++
++struct usbd_endpoint_descriptor {
++ u8 bLength;
++ u8 bDescriptorType; // 0x5
++ u8 bEndpointAddress;
++ u8 bmAttributes;
++ u16 wMaxPacketSize;
++ u8 bInterval;
++} PACKED;
++
++struct usbd_interface_descriptor {
++ u8 bLength;
++ u8 bDescriptorType; // 0x04
++ u8 bInterfaceNumber;
++ u8 bAlternateSetting;
++ u8 bNumEndpoints;
++ u8 bInterfaceClass;
++ u8 bInterfaceSubClass;
++ u8 bInterfaceProtocol;
++ u8 iInterface;
++} PACKED;
++
++struct usbd_configuration_descriptor {
++ u8 bLength;
++ u8 bDescriptorType; // 0x2
++ u16 wTotalLength;
++ u8 bNumInterfaces;
++ u8 bConfigurationValue;
++ u8 iConfiguration;
++ u8 bmAttributes;
++ u8 bMaxPower;
++} PACKED;
++
++struct usbd_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;
++} PACKED;
++
++struct usbd_string_descriptor {
++ u8 bLength;
++ u8 bDescriptorType; // 0x03
++ u16 wData[0];
++} PACKED;
++
++struct usbd_device_qualifier_descriptor {
++ u8 bLength;
++ u8 bDescriptorType;
++ u16 bcdUSB;
++ u8 bDeviceClass;
++ u8 bDeviceSubClass;
++ u8 bDeviceProtocol;
++ u8 bMaxPacketSize0;
++ u8 bNumConfigurations;
++ u8 bReserved;
++} PACKED;
++
++struct usbd_generic_descriptor {
++ u8 bLength;
++ u8 bDescriptorType;
++} PACKED;
++
++struct usbd_generic_class_descriptor {
++ u8 bLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype;
++} PACKED;
++/*! @} */
++
++/*!
++ * @name Communications Class Dscriptor Structures
++ * c.f. CDC 5.2 Table 25c
++ */
++
++/*! @{*/
++
++struct usbd_class_function_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype;
++} PACKED;
++
++struct usbd_class_function_descriptor_generic {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype;
++ u8 bmCapabilities;
++} PACKED;
++
++struct usbd_class_header_function_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x00
++ u16 bcdCDC;
++} PACKED;
++
++struct usbd_class_call_management_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x01
++ u8 bmCapabilities;
++ u8 bDataInterface;
++} PACKED;
++
++struct usbd_class_abstract_control_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x02
++ u8 bmCapabilities;
++} PACKED;
++
++struct usbd_class_direct_line_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x03
++} PACKED;
++
++struct usbd_class_telephone_ringer_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x04
++ u8 bRingerVolSeps;
++ u8 bNumRingerPatterns;
++} PACKED;
++
++struct usbd_class_telephone_call_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x05
++ u8 bmCapabilities;
++} PACKED;
++
++struct usbd_class_union_function_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x06
++ u8 bMasterInterface;
++ u8 bSlaveInterface0[0];
++} PACKED;
++
++struct usbd_class_country_selection_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x07
++ u8 iCountryCodeRelDate;
++ u16 wCountryCode0[0];
++} PACKED;
++
++
++struct usbd_class_telephone_operational_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x08
++ u8 bmCapabilities;
++} PACKED;
++
++
++struct usbd_class_usbd_terminal_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x09
++ u8 bEntityId;
++ u8 bInterfaceNo;
++ u8 bOutInterfaceNo;
++ u8 bmOptions;
++ u8 bChild0[0];
++} PACKED;
++
++struct usbd_class_network_channel_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x0a
++ u8 bEntityId;
++ u8 iName;
++ u8 bChannelIndex;
++ u8 bPhysicalInterface;
++} PACKED;
++
++struct usbd_class_protocol_unit_function_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x0b
++ u8 bEntityId;
++ u8 bProtocol;
++ u8 bChild0[0];
++} PACKED;
++
++struct usbd_class_extension_unit_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x0c
++ u8 bEntityId;
++ u8 bExtensionCode;
++ u8 iName;
++ u8 bChild0[0];
++} PACKED;
++
++struct usbd_class_multi_channel_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x0d
++ u8 bmCapabilities;
++} PACKED;
++
++struct usbd_class_capi_control_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x0e
++ u8 bmCapabilities;
++} PACKED;
++
++struct usbd_class_ethernet_networking_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x0f
++ u8 iMACAddress;
++ u32 bmEthernetStatistics;
++ u16 wMaxSegmentSize;
++ u16 wNumberMCFilters;
++ u8 bNumberPowerFilters;
++} PACKED;
++
++struct usbd_class_atm_networking_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x10
++ u8 iEndSystermIdentifier;
++ u8 bmDataCapabilities;
++ u8 bmATMDeviceStatistics;
++ u16 wType2MaxSegmentSize;
++ u16 wType3MaxSegmentSize;
++ u16 wMaxVC;
++} PACKED;
++
++
++struct usbd_class_mdlm_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x12
++ u16 bcdVersion;
++ u8 bGUID[16];
++} PACKED;
++
++/*
++struct usbd_class_mdlmd_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x13
++ u8 bGuidDescriptorType;
++ u8 bDetailData[0];
++} PACKED;
++*/
++
++struct usbd_class_blan_descriptor {
++ u8 bFunctionLength; // 0x7
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x13
++ u8 bGuidDescriptorType;
++ u8 bmNetworkCapabilities;
++ u8 bmDataCapabilities;
++ u8 bPad;
++} PACKED;
++
++struct usbd_class_safe_descriptor {
++ u8 bFunctionLength; // 0x6
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype; // 0x13
++ u8 bGuidDescriptorType;
++ u8 bmNetworkCapabilities;
++ u8 bmDataCapabilities;
++} PACKED;
++
++/*@}*/
++
++
++/*!
++ * @name Descriptor Union Structures
++ */
++ /*! @{ */
++
++struct usbd_descriptor {
++ union {
++ struct usbd_generic_descriptor generic_descriptor;
++ struct usbd_generic_class_descriptor generic_class_descriptor;
++ struct usbd_endpoint_descriptor endpoint_descriptor;
++ struct usbd_interface_descriptor interface_descriptor;
++ struct usbd_configuration_descriptor configuration_descriptor;
++ struct usbd_device_descriptor device_descriptor;
++ struct usbd_string_descriptor string_descriptor;
++ } descriptor;
++
++} PACKED;
++
++struct usbd_class_descriptor {
++ union {
++ struct usbd_class_function_descriptor function;
++ struct usbd_class_function_descriptor_generic generic;
++ struct usbd_class_header_function_descriptor header_function;
++ struct usbd_class_call_management_descriptor call_management;
++ struct usbd_class_abstract_control_descriptor abstract_control;
++ struct usbd_class_direct_line_descriptor direct_line;
++ struct usbd_class_telephone_ringer_descriptor telephone_ringer;
++ struct usbd_class_telephone_operational_descriptor telephone_operational;
++ struct usbd_class_telephone_call_descriptor telephone_call;
++ struct usbd_class_union_function_descriptor union_function;
++ struct usbd_class_country_selection_descriptor country_selection;
++ struct usbd_class_usbd_terminal_descriptor usb_terminal;
++ struct usbd_class_network_channel_descriptor network_channel;
++ struct usbd_class_extension_unit_descriptor extension_unit;
++ struct usbd_class_multi_channel_descriptor multi_channel;
++ struct usbd_class_capi_control_descriptor capi_control;
++ struct usbd_class_ethernet_networking_descriptor ethernet_networking;
++ struct usbd_class_atm_networking_descriptor atm_networking;
++ struct usbd_class_mdlm_descriptor mobile_direct;
++ //struct usbd_class_mdlmd_descriptor mobile_direct_detail;
++ struct usbd_class_blan_descriptor mobile_direct_blan_detail;
++ struct usbd_class_safe_descriptor mobile_direct_safe_detail;
++ } descriptor;
++
++} PACKED;
++/*! @} */
++
++/*!
++ * @name 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 usbd_audio_status_word {
++ u8 bStatusType;
++ u8 bOriginator;
++} PACKED;
++
++struct usbd_audio_ac_interface_header_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype;
++ u16 bcdADC;
++ u16 wTotalLength;
++ u8 binCollection;
++ u8 bainterfaceNr[0];
++} PACKED;
++
++struct usbd_audio_input_terminal_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype;
++ u8 bTerminalID;
++ u16 wTerminalType;
++ u8 bAssocTerminal;
++ u8 bNrChannels;
++ u16 wChannelConfig;
++ u8 iChannelNames;
++ u8 iTerminal;
++} PACKED;
++
++struct usbd_audio_input_terminal_description {
++ struct usbd_audio_input_terminal_descriptor *audio_input_terminal_descriptor;
++ u16 wTerminalType;
++ u16 wChannelConfig;
++ char * iChannelNames;
++ char * iTerminal;
++};
++
++struct usbd_audio_output_terminal_descriptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype;
++ u8 bTerminalID;
++ u16 wTerminalType;
++ u8 bAssocTerminal;
++ u8 bSourceID;
++ u8 iTerminal;
++} PACKED;
++
++struct usbd_audio_output_terminal_description {
++ struct usbd_audio_output_terminal_descriptor *audio_output_terminal_descriptor;
++ u16 wTerminalType;
++ char * iTerminal;
++};
++
++struct usbd_audio_mixer_unit_descriptor_a {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype;
++ u8 bUniteID;
++ u8 bNrinPins;
++} PACKED;
++
++struct usbd_audio_mixer_unit_descriptor_b {
++ u8 baSourceID;
++ u8 bNrChannels;
++ u16 wChannelConfig;
++ u8 iChannelNames;
++ u8 bmControls;
++ u8 iMixer;
++} PACKED;
++
++struct usbd_audio_mixer_unit_description {
++ struct usbd_audio_mixer_unit_descriptor *audio_mixer_unit_descriptor;
++ u16 wChannelConfig;
++ char * iMixer;
++};
++
++
++struct usbd_audio_as_general_interface_descriptor {
++ u8 bLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype;
++ u8 bTerminalLink;
++ u8 bDelay;
++ u16 wFormatTag;
++} PACKED;
++
++struct usbd_audio_as_general_interface_description {
++ struct usbd_audio_as_general_interface_descriptor *audio_as_general_interface_descriptor;
++ u16 wFormatTag;
++};
++
++struct usbd_audio_as_format_type_descriptor {
++ u8 bLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype;
++ u8 bFormatType;
++ u8 bNrChannels;
++ u8 bSubFrameSize;
++ u8 bBitResolution;
++ u8 bSamFreqType;
++ u8 iSamFreq[3];
++} PACKED;
++
++struct usbd_audio_as_format_type_description {
++ struct usbd_audio_as_format_type_descriptor *audio_as_format_type_descriptor;
++ u16 wFormatTag;
++};
++
++
++
++
++struct usbd_audio_descriptor {
++ union {
++ struct usbd_audio_ac_interface_header_descriptor header;
++ struct usbd_audio_input_terminal_descriptor input;
++ struct usbd_audio_output_terminal_descriptor output;
++ } descriptor;
++} PACKED;
++
++
++
++struct usbd_ac_endpoint_descriptor {
++ u8 bLength;
++ u8 bDescriptorType;
++ u8 bEndpointAddress;
++ u8 bmAttributes;
++ u16 wMaxPacketSize;
++ u8 bInterval;
++ u8 bRefresh;
++ u8 bSynchAddress;
++} PACKED;
++
++
++struct usbd_as_iso_endpoint_descriptor {
++ u8 bLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubtype;
++ u8 bmAttributes;
++ u8 bLockDelayUnits;
++ u16 wLockDelay;
++} PACKED;
++/*! @}*/
++
++
++/*!
++ * @name MCPC
++ */
++ /*! @{ */
++
++/*! struct usbd_interface_association
++ * Used in AB-1 or DL-1 interface bundles.
++ */
++struct usbd_interface_association_descriptor {
++ u8 bLength;
++ u8 bDescriptorType;
++ u8 bFirstInterface;
++ u8 bInterfaceCount;
++ u8 bFunctionClass;
++ u8 bFunctionSubClass;
++ u8 bFunctionProcotol;
++ u8 iFunction;
++} PACKED;
++
++struct usbd_mobile_abstract_control_model_specific_desciptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubType;
++ u8 bType;
++ u8 bMode_1;
++};
++
++struct usbd_mobile_direct_line_model_specific_desciptor {
++ u8 bFunctionLength;
++ u8 bDescriptorType;
++ u8 bDescriptorSubType;
++ u8 bType;
++ u8 bMode_N[2];
++};
++
++
++/*! @} */
++
++/*!
++ * 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 usbd_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
++
++} usbd_device_event_t;
++
++/*! USB Request Block 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..)
++ *
++ * USBD_URB_SENDZLP - set this flag if a ZLP (zero length packet) should be
++ * sent after the data is sent. This is required if sending data that is a
++ * multiple of the packetsize but less than the maximum transfer size for
++ * the protocol in use. A ZLP is required to ensure that the host
++ * recognizes a short transfer.
++ *
++ */
++
++typedef struct urb_link {
++ struct urb_link *next;
++ struct urb_link *prev;
++} urb_link;
++
++
++/*! URB Status
++ *
++ * This defines the current status of a pending or finshed URB.
++ *
++ */
++typedef enum usbd_urb_status {
++ SEND_IN_QUEUE,
++ SEND_IN_PROGRESS,
++ SEND_FINISHED_OK,
++ SEND_FINISHED_ERROR,
++ SEND_CANCELLED,
++ SEND_STALLED,
++ SEND_DISABLED,
++ RECV_IN_QUEUE,
++ RECV_IN_PROGRESS,
++ RECV_OK,
++ RECV_ERROR,
++ RECV_CANCELLED,
++ RECV_STALLED,
++ RECV_DISABLED
++} usbd_urb_status_t;
++
++#define USBD_URB_SENDZLP 0x01
++
++struct usbd_urb {
++
++ struct usbd_bus_instance *bus;
++ struct usbd_function_instance *function_instance;
++ struct usbd_endpoint_instance *endpoint;
++
++ int (*callback) (struct usbd_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 *function_privdata;
++ void *bus_privdata;
++ void *pcimap;
++
++ 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
++};
++
++/*! 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 usbd_endpoint_request {
++ u8 configuration; /* configuration endpoint will be in */
++ u8 interface_num; /* 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 */
++};
++
++/*!
++ * Device status
++ *
++ * Overall state, we use this to show when we are suspended.
++ * This is required because when resumed we need to go back
++ * to previous state.
++ */
++typedef enum usbd_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,
++} usbd_device_status_t;
++
++
++/*!
++ * 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 usbd_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, // device has been suspended
++ STATE_UNKNOWN, // destroyed
++} usbd_device_state_t;
++
++
++
++#ifdef PRAGMAPACK
++#pragma pack(pop)
++#endif
++
++
+diff -uNr linux/drivers/no-otg/otg/usbp-func.h linux/drivers/otg/otg/usbp-func.h
+--- linux/drivers/no-otg/otg/usbp-func.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/usbp-func.h 2006-09-01 21:41:33.000000000 +0200
+@@ -0,0 +1,428 @@
++/*
++ * otg/otg/usbp-func.h - USB Device Function Driver Interface
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ *
++ */
++
++/*!
++ * @file otg/otg/usbp-func.h
++ * @brief Function Driver related structures and definitions.
++ *
++ * This file contains the USB Function Driver and USB Interface Driver
++ * definitions.
++ *
++ * The USBOTG support allows for implementation of composite devices.
++ *
++ * From USB 2.0, C.f. 5.2.3:
++ *
++ * A Device that has multiple interfaces controlled independantly of
++ * each other is referred to as a composite device. A composite device
++ * has only a single device.
++ *
++ * In this implemenation the function portion of the device is split into
++ * two types of drivers:
++ *
++ * - USB Interface Driver
++ * - USB Function Driver
++ *
++ *
++ * USB Interface Driver
++ *
++ * An USB Interface Driver specifies the Interface related descriptors and
++ * implements the data handling processes for each of the data endpoints
++ * associated with the interface (or interfaces) required for the function.
++ * It typically will also implement the upper edge interface to the OS.
++ *
++ * The USB Interface Driver will also handle non-standard device requests
++ * and feature requests that are for the interface or an endpoint associated
++ * with one of the interfaces associated with the driver.
++ *
++ * Each interface implemented by an USB Interface Driver will have a
++ * interface instance that stores a pointer to the parent USB Function
++ * Driver and has an array of pointers to endpoint instances for the data
++ * endpoints associated with the interface.
++ *
++ *
++ * USB Function Driver
++ *
++ * A USB Function Driver specifies the device and configuration descriptors.
++ * A configuration descriptor is assembled from the interface descriptors
++ * from the USB Interface Driver (or drivers) that it is making available to
++ * the USB Host.
++ *
++ * The USB Function Driver handles non-standard device requests and feature
++ * requests for the device.
++ *
++ * Each function driver has a function instance that maintains an array
++ * of pointers to configuration instances and a pointer to the device
++ * descriptor.
++ *
++ * Each configuration instance maintains an array of pointers to the
++ * interface instances for that configuration and a pointer to the
++ * complete configuration descriptor.
++ *
++ * @ingroup USBP
++ */
++
++/*!
++ * 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
++ *
++ */
++
++
++
++struct usbd_bus_instance;
++struct usbd_endpoint_instance;
++struct usbd_function_instance;
++
++/*!
++ * USB Function Driver types
++ */
++typedef enum usbd_function_types {
++ function_simple,
++ function_interface,
++ function_composite
++} usbd_function_types_t;
++
++
++/*!
++ * USB Function Driver structures
++ *
++ * Descriptors:
++ * struct usbd_endpoint_description
++ * struct usbd_interface_description
++ * struct usbd_configuration_description
++ *
++ * Driver description:
++ * struct usbd_function_driver
++ * struct usbd_function_operations
++ *
++ */
++
++struct usbd_function_operations {
++
++ int (*function_enable) (struct usbd_function_instance *);
++ void (*function_disable) (struct usbd_function_instance *);
++
++ /*
++ * All of the following may be called from an interrupt context
++ */
++ void (*event_handler) (struct usbd_function_instance *, usbd_device_event_t, int);
++ int (*device_request) (struct usbd_function_instance *, struct usbd_device_request *);
++ int (*set_configuration) (struct usbd_function_instance *, int configuration);
++
++ int (*set_interface) (struct usbd_function_instance *, int interface, int altsetting);
++
++ void * (*get_descriptor)(struct usbd_function_instance *, int descriptor_type, int descriptor_index);
++ int * (*set_descriptor)(struct usbd_function_instance *, int descriptor_type, int descriptor_index, void *);
++
++ void (*endpoint_cleared)(struct usbd_function_instance*, int wIndex, int);
++
++};
++
++
++/*!
++ * function driver definitions
++ */
++struct usbd_alternate_instance {
++ struct usbd_interface_descriptor *interface_descriptor;
++ int classes;
++ struct usbd_generic_class_descriptor **class_list;
++ int endpoints;
++ struct usbd_endpoint_descriptor **endpoint_list;
++ u8 *endpoint_indexes;
++};
++
++
++/*!
++ * usb device description structures
++ */
++
++struct usbd_alternate_description {
++ struct usbd_interface_descriptor *interface_descriptor;
++ char *iInterface;
++
++ // list of CDC class descriptions for this alternate interface
++ u8 classes;
++ struct usbd_generic_class_descriptor **class_list;
++
++ // list of endpoint descriptions for this alternate interface
++ u8 endpoints;
++ struct usbd_endpoint_descriptor **endpoint_list;
++
++ // list of indexes into endpoint request map for each endpoint descriptor
++ u8 *endpoint_indexes;
++};
++
++typedef struct usbd_generic_class_descriptor usbd_class_descriptor_t;
++typedef struct usbd_endpoint_descriptor usbd_endpoint_descriptor_t;
++
++struct usbd_interface_description {
++ // list of alternate interface descriptions for this interface
++ u8 alternates;
++ struct usbd_alternate_description *alternate_list;
++};
++
++struct usbd_configuration_description {
++ struct usbd_configuration_descriptor *configuration_descriptor;
++ char *iConfiguration;
++ // list of interface descriptons for this configuration
++ //u8 bNumInterfaces;
++ //struct usbd_interface_description *interface_list;
++ int configuration_type;
++};
++
++struct usbd_device_description {
++ struct usbd_device_descriptor *device_descriptor;
++ #ifdef CONFIG_OTG_HIGH_SPEED
++ struct usbd_device_qualifier_descriptor *device_qualifier_descriptor;
++ #endif /* CONFIG_OTG_HIGH_SPEED */
++ struct usbd_otg_descriptor *otg_descriptor;
++ u8 *iManufacturer;
++ u8 *iProduct;
++ u8 *iSerialNumber;
++ //u8 endpointsRequested;
++ //struct usbd_endpoint_request *requestedEndpoints;
++};
++
++
++struct usbd_interfaces_instance {
++ u8 alternates;
++ struct usbd_alternate_instance *alternates_instance_array;
++};
++
++struct usbd_configuration_instance {
++ int bNumInterfaces;
++ struct usbd_configuration_descriptor *configuration_descriptor;
++ struct usbd_interfaces_instance *interfaces_instance_array;
++ struct usbd_function_driver *function_driver;
++};
++
++
++/*! 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 usbd_function_driver {
++ const char *name;
++ struct usbd_function_operations *fops; // functions
++
++ // device & configuration descriptions
++ struct usbd_device_description *device_description;
++ struct usbd_configuration_description *configuration_description;
++ int bNumConfigurations;
++
++ u16 idVendor;
++ u16 idProduct;
++ u16 bcdDevice;
++
++ u8 bNumInterfaces;
++ struct usbd_interface_description *interface_list;
++
++ u8 endpointsRequested;
++ struct usbd_endpoint_request *requestedEndpoints;
++
++ // constructed descriptors
++ struct usbd_device_descriptor *device_descriptor;
++#ifdef CONFIG_OTG_HIGH_SPEED
++ struct usbd_device_qualifier_descriptor *device_qualifier_descriptor;
++#endif /* CONFIG_OTG_HIGH_SPEED */
++ struct usbd_otg_descriptor *otg_descriptor;
++ struct usbd_configuration_instance *configuration_instance_array;
++};
++
++/*! Function configuration structure
++ *
++ * This is allocated for each configured instance of a function driver.
++ *
++ * It stores pointers to the usbd_function_driver for the appropriate function,
++ * and pointers to the USB HOST requested usbd_configuration_description and
++ * usbd_interface_description.
++ *
++ * The privdata pointer may be used by the function driver to store private
++ * per instance state information.
++ *
++ * The endpoint map will contain a list of all endpoints for the configuration
++ * driver, and only related endpoints for an interface driver.
++ *
++ * The interface driver array will be NULL for an interface driver.
++ */
++struct usbd_function_instance {
++ char * name;
++ LIST_NODE instances; // linked list (was drivers in usbd_function_driver)
++ struct usbd_bus_instance *bus;
++ struct usbd_function_driver *function_driver;
++ void *privdata; // private data for the function
++
++ usbd_function_types_t function_type;
++
++ int configuration; // configuration driver only
++ int altsetting; // interface driver only
++
++ char **interfaces_list;
++
++ int interfaces;
++ struct usbd_function_instance **interfaces_array;
++
++ int endpoints;
++ struct usbd_endpoint_request *requestedEndpoints;
++ struct usbd_endpoint_map *endpoint_map_array;
++
++};
++
++
++struct usbd_function_instance;
++
++/*!
++ * @name Function Driver Registration
++ *
++ * Called by function drivers to register themselves when loaded
++ * or de-register when unloading.
++ * @{
++ */
++struct usbd_function_instance * usbd_register_function (struct usbd_function_driver *, char *, void *);
++struct usbd_function_instance * usbd_register_interface (struct usbd_function_driver *, char *, void *);
++struct usbd_function_instance * usbd_register_composite (struct usbd_function_driver *function_driver, char*, char **, void *);
++
++void usbd_deregister_function (struct usbd_function_instance *);
++struct usbd_function_instance *usbd_find_function (char *name);
++struct usbd_function_instance *usbd_find_interface(char *name);
++/*! @} */
++
++
++/*!
++ * @name String Descriptor database
++ *
++ * @{
++ */
++
++struct usbd_string_descriptor *usbd_get_string_descriptor (u8);
++u8 usbd_realloc_string (u8, char *);
++u8 usbd_alloc_string (char *);
++void usbd_free_string_descriptor(u8 );
++
++//extern struct usbd_string_descriptor **usb_strings;
++//void usbd_free_descriptor_strings (struct usbd_descriptor *);
++
++/*! @} */
++
++
++
++/*!
++ * @name Device Information
++ *
++ * @}
++ */
++int usbd_high_speed(struct usbd_function_instance *);
++int usbd_bmaxpower(struct usbd_function_instance *);
++int usbd_endpoint_wMaxPacketSize(struct usbd_function_instance *, int, int);
++int usbd_endpoint_zero_wMaxPacketSize(struct usbd_function_instance *, int);
++int usbd_endpoint_bEndpointAddress(struct usbd_function_instance *, int, int);
++int usbd_get_bMaxPower(struct usbd_function_instance *);
++/*! @} */
++
++
++/*!
++ * @name Device Control
++ *
++ * @}
++ */
++usbd_device_state_t usbd_get_device_state(struct usbd_function_instance *);
++usbd_device_status_t usbd_get_device_status(struct usbd_function_instance *);
++int usbd_framenum(struct usbd_function_instance *);
++u64 usbd_ticks(struct usbd_function_instance *);
++u64 usbd_elapsed(struct usbd_function_instance *, u64 *, u64 *);
++
++/*! @} */
++
++/*!
++ * @name Endpoint I/O
++ *
++ * @}
++ */
++
++struct usbd_urb *usbd_alloc_urb (struct usbd_function_instance *, int, int length, int (*callback) (struct usbd_urb *, int));
++struct usbd_urb *usbd_alloc_urb_ep0 (struct usbd_function_instance *, int length, int (*callback) (struct usbd_urb *, int));
++void usbd_free_urb (struct usbd_urb *urb);
++int usbd_start_in_urb (struct usbd_urb *urb);
++int usbd_start_out_urb (struct usbd_urb *);
++int usbd_cancel_urb(struct usbd_urb *);
++int usbd_halt_endpoint (struct usbd_function_instance *function, int endpoint_index);
++int usbd_endpoint_halted (struct usbd_function_instance *function, int endpoint);
++
++
++/*! @} */
++
++
++/*!
++ * @name endpoint information
++ *
++ * Used by function drivers to get specific endpoint information
++ * @{
++ */
++
++int usbd_endpoint_transferSize(struct usbd_function_instance *, int, int);
++int usbd_endpoint_interface(struct usbd_function_instance *, int);
++int usbd_interface_AltSetting(struct usbd_function_instance *, int);
++int usbd_ConfigurationValue(struct usbd_function_instance *);
++void usbd_endpoint_update(struct usbd_function_instance *, int , struct usbd_endpoint_descriptor *, int);
++/*! @} */
++
++//int usbd_remote_wakeup_enabled(struct usbd_function_instance *);
++
++/*!
++ * @name device information
++ *
++ * Used by function drivers to get device feature information
++ * @{
++ */
++int usbd_otg_bmattributes(struct usbd_function_instance *);
++/*! @} */
++
++/*!
++ * @name usbd_feature_enabled - return non-zero if specified feature has been enabled
++ * @{
++ */
++int usbd_feature_enabled(struct usbd_function_instance *function, int f);
++/*! @} */
++
++/* DEPRECATED */
++/*!
++ * @name Access to function privdata (DEPRECATED)
++ * @{
++ */
++void *usbd_function_get_privdata(struct usbd_function_instance *function);
++void usbd_function_set_privdata(struct usbd_function_instance *function, void *privdata);
++void usbd_flush_endpoint_index (struct usbd_function_instance *, int );
++int usbd_old_get_descriptor (struct usbd_function_instance *function, u8 *buffer, int max, int descriptor_type, int index);
++/*! @} */
++
+diff -uNr linux/drivers/no-otg/otg/usbp-pcd.h linux/drivers/otg/otg/usbp-pcd.h
+--- linux/drivers/no-otg/otg/usbp-pcd.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otg/usbp-pcd.h 2006-09-01 21:41:34.000000000 +0200
+@@ -0,0 +1,279 @@
++/*
++ * otg/otg/usbp-pcd.h - OTG Peripheral Controller Driver
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++
++/*!
++ * @file otg/otg/usbp-pcd.h
++ * @brief Peripheral Controller Driver Related Structures and Definitions.
++ *
++ * @ingroup USBP
++ */
++
++/*!
++ * The pcd_ops structure contains pointers to all of the functions implemented for the
++ * linked in driver. Having them in this structure allows us to easily determine what
++ * functions are available without resorting to ugly compile time macros or ifdefs
++ *
++ * There is only one instance of this, defined in the device specific lower layer.
++ */
++struct usbd_pcd_ops {
++
++ /* mandatory */
++ u8 bmAttributes;
++ int max_endpoints;
++ int ep0_packetsize;
++ u32 capabilities; /* UDC Capabilities - see usbd-bus.h for details */
++ u8 bMaxPower;
++ char *name;
++ u8 ports;
++
++
++ /* 3. called by ot_init() if defined */
++ int (* serial_init) (struct pcd_instance *); /* get device serial number if available */
++
++ /* 4. called from usbd_enable_function_irq() - REQUIRED */
++ int (*request_endpoints) /* process endpoint_request list and return endpoint_map */
++ (struct pcd_instance *,
++ struct usbd_endpoint_map *, /* showing allocated endpoints with attributes, addresses */
++ int, struct usbd_endpoint_request*); /* and other associated information */
++
++ /* 5. called from usbd_enable_function_irq() - REQUIRED */
++ int (*set_endpoints) /* setup required endpoints in hardware */
++ (struct pcd_instance *, int , struct usbd_endpoint_map *);
++
++ /* 6. called by xxx() if defined */
++ void (*enable) (struct pcd_instance *); /* enable the UDC */
++
++ /* 7. called by xxx() if defined */
++ void (*disable) (struct pcd_instance *); /* disable the UDC */
++
++ /* 8. called by xxx() if defined */
++ void (*start) (struct pcd_instance *); /* called for DEVICE_CREATE to start the UDC */
++ void (*stop) (struct pcd_instance *); /* called for DEVICE_DESTROY to stop the UDC */
++ void (*disable_ep)
++ (struct pcd_instance *,
++ unsigned int ep); /* called for DEVICE_DESTROTY to disable endpoint zero */
++
++ /* 9. called by xxx() if defined */
++ void (*set_address)
++ (struct pcd_instance *,
++ unsigned char address); /* called for DEVICE_RESET and DEVICE_ADDRESS_ASSIGNED to */
++
++
++ /* 10. called by xxx() if defined */
++ void (*setup_ep)
++ (struct pcd_instance *,
++ unsigned int ep, /* called for DEVICE_CONFIGURED to setup specified endpoint for use */
++ struct usbd_endpoint_instance *endpoint);
++
++ /* 11. called by xxx() if defined */
++ void (*reset_ep)
++ (struct pcd_instance *,
++ unsigned int ep); /* called for DEVICE_RESET to reset endpoint zero */
++
++
++ /* 12. called by usbd_send_urb() - REQUIRED */
++ void (*start_endpoint_in) /* start an IN urb */
++ (struct pcd_instance *,
++ struct usbd_endpoint_instance *);
++
++ /* 13. called by usbd_start_recv() - REQUIRED */
++ void (*start_endpoint_out) /* start an OUT urb */
++ (struct pcd_instance *,
++ struct usbd_endpoint_instance *);
++
++ /* 14. called by usbd_cancel_urb_irq() */
++ void (*cancel_in_irq)
++ (struct pcd_instance *,
++ struct usbd_urb *urb); /* cancel active urb for IN endpoint */
++ void (*cancel_out_irq)
++ (struct pcd_instance *,
++ struct usbd_urb *urb); /* cancel active urb for OUT endpoint */
++
++
++ /* 15. called from ep0_recv_setup() for GET_STATUS request */
++ int (*endpoint_halted)
++ (struct pcd_instance *,
++ struct usbd_endpoint_instance *); /* Return non-zero if requested endpoint is halted */
++ int (*halt_endpoint)
++ (struct pcd_instance *,
++ struct usbd_endpoint_instance *,
++ int); /* Return non-zero if requested endpoint clear fails */
++
++ /* 16 */
++ void (*startup_events) (struct pcd_instance *); /* perform UDC specific USB events */
++
++ /* 17. root hub operations
++ */
++ int (*hub_status) (struct pcd_instance *);
++ int (*port_status) (struct pcd_instance *, int);
++ int (*hub_feature) (struct pcd_instance *, int, int);
++ int (*port_feature) (struct pcd_instance *, int, int, int);
++ int (*get_ports_status) (struct pcd_instance *);
++ int (*wait_for_change) (struct pcd_instance *);
++};
++
++extern struct usbd_pcd_ops usbd_pcd_ops;
++
++
++/*! pcd_rcv_next_irq - get the current or next urb to receive into
++ * Called by UDC driver to get current receive urb or next available receive urb.
++ */
++static __inline__ struct usbd_urb * pcd_rcv_next_irq (struct usbd_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_MSG1(PCD, "BUS_RCV_URB: %p", endpoint->rcv_urb);
++ return endpoint->rcv_urb;
++}
++
++
++/*! pcd_rcv_complete_irq - complete a receive operation
++ * Called by UDC driver to show completion of outstanding I/O, this will
++ * update the urb length and if necessary will finish the urb passing it to the
++ * bottom half which will in turn call the function driver callback.
++ */
++struct usbd_urb * pcd_rcv_complete_irq (struct usbd_endpoint_instance *endpoint, int len, int urb_bad);
++struct usbd_urb * pcd_rcv_finished_irq (struct usbd_endpoint_instance *endpoint, int len, int urb_bad);
++
++
++/*! pcd_rcv_cancelled_irq - cancel current receive urb
++ * Called by UDC driver to cancel the current receive urb.
++ */
++static __inline__ void pcd_rcv_cancelled_irq (struct usbd_endpoint_instance *endpoint)
++{
++ struct usbd_urb *rcv_urb;
++
++ TRACE_MSG1(PCD, "BUS_RCV CANCELLED: %p", (int) endpoint->rcv_urb);
++ RETURN_IF (! (rcv_urb = endpoint->rcv_urb));
++ //TRACE_MSG1(PCD, "rcv_urb: %p", (int)endpoint->rcv_urb);
++ usbd_urb_finished_irq (rcv_urb, RECV_CANCELLED);
++ endpoint->sent = endpoint->last = 0;
++ endpoint->rcv_urb = NULL;
++}
++
++
++/*! pcd_tx_next_irq - get the current or next urb to transmit
++ * Called by UDC driver to get current transmit urb or next available transmit urb.
++ */
++static __inline__ struct usbd_urb * pcd_tx_next_irq (struct usbd_endpoint_instance *endpoint)
++{
++ if (!endpoint->tx_urb)
++ if ( (endpoint->tx_urb = usbd_first_urb_detached_irq (&endpoint->tx))) {
++#if 0
++ int i;
++ u8 *cp = endpoint->tx_urb->buffer;
++
++ TRACE_MSG2(PCD, "NEXT TX: length: %d flags: %x",
++ endpoint->tx_urb->actual_length, endpoint->tx_urb->flags);
++
++ for (i = 0; i < endpoint->tx_urb->actual_length; i+= 8)
++
++ TRACE_MSG8(PCD, "SENT %02x %02x %02x %02x %02x %02x %02x %02x",
++ cp[i + 0], cp[i + 1], cp[i + 2], cp[i + 3],
++ cp[i + 4], cp[i + 5], cp[i + 6], cp[i + 7]
++ );
++#endif
++ endpoint->tx_urb->status = SEND_IN_PROGRESS;
++ }
++ //TRACE_MSG1(PCD, "BUS_TX NEXT TX_URB: %p", (int)endpoint->tx_urb);
++ return endpoint->tx_urb;
++}
++
++
++/*! pcd_tx_complete_irq - complete a transmit operation
++ * Called by UDC driver to show completion of an outstanding I/O, this will update the urb sent
++ * information and if necessary will finish the urb passing it to the bottom half which will in
++ * turn call the function driver callback.
++ */
++struct usbd_urb * pcd_tx_complete_irq (struct usbd_endpoint_instance *endpoint, int restart);
++
++
++/*! pcd_tx_cancelled_irq - finish pending tx_urb with SEND_CANCELLED
++ * Called by UDC driver to cancel the current transmit urb.
++ */
++static __inline__ void pcd_tx_cancelled_irq (struct usbd_endpoint_instance *endpoint)
++{
++ struct usbd_urb *tx_urb;
++
++ TRACE_MSG1(PCD, "BUS_TX CANCELLED: %p", (int) endpoint->tx_urb);
++ RETURN_IF (! (tx_urb = endpoint->tx_urb));
++ usbd_urb_finished_irq (tx_urb, SEND_CANCELLED);
++ endpoint->sent = endpoint->last = 0;
++ endpoint->tx_urb = NULL;
++}
++
++
++/*! pcd_tx_sendzlp - test if we need to send a ZLP
++ * This has a side-effect of reseting the USBD_URB_SENDZLP flag.
++ */
++static __inline__ int pcd_tx_sendzlp (struct usbd_endpoint_instance *endpoint)
++{
++ struct usbd_urb *tx_urb = endpoint->tx_urb;
++ RETURN_FALSE_IF (!tx_urb || (tx_urb->actual_length < endpoint->sent) || ! (tx_urb->flags & USBD_URB_SENDZLP));
++ tx_urb->flags &= ~USBD_URB_SENDZLP;
++ return TRUE;
++}
++
++
++/*! pcd_rcv_complete_irq - complete a receive
++ * Called from rcv interrupt to complete.
++ */
++static __inline__ void pcd_rcv_fast_complete_irq (struct usbd_endpoint_instance *endpoint, struct usbd_urb *rcv_urb)
++{
++ //TRACE_MSG1(PCD, "BUS_RCV FAST COMPLETE: %d", rcv_urb->actual_length);
++ usbd_urb_finished_irq (rcv_urb, RECV_OK);
++}
++
++/*! pcd_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 pcd_recv_setup_irq (struct pcd_instance *pcd, struct usbd_device_request *request)
++{
++ struct usbd_bus_instance *bus = pcd->bus;
++ struct usbd_endpoint_instance *endpoint = bus->endpoint_array + 0;
++ TRACE_SETUP (PCD, request);
++ RETURN_EINVAL_IF (usbd_device_request(bus, request)); // fail if already failed
++
++ //TRACE_MSG2(PCD, "BUS_RECV SETUP: RCV URB: %x TX_URB: %x", (int)endpoint->rcv_urb, (int)endpoint->tx_urb);
++ 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;
++}
++
++/*! pcd_recv_setup_emulate_irq - emulate a device request
++ * Called by the UDC driver to inject a SETUP request. This is typically used
++ * by drivers for UDC's that do not pass all SETUP requests to us but instead give us
++ * a configuration change interrupt.
++ */
++int pcd_recv_setup_emulate_irq(struct usbd_bus_instance *, u8, u8, u16, u16, u16);
++
++/*! pcd_ep0_reset_irq - reset ep0 endpoint
++ */
++static void __inline__ pcd_ep0_reset_endpoint_irq (struct usbd_endpoint_instance *endpoint)
++{
++ TRACE_MSG0(PCD, "BUS_EP0 RESET");
++ pcd_tx_cancelled_irq (endpoint);
++ pcd_rcv_cancelled_irq (endpoint);
++ endpoint->sent = endpoint->last = 0;
++}
++
++/*! pcd_check_device_feature - verify that feature is set or clear
++ * Check current feature setting and emulate SETUP Request to set or clear
++ * if required.
++ */
++void pcd_check_device_feature(struct usbd_bus_instance *, int , int );
++
+diff -uNr linux/drivers/no-otg/otgcore/Makefile linux/drivers/otg/otgcore/Makefile
+--- linux/drivers/no-otg/otgcore/Makefile 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otgcore/Makefile 2006-09-01 21:41:34.000000000 +0200
+@@ -0,0 +1,107 @@
++#
++# Belcarra OTG - On-The-Go
++#
++# Copyright (c) 2004 Belcarra Technologies Corp
++
++TOPDIR ?= ../../../..
++
++subdir-y :=
++subdir-m :=
++subdir-n :=
++subdir- :=
++
++
++# The target object and module list name.
++
++O_TARGET := otgcore_target.o
++
++# Objects that export symbols.
++
++export-objs := core-init-l24.o otg.o otg-trace.o otg-mesg.o usbp-bops.o usbp-fops.o otg-mesg-l24.o
++
++# Multipart objects. (core layer)
++
++list-multi := otgtrace.o otgcore.o otgadmin.o
++
++otgcore-objs := core-init-l24.o otg.o \
++ otg-trace.o otg-trace-l24.o \
++ otg-mesg.o otg-mesg-l24.o \
++ otg-fw.o \
++ usbp-fops.o usbp-bops.o
++
++
++usbprocfs-objs := usbp-procfs.o
++
++
++ifeq ("$(CONFIG_OTG_FW_MN)", "y")
++otgcore-objs += otg-fw-mn.o
++else
++otgcore-objs += otg-fw-df.o
++endif
++
++
++# 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_OTG) += otgcore.o
++obj-$(CONFIG_OTG_PROCFSM) += usbprocfs.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
++OTG=$(TOPDIR)/drivers/otg
++#USBDCORE_DIR=$(OTG)/usbdcore
++OTGCORE_DIR=$(OTG)/otgcore
++EXTRA_CFLAGS += -Wno-missing-prototypes -Wno-unused -Wno-format -I$(OTG)
++EXTRA_CFLAGS_nostdinc += -Wno-missing-prototypes -Wno-unused -Wno-format -I$(OTG)
++
++vpath %.c $(OTGCORE_DIR)
++
++# Link rules for multi-part drivers.
++
++otgadmin.o: $(otgadmin-objs)
++ $(LD) -r -o $@ $(otgadmin-objs)
++
++otgcore.o: $(otgcore-objs)
++ $(LD) -r -o $@ $(otgcore-objs)
++
++otgtrace.o: $(otgtrace-objs)
++ $(LD) -r -o $@ $(otgtrace-objs)
++
++usbprocfs.o: $(usbprocfs-objs)
++ $(LD) -r -o $@ $(usbprocfs-objs)
++
+diff -uNr linux/drivers/no-otg/otgcore/Makefile-l26 linux/drivers/otg/otgcore/Makefile-l26
+--- linux/drivers/no-otg/otgcore/Makefile-l26 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otgcore/Makefile-l26 2006-09-01 21:41:34.000000000 +0200
+@@ -0,0 +1,24 @@
++#
++# Belcarra OTG - On-The-Go
++#
++# Copyright (c) 2004 Belcarra Technologies Corp
++
++OTG=$(TOPDIR)/drivers/otg
++EXTRA_CFLAGS += -Wno-missing-prototypes -Wno-unused -Wno-format -I$(OTG)
++EXTRA_CFLAGS_nostdinc += -Wno-missing-prototypes -Wno-unused -Wno-format -I$(OTG)
++
++#otgadmin-objs := admin-init-l24.o otg-admin.o otg-decode.o
++#obj-$(CONFIG_OTG) += otgadmin.o
++
++otgcore-objs := core-init-l24.o otg.o \
++ otg-trace.o otg-trace-l24.o \
++ otg-mesg.o otg-mesg-l24.o \
++ otg-fw.o \
++ usbp-bops.o \
++ usbp-fops.o \
++
++obj-$(CONFIG_OTG) += otgcore.o
++
++#otgtrace-objs := otg-trace.o
++#obj-$(CONFIG_OTG_TRACE) += otgtrace.o
++
+diff -uNr linux/drivers/no-otg/otgcore/TODO-USBP.txt linux/drivers/otg/otgcore/TODO-USBP.txt
+--- linux/drivers/no-otg/otgcore/TODO-USBP.txt 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otgcore/TODO-USBP.txt 2006-09-01 21:41:34.000000000 +0200
+@@ -0,0 +1,51 @@
++USBD Core Architecture ToDo Stuart Lynne
++Belcarra Fri Aug 13 14:37:13 PDT 2004
++
++
++The following need to be addressed to support ongoing development and support
++for the USB Device core and functions.
++
++
++Specifically:
++ - finish acm, make CDC compliant, support all possible operations
++ - enhance network, add NDIS support,
++ - wmc - implement wmc
++ - obex
++ - mass storage
++
++
++These require:
++
++ - enhancements to allow building composite functions
++ - common routines for handling CDC class requirements
++
++
++1. interface list
++
++ - currently we have an endpoint list that allows each endpoint to be
++ mapped to a function
++
++ - we need to do the same for interfaces, allow each interface to be
++ owned by a function, this will allow ep0 to multiplex per
++ interface standard requests to the proper function driver
++
++
++2. common functions
++
++ - a common send_interrupt_urb function
++
++ int usbd_send_interrupt(struct usbd_function_instance *,
++ int, void *, int, int (*callback) (struct usbd_urb *, int));
++
++
++ - this creates an interrupt urb on the required endpoint, copies the
++ data in, and starts it with the appropriate callback etc.
++
++
++ - notification
++
++ usbd_network_notfication
++ usbd_response_available
++ usbd_serial_state
++
++
+diff -uNr linux/drivers/no-otg/otgcore/core-init-l24.c linux/drivers/otg/otgcore/core-init-l24.c
+--- linux/drivers/no-otg/otgcore/core-init-l24.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otgcore/core-init-l24.c 2006-09-01 21:41:34.000000000 +0200
+@@ -0,0 +1,173 @@
++/*
++ * otg/otg/core-init-l24.c - OTG Peripheral Controller Driver Module Initialization
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcara.com>,
++ * Tom Rushworth <tbr@belcara.com>,
++ * Bruce Balden <balden@belcara.com>
++ *
++ * This is the linux 2.4 version.
++ *
++ */
++/*!
++ * @file otg/otgcore/core-init-l24.c
++ * @brief OTG Core Linux initialization.
++ *
++ * This file is the starting point for defining the Linux OTG Core
++ * driver. It references and starts all of the other components that
++ * must be "linked" into the OTGCORE mdoule.
++ *
++ * @ingroup OTGCore
++ */
++
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/usbp-bus.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-tcd.h>
++#include <otg/otg-hcd.h>
++#include <otg/otg-pcd.h>
++#include <otg/otg-ocd.h>
++
++EMBED_LICENSE(); // When supported by the OS, embed license information in the binary
++
++
++#ifdef OTG_MALLOC_TEST
++int otg_mallocs;
++#endif /* OTG_MALLOC_TEST */
++
++otg_tag_t CORE;
++
++#ifdef CONFIG_OTG_FW_MN
++struct otg_firmware *otg_firmware_loaded = &otg_firmware_mn;
++struct otg_firmware *otg_firmware_orig = &otg_firmware_mn;
++#else /* CONFIG_OTG_FW_MN */
++struct otg_firmware *otg_firmware_loaded = &otg_firmware_df;
++struct otg_firmware *otg_firmware_orig = &otg_firmware_df;
++#endif /* CONFIG_OTG_FW_MN */
++
++struct otg_firmware *otg_firmware_loading;
++
++
++struct otg_instance otg_instance_private;
++
++struct hcd_instance hcd_instance_private = { otg: &otg_instance_private, };
++struct ocd_instance ocd_instance_private = { otg: &otg_instance_private, };
++struct pcd_instance pcd_instance_private = { otg: &otg_instance_private, };
++struct tcd_instance tcd_instance_private = { otg: &otg_instance_private, };
++
++struct otg_instance otg_instance_private = {
++ hcd: &hcd_instance_private,
++ ocd: &ocd_instance_private,
++ pcd: &pcd_instance_private,
++ tcd: &tcd_instance_private,
++};
++
++struct otg_instance *otg_instance = &otg_instance_private;
++
++char * otg_get_state_name(int state)
++{
++ struct otg_state *otg_state;
++ if (!otg_firmware_loaded || (state >= otg_firmware_loaded->number_of_states))
++ return "UNKNOWN_STATE";
++
++ otg_state = otg_firmware_loaded->otg_states + state;
++ return otg_state->name;
++}
++
++
++/* ************************************************************************************* */
++
++
++/* otg_modinit - linux module initialization
++ */
++static int otg_modinit (void)
++{
++ int message_init = 0;
++ int message_init_l24 = 0;
++ int trace_init = 0;
++ int trace_init_l24 = 0;
++
++
++ printk(KERN_INFO"%s: \n", __FUNCTION__);
++
++ trace_init = otg_trace_init();
++ trace_init_l24 = otg_trace_init_l24();
++
++ CORE = otg_trace_obtain_tag();
++
++ TRACE_MSG0(CORE,"--");
++ otg_instance->current_outputs = otg_firmware_loaded->otg_states;
++ otg_instance->previous_outputs = otg_firmware_loaded->otg_states;
++
++ /* initialize otg-mesg and usbp
++ */
++ THROW_IF((message_init = otg_message_init(otg_instance)), error);
++ THROW_IF((message_init_l24 = otg_message_init_l24(otg_instance)), error);
++ THROW_IF(usbd_device_init(), error);
++
++ otg_set_ocd_ops(NULL);
++ otg_set_tcd_ops(NULL);
++ otg_set_hcd_ops(NULL);
++ otg_set_pcd_ops(NULL);
++
++ CATCH(error) {
++ CORE = otg_trace_invalidate_tag(CORE);
++ if (trace_init_l24 )otg_trace_exit_l24();
++ if (trace_init) otg_trace_exit();
++ if (message_init_l24 )otg_message_exit_l24();
++ if (message_init) otg_message_exit();
++ return -EINVAL;
++ }
++ return 0;
++}
++module_init (otg_modinit);
++
++
++#if OTG_EPILOGUE /* Set nonzero in <otg-module.h> when -DMODULE is in force */
++/* otg_modexit - This is *only* used for drivers compiled and used as a module.
++ */
++static void otg_modexit (void)
++{
++ printk(KERN_INFO"%s: \n", __FUNCTION__);
++
++ usbd_device_exit();
++ otg_message_exit_l24();
++
++ CORE = otg_trace_invalidate_tag(CORE);
++ otg_trace_exit();
++
++ if (otg_firmware_loading) {
++ lkfree(otg_firmware_loading->otg_states);
++ lkfree(otg_firmware_loading->otg_tests);
++ lkfree(otg_firmware_loading);
++ }
++ if (otg_firmware_loaded && (otg_firmware_loaded != otg_firmware_orig)) {
++ lkfree(otg_firmware_loaded->otg_states);
++ lkfree(otg_firmware_loaded->otg_tests);
++ lkfree(otg_firmware_loaded);
++ }
++}
++#endif
++
++#if defined (CONFIG_OTG_USBD_PM)
++int usbd_load(char * arg) { return 0; }
++int usbd_unload(char *arg) { return 0; }
++OTG_EXPORT_SYMBOL(usbd_load);
++OTG_EXPORT_SYMBOL(usbd_unload);
++#endif
++
++MOD_EXIT(otg_modexit);
++OTG_EXPORT_SYMBOL(otg_get_state_name);
++
++#ifdef OTG_MALLOC_TEST
++OTG_EXPORT_SYMBOL(otg_mallocs);
++#endif /* OTG_MALLOC_TEST */
++
+diff -uNr linux/drivers/no-otg/otgcore/hub.c linux/drivers/otg/otgcore/hub.c
+--- linux/drivers/no-otg/otgcore/hub.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otgcore/hub.c 2006-09-01 21:41:34.000000000 +0200
+@@ -0,0 +1,607 @@
++/*
++ * otg/otgcore/hub.c
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ * This is a root hub function.
++ *
++ */
++/*!
++ * @file otg/otgcore/hub.c
++ * @brief A simple hub function driver.
++ *
++ *
++ * @ingroup USBDCore
++ */
++#include <otg/otg-compat.h>
++#include <linux/config.h>
++#include <linux/kernel.h>
++#include <linux/version.h>
++#include <linux/ctype.h>
++#include <linux/timer.h>
++#include <linux/slab.h>
++#include <linux/errno.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/usbp-bus.h>
++
++#ifdef CONFIG_OTG_ROOT_HUB
++/*
++ * Root Hub Configuration
++ *
++ * Endpoint, Class, Interface, Configuration and Device descriptors/descriptions
++ * Data Interface Alternate description(s)
++ * Interface description(s)
++ * Configuration description(s)
++ * Device Description
++ */
++
++#define BULK_INT 0x00
++#define ENDPOINTS 0x01
++
++#if 0
++
++Configuration descriptor [1 ] 09 02 19 00 01 01 02 00 00
++ 09 02 19 00 01 01 00 40 00
++
++Interface descriptor [1:1:0 ] 09 04 00 00 01 09 00 00 03
++Endpoint descriptor [1:1:0:1] 07 05 81 03 10 00 ff
++
++#endif
++
++#if defined(OTG_WINCE)
++
++static struct hub_descriptor rh_hub_descriptor;
++struct usbd_endpoint_descriptor rh_data;
++
++static struct usbd_endpoint_descriptor *rh_default[] = { &rh_data, };
++u8 rh_indexes[] = { BULK_INT, };
++
++static struct usbd_interface_descriptor rh_data_alternate_descriptor;
++static struct usbd_alternate_description rh_data_alternate_descriptions[1];
++};
++
++static struct usbd_interface_description rh_interfaces[1];
++
++struct usbd_configuration_descriptor rh_configuration_descriptor;
++
++struct usbd_configuration_description rh_description[1];
++
++static struct usbd_device_descriptor rh_device_descriptor;
++#ifdef CONFIG_OTG_HIGH_SPEED
++static struct usbd_device_qualifier_descriptor rh_device_qualifier_descriptor;
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++static struct usbd_endpoint_request rh_endpoint_requests[ENDPOINTS+1] = {
++ { 1, 0, 0, USB_DIR_IN | USB_ENDPOINT_INTERRUPT, 16, 64, },
++ { 0, },
++};
++
++static struct usbd_otg_descriptor rh_otg_descriptor;
++
++struct usbd_device_description rh_device_description;
++
++void hub_global_init(void)
++{
++ ZERO(rh_hub_descriptor);
++ rh_hub_descriptor.bDescLength = 0x09;
++ rh_hub_descriptor.bDescriptorType = USB_DT_HUB;
++ rh_hub_descriptor.bNbrPorts = 0x00;
++ rh_hub_descriptor.wHubCharacteristics = HUB_GANGED_POWER | HUB_GLOBAL_OVERCURRENT;
++ rh_hub_descriptor.bPwrOn2PwrGood = 0x01;
++ rh_hub_descriptor.bHubContrCurrent = 0x01;
++ rh_hub_descriptor.DeviceRemovable = 0x00;
++ rh_hub_descriptor.PortPwrCtrlMask = 0xff;
++
++ ZERO(rh_data);
++ rh_data.bLength: 0x07;
++ rh_data.bDescriptorType = USB_DT_ENDPOINT;
++ rh_data.bEndpointAddress = USB_DIR_IN;
++ rh_data.bmAttributes = INTERRUPT;
++ rh_data.wMaxPacketSize = __constant_cpu_to_le16(0x4);
++ rh_data.bInterval: 0xff;
++
++ ZERO(rh_data_alternate_desriptor);
++ rh_data_alternate_descriptor.bLength = 0x09;
++ rh_data_alternate_descriptor.bDescriptorType = USB_DT_INTERFACE;
++ rh_data_alternate_descriptor.bNumEndpoints = 0x01;
++ rh_data_alternate_descriptor.bInterfaceClass = USB_CLASS_HUB;
++
++ ZERO(rh_data_alternate_descriptions);
++ rh_data_alternate_descriptors[0].iInterface =Root hub - Status";
++ rh_data_alternate_descriptors[0].interface_descriptor = &rh_data_alternate_descriptor;
++ rh_data_alternate_descriptors[0].endpoints = sizeof (rh_default) / sizeof(struct usbd_endpoint_descriptor *);
++ rh_data_alternate_descriptors[0].endpoint_list = rh_default;
++ rh_data_alternate_descriptors[0].endpoint_indexes = rh_indexes;
++
++ ZERO(rh_interfaces);
++
++ rh_interfaces[0].alternates = sizeof (rh_data_alternate_descriptions) / sizeof (struct usbd_alternate_description);
++ rh_interfaces[0].alternate_list = rh_data_alternate_descriptions;
++
++
++ ZERO(rh_configuration_descriptor);
++ rh_configuration_descriptor.bLength = 0x09;
++ rh_configuration_descriptor.bDescriptorType = USB_DT_CONFIGURATION;
++ rh_configuration_descriptor.bNumInterfaces = sizeof (rh_interfaces) / sizeof (struct usbd_interface_description);
++ rh_configuration_descriptor.bConfigurationValue = 0x01;
++
++
++ ZERO(rh_description);
++ rh_description[0].configuration_descriptor = &rh_configuration_descriptor;
++ rh_description[0].iConfiguration = Root Hub";
++ rh_description[0].bNumInterfaces = sizeof (rh_interfaces) / sizeof (struct usbd_interface_description);
++ rh_description[0].interface_list = rh_interfaces;
++
++ ZERO(rh_device_descriptor);
++
++ rh_device_descriptor.bLength = sizeof(struct usbd_device_descriptor);
++ rh_device_descriptor.bDescriptorType = USB_DT_DEVICE;
++ rh_device_descriptor.bcdUSB = __constant_cpu_to_le16(USB_BCD_VERSION);
++ rh_device_descriptor.bDeviceClass = USB_CLASS_HUB;
++
++
++#ifdef CONFIG_OTG_HIGH_SPEED
++ ZERO(rh_device_qualifier_descriptor);
++ rh_device_qualifier_descriptor.bLength = sizeof(struct usbd_device_qualifier_descriptor);
++ rh_device_qualifier_descriptor.bDescriptorType = USB_DT_DEVICE_QUALIFIER;
++ rh_device_qualifier_descriptor.bcdUSB = __constant_cpu_to_le16(USB_BCD_VERSION);
++ rh_device_qualifier_descriptor.bDeviceClass = USB_CLASS_HUB;
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++ ZERO(rh_otg_descriptor);
++ rh_otg_descriptor.bLength = sizeof(struct usbd_otg_descriptor);
++ rh_otg_descriptor.bDescriptorType = USB_DT_OTG;
++ rh_otg_descriptor.bmAttributes = 0;
++
++
++ ZERO(rh_device_description);
++ rh_device_description.device_descriptor = &rh_device_descriptor;
++ #ifdef CONFIG_OTG_HIGH_SPEED
++ rh_device_description.device_qualifier_descriptor = &rh_device_qualifier_descriptor;
++ #endif /* CONFIG_OTG_HIGH_SPEED */
++ rh_device_description.otg_descriptor = &rh_otg_descriptor;
++ rh_device_description.iManufacturer = "";
++ rh_device_description.iProduct = "root hub";
++ rh_device_description.endpointsRequested = ENDPOINTS;
++ rh_device_description.requestedEndpoints = rh_endpoint_requests;
++
++}
++#else /* defined(OTG_WINCE) */
++
++static struct hub_descriptor rh_hub_descriptor = {
++ bDescLength: 0x09,
++ bDescriptorType: USB_DT_HUB,
++ bNbrPorts: 0x00,
++ wHubCharacteristics: HUB_GANGED_POWER | HUB_GLOBAL_OVERCURRENT,
++ bPwrOn2PwrGood: 0x01,
++ bHubContrCurrent: 0x01,
++ DeviceRemovable: 0x00,
++ PortPwrCtrlMask: 0xff,
++};
++
++struct usbd_endpoint_descriptor rh_data = {
++ bLength: 0x07,
++ bDescriptorType: USB_DT_ENDPOINT,
++ bEndpointAddress: USB_DIR_IN,
++ bmAttributes: INTERRUPT,
++ wMaxPacketSize: __constant_cpu_to_le16(0x4),
++ bInterval: 0xff,
++};
++
++static struct usbd_endpoint_descriptor *rh_default[] = { &rh_data, };
++u8 rh_indexes[] = { BULK_INT, };
++
++static struct usbd_interface_descriptor rh_data_alternate_descriptor = {
++ bLength: 0x09,
++ bDescriptorType: USB_DT_INTERFACE,
++ bNumEndpoints: 0x01,
++ bInterfaceClass: USB_CLASS_HUB,
++};
++
++static struct usbd_alternate_description rh_data_alternate_descriptions[] = {
++ { iInterface:"Root hub - Status",
++ interface_descriptor: &rh_data_alternate_descriptor,
++ endpoints:sizeof (rh_default) / sizeof(struct usbd_endpoint_descriptor *),
++ endpoint_list: rh_default,
++ endpoint_indexes: rh_indexes,
++ },
++};
++
++static struct usbd_interface_description rh_interfaces[] = {
++ { alternates:sizeof (rh_data_alternate_descriptions) / sizeof (struct usbd_alternate_description),
++ alternate_list:rh_data_alternate_descriptions,},
++};
++
++
++struct usbd_configuration_descriptor rh_configuration_descriptor = {
++ bLength: 0x09,
++ bDescriptorType: USB_DT_CONFIGURATION,
++ bNumInterfaces: sizeof (rh_interfaces) / sizeof (struct usbd_interface_description),
++ bConfigurationValue: 0x01,
++};
++
++struct usbd_configuration_description rh_description[] = {
++ { configuration_descriptor: &rh_configuration_descriptor,
++ iConfiguration:"Root Hub",
++ bNumInterfaces:sizeof (rh_interfaces) / sizeof (struct usbd_interface_description),
++ interface_list:rh_interfaces,},
++};
++
++static struct usbd_device_descriptor rh_device_descriptor = {
++ bLength: sizeof(struct usbd_device_descriptor),
++ bDescriptorType: USB_DT_DEVICE,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: USB_CLASS_HUB,
++};
++
++#ifdef CONFIG_OTG_HIGH_SPEED
++static struct usbd_device_qualifier_descriptor rh_device_qualifier_descriptor = {
++ bLength: sizeof(struct usbd_device_qualifier_descriptor),
++ bDescriptorType: USB_DT_DEVICE_QUALIFIER,
++ bcdUSB: __constant_cpu_to_le16(USB_BCD_VERSION),
++ bDeviceClass: USB_CLASS_HUB,
++};
++#endif /* CONFIG_OTG_HIGH_SPEED */
++
++static struct usbd_endpoint_request rh_endpoint_requests[ENDPOINTS+1] = {
++ { 1, 0, 0, USB_DIR_IN | USB_ENDPOINT_INTERRUPT, 16, 64, },
++ { 0, },
++};
++
++static struct usbd_otg_descriptor rh_otg_descriptor = {
++ bLength : sizeof(struct usbd_otg_descriptor),
++ bDescriptorType: USB_DT_OTG,
++ bmAttributes: 0,
++};
++
++struct usbd_device_description rh_device_description = {
++ device_descriptor: &rh_device_descriptor,
++ #ifdef CONFIG_OTG_HIGH_SPEED
++ device_qualifier_descriptor: &rh_device_qualifier_descriptor,
++ #endif /* CONFIG_OTG_HIGH_SPEED */
++ otg_descriptor: &rh_otg_descriptor,
++ iManufacturer: "",
++ iProduct: "root hub",
++ endpointsRequested: ENDPOINTS,
++ requestedEndpoints: rh_endpoint_requests,
++};
++#endif /* defined(OTG_WINCE) */
++
++/* root hub Private variables ******************************************************************** */
++
++struct rh_private {
++ struct usbd_function_instance *function;
++ int usb_driver_registered; // non-zero if usb function registered
++ unsigned char connected; // non-zero if connected to host (configured)
++ u8 ports;
++ u8 hub_features;
++ u32 *port_features;
++ u32 ports_status;
++ struct WORK_STRUCT bh;
++};
++
++struct rh_private rh_private;
++
++/* Transmit Function *************************************************************************** */
++
++void rh_task(void *data)
++{
++
++ //struct rh_private *rh = (struct rh_private *)data;
++ //struct usbd_function_instance *function = rh->function;
++ //struct usbd_bus_instance *bus = function->bus;
++
++ printk(KERN_INFO"%s: start\n", __FUNCTION__);
++#if 0
++ wait_queue_head_t rh_wait_queue;
++ init_waitqueue_head(&rh_wait_queue);
++
++ while (rh->bh.data && rh->connected) {
++ u32 ports_status = cpu_to_le32(bus->driver->bops->get_ports_status(bus));
++
++ printk(KERN_INFO"%s: status: %08x\n", __FUNCTION__, ports_status);
++
++ if (rh->ports_status != ports_status) {
++ struct usbd_urb *urb = usbd_alloc_urb (function, BULK_INT, 4, NULL);
++ BREAK_UNLESS(urb);
++ memcpy(urb->buffer, &ports_status, 4);
++ urb->actual_length = 4;
++ if (usbd_send_urb(urb)) {
++ printk(KERN_INFO"%s: usbd_send_urb failed\n", __FUNCTION__);
++ usbd_dealloc_urb (urb);
++ }
++ }
++ rh->ports_status = ports_status;
++ interruptible_sleep_on_timeout(&rh_wait_queue, 10000);
++ }
++#endif
++ printk(KERN_INFO"%s: exiting\n", __FUNCTION__);
++}
++
++/* USB Device Functions ************************************************************************ */
++
++/* rh_event_irq - process a device event
++ */
++void rh_event_irq (struct usbd_function_instance *function, usbd_device_event_t event, int data)
++{
++ struct rh_private *rh = &rh_private;
++
++ switch (event) {
++ case DEVICE_CONFIGURED:
++ rh->connected = 1;
++
++ SET_WORK_ARG(rh->bh, &rh_private);
++// rh->bh.data = &rh_private;
++ SCHEDULE_WORK(rh_private.bh);
++// schedule_task(&rh_private.bh);
++ break;
++
++ case DEVICE_RESET:
++ case DEVICE_DE_CONFIGURED:
++ BREAK_UNLESS(rh->connected);
++ rh->connected = 0;
++ rh->bh.data = 0;
++ 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 usbd_urb *urb, void *data, int size, int max_buf)
++{
++ int available;
++ int length = size;
++
++ //printk(KERN_INFO"%s: data: %p size: %d max: %d\n", __FUNCTION__, data, size, max_buf);
++ RETURN_EINVAL_UNLESS (urb);
++ RETURN_EINVAL_UNLESS (data);
++ RETURN_EINVAL_UNLESS (size);
++
++ RETURN_EINVAL_IF ((available = max_buf - urb->actual_length) <= 0);
++
++ //printk(KERN_INFO"%s: length: %d available: %d\n", __FUNCTION__, length, available);
++
++ length = (length < available) ? length : available;
++ memcpy (urb->buffer + urb->actual_length, data, length);
++ urb->actual_length += length;
++ return 0;
++}
++
++/* rh_recv_setup_irq - called to indicate urb has been received
++ */
++int rh_recv_setup_irq (struct usbd_function_instance *function, struct usbd_device_request *request)
++{
++ struct usbd_bus_instance *bus = function->bus;
++ u8 bRequest = request->bRequest;
++ u8 bmRequestType = request->bmRequestType;
++ u16 wValue = le16_to_cpu(request->wValue);
++ u16 wIndex = le16_to_cpu(request->wIndex);
++ u16 wLength = le16_to_cpu(request->wLength);
++
++ u8 direction = bmRequestType & USB_REQ_DIRECTION_MASK;
++ u8 recipient = bmRequestType & USB_REQ_RECIPIENT_MASK;
++
++ //printk(KERN_INFO"%s:\n", __FUNCTION__);
++ /* verify that this is a class request
++ */
++ RETURN_EINVAL_UNLESS((request->bmRequestType & USB_REQ_TYPE_MASK) == USB_REQ_TYPE_CLASS);
++
++ //printk(KERN_INFO"%s: valid direction: %x recipient: %x bRequest: %02x\n",
++ // __FUNCTION__, direction, recipient, bRequest);
++
++ if (USB_REQ_HOST2DEVICE == direction) {
++
++ //printk(KERN_INFO"%s: H2D\n", __FUNCTION__);
++
++ /* these do not require a reply
++ */
++ int setclear_flag = USB_REQ_SET_FEATURE == bRequest;
++ switch (recipient) {
++ case USB_RECIP_HUB:
++ switch (request->bRequest) {
++ case USB_REQ_CLEAR_FEATURE:
++ case USB_REQ_SET_FEATURE:
++ bus->driver->bops->hub_feature(bus, wValue, setclear_flag);
++ }
++ return 0;
++ case USB_RECIP_PORT:
++ switch (request->bRequest) {
++ case USB_REQ_CLEAR_FEATURE:
++ case USB_REQ_SET_FEATURE:
++ bus->driver->bops->port_feature(bus, wValue, wIndex, setclear_flag);
++#if 0
++ case USB_REQ_CLEAR_TT_BUFFER:
++ case USB_REQ_RESET_TT:
++ case USB_REQ_STOP_TT:
++#endif
++ }
++ return 0;
++ }
++ }
++ else {
++ //printk(KERN_INFO"%s: D2H\n", __FUNCTION__);
++
++ /* these do require a reply
++ */
++ struct usbd_urb *urb;
++ int rc = 0;
++ u32 status;
++
++ RETURN_EINVAL_UNLESS(wLength);
++ RETURN_EINVAL_UNLESS((urb = usbd_alloc_urb_ep0(function, wLength, NULL)));
++
++ switch (recipient) {
++ case USB_RECIP_HUB:
++ //printk(KERN_INFO"%s: HUB\n", __FUNCTION__);
++ switch (request->bRequest) {
++ case USB_REQ_GET_DESCRIPTOR:
++ BREAK_UNLESS (copy_report(urb, (void *)&rh_hub_descriptor, sizeof(rh_hub_descriptor), wLength));
++ rc = -EINVAL;
++ break;
++
++ case USB_REQ_GET_STATUS:
++ status = cpu_to_le16(bus->driver->bops->hub_status(bus));
++ urb->actual_length = 4;
++ memcpy(urb->buffer, &status, 4);
++ break;
++ }
++ break;
++ case USB_RECIP_PORT:
++ //printk(KERN_INFO"%s: PORT\n", __FUNCTION__);
++ switch (request->bRequest) {
++ case USB_REQ_GET_STATUS:
++ status = cpu_to_le16(bus->driver->bops->port_status(bus, wIndex));
++ urb->actual_length = 4;
++ memcpy(urb->buffer, &status, 4);
++ break;
++#if 0
++ case USB_REQ_GET_TT_STATE:
++#endif
++ }
++ break;
++ default:
++ rc = -EINVAL;
++ }
++ UNLESS (rc)
++ RETURN_ZERO_IF(!usbd_send_urb(urb));
++ /* error */
++ usbd_dealloc_urb(urb);
++ }
++ return -EINVAL;
++}
++
++
++static int rh_function_enable (struct usbd_function_instance *function)
++{
++ struct rh_private *rh = &rh_private;
++ struct usbd_bus_instance *bus = function->bus;
++ int ports;
++
++ printk (KERN_INFO "%s:\n", __FUNCTION__);
++
++ if (rh->port_features)
++ lkfree(rh->port_features);
++
++ rh->ports = ports = bus->driver->ports;
++ rh->port_features = ckmalloc(4 * ports, GFP_KERNEL);
++ rh_private.bh.data = &rh_private;
++
++ rh_hub_descriptor.bNbrPorts = ports;
++
++ printk (KERN_INFO "%s: ports: %d\n", __FUNCTION__, ports);
++
++ //schedule_task(&rh_private.bh);
++
++ printk (KERN_INFO "%s: finished\n", __FUNCTION__);
++
++ return 0;
++}
++
++static void rh_function_disable (struct usbd_function_instance *function)
++{
++ struct rh_private *rh = &rh_private;
++ printk (KERN_INFO "%s:\n", __FUNCTION__);
++ if (rh->port_features)
++ lkfree(rh->port_features);
++ printk (KERN_INFO "%s: finished\n", __FUNCTION__);
++}
++
++#if defined(OTG_WINCE)
++
++struct otg_instance otg_instance_private;
++
++void hub_ops_init(void)
++{
++ ZERO(otg_instance_private);
++ otg_instance_private.hcd = &hcd_instance_privatej
++}
++
++#else /* defined(OTG_WINCE) */
++
++static struct usbd_function_operations function_ops = {
++ event_irq: rh_event_irq,
++ recv_setup_irq: rh_recv_setup_irq,
++ function_enable: rh_function_enable,
++ function_disable: rh_function_disable,
++};
++
++static struct usbd_function_driver function_driver = {
++ name:"root hub",
++ fops:&function_ops,
++ device_description:&rh_device_description,
++ bNumConfigurations:sizeof (rh_description) / sizeof (struct usbd_configuration_description),
++ configuration_description:rh_description,
++ idVendor: __constant_cpu_to_le16(0x15ec),
++ idProduct: __constant_cpu_to_le16(0xf010),
++ bcdDevice: __constant_cpu_to_le16(0x000),
++};
++#endif /* defined(OTG_WINCE) */
++
++/* USB Module init/exit ************************************************************************ */
++#if defined(OTG_WINCE)
++
++
++#else /* defined(OTG_WINCE) */
++
++
++/*
++ * rh_modinit - module init
++ */
++int rh_init (void)
++{
++ printk (KERN_INFO "%s:\n", __FUNCTION__);
++
++ THROW_IF (usbd_register_function (&function_driver), error);
++
++ printk (KERN_INFO "%s: registered\n", __FUNCTION__);
++
++ rh_private.usb_driver_registered++;
++
++// rh_private.bh.sync = 0;
++// rh_private.bh.routine = rh_task;
++ PREPARE_WORK_ITEM(rh_private.bh,rh_task,NULL);
++
++ CATCH(error) {
++ if (rh_private.usb_driver_registered) {
++ usbd_deregister_function (&function_driver);
++ rh_private.usb_driver_registered = 0;
++ }
++ return -EINVAL;
++ }
++ printk (KERN_INFO "%s: finished\n", __FUNCTION__);
++ return 0;
++}
++
++/* rh_modexit - module cleanup
++ */
++void rh_exit (void)
++{
++ //while (rh_private.bh.sync)
++ while (PENDING_WORK_ITEM(rh_private.bh))
++ schedule_timeout(HZ);
++
++ //rh_private.bh.data = 0;
++ SET_WORK_ARG(rh_private.bh,0);
++ while (PENDING_WORK_ITEM(rh_private.bh))
++ schedule_timeout(HZ);
++
++ if (rh_private.usb_driver_registered)
++ usbd_deregister_function (&function_driver);
++}
++#endif /* defined(OTG_WINCE) */
++#endif /* CONFIG_OTG_ROOT_HUB */
++
+diff -uNr linux/drivers/no-otg/otgcore/otg-fw-df.c linux/drivers/otg/otgcore/otg-fw-df.c
+--- linux/drivers/no-otg/otgcore/otg-fw-df.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otgcore/otg-fw-df.c 2006-09-01 21:41:34.000000000 +0200
+@@ -0,0 +1,121 @@
++
++/* Generated by otg-tests-c.awk
++ *
++ * Do not Edit, see otg-state.awk
++ */
++
++
++/*!
++* @file otg/otgcore/otg-fw-df.c
++* @brief OTG Firmware - Firmware for df
++*
++* This file defines the OTG State Machine tests.
++*
++*
++* @ingroup OTGFW
++*/
++
++/*!
++* @page OTGFW
++* @section OTGFW - otg-fw-df.c
++* This contains the input, output and timout definitions for the OTG state machine firmware
++*/
++
++
++#ifdef OTG_APPLICATION
++#define NULL 0
++#include "otg-fw.h"
++#include "otg-fw-df.h"
++#else /* OTG_APPLICATION/ */
++#include <otg/otg-compat.h>
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/usbp-bus.h>
++#include <otg/otg-trace.h>
++//#include <otg/otg-api.h>
++#include <otg/otg-fw.h>
++#include <otg/otg-fw-df.h>
++#endif /* OTG_APPLICATION */
++
++char otg_fw_name_df[] = "otg_df";
++
++
++struct otg_test otg_tests_df[] = {
++ /*
++ * Copyright (c) 2004 Belcarra
++ *
++ */
++ /*!
++ * This is the default Firmware. It is included in the
++ * compiled modules and supports the auto Traditional USB
++ * mode. No user inputs are implemented.
++ */
++ { /* */
++ 0, /* .test */
++ invalid_state, /* .state */
++ otg_disabled, /* .target */
++ enable_otg, /* .test1 */
++ },
++ /*
++ * This is not an OTG State. It is used internally to mark the end of the
++ * list of states and inputs.
++ */
++ { /* */
++ 1, /* .test */
++ terminator_state, /* .state */
++ invalid_state, /* .target */
++ 0, /* .test1 */
++ },
++ {2, invalid_state,},
++
++};
++
++#define OTG_TESTS_DF 2
++
++int otg_test_max_df = 2;
++
++ /* eof */
++
++/* Generated by otg-info-c.awk
++ *
++ * Do not Edit, see otg-state.awk
++ */
++
++struct otg_state otg_states_df[OTG_STATES_DF + 1] = {
++ { /* 0 */
++ invalid_state, /* .state */
++ m_otg_init, /* .meta */
++ "invalid_state", /* .name */
++ 0, /* .tmout */
++ 0, /* .reset */
++ },
++ { /* 1 */
++ otg_disabled, /* .state */
++ m_otg_init, /* .meta */
++ "otg_disabled", /* .name */
++ 0, /* .tmout */
++ 0, /* .reset */
++ },
++ { /* 2 */
++ terminator_state, /* .state */
++ m_otg_init, /* .meta */
++ "terminator_state", /* .name */
++ 0, /* .tmout */
++ 0, /* .reset */
++ /* .outputs */
++ 0,
++ },
++
++ {0, 0, "", 0, 0,},
++
++};
++
++struct otg_firmware otg_firmware_df = {
++ OTG_STATES_DF, /* number of states */
++ OTG_TESTS_DF, /* number of tests */
++ "otg-df", /* name of firmware */
++ otg_states_df, /* struct otg_state * */
++ otg_tests_df, /* struct otg_test * */
++};
++
++/* eof */
+diff -uNr linux/drivers/no-otg/otgcore/otg-fw-mn.c linux/drivers/otg/otgcore/otg-fw-mn.c
+--- linux/drivers/no-otg/otgcore/otg-fw-mn.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otgcore/otg-fw-mn.c 2006-09-01 21:41:34.000000000 +0200
+@@ -0,0 +1,511 @@
++
++/* Generated by otg-tests-c.awk
++ *
++ * Do not Edit, see otg-state.awk
++ */
++
++
++/*!
++* @file otg/otgcore/otg-fw-mn.c
++* @brief OTG Firmware - Firmware for mn
++*
++* This file defines the OTG State Machine tests.
++*
++*
++* @ingroup OTGFW
++*/
++
++/*!
++* @page OTGFW
++* @section OTGFW - otg-fw-mn.c
++* This contains the input, output and timout definitions for the OTG state machine firmware
++*/
++
++
++#ifdef OTG_APPLICATION
++#define NULL 0
++#include "otg-fw.h"
++#include "otg-fw-mn.h"
++#else /* OTG_APPLICATION/ */
++#include <otg/otg-compat.h>
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/usbp-bus.h>
++#include <otg/otg-trace.h>
++//#include <otg/otg-api.h>
++#include <otg/otg-fw.h>
++#include <otg/otg-fw-mn.h>
++#endif /* OTG_APPLICATION */
++
++char otg_fw_name_mn[] = "otg_mn";
++
++
++struct otg_test otg_tests_mn[] = {
++ /*
++ * Copyright (c) 2004 Belcarra
++ */
++ /*!
++ * This is the initialization set for pcd and tcd.
++ */
++ /*
++ * This the initial state of the software when first loaded.
++ * It is not possible to return to this state.
++ */
++ { /* Initialize by sending the otg_enable signal. */
++ 0, /* .test */
++ invalid_state, /* .state */
++ otg_disabled, /* .target */
++ enable_otg, /* .test1 */
++ },
++ /*
++ * The USBOTG State Machine has been initialized but is inactive.
++ * This state may have arrived at from either the invalid_state or
++ * from the otg_disable state.
++ */
++ { /* Initialize by sending the otg_enable signal. */
++ 1, /* .test */
++ otg_disabled, /* .state */
++ otg_enable_pcd, /* .target */
++ enable_otg, /* .test1 */
++ },
++ /*
++ * The State Machine stops the device drivers and waits for them
++ * to signal that they have finished de-initializing.
++ *
++ * This state disables the TCD driver and waits for TCD ok.
++ */
++ { /* Wait for ok from de-initializing drivers. */
++ 2, /* .test */
++ otg_disable_tcd, /* .state */
++ otg_disable_pcd, /* .target */
++ TCD_OK, /* .test1 */
++ },
++ /*
++ * The State Machine stops the device drivers and waits for them
++ * to signal that they have finished de-initializing.
++ *
++ * This state disables the PCD driver and waits for PCD ok.
++ */
++ { /* Wait for ok from de-initializing drivers. */
++ 3, /* .test */
++ otg_disable_pcd, /* .state */
++ otg_disabled, /* .target */
++ PCD_OK, /* .test1 */
++ },
++ /*
++ * The State Machine starts the device drivers and waits for them
++ * to signal that they have finished initializing.
++ *
++ * This state enables the PCD driver and waits for PCD ok.
++ */
++ { /* Wait for ok from initializing drivers. */
++ 4, /* .test */
++ otg_enable_pcd, /* .state */
++ otg_enable_tcd, /* .target */
++ PCD_OK, /* .test1 */
++ },
++ /*
++ * The State Machine starts the device drivers and waits for them
++ * to signal that they have finished initializing.
++ *
++ * This state enables the PCD driver and waits for PCD ok.
++ */
++ { /* Wait for ok from initializing drivers. */
++ 5, /* .test */
++ otg_enable_tcd, /* .state */
++ otg_enabled, /* .target */
++ TCD_OK, /* .test1 */
++ },
++ /*
++ * Copyright (c) 2004 Belcarra
++ *
++ */
++ /*!
++ * This is the minimal firmware. It can be included in the
++ * compiled modules and supports the auto Traditional USB
++ * mode. No user inputs are required for normal operation.
++ *
++ * The b_bus_drop input can be optionally used to disconnect and re-connect.
++ *
++ * The enable_otg input can be optionally used to disable and re-enable.
++ * Note that disable/enable will reset b_bus_drop.
++ *
++ */
++ /*!
++ * The State Machine has successfully started the device drivers and
++ * is waiting for an input event. Typically it will move from here to
++ * an idle state specific to the current conditions (a_idle, b_idle, mn_idle etc.)
++ * based on user request b_bus_drop.
++ *
++ */
++ { /* Check for disable. */
++ 6, /* .test */
++ otg_enabled, /* .state */
++ otg_disable_tcd, /* .target */
++ enable_otg_, /* .test1 */
++ },
++ { /* Move to idle. */
++ 7, /* .test */
++ otg_enabled, /* .state */
++ mn_idle, /* .target */
++ AUTO | AUTO_, /* .test1 */
++ },
++ /*!
++ * The State Machine is in the idle state for a Traditional USB Device.
++ * It is waiting for Vbus to indicate that it has been plugged into a USB Host.
++ *
++ */
++ { /* Check for disable (must be done for check for bus_drop.) */
++ 8, /* .test */
++ mn_idle, /* .state */
++ otg_disable_tcd, /* .target */
++ enable_otg_, /* .test1 */
++ },
++ { /* Check for b_bus_drop */
++ 9, /* .test */
++ mn_idle, /* .state */
++ mn_bus_drop, /* .target */
++ b_bus_drop, /* .test1 */
++ },
++ { /* move to peripheral mode when SESSION valid. */
++ 10, /* .test */
++ mn_idle, /* .state */
++ mn_peripheral, /* .target */
++ b_bus_drop_, /* .test1 */
++ B_SESS_VLD, /* .test2 */
++ },
++ /*!
++ * The State Machine is in the idle state for a Traditional USB Device.
++ * The B-Device applications has requested that the bus connection be dropped.
++ * Wait for either enable_otg reset or b_bus_drop reset.
++ */
++ { /* Wait for b_bus_drop/ or enable_otg/ */
++ 11, /* .test */
++ mn_bus_drop, /* .state */
++ mn_idle, /* .target */
++ b_bus_drop_ | enable_otg_, /* .test1 */
++ },
++ /*!
++ * The State Machine in the peripheral state for a Traditional USB Device.
++ * The D+ pullup is enabled and we are waiting for a BUS_RESET to
++ * indicate that the USB Host has recognized that a USB Device is attached.
++ */
++ { /* Move to idle if we loose any of these inputs. */
++ 12, /* .test */
++ mn_peripheral, /* .state */
++ mn_idle, /* .target */
++ enable_otg_ | B_SESS_VLD_ | b_bus_drop, /* .test1 */
++ },
++ { /* Move to next state if bus reset is seen. */
++ 13, /* .test */
++ mn_peripheral, /* .state */
++ mn_bus_reset, /* .target */
++ BUS_RESET, /* .test1 */
++ },
++ /*!
++ * The State Machine in the bus_reset state for a Traditional USB Device.
++ * It is waiting to be enumerated and configured by the USB Host.
++ */
++ { /* Move to idle via discharge, if we loose any of these inputs. */
++ 14, /* .test */
++ mn_bus_reset, /* .state */
++ mn_discharge, /* .target */
++ enable_otg_ | B_SESS_VLD_ | b_bus_drop, /* .test1 */
++ },
++ { /* Progress if we are addressed. */
++ 15, /* .test */
++ mn_bus_reset, /* .state */
++ mn_addressed, /* .target */
++ ADDRESSED, /* .test1 */
++ },
++ /*!
++ * The State Machine in the configured state for a Traditional USB Device.
++ * This means that there is an active session, there is packet traffic
++ * with this device.
++ */
++ { /* Move to idle via discharge, if we loose any of these inputs. */
++ 16, /* .test */
++ mn_addressed, /* .state */
++ mn_discharge, /* .target */
++ enable_otg_ | B_SESS_VLD_ | b_bus_drop, /* .test1 */
++ },
++ { /* Progress if we are configured. */
++ 17, /* .test */
++ mn_addressed, /* .state */
++ mn_configured, /* .target */
++ CONFIGURED, /* .test1 */
++ },
++ /*!
++ * The State Machine in the configured state for a Traditional USB Device.
++ * This means that there is an active session, there is packet traffic
++ * with this device.
++ */
++ { /* */
++ 18, /* .test */
++ mn_configured, /* .state */
++ mn_suspended, /* .target */
++ BUS_SUSPENDED, /* .test1 */
++ },
++ { /* Move to idle via discharge, if we loose any of these inputs. */
++ 19, /* .test */
++ mn_configured, /* .state */
++ mn_discharge, /* .target */
++ enable_otg_ | B_SESS_VLD_ | b_bus_drop, /* .test1 */
++ },
++ /*!
++ * The State Machine in the discharge state for a Traditional USB Device.
++ * The device has been unplugged. The Vbus discharge resistor will be enabled
++ * for the TLDISC_DSCHRG time period.
++ */
++ { /* Progress to idle on timeout. */
++ 20, /* .test */
++ mn_discharge, /* .state */
++ mn_idle, /* .target */
++ Tldisc_dschrg, /* .test1 */
++ },
++ /*!
++ * The State Machine in the suspend state for a Traditional USB Device.
++ */
++ { /* Move to idle via discharge, if we loose any of these inputs. */
++ 21, /* .test */
++ mn_suspended, /* .state */
++ mn_discharge, /* .target */
++ enable_otg_ | B_SESS_VLD_ | b_bus_drop, /* .test1 */
++ },
++ { /* Check for a resumed bus. */
++ 22, /* .test */
++ mn_suspended, /* .state */
++ mn_configured, /* .target */
++ BUS_SUSPENDED_, /* .test1 */
++ },
++ { /* Is remote wakeup enabled? */
++ 23, /* .test */
++ mn_suspended, /* .state */
++ mn_wakeup_enabled, /* .target */
++ REMOTE_WAKEUP_ENABLED, /* .test1 */
++ },
++ /*!
++ * The State Machine in the suspend state for a Traditional USB Device,
++ * prior to suspended the USB Host enabled Remote Wakeup by sending a
++ * set REMOTE WAKUP request.
++ */
++ { /* Move to idle via discharge, if we loose any of these inputs. */
++ 24, /* .test */
++ mn_wakeup_enabled, /* .state */
++ mn_discharge, /* .target */
++ enable_otg_ | b_bus_req_ | B_SESS_VLD_, /* .test1 */
++ },
++ { /* Check for a resumed bus. */
++ 25, /* .test */
++ mn_wakeup_enabled, /* .state */
++ mn_suspended, /* .target */
++ BUS_SUSPENDED_, /* .test1 */
++ },
++ { /* Remote wakeup requested? */
++ 26, /* .test */
++ mn_wakeup_enabled, /* .state */
++ mn_wakeup, /* .target */
++ remote_wakeup_cmd, /* .test1 */
++ },
++ /*!
++ * The State Machine in the wakeup state for a Traditional USB Device,
++ * The REMOTE WAKEUP procedure will be performed.
++ */
++ { /* Automatic return. */
++ 27, /* .test */
++ mn_wakeup, /* .state */
++ mn_wakeup_enabled, /* .target */
++ AUTO | AUTO_, /* .test1 */
++ },
++ /*!
++ * This is not an OTG State. It is used internally to mark the end of the
++ * list of states and inputs.
++ */
++ { /* */
++ 28, /* .test */
++ terminator_state, /* .state */
++ invalid_state, /* .target */
++ 0, /* .test1 */
++ },
++ {29, invalid_state,},
++
++};
++
++#define OTG_TESTS_MN 29
++
++int otg_test_max_mn = 29;
++
++ /* eof */
++
++/* Generated by otg-info-c.awk
++ *
++ * Do not Edit, see otg-state.awk
++ */
++
++struct otg_state otg_states_mn[OTG_STATES_MN + 1] = {
++ { /* 0 */
++ invalid_state, /* .state */
++ m_otg_init, /* .meta */
++ "invalid_state", /* .name */
++ 0, /* .tmout */
++ 0, /* .reset */
++ },
++ { /* 1 */
++ otg_disabled, /* .state */
++ m_otg_init, /* .meta */
++ "otg_disabled", /* .name */
++ 0, /* .tmout */
++ enable_otg_, /* .reset */
++ /* .outputs */
++ chrg_vbus_out_ | drv_vbus_out_ | dp_pullup_out_ | loc_sof_out_,
++ },
++ { /* 2 */
++ otg_disable_tcd, /* .state */
++ m_otg_init, /* .meta */
++ "otg_disable_tcd", /* .name */
++ 0, /* .tmout */
++ TCD_OK_, /* .reset */
++ /* .outputs */
++ tcd_init_out_,
++ },
++ { /* 3 */
++ otg_disable_pcd, /* .state */
++ m_otg_init, /* .meta */
++ "otg_disable_pcd", /* .name */
++ 0, /* .tmout */
++ PCD_OK_, /* .reset */
++ /* .outputs */
++ pcd_init_out_,
++ },
++ { /* 4 */
++ otg_enable_pcd, /* .state */
++ m_otg_init, /* .meta */
++ "otg_enable_pcd", /* .name */
++ 0, /* .tmout */
++ PCD_OK_, /* .reset */
++ /* .outputs */
++ chrg_vbus_out_ | drv_vbus_out_ | dp_pullup_out_ | loc_sof_out_ | pcd_init_out,
++ },
++ { /* 5 */
++ otg_enable_tcd, /* .state */
++ m_otg_init, /* .meta */
++ "otg_enable_tcd", /* .name */
++ 0, /* .tmout */
++ TCD_OK_, /* .reset */
++ /* .outputs */
++ chrg_vbus_out_ | drv_vbus_out_ | dp_pullup_out_ | loc_sof_out_ | tcd_init_out,
++ },
++ { /* 6 */
++ otg_enabled, /* .state */
++ m_otg_init, /* .meta */
++ "otg_enabled", /* .name */
++ 0, /* .tmout */
++ b_bus_drop_, /* .reset */
++ },
++ { /* 7 */
++ mn_idle, /* .state */
++ m_b_idle, /* .meta */
++ "mn_idle", /* .name */
++ 0, /* .tmout */
++ 0, /* .reset */
++ /* .outputs */
++ dp_pullup_out_ | pcd_en_out_ | tcd_en_out_power | dischrg_vbus_out_,
++ },
++ { /* 8 */
++ mn_bus_drop, /* .state */
++ m_b_idle, /* .meta */
++ "mn_bus_drop", /* .name */
++ 0, /* .tmout */
++ 0, /* .reset */
++ },
++ { /* 9 */
++ mn_peripheral, /* .state */
++ m_b_peripheral, /* .meta */
++ "mn_peripheral", /* .name */
++ 0, /* .tmout */
++ BUS_RESET_, /* .reset */
++ /* .outputs */
++ dp_pullup_out | pcd_en_out | dischrg_vbus_out_,
++ },
++ { /* 10 */
++ mn_bus_reset, /* .state */
++ m_b_peripheral, /* .meta */
++ "mn_bus_reset", /* .name */
++ 0, /* .tmout */
++ BUS_RESET_ | ADDRESSED_, /* .reset */
++ },
++ { /* 11 */
++ mn_addressed, /* .state */
++ m_b_peripheral, /* .meta */
++ "mn_addressed", /* .name */
++ 0, /* .tmout */
++ ADDRESSED_ | CONFIGURED_, /* .reset */
++ /* .outputs */
++ dp_pullup_out | pcd_en_out | dischrg_vbus_out_,
++ },
++ { /* 12 */
++ mn_configured, /* .state */
++ m_b_peripheral, /* .meta */
++ "mn_configured", /* .name */
++ 0, /* .tmout */
++ CONFIGURED_ | BUS_SUSPENDED_, /* .reset */
++ /* .outputs */
++ dp_pullup_out | pcd_en_out | dischrg_vbus_out_,
++ },
++ { /* 13 */
++ mn_discharge, /* .state */
++ m_b_peripheral, /* .meta */
++ "mn_discharge", /* .name */
++ TLDISC_DSCHRG, /* .tmout */
++ 0, /* .reset */
++ /* .outputs */
++ dischrg_vbus_out | pcd_en_out_,
++ },
++ { /* 14 */
++ mn_suspended, /* .state */
++ m_b_suspended, /* .meta */
++ "mn_suspended", /* .name */
++ 0, /* .tmout */
++ 0, /* .reset */
++ },
++ { /* 15 */
++ mn_wakeup_enabled, /* .state */
++ m_b_suspended, /* .meta */
++ "mn_wakeup_enabled", /* .name */
++ 0, /* .tmout */
++ remote_wakeup_cmd_, /* .reset */
++ /* .outputs */
++ remote_wakeup_out_,
++ },
++ { /* 16 */
++ mn_wakeup, /* .state */
++ m_b_suspended, /* .meta */
++ "mn_wakeup", /* .name */
++ 0, /* .tmout */
++ 0, /* .reset */
++ /* .outputs */
++ remote_wakeup_out,
++ },
++ { /* 17 */
++ terminator_state, /* .state */
++ m_otg_init, /* .meta */
++ "terminator_state", /* .name */
++ 0, /* .tmout */
++ 0, /* .reset */
++ /* .outputs */
++ 0,
++ },
++
++ {0, 0, "", 0, 0,},
++
++};
++
++struct otg_firmware otg_firmware_mn = {
++ OTG_STATES_MN, /* number of states */
++ OTG_TESTS_MN, /* number of tests */
++ "otg-mn", /* name of firmware */
++ otg_states_mn, /* struct otg_state * */
++ otg_tests_mn, /* struct otg_test * */
++};
++
++/* eof */
+diff -uNr linux/drivers/no-otg/otgcore/otg-fw.c linux/drivers/otg/otgcore/otg-fw.c
+--- linux/drivers/no-otg/otgcore/otg-fw.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otgcore/otg-fw.c 2006-09-01 21:41:34.000000000 +0200
+@@ -0,0 +1,251 @@
++
++/* Generated by otg-fw-c.awk
++ *
++ * Do not Edit, see otg-state.awk
++ */
++
++/*!
++* @file otg/otgcore/otg-fw.c
++* @brief OTG Firmware - Input, Output and Timeout definitions
++*
++* This file defines the OTG State Machine input, output and timeout constants.
++*
++*
++* @ingroup OTGFW
++*/
++
++/*!
++* @page OTGFW
++* @section OTGFW - otg-fw.c
++* This contains the input, output and timout definitions for the OTG state machine firmware
++*/
++
++
++#ifdef OTG_APPLICATION
++#include "otg-fw.h"
++#else /* OTG_APPLICATION/ */
++#include <otg/otg-compat.h>
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/usbp-bus.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#endif /* OTG_APPLICATION */
++
++#define OTG_VERSION_FWC 200502152159L
++
++
++#if OTG_VERSION_FWC != OTG_VERSION_FW
++#error OTG_VERSION_FWC != OTG_VERSION_FW
++#endif /* OTG_VERSION_FWC != OTG_VERSION_FW */
++
++/* Generated by otg-input-name-c.awk
++ *
++ * Do not Edit, see otg-state.awk
++ */
++
++
++/* #include "otg-fw.h" */
++
++#define OTG_VERSION_INPUT_TABLE 200502152159L
++
++
++#if OTG_VERSION_INPUT_TABLE != OTG_VERSION_FW
++#error OTG_VERSION_INPUT_TABLE != OTG_VERSION_FW
++#endif /* OTG_VERSION_INPUT_TABLE != OTG_VERSION_FW */
++
++
++struct otg_input_name otg_input_names[] = {
++ {ID_GND, "ID_GND",},
++ {ID_FLOAT, "ID_FLOAT",},
++ {DP_HIGH, "DP_HIGH",},
++ {DM_HIGH, "DM_HIGH",},
++ {B_SESS_END, "B_SESS_END",},
++ {A_SESS_VLD, "A_SESS_VLD",},
++ {B_SESS_VLD, "B_SESS_VLD",},
++ {VBUS_VLD, "VBUS_VLD",},
++ {SRP_DET, "SRP_DET",},
++ {SE0_DET, "SE0_DET",},
++ {SE1_DET, "SE1_DET",},
++ {BDIS_ACON, "BDIS_ACON",},
++ {CR_INT_DET, "CR_INT_DET",},
++ {HUB_PORT_CONNECT, "HUB_PORT_CONNECT",},
++ {BUS_RESET, "BUS_RESET",},
++ {ADDRESSED, "ADDRESSED",},
++ {CONFIGURED, "CONFIGURED",},
++ {NOT_SUPPORTED, "NOT_SUPPORTED",},
++ {BUS_SUSPENDED, "BUS_SUSPENDED",},
++ {a_bcon_no_tmout_req, "a_bcon_no_tmout_req",},
++ {a_hpwr_req, "a_hpwr_req",},
++ {bus_drop, "bus_drop",},
++ {a_bus_drop, "a_bus_drop",},
++ {b_bus_drop, "b_bus_drop",},
++ {bus_req, "bus_req",},
++ {a_bus_req, "a_bus_req",},
++ {b_bus_req, "b_bus_req",},
++ {b_sess_req, "b_sess_req",},
++ {suspend_req, "suspend_req",},
++ {a_suspend_req, "a_suspend_req",},
++ {b_suspend_req, "b_suspend_req",},
++ {set_remote_wakeup_cmd, "set_remote_wakeup_cmd",},
++ {remote_wakeup_cmd, "remote_wakeup_cmd",},
++ {reset_remote_wakeup_cmd, "reset_remote_wakeup_cmd",},
++ {clr_err_cmd, "clr_err_cmd",},
++ {b_hnp_cmd, "b_hnp_cmd",},
++ {ph_int_cmd, "ph_int_cmd",},
++ {ph_audio_cmd, "ph_audio_cmd",},
++ {cr_int_cmd, "cr_int_cmd",},
++ {led_on_cmd, "led_on_cmd",},
++ {led_off_cmd, "led_off_cmd",},
++ {HNP_ENABLED, "HNP_ENABLED",},
++ {HNP_CAPABLE, "HNP_CAPABLE",},
++ {HNP_SUPPORTED, "HNP_SUPPORTED",},
++ {REMOTE_WAKEUP_ENABLED, "REMOTE_WAKEUP_ENABLED",},
++ {REMOTE_CAPABLE, "REMOTE_CAPABLE",},
++ {PCD_OK, "PCD_OK",},
++ {TCD_OK, "TCD_OK",},
++ {HCD_OK, "HCD_OK",},
++ {OCD_OK, "OCD_OK",},
++ {TMOUT, "TMOUT",},
++ {enable_otg, "enable_otg",},
++ {AUTO, "AUTO",},
++ {0, "0",},
++
++};
++
++ /* eof */
++
++/* Generated by otg-ioctls-names-c.awk
++ *
++ * Do not Edit, see otg-state.awk
++ */
++#if defined(OTG_LINUX) || defined(OTG_WINCE)
++
++
++/* #include "otg-fw.h" */
++
++#define OTG_VERSION_IOCTL_TABLE 200502152159L
++
++
++#if OTG_VERSION_IOCTL_TABLE != OTG_VERSION_FW
++#error OTG_VERSION_IOCTL_TABLE != OTG_VERSION_FW
++#endif /* OTG_VERSION_IOCTL_TABLE != OTG_VERSION_FW */
++
++struct otg_ioctl_name otg_ioctl_names[] = {
++ {OTGADMIN_A_BCON_NO_TMOUT_REQ, a_bcon_no_tmout_req, "OTGADMIN_A_BCON_NO_TMOUT_REQ",},
++ {OTGADMIN_A_HPWR_REQ, a_hpwr_req, "OTGADMIN_A_HPWR_REQ",},
++ {OTGADMIN_BUS_DROP, bus_drop, "OTGADMIN_BUS_DROP",},
++ {OTGADMIN_A_BUS_DROP, a_bus_drop, "OTGADMIN_A_BUS_DROP",},
++ {OTGADMIN_B_BUS_DROP, b_bus_drop, "OTGADMIN_B_BUS_DROP",},
++ {OTGADMIN_BUS_REQ, bus_req, "OTGADMIN_BUS_REQ",},
++ {OTGADMIN_A_BUS_REQ, a_bus_req, "OTGADMIN_A_BUS_REQ",},
++ {OTGADMIN_B_BUS_REQ, b_bus_req, "OTGADMIN_B_BUS_REQ",},
++ {OTGADMIN_B_SESS_REQ, b_sess_req, "OTGADMIN_B_SESS_REQ",},
++ {OTGADMIN_SUSPEND_REQ, suspend_req, "OTGADMIN_SUSPEND_REQ",},
++ {OTGADMIN_A_SUSPEND_REQ, a_suspend_req, "OTGADMIN_A_SUSPEND_REQ",},
++ {OTGADMIN_B_SUSPEND_REQ, b_suspend_req, "OTGADMIN_B_SUSPEND_REQ",},
++ {OTGADMIN_SET_REMOTE_WAKEUP_CMD, set_remote_wakeup_cmd, "OTGADMIN_SET_REMOTE_WAKEUP_CMD",},
++ {OTGADMIN_REMOTE_WAKEUP_CMD, remote_wakeup_cmd, "OTGADMIN_REMOTE_WAKEUP_CMD",},
++ {OTGADMIN_RESET_REMOTE_WAKEUP_CMD, reset_remote_wakeup_cmd, "OTGADMIN_RESET_REMOTE_WAKEUP_CMD",},
++ {OTGADMIN_CLR_ERR_CMD, clr_err_cmd, "OTGADMIN_CLR_ERR_CMD",},
++ {OTGADMIN_B_HNP_CMD, b_hnp_cmd, "OTGADMIN_B_HNP_CMD",},
++ {OTGADMIN_PH_INT_CMD, ph_int_cmd, "OTGADMIN_PH_INT_CMD",},
++ {OTGADMIN_PH_AUDIO_CMD, ph_audio_cmd, "OTGADMIN_PH_AUDIO_CMD",},
++ {OTGADMIN_CR_INT_CMD, cr_int_cmd, "OTGADMIN_CR_INT_CMD",},
++ {OTGADMIN_LED_ON_CMD, led_on_cmd, "OTGADMIN_LED_ON_CMD",},
++ {OTGADMIN_LED_OFF_CMD, led_off_cmd, "OTGADMIN_LED_OFF_CMD",},
++ {OTGADMIN_ENABLE_OTG, enable_otg, "OTGADMIN_ENABLE_OTG",},
++ {0, 0, "",},
++
++};
++
++ /* eof */
++#endif /* defined(OTG_LINUX) || defined(OTG_WINCE) */
++
++/* Generated by otg-output-names-c.awk
++ *
++ * Do not Edit, see otg-state.awk
++ */
++
++char *otg_output_names[] = {
++ "tcd_init_out", /* 0 Initiate Transceiver Controller Driver Initialization (or De-initialization.) */
++ "pcd_init_out", /* 1 Initiate Peripheral Controller Driver Initialization (or De-initialization.) */
++ "hcd_init_out", /* 2 Initiate Host Controller Driver Initialization (or De-initialization). */
++ "ocd_init_out", /* 3 Initiate OTG Controller Driver Initialization (or De-initialization). */
++ "tcd_en_out", /* 4 Enable Transceiver Controller Driver */
++ "pcd_en_out", /* 5 Enable Peripheral Controller Driver */
++ "hcd_en_out", /* 6 Enable Host Controller Driver */
++ "drv_vbus_out", /* 7 A-Device will Drive Vbus to 5V through charge pump. */
++ "chrg_vbus_out", /* 8 B-Device will charge Vbus to 3.3V through resistor (SRP.) */
++ "dischrg_vbus_out", /* 9 B-Device will discharge Vbus (enable dischage resistor.) */
++ "dm_pullup_out", /* 10 DM pullup control - aka loc_carkit */
++ "dm_pulldown_out", /* 11 DM pulldown control */
++ "dp_pullup_out", /* 12 DP pullup control - aka loc_conn */
++ "dp_pulldown_out", /* 13 DP pulldown control */
++ "clr_overcurrent_out", /* 14 Clear overcurrent indication */
++ "dm_det_out", /* 15 Enable B-Device D- High detect */
++ "dp_det_out", /* 16 Enable B-Device D+ High detect */
++ "cr_det_out", /* 17 Enable D+ CR detect */
++ "charge_pump_out", /* 18 Enable external charge pump. */
++ "bdis_acon_out", /* 19 Enable auto A-connect after B-disconnect. */
++ "mx21_vbus_drain", /* 20 MX21 hack */
++ "id_pulldown_out", /* 21 Enable the ID to ground pulldown ( (CEA-936 - 5 wire carkit.) */
++ "uart_out", /* 22 Enable Transparent UART mode (CEA-936.) */
++ "audio_out", /* 23 Enable Audio mode (CEA-936 CarKit interrupt detector.) */
++ "mono_out", /* 24 Enable Mono-Audio mode (CEA-936.) */
++ "remote_wakeup_out", /* 25 Peripheral will perform remote wakeup. */
++ "loc_sof_out", /* 26 Host will enable packet traffic. */
++ "loc_suspend_out", /* 27 Host will suspend bus. */
++ "remote_wakeup_en_out", /* 28 Host will send remote wakeup enable or disable request. */
++ "hnp_en_out", /* 29 Host will send HNP enable request. */
++ "hpwr_out", /* 30 Host will enable high power (external charge pump.) */
++ NULL,
++
++};
++
++ /* eof */
++
++/* Generated by otg-meta-names-c.awk
++ *
++ * Do not Edit, see otg-state.awk
++ */
++
++
++
++char *otg_meta_names[] = {
++ "a_idle", /* 0 - */
++ "a_wait_vrise", /* 1 - */
++ "a_wait_bcon", /* 2 - */
++ "a_host", /* 3 - */
++ "a_suspend", /* 4 - */
++ "a_peripheral", /* 5 - */
++ "a_wait_vfall", /* 6 - */
++ "a_vbus_err", /* 7 - */
++ "b_idle", /* 8 - */
++ "b_srp_init", /* 9 - */
++ "b_peripheral", /* 10 - */
++ "b_suspend", /* 11 - */
++ "b_wait_acon", /* 12 - */
++ "b_host", /* 13 - */
++ "b_suspended", /* 14 - */
++ "ph_disc", /* 15 - Equivalent to b_peripheral */
++ "ph_init", /* 16 - */
++ "ph_uart", /* 17 - */
++ "ph_aud", /* 18 - */
++ "ph_wait", /* 19 - */
++ "ph_exit", /* 20 - */
++ "cr_init", /* 21 - */
++ "cr_uart", /* 22 - */
++ "cr_aud", /* 23 - */
++ "cr_ack", /* 24 - */
++ "cr_wait", /* 25 - */
++ "cr_disc", /* 26 - */
++ "otg_init", /* 27 - */
++ "usb_accessory", /* 28 - */
++ "usb_factory", /* 29 - */
++ "unknown", /* 30 - */
++
++ "",
++};
++
++/* eof */
+diff -uNr linux/drivers/no-otg/otgcore/otg-mesg-l24.c linux/drivers/otg/otgcore/otg-mesg-l24.c
+--- linux/drivers/no-otg/otgcore/otg-mesg-l24.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otgcore/otg-mesg-l24.c 2006-09-01 21:41:34.000000000 +0200
+@@ -0,0 +1,399 @@
++/*
++ * otg/otgcore/otg-mesg-l24.c - OTG state machine Administration
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/otgcore/otg-mesg-l24.c
++ * @brief OTG Core Linux Message Interface.
++ *
++ * Implement linux char device via /proc/otg-mesg.
++ *
++ * @ingroup OTGCore
++ */
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/usbp-bus.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-tcd.h>
++#include <otg/otg-hcd.h>
++#include <otg/otg-pcd.h>
++#include <otg/otg-ocd.h>
++
++#include <linux/poll.h>
++#include <linux/sched.h>
++
++
++wait_queue_head_t otg_message_queue;
++
++/*!
++ * otg_message() - queue message data
++ * @param buf message to send.
++ */
++void otg_message (char *buf)
++{
++ char time_buf[64];
++ static u64 save_ticks;
++ u64 new_ticks;
++ u64 ticks;
++
++ new_ticks = otg_tmr_ticks();
++
++ otg_write_message(buf, strlen(buf));
++
++ ticks = otg_tmr_elapsed(&new_ticks, &save_ticks);
++ save_ticks = new_ticks;
++
++ if (ticks < 10000)
++ sprintf(time_buf, " %d uS\n", ticks);
++ else if (ticks < 10000000)
++ //sprintf(time_buf, " %d mS\n", ticks / 1000);
++ sprintf(time_buf, " %d mS\n", ticks >> 10);
++ else
++ //sprintf(time_buf, " %d S\n", ticks / 1000000);
++ sprintf(time_buf, " %d S\n", ticks >> 20);
++
++ otg_write_message(time_buf, strlen(time_buf));
++
++
++ //TRACE_MSG0(CORE, "wakeup ");
++ //printk(KERN_INFO"%s: wakeup\n", __FUNCTION__);
++ wake_up_interruptible(&otg_message_queue);
++}
++
++/*!
++ * otg_message_block() - implement block
++ */
++unsigned int otg_message_block(void)
++{
++ int count = otg_data_queued();
++ if (count) return count;
++ //TRACE_MSG0(CORE, "sleeping ");
++ //printk(KERN_INFO"%s: sleeping\n", __FUNCTION__);
++ interruptible_sleep_on(&otg_message_queue);
++ return otg_data_queued();
++}
++
++/*!
++ * otg_message_poll() - implement poll
++ * @param filp file pointer
++ * @param wait poll table structure
++ */
++unsigned int otg_message_poll(struct file *filp, struct poll_table_struct *wait)
++{
++ //TRACE_MSG0(CORE, "polling ");
++ poll_wait(filp, &otg_message_queue, wait);
++ return otg_data_queued() ? POLLIN | POLLRDNORM : 0;
++}
++
++/*!
++ * otg_message_ioctl_internal() - ioctl call
++ * @param cmd ioctl command.
++ * @param arg ioctl arguement.
++ * @return non-zero for error.
++ */
++int otg_message_ioctl_internal(unsigned int cmd, unsigned long arg)
++{
++ int i;
++ int len;
++ int flag;
++ struct otg_admin_command admin_command;
++ struct otg_status_update status_update;
++ struct otg_firmware_info firmware_info;
++ struct otg_state otg_state;
++ struct otg_test otg_test;
++ struct otg_ioctl_name *otg_ioctl_name;
++ static char func_buf[32];
++ char *sp, *dp;
++ char *name;
++
++ switch (cmd) {
++
++ case OTGADMIN_GET_FUNCTION:
++ //TRACE_MSG0(CORE, "OTGADMIN_GET_FUNCTION");
++ RETURN_EINVAL_UNLESS(otg_firmware_loaded);
++ RETURN_EINVAL_IF(copy_from_user(&admin_command, (void *)arg, _IOC_SIZE(cmd)));
++ name = otg_usbd_ops->function_name(admin_command.n);
++ admin_command.string[0] = '\0';
++ if (name)
++ strncat(admin_command.string, name, sizeof(admin_command.string));
++
++ RETURN_EINVAL_IF(copy_to_user((void *)arg, &admin_command, _IOC_SIZE(cmd)));
++ return 0;
++
++ case OTGADMIN_SET_FUNCTION:
++ //TRACE_MSG0(CORE, "OTGADMIN_SET_FUNCTION");
++ RETURN_EINVAL_UNLESS(otg_firmware_loaded);
++ memset(&admin_command, 0x41, sizeof(struct otg_admin_command));
++ RETURN_EINVAL_IF(copy_from_user(&admin_command, (void *)arg, _IOC_SIZE(cmd)));
++ len = sizeof(mesg_otg_instance->function_name);
++ admin_command.string[len] = '\0';
++ //TRACE_MSG1(CORE, "Setting function: \"%s\"", mesg_otg_instance->function_name);
++ strncpy(mesg_otg_instance->function_name, admin_command.string, len);
++ mesg_otg_instance->function_name[len-1] = '\0';
++ return 0;
++
++ case OTGADMIN_GET_SERIAL:
++ //TRACE_MSG0(CORE, "OTGADMIN_GET_SERIAL");
++ RETURN_EINVAL_UNLESS(otg_firmware_loaded);
++ strncpy(admin_command.string, mesg_otg_instance->serial_number, sizeof(admin_command.string));
++ admin_command.string[sizeof(admin_command.string) - 1] = '\0';
++ RETURN_EINVAL_IF(copy_to_user((void *)arg, &admin_command, _IOC_SIZE(cmd)));
++ return 0;
++
++ case OTGADMIN_SET_SERIAL:
++ //TRACE_MSG0(CORE, "OTGADMIN_SET_SERIAL");
++ RETURN_EINVAL_UNLESS(otg_firmware_loaded);
++ RETURN_EINVAL_IF(copy_from_user(&admin_command, (void *)arg, _IOC_SIZE(cmd)));
++ admin_command.string[sizeof(admin_command.string) - 1] = '\0';
++ printk(KERN_INFO"%s: string: %s\n", __FUNCTION__, admin_command.string);
++ for (sp = admin_command.string, dp = mesg_otg_instance->serial_number, i = 0;
++ *sp && (i < (sizeof(admin_command.string) - 1)); i++, sp++)
++ if (isxdigit(*sp)) *dp++ = toupper(*sp);
++
++ *sp = '\0';
++ //TRACE_MSG1(CORE, "serial_number: %s", mesg_otg_instance->serial_number);
++ printk(KERN_INFO"%s: serial: %s\n", __FUNCTION__, mesg_otg_instance->serial_number);
++ return 0;
++
++ case OTGADMIN_STATUS:
++ //TRACE_MSG0(CORE, "OTGADMIN_STATUS");
++ RETURN_EINVAL_UNLESS(otg_firmware_loaded);
++ memset(&status_update, 0, sizeof(struct otg_status_update));
++
++ otg_mesg_get_status_update(&status_update);
++
++ RETURN_EINVAL_IF(copy_to_user((void *)arg, &status_update, _IOC_SIZE(cmd)));
++ return 0;
++
++ case OTGADMIN_GET_INFO:
++ //TRACE_MSG0(CORE, "OTGADMIN_GET_INFO");
++ RETURN_EINVAL_UNLESS(otg_firmware_loaded);
++
++ otg_mesg_get_firmware_info(&firmware_info);
++
++ RETURN_EINVAL_IF(copy_to_user((void *)arg, &firmware_info, _IOC_SIZE(cmd)));
++ //TRACE_MSG0(CORE, "OTGADMIN_GET_INFO: finished");
++ return 0;
++
++ case OTGADMIN_SET_INFO:
++ //TRACE_MSG0(CORE, "OTGADMIN_SET_INFO");
++ memset(&firmware_info, 0x41, sizeof(firmware_info));
++ RETURN_EINVAL_IF(copy_from_user(&firmware_info, (void *)arg, _IOC_SIZE(cmd)));
++
++
++ return otg_mesg_set_firmware_info(&firmware_info);
++ return 0;
++
++ case OTGADMIN_GET_STATE:
++ case OTGADMIN_SET_STATE:
++ //TRACE_MSG0(CORE, "OTGADMIN_XXX_STATE");
++ RETURN_EINVAL_IF(copy_from_user(&otg_state, (void *)arg, _IOC_SIZE(cmd)));
++
++ switch (cmd) {
++ case OTGADMIN_GET_STATE:
++ RETURN_EINVAL_UNLESS(otg_firmware_loaded);
++ //TRACE_MSG0(CORE, "OTGADMIN_GET_STATE");
++ RETURN_EINVAL_UNLESS (otg_state.state < otg_firmware_loaded->number_of_states);
++ memcpy(&otg_state, otg_firmware_loaded->otg_states + otg_state.state, sizeof(otg_state));
++ RETURN_EINVAL_IF(copy_to_user((void *)arg, &otg_state, _IOC_SIZE(cmd)));
++ break;
++ case OTGADMIN_SET_STATE:
++ RETURN_EINVAL_UNLESS(otg_firmware_loading);
++ //TRACE_MSG0(CORE, "OTGADMIN_SET_STATE");
++ RETURN_EINVAL_UNLESS (otg_state.state < otg_firmware_loading->number_of_states);
++ memcpy(otg_firmware_loading->otg_states + otg_state.state, &otg_state, sizeof(otg_state));
++ break;
++ }
++ return 0;
++
++
++ case OTGADMIN_GET_TEST:
++ case OTGADMIN_SET_TEST:
++ RETURN_EINVAL_IF(copy_from_user(&otg_test, (void *)arg, _IOC_SIZE(cmd)));
++
++ switch (cmd) {
++ case OTGADMIN_GET_TEST:
++ RETURN_EINVAL_UNLESS(otg_firmware_loaded);
++ //TRACE_MSG1(CORE, "OTGADMIN_GET_TEST: %d", otg_test.test);
++ RETURN_EINVAL_UNLESS (otg_test.test < otg_firmware_loaded->number_of_tests);
++ memcpy(&otg_test, otg_firmware_loaded->otg_tests + otg_test.test, sizeof(otg_test));
++ RETURN_EINVAL_IF(copy_to_user((void *)arg, &otg_test, _IOC_SIZE(cmd)));
++ break;
++ case OTGADMIN_SET_TEST:
++ RETURN_EINVAL_UNLESS(otg_firmware_loading);
++ //TRACE_MSG1(CORE, "OTGADMIN_SET_TEST : %d", otg_test.test);
++ RETURN_EINVAL_UNLESS (otg_test.test < otg_firmware_loading->number_of_tests);
++ memcpy(otg_firmware_loading->otg_tests + otg_test.test, &otg_test, sizeof(otg_test));
++ break;
++ }
++ return 0;
++
++ default:
++ //TRACE_MSG0(CORE, "OTGADMIN_");
++ RETURN_EINVAL_UNLESS(otg_firmware_loaded);
++ for (otg_ioctl_name = otg_ioctl_names; otg_ioctl_name && otg_ioctl_name->cmd; otg_ioctl_name++) {
++ //TRACE_MSG4(CORE, "lookup: %04x %04x %08x %08x",
++ // _IOC_NR(cmd), _IOC_NR(otg_ioctl_name->cmd), cmd, otg_ioctl_name->cmd);
++ BREAK_IF(_IOC_NR(otg_ioctl_name->cmd) == _IOC_NR(cmd));
++ }
++ //TRACE_MSG3(CORE, "checking %d %08x %08x", _IOC_NR(cmd), otg_ioctl_name->cmd, cmd);
++ RETURN_EINVAL_UNLESS(otg_ioctl_name->cmd);
++ __get_user(flag, (int *)arg);
++ //TRACE_MSG3(CORE, "%s %08x flag: %d", otg_ioctl_name->name, otg_ioctl_name->set, flag);
++ otg_event (mesg_otg_instance, flag ? otg_ioctl_name->set : _NOT(otg_ioctl_name->set), CORE, otg_ioctl_name->name);
++ return 0;
++ }
++ return 0;
++}
++
++
++
++/*!
++ * otg_message_ioctl() - ioctl
++ * @param inode inode structure.
++ * @param filp file.
++ * @param cmd ioctl command.
++ * @param arg ioctl argument.
++ * @return non-zero for error.
++ */
++int otg_message_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
++{
++ int i;
++ int len;
++ int flag;
++ struct otg_admin_command admin_command;
++ struct otg_status_update status_update;
++ struct otg_firmware_info firmware_info;
++ struct otg_state otg_state;
++ struct otg_test otg_test;
++ //struct otg_ioctl_map *map = ioctl_map;
++ struct otg_ioctl_name *otg_ioctl_name;
++
++ static char func_buf[32];
++
++ //TRACE_MSG6(CORE, "cmd: %08x arg: %08x type: %02d nr: %02d dir: %02d size: %02d",
++ // cmd, arg, _IOC_TYPE(cmd), _IOC_NR(cmd), _IOC_DIR(cmd), _IOC_SIZE(cmd));
++
++ RETURN_EINVAL_UNLESS (_IOC_TYPE(cmd) == OTGADMIN_MAGIC);
++ RETURN_EINVAL_UNLESS (_IOC_NR(cmd) <= OTGADMIN_MAXNR);
++
++ RETURN_EFAULT_IF((_IOC_DIR(cmd) == _IOC_READ) && !access_ok(VERIFY_WRITE, (void *)arg, _IOC_SIZE(cmd)));
++ RETURN_EFAULT_IF((_IOC_DIR(cmd) == _IOC_WRITE) && !access_ok(VERIFY_READ, (void *)arg, _IOC_SIZE(cmd)));
++
++ return otg_message_ioctl_internal(cmd, arg);
++}
++
++
++/*!
++ * otg_message_proc_read() - implement proc file system read.
++ * Standard proc file system read function.
++ * @param file file.
++ * @param buf buffer to fill
++ * @param count size of buffer
++ * @param pos file position
++ * @return number of bytes or negative number for error
++ */
++static ssize_t otg_message_proc_read (struct file *file, char *buf, size_t count, loff_t * pos)
++{
++ unsigned long page;
++ int len = 0, avail;
++ char *bp,*ep;
++ struct list_head *lhd;
++ int state;
++
++ // get a page, max 4095 bytes of data...
++ RETURN_ENOMEM_UNLESS ((page = GET_KERNEL_PAGE()));
++
++ bp = (char *) page;
++
++ len = bp - (char *) page;
++
++ if (( avail = otg_message_block())) {
++
++ len += otg_read_message(bp, 4095);
++
++ if (len > count)
++ len = -EINVAL;
++ else if ((len > 0) && copy_to_user (buf, (char *) page, len))
++ len = -EFAULT;
++
++ }
++
++ free_page (page);
++ return len;
++}
++
++/*! otg_message_proc_ioctl() -
++ * @param inode inode structure.
++ * @param filp file.
++ * @param cmd ioctl command.
++ * @param arg ioctl argument.
++ * @return non-zero for error.
++ */
++int otg_message_proc_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
++{
++ return otg_message_ioctl(inode, filp, cmd, arg);
++}
++
++/*!
++ * @param filp file.
++ * @param wait buffer to fill
++ * @return number of bytes or negative number for error
++ */
++unsigned int otg_message_proc_poll(struct file *filp, struct poll_table_struct *wait)
++{
++ return otg_message_poll(filp, wait);
++}
++
++/*!
++ * @var otg_message_proc_switch_functions
++ */
++static struct file_operations otg_message_proc_switch_functions = {
++ ioctl:otg_message_proc_ioctl,
++ poll:otg_message_proc_poll,
++ read:otg_message_proc_read,
++};
++
++
++/*!
++ * otg_message_init_l24() - initialize
++ */
++int otg_message_init_l24(struct otg_instance *otg)
++{
++ struct proc_dir_entry *message = NULL;
++ init_waitqueue_head(&otg_message_queue);
++
++ THROW_IF (!(message = create_proc_entry ("otg_message", 0666, 0)), error);
++ message->proc_fops = &otg_message_proc_switch_functions;
++ CATCH(error) {
++ printk(KERN_ERR"%s: creating /proc/otg_message failed\n", __FUNCTION__);
++ if (message)
++ remove_proc_entry("otg_message", NULL);
++ return -EINVAL;
++ }
++ return 0;
++}
++
++/*!
++ * otg_message_exit_l24() - exit
++ */
++void otg_message_exit_l24(void)
++{
++ remove_proc_entry("otg_message", NULL);
++}
++
++EXPORT_SYMBOL(otg_message);
++
++
+diff -uNr linux/drivers/no-otg/otgcore/otg-mesg.c linux/drivers/otg/otgcore/otg-mesg.c
+--- linux/drivers/no-otg/otgcore/otg-mesg.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otgcore/otg-mesg.c 2006-09-01 21:41:35.000000000 +0200
+@@ -0,0 +1,369 @@
++/*
++ * otg/otgcore/otg-mesg.c - OTG state machine Administration
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/otgcore/otg-mesg.c
++ * @brief OTG Core Message Facility.
++ *
++ * The OTG Core Message Facility has two functions:
++ *
++ * 1. implement a message queue for messages from the otg state machine to the otg
++ * management application
++ *
++ * 2. implement an ioctl control mechanism allowing the otg managment application
++ * to pass data and commands to the otg state machine
++ *
++ * @ingroup OTGCore
++ */
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/usbp-bus.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-tcd.h>
++#include <otg/otg-hcd.h>
++#include <otg/otg-pcd.h>
++#include <otg/otg-ocd.h>
++
++#if defined(OTG_LINUX)
++#include <linux/poll.h>
++#include <linux/sched.h>
++#endif /* defined(OTG_LINUX) */
++
++//#define OTG_MESSAGE_BUF_SIZE 512
++#define OTG_MESSAGE_BUF_SIZE 2048
++
++struct otg_instance * mesg_otg_instance;
++
++char *otg_message_buf; // buffer
++char *otg_message_head; // next available empty space
++char *otg_message_tail; // next available data if not equal to head
++
++/*!
++ * otg_data_avail() - amount of data in buffer
++ * space data
++ * tp hp 20 - (10 - 5) = 15 (10 - 5)
++ * 0......5.data.10......20
++ *
++ * hp tp (10 - 5) = 5 20 - (10 - 5)
++ * 0.data.5......10.data.20
++ *
++ * @return Bytes available in message ring buffer.
++ */
++int otg_data_avail(void)
++{
++ int avail = (otg_message_head >= otg_message_tail) ?
++ (otg_message_head - otg_message_tail) :
++ OTG_MESSAGE_BUF_SIZE - (otg_message_tail - otg_message_head) ;
++
++ //TRACE_MSG4(CORE, "buf: %p head: %p tail: %p data avail: %d", otg_message_buf, otg_message_head, otg_message_tail, avail);
++ return avail;
++}
++
++/*!
++ * otg_space_avail() - amount of space in buffer
++ *
++ * @return Space available in message ring buffer.
++ */
++int otg_space_avail(void)
++{
++ int avail = (otg_message_head >= otg_message_tail) ?
++ OTG_MESSAGE_BUF_SIZE - (otg_message_head - otg_message_tail) :
++ (otg_message_tail - otg_message_head) ;
++
++ //TRACE_MSG4(CORE, "buf: %p head: %p tail: %p space avail: %d", otg_message_buf, otg_message_head, otg_message_tail, avail);
++ return avail;
++}
++
++/*!
++ * otg_get_byte() - return next byte
++ *
++ * @return Next byte in message ring buffer
++ */
++char otg_get_byte(void)
++{
++ char c = *otg_message_tail;
++
++ //TRACE_MSG3(CORE, "buf: %p head: %p tail: %p", otg_message_buf, otg_message_head, otg_message_tail);
++ if ((otg_message_tail - otg_message_buf) == OTG_MESSAGE_BUF_SIZE)
++ otg_message_tail = otg_message_buf;
++ else
++ otg_message_tail++;
++
++ return c;
++}
++
++/*!
++ * otg_put_byte() - put byte into buffer
++ *
++ * Put byte into message ring buffer
++ *
++ * @param byte put into message ring.
++ */
++void otg_put_byte(char byte)
++{
++ *otg_message_head = byte;
++ if ((otg_message_head - otg_message_buf) == OTG_MESSAGE_BUF_SIZE)
++ otg_message_head = otg_message_buf;
++ else
++ otg_message_head++;
++
++}
++
++/*!
++ * otg_write_message_irq() - queue message data (interrupt version)
++ *
++ * Attempt to write message data into ring buffer, return amount
++ * of data actually written.
++ *
++ * @param buf - pointer to data
++ * @param size - amount of available data
++ * @return number of bytes that where not written.
++ */
++int otg_write_message_irq (char *buf, int size)
++{
++ struct pcd_instance *pcd = NULL;
++ struct usbd_bus_instance *bus = NULL;
++
++ pcd = (struct pcd_instance *)mesg_otg_instance->pcd;
++ if (pcd)
++ bus = pcd->bus;
++
++ if (size >= (OTG_MESSAGE_BUF_SIZE - 2))
++ return size;
++
++ while (otg_space_avail() < (size + 1))
++ otg_get_byte();
++
++
++ /* copy, note that we don't have to test for space as we have
++ * already ensured that there is enough room for all of the data
++ */
++ while (size--)
++ otg_put_byte(*buf++);
++
++ //otg_put_byte('\n');
++
++ return size;
++}
++
++/*!
++ * otg_write_message() - queue message data
++ *
++ * Attempt to write message data into ring buffer, return amount
++ * of data actually written.
++ *
++ * @param buf - pointer to data
++ * @param size - amount of available data
++ * @return number of bytes that where not written.
++ */
++int otg_write_message (char *buf, int size)
++{
++ int rc;
++ unsigned long flags;
++ local_irq_save (flags);
++ rc = otg_write_message_irq(buf, size);
++ local_irq_restore (flags);
++ return size;
++}
++
++/*!
++ * otg_read_message() - get queued message data
++ *
++ * @param buf - pointer to data
++ * @param size - amount of available data
++ * @return the number of bytes read.
++ */
++int otg_read_message(char *buf, int size)
++{
++ int count = 0;
++ unsigned long flags;
++
++ local_irq_save (flags);
++
++ /* Copy bytes to the buffer while there is data available and space
++ * to put it in the buffer
++ */
++ for ( ; otg_data_avail() && size--; count++)
++ BREAK_IF((*buf++ = otg_get_byte()) == '\n');
++
++ local_irq_restore (flags);
++ return count;
++}
++
++/*!
++ * otg_data_queued() - return amount of data currently queued
++ *
++ * @return Amount of data currently queued in mesage ring buffer.
++ */
++int otg_data_queued(void)
++{
++ int count;
++ unsigned long flags;
++ local_irq_save (flags);
++ count = otg_data_avail();
++ local_irq_restore (flags);
++ //printk(KERN_INFO"%s: count: %d\n", __FUNCTION__, count);
++ return count;
++}
++
++
++/*!
++ * otg_message_init() - initialize
++ * @param otg OTG instance
++ */
++int otg_message_init(struct otg_instance *otg)
++{
++ struct proc_dir_entry *message = NULL;
++ otg_message_buf = otg_message_head = otg_message_tail = NULL;
++ THROW_UNLESS((otg_message_buf = CKMALLOC(OTG_MESSAGE_BUF_SIZE + 16, GFP_KERNEL)), error);
++ otg_message_head = otg_message_tail = otg_message_buf ;
++
++ mesg_otg_instance = otg;
++ CATCH(error) {
++ #if defined(OTG_LINUX)
++ printk(KERN_ERR"%s: creating /proc/otg_message failed\n", __FUNCTION__);
++ #endif /* defined(OTG_LINUX) */
++ #if defined(OTG_WINCE)
++ DEBUGMSG(ZONE_INIT, (_T("otg_message_init: creating //proc//otg_message failed\n")) );
++ #endif /* defined(OTG_LINUX) */
++ return -EINVAL;
++ }
++ return 0;
++}
++
++/*!
++ * otg_message_exit() - exit
++ */
++void otg_message_exit(void)
++{
++ mesg_otg_instance = NULL;
++ if (otg_message_buf)
++ LKFREE(otg_message_buf);
++ otg_message_buf = otg_message_head = otg_message_tail = NULL;
++}
++
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++
++/*!
++ * otg_mesg_get_status_update() - get status update
++ * @param status_update
++ */
++void otg_mesg_get_status_update(struct otg_status_update *status_update)
++{
++
++ TRACE_MSG0(CORE, "--");
++ status_update->state = mesg_otg_instance->state;
++ status_update->meta = mesg_otg_instance->current_outputs->meta;
++ status_update->inputs = mesg_otg_instance->current_inputs;
++ status_update->outputs = mesg_otg_instance->outputs;
++ status_update->capabilities = otg_ocd_ops ? otg_ocd_ops->capabilities : 0;
++
++ strncpy(status_update->fw_name, otg_firmware_loaded->fw_name, OTGADMIN_MAXSTR);
++ strncpy(status_update->state_name, otg_get_state_name(mesg_otg_instance->state), OTGADMIN_MAXSTR);
++
++ if (mesg_otg_instance->function_name)
++ strncpy(status_update->function_name, mesg_otg_instance->function_name, OTGADMIN_MAXSTR);
++
++ TRACE_MSG5(CORE, "state: %02x meta: %02x inputs: %08x outputs: %04x",
++ status_update->state, status_update->meta, status_update->inputs,
++ status_update->outputs, status_update->capabilities);
++}
++
++
++/*!
++ * otg_mesg_get_firmware_info() - get firmware info
++ * @param firmware_info
++ */
++void otg_mesg_get_firmware_info(struct otg_firmware_info *firmware_info)
++{
++ memset(firmware_info, 0, sizeof(firmware_info));
++ // XXX irq lock
++
++ firmware_info->number_of_states = otg_firmware_loaded->number_of_states;
++ firmware_info->number_of_tests = otg_firmware_loaded->number_of_tests;
++ memcpy(&firmware_info->fw_name, otg_firmware_loaded->fw_name, sizeof(firmware_info->fw_name));
++
++}
++
++/*!
++ * otg_mesg_set_firmware_info() - set firmware info
++ * @param firmware_info
++ */
++int otg_mesg_set_firmware_info(struct otg_firmware_info *firmware_info)
++{
++
++ if (otg_firmware_loading) {
++
++ if ( (otg_firmware_loading->number_of_states == firmware_info->number_of_states) &&
++ (otg_firmware_loading->number_of_tests == firmware_info->number_of_tests)
++ ) {
++ TRACE_MSG0(CORE, "OTGADMIN_SET_INFO: loaded");
++ otg_firmware_loaded = otg_firmware_loading;
++ otg_firmware_loading = NULL;
++ return 0;
++ }
++ else {
++ TRACE_MSG0(CORE, "OTGADMIN_SET_INFO: abandoned");
++ LKFREE(otg_firmware_loading->otg_states);
++ LKFREE(otg_firmware_loading->otg_tests);
++ LKFREE(otg_firmware_loading);
++ return -EINVAL;
++ }
++ }
++
++ TRACE_MSG2(CORE, "OTGADMIN_SET_INFO: otg_firmware_loaded: %x otg_firmware_orig: %x",
++ otg_firmware_loaded, otg_firmware_orig);
++ if (otg_firmware_loaded && (otg_firmware_loaded != otg_firmware_orig)) {
++ LKFREE(otg_firmware_loaded->otg_states);
++ LKFREE(otg_firmware_loaded->otg_tests);
++ LKFREE(otg_firmware_loaded);
++ otg_firmware_loaded = otg_firmware_orig;
++ TRACE_MSG0(CORE, "OTGADMIN_SET_INFO: unloaded");
++ }
++ if (firmware_info->number_of_states && firmware_info->number_of_tests) {
++ int size;
++ otg_firmware_loaded = NULL;
++ TRACE_MSG0(CORE, "OTGADMIN_SET_INFO: setup");
++ THROW_UNLESS((otg_firmware_loading = CKMALLOC(sizeof(struct otg_firmware), GFP_KERNEL)), error);
++ size = sizeof(struct otg_state) * firmware_info->number_of_states;
++ THROW_UNLESS((otg_firmware_loading->otg_states = CKMALLOC(size, GFP_KERNEL)), error);
++ size = sizeof(struct otg_test) * firmware_info->number_of_tests;
++ THROW_UNLESS((otg_firmware_loading->otg_tests = CKMALLOC(size, GFP_KERNEL)), error);
++
++ otg_firmware_loading->number_of_states = firmware_info->number_of_states;
++ otg_firmware_loading->number_of_tests = firmware_info->number_of_tests;
++ memcpy(otg_firmware_loading->fw_name, &firmware_info->fw_name, sizeof(firmware_info->fw_name));
++
++ CATCH(error) {
++ TRACE_MSG0(CORE, "OTGADMIN_SET_INFO: setup error");
++ if (otg_firmware_loading) {
++ if (otg_firmware_loading->otg_states) LKFREE(otg_firmware_loading->otg_states);
++ if (otg_firmware_loading->otg_tests) LKFREE(otg_firmware_loading->otg_tests);
++ LKFREE(otg_firmware_loading);
++ return -EINVAL;
++ }
++ }
++
++ }
++ return 0;
++}
++
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++
+diff -uNr linux/drivers/no-otg/otgcore/otg-trace-l24.c linux/drivers/otg/otgcore/otg-trace-l24.c
+--- linux/drivers/no-otg/otgcore/otg-trace-l24.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otgcore/otg-trace-l24.c 2006-09-01 21:41:35.000000000 +0200
+@@ -0,0 +1,174 @@
++/*
++ * otg/otgcore/otg-trace-l24.c
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ *
++ */
++/*!
++ * @file otg/otgcore/otg-trace-l24.c
++ * @brief OTG Core Linux Debug Trace Facility
++ *
++ * This allows access to the OTG Core Trace via /proc/trace_otg. Each time
++ * this file is opened and read it will contain a snapshot of the most
++ * recent trace messages.
++ *
++ * Reading the trace resets it, the next read will open a new snapshot.
++ *
++ * N.B. There is no protection from multiple reads.
++ *
++ * N.B. This is for debugging and is not normally enabled for production software.
++ *
++ * @ingroup OTGCore
++ */
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++#include <linux/vmalloc.h>
++#include <stdarg.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/usbp-bus.h>
++
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++
++#if defined(CONFIG_OTG_TRACE) || defined(CONFIG_OTG_TRACE_MODULE)
++
++DECLARE_MUTEX(otg_trace_sem_l24);
++
++
++/* *
++ * otg_trace_proc_read_l24 - implement proc file system read.
++ * @file
++ * @buf
++ * @count
++ * @pos
++ *
++ * Standard proc file system read function.
++ */
++static ssize_t otg_trace_proc_read_l24 (struct file *file, char *buf, size_t count, loff_t * pos)
++{
++ unsigned long page;
++ int len = 0;
++ int index;
++ int oindex;
++ int rc;
++
++ u64 ticks = 0;
++
++ unsigned char *cp;
++ int skip = 0;
++
++ otg_trace_t px;
++ otg_trace_t ox;
++ otg_trace_t vx;
++ otg_trace_t *o, *p;
++
++ RETURN_ENOMEM_IF (!(page = GET_KERNEL_PAGE()));
++
++ _MOD_INC_USE_COUNT;
++
++ // Lock out tag changes while reading
++ DOWN(&otg_trace_sem_l24);
++ len = otg_trace_proc_read((char *)page, count, (int *)pos);
++
++ if (len > count)
++ len = -EINVAL;
++
++ else if (len > 0 && copy_to_user (buf, (char *) page, len))
++ len = -EFAULT;
++
++ free_page (page);
++
++ UP(&otg_trace_sem_l24);
++ free_page (page);
++ _MOD_DEC_USE_COUNT;
++ return len;
++}
++
++#define MAX_TRACE_CMD_LEN 64
++/* *
++ * otg_trace_proc_write_l24 - implement proc file system write.
++ * @file
++ * @buf
++ * @count
++ * @pos
++ *
++ * Proc file system write function.
++ */
++static ssize_t otg_trace_proc_write_l24 (struct file *file, const char *buf, size_t count, loff_t * pos)
++{
++ char command[MAX_TRACE_CMD_LEN+1];
++ size_t l = MIN(count, MAX_TRACE_CMD_LEN);
++
++ RETURN_ZERO_UNLESS(count);
++ RETURN_EINVAL_IF (copy_from_user (command, buf, l));
++
++
++ RETURN_EINVAL_IF(copy_from_user (command, buf, l));
++
++ return otg_trace_proc_write(command, l, (int *)pos);
++#if 0
++ else {
++ n -= l;
++ while (n > 0) {
++ 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;
++ }
++#endif
++}
++
++/* Module init ************************************************************** */
++
++
++
++static struct file_operations otg_trace_proc_operations_functions = {
++ read: otg_trace_proc_read_l24,
++ write: otg_trace_proc_write_l24,
++};
++
++/*! otg_trace_init_l24
++ *
++ * Return non-zero if not successful.
++ */
++int otg_trace_init_l24 (void)
++{
++ struct proc_dir_entry *p;
++
++ // create proc filesystem entries
++ if ((p = create_proc_entry ("trace_otg", 0, 0)) == NULL)
++ printk(KERN_INFO"%s PROC FS failed\n", "trace_otg");
++ else
++ p->proc_fops = &otg_trace_proc_operations_functions;
++
++ return 0;
++}
++
++/*! otg_trace_exit_l24 - remove procfs entry, free trace data space.
++ */
++void otg_trace_exit_l24 (void)
++{
++ otg_trace_t *p;
++ unsigned long flags;
++ remove_proc_entry ("trace_otg", NULL);
++}
++
++#else /* defined(CONFIG_OTG_TRACE) || defined(CONFIG_OTG_TRACE_MODULE) */
++int otg_trace_init_l24 (void) {return 0;}
++void otg_trace_exit_l24 (void) {}
++#endif /* defined(CONFIG_OTG_TRACE) || defined(CONFIG_OTG_TRACE_MODULE) */
++
+diff -uNr linux/drivers/no-otg/otgcore/otg-trace.c linux/drivers/otg/otgcore/otg-trace.c
+--- linux/drivers/no-otg/otgcore/otg-trace.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otgcore/otg-trace.c 2006-09-01 21:41:35.000000000 +0200
+@@ -0,0 +1,615 @@
++/*
++ * otg/otgcore/otg-trace.c
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ *
++ */
++/*!
++ * @file otg/otgcore/otg-trace.c
++ * @brief OTG Core Debug Trace Facility
++ *
++ * This implements the OTG Core Trace Facility.
++ *
++ * @ingroup OTGCore
++ */
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#if defined(OTG_LINUX)
++#include <linux/vmalloc.h>
++#include <stdarg.h>
++#endif /* defined(OTG_LINUX) */
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/usbp-bus.h>
++
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++
++#define STATIC static
++
++#if defined(CONFIG_OTG_TRACE) || defined(CONFIG_OTG_TRACE_MODULE)
++
++DECLARE_MUTEX(otg_trace_sem);
++
++static int otg_trace_exiting;
++
++#define OTG_TRACE_NAME "trace_otg"
++
++typedef struct otg_trace_snapshot {
++ int first;
++ int next;
++ int total;
++ otg_trace_t *traces;
++} otg_trace_snapshot;
++
++otg_trace_snapshot otg_snapshot1;
++otg_trace_snapshot otg_snapshot2;
++
++static otg_trace_snapshot *otg_trace_current_traces;
++static otg_trace_snapshot *otg_trace_other_traces;
++
++STATIC otg_trace_snapshot *rel_snapshot(otg_trace_snapshot *tss)
++{
++ RETURN_NULL_UNLESS(tss);
++ if (tss->traces) {
++ vfree(tss->traces);
++ tss->traces = NULL;
++ }
++ //vfree(tss);
++ return NULL;
++}
++
++STATIC void init_snapshot(otg_trace_snapshot *tss)
++{
++ tss->first = tss->next = tss->total = 0;
++ memset(tss->traces,0,sizeof(otg_trace_t) * TRACE_MAX);
++}
++
++STATIC otg_trace_snapshot *get_snapshot(otg_trace_snapshot *tss)
++{
++ //otg_trace_snapshot *tss;
++ unsigned long flags;
++ //UNLESS ((tss = vmalloc(sizeof(otg_trace_snapshot)))) {
++ // printk(KERN_ERR "Cannot allocate memory for OTG trace snapshot.\n");
++ // return NULL;
++ //}
++
++ UNLESS ((tss->traces = vmalloc(sizeof(otg_trace_t) * TRACE_MAX))) {
++ printk(KERN_ERR "Cannot allocate memory for OTG trace log.\n");
++ return rel_snapshot(tss);
++ }
++ init_snapshot(tss);
++ return tss;
++}
++
++/*! otg_trace_get_next
++ */
++STATIC otg_trace_t *otg_trace_get_next(otg_trace_snapshot *tss, otg_tag_t tag, const char *fn, otg_trace_types_t otg_trace_type, int n)
++{
++ otg_trace_t *p;
++
++ // Get the next (n) trace slots.
++
++ p = tss->traces + tss->next;
++
++ while (n-- > 0) {
++ tss->next = (tss->next + 1) & TRACE_MASK;
++ if (tss->next == tss->first) {
++ // We have wraparound, bump tss->first
++ tss->first = (tss->first + 1) & TRACE_MASK;
++ }
++ tss->total++;
++ }
++ // End of next trace slot.
++
++ otg_get_trace_info(p);
++ p->otg_trace_type = otg_trace_type;
++ p->tag = tag;
++ p->va.s.function = fn;
++
++ return p;
++}
++
++/* otg_trace_next_va
++ */
++STATIC otg_trace_t *otg_trace_next_va(otg_trace_snapshot *tss, otg_trace_t *p)
++{
++ /* Return the next trace slot in a va group.
++ No need to be atomic, just worry about wraparound. */
++ int nxt = (p - tss->traces);
++ nxt = (nxt + 1) & TRACE_MASK;
++ p = tss->traces + nxt;
++ return(p);
++}
++
++/* otg_trace_setup
++ */
++void otg_trace_setup(otg_tag_t tag, const char *fn, void *setup)
++{
++ otg_trace_t *p;
++ otg_trace_snapshot *tss;
++ unsigned long flags;
++ local_irq_save(flags);
++ UNLESS ((tss = otg_trace_current_traces)) {
++ local_irq_restore(flags);
++ return;
++ }
++ // Reserve the trace slots.
++ UNLESS ((p = otg_trace_get_next(tss,tag,fn,otg_trace_setup_n,1))) {
++ local_irq_restore(flags);
++ return;
++ }
++ p->va_num_args = 0;
++ memcpy(&p->va.s.trace.setup, setup, sizeof(p->va.s.trace.setup) /*sizeof(struct usbd_device_request)*/);
++ local_irq_restore(flags);
++}
++
++/* otg_trace_msg
++ */
++void otg_trace_msg(otg_tag_t tag, const char *fn, u8 nargs, char *fmt, ...)
++{
++ int n;
++ otg_trace_t *p;
++ otg_trace_snapshot *tss;
++ unsigned long flags;
++
++ // Figure out how many trace slots we're going to need.
++ n = 1;
++ if (nargs > 1) {
++ n = 2;
++ // Too many arguments, bail.
++ RETURN_IF (nargs > (OTG_TRACE_MAX_IN_VA+1));
++ }
++
++ local_irq_save(flags);
++ UNLESS ((tss = otg_trace_current_traces)) {
++ local_irq_restore(flags);
++ return;
++ }
++ // Reserve the trace slots.
++ UNLESS((p = otg_trace_get_next(tss,tag,fn,otg_trace_msg_va_start_n,n))) {
++ local_irq_restore(flags);
++ return;
++ }
++ p->va.s.trace.msg32.msg = fmt;
++ p->va_num_args = nargs;
++ if (nargs > 0) {
++ va_list ap;
++ va_start(ap,fmt);
++ p->va.s.trace.msg32.val = va_arg(ap,u32);
++ if (--nargs > 0) {
++ // We need the next trace slot.
++ int i;
++ while (nargs >= 8) {
++ p = otg_trace_next_va(tss,p);
++ p->otg_trace_type = otg_trace_msg_va_list_n;
++ for (i = 0; i < 8; i++) p->va.l.val[i] = va_arg(ap,u32);
++ nargs -= 8;
++ }
++ p = otg_trace_next_va(tss,p);
++ p->otg_trace_type = otg_trace_msg_va_list_n;
++ for (i = 0; i < nargs; i++) p->va.l.val[i] = va_arg(ap,u32);
++ }
++ va_end(ap);
++ }
++ local_irq_restore(flags);
++}
++
++/* Proc Filesystem *************************************************************************** */
++
++/* int slot_in_data
++ */
++STATIC int slot_in_data(otg_trace_snapshot *tss, int slot)
++{
++ // Return 1 if slot is in the valid data region, 0 otherwise.
++ return (((tss->first < tss->next) && (slot >= tss->first) && (slot < tss->next)) ||
++ ((tss->first > tss->next) && ((slot < tss->next) || (slot >= tss->first))));
++
++}
++
++/*! otg_trace_read_slot
++ *
++ * Place a slot pointer in *ps (and possibly *pv), with the older entry (if any) in *po.
++ * Return: -1 at end of data
++ * 0 if not a valid enty
++ * 1 if entry valid but no older valid entry
++ * 2 if both entry and older are valid.
++ */
++STATIC int otg_trace_read_slot(otg_trace_snapshot *tss, int index, otg_trace_t **ps, otg_trace_t **po)
++{
++ int res;
++ int previous;
++ otg_trace_t *s,*o;
++
++ *ps = *po = NULL;
++ index = (tss->first + index) & TRACE_MASK;
++ // Are we at the end of the data?
++ if (!slot_in_data(tss,index)) {
++ // End of data.
++ return(-1);
++ }
++ /* Nope, there's data to show. */
++ s = tss->traces + index;
++ if (!s->tag ||
++ s->otg_trace_type == otg_trace_msg_invalid_n ||
++ s->otg_trace_type == otg_trace_msg_va_list_n) {
++ /* Ignore this slot, it's not valid, or is part
++ of a previously processed varargs. */
++ return(0);
++ }
++ *ps = s;
++ res = 1;
++ // Is there a previous event (for "ticks" calculation)?
++ previous = (index - 1) & TRACE_MASK;
++ if (previous != tss->next && tss->total > 1) {
++ // There is a valid previous event.
++ res = 2;
++ o = tss->traces + previous;
++ /* If the previous event was a varargs event, we want
++ a copy of the first slot, not the last. */
++ while (o->otg_trace_type == otg_trace_msg_va_list_n) {
++ previous = (previous - 1) & TRACE_MASK;
++ if (previous == tss->next) {
++ res = 1;
++ o = NULL;
++ break;
++ }
++ o = tss->traces + previous;
++ }
++ *po = o;
++ }
++ return(res);
++}
++
++
++/*! otg_trace_proc_read - implement proc file system read.
++ *
++ * Standard proc file system read function.
++ * @file
++ * @buf
++ * @count
++ * @pos
++ */
++int otg_trace_proc_read(char *page, int count, int * pos)
++{
++ int len = 0;
++ int index;
++ int oindex;
++ int rc;
++
++ u64 ticks = 0;
++
++ unsigned char *cp;
++ int skip = 0;
++
++ otg_trace_t *o;
++ otg_trace_t *s;
++ otg_trace_snapshot *tss;
++
++ DOWN(&otg_trace_sem);
++
++ /* Grab the current snapshot, and replace it with the other. This
++ * needs to be atomic WRT otg_trace_msg() calls.
++ */
++ UNLESS (*pos) {
++ unsigned long flags;
++ tss = otg_trace_other_traces;
++ init_snapshot(tss); // clear previous
++ local_irq_save(flags);
++ otg_trace_other_traces = otg_trace_current_traces; // swap snapshots
++ otg_trace_current_traces = tss;
++ local_irq_restore(flags);
++ }
++
++ tss = otg_trace_other_traces;
++
++ /* Get the index of the entry to read - this needs to be atomic WRT tag operations.
++ */
++ s = o = NULL;
++ oindex = index = (*pos)++;
++ do {
++ rc = otg_trace_read_slot(tss,index,&s,&o);
++ switch (rc) {
++ case -1: // End of data.
++ UP(&otg_trace_sem);
++ return(0);
++
++ case 0: // Invalid slot, skip it and try the next.
++ index = (*pos)++;
++ break;
++
++ case 1: // s valid, o NULL
++ case 2: // s and o valid
++ break;
++ }
++ } while (rc == 0);
++
++ len = 0;
++
++ UNLESS (oindex)
++ len += sprintf((char *) page + len, "Tag Index Ints Framenum Ticks\n");
++
++ /* 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, varargs and wraparound.
++ */
++ if (o) {
++
++ ticks = otg_tmr_elapsed(&s->va.s.ticks, &o->va.s.ticks);
++
++ if ((o->va.s.interrupts != s->va.s.interrupts) || (o->tag != s->tag) || (o->in_interrupt != s->in_interrupt))
++ skip++;
++ }
++
++ len += sprintf((char *) page + len, "%s%02x %c %8u %8d ", skip?"\n":"",
++ s->tag, s->id_gnd ? 'A' : 'B', index, s->va.s.interrupts);
++
++ len += sprintf((char *) page + len, "%03x ", s->va.s.framenum);
++
++ if (ticks < 10000)
++ len += sprintf((char *) page + len, "%8duS", ticks);
++ else if (ticks < 10000000)
++ len += sprintf((char *) page + len, "%8dmS", ticks >> 10);
++ else
++ len += sprintf((char *) page + len, "%8dS ", ticks >> 20);
++
++ len += sprintf((char *) page + len, " %s ", s->in_interrupt ? "--" : "==");
++ len += sprintf((char *) page + len, "%-24s: ",s->va.s.function);
++
++ switch (s->otg_trace_type) {
++ case otg_trace_msg_invalid_n:
++ case otg_trace_msg_va_list_n:
++ len += sprintf((char *) page + len, " -- N/A");
++ break;
++
++ case otg_trace_msg_va_start_n:
++ if (s->va_num_args <= 1)
++ len += sprintf((char *) page + len, s->va.s.trace.msg32.msg, s->va.s.trace.msg32.val);
++
++ else {
++ otg_trace_t *v = otg_trace_next_va(tss,s);
++ len += sprintf((char *) page + len, s->va.s.trace.msg32.msg, s->va.s.trace.msg32.val,
++ v->va.l.val[0], v->va.l.val[1], v->va.l.val[2], v->va.l.val[3],
++ v->va.l.val[4], v->va.l.val[5], v->va.l.val[6]);
++ }
++ break;
++
++ case otg_trace_msg_n:
++ len += sprintf((char *) page + len, s->va.s.trace.msg.msg);
++ break;
++
++ case otg_trace_msg32_n:
++ len += sprintf((char *) page + len, s->va.s.trace.msg32.msg, s->va.s.trace.msg32.val);
++ break;
++
++ case otg_trace_msg16_n:
++ len += sprintf((char *) page + len, s->va.s.trace.msg16.msg, s->va.s.trace.msg16.val0, s->va.s.trace.msg16.val1);
++ break;
++
++ case otg_trace_msg8_n:
++ len += sprintf((char *) page + len, s->va.s.trace.msg8.msg,
++ s->va.s.trace.msg8.val0, s->va.s.trace.msg8.val1, s->va.s.trace.msg8.val2,
++ s->va.s.trace.msg8.val3);
++ break;
++
++ case otg_trace_setup_n:
++ cp = (unsigned char *)&s->va.s.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;
++ }
++ len += sprintf((char *) page + len, "\n");
++
++ UP(&otg_trace_sem);
++ return len;
++}
++
++/*! otg_trace_proc_write - implement proc file system write.
++ * @file
++ * @buf
++ * @count
++ * @pos
++ *
++ * Proc file system write function.
++ */
++int otg_trace_proc_write (const char *buf, int count, int * 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 {
++ n -= l;
++ while (n > 0) {
++ 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;
++ }
++
++
++ return count;
++}
++
++static u32 otg_tags_mask = 0x0;
++extern void otg_trace_exit (void);
++
++/*! otg_trace_obtain_tag(void)
++ */
++otg_tag_t otg_trace_obtain_tag(void)
++{
++ /* Return the next unused tag value [1..32] if one is available,
++ * return 0 if none is available.
++ */
++ otg_tag_t tag = 0;
++ DOWN(&otg_trace_sem);
++ if (otg_tags_mask == 0xffffffff || otg_trace_exiting) {
++ // They're all in use.
++ UP(&otg_trace_sem);
++ return tag;
++ }
++ if (otg_tags_mask != 0x00000000) {
++ // 2nd or later tag, search for an unused one
++ while (otg_tags_mask & (0x1 << tag)) {
++ tag += 1;
++ }
++ }
++
++ // Successful 1st or later tag.
++ otg_tags_mask |= 0x1 << tag;
++ UP(&otg_trace_sem);
++ return tag + 1;
++}
++
++/*! otg_trace_invalidate_tag(otg_tag_t tag)
++ */
++otg_tag_t otg_trace_invalidate_tag(otg_tag_t tag)
++{
++ otg_trace_t *p,*e;
++ otg_trace_snapshot *css,*oss;
++ unsigned long flags;
++
++ // Nothing to do
++ RETURN_ZERO_IF ((0 >= tag) || (tag > 32));
++
++ // Grab a local copy of the snapshot pointers.
++ local_irq_save(flags);
++ css = otg_trace_current_traces;
++ oss = otg_trace_other_traces;
++ local_irq_restore(flags);
++
++
++ // Run through all the trace messages, and invalidate any with the given tag.
++
++ DOWN(&otg_trace_sem);
++ if (css)
++ for (e = TRACE_MAX + (p = css->traces); p < e; p++) {
++ if (p->tag == tag) {
++ p->otg_trace_type = otg_trace_msg_invalid_n;
++ p->tag = 0;
++ }
++ }
++ if (oss)
++ for (e = TRACE_MAX + (p = oss->traces); p < e; p++) {
++ if (p->tag == tag) {
++ p->otg_trace_type = otg_trace_msg_invalid_n;
++ p->tag = 0;
++ }
++ }
++
++ // Turn off the tag
++ otg_tags_mask &= ~(0x1 << (tag-1));
++ if (otg_tags_mask == 0x00000000) { /* otg_trace_exit (); */ }
++ UP(&otg_trace_sem);
++ return 0;
++}
++
++
++
++/* Module init ************************************************************** */
++
++#define OT otg_trace_init_test
++otg_tag_t OT;
++
++/*! otg_trace_init
++ *
++ * Return non-zero if not successful.
++ */
++int otg_trace_init (void)
++{
++ otg_trace_exiting = 0;
++ otg_trace_current_traces = otg_trace_other_traces = NULL;
++ UNLESS ((otg_trace_current_traces = get_snapshot(&otg_snapshot1)) &&
++ (otg_trace_other_traces = get_snapshot(&otg_snapshot2)))
++ {
++ printk(KERN_ERR"%s: malloc failed (2x) %d\n", __FUNCTION__, sizeof(otg_trace_t) * TRACE_MAX);
++ otg_trace_current_traces = rel_snapshot(otg_trace_current_traces);
++ otg_trace_other_traces = rel_snapshot(otg_trace_other_traces);
++ return -ENOMEM;
++ }
++ OT = otg_trace_obtain_tag();
++ RETURN_ENOMEM_IF(!OT);
++ TRACE_MSG0(OT,"--");
++ return 0;
++}
++
++/*! otg_trace_exit - remove procfs entry, free trace data space.
++ */
++void otg_trace_exit (void)
++{
++ otg_trace_t *p;
++ otg_tag_t tag;
++
++ unsigned long flags;
++ otg_trace_snapshot *c,*o;
++
++ otg_trace_invalidate_tag(OT);
++ otg_trace_exiting = 1;
++
++ local_irq_save (flags);
++
++ /* Look for any outstanding tags. */
++ for (tag = 32; otg_tags_mask && tag > 0; tag--)
++ if (otg_tags_mask & (0x1 << (tag-1)))
++ otg_trace_invalidate_tag(tag);
++
++ c = otg_trace_current_traces;
++ o = otg_trace_other_traces;
++ otg_trace_current_traces = otg_trace_other_traces = NULL;
++ local_irq_restore (flags);
++
++ c = rel_snapshot(c);
++ o = rel_snapshot(o);
++}
++
++#else /* defined(CONFIG_OTG_TRACE) || defined(CONFIG_OTG_TRACE_MODULE) */
++int otg_trace_init (void) {return 0;}
++void otg_trace_exit (void) {}
++otg_tag_t otg_trace_obtain_tag(void) { return 0; }
++void otg_trace_setup(otg_tag_t tag, const char *fn, void *setup) { }
++void otg_trace_msg(otg_tag_t tag, const char *fn, u8 nargs, char *fmt, ...) { }
++otg_tag_t otg_trace_invalidate_tag(otg_tag_t tag) { return 0; }
++#endif /* defined(CONFIG_OTG_TRACE) || defined(CONFIG_OTG_TRACE_MODULE) */
++
++OTG_EXPORT_SYMBOL(otg_trace_setup);
++OTG_EXPORT_SYMBOL(otg_trace_msg);
++OTG_EXPORT_SYMBOL(otg_trace_obtain_tag);
++OTG_EXPORT_SYMBOL(otg_trace_invalidate_tag);
++
++#if 0
++// These are only needed when debugging the trace code itself.
++OTG_EXPORT_SYMBOL(otg_trace_get_next);
++OTG_EXPORT_SYMBOL(otg_trace_next_va);
++OTG_EXPORT_SYMBOL(slot_in_data);
++OTG_EXPORT_SYMBOL(otg_trace_read_slot);
++OTG_EXPORT_SYMBOL(otg_trace_proc_read);
++#endif
++
+diff -uNr linux/drivers/no-otg/otgcore/otg.c linux/drivers/otg/otgcore/otg.c
+--- linux/drivers/no-otg/otgcore/otg.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otgcore/otg.c 2006-09-01 21:41:35.000000000 +0200
+@@ -0,0 +1,936 @@
++/*
++ * otg/otgcore/otg.c - OTG state machine
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/otgcore/otg.c
++ * @brief OTG Core State Machine Event Processing
++ *
++ * The OTG State Machine receives "input" information passed to it
++ * from the other drivers (pcd, tcd, hcd and ocd) that describe what
++ * is happening.
++ *
++ * The State Machine uses the inputs to move from state to state. Each
++ * state defines four things:
++ *
++ * 1. Reset - what inputs to set or reset on entry to the state.
++ *
++ * 2. Outputs - what output functions to call to set or reset.
++ *
++ * 3. Timeout - an optional timeout value to set
++ *
++ * 4. Tests - a series of tests that allow the state machine to move to
++ * new states based on current or new inputs.
++ *
++ * @ingroup OTGCore
++ */
++#ifndef OTG_REGRESS
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/usbp-bus.h>
++
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-tcd.h>
++#include <otg/otg-hcd.h>
++#include <otg/otg-pcd.h>
++#include <otg/otg-ocd.h>
++
++
++struct hcd_ops *otg_hcd_ops;
++struct ocd_ops *otg_ocd_ops;
++struct pcd_ops *otg_pcd_ops;
++struct tcd_ops *otg_tcd_ops;
++struct usbd_ops *otg_usbd_ops;
++
++extern struct otg_instance otg_instance_private;
++extern struct hcd_instance hcd_instance_private;
++extern struct ocd_instance ocd_instance_private;
++extern struct pcd_instance pcd_instance_private;
++extern struct tcd_instance tcd_instance_private;
++
++#if 0
++/* otg_vbus - return vbus status
++ *
++ * XXX Should we default to set or reset if there is no vbus function
++ */
++int otg_vbus(struct otg_instance *otg)
++{
++ TRACE_MSG2(CORE, "otg_tcd_ops: %p vbus: %p", otg_tcd_ops, otg_tcd_ops ? otg_tcd_ops->vbus : NULL);
++ return (otg_tcd_ops && otg_tcd_ops->vbus) ? otg_tcd_ops->vbus(otg) : 1;
++}
++#endif
++
++#if defined (OTG_WINCE)
++#define TRACE_SM_CURRENT(t, m, o) \
++
++#else
++#define TRACE_SM_CURRENT(t, m, o) \
++ TRACE_MSG5(t, "SM_CURRENT: RESET: %08x SET: %08x %s (%s) %s",\
++ (u32)(~o->current_inputs), \
++ (u32)(o->current_inputs), \
++ o->current_outputs->name, \
++ o->previous_outputs->name, \
++ m \
++ );
++#endif //OTG_WINCE
++#define TRACE_SM_CHANGE(t, m, o) \
++ TRACE_MSG5(t, "SM_CHANGE: RESET: %08x SET: %08x %s (%s) %s",\
++ (u32)(~o->current_inputs), \
++ (u32)(o->current_inputs), \
++ o->current_outputs->name, \
++ o->previous_outputs->name, \
++ m \
++ );
++
++#define TRACE_SM_NEW(t, m, o) \
++ TRACE_MSG5(t, "SM_NEW: RESET: %08x SET: %08x %s (%s) %s",\
++ (u32)(~o->current_inputs), \
++ (u32)(o->current_inputs), \
++ o->current_outputs->name, \
++ o->previous_outputs->name, \
++ m \
++ );
++
++
++#define TRACE_SM_INPUTS(t, m, u, c) \
++ TRACE_MSG4(t, "SM_INPUTS: RESET: %08x SET: %08x CUR: %08x %s",\
++ (u32)(u >> 32), \
++ (u32)(u & 0xffffffff), \
++ c, \
++ m \
++ )
++
++#endif
++
++
++
++DECLARE_MUTEX (otg_sem);
++
++/*!
++ * Output change lookup table - this maps the current output and the desired
++ * output to what should be done. This is just so that we don't redo changes,
++ * if the output does not change we do not want to re-call the output function
++ */
++u8 otg_output_lookup[4][4] = {
++ /* NC SET RESET PULSE, <--- current/ new */
++ { NC, NC, NC, PULSE, }, /* NC */
++ { SET, NC, SET, PULSE, }, /* SET */
++ { RESET, RESET, NC, PULSE, }, /* RESET */
++ { PULSE, PULSE, PULSE, PULSE, }, /* UNKNOWN */
++};
++
++
++/*!
++ * otg_new() - check OTG new inputs and select new state to be in
++ *
++ * This is used by the OTG event handler to see if the state should
++ * change based on the current input values.
++ *
++ * @param otg pointer to the otg instance.
++ * @return either the next OTG state or invalid_state if no change.
++ */
++static int otg_new(struct otg_instance *otg)
++{
++ int state = otg->state;
++ struct otg_test *otg_test = otg_firmware_loaded ? otg_firmware_loaded->otg_tests : NULL;
++ u64 input_mask = ((u64)otg->current_inputs) | ((u64)(~otg->current_inputs) << 32); // get a copy of current inputs
++
++ UNLESS(otg_test) return invalid_state;
++
++ TRACE_MSG3(CORE, "OTG_NEW: %s inputs: %08x %08x", otg_get_state_name(state),
++ (u32)(input_mask>>32&0xffffffff), (u32)(input_mask&0xffffffff));
++
++ /* iterate across the otg inputs table, for each entry that matches the current
++ * state, test the input_mask to see if a state transition is required.
++ */
++ for (; otg_test->target != invalid_state; otg_test++) {
++
++ u64 test1 = otg_test->test1;
++ u64 test2 = otg_test->test2;
++ u64 test3 = otg_test->test3;
++
++ CONTINUE_UNLESS(otg_test->state == state); // skip states that don't match
++
++
++ TRACE_MSG7(CORE, "OTG_NEW: %s (%s, %d) test1: %08x %08x test2 %08x %08x",
++ otg_get_state_name(otg_test->state),
++ otg_get_state_name(otg_test->target),
++ otg_test->test,
++ (u32)(test1>>32&0xffffffff), (u32)(test1&0xffffffff),
++ (u32)(test2>>32&0xffffffff), (u32)(test2&0xffffffff)
++ );
++
++ /* the otg inputs table has multiple masks that define between multiple tests. Each
++ * test is a simple OR to check if specific inputs are present.
++ */
++ CONTINUE_UNLESS (
++ (!otg_test->test1 || ((test1 = otg_test->test1 & input_mask))) &&
++ (!otg_test->test2 || ((test2 = otg_test->test2 & input_mask))) &&
++ (!otg_test->test3 || ((test3 = otg_test->test3 & input_mask))) /*&&
++ (!otg_test->test4 || (otg_test->test4 & input_mask)) */ );
++
++ TRACE_MSG7(CORE, "OTG_NEW: GOTO %s test1: %08x %08x test2 %08x %08x test3 %08x %08x",
++ otg_get_state_name(otg_test->target),
++ (u32)(test1>>32&0xffffffff), (u32)(test1&0xffffffff),
++ (u32)(test2>>32&0xffffffff), (u32)(test2&0xffffffff),
++ (u32)(test3>>32&0xffff), (u32)(test3&0xffff)
++ );
++
++ return otg_test->target;
++ }
++ return invalid_state;
++}
++
++char mbuf[96];
++
++/*!
++ * otg_write_state_message_irq() -
++ *
++ * Send a message to the otg management application.
++ *
++ * @param msg
++ * @param reset
++ * @param inputs
++ */
++void otg_write_state_message_irq(char *msg, u64 reset, u32 inputs)
++{
++ sprintf(mbuf, "State: %s reset: %08x set: %08x inputs: %08x ", msg, (u32)(reset>>32), (u32)(reset&0xffffffff), inputs);
++ mbuf[95] = '\0';
++ otg_message(mbuf);
++}
++
++/*!
++ * otg_write_output_message_irq() -
++ *
++ * Send a message to the otg management application.
++ *
++ * @param msg
++ * @param val
++ */
++void otg_write_output_message_irq(char *msg, int val)
++{
++ strcpy(mbuf, "Output: ");
++ strncat(mbuf, msg, 64 - strlen(mbuf));
++ if (val == 2) strncat(mbuf, "/", 64 - strlen(mbuf));
++ mbuf[95] = '\0';
++ otg_message(mbuf);
++}
++
++/*!
++ * otg_write_timer_message_irq() -
++ *
++ * Send a message to the otg management application.
++ *
++ * @param msg
++ * @param val
++ */
++void otg_write_timer_message_irq(char *msg, int val)
++{
++ if (val < 10000)
++ sprintf(mbuf, "Timer: %s %d uS %u", msg, val, otg_tmr_ticks());
++ else if (val < 10000000)
++ //sprintf(time_buf, " %d mS\n", ticks / 1000);
++ sprintf(mbuf, "Timer: %s %d mS %u", msg, val >> 10, otg_tmr_ticks());
++ else
++ //sprintf(time_buf, " %d S\n", ticks / 1000000);
++ sprintf(mbuf, "Timer: %s %d S %u", msg, val >> 20, otg_tmr_ticks());
++
++ mbuf[95] = '\0';
++ otg_message(mbuf);
++}
++
++/*!
++ * otg_write_info_message_irq() -
++ *
++ * Send a message to the otg management application.
++ *
++ * @param msg
++ */
++void otg_write_info_message(char *msg)
++{
++ unsigned long flags;
++ local_irq_save (flags);
++ sprintf(mbuf, "Info: %s", msg);
++ mbuf[95] = '\0';
++ otg_message(mbuf);
++ local_irq_restore (flags);
++}
++
++/*!
++ * otg_write_reset_message_irq() -
++ *
++ * Send a message to the otg management application.
++ *
++ * @param msg
++ * @param val
++ */
++void otg_write_reset_message(char *msg, int val)
++{
++ unsigned long flags;
++ local_irq_save (flags);
++ sprintf(mbuf, "State: %s reset: %x", msg, val);
++ mbuf[95] = '\0';
++ otg_message(mbuf);
++ local_irq_restore (flags);
++}
++
++OTG_EXPORT_SYMBOL(otg_write_info_message);
++
++char otg_change_names[4] = {
++ '_', ' ', '/', '#',
++};
++
++/*!
++ * otg_do_event_irq() - process OTG events and determine OTG outputs to reflect new state
++ *
++ * This function is passed a mask with changed input values. This
++ * is passed to the otg_new() function to see if the state should
++ * change. If it changes then the output functions required for
++ * the new state are called.
++ *
++ * @param otg pointer to the otg instance.
++ * @param inputs input mask
++ * @param tag trace tag to use for tracing
++ * @param msg message for tracing
++ * @return non-zero if state changed.
++ */
++static int otg_do_event_irq(struct otg_instance *otg, u64 inputs, otg_tag_t tag, char *msg)
++{
++ u32 current_inputs = otg->current_inputs;
++ int current_state = otg->state;
++ u32 inputs_set = (u32)(inputs & 0xffffffff); // get changed inputs that SET something
++ u32 inputs_reset = (u32) (inputs >> 32); // get changed inputs that RESET something
++ int target;
++
++ RETURN_ZERO_UNLESS(otg && inputs);;
++ TRACE_SM_INPUTS(tag, msg, inputs, current_inputs);
++
++ /* Special Overrides - These are special tests that satisfy specific injunctions from the
++ * OTG Specification.
++ */
++ if (inputs_set & inputs_reset) { // verify that there is no overlap between SET and RESET masks
++ TRACE_MSG1(CORE, "OTG_EVENT: ERROR attempting to set and reset the same input: %08x", inputs_set & inputs_reset);
++ return 0;
++ }
++ /* don't allow bus_req and bus_drop to be set at the same time
++ */
++ if ((inputs_set & (bus_req | bus_drop)) == (bus_req | bus_drop) ) {
++ TRACE_MSG2(CORE, "OTG_EVENT: ERROR attempting to set both bus_req and bus_drop: %08x %08x",
++ inputs_set, (bus_req | bus_drop));
++ return 0;
++ }
++ /* set bus_drop_ if bus_req, set bus_req_ if bus_drop
++ */
++ if (inputs_set & bus_req) {
++ inputs |= bus_drop_;
++ TRACE_MSG1(CORE, "OTG_EVENT: forcing bus_drop/: %08x", inputs_set);
++ }
++ if (inputs_set & bus_drop) {
++ inputs |= bus_req_;
++ TRACE_MSG1(CORE, "OTG_EVENT: forcing bus_req/: %08x", inputs_set);
++ }
++
++ otg->current_inputs &= ~inputs_reset;
++ otg->current_inputs |= inputs_set;
++ TRACE_MSG3(CORE, "OTG_EVENT: reset: %08x set: %08x inputs: %08x", inputs_reset, inputs_set, otg->current_inputs);
++
++ TRACE_SM_CHANGE(tag, msg, otg);
++
++ RETURN_ZERO_IF(otg->active);
++
++ otg->active++;
++
++ /* Search the state input change table to see if we need to change to a new state.
++ * This may take several iterations.
++ */
++ while (invalid_state != (target = otg_new(otg))) {
++
++ struct otg_state *otg_state;
++ int original_state = otg->state;
++ u64 current_outputs;
++ u64 output_results;
++ u64 new_outputs;
++ int i;
++
++ /* if previous output started timer, then cancel timer before proceeding
++ */
++ if ((otg_state = otg->current_outputs) && otg_state->tmout && otg->start_timer) {
++ TRACE_MSG0(CORE, "reseting timer");
++ otg->start_timer(otg, 0);
++ }
++
++ BREAK_UNLESS(otg_firmware_loaded);
++
++ BREAK_UNLESS(target < otg_firmware_loaded->number_of_states);
++
++ otg_state = otg_firmware_loaded->otg_states + target;
++
++ BREAK_UNLESS(otg_state->name);
++
++ otg->previous = otg->state;
++ otg->state = target;
++ otg->tickcount = otg_tmr_ticks();
++
++
++ otg->previous_outputs= otg->current_outputs;
++ //otg->current_outputs = NULL;
++
++
++ /* A matching input table rule has been found, we are transitioning to a new
++ * state. We need to find the new state entry in the output table.
++ * XXX this could be a table lookup instead of linear search.
++ */
++
++ current_outputs = otg->outputs;
++ new_outputs = otg_state->outputs;
++ output_results = 0;
++
++ TRACE_SM_NEW(tag, msg, otg);
++
++ /* reset any inputs that the new state want's reset
++ */
++ otg_do_event_irq(otg, otg_state->reset | TMOUT_, tag, otg_state->name);
++
++ otg_write_state_message_irq(otg_state->name, otg_state->reset, otg->current_inputs);
++
++#if 1
++ switch (target) { /* C.f. 6.6.1.12 b_conn reset */
++ case otg_disabled:
++ otg->current_inputs = 0;
++ otg->outputs = 0;
++ break;
++ default:
++ //otg_event_irq(otg, not(b_conn), "a_host/ & a_suspend/: set b_conn/");
++ break;
++ }
++#endif
++ TRACE_MSG5(CORE, "OTG_EVENT: CALLING OUTPUT MAX:%d OUTPUTS CURRENT: %08x %08x NEW: %08x %08x",
++ MAX_OUTPUTS,
++ (u32)(current_outputs >> 32),
++ (u32)(current_outputs & 0xffffffff),
++ (u32)(new_outputs >> 32),
++ (u32)(new_outputs & 0xffffffff)
++ );
++
++ /* Iterate across the outputs bitmask, calling the appropriate functions
++ * to make required changes. The current outputs are saved and we DO NOT
++ * make calls to change output values until they change again.
++ */
++ for (i = 0; i < MAX_OUTPUTS; i++) {
++
++ u8 current_output = (u8)(current_outputs & 0x3);
++ u8 new_output = (u8)(new_outputs & 0x3);
++ u8 changed = otg_output_lookup[new_output][current_output];
++
++ output_results >>= 2;
++
++ switch (changed) {
++ case NC:
++ output_results |= ((current_outputs & 0x3) << (MAX_OUTPUTS * 2));
++ break;
++ case SET:
++ case RESET:
++ output_results |= (((u64)changed) << (MAX_OUTPUTS * 2));
++ case PULSE:
++
++
++ otg_write_output_message_irq(otg_output_names[i], changed);
++
++ //TRACE_MSG3(CORE, "OTG_EVENT: CHECKING OUTPUT %s %d %s",
++ // otg_state->name, i, otg_output_names[i]);
++
++ BREAK_UNLESS(otg->otg_output_ops[i]); // Check if we have an output routine
++
++ TRACE_MSG7(CORE, "OTG_EVENT: CALLING OUTPUT %s %d %s%c cur: %02x new: %02x chng: %02x",
++ otg_state->name, i, otg_output_names[i],
++ otg_change_names[changed&0x3],
++ current_output, new_output,
++ changed);
++
++ otg->otg_output_ops[i](otg, changed); // Output changed, call function to do it
++
++ //TRACE_MSG2(CORE, "OTG_EVENT: OUTPUT FINISED %s %s", otg_state->name, otg_output_names[i]);
++ break;
++ }
++
++ current_outputs >>= 2;
++ new_outputs >>= 2;
++ }
++
++ output_results >>= 2;
++ otg->outputs = output_results;
++ otg->current_outputs = otg_state;
++
++ //TRACE_MSG2(CORE, "OTG_EVENT: STATE: otg->current_outputs: %08x %08x",
++ // (u32)(otg->outputs & 0xffffffff), (u32)(otg->outputs >> 32));
++
++ if (((otg->outputs & pcd_en_out_set) == pcd_en_out_set) &&
++ ((otg->outputs & hcd_en_out_set) == hcd_en_out_set))
++ {
++ TRACE_MSG0(CORE, "WARNING PCD_EN and HCD_EN both set");
++ printk(KERN_INFO "%s: WARNING PCD_EN and HCD_EN both set\n", __FUNCTION__);
++ }
++
++ /* start timer?
++ */
++ CONTINUE_UNLESS(otg_state->tmout);
++ TRACE_MSG1(CORE, "setting timer: %d", otg_state->tmout);
++ if (otg->start_timer) {
++ otg_write_timer_message_irq(otg_state->name, otg_state->tmout);
++ otg->start_timer(otg, otg_state->tmout);
++ }
++ else {
++ //TRACE_MSG0(CORE, "NO TIMER");
++ otg_do_event_irq(otg, TMOUT_, CORE, otg_state->name);
++ }
++
++ }
++ //TRACE_MSG0(CORE, "finishing");
++ otg->active = 0;
++
++ if (current_state == otg->state)
++ TRACE_MSG0(CORE, "OTG_EVENT: NOT CHANGED");
++
++ otg->active = 0;
++ return 0;
++}
++
++/*!
++ * otg_write_input_message_irq() -
++
++ * @param inputs input mask
++ * @param tag trace tag to use for tracing
++ * @param msg message for tracing
++ */
++void otg_write_input_message_irq(u64 inputs, otg_tag_t tag, char *msg)
++{
++ u32 reset = (u32)(inputs >> 32);
++ u32 set = (u32) (inputs & 0xffffffff);
++
++ char buf[64];
++ //snprintf(buf, sizeof(buf), "Input: %08x %08x %s", *inputs >> 32, *inputs & 0xffffffff, msg ? msg : "NULL");
++ TRACE_MSG3(tag, "Inputs: %08x %08x %s", set, reset, msg ? msg : "NULL");
++ #ifdef OTG_WINCE
++ sprintf(buf, "Inputs: %08x %08x %s", reset, set, msg ? msg : "NULL");
++ #else /* OTG_WINCE */
++ snprintf(buf, sizeof(buf), "Inputs: %08x %08x %s", reset, set, msg ? msg : "NULL");
++ #endif /* OTG_WINCE */
++ buf[63] = '\0';
++ otg_message(buf);
++}
++
++
++/*!
++ * otg_event_input_message_irq() -
++ * @param otg pointer to the otg instance.
++ * @param inputs input mask
++ * @param tag trace tag to use for tracing
++ * @param msg message for tracing
++ * @return non-zero if state changed.
++ */
++int otg_event_irq(struct otg_instance *otg, u64 inputs, otg_tag_t tag, char *msg)
++{
++ TRACE_SM_INPUTS(tag, msg, inputs, otg->current_inputs);
++ //otg_write_input_message_irq((u32)(inputs >> 32), (u32) (inputs & 0xffffffff), tag, msg);
++ otg_write_input_message_irq(inputs, tag, msg);
++ return otg_do_event_irq(otg, inputs, tag, msg);
++}
++
++/*!
++ * otg_event() -
++ * @param otg pointer to the otg instance.
++ * @param inputs input mask
++ * @param tag trace tag to use for tracing
++ * @param msg message for tracing
++ * @return non-zero if state changed.
++ */
++int otg_event(struct otg_instance *otg, u64 inputs, otg_tag_t tag, char *msg)
++{
++ int rc;
++ unsigned long flags;
++ RETURN_ZERO_UNLESS(otg);
++ local_irq_save (flags);
++ rc = otg_event_irq(otg, inputs, tag, msg);
++ local_irq_restore (flags);
++ return rc;
++}
++
++
++/*!
++ * otg_event_set_irq() -
++ * @param otg pointer to the otg instance.
++ * @param changed
++ * @param flag
++ * @param input input mask
++ * @param tag trace tag to use for tracing
++ * @param msg message for tracing
++ * @return non-zero if state changed.
++ */
++int otg_event_set_irq(struct otg_instance *otg, int changed, int flag, u32 input, otg_tag_t tag, char *msg)
++{
++ RETURN_ZERO_UNLESS(changed);
++ TRACE_MSG4(tag, "%s: %08x changed: %d flag: %d", msg, input, changed, flag);
++ return otg_event(otg, flag ? input : _NOT(input), tag, msg);
++}
++
++
++/*!
++ * otg_init() - create and initialize otg instance
++ *
++ * Called to initialize the OTG state machine. This will cause the state
++ * to change from the invalid_state to otg_disabled.
++ *
++ * If the device has the OCD_CAPABILITIES_AUTO flag set then
++ * an initial enable_otg event is generated. This will cause
++ * the state to move from otg_disabled to otg_enabled. The
++ * requird drivers will be initialized by calling the appropriate
++ * output functions:
++ *
++ * - pcd_init_func
++ * - hcd_init_func
++ * - tcd_init_func
++ *
++ * @param otg pointer to the otg instance.
++ */
++void otg_init (struct otg_instance *otg)
++{
++ DOWN(&otg_sem);
++ otg->outputs = tcd_init_out_ | pcd_init_out_ | hcd_init_out_;
++
++ /* This will move the state machine into the otg_disabled state
++ */
++ otg_event(otg, enable_otg, CORE, "enable_otg"); // XXX
++
++ if (otg_ocd_ops->capabilities & OCD_CAPABILITIES_AUTO)
++ otg_event(otg, AUTO, CORE, "AUTO"); // XXX
++
++ UP(&otg_sem);
++}
++
++
++/*!
++ * otg_exit()
++ *
++ * This is called by the driver that started the state machine to
++ * cause it to exit. The state will move to otg_disabled.
++ *
++ * The appropriate output functions will be called to disable the
++ * peripheral drivers.
++ *
++ * @param otg pointer to the otg instance.
++ */
++void otg_exit (struct otg_instance *otg)
++{
++ //TRACE_MSG0(CORE, "DOWN OTG_SEM");
++ DOWN(&otg_sem);
++
++ //TRACE_MSG0(CORE, "OTG_EXIT");
++ //otg_event(otg, exit_all | not(a_bus_req) | a_bus_drop | not(b_bus_req), "tcd_otg_exit");
++
++ otg_event(otg, enable_otg_, CORE, "enable_otg_");
++
++ while (otg->state != otg_disabled) {
++ // TRACE_MSG pointless here, module will be gon before we can look at it.
++ #ifdef OTG_WINCE
++ //DEBUGMSG(KERN_ERR"%s: waiting for state machine to disable\n", __FUNCTION__);
++ #else /* OTG_WINCE */
++ printk(KERN_ERR"%s: waiting for state machine to disable\n", __FUNCTION__);
++ #endif /* OTG_WINCE */
++ SCHEDULE_TIMEOUT(10 * HZ);
++ }
++ //TRACE_MSG0(CORE, "UP OTG_SEM");
++ UP(&otg_sem);
++}
++
++
++OTG_EXPORT_SYMBOL(otg_event);
++OTG_EXPORT_SYMBOL(otg_event_irq);
++OTG_EXPORT_SYMBOL(otg_init);
++OTG_EXPORT_SYMBOL(otg_exit);
++OTG_EXPORT_SYMBOL(otg_event_set_irq);
++
++/* ********************************************************************************************* */
++
++/*!
++ * otg_tcd_init_func() -
++ *
++ * This is a default tcd_init_func. It will be used
++ * if no other is provided.
++ *
++ * @param otg pointer to the otg instance.
++ * @param flag set or reset
++ */
++void otg_tcd_init_func (struct otg_instance *otg, u8 flag)
++{
++ otg_event(otg, TCD_OK, CORE, "TCD_OK");
++}
++
++/*!
++ * otg_pcd_init_func() -
++ *
++ * This is a default pcd_init_func. It will be used
++ * if no other is provided.
++ *
++ * @param otg pointer to the otg instance.
++ * @param flag set or reset
++ */
++void otg_pcd_init_func (struct otg_instance *otg, u8 flag)
++{
++ otg_event(otg, PCD_OK, CORE, "PCD_OK");
++}
++
++/*!
++ * otg_hcd_init_func() -
++ *
++ * This is a default hcd_init_func. It will be used
++ * if no other is provided.
++ *
++ * @param otg pointer to the otg instance.
++ * @param flag set or reset
++ */
++void otg_hcd_init_func (struct otg_instance *otg, u8 flag)
++{
++ otg_event(otg, HCD_OK, CORE, "HCD_OK");
++}
++
++/*!
++ * otg_ocd_init_func() -
++ *
++ * This is a default hcd_init_func. It will be used
++ * if no other is provided.
++ *
++ * @param otg pointer to the otg instance.
++ * @param flag set or reset
++ */
++void otg_ocd_init_func (struct otg_instance *otg, u8 flag)
++{
++ otg_event(otg, HCD_OK, CORE, "OCD_OK");
++}
++
++/*!
++ * otg_hcd_set_ops() -
++ * @param hcd_ops - host operations table to use
++ */
++struct hcd_instance * otg_set_hcd_ops(struct hcd_ops *hcd_ops)
++{
++ otg_hcd_ops = hcd_ops;
++ if (hcd_ops) {
++ otg_instance_private.otg_output_ops[HCD_INIT_OUT] = otg_hcd_ops->hcd_init_func;
++ otg_instance_private.otg_output_ops[HCD_EN_OUT] = otg_hcd_ops->hcd_en_func;
++ otg_instance_private.otg_output_ops[LOC_SOF_OUT] = otg_hcd_ops->loc_sof_func;
++ otg_instance_private.otg_output_ops[LOC_SUSPEND_OUT] = otg_hcd_ops->loc_suspend_func;
++ otg_instance_private.otg_output_ops[REMOTE_WAKEUP_EN_OUT] = otg_hcd_ops->remote_wakeup_en_func;
++ otg_instance_private.otg_output_ops[HNP_EN_OUT] = otg_hcd_ops->hnp_en_func;
++ }
++ else
++ otg_instance_private.otg_output_ops[HCD_INIT_OUT] =
++ otg_instance_private.otg_output_ops[HCD_EN_OUT] =
++ otg_instance_private.otg_output_ops[LOC_SOF_OUT] =
++ otg_instance_private.otg_output_ops[LOC_SUSPEND_OUT] =
++ otg_instance_private.otg_output_ops[REMOTE_WAKEUP_EN_OUT] =
++ otg_instance_private.otg_output_ops[HNP_EN_OUT] = NULL;
++
++
++ UNLESS (otg_instance_private.otg_output_ops[HCD_INIT_OUT])
++ otg_instance_private.otg_output_ops[HCD_INIT_OUT] = otg_hcd_init_func;
++
++ return &hcd_instance_private;
++}
++
++/*!
++ * otg_ocd_set_ops() -
++ *
++ * @param ocd_ops - ocd operations table to use
++ */
++struct ocd_instance * otg_set_ocd_ops(struct ocd_ops *ocd_ops)
++{
++ otg_ocd_ops = ocd_ops;
++ if (ocd_ops) {
++ otg_instance_private.otg_output_ops[OCD_INIT_OUT] = otg_ocd_ops->ocd_init_func;
++ otg_instance_private.start_timer = ocd_ops->start_timer;
++ }
++ else {
++ otg_instance_private.otg_output_ops[OCD_INIT_OUT] = NULL;
++ otg_instance_private.start_timer = NULL;
++ }
++
++ UNLESS (otg_instance_private.otg_output_ops[OCD_INIT_OUT])
++ otg_instance_private.otg_output_ops[OCD_INIT_OUT] = otg_ocd_init_func;
++
++ return &ocd_instance_private;
++}
++
++/*!
++ * otg_pcd_set_ops() -
++ * @param pcd_ops - pcd operations table to use
++ */
++struct pcd_instance * otg_set_pcd_ops(struct pcd_ops *pcd_ops)
++{
++ otg_pcd_ops = pcd_ops;
++ if (pcd_ops) {
++ otg_instance_private.otg_output_ops[PCD_INIT_OUT] = otg_pcd_ops->pcd_init_func;
++ otg_instance_private.otg_output_ops[PCD_EN_OUT] = otg_pcd_ops->pcd_en_func;
++ otg_instance_private.otg_output_ops[REMOTE_WAKEUP_OUT] = otg_pcd_ops->remote_wakeup_func;
++ }
++ else
++ otg_instance_private.otg_output_ops[PCD_INIT_OUT] =
++ otg_instance_private.otg_output_ops[PCD_EN_OUT] =
++ otg_instance_private.otg_output_ops[REMOTE_WAKEUP_OUT] = NULL;
++
++ UNLESS (otg_instance_private.otg_output_ops[PCD_INIT_OUT])
++ otg_instance_private.otg_output_ops[PCD_INIT_OUT] = otg_pcd_init_func;
++
++ return &pcd_instance_private;
++}
++
++/*!
++ * otg_tcd_set_ops() -
++ * @param tcd_ops - tcd operations table to use
++ */
++struct tcd_instance * otg_set_tcd_ops(struct tcd_ops *tcd_ops)
++{
++ otg_tcd_ops = tcd_ops;
++ if (tcd_ops) {
++ otg_instance_private.otg_output_ops[TCD_INIT_OUT] = otg_tcd_ops->tcd_init_func;
++ otg_instance_private.otg_output_ops[TCD_EN_OUT] = otg_tcd_ops->tcd_en_func;
++ otg_instance_private.otg_output_ops[CHRG_VBUS_OUT] = otg_tcd_ops->chrg_vbus_func;
++ otg_instance_private.otg_output_ops[DRV_VBUS_OUT] = otg_tcd_ops->drv_vbus_func;
++ otg_instance_private.otg_output_ops[DISCHRG_VBUS_OUT] = otg_tcd_ops->dischrg_vbus_func;
++ otg_instance_private.otg_output_ops[DP_PULLUP_OUT] = otg_tcd_ops->dp_pullup_func;
++ otg_instance_private.otg_output_ops[DM_PULLUP_OUT] = otg_tcd_ops->dm_pullup_func;
++ otg_instance_private.otg_output_ops[DP_PULLDOWN_OUT] = otg_tcd_ops->dp_pulldown_func;
++ otg_instance_private.otg_output_ops[DM_PULLDOWN_OUT] = otg_tcd_ops->dm_pulldown_func;
++ //otg_instance_private.otg_output_ops[PERIPHERAL_HOST] = otg_tcd_ops->peripheral_host_func;
++ otg_instance_private.otg_output_ops[CLR_OVERCURRENT_OUT] = otg_tcd_ops->overcurrent_func;
++ otg_instance_private.otg_output_ops[DM_DET_OUT] = otg_tcd_ops->dm_det_func;
++ otg_instance_private.otg_output_ops[DP_DET_OUT] = otg_tcd_ops->dp_det_func;
++ otg_instance_private.otg_output_ops[CR_DET_OUT] = otg_tcd_ops->cr_det_func;
++ otg_instance_private.otg_output_ops[AUDIO_OUT] = otg_tcd_ops->audio_func;
++ otg_instance_private.otg_output_ops[CHARGE_PUMP_OUT] = otg_tcd_ops->charge_pump_func;
++ otg_instance_private.otg_output_ops[BDIS_ACON_OUT] = otg_tcd_ops->bdis_acon_func;
++ otg_instance_private.otg_output_ops[MX21_VBUS_DRAIN] = otg_tcd_ops->mx21_vbus_drain_func;
++ otg_instance_private.otg_output_ops[ID_PULLDOWN_OUT] = otg_tcd_ops->id_pulldown_func;
++ otg_instance_private.otg_output_ops[UART_OUT] = otg_tcd_ops->uart_func;
++ otg_instance_private.otg_output_ops[MONO_OUT] = otg_tcd_ops->mono_func;
++ }
++ else
++ otg_instance_private.otg_output_ops[TCD_INIT_OUT] =
++ otg_instance_private.otg_output_ops[TCD_EN_OUT] =
++ otg_instance_private.otg_output_ops[CHRG_VBUS_OUT] =
++ otg_instance_private.otg_output_ops[DRV_VBUS_OUT] =
++ otg_instance_private.otg_output_ops[DISCHRG_VBUS_OUT] =
++ otg_instance_private.otg_output_ops[DP_PULLUP_OUT] =
++ otg_instance_private.otg_output_ops[DM_PULLUP_OUT] =
++ otg_instance_private.otg_output_ops[DP_PULLDOWN_OUT] =
++ otg_instance_private.otg_output_ops[DM_PULLDOWN_OUT] =
++ //otg_instance_private.otg_output_ops[PERIPHERAL_HOST] =
++ otg_instance_private.otg_output_ops[CLR_OVERCURRENT_OUT] =
++ otg_instance_private.otg_output_ops[DM_DET_OUT] =
++ otg_instance_private.otg_output_ops[DP_DET_OUT] =
++ otg_instance_private.otg_output_ops[CR_DET_OUT] =
++ otg_instance_private.otg_output_ops[AUDIO_OUT] =
++ otg_instance_private.otg_output_ops[CHARGE_PUMP_OUT] =
++ otg_instance_private.otg_output_ops[BDIS_ACON_OUT] =
++ otg_instance_private.otg_output_ops[MX21_VBUS_DRAIN] =
++ otg_instance_private.otg_output_ops[ID_PULLDOWN_OUT] =
++ otg_instance_private.otg_output_ops[UART_OUT] =
++ otg_instance_private.otg_output_ops[MONO_OUT] = NULL;
++
++ UNLESS (otg_instance_private.otg_output_ops[TCD_INIT_OUT])
++ otg_instance_private.otg_output_ops[TCD_INIT_OUT] = otg_tcd_init_func;
++
++ return &tcd_instance_private;
++}
++
++/*!
++ * otg_set_usbd_ops() -
++ * @param usbd_ops
++ */
++int otg_set_usbd_ops(struct usbd_ops *usbd_ops)
++{
++ otg_usbd_ops = usbd_ops;
++ return 0;
++}
++
++
++/*!
++ * otg_get_trace_info()
++ */
++void otg_get_trace_info(otg_trace_t *p)
++{
++ p->id_gnd = otg_instance_private.current_inputs & ID_GND ? 1 : 0;
++ p->va.s.ticks = (otg_ocd_ops && otg_ocd_ops->ticks) ? otg_ocd_ops->ticks () : 0;
++ p->va.s.interrupts = (otg_ocd_ops && otg_ocd_ops->interrupts) ? otg_ocd_ops->interrupts : 0;
++ p->va.s.framenum = (otg_pcd_ops && otg_pcd_ops->framenum) ? otg_pcd_ops->framenum() : 0;
++ p->in_interrupt = in_interrupt();
++}
++
++/*!
++ * otg_tmr_ticks() -
++ * @return number of ticks.
++ */
++u64 otg_tmr_ticks(void)
++{
++ return (otg_ocd_ops && otg_ocd_ops->ticks) ? otg_ocd_ops->ticks () : 0;
++}
++
++/*!
++ * otg_tmr_elapsed() -
++ * @param t1
++ * @param t2
++ * @return number of uSecs between t1 and t2 ticks.
++ */
++u64 otg_tmr_elapsed(u64 *t1, u64 *t2)
++{
++ return (otg_ocd_ops && otg_ocd_ops->elapsed) ? otg_ocd_ops->elapsed (t1, t2) : 0;
++}
++
++/*!
++ * otg_tmr_framenum() -
++ * @return the current USB frame number.
++ */
++u16 otg_tmr_framenum(void)
++{
++ return (otg_pcd_ops && otg_pcd_ops->framenum) ? otg_pcd_ops->framenum() : 0;
++}
++
++/*!
++ * otg_tmr_interrupts() -
++ * @return the current number of interrupts.
++ */
++u32 otg_tmr_interrupts(void)
++{
++ return (otg_ocd_ops && otg_ocd_ops->interrupts) ? otg_ocd_ops->interrupts : 0;
++}
++
++
++OTG_EXPORT_SYMBOL(otg_hcd_ops);
++OTG_EXPORT_SYMBOL(otg_ocd_ops);
++OTG_EXPORT_SYMBOL(otg_pcd_ops);
++OTG_EXPORT_SYMBOL(otg_tcd_ops);
++OTG_EXPORT_SYMBOL(otg_set_hcd_ops);
++OTG_EXPORT_SYMBOL(otg_set_ocd_ops);
++OTG_EXPORT_SYMBOL(otg_set_pcd_ops);
++OTG_EXPORT_SYMBOL(otg_set_tcd_ops);
++OTG_EXPORT_SYMBOL(otg_set_usbd_ops);
++OTG_EXPORT_SYMBOL(otg_tmr_ticks);
++OTG_EXPORT_SYMBOL(otg_tmr_elapsed);
++OTG_EXPORT_SYMBOL(otg_write_input_message_irq);
++
++
++#if defined(OTG_WINCE)
++#else /* defined(OTG_WINCE) */
++#endif /* defined(OTG_WINCE) */
++
+diff -uNr linux/drivers/no-otg/otgcore/sources linux/drivers/otg/otgcore/sources
+--- linux/drivers/no-otg/otgcore/sources 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otgcore/sources 2006-09-01 21:41:34.000000000 +0200
+@@ -0,0 +1,41 @@
++!if 0
++Copyright (c) Microsoft Corporation. All rights reserved.
++!endif
++!if 0
++Use of this source code is subject to the terms of the Microsoft end-user
++license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
++If you did not accept the terms of the EULA, you are not authorized to use
++this source code. For a copy of the EULA, please see the LICENSE.RTF on your
++install media.
++!endif
++
++SYNCHRONIZE_DRAIN=1
++
++INCLUDES= \
++ $(_PUBLICROOT)\common\ddk\inc; $(_PUBLICROOT)\common\oak\inc; $(_PUBLICROOT)\common\sdk\inc; \
++ $(_WINCEROOT)\public\common\oak\DRIVERS\otg;
++
++
++TARGETNAME=otgcore
++TARGETTYPE=LIBRARY
++
++
++SOURCES= \
++ core-init-w42.c \
++ otg.c \
++ otg-mesg.c \
++ otg-mesg-w42.c \
++ otg-ops.c \
++ usbp-bops.c \
++ usbp-fops.c \
++ otg-fw.c \
++ otg-fw-df.c \
++ otg-fw-mn.c \
++ usbp.c \
++ otg-trace.c \
++ otg-trace-w42.c \
++ ep0.c \
++
++# usbp-procfs.c \
++
++
+diff -uNr linux/drivers/no-otg/otgcore/usbp-bops.c linux/drivers/otg/otgcore/usbp-bops.c
+--- linux/drivers/no-otg/otgcore/usbp-bops.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otgcore/usbp-bops.c 2006-09-01 21:41:35.000000000 +0200
+@@ -0,0 +1,1857 @@
++/*
++ * otg/otgcore/usbp-bops.c - USB Device Prototype
++ *
++ * Copyright (c) 2004-2005 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/otgcore/usbp-bops.c
++ * @brief Bus Interface related functions.
++ *
++ * This implements the functions used to implement Peripheral Controller Drivers (PCD.)
++ *
++ * @ingroup USBP
++ */
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/otg-trace.h>
++#include <otg/otg-api.h>
++#include <otg/otg-trace.h>
++#include <otg/usbp-func.h>
++#include <otg/usbp-bus.h>
++#include <otg/otg-pcd.h>
++
++/* ********************************************************************************************* */
++/*!
++ * Note that all of the list functions 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);
++void usbd_device_bh (void *data);
++
++/* ********************************************************************************************* */
++/*!
++ * 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_strings_init (void);
++void usbd_strings_exit(void);
++
++extern struct usbd_function_instance *usbd_find_function (char *name);
++
++struct usbd_bus_instance *usbd_bus_instance;
++OTG_EXPORT_SYMBOL(usbd_bus_instance);
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++/*!
++ * Bus Interface Management:
++ * usbd_register_bus()
++ * usbd_deregister_bus()
++ */
++
++/*! urb_link_init() - initialize urb linke
++ *
++ * 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.
++ *
++ * @param ul link to urb
++ */
++static INLINE void urb_link_init (urb_link * ul)
++{
++ ul->prev = ul->next = ul;
++}
++
++static struct usbd_function_operations ep0_ops;
++struct usbd_function_driver ep0_driver;
++
++
++/*!
++ * 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.
++ *
++ * @param driver
++ * @param ep0_wMaxPacketSize
++ * @return non-zero if error
++ */
++struct usbd_bus_instance *usbd_register_bus (struct usbd_bus_driver *driver, int ep0_wMaxPacketSize)
++{
++ int i;
++ struct usbd_bus_instance *bus = NULL;
++
++ DOWN(&usbd_bus_sem);
++
++ THROW_IF(usbd_bus_instance, error);
++ THROW_IF((bus = CKMALLOC (sizeof (struct usbd_bus_instance), GFP_ATOMIC)) == NULL, error);
++
++ bus->driver = driver;
++ bus->endpoints = bus->driver->max_endpoints;
++ bus->otg_bmAttributes = bus->driver->otg_bmAttributes;
++
++ THROW_IF(!(bus->endpoint_array = CKMALLOC(sizeof (struct usbd_endpoint_instance) * bus->endpoints, GFP_ATOMIC)), error);
++
++ for (i = 0; i < bus->endpoints; i++) {
++ struct usbd_endpoint_instance *endpoint = bus->endpoint_array + i;
++ endpoint->physical_endpoint = i;
++ urb_link_init (&endpoint->rdy);
++ urb_link_init (&endpoint->tx);
++ }
++
++ urb_link_init (&bus->finished);
++
++ ZERO(ep0_ops);
++ ZERO(ep0_driver);
++ ep0_driver.name = "EP0";
++ ep0_driver.fops = &ep0_ops;
++
++
++ THROW_IF((bus->ep0 = CKMALLOC (sizeof (struct usbd_function_instance), GFP_ATOMIC)) == NULL, error);
++ bus->ep0->function_driver = &ep0_driver;
++ THROW_IF(!(bus->ep0->endpoint_map_array = CKMALLOC(sizeof(struct usbd_endpoint_map) * 2, GFP_KERNEL)), error);
++ bus->ep0->endpoint_map_array[0].wMaxPacketSize[0] = ep0_wMaxPacketSize;
++ bus->ep0->endpoint_map_array[0].wMaxPacketSize[1] = ep0_wMaxPacketSize;
++
++ 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;
++ #if defined(OTG_LINUX)
++ printk(KERN_INFO"%s: FAILED\n", __FUNCTION__);
++ #endif /* defined(OTG_LINUX) */
++ #if defined(OTG_WINCE)
++ DEBUGMSG(ZONE_INIT, (_T("usbd_register_bus: FAILED\n")));
++ #endif /* defined(OTG_LINUX) */
++ bus = NULL;
++ }
++
++ UP(&usbd_bus_sem);
++ 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.
++ *
++ * @param bus
++ */
++void usbd_deregister_bus (struct usbd_bus_instance *bus)
++{
++ 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;
++ UP(&usbd_bus_sem);
++}
++
++OTG_EXPORT_SYMBOL(usbd_register_bus);
++OTG_EXPORT_SYMBOL(usbd_deregister_bus);
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++/*!
++ * Function Management:
++ * usbd_enable_function()
++ * usbd_disable_function()
++ *
++ */
++
++/*!
++ * 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.
++ * @param bInterfaceNumber
++ * @param interface_description
++ * @param alternates
++ * @param alternate_description_array
++ * @return pointer to alternate instance array
++ */
++static struct usbd_alternate_instance *
++alloc_function_alternates (int bInterfaceNumber,
++ struct usbd_interface_description *interface_description,
++ int alternates, struct usbd_alternate_description *alternate_description_array)
++{
++ int alternate_num;
++ struct usbd_alternate_instance *alternate_instance_array = NULL;
++
++ // allocate array of alternate instances
++ RETURN_NULL_IF(!(alternate_instance_array = (struct usbd_alternate_instance *)
++ CKMALLOC (sizeof (struct usbd_alternate_instance) * alternates, GFP_KERNEL)));
++
++ // iterate across the alternate descriptions
++ for (alternate_num = 0; alternate_num < alternates; alternate_num++) {
++
++ struct usbd_alternate_description *alternate_description = alternate_description_array + alternate_num;
++ struct usbd_alternate_instance *alternate_instance = alternate_instance_array + alternate_num;
++ struct usbd_interface_descriptor *interface_descriptor;
++
++ interface_descriptor = alternate_description->interface_descriptor;
++ if (interface_descriptor->bInterfaceNumber != bInterfaceNumber) {
++ //TRACE_MSG2(USBD, "bInterfaceNumber mis-match: %d should be %d",
++ // 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.
++ *
++ * @param bNumInterfaces
++ * @param interface_description_array
++ * @return interface instance
++ */
++static struct usbd_interfaces_instance *
++alloc_function_interfaces (int bNumInterfaces, struct usbd_interface_description *interface_description_array)
++{
++ int interface_num;
++ struct usbd_interfaces_instance *interfaces_instance_array = NULL;
++
++ // allocate array of interface instances
++ RETURN_NULL_IF(!(interfaces_instance_array = (struct usbd_interfaces_instance *)
++ CKMALLOC (sizeof (struct usbd_interfaces_instance) * bNumInterfaces, GFP_KERNEL)));
++
++ // iterate across the interface descriptions
++ for (interface_num = 0; interface_num < bNumInterfaces; interface_num++) {
++
++ struct usbd_interface_description *interface_description = interface_description_array + interface_num;
++ struct usbd_interfaces_instance *interfaces_instance = interfaces_instance_array + interface_num;
++
++ interfaces_instance->alternates_instance_array =
++ alloc_function_alternates (interface_num, interface_description,
++ interface_description->alternates, interface_description->alternate_list);
++ interfaces_instance->alternates = interface_description->alternates;
++ }
++ return interfaces_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.
++ *
++ * @param bNumConfigurations
++ * @param configuration_description_array
++ * @param otg_descriptor
++ * @param remote_wakeup_supported
++ * @param bMaxPower
++ * @return configuration instance
++ */
++static struct usbd_configuration_instance *
++alloc_function_configurations (struct usbd_function_driver *function_driver,
++ int remote_wakeup_supported,
++ int bMaxPower)
++{
++
++ int bNumConfigurations = function_driver->bNumConfigurations;
++ struct usbd_configuration_description *configuration_description_array = function_driver->configuration_description;
++ struct usbd_otg_descriptor *otg_descriptor = function_driver->otg_descriptor;
++ int config_num;
++ struct usbd_configuration_instance *configuration_instance_array = NULL;
++
++ //TRACE_MSG2(USBD, "remote: %x bMaxPower: %x", remote_wakeup_supported, bMaxPower);
++
++ // allocate array
++ RETURN_NULL_IF(!(configuration_instance_array = (struct usbd_configuration_instance *)
++ CKMALLOC (sizeof (struct usbd_configuration_instance) * bNumConfigurations, GFP_KERNEL)));
++ // fill in array
++ for (config_num = 0; config_num < bNumConfigurations; config_num++) {
++ int interface_num;
++ int length;
++
++ struct usbd_configuration_description *configuration_description = configuration_description_array + config_num;
++ struct usbd_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 = config_num + 1;
++ configuration_descriptor->wTotalLength = 0;
++ configuration_descriptor->bNumInterfaces = function_driver->bNumInterfaces;
++ configuration_descriptor->iConfiguration = usbd_alloc_string (configuration_description->iConfiguration);
++ configuration_descriptor->bMaxPower = bMaxPower;
++ configuration_descriptor->bmAttributes = BMATTRIBUTE_RESERVED |
++ bMaxPower ? 0 : BMATTRIBUTE_SELF_POWERED |
++ remote_wakeup_supported ? BMATTRIBUTE_REMOTE_WAKEUP : 0;
++
++ // save the configuration descriptor in the configuration instance array
++ configuration_instance_array[config_num].configuration_descriptor = configuration_descriptor;
++
++ RETURN_NULL_IF (!(configuration_instance_array[config_num].interfaces_instance_array =
++ alloc_function_interfaces (function_driver->bNumInterfaces,
++ function_driver->interface_list)));
++
++ length = sizeof(struct usbd_configuration_descriptor);
++
++ for (interface_num = 0; interface_num < configuration_descriptor->bNumInterfaces; interface_num++) {
++
++ int alternate_num;
++ struct usbd_interfaces_instance *interfaces_instance =
++ configuration_instance_array[config_num].interfaces_instance_array + interface_num;
++
++ TRACE_MSG2(USBD, "len: %02x:%02d configuration", length, length);
++ for (alternate_num = 0; alternate_num < interfaces_instance->alternates; alternate_num++) {
++ int class_num;
++ int endpoint;
++ struct usbd_alternate_instance *alternate_instance =
++ interfaces_instance->alternates_instance_array + alternate_num;
++
++ length += sizeof (struct usbd_interface_descriptor);
++
++ TRACE_MSG2(USBD, "len: %02x:%02d interface", length, length);
++ for (class_num = 0; class_num < alternate_instance->classes; class_num++) {
++ struct usbd_generic_class_descriptor * class_descriptor =
++ *(alternate_instance->class_list + class_num);
++ length += class_descriptor->bLength;
++ TRACE_MSG2(USBD, "len: %02x:%02d class_num", length, length);
++ }
++
++ for (endpoint = 0; endpoint < alternate_instance->endpoints; endpoint++) {
++ struct usbd_endpoint_descriptor * endpoint_descriptor =
++ *(alternate_instance->endpoint_list + endpoint);
++ length += endpoint_descriptor->bLength;
++ TRACE_MSG2(USBD, "len: %02x:%02d endpoint", length, length);
++ }
++ }
++ }
++ length += otg_descriptor ? sizeof(struct usbd_otg_descriptor) : 0;
++ configuration_descriptor->wTotalLength = cpu_to_le16 ((u16)length);
++ // XXX only support a single configuration currently
++ configuration_instance_array[config_num].bNumInterfaces = function_driver->bNumInterfaces;
++ TRACE_MSG3(USBD, "configuration_instance_array[%d]: %p wTotalLength: %d", config_num,
++ &configuration_instance_array[config_num], length);
++ }
++ return configuration_instance_array;
++}
++
++
++/*!
++ * bus_function_enable() - enable a usbd function driver for use
++ *
++ * This will copy descriptors from the function driver and get them ready
++ * for use.
++ * @param bus
++ * @param function
++ * @param serial_number
++ * @return non-zero if error
++ */
++static int
++bus_function_enable (struct usbd_bus_instance *bus, struct usbd_function_instance *function, char *serial_number)
++{
++ struct usbd_function_driver *function_driver = function->function_driver;
++ struct usbd_device_description *device_description;
++ struct usbd_device_descriptor *device_descriptor;
++#ifdef CONFIG_OTG_HIGH_SPEED
++ struct usbd_device_qualifier_descriptor *device_qualifier_descriptor;
++#endif /* CONFIG_OTG_HIGH_SPEED */
++ struct usbd_otg_descriptor *otg_descriptor;
++ int rc = 0;
++
++ function->bus = bus;
++
++ RETURN_EINVAL_IF(function_driver->fops->function_enable && 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 (strlen (serial_number))
++ device_descriptor->iSerialNumber = usbd_alloc_string (serial_number);
++ 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;
++
++ if ((otg_descriptor = device_description->otg_descriptor)) {
++ otg_descriptor->bmAttributes = usbd_otg_bmattributes(function);
++ function_driver->otg_descriptor = otg_descriptor;
++ }
++
++ /* call alloc_function_configurations() to allocate the configuration descriptor array
++ */
++ RETURN_EINVAL_IF (!(function_driver->configuration_instance_array =
++ alloc_function_configurations (function_driver,
++ bus->driver->capabilities & REMOTE_WAKEUP_SUPPORTED,
++ bus->driver->bMaxPower
++ )));
++
++ function_driver->device_descriptor = device_descriptor;
++#ifdef CONFIG_OTG_HIGH_SPEED
++ TRACE_MSG0(USBD, "HIGH SPEED");
++ if ((device_qualifier_descriptor = device_description->device_qualifier_descriptor)) {
++ device_qualifier_descriptor->bNumConfigurations = function_driver->bNumConfigurations;
++ function_driver->device_qualifier_descriptor = device_qualifier_descriptor;
++ }
++#endif /* CONFIG_OTG_HIGH_SPEED */
++ //TRACE_MSG0(USBD, "finished");
++ return rc;
++}
++
++/*!
++ * usbd_function_disable() - disable a usbd function driver
++ * @param function
++ */
++void usbd_function_disable (struct usbd_function_instance *function)
++{
++ int configuration;
++ struct usbd_function_driver *function_driver = function->function_driver;
++ struct usbd_configuration_instance *configuration_instance_array = function_driver->configuration_instance_array;
++
++ if (function->function_driver->fops->function_disable)
++ 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_num;
++ struct usbd_configuration_instance *configuration_instance = configuration_instance_array + configuration;
++
++ for (interface_num = 0; interface_num < configuration_instance->bNumInterfaces; interface_num++) {
++
++ //int alternate_num;
++ struct usbd_interfaces_instance *interfaces_instance =
++ configuration_instance->interfaces_instance_array + interface_num;
++
++ LKFREE (interfaces_instance->alternates_instance_array);
++ }
++ LKFREE (configuration_instance->interfaces_instance_array);
++ }
++ }
++ LKFREE (configuration_instance_array);
++ function->bus = NULL;
++}
++
++
++/*!
++ * usbd_enable_function() - called to enable the desired function
++ *
++ * Used by a USB Bus interface driver to create a virtual device.
++ *
++ * @param bus
++ * @param arg
++ * @param serial_number
++ * @return non-zero if error
++ */
++int usbd_enable_function(struct usbd_bus_instance *bus, char *arg, char *serial_number)
++{
++ struct usbd_function_instance *function = NULL;
++ struct usbd_function_driver *function_driver = NULL;
++ LIST_NODE *lhd = NULL;
++ int len = 0;
++ int i;
++ int rc = -EINVAL;
++ int epn, endpointsRequested;
++ int endpoints;
++
++ DOWN(&usbd_bus_sem);
++
++ if (arg && bus->arg)
++ LKFREE(bus->arg);
++
++ if (arg) {
++ bus->arg = LSTRDUP(arg);
++ len = strlen(arg);
++ }
++
++ /* initialize the strings pool, and zero endpoint array urbs
++ */
++ THROW_IF(usbd_strings_init (), error);
++
++ for (i = 1; i < bus->endpoints; i++) {
++ struct usbd_endpoint_instance *endpoint = bus->endpoint_array + i;
++ endpoint->rcv_urb = endpoint->tx_urb = NULL;
++ }
++
++ /* find requested function
++ */
++ if ((function = usbd_find_function(arg))) {
++
++ function_driver = function->function_driver;
++
++ TRACE_MSG1(USBD, "request endpoints: %x", function_driver);
++
++ switch(function->function_type) {
++ case function_simple:
++ THROW_IF(bus->driver->bops->request_endpoints( bus, function->endpoint_map_array,
++ function->function_driver->endpointsRequested,
++ function->function_driver->requestedEndpoints), error);
++ break;
++ case function_interface:
++ break;
++ case function_composite:
++ THROW_IF(bus->driver->bops->request_endpoints( bus, function->endpoint_map_array,
++ function->endpoints,
++ function->requestedEndpoints), error);
++ break;
++ }
++
++
++ bus_function_enable (bus, function, serial_number);
++ }
++
++ THROW_IF (!(bus->function_instance = function), error);
++
++
++ /* if composite we need to compose the interface list and endpoint map
++ */
++ if(function_composite == function->function_type) {
++ char *name;
++ int i;
++ }
++
++ /* we need to de-compose the endpoint request array into the individual
++ * interface endpoint map array.
++ */
++ for (endpoints = 0, i = 0; i < function->interfaces; i++) {
++ struct usbd_function_instance *interface_function = function->interfaces_array[i];
++ interface_function->endpoint_map_array = function->endpoint_map_array;
++ endpoints += interface_function->endpoints;
++ }
++
++
++ switch(bus->function_instance->function_type) {
++ case function_simple:
++ case function_composite:
++ THROW_IF(bus->driver->bops->set_endpoints( bus,
++ function->function_driver->endpointsRequested,
++ function->endpoint_map_array), error);
++ break;
++ case function_interface:
++ break;
++ }
++
++ // device bottom half
++ PREPARE_WORK_ITEM(bus->device_bh, usbd_device_bh, bus);
++ bus->status = USBD_OK;
++ bus->bus_state = usbd_bus_state_enabled;
++ bus->ep0->endpoint_map_array->endpoint = bus->endpoint_array;
++ THROW_IF (bus_function_enable (bus, bus->ep0, NULL), error);
++
++ // iterate across the logical endpoint map to copy appropriate information
++ // into the physical endpoint instance array
++
++ endpointsRequested = bus->function_instance->function_driver->endpointsRequested;
++
++ for (epn = 0; epn < /*bus->function_instance->*/endpointsRequested; epn++) {
++
++ struct usbd_endpoint_map *endpoint_map = bus->function_instance->endpoint_map_array + epn;
++ int physicalEndpoint = endpoint_map->physicalEndpoint[0];
++ struct usbd_endpoint_instance *endpoint = bus->endpoint_array + physicalEndpoint;
++
++ 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->tx_transferSize = endpoint_map->transferSize[0];
++ 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;
++ }
++ }
++
++ /* if composite we need to de-compose the endpoint map into the individual
++ * interface endpoint maps.
++ */
++ if(function_composite == function->function_type) {
++ }
++
++ rc = 0;
++
++ CATCH(error) {
++ usbd_strings_exit();
++ }
++ UP(&usbd_bus_sem);
++ return rc;
++}
++
++int usbd_enable_function_irq (struct usbd_bus_instance *bus, char *arg, char *serial_number)
++{
++ return usbd_enable_function(bus, arg, serial_number);
++}
++
++/*!
++ * usbd_disable_function() - called to disable the current function
++ *
++ * Used by a USB Bus interface driver to destroy a virtual device.
++ *
++ * @param bus
++ */
++void usbd_disable_function (struct usbd_bus_instance *bus)
++{
++ DOWN(&usbd_bus_sem);
++
++ // prevent any more bottom half scheduling
++ bus->status = USBD_CLOSING;
++ UP(&usbd_bus_sem);
++
++ /* XXX
++ * if composite ???
++ */
++ switch(bus->function_instance->function_type) {
++ case function_simple:
++ case function_interface:
++ break;
++ case function_composite:
++ break;
++ }
++
++ // wait for pending device bottom half to finish
++//XXX FIXME
++ //while (bus->device_bh.data /*|| device->function_bh.data */) {
++ while (PENDING_WORK_ITEM(bus->device_bh)){
++
++ //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...
++#if 1
++ //I.e. run this task immediately and then delay up to 2000 secdons ...
++#ifdef LINUX24
++ queue_task(&bus->device_bh, &tq_immediate);
++ mark_bh (IMMEDIATE_BH);
++#else
++ SCHEDULE_WORK(bus->device_bh);
++#endif
++ // schedule_task(&device->device_bh);
++
++ SCHEDULE_TIMEOUT (2000 * HZ);
++#else
++ //Generic version ...
++ SCHEDULE_IMMEDIATE_WORK(bus->device_bh);
++ SCHEDULE_TIMEOUT(2000); //Seconds
++#endif
++ }
++ 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->alternates) {
++ bus->bNumInterfaces = 0;
++ LKFREE(bus->alternates);
++ bus->alternates = NULL;
++ }
++ if (bus->function_instance) {
++#if 0
++ if (bus->function_instance->endpoint_map_array)
++ LKFREE(bus->function_instance->endpoint_map_array);
++ LKFREE(bus->function_instance);
++#endif
++ bus->function_instance = NULL;
++ }
++ usbd_strings_exit();
++ bus->status = USBD_CLOSED;
++ UP(&usbd_bus_sem);
++}
++
++OTG_EXPORT_SYMBOL(usbd_enable_function);
++OTG_EXPORT_SYMBOL(usbd_enable_function_irq);
++OTG_EXPORT_SYMBOL(usbd_disable_function);
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++/*!
++ * Bus Event Handling:
++ * usbd_bus_event_handler()
++ *
++ */
++static usbd_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 usbd_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_bus_event_handler_irq() - called to respond to various usb events
++ *
++ * This is called from an interrupt context.
++ *
++ * Used by a Bus driver to indicate an event.
++ * @param bus
++ * @param event
++ * @param data
++ */
++void usbd_bus_event_handler_irq (struct usbd_bus_instance *bus, usbd_device_event_t event, int data)
++{
++ RETURN_UNLESS(bus);
++
++ /* get the next bus device state by table lookup of event, we need to save the
++ * current state IFF we are suspending so that it can be restored on resume.
++ */
++ switch (event) {
++ case DEVICE_BUS_INACTIVE:
++ bus->suspended_state = bus->device_state;
++ /* FALL THROUGH */
++ default:
++ bus->device_state = event_states[event];
++ //TRACE_MSG0(USBD, "default");
++ break;
++ case DEVICE_UNKNOWN:
++ //TRACE_MSG0(USBD, "UNKNOWN");
++ break;
++ case DEVICE_BUS_ACTIVITY:
++ bus->device_state = bus->suspended_state;
++ //TRACE_MSG0(USBD, "ACTIVITY");
++ break;
++
++ case DEVICE_SET_INTERFACE:
++ case DEVICE_SET_FEATURE:
++ case DEVICE_CLEAR_FEATURE:
++ //TRACE_MSG0(USBD, "SET");
++ break;
++ }
++
++ /* set the bus status by table lookup of event.
++ */
++ switch (event) {
++ case DEVICE_BUS_ACTIVITY:
++ case DEVICE_BUS_INACTIVE:
++ BREAK_IF(USBD_CLOSING != bus->status);
++ /* FALL THROUGH */
++ default:
++ bus->status = event_status[event];
++ //TRACE_MSG0(USBD, "DEFAULT");
++ break;
++ }
++
++ /* we need to reset things on some transitions
++ */
++ switch (bus->device_state) {
++ default:
++ // if we lost configuration then get rid of alternate settings
++ if (bus->alternates) {
++ LKFREE(bus->alternates);
++ bus->alternates = NULL;
++ }
++ bus->bNumInterfaces = 0;
++ bus->device_feature_settings = 0;
++ bus->ConfigurationValue = 0;
++ case STATE_CONFIGURED:
++ break;
++ case STATE_SUSPENDED:
++ // XXX Checkme - is suspend equivalent to end of session?
++ // C.f. OTG 6.5.1-6.5.3 imply that these must be reset at the end of a session or reset
++ //bus->device_feature_settings &=
++ // ~(FEATURE(USB_OTG_A_HNP_ENABLE) | FEATURE(USB_OTG_B_HNP_ENABLE) | FEATURE(USB_OTG_A_ALT_HNP_ENABLE));
++ break;
++ }
++ /* Pass the event to the bus interface driver and then the function driver and
++ * any interface function drivers.
++ */
++ bus->driver->bops->event_handler (bus, event, data);
++ bus->function_instance->function_driver->fops->event_handler(bus->function_instance, event, data);
++ #if 0
++ // XXX pass to interface function drivers
++ #endif
++}
++
++/*!
++ * usbd_bus_event_handler() - process bus event
++ * @param bus
++ * @param event
++ * @param data
++ */
++void usbd_bus_event_handler (struct usbd_bus_instance *bus, usbd_device_event_t event, int data)
++{
++ unsigned long flags;
++ local_irq_save (flags);
++ usbd_bus_event_handler_irq(bus, event, data);
++ local_irq_restore (flags);
++}
++
++OTG_EXPORT_SYMBOL(usbd_bus_event_handler);
++OTG_EXPORT_SYMBOL(usbd_bus_event_handler_irq);
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++/*!
++ * Device Request Processing:
++ * usbd_device_request()
++ *
++ */
++
++/*!
++ * C.f. 9.4 Standard Requests and table 9.3
++ *
++ * Encode valid requests into a bitmap for each recipient type for
++ * both directions. This is needed because there are some requests
++ * that appear to be a standard request but are not described in
++ * Chapter nine. For example the mouse driver hid request.
++ *
++ * So we only process the actual set of standard requests that are
++ * defined in chapter nine and even if it appears to be standard but
++ * is not in chapter nine then we pass it to the function driver.
++ *
++ * @{
++ */
++
++#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_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) |
++ STD(USB_REQ_GET_CONFIGURATION),
++ // 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,
++};
++
++/* @} */
++
++
++/*!
++ * devreq_set_configuration() - process a received urb
++ *
++ * Used by a USB Bus interface driver to pass received device request to
++ * the appropriate USB Function driver.
++ *
++ * @param function
++ * @param request
++ * @return non-zero if errror
++ */
++static int devreq_set_configuration(struct usbd_function_instance *function, int wValue)
++{
++ struct usbd_bus_instance *bus = function->bus;
++ struct usbd_function_driver *function_driver = bus->function_instance->function_driver;
++ int bNumConfigurations = function_driver->bNumConfigurations;
++ int bNumInterfaces;
++ u8 ConfigurationValue;
++
++ struct usbd_configuration_instance *configuration_instance;
++ struct usbd_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 = wValue & 0x7f;
++
++ RETURN_EINVAL_IF(ConfigurationValue > bNumConfigurations);
++
++ /* save ConfigurationValue for GET_CONFIGURATION request
++ */
++ bus->ConfigurationValue = ConfigurationValue;
++
++ /* A ConfigurationValue of zero is for the default configuration (i.e.) the
++ * first one. A non-zero value needs to be decremented to allow it to be used
++ * as an index.
++ */
++ 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;
++
++ /* reset interface and alternate settings
++ */
++ RETURN_EINVAL_IF (!(bus->alternates = (u8 *) CKMALLOC(bNumInterfaces, GFP_ATOMIC)));
++ bus->bNumInterfaces = bNumInterfaces;
++
++ /* Call function driver set_configuration() operation and if available any
++ * interface drivers set_configuration() operations.
++ */
++ if (function_driver->fops->set_configuration) {
++ function_driver->fops->function_enable && function_driver->fops->set_configuration (function, wValue);
++ }
++ /*
++ * XXX
++ */
++
++ usbd_bus_event_handler (bus, DEVICE_CONFIGURED, 0);
++ return 0;
++}
++
++/*!
++ * devreq_set_interface_altsetting() -
++ *
++ * Used by a USB Bus interface driver to pass received device request to
++ * the appropriate USB Function driver.
++ *
++ * @param function
++ * @param request
++ * @return non-zero if errror
++ */
++static int devreq_set_interface_altsetting(struct usbd_function_instance *function, int wIndex, int wValue)
++{
++ struct usbd_bus_instance *bus = function->bus;
++ struct usbd_function_driver *function_driver = function->function_driver;
++
++ RETURN_EINVAL_IF(wIndex > bus->bNumInterfaces); // wIndex is interface
++
++ bus->alternates[wIndex] = (u8) wValue;
++
++ /* Call function driver set_interface() operation and if available any
++ * interface drivers set_interface() operations.
++ */
++ if (function_driver->fops->set_interface)
++ function_driver->fops->function_enable && function_driver->fops->set_interface (function, wIndex, wValue);
++ /*
++ * XXX
++ */
++
++ usbd_bus_event_handler (bus, DEVICE_SET_INTERFACE, 0);
++
++ return 0;
++}
++
++/*!
++ * devreq_get_device_feature_settings() - process a received urb
++ *
++ * Used by a USB Bus interface driver to pass received device request to
++ * the appropriate USB Function driver.
++ *
++ * @param function
++ * @param request
++ * @return non-zero if errror
++ */
++int devreq_get_device_feature_settings(struct usbd_function_instance *function)
++{
++ struct usbd_bus_instance *bus = function->bus;
++ return bus->device_feature_settings;
++}
++
++
++/*! devreq_device_feature - handle set/clear feature requests for device
++ * Used by the USB Device Core to set/clear endpoint halt status.
++ *
++ * We assume that if the udc driver does not implement anything then
++ * we should just return zero for ok.
++ */
++int devreq_device_feature (struct usbd_bus_instance *bus, int features, int flag)
++{
++ struct pcd_instance *pcd = (struct pcd_instance *)bus->privdata;
++ //u32 features = bus->device_feature_settings;
++
++ TRACE_MSG0(USBD, "BUS_DEVICE FEATURE");
++
++ /* if A-Device has enabled hnp
++ */
++ if (features & FEATURE(USB_OTG_B_HNP_ENABLE) )
++ otg_event(pcd->otg, HNP_ENABLED, USBD, "DEVICE FEATURE - B_HNP_ENABLE");
++
++ /* if A-Device does not support HNP on this port
++ */
++ else if ( features & FEATURE(USB_OTG_A_ALT_HNP_ENABLE) )
++ ; //otg_event(pcd->otg, not(a_hnp_support));
++
++ /* if A-Device does support HNP
++ */
++ else if (features & FEATURE(USB_OTG_A_HNP_SUPPORT))
++ ; //otg_event(pcd->otg, a_hnp_support);
++
++ return 0;
++ //return usbd_pcd_ops.device_feature ? usbd_pcd_ops.device_feature() : 0;
++}
++
++/*!
++ * copy_config() - copy data into 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_UNLESS (data);
++ RETURN_ZERO_UNLESS (length);
++ memcpy (cp, data, length);
++ return length;
++}
++
++/*!
++ * copy_endpoint() - copy data into buffer
++ */
++static int copy_endpoint (struct usbd_function_instance *function, u8 *cp,
++ struct usbd_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 usbd_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_old_get_descriptor() - copy a descriptor into buffer
++ *
++ * Return non-zero for error.
++ */
++int usbd_old_get_descriptor (struct usbd_function_instance *function, u8 *buffer, int max, int descriptor_type, int index)
++{
++ struct usbd_bus_instance *bus = function->bus;
++ struct usbd_function_driver *function_driver = bus->function_instance->function_driver;
++ int actual_length = 0;
++
++ switch (descriptor_type) {
++ case USB_DT_DEVICE:
++ {
++ struct usbd_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 usbd_device_descriptor *) buffer;
++ device_descriptor->bMaxPacketSize0 = bus->driver->maxpacketsize;
++ }
++ break;
++
++ #ifdef CONFIG_OTG_HIGH_SPEED
++ case USB_DT_DEVICE_QUALIFIER: // c.f. 9.6.2 Device Qualifier
++ {
++ struct usbd_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_DT_OTHER_SPEED_CONFIGURATION:
++ #endif /* CONFIG_OTG_HIGH_SPEED */
++
++ case USB_DT_CONFIGURATION:
++ {
++ #ifdef CONFIG_OTG_HIGH_SPEED
++ int hs = bus->HighSpeedFlag ? descriptor_type == USB_DT_CONFIGURATION:
++ descriptor_type == USB_DT_OTHER_SPEED_CONFIGURATION;
++ #else /* CONFIG_OTG_HIGH_SPEED */
++ int hs = 0;
++ #endif /* CONFIG_OTG_HIGH_SPEED */
++ int interface_num;
++
++ struct usbd_configuration_instance *configuration_instance =
++ &function_driver->configuration_instance_array[index];
++
++ struct usbd_configuration_descriptor *configuration_descriptor =
++ configuration_instance->configuration_descriptor;
++
++ struct usbd_otg_descriptor *otg_descriptor = function_driver->otg_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 all bNumInterfaces for specified configuration
++ for (interface_num = 0; interface_num < configuration_descriptor->bNumInterfaces; interface_num++) {
++
++ int alternate_num;
++ struct usbd_interfaces_instance *interfaces_instance =
++ configuration_instance->interfaces_instance_array + interface_num;
++
++ // iterate across all interface alternates
++ for (alternate_num = 0; alternate_num < interfaces_instance->alternates; alternate_num++) {
++
++ int class_num;
++ int endpoint;
++
++ struct usbd_alternate_instance *alternate_instance =
++ interfaces_instance->alternates_instance_array + alternate_num;
++
++ //struct usbd_interface_descriptor *usbd_interface_descriptor;
++
++ // copy descriptor for this interface
++ actual_length += copy_config (buffer + actual_length,
++ alternate_instance->interface_descriptor, actual_length, max);
++
++ // iterate across all classes for the alternate interface
++ for (class_num = 0; class_num < alternate_instance->classes; class_num++)
++ actual_length += copy_config (buffer + actual_length,
++ *(alternate_instance->class_list + class_num),
++ actual_length, max);
++
++ // iterate across all endpoints for the alternate interface
++ //interface_descriptor = alternate_instance->interface_descriptor;
++
++ for (endpoint = 0; endpoint < alternate_instance->endpoints ; endpoint++) {
++
++ TRACE_MSG2(USBD, "endpoint: %d index: %d",
++ 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);
++ }
++ }
++ }
++
++ /* copy the OTG descriptor if required
++ */
++ actual_length += copy_config (buffer + actual_length, otg_descriptor, actual_length, max);
++
++ /* set the configuration attributes and power fields in the configuration descriptor
++ */
++ configuration_descriptor = (struct usbd_configuration_descriptor *)buffer;
++
++ configuration_descriptor->bmAttributes = BMATTRIBUTE_RESERVED;
++
++ if (bus->device_feature_settings & FEATURE(USB_DEVICE_REMOTE_WAKEUP))
++ configuration_descriptor->bmAttributes |= BMATTRIBUTE_REMOTE_WAKEUP;
++
++ if (bus->driver->bMaxPower == 0) {
++ configuration_descriptor->bmAttributes |= BMATTRIBUTE_SELF_POWERED;
++ configuration_descriptor->bMaxPower = 1;
++ }
++ else
++ configuration_descriptor->bMaxPower = bus->driver->bMaxPower;
++
++ TRACE_MSG2(USBD, "bmAttributes: %02x bMaxPower: %02x",
++ configuration_descriptor->bmAttributes, configuration_descriptor->bMaxPower);
++ }
++ break;
++
++ case USB_DT_STRING:
++ {
++ struct usbd_string_descriptor *string_descriptor = NULL;
++ RETURN_EINVAL_IF (!(string_descriptor = usbd_get_string_descriptor ((u8)index)));
++ actual_length += copy_config (buffer + actual_length, string_descriptor, actual_length, max);
++ }
++ break;
++ default:
++ return -EINVAL;
++ }
++ return actual_length;
++}
++
++
++
++
++/*!
++ * setclear() - set or reset a bit in a mask
++ * @param features
++ * @param flag
++ * @param value
++ */
++static void setclear(u32 *features, u32 flag, u32 value)
++{
++ if (value) *features |= flag;
++ else *features &= ~flag;
++}
++
++/*! do_standard_device_request - process a device request
++ *
++ * Process a received device request. If not a Chapter nine request pass it
++ * to the other loaded function driver device_request() function.
++ *
++ * Return non-zero to indicate failure.
++ */
++static int do_standard_device_request (struct usbd_function_instance *function, struct usbd_device_request *request)
++{
++ struct usbd_bus_instance *bus = function->bus;
++ u8 bRequest = request->bRequest;
++ u8 bmRequestType = request->bmRequestType;
++ u16 wValue = le16_to_cpu(request->wValue);
++ u16 wIndex = le16_to_cpu(request->wIndex);
++ u16 wLength = le16_to_cpu(request->wLength);
++ u16 endpoint_index;
++
++ usbd_device_state_t device_state = usbd_get_device_state(function);
++
++ switch (device_state) {
++ case STATE_CREATED:
++ case STATE_ATTACHED:
++ case STATE_POWERED:
++ TRACE_MSG1(USBD, "bad device_state: %d", device_state);
++ return -EINVAL;
++
++ case STATE_INIT:
++ case STATE_DEFAULT:
++ switch (bRequest) {
++ case USB_REQ_CLEAR_FEATURE:
++ case USB_REQ_GET_INTERFACE:
++ case USB_REQ_GET_STATUS:
++ case USB_REQ_SET_DESCRIPTOR:
++ case USB_REQ_SET_INTERFACE:
++ case USB_REQ_SYNCH_FRAME:
++ TRACE_MSG2(USBD, "bad request: %d for this device_state: %d", bRequest, device_state);
++ return -EINVAL;
++
++ case USB_REQ_GET_CONFIGURATION:
++ case USB_REQ_SET_ADDRESS:
++ case USB_REQ_SET_CONFIGURATION:
++ case USB_REQ_GET_DESCRIPTOR:
++ case USB_REQ_SET_FEATURE:
++ break;
++ }
++ case STATE_ADDRESSED:
++ case STATE_CONFIGURED:
++ case STATE_SUSPENDED:
++ break;
++ case STATE_UNKNOWN:
++ TRACE_MSG1(USBD, "unknown device_state: %d", device_state);
++ return -EINVAL;
++ }
++
++ /* Handle all requests that return data (direction bit set on bm RequestType).
++ * N.B. no Chapter 9 requests send additional data.
++ */
++ if ((bmRequestType & USB_REQ_DIRECTION_MASK)) {
++ struct usbd_urb *urb;
++ int rc = 0;
++ switch (bRequest) {
++ case USB_REQ_CLEAR_FEATURE:
++ case USB_REQ_SET_ADDRESS:
++ case USB_REQ_SET_CONFIGURATION:
++ case USB_REQ_SET_DESCRIPTOR:
++ case USB_REQ_SET_FEATURE:
++ case USB_REQ_SET_INTERFACE:
++ case USB_REQ_SYNCH_FRAME:
++ TRACE_MSG0(USBD, "bad direction");
++ return -EINVAL;
++ }
++
++ RETURN_EINVAL_IF(!wLength);
++
++ /* allocate urb, no callback, urb will be automatically de-allocated
++ */
++ RETURN_EINVAL_IF(!(urb = usbd_alloc_urb_ep0 (function, wLength, NULL)));
++
++ switch (bRequest) {
++
++ case USB_REQ_GET_STATUS:
++ urb->actual_length = 2;
++ urb->buffer[0] = urb->buffer[1] = 0;
++
++ rc = 0;
++ switch (bmRequestType & USB_REQ_RECIPIENT_MASK) {
++ case USB_REQ_RECIPIENT_DEVICE:
++
++ UNLESS (usbd_get_bMaxPower(function)) urb->buffer[0] |= USB_STATUS_SELFPOWERED;
++ urb->buffer[0] |=
++ (devreq_get_device_feature_settings(function) & FEATURE(USB_DEVICE_REMOTE_WAKEUP)) ?
++ USB_STATUS_REMOTEWAKEUP : 0;
++ break;
++ case USB_REQ_RECIPIENT_ENDPOINT:
++ RETURN_EINVAL_UNLESS((endpoint_index = usbd_find_endpoint_index(bus, wIndex)) < bus->endpoints);
++ urb->buffer[0] = usbd_endpoint_halted (function, endpoint_index);
++ break;
++ case USB_REQ_RECIPIENT_INTERFACE:
++ break;
++ case USB_REQ_RECIPIENT_OTHER:
++ default:
++ TRACE_MSG0(USBD, "bad recipient");
++ rc = -EINVAL;
++ }
++ break;
++
++ case USB_REQ_GET_DESCRIPTOR:
++ rc = usbd_old_get_descriptor (function, urb->buffer, wLength, wValue >> 8, wValue & 0xff);
++ if (rc != -EINVAL) {
++ urb->actual_length = rc;
++ rc = 0;
++ }
++ else
++ TRACE_MSG0(USBD, "bad description");
++ break;
++
++ case USB_REQ_GET_CONFIGURATION:
++ TRACE_MSG1(USBD, "GET CONFIGURATION: %d", bus->ConfigurationValue);
++ urb->actual_length = 1;
++ urb->buffer[0] = bus->ConfigurationValue;
++ break;
++
++ case USB_REQ_GET_INTERFACE:
++ RETURN_EINVAL_IF(wIndex > bus->bNumInterfaces);
++ urb->actual_length = 1;
++ urb->buffer[0] = bus->alternates[wIndex];
++ break;
++ default:
++ TRACE_MSG0(USBD, "bad descriptor type");
++ rc = 1;
++ }
++
++ if (!(urb->actual_length % usbd_endpoint_zero_wMaxPacketSize(function, usbd_high_speed(function))) &&
++ (urb->actual_length < wLength))
++ urb->flags |= USBD_URB_SENDZLP;
++
++ RETURN_ZERO_UNLESS(rc || usbd_start_in_urb(urb));
++ /* only get here if error */
++ usbd_free_urb(urb);
++ TRACE_MSG0(USBD, "get failed");
++ return -EINVAL;
++ }
++ /* Handle the requests that do not return data.
++ */
++ else {
++ int setclear_flag = USB_REQ_SET_FEATURE == bRequest;
++ switch (bRequest) {
++ case USB_REQ_CLEAR_FEATURE:
++ case USB_REQ_SET_FEATURE:
++ TRACE_MSG2(USBD, "FEATURE: recipient: %d wValue: %d",
++ bmRequestType & USB_REQ_RECIPIENT_MASK, wValue);
++ switch (bmRequestType & USB_REQ_RECIPIENT_MASK) {
++ case USB_REQ_RECIPIENT_DEVICE:
++ //switch (wValue) {
++ // otg_event(pcd->otg, HNP_ENABLED, PCD, "DEVICE FEATURE - B_HNP_ENABLE");
++ // break;
++ //}
++ switch (wValue) {
++ case USB_OTG_A_ALT_HNP_ENABLE: // C.f. OTG 6.5.3
++ case USB_OTG_A_HNP_SUPPORT: // C.f. OTG 6.5.2
++ case USB_OTG_B_HNP_ENABLE: // C.f. OTG 6.5.1
++ RETURN_EINVAL_UNLESS(setclear_flag); // cleared by reset
++ case USB_DEVICE_REMOTE_WAKEUP:
++ break;
++ default:
++ return -EINVAL;
++ }
++ setclear(&bus->device_feature_settings, FEATURE(wValue), setclear_flag);
++ return devreq_device_feature(bus, FEATURE(wValue), setclear_flag);
++
++ case USB_REQ_RECIPIENT_ENDPOINT:
++ RETURN_EINVAL_UNLESS(USB_ENDPOINT_HALT == wValue);
++
++ setclear(&(bus->endpoint_array[wIndex].feature_setting),
++ FEATURE(wValue), bRequest == USB_REQ_SET_FEATURE);
++
++ /* wIndex contains bEndpointAddress, also find and verify the endpoint map index as well.
++ * Then clear the endpoint using the bus interface driver halt_endpoint() operation,
++ * if that is ok, then inform the function driver using the endpoint_cleared() operation.
++ *
++ */
++ RETURN_EINVAL_UNLESS((endpoint_index = usbd_find_endpoint_index(bus, wIndex)) < bus->endpoints);
++ RETURN_EINVAL_IF(function->bus->driver->bops->halt_endpoint(bus, wIndex,
++ endpoint_index, setclear_flag));
++
++ if (function->function_driver->fops->endpoint_cleared && !setclear_flag)
++ function->function_driver->fops->endpoint_cleared(function, wIndex, endpoint_index );
++
++ return 0;
++
++ case USB_REQ_RECIPIENT_INTERFACE:
++ case USB_REQ_RECIPIENT_OTHER:
++ default:
++ TRACE_MSG0(USBD, "bad recipient");
++ return -EINVAL;
++ }
++
++ case USB_REQ_SET_ADDRESS:
++ if (bus->driver->bops->set_address) bus->driver->bops->set_address (bus, wValue);
++ usbd_bus_event_handler (bus, DEVICE_ADDRESS_ASSIGNED, wValue);
++ return 0;
++
++ case USB_REQ_SET_DESCRIPTOR:
++ TRACE_MSG0(USBD, "set descriptor not supported");
++ return -EINVAL;
++
++ case USB_REQ_SET_CONFIGURATION:
++ return devreq_set_configuration(function, wValue);
++
++ case USB_REQ_SET_INTERFACE:
++ return devreq_set_interface_altsetting(function, wIndex, wValue);
++
++ case USB_REQ_GET_CONFIGURATION:
++ case USB_REQ_GET_DESCRIPTOR:
++ case USB_REQ_GET_INTERFACE:
++ case USB_REQ_GET_STATUS:
++ case USB_REQ_SYNCH_FRAME:
++ TRACE_MSG0(USBD, "unkown");
++ return -EINVAL;
++ }
++ }
++ TRACE_MSG0(USBD, "not possible");
++ return -EINVAL;
++}
++
++
++/*!
++ * usbd_device_request() - process a device request
++ *
++ * Used by a USB Bus interface driver to pass received device request to
++ * the appropriate USB Function driver.
++ *
++ * @param function
++ * @param request
++ * @return non-zero if errror
++ */
++int usbd_device_request(struct usbd_bus_instance *bus, struct usbd_device_request *request)
++{
++ struct usbd_function_instance *function = bus->function_instance;
++ u8 bRequest = request->bRequest;
++ u8 bmRequestType = request->bmRequestType;
++ u16 wValue = le16_to_cpu(request->wValue);
++ u16 wIndex = le16_to_cpu(request->wIndex);
++ u16 wLength = le16_to_cpu(request->wLength);
++
++ TRACE_MSG5(USBD, "bmRequestType:%02x bRequest:%02x wValue:%04x wIndex:%04x wLength:%04x",
++ bmRequestType, bRequest, wValue, wIndex, wLength);
++
++ /* Handle only USB Standard Requests (c.f. USB Spec table 9-2, D6..5 must be 0),
++ * otherwise call the currently enabled function specific receive setup.
++ */
++ if (!(bmRequestType & USB_REQ_TYPE_MASK) &&
++ ((bmRequestType & USB_DIR_IN ? d2h_standard_requests : h2d_standard_requests)
++ [bmRequestType & 0x3] & STD(bRequest)))
++ return do_standard_device_request(function, request);
++
++ /* Standard Requests not in Chapter nine, Class and Vendor device requests
++ * must be handled by the function driver or interface driver as appropriate.
++ */
++ switch(bmRequestType & USB_REQ_RECIPIENT_MASK) {
++ case USB_REQ_RECIPIENT_INTERFACE:
++ case USB_REQ_RECIPIENT_ENDPOINT:
++ /* XXX
++ * if function->interfaces[] is valid then we shuffle request off to
++ * interface driver for interface and endpoint recipients, otherwise
++ * fall through.
++ */
++
++ /*
++ * XXX for now just fall through for all.
++ */
++
++ case USB_REQ_RECIPIENT_DEVICE:
++ case USB_REQ_RECIPIENT_OTHER:
++ default:
++ return function->function_driver->fops->device_request(function, request);
++ }
++}
++
++OTG_EXPORT_SYMBOL(usbd_device_request);
++OTG_EXPORT_SYMBOL(usbd_old_get_descriptor);
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++/*!
++ * Device I/O:
++ * usbd_urb_finished()
++ * usbd_first_urb_detached()
++ * usbd_find_endpoint_address()
++ */
++
++/*!
++ * do_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.
++ *
++ * If there is no callback or if the URB call back returns non-zero then the
++ * urb must be de-allocated here.
++ *
++ * @param urb
++ * @param rc
++ */
++static void do_urb_callback (struct usbd_urb *urb, int rc)
++{
++ RETURN_UNLESS (urb);
++ if (!urb->callback || urb->callback(urb,rc))
++ usbd_free_urb(urb);
++}
++
++/*!
++ * urb_append_irq() - append a linked list of urbs to another linked list
++ * @param hd link to urb list
++ * @param urb to append to list
++ */
++static INLINE void urb_append_irq (urb_link * hd, struct usbd_urb *urb)
++{
++ urb_link *new;
++ urb_link *pul;
++ RETURN_UNLESS (hd && urb);
++ new = &urb->link;
++ pul = hd->prev;
++ new->prev->next = hd;
++ hd->prev = new->prev;
++ new->prev = pul;
++ pul->next = new;
++}
++
++/*!
++ * urb_append() - irq safe version
++ * @param hd list of urbs
++ * @param urb urb to append
++ */
++void urb_append(urb_link *hd, struct usbd_urb *urb)
++{
++ unsigned long flags;
++ local_irq_save (flags);
++ urb_append_irq(hd, urb);
++ local_irq_restore (flags);
++}
++
++
++/*!
++ * usbd_urb_finished() - tell function that an urb has been finished.
++ *
++ * Used by a USB Bus driver to pass a sent urb back to the function
++ * driver via the endpoints finished queue.
++ * @param urb urb to process
++ * @param rc result code
++ *
++ */
++void usbd_urb_finished(struct usbd_urb *urb, int rc)
++{
++ urb->status = (usbd_urb_status_t)rc;
++ #if defined(OTG_LINUX)
++ urb->jiffies = jiffies;
++ #endif /* defined(OTG_LINUX) */
++ if (USBD_OK != urb->bus->status)
++ do_urb_callback (urb, rc);
++ else {
++ urb_append_irq (&(urb->bus->finished), urb);
++ RETURN_IF (PENDING_WORK_ITEM(urb->bus->device_bh));
++#ifdef LINUX24
++ //FIXME XXX
++ queue_task (&urb->bus->device_bh, &tq_immediate);
++ mark_bh (IMMEDIATE_BH);
++#else
++ SCHEDULE_WORK(urb->bus->device_bh);
++#endif
++ }
++}
++void usbd_urb_finished_irq (struct usbd_urb *urb, int rc)
++{
++ usbd_urb_finished(urb, rc);
++}
++
++/*!
++ * @name STRUCT
++ * @brief
++ * 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)))
++
++/*!
++ * @name list
++ * @brief List support functions
++ *
++ * @{
++ */
++
++/*!
++ * urb_link() - return first urb_link in list
++ *
++ * 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.
++ *
++ * @return link to urb
++ */
++static INLINE urb_link *first_urb_link_irq (urb_link * hd)
++{
++ urb_link *nx;
++ return (!hd || !(nx = hd->next) || (nx == hd)) ? NULL : nx;
++}
++
++/*!
++ * first_urb_irq() - return first urb in list
++ * Return the first urb in a list with a distinguished
++ * head "hd", or NULL if the list is empty.
++ *
++ * Called from interrupt.
++ *
++ * @param hd linked list of urbs
++ * @return pointer to urb
++ */
++static INLINE struct usbd_urb *first_urb_irq (urb_link * hd)
++{
++ urb_link *nx;
++ return (!(nx = first_urb_link_irq (hd))) ? NULL : p2surround (struct usbd_urb, link, nx);
++}
++
++
++
++/*!
++ * usbd_first_urb_detached_irq() - detach an return first urb
++ * Detach and return the first urb in a list with a distinguished
++ * head "hd", or NULL if the list is empty.
++ *
++ * @param hd linked list of urbs
++ * @return pointer to urb or NULL
++ */
++struct usbd_urb *usbd_first_urb_detached_irq (urb_link * hd)
++{
++ struct usbd_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;
++}
++/* @} */
++
++/*!
++ * usbd_first_urb_detached() - detach and return urb
++ *
++ * Detach and return the first urb in a list with a distinguished
++ * head "hd", or NULL if the list is empty.
++ *
++ * @param hd list of urbs
++ * @return pointer to urb or NULL
++ */
++struct usbd_urb *usbd_first_urb_detached (urb_link * hd)
++{
++ struct usbd_urb *urb;
++ unsigned long flags;
++ local_irq_save (flags);
++ urb = usbd_first_urb_detached_irq (hd);
++ local_irq_restore (flags);
++ return urb;
++}
++
++
++/*!
++ * usbd_find_endpoint_index()
++ * @param bus
++ * @param bEndpointAddress
++ * Find the endpoint map index for the specified bEndpointAddress.
++ */
++int usbd_find_endpoint_index(struct usbd_bus_instance *bus, int bEndpointAddress)
++{
++ int i;
++ for (i = 0; i < bus->endpoints; i++)
++ BREAK_IF (bus->endpoint_array[i].bEndpointAddress == bEndpointAddress);
++ return i;
++}
++
++OTG_EXPORT_SYMBOL(usbd_urb_finished);
++OTG_EXPORT_SYMBOL(usbd_urb_finished_irq);
++OTG_EXPORT_SYMBOL(usbd_first_urb_detached);
++OTG_EXPORT_SYMBOL(usbd_first_urb_detached_irq);
++OTG_EXPORT_SYMBOL(usbd_find_endpoint_index);
++
++/* ********************************************************************************************** */
++/* usbb bus bottom half ************************************************************************* */
++
++/*!
++ * usbd_device_bh() - Bottom half handler to process sent or received urbs.
++ * @param data
++ */
++void usbd_device_bh (void *data)
++{
++ struct usbd_bus_instance *bus = data;
++ struct usbd_endpoint_instance *endpoint;
++ struct usbd_urb *urb;
++
++ RETURN_IF (!bus || !(endpoint = bus->endpoint_array));
++ DOWN(&usbd_bus_sem);
++
++ for (; (urb = usbd_first_urb_detached (&bus->finished)); do_urb_callback (urb, urb->status));
++
++ #if defined(OTG_LINUX)
++ if (USBD_CLOSING == bus->status)
++ bus->device_bh.data = NULL;
++ #endif /* defined(OTG_LINUX) */
++ UP(&usbd_bus_sem);
++}
++
++/* ********************************************************************************************** */
++/* Module init ********************************************************************************** */
++
++extern char * usbd_function_name(int n);
++struct usbd_ops usbd_ops;
++otg_tag_t USBD;
++
++/*!
++ * usbd_device_init() - initialize
++ */
++int usbd_device_init (void)
++{
++ USBD = otg_trace_obtain_tag();
++ TRACE_MSG0(USBD,"--");
++ usbd_ops.function_name = usbd_function_name;
++ otg_set_usbd_ops(&usbd_ops);
++ return 0;
++}
++
++/*!
++ * usbd_device_exit() - de-initialize
++ */
++void usbd_device_exit (void)
++{
++ otg_set_usbd_ops(NULL);
++ otg_trace_invalidate_tag(USBD);
++}
++
++
+diff -uNr linux/drivers/no-otg/otgcore/usbp-fops.c linux/drivers/otg/otgcore/usbp-fops.c
+--- linux/drivers/no-otg/otgcore/usbp-fops.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otgcore/usbp-fops.c 2006-09-01 21:41:35.000000000 +0200
+@@ -0,0 +1,1123 @@
++/*
++ * otg/otgcore/usbp-fops.c - USB Function support
++ *
++ * Copyright (c) 2004-2005 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/otgcore/usbp-fops.c
++ * @brief Function driver related functions.
++ *
++ * This implements the functions used to implement USB Function drivers.
++ *
++ * @ingroup USBP
++ */
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#include <otg/usbp-chap9.h>
++#include <otg/otg-trace.h>
++#include <otg/usbp-func.h>
++#include <otg/usbp-bus.h>
++
++
++struct usbd_string_descriptor **usb_strings;
++void urb_append(urb_link *hd, struct usbd_urb *urb);
++
++LIST_NODE_INIT(usbd_function_instances); // list of all registered configuration function modules
++LIST_NODE_INIT(usbd_interface_instances); // list of all registered interface function modules
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++/*!
++ * Function Registration:
++ * usbd_register_function()
++ * usbd_register_interface()
++ * usbd_register_composite()
++ * usbd_deregister_function()
++ * usbd_find_function()
++ * usbd_find_interface()
++ *
++ */
++
++/*!
++ * usbd_register_function_internal() - register a usbd function driver
++ *
++ * USBD Function drivers call this to register with the USBD Core layer.
++ * Return NULL on failure.
++ *
++ * @param function_driver
++ * @param privdata
++ * @return function instance
++ *
++ */
++static struct usbd_function_instance *
++usbd_register_function_internal(struct usbd_function_driver *function_driver, char *name,
++ usbd_function_types_t function_type, char **interface_list, void *privdata)
++{
++ struct usbd_function_instance *function = NULL;
++
++ TRACE_MSG3(USBD, "interface: %s driver: %s endpoints: %d", name,
++ function_driver->name, function_driver->endpointsRequested);
++
++ if (!(function = (struct usbd_function_instance *) CKMALLOC (sizeof (struct usbd_function_instance), GFP_KERNEL))) {
++ #if defined(OTG_LINUX)
++ printk(KERN_ERR,"usbd_function_instance allocation failed.\n");
++ #endif /* defined(OTG_LINUX) */
++ #if defined(OTG_WINCE)
++ DEBUGMSG(ZONE_INIT, (_T("usbd_register_function: FAILED\n")));
++ #endif /* defined(OTG_LINUX) */
++ return(NULL);
++ }
++ function->name = LSTRDUP(name);
++ function->function_driver = function_driver;
++ function->privdata = privdata;
++ function->function_type = function_type;
++ function->interfaces_list = interface_list;
++
++ //function->endpointsRequested = function->function_driver->endpointsRequested;
++ //function->requestedEndpoitns = function->function_driver->requestedEndpoints;
++
++ switch(function_type) {
++ case function_simple:
++ case function_interface:
++ break;
++ case function_composite:
++ break;
++ }
++
++ if (!(function->endpoint_map_array = (struct usbd_endpoint_map *)
++ CKMALLOC (sizeof(struct usbd_endpoint_map) *
++ function_driver->endpointsRequested, GFP_KERNEL))) {
++ #if defined(OTG_LINUX)
++ printk(KERN_ERR,"usbd_endpoint_map allocation failed.\n");
++ #endif /* defined(OTG_LINUX) */
++ #if defined(OTG_WINCE)
++ DEBUGMSG(ZONE_INIT, (_T("usbd_register_function: FAILED\n")));
++ #endif /* defined(OTG_LINUX) */
++ LKFREE(function);
++ return(NULL);
++ }
++
++ switch(function_type) {
++ case function_simple:
++ case function_interface:
++ case function_composite:
++ break;
++ }
++ return function;
++}
++
++/*!
++ * usbd_register_function() - register a usbd function driver
++ *
++ * USBD Function drivers call this to register with the USBD Core layer.
++ * Return NULL on failure.
++ *
++ * @param function_driver
++ * @param privdata
++ * @return function instance
++ *
++ */
++struct usbd_function_instance *
++usbd_register_function (struct usbd_function_driver *function_driver, char * name, void *privdata)
++{
++ struct usbd_function_instance *function =
++ usbd_register_function_internal(function_driver, name, function_simple, NULL, privdata);
++ TRACE_MSG1(USBD, "%s", name);
++
++ LIST_ADD_TAIL (&function->instances, &usbd_function_instances);
++ return function;
++}
++
++/*!
++ * usbd_register_interface() - register a usbd function driver
++ *
++ * USBD Function drivers call this to register with the USBD Core layer.
++ * Return NULL on failure.
++ *
++ * @param function_driver
++ * @param privdata
++ * @return function instance
++ *
++ */
++struct usbd_function_instance *
++usbd_register_interface(struct usbd_function_driver *function_driver, char * name, void *privdata)
++{
++ struct usbd_function_instance *function =
++ usbd_register_function_internal(function_driver, name, function_interface, NULL, privdata);
++ TRACE_MSG1(USBD, "%s", name);
++ LIST_ADD_TAIL (&function->instances, &usbd_interface_instances);
++ return function;
++}
++
++/*!
++ * usbd_register_composite() - register a usbd function driver
++ *
++ * USBD Function drivers call this to register with the USBD Core layer.
++ * Return NULL on failure.
++ *
++ * @param function_driver
++ * @param privdata
++ * @return function instance
++ *
++ */
++struct usbd_function_instance *
++usbd_register_composite (struct usbd_function_driver *function_driver, char * name, char **interfaces_list, void *privdata)
++{
++ struct usbd_function_instance *function = NULL;
++ struct usbd_function_instance **interfaces_array = NULL;
++ struct usbd_endpoint_request *requestedEndpoints = NULL;
++ struct usbd_endpoint_map *endpoint_map_array = NULL;
++
++ int i, j, k, l;
++ char *interface_name;
++ int endpoints = 0;
++ int cfg_length = 0;
++
++ TRACE_MSG1(USBD, "%s", name);
++ THROW_UNLESS((function = usbd_register_function_internal(function_driver,
++ name, function_composite, interfaces_list, privdata)), error);
++
++ /* list and count interfaces, then allocate interfaces_array.
++ */
++ for (i = 0; (interface_name = function->interfaces_list[i]); i++) {
++ TRACE_MSG2(USBD, "INTERFACE[%02d] %20s", i, interface_name);
++ }
++ function->interfaces = i;
++
++ TRACE_MSG1(USBD, "interfaces: %d", function->interfaces);
++
++ THROW_UNLESS((interfaces_array = (struct usbd_function_instance **)
++ CKMALLOC (sizeof(struct usbd_function_instance) * function->interfaces, GFP_KERNEL)), error);
++ function->interfaces_array = interfaces_array;
++
++#if 0
++ /* Find all interfaces and compose the interface list, count the endpoints
++ * and allocte the endpoint request array. Also find and total descriptor sizes.
++ */
++ for (i = 0; i < function->interfaces; i++) {
++ struct usbd_function_instance *interface_function;
++ struct usbd_interface_description *interface_description = interface_function->interface_list;
++ THROW_UNLESS(interface_function = usbd_find_interface(interfaces_list[i]), error);
++
++ TRACE_MSG4(USBD, "interface_function: %x name: %s driver: %s %d", interface_function,
++ interface_function->name,
++ interface_function->function_driver->name,
++ interface_function->function_driver->endpointsRequested);
++
++ interfaces_array[i] = interface_function;
++ endpoints += interface_function->function_driver->endpointsRequested;
++ TRACE_MSG4(USBD, "ENDPOINT [%02d] %20s %02d %02d",
++ i, interfaces_list[i], interface_function->function_driver->endpointsRequested, endpoints);
++
++ /* iterate across all interface descriptions */
++ for (j = 0; j < bNumInterfaces; j++) {
++ struct usbd_alternate_instance *alternate_instance = interface_description[j];
++
++ /* iterate across all alternates for this interface */
++ for (k = 0; k < interface_description[j].alternates; k++) {
++
++
++
++ }
++ }
++
++ }
++#endif
++ function->endpoints = endpoints;
++ TRACE_MSG2(USBD, "endpoints: %d %d", endpoints, function->endpoints);
++
++
++ /* requeset the endpoints from the bus interface driver
++ */
++ THROW_UNLESS((requestedEndpoints = (struct usbd_endpoint_request *)
++ CKMALLOC (sizeof(struct usbd_endpoint_request) * function->endpoints, GFP_KERNEL)), error);
++
++ function->requestedEndpoints = requestedEndpoints;
++#if 0
++ /* we need to compose the endpoint request array
++ */
++ for (endpoints = 0, i = 0; i < function->interfaces; i++) {
++ struct usbd_function_instance *interface_function = interfaces_array[i];
++ struct usbd_interface_description *interface_description = interface_function->interface_list;
++
++ for (j = 0; j < interface_function->endpoints; j++) {
++ memcpy(&requestedEndpoints[endpoints], &interface_function->requestedEndpoints[j],
++ sizeof(struct usbd_endpoint_request));
++ requestedEndpoints[endpoints].interface_num = i;
++ }
++ }
++#endif
++
++
++ /* Insert into function list
++ */
++ LIST_ADD_TAIL (&function->instances, &usbd_function_instances);
++ return function;
++
++ CATCH(error) {
++ if (requestedEndpoints) LKFREE(requestedEndpoints);
++ if (interfaces_array) LKFREE(interfaces_array);
++ if (function) usbd_deregister_function(function);
++ return NULL;
++ }
++}
++
++/*!
++ * usbd_deregister_function() - de-register a usbd function driver instance
++ *
++ * USBD Function drivers call this to de-register with the USBD Core layer.
++ * @param function_instance
++ */
++void usbd_deregister_function (struct usbd_function_instance *function_instance)
++{
++ RETURN_UNLESS (function_instance);
++ LIST_DEL (function_instance->instances);
++ if (function_instance->name) LKFREE(function_instance->name);
++ if (function_instance->endpoint_map_array) LKFREE(function_instance->endpoint_map_array);
++ LKFREE(function_instance);
++}
++
++/*!
++ * usbd_find_function_internal() - register a usbd function driver
++ *
++ * USBD Function drivers call this to register with the USBD Core layer.
++ * Return NULL on failure.
++ *
++ * @param name
++ * @return function instance
++ *
++ */
++static struct usbd_function_instance *
++usbd_find_function_internal(LIST_NODE *usbd_function_instances, char *name)
++{
++ int len = name ? strlen(name) : 0;
++ LIST_NODE *lhd = NULL;
++ TRACE_MSG1(USBD, "%s", name);
++ LIST_FOR_EACH (lhd, usbd_function_instances) {
++
++ struct usbd_function_instance *function = LIST_ENTRY (lhd, struct usbd_function_instance, instances);
++ struct usbd_function_driver *function_driver;
++ function_driver = function->function_driver;
++ printk(KERN_ERR"%s: name: %s len: %d function: %s\n", __FUNCTION__, name ? name : "", len, function_driver->name);
++ CONTINUE_IF(len || strncmp(function_driver->name, name, len));
++
++ TRACE_MSG5(USBD, "%s %s %d %s %d", name, function->name, len,
++ function->function_driver->name,
++ function->function_driver->endpointsRequested);
++ CONTINUE_IF(len && strncmp(function->name, name, len));
++
++ TRACE_MSG4(USBD, "FOUND %s %x %s %d", name, function,
++ function->function_driver->name,
++ function->function_driver->endpointsRequested);
++
++ return function;
++
++ //struct usbd_function_driver *function_driver = function->function_driver;
++ //printk(KERN_ERR"%s: name: %s len: %d function: %s\n", __FUNCTION__,name?name : "", len, function_driver->name);
++ //CONTINUE_IF(len || strncmp(function_driver->name, name, len));
++ }
++ return NULL;
++}
++
++
++/*!
++ * usbd_find_function() - register a usbd function driver
++ *
++ * USBD Function drivers call this to register with the USBD Core layer.
++ * Return NULL on failure.
++ *
++ * @param name
++ * @return function instance
++ *
++ */
++struct usbd_function_instance *
++usbd_find_function (char *name)
++{
++ return usbd_find_function_internal(&usbd_function_instances, name);
++}
++
++/*!
++ * usbd_default_function() - register a usbd function driver
++ *
++ * USBD Function drivers call this to register with the USBD Core layer.
++ * Return NULL on failure.
++ *
++ * @param name
++ * @return function instance
++ *
++ */
++struct usbd_function_instance *
++usbd_default_function (char *name)
++{
++ return usbd_find_function_internal(&usbd_function_instances, "");
++}
++
++/*!
++ * usbd_find_interface() - register a usbd function driver
++ *
++ * USBD Function drivers call this to register with the USBD Core layer.
++ * Return NULL on failure.
++ *
++ * @param name
++ * @return function instance
++ *
++ */
++struct usbd_function_instance *usbd_find_interface(char *name)
++{
++ TRACE_MSG1(USBD, "%s", name);
++ return usbd_find_function_internal(&usbd_interface_instances, name);
++}
++
++
++/*!
++ * usbd_function_name() - return name of nth function driver
++ * @param n index to function name
++ */
++char * usbd_function_name(int n)
++{
++ struct usbd_function_instance *function = NULL;
++ LIST_NODE *lhd = NULL;
++
++ LIST_FOR_EACH (lhd, &usbd_function_instances) {
++ struct usbd_function_driver *function_driver;
++ function = LIST_ENTRY (lhd, struct usbd_function_instance, instances);
++ function_driver = function->function_driver;
++
++ TRACE_MSG2(USBD, "name: [%d] %s", n, function_driver->name);
++
++ CONTINUE_IF(n--);
++ return (char *)function_driver->name;
++ };
++ return NULL;
++}
++
++OTG_EXPORT_SYMBOL(usbd_register_function);
++OTG_EXPORT_SYMBOL(usbd_register_interface);
++OTG_EXPORT_SYMBOL(usbd_register_composite);
++OTG_EXPORT_SYMBOL(usbd_deregister_function);
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++/*!
++ * String Descriptors:
++ * usbd_alloc_string_descriptor()
++ * usbd_free_string_descriptor()
++ * usbd_get_string_descriptor()
++ */
++
++#define LANGID_ENGLISH "\011"
++#define LANGID_US_ENGLISH "\004"
++#define LANGIDs LANGID_US_ENGLISH LANGID_ENGLISH
++
++/*!
++ * 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.
++ *
++ * @param str string to allocate
++ * @return the slot number
++ */
++static u8 usbd_alloc_string_zero (char *str)
++{
++ u8 bLength;
++ u16 *wData;
++ struct usbd_string_descriptor *string = NULL;
++
++ RETURN_ZERO_IF(usb_strings[0] != NULL);
++
++ bLength = sizeof (struct usbd_string_descriptor) + strlen (str);
++
++ RETURN_ZERO_IF(!(string = (struct usbd_string_descriptor *) CKMALLOC (bLength, GFP_KERNEL)));
++
++ string->bLength = bLength; // set descriptor length
++ string->bDescriptorType = USB_DT_STRING; // set descriptor type
++
++ for (wData = string->wData; *str; str += 2, wData++) // copy
++ *wData = (u16) ((str[0] << 8 | str[1]));
++
++ usb_strings[0] = string; // save in string index array
++ return 0;
++}
++
++int usbd_maxstrings = 40;
++
++/*!
++ * usbd_strings_init() - initialize usb strings pool
++ */
++int usbd_strings_init (void)
++{
++ //TRACE_MSG0(USBD, "entered");
++ RETURN_ZERO_IF(usb_strings);
++ usbd_maxstrings = MIN(usbd_maxstrings, 254);
++
++ RETURN_EINVAL_IF (!(usb_strings = CKMALLOC (sizeof (struct usbd_string_descriptor *) * usbd_maxstrings, GFP_KERNEL)));
++ if (usbd_alloc_string_zero (LANGIDs) != 0) {
++ LKFREE (usb_strings);
++ return -1;
++ }
++ return 0;
++}
++
++/*!
++ * usbd_strings_exit() - de-initialize usb strings pool
++ */
++void usbd_strings_exit(void)
++{
++ int i;
++ //TRACE_MSG0(USBD, "entered");
++ RETURN_IF (!usb_strings);
++ for (i = 0; i < usbd_maxstrings; i++)
++ usbd_free_string_descriptor((u8)i);
++ LKFREE (usb_strings);
++ usb_strings = NULL;
++}
++
++
++/*!
++ * usbd_get_string_descriptor() - find and return a string descriptor
++ *
++ * Find an indexed string and return a pointer to a it.
++ * @param index of string
++ * @return pointer to string descriptor or NULL
++ */
++struct usbd_string_descriptor *usbd_get_string_descriptor (u8 index)
++{
++ RETURN_NULL_IF (index >= usbd_maxstrings);
++ return usb_strings[index];
++}
++
++/*!
++ * usbd_realloc_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.
++ * @param index
++ * @param str
++ * @return new index
++ */
++u8 usbd_realloc_string (u8 index, char *str)
++{
++ struct usbd_string_descriptor *string;
++ u8 bLength;
++ u16 *wData;
++
++ RETURN_ZERO_IF(!str || !strlen (str));
++ //TRACE_MSG2(USBD, "index: %d str: %s", index, str);
++
++ // XXX should have semaphores...
++
++ if ((index < usbd_maxstrings) && (string = usb_strings[index])) {
++ usb_strings[index] = NULL;
++ LKFREE (string);
++ }
++
++ bLength = sizeof (struct usbd_string_descriptor) + 2 * strlen (str);
++
++ RETURN_ZERO_IF(!(string = (struct usbd_string_descriptor *)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[index] = string;
++ return 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.
++ * @param str
++ * @return index
++ *
++ * XXX rename to usbd_alloc_string_descriptor
++ */
++u8 usbd_alloc_string (char *str)
++{
++ int i;
++ struct usbd_string_descriptor *string = NULL;
++ u8 bLength;
++ u16 *wData;
++
++ RETURN_ZERO_IF(!str || !strlen (str));
++
++ // find an empty string descriptor slot
++ for (i = 1; i < usbd_maxstrings; i++) {
++
++ CONTINUE_IF (usb_strings[i] != NULL);
++
++ bLength = sizeof (struct usbd_string_descriptor) + 2 * strlen (str);
++
++ RETURN_ZERO_IF(!(string = (struct usbd_string_descriptor *)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_free_string_descriptor() - deallocate a string descriptor
++ *
++ * Find and remove an allocated string.
++ * @param index
++ *
++ */
++void usbd_free_string_descriptor (u8 index)
++{
++ struct usbd_string_descriptor *string;
++
++ if ((index < usbd_maxstrings) && (string = usb_strings[index])) {
++ usb_strings[index] = NULL;
++ LKFREE (string);
++ }
++}
++
++OTG_EXPORT_SYMBOL(usbd_realloc_string);
++OTG_EXPORT_SYMBOL(usbd_alloc_string);
++OTG_EXPORT_SYMBOL(usbd_free_string_descriptor);
++OTG_EXPORT_SYMBOL(usbd_get_string_descriptor);
++OTG_EXPORT_SYMBOL(usbd_maxstrings);
++
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++/*!
++ * Device Information:
++ * usbd_high_speed()
++ * usbd_get_bMaxPower()
++ * usbd_endpoint_wMaxPacketsize()
++ * usbd_endpoint_wMaxPacketsize_ep0()
++ * usbd_endpoint_bEndpointAddress()
++ *
++ */
++
++
++/*!
++ * usbd_high_speed() - return high speed status
++ * @return true if operating at high speed
++ */
++int usbd_high_speed(struct usbd_function_instance *function)
++{
++ // XXX TODO - per function modifications for composite devices
++ return function->bus->HighSpeedFlag ? 1 : 0;
++}
++
++/*!
++ * usbd_get_bMaxPower() - process a received urb
++ *
++ * Used by a USB Bus interface driver to pass received device request to
++ * the appropriate USB Function driver.
++ *
++ * @param function
++ * @param request
++ * @return non-zero if errror
++ */
++int usbd_get_bMaxPower(struct usbd_function_instance *function)
++{
++ struct usbd_bus_instance *bus = function->bus;
++ return bus->driver->bMaxPower;
++}
++
++
++/*!
++ * usbd_endpoint_wMaxPacketSize() - get maximum packet size for endpoint
++ * @param function
++ * @param endpoint_index
++ * @param hs highspeed flag
++ * @return endpoint size
++ */
++int usbd_endpoint_wMaxPacketSize(struct usbd_function_instance *function, int endpoint_index, int hs)
++{
++ struct usbd_endpoint_map *endpoint_map;
++ RETURN_ZERO_IF(!(endpoint_map = function->endpoint_map_array));
++ return le16_to_cpu(endpoint_map[endpoint_index].wMaxPacketSize[hs]);
++}
++
++/*!
++ * usbd_endpoint_zero_wMaxPacketSize() - get maximum packet size for endpoint zero
++ * @param function
++ * @param hs highspeed flag
++ * @return endpoint size
++ */
++int usbd_endpoint_zero_wMaxPacketSize(struct usbd_function_instance *function, int hs)
++{
++ struct usbd_endpoint_map *endpoint_map;
++ RETURN_ZERO_IF(!(endpoint_map = function->bus->ep0->endpoint_map_array));
++ return le16_to_cpu(endpoint_map[0].wMaxPacketSize[hs]);
++}
++
++/*!
++ * usbd_endpoint_bEndpointAddress() - get endpoint addrsess
++ * @param function
++ * @param endpoint_index
++ * @param hs high speed flag
++ * @return endpoint address
++ */
++int usbd_endpoint_bEndpointAddress(struct usbd_function_instance *function, int endpoint_index, int hs)
++{
++ struct usbd_endpoint_map *endpoint_map;
++ RETURN_ZERO_IF(!(endpoint_map = function->endpoint_map_array));
++ return endpoint_map[endpoint_index].bEndpointAddress[hs];
++}
++
++OTG_EXPORT_SYMBOL(usbd_endpoint_wMaxPacketSize);
++OTG_EXPORT_SYMBOL(usbd_endpoint_zero_wMaxPacketSize);
++OTG_EXPORT_SYMBOL(usbd_endpoint_bEndpointAddress);
++OTG_EXPORT_SYMBOL(usbd_high_speed);
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++/*!
++ * Device Control:
++ *
++ * XXX usbd_request_endpoints()
++ * XXX usbd_configure_endpoints()
++ *
++ * usbd_get_device_state()
++ * usbd_get_device_status()
++ * usbd_framenum()
++ * usbd_ticks()
++ * usbd_elapsed()
++ */
++
++/*!
++ * usbd_flush_endpoint_irq() - flush urbs from endpoint
++ *
++ * Iterate across the approrpiate tx or rcv list and cancel any outstanding urbs.
++ *
++ * @param endpoint flush urbs on this endpoint
++ */
++void usbd_flush_endpoint_irq (struct usbd_endpoint_instance *endpoint)
++{
++ struct usbd_urb *urb;
++
++ if (endpoint->bEndpointAddress)
++ TRACE_MSG1(USBD, "bEndpointAddress: %02x", endpoint->bEndpointAddress);
++
++ if ((urb = endpoint->tx_urb))
++ usbd_cancel_urb(urb);
++
++ for (; (urb = usbd_first_urb_detached_irq (&endpoint->tx)); usbd_cancel_urb(urb));
++
++ if ((urb = endpoint->rcv_urb))
++ usbd_cancel_urb(urb);
++
++ for (; (urb = usbd_first_urb_detached_irq (&endpoint->rdy)); usbd_cancel_urb(urb));
++}
++
++/*!
++ * usbd_flush_endpoint() - flush urbs from endpoint
++ *
++ * Iterate across the approrpiate tx or rcv list and cancel any outstanding urbs.
++ *
++ * @param endpoint flush urbs on this endpoint
++ */
++void usbd_flush_endpoint (struct usbd_endpoint_instance *endpoint)
++{
++ unsigned long flags;
++ local_irq_save (flags);
++ usbd_flush_endpoint_irq(endpoint);
++ local_irq_restore (flags);
++}
++
++/*!
++ * usbd_flush_endpoint_address() - flush endpoint
++ * @param function
++ * @param endpoint_index
++ */
++void usbd_flush_endpoint_index (struct usbd_function_instance *function, int endpoint_index)
++{
++ struct usbd_endpoint_map *endpoint_map;
++ struct usbd_endpoint_instance *endpoint;
++
++ RETURN_IF(!function);
++ RETURN_IF(!(endpoint_map = function->endpoint_map_array));
++ RETURN_IF(!(endpoint = endpoint_map[endpoint_index].endpoint));
++ usbd_flush_endpoint (endpoint);
++}
++
++/*!
++ * usbd_get_device_state() - return device state
++ * @param function
++ * @return current device state
++ */
++usbd_device_state_t usbd_get_device_state(struct usbd_function_instance *function)
++{
++ //TRACE_MSG1(USBD, "%d", function->bus->device_state);
++ return (function && function->bus) ? function->bus->device_state : STATE_UNKNOWN;
++}
++
++/*!
++ * usbd_get_device_status() - return device status
++ * @param function
++ * @return current device status
++ */
++usbd_device_status_t usbd_get_device_status(struct usbd_function_instance *function)
++{
++ //TRACE_MSG1(USBD, "%d", function->bus->status);
++ return (function && function->bus) ? function->bus->status : USBD_UNKNOWN;
++}
++
++/*!
++ * usbd_framenum() - return framenum
++ * @param function
++ * @return current framenum
++ */
++int usbd_framenum(struct usbd_function_instance * function)
++{
++ RETURN_ZERO_UNLESS(function);
++ RETURN_ZERO_UNLESS(function->bus->driver->bops->framenum);
++ return function->bus->driver->bops->framenum ();
++}
++
++/*!
++ * usbd_ticks() - return ticks
++ * @param function
++ * @return current ticks
++ */
++u64 usbd_ticks(struct usbd_function_instance *function)
++{
++ RETURN_ZERO_UNLESS(function);
++ RETURN_ZERO_UNLESS(function->bus->driver->bops->ticks);
++ return function->bus->driver->bops->ticks ();
++}
++
++/*!
++ * usbd_elapsed() - return elapsed
++ * @param function
++ * @param t1
++ * @param t2
++ * @return elapsed uSecs between t1 and t2
++ */
++u64 usbd_elapsed(struct usbd_function_instance *function, u64 *t1, u64 *t2)
++{
++ RETURN_ZERO_UNLESS(function);
++ RETURN_ZERO_UNLESS(function->bus->driver->bops->elapsed);
++ return function->bus->driver->bops->elapsed (t1, t2);
++}
++
++
++//OTG_EXPORT_SYMBOL(usbd_set_endpoint_halt);
++//OTG_EXPORT_SYMBOL(usbd_endpoint_halted);
++OTG_EXPORT_SYMBOL(usbd_get_device_state);
++OTG_EXPORT_SYMBOL(usbd_get_device_status);
++OTG_EXPORT_SYMBOL(usbd_framenum);
++OTG_EXPORT_SYMBOL(usbd_ticks);
++OTG_EXPORT_SYMBOL(usbd_elapsed);
++OTG_EXPORT_SYMBOL(usbd_flush_endpoint);
++OTG_EXPORT_SYMBOL(usbd_flush_endpoint_index);
++
++/* ********************************************************************************************* */
++/* ********************************************************************************************* */
++/*!
++ * Endpoint I/O:
++ * usbd_alloc_urb()
++ * usbd_start_in_urb()
++ * usbd_start_out_urb()
++ * usbd_cancel_urb()
++ *
++ */
++
++/*!
++ * 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.
++ *
++ * @param function
++ * @param endpoint_index
++ * @param length
++ * @param callback
++ * @return urb
++ */
++struct usbd_urb *usbd_alloc_urb (struct usbd_function_instance *function, int endpoint_index,
++ int length, int (*callback) (struct usbd_urb *, int))
++{
++ struct usbd_urb *urb = NULL;
++ struct usbd_endpoint_map *endpoint_map;
++ struct usbd_endpoint_instance *endpoint;
++ unsigned long flags;
++
++ 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 = (struct usbd_urb *)CKMALLOC (sizeof (struct usbd_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 0
++ 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
++ #endif
++ THROW_IF(!(urb->buffer = (u8 *)CKMALLOC (length, GFP_ATOMIC)), error);
++
++ }
++
++ CATCH(error) {
++ #if defined(OTG_LINUX)
++ printk(KERN_ERR"%s: dealloc %p\n", __FUNCTION__, urb);
++ #endif /* defined(OTG_LINUX) */
++ #if defined(OTG_WINCE)
++ DEBUGMSG(ZONE_INIT, (_T("usbd_alloc_urb: FAILED\n")));
++ #endif /* defined(OTG_LINUX) */
++ usbd_free_urb(urb);
++ urb = NULL;
++ }
++ local_irq_restore(flags);
++ return urb;
++}
++
++/*!
++ * usbd_halt_endpoint() -
++ *
++ * @param function function that owns endpoint
++ * @param endpoint endpoint number
++ * @return non-zero if endpoint is halted.
++ */
++int usbd_halt_endpoint (struct usbd_function_instance *function, int endpoint_index)
++{
++ struct usbd_endpoint_map *endpoint_map;
++ struct usbd_endpoint_instance *endpoint;
++
++ RETURN_ZERO_IF(!(endpoint_map = function->endpoint_map_array));
++ RETURN_ZERO_IF(!(endpoint = endpoint_map[endpoint_index].endpoint));
++
++ return function->bus->driver->bops->halt_endpoint (function->bus, endpoint->bEndpointAddress, endpoint_index, 1);
++}
++
++
++/*!
++ * usbd_alloc_urb_ep0() - allocate an urb for endpoint zero
++ * @param function
++ * @param length
++ * @param callback
++ * @return urb
++ */
++struct usbd_urb *usbd_alloc_urb_ep0 (struct usbd_function_instance *function, int length,
++ int (*callback) (struct usbd_urb *, int))
++{
++ return usbd_alloc_urb(function->bus->ep0, 0, length, callback);
++}
++
++/*!
++ * usbd_free_urb() - deallocate an URB and associated buffer
++ *
++ * Deallocate an urb structure and associated data.
++ * @param urb
++ */
++void usbd_free_urb (struct usbd_urb *urb)
++{
++ RETURN_IF (!urb);
++ if (urb->buffer) {
++ #if 0
++ if (urb->function_instance && urb->function_instance->function_driver->fops->dealloc_urb_data)
++ urb->function_instance->function_driver->fops->dealloc_urb_data ((void *) urb->buffer);
++ else
++ #endif
++ LKFREE ((void *) urb->buffer);
++ }
++ LKFREE (urb);
++}
++
++
++/*!
++ * usbd_start_in_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.
++ *
++ * @param urb to send
++ * @return non-zero if error
++ */
++int usbd_start_in_urb (struct usbd_urb *urb)
++{
++ RETURN_EINVAL_IF (urb->endpoint->bEndpointAddress && (USBD_OK != urb->bus->status));
++ if (urb->endpoint->feature_setting & FEATURE(USB_ENDPOINT_HALT)) {
++ usbd_urb_finished(urb, SEND_STALLED);
++ return 0;
++ }
++ urb->status = SEND_IN_QUEUE;
++ #if defined(OTG_LINUX)
++ urb->jiffies = jiffies;
++ #endif /* defined(OTG_LINUX) */
++ urb_append (&(urb->endpoint->tx), urb);
++ return urb->bus->driver->bops->start_endpoint_in(urb->bus, urb->endpoint);
++}
++
++/*!
++ * usbd_start_out_urb() - recycle a received urb
++ *
++ * Used by a USB Function interface driver to recycle an urb.
++ *
++ * @param urb to process
++ * @return non-zero if error
++ */
++int usbd_start_out_urb (struct usbd_urb *urb)
++{
++ RETURN_EINVAL_IF (urb->endpoint->bEndpointAddress && (USBD_OK != urb->bus->status));
++ if (urb->endpoint->feature_setting & FEATURE(USB_ENDPOINT_HALT)) {
++ usbd_urb_finished(urb, RECV_STALLED);
++ return 0;
++ }
++ urb->actual_length = 0;
++ urb->status = RECV_IN_QUEUE;
++ #if defined(OTG_LINUX)
++ urb->jiffies = jiffies;
++ #endif /* defined(OTG_LINUX) */
++ urb_append (&(urb->endpoint->rdy), urb);
++ return urb->bus->driver->bops->start_endpoint_out(urb->bus, urb->endpoint);
++}
++
++/*!
++ * usbd_cancel_urb() - cancel an urb being sent
++ *
++ * @param urb to process
++ * @return non-zero if error
++ */
++int usbd_cancel_urb (struct usbd_urb *urb)
++{
++ //TRACE_MSG0(USBD, "entered");
++ return urb->bus->driver->bops->cancel_urb_irq (urb);
++}
++
++
++/*!
++ * usbd_endpoint_halted() - return halt status
++ *
++ * @param function function that owns endpoint
++ * @param endpoint endpoint number
++ * @return non-zero if endpoint is halted.
++ */
++int usbd_endpoint_halted (struct usbd_function_instance *function, int endpoint_index)
++{
++ struct usbd_endpoint_instance *endpoint;
++ struct usbd_endpoint_map *endpoint_map;
++ //TRACE_MSG0(USBD, "entered");
++ //
++ RETURN_ZERO_UNLESS((endpoint_map = function->endpoint_map_array));
++ RETURN_ZERO_UNLESS((endpoint = endpoint_map[endpoint_index].endpoint));
++ return function->bus->driver->bops->endpoint_halted (function->bus, endpoint->bEndpointAddress, endpoint_index);
++}
++
++
++OTG_EXPORT_SYMBOL(usbd_alloc_urb);
++OTG_EXPORT_SYMBOL(usbd_alloc_urb_ep0);
++OTG_EXPORT_SYMBOL(usbd_free_urb);
++
++OTG_EXPORT_SYMBOL(usbd_start_in_urb);
++OTG_EXPORT_SYMBOL(usbd_start_out_urb);
++OTG_EXPORT_SYMBOL(usbd_cancel_urb);
++OTG_EXPORT_SYMBOL(usbd_halt_endpoint);
++
++/* ********************************************************************************************* */
++
++/*!
++ * usbd_function_get_privdata() - get private data pointer
++ * @param function
++ * @return void * pointer to private data
++ */
++void *usbd_function_get_privdata(struct usbd_function_instance *function)
++{
++ return(function->privdata);
++}
++
++/*!
++ * usbd_function_set_privdata() - set private data structure in function
++ * @param function
++ * @param privdata
++ */
++void usbd_function_set_privdata(struct usbd_function_instance *function, void *privdata)
++{
++ function->privdata = privdata;
++}
++
++
++
++
++/*!
++ * usbd_endpoint_transferSize() - get transferSize for endpoint
++ * @param function
++ * @param endpoint_index
++ * @param hs highspeed flag
++ * @return transfer size
++ */
++int usbd_endpoint_transferSize(struct usbd_function_instance *function, int endpoint_index, int hs)
++{
++ struct usbd_endpoint_map *endpoint_map;
++ RETURN_ZERO_IF(!(endpoint_map = function->endpoint_map_array));
++ return endpoint_map[endpoint_index].transferSize[hs];
++}
++
++/*!
++ * usbd_endpoint_update() - update endpoint address and size
++ * @param function
++ * @param endpoint_index
++ * @param endpoint descriptor
++ * @param hs high speed flag
++ */
++void usbd_endpoint_update(struct usbd_function_instance *function, int endpoint_index,
++ struct usbd_endpoint_descriptor *endpoint, int hs)
++{
++ endpoint->bEndpointAddress = usbd_endpoint_bEndpointAddress(function, endpoint_index, hs);
++ endpoint->wMaxPacketSize = usbd_endpoint_wMaxPacketSize(function, endpoint_index, hs);
++}
++
++/*!
++ * usbd_otg_bmattributes() - return attributes
++ * @param function
++ * @return endpoint attributes
++ */
++int usbd_otg_bmattributes(struct usbd_function_instance *function)
++{
++ // XXX TODO - per function modifications for composite devices
++ return function->bus->otg_bmAttributes;
++}
++
++OTG_EXPORT_SYMBOL(usbd_function_get_privdata);
++OTG_EXPORT_SYMBOL(usbd_function_set_privdata);
++OTG_EXPORT_SYMBOL(usbd_endpoint_transferSize);
++OTG_EXPORT_SYMBOL(usbd_otg_bmattributes);
++OTG_EXPORT_SYMBOL(usbd_endpoint_update);
+diff -uNr linux/drivers/no-otg/otgcore/usbp-procfs.c linux/drivers/otg/otgcore/usbp-procfs.c
+--- linux/drivers/no-otg/otgcore/usbp-procfs.c 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otgcore/usbp-procfs.c 2006-09-01 21:41:35.000000000 +0200
+@@ -0,0 +1,302 @@
++/*
++ * otg/otgcore/usbp-procfs.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>
++ *
++ */
++/*!
++ * @file otg/otgcore/usbp-procfs.c
++ * @brief Implements /proc/usbd-functions, which displays descriptors for the current selected function.
++ *
++ *
++ * @ingroup USBP
++ */
++
++#include <otg/otg-compat.h>
++#include <otg/otg-module.h>
++
++#ifdef LINUX24
++EXPORT_NO_SYMBOLS;
++#endif
++
++
++MOD_AUTHOR ("sl@belcarra.com, tbr@belcarra.com");
++MOD_DESCRIPTION ("USB Device Core Support Procfs");
++EMBED_LICENSE();
++
++#include <otg/usbp-chap9.h>
++#include <otg/usbp-func.h>
++#include <otg/usbp-bus.h>
++
++EMBED_USBD_INFO ("usbdprocfs 2.0-beta");
++
++#define MAX_INTERFACES 2
++
++extern struct usbd_bus_instance *usbd_bus_instance;
++
++/* 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;
++ int len = 0;
++
++ RETURN_ZERO_UNLESS(sp);
++
++ num = *sp;
++
++ //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 usbd_configuration_descriptor *config = (struct usbd_configuration_descriptor *) sp;
++
++ int wTotalLength = le16_to_cpu(config->wTotalLength);
++ int bConfigurationValue = config->bConfigurationValue;
++ int interface_num;
++ int class_num;
++ int endpoint_num;
++ int total;
++
++ interface_num = class_num = endpoint_num = 0;
++
++ for (total = 0; wTotalLength > 0; ) {
++ //printk(KERN_INFO"%s: wTotalLength: %d total: %d bLength: %d type: %d\n",
++ // __FUNCTION__, wTotalLength, total, sp[0], sp[1]);
++ BREAK_UNLESS(sp[0]);
++ switch (sp[1]) {
++ case USB_DT_CONFIGURATION:
++ interface_num = class_num = endpoint_num = 0;
++ total += sprintf(buf + total, "\nConfiguration descriptor [%d ] ",
++ bConfigurationValue);
++ break;
++ case USB_DT_INTERFACE:
++ class_num = 0;
++ total += sprintf(buf + total, "\nInterface descriptor [%d:%d:%d ] ",
++ bConfigurationValue, ++interface_num, class_num);
++ break;
++ case USB_DT_ENDPOINT:
++ class_num = endpoint_num = 0;
++ total += sprintf(buf + total, "Endpoint descriptor [%d:%d:%d:%d] ",
++ bConfigurationValue, interface_num, class_num, ++endpoint_num);
++ break;
++ case USB_DT_OTG:
++ class_num = endpoint_num = 0;
++ total += sprintf(buf + total, "OTG descriptor [%d ] ", bConfigurationValue);
++ break;
++ default:
++ endpoint_num = 0;
++ total += sprintf(buf + total, "Class descriptor [%d:%d:%d ] ",
++ bConfigurationValue, interface_num, ++class_num);
++ 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.
++ * @param file
++ * @param buf
++ * @param count
++ * @param 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))) {
++
++ if (!(page = GET_KERNEL_PAGE())) {
++ 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 usbd_function_instance *function_instance = usbd_bus_instance->function_instance;
++ struct usbd_function_driver *function_driver = function_instance->function_driver;
++ struct usbd_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_OTG_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_old_get_descriptor(usbd_bus_instance->ep0, config_descriptor,
++ sizeof(config_descriptor),
++ USB_DT_CONFIGURATION, 0)) > index) {
++ len += dump_config_descriptor((char *)page + len, config_descriptor );
++ }
++#ifdef CONFIG_OTG_HIGH_SPEED
++ if ((config_size = usbd_old_get_descriptor(usbd_bus_instance->ep0, config_descriptor,
++ sizeof(config_descriptor),
++ USB_DT_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 usbd_string_descriptor *string_descriptor;
++
++ //len += sprintf ((char *) page + len, "\n\n");
++
++ if ((string_descriptor = usbd_get_string_descriptor (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_descriptor (i)) != NULL) {
++
++ len += sprintf((char *)page+len, "String [%2d:%2d] ",
++ i, string_descriptor->bLength);
++
++ // bLength = sizeof(struct usbd_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;
++}
++
++/* Module init ******************************************************************************* */
++#if defined(OTG_WINCE)
++
++#else /* defined(OTG_WINCE) */
++
++static struct file_operations usbd_device_proc_operations_functions = {
++ read:usbd_device_proc_read_functions,
++};
++
++static int usbd_procfs_init (void)
++{
++ 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;
++ return 0;
++}
++
++static void usbd_procfs_exit (void)
++{
++ // remove proc filesystem entry
++ remove_proc_entry ("usb-functions", NULL);
++}
++
++module_init (usbd_procfs_init);
++module_exit (usbd_procfs_exit);
++
++#endif /* defined(OTG_WINCE) */
++
+diff -uNr linux/drivers/no-otg/otghw/atlas-hardware.h linux/drivers/otg/otghw/atlas-hardware.h
+--- linux/drivers/no-otg/otghw/atlas-hardware.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otghw/atlas-hardware.h 2006-09-01 21:41:35.000000000 +0200
+@@ -0,0 +1,59 @@
++/*
++ * otg/include/atlas-hardware.h -- Atlas Transceiver hardware specific defines
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @defgroup ATLAS
++ * @ingroup tcdgroup
++ */
++/*!
++ * @file otghw/atlas-hardware.h
++ * @brief Hardware defines for Freescale USBOTG Hardware
++ *
++ * @ingroup ATLAS
++ */
++
++/* References are to:
++ *
++ * Atlas DTS 0.7 - 04/02/27
++ */
++
++/*
++ * SPI Register Summary
++ */
++
++#define ATLAS_FSENB (1 << 0)
++#define ATLAS_USB_SUSPEND (1 << 1)
++#define ATLAS_USB_PU (1 << 2)
++#define ATLAS_UDP_PD (1 << 3)
++#define ATLAS_UDM_PD (1 << 4)
++#define ATLAS_PULLOVR (1 << 5)
++#define ATLAS_VUSB_EN (1 << 6)
++#define ATLAS_USB_PS (1 << 7)
++#define ATLAS_VBUS_REG_EN (1 << 8)
++#define ATLAS_VBUS_PD_ENB (1 << 9)
++#define ATLAS_CURRLIM (1 << 10)
++#define ATLAS_SE0_CONN (1 << 11)
++#define ATLAS_DLP_SRP (1 << 12)
++#define ATLAS_USB_XCVR_EN (1 << 13)
++#define ATLAS_VBUS_REG_LVL (1 << 14)
++
++#define ATLAS_DATA_MODE_MASK (3 << 15)
++#define ATLAS_DATA_MODE_USE (0 << 15)
++#define ATLAS_DATA_MODE_BSE (1 << 15)
++#define ATLAS_DATA_MODE_DM (2 << 15)
++#define ATLAS_DATA_MODE_NU (3 << 15)
++
++#define ATLAS_RS232ENB (1 << 17)
++#define ATLAS_ID_INTERRUPT (1 << 20)
++#define ATLAS_AUDIO_EN (1 << 21)
++#define ATLAS_STEREO_EN (1 << 22)
++
++
+diff -uNr linux/drivers/no-otg/otghw/bvd-hardware.h linux/drivers/otg/otghw/bvd-hardware.h
+--- linux/drivers/no-otg/otghw/bvd-hardware.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otghw/bvd-hardware.h 2006-09-01 21:41:35.000000000 +0200
+@@ -0,0 +1,601 @@
++/*
++ * otg/otghw/bvd-hardware.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ *
++ * TODO
++ *
++ * 1. see if using UDCCSR0_ACM/AREN will help
++ *
++ */
++/*!
++ * @file otghw/bvd-hardware.h
++ * @brief Hardware defines for Intel PXA-270 Hardware
++ *
++ * @ingroup BVD
++ */
++
++
++#ifndef UDCOTGICR
++#define UDCOTGICR __REG(0x40600018) /* UDC On-The-Go interrupt control */
++#endif
++
++#ifndef UDCOTGISR
++#define UDCOTGISR __REG(0x4060001c)
++
++#define UDCOTGISR_IRSF (1 << 24) /* OTG SET_FEATURE command recvd */
++#define UDCOTGISR_IRXR (1 << 17) /* Extra Transciever Interrupt Rising Edge Interrupt Enable */
++#define UDCOTGISR_IRXF (1 << 16) /* Extra Transciever Interrupt Falling Edge Interrupt Enable */
++#define UDCOTGISR_IRVV40R (1 << 9) /* OTG Vbus Valid 4.0V Rising Edge Interrupt Enable */
++#define UDCOTGISR_IRVV40F (1 << 8) /* OTG Vbus Valid 4.0V Falling Edge Interrupt Enable */
++#define UDCOTGISR_IRVV44R (1 << 7) /* OTG Vbus Valid 4.4V Rising Edge Interrupt Enable */
++#define UDCOTGISR_IRVV44F (1 << 6) /* OTG Vbus Valid 4.4V Falling Edge Interrupt Enable */
++#define UDCOTGISR_IRSVR (1 << 5) /* OTG Session Valid Rising Edge Interrupt Enable */
++#define UDCOTGISR_IRSVF (1 << 4) /* OTG Session Valid Falling Edge Interrupt Enable */
++#define UDCOTGISR_IRSDR (1 << 3) /* OTG A-Device SRP Detect Rising Edge Interrupt Enable */
++#define UDCOTGISR_IRSDF (1 << 2) /* OTG A-Device SRP Detect Falling Edge Interrupt Enable */
++#define UDCOTGISR_IRIDR (1 << 1) /* OTG ID Change Rising Edge Interrupt Enable */
++#define UDCOTGISR_IRIDF (1 << 0) /* OTG ID Change Falling Edge */
++
++
++#endif
++
++
++#ifndef UP2OCR
++#define UP2OCR __REG(0x40600020)
++
++#define UP2OCR_SEOS_OFF (0x00 << 24)
++#define UP2OCR_SEOS_DSEO (0x02 << 24)
++#define UP2OCR_SEOS_HSEO (0x03 << 24)
++#define UP2OCR_SEOS_DEXT (0x04 << 24)
++#define UP2OCR_SEOS_HEXT (0x05 << 24)
++#define UP2OCR_SEOS_DINT (0x06 << 24)
++#define UP2OCR_SEOS_HINT (0x07 << 24)
++
++#define UP2OCR_HXOE (0x1 << 17)
++#define UP2OCR_HXS (0x1 << 16)
++
++#define UP2OCR_IDON (0x1 << 10)
++#define UP2OCR_EXSUS (0x1 << 9)
++#define UP2OCR_EXSP (0x1 << 8)
++#define UP2OCR_DMPUBE (0x1 << 7)
++#define UP2OCR_DPPUBE (0x1 << 6)
++#define UP2OCR_DMPUE (0x1 << 5)
++#define UP2OCR_DPPUE (0x1 << 4)
++#define UP2OCR_DMPDE (0x1 << 3)
++#define UP2OCR_DPPDE (0x1 << 2)
++#define UP2OCR_CPVPE (0x1 << 1)
++#define UP2OCR_CPVEN (0x1 << 0)
++
++#endif
++
++#ifndef UP3OCR
++#define UP3OCR __REG(0x40600024)
++#endif
++
++/*
++ * UDCCSR0 Bit Definitions C.f. Sheet 1 or 3
++ */
++#define UDCCSR0_ACM (1 << 9)
++#define UDCCSR0_AREN (1 << 8)
++
++
++/*
++ * Mainstone Miscellanous Write Register (MSCWR2) C.f. 3.2.2.6 (DVK)
++ *
++ * USB_OTG_RST enable external usb otg transceiver
++ * USB_OTG_SEL enable usb otg (disables ffuart)
++ * nUSBC_SC enable usb client detection
++ */
++#ifndef MSCWR2_USB_OTG_SEL
++#define MSCWR2_USB_OTG_SEL MST_MSCWR2_USB_OTG_SEL
++#endif
++#ifndef MSCWR2_USB_OTG_RST
++#define MSCWR2_USB_OTG_RST MST_MSCWR2_USB_OTG_RST
++#endif
++#ifndef MSCRD1_USB_CBL
++#define MSCRD1_USB_CBL MST_MSCRD_USB_CBL
++#endif
++#ifndef MSCWR2_nUSBC_SC
++#define MSCWR2_nUSBC_SC MST_MSCWR2_nUSBC_SC
++#endif
++
++/*
++ * USB_P2_N GPIO configuration - C.f. 24.2
++ *
++ * These should be in
++ */
++#define GPIO34_USB_P2_2 (34 | GPIO_ALT_FN_1_OUT)
++#define GPIO35_USB_P2_1 (35 | GPIO_ALT_FN_2_IN)
++#define GPIO36_USB_P2_4 (36 | GPIO_ALT_FN_1_OUT)
++#define GPIO37_USB_P2_8 (37 | GPIO_ALT_FN_1_OUT)
++#define GPIO38_USB_P2_3 (38 | GPIO_ALT_FN_3_IN)
++#define GPIO39_USB_P2_6 (39 | GPIO_ALT_FN_1_OUT)
++#define GPIO40_USB_P2_5 (40 | GPIO_ALT_FN_3_IN)
++#define GPIO41_USB_P2_7 (41 | GPIO_ALT_FN_2_IN)
++
++
++#if 0
++/* UDC endpiont0 states */
++#define EP0_WAIT_FOR_SETUP 0
++#define EP0_DATA_STATE_XMIT 1
++#define EP0_DATA_STATE_NEED_ZLP 2
++#define EP0_WAIT_FOR_OUT_STATUS 3
++
++/* UDC register definitions */
++#define UDCCR __REG(0x40600000) /* UDC Control Register */
++#define UDCICR0 __REG(0x40600004) /* UDC Interrupt Control Register0 */
++#define UDCICR1 __REG(0x40600008) /* UDC Interrupt Control Register1 */
++#define UDCISR0 __REG(0x4060000C) /* UDC Interrupt Status Register 0 */
++#define UDCISR1 __REG(0x40600010) /* UDC Interrupt Status Register 1 */
++#define UDCFNR __REG(0x40600014) /* UDC Frame Number Register */
++
++#define UDCCSR0 __REG(0x40600100) /* UDC Control/Status register - Endpoint 0 */
++#define UDCCSRA __REG(0x40600104) /* UDC Control/Status register - Endpoint A */
++#define UDCCSRB __REG(0x40600108) /* UDC Control/Status register - Endpoint B */
++#define UDCCSRC __REG(0x4060010C) /* UDC Control/Status register - Endpoint C */
++#define UDCCSRD __REG(0x40600110) /* UDC Control/Status register - Endpoint D */
++#define UDCCSRE __REG(0x40600114) /* UDC Control/Status register - Endpoint E */
++#define UDCCSRF __REG(0x40600118) /* UDC Control/Status register - Endpoint F */
++#define UDCCSRG __REG(0x4060011C) /* UDC Control/Status register - Endpoint G */
++#define UDCCSRH __REG(0x40600120) /* UDC Control/Status register - Endpoint H */
++#define UDCCSRI __REG(0x40600124) /* UDC Control/Status register - Endpoint I */
++#define UDCCSRJ __REG(0x40600128) /* UDC Control/Status register - Endpoint J */
++#define UDCCSRK __REG(0x4060012C) /* UDC Control/Status register - Endpoint K */
++#define UDCCSRL __REG(0x40600130) /* UDC Control/Status register - Endpoint L */
++#define UDCCSRM __REG(0x40600134) /* UDC Control/Status register - Endpoint M */
++#define UDCCSRN __REG(0x40600138) /* UDC Control/Status register - Endpoint N */
++#define UDCCSRP __REG(0x4060013C) /* UDC Control/Status register - Endpoint P */
++#define UDCCSRQ __REG(0x40600140) /* UDC Control/Status register - Endpoint Q */
++#define UDCCSRR __REG(0x40600144) /* UDC Control/Status register - Endpoint R */
++#define UDCCSRS __REG(0x40600148) /* UDC Control/Status register - Endpoint S */
++#define UDCCSRT __REG(0x4060014C) /* UDC Control/Status register - Endpoint T */
++#define UDCCSRU __REG(0x40600150) /* UDC Control/Status register - Endpoint U */
++#define UDCCSRV __REG(0x40600154) /* UDC Control/Status register - Endpoint V */
++#define UDCCSRW __REG(0x40600158) /* UDC Control/Status register - Endpoint W */
++#define UDCCSRX __REG(0x4060015C) /* UDC Control/Status register - Endpoint X */
++
++#define UDCBCR0 __REG(0x40600200) /* Byte Count Register - EP0 */
++#define UDCBCRA __REG(0x40600204) /* Byte Count Register - EPA */
++#define UDCBCRB __REG(0x40600208) /* Byte Count Register - EPB */
++#define UDCBCRC __REG(0x4060020C) /* Byte Count Register - EPC */
++#define UDCBCRD __REG(0x40600210) /* Byte Count Register - EPD */
++#define UDCBCRE __REG(0x40600214) /* Byte Count Register - EPE */
++#define UDCBCRF __REG(0x40600218) /* Byte Count Register - EPF */
++#define UDCBCRG __REG(0x4060021C) /* Byte Count Register - EPG */
++#define UDCBCRH __REG(0x40600220) /* Byte Count Register - EPH */
++#define UDCBCRI __REG(0x40600224) /* Byte Count Register - EPI */
++#define UDCBCRJ __REG(0x40600228) /* Byte Count Register - EPJ */
++#define UDCBCRK __REG(0x4060022C) /* Byte Count Register - EPK */
++#define UDCBCRL __REG(0x40600230) /* Byte Count Register - EPL */
++#define UDCBCRM __REG(0x40600234) /* Byte Count Register - EPM */
++#define UDCBCRN __REG(0x40600238) /* Byte Count Register - EPN */
++#define UDCBCRP __REG(0x4060023C) /* Byte Count Register - EPP */
++#define UDCBCRQ __REG(0x40600240) /* Byte Count Register - EPQ */
++#define UDCBCRR __REG(0x40600244) /* Byte Count Register - EPR */
++#define UDCBCRS __REG(0x40600248) /* Byte Count Register - EPS */
++#define UDCBCRT __REG(0x4060024C) /* Byte Count Register - EPT */
++#define UDCBCRU __REG(0x40600250) /* Byte Count Register - EPU */
++#define UDCBCRV __REG(0x40600254) /* Byte Count Register - EPV */
++#define UDCBCRW __REG(0x40600258) /* Byte Count Register - EPW */
++#define UDCBCRX __REG(0x4060025C) /* Byte Count Register - EPX */
++
++#define UDCDR0 __REG(0x40600300) /* Data Register - EP0 */
++#define UDCDRA __REG(0x40600304) /* Data Register - EPA */
++#define UDCDRB __REG(0x40600308) /* Data Register - EPB */
++#define UDCDRC __REG(0x4060030C) /* Data Register - EPC */
++#define UDCDRD __REG(0x40600310) /* Data Register - EPD */
++#define UDCDRE __REG(0x40600314) /* Data Register - EPE */
++#define UDCDRF __REG(0x40600318) /* Data Register - EPF */
++#define UDCDRG __REG(0x4060031C) /* Data Register - EPG */
++#define UDCDRH __REG(0x40600320) /* Data Register - EPH */
++#define UDCDRI __REG(0x40600324) /* Data Register - EPI */
++#define UDCDRJ __REG(0x40600328) /* Data Register - EPJ */
++#define UDCDRK __REG(0x4060032C) /* Data Register - EPK */
++#define UDCDRL __REG(0x40600330) /* Data Register - EPL */
++#define UDCDRM __REG(0x40600334) /* Data Register - EPM */
++#define UDCDRN __REG(0x40600338) /* Data Register - EPN */
++#define UDCDRP __REG(0x4060033C) /* Data Register - EPP */
++#define UDCDRQ __REG(0x40600340) /* Data Register - EPQ */
++#define UDCDRR __REG(0x40600344) /* Data Register - EPR */
++#define UDCDRS __REG(0x40600348) /* Data Register - EPS */
++#define UDCDRT __REG(0x4060034C) /* Data Register - EPT */
++#define UDCDRU __REG(0x40600350) /* Data Register - EPU */
++#define UDCDRV __REG(0x40600354) /* Data Register - EPV */
++#define UDCDRW __REG(0x40600358) /* Data Register - EPW */
++#define UDCDRX __REG(0x4060035C) /* Data Register - EPX */
++
++#define UDCCRA __REG(0x40600404) /* Configuration register EPA */
++#define UDCCRB __REG(0x40600408) /* Configuration register EPB */
++#define UDCCRC __REG(0x4060040C) /* Configuration register EPC */
++#define UDCCRD __REG(0x40600410) /* Configuration register EPD */
++#define UDCCRE __REG(0x40600414) /* Configuration register EPE */
++#define UDCCRF __REG(0x40600418) /* Configuration register EPF */
++#define UDCCRG __REG(0x4060041C) /* Configuration register EPG */
++#define UDCCRH __REG(0x40600420) /* Configuration register EPH */
++#define UDCCRI __REG(0x40600424) /* Configuration register EPI */
++#define UDCCRJ __REG(0x40600428) /* Configuration register EPJ */
++#define UDCCRK __REG(0x4060042C) /* Configuration register EPK */
++#define UDCCRL __REG(0x40600430) /* Configuration register EPL */
++#define UDCCRM __REG(0x40600434) /* Configuration register EPM */
++#define UDCCRN __REG(0x40600438) /* Configuration register EPN */
++#define UDCCRP __REG(0x4060043C) /* Configuration register EPP */
++#define UDCCRQ __REG(0x40600440) /* Configuration register EPQ */
++#define UDCCRR __REG(0x40600444) /* Configuration register EPR */
++#define UDCCRS __REG(0x40600448) /* Configuration register EPS */
++#define UDCCRT __REG(0x4060044C) /* Configuration register EPT */
++#define UDCCRU __REG(0x40600450) /* Configuration register EPU */
++#define UDCCRV __REG(0x40600454) /* Configuration register EPV */
++#define UDCCRW __REG(0x40600458) /* Configuration register EPW */
++#define UDCCRX __REG(0x4060045C) /* Configuration register EPX */
++
++/* UDC Control Register (UDCCR) */
++#define UDCCR_DWRE (1 <<16) /* Device Remote Wake-up Feature */
++#define UDCCR_ACN (1 <<11) /* Active UDC Configuration Number */
++#define UDCCR_AIN (1 << 8) /* Active UDC Interface Number */
++#define UDCCR_AAISN (1 << 5) /* Active UDC Alternative Interface Setting Number */
++#define UDCCR_SMAC (1 << 4) /* Switch Endpoint Memory to Active Configuration */
++#define UDCCR_EMCE (1 << 3) /* Endpoint Meory Configuration Error */
++#define UDCCR_UDR (1 << 2) /* UDC Resume */
++#define UDCCR_UDA (1 << 1) /* UDC Active */
++#define UDCCR_UDE (1 << 0) /* UDC Enable */
++
++#define UDCCR_ACN_MASK 0x3
++#define UDCCR_AIN_MASK 0x7
++#define UDCCR_AAISN_MASK 0x7
++
++#define UDCICR0_IE0 (1<<0) /* EP0 Interrupt Enable */
++#define UDCICR0_IEA (1<<2) /* EPA Interrupt Enable */
++#define UDCICR0_IEB (1<<4) /* EPB Interrupt Enable */
++#define UDCICR0_IEC (1<<6) /* EPC Interrupt Enable */
++#define UDCICR0_IED (1<<8) /* EPD Interrupt Enable */
++#define UDCICR0_IEE (1<<10) /* EPE Interrupt Enable */
++#define UDCICR0_IEF (1<<12) /* EPF Interrupt Enable */
++#define UDCICR0_IEG (1<<14) /* EPG Interrupt Enable */
++#define UDCICR0_IEH (1<<16) /* EPH Interrupt Enable */
++#define UDCICR0_IEI (1<<18) /* EPI Interrupt Enable */
++#define UDCICR0_IEJ (1<<20) /* EPJ Interrupt Enable */
++#define UDCICR0_IEK (1<<22) /* EPK Interrupt Enable */
++#define UDCICR0_IEL (1<<24) /* EPL Interrupt Enable */
++#define UDCICR0_IEM (1<<26) /* EPM Interrupt Enable */
++#define UDCICR0_IEN (1<<28) /* EPN Interrupt Enable */
++#define UDCICR0_IEP (1<<30) /* EPP Interrupt Enable */
++#define UDCICR1_IEQ (1<<0) /* EPQ Interrupt Enable */
++#define UDCICR1_IER (1<<2) /* EPR Interrupt Enable */
++#define UDCICR1_IES (1<<4) /* EPS Interrupt Enable */
++#define UDCICR1_IET (1<<6) /* EPT Interrupt Enable */
++#define UDCICR1_IEU (1<<8) /* EPU Interrupt Enable */
++#define UDCICR1_IEV (1<<10) /* EPV Interrupt Enable */
++#define UDCICR1_IEW (1<<12) /* EPW Interrupt Enable */
++#define UDCICR1_IEX (1<<14) /* EPX Interrupt Enable */
++#define UDCICR1_IERS (1<<27) /* Reset */
++#define UDCICR1_IESU (1<<28) /* Suspend */
++#define UDCICR1_IERU (1<<29) /* Resume */
++#define UDCICR1_IESOF (1<<30) /* Start Of Frame */
++#define UDCICR1_IECC (1<<31) /* Configuration Changed */
++
++#define UDCISR0_IE0 (1<<0) /* EP0 Interrupt Enable */
++#define UDCISR0_IEA (1<<2) /* EPA Interrupt Enable */
++#define UDCISR0_IEB (1<<4) /* EPB Interrupt Enable */
++#define UDCISR0_IEC (1<<6) /* EPC Interrupt Enable */
++#define UDCISR0_IED (1<<8) /* EPD Interrupt Enable */
++#define UDCISR0_IEE (1<<10) /* EPE Interrupt Enable */
++#define UDCISR0_IEF (1<<12) /* EPF Interrupt Enable */
++#define UDCISR0_IEG (1<<14) /* EPG Interrupt Enable */
++#define UDCISR0_IEH (1<<16) /* EPH Interrupt Enable */
++#define UDCISR0_IEI (1<<18) /* EPI Interrupt Enable */
++#define UDCISR0_IEJ (1<<20) /* EPJ Interrupt Enable */
++#define UDCISR0_IEK (1<<22) /* EPK Interrupt Enable */
++#define UDCISR0_IEL (1<<24) /* EPL Interrupt Enable */
++#define UDCISR0_IEM (1<<26) /* EPM Interrupt Enable */
++#define UDCISR0_IEN (1<<28) /* EPN Interrupt Enable */
++#define UDCISR0_IEP (1<<30) /* EPP Interrupt Enable */
++#define UDCISR1_IEQ (1<<0) /* EPQ Interrupt Enable */
++#define UDCISR1_IER (1<<2) /* EPR Interrupt Enable */
++#define UDCISR1_IES (1<<4) /* EPS Interrupt Enable */
++#define UDCISR1_IET (1<<6) /* EPT Interrupt Enable */
++#define UDCISR1_IEU (1<<8) /* EPU Interrupt Enable */
++#define UDCISR1_IEV (1<<10) /* EPV Interrupt Enable */
++#define UDCISR1_IEW (1<<12) /* EPW Interrupt Enable */
++#define UDCISR1_IEX (1<<14) /* EPX Interrupt Enable */
++#define UDCISR1_IERS (1<<27) /* Reset */
++#define UDCISR1_IESU (1<<28) /* Suspend */
++#define UDCISR1_IERU (1<<29) /* Resume */
++#define UDCISR1_IESOF (1<<30) /* Start Of Frame */
++#define UDCISR1_IECC (1<<31) /* Configuration Changed */
++
++#define UDC_INT_FIFOERROR (0x2)
++#define UDC_INT_PACKETCMP (0x1)
++
++#define UDC_FNR_MASK (0x7ff)
++
++/* UDC Endpoint 0 Control Status Register (UDCCS0) */
++#define UDCCSR0_OPR (1 << 0) /* OUT packet ready */
++#define UDCCSR0_IPR (1 << 1) /* IN packet ready */
++#define UDCCSR0_FTF (1 << 2) /* Flush Tx FIFO */
++#define UDCCSR0_DME (1 << 3) /* DMA Enable */
++#define UDCCSR0_SST (1 << 4) /* Sent stall */
++#define UDCCSR0_FST (1 << 5) /* Force stall */
++#define UDCCSR0_RNE (1 << 6) /* Receive FIFO not empty */
++#define UDCCSR0_SA (1 << 7) /* Setup Active */
++
++/* UDC Endpoint A-X */
++#define UDCCSR_FS (1 << 0) /* FIFO service */
++#define UDCCSR_PC (1 << 1) /* Packet complete */
++#define UDCCSR_TRN (1 << 2) /* Tx/Rx NAK */
++#define UDCCSR_DME (1 << 3) /* DMA Enable */
++#define UDCCSR_SST (1 << 4) /* Sent STALL */
++#define UDCCSR_FST (1 << 5) /* Force STALL */
++#define UDCCSR_BNE (1 << 6) /* Buffer Not Empty */
++#define UDCCSR_BNF (1 << 6) /* Buffer Not Full */
++#define UDCCSR_SP (1 << 7) /* Short packet */
++#define UDCCSR_FEF (1 << 8) /* Flush Endpoint FIFO */
++#define UDCCSR_DPE (1 << 9) /* Data Packet Error */
++
++#define UDCCSR_WR_MASK (UDCCSR_DME|UDCCSR_FST)
++#define UDC_BCR_MASK (0x3ff)
++
++#define UDCCONR_EE (1 << 0) /* Endpoint Enable */
++#define UDCCONR_DE (1 << 1) /* Double-buffering Enable */
++#define UDCCONR_MPS (1 << 2) /* Maximum Packet Size */
++#define UDCCONR_ED (1 <<12) /* USB Endpoint Direction */
++#define UDCCONR_ET (1 <<13) /* Endpoint Type */
++#define UDCCONR_EN (1 <<15) /* Endpoint Number */
++#define UDCCONR_AISN (1 <<19) /* Alternate Interface Number */
++#define UDCCONR_IN (1 <<22) /* Interface Number */
++#define UDCCONR_CN (1 <<25) /* Configuration Number */
++
++#define UDC_CON_CN_MASK (0x3)
++#define UDC_CON_IN_MASK (0x7)
++#define UDC_CON_AISN_MASK (0x7)
++#define UDC_CON_EN_MASK (0xf)
++#define UDC_CON_ET_MASK (0x3)
++#define UDC_CON_MPS_MASK (0x3ff)
++
++/* DMA Request to Channel Map Register */
++
++/* Endpoint 0 state definitions */
++#define WAIT_FOR_SETUP 0
++#define DATA_STATE_XMIT 1
++#define DATA_STATE_RECV 2
++#define DATA_STATE_PENDING_XMIT 3
++#define DATA_STATE_NEED_ZLP 4
++#define WAIT_FOR_OUT_STATUS 5
++
++#endif
++
++
++#define UDCCR __REG(0x40600000) /* UDC Control Register */
++#define UDCCR_OEN (1 << 31) /* On-the-Go Enable */
++#define UDCCR_AALTHNP (1 << 30) /* A-device Alternate Host Negotiation
++ Protocol Port Support */
++#define UDCCR_AHNP (1 << 29) /* A-device Host Negotiation Protocol
++ Support */
++#define UDCCR_BHNP (1 << 28) /* B-device Host Negotiation Protocol
++ Enable */
++#define UDCCR_DWRE (1 << 16) /* Device Remote Wake-up Enable */
++#define UDCCR_ACN (0x03 << 11) /* Active UDC configuration Number */
++#define UDCCR_ACN_S 11
++#define UDCCR_AIN (0x07 << 8) /* Active UDC interface Number */
++#define UDCCR_AIN_S 8
++#define UDCCR_AAISN (0x07 << 5) /* Active UDC Alternate Interface
++ Setting Number */
++#define UDCCR_AAISN_S 5
++#define UDCCR_SMAC (1 << 4) /* Switch Endpoint Memory to Active
++ Configuration */
++#define UDCCR_EMCE (1 << 3) /* Endpoint Memory Configuration
++ Error */
++#define UDCCR_UDR (1 << 2) /* UDC Resume */
++#define UDCCR_UDA (1 << 1) /* UDC Active */
++#define UDCCR_UDE (1 << 0) /* UDC Enable */
++
++#define UDCICR0 __REG(0x40600004) /* UDC Interrupt Control Register0 */
++#define UDCICR1 __REG(0x40600008) /* UDC Interrupt Control Register1 */
++#define UDCICR_FIFOERR (1 << 1) /* FIFO Error interrupt for EP */
++#define UDCICR_PKTCOMPL (1 << 0) /* Packet Complete interrupt for EP */
++
++#define UDC_INT_FIFOERROR (0x2)
++#define UDC_INT_PACKETCMP (0x1)
++
++#define UDCICR_INT(n,intr) (((intr) & 0x03) << (((n) & 0x0F) * 2))
++#define UDCICR1_IECC (1 << 31) /* IntEn - Configuration Change */
++#define UDCICR1_IESOF (1 << 30) /* IntEn - Start of Frame */
++#define UDCICR1_IERU (1 << 29) /* IntEn - Resume */
++#define UDCICR1_IESU (1 << 28) /* IntEn - Suspend */
++#define UDCICR1_IERS (1 << 27) /* IntEn - Reset */
++
++#define UDCISR0 __REG(0x4060000C) /* UDC Interrupt Status Register 0 */
++#define UDCISR1 __REG(0x40600010) /* UDC Interrupt Status Register 1 */
++#define UDCISR_INT(n,intr) (((intr) & 0x03) << (((n) & 0x0F) * 2))
++#define UDCISR1_IECC (1 << 31) /* IntEn - Configuration Change */
++#define UDCISR1_IESOF (1 << 30) /* IntEn - Start of Frame */
++#define UDCISR1_IERU (1 << 29) /* IntEn - Resume */
++#define UDCISR1_IESU (1 << 28) /* IntEn - Suspend */
++#define UDCISR1_IERS (1 << 27) /* IntEn - Reset */
++
++
++#define UDCFNR __REG(0x40600014) /* UDC Frame Number Register */
++#define UDCOTGICR __REG(0x40600018) /* UDC On-The-Go interrupt control */
++#define UDCOTGICR_IESF (1 << 24) /* OTG SET_FEATURE command recvd */
++#define UDCOTGICR_IEXR (1 << 17) /* Extra Transciever Interrupt
++ Rising Edge Interrupt Enable */
++#define UDCOTGICR_IEXF (1 << 16) /* Extra Transciever Interrupt
++ Falling Edge Interrupt Enable */
++#define UDCOTGICR_IEVV40R (1 << 9) /* OTG Vbus Valid 4.0V Rising Edge
++ Interrupt Enable */
++#define UDCOTGICR_IEVV40F (1 << 8) /* OTG Vbus Valid 4.0V Falling Edge
++ Interrupt Enable */
++#define UDCOTGICR_IEVV44R (1 << 7) /* OTG Vbus Valid 4.4V Rising Edge
++ Interrupt Enable */
++#define UDCOTGICR_IEVV44F (1 << 6) /* OTG Vbus Valid 4.4V Falling Edge
++ Interrupt Enable */
++#define UDCOTGICR_IESVR (1 << 5) /* OTG Session Valid Rising Edge
++ Interrupt Enable */
++#define UDCOTGICR_IESVF (1 << 4) /* OTG Session Valid Falling Edge
++ Interrupt Enable */
++#define UDCOTGICR_IESDR (1 << 3) /* OTG A-Device SRP Detect Rising
++ Edge Interrupt Enable */
++#define UDCOTGICR_IESDF (1 << 2) /* OTG A-Device SRP Detect Falling
++ Edge Interrupt Enable */
++#define UDCOTGICR_IEIDR (1 << 1) /* OTG ID Change Rising Edge
++ Interrupt Enable */
++#define UDCOTGICR_IEIDF (1 << 0) /* OTG ID Change Falling Edge
++ Interrupt Enable */
++
++#define UDCCSN(x) __REG2(0x40600100, (x) << 2)
++#define UDCCSR0 __REG(0x40600100) /* UDC Control/Status register - Endpoint 0 */
++#define UDCCSR0_SA (1 << 7) /* Setup Active */
++#define UDCCSR0_RNE (1 << 6) /* Receive FIFO Not Empty */
++#define UDCCSR0_FST (1 << 5) /* Force Stall */
++#define UDCCSR0_SST (1 << 4) /* Sent Stall */
++#define UDCCSR0_DME (1 << 3) /* DMA Enable */
++#define UDCCSR0_FTF (1 << 2) /* Flush Transmit FIFO */
++#define UDCCSR0_IPR (1 << 1) /* IN Packet Ready */
++#define UDCCSR0_OPC (1 << 0) /* OUT Packet Complete */
++
++#define UDCCSRA __REG(0x40600104) /* UDC Control/Status register - Endpoint A */
++#define UDCCSRB __REG(0x40600108) /* UDC Control/Status register - Endpoint B */
++#define UDCCSRC __REG(0x4060010C) /* UDC Control/Status register - Endpoint C */
++#define UDCCSRD __REG(0x40600110) /* UDC Control/Status register - Endpoint D */
++#define UDCCSRE __REG(0x40600114) /* UDC Control/Status register - Endpoint E */
++#define UDCCSRF __REG(0x40600118) /* UDC Control/Status register - Endpoint F */
++#define UDCCSRG __REG(0x4060011C) /* UDC Control/Status register - Endpoint G */
++#define UDCCSRH __REG(0x40600120) /* UDC Control/Status register - Endpoint H */
++#define UDCCSRI __REG(0x40600124) /* UDC Control/Status register - Endpoint I */
++#define UDCCSRJ __REG(0x40600128) /* UDC Control/Status register - Endpoint J */
++#define UDCCSRK __REG(0x4060012C) /* UDC Control/Status register - Endpoint K */
++#define UDCCSRL __REG(0x40600130) /* UDC Control/Status register - Endpoint L */
++#define UDCCSRM __REG(0x40600134) /* UDC Control/Status register - Endpoint M */
++#define UDCCSRN __REG(0x40600138) /* UDC Control/Status register - Endpoint N */
++#define UDCCSRP __REG(0x4060013C) /* UDC Control/Status register - Endpoint P */
++#define UDCCSRQ __REG(0x40600140) /* UDC Control/Status register - Endpoint Q */
++#define UDCCSRR __REG(0x40600144) /* UDC Control/Status register - Endpoint R */
++#define UDCCSRS __REG(0x40600148) /* UDC Control/Status register - Endpoint S */
++#define UDCCSRT __REG(0x4060014C) /* UDC Control/Status register - Endpoint T */
++#define UDCCSRU __REG(0x40600150) /* UDC Control/Status register - Endpoint U */
++#define UDCCSRV __REG(0x40600154) /* UDC Control/Status register - Endpoint V */
++#define UDCCSRW __REG(0x40600158) /* UDC Control/Status register - Endpoint W */
++#define UDCCSRX __REG(0x4060015C) /* UDC Control/Status register - Endpoint X */
++
++#define UDCCSR_DPE (1 << 9) /* Data Packet Error */
++#define UDCCSR_FEF (1 << 8) /* Flush Endpoint FIFO */
++#define UDCCSR_SP (1 << 7) /* Short Packet Control/Status */
++#define UDCCSR_BNE (1 << 6) /* Buffer Not Empty (IN endpoints) */
++#define UDCCSR_BNF (1 << 6) /* Buffer Not Full (OUT endpoints) */
++#define UDCCSR_FST (1 << 5) /* Force STALL */
++#define UDCCSR_SST (1 << 4) /* Sent STALL */
++#define UDCCSR_DME (1 << 3) /* DMA Enable */
++#define UDCCSR_TRN (1 << 2) /* Tx/Rx NAK */
++#define UDCCSR_PC (1 << 1) /* Packet Complete */
++#define UDCCSR_FS (1 << 0) /* FIFO needs service */
++
++#define UDCBCN(x) __REG2(0x40600200, (x)<<2)
++#define UDCBCR0 __REG(0x40600200) /* Byte Count Register - EP0 */
++#define UDCBCRA __REG(0x40600204) /* Byte Count Register - EPA */
++#define UDCBCRB __REG(0x40600208) /* Byte Count Register - EPB */
++#define UDCBCRC __REG(0x4060020C) /* Byte Count Register - EPC */
++#define UDCBCRD __REG(0x40600210) /* Byte Count Register - EPD */
++#define UDCBCRE __REG(0x40600214) /* Byte Count Register - EPE */
++#define UDCBCRF __REG(0x40600218) /* Byte Count Register - EPF */
++#define UDCBCRG __REG(0x4060021C) /* Byte Count Register - EPG */
++#define UDCBCRH __REG(0x40600220) /* Byte Count Register - EPH */
++#define UDCBCRI __REG(0x40600224) /* Byte Count Register - EPI */
++#define UDCBCRJ __REG(0x40600228) /* Byte Count Register - EPJ */
++#define UDCBCRK __REG(0x4060022C) /* Byte Count Register - EPK */
++#define UDCBCRL __REG(0x40600230) /* Byte Count Register - EPL */
++#define UDCBCRM __REG(0x40600234) /* Byte Count Register - EPM */
++#define UDCBCRN __REG(0x40600238) /* Byte Count Register - EPN */
++#define UDCBCRP __REG(0x4060023C) /* Byte Count Register - EPP */
++#define UDCBCRQ __REG(0x40600240) /* Byte Count Register - EPQ */
++#define UDCBCRR __REG(0x40600244) /* Byte Count Register - EPR */
++#define UDCBCRS __REG(0x40600248) /* Byte Count Register - EPS */
++#define UDCBCRT __REG(0x4060024C) /* Byte Count Register - EPT */
++#define UDCBCRU __REG(0x40600250) /* Byte Count Register - EPU */
++#define UDCBCRV __REG(0x40600254) /* Byte Count Register - EPV */
++#define UDCBCRW __REG(0x40600258) /* Byte Count Register - EPW */
++#define UDCBCRX __REG(0x4060025C) /* Byte Count Register - EPX */
++
++#define UDCDN(x) __REG2(0x40600300, (x)<<2)
++#define PHYS_UDCDN(x) (0x40600300 + ((x)<<2))
++#define PUDCDN(x) (volatile u32 *)(io_p2v(PHYS_UDCDN((x))))
++#define UDCDR0 __REG(0x40600300) /* Data Register - EP0 */
++#define UDCDRA __REG(0x40600304) /* Data Register - EPA */
++#define UDCDRB __REG(0x40600308) /* Data Register - EPB */
++#define UDCDRC __REG(0x4060030C) /* Data Register - EPC */
++#define UDCDRD __REG(0x40600310) /* Data Register - EPD */
++#define UDCDRE __REG(0x40600314) /* Data Register - EPE */
++#define UDCDRF __REG(0x40600318) /* Data Register - EPF */
++#define UDCDRG __REG(0x4060031C) /* Data Register - EPG */
++#define UDCDRH __REG(0x40600320) /* Data Register - EPH */
++#define UDCDRI __REG(0x40600324) /* Data Register - EPI */
++#define UDCDRJ __REG(0x40600328) /* Data Register - EPJ */
++#define UDCDRK __REG(0x4060032C) /* Data Register - EPK */
++#define UDCDRL __REG(0x40600330) /* Data Register - EPL */
++#define UDCDRM __REG(0x40600334) /* Data Register - EPM */
++#define UDCDRN __REG(0x40600338) /* Data Register - EPN */
++#define UDCDRP __REG(0x4060033C) /* Data Register - EPP */
++#define UDCDRQ __REG(0x40600340) /* Data Register - EPQ */
++#define UDCDRR __REG(0x40600344) /* Data Register - EPR */
++#define UDCDRS __REG(0x40600348) /* Data Register - EPS */
++#define UDCDRT __REG(0x4060034C) /* Data Register - EPT */
++#define UDCDRU __REG(0x40600350) /* Data Register - EPU */
++#define UDCDRV __REG(0x40600354) /* Data Register - EPV */
++#define UDCDRW __REG(0x40600358) /* Data Register - EPW */
++#define UDCDRX __REG(0x4060035C) /* Data Register - EPX */
++
++#define UDCCN(x) __REG2(0x40600400, (x)<<2)
++#define UDCCRA __REG(0x40600404) /* Configuration register EPA */
++#define UDCCRB __REG(0x40600408) /* Configuration register EPB */
++#define UDCCRC __REG(0x4060040C) /* Configuration register EPC */
++#define UDCCRD __REG(0x40600410) /* Configuration register EPD */
++#define UDCCRE __REG(0x40600414) /* Configuration register EPE */
++#define UDCCRF __REG(0x40600418) /* Configuration register EPF */
++#define UDCCRG __REG(0x4060041C) /* Configuration register EPG */
++#define UDCCRH __REG(0x40600420) /* Configuration register EPH */
++#define UDCCRI __REG(0x40600424) /* Configuration register EPI */
++#define UDCCRJ __REG(0x40600428) /* Configuration register EPJ */
++#define UDCCRK __REG(0x4060042C) /* Configuration register EPK */
++#define UDCCRL __REG(0x40600430) /* Configuration register EPL */
++#define UDCCRM __REG(0x40600434) /* Configuration register EPM */
++#define UDCCRN __REG(0x40600438) /* Configuration register EPN */
++#define UDCCRP __REG(0x4060043C) /* Configuration register EPP */
++#define UDCCRQ __REG(0x40600440) /* Configuration register EPQ */
++#define UDCCRR __REG(0x40600444) /* Configuration register EPR */
++#define UDCCRS __REG(0x40600448) /* Configuration register EPS */
++#define UDCCRT __REG(0x4060044C) /* Configuration register EPT */
++#define UDCCRU __REG(0x40600450) /* Configuration register EPU */
++#define UDCCRV __REG(0x40600454) /* Configuration register EPV */
++#define UDCCRW __REG(0x40600458) /* Configuration register EPW */
++#define UDCCRX __REG(0x4060045C) /* Configuration register EPX */
++
++#define UDCCONR_CN (0x03 << 25) /* Configuration Number */
++#define UDCCONR_CN_S (25)
++#define UDCCONR_IN (0x07 << 22) /* Interface Number */
++#define UDCCONR_IN_S (22)
++#define UDCCONR_AISN (0x07 << 19) /* Alternate Interface Number */
++#define UDCCONR_AISN_S (19)
++#define UDCCONR_EN (0x0f << 15) /* Endpoint Number */
++#define UDCCONR_EN_S (15)
++#define UDCCONR_ET (0x03 << 13) /* Endpoint Type: */
++#define UDCCONR_ET_S (13)
++#define UDCCONR_ET_INT (0x03 << 13) /* Interrupt */
++#define UDCCONR_ET_BULK (0x02 << 13) /* Bulk */
++#define UDCCONR_ET_ISO (0x01 << 13) /* Isochronous */
++#define UDCCONR_ET_NU (0x00 << 13) /* Not used */
++#define UDCCONR_ED (1 << 12) /* Endpoint Direction */
++#define UDCCONR_MPS (0x3ff << 2) /* Maximum Packet Size */
++#define UDCCONR_MPS_S (2)
++#define UDCCONR_DE (1 << 1) /* Double Buffering Enable */
++#define UDCCONR_EE (1 << 0) /* Endpoint Enable */
++
++
++#define UDC_INT_FIFOERROR (0x2)
++#define UDC_INT_PACKETCMP (0x1)
++
++#define UDC_FNR_MASK (0x7ff)
++
++#define UDCCSR_WR_MASK (UDCCSR_DME|UDCCSR_FST)
++#define UDC_BCR_MASK (0x3ff)
++
++
+diff -uNr linux/drivers/no-otg/otghw/cea-936.h linux/drivers/otg/otghw/cea-936.h
+--- linux/drivers/no-otg/otghw/cea-936.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otghw/cea-936.h 2006-09-01 21:41:35.000000000 +0200
+@@ -0,0 +1,148 @@
++/*
++ * otg/carkit.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ *
++ * Notes
++ *
++ * 1. Document references are to CEA-936a - Dec 12, 2003
++ *
++ */
++/*!
++ * @defgroup CEA
++ * @ingroup tcdgroup
++ */
++/*!
++ * @file otghw/cea-936.h
++ * @brief Hardware defines for CEA-936 Hardware
++ *
++ * @ingroup CEA
++ */
++
++
++/*
++ * Command Descriptions - C.f. 10.3
++ */
++#define CARKIT_GET_DEVICE 0x01
++#define CARKIT_GET_CARKIT 0x02
++#define CARKIT_AUDIO_EN 0x03
++#define CARKIT_SET_CRNT 0x04
++#define CARKIT_SET_UART 0x05
++#define CARKIT_CARKIT_MASTER 0x06
++
++/*
++ * generic get command
++ */
++struct carkit_get {
++ u8 strt;
++ u8 command_type;
++ u8 crc;
++ u8 terminator;
++};
++
++struct carkit_set {
++ u8 strt;
++ u8 command_type;
++ u8 command_value;
++ u8 crc;
++ u8 terminator;
++};
++
++struct carkit_get_carkit_ack {
++ u8 ack;
++ u8 terminator;
++};
++
++/*
++ * Get Device - C.f 10.3.1
++ */
++
++struct carkit_get_device_carkit {
++ u8 ack;
++ u8 device_id;
++ u16 vendor_id;
++ u16 product_id;
++ u8 crc;
++ u8 terminator;
++};
++
++#define CARKIT_DEVICE_ID_GENERIC 0x01
++#define CARKIT_DEVICE_ID_ENHANCED 0x02
++#define CARKIT_DEVICE_ID_PROPRIETARY 0x03
++
++
++/*
++ * Get CarKit - C.f. 10.3.2
++ */
++
++struct carkit_get_carkit_carkit {
++ u8 ack;
++ u16 cr_ftrs;
++ u8 cr_sts;
++ u8 crc;
++ u8 terminator;
++};
++
++#define CARKIT_CR_FTRS_0_STERO (1 << 0)
++#define CARKIT_CR_FTRS_0_CRNT_ADJ (1 << 1)
++#define CARKIT_CR_FTRS_0_UART_MAX (7 << 2)
++#define CARKIT_CR_FTRS_0_UART_MSTR (1 << 5)
++
++#define CARKIT_CR_FTRS_1_PH_REMOVE_FTR (1 << 0)
++#define CARKIT_CR_FTRS_1_CAR_OFF_FTR (1 << 1)
++#define CARKIT_CR_FTRS_1_CRDL_BTN_FTR (1 << 2)
++
++#define CARKIT_CR_PH_REMOVE_STS (1 << 0)
++#define CARKIT_CR_CAR_OFF_STS (1 << 1)
++#define CARKIT_CR_CRDL_BTN_STS (1 << 2)
++#define CARKIT_CR_PH_RMV_CHG (1 << 4)
++#define CARKIT_CR_CAR_OFF_CHG (1 << 5)
++#define CARKIT_CR_CRDL_BTN_CHG (1 << 6)
++
++
++/*
++ * Set Carkit - C.f. 10.3.3
++ */
++#define CARKIT_CR_CTL_PH_RMV_IEN (1 << 0)
++#define CARKIT_CR_CAR_OFF_IEN (1 << 1)
++#define CARKIT_CR_CRDL_BTN_IEN (1 << 2)
++#define CARKIT_CR_CARKIT_MSTR (1 << 5)
++#define CARKIT_CR_PULSE_ID (1 << 6)
++#define CARKIT_CR_ID_INT_EN (1 << 7)
++
++
++/*
++ * Audio En - C.f. 10.3.4
++ */
++#define CARKIT_AUDIO_MODE_MONO (1 << 0)
++#define CARKIT_AUDIO_MODE_STEREO (1 << 1)
++
++/*
++ * Set Crnt - C.f. 10.3.5
++ */
++#define CARKIT_CRNT_LMT (0xf)
++
++
++/*
++ * Set UART - C.f. 10.3.6
++ */
++#define CARKIT_UART_SPEED_9600 (1 << 0)
++#define CARKIT_UART_SPEED_19200 (1 << 1)
++#define CARKIT_UART_SPEED_38400 (1 << 3)
++#define CARKIT_UART_SPEED_57600 (1 << 4)
++#define CARKIT_UART_SPEED_115200 (1 << 4)
++
++
++/*
++ * Special chars - C.f. 10.4
++ */
++#define CARKIT_STRT 0x41
++#define CARKIT_ESC 0x18
++#define CARKIT_ACK 0x06
++#define CARKIT_NYET 0x30
++#define CARKIT_NAK 0x15
++#define CARKIT_NSUP 0x1f
++#define CARKIT_CR 0x0d
++
++
+diff -uNr linux/drivers/no-otg/otghw/fsotg-hardware.h linux/drivers/otg/otghw/fsotg-hardware.h
+--- linux/drivers/no-otg/otghw/fsotg-hardware.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otghw/fsotg-hardware.h 2006-09-01 21:41:35.000000000 +0200
+@@ -0,0 +1,1054 @@
++/*
++ * otghw/fsotg-hardware.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++
++/*!
++ * @defgroup FSOTG Freescale USBOTG Support
++ * @ingroup libgroup
++ */
++/*!
++ * @file otghw/fsotg-hardware.h
++ * @brief Hardware defines for Freescale USBOTG Hardware
++ *
++ * This supports the Freescale implementation of the Trans Dimension
++ * USBOTG.
++ *
++ * This is used on:
++ *
++ * - i.MX21
++ * - SCM-A11
++ * - Argon+
++ * - Zeus
++ *
++ * @ingroup FSOTG
++ */
++
++#if defined(CONFIG_ARCH_MX2ADS)
++#include <otghw/mx2ads.h>
++#include <otghw/mx2ads-hardware.h>
++#endif /* defined(CONFIG_ARCH_MX2ADS) */
++
++#if defined(CONFIG_ARCH_SCMA11EVB)
++#endif /* defined(CONFIG_ARCH_SCMA11EVB) */
++
++
++
++/*!
++ * @name OTG_SYS_CTRL
++ * C.f. 23.8 USB Control Register
++ */
++ /*! @{ */
++
++//#define OTG_SYS_CTRL (OTG_SYS_BASE+0x00)
++
++#define SYS_CTRL_I2C_WU_INT_STAT (1 << 27)
++#define SYS_CTRL_OTG_WU_INT_STAT (1 << 26)
++#define SYS_CTRL_HOST_WU_INT_STAT (1 << 25)
++#define SYS_CTRL_FNT_WU_INT_STAT (1 << 24)
++
++#define SYS_CTRL_I2C_WU_INT_EN (1 << 19)
++#define SYS_CTRL_OTG_WU_INT_EN (1 << 18)
++#define SYS_CTRL_HOST_WU_INT_EN (1 << 17)
++#define SYS_CTRL_FNT_WU_INT_EN (1 << 16)
++
++#define SYS_CTRL_OTG_BYP_VAL (0x3 << 11)
++#define SYS_CTRL_HOST1_BYP_VAL (0x3 << 9)
++
++#define SYS_CTRL_OTG_PWR_MASK (1 << 6)
++#define SYS_CTRL_HOST1_PWR_MASK (1 << 6)
++#define SYS_CTRL_HOST2_PWR_MASK (1 << 4)
++#define SYS_CTRL_USB_BYP (1 << 2)
++#define SYS_CTRL_HOST1_TXEN_OE (1 << 1)
++/*! @} */
++
++/*!
++ * @name C.f. 23.9 USBOTG Module Registers
++ */
++ /*! @{ */
++
++#define OTG_CORE_HWMODE (OTG_CORE_BASE+0x00) // 32bit core hardware mode reg
++
++#define XCVR_D_D 0x00
++#define XCVR_SE_D 0x01
++#define XCVR_D_SE 0x02
++#define XCVR_SE_SE 0x03
++
++#define MODULE_ANASDBEN (1 << 14)
++#define MODULE_OTGXCVR (0x3 << 6)
++#define MODULE_HOSTXCVR (0x3 << 4)
++#define MODULE_CRECFG (0x3)
++#define MODULE_CRECFG_HHNP (0x0)
++#define MODULE_CRECFG_HOST (0x1)
++#define MODULE_CRECFG_FUNC (0x2)
++#define MODULE_CRECFG_SHNP (0x3)
++
++#define OTG_CORE_CINT_STAT (OTG_CORE_BASE+0x04) // 32bit core int status reg
++
++#define MODULE_FCINTDSPEN (1 << 6)
++
++#define MODULE_ASHNPINT (1 << 5)
++#define MODULE_ASFCINT (1 << 4)
++#define MODULE_ASHCINT (1 << 3)
++#define MODULE_HNPINT (1 << 2)
++#define MODULE_FCINT (1 << 1)
++#define MODULE_HCINT (1)
++
++#define OTG_CORE_CINT_STEN (OTG_CORE_BASE+0x08) // 32bit core int enable reg
++
++#define MODULE_ASHNPINT_EN (1 << 5)
++#define MODULE_ASFCINT_EN (1 << 4)
++#define MODULE_ASHCINT_EN (1 << 3)
++#define MODULE_HNPINT_EN (1 << 2)
++#define MODULE_FCINT_EN (1 << 1)
++#define MODULE_HCINT_EN (1)
++
++#define OTG_CORE_CLK_CTRL (OTG_CORE_BASE+0x0C) // 32bit core clock control reg
++
++#define MODULE_FUNC_CLK (1 << 2)
++#define MODULE_HOST_CLK (1 << 1)
++#define MODULE_MAIN_CLK (1)
++
++#define OTG_CORE_RST_CTRL (OTG_CORE_BASE+0x10) // 32bit core reset control reg
++
++#define MODULE_RSTI2C (1 << 15)
++#define MODULE_RSTCTRL (1 << 5)
++#define MODULE_RSTFC (1 << 4)
++#define MODULE_RSTFSIE (1 << 3)
++#define MODULE_RSTRH (1 << 2)
++#define MODULE_RSTHSIE (1 << 1)
++#define MODULE_RSTHC (1)
++
++#define OTG_CORE_FRM_INTVL (OTG_CORE_BASE+0x14) // 32bit core frame interval reg
++
++#define MODULE_RESET_FRAME (1 << 15)
++
++#define OTG_CORE_FRM_REMAIN (OTG_CORE_BASE+0x18) // 32bit core frame remaining reg
++
++#define OTG_CORE_HNP_CSTAT (OTG_CORE_BASE+0x1C) // 32bit core HNP current state reg
++
++#define MODULE_HNPDAT (1 << 30)
++#define MODULE_VBUSBSE (1 << 29)
++#define MODULE_VBUSABSV (1 << 28)
++#define MODULE_VBUSGTAVV (1 << 27)
++
++#define MODULE_ARMTHNPE (1 << 25)
++#define MODULE_BHNPEN (1 << 24)
++
++#define MODULE_SLAVE (1 << 22)
++#define MODULE_MASTER (1 << 21)
++#define MODULE_BGEN (1 << 20)
++#define MODULE_CMPEN (1 << 19)
++#define MODULE_ISBDEV (1 << 18)
++#define MODULE_ISADEV (1 << 17)
++
++#define MODULE_SWVBUSPUL (1 << 15)
++
++#define MODULE_SWAUTORST (1 << 12)
++#define MODULE_SWPUDP (1 << 11)
++
++#define MODULE_SWPDDM (1 << 9)
++#define MODULE_HNPSTATE (0x1f << 8)
++#define MODULE_CLRERROR (1 << 3)
++#define MODULE_ADROPBUS (1 << 2)
++#define MODULE_ABBUSREQ (1 << 1)
++
++#define HNP_A_IDLE (0x10 << 8)
++#define HNP_A_MASTER (0x11 << 8)
++#define HNP_A_SLAVE (0x12 << 8)
++#define HNP_A_WAIT_VPULSE (0x13 << 8)
++
++#define HNP_A_WAIT_DPULSE (0x14 << 8)
++#define HNP_A_WAIT_CONN_A (0x15 << 8)
++#define HNP_A_WAIT_CONN_B (0x16 << 8)
++#define HNP_A_WAIT_VRISE (0x17 << 8)
++#define HNP_A_SUSPEND (0x18 << 8)
++#define HNP_A_WAIT_VFALL (0x19 << 8)
++#define HNP_A_VBUS_ERR (0x1a << 8)
++#define HNP_CONN_DEBOUNCE (0x1b << 8)
++#define HNP_A_WAIT_ABREQ (0x1c << 8)
++#define HNP_B_IDLE (0x00 << 8)
++#define HNP_B_MASTER (0x01 << 8)
++#define HNP_B_SLAVE (0x02 << 8)
++#define HNP_B_SRP_INIT_V (0x03 << 8)
++#define HNP_B_SRP_INIT_D (0x04 << 8)
++#define HNP_B_PRE_WAIT_CONN_AB_SHORT_DB (0x05 << 8)
++#define HNP_B_WAIT_CONN_A (0x06 << 8)
++#define HNP_B_PRE_SLAVE (0x0a << 8)
++
++
++#define OTG_CORE_HNP_TIMER1 (OTG_CORE_BASE+0x20) // 32bit core HNP timer 1 reg
++#define OTG_CORE_HNP_TIMER2 (OTG_CORE_BASE+0x24) // 32bit core HNP timer 2 reg
++#define OTG_CORE_HNP_T3PCR (OTG_CORE_BASE+0x28) // 32bit core HNP timer 3 pulse ctrl
++
++#define HNP_DATAPULSE (1 << 5)
++#define HNP_VBUSPULSE (1 << 4)
++
++#define OTG_CORE_HINT_STAT (OTG_CORE_BASE+0x2C) // 32bit core HNP int status reg
++
++#define HNP_I2COTGINT (1 << 15)
++#define HNP_AWAITBTO (1 << 8) // Hardware HNP Only
++#define HNP_AIDLEBDTO (1 << 7) // Hardware HNP Only
++#define HNP_SRPSUCFAIL (1 << 6) // Hardware HNP Only
++#define HNP_SRPINT (1 << 5)
++#define HNP_VBUSERROR (1 << 4) // Hardware HNP Only
++#define HNP_ABSEVAILD (1 << 3)
++#define HNP_ABUSVALID (1 << 2)
++#define HNP_MASSLVCHG (1 << 1) // Hardware HNP Only
++#define HNP_IDCHANGE (1)
++
++#define OTG_CORE_HINT_STEN (OTG_CORE_BASE+0x30) // 32bit core HNP int enable reg
++
++#define HNP_I2COTGINT_EN (1 << 15)
++#define HNP_AWAITBTO_EN (1 << 8)
++#define HNP_AIDLEBDTO_EN (1 << 7)
++#define HNP_SRPSUCFAIL_EN (1 << 6)
++#define HNP_SRPINT_EN (1 << 5)
++#define HNP_VBUSERROR_EN (1 << 4)
++#define HNP_ABSEVAILD_EN (1 << 3)
++#define HNP_ABUSVALID_EN (1 << 2)
++#define HNP_MASSLVCHG_EN (1 << 1)
++#define HNP_IDCHANGE_EN (1)
++
++
++#define OTG_CORE_CPUEPSEL_STAT (OTG_CORE_BASE+0x34)
++#define OTG_CORE_INTERRUPT_STEN (OTG_CORE_BASE+0x3c)
++/*! @} */
++
++
++/*!
++ * @name C.f. 23.11.11 Host Registers
++ */
++ /*! @{ */
++
++
++#define OTG_HOST_CONTROL (OTG_HOST_BASE+0x00) // 32bit host controller config reg
++
++#define HOST_CONTROL_HCRESET (1 << 31)
++#define HOST_CONTROL_RMTWUEN (1 << 4)
++
++#define HOST_CONTROL_HCUSBSTE_RESET (0 << 2)
++#define HOST_CONTROL_HCUSBSTE_RESUME (1 << 2)
++#define HOST_CONTROL_HCUSBSTE_OPERATIONAL (2 << 2)
++#define HOST_CONTROL_HCUSBSTE_SUSPEND (3 << 2)
++
++#define HOST_CONTROL_CTLBLKSR_11 (0)
++#define HOST_CONTROL_CTLBLKSR_21 (1)
++#define HOST_CONTROL_CTLBLKSR_41 (2)
++#define HOST_CONTROL_CTLBLKSR_81 (3)
++
++
++#define OTG_HOST_SINT_STAT (OTG_HOST_BASE+0x08) // 32bit host system int status reg
++
++#define HOST_PSCINT (1 << 6) // Port Status Change
++#define HOST_FMOFINT (1 << 5) // Frame Number Overflow
++#define HOST_HERRINT (1 << 4) // Host Error
++#define HOST_RESDETINT (1 << 3) // Resume Detected
++#define HOST_SOFINT (1 << 2) // Start of Frame
++#define HOST_DONEINT (1 << 1) // Done Register
++#define HOST_SORINT (1) // Schedule Overrun
++
++#define OTG_HOST_SINT_STEN (OTG_HOST_BASE+0x0C) // 32bit host system int enable reg
++
++#define HOST_PSCINT_EN (1 << 6) // Port Status Change
++#define HOST_FMOFINT_EN (1 << 5) // Frame Number Overflow
++#define HOST_HERRINT_EN (1 << 4) // Host Error
++#define HOST_RESDETINT_EN (1 << 3) // Resume Detected
++#define HOST_SOFINT_EN (1 << 2) // Start of Frame
++#define HOST_DONEINT_EN (1 << 1) // Done Register
++#define HOST_SORINT_EN (1) // Schedule Overrun
++
++#define OTG_HOST_XINT_STAT (OTG_HOST_BASE+0x18) // 32bit host X buf int status reg
++#define OTG_HOST_YINT_STAT (OTG_HOST_BASE+0x1C) // 32bit host Y buf int status reg
++
++#define OTG_HOST_XYINT_STEN (OTG_HOST_BASE+0x20) // 32bit host XY buf int enable reg
++#define OTG_HOST_XFILL_STAT (OTG_HOST_BASE+0x28) // 32bit host X filled status reg
++#define OTG_HOST_YFILL_STAT (OTG_HOST_BASE+0x2C) // 32bit host Y filled status reg
++
++#define OTG_HOST_ETD_EN (OTG_HOST_BASE+0x40) // 32bit host ETD enables reg
++#define OTG_HOST_DIR_ROUTE (OTG_HOST_BASE+0x48) // 32bit host direct routing reg
++#define OTG_HOST_IINT (OTG_HOST_BASE+0x4C) // 32bit host immediate interrupt reg
++
++#define OTG_HOST_EP_DSTAT (OTG_HOST_BASE+0x50) // 32bit host endpoints done status
++#define OTG_HOST_ETD_DONE (OTG_HOST_BASE+0x54) // 32bit host ETD done reg
++
++#define OTG_HOST_FRM_NUM (OTG_HOST_BASE+0x60) // 32bit host frame number reg
++#define OTG_HOST_LSP_THRESH (OTG_HOST_BASE+0x64) // 32bit host low speed threshold reg
++
++#define OTG_HOST_ROOTHUB_DESCA (OTG_HOST_BASE+0x68) // 32bit host root hub descriptor A
++#define OTG_HOST_ROOTHUB_DESCB (OTG_HOST_BASE+0x6C) // 32bit host root hub descriptor B
++/* @} */
++
++/*!
++ * @name C.f. 23.11.29
++ */
++/*! @{ */
++#define OTG_HOST_ROOTHUB_STATUS (OTG_HOST_BASE+0x70) // 32bit host root hub status reg
++
++#define ROOTHUB_STATUS_CLRMTWUE (1 << 31) // Clear Remote Wakeup Enable
++#define ROOTHUB_STATUS_OVRCURCHG (1 << 17) // Over Current Indicator Change
++#define ROOTHUB_STATUS_LOCPWRSC (1 << 16) // Local Power Status Change
++#define ROOTHUB_STATUS_DEVCONWUE (1 << 15) // Device Connect Wakeup Enable
++#define ROOTHUB_STATUS_OVRCURI (1 << 1) // Over Current Indicator
++#define ROOTHUB_STATUS_LOCPWRS (1) // Local Power Status
++/*! @} */
++
++
++/*!
++ * @name C.f. 23.11.30
++ */
++/*! @{ */
++#define OTG_HOST_PORT_STATUS_1 (OTG_HOST_BASE+0x74) // 32bit host port 1 status bits
++#define OTG_HOST_PORT_STATUS_2 (OTG_HOST_BASE+0x78) // 32bit host port 2 status bits
++#define OTG_HOST_PORT_STATUS_3 (OTG_HOST_BASE+0x7c) // 32bit host port 3 status bits
++
++#define PORT_STATUS_PRTRSTSC (1 << 20) // Port Reset Status Change
++#define PORT_STATUS_OVRCURIC (1 << 19) // Port Over Current Indicator Change
++#define PORT_STATUS_PRTSTATSC (1 << 18) // Port Suspend Status Change
++#define PORT_STATUS_PRTENBLSC (1 << 17) // Port Enable Status Change
++#define PORT_STATUS_CONNECTSC (1 << 16) // Connect Status Change
++
++#define PORT_STATUS_LSDEVCON (1 << 9) // Low Speed Device Attached
++#define PORT_STATUS_PRTPWRST (1 << 8) // Port Power Status
++
++#define PORT_STATUS_PRTRSTST (1 << 4) // Port Reset Status
++#define PORT_STATUS_PRTOVRCURI (1 << 3) // Port Over Current Indicator
++#define PORT_STATUS_PRTSUSPST (1 << 2) // Port Suspend Status
++#define PORT_STATUS_PRTENABST (1 << 1) // Port Enable Status
++#define PORT_STATUS_CURCONST (1) // Current Connect Status
++
++
++/* flags are the same for the interrupt, control and bulk transfer descriptors */
++// R1: sec 23.11.10.2,3 pg 23-44,47
++#define ETD_GET_COMPCODE(flags) ((flags >> 12) & 0xf)
++// R1: sec 23.11.10 Table 23-23 pg 23-40
++#define ETD_CC_NOERROR 0x0
++#define ETD_CC_CRCERR 0x1
++#define ETD_CC_BITSTUFFERR 0x2
++#define ETD_CC_DATATOGERR 0x3
++#define ETD_CC_STALL 0x4
++#define ETD_CC_DEVNOTRESPONDING 0x5
++#define ETD_CC_PIDFAILURE 0x6
++// Reserved 0x7
++#define ETD_CC_DATAOVERRUN 0x8
++#define ETD_CC_DATAUNDERRUN 0x9
++#define ETD_CC_ACK 0xA
++#define ETD_CC_NAK 0xB
++#define ETD_CC_BUFFEROVERRUN 0xC
++#define ETD_CC_BUFFERUNDERRUN 0xD
++#define ETD_CC_SCHEDOVERRUN 0xE
++#define ETD_CC_NOTACCESSED 0xF
++
++// R1: sec 23.11.10.2,3 pg 23-44,47 (contd)
++#define ETD_GET_ERRORCNT(flags) (((flags) >> 8) & 0xf)
++#define ETD_GET_DATATOGL(flags) (((flags) >> 6) & 0x3)
++#define ETD_SET_DATATOGL(v) (((v) & 0x3) << 6)
++#define ETD_GET_DELAYINT(flags) (((flags) >> 3) & 0x7)
++#define ETD_SET_DELAYINT(v) (((v) & 0x7) << 3)
++#define ETD_GET_BUFROUND(flags) (((flags) >> 2) & 0x1)
++#define ETD_SET_BUFROUND(v) (((v) & 0x1) << 2)
++#define ETD_GET_DIRPID(flags) ((flags) & 0x3)
++#define ETD_SET_DIRPID(v) ((v) & 0x3)
++#define ETD_FLIP_DIRPID(flags) ((flags) ^ 0x3) /* xor with 0x3 flips 2<->1 (IN<->OUT) */
++#define ETD_DIRPID_SETUP 0x0 // OUT
++#define ETD_DIRPID_OUT 0x1
++#define ETD_DIRPID_IN 0x2
++#define ETD_DIRPID_RESERVED 0x3
++
++// For non-isoc td.w3.val -
++#define ETD_GET_BUFSIZE(w3) (((w3) >> 21) & 0xfff)
++#define ETD_SET_BUFSIZE(v) (((v) & 0xfff) << 21)
++#define ETD_GET_TOTBYECNT(w3) ((w3) & 0xfffff)
++#define ETD_SET_TOTBYECNT(v) ((v) & 0xfffff)
++
++/* isoc flags shares the COMPCODE and DELAYINT bitfields with the other TDs,
++ but the remaining bits are different. */
++#define ETD_GET_AUTOISO(flags) (((flags) >> 11) & 0x1)
++#define ETD_SET_AUTOISO(v) (((v) & 0x1) << 11)
++#define ETD_GET_FRAMECNT(flags) (((flags) >> 8) & 0x1)
++#define ETD_SET_FRAMECNT(v) (((v) & 0x1) << 8)
++// For isoc td.w3.val -
++/* pkt1 and pkt0 use the COMPCODE bitfield, and add a PKTLEN field. */
++#define ETD_GET_PKTLEN(pkt) ((pkt) & 0x3ff)
++#define ETD_SET_PKTLEN(v) ((v) & 0x3ff)
++
++
++// ETD endpoint descriptor (etd->epd) bitfield access
++// R1: sec 23.11.10.1 pg 23-41 (word0)
++#define ETD_GET_SNDNAK(epd) (((epd) >> 30) & 0x1)
++#define ETD_SET_SNDNAK(v) (((v) & 0x1) << 30)
++#define ETD_GET_TOGCRY(epd) (((epd) >> 28) & 0x1)
++#define ETD_SET_TOGCRY(v) (((v) & 0x1) << 28)
++#define ETD_GET_HALTED(epd) (((epd) >> 27) & 0x1)
++#define ETD_SET_HALTED(v) (((v) & 0x1) << 27)
++#define ETD_GET_MAXPKTSIZ(epd) (((epd) >> 16) & 0x3ff)
++#define ETD_SET_MAXPKTSIZ(v) (((v) & 0x3ff) << 16)
++#define ETD_GET_FORMAT(epd) (((epd) >> 14) & 0x3)
++#define ETD_SET_FORMAT(v) (((v) & 0x3) << 14)
++#define ETD_FORMAT_CONTROL 0x0
++#define ETD_FORMAT_ISOC 0x1
++#define ETD_FORMAT_BULK 0x2
++#define ETD_FORMAT_INTERRUPT 0x3
++#define ETD_GET_SPEED(epd) (((epd) >> 13) & 0x1)
++#define ETD_SET_SPEED(v) (((v) & 0x1) << 13)
++#define ETD_SPEED_FULL 0x0
++#define ETD_SPEED_LOW 0x1
++#define ETD_GET_DIRECT(epd) (((epd) >> 11) & 0x3)
++#define ETD_SET_DIRECT(v) (((v) & 0x3) << 11)
++/* xor with 3 flips 2<->1 */
++#define ETD_FLIP_DIRECT(epd) ((epd) ^ (0x3 << 11))
++#define ETD_DIRECT_TD00 0x0
++#define ETD_DIRECT_OUT 0x1
++#define ETD_DIRECT_IN 0x2
++#define ETD_DIRECT_TD11 0x3
++#define ETD_GET_ENDPNT(epd) (((epd) >> 7) & 0xf)
++#define ETD_SET_ENDPNT(v) (((v) & 0xf) << 7)
++#define ETD_GET_ADDRESS(epd) ((epd) & 0x7f)
++#define ETD_SET_ADDRESS(v) ((v) & 0x7f)
++
++// etd_urb_state[] values
++#define ETD_URB_COMPLETED 0
++#define ETD_URB_SETUP_STATUS 1
++#define ETD_URB_SETUP_DATA 2
++#define ETD_URB_SETUP_START 3
++#define ETD_URB_BULK_START 4
++#define ETD_URB_BULKWZLP 5
++#define ETD_URB_BULKWZLP_START 6
++#define ETD_URB_INTERRUPT_START 7
++#define ETD_URB_ISOC_START 8
++/*! @} */
++
++
++/*!
++ * @name C.f. 23.12.8 Function Registers
++ */
++/*! @{ */
++
++#define OTG_FUNC_CMD_STAT (OTG_FUNC_BASE+0x00) // 32bit func command status reg
++
++#define COMMAND_SOFTRESET (1 << 7)
++#define COMMAND_BADISOAP (1 << 3)
++#define COMMAND_SUPDET (1 << 2)
++#define COMMAND_RSMINPROG (1 << 1)
++#define COMMAND_RESETDET (1)
++
++
++#define OTG_FUNC_DEV_ADDR (OTG_FUNC_BASE+0x04) // 32bit func device address reg
++
++#define OTG_FUNC_SINT_STAT (OTG_FUNC_BASE+0x08) // 32bit func system int status reg
++
++#define SYSTEM_DONEREGINTDS (1 << 5)
++#define SYSTEM_SOFDETINT (1 << 4)
++#define SYSTEM_DONEREGINT (1 << 3)
++#define SYSTEM_SUSPDETINT (1 << 2)
++#define SYSTEM_RSMFININT (1 << 1)
++#define SYSTEM_RESETINT (1)
++
++#define OTG_FUNC_SINT_STEN (OTG_FUNC_BASE+0x0C) // 32bit func system int enable reg
++
++#define SYSTEM_DONEREGINTDS_EN (1 << 5)
++#define SYSTEM_SOFDETINT_EN (1 << 4)
++#define SYSTEM_DONEREGINT_EN (1 << 3)
++#define SYSTEM_SUSPDETINT_EN (1 << 2)
++#define SYSTEM_RSMFININT_EN (1 << 1)
++#define SYSTEM_RESETINT_EN (1)
++
++
++#define OTG_FUNC_XINT_STAT (OTG_FUNC_BASE+0x10) // 32bit func X buf int status reg
++#define OTG_FUNC_YINT_STAT (OTG_FUNC_BASE+0x14) // 32bit func Y buf int status reg
++#define OTG_FUNC_XYINT_STEN (OTG_FUNC_BASE+0x18) // 32bit func XY buf int enable reg
++#define OTG_FUNC_XFILL_STAT (OTG_FUNC_BASE+0x1C) // 32bit func X filled status reg
++
++#define OTG_FUNC_YFILL_STAT (OTG_FUNC_BASE+0x20) // 32bit func Y filled status reg
++#define OTG_FUNC_EP_EN (OTG_FUNC_BASE+0x24) // 32bit func endpoints enable reg
++#define OTG_FUNC_EP_RDY (OTG_FUNC_BASE+0x28) // 32bit func endpoints ready reg
++#define OTG_FUNC_IINT (OTG_FUNC_BASE+0x2C) // 32bit func immediate interrupt reg
++
++#define OTG_FUNC_EP_DSTAT (OTG_FUNC_BASE+0x30) // 32bit func endpoints done status
++#define OTG_FUNC_EP_DEN (OTG_FUNC_BASE+0x34) // 32bit func endpoints done enable
++#define OTG_FUNC_EP_TOGGLE (OTG_FUNC_BASE+0x38) // 32bit func endpoints toggle bits
++#define OTG_FUNC_FRM_NUM (OTG_FUNC_BASE+0x3C) // 32bit func frame number reg
++
++
++#define EP0_STALL (1 << 31)
++#define EP0_SETUP (1 << 30)
++#define EP0_OVERRUN (1 << 29)
++#define EP0_AUTOISO (1 << 27)
++
++
++/* generic endpoint register manipulations
++ */
++#define EP_OUT 0x1
++#define EP_IN 0x2
++#define EP_BOTH 0x3
++
++#define ETD_MASK(n) (1 << n)
++#define ep_num_both(n) (EP_BOTH << n)
++#define ep_num_dir(n, dir) ((dir ? EP_IN : EP_OUT) << (n*2))
++#define ep_num_out(n) ep_num_dir(n, USB_DIR_OUT)
++#define ep_num_in(n) ep_num_dir(n, USB_DIR_IN)
++
++
++/* ep descriptor access
++ */
++static __inline__ u32 etd_word(int n, int word)
++{
++ u32 offset = n * 16;
++ offset += word * 4;
++ return OTG_ETD_BASE + offset;
++}
++
++/* ep descriptor access
++ */
++static __inline__ u32 ep_word(int n, int dir, int word)
++{
++ u32 offset = n * 2;
++ offset += dir ? 1 : 0;
++ offset *= 16;
++ offset += word * 4;
++ return OTG_EP_BASE + offset;
++}
++
++/* endpoint data buffer access
++ *
++ * This is a simplistic allocator, will do until we want to support ISO or host mode.
++ *
++ * This works because we are assuming a maximum of 16 allocate endpoints, and no
++ * overlapped endpoints (both in and out are allocated).
++ */
++
++static volatile __inline__ u16 data_x_buf(int n, int dir)
++{
++ return 0x40 * (n * 4 + 2 * (dir ? 1 : 0));
++}
++static volatile __inline__ u16 data_y_buf(int n, int dir)
++{
++ return 0x40 * (n * 4 + 2 * (dir ? 1 : 0) + 1);
++}
++
++static volatile __inline__ u8 * data_x_address(int n, int dir)
++{
++ return (volatile u8 *) IO_ADDRESS(OTG_DATA_BASE + data_x_buf(n, dir));
++}
++static volatile __inline__ u8 * data_y_address(int n, int dir)
++{
++ return (volatile u8 *) IO_ADDRESS(OTG_DATA_BASE + data_y_buf(n, dir));
++}
++/*! @} */
++
++/*!
++ * @name C.f. 23.13.3 DMA Registers
++ */
++/*! @{ */
++#define OTG_DMA_REV_NUM (OTG_DMA_BASE+0x000) // 32bit dma revision number reg
++#define OTG_DMA_DINT_STAT (OTG_DMA_BASE+0x004) // 32bit dma int status reg
++#define OTG_DMA_DINT_STEN (OTG_DMA_BASE+0x008) // 32bit dma int enable reg
++#define OTG_DMA_ETD_ERR (OTG_DMA_BASE+0x00C) // 32bit dma ETD error status reg
++#define OTG_DMA_EP_ERR (OTG_DMA_BASE+0x010) // 32bit dma EP error status reg
++#define OTG_DMA_ETD_EN (OTG_DMA_BASE+0x020) // 32bit dma ETD DMA enable reg
++#define OTG_DMA_EP_EN (OTG_DMA_BASE+0x024) // 32bit dma EP DMA enable reg
++#define OTG_DMA_ETD_ENXREQ (OTG_DMA_BASE+0x028) // 32bit dma ETD DMA enable Xtrig req
++#define OTG_DMA_EP_ENXREQ (OTG_DMA_BASE+0x02C) // 32bit dma EP DMA enable Ytrig req
++#define OTG_DMA_ETD_ENXYREQ (OTG_DMA_BASE+0x030) // 32bit dma ETD DMA enble XYtrig req
++#define OTG_DMA_EP_ENXYREQ (OTG_DMA_BASE+0x034) // 32bit dma EP DMA enable XYtrig req
++#define OTG_DMA_ETD_BURST4 (OTG_DMA_BASE+0x038) // 32bit dma ETD DMA enble burst4 reg
++#define OTG_DMA_EP_BURST4 (OTG_DMA_BASE+0x03C) // 32bit dma EP DMA enable burst4 reg
++#define OTG_DMA_MISC_CTRL (OTG_DMA_BASE+0x040) // 32bit dma EP misc control reg
++#define OTG_DMA_ETD_CH_CLR (OTG_DMA_BASE+0x044) // 32bit dma ETD clear channel reg
++#define OTG_DMA_EP_CH_CLR (OTG_DMA_BASE+0x048) // 32bit dma EP clear channel reg
++
++
++#define OTG_DMA_ETD_CH_CLR (OTG_DMA_BASE+0x044) // 32bit dma ETD clear channel reg
++#define OTG_DMA_ETD_ERR (OTG_DMA_BASE+0x00C) // 32bit dma ETD error status reg
++#define OTG_DMA_ETD_EN (OTG_DMA_BASE+0x020) // 32bit dma ETD DMA enable reg
++#define OTG_DMA_ETD_ENXREQ (OTG_DMA_BASE+0x028) // 32bit dma ETD DMA enable Xtrig req
++#define OTG_DMA_ETD_ENXYREQ (OTG_DMA_BASE+0x030) // 32bit dma ETD DMA enble XYtrig req
++#define OTG_DMA_ETD_BURST4 (OTG_DMA_BASE+0x038) // 32bit dma ETD DMA enble burst4 reg
++
++
++
++#define OTG_DMA_EP_CH_CLR (OTG_DMA_BASE+0x048) // 32bit dma EP clear channel reg
++#define OTG_DMA_EP_ERR (OTG_DMA_BASE+0x010) // 32bit dma EP error status reg
++#define OTG_DMA_EP_EN (OTG_DMA_BASE+0x024) // 32bit dma EP DMA enable reg
++#define OTG_DMA_EP_ENXREQ (OTG_DMA_BASE+0x02C) // 32bit dma EP DMA enable Ytrig req
++#define OTG_DMA_EP_ENXYREQ (OTG_DMA_BASE+0x034) // 32bit dma EP DMA enable XYtrig req
++#define OTG_DMA_EP_BURST4 (OTG_DMA_BASE+0x03C) // 32bit dma EP DMA enable burst4 reg
++
++
++#define dma_num_dir(n, dir) (n * 2 + (dir ? 1 : 0))
++#define dma_num_out(n) dma_num_dir(n, USB_DIR_OUT)
++#define dma_num_in(n) dma_num_dir(n, USB_DIR_IN)
++
++#define OTG_DMA_ETD_MSA(x) (OTG_DMA_BASE+0x100+x*4)
++#define OTG_DMA_EPN_MSA(x) (OTG_DMA_BASE+0x180+x*4)
++#define OTG_DMA_ETDN_BPTR(x) (OTG_DMA_BASE+0x280+x*4)
++#define OTG_DMA_EPN_BPTR(x) (OTG_DMA_BASE+0x284+x*4)
++
++/*! @} */
++
++/* ********************************************************************************************** */
++/*!
++ * Warning: the MX21 memory mapped region appears to require 32-bit access only.
++ * As of this writing, only the ETD region has been tested, but it does show the
++ * following behavior:
++ *
++ * Step 1: *(volatile u32 *)(void*)0xe40243f8 == 00000000
++ * Step 2: *(volatile u16 *)(void*)0xe40243f8 = 0x0084;
++ * Step 3: *(volatile u32 *)(void*)0xe40243f8 == 00840084
++ * Step 4: *(volatile u8 *)(void*)(0xe40243f8+3) = 0x01;
++ * Step 5: *(volatile u32 *)(void*)0xe40243f8 == 01010101
++ *
++ * Any access to less than 32 bits is replicated as many times as required
++ * to make 32 bits, and the surrounding 32-bit region is changed.
++ *
++ * Just to add insult to injury, gcc 3.2.3 wants to store constants
++ * that are small enough using byte instructions. E.g.
++ *
++ * mm->host.System_Interrupt_Enables = (SIEN_PSCIEN | SIEN_FMOFIEN | SIEN_HERRIEN | SIEN_RESDETIEN |
++ * SIEN_DONEIEN | SIEN_SORIEN);
++ *
++ * becomes:
++ *
++ * ldrb r2, [r3, #140]
++ * mov r2, #123
++ * strb r2, [r3, #140]
++ * ldrb r2, [r3, #141]
++ * strb r1, [r3, #141]
++ * ldrb r2, [r3, #142]
++ * strb r1, [r3, #142]
++ * ldrb r2, [r3, #143]
++ * strb r1, [r3, #143]
++ *
++ * which, given the 32-bit access restrictions above,
++ * is not going to work very well. Changing the original assignment to:
++ *
++ * *&(mm->host.System_Interrupt_Enables) = (SIEN_PSCIEN | SIEN_FMOFIEN | SIEN_HERRIEN | SIEN_RESDETIEN |
++ * SIEN_DONEIEN | SIEN_SORIEN);
++ *
++ * which should be identical, from a language definition point of view,
++ * produces:
++ *
++ * mov r2, #123
++ * str r2, [r3, #140]
++ *
++ */
++
++
++/*!
++ * @name TransferDescriptors
++ *
++ * Note that the MX21 needs to run in little-endian mode for OTG, but
++ * since the memory can only be accessed in 32-bit quantities, anything
++ * smaller will be built in regular memory, then transfered one word at
++ * a time to the memory-mapped registers, and that word access will flip
++ * the order of bytes. u16 quantities survive this flipping because they
++ * get "pre-flipped" in regular memory.
++ *
++ *
++ * An Endpoint Transfer Descriptor (ETD) consists of 4x32bit words.
++ * The first word is the Endpoint Descriptor, the last three are
++ * the transfer descriptor. Transfer descriptors come in 3 formats,
++ * CONTROL/BULK, INTERRUPT, and ISOCRONOUS. Becasue of the memory
++ * access restrictions to less than 32 bits described above, only
++ * the words are mapped directly, The smaller fields are assembled
++ * into 32-bit words before being placed into the live ETD.
++ *
++ */
++ /*! @{ */
++
++/*!
++ * @struct transfer_descriptor_w1
++ * All three types of TD have the same format for w1.
++ */
++typedef struct transfer_descriptor_w1 {
++#if defined(LITTLE_ENDIAN)
++ u16 x;
++ u16 y;
++#else
++ u16 y;
++ u16 x;
++#endif
++} __attribute__ ((packed)) volatile transfer_descriptor_w1;
++
++/*!
++ * @struct control_bulk_transfer_descriptor_w2
++ * There are 3 different formats for w2.
++ * C.f. R1: sec 23.11.10.2 pg 23-43
++ */
++typedef struct control_bulk_transfer_descriptor_w2 {
++#if defined(LITTLE_ENDIAN)
++ u8 rtrydelay;
++ u8 reserved;
++ u16 flags;
++#else
++ u16 flags;
++ u8 reserved;
++ u8 rtrydelay;
++#endif
++} __attribute__ ((packed)) volatile control_bulk_transfer_descriptor_w2;
++
++/*!
++ * @struct interrupt_transfer_descriptor_w2
++ * C.f. R1: sec 23.11.10.3 pg 23-46
++ */
++typedef struct interrupt_transfer_descriptor_w2 {
++#if defined(LITTLE_ENDIAN)
++ u8 polinterv;
++ u8 relpolpos;
++ u16 flags;
++#else
++ u16 flags;
++ u8 relpolpos;
++ u8 polinterv;
++#endif
++} __attribute__ ((packed)) volatile interrupt_transfer_descriptor_w2;
++
++/*!
++ * @struct isoc_transfer_descriptor_w2
++ * C.f. R1: sec 23.11.10.4 pg 23-48
++ */
++typedef struct isoc_transfer_descriptor_w2 {
++#if defined(LITTLE_ENDIAN)
++ u16 startfrm;
++ u16 flags;
++#else
++ u16 flags;
++ u16 startfrm;
++#endif
++} __attribute__ ((packed)) volatile isoc_transfer_descriptor_w2;
++
++
++
++/*!
++ * @struct isoc_transfer_descriptor_w3
++ * There are 2 different formats for w3.
++ * All but isoc use a packet size and 20-bit bytecount, accessed through w3.val.
++ */
++typedef struct isoc_transfer_descriptor_w3 {
++#if defined(LITTLE_ENDIAN)
++ u16 pkt0;
++ u16 pkt1;
++#else
++ u16 pkt1;
++ u16 pkt0;
++#endif
++} __attribute__ ((packed)) volatile isoc_transfer_descriptor_w3;
++
++/*!
++ * @name transfer_descriptor
++ */
++/*! @{ */
++typedef struct transfer_descriptor {
++ union {
++ u32 val;
++ transfer_descriptor_w1 bufsrtad;
++ } volatile w1;
++ union {
++ u32 val;
++ control_bulk_transfer_descriptor_w2 cb;
++ interrupt_transfer_descriptor_w2 intr;
++ isoc_transfer_descriptor_w2 isoc;
++ } volatile w2;
++ union {
++ u32 val;
++ isoc_transfer_descriptor_w3 isoc;
++ } volatile w3;
++} __attribute__ ((packed)) volatile transfer_descriptor;
++
++/*! @} */
++
++/*!
++ * @name endpoint_transfer_descriptor
++ * C.f. R1: sec 23.11.10 pg 23-41
++ */
++ /*! @{ */
++typedef struct endpoint_transfer_descriptor {
++ u32 epd;
++ transfer_descriptor td;
++} __attribute__ ((packed)) volatile endpoint_transfer_descriptor; // ETD
++
++/*! @} */
++
++
++/*!
++ * @name DataBuffs
++ *
++ * There is no predetermined size for data buffers, so
++ * this structure was chosen as an arbitrary, but generally
++ * adequate size.
++ */
++/*! @{ */
++
++/*!
++ * @struct fs_data_buff
++ */
++typedef struct fs_data_buff {
++ u32 data[DATA_BUFF_SIZE/sizeof(u32)]; // Cannot safely write less than 32-bit quantities
++} volatile fs_data_buff;
++
++
++/*!
++ * @struct fs_hcpriv
++ */
++typedef struct fs_hcpriv {
++ struct bus_hcpriv *bus_hcpriv;
++ u32 sof_count;
++ u32 free_etds;
++ endpoint_transfer_descriptor sdp_etd[NUM_ETDS]; // Setup data phase save area
++ void *sdp_data[NUM_ETDS];
++ u8 etd_urb_state[NUM_ETDS];
++ u16 free_buffs;
++ u16 buff_list[NUM_DATA_BUFFS];
++} fs_hcpriv;
++
++
++/*!
++ * get_data_buff() - get data buff
++ */
++static __inline__ fs_data_buff *get_data_buff(fs_hcpriv *fs_hcpriv)
++{
++ // Get the next available free data_buff, return NULL if none available.
++ unsigned long flags;
++ fs_data_buff *db;
++ u16 ndx;
++ local_irq_save(flags);
++ if (0xffff != (ndx = fs_hcpriv->free_buffs)) {
++ fs_hcpriv->free_buffs = fs_hcpriv->buff_list[ndx];
++ db = ndx + (fs_data_buff *)OTG_DATA_BASE;
++ }
++ else
++ db = NULL;
++ local_irq_restore(flags);
++ return(db);
++}
++
++/*!
++ * rel_data_buff() - release data buff
++ */
++static __inline__ fs_data_buff *rel_data_buff(fs_hcpriv *fs_hcpriv, fs_data_buff *db)
++{
++ // Release db to the pool of available data_buffs.
++ unsigned long flags;
++ u16 ndx;
++ if (NULL != db) {
++ local_irq_save(flags);
++ ndx = db - (fs_data_buff *)OTG_DATA_BASE;
++ fs_hcpriv->buff_list[ndx] = fs_hcpriv->free_buffs;
++ fs_hcpriv->free_buffs = ndx;
++#if 0
++ db->next = fs_hcpriv->free_buffs;
++ fs_hcpriv->free_buffs = db;
++#endif
++ local_irq_restore(flags);
++ }
++ return(NULL);
++}
++
++/*!
++ * data_buff_boff() - get data buffer offset given address
++ */
++static __inline__ u16 data_buff_boff(fs_data_buff *db)
++{
++ return((u16)(((void *) db) - ((void *) OTG_DATA_BASE)));
++}
++
++/*!
++ * data_buff_addr() - get data buffer address given offset
++ */
++static __inline__ fs_data_buff *data_buff_addr(u16 boff)
++{
++ // Return the address of the fs_data_buffer that is boff bytes from the start of data buffer memory.
++ return(boff + ((void *) OTG_DATA_BASE));
++}
++/*! @} */
++
++/* ********************************************************************************************** */
++
++/*!
++ * @name FSUSBOTGIO
++ * @brief Freescale USBOTG I/O support.
++ */
++ /*! @{ */
++
++/*!
++ * fs_rb() - read a byte
++ * @param port
++ * @return byte read
++ */
++static u8 __inline__ fs_rb(u32 port)
++{
++ return *(volatile u8 *) (IO_ADDRESS(port));
++}
++
++/*!
++ * fs_rl() - read a long
++ * @param port
++ * @return word read
++ */
++static u32 __inline__ fs_rl(u32 port)
++{
++ return *(volatile u32 *) (IO_ADDRESS(port));
++}
++
++/*!
++ * fs_wb() - write a byte
++ * @param port
++ * @param val
++ */
++static void __inline__ fs_wb(u32 port, u8 val)
++{
++ *(volatile u8 *)(IO_ADDRESS(port)) = val;
++}
++
++/*!
++ * fs_orb() - or a byte
++ * @param port
++ * @param val
++ */
++static void __inline__ fs_orb(u32 port, u8 val)
++{
++ u8 set = fs_rb(port) | val;
++ *(volatile u8 *)(IO_ADDRESS(port)) = set;
++}
++
++/*!
++ * fs_andb() - and a byte
++ * @param port
++ * @param val
++ */
++static void __inline__ fs_andb(u32 port, u8 val)
++{
++ u8 set = fs_rb(port) & val;
++ *(volatile u8 *)(IO_ADDRESS(port)) = set;
++}
++
++/*!
++ * fs_wl() - write a long
++ * @param port
++ * @param val
++ */
++static void __inline__ fs_wl(u32 port, u32 val)
++{
++ u32 set;
++ *(volatile u32 *)(IO_ADDRESS(port)) = val;
++ set = fs_rl(port);
++}
++
++/*!
++ * fs_orl() - or a long
++ * @param port
++ * @param val
++ */
++static void __inline__ fs_orl(u32 port, u32 val)
++{
++ u32 set = fs_rl(port);
++ *(volatile u32 *)(IO_ADDRESS(port)) = (set | val);
++}
++
++/*!
++ * fs_andl() - and a long
++ * @param port
++ * @param val
++ */
++static void __inline__ fs_andl(u32 port, u32 val)
++{
++ u32 set = fs_rl(port);
++ *(volatile u32 *)(IO_ADDRESS(port)) = (set & val);
++}
++
++/*!
++ * fs_host_port_stat() - get host start port address for ports 1-3
++ * @param n
++ * @returns port address
++ */
++static u32 inline fs_host_port_stat(int n)
++{
++ switch (n) {
++ default:
++ case 1:
++ return OTG_HOST_PORT_STATUS_1;
++ case 2:
++ return OTG_HOST_PORT_STATUS_2;
++ case 3:
++ return OTG_HOST_PORT_STATUS_3;
++ }
++}
++
++
++/*!
++ * fs_wl_set() - set a word and verify
++ * @param tag
++ * @param port
++ * @param val
++ */
++static void inline fs_wl_set(otg_tag_t tag, u32 port, u32 val)
++{
++ u32 set;
++ *(volatile u32 *)(IO_ADDRESS(port)) = val;
++ set = fs_rl(port);
++ if ((set & val) != val) {
++ TRACE_MSG1(tag, "SET FAILED: %08x", set);
++ }
++}
++
++/*!
++ * fs_wl_clr() - clr a word and verify
++ * @param tag
++ * @param port
++ * @param clr
++ */
++static void inline fs_wl_clr(otg_tag_t tag, u32 port, u32 clr)
++{
++ u32 set;
++ *(volatile u32 *)(IO_ADDRESS(port)) = clr;
++ set = fs_rl(port);
++ if (set & clr) {
++ TRACE_MSG1(tag, "CLEAR FAILED 1: %08x", set);
++ *(volatile u32 *)(IO_ADDRESS(port)) = clr;
++ set = fs_rl(port);
++ if (set & clr)
++ TRACE_MSG1(tag, "CLEAR FAILED 2: %08x", set);
++ }
++}
++
++
++/*!
++ * fs_memcpy32() - emulage memcpy using long copy
++ * @param dp destination pointer
++ * @param sp source pointer
++ * @param words number of 32bit words to copy
++ *
++ */
++static void inline fs_memcpy32(u32 *dp, u32 *sp, volatile int words)
++{
++ while (words--) *dp++ = *sp++;
++}
++/*!
++ * fs_memcpy() - emulage memcpy using byte copy
++ * @param dp destination pointer
++ * @param sp source pointer
++ * @param bytes number of 8bit bytes to copy
++ */
++static void inline fs_memcpy(u8 *dp, u8 *sp, volatile int bytes)
++{
++ while (bytes--) *dp++ = *sp++;
++}
++/*!
++ * fs_clear_words() - clear memory
++ * @param addr address to clear from
++ * @param words number of 32bit words to clear.
++ */
++static void inline fs_clear_words(volatile u32 *addr, int words)
++{
++ while (words--) *addr++ = 0;
++}
++
++/*! @} */
++
+diff -uNr linux/drivers/no-otg/otghw/isp1301-hardware.h linux/drivers/otg/otghw/isp1301-hardware.h
+--- linux/drivers/no-otg/otghw/isp1301-hardware.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otghw/isp1301-hardware.h 2006-09-01 21:41:35.000000000 +0200
+@@ -0,0 +1,218 @@
++/*
++ * otg/otghw/isp1301-hardware.h -- ISP1301 hardware specific defines
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/otghw/isp1301-hardware.h
++ * @brief Public Structures And Defines For ISP1301 Hardware.
++ *
++ * The Phillips ISP1301 is an OTG Transceiver. There a additional
++ * compatible parts such as the Maxim MAX3301E
++ *
++ * @ingroup ISP1301TCD
++ */
++
++
++/*!
++ * @name ADR/PSW - C.f. 8.9.1
++ *
++ * The i2c address is either 0x2c or 0x2d depending on the level of the
++ * ADR/PSW pin after device reset. Note that this pin can be programmed as
++ * an output via the Mode Control 2 register, bit PSW_OE to enable an
++ * @{
++ */
++
++#define ISP1301_I2C_ADDR_LOW 0x2c
++#define ISP1301_I2C_ADDR_HIGH 0x2d
++/*! @} */
++
++/*!
++ * @name ISP1301 Registers C.f. 11.1
++ * @{
++ */
++
++#define ISP1301_VENDOR_ID 0x00
++#define ISP1301_PRODUCT_ID 0x02
++#define ISP1301_VERSION_ID 0x14
++
++#define ISP1301_VENDOR_ID_LOW 0x00
++#define ISP1301_PRODUCT_ID_LOW 0x02
++#define ISP1301_VERSION_ID_LOW 0x14
++#define ISP1301_VENDOR_ID_HIGH 0x01
++#define ISP1301_PRODUCT_ID_HIGH 0x03
++#define ISP1301_VERSION_ID_HIGH 0x15
++
++/* these are all single byte registers
++ */
++#define ISP1301_MODE_CONTROL_1 0x04
++#define ISP1301_MODE_CONTROL_1_SET 0x04
++#define ISP1301_MODE_CONTROL_1_CLR 0x05
++
++#define ISP1301_MODE_CONTROL_2 0x12
++#define ISP1301_MODE_CONTROL_2_SET 0x12
++#define ISP1301_MODE_CONTROL_2_CLR 0x13
++
++#define ISP1301_OTG_CONTROL 0x06
++#define ISP1301_OTG_CONTROL_SET 0x06
++#define ISP1301_OTG_CONTROL_CLR 0x07
++
++#define ISP1301_OTG_STATUS 0x10
++
++#define ISP1301_INTERRUPT_SOURCE 0x08
++
++#define ISP1301_INTERRUPT_LATCH 0x0a
++#define ISP1301_INTERRUPT_LATCH_SET 0x0a
++#define ISP1301_INTERRUPT_LATCH_CLR 0x0b
++
++#define ISP1301_INTERRUPT_ENABLE_LOW 0x0c
++#define ISP1301_INTERRUPT_ENABLE_LOW_SET 0x0c
++#define ISP1301_INTERRUPT_ENABLE_LOW_CLR 0x0d
++
++#define ISP1301_INTERRUPT_ENABLE_HIGH 0x0e
++#define ISP1301_INTERRUPT_ENABLE_HIGH_SET 0x0e
++#define ISP1301_INTERRUPT_ENABLE_HIGH_CLR 0x0f
++/*! @} */
++
++
++/*!
++ * @name Mode Control 1 register - C.f. Table 17 and Table 18
++ * @{
++ */
++#define ISP1301_UART_EN (1 << 6)
++#define ISP1301_OE_INT_EN (1 << 5)
++#define ISP1301_BDIS_ACON_EN (1 << 4)
++#define ISP1301_TRANSP_EN (1 << 3)
++#define ISP1301_DAT_SE0 (1 << 2)
++#define ISP1301_SUSPEND_REG (1 << 1)
++#define ISP1301_SPEED_REG (1 << 0)
++/*! @} */
++
++
++/*!
++ * @name Mode Control 2 register - C.f. Table 19 and Table 20
++ * @{
++ */
++#define ISP1301_EN2V7 (1 << 7)
++#define ISP1301_PSW_OE (1 << 6)
++#define ISP1301_AUDIO_EN (1 << 5)
++#define ISP1301_TRANSP_BDIR (3 << 3)
++#define ISP1301_BI_DI (1 << 2)
++#define ISP1301_SPD_SUSP_CTRL (1 << 1)
++#define ISP1301_GLOBAL_PWR_ON (1 << 0)
++/*! @} */
++
++
++/*!
++ * @name OTG Control register - C.f. Table 21 and Table 22
++ * @{
++ */
++#define ISP1301_VBUS_CHRG (1 << 7)
++#define ISP1301_VBUS_DISCHRG (1 << 6)
++#define ISP1301_VBUS_DRV (1 << 5)
++#define ISP1301_ID_PULLDOWN (1 << 4)
++#define ISP1301_DM_PULLDOWN (1 << 3)
++#define ISP1301_DP_PULLDOWN (1 << 2)
++#define ISP1301_DM_PULLUP (1 << 1)
++#define ISP1301_DP_PULLUP (1 << 0)
++
++#define ISP1301_VBUS_RESET (ISP1301_VBUS_CHRG | ISP1301_VBUS_DISCHRG | ISP1301_VBUS_DRV)
++
++/*! @} */
++
++
++/*!
++ * @name OTG Status register - C.f. Table 23 and Table 24
++ * @{
++ */
++#define ISP1301_B_SESS_VLD (1 << 7)
++#define ISP1301_B_SESS_END (1 << 6)
++/*! @} */
++
++
++/*!
++ * @name Interrupt Source Register
++ * Interrupt Source register - C.f. Table 25 and Table 26
++ * Interrupt Latch register - C.f. Table 27 and Table 28
++ * Interrupt Enable Low register - C.f. Table 29 and Table 30
++ * Interrupt Enable High register - C.f. Table 31 and Table 32
++ * @{
++ */
++#define ISP1301_CR_INT (1 << 7)
++#define ISP1301_BDIS_ACON (1 << 6)
++#define ISP1301_ID_FLOAT (1 << 5)
++#define ISP1301_DM_HI (1 << 4)
++#define ISP1301_ID_GND (1 << 3)
++#define ISP1301_DP_HI (1 << 2)
++#define ISP1301_SESS_VLD (1 << 1)
++#define ISP1301_VBUS_VLD (1 << 0)
++
++//#define ISP1301_SE1 (ISP1301_DM_HI | ISP1301_DP_HI)
++
++/*! @} */
++
++/*!
++ * @name Maxim MAX3301E
++ *
++ * This part is compatible with the ISP1301 with minor differences:
++ *
++ * Mode Control 1 register is called Control Register 1. It is almost
++ * identical except for:
++ *
++ * bit isp1301 max3301e
++ * 3 transp_en not used
++ * @{
++ */
++#define MAX3301E_CONTROL_REGISTER_1 0x04
++#define MAX3301E_CONTROL_REGISTER_1_SET 0x04
++#define MAX3301E_CONTROL_REGISTER_1_CLR 0x05
++/*! @} */
++
++/*!
++ * @name Mode Control 2
++ * Mode Control 2 is called Special Function Register 1. Mostly the same
++ * except for:
++ *
++ * bit isp1301 max3301e
++ * 7 en2v7 gp_en
++ * 6 psw_oe sess_end
++ * 5 audio_en int_source
++ * @{
++ */
++#define MAX3301E_SPECIAL_FUNCTION_1 0x12
++#define MAX3301E_SPECIAL_FUNCTION_1_SET 0x12
++#define MAX3301E_SPECIAL_FUNCTION_1_CLR 0x13
++#define MAX3301E_GP_EN (1 << 7)
++#define MAX3301E_SESS_END (1 << 6)
++#define MAX3301E_INT_SOURCE (1 << 5)
++/*! @} */
++
++/*!
++ * @name OTG Status
++ * The OTG Status is not present, but B_SESS_END seems to be available
++ * in the Mode Control 2 register bit 6.
++ *
++ * An additional register is available for MAX3301E specific features.
++ *
++ * Special Function Register 2
++ * @{
++ */
++
++#define MAX3301E_SPECIAL_FUNCTION_2 0x16
++#define MAX3301E_SPECIAL_FUNCTION_2_SET 0x16
++#define MAX3301E_SPECIAL_FUNCTION_2_CLR 0x17
++#define MAX3301E_SDWN (1 << 0)
++#define MAX3301E_IRQ_MODE (1 << 1)
++#define MAX3301E_XCVR_INPUT_DISC (1 << 2)
++#define MAX3301E_REQ_SET (1 << 3)
++/*! @} */
++
++
++
++
+diff -uNr linux/drivers/no-otg/otghw/isp1301.h linux/drivers/otg/otghw/isp1301.h
+--- linux/drivers/no-otg/otghw/isp1301.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otghw/isp1301.h 2006-09-01 21:41:35.000000000 +0200
+@@ -0,0 +1,158 @@
++/*
++ * otg/otghw/isp1301/isp1301.h -- USB Transceiver Controller driver
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @defgroup ISP1301TCD Phillips ISP1301
++ * @ingroup tcdgroup
++ */
++/*!
++ * @file otg/otghw/isp1301.h
++ * @brief Private structures and defines for ISP1301 Transciever Controller Driver.
++ *
++ * This file contains the private defines and structures for the ISP1301 Transceiver
++ * Driver.
++ *
++ * @ingroup ISP1301TCD
++ */
++
++/*!
++ * @name ISP1301 ISP1301 configuration
++ * @{
++ */
++
++#ifdef CONFIG_OMAP_H2
++#define ISP1301_GPIO (2)
++#define TCD_ISP1301_I2C_ADDR ISP1301_I2C_ADDR_HIGH;
++#endif
++
++#define ISP1301_NAME "isp1301"
++
++#define ISP1301_LOC_CONN 0x01
++
++#define ISP1301_INT_SRC 0xeb
++
++/*!
++ * @enum otg_transceiver
++ * Define ISP1301 compatible transceivers
++ */
++typedef enum otg_transceiver {
++ unknown_transceiver, /*!< unknown */
++ isp1301, /*!< Phillips ISP1301 */
++ max3301e /*!< Maxim MAX3301e */
++} otg_transceiver_t;
++
++/*!
++ * @struct otg_transceiver_map
++ * How to determine transceiver model and manufacturer
++ */
++struct otg_transceiver_map {
++ otg_transceiver_t transceiver_type; /*!< transceiver type */
++ u16 vendor; /*!< vendor number */
++ u16 product; /*!< product number */
++ u16 revision; /*!< revision number */
++ char *name; /*!< name */
++};
++
++/*!
++ * @struct isp1301_private
++ * Information required for operation
++ */
++struct isp1301_private {
++ WORK_STRUCT bh; /*!< work structure for bottom half handler */
++ u16 vendor; /*!< vendor number found */
++ u16 product; /*!< product number found */
++ u16 revision; /*!< revision number found */
++ u32 flags; /*!< flags */
++ u8 int_src; /*!< current interrupt source */
++ struct otg_transceiver_map *transceiver_map; /*! pointer to transceiver map for this transceiver */
++};
++
++/*!
++ * @enum tx_mode
++ * This defines the various ways that the ISP1301 can be
++ * wired into the host USB.
++ */
++typedef enum tx_mode {
++ dat_se0_bidirectional, /*!< 3-Wire */
++ vp_vm_bidirectional, /*!< 4-Wire */
++ dat_se0_unidirectional /*!< 6-Wire */
++} tx_mode_t;
++
++/*!
++ * @enum spd_ctrl
++ * This defines how the speed and suspend pins are controlled
++ * for this host.
++ */
++typedef enum spd_ctrl {
++ spd_susp_pins, /*!< controlled by SPEED and SUSPEND pins */
++ spd_susp_reg, /*!< controled by SPEED_REG and SUSPEND_REG in Mode Control 1 register */
++} spd_ctrl_t;
++
++
++extern struct tcd_ops tcd_ops;
++extern struct isp1301_private isp1301_private;
++extern struct tcd_instance *tcd_instance;
++
++/* isp1301.c */
++extern int isp1301_mod_init(WORK_PROC );
++extern int isp1301_mod_init__(void );
++extern void isp1301_mod_exit(void);
++extern void isp1301_tcd_en(struct otg_instance *, u8 );
++extern void isp1301_chrg_vbus(struct otg_instance *, u8 );
++extern void isp1301_drv_vbus(struct otg_instance *, u8 );
++extern void isp1301_dischrg_vbus(struct otg_instance *, u8 );
++extern void isp1301_dp_pullup_func(struct otg_instance *, u8 );
++extern void isp1301_dm_pullup_func(struct otg_instance *, u8 );
++extern void isp1301_dp_pulldown_func(struct otg_instance *, u8 );
++extern void isp1301_dm_pulldown_func(struct otg_instance *, u8 );
++extern void isp1301_peripheral_host_func(struct otg_instance *, u8 );
++extern void isp1301_dm_det_func(struct otg_instance *, u8 );
++extern void isp1301_dp_det_func(struct otg_instance *, u8 );
++extern void isp1301_cr_det_func(struct otg_instance *, u8 );
++extern void isp1301_bdis_acon_func(struct otg_instance *, u8 );
++extern void isp1301_mx21_vbus_drain_func(struct otg_instance *, u8 );
++extern void isp1301_id_pulldown_func(struct otg_instance *, u8 );
++extern void isp1301_audio_func(struct otg_instance *, u8 );
++extern void isp1301_uart_func(struct otg_instance *, u8 );
++extern void isp1301_mono_func(struct otg_instance *, u8 );
++
++extern void isp1301_otg_timer(struct otg_instance *, u8 );
++extern void isp1301_bh(void *);
++extern int isp1301_id (struct otg_instance *);
++extern int isp1301_vbus (struct otg_instance *);
++extern void isp1301_configure(tx_mode_t, spd_ctrl_t );
++
++extern void isp1301_bh_wakeup(int);
++
++/* thread */
++extern int isp1301_thread_init (void (bh_proc)(void *));
++extern void isp1301_thread_exit (wait_queue_head_t *);
++extern void isp1301_thread_wakeup(int enabled, int first);
++
++
++
++/* i2c-xxx.c */
++int i2c_configure(char *name, int addr);
++extern void i2c_close(void);
++extern u8 i2c_readb(u8 );
++extern u16 i2c_readw(u8 );
++extern u32 i2c_readl(u8 );
++extern void i2c_writeb(u8 , u8 );
++
++
++/* ********************************************************************************************* */
++#define TRACE_I2CB(t,r) TRACE_MSG3(t, "%-40s[%02x] %02x", #r, r, i2c_readb(r))
++#define TRACE_I2CW(t,r) TRACE_MSG3(t, "%-40s[%02x] %04x", #r, r, i2c_readw(r))
++#define TRACE_GPIO(t,b,r) TRACE_MSG2(t, "%-40s %04x", #r, readw(b + r))
++#define TRACE_REGL(t,r) TRACE_MSG2(t, "%-40s %08x", #r, readl(r))
++
++/* @} */
++
+diff -uNr linux/drivers/no-otg/otghw/max3353e-hardware.h linux/drivers/otg/otghw/max3353e-hardware.h
+--- linux/drivers/no-otg/otghw/max3353e-hardware.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otghw/max3353e-hardware.h 2006-09-01 21:41:35.000000000 +0200
+@@ -0,0 +1,141 @@
++/*
++ * otg/otg/max3353e-hardware.h -- MAX3353E hardware specific defines
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@lbelcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otg/otg/max3353e-hardware.h
++ * @brief Public structures and defines for MAX3353E Hardware.
++ *
++ * The Maxim MAX3353E is an OTG Charge Pump with controllable
++ * pullup resistors.
++ *
++ * @ingroup MAX3353ETCD
++ */
++
++
++/*!
++ * @name ADR/PSW - C.f. Slave Address
++ *
++ * The high/low address is selected with the ADD pin.
++ *
++ * @{
++ */
++
++#define MAX3353E_I2C_ADDR_LOW 0x16
++#define MAX3353E_I2C_ADDR_HIGH 0x2C
++
++/*! @} */
++
++
++
++/*!
++ * @name MAX3353E Registers C.f. Table 2 - Register Address Map
++ * @{
++ */
++
++#define MAX3353E_MANUFACTURER_REGISTER_0 0x00
++#define MAX3353E_MANUFACTURER_REGISTER_1 0x01
++#define MAX3353E_MANUFACTURER_REGISTER_2 0x02
++#define MAX3353E_MANUFACTURER_REGISTER_3 0x03
++
++#define MAX3353E_PRODUCT_ID_REGISTER_0 0x04
++#define MAX3353E_PRODUCT_ID_REGISTER_1 0x05
++#define MAX3353E_PRODUCT_ID_REGISTER_2 0x06
++#define MAX3353E_PRODUCT_ID_REGISTER_3 0x07
++
++#define MAX3353E_CONTROL_REGISTER_1 0x10
++#define MAX3353E_CONTROL_REGISTER_2 0x11
++
++#define MAX3353E_STATUS_REGISTER 0x13
++
++#define MAX3353E_INTERRUPT_MASK 0x14
++#define MAX3353E_INTERRUPT_EDGE 0x15
++#define MAX3353E_INTERRUPT_LATCH 0x16
++
++/*! @} */
++
++
++/*!
++ * @name Control Register 1
++ * @{
++ */
++#define MAX3353E_DM_PULLDOWN (1 << 7)
++#define MAX3353E_DP_PULLDOWN (1 << 6)
++#define MAX3353E_DM_PULLUP (1 << 5)
++#define MAX3353E_DP_PULLUP (1 << 4)
++
++#define MAX3353E_BDISC_ACONN (1 << 2)
++#define MAX3353E_IRQ_MODE (1 << 1)
++
++/*! @} */
++
++/*!
++ * @name Control Register 2
++ * @{
++ */
++#define MAX3353E_VBUS_DISCHG (1 << 4)
++#define MAX3353E_VBUS_DRV (1 << 3)
++#define MAX3353E_VBUS_CHG2 (1 << 2)
++#define MAX3353E_VBUS_CHG1 (1 << 1)
++#define MAX3353E_DSWIN (1 << 0)
++
++/*! @} */
++
++/*!
++ * @name Status Register
++ * @{
++ */
++#define MAX3353E_B_HNP (1 << 6)
++#define MAX3353E_A_HNP (1 << 5)
++#define MAX3353E_ID_FLOAT (1 << 4)
++#define MAX3353E_ID_GND (1 << 3)
++#define MAX3353E_SESSION_END (1 << 2)
++#define MAX3353E_SESSION_VALID_EN (1 << 1)
++#define MAX3353E_VBUS_VALID (1 << 0)
++
++/*! @} */
++
++/*!
++ * @name Interrupt Mask
++ * @{
++ */
++#define MAX3353E_A_HNP_EN (1 << 5)
++#define MAX3353E_ID_FLOAT_EN (1 << 4)
++#define MAX3353E_ID_GND_EN (1 << 3)
++#define MAX3353E_SESSION_END_EN (1 << 2)
++#define MAX3353E_SESSION_VALID_EN (1 << 1)
++#define MAX3353E_VBUS_VALID_EN (1 << 0)
++
++/*! @} */
++
++/*!
++ * @name Interrupt Edge
++ * @{
++ */
++#define MAX3353E_SESSION_VALID_ED (1 << 1)
++#define MAX3353E_VBUS_VALID_ED (1 << 0)
++
++/*! @} */
++
++/*!
++ * @name Interrupt Latch
++ * @{
++ */
++#define MAX3353E_A_HNP_RQ (1 << 7)
++#define MAX3353E_ID_FLOAT_RQ (1 << 6)
++#define MAX3353E_ID_GND_RQ (1 << 5)
++#define MAX3353E_SESSION_END_RQ (1 << 4)
++#define MAX3353E_SESSION_VALID_RN (1 << 3)
++#define MAX3353E_VBUS_VALID_RN (1 << 2)
++#define MAX3353E_SESSION_VALID_RP (1 << 1)
++#define MAX3353E_VBUS_VALID_RP (1 << 0)
++
++/*! @} */
++
+diff -uNr linux/drivers/no-otg/otghw/mx2ads-hardware.h linux/drivers/otg/otghw/mx2ads-hardware.h
+--- linux/drivers/no-otg/otghw/mx2ads-hardware.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otghw/mx2ads-hardware.h 2006-09-01 21:41:35.000000000 +0200
+@@ -0,0 +1,111 @@
++/*
++ * otghw/mx2ads-hardware.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @file otghw/mx2ads-hardware.h
++ * @brief MX2ADS Hardware constants
++ *
++ * @ingroup MX2ADS
++ */
++
++
++/*!
++ * @name MX2ETDS
++ * R1 = i.MX21 Application Processor Reference Manual Rev 0.6 2003/11/01 TO 1.0
++ * (aka "IMX21RM_TO1.pdf")
++ * R2 = "USBOTG_L3_Specification_v.C1.0.pdf"
++ * @{
++ */
++
++#define NUM_ETDS 32
++#define DATA_BUFF_SIZE 64
++#define DATA_BUFFER_TOTAL 4096
++#define NUM_DATA_BUFFS (4096/DATA_BUFF_SIZE)
++//#define LITTLE_ENDIAN 1
++
++/* @} */
++
++
++/*!
++ * @name MX2Interrupts
++ * @{
++ */
++#define OTG_USBWKUP 53
++#define OTG_USBDMA 54
++#define OTG_USBHOST 55
++#define OTG_USBFUNC 56
++#define OTG_USBHNP 57
++#define OTG_USBCTRL 58
++/* @} */
++
++/*!
++ * @name AHBMemoryMap
++ * C.F. Table 23-5 AHB Memory Map
++ * @{
++ */
++#ifndef OTG_BASE_ADDR
++#define OTG_BASE_ADDR 0x10024000
++
++#define OTG_CORE_BASE (OTG_BASE_ADDR+0x000) // base location for core
++#define OTG_FUNC_BASE (OTG_BASE_ADDR+0x040) // base location for function
++#define OTG_HOST_BASE (OTG_BASE_ADDR+0x080) // base location for host
++#define OTG_I2C_BASE (OTG_BASE_ADDR+0x100) // base location for I2C
++
++#define OTG_ETD_BASE (OTG_BASE_ADDR+0x200) // base location for etd memory
++#define OTG_EP_BASE (OTG_BASE_ADDR+0x400) // base location for ep memory
++#define OTG_SYS_BASE (OTG_BASE_ADDR+0x600) // base location for system
++
++#define OTG_DMA_BASE (OTG_BASE_ADDR+0x800) // base location for dma
++
++#define OTG_DATA_BASE (OTG_BASE_ADDR+0x1000) // base location for data memory
++
++#define OTG_SYS_CTRL (OTG_SYS_BASE+0x000) // base location for system
++#endif
++/* @} */
++
++/*!
++ * @name I2CTransceiver
++ * C.f. 23.14.10 I2C OTG Transceiver Controller Registers
++ * These are the I2C controller and access registers.
++ *
++ * N.B. I2C_ERROR is not documented.
++ * @{
++ */
++
++
++#define I2C_BUSY (1 << 7)
++#define I2C_ERROR (1 << 2)
++#define I2C_HWSMODE (1 << 1)
++#define I2C_I2COE (1 << 0)
++
++#define I2C_SCLK_TO_SCL_DIVISION (OTG_I2C_BASE+0x1E)
++
++#define I2C_INTERRUPT_AND_CONTROL (OTG_I2C_BASE+0x1F)
++
++#define I2C_STATUS_MASK (0x7)
++
++#define I2C_NOACK_EN (1 << 6)
++#define I2C_RWREADY_EN (1 << 5)
++#define I2C_OTGXCVRINT_EN (1 << 4)
++
++#define I2C_NOACK (1 << 2)
++#define I2C_RWREADY (1 << 1)
++#define I2C_OTGXCVRINT (1 << 0)
++
++#define MX2_OTG_XCVR_DEVAD OTG_I2C_BASE+0x18
++#define MX2_SEQ_OP_REG OTG_I2C_BASE+0x19
++#define MX2_SEQ_RD_STARTAD OTG_I2C_BASE+0x1a
++#define MX2_I2C_OP_CTRL_REG OTG_I2C_BASE+0x1b
++#define MX2_SCLK_TO_SCL_HPER OTG_I2C_BASE+0x1e
++#define MX2_I2C_INTERRUPT_AND_CTRL OTG_I2C_BASE+0x1f
++
++/* @} */
++
+diff -uNr linux/drivers/no-otg/otghw/mx2ads.h linux/drivers/otg/otghw/mx2ads.h
+--- linux/drivers/no-otg/otghw/mx2ads.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otghw/mx2ads.h 2006-09-01 21:41:35.000000000 +0200
+@@ -0,0 +1,46 @@
++/*
++ * otghw/mx2ads.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ */
++
++/*!
++ * @defgroup MX2ADS Freescale MX2ADS
++ * @ingroup platformgroup
++ */
++/*!
++ * @file otghw/mx2ads.h
++ * @brief MX2ADS Platform constants
++ *
++ * Notes
++ *
++ * 1. Interrupts - we seem to get all interrupts on the ctrl interrupt.
++ *
++ * 2. Clearing - it appears that clearing the status bits sometimes fails, This
++ * has been observed in SINT_STAT and XFILL_STAT.
++ *
++ * 3. Double buffer - without DMA it does not appear to be possible to use
++ * both X and Y buffers for OUT transfers because we can not apparantely guarantee
++ * the order that the X and Y buffers will be used. If we get an interrupt with
++ * both X and Y active we cannot determine which order to use them. As long as
++ * we get each interrupt fast enough this is not a problem as we can then just
++ * use whichever is active.
++ *
++ * 4. Remote Wakeup - cannot set RSMINPROG bit
++ *
++ * @ingroup MX2ADS
++ */
++
++
++#define UDC_NAME "MX21"
++#define UDC_MAX_ENDPOINTS 32
++#define EP0_PACKETSIZE 64
++
++
++extern otg_tag_t MX2;
++
+diff -uNr linux/drivers/no-otg/otghw/td243-hardware.h linux/drivers/otg/otghw/td243-hardware.h
+--- linux/drivers/no-otg/otghw/td243-hardware.h 1970-01-01 01:00:00.000000000 +0100
++++ linux/drivers/otg/otghw/td243-hardware.h 2006-09-01 21:41:35.000000000 +0200
+@@ -0,0 +1,709 @@
++/*
++ * otg/pcd/mx2/td243-hardware.h
++ *
++ * Copyright (c) 2004 Belcarra
++ *
++ * By:
++ * Stuart Lynne <sl@belcarra.com>,
++ * Tom Rushworth <tbr@belcarra.com>,
++ * Bruce Balden <balden@belcarra.com>
++ *
++ */
++/*!
++ * @defgroup TD243 Transdimension USBOTG
++ * @ingroup libgroup
++ */
++/*!
++ * @file /otg/otghw/td243-hardware.h
++ * @brief Hardware defines for Transimension USBOTG Hardware
++ *
++ * @ingroup TD243
++ */
++
++
++/*
++ * C.f. 23.8 USB Control Register
++ */
++
++#define SYS_CTRL_I2C_WU_INT_STAT (1 << 27)
++#define SYS_CTRL_OTG_WU_INT_STAT (1 << 26)
++#define SYS_CTRL_HOST_WU_INT_STAT (1 << 25)
++#define SYS_CTRL_FNT_WU_INT_STAT (1 << 24)
++
++#define SYS_CTRL_I2C_WU_INT_EN (1 << 19)
++#define SYS_CTRL_OTG_WU_INT_EN (1 << 18)
++#define SYS_CTRL_HOST_WU_INT_EN (1 << 17)
++#define SYS_CTRL_FNT_WU_INT_EN (1 << 16)
++
++#define SYS_CTRL_OTG_BYP_VAL (0x3 << 11)
++#define SYS_CTRL_HOST1_BYP_VAL (0x3 << 9)
++
++
++
++#define SYS_CTRL_OTG_PWR_MASK (1 << 6)
++#define SYS_CTRL_HOST1_PWR_MASK (1 << 6)
++#define SYS_CTRL_HOST2_PWR_MASK (1 << 4)
++#define SYS_CTRL_USB_BYP (1 << 2)
++#define SYS_CTRL_HOST1_TXEN_OE (1 << 1)
++
++
++/*
++ * C.f. 23.9 USBOTG Module Registers
++ */
++
++#define OTG_CORE_HWMODE (OTG_CORE_BASE+0x00) // 32bit core hardware mode reg
++
++#define XCVR_D_D 0x00
++#define XCVR_SE_D 0x01
++#define XCVR_D_SE 0x02
++#define XCVR_SE_SE 0x03
++
++#define MODULE_ANASDBEN (1 << 14)
++#define MODULE_OTGXCVR (0x3 << 6)
++#define MODULE_HOSTXCVR (0x3 << 4)
++#define MODULE_CRECFG (0x3)
++#define MODULE_CRECFG_HHNP (0x0)
++#define MODULE_CRECFG_HOST (0x1)
++#define MODULE_CRECFG_FUNC (0x2)
++#define MODULE_CRECFG_SHNP (0x3)
++
++#define OTG_CORE_CINT_STAT (OTG_CORE_BASE+0x04) // 32bit core int status reg
++
++#define MODULE_FCINTDSPEN (1 << 6)
++
++#define MODULE_ASHNPINT (1 << 5)
++#define MODULE_ASFCINT (1 << 4)
++#define MODULE_ASHCINT (1 << 3)
++#define MODULE_HNPINT (1 << 2)
++#define MODULE_FCINT (1 << 1)
++#define MODULE_HCINT (1)
++
++#define OTG_CORE_CINT_STEN (OTG_CORE_BASE+0x08) // 32bit core int enable reg
++
++#define MODULE_ASHNPINT_EN (1 << 5)
++#define MODULE_ASFCINT_EN (1 << 4)
++#define MODULE_ASHCINT_EN (1 << 3)
++#define MODULE_HNPINT_EN (1 << 2)
++#define MODULE_FCINT_EN (1 << 1)
++#define MODULE_HCINT_EN (1)
++
++#define OTG_CORE_CLK_CTRL (OTG_CORE_BASE+0x0C) // 32bit core clock control reg
++
++#define MODULE_FUNC_CLK (1 << 2)
++#define MODULE_HOST_CLK (1 << 1)
++#define MODULE_MAIN_CLK (1)
++
++#define OTG_CORE_RST_CTRL (OTG_CORE_BASE+0x10) // 32bit core reset control reg
++
++#define MODULE_RSTI2C (1 << 15)
++#define MODULE_RSTCTRL (1 << 5)
++#define MODULE_RSTFC (1 << 4)
++#define MODULE_RSTFSIE (1 << 3)
++#define MODULE_RSTRH (1 << 2)
++#define MODULE_RSTHSIE (1 << 1)
++#define MODULE_RSTHC (1)
++
++#define OTG_CORE_FRM_INTVL (OTG_CORE_BASE+0x14) // 32bit core frame interval reg
++
++#define MODULE_RESET_FRAME (1 << 15)
++
++#define OTG_CORE_FRM_REMAIN (OTG_CORE_BASE+0x18) // 32bit core frame remaining reg
++
++#define OTG_CORE_HNP_CSTAT (OTG_CORE_BASE+0x1C) // 32bit core HNP current state reg
++
++#define MODULE_HNPDAT (1 << 30)
++#define MODULE_VBUSBSE (1 << 29)
++#define MODULE_VBUSABSV (1 << 28)
++#define MODULE_VBUSGTAVV (1 << 27)
++
++#define MODULE_ARMTHNPE (1 << 25)
++#define MODULE_BHNPEN (1 << 24)
++
++#define MODULE_SLAVE (1 << 22)
++#define MODULE_MASTER (1 << 21)
++#define MODULE_BGEN (1 << 20)
++#define MODULE_CMPEN (1 << 19)
++#define MODULE_ISBDEV (1 << 18)
++#define MODULE_ISADEV (1 << 17)
++
++#define MODULE_SWVBUSPUL (1 << 15)
++
++#define MODULE_SWAUTORST (1 << 12)
++#define MODULE_SWPUDP (1 << 11)
++
++#define MODULE_SWPDDM (1 << 9)
++#define MODULE_HNPSTATE (0x1f << 8)
++#define MODULE_CLRERROR (1 << 3)
++#define MODULE_ADROPBUS (1 << 2)
++#define MODULE_ABBUSREQ (1 << 1)
++
++#define HNP_A_IDLE (0x10 << 8)
++#define HNP_A_MASTER (0x11 << 8)
++#define HNP_A_SLAVE (0x12 << 8)
++#define HNP_A_WAIT_VPULSE (0x13 << 8)
++
++#define HNP_A_WAIT_DPULSE (0x14 << 8)
++#define HNP_A_WAIT_CONN_A (0x15 << 8)
++#define HNP_A_WAIT_CONN_B (0x16 << 8)
++#define HNP_A_WAIT_VRISE (0x17 << 8)
++#define HNP_A_SUSPEND (0x18 << 8)
++#define HNP_A_WAIT_VFALL (0x19 << 8)
++#define HNP_A_VBUS_ERR (0x1a << 8)
++#define HNP_CONN_DEBOUNCE (0x1b << 8)
++#define HNP_A_WAIT_ABREQ (0x1c << 8)
++#define HNP_B_IDLE (0x00 << 8)
++#define HNP_B_MASTER (0x01 << 8)
++#define HNP_B_SLAVE (0x02 << 8)
++#define HNP_B_SRP_INIT_V (0x03 << 8)
++#define HNP_B_SRP_INIT_D (0x04 << 8)
++#define HNP_B_PRE_WAIT_CONN_AB_SHORT_DB (0x05 << 8)
++#define HNP_B_WAIT_CONN_A (0x06 << 8)
++#define HNP_B_PRE_SLAVE (0x0a << 8)
++
++
++#define OTG_CORE_HNP_TIMER1 (OTG_CORE_BASE+0x20) // 32bit core HNP timer 1 reg
++#define OTG_CORE_HNP_TIMER2 (OTG_CORE_BASE+0x24) // 32bit core HNP timer 2 reg
++#define OTG_CORE_HNP_T3PCR (OTG_CORE_BASE+0x28) // 32bit core HNP timer 3 pulse ctrl
++
++#define HNP_DATAPULSE (1 << 5)
++#define HNP_VBUSPULSE (1 << 4)
++
++#define OTG_CORE_HINT_STAT (OTG_CORE_BASE+0x2C) // 32bit core HNP int status reg
++
++#define HNP_I2COTGINT (1 << 15)
++#define HNP_AWAITBTO (1 << 8) // Hardware HNP Only
++#define HNP_AIDLEBDTO (1 << 7) // Hardware HNP Only
++#define HNP_SRPSUCFAIL (1 << 6) // Hardware HNP Only
++#define HNP_SRPINT (1 << 5)
++#define HNP_VBUSERROR (1 << 4) // Hardware HNP Only
++#define HNP_ABSEVAILD (1 << 3)
++#define HNP_ABUSVALID (1 << 2)
++#define HNP_MASSLVCHG (1 << 1) // Hardware HNP Only
++#define HNP_IDCHANGE (1)
++
++#define OTG_CORE_HINT_STEN (OTG_CORE_BASE+0x30) // 32bit core HNP int enable reg
++
++#define HNP_I2COTGINT_EN (1 << 15)
++#define HNP_AWAITBTO_EN (1 << 8)
++#define HNP_AIDLEBDTO_EN (1 << 7)
++#define HNP_SRPSUCFAIL_EN (1 << 6)
++#define HNP_SRPINT_EN (1 << 5)
++#define HNP_VBUSERROR_EN (1 << 4)
++#define HNP_ABSEVAILD_EN (1 << 3)
++#define HNP_ABUSVALID_EN (1 << 2)
++#define HNP_MASSLVCHG_EN (1 << 1)
++#define HNP_IDCHANGE_EN (1)
++
++
++#define OTG_CORE_CPUEPSEL_STAT (OTG_CORE_BASE+0x34)
++#define OTG_CORE_INTERRUPT_STEN (OTG_CORE_BASE+0x3c)
++
++
++/*
++ * C.f. 23.11.11 Host Registers
++ */
++
++
++#define OTG_HOST_CONTROL (OTG_HOST_BASE+0x00) // 32bit host controller config reg
++
++#define HOST_CONTROL_HCRESET (1 << 31)
++#define HOST_CONTROL_RMTWUEN (1 << 4)
++
++#define HOST_CONTROL_HCUSBSTE_RESET (0 << 2)
++#define HOST_CONTROL_HCUSBSTE_RESUME (1 << 2)
++#define HOST_CONTROL_HCUSBSTE_OPERATIONAL (2 << 2)
++#define HOST_CONTROL_HCUSBSTE_SUSPEND (3 << 2)
++
++#define HOST_CONTROL_CTLBLKSR_11 (0)
++#define HOST_CONTROL_CTLBLKSR_21 (1)
++#define HOST_CONTROL_CTLBLKSR_41 (2)
++#define HOST_CONTROL_CTLBLKSR_81 (3)
++
++
++#define OTG_HOST_SINT_STAT (OTG_HOST_BASE+0x08) // 32bit host system int status reg
++
++#define HOST_PSCINT (1 << 6) // Port Status Change
++#define HOST_FMOFINT (1 << 5) // Frame Number Overflow
++#define HOST_HERRINT (1 << 4) // Host Error
++#define HOST_RESDETINT (1 << 3) // Resume Detected
++#define HOST_SOFINT (1 << 2) // Start of Frame
++#define HOST_DONEINT (1 << 1) // Done Register
++#define HOST_SORINT (1) // Schedule Overrun
++
++#define OTG_HOST_SINT_STEN (OTG_HOST_BASE+0x0C) // 32bit host system int enable reg
++
++#define HOST_PSCINT_EN (1 << 6) // Port Status Change
++#define HOST_FMOFINT_EN (1 << 5) // Frame Number Overflow
++#define HOST_HERRINT_EN (1 << 4) // Host Error
++#define HOST_RESDETINT_EN (1 << 3) // Resume Detected
++#define HOST_SOFINT_EN (1 << 2) // Start of Frame
++#define HOST_DONEINT_EN (1 << 1) // Done Register
++#define HOST_SORINT_EN (1) // Schedule Overrun
++
++#define OTG_HOST_XINT_STAT (OTG_HOST_BASE+0x18) // 32bit host X buf int status reg
++#define OTG_HOST_YINT_STAT (OTG_HOST_BASE+0x1C) // 32bit host Y buf int status reg
++
++#define OTG_HOST_XYINT_STEN (OTG_HOST_BASE+0x20) // 32bit host XY buf int enable reg
++#define OTG_HOST_XFILL_STAT (OTG_HOST_BASE+0x28) // 32bit host X filled status reg
++#define OTG_HOST_YFILL_STAT (OTG_HOST_BASE+0x2C) // 32bit host Y filled status reg
++
++#define OTG_HOST_ETD_EN (OTG_HOST_BASE+0x40) // 32bit host ETD enables reg
++#define OTG_HOST_DIR_ROUTE (OTG_HOST_BASE+0x48) // 32bit host direct routing reg
++#define OTG_HOST_IINT (OTG_HOST_BASE+0x4C) // 32bit host immediate interrupt reg
++
++#define OTG_HOST_EP_DSTAT (OTG_HOST_BASE+0x50) // 32bit host endpoints done status
++#define OTG_HOST_ETD_DONE (OTG_HOST_BASE+0x54) // 32bit host ETD done reg
++
++#define OTG_HOST_FRM_NUM (OTG_HOST_BASE+0x60) // 32bit host frame number reg
++#define OTG_HOST_LSP_THRESH (OTG_HOST_BASE+0x64) // 32bit host low speed threshold reg
++
++#define OTG_HOST_ROOTHUB_DESCA (OTG_HOST_BASE+0x68) // 32bit host root hub descriptor A
++#define OTG_HOST_ROOTHUB_DESCB (OTG_HOST_BASE+0x6C) // 32bit host root hub descriptor B
++
++/*
++ * C.f. 23.11.29
++ */
++#define OTG_HOST_ROOTHUB_STATUS (OTG_HOST_BASE+0x70) // 32bit host root hub status reg
++
++#define ROOTHUB_STATUS_CLRMTWUE (1 << 31) // Clear Remote Wakeup Enable
++#define ROOTHUB_STATUS_OVRCURCHG (1 << 17) // Over Current Indicator Change
++#define ROOTHUB_STATUS_LOCPWRSC (1 << 16) // Local Power Status Change
++#define ROOTHUB_STATUS_DEVCONWUE (1 << 15) // Device Connect Wakeup Enable
++#define ROOTHUB_STATUS_OVRCURI (1 << 1) // Over Current Indicator
++#define ROOTHUB_STATUS_LOCPWRS (1) // Local Power Status
++
++
++/*
++ * C.f. 23.11.30
++ */
++#define OTG_HOST_PORT_STATUS_1 (OTG_HOST_BASE+0x74) // 32bit host port 1 status bits
++#define OTG_HOST_PORT_STATUS_2 (OTG_HOST_BASE+0x78) // 32bit host port 2 status bits
++#define OTG_HOST_PORT_STATUS_3 (OTG_HOST_BASE+0x7c) // 32bit host port 3 status bits
++
++#define PORT_STATUS_PRTRSTSC (1 << 20) // Port Reset Status Change
++#define PORT_STATUS_OVRCURIC (1 << 19) // Port Over Current Indicator Change
++#define PORT_STATUS_PRTSTATSC (1 << 18) // Port Suspend Status Change
++#define PORT_STATUS_PRTENBLSC (1 << 17) // Port Enable Status Change
++#define PORT_STATUS_CONNECTSC (1 << 16) // Connect Status Change
++
++#define PORT_STATUS_LSDEVCON (1 << 9) // Low Speed Device Attached
++#define PORT_STATUS_PRTPWRST (1 << 8) // Port Power Status
++
++#define PORT_STATUS_PRTRSTST (1 << 4) // Port Reset Status
++#define PORT_STATUS_PRTOVRCURI (1 << 3) // Port Over Current Indicator
++#define PORT_STATUS_PRTSUSPST (1 << 2) // Port Suspend Status
++#define PORT_STATUS_PRTENABST (1 << 1) // Port Enable Status
++#define PORT_STATUS_CURCONST (1) // Current Connect Status
++
++
++/* flags are the same for the interrupt, control and bulk transfer descriptors */
++// R1: sec 23.11.10.2,3 pg 23-44,47
++#define ETD_GET_COMPCODE(flags) ((flags >> 12) & 0xf)
++// R1: sec 23.11.10 Table 23-23 pg 23-40
++#define ETD_CC_NOERROR 0x0
++#define ETD_CC_CRCERR 0x1
++#define ETD_CC_BITSTUFFERR 0x2
++#define ETD_CC_DATATOGERR 0x3
++#define ETD_CC_STALL 0x4
++#define ETD_CC_DEVNOTRESPONDING 0x5
++#define ETD_CC_PIDFAILURE 0x6
++// Reserved 0x7
++#define ETD_CC_DATAOVERRUN 0x8
++#define ETD_CC_DATAUNDERRUN 0x9
++#define ETD_CC_ACK 0xA
++#define ETD_CC_NAK 0xB
++#define ETD_CC_BUFFEROVERRUN 0xC
++#define ETD_CC_BUFFERUNDERRUN 0xD
++#define ETD_CC_SCHEDOVERRUN 0xE
++#define ETD_CC_NOTACCESSED 0xF
++
++// R1: sec 23.11.10.2,3 pg 23-44,47 (contd)
++#define ETD_GET_ERRORCNT(flags) (((flags) >> 8) & 0xf)
++#define ETD_GET_DATATOGL(flags) (((flags) >> 6) & 0x3)
++#define ETD_SET_DATATOGL(v) (((v) & 0x3) << 6)
++#define ETD_GET_DELAYINT(flags) (((flags) >> 3) & 0x7)
++#define ETD_SET_DELAYINT(v) (((v) & 0x7) << 3)
++#define ETD_GET_BUFROUND(flags) (((flags) >> 2) & 0x1)
++#define ETD_SET_BUFROUND(v) (((v) & 0x1) << 2)
++#define ETD_GET_DIRPID(flags) ((flags) & 0x3)
++#define ETD_SET_DIRPID(v) ((v) & 0x3)
++#define ETD_FLIP_DIRPID(flags) ((flags) ^ 0x3) /* xor with 0x3 flips 2<->1 (IN<->OUT) */
++#define ETD_DIRPID_SETUP 0x0 // OUT
++#define ETD_DIRPID_OUT 0x1
++#define ETD_DIRPID_IN 0x2
++#define ETD_DIRPID_RESERVED 0x3
++
++// For non-isoc td.w3.val -
++#define ETD_GET_BUFSIZE(w3) (((w3) >> 21) & 0xfff)
++#define ETD_SET_BUFSIZE(v) (((v) & 0xfff) << 21)
++#define ETD_GET_TOTBYECNT(w3) ((w3) & 0xfffff)
++#define ETD_SET_TOTBYECNT(v) ((v) & 0xfffff)
++
++/* isoc flags shares the COMPCODE and DELAYINT bitfields with the other TDs,
++ but the remaining bits are different. */
++#define ETD_GET_AUTOISO(flags) (((flags) >> 11) & 0x1)
++#define ETD_SET_AUTOISO(v) (((v) & 0x1) << 11)
++#define ETD_GET_FRAMECNT(flags) (((flags) >> 8) & 0x1)
++#define ETD_SET_FRAMECNT(v) (((v) & 0x1) << 8)
++// For isoc td.w3.val -
++/* pkt1 and pkt0 use the COMPCODE bitfield, and add a PKTLEN field. */
++#define ETD_GET_PKTLEN(pkt) ((pkt) & 0x3ff)
++#define ETD_SET_PKTLEN(v) ((v) & 0x3ff)
++
++
++// ETD endpoint descriptor (etd->epd) bitfield access
++// R1: sec 23.11.10.1 pg 23-41 (word0)
++#define ETD_GET_SNDNAK(epd) (((epd) >> 30) & 0x1)
++#define ETD_SET_SNDNAK(v) (((v) & 0x1) << 30)
++#define ETD_GET_TOGCRY(epd) (((epd) >> 28) & 0x1)
++#define ETD_SET_TOGCRY(v) (((v) & 0x1) << 28)
++#define ETD_GET_HALTED(epd) (((epd) >> 27) & 0x1)
++#define ETD_SET_HALTED(v) (((v) & 0x1) << 27)
++#define ETD_GET_MAXPKTSIZ(epd) (((epd) >> 16) & 0x3ff)
++#define ETD_SET_MAXPKTSIZ(v) (((v) & 0x3ff) << 16)
++#define ETD_GET_FORMAT(epd) (((epd) >> 14) & 0x3)
++#define ETD_SET_FORMAT(v) (((v) & 0x3) << 14)
++#define ETD_FORMAT_CONTROL 0x0
++#define ETD_FORMAT_ISOC 0x1
++#define ETD_FORMAT_BULK 0x2
++#define ETD_FORMAT_INTERRUPT 0x3
++#define ETD_GET_SPEED(epd) (((epd) >> 13) & 0x1)
++#define ETD_SET_SPEED(v) (((v) & 0x1) << 13)
++#define ETD_SPEED_FULL 0x0
++#define ETD_SPEED_LOW 0x1
++#define ETD_GET_DIRECT(epd) (((epd) >> 11) & 0x3)
++#define ETD_SET_DIRECT(v) (((v) & 0x3) << 11)
++/* xor with 3 flips 2<->1 */
++#define ETD_FLIP_DIRECT(epd) ((epd) ^ (0x3 << 11))
++#define ETD_DIRECT_TD00 0x0
++#define ETD_DIRECT_OUT 0x1
++#define ETD_DIRECT_IN 0x2
++#define ETD_DIRECT_TD11 0x3
++#define ETD_GET_ENDPNT(epd) (((epd) >> 7) & 0xf)
++#define ETD_SET_ENDPNT(v) (((v) & 0xf) << 7)
++#define ETD_GET_ADDRESS(epd) ((epd) & 0x7f)
++#define ETD_SET_ADDRESS(v) ((v) & 0x7f)
++
++// etd_urb_state[] values
++#define ETD_URB_COMPLETED 0
++#define ETD_URB_SETUP_STATUS 1
++#define ETD_URB_SETUP_DATA 2
++#define ETD_URB_SETUP_START 3
++#define ETD_URB_BULK_START 4
++#define ETD_URB_BULKWZLP 5
++#define ETD_URB_BULKWZLP_START 6
++#define ETD_URB_INTERRUPT_START 7
++#define ETD_URB_ISOC_START 8
++
++
++/*
++ * C.f. 23.12.8 Function Registers
++ */
++
++#define OTG_FUNC_CMD_STAT (OTG_FUNC_BASE+0x00) // 32bit func command status reg
++
++#define COMMAND_SOFTRESET (1 << 7)
++#define COMMAND_BADISOAP (1 << 3)
++#define COMMAND_SUPDET (1 << 2)
++#define COMMAND_RSMINPROG (1 << 1)
++#define COMMAND_RESETDET (1)
++
++
++#define OTG_FUNC_DEV_ADDR (OTG_FUNC_BASE+0x04) // 32bit func device address reg
++
++#define OTG_FUNC_SINT_STAT (OTG_FUNC_BASE+0x08) // 32bit func system int status reg
++
++#define SYSTEM_DONEREGINTDS (1 << 5)
++#define SYSTEM_SOFDETINT (1 << 4)
++#define SYSTEM_DONEREGINT (1 << 3)
++#define SYSTEM_SUSPDETINT (1 << 2)
++#define SYSTEM_RSMFININT (1 << 1)
++#define SYSTEM_RESETINT (1)
++
++#define OTG_FUNC_SINT_STEN (OTG_FUNC_BASE+0x0C) // 32bit func system int enable reg
++
++#define SYSTEM_DONEREGINTDS_EN (1 << 5)
++#define SYSTEM_SOFDETINT_EN (1 << 4)
++#define SYSTEM_DONEREGINT_EN (1 << 3)
++#define SYSTEM_SUSPDETINT_EN (1 << 2)
++#define SYSTEM_RSMFININT_EN (1 << 1)
++#define SYSTEM_RESETINT_EN (1)
++
++
++#define OTG_FUNC_XINT_STAT (OTG_FUNC_BASE+0x10) // 32bit func X buf int status reg
++#define OTG_FUNC_YINT_STAT (OTG_FUNC_BASE+0x14) // 32bit func Y buf int status reg
++#define OTG_FUNC_XYINT_STEN (OTG_FUNC_BASE+0x18) // 32bit func XY buf int enable reg
++#define OTG_FUNC_XFILL_STAT (OTG_FUNC_BASE+0x1C) // 32bit func X filled status reg
++
++#define OTG_FUNC_YFILL_STAT (OTG_FUNC_BASE+0x20) // 32bit func Y filled status reg
++#define OTG_FUNC_EP_EN (OTG_FUNC_BASE+0x24) // 32bit func endpoints enable reg
++#define OTG_FUNC_EP_RDY (OTG_FUNC_BASE+0x28) // 32bit func endpoints ready reg
++#define OTG_FUNC_IINT (OTG_FUNC_BASE+0x2C) // 32bit func immediate interrupt reg
++
++#define OTG_FUNC_EP_DSTAT (OTG_FUNC_BASE+0x30) // 32bit func endpoints done status
++#define OTG_FUNC_EP_DEN (OTG_FUNC_BASE+0x34) // 32bit func endpoints done enable
++#define OTG_FUNC_EP_TOGGLE (OTG_FUNC_BASE+0x38) // 32bit func endpoints toggle bits
++#define OTG_FUNC_FRM_NUM (OTG_FUNC_BASE+0x3C) // 32bit func frame number reg
++
++
++#define EP0_STALL (1 << 31)
++#define EP0_SETUP (1 << 30)
++#define EP0_OVERRUN (1 << 29)
++#define EP0_AUTOISO (1 << 27)
++
++
++/* generic endpoint register manipulations
++ */
++#define EP_OUT 0x1
++#define EP_IN 0x2
++#define EP_BOTH 0x3
++
++#define ETD_MASK(n) (1 << n)
++#define ep_num_both(n) (EP_BOTH << n)
++#define ep_num_dir(n, dir) ((dir ? EP_IN : EP_OUT) << (n*2))
++#define ep_num_out(n) ep_num_dir(n, USB_DIR_OUT)
++#define ep_num_in(n) ep_num_dir(n, USB_DIR_IN)
++
++
++/* ep descriptor access
++ */
++static __inline__ u32 etd_word(int n, int word)
++{
++ u32 offset = n * 16;
++ offset += word * 4;
++ return OTG_ETD_BASE + offset;
++}
++
++/* ep descriptor access
++ */
++static __inline__ u32 ep_word(int n, int dir, int word)
++{
++ u32 offset = n * 2;
++ offset += dir ? 1 : 0;
++ offset *= 16;
++ offset += word * 4;
++ return OTG_EP_BASE + offset;
++}
++
++/* endpoint data buffer access
++ *
++ * This is a simplistic allocator, will do until we want to support ISO or host mode.
++ *
++ * This works because we are assuming a maximum of 16 allocate endpoints, and no
++ * overlapped endpoints (both in and out are allocated).
++ */
++
++static volatile __inline__ u16 data_x_buf(int n, int dir)
++{
++ return 0x40 * (n * 4 + 2 * (dir ? 1 : 0));
++}
++static volatile __inline__ u16 data_y_buf(int n, int dir)
++{
++ return 0x40 * (n * 4 + 2 * (dir ? 1 : 0) + 1);
++}
++
++static volatile __inline__ u8 * data_x_address(int n, int dir)
++{
++ return (volatile u8 *) IO_ADDRESS(OTG_DATA_BASE + data_x_buf(n, dir));
++}
++static volatile __inline__ u8 * data_y_address(int n, int dir)
++{
++ return (volatile u8 *) IO_ADDRESS(OTG_DATA_BASE + data_y_buf(n, dir));
++}
++
++/*
++ * C.f. 23.13.3 DMA Registers
++ */
++#define OTG_DMA_REV_NUM (OTG_DMA_BASE+0x000) // 32bit dma revision number reg
++#define OTG_DMA_DINT_STAT (OTG_DMA_BASE+0x004) // 32bit dma int status reg
++#define OTG_DMA_DINT_STEN (OTG_DMA_BASE+0x008) // 32bit dma int enable reg
++#define OTG_DMA_ETD_ERR (OTG_DMA_BASE+0x00C) // 32bit dma ETD error status reg
++#define OTG_DMA_EP_ERR (OTG_DMA_BASE+0x010) // 32bit dma EP error status reg
++#define OTG_DMA_ETD_EN (OTG_DMA_BASE+0x020) // 32bit dma ETD DMA enable reg
++#define OTG_DMA_EP_EN (OTG_DMA_BASE+0x024) // 32bit dma EP DMA enable reg
++#define OTG_DMA_ETD_ENXREQ (OTG_DMA_BASE+0x028) // 32bit dma ETD DMA enable Xtrig req
++#define OTG_DMA_EP_ENXREQ (OTG_DMA_BASE+0x02C) // 32bit dma EP DMA enable Ytrig req
++#define OTG_DMA_ETD_ENXYREQ (OTG_DMA_BASE+0x030) // 32bit dma ETD DMA enble XYtrig req
++#define OTG_DMA_EP_ENXYREQ (OTG_DMA_BASE+0x034) // 32bit dma EP DMA enable XYtrig req
++#define OTG_DMA_ETD_BURST4 (OTG_DMA_BASE+0x038) // 32bit dma ETD DMA enble burst4 reg
++#define OTG_DMA_EP_BURST4 (OTG_DMA_BASE+0x03C) // 32bit dma EP DMA enable burst4 reg
++#define OTG_DMA_MISC_CTRL (OTG_DMA_BASE+0x040) // 32bit dma EP misc control reg
++#define OTG_DMA_ETD_CH_CLR (OTG_DMA_BASE+0x044) // 32bit dma ETD clear channel reg
++#define OTG_DMA_EP_CH_CLR (OTG_DMA_BASE+0x048) // 32bit dma EP clear channel reg
++
++
++#define OTG_DMA_ETD_CH_CLR (OTG_DMA_BASE+0x044) // 32bit dma ETD clear channel reg
++#define OTG_DMA_ETD_ERR (OTG_DMA_BASE+0x00C) // 32bit dma ETD error status reg
++#define OTG_DMA_ETD_EN (OTG_DMA_BASE+0x020) // 32bit dma ETD DMA enable reg
++#define OTG_DMA_ETD_ENXREQ (OTG_DMA_BASE+0x028) // 32bit dma ETD DMA enable Xtrig req
++#define OTG_DMA_ETD_ENXYREQ (OTG_DMA_BASE+0x030) // 32bit dma ETD DMA enble XYtrig req
++#define OTG_DMA_ETD_BURST4 (OTG_DMA_BASE+0x038) // 32bit dma ETD DMA enble burst4 reg
++
++
++
++#define OTG_DMA_EP_CH_CLR (OTG_DMA_BASE+0x048) // 32bit dma EP clear channel reg
++#define OTG_DMA_EP_ERR (OTG_DMA_BASE+0x010) // 32bit dma EP error status reg
++#define OTG_DMA_EP_EN (OTG_DMA_BASE+0x024) // 32bit dma EP DMA enable reg
++#define OTG_DMA_EP_ENXREQ (OTG_DMA_BASE+0x02C) // 32bit dma EP DMA enable Ytrig req
++#define OTG_DMA_EP_ENXYREQ (OTG_DMA_BASE+0x034) // 32bit dma EP DMA enable XYtrig req
++#define OTG_DMA_EP_BURST4 (OTG_DMA_BASE+0x03C) // 32bit dma EP DMA enable burst4 reg
++
++
++#define dma_num_dir(n, dir) (n * 2 + (dir ? 1 : 0))
++#define dma_num_out(n) dma_num_dir(n, USB_DIR_OUT)
++#define dma_num_in(n) dma_num_dir(n, USB_DIR_IN)
++
++#define OTG_DMA_ETD_MSA(x) (OTG_DMA_BASE+0x100+x*4)
++#define OTG_DMA_EPN_MSA(x) (OTG_DMA_BASE+0x180+x*4)
++#define OTG_DMA_ETDN_BPTR(x) (OTG_DMA_BASE+0x280+x*4)
++#define OTG_DMA_EPN_BPTR(x) (OTG_DMA_BASE+0x284+x*4)
++
++
++/*
++ * C.f. 23.14.10 I2C OTG Transceiver Controller Registers
++ * These are the ISP1301 shadow registers.
++ *
++ * See isp1301-hardware.h for register bit defines.
++ */
++#if 1
++#define MX2_VENDOR_ID_LOW OTG_I2C_BASE+0x00
++#define MX2_VENDOR_ID_HIGH OTG_I2C_BASE+0x01
++#define MX2_PRODUCT_ID_LOW OTG_I2C_BASE+0x02
++#define MX2_PRODUCT_ID_HIGH OTG_I2C_BASE+0x03
++
++#define MX2_MODE_CONTROL_1_SET OTG_I2C_BASE+0x04
++#define MX2_MODE_CONTROL_1_CLR OTG_I2C_BASE+0x05
++#define MX2_OTG_CONTROL_SET OTG_I2C_BASE+0x06
++#define MX2_OTG_CONTROL_CLR OTG_I2C_BASE+0x07
++
++#define MX2_INTERRUPT_SOURCE OTG_I2C_BASE+0x08
++
++#define MX2_INT_LAT_REG_SET OTG_I2C_BASE+0x0a
++#define MX2_INT_LAT_REG_CLR OTG_I2C_BASE+0x0b
++
++#define MX2_INT_FALSE_REG_SET OTG_I2C_BASE+0x0c
++#define MX2_INT_FALSE_REG_CLR OTG_I2C_BASE+0x0d
++#define MX2_INT_TRUE_REG_SET OTG_I2C_BASE+0x0e
++#define MX2_INT_TRUE_REG_CLR OTG_I2C_BASE+0x0f
++
++#define MX2_OTG_STATUS_REG OTG_I2C_BASE+0x10
++
++#define MX2_MODE_CONTROL_2_SET OTG_I2C_BASE+0x12
++#define MX2_MODE_CONTROL_2_CLR OTG_I2C_BASE+0x13
++
++#define MX2_BCD_DEV_LOW OTG_I2C_BASE+0x14
++#define MX2_BCD_DEV_HIGH OTG_I2C_BASE+0x15
++#endif
++
++/*
++ * C.f. 23.14.10 I2C OTG Transceiver Controller Registers
++ * These are the I2C controller and access registers.
++ *
++ * N.B. I2C_ERROR is not documented.
++ */
++
++
++#define I2C_BUSY (1 << 7)
++#define I2C_ERROR (1 << 2)
++#define I2C_HWSMODE (1 << 1)
++#define I2C_I2COE (1 << 0)
++
++#define I2C_SCLK_TO_SCL_DIVISION (OTG_I2C_BASE+0x1E)
++
++#define I2C_INTERRUPT_AND_CONTROL (OTG_I2C_BASE+0x1F)
++
++#define I2C_STATUS_MASK (0x7)
++
++#define I2C_NOACK_EN (1 << 6)
++#define I2C_RWREADY_EN (1 << 5)
++#define I2C_OTGXCVRINT_EN (1 << 4)
++
++#define I2C_NOACK (1 << 2)
++#define I2C_RWREADY (1 << 1)
++#define I2C_OTGXCVRINT (1 << 0)
++
++#define MX2_OTG_XCVR_DEVAD OTG_I2C_BASE+0x18
++#define MX2_SEQ_OP_REG OTG_I2C_BASE+0x19
++#define MX2_SEQ_RD_STARTAD OTG_I2C_BASE+0x1a
++#define MX2_I2C_OP_CTRL_REG OTG_I2C_BASE+0x1b
++#define MX2_SCLK_TO_SCL_HPER OTG_I2C_BASE+0x1e
++#define MX2_I2C_INTERRUPT_AND_CTRL OTG_I2C_BASE+0x1f
++
++
++/* ********************************************************************************************** */
++
++/*! mx2_rb
++ */
++static u8 __inline__ mx2_rb(u32 port)
++{
++ return *(volatile u8 *) (IO_ADDRESS(port));
++}
++
++/*! mx2_rl
++ */
++static u32 __inline__ mx2_rl(u32 port)
++{
++ return *(volatile u32 *) (IO_ADDRESS(port));
++}
++
++/*! mx2_wb
++ */
++static void __inline__ mx2_wb(u32 port, u8 val)
++{
++ *(volatile u8 *)(IO_ADDRESS(port)) = val;
++}
++
++/*! mx2_orb
++ */
++static void __inline__ mx2_orb(u32 port, u8 val)
++{
++ u8 set = mx2_rb(port) | val;
++ *(volatile u8 *)(IO_ADDRESS(port)) = set;
++}
++
++/*! mx2_andb
++ */
++static void __inline__ mx2_andb(u32 port, u8 val)
++{
++ u8 set = mx2_rb(port) & val;
++ *(volatile u8 *)(IO_ADDRESS(port)) = set;
++}
++
++/*! mx2_wl
++ */
++static void __inline__ mx2_wl(u32 port, u32 val)
++{
++ u32 set;
++ *(volatile u32 *)(IO_ADDRESS(port)) = val;
++ set = mx2_rl(port);
++}
++
++/*! mx2_orl
++ */
++static void __inline__ mx2_orl(u32 port, u32 val)
++{
++ u32 set = mx2_rl(port);
++ *(volatile u32 *)(IO_ADDRESS(port)) = (set | val);
++}
++
++/*! mx2_andl
++ */
++static void __inline__ mx2_andl(u32 port, u32 val)
++{
++ u32 set = mx2_rl(port);
++ *(volatile u32 *)(IO_ADDRESS(port)) = (set & val);
++}
++
++static u32 inline mx2_host_port_stat(int n)
++{
++ switch (n) {
++ default:
++ case 1:
++ return OTG_HOST_PORT_STATUS_1;
++ case 2:
++ return OTG_HOST_PORT_STATUS_2;
++ case 3:
++ return OTG_HOST_PORT_STATUS_3;
++ }
++}
++
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-24 02:35:51 +0000