diff options
| author | Denys Dmytriyenko <denis@denix.org> | 2009-03-17 14:32:59 -0400 |
|---|---|---|
| committer | Denys Dmytriyenko <denis@denix.org> | 2009-03-17 14:32:59 -0400 |
| commit | 709c4d66e0b107ca606941b988bad717c0b45d9b (patch) | |
| tree | 37ee08b1eb308f3b2b6426d5793545c38396b838 /recipes/linux/linux-mtx-2-2.4.27/46-otg.patch | |
| parent | fa6cd5a3b993f16c27de4ff82b42684516d433ba (diff) | |
rename packages/ to recipes/ per earlier agreement
See links below for more details:
http://thread.gmane.org/gmane.comp.handhelds.openembedded/21326
http://thread.gmane.org/gmane.comp.handhelds.openembedded/21816
Signed-off-by: Denys Dmytriyenko <denis@denix.org>
Acked-by: Mike Westerhof <mwester@dls.net>
Acked-by: Philip Balister <philip@balister.org>
Acked-by: Khem Raj <raj.khem@gmail.com>
Acked-by: Marcin Juszkiewicz <hrw@openembedded.org>
Acked-by: Koen Kooi <koen@openembedded.org>
Acked-by: Frans Meulenbroeks <fransmeulenbroeks@gmail.com>
Diffstat (limited to 'recipes/linux/linux-mtx-2-2.4.27/46-otg.patch')
| -rw-r--r-- | recipes/linux/linux-mtx-2-2.4.27/46-otg.patch | 56853 |
1 files changed, 56853 insertions, 0 deletions
diff --git a/recipes/linux/linux-mtx-2-2.4.27/46-otg.patch b/recipes/linux/linux-mtx-2-2.4.27/46-otg.patch new file mode 100644 index 0000000000..2004894b3e --- /dev/null +++ b/recipes/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, §or, 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, §or, 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, §or, 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, §or, 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 = ¶ms; ++ 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; ++ } ++} ++ |