Merge branch 'master' of /pub/scm/linux/kernel/git/torvalds/linux-2.6

206 files changed, 8362 insertions, 5884 deletions

diff --git a/Documentation/DocBook/usb.tmpl b/Documentation/DocBook/usb.tmpl
index 705c442c7bf4..15ce0f21e5e0 100644
--- a/Documentation/DocBook/usb.tmpl
+++ b/Documentation/DocBook/usb.tmpl
@@ -291,7 +291,7 @@
 
 !Edrivers/usb/core/hcd.c
 !Edrivers/usb/core/hcd-pci.c
-!Edrivers/usb/core/buffer.c
+!Idrivers/usb/core/buffer.c
     </chapter>
 
     <chapter>
diff --git a/Documentation/input/yealink.txt b/Documentation/input/yealink.txt
index 85f095a7ad04..0962c5c948be 100644
--- a/Documentation/input/yealink.txt
+++ b/Documentation/input/yealink.txt
@@ -2,7 +2,6 @@ Driver documentation for yealink usb-p1k phones
 
 0. Status
 ~~~~~~~~~
-
 The p1k is a relatively cheap usb 1.1 phone with:
   - keyboard            full support, yealink.ko / input event API
   - LCD                 full support, yealink.ko / sysfs API
@@ -17,9 +16,8 @@ For vendor documentation see http://www.yealink.com
 
 1. Compilation (stand alone version)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
 Currently only kernel 2.6.x.y versions are supported.
-In order to build the yealink.ko module do:
+In order to build the yealink.ko module do
 
   make
 
@@ -28,6 +26,21 @@ the Makefile is pointing to the location where your kernel sources
 are located, default /usr/src/linux.
 
 
+1.1 Troubleshooting
+~~~~~~~~~~~~~~~~~~~
+Q: Module yealink compiled and installed without any problem but phone
+   is not initialized and does not react to any actions.
+A: If you see something like:
+   hiddev0: USB HID v1.00 Device [Yealink Network Technology Ltd. VOIP USB Phone
+   in dmesg, it means that the hid driver has grabbed the device first. Try to
+   load module yealink before any other usb hid driver. Please see the
+   instructions provided by your distribution on module configuration.
+
+Q: Phone is working now (displays version and accepts keypad input) but I can't
+   find the sysfs files.
+A: The sysfs files are located on the particular usb endpoint. On most
+   distributions you can do: "find /sys/ -name get_icons" for a hint.
+
 
 2. keyboard features
 ~~~~~~~~~~~~~~~~~~~~
diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index 971589a9752d..90766b75d1b7 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -1517,8 +1517,6 @@ running once the system is up.
         uart6850=       [HW,OSS]
                         Format: <io>,<irq>
 
-        usb-handoff     [HW] Enable early USB BIOS -> OS handoff
-
         usbhid.mousepoll=
                         [USBHID] The interval which mice are to be polled at.
 
diff --git a/MAINTAINERS b/MAINTAINERS
index 3928dc7d6ea9..770155a01523 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -116,12 +116,6 @@ M:	ajk@iehk.rwth-aachen.de
 L:      linux-hams@vger.kernel.org
 S:      Maintained
 
-YEALINK PHONE DRIVER
-P:      Henk Vergonet
-M:      Henk.Vergonet@gmail.com
-L:      usbb2k-api-dev@nongnu.org
-S:      Maintained
-
 8139CP 10/100 FAST ETHERNET DRIVER
 P:      Jeff Garzik
 M:      jgarzik@pobox.com
@@ -2495,14 +2489,6 @@ L:	linux-kernel@vger.kernel.org
 L:      linux-usb-devel@lists.sourceforge.net
 S:      Supported
 
-USB BLUETOOTH TTY CONVERTER DRIVER
-P:      Greg Kroah-Hartman
-M:      greg@kroah.com
-L:      linux-usb-users@lists.sourceforge.net
-L:      linux-usb-devel@lists.sourceforge.net
-S:      Maintained
-W:      http://www.kroah.com/linux-usb/
-
 USB CDC ETHERNET DRIVER
 P:      Greg Kroah-Hartman
 M:      greg@kroah.com
@@ -2863,6 +2849,12 @@ M:	jpr@f6fbb.org
 L:      linux-hams@vger.kernel.org
 S:      Maintained
 
+YEALINK PHONE DRIVER
+P:      Henk Vergonet
+M:      Henk.Vergonet@gmail.com
+L:      usbb2k-api-dev@nongnu.org
+S:      Maintained
+
 YMFPCI YAMAHA PCI SOUND (Use ALSA instead)
 P:      Pete Zaitcev
 M:      zaitcev@yahoo.com
diff --git a/arch/ia64/Kconfig b/arch/ia64/Kconfig
index 945c15a0722b..1642375fb14e 100644
--- a/arch/ia64/Kconfig
+++ b/arch/ia64/Kconfig
@@ -63,8 +63,6 @@ config IA64_GENERIC
         select ACPI
         select NUMA
         select ACPI_NUMA
-        select VIRTUAL_MEM_MAP
-        select DISCONTIGMEM
         help
           This selects the system type of your hardware.  A "generic" kernel
           will run on any supported IA-64 system.  However, if you configure
@@ -176,40 +174,6 @@ config IA64_L1_CACHE_SHIFT
         default "6" if ITANIUM
 
 # align cache-sensitive data to 64 bytes
-config NUMA
-        bool "NUMA support"
-        depends on !IA64_HP_SIM
-        default y if IA64_SGI_SN2
-        select ACPI_NUMA
-        help
-          Say Y to compile the kernel to support NUMA (Non-Uniform Memory
-          Access).  This option is for configuring high-end multiprocessor
-          server systems.  If in doubt, say N.
-
-config VIRTUAL_MEM_MAP
-        bool "Virtual mem map"
-        default y if !IA64_HP_SIM
-        help
-          Say Y to compile the kernel with support for a virtual mem map.
-          This code also only takes effect if a memory hole of greater than
-          1 Gb is found during boot.  You must turn this option on if you
-          require the DISCONTIGMEM option for your machine. If you are
-          unsure, say Y.
-
-config HOLES_IN_ZONE
-        bool
-        default y if VIRTUAL_MEM_MAP
-
-config ARCH_DISCONTIGMEM_ENABLE
-        bool "Discontiguous memory support"
-        depends on (IA64_DIG || IA64_SGI_SN2 || IA64_GENERIC || IA64_HP_ZX1 || IA64_HP_ZX1_SWIOTLB) && NUMA && VIRTUAL_MEM_MAP
-        default y if (IA64_SGI_SN2 || IA64_GENERIC) && NUMA
-        help
-          Say Y to support efficient handling of discontiguous physical memory,
-          for architectures which are either NUMA (Non-Uniform Memory Access)
-          or have huge holes in the physical address space for other reasons.
-          See <file:Documentation/vm/numa> for more.
-
 config IA64_CYCLONE
         bool "Cyclone (EXA) Time Source support"
         help
@@ -232,8 +196,10 @@ config IA64_SGI_SN_XP
           based on a network adapter and DMA messaging.
 
 config FORCE_MAX_ZONEORDER
-        int
-        default "18"
+        int "MAX_ORDER (11 - 17)"  if !HUGETLB_PAGE
+        range 11 17  if !HUGETLB_PAGE
+        default "17" if HUGETLB_PAGE
+        default "11"
 
 config SMP
         bool "Symmetric multi-processing support"
@@ -254,8 +220,8 @@ config SMP
           If you don't know what to do here, say N.
 
 config NR_CPUS
-        int "Maximum number of CPUs (2-512)"
-        range 2 512
+        int "Maximum number of CPUs (2-1024)"
+        range 2 1024
         depends on SMP
         default "64"
         help
@@ -298,6 +264,58 @@ config PREEMPT
 
 source "mm/Kconfig"
 
+config ARCH_SELECT_MEMORY_MODEL
+        def_bool y
+
+config ARCH_DISCONTIGMEM_ENABLE
+        def_bool y
+        help
+          Say Y to support efficient handling of discontiguous physical memory,
+          for architectures which are either NUMA (Non-Uniform Memory Access)
+          or have huge holes in the physical address space for other reasons.
+          See <file:Documentation/vm/numa> for more.
+
+config ARCH_FLATMEM_ENABLE
+        def_bool y
+
+config ARCH_SPARSEMEM_ENABLE
+        def_bool y
+        depends on ARCH_DISCONTIGMEM_ENABLE
+
+config ARCH_DISCONTIGMEM_DEFAULT
+        def_bool y if (IA64_SGI_SN2 || IA64_GENERIC || IA64_HP_ZX1 || IA64_HP_ZX1_SWIOTLB)
+        depends on ARCH_DISCONTIGMEM_ENABLE
+
+config NUMA
+        bool "NUMA support"
+        depends on !IA64_HP_SIM && !FLATMEM
+        default y if IA64_SGI_SN2
+        help
+          Say Y to compile the kernel to support NUMA (Non-Uniform Memory
+          Access).  This option is for configuring high-end multiprocessor
+          server systems.  If in doubt, say N.
+
+# VIRTUAL_MEM_MAP and FLAT_NODE_MEM_MAP are functionally equivalent.
+# VIRTUAL_MEM_MAP has been retained for historical reasons.
+config VIRTUAL_MEM_MAP
+        bool "Virtual mem map"
+        depends on !SPARSEMEM
+        default y if !IA64_HP_SIM
+        help
+          Say Y to compile the kernel with support for a virtual mem map.
+          This code also only takes effect if a memory hole of greater than
+          1 Gb is found during boot.  You must turn this option on if you
+          require the DISCONTIGMEM option for your machine. If you are
+          unsure, say Y.
+
+config HOLES_IN_ZONE
+        bool
+        default y if VIRTUAL_MEM_MAP
+
+config HAVE_ARCH_EARLY_PFN_TO_NID
+        def_bool y
+        depends on NEED_MULTIPLE_NODES
+
 config IA32_SUPPORT
         bool "Support for Linux/x86 binaries"
         help
diff --git a/arch/ia64/configs/bigsur_defconfig b/arch/ia64/configs/bigsur_defconfig
index 3b65cbb31b1d..b40672bb3ab0 100644
--- a/arch/ia64/configs/bigsur_defconfig
+++ b/arch/ia64/configs/bigsur_defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.10-rc2
-# Mon Nov 29 13:27:48 2004
+# Linux kernel version: 2.6.14-rc1
+# Wed Sep 14 15:18:49 2005
 #
 
 #
@@ -10,34 +10,40 @@
 CONFIG_EXPERIMENTAL=y
 CONFIG_CLEAN_COMPILE=y
 CONFIG_LOCK_KERNEL=y
+CONFIG_INIT_ENV_ARG_LIMIT=32
 
 #
 # General setup
 #
 CONFIG_LOCALVERSION=""
+CONFIG_LOCALVERSION_AUTO=y
 CONFIG_SWAP=y
 CONFIG_SYSVIPC=y
 CONFIG_POSIX_MQUEUE=y
 # CONFIG_BSD_PROCESS_ACCT is not set
 CONFIG_SYSCTL=y
 # CONFIG_AUDIT is not set
-CONFIG_LOG_BUF_SHIFT=16
 CONFIG_HOTPLUG=y
 CONFIG_KOBJECT_UEVENT=y
 # CONFIG_IKCONFIG is not set
+# CONFIG_CPUSETS is not set
+CONFIG_INITRAMFS_SOURCE=""
 # CONFIG_EMBEDDED is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_ALL is not set
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+CONFIG_PRINTK=y
+CONFIG_BUG=y
+CONFIG_BASE_FULL=y
 CONFIG_FUTEX=y
 CONFIG_EPOLL=y
-# CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 CONFIG_SHMEM=y
 CONFIG_CC_ALIGN_FUNCTIONS=0
 CONFIG_CC_ALIGN_LABELS=0
 CONFIG_CC_ALIGN_LOOPS=0
 CONFIG_CC_ALIGN_JUMPS=0
 # CONFIG_TINY_SHMEM is not set
+CONFIG_BASE_SMALL=0
 
 #
 # Loadable module support
@@ -58,12 +64,15 @@ CONFIG_IA64=y
 CONFIG_64BIT=y
 CONFIG_MMU=y
 CONFIG_RWSEM_XCHGADD_ALGORITHM=y
+CONFIG_GENERIC_CALIBRATE_DELAY=y
 CONFIG_TIME_INTERPOLATION=y
 CONFIG_EFI=y
 CONFIG_GENERIC_IOMAP=y
+CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER=y
 # CONFIG_IA64_GENERIC is not set
 CONFIG_IA64_DIG=y
 # CONFIG_IA64_HP_ZX1 is not set
+# CONFIG_IA64_HP_ZX1_SWIOTLB is not set
 # CONFIG_IA64_SGI_SN2 is not set
 # CONFIG_IA64_HP_SIM is not set
 CONFIG_ITANIUM=y
@@ -72,17 +81,30 @@ CONFIG_ITANIUM=y
 # CONFIG_IA64_PAGE_SIZE_8KB is not set
 CONFIG_IA64_PAGE_SIZE_16KB=y
 # CONFIG_IA64_PAGE_SIZE_64KB is not set
+# CONFIG_HZ_100 is not set
+CONFIG_HZ_250=y
+# CONFIG_HZ_1000 is not set
+CONFIG_HZ=250
 CONFIG_IA64_BRL_EMU=y
 CONFIG_IA64_L1_CACHE_SHIFT=6
 # CONFIG_NUMA is not set
 # CONFIG_VIRTUAL_MEM_MAP is not set
 # CONFIG_IA64_CYCLONE is not set
 CONFIG_IOSAPIC=y
+# CONFIG_IA64_SGI_SN_XP is not set
 CONFIG_FORCE_MAX_ZONEORDER=18
 CONFIG_SMP=y
 CONFIG_NR_CPUS=2
 # CONFIG_HOTPLUG_CPU is not set
+# CONFIG_SCHED_SMT is not set
 CONFIG_PREEMPT=y
+CONFIG_SELECT_MEMORY_MODEL=y
+CONFIG_FLATMEM_MANUAL=y
+# CONFIG_DISCONTIGMEM_MANUAL is not set
+# CONFIG_SPARSEMEM_MANUAL is not set
+CONFIG_FLATMEM=y
+CONFIG_FLAT_NODE_MEM_MAP=y
+# CONFIG_SPARSEMEM_STATIC is not set
 CONFIG_HAVE_DEC_LOCK=y
 CONFIG_IA32_SUPPORT=y
 CONFIG_COMPAT=y
@@ -95,6 +117,7 @@ CONFIG_IA64_PALINFO=y
 #
 CONFIG_EFI_VARS=y
 CONFIG_EFI_PCDP=y
+# CONFIG_DELL_RBU is not set
 CONFIG_BINFMT_ELF=y
 CONFIG_BINFMT_MISC=m
 
@@ -102,18 +125,26 @@ CONFIG_BINFMT_MISC=m
 # Power management and ACPI
 #
 CONFIG_PM=y
-CONFIG_ACPI=y
+# CONFIG_PM_DEBUG is not set
 
 #
 # ACPI (Advanced Configuration and Power Interface) Support
 #
+CONFIG_ACPI=y
 CONFIG_ACPI_BUTTON=m
 CONFIG_ACPI_FAN=m
 CONFIG_ACPI_PROCESSOR=m
 CONFIG_ACPI_THERMAL=m
+CONFIG_ACPI_BLACKLIST_YEAR=0
 # CONFIG_ACPI_DEBUG is not set
 CONFIG_ACPI_POWER=y
 CONFIG_ACPI_SYSTEM=y
+# CONFIG_ACPI_CONTAINER is not set
+
+#
+# CPU Frequency scaling
+#
+# CONFIG_CPU_FREQ is not set
 
 #
 # Bus options (PCI, PCMCIA)
@@ -122,7 +153,7 @@ CONFIG_PCI=y
 CONFIG_PCI_DOMAINS=y
 # CONFIG_PCI_MSI is not set
 CONFIG_PCI_LEGACY_PROC=y
-CONFIG_PCI_NAMES=y
+# CONFIG_PCI_DEBUG is not set
 
 #
 # PCI Hotplug Support
@@ -135,8 +166,70 @@ CONFIG_PCI_NAMES=y
 # CONFIG_PCCARD is not set
 
 #
-# PC-card bridges
+# Networking
+#
+CONFIG_NET=y
+
+#
+# Networking options
+#
+CONFIG_PACKET=y
+CONFIG_PACKET_MMAP=y
+CONFIG_UNIX=y
+# CONFIG_NET_KEY is not set
+CONFIG_INET=y
+# CONFIG_IP_MULTICAST is not set
+# CONFIG_IP_ADVANCED_ROUTER is not set
+CONFIG_IP_FIB_HASH=y
+# CONFIG_IP_PNP is not set
+# CONFIG_NET_IPIP is not set
+# CONFIG_NET_IPGRE is not set
+# CONFIG_ARPD is not set
+# CONFIG_SYN_COOKIES is not set
+# CONFIG_INET_AH is not set
+# CONFIG_INET_ESP is not set
+# CONFIG_INET_IPCOMP is not set
+# CONFIG_INET_TUNNEL is not set
+CONFIG_INET_DIAG=y
+CONFIG_INET_TCP_DIAG=y
+# CONFIG_TCP_CONG_ADVANCED is not set
+CONFIG_TCP_CONG_BIC=y
+# CONFIG_IPV6 is not set
+# CONFIG_NETFILTER is not set
+
+#
+# DCCP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_DCCP is not set
+
+#
+# SCTP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_SCTP is not set
+# CONFIG_ATM is not set
+# CONFIG_BRIDGE is not set
+# CONFIG_VLAN_8021Q is not set
+# CONFIG_DECNET is not set
+# CONFIG_LLC2 is not set
+# CONFIG_IPX is not set
+# CONFIG_ATALK is not set
+# CONFIG_X25 is not set
+# CONFIG_LAPB is not set
+# CONFIG_NET_DIVERT is not set
+# CONFIG_ECONET is not set
+# CONFIG_WAN_ROUTER is not set
+# CONFIG_NET_SCHED is not set
+# CONFIG_NET_CLS_ROUTE is not set
+
+#
+# Network testing
 #
+# CONFIG_NET_PKTGEN is not set
+# CONFIG_NETFILTER_NETLINK is not set
+# CONFIG_HAMRADIO is not set
+# CONFIG_IRDA is not set
+# CONFIG_BT is not set
+# CONFIG_IEEE80211 is not set
 
 #
 # Device Drivers
@@ -151,6 +244,11 @@ CONFIG_PREVENT_FIRMWARE_BUILD=y
 # CONFIG_DEBUG_DRIVER is not set
 
 #
+# Connector - unified userspace <-> kernelspace linker
+#
+# CONFIG_CONNECTOR is not set
+
+#
 # Memory Technology Devices (MTD)
 #
 # CONFIG_MTD is not set
@@ -163,7 +261,13 @@ CONFIG_PREVENT_FIRMWARE_BUILD=y
 #
 # Plug and Play support
 #
-# CONFIG_PNP is not set
+CONFIG_PNP=y
+# CONFIG_PNP_DEBUG is not set
+
+#
+# Protocols
+#
+CONFIG_PNPACPI=y
 
 #
 # Block devices
@@ -172,14 +276,15 @@ CONFIG_PREVENT_FIRMWARE_BUILD=y
 # CONFIG_BLK_CPQ_CISS_DA is not set
 # CONFIG_BLK_DEV_DAC960 is not set
 # CONFIG_BLK_DEV_UMEM is not set
+# CONFIG_BLK_DEV_COW_COMMON is not set
 CONFIG_BLK_DEV_LOOP=m
 CONFIG_BLK_DEV_CRYPTOLOOP=m
 CONFIG_BLK_DEV_NBD=m
 # CONFIG_BLK_DEV_SX8 is not set
 # CONFIG_BLK_DEV_UB is not set
 CONFIG_BLK_DEV_RAM=m
+CONFIG_BLK_DEV_RAM_COUNT=16
 CONFIG_BLK_DEV_RAM_SIZE=4096
-CONFIG_INITRAMFS_SOURCE=""
 # CONFIG_CDROM_PKTCDVD is not set
 
 #
@@ -189,6 +294,7 @@ CONFIG_IOSCHED_NOOP=y
 CONFIG_IOSCHED_AS=y
 CONFIG_IOSCHED_DEADLINE=y
 CONFIG_IOSCHED_CFQ=y
+# CONFIG_ATA_OVER_ETH is not set
 
 #
 # ATA/ATAPI/MFM/RLL support
@@ -211,7 +317,8 @@ CONFIG_BLK_DEV_IDEFLOPPY=m
 #
 # IDE chipset support/bugfixes
 #
-CONFIG_IDE_GENERIC=m
+# CONFIG_IDE_GENERIC is not set
+# CONFIG_BLK_DEV_IDEPNP is not set
 CONFIG_BLK_DEV_IDEPCI=y
 CONFIG_IDEPCI_SHARE_IRQ=y
 # CONFIG_BLK_DEV_OFFBOARD is not set
@@ -233,6 +340,7 @@ CONFIG_IDEDMA_PCI_AUTO=y
 # CONFIG_BLK_DEV_HPT366 is not set
 # CONFIG_BLK_DEV_SC1200 is not set
 CONFIG_BLK_DEV_PIIX=m
+# CONFIG_BLK_DEV_IT821X is not set
 # CONFIG_BLK_DEV_NS87415 is not set
 # CONFIG_BLK_DEV_PDC202XX_OLD is not set
 # CONFIG_BLK_DEV_PDC202XX_NEW is not set
@@ -250,6 +358,7 @@ CONFIG_IDEDMA_AUTO=y
 #
 # SCSI device support
 #
+# CONFIG_RAID_ATTRS is not set
 CONFIG_SCSI=y
 CONFIG_SCSI_PROC_FS=y
 
@@ -261,6 +370,7 @@ CONFIG_BLK_DEV_SD=y
 # CONFIG_CHR_DEV_OSST is not set
 # CONFIG_BLK_DEV_SR is not set
 # CONFIG_CHR_DEV_SG is not set
+# CONFIG_CHR_DEV_SCH is not set
 
 #
 # Some SCSI devices (e.g. CD jukebox) support multiple LUNs
@@ -274,6 +384,8 @@ CONFIG_SCSI_LOGGING=y
 #
 CONFIG_SCSI_SPI_ATTRS=m
 # CONFIG_SCSI_FC_ATTRS is not set
+# CONFIG_SCSI_ISCSI_ATTRS is not set
+# CONFIG_SCSI_SAS_ATTRS is not set
 
 #
 # SCSI low-level drivers
@@ -288,18 +400,13 @@ CONFIG_SCSI_SPI_ATTRS=m
 # CONFIG_MEGARAID_NEWGEN is not set
 # CONFIG_MEGARAID_LEGACY is not set
 # CONFIG_SCSI_SATA is not set
-# CONFIG_SCSI_BUSLOGIC is not set
 # CONFIG_SCSI_DMX3191D is not set
-# CONFIG_SCSI_EATA is not set
-# CONFIG_SCSI_EATA_PIO is not set
 # CONFIG_SCSI_FUTURE_DOMAIN is not set
-# CONFIG_SCSI_GDTH is not set
 # CONFIG_SCSI_IPS is not set
 # CONFIG_SCSI_INITIO is not set
 # CONFIG_SCSI_INIA100 is not set
 # CONFIG_SCSI_SYM53C8XX_2 is not set
 # CONFIG_SCSI_IPR is not set
-# CONFIG_SCSI_QLOGIC_ISP is not set
 # CONFIG_SCSI_QLOGIC_FC is not set
 CONFIG_SCSI_QLOGIC_1280=y
 # CONFIG_SCSI_QLOGIC_1280_1040 is not set
@@ -309,7 +416,8 @@ CONFIG_SCSI_QLA2XXX=y
 # CONFIG_SCSI_QLA2300 is not set
 # CONFIG_SCSI_QLA2322 is not set
 # CONFIG_SCSI_QLA6312 is not set
-# CONFIG_SCSI_QLA6322 is not set
+# CONFIG_SCSI_QLA24XX is not set
+# CONFIG_SCSI_LPFC is not set
 # CONFIG_SCSI_DC395x is not set
 # CONFIG_SCSI_DC390T is not set
 # CONFIG_SCSI_DEBUG is not set
@@ -332,11 +440,14 @@ CONFIG_DM_CRYPT=m
 CONFIG_DM_SNAPSHOT=m
 CONFIG_DM_MIRROR=m
 CONFIG_DM_ZERO=m
+# CONFIG_DM_MULTIPATH is not set
 
 #
 # Fusion MPT device support
 #
 # CONFIG_FUSION is not set
+# CONFIG_FUSION_SPI is not set
+# CONFIG_FUSION_FC is not set
 
 #
 # IEEE 1394 (FireWire) support
@@ -349,72 +460,14 @@ CONFIG_DM_ZERO=m
 # CONFIG_I2O is not set
 
 #
-# Networking support
+# Network device support
 #
-CONFIG_NET=y
-
-#
-# Networking options
-#
-CONFIG_PACKET=y
-CONFIG_PACKET_MMAP=y
-# CONFIG_NETLINK_DEV is not set
-CONFIG_UNIX=y
-# CONFIG_NET_KEY is not set
-CONFIG_INET=y
-# CONFIG_IP_MULTICAST is not set
-# CONFIG_IP_ADVANCED_ROUTER is not set
-# CONFIG_IP_PNP is not set
-# CONFIG_NET_IPIP is not set
-# CONFIG_NET_IPGRE is not set
-# CONFIG_ARPD is not set
-# CONFIG_SYN_COOKIES is not set
-# CONFIG_INET_AH is not set
-# CONFIG_INET_ESP is not set
-# CONFIG_INET_IPCOMP is not set
-# CONFIG_INET_TUNNEL is not set
-CONFIG_IP_TCPDIAG=y
-# CONFIG_IP_TCPDIAG_IPV6 is not set
-# CONFIG_IPV6 is not set
-# CONFIG_NETFILTER is not set
-
-#
-# SCTP Configuration (EXPERIMENTAL)
-#
-# CONFIG_IP_SCTP is not set
-# CONFIG_ATM is not set
-# CONFIG_BRIDGE is not set
-# CONFIG_VLAN_8021Q is not set
-# CONFIG_DECNET is not set
-# CONFIG_LLC2 is not set
-# CONFIG_IPX is not set
-# CONFIG_ATALK is not set
-# CONFIG_X25 is not set
-# CONFIG_LAPB is not set
-# CONFIG_NET_DIVERT is not set
-# CONFIG_ECONET is not set
-# CONFIG_WAN_ROUTER is not set
-
-#
-# QoS and/or fair queueing
-#
-# CONFIG_NET_SCHED is not set
-# CONFIG_NET_CLS_ROUTE is not set
-
-#
-# Network testing
-#
-# CONFIG_NET_PKTGEN is not set
-# CONFIG_NETPOLL is not set
-# CONFIG_NET_POLL_CONTROLLER is not set
-# CONFIG_HAMRADIO is not set
-# CONFIG_IRDA is not set
-# CONFIG_BT is not set
 CONFIG_NETDEVICES=y
 CONFIG_DUMMY=y
 # CONFIG_BONDING is not set
 # CONFIG_EQUALIZER is not set
 # CONFIG_TUN is not set
+# CONFIG_NET_SB1000 is not set
 
 #
 # ARCnet devices
@@ -422,6 +475,11 @@ CONFIG_DUMMY=y
 # CONFIG_ARCNET is not set
 
 #
+# PHY device support
+#
+# CONFIG_PHYLIB is not set
+
+#
 # Ethernet (10 or 100Mbit)
 #
 CONFIG_NET_ETHERNET=y
@@ -443,7 +501,6 @@ CONFIG_NET_PCI=y
 # CONFIG_FORCEDETH is not set
 # CONFIG_DGRS is not set
 CONFIG_EEPRO100=y
-# CONFIG_EEPRO100_PIO is not set
 # CONFIG_E100 is not set
 # CONFIG_FEALNX is not set
 # CONFIG_NATSEMI is not set
@@ -465,13 +522,17 @@ CONFIG_EEPRO100=y
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
 # CONFIG_R8169 is not set
+# CONFIG_SIS190 is not set
+# CONFIG_SKGE is not set
 # CONFIG_SK98LIN is not set
 # CONFIG_VIA_VELOCITY is not set
 # CONFIG_TIGON3 is not set
+# CONFIG_BNX2 is not set
 
 #
 # Ethernet (10000 Mbit)
 #
+# CONFIG_CHELSIO_T1 is not set
 # CONFIG_IXGB is not set
 # CONFIG_S2IO is not set
 
@@ -496,6 +557,8 @@ CONFIG_EEPRO100=y
 # CONFIG_NET_FC is not set
 # CONFIG_SHAPER is not set
 # CONFIG_NETCONSOLE is not set
+# CONFIG_NETPOLL is not set
+# CONFIG_NET_POLL_CONTROLLER is not set
 
 #
 # ISDN subsystem
@@ -525,18 +588,6 @@ CONFIG_INPUT_EVDEV=y
 # CONFIG_INPUT_EVBUG is not set
 
 #
-# Input I/O drivers
-#
-# CONFIG_GAMEPORT is not set
-CONFIG_SOUND_GAMEPORT=y
-CONFIG_SERIO=y
-CONFIG_SERIO_I8042=y
-CONFIG_SERIO_SERPORT=y
-# CONFIG_SERIO_CT82C710 is not set
-# CONFIG_SERIO_PCIPS2 is not set
-# CONFIG_SERIO_RAW is not set
-
-#
 # Input Device Drivers
 #
 CONFIG_INPUT_KEYBOARD=y
@@ -554,6 +605,17 @@ CONFIG_MOUSE_PS2=y
 # CONFIG_INPUT_MISC is not set
 
 #
+# Hardware I/O ports
+#
+CONFIG_SERIO=y
+CONFIG_SERIO_I8042=y
+CONFIG_SERIO_SERPORT=y
+# CONFIG_SERIO_PCIPS2 is not set
+CONFIG_SERIO_LIBPS2=y
+# CONFIG_SERIO_RAW is not set
+# CONFIG_GAMEPORT is not set
+
+#
 # Character devices
 #
 CONFIG_VT=y
@@ -571,7 +633,6 @@ CONFIG_SERIAL_8250_NR_UARTS=4
 CONFIG_SERIAL_8250_EXTENDED=y
 CONFIG_SERIAL_8250_SHARE_IRQ=y
 # CONFIG_SERIAL_8250_DETECT_IRQ is not set
-# CONFIG_SERIAL_8250_MULTIPORT is not set
 # CONFIG_SERIAL_8250_RSA is not set
 
 #
@@ -579,6 +640,7 @@ CONFIG_SERIAL_8250_SHARE_IRQ=y
 #
 CONFIG_SERIAL_CORE=y
 CONFIG_SERIAL_CORE_CONSOLE=y
+# CONFIG_SERIAL_JSM is not set
 CONFIG_UNIX98_PTYS=y
 CONFIG_LEGACY_PTYS=y
 CONFIG_LEGACY_PTY_COUNT=256
@@ -603,14 +665,22 @@ CONFIG_EFI_RTC=y
 #
 CONFIG_AGP=m
 CONFIG_AGP_I460=m
-CONFIG_DRM=y
+CONFIG_DRM=m
 # CONFIG_DRM_TDFX is not set
 CONFIG_DRM_R128=m
 # CONFIG_DRM_RADEON is not set
 # CONFIG_DRM_MGA is not set
 # CONFIG_DRM_SIS is not set
+# CONFIG_DRM_VIA is not set
+# CONFIG_DRM_SAVAGE is not set
 # CONFIG_RAW_DRIVER is not set
 # CONFIG_HPET is not set
+# CONFIG_HANGCHECK_TIMER is not set
+
+#
+# TPM devices
+#
+# CONFIG_TCG_TPM is not set
 
 #
 # I2C support
@@ -635,7 +705,7 @@ CONFIG_I2C_ALGOBIT=y
 # CONFIG_I2C_AMD8111 is not set
 # CONFIG_I2C_I801 is not set
 # CONFIG_I2C_I810 is not set
-# CONFIG_I2C_ISA is not set
+# CONFIG_I2C_PIIX4 is not set
 # CONFIG_I2C_NFORCE2 is not set
 # CONFIG_I2C_PARPORT_LIGHT is not set
 # CONFIG_I2C_PROSAVAGE is not set
@@ -651,16 +721,43 @@ CONFIG_I2C_ALGOBIT=y
 # CONFIG_I2C_PCA_ISA is not set
 
 #
-# Hardware Sensors Chip support
+# Miscellaneous I2C Chip support
 #
-# CONFIG_I2C_SENSOR is not set
+# CONFIG_SENSORS_DS1337 is not set
+# CONFIG_SENSORS_DS1374 is not set
+# CONFIG_SENSORS_EEPROM is not set
+# CONFIG_SENSORS_PCF8574 is not set
+# CONFIG_SENSORS_PCA9539 is not set
+# CONFIG_SENSORS_PCF8591 is not set
+# CONFIG_SENSORS_RTC8564 is not set
+# CONFIG_SENSORS_MAX6875 is not set
+# CONFIG_I2C_DEBUG_CORE is not set
+# CONFIG_I2C_DEBUG_ALGO is not set
+# CONFIG_I2C_DEBUG_BUS is not set
+# CONFIG_I2C_DEBUG_CHIP is not set
+
+#
+# Dallas's 1-wire bus
+#
+# CONFIG_W1 is not set
+
+#
+# Hardware Monitoring support
+#
+CONFIG_HWMON=y
+# CONFIG_HWMON_VID is not set
 # CONFIG_SENSORS_ADM1021 is not set
 # CONFIG_SENSORS_ADM1025 is not set
+# CONFIG_SENSORS_ADM1026 is not set
 # CONFIG_SENSORS_ADM1031 is not set
+# CONFIG_SENSORS_ADM9240 is not set
 # CONFIG_SENSORS_ASB100 is not set
+# CONFIG_SENSORS_ATXP1 is not set
 # CONFIG_SENSORS_DS1621 is not set
 # CONFIG_SENSORS_FSCHER is not set
+# CONFIG_SENSORS_FSCPOS is not set
 # CONFIG_SENSORS_GL518SM is not set
+# CONFIG_SENSORS_GL520SM is not set
 # CONFIG_SENSORS_IT87 is not set
 # CONFIG_SENSORS_LM63 is not set
 # CONFIG_SENSORS_LM75 is not set
@@ -671,33 +768,26 @@ CONFIG_I2C_ALGOBIT=y
 # CONFIG_SENSORS_LM85 is not set
 # CONFIG_SENSORS_LM87 is not set
 # CONFIG_SENSORS_LM90 is not set
+# CONFIG_SENSORS_LM92 is not set
 # CONFIG_SENSORS_MAX1619 is not set
 # CONFIG_SENSORS_PC87360 is not set
+# CONFIG_SENSORS_SIS5595 is not set
 # CONFIG_SENSORS_SMSC47M1 is not set
+# CONFIG_SENSORS_SMSC47B397 is not set
 # CONFIG_SENSORS_VIA686A is not set
 # CONFIG_SENSORS_W83781D is not set
+# CONFIG_SENSORS_W83792D is not set
 # CONFIG_SENSORS_W83L785TS is not set
 # CONFIG_SENSORS_W83627HF is not set
+# CONFIG_SENSORS_W83627EHF is not set
+# CONFIG_HWMON_DEBUG_CHIP is not set
 
 #
-# Other I2C Chip support
-#
-# CONFIG_SENSORS_EEPROM is not set
-# CONFIG_SENSORS_PCF8574 is not set
-# CONFIG_SENSORS_PCF8591 is not set
-# CONFIG_SENSORS_RTC8564 is not set
-# CONFIG_I2C_DEBUG_CORE is not set
-# CONFIG_I2C_DEBUG_ALGO is not set
-# CONFIG_I2C_DEBUG_BUS is not set
-# CONFIG_I2C_DEBUG_CHIP is not set
-
-#
-# Dallas's 1-wire bus
+# Misc devices
 #
-# CONFIG_W1 is not set
 
 #
-# Misc devices
+# Multimedia Capabilities Port drivers
 #
 
 #
@@ -752,11 +842,12 @@ CONFIG_SND_OPL3_LIB=m
 # CONFIG_SND_MTPAV is not set
 # CONFIG_SND_SERIAL_U16550 is not set
 # CONFIG_SND_MPU401 is not set
+CONFIG_SND_AC97_CODEC=m
+CONFIG_SND_AC97_BUS=m
 
 #
 # PCI devices
 #
-CONFIG_SND_AC97_CODEC=m
 # CONFIG_SND_ALI5451 is not set
 # CONFIG_SND_ATIIXP is not set
 # CONFIG_SND_ATIIXP_MODEM is not set
@@ -768,6 +859,8 @@ CONFIG_SND_AC97_CODEC=m
 # CONFIG_SND_CS46XX is not set
 CONFIG_SND_CS4281=m
 # CONFIG_SND_EMU10K1 is not set
+# CONFIG_SND_EMU10K1X is not set
+# CONFIG_SND_CA0106 is not set
 # CONFIG_SND_KORG1212 is not set
 # CONFIG_SND_MIXART is not set
 # CONFIG_SND_NM256 is not set
@@ -775,9 +868,10 @@ CONFIG_SND_CS4281=m
 # CONFIG_SND_RME96 is not set
 # CONFIG_SND_RME9652 is not set
 # CONFIG_SND_HDSP is not set
+# CONFIG_SND_HDSPM is not set
 # CONFIG_SND_TRIDENT is not set
 # CONFIG_SND_YMFPCI is not set
-# CONFIG_SND_ALS4000 is not set
+# CONFIG_SND_AD1889 is not set
 # CONFIG_SND_CMIPCI is not set
 # CONFIG_SND_ENS1370 is not set
 # CONFIG_SND_ENS1371 is not set
@@ -791,13 +885,14 @@ CONFIG_SND_CS4281=m
 # CONFIG_SND_INTEL8X0M is not set
 # CONFIG_SND_SONICVIBES is not set
 # CONFIG_SND_VIA82XX is not set
+# CONFIG_SND_VIA82XX_MODEM is not set
 # CONFIG_SND_VX222 is not set
+# CONFIG_SND_HDA_INTEL is not set
 
 #
 # USB devices
 #
 # CONFIG_SND_USB_AUDIO is not set
-# CONFIG_SND_USB_USX2Y is not set
 
 #
 # Open Sound System
@@ -807,6 +902,8 @@ CONFIG_SND_CS4281=m
 #
 # USB support
 #
+CONFIG_USB_ARCH_HAS_HCD=y
+CONFIG_USB_ARCH_HAS_OHCI=y
 CONFIG_USB=m
 # CONFIG_USB_DEBUG is not set
 
@@ -818,35 +915,38 @@ CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DYNAMIC_MINORS is not set
 # CONFIG_USB_SUSPEND is not set
 # CONFIG_USB_OTG is not set
-CONFIG_USB_ARCH_HAS_HCD=y
-CONFIG_USB_ARCH_HAS_OHCI=y
 
 #
 # USB Host Controller Drivers
 #
 # CONFIG_USB_EHCI_HCD is not set
+# CONFIG_USB_ISP116X_HCD is not set
 # CONFIG_USB_OHCI_HCD is not set
 CONFIG_USB_UHCI_HCD=m
+# CONFIG_USB_SL811_HCD is not set
 
 #
 # USB Device Class drivers
 #
-CONFIG_USB_AUDIO=m
+# CONFIG_OBSOLETE_OSS_USB_DRIVER is not set
 CONFIG_USB_BLUETOOTH_TTY=m
-CONFIG_USB_MIDI=m
 CONFIG_USB_ACM=m
 CONFIG_USB_PRINTER=m
+
+#
+# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support' may also be needed; see USB_STORAGE Help for more information
+#
 CONFIG_USB_STORAGE=m
 # CONFIG_USB_STORAGE_DEBUG is not set
-# CONFIG_USB_STORAGE_RW_DETECT is not set
 # CONFIG_USB_STORAGE_DATAFAB is not set
 # CONFIG_USB_STORAGE_FREECOM is not set
 # CONFIG_USB_STORAGE_ISD200 is not set
 # CONFIG_USB_STORAGE_DPCM is not set
-# CONFIG_USB_STORAGE_HP8200e is not set
+# CONFIG_USB_STORAGE_USBAT is not set
 # CONFIG_USB_STORAGE_SDDR09 is not set
 # CONFIG_USB_STORAGE_SDDR55 is not set
 # CONFIG_USB_STORAGE_JUMPSHOT is not set
+# CONFIG_USB_STORAGE_ONETOUCH is not set
 
 #
 # USB Input Devices
@@ -863,19 +963,23 @@ CONFIG_USB_HIDDEV=y
 # CONFIG_USB_MOUSE is not set
 # CONFIG_USB_AIPTEK is not set
 # CONFIG_USB_WACOM is not set
+# CONFIG_USB_ACECAD is not set
 # CONFIG_USB_KBTAB is not set
 # CONFIG_USB_POWERMATE is not set
 # CONFIG_USB_MTOUCH is not set
+# CONFIG_USB_ITMTOUCH is not set
 # CONFIG_USB_EGALAX is not set
+# CONFIG_USB_YEALINK is not set
 # CONFIG_USB_XPAD is not set
 # CONFIG_USB_ATI_REMOTE is not set
+# CONFIG_USB_KEYSPAN_REMOTE is not set
+# CONFIG_USB_APPLETOUCH is not set
 
 #
 # USB Imaging devices
 #
 # CONFIG_USB_MDC800 is not set
 # CONFIG_USB_MICROTEK is not set
-# CONFIG_USB_HPUSBSCSI is not set
 
 #
 # USB Multimedia devices
@@ -894,6 +998,7 @@ CONFIG_USB_HIDDEV=y
 # CONFIG_USB_PEGASUS is not set
 # CONFIG_USB_RTL8150 is not set
 # CONFIG_USB_USBNET is not set
+CONFIG_USB_MON=y
 
 #
 # USB port drivers
@@ -909,7 +1014,6 @@ CONFIG_USB_HIDDEV=y
 #
 # CONFIG_USB_EMI62 is not set
 # CONFIG_USB_EMI26 is not set
-# CONFIG_USB_TIGL is not set
 # CONFIG_USB_AUERSWALD is not set
 # CONFIG_USB_RIO500 is not set
 # CONFIG_USB_LEGOTOWER is not set
@@ -918,10 +1022,12 @@ CONFIG_USB_HIDDEV=y
 # CONFIG_USB_CYTHERM is not set
 # CONFIG_USB_PHIDGETKIT is not set
 # CONFIG_USB_PHIDGETSERVO is not set
+# CONFIG_USB_IDMOUSE is not set
+# CONFIG_USB_LD is not set
 # CONFIG_USB_TEST is not set
 
 #
-# USB ATM/DSL drivers
+# USB DSL modem support
 #
 
 #
@@ -930,10 +1036,25 @@ CONFIG_USB_HIDDEV=y
 # CONFIG_USB_GADGET is not set
 
 #
+# MMC/SD Card support
+#
+# CONFIG_MMC is not set
+
+#
+# InfiniBand support
+#
+# CONFIG_INFINIBAND is not set
+
+#
+# SN Devices
+#
+
+#
 # File systems
 #
 CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
+# CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
@@ -945,17 +1066,20 @@ CONFIG_FS_MBCACHE=y
 # CONFIG_JFS_FS is not set
 CONFIG_FS_POSIX_ACL=y
 CONFIG_XFS_FS=y
-# CONFIG_XFS_RT is not set
+CONFIG_XFS_EXPORT=y
 CONFIG_XFS_QUOTA=y
 CONFIG_XFS_SECURITY=y
 CONFIG_XFS_POSIX_ACL=y
+# CONFIG_XFS_RT is not set
 # CONFIG_MINIX_FS is not set
 # CONFIG_ROMFS_FS is not set
+CONFIG_INOTIFY=y
 # CONFIG_QUOTA is not set
 CONFIG_QUOTACTL=y
 CONFIG_DNOTIFY=y
 CONFIG_AUTOFS_FS=m
 CONFIG_AUTOFS4_FS=m
+# CONFIG_FUSE_FS is not set
 
 #
 # CD-ROM/DVD Filesystems
@@ -982,14 +1106,11 @@ CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
 CONFIG_PROC_FS=y
 CONFIG_PROC_KCORE=y
 CONFIG_SYSFS=y
-# CONFIG_DEVFS_FS is not set
-CONFIG_DEVPTS_FS_XATTR=y
-CONFIG_DEVPTS_FS_SECURITY=y
 CONFIG_TMPFS=y
-# CONFIG_TMPFS_XATTR is not set
 CONFIG_HUGETLBFS=y
 CONFIG_HUGETLB_PAGE=y
 CONFIG_RAMFS=y
+# CONFIG_RELAYFS_FS is not set
 
 #
 # Miscellaneous filesystems
@@ -1013,15 +1134,18 @@ CONFIG_RAMFS=y
 #
 CONFIG_NFS_FS=m
 CONFIG_NFS_V3=y
+# CONFIG_NFS_V3_ACL is not set
 CONFIG_NFS_V4=y
 # CONFIG_NFS_DIRECTIO is not set
 CONFIG_NFSD=m
 CONFIG_NFSD_V3=y
+# CONFIG_NFSD_V3_ACL is not set
 CONFIG_NFSD_V4=y
 CONFIG_NFSD_TCP=y
 CONFIG_LOCKD=m
 CONFIG_LOCKD_V4=y
-CONFIG_EXPORTFS=m
+CONFIG_EXPORTFS=y
+CONFIG_NFS_COMMON=y
 CONFIG_SUNRPC=m
 CONFIG_SUNRPC_GSS=m
 CONFIG_RPCSEC_GSS_KRB5=m
@@ -1031,9 +1155,11 @@ CONFIG_CIFS=m
 CONFIG_CIFS_STATS=y
 CONFIG_CIFS_XATTR=y
 CONFIG_CIFS_POSIX=y
+# CONFIG_CIFS_EXPERIMENTAL is not set
 # CONFIG_NCP_FS is not set
 # CONFIG_CODA_FS is not set
 # CONFIG_AFS_FS is not set
+# CONFIG_9P_FS is not set
 
 #
 # Partition Types
@@ -1103,8 +1229,12 @@ CONFIG_NLS_UTF8=m
 # Library routines
 #
 # CONFIG_CRC_CCITT is not set
+# CONFIG_CRC16 is not set
 CONFIG_CRC32=y
 # CONFIG_LIBCRC32C is not set
+CONFIG_GENERIC_HARDIRQS=y
+CONFIG_GENERIC_IRQ_PROBE=y
+CONFIG_GENERIC_PENDING_IRQ=y
 
 #
 # Profiling support
@@ -1115,14 +1245,20 @@ CONFIG_OPROFILE=y
 #
 # Kernel hacking
 #
+# CONFIG_PRINTK_TIME is not set
 CONFIG_DEBUG_KERNEL=y
 CONFIG_MAGIC_SYSRQ=y
+CONFIG_LOG_BUF_SHIFT=16
+CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_DEBUG_SLAB is not set
+CONFIG_DEBUG_PREEMPT=y
 # CONFIG_DEBUG_SPINLOCK is not set
 # CONFIG_DEBUG_SPINLOCK_SLEEP is not set
 # CONFIG_DEBUG_KOBJECT is not set
 # CONFIG_DEBUG_INFO is not set
+# CONFIG_DEBUG_FS is not set
+# CONFIG_KPROBES is not set
 # CONFIG_IA64_GRANULE_16MB is not set
 CONFIG_IA64_GRANULE_64MB=y
 # CONFIG_IA64_PRINT_HAZARDS is not set
@@ -1149,6 +1285,7 @@ CONFIG_CRYPTO_MD5=y
 # CONFIG_CRYPTO_SHA256 is not set
 # CONFIG_CRYPTO_SHA512 is not set
 # CONFIG_CRYPTO_WP512 is not set
+# CONFIG_CRYPTO_TGR192 is not set
 CONFIG_CRYPTO_DES=y
 # CONFIG_CRYPTO_BLOWFISH is not set
 # CONFIG_CRYPTO_TWOFISH is not set
@@ -1164,3 +1301,7 @@ CONFIG_CRYPTO_DES=y
 # CONFIG_CRYPTO_MICHAEL_MIC is not set
 # CONFIG_CRYPTO_CRC32C is not set
 # CONFIG_CRYPTO_TEST is not set
+
+#
+# Hardware crypto devices
+#
diff --git a/arch/ia64/configs/gensparse_defconfig b/arch/ia64/configs/gensparse_defconfig
new file mode 100644
index 000000000000..80f8663bc6d9
--- /dev/null
+++ b/arch/ia64/configs/gensparse_defconfig
@@ -0,0 +1,1319 @@
+#
+# Automatically generated make config: don't edit
+# Linux kernel version: 2.6.14-rc2
+# Wed Sep 28 08:27:29 2005
+#
+
+#
+# Code maturity level options
+#
+CONFIG_EXPERIMENTAL=y
+CONFIG_CLEAN_COMPILE=y
+CONFIG_LOCK_KERNEL=y
+CONFIG_INIT_ENV_ARG_LIMIT=32
+
+#
+# General setup
+#
+CONFIG_LOCALVERSION=""
+CONFIG_LOCALVERSION_AUTO=y
+CONFIG_SWAP=y
+CONFIG_SYSVIPC=y
+CONFIG_POSIX_MQUEUE=y
+# CONFIG_BSD_PROCESS_ACCT is not set
+CONFIG_SYSCTL=y
+# CONFIG_AUDIT is not set
+CONFIG_HOTPLUG=y
+CONFIG_KOBJECT_UEVENT=y
+CONFIG_IKCONFIG=y
+CONFIG_IKCONFIG_PROC=y
+# CONFIG_CPUSETS is not set
+CONFIG_INITRAMFS_SOURCE=""
+# CONFIG_EMBEDDED is not set
+CONFIG_KALLSYMS=y
+CONFIG_KALLSYMS_ALL=y
+# CONFIG_KALLSYMS_EXTRA_PASS is not set
+CONFIG_PRINTK=y
+CONFIG_BUG=y
+CONFIG_BASE_FULL=y
+CONFIG_FUTEX=y
+CONFIG_EPOLL=y
+CONFIG_SHMEM=y
+CONFIG_CC_ALIGN_FUNCTIONS=0
+CONFIG_CC_ALIGN_LABELS=0
+CONFIG_CC_ALIGN_LOOPS=0
+CONFIG_CC_ALIGN_JUMPS=0
+# CONFIG_TINY_SHMEM is not set
+CONFIG_BASE_SMALL=0
+
+#
+# Loadable module support
+#
+CONFIG_MODULES=y
+CONFIG_MODULE_UNLOAD=y
+# CONFIG_MODULE_FORCE_UNLOAD is not set
+CONFIG_OBSOLETE_MODPARM=y
+CONFIG_MODVERSIONS=y
+# CONFIG_MODULE_SRCVERSION_ALL is not set
+CONFIG_KMOD=y
+CONFIG_STOP_MACHINE=y
+
+#
+# Processor type and features
+#
+CONFIG_IA64=y
+CONFIG_64BIT=y
+CONFIG_MMU=y
+CONFIG_RWSEM_XCHGADD_ALGORITHM=y
+CONFIG_GENERIC_CALIBRATE_DELAY=y
+CONFIG_TIME_INTERPOLATION=y
+CONFIG_EFI=y
+CONFIG_GENERIC_IOMAP=y
+CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER=y
+CONFIG_IA64_GENERIC=y
+# CONFIG_IA64_DIG is not set
+# CONFIG_IA64_HP_ZX1 is not set
+# CONFIG_IA64_HP_ZX1_SWIOTLB is not set
+# CONFIG_IA64_SGI_SN2 is not set
+# CONFIG_IA64_HP_SIM is not set
+# CONFIG_ITANIUM is not set
+CONFIG_MCKINLEY=y
+# CONFIG_IA64_PAGE_SIZE_4KB is not set
+# CONFIG_IA64_PAGE_SIZE_8KB is not set
+CONFIG_IA64_PAGE_SIZE_16KB=y
+# CONFIG_IA64_PAGE_SIZE_64KB is not set
+# CONFIG_HZ_100 is not set
+CONFIG_HZ_250=y
+# CONFIG_HZ_1000 is not set
+CONFIG_HZ=250
+CONFIG_IA64_L1_CACHE_SHIFT=7
+CONFIG_IA64_CYCLONE=y
+CONFIG_IOSAPIC=y
+# CONFIG_IA64_SGI_SN_XP is not set
+CONFIG_FORCE_MAX_ZONEORDER=17
+CONFIG_SMP=y
+CONFIG_NR_CPUS=512
+CONFIG_HOTPLUG_CPU=y
+# CONFIG_SCHED_SMT is not set
+# CONFIG_PREEMPT is not set
+CONFIG_SELECT_MEMORY_MODEL=y
+# CONFIG_FLATMEM_MANUAL is not set
+# CONFIG_DISCONTIGMEM_MANUAL is not set
+CONFIG_SPARSEMEM_MANUAL=y
+CONFIG_SPARSEMEM=y
+CONFIG_NEED_MULTIPLE_NODES=y
+CONFIG_HAVE_MEMORY_PRESENT=y
+# CONFIG_SPARSEMEM_STATIC is not set
+CONFIG_SPARSEMEM_EXTREME=y
+CONFIG_ARCH_SELECT_MEMORY_MODEL=y
+CONFIG_ARCH_DISCONTIGMEM_ENABLE=y
+CONFIG_ARCH_FLATMEM_ENABLE=y
+CONFIG_ARCH_SPARSEMEM_ENABLE=y
+CONFIG_ARCH_DISCONTIGMEM_DEFAULT=y
+CONFIG_NUMA=y
+CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID=y
+CONFIG_IA32_SUPPORT=y
+CONFIG_COMPAT=y
+CONFIG_IA64_MCA_RECOVERY=y
+CONFIG_PERFMON=y
+CONFIG_IA64_PALINFO=y
+
+#
+# Firmware Drivers
+#
+CONFIG_EFI_VARS=y
+CONFIG_EFI_PCDP=y
+# CONFIG_DELL_RBU is not set
+CONFIG_BINFMT_ELF=y
+CONFIG_BINFMT_MISC=m
+
+#
+# Power management and ACPI
+#
+CONFIG_PM=y
+# CONFIG_PM_DEBUG is not set
+
+#
+# ACPI (Advanced Configuration and Power Interface) Support
+#
+CONFIG_ACPI=y
+CONFIG_ACPI_BUTTON=m
+CONFIG_ACPI_FAN=m
+CONFIG_ACPI_PROCESSOR=m
+CONFIG_ACPI_HOTPLUG_CPU=y
+CONFIG_ACPI_THERMAL=m
+CONFIG_ACPI_NUMA=y
+CONFIG_ACPI_BLACKLIST_YEAR=0
+# CONFIG_ACPI_DEBUG is not set
+CONFIG_ACPI_POWER=y
+CONFIG_ACPI_SYSTEM=y
+CONFIG_ACPI_CONTAINER=m
+
+#
+# CPU Frequency scaling
+#
+# CONFIG_CPU_FREQ is not set
+
+#
+# Bus options (PCI, PCMCIA)
+#
+CONFIG_PCI=y
+CONFIG_PCI_DOMAINS=y
+# CONFIG_PCI_MSI is not set
+CONFIG_PCI_LEGACY_PROC=y
+# CONFIG_PCI_DEBUG is not set
+
+#
+# PCI Hotplug Support
+#
+CONFIG_HOTPLUG_PCI=m
+# CONFIG_HOTPLUG_PCI_FAKE is not set
+CONFIG_HOTPLUG_PCI_ACPI=m
+# CONFIG_HOTPLUG_PCI_ACPI_IBM is not set
+# CONFIG_HOTPLUG_PCI_CPCI is not set
+# CONFIG_HOTPLUG_PCI_SHPC is not set
+# CONFIG_HOTPLUG_PCI_SGI is not set
+
+#
+# PCCARD (PCMCIA/CardBus) support
+#
+# CONFIG_PCCARD is not set
+
+#
+# Networking
+#
+CONFIG_NET=y
+
+#
+# Networking options
+#
+CONFIG_PACKET=y
+# CONFIG_PACKET_MMAP is not set
+CONFIG_UNIX=y
+# CONFIG_NET_KEY is not set
+CONFIG_INET=y
+CONFIG_IP_MULTICAST=y
+# CONFIG_IP_ADVANCED_ROUTER is not set
+CONFIG_IP_FIB_HASH=y
+# CONFIG_IP_PNP is not set
+# CONFIG_NET_IPIP is not set
+# CONFIG_NET_IPGRE is not set
+# CONFIG_IP_MROUTE is not set
+CONFIG_ARPD=y
+CONFIG_SYN_COOKIES=y
+# CONFIG_INET_AH is not set
+# CONFIG_INET_ESP is not set
+# CONFIG_INET_IPCOMP is not set
+# CONFIG_INET_TUNNEL is not set
+CONFIG_INET_DIAG=y
+CONFIG_INET_TCP_DIAG=y
+# CONFIG_TCP_CONG_ADVANCED is not set
+CONFIG_TCP_CONG_BIC=y
+# CONFIG_IPV6 is not set
+# CONFIG_NETFILTER is not set
+
+#
+# DCCP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_DCCP is not set
+
+#
+# SCTP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_SCTP is not set
+# CONFIG_ATM is not set
+# CONFIG_BRIDGE is not set
+# CONFIG_VLAN_8021Q is not set
+# CONFIG_DECNET is not set
+# CONFIG_LLC2 is not set
+# CONFIG_IPX is not set
+# CONFIG_ATALK is not set
+# CONFIG_X25 is not set
+# CONFIG_LAPB is not set
+# CONFIG_NET_DIVERT is not set
+# CONFIG_ECONET is not set
+# CONFIG_WAN_ROUTER is not set
+# CONFIG_NET_SCHED is not set
+# CONFIG_NET_CLS_ROUTE is not set
+
+#
+# Network testing
+#
+# CONFIG_NET_PKTGEN is not set
+# CONFIG_HAMRADIO is not set
+# CONFIG_IRDA is not set
+# CONFIG_BT is not set
+# CONFIG_IEEE80211 is not set
+
+#
+# Device Drivers
+#
+
+#
+# Generic Driver Options
+#
+CONFIG_STANDALONE=y
+CONFIG_PREVENT_FIRMWARE_BUILD=y
+CONFIG_FW_LOADER=m
+# CONFIG_DEBUG_DRIVER is not set
+
+#
+# Connector - unified userspace <-> kernelspace linker
+#
+# CONFIG_CONNECTOR is not set
+
+#
+# Memory Technology Devices (MTD)
+#
+# CONFIG_MTD is not set
+
+#
+# Parallel port support
+#
+# CONFIG_PARPORT is not set
+
+#
+# Plug and Play support
+#
+# CONFIG_PNP is not set
+
+#
+# Block devices
+#
+# CONFIG_BLK_CPQ_DA is not set
+# CONFIG_BLK_CPQ_CISS_DA is not set
+# CONFIG_BLK_DEV_DAC960 is not set
+# CONFIG_BLK_DEV_UMEM is not set
+# CONFIG_BLK_DEV_COW_COMMON is not set
+CONFIG_BLK_DEV_LOOP=m
+CONFIG_BLK_DEV_CRYPTOLOOP=m
+CONFIG_BLK_DEV_NBD=m
+# CONFIG_BLK_DEV_SX8 is not set
+# CONFIG_BLK_DEV_UB is not set
+CONFIG_BLK_DEV_RAM=y
+CONFIG_BLK_DEV_RAM_COUNT=16
+CONFIG_BLK_DEV_RAM_SIZE=4096
+CONFIG_BLK_DEV_INITRD=y
+# CONFIG_CDROM_PKTCDVD is not set
+
+#
+# IO Schedulers
+#
+CONFIG_IOSCHED_NOOP=y
+CONFIG_IOSCHED_AS=y
+CONFIG_IOSCHED_DEADLINE=y
+CONFIG_IOSCHED_CFQ=y
+# CONFIG_ATA_OVER_ETH is not set
+
+#
+# ATA/ATAPI/MFM/RLL support
+#
+CONFIG_IDE=y
+CONFIG_BLK_DEV_IDE=y
+
+#
+# Please see Documentation/ide.txt for help/info on IDE drives
+#
+# CONFIG_BLK_DEV_IDE_SATA is not set
+CONFIG_BLK_DEV_IDEDISK=y
+# CONFIG_IDEDISK_MULTI_MODE is not set
+CONFIG_BLK_DEV_IDECD=y
+# CONFIG_BLK_DEV_IDETAPE is not set
+CONFIG_BLK_DEV_IDEFLOPPY=y
+CONFIG_BLK_DEV_IDESCSI=m
+# CONFIG_IDE_TASK_IOCTL is not set
+
+#
+# IDE chipset support/bugfixes
+#
+CONFIG_IDE_GENERIC=y
+CONFIG_BLK_DEV_IDEPCI=y
+# CONFIG_IDEPCI_SHARE_IRQ is not set
+# CONFIG_BLK_DEV_OFFBOARD is not set
+CONFIG_BLK_DEV_GENERIC=y
+# CONFIG_BLK_DEV_OPTI621 is not set
+CONFIG_BLK_DEV_IDEDMA_PCI=y
+# CONFIG_BLK_DEV_IDEDMA_FORCED is not set
+CONFIG_IDEDMA_PCI_AUTO=y
+# CONFIG_IDEDMA_ONLYDISK is not set
+# CONFIG_BLK_DEV_AEC62XX is not set
+# CONFIG_BLK_DEV_ALI15X3 is not set
+# CONFIG_BLK_DEV_AMD74XX is not set
+CONFIG_BLK_DEV_CMD64X=y
+# CONFIG_BLK_DEV_TRIFLEX is not set
+# CONFIG_BLK_DEV_CY82C693 is not set
+# CONFIG_BLK_DEV_CS5520 is not set
+# CONFIG_BLK_DEV_CS5530 is not set
+# CONFIG_BLK_DEV_HPT34X is not set
+# CONFIG_BLK_DEV_HPT366 is not set
+# CONFIG_BLK_DEV_SC1200 is not set
+CONFIG_BLK_DEV_PIIX=y
+# CONFIG_BLK_DEV_IT821X is not set
+# CONFIG_BLK_DEV_NS87415 is not set
+# CONFIG_BLK_DEV_PDC202XX_OLD is not set
+# CONFIG_BLK_DEV_PDC202XX_NEW is not set
+# CONFIG_BLK_DEV_SVWKS is not set
+CONFIG_BLK_DEV_SGIIOC4=y
+# CONFIG_BLK_DEV_SIIMAGE is not set
+# CONFIG_BLK_DEV_SLC90E66 is not set
+# CONFIG_BLK_DEV_TRM290 is not set
+# CONFIG_BLK_DEV_VIA82CXXX is not set
+# CONFIG_IDE_ARM is not set
+CONFIG_BLK_DEV_IDEDMA=y
+# CONFIG_IDEDMA_IVB is not set
+CONFIG_IDEDMA_AUTO=y
+# CONFIG_BLK_DEV_HD is not set
+
+#
+# SCSI device support
+#
+# CONFIG_RAID_ATTRS is not set
+CONFIG_SCSI=y
+CONFIG_SCSI_PROC_FS=y
+
+#
+# SCSI support type (disk, tape, CD-ROM)
+#
+CONFIG_BLK_DEV_SD=y
+CONFIG_CHR_DEV_ST=m
+# CONFIG_CHR_DEV_OSST is not set
+CONFIG_BLK_DEV_SR=m
+# CONFIG_BLK_DEV_SR_VENDOR is not set
+CONFIG_CHR_DEV_SG=m
+# CONFIG_CHR_DEV_SCH is not set
+
+#
+# Some SCSI devices (e.g. CD jukebox) support multiple LUNs
+#
+# CONFIG_SCSI_MULTI_LUN is not set
+# CONFIG_SCSI_CONSTANTS is not set
+# CONFIG_SCSI_LOGGING is not set
+
+#
+# SCSI Transport Attributes
+#
+CONFIG_SCSI_SPI_ATTRS=y
+CONFIG_SCSI_FC_ATTRS=y
+# CONFIG_SCSI_ISCSI_ATTRS is not set
+# CONFIG_SCSI_SAS_ATTRS is not set
+
+#
+# SCSI low-level drivers
+#
+# CONFIG_BLK_DEV_3W_XXXX_RAID is not set
+# CONFIG_SCSI_3W_9XXX is not set
+# CONFIG_SCSI_ACARD is not set
+# CONFIG_SCSI_AACRAID is not set
+# CONFIG_SCSI_AIC7XXX is not set
+# CONFIG_SCSI_AIC7XXX_OLD is not set
+# CONFIG_SCSI_AIC79XX is not set
+# CONFIG_MEGARAID_NEWGEN is not set
+# CONFIG_MEGARAID_LEGACY is not set
+CONFIG_SCSI_SATA=y
+# CONFIG_SCSI_SATA_AHCI is not set
+# CONFIG_SCSI_SATA_SVW is not set
+# CONFIG_SCSI_ATA_PIIX is not set
+# CONFIG_SCSI_SATA_MV is not set
+# CONFIG_SCSI_SATA_NV is not set
+# CONFIG_SCSI_SATA_PROMISE is not set
+# CONFIG_SCSI_SATA_QSTOR is not set
+# CONFIG_SCSI_SATA_SX4 is not set
+# CONFIG_SCSI_SATA_SIL is not set
+# CONFIG_SCSI_SATA_SIS is not set
+# CONFIG_SCSI_SATA_ULI is not set
+# CONFIG_SCSI_SATA_VIA is not set
+CONFIG_SCSI_SATA_VITESSE=y
+# CONFIG_SCSI_DMX3191D is not set
+# CONFIG_SCSI_FUTURE_DOMAIN is not set
+# CONFIG_SCSI_IPS is not set
+# CONFIG_SCSI_INITIO is not set
+# CONFIG_SCSI_INIA100 is not set
+CONFIG_SCSI_SYM53C8XX_2=y
+CONFIG_SCSI_SYM53C8XX_DMA_ADDRESSING_MODE=1
+CONFIG_SCSI_SYM53C8XX_DEFAULT_TAGS=16
+CONFIG_SCSI_SYM53C8XX_MAX_TAGS=64
+# CONFIG_SCSI_SYM53C8XX_IOMAPPED is not set
+# CONFIG_SCSI_IPR is not set
+# CONFIG_SCSI_QLOGIC_FC is not set
+CONFIG_SCSI_QLOGIC_1280=y
+# CONFIG_SCSI_QLOGIC_1280_1040 is not set
+CONFIG_SCSI_QLA2XXX=y
+CONFIG_SCSI_QLA21XX=m
+CONFIG_SCSI_QLA22XX=m
+CONFIG_SCSI_QLA2300=m
+CONFIG_SCSI_QLA2322=m
+# CONFIG_SCSI_QLA6312 is not set
+# CONFIG_SCSI_QLA24XX is not set
+# CONFIG_SCSI_LPFC is not set
+# CONFIG_SCSI_DC395x is not set
+# CONFIG_SCSI_DC390T is not set
+# CONFIG_SCSI_DEBUG is not set
+
+#
+# Multi-device support (RAID and LVM)
+#
+CONFIG_MD=y
+CONFIG_BLK_DEV_MD=m
+CONFIG_MD_LINEAR=m
+CONFIG_MD_RAID0=m
+CONFIG_MD_RAID1=m
+# CONFIG_MD_RAID10 is not set
+CONFIG_MD_RAID5=m
+CONFIG_MD_RAID6=m
+CONFIG_MD_MULTIPATH=m
+# CONFIG_MD_FAULTY is not set
+CONFIG_BLK_DEV_DM=m
+CONFIG_DM_CRYPT=m
+CONFIG_DM_SNAPSHOT=m
+CONFIG_DM_MIRROR=m
+CONFIG_DM_ZERO=m
+CONFIG_DM_MULTIPATH=m
+# CONFIG_DM_MULTIPATH_EMC is not set
+
+#
+# Fusion MPT device support
+#
+CONFIG_FUSION=y
+CONFIG_FUSION_SPI=y
+CONFIG_FUSION_FC=m
+CONFIG_FUSION_MAX_SGE=128
+# CONFIG_FUSION_CTL is not set
+
+#
+# IEEE 1394 (FireWire) support
+#
+# CONFIG_IEEE1394 is not set
+
+#
+# I2O device support
+#
+# CONFIG_I2O is not set
+
+#
+# Network device support
+#
+CONFIG_NETDEVICES=y
+CONFIG_DUMMY=m
+# CONFIG_BONDING is not set
+# CONFIG_EQUALIZER is not set
+# CONFIG_TUN is not set
+
+#
+# ARCnet devices
+#
+# CONFIG_ARCNET is not set
+
+#
+# PHY device support
+#
+# CONFIG_PHYLIB is not set
+
+#
+# Ethernet (10 or 100Mbit)
+#
+CONFIG_NET_ETHERNET=y
+CONFIG_MII=m
+# CONFIG_HAPPYMEAL is not set
+# CONFIG_SUNGEM is not set
+# CONFIG_NET_VENDOR_3COM is not set
+
+#
+# Tulip family network device support
+#
+CONFIG_NET_TULIP=y
+# CONFIG_DE2104X is not set
+CONFIG_TULIP=m
+# CONFIG_TULIP_MWI is not set
+# CONFIG_TULIP_MMIO is not set
+# CONFIG_TULIP_NAPI is not set
+# CONFIG_DE4X5 is not set
+# CONFIG_WINBOND_840 is not set
+# CONFIG_DM9102 is not set
+# CONFIG_ULI526X is not set
+# CONFIG_HP100 is not set
+CONFIG_NET_PCI=y
+# CONFIG_PCNET32 is not set
+# CONFIG_AMD8111_ETH is not set
+# CONFIG_ADAPTEC_STARFIRE is not set
+# CONFIG_B44 is not set
+# CONFIG_FORCEDETH is not set
+# CONFIG_DGRS is not set
+CONFIG_EEPRO100=m
+CONFIG_E100=m
+# CONFIG_FEALNX is not set
+# CONFIG_NATSEMI is not set
+# CONFIG_NE2K_PCI is not set
+# CONFIG_8139CP is not set
+# CONFIG_8139TOO is not set
+# CONFIG_SIS900 is not set
+# CONFIG_EPIC100 is not set
+# CONFIG_SUNDANCE is not set
+# CONFIG_VIA_RHINE is not set
+
+#
+# Ethernet (1000 Mbit)
+#
+# CONFIG_ACENIC is not set
+# CONFIG_DL2K is not set
+CONFIG_E1000=y
+# CONFIG_E1000_NAPI is not set
+# CONFIG_NS83820 is not set
+# CONFIG_HAMACHI is not set
+# CONFIG_YELLOWFIN is not set
+# CONFIG_R8169 is not set
+# CONFIG_SIS190 is not set
+# CONFIG_SKGE is not set
+# CONFIG_SK98LIN is not set
+# CONFIG_VIA_VELOCITY is not set
+CONFIG_TIGON3=y
+# CONFIG_BNX2 is not set
+
+#
+# Ethernet (10000 Mbit)
+#
+# CONFIG_CHELSIO_T1 is not set
+# CONFIG_IXGB is not set
+# CONFIG_S2IO is not set
+
+#
+# Token Ring devices
+#
+# CONFIG_TR is not set
+
+#
+# Wireless LAN (non-hamradio)
+#
+# CONFIG_NET_RADIO is not set
+
+#
+# Wan interfaces
+#
+# CONFIG_WAN is not set
+# CONFIG_FDDI is not set
+# CONFIG_HIPPI is not set
+# CONFIG_PPP is not set
+# CONFIG_SLIP is not set
+# CONFIG_NET_FC is not set
+# CONFIG_SHAPER is not set
+CONFIG_NETCONSOLE=y
+CONFIG_NETPOLL=y
+# CONFIG_NETPOLL_RX is not set
+# CONFIG_NETPOLL_TRAP is not set
+CONFIG_NET_POLL_CONTROLLER=y
+
+#
+# ISDN subsystem
+#
+# CONFIG_ISDN is not set
+
+#
+# Telephony Support
+#
+# CONFIG_PHONE is not set
+
+#
+# Input device support
+#
+CONFIG_INPUT=y
+
+#
+# Userland interfaces
+#
+CONFIG_INPUT_MOUSEDEV=y
+CONFIG_INPUT_MOUSEDEV_PSAUX=y
+CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024
+CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
+# CONFIG_INPUT_JOYDEV is not set
+# CONFIG_INPUT_TSDEV is not set
+# CONFIG_INPUT_EVDEV is not set
+# CONFIG_INPUT_EVBUG is not set
+
+#
+# Input Device Drivers
+#
+CONFIG_INPUT_KEYBOARD=y
+CONFIG_KEYBOARD_ATKBD=y
+# CONFIG_KEYBOARD_SUNKBD is not set
+# CONFIG_KEYBOARD_LKKBD is not set
+# CONFIG_KEYBOARD_XTKBD is not set
+# CONFIG_KEYBOARD_NEWTON is not set
+CONFIG_INPUT_MOUSE=y
+CONFIG_MOUSE_PS2=y
+# CONFIG_MOUSE_SERIAL is not set
+# CONFIG_MOUSE_VSXXXAA is not set
+# CONFIG_INPUT_JOYSTICK is not set
+# CONFIG_INPUT_TOUCHSCREEN is not set
+# CONFIG_INPUT_MISC is not set
+
+#
+# Hardware I/O ports
+#
+CONFIG_SERIO=y
+CONFIG_SERIO_I8042=y
+# CONFIG_SERIO_SERPORT is not set
+# CONFIG_SERIO_PCIPS2 is not set
+CONFIG_SERIO_LIBPS2=y
+# CONFIG_SERIO_RAW is not set
+CONFIG_GAMEPORT=m
+# CONFIG_GAMEPORT_NS558 is not set
+# CONFIG_GAMEPORT_L4 is not set
+# CONFIG_GAMEPORT_EMU10K1 is not set
+# CONFIG_GAMEPORT_FM801 is not set
+
+#
+# Character devices
+#
+CONFIG_VT=y
+CONFIG_VT_CONSOLE=y
+CONFIG_HW_CONSOLE=y
+CONFIG_SERIAL_NONSTANDARD=y
+# CONFIG_ROCKETPORT is not set
+# CONFIG_CYCLADES is not set
+# CONFIG_DIGIEPCA is not set
+# CONFIG_MOXA_SMARTIO is not set
+# CONFIG_ISI is not set
+# CONFIG_SYNCLINKMP is not set
+# CONFIG_N_HDLC is not set
+# CONFIG_SPECIALIX is not set
+# CONFIG_SX is not set
+# CONFIG_STALDRV is not set
+CONFIG_SGI_SNSC=y
+CONFIG_SGI_TIOCX=y
+CONFIG_SGI_MBCS=m
+
+#
+# Serial drivers
+#
+CONFIG_SERIAL_8250=y
+CONFIG_SERIAL_8250_CONSOLE=y
+CONFIG_SERIAL_8250_ACPI=y
+CONFIG_SERIAL_8250_NR_UARTS=6
+CONFIG_SERIAL_8250_EXTENDED=y
+CONFIG_SERIAL_8250_SHARE_IRQ=y
+# CONFIG_SERIAL_8250_DETECT_IRQ is not set
+# CONFIG_SERIAL_8250_RSA is not set
+
+#
+# Non-8250 serial port support
+#
+CONFIG_SERIAL_CORE=y
+CONFIG_SERIAL_CORE_CONSOLE=y
+CONFIG_SERIAL_SGI_L1_CONSOLE=y
+# CONFIG_SERIAL_JSM is not set
+CONFIG_SERIAL_SGI_IOC4=y
+CONFIG_UNIX98_PTYS=y
+CONFIG_LEGACY_PTYS=y
+CONFIG_LEGACY_PTY_COUNT=256
+
+#
+# IPMI
+#
+# CONFIG_IPMI_HANDLER is not set
+
+#
+# Watchdog Cards
+#
+# CONFIG_WATCHDOG is not set
+# CONFIG_HW_RANDOM is not set
+CONFIG_EFI_RTC=y
+# CONFIG_DTLK is not set
+# CONFIG_R3964 is not set
+# CONFIG_APPLICOM is not set
+
+#
+# Ftape, the floppy tape device driver
+#
+CONFIG_AGP=m
+CONFIG_AGP_I460=m
+CONFIG_AGP_HP_ZX1=m
+CONFIG_AGP_SGI_TIOCA=m
+CONFIG_DRM=m
+CONFIG_DRM_TDFX=m
+CONFIG_DRM_R128=m
+CONFIG_DRM_RADEON=m
+CONFIG_DRM_MGA=m
+CONFIG_DRM_SIS=m
+# CONFIG_DRM_VIA is not set
+# CONFIG_DRM_SAVAGE is not set
+CONFIG_RAW_DRIVER=m
+CONFIG_HPET=y
+# CONFIG_HPET_RTC_IRQ is not set
+CONFIG_HPET_MMAP=y
+CONFIG_MAX_RAW_DEVS=256
+# CONFIG_HANGCHECK_TIMER is not set
+CONFIG_MMTIMER=y
+
+#
+# TPM devices
+#
+# CONFIG_TCG_TPM is not set
+
+#
+# I2C support
+#
+# CONFIG_I2C is not set
+
+#
+# Dallas's 1-wire bus
+#
+# CONFIG_W1 is not set
+
+#
+# Hardware Monitoring support
+#
+CONFIG_HWMON=y
+# CONFIG_HWMON_VID is not set
+# CONFIG_HWMON_DEBUG_CHIP is not set
+
+#
+# Misc devices
+#
+
+#
+# Multimedia Capabilities Port drivers
+#
+
+#
+# Multimedia devices
+#
+# CONFIG_VIDEO_DEV is not set
+
+#
+# Digital Video Broadcasting Devices
+#
+# CONFIG_DVB is not set
+
+#
+# Graphics support
+#
+# CONFIG_FB is not set
+
+#
+# Console display driver support
+#
+CONFIG_VGA_CONSOLE=y
+CONFIG_DUMMY_CONSOLE=y
+
+#
+# Sound
+#
+CONFIG_SOUND=m
+
+#
+# Advanced Linux Sound Architecture
+#
+CONFIG_SND=m
+CONFIG_SND_TIMER=m
+CONFIG_SND_PCM=m
+CONFIG_SND_HWDEP=m
+CONFIG_SND_RAWMIDI=m
+CONFIG_SND_SEQUENCER=m
+CONFIG_SND_SEQ_DUMMY=m
+CONFIG_SND_OSSEMUL=y
+CONFIG_SND_MIXER_OSS=m
+CONFIG_SND_PCM_OSS=m
+CONFIG_SND_SEQUENCER_OSS=y
+CONFIG_SND_VERBOSE_PRINTK=y
+# CONFIG_SND_DEBUG is not set
+CONFIG_SND_GENERIC_DRIVER=y
+
+#
+# Generic devices
+#
+CONFIG_SND_MPU401_UART=m
+CONFIG_SND_OPL3_LIB=m
+CONFIG_SND_DUMMY=m
+CONFIG_SND_VIRMIDI=m
+CONFIG_SND_MTPAV=m
+CONFIG_SND_SERIAL_U16550=m
+CONFIG_SND_MPU401=m
+CONFIG_SND_AC97_CODEC=m
+CONFIG_SND_AC97_BUS=m
+
+#
+# PCI devices
+#
+# CONFIG_SND_ALI5451 is not set
+# CONFIG_SND_ATIIXP is not set
+# CONFIG_SND_ATIIXP_MODEM is not set
+# CONFIG_SND_AU8810 is not set
+# CONFIG_SND_AU8820 is not set
+# CONFIG_SND_AU8830 is not set
+# CONFIG_SND_AZT3328 is not set
+# CONFIG_SND_BT87X is not set
+CONFIG_SND_CS46XX=m
+CONFIG_SND_CS46XX_NEW_DSP=y
+CONFIG_SND_CS4281=m
+CONFIG_SND_EMU10K1=m
+# CONFIG_SND_EMU10K1X is not set
+# CONFIG_SND_CA0106 is not set
+# CONFIG_SND_KORG1212 is not set
+# CONFIG_SND_MIXART is not set
+# CONFIG_SND_NM256 is not set
+# CONFIG_SND_RME32 is not set
+# CONFIG_SND_RME96 is not set
+# CONFIG_SND_RME9652 is not set
+# CONFIG_SND_HDSP is not set
+# CONFIG_SND_HDSPM is not set
+# CONFIG_SND_TRIDENT is not set
+# CONFIG_SND_YMFPCI is not set
+# CONFIG_SND_AD1889 is not set
+# CONFIG_SND_CMIPCI is not set
+# CONFIG_SND_ENS1370 is not set
+# CONFIG_SND_ENS1371 is not set
+# CONFIG_SND_ES1938 is not set
+# CONFIG_SND_ES1968 is not set
+# CONFIG_SND_MAESTRO3 is not set
+CONFIG_SND_FM801=m
+# CONFIG_SND_FM801_TEA575X is not set
+# CONFIG_SND_ICE1712 is not set
+# CONFIG_SND_ICE1724 is not set
+# CONFIG_SND_INTEL8X0 is not set
+# CONFIG_SND_INTEL8X0M is not set
+# CONFIG_SND_SONICVIBES is not set
+# CONFIG_SND_VIA82XX is not set
+# CONFIG_SND_VIA82XX_MODEM is not set
+# CONFIG_SND_VX222 is not set
+# CONFIG_SND_HDA_INTEL is not set
+
+#
+# USB devices
+#
+# CONFIG_SND_USB_AUDIO is not set
+
+#
+# Open Sound System
+#
+# CONFIG_SOUND_PRIME is not set
+
+#
+# USB support
+#
+CONFIG_USB_ARCH_HAS_HCD=y
+CONFIG_USB_ARCH_HAS_OHCI=y
+CONFIG_USB=m
+# CONFIG_USB_DEBUG is not set
+
+#
+# Miscellaneous USB options
+#
+CONFIG_USB_DEVICEFS=y
+# CONFIG_USB_BANDWIDTH is not set
+# CONFIG_USB_DYNAMIC_MINORS is not set
+# CONFIG_USB_SUSPEND is not set
+# CONFIG_USB_OTG is not set
+
+#
+# USB Host Controller Drivers
+#
+CONFIG_USB_EHCI_HCD=m
+# CONFIG_USB_EHCI_SPLIT_ISO is not set
+# CONFIG_USB_EHCI_ROOT_HUB_TT is not set
+# CONFIG_USB_ISP116X_HCD is not set
+CONFIG_USB_OHCI_HCD=m
+# CONFIG_USB_OHCI_BIG_ENDIAN is not set
+CONFIG_USB_OHCI_LITTLE_ENDIAN=y
+CONFIG_USB_UHCI_HCD=m
+# CONFIG_USB_SL811_HCD is not set
+
+#
+# USB Device Class drivers
+#
+# CONFIG_OBSOLETE_OSS_USB_DRIVER is not set
+# CONFIG_USB_BLUETOOTH_TTY is not set
+# CONFIG_USB_ACM is not set
+# CONFIG_USB_PRINTER is not set
+
+#
+# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support' may also be needed; see USB_STORAGE Help for more information
+#
+CONFIG_USB_STORAGE=m
+# CONFIG_USB_STORAGE_DEBUG is not set
+# CONFIG_USB_STORAGE_DATAFAB is not set
+# CONFIG_USB_STORAGE_FREECOM is not set
+# CONFIG_USB_STORAGE_ISD200 is not set
+# CONFIG_USB_STORAGE_DPCM is not set
+# CONFIG_USB_STORAGE_USBAT is not set
+# CONFIG_USB_STORAGE_SDDR09 is not set
+# CONFIG_USB_STORAGE_SDDR55 is not set
+# CONFIG_USB_STORAGE_JUMPSHOT is not set
+
+#
+# USB Input Devices
+#
+CONFIG_USB_HID=m
+CONFIG_USB_HIDINPUT=y
+# CONFIG_HID_FF is not set
+# CONFIG_USB_HIDDEV is not set
+
+#
+# USB HID Boot Protocol drivers
+#
+# CONFIG_USB_KBD is not set
+# CONFIG_USB_MOUSE is not set
+# CONFIG_USB_AIPTEK is not set
+# CONFIG_USB_WACOM is not set
+# CONFIG_USB_ACECAD is not set
+# CONFIG_USB_KBTAB is not set
+# CONFIG_USB_POWERMATE is not set
+# CONFIG_USB_MTOUCH is not set
+# CONFIG_USB_ITMTOUCH is not set
+# CONFIG_USB_EGALAX is not set
+# CONFIG_USB_YEALINK is not set
+# CONFIG_USB_XPAD is not set
+# CONFIG_USB_ATI_REMOTE is not set
+# CONFIG_USB_KEYSPAN_REMOTE is not set
+# CONFIG_USB_APPLETOUCH is not set
+
+#
+# USB Imaging devices
+#
+# CONFIG_USB_MDC800 is not set
+# CONFIG_USB_MICROTEK is not set
+
+#
+# USB Multimedia devices
+#
+# CONFIG_USB_DABUSB is not set
+
+#
+# Video4Linux support is needed for USB Multimedia device support
+#
+
+#
+# USB Network Adapters
+#
+# CONFIG_USB_CATC is not set
+# CONFIG_USB_KAWETH is not set
+# CONFIG_USB_PEGASUS is not set
+# CONFIG_USB_RTL8150 is not set
+# CONFIG_USB_USBNET is not set
+CONFIG_USB_MON=y
+
+#
+# USB port drivers
+#
+
+#
+# USB Serial Converter support
+#
+# CONFIG_USB_SERIAL is not set
+
+#
+# USB Miscellaneous drivers
+#
+# CONFIG_USB_EMI62 is not set
+# CONFIG_USB_EMI26 is not set
+# CONFIG_USB_AUERSWALD is not set
+# CONFIG_USB_RIO500 is not set
+# CONFIG_USB_LEGOTOWER is not set
+# CONFIG_USB_LCD is not set
+# CONFIG_USB_LED is not set
+# CONFIG_USB_CYTHERM is not set
+# CONFIG_USB_PHIDGETKIT is not set
+# CONFIG_USB_PHIDGETSERVO is not set
+# CONFIG_USB_IDMOUSE is not set
+# CONFIG_USB_SISUSBVGA is not set
+# CONFIG_USB_LD is not set
+# CONFIG_USB_TEST is not set
+
+#
+# USB DSL modem support
+#
+
+#
+# USB Gadget Support
+#
+# CONFIG_USB_GADGET is not set
+
+#
+# MMC/SD Card support
+#
+# CONFIG_MMC is not set
+
+#
+# InfiniBand support
+#
+CONFIG_INFINIBAND=m
+# CONFIG_INFINIBAND_USER_MAD is not set
+# CONFIG_INFINIBAND_USER_ACCESS is not set
+CONFIG_INFINIBAND_MTHCA=m
+# CONFIG_INFINIBAND_MTHCA_DEBUG is not set
+CONFIG_INFINIBAND_IPOIB=m
+# CONFIG_INFINIBAND_IPOIB_DEBUG is not set
+
+#
+# SN Devices
+#
+CONFIG_SGI_IOC4=y
+
+#
+# File systems
+#
+CONFIG_EXT2_FS=y
+CONFIG_EXT2_FS_XATTR=y
+CONFIG_EXT2_FS_POSIX_ACL=y
+CONFIG_EXT2_FS_SECURITY=y
+# CONFIG_EXT2_FS_XIP is not set
+CONFIG_EXT3_FS=y
+CONFIG_EXT3_FS_XATTR=y
+CONFIG_EXT3_FS_POSIX_ACL=y
+CONFIG_EXT3_FS_SECURITY=y
+CONFIG_JBD=y
+# CONFIG_JBD_DEBUG is not set
+CONFIG_FS_MBCACHE=y
+CONFIG_REISERFS_FS=y
+# CONFIG_REISERFS_CHECK is not set
+# CONFIG_REISERFS_PROC_INFO is not set
+CONFIG_REISERFS_FS_XATTR=y
+CONFIG_REISERFS_FS_POSIX_ACL=y
+CONFIG_REISERFS_FS_SECURITY=y
+# CONFIG_JFS_FS is not set
+CONFIG_FS_POSIX_ACL=y
+CONFIG_XFS_FS=y
+CONFIG_XFS_EXPORT=y
+# CONFIG_XFS_QUOTA is not set
+# CONFIG_XFS_SECURITY is not set
+# CONFIG_XFS_POSIX_ACL is not set
+# CONFIG_XFS_RT is not set
+# CONFIG_MINIX_FS is not set
+# CONFIG_ROMFS_FS is not set
+CONFIG_INOTIFY=y
+# CONFIG_QUOTA is not set
+CONFIG_DNOTIFY=y
+CONFIG_AUTOFS_FS=y
+CONFIG_AUTOFS4_FS=y
+# CONFIG_FUSE_FS is not set
+
+#
+# CD-ROM/DVD Filesystems
+#
+CONFIG_ISO9660_FS=m
+CONFIG_JOLIET=y
+# CONFIG_ZISOFS is not set
+CONFIG_UDF_FS=m
+CONFIG_UDF_NLS=y
+
+#
+# DOS/FAT/NT Filesystems
+#
+CONFIG_FAT_FS=y
+# CONFIG_MSDOS_FS is not set
+CONFIG_VFAT_FS=y
+CONFIG_FAT_DEFAULT_CODEPAGE=437
+CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
+CONFIG_NTFS_FS=m
+# CONFIG_NTFS_DEBUG is not set
+# CONFIG_NTFS_RW is not set
+
+#
+# Pseudo filesystems
+#
+CONFIG_PROC_FS=y
+CONFIG_PROC_KCORE=y
+CONFIG_SYSFS=y
+CONFIG_TMPFS=y
+CONFIG_HUGETLBFS=y
+CONFIG_HUGETLB_PAGE=y
+CONFIG_RAMFS=y
+# CONFIG_RELAYFS_FS is not set
+
+#
+# Miscellaneous filesystems
+#
+# CONFIG_ADFS_FS is not set
+# CONFIG_AFFS_FS is not set
+# CONFIG_HFS_FS is not set
+# CONFIG_HFSPLUS_FS is not set
+# CONFIG_BEFS_FS is not set
+# CONFIG_BFS_FS is not set
+# CONFIG_EFS_FS is not set
+# CONFIG_CRAMFS is not set
+# CONFIG_VXFS_FS is not set
+# CONFIG_HPFS_FS is not set
+# CONFIG_QNX4FS_FS is not set
+# CONFIG_SYSV_FS is not set
+# CONFIG_UFS_FS is not set
+
+#
+# Network File Systems
+#
+CONFIG_NFS_FS=m
+CONFIG_NFS_V3=y
+# CONFIG_NFS_V3_ACL is not set
+CONFIG_NFS_V4=y
+CONFIG_NFS_DIRECTIO=y
+CONFIG_NFSD=m
+CONFIG_NFSD_V3=y
+# CONFIG_NFSD_V3_ACL is not set
+CONFIG_NFSD_V4=y
+CONFIG_NFSD_TCP=y
+CONFIG_LOCKD=m
+CONFIG_LOCKD_V4=y
+CONFIG_EXPORTFS=y
+CONFIG_NFS_COMMON=y
+CONFIG_SUNRPC=m
+CONFIG_SUNRPC_GSS=m
+CONFIG_RPCSEC_GSS_KRB5=m
+# CONFIG_RPCSEC_GSS_SPKM3 is not set
+CONFIG_SMB_FS=m
+CONFIG_SMB_NLS_DEFAULT=y
+CONFIG_SMB_NLS_REMOTE="cp437"
+CONFIG_CIFS=m
+# CONFIG_CIFS_STATS is not set
+# CONFIG_CIFS_XATTR is not set
+# CONFIG_CIFS_EXPERIMENTAL is not set
+# CONFIG_NCP_FS is not set
+# CONFIG_CODA_FS is not set
+# CONFIG_AFS_FS is not set
+# CONFIG_9P_FS is not set
+
+#
+# Partition Types
+#
+CONFIG_PARTITION_ADVANCED=y
+# CONFIG_ACORN_PARTITION is not set
+# CONFIG_OSF_PARTITION is not set
+# CONFIG_AMIGA_PARTITION is not set
+# CONFIG_ATARI_PARTITION is not set
+# CONFIG_MAC_PARTITION is not set
+CONFIG_MSDOS_PARTITION=y
+# CONFIG_BSD_DISKLABEL is not set
+# CONFIG_MINIX_SUBPARTITION is not set
+# CONFIG_SOLARIS_X86_PARTITION is not set
+# CONFIG_UNIXWARE_DISKLABEL is not set
+# CONFIG_LDM_PARTITION is not set
+CONFIG_SGI_PARTITION=y
+# CONFIG_ULTRIX_PARTITION is not set
+# CONFIG_SUN_PARTITION is not set
+CONFIG_EFI_PARTITION=y
+
+#
+# Native Language Support
+#
+CONFIG_NLS=y
+CONFIG_NLS_DEFAULT="iso8859-1"
+CONFIG_NLS_CODEPAGE_437=y
+CONFIG_NLS_CODEPAGE_737=m
+CONFIG_NLS_CODEPAGE_775=m
+CONFIG_NLS_CODEPAGE_850=m
+CONFIG_NLS_CODEPAGE_852=m
+CONFIG_NLS_CODEPAGE_855=m
+CONFIG_NLS_CODEPAGE_857=m
+CONFIG_NLS_CODEPAGE_860=m
+CONFIG_NLS_CODEPAGE_861=m
+CONFIG_NLS_CODEPAGE_862=m
+CONFIG_NLS_CODEPAGE_863=m
+CONFIG_NLS_CODEPAGE_864=m
+CONFIG_NLS_CODEPAGE_865=m
+CONFIG_NLS_CODEPAGE_866=m
+CONFIG_NLS_CODEPAGE_869=m
+CONFIG_NLS_CODEPAGE_936=m
+CONFIG_NLS_CODEPAGE_950=m
+CONFIG_NLS_CODEPAGE_932=m
+CONFIG_NLS_CODEPAGE_949=m
+CONFIG_NLS_CODEPAGE_874=m
+CONFIG_NLS_ISO8859_8=m
+CONFIG_NLS_CODEPAGE_1250=m
+CONFIG_NLS_CODEPAGE_1251=m
+# CONFIG_NLS_ASCII is not set
+CONFIG_NLS_ISO8859_1=y
+CONFIG_NLS_ISO8859_2=m
+CONFIG_NLS_ISO8859_3=m
+CONFIG_NLS_ISO8859_4=m
+CONFIG_NLS_ISO8859_5=m
+CONFIG_NLS_ISO8859_6=m
+CONFIG_NLS_ISO8859_7=m
+CONFIG_NLS_ISO8859_9=m
+CONFIG_NLS_ISO8859_13=m
+CONFIG_NLS_ISO8859_14=m
+CONFIG_NLS_ISO8859_15=m
+CONFIG_NLS_KOI8_R=m
+CONFIG_NLS_KOI8_U=m
+CONFIG_NLS_UTF8=m
+
+#
+# Library routines
+#
+# CONFIG_CRC_CCITT is not set
+# CONFIG_CRC16 is not set
+CONFIG_CRC32=y
+# CONFIG_LIBCRC32C is not set
+CONFIG_GENERIC_HARDIRQS=y
+CONFIG_GENERIC_IRQ_PROBE=y
+CONFIG_GENERIC_PENDING_IRQ=y
+
+#
+# HP Simulator drivers
+#
+# CONFIG_HP_SIMETH is not set
+# CONFIG_HP_SIMSERIAL is not set
+# CONFIG_HP_SIMSCSI is not set
+
+#
+# Profiling support
+#
+# CONFIG_PROFILING is not set
+
+#
+# Kernel hacking
+#
+# CONFIG_PRINTK_TIME is not set
+CONFIG_DEBUG_KERNEL=y
+CONFIG_MAGIC_SYSRQ=y
+CONFIG_LOG_BUF_SHIFT=20
+CONFIG_DETECT_SOFTLOCKUP=y
+# CONFIG_SCHEDSTATS is not set
+# CONFIG_DEBUG_SLAB is not set
+# CONFIG_DEBUG_SPINLOCK is not set
+# CONFIG_DEBUG_SPINLOCK_SLEEP is not set
+# CONFIG_DEBUG_KOBJECT is not set
+# CONFIG_DEBUG_INFO is not set
+# CONFIG_DEBUG_FS is not set
+# CONFIG_KPROBES is not set
+CONFIG_IA64_GRANULE_16MB=y
+# CONFIG_IA64_GRANULE_64MB is not set
+# CONFIG_IA64_PRINT_HAZARDS is not set
+# CONFIG_DISABLE_VHPT is not set
+# CONFIG_IA64_DEBUG_CMPXCHG is not set
+# CONFIG_IA64_DEBUG_IRQ is not set
+CONFIG_SYSVIPC_COMPAT=y
+
+#
+# Security options
+#
+# CONFIG_KEYS is not set
+# CONFIG_SECURITY is not set
+
+#
+# Cryptographic options
+#
+CONFIG_CRYPTO=y
+# CONFIG_CRYPTO_HMAC is not set
+# CONFIG_CRYPTO_NULL is not set
+# CONFIG_CRYPTO_MD4 is not set
+CONFIG_CRYPTO_MD5=y
+# CONFIG_CRYPTO_SHA1 is not set
+# CONFIG_CRYPTO_SHA256 is not set
+# CONFIG_CRYPTO_SHA512 is not set
+# CONFIG_CRYPTO_WP512 is not set
+# CONFIG_CRYPTO_TGR192 is not set
+CONFIG_CRYPTO_DES=m
+# CONFIG_CRYPTO_BLOWFISH is not set
+# CONFIG_CRYPTO_TWOFISH is not set
+# CONFIG_CRYPTO_SERPENT is not set
+# CONFIG_CRYPTO_AES is not set
+# CONFIG_CRYPTO_CAST5 is not set
+# CONFIG_CRYPTO_CAST6 is not set
+# CONFIG_CRYPTO_TEA is not set
+# CONFIG_CRYPTO_ARC4 is not set
+# CONFIG_CRYPTO_KHAZAD is not set
+# CONFIG_CRYPTO_ANUBIS is not set
+# CONFIG_CRYPTO_DEFLATE is not set
+# CONFIG_CRYPTO_MICHAEL_MIC is not set
+# CONFIG_CRYPTO_CRC32C is not set
+# CONFIG_CRYPTO_TEST is not set
+
+#
+# Hardware crypto devices
+#
diff --git a/arch/ia64/configs/tiger_defconfig b/arch/ia64/configs/tiger_defconfig
index d452e18ac494..9bc8bcafc905 100644
--- a/arch/ia64/configs/tiger_defconfig
+++ b/arch/ia64/configs/tiger_defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.13-rc6-tiger-smp
-# Wed Aug 17 10:19:51 2005
+# Linux kernel version: 2.6.14-rc1
+# Wed Sep 14 15:17:57 2005
 #
 
 #
@@ -16,6 +16,7 @@ CONFIG_INIT_ENV_ARG_LIMIT=32
 # General setup
 #
 CONFIG_LOCALVERSION=""
+CONFIG_LOCALVERSION_AUTO=y
 CONFIG_SWAP=y
 CONFIG_SYSVIPC=y
 CONFIG_POSIX_MQUEUE=y
@@ -27,6 +28,7 @@ CONFIG_KOBJECT_UEVENT=y
 CONFIG_IKCONFIG=y
 CONFIG_IKCONFIG_PROC=y
 # CONFIG_CPUSETS is not set
+CONFIG_INITRAMFS_SOURCE=""
 # CONFIG_EMBEDDED is not set
 CONFIG_KALLSYMS=y
 CONFIG_KALLSYMS_ALL=y
@@ -103,6 +105,7 @@ CONFIG_FLATMEM_MANUAL=y
 # CONFIG_SPARSEMEM_MANUAL is not set
 CONFIG_FLATMEM=y
 CONFIG_FLAT_NODE_MEM_MAP=y
+# CONFIG_SPARSEMEM_STATIC is not set
 CONFIG_HAVE_DEC_LOCK=y
 CONFIG_IA32_SUPPORT=y
 CONFIG_COMPAT=y
@@ -115,6 +118,7 @@ CONFIG_IA64_PALINFO=y
 #
 CONFIG_EFI_VARS=y
 CONFIG_EFI_PCDP=y
+# CONFIG_DELL_RBU is not set
 CONFIG_BINFMT_ELF=y
 CONFIG_BINFMT_MISC=m
 
@@ -122,20 +126,27 @@ CONFIG_BINFMT_MISC=m
 # Power management and ACPI
 #
 CONFIG_PM=y
-CONFIG_ACPI=y
+# CONFIG_PM_DEBUG is not set
 
 #
 # ACPI (Advanced Configuration and Power Interface) Support
 #
+CONFIG_ACPI=y
 CONFIG_ACPI_BUTTON=m
 CONFIG_ACPI_FAN=m
 CONFIG_ACPI_PROCESSOR=m
-# CONFIG_ACPI_HOTPLUG_CPU is not set
+CONFIG_ACPI_HOTPLUG_CPU=y
 CONFIG_ACPI_THERMAL=m
+CONFIG_ACPI_BLACKLIST_YEAR=0
 # CONFIG_ACPI_DEBUG is not set
 CONFIG_ACPI_POWER=y
 CONFIG_ACPI_SYSTEM=y
-# CONFIG_ACPI_CONTAINER is not set
+CONFIG_ACPI_CONTAINER=m
+
+#
+# CPU Frequency scaling
+#
+# CONFIG_CPU_FREQ is not set
 
 #
 # Bus options (PCI, PCMCIA)
@@ -144,7 +155,6 @@ CONFIG_PCI=y
 CONFIG_PCI_DOMAINS=y
 # CONFIG_PCI_MSI is not set
 CONFIG_PCI_LEGACY_PROC=y
-CONFIG_PCI_NAMES=y
 # CONFIG_PCI_DEBUG is not set
 
 #
@@ -188,14 +198,19 @@ CONFIG_SYN_COOKIES=y
 # CONFIG_INET_ESP is not set
 # CONFIG_INET_IPCOMP is not set
 # CONFIG_INET_TUNNEL is not set
-CONFIG_IP_TCPDIAG=y
-# CONFIG_IP_TCPDIAG_IPV6 is not set
+CONFIG_INET_DIAG=y
+CONFIG_INET_TCP_DIAG=y
 # CONFIG_TCP_CONG_ADVANCED is not set
 CONFIG_TCP_CONG_BIC=y
 # CONFIG_IPV6 is not set
 # CONFIG_NETFILTER is not set
 
 #
+# DCCP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_DCCP is not set
+
+#
 # SCTP Configuration (EXPERIMENTAL)
 #
 # CONFIG_IP_SCTP is not set
@@ -218,9 +233,11 @@ CONFIG_TCP_CONG_BIC=y
 # Network testing
 #
 # CONFIG_NET_PKTGEN is not set
+# CONFIG_NETFILTER_NETLINK is not set
 # CONFIG_HAMRADIO is not set
 # CONFIG_IRDA is not set
 # CONFIG_BT is not set
+# CONFIG_IEEE80211 is not set
 
 #
 # Device Drivers
@@ -235,6 +252,11 @@ CONFIG_FW_LOADER=m
 # CONFIG_DEBUG_DRIVER is not set
 
 #
+# Connector - unified userspace <-> kernelspace linker
+#
+# CONFIG_CONNECTOR is not set
+
+#
 # Memory Technology Devices (MTD)
 #
 # CONFIG_MTD is not set
@@ -247,7 +269,13 @@ CONFIG_FW_LOADER=m
 #
 # Plug and Play support
 #
-# CONFIG_PNP is not set
+CONFIG_PNP=y
+# CONFIG_PNP_DEBUG is not set
+
+#
+# Protocols
+#
+CONFIG_PNPACPI=y
 
 #
 # Block devices
@@ -266,7 +294,6 @@ CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_COUNT=16
 CONFIG_BLK_DEV_RAM_SIZE=4096
 CONFIG_BLK_DEV_INITRD=y
-CONFIG_INITRAMFS_SOURCE=""
 # CONFIG_CDROM_PKTCDVD is not set
 
 #
@@ -299,7 +326,8 @@ CONFIG_BLK_DEV_IDESCSI=m
 #
 # IDE chipset support/bugfixes
 #
-CONFIG_IDE_GENERIC=y
+# CONFIG_IDE_GENERIC is not set
+# CONFIG_BLK_DEV_IDEPNP is not set
 CONFIG_BLK_DEV_IDEPCI=y
 # CONFIG_IDEPCI_SHARE_IRQ is not set
 # CONFIG_BLK_DEV_OFFBOARD is not set
@@ -339,6 +367,7 @@ CONFIG_IDEDMA_AUTO=y
 #
 # SCSI device support
 #
+# CONFIG_RAID_ATTRS is not set
 CONFIG_SCSI=y
 CONFIG_SCSI_PROC_FS=y
 
@@ -366,6 +395,7 @@ CONFIG_CHR_DEV_SG=m
 CONFIG_SCSI_SPI_ATTRS=y
 CONFIG_SCSI_FC_ATTRS=y
 # CONFIG_SCSI_ISCSI_ATTRS is not set
+# CONFIG_SCSI_SAS_ATTRS is not set
 
 #
 # SCSI low-level drivers
@@ -454,6 +484,7 @@ CONFIG_DUMMY=m
 # CONFIG_BONDING is not set
 # CONFIG_EQUALIZER is not set
 # CONFIG_TUN is not set
+# CONFIG_NET_SB1000 is not set
 
 #
 # ARCnet devices
@@ -461,6 +492,11 @@ CONFIG_DUMMY=m
 # CONFIG_ARCNET is not set
 
 #
+# PHY device support
+#
+# CONFIG_PHYLIB is not set
+
+#
 # Ethernet (10 or 100Mbit)
 #
 CONFIG_NET_ETHERNET=y
@@ -481,6 +517,7 @@ CONFIG_TULIP=m
 # CONFIG_DE4X5 is not set
 # CONFIG_WINBOND_840 is not set
 # CONFIG_DM9102 is not set
+# CONFIG_ULI526X is not set
 # CONFIG_HP100 is not set
 CONFIG_NET_PCI=y
 # CONFIG_PCNET32 is not set
@@ -512,6 +549,7 @@ CONFIG_E1000=y
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
 # CONFIG_R8169 is not set
+# CONFIG_SIS190 is not set
 # CONFIG_SKGE is not set
 # CONFIG_SK98LIN is not set
 # CONFIG_VIA_VELOCITY is not set
@@ -521,6 +559,7 @@ CONFIG_TIGON3=y
 #
 # Ethernet (10000 Mbit)
 #
+# CONFIG_CHELSIO_T1 is not set
 # CONFIG_IXGB is not set
 # CONFIG_S2IO is not set
 
@@ -618,6 +657,7 @@ CONFIG_HW_CONSOLE=y
 CONFIG_SERIAL_NONSTANDARD=y
 # CONFIG_ROCKETPORT is not set
 # CONFIG_CYCLADES is not set
+# CONFIG_DIGIEPCA is not set
 # CONFIG_MOXA_SMARTIO is not set
 # CONFIG_ISI is not set
 # CONFIG_SYNCLINKMP is not set
@@ -675,6 +715,7 @@ CONFIG_DRM_RADEON=m
 CONFIG_DRM_MGA=m
 CONFIG_DRM_SIS=m
 # CONFIG_DRM_VIA is not set
+# CONFIG_DRM_SAVAGE is not set
 CONFIG_RAW_DRIVER=m
 CONFIG_HPET=y
 # CONFIG_HPET_RTC_IRQ is not set
@@ -691,7 +732,6 @@ CONFIG_MAX_RAW_DEVS=256
 # I2C support
 #
 # CONFIG_I2C is not set
-# CONFIG_I2C_SENSOR is not set
 
 #
 # Dallas's 1-wire bus
@@ -702,6 +742,7 @@ CONFIG_MAX_RAW_DEVS=256
 # Hardware Monitoring support
 #
 CONFIG_HWMON=y
+# CONFIG_HWMON_VID is not set
 # CONFIG_HWMON_DEBUG_CHIP is not set
 
 #
@@ -709,6 +750,10 @@ CONFIG_HWMON=y
 #
 
 #
+# Multimedia Capabilities Port drivers
+#
+
+#
 # Multimedia devices
 #
 # CONFIG_VIDEO_DEV is not set
@@ -800,9 +845,11 @@ CONFIG_USB_HIDINPUT=y
 # CONFIG_USB_MTOUCH is not set
 # CONFIG_USB_ITMTOUCH is not set
 # CONFIG_USB_EGALAX is not set
+# CONFIG_USB_YEALINK is not set
 # CONFIG_USB_XPAD is not set
 # CONFIG_USB_ATI_REMOTE is not set
 # CONFIG_USB_KEYSPAN_REMOTE is not set
+# CONFIG_USB_APPLETOUCH is not set
 
 #
 # USB Imaging devices
@@ -902,16 +949,12 @@ CONFIG_REISERFS_FS_POSIX_ACL=y
 CONFIG_REISERFS_FS_SECURITY=y
 # CONFIG_JFS_FS is not set
 CONFIG_FS_POSIX_ACL=y
-
-#
-# XFS support
-#
 CONFIG_XFS_FS=y
 CONFIG_XFS_EXPORT=y
-# CONFIG_XFS_RT is not set
 # CONFIG_XFS_QUOTA is not set
 # CONFIG_XFS_SECURITY is not set
 # CONFIG_XFS_POSIX_ACL is not set
+# CONFIG_XFS_RT is not set
 # CONFIG_MINIX_FS is not set
 # CONFIG_ROMFS_FS is not set
 CONFIG_INOTIFY=y
@@ -919,6 +962,7 @@ CONFIG_INOTIFY=y
 CONFIG_DNOTIFY=y
 CONFIG_AUTOFS_FS=y
 CONFIG_AUTOFS4_FS=y
+# CONFIG_FUSE_FS is not set
 
 #
 # CD-ROM/DVD Filesystems
@@ -947,13 +991,11 @@ CONFIG_NTFS_FS=m
 CONFIG_PROC_FS=y
 CONFIG_PROC_KCORE=y
 CONFIG_SYSFS=y
-# CONFIG_DEVPTS_FS_XATTR is not set
 CONFIG_TMPFS=y
-CONFIG_TMPFS_XATTR=y
-CONFIG_TMPFS_SECURITY=y
 CONFIG_HUGETLBFS=y
 CONFIG_HUGETLB_PAGE=y
 CONFIG_RAMFS=y
+# CONFIG_RELAYFS_FS is not set
 
 #
 # Miscellaneous filesystems
@@ -1003,6 +1045,7 @@ CONFIG_CIFS=m
 # CONFIG_NCP_FS is not set
 # CONFIG_CODA_FS is not set
 # CONFIG_AFS_FS is not set
+# CONFIG_9P_FS is not set
 
 #
 # Partition Types
@@ -1072,10 +1115,12 @@ CONFIG_NLS_UTF8=m
 # Library routines
 #
 # CONFIG_CRC_CCITT is not set
+# CONFIG_CRC16 is not set
 CONFIG_CRC32=y
 # CONFIG_LIBCRC32C is not set
 CONFIG_GENERIC_HARDIRQS=y
 CONFIG_GENERIC_IRQ_PROBE=y
+CONFIG_GENERIC_PENDING_IRQ=y
 
 #
 # Profiling support
@@ -1089,6 +1134,7 @@ CONFIG_GENERIC_IRQ_PROBE=y
 CONFIG_DEBUG_KERNEL=y
 CONFIG_MAGIC_SYSRQ=y
 CONFIG_LOG_BUF_SHIFT=20
+CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_DEBUG_SLAB is not set
 # CONFIG_DEBUG_SPINLOCK is not set
diff --git a/arch/ia64/configs/zx1_defconfig b/arch/ia64/configs/zx1_defconfig
index 80b0e9eb7fb3..0856ca67dd50 100644
--- a/arch/ia64/configs/zx1_defconfig
+++ b/arch/ia64/configs/zx1_defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.13-rc6
-# Wed Aug 17 10:02:43 2005
+# Linux kernel version: 2.6.14-rc1
+# Wed Sep 14 15:15:01 2005
 #
 
 #
@@ -18,6 +18,7 @@ CONFIG_INIT_ENV_ARG_LIMIT=32
 # General setup
 #
 CONFIG_LOCALVERSION=""
+CONFIG_LOCALVERSION_AUTO=y
 CONFIG_SWAP=y
 CONFIG_SYSVIPC=y
 # CONFIG_POSIX_MQUEUE is not set
@@ -29,6 +30,7 @@ CONFIG_HOTPLUG=y
 CONFIG_KOBJECT_UEVENT=y
 # CONFIG_IKCONFIG is not set
 # CONFIG_CPUSETS is not set
+CONFIG_INITRAMFS_SOURCE=""
 # CONFIG_EMBEDDED is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_ALL is not set
@@ -103,6 +105,7 @@ CONFIG_FLATMEM_MANUAL=y
 # CONFIG_SPARSEMEM_MANUAL is not set
 CONFIG_FLATMEM=y
 CONFIG_FLAT_NODE_MEM_MAP=y
+# CONFIG_SPARSEMEM_STATIC is not set
 CONFIG_HAVE_DEC_LOCK=y
 CONFIG_IA32_SUPPORT=y
 CONFIG_COMPAT=y
@@ -115,6 +118,7 @@ CONFIG_IA64_PALINFO=y
 #
 CONFIG_EFI_VARS=y
 CONFIG_EFI_PCDP=y
+# CONFIG_DELL_RBU is not set
 CONFIG_BINFMT_ELF=y
 CONFIG_BINFMT_MISC=y
 
@@ -122,28 +126,34 @@ CONFIG_BINFMT_MISC=y
 # Power management and ACPI
 #
 CONFIG_PM=y
-CONFIG_ACPI=y
+# CONFIG_PM_DEBUG is not set
 
 #
 # ACPI (Advanced Configuration and Power Interface) Support
 #
+CONFIG_ACPI=y
 CONFIG_ACPI_BUTTON=y
 CONFIG_ACPI_FAN=y
 CONFIG_ACPI_PROCESSOR=y
 CONFIG_ACPI_THERMAL=y
+CONFIG_ACPI_BLACKLIST_YEAR=0
 # CONFIG_ACPI_DEBUG is not set
 CONFIG_ACPI_POWER=y
 CONFIG_ACPI_SYSTEM=y
 # CONFIG_ACPI_CONTAINER is not set
 
 #
+# CPU Frequency scaling
+#
+# CONFIG_CPU_FREQ is not set
+
+#
 # Bus options (PCI, PCMCIA)
 #
 CONFIG_PCI=y
 CONFIG_PCI_DOMAINS=y
 # CONFIG_PCI_MSI is not set
 CONFIG_PCI_LEGACY_PROC=y
-CONFIG_PCI_NAMES=y
 # CONFIG_PCI_DEBUG is not set
 
 #
@@ -187,8 +197,8 @@ CONFIG_IP_FIB_HASH=y
 # CONFIG_INET_ESP is not set
 # CONFIG_INET_IPCOMP is not set
 # CONFIG_INET_TUNNEL is not set
-# CONFIG_IP_TCPDIAG is not set
-# CONFIG_IP_TCPDIAG_IPV6 is not set
+CONFIG_INET_DIAG=y
+CONFIG_INET_TCP_DIAG=y
 # CONFIG_TCP_CONG_ADVANCED is not set
 CONFIG_TCP_CONG_BIC=y
 
@@ -204,7 +214,6 @@ CONFIG_NETFILTER=y
 # IP: Netfilter Configuration
 #
 # CONFIG_IP_NF_CONNTRACK is not set
-# CONFIG_IP_NF_CONNTRACK_MARK is not set
 # CONFIG_IP_NF_QUEUE is not set
 # CONFIG_IP_NF_IPTABLES is not set
 CONFIG_IP_NF_ARPTABLES=y
@@ -212,6 +221,11 @@ CONFIG_IP_NF_ARPTABLES=y
 # CONFIG_IP_NF_ARP_MANGLE is not set
 
 #
+# DCCP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_DCCP is not set
+
+#
 # SCTP Configuration (EXPERIMENTAL)
 #
 # CONFIG_IP_SCTP is not set
@@ -234,9 +248,11 @@ CONFIG_IP_NF_ARPTABLES=y
 # Network testing
 #
 # CONFIG_NET_PKTGEN is not set
+# CONFIG_NETFILTER_NETLINK is not set
 # CONFIG_HAMRADIO is not set
 # CONFIG_IRDA is not set
 # CONFIG_BT is not set
+# CONFIG_IEEE80211 is not set
 
 #
 # Device Drivers
@@ -251,6 +267,11 @@ CONFIG_PREVENT_FIRMWARE_BUILD=y
 # CONFIG_DEBUG_DRIVER is not set
 
 #
+# Connector - unified userspace <-> kernelspace linker
+#
+# CONFIG_CONNECTOR is not set
+
+#
 # Memory Technology Devices (MTD)
 #
 # CONFIG_MTD is not set
@@ -263,7 +284,13 @@ CONFIG_PREVENT_FIRMWARE_BUILD=y
 #
 # Plug and Play support
 #
-# CONFIG_PNP is not set
+CONFIG_PNP=y
+# CONFIG_PNP_DEBUG is not set
+
+#
+# Protocols
+#
+CONFIG_PNPACPI=y
 
 #
 # Block devices
@@ -282,7 +309,6 @@ CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_COUNT=16
 CONFIG_BLK_DEV_RAM_SIZE=4096
 CONFIG_BLK_DEV_INITRD=y
-CONFIG_INITRAMFS_SOURCE=""
 # CONFIG_CDROM_PKTCDVD is not set
 
 #
@@ -315,7 +341,8 @@ CONFIG_BLK_DEV_IDECD=y
 #
 # IDE chipset support/bugfixes
 #
-CONFIG_IDE_GENERIC=y
+# CONFIG_IDE_GENERIC is not set
+# CONFIG_BLK_DEV_IDEPNP is not set
 CONFIG_BLK_DEV_IDEPCI=y
 CONFIG_IDEPCI_SHARE_IRQ=y
 # CONFIG_BLK_DEV_OFFBOARD is not set
@@ -354,6 +381,7 @@ CONFIG_BLK_DEV_IDEDMA=y
 #
 # SCSI device support
 #
+# CONFIG_RAID_ATTRS is not set
 CONFIG_SCSI=y
 CONFIG_SCSI_PROC_FS=y
 
@@ -381,6 +409,7 @@ CONFIG_SCSI_LOGGING=y
 CONFIG_SCSI_SPI_ATTRS=y
 # CONFIG_SCSI_FC_ATTRS is not set
 # CONFIG_SCSI_ISCSI_ATTRS is not set
+# CONFIG_SCSI_SAS_ATTRS is not set
 
 #
 # SCSI low-level drivers
@@ -457,6 +486,7 @@ CONFIG_DUMMY=y
 # CONFIG_BONDING is not set
 # CONFIG_EQUALIZER is not set
 # CONFIG_TUN is not set
+# CONFIG_NET_SB1000 is not set
 
 #
 # ARCnet devices
@@ -464,6 +494,11 @@ CONFIG_DUMMY=y
 # CONFIG_ARCNET is not set
 
 #
+# PHY device support
+#
+# CONFIG_PHYLIB is not set
+
+#
 # Ethernet (10 or 100Mbit)
 #
 CONFIG_NET_ETHERNET=y
@@ -485,6 +520,7 @@ CONFIG_TULIP_NAPI_HW_MITIGATION=y
 # CONFIG_DE4X5 is not set
 # CONFIG_WINBOND_840 is not set
 # CONFIG_DM9102 is not set
+# CONFIG_ULI526X is not set
 # CONFIG_HP100 is not set
 CONFIG_NET_PCI=y
 # CONFIG_PCNET32 is not set
@@ -516,6 +552,7 @@ CONFIG_E1000=y
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
 # CONFIG_R8169 is not set
+# CONFIG_SIS190 is not set
 # CONFIG_SKGE is not set
 # CONFIG_SK98LIN is not set
 # CONFIG_VIA_VELOCITY is not set
@@ -525,6 +562,7 @@ CONFIG_TIGON3=y
 #
 # Ethernet (10000 Mbit)
 #
+# CONFIG_CHELSIO_T1 is not set
 # CONFIG_IXGB is not set
 # CONFIG_S2IO is not set
 
@@ -650,12 +688,12 @@ CONFIG_AGP=y
 CONFIG_AGP_HP_ZX1=y
 CONFIG_DRM=y
 # CONFIG_DRM_TDFX is not set
-# CONFIG_DRM_GAMMA is not set
 # CONFIG_DRM_R128 is not set
 CONFIG_DRM_RADEON=y
 # CONFIG_DRM_MGA is not set
 # CONFIG_DRM_SIS is not set
 # CONFIG_DRM_VIA is not set
+# CONFIG_DRM_SAVAGE is not set
 # CONFIG_RAW_DRIVER is not set
 # CONFIG_HPET is not set
 # CONFIG_HANGCHECK_TIMER is not set
@@ -689,7 +727,6 @@ CONFIG_I2C_ALGOPCF=y
 # CONFIG_I2C_I801 is not set
 # CONFIG_I2C_I810 is not set
 # CONFIG_I2C_PIIX4 is not set
-# CONFIG_I2C_ISA is not set
 # CONFIG_I2C_NFORCE2 is not set
 # CONFIG_I2C_PARPORT_LIGHT is not set
 # CONFIG_I2C_PROSAVAGE is not set
@@ -703,7 +740,6 @@ CONFIG_I2C_ALGOPCF=y
 # CONFIG_I2C_VIAPRO is not set
 # CONFIG_I2C_VOODOO3 is not set
 # CONFIG_I2C_PCA_ISA is not set
-# CONFIG_I2C_SENSOR is not set
 
 #
 # Miscellaneous I2C Chip support
@@ -730,12 +766,17 @@ CONFIG_I2C_ALGOPCF=y
 # Hardware Monitoring support
 #
 # CONFIG_HWMON is not set
+# CONFIG_HWMON_VID is not set
 
 #
 # Misc devices
 #
 
 #
+# Multimedia Capabilities Port drivers
+#
+
+#
 # Multimedia devices
 #
 CONFIG_VIDEO_DEV=y
@@ -806,6 +847,7 @@ CONFIG_FB_RADEON_DEBUG=y
 # CONFIG_FB_KYRO is not set
 # CONFIG_FB_3DFX is not set
 # CONFIG_FB_VOODOO1 is not set
+# CONFIG_FB_CYBLA is not set
 # CONFIG_FB_TRIDENT is not set
 # CONFIG_FB_PM3 is not set
 # CONFIG_FB_S1D13XXX is not set
@@ -862,11 +904,12 @@ CONFIG_SND_OPL3_LIB=y
 # CONFIG_SND_MTPAV is not set
 # CONFIG_SND_SERIAL_U16550 is not set
 # CONFIG_SND_MPU401 is not set
+CONFIG_SND_AC97_CODEC=y
+CONFIG_SND_AC97_BUS=y
 
 #
 # PCI devices
 #
-CONFIG_SND_AC97_CODEC=y
 # CONFIG_SND_ALI5451 is not set
 # CONFIG_SND_ATIIXP is not set
 # CONFIG_SND_ATIIXP_MODEM is not set
@@ -890,7 +933,7 @@ CONFIG_SND_AC97_CODEC=y
 # CONFIG_SND_HDSPM is not set
 # CONFIG_SND_TRIDENT is not set
 # CONFIG_SND_YMFPCI is not set
-# CONFIG_SND_ALS4000 is not set
+# CONFIG_SND_AD1889 is not set
 # CONFIG_SND_CMIPCI is not set
 # CONFIG_SND_ENS1370 is not set
 # CONFIG_SND_ENS1371 is not set
@@ -952,9 +995,8 @@ CONFIG_USB_UHCI_HCD=y
 #
 # USB Device Class drivers
 #
-# CONFIG_USB_AUDIO is not set
+# CONFIG_OBSOLETE_OSS_USB_DRIVER is not set
 # CONFIG_USB_BLUETOOTH_TTY is not set
-# CONFIG_USB_MIDI is not set
 # CONFIG_USB_ACM is not set
 # CONFIG_USB_PRINTER is not set
 
@@ -971,6 +1013,7 @@ CONFIG_USB_STORAGE=y
 # CONFIG_USB_STORAGE_SDDR09 is not set
 # CONFIG_USB_STORAGE_SDDR55 is not set
 # CONFIG_USB_STORAGE_JUMPSHOT is not set
+# CONFIG_USB_STORAGE_ONETOUCH is not set
 
 #
 # USB Input Devices
@@ -987,9 +1030,11 @@ CONFIG_USB_HIDDEV=y
 # CONFIG_USB_MTOUCH is not set
 # CONFIG_USB_ITMTOUCH is not set
 # CONFIG_USB_EGALAX is not set
+# CONFIG_USB_YEALINK is not set
 # CONFIG_USB_XPAD is not set
 # CONFIG_USB_ATI_REMOTE is not set
 # CONFIG_USB_KEYSPAN_REMOTE is not set
+# CONFIG_USB_APPLETOUCH is not set
 
 #
 # USB Imaging devices
@@ -1088,10 +1133,6 @@ CONFIG_FS_MBCACHE=y
 # CONFIG_REISERFS_FS is not set
 # CONFIG_JFS_FS is not set
 # CONFIG_FS_POSIX_ACL is not set
-
-#
-# XFS support
-#
 # CONFIG_XFS_FS is not set
 # CONFIG_MINIX_FS is not set
 # CONFIG_ROMFS_FS is not set
@@ -1100,6 +1141,7 @@ CONFIG_FS_MBCACHE=y
 CONFIG_DNOTIFY=y
 CONFIG_AUTOFS_FS=y
 # CONFIG_AUTOFS4_FS is not set
+# CONFIG_FUSE_FS is not set
 
 #
 # CD-ROM/DVD Filesystems
@@ -1126,13 +1168,11 @@ CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
 CONFIG_PROC_FS=y
 CONFIG_PROC_KCORE=y
 CONFIG_SYSFS=y
-# CONFIG_DEVPTS_FS_XATTR is not set
 CONFIG_TMPFS=y
-CONFIG_TMPFS_XATTR=y
-CONFIG_TMPFS_SECURITY=y
 CONFIG_HUGETLBFS=y
 CONFIG_HUGETLB_PAGE=y
 CONFIG_RAMFS=y
+# CONFIG_RELAYFS_FS is not set
 
 #
 # Miscellaneous filesystems
@@ -1177,6 +1217,7 @@ CONFIG_RPCSEC_GSS_KRB5=y
 # CONFIG_NCP_FS is not set
 # CONFIG_CODA_FS is not set
 # CONFIG_AFS_FS is not set
+# CONFIG_9P_FS is not set
 
 #
 # Partition Types
@@ -1246,10 +1287,12 @@ CONFIG_NLS_UTF8=y
 # Library routines
 #
 # CONFIG_CRC_CCITT is not set
+# CONFIG_CRC16 is not set
 CONFIG_CRC32=y
 # CONFIG_LIBCRC32C is not set
 CONFIG_GENERIC_HARDIRQS=y
 CONFIG_GENERIC_IRQ_PROBE=y
+CONFIG_GENERIC_PENDING_IRQ=y
 
 #
 # Profiling support
@@ -1263,6 +1306,7 @@ CONFIG_GENERIC_IRQ_PROBE=y
 CONFIG_DEBUG_KERNEL=y
 CONFIG_MAGIC_SYSRQ=y
 CONFIG_LOG_BUF_SHIFT=17
+CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_DEBUG_SLAB is not set
 # CONFIG_DEBUG_SPINLOCK is not set
diff --git a/arch/ia64/defconfig b/arch/ia64/defconfig
index 5da208115ea1..6e3f147e03e5 100644
--- a/arch/ia64/defconfig
+++ b/arch/ia64/defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.12
-# Tue Jun 21 11:30:42 2005
+# Linux kernel version: 2.6.14-rc1
+# Wed Sep 14 15:13:03 2005
 #
 
 #
@@ -16,6 +16,7 @@ CONFIG_INIT_ENV_ARG_LIMIT=32
 # General setup
 #
 CONFIG_LOCALVERSION=""
+CONFIG_LOCALVERSION_AUTO=y
 CONFIG_SWAP=y
 CONFIG_SYSVIPC=y
 CONFIG_POSIX_MQUEUE=y
@@ -27,6 +28,7 @@ CONFIG_KOBJECT_UEVENT=y
 CONFIG_IKCONFIG=y
 CONFIG_IKCONFIG_PROC=y
 # CONFIG_CPUSETS is not set
+CONFIG_INITRAMFS_SOURCE=""
 # CONFIG_EMBEDDED is not set
 CONFIG_KALLSYMS=y
 CONFIG_KALLSYMS_ALL=y
@@ -80,6 +82,10 @@ CONFIG_MCKINLEY=y
 # CONFIG_IA64_PAGE_SIZE_8KB is not set
 CONFIG_IA64_PAGE_SIZE_16KB=y
 # CONFIG_IA64_PAGE_SIZE_64KB is not set
+# CONFIG_HZ_100 is not set
+CONFIG_HZ_250=y
+# CONFIG_HZ_1000 is not set
+CONFIG_HZ=250
 CONFIG_IA64_L1_CACHE_SHIFT=7
 CONFIG_NUMA=y
 CONFIG_VIRTUAL_MEM_MAP=y
@@ -87,12 +93,21 @@ CONFIG_HOLES_IN_ZONE=y
 CONFIG_ARCH_DISCONTIGMEM_ENABLE=y
 CONFIG_IA64_CYCLONE=y
 CONFIG_IOSAPIC=y
+# CONFIG_IA64_SGI_SN_XP is not set
 CONFIG_FORCE_MAX_ZONEORDER=18
 CONFIG_SMP=y
 CONFIG_NR_CPUS=512
 CONFIG_HOTPLUG_CPU=y
 # CONFIG_SCHED_SMT is not set
 # CONFIG_PREEMPT is not set
+CONFIG_SELECT_MEMORY_MODEL=y
+# CONFIG_FLATMEM_MANUAL is not set
+CONFIG_DISCONTIGMEM_MANUAL=y
+# CONFIG_SPARSEMEM_MANUAL is not set
+CONFIG_DISCONTIGMEM=y
+CONFIG_FLAT_NODE_MEM_MAP=y
+CONFIG_NEED_MULTIPLE_NODES=y
+# CONFIG_SPARSEMEM_STATIC is not set
 CONFIG_HAVE_DEC_LOCK=y
 CONFIG_IA32_SUPPORT=y
 CONFIG_COMPAT=y
@@ -105,6 +120,7 @@ CONFIG_IA64_PALINFO=y
 #
 CONFIG_EFI_VARS=y
 CONFIG_EFI_PCDP=y
+# CONFIG_DELL_RBU is not set
 CONFIG_BINFMT_ELF=y
 CONFIG_BINFMT_MISC=m
 
@@ -112,30 +128,36 @@ CONFIG_BINFMT_MISC=m
 # Power management and ACPI
 #
 CONFIG_PM=y
-CONFIG_ACPI=y
+# CONFIG_PM_DEBUG is not set
 
 #
 # ACPI (Advanced Configuration and Power Interface) Support
 #
+CONFIG_ACPI=y
 CONFIG_ACPI_BUTTON=m
 CONFIG_ACPI_FAN=m
 CONFIG_ACPI_PROCESSOR=m
 CONFIG_ACPI_HOTPLUG_CPU=y
 CONFIG_ACPI_THERMAL=m
 CONFIG_ACPI_NUMA=y
+CONFIG_ACPI_BLACKLIST_YEAR=0
 # CONFIG_ACPI_DEBUG is not set
 CONFIG_ACPI_POWER=y
 CONFIG_ACPI_SYSTEM=y
 CONFIG_ACPI_CONTAINER=m
 
 #
+# CPU Frequency scaling
+#
+# CONFIG_CPU_FREQ is not set
+
+#
 # Bus options (PCI, PCMCIA)
 #
 CONFIG_PCI=y
 CONFIG_PCI_DOMAINS=y
 # CONFIG_PCI_MSI is not set
 CONFIG_PCI_LEGACY_PROC=y
-CONFIG_PCI_NAMES=y
 # CONFIG_PCI_DEBUG is not set
 
 #
@@ -147,6 +169,7 @@ CONFIG_HOTPLUG_PCI_ACPI=m
 # CONFIG_HOTPLUG_PCI_ACPI_IBM is not set
 # CONFIG_HOTPLUG_PCI_CPCI is not set
 # CONFIG_HOTPLUG_PCI_SHPC is not set
+# CONFIG_HOTPLUG_PCI_SGI is not set
 
 #
 # PCCARD (PCMCIA/CardBus) support
@@ -154,6 +177,73 @@ CONFIG_HOTPLUG_PCI_ACPI=m
 # CONFIG_PCCARD is not set
 
 #
+# Networking
+#
+CONFIG_NET=y
+
+#
+# Networking options
+#
+CONFIG_PACKET=y
+# CONFIG_PACKET_MMAP is not set
+CONFIG_UNIX=y
+# CONFIG_NET_KEY is not set
+CONFIG_INET=y
+CONFIG_IP_MULTICAST=y
+# CONFIG_IP_ADVANCED_ROUTER is not set
+CONFIG_IP_FIB_HASH=y
+# CONFIG_IP_PNP is not set
+# CONFIG_NET_IPIP is not set
+# CONFIG_NET_IPGRE is not set
+# CONFIG_IP_MROUTE is not set
+CONFIG_ARPD=y
+CONFIG_SYN_COOKIES=y
+# CONFIG_INET_AH is not set
+# CONFIG_INET_ESP is not set
+# CONFIG_INET_IPCOMP is not set
+# CONFIG_INET_TUNNEL is not set
+CONFIG_INET_DIAG=y
+CONFIG_INET_TCP_DIAG=y
+# CONFIG_TCP_CONG_ADVANCED is not set
+CONFIG_TCP_CONG_BIC=y
+# CONFIG_IPV6 is not set
+# CONFIG_NETFILTER is not set
+
+#
+# DCCP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_DCCP is not set
+
+#
+# SCTP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_SCTP is not set
+# CONFIG_ATM is not set
+# CONFIG_BRIDGE is not set
+# CONFIG_VLAN_8021Q is not set
+# CONFIG_DECNET is not set
+# CONFIG_LLC2 is not set
+# CONFIG_IPX is not set
+# CONFIG_ATALK is not set
+# CONFIG_X25 is not set
+# CONFIG_LAPB is not set
+# CONFIG_NET_DIVERT is not set
+# CONFIG_ECONET is not set
+# CONFIG_WAN_ROUTER is not set
+# CONFIG_NET_SCHED is not set
+# CONFIG_NET_CLS_ROUTE is not set
+
+#
+# Network testing
+#
+# CONFIG_NET_PKTGEN is not set
+# CONFIG_NETFILTER_NETLINK is not set
+# CONFIG_HAMRADIO is not set
+# CONFIG_IRDA is not set
+# CONFIG_BT is not set
+# CONFIG_IEEE80211 is not set
+
+#
 # Device Drivers
 #
 
@@ -162,10 +252,15 @@ CONFIG_HOTPLUG_PCI_ACPI=m
 #
 CONFIG_STANDALONE=y
 CONFIG_PREVENT_FIRMWARE_BUILD=y
-# CONFIG_FW_LOADER is not set
+CONFIG_FW_LOADER=m
 # CONFIG_DEBUG_DRIVER is not set
 
 #
+# Connector - unified userspace <-> kernelspace linker
+#
+# CONFIG_CONNECTOR is not set
+
+#
 # Memory Technology Devices (MTD)
 #
 # CONFIG_MTD is not set
@@ -178,7 +273,13 @@ CONFIG_PREVENT_FIRMWARE_BUILD=y
 #
 # Plug and Play support
 #
-# CONFIG_PNP is not set
+CONFIG_PNP=y
+# CONFIG_PNP_DEBUG is not set
+
+#
+# Protocols
+#
+CONFIG_PNPACPI=y
 
 #
 # Block devices
@@ -197,7 +298,6 @@ CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_COUNT=16
 CONFIG_BLK_DEV_RAM_SIZE=4096
 CONFIG_BLK_DEV_INITRD=y
-CONFIG_INITRAMFS_SOURCE=""
 # CONFIG_CDROM_PKTCDVD is not set
 
 #
@@ -230,7 +330,8 @@ CONFIG_BLK_DEV_IDESCSI=m
 #
 # IDE chipset support/bugfixes
 #
-CONFIG_IDE_GENERIC=y
+# CONFIG_IDE_GENERIC is not set
+# CONFIG_BLK_DEV_IDEPNP is not set
 CONFIG_BLK_DEV_IDEPCI=y
 # CONFIG_IDEPCI_SHARE_IRQ is not set
 # CONFIG_BLK_DEV_OFFBOARD is not set
@@ -252,6 +353,7 @@ CONFIG_BLK_DEV_CMD64X=y
 # CONFIG_BLK_DEV_HPT366 is not set
 # CONFIG_BLK_DEV_SC1200 is not set
 CONFIG_BLK_DEV_PIIX=y
+# CONFIG_BLK_DEV_IT821X is not set
 # CONFIG_BLK_DEV_NS87415 is not set
 # CONFIG_BLK_DEV_PDC202XX_OLD is not set
 # CONFIG_BLK_DEV_PDC202XX_NEW is not set
@@ -270,6 +372,7 @@ CONFIG_IDEDMA_AUTO=y
 #
 # SCSI device support
 #
+# CONFIG_RAID_ATTRS is not set
 CONFIG_SCSI=y
 CONFIG_SCSI_PROC_FS=y
 
@@ -297,6 +400,7 @@ CONFIG_CHR_DEV_SG=m
 CONFIG_SCSI_SPI_ATTRS=y
 CONFIG_SCSI_FC_ATTRS=y
 # CONFIG_SCSI_ISCSI_ATTRS is not set
+# CONFIG_SCSI_SAS_ATTRS is not set
 
 #
 # SCSI low-level drivers
@@ -314,6 +418,7 @@ CONFIG_SCSI_SATA=y
 # CONFIG_SCSI_SATA_AHCI is not set
 # CONFIG_SCSI_SATA_SVW is not set
 # CONFIG_SCSI_ATA_PIIX is not set
+# CONFIG_SCSI_SATA_MV is not set
 # CONFIG_SCSI_SATA_NV is not set
 # CONFIG_SCSI_SATA_PROMISE is not set
 # CONFIG_SCSI_SATA_QSTOR is not set
@@ -335,7 +440,6 @@ CONFIG_SCSI_SYM53C8XX_MAX_TAGS=64
 # CONFIG_SCSI_SYM53C8XX_IOMAPPED is not set
 # CONFIG_SCSI_IPR is not set
 # CONFIG_SCSI_QLOGIC_FC is not set
-# CONFIG_SCSI_QLOGIC_FC_FIRMWARE is not set
 CONFIG_SCSI_QLOGIC_1280=y
 # CONFIG_SCSI_QLOGIC_1280_1040 is not set
 CONFIG_SCSI_QLA2XXX=y
@@ -344,6 +448,7 @@ CONFIG_SCSI_QLA22XX=m
 CONFIG_SCSI_QLA2300=m
 CONFIG_SCSI_QLA2322=m
 # CONFIG_SCSI_QLA6312 is not set
+# CONFIG_SCSI_QLA24XX is not set
 # CONFIG_SCSI_LPFC is not set
 # CONFIG_SCSI_DC395x is not set
 # CONFIG_SCSI_DC390T is not set
@@ -390,74 +495,14 @@ CONFIG_FUSION_MAX_SGE=128
 # CONFIG_I2O is not set
 
 #
-# Networking support
-#
-CONFIG_NET=y
-
-#
-# Networking options
-#
-CONFIG_PACKET=y
-# CONFIG_PACKET_MMAP is not set
-CONFIG_UNIX=y
-# CONFIG_NET_KEY is not set
-CONFIG_INET=y
-CONFIG_IP_MULTICAST=y
-# CONFIG_IP_ADVANCED_ROUTER is not set
-# CONFIG_IP_PNP is not set
-# CONFIG_NET_IPIP is not set
-# CONFIG_NET_IPGRE is not set
-# CONFIG_IP_MROUTE is not set
-CONFIG_ARPD=y
-CONFIG_SYN_COOKIES=y
-# CONFIG_INET_AH is not set
-# CONFIG_INET_ESP is not set
-# CONFIG_INET_IPCOMP is not set
-# CONFIG_INET_TUNNEL is not set
-CONFIG_IP_TCPDIAG=y
-# CONFIG_IP_TCPDIAG_IPV6 is not set
-# CONFIG_IPV6 is not set
-# CONFIG_NETFILTER is not set
-
-#
-# SCTP Configuration (EXPERIMENTAL)
-#
-# CONFIG_IP_SCTP is not set
-# CONFIG_ATM is not set
-# CONFIG_BRIDGE is not set
-# CONFIG_VLAN_8021Q is not set
-# CONFIG_DECNET is not set
-# CONFIG_LLC2 is not set
-# CONFIG_IPX is not set
-# CONFIG_ATALK is not set
-# CONFIG_X25 is not set
-# CONFIG_LAPB is not set
-# CONFIG_NET_DIVERT is not set
-# CONFIG_ECONET is not set
-# CONFIG_WAN_ROUTER is not set
-
+# Network device support
 #
-# QoS and/or fair queueing
-#
-# CONFIG_NET_SCHED is not set
-# CONFIG_NET_CLS_ROUTE is not set
-
-#
-# Network testing
-#
-# CONFIG_NET_PKTGEN is not set
-CONFIG_NETPOLL=y
-# CONFIG_NETPOLL_RX is not set
-# CONFIG_NETPOLL_TRAP is not set
-CONFIG_NET_POLL_CONTROLLER=y
-# CONFIG_HAMRADIO is not set
-# CONFIG_IRDA is not set
-# CONFIG_BT is not set
 CONFIG_NETDEVICES=y
 CONFIG_DUMMY=m
 # CONFIG_BONDING is not set
 # CONFIG_EQUALIZER is not set
 # CONFIG_TUN is not set
+# CONFIG_NET_SB1000 is not set
 
 #
 # ARCnet devices
@@ -465,6 +510,11 @@ CONFIG_DUMMY=m
 # CONFIG_ARCNET is not set
 
 #
+# PHY device support
+#
+# CONFIG_PHYLIB is not set
+
+#
 # Ethernet (10 or 100Mbit)
 #
 CONFIG_NET_ETHERNET=y
@@ -485,6 +535,7 @@ CONFIG_TULIP=m
 # CONFIG_DE4X5 is not set
 # CONFIG_WINBOND_840 is not set
 # CONFIG_DM9102 is not set
+# CONFIG_ULI526X is not set
 # CONFIG_HP100 is not set
 CONFIG_NET_PCI=y
 # CONFIG_PCNET32 is not set
@@ -516,6 +567,7 @@ CONFIG_E1000=y
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
 # CONFIG_R8169 is not set
+# CONFIG_SIS190 is not set
 # CONFIG_SKGE is not set
 # CONFIG_SK98LIN is not set
 # CONFIG_VIA_VELOCITY is not set
@@ -525,6 +577,7 @@ CONFIG_TIGON3=y
 #
 # Ethernet (10000 Mbit)
 #
+# CONFIG_CHELSIO_T1 is not set
 # CONFIG_IXGB is not set
 # CONFIG_S2IO is not set
 
@@ -549,6 +602,10 @@ CONFIG_TIGON3=y
 # CONFIG_NET_FC is not set
 # CONFIG_SHAPER is not set
 CONFIG_NETCONSOLE=y
+CONFIG_NETPOLL=y
+# CONFIG_NETPOLL_RX is not set
+# CONFIG_NETPOLL_TRAP is not set
+CONFIG_NET_POLL_CONTROLLER=y
 
 #
 # ISDN subsystem
@@ -607,9 +664,7 @@ CONFIG_GAMEPORT=m
 # CONFIG_GAMEPORT_NS558 is not set
 # CONFIG_GAMEPORT_L4 is not set
 # CONFIG_GAMEPORT_EMU10K1 is not set
-# CONFIG_GAMEPORT_VORTEX is not set
 # CONFIG_GAMEPORT_FM801 is not set
-# CONFIG_GAMEPORT_CS461X is not set
 
 #
 # Character devices
@@ -620,6 +675,7 @@ CONFIG_HW_CONSOLE=y
 CONFIG_SERIAL_NONSTANDARD=y
 # CONFIG_ROCKETPORT is not set
 # CONFIG_CYCLADES is not set
+# CONFIG_DIGIEPCA is not set
 # CONFIG_MOXA_SMARTIO is not set
 # CONFIG_ISI is not set
 # CONFIG_SYNCLINKMP is not set
@@ -641,7 +697,6 @@ CONFIG_SERIAL_8250_NR_UARTS=6
 CONFIG_SERIAL_8250_EXTENDED=y
 CONFIG_SERIAL_8250_SHARE_IRQ=y
 # CONFIG_SERIAL_8250_DETECT_IRQ is not set
-# CONFIG_SERIAL_8250_MULTIPORT is not set
 # CONFIG_SERIAL_8250_RSA is not set
 
 #
@@ -650,8 +705,8 @@ CONFIG_SERIAL_8250_SHARE_IRQ=y
 CONFIG_SERIAL_CORE=y
 CONFIG_SERIAL_CORE_CONSOLE=y
 CONFIG_SERIAL_SGI_L1_CONSOLE=y
-CONFIG_SERIAL_SGI_IOC4=y
 # CONFIG_SERIAL_JSM is not set
+CONFIG_SERIAL_SGI_IOC4=y
 CONFIG_UNIX98_PTYS=y
 CONFIG_LEGACY_PTYS=y
 CONFIG_LEGACY_PTY_COUNT=256
@@ -684,6 +739,8 @@ CONFIG_DRM_R128=m
 CONFIG_DRM_RADEON=m
 CONFIG_DRM_MGA=m
 CONFIG_DRM_SIS=m
+# CONFIG_DRM_VIA is not set
+# CONFIG_DRM_SAVAGE is not set
 CONFIG_RAW_DRIVER=m
 CONFIG_HPET=y
 # CONFIG_HPET_RTC_IRQ is not set
@@ -708,10 +765,21 @@ CONFIG_MMTIMER=y
 # CONFIG_W1 is not set
 
 #
+# Hardware Monitoring support
+#
+CONFIG_HWMON=y
+# CONFIG_HWMON_VID is not set
+# CONFIG_HWMON_DEBUG_CHIP is not set
+
+#
 # Misc devices
 #
 
 #
+# Multimedia Capabilities Port drivers
+#
+
+#
 # Multimedia devices
 #
 # CONFIG_VIDEO_DEV is not set
@@ -753,6 +821,7 @@ CONFIG_SND_PCM_OSS=m
 CONFIG_SND_SEQUENCER_OSS=y
 CONFIG_SND_VERBOSE_PRINTK=y
 # CONFIG_SND_DEBUG is not set
+CONFIG_SND_GENERIC_DRIVER=y
 
 #
 # Generic devices
@@ -764,11 +833,12 @@ CONFIG_SND_VIRMIDI=m
 CONFIG_SND_MTPAV=m
 CONFIG_SND_SERIAL_U16550=m
 CONFIG_SND_MPU401=m
+CONFIG_SND_AC97_CODEC=m
+CONFIG_SND_AC97_BUS=m
 
 #
 # PCI devices
 #
-CONFIG_SND_AC97_CODEC=m
 # CONFIG_SND_ALI5451 is not set
 # CONFIG_SND_ATIIXP is not set
 # CONFIG_SND_ATIIXP_MODEM is not set
@@ -790,9 +860,10 @@ CONFIG_SND_EMU10K1=m
 # CONFIG_SND_RME96 is not set
 # CONFIG_SND_RME9652 is not set
 # CONFIG_SND_HDSP is not set
+# CONFIG_SND_HDSPM is not set
 # CONFIG_SND_TRIDENT is not set
 # CONFIG_SND_YMFPCI is not set
-# CONFIG_SND_ALS4000 is not set
+# CONFIG_SND_AD1889 is not set
 # CONFIG_SND_CMIPCI is not set
 # CONFIG_SND_ENS1370 is not set
 # CONFIG_SND_ENS1371 is not set
@@ -844,6 +915,7 @@ CONFIG_USB_DEVICEFS=y
 CONFIG_USB_EHCI_HCD=m
 # CONFIG_USB_EHCI_SPLIT_ISO is not set
 # CONFIG_USB_EHCI_ROOT_HUB_TT is not set
+# CONFIG_USB_ISP116X_HCD is not set
 CONFIG_USB_OHCI_HCD=m
 # CONFIG_USB_OHCI_BIG_ENDIAN is not set
 CONFIG_USB_OHCI_LITTLE_ENDIAN=y
@@ -853,9 +925,8 @@ CONFIG_USB_UHCI_HCD=m
 #
 # USB Device Class drivers
 #
-# CONFIG_USB_AUDIO is not set
+# CONFIG_OBSOLETE_OSS_USB_DRIVER is not set
 # CONFIG_USB_BLUETOOTH_TTY is not set
-# CONFIG_USB_MIDI is not set
 # CONFIG_USB_ACM is not set
 # CONFIG_USB_PRINTER is not set
 
@@ -888,12 +959,17 @@ CONFIG_USB_HIDINPUT=y
 # CONFIG_USB_MOUSE is not set
 # CONFIG_USB_AIPTEK is not set
 # CONFIG_USB_WACOM is not set
+# CONFIG_USB_ACECAD is not set
 # CONFIG_USB_KBTAB is not set
 # CONFIG_USB_POWERMATE is not set
 # CONFIG_USB_MTOUCH is not set
+# CONFIG_USB_ITMTOUCH is not set
 # CONFIG_USB_EGALAX is not set
+# CONFIG_USB_YEALINK is not set
 # CONFIG_USB_XPAD is not set
 # CONFIG_USB_ATI_REMOTE is not set
+# CONFIG_USB_KEYSPAN_REMOTE is not set
+# CONFIG_USB_APPLETOUCH is not set
 
 #
 # USB Imaging devices
@@ -918,7 +994,7 @@ CONFIG_USB_HIDINPUT=y
 # CONFIG_USB_PEGASUS is not set
 # CONFIG_USB_RTL8150 is not set
 # CONFIG_USB_USBNET is not set
-CONFIG_USB_MON=m
+CONFIG_USB_MON=y
 
 #
 # USB port drivers
@@ -944,10 +1020,11 @@ CONFIG_USB_MON=m
 # CONFIG_USB_PHIDGETSERVO is not set
 # CONFIG_USB_IDMOUSE is not set
 # CONFIG_USB_SISUSBVGA is not set
+# CONFIG_USB_LD is not set
 # CONFIG_USB_TEST is not set
 
 #
-# USB ATM/DSL drivers
+# USB DSL modem support
 #
 
 #
@@ -964,6 +1041,8 @@ CONFIG_USB_MON=m
 # InfiniBand support
 #
 CONFIG_INFINIBAND=m
+# CONFIG_INFINIBAND_USER_MAD is not set
+# CONFIG_INFINIBAND_USER_ACCESS is not set
 CONFIG_INFINIBAND_MTHCA=m
 # CONFIG_INFINIBAND_MTHCA_DEBUG is not set
 CONFIG_INFINIBAND_IPOIB=m
@@ -981,6 +1060,7 @@ CONFIG_EXT2_FS=y
 CONFIG_EXT2_FS_XATTR=y
 CONFIG_EXT2_FS_POSIX_ACL=y
 CONFIG_EXT2_FS_SECURITY=y
+# CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
 CONFIG_EXT3_FS_XATTR=y
 CONFIG_EXT3_FS_POSIX_ACL=y
@@ -996,22 +1076,20 @@ CONFIG_REISERFS_FS_POSIX_ACL=y
 CONFIG_REISERFS_FS_SECURITY=y
 # CONFIG_JFS_FS is not set
 CONFIG_FS_POSIX_ACL=y
-
-#
-# XFS support
-#
 CONFIG_XFS_FS=y
 CONFIG_XFS_EXPORT=y
-# CONFIG_XFS_RT is not set
 # CONFIG_XFS_QUOTA is not set
 # CONFIG_XFS_SECURITY is not set
 # CONFIG_XFS_POSIX_ACL is not set
+# CONFIG_XFS_RT is not set
 # CONFIG_MINIX_FS is not set
 # CONFIG_ROMFS_FS is not set
+CONFIG_INOTIFY=y
 # CONFIG_QUOTA is not set
 CONFIG_DNOTIFY=y
 CONFIG_AUTOFS_FS=y
 CONFIG_AUTOFS4_FS=y
+# CONFIG_FUSE_FS is not set
 
 #
 # CD-ROM/DVD Filesystems
@@ -1040,14 +1118,11 @@ CONFIG_NTFS_FS=m
 CONFIG_PROC_FS=y
 CONFIG_PROC_KCORE=y
 CONFIG_SYSFS=y
-# CONFIG_DEVFS_FS is not set
-# CONFIG_DEVPTS_FS_XATTR is not set
 CONFIG_TMPFS=y
-CONFIG_TMPFS_XATTR=y
-CONFIG_TMPFS_SECURITY=y
 CONFIG_HUGETLBFS=y
 CONFIG_HUGETLB_PAGE=y
 CONFIG_RAMFS=y
+# CONFIG_RELAYFS_FS is not set
 
 #
 # Miscellaneous filesystems
@@ -1071,15 +1146,18 @@ CONFIG_RAMFS=y
 #
 CONFIG_NFS_FS=m
 CONFIG_NFS_V3=y
+# CONFIG_NFS_V3_ACL is not set
 CONFIG_NFS_V4=y
 CONFIG_NFS_DIRECTIO=y
 CONFIG_NFSD=m
 CONFIG_NFSD_V3=y
+# CONFIG_NFSD_V3_ACL is not set
 CONFIG_NFSD_V4=y
 CONFIG_NFSD_TCP=y
 CONFIG_LOCKD=m
 CONFIG_LOCKD_V4=y
 CONFIG_EXPORTFS=y
+CONFIG_NFS_COMMON=y
 CONFIG_SUNRPC=m
 CONFIG_SUNRPC_GSS=m
 CONFIG_RPCSEC_GSS_KRB5=m
@@ -1094,6 +1172,7 @@ CONFIG_CIFS=m
 # CONFIG_NCP_FS is not set
 # CONFIG_CODA_FS is not set
 # CONFIG_AFS_FS is not set
+# CONFIG_9P_FS is not set
 
 #
 # Partition Types
@@ -1163,10 +1242,12 @@ CONFIG_NLS_UTF8=m
 # Library routines
 #
 # CONFIG_CRC_CCITT is not set
+# CONFIG_CRC16 is not set
 CONFIG_CRC32=y
 # CONFIG_LIBCRC32C is not set
 CONFIG_GENERIC_HARDIRQS=y
 CONFIG_GENERIC_IRQ_PROBE=y
+CONFIG_GENERIC_PENDING_IRQ=y
 
 #
 # HP Simulator drivers
@@ -1187,6 +1268,7 @@ CONFIG_GENERIC_IRQ_PROBE=y
 CONFIG_DEBUG_KERNEL=y
 CONFIG_MAGIC_SYSRQ=y
 CONFIG_LOG_BUF_SHIFT=20
+CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_DEBUG_SLAB is not set
 # CONFIG_DEBUG_SPINLOCK is not set
@@ -1194,6 +1276,7 @@ CONFIG_LOG_BUF_SHIFT=20
 # CONFIG_DEBUG_KOBJECT is not set
 # CONFIG_DEBUG_INFO is not set
 # CONFIG_DEBUG_FS is not set
+# CONFIG_KPROBES is not set
 CONFIG_IA64_GRANULE_16MB=y
 # CONFIG_IA64_GRANULE_64MB is not set
 # CONFIG_IA64_PRINT_HAZARDS is not set
@@ -1215,7 +1298,7 @@ CONFIG_CRYPTO=y
 # CONFIG_CRYPTO_HMAC is not set
 # CONFIG_CRYPTO_NULL is not set
 # CONFIG_CRYPTO_MD4 is not set
-CONFIG_CRYPTO_MD5=m
+CONFIG_CRYPTO_MD5=y
 # CONFIG_CRYPTO_SHA1 is not set
 # CONFIG_CRYPTO_SHA256 is not set
 # CONFIG_CRYPTO_SHA512 is not set
diff --git a/arch/ia64/hp/common/hwsw_iommu.c b/arch/ia64/hp/common/hwsw_iommu.c
index 1ba02baf2f94..a5a5637507be 100644
--- a/arch/ia64/hp/common/hwsw_iommu.c
+++ b/arch/ia64/hp/common/hwsw_iommu.c
@@ -17,7 +17,7 @@
 #include <asm/machvec.h>
 
 /* swiotlb declarations & definitions: */
-extern void swiotlb_init_with_default_size (size_t size);
+extern int swiotlb_late_init_with_default_size (size_t size);
 extern ia64_mv_dma_alloc_coherent       swiotlb_alloc_coherent;
 extern ia64_mv_dma_free_coherent        swiotlb_free_coherent;
 extern ia64_mv_dma_map_single           swiotlb_map_single;
@@ -67,7 +67,16 @@ void
 hwsw_init (void)
 {
         /* default to a smallish 2MB sw I/O TLB */
-        swiotlb_init_with_default_size (2 * (1<<20));
+        if (swiotlb_late_init_with_default_size (2 * (1<<20)) != 0) {
+#ifdef CONFIG_IA64_GENERIC
+                /* Better to have normal DMA than panic */
+                printk(KERN_WARNING "%s: Failed to initialize software I/O TLB,"
+                       " reverting to hpzx1 platform vector\n", __FUNCTION__);
+                machvec_init("hpzx1");
+#else
+                panic("Unable to initialize software I/O TLB services");
+#endif
+        }
 }
 
 void *
diff --git a/arch/ia64/hp/common/sba_iommu.c b/arch/ia64/hp/common/sba_iommu.c
index 21bffba78b6d..bdccd0b1eb60 100644
--- a/arch/ia64/hp/common/sba_iommu.c
+++ b/arch/ia64/hp/common/sba_iommu.c
@@ -2028,9 +2028,40 @@ static struct acpi_driver acpi_sba_ioc_driver = {
 static int __init
 sba_init(void)
 {
+        if (!ia64_platform_is("hpzx1") && !ia64_platform_is("hpzx1_swiotlb"))
+                return 0;
+
         acpi_bus_register_driver(&acpi_sba_ioc_driver);
-        if (!ioc_list)
+        if (!ioc_list) {
+#ifdef CONFIG_IA64_GENERIC
+                extern int swiotlb_late_init_with_default_size (size_t size);
+
+                /*
+                 * If we didn't find something sba_iommu can claim, we
+                 * need to setup the swiotlb and switch to the dig machvec.
+                 */
+                if (swiotlb_late_init_with_default_size(64 * (1<<20)) != 0)
+                        panic("Unable to find SBA IOMMU or initialize "
+                              "software I/O TLB: Try machvec=dig boot option");
+                machvec_init("dig");
+#else
+                panic("Unable to find SBA IOMMU: Try a generic or DIG kernel");
+#endif
                 return 0;
+        }
+
+#if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_HP_ZX1_SWIOTLB)
+        /*
+         * hpzx1_swiotlb needs to have a fairly small swiotlb bounce
+         * buffer setup to support devices with smaller DMA masks than
+         * sba_iommu can handle.
+         */
+        if (ia64_platform_is("hpzx1_swiotlb")) {
+                extern void hwsw_init(void);
+
+                hwsw_init();
+        }
+#endif
 
 #ifdef CONFIG_PCI
         {
@@ -2048,18 +2079,6 @@ sba_init(void)
 
 subsys_initcall(sba_init); /* must be initialized after ACPI etc., but before any drivers... */
 
-extern void dig_setup(char**);
-/*
- * MAX_DMA_ADDRESS needs to be setup prior to paging_init to do any good,
- * so we use the platform_setup hook to fix it up.
- */
-void __init
-sba_setup(char **cmdline_p)
-{
-        MAX_DMA_ADDRESS = ~0UL;
-        dig_setup(cmdline_p);
-}
-
 static int __init
 nosbagart(char *str)
 {
diff --git a/arch/ia64/hp/sim/simscsi.c b/arch/ia64/hp/sim/simscsi.c
index a18983a3c934..a3fe97531134 100644
--- a/arch/ia64/hp/sim/simscsi.c
+++ b/arch/ia64/hp/sim/simscsi.c
@@ -205,10 +205,11 @@ simscsi_get_disk_size (int fd)
         char buf[512];
 
         /*
-         * This is a bit kludgey: the simulator doesn't provide a direct way of determining
-         * the disk size, so we do a binary search, assuming a maximum disk size of 4GB.
+         * This is a bit kludgey: the simulator doesn't provide a
+         * direct way of determining the disk size, so we do a binary
+         * search, assuming a maximum disk size of 128GB.
          */
-        for (bit = (4UL << 30)/512; bit != 0; bit >>= 1) {
+        for (bit = (128UL << 30)/512; bit != 0; bit >>= 1) {
                 req.addr = __pa(&buf);
                 req.len = sizeof(buf);
                 ia64_ssc(fd, 1, __pa(&req), ((sectors | bit) - 1)*512, SSC_READ);
@@ -225,8 +226,10 @@ simscsi_readwrite10 (struct scsi_cmnd *sc, int mode)
 {
         unsigned long offset;
 
-        offset = (  (sc->cmnd[2] << 24) | (sc->cmnd[3] << 16)
-                  | (sc->cmnd[4] <<  8) | (sc->cmnd[5] <<  0))*512;
+        offset = (((unsigned long)sc->cmnd[2] << 24) 
+                | ((unsigned long)sc->cmnd[3] << 16)
+                | ((unsigned long)sc->cmnd[4] <<  8) 
+                | ((unsigned long)sc->cmnd[5] <<  0))*512UL;
         if (sc->use_sg > 0)
                 simscsi_sg_readwrite(sc, mode, offset);
         else
diff --git a/arch/ia64/kernel/acpi.c b/arch/ia64/kernel/acpi.c
index 7e926471e4ec..9ad94ddf6687 100644
--- a/arch/ia64/kernel/acpi.c
+++ b/arch/ia64/kernel/acpi.c
@@ -838,7 +838,7 @@ EXPORT_SYMBOL(acpi_unmap_lsapic);
 #endif                          /* CONFIG_ACPI_HOTPLUG_CPU */
 
 #ifdef CONFIG_ACPI_NUMA
-acpi_status __devinit
+static acpi_status __devinit
 acpi_map_iosapic(acpi_handle handle, u32 depth, void *context, void **ret)
 {
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
@@ -890,7 +890,16 @@ acpi_map_iosapic(acpi_handle handle, u32 depth, void *context, void **ret)
         map_iosapic_to_node(gsi_base, node);
         return AE_OK;
 }
-#endif                          /* CONFIG_NUMA */
+
+static int __init
+acpi_map_iosapics (void)
+{
+        acpi_get_devices(NULL, acpi_map_iosapic, NULL, NULL);
+        return 0;
+}
+
+fs_initcall(acpi_map_iosapics);
+#endif                          /* CONFIG_ACPI_NUMA */
 
 int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base)
 {
diff --git a/arch/ia64/kernel/efi.c b/arch/ia64/kernel/efi.c
index 179f230816ed..f72ea6aebcb1 100644
--- a/arch/ia64/kernel/efi.c
+++ b/arch/ia64/kernel/efi.c
@@ -239,57 +239,30 @@ is_available_memory (efi_memory_desc_t *md)
         return 0;
 }
 
-/*
- * Trim descriptor MD so its starts at address START_ADDR.  If the descriptor covers
- * memory that is normally available to the kernel, issue a warning that some memory
- * is being ignored.
- */
-static void
-trim_bottom (efi_memory_desc_t *md, u64 start_addr)
-{
-        u64 num_skipped_pages;
+typedef struct kern_memdesc {
+        u64 attribute;
+        u64 start;
+        u64 num_pages;
+} kern_memdesc_t;
 
-        if (md->phys_addr >= start_addr || !md->num_pages)
-                return;
-
-        num_skipped_pages = (start_addr - md->phys_addr) >> EFI_PAGE_SHIFT;
-        if (num_skipped_pages > md->num_pages)
-                num_skipped_pages = md->num_pages;
-
-        if (is_available_memory(md))
-                printk(KERN_NOTICE "efi.%s: ignoring %luKB of memory at 0x%lx due to granule hole "
-                       "at 0x%lx\n", __FUNCTION__,
-                       (num_skipped_pages << EFI_PAGE_SHIFT) >> 10,
-                       md->phys_addr, start_addr - IA64_GRANULE_SIZE);
-        /*
-         * NOTE: Don't set md->phys_addr to START_ADDR because that could cause the memory
-         * descriptor list to become unsorted.  In such a case, md->num_pages will be
-         * zero, so the Right Thing will happen.
-         */
-        md->phys_addr += num_skipped_pages << EFI_PAGE_SHIFT;
-        md->num_pages -= num_skipped_pages;
-}
+static kern_memdesc_t *kern_memmap;
 
 static void
-trim_top (efi_memory_desc_t *md, u64 end_addr)
+walk (efi_freemem_callback_t callback, void *arg, u64 attr)
 {
-        u64 num_dropped_pages, md_end_addr;
-
-        md_end_addr = md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT);
-
-        if (md_end_addr <= end_addr || !md->num_pages)
-                return;
+        kern_memdesc_t *k;
+        u64 start, end, voff;
 
-        num_dropped_pages = (md_end_addr - end_addr) >> EFI_PAGE_SHIFT;
-        if (num_dropped_pages > md->num_pages)
-                num_dropped_pages = md->num_pages;
-
-        if (is_available_memory(md))
-                printk(KERN_NOTICE "efi.%s: ignoring %luKB of memory at 0x%lx due to granule hole "
-                       "at 0x%lx\n", __FUNCTION__,
-                       (num_dropped_pages << EFI_PAGE_SHIFT) >> 10,
-                       md->phys_addr, end_addr);
-        md->num_pages -= num_dropped_pages;
+        voff = (attr == EFI_MEMORY_WB) ? PAGE_OFFSET : __IA64_UNCACHED_OFFSET;
+        for (k = kern_memmap; k->start != ~0UL; k++) {
+                if (k->attribute != attr)
+                        continue;
+                start = PAGE_ALIGN(k->start);
+                end = (k->start + (k->num_pages << EFI_PAGE_SHIFT)) & PAGE_MASK;
+                if (start < end)
+                        if ((*callback)(start + voff, end + voff, arg) < 0)
+                                return;
+        }
 }
 
 /*
@@ -299,148 +272,19 @@ trim_top (efi_memory_desc_t *md, u64 end_addr)
 void
 efi_memmap_walk (efi_freemem_callback_t callback, void *arg)
 {
-        int prev_valid = 0;
-        struct range {
-                u64 start;
-                u64 end;
-        } prev, curr;
-        void *efi_map_start, *efi_map_end, *p, *q;
-        efi_memory_desc_t *md, *check_md;
-        u64 efi_desc_size, start, end, granule_addr, last_granule_addr, first_non_wb_addr = 0;
-        unsigned long total_mem = 0;
-
-        efi_map_start = __va(ia64_boot_param->efi_memmap);
-        efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
-        efi_desc_size = ia64_boot_param->efi_memdesc_size;
-
-        for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
-                md = p;
-
-                /* skip over non-WB memory descriptors; that's all we're interested in... */
-                if (!(md->attribute & EFI_MEMORY_WB))
-                        continue;
-
-                /*
-                 * granule_addr is the base of md's first granule.
-                 * [granule_addr - first_non_wb_addr) is guaranteed to
-                 * be contiguous WB memory.
-                 */
-                granule_addr = GRANULEROUNDDOWN(md->phys_addr);
-                first_non_wb_addr = max(first_non_wb_addr, granule_addr);
-
-                if (first_non_wb_addr < md->phys_addr) {
-                        trim_bottom(md, granule_addr + IA64_GRANULE_SIZE);
-                        granule_addr = GRANULEROUNDDOWN(md->phys_addr);
-                        first_non_wb_addr = max(first_non_wb_addr, granule_addr);
-                }
-
-                for (q = p; q < efi_map_end; q += efi_desc_size) {
-                        check_md = q;
-
-                        if ((check_md->attribute & EFI_MEMORY_WB) &&
-                            (check_md->phys_addr == first_non_wb_addr))
-                                first_non_wb_addr += check_md->num_pages << EFI_PAGE_SHIFT;
-                        else
-                                break;          /* non-WB or hole */
-                }
-
-                last_granule_addr = GRANULEROUNDDOWN(first_non_wb_addr);
-                if (last_granule_addr < md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT))
-                        trim_top(md, last_granule_addr);
-
-                if (is_available_memory(md)) {
-                        if (md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) >= max_addr) {
-                                if (md->phys_addr >= max_addr)
-                                        continue;
-                                md->num_pages = (max_addr - md->phys_addr) >> EFI_PAGE_SHIFT;
-                                first_non_wb_addr = max_addr;
-                        }
-
-                        if (total_mem >= mem_limit)
-                                continue;
-
-                        if (total_mem + (md->num_pages << EFI_PAGE_SHIFT) > mem_limit) {
-                                unsigned long limit_addr = md->phys_addr;
-
-                                limit_addr += mem_limit - total_mem;
-                                limit_addr = GRANULEROUNDDOWN(limit_addr);
-
-                                if (md->phys_addr > limit_addr)
-                                        continue;
-
-                                md->num_pages = (limit_addr - md->phys_addr) >>
-                                                EFI_PAGE_SHIFT;
-                                first_non_wb_addr = max_addr = md->phys_addr +
-                                              (md->num_pages << EFI_PAGE_SHIFT);
-                        }
-                        total_mem += (md->num_pages << EFI_PAGE_SHIFT);
-
-                        if (md->num_pages == 0)
-                                continue;
-
-                        curr.start = PAGE_OFFSET + md->phys_addr;
-                        curr.end   = curr.start + (md->num_pages << EFI_PAGE_SHIFT);
-
-                        if (!prev_valid) {
-                                prev = curr;
-                                prev_valid = 1;
-                        } else {
-                                if (curr.start < prev.start)
-                                        printk(KERN_ERR "Oops: EFI memory table not ordered!\n");
-
-                                if (prev.end == curr.start) {
-                                        /* merge two consecutive memory ranges */
-                                        prev.end = curr.end;
-                                } else {
-                                        start = PAGE_ALIGN(prev.start);
-                                        end = prev.end & PAGE_MASK;
-                                        if ((end > start) && (*callback)(start, end, arg) < 0)
-                                                return;
-                                        prev = curr;
-                                }
-                        }
-                }
-        }
-        if (prev_valid) {
-                start = PAGE_ALIGN(prev.start);
-                end = prev.end & PAGE_MASK;
-                if (end > start)
-                        (*callback)(start, end, arg);
-        }
+        walk(callback, arg, EFI_MEMORY_WB);
 }
 
 /*
- * Walk the EFI memory map to pull out leftover pages in the lower
- * memory regions which do not end up in the regular memory map and
- * stick them into the uncached allocator
- *
- * The regular walk function is significantly more complex than the
- * uncached walk which means it really doesn't make sense to try and
- * marge the two.
+ * Walks the EFI memory map and calls CALLBACK once for each EFI memory descriptor that
+ * has memory that is available for uncached allocator.
  */
-void __init
-efi_memmap_walk_uc (efi_freemem_callback_t callback)
+void
+efi_memmap_walk_uc (efi_freemem_callback_t callback, void *arg)
 {
-        void *efi_map_start, *efi_map_end, *p;
-        efi_memory_desc_t *md;
-        u64 efi_desc_size, start, end;
-
-        efi_map_start = __va(ia64_boot_param->efi_memmap);
-        efi_map_end = efi_map_start + ia64_boot_param->efi_memmap_size;
-        efi_desc_size = ia64_boot_param->efi_memdesc_size;
-
-        for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
-                md = p;
-                if (md->attribute == EFI_MEMORY_UC) {
-                        start = PAGE_ALIGN(md->phys_addr);
-                        end = PAGE_ALIGN((md->phys_addr+(md->num_pages << EFI_PAGE_SHIFT)) & PAGE_MASK);
-                        if ((*callback)(start, end, NULL) < 0)
-                                return;
-                }
-        }
+        walk(callback, arg, EFI_MEMORY_UC);
 }
 
-
 /*
  * Look for the PAL_CODE region reported by EFI and maps it using an
  * ITR to enable safe PAL calls in virtual mode.  See IA-64 Processor
@@ -862,3 +706,307 @@ efi_uart_console_only(void)
         printk(KERN_ERR "Malformed %s value\n", name);
         return 0;
 }
+
+#define efi_md_size(md) (md->num_pages << EFI_PAGE_SHIFT)
+
+static inline u64
+kmd_end(kern_memdesc_t *kmd)
+{
+        return (kmd->start + (kmd->num_pages << EFI_PAGE_SHIFT));
+}
+
+static inline u64
+efi_md_end(efi_memory_desc_t *md)
+{
+        return (md->phys_addr + efi_md_size(md));
+}
+
+static inline int
+efi_wb(efi_memory_desc_t *md)
+{
+        return (md->attribute & EFI_MEMORY_WB);
+}
+
+static inline int
+efi_uc(efi_memory_desc_t *md)
+{
+        return (md->attribute & EFI_MEMORY_UC);
+}
+
+/*
+ * Look for the first granule aligned memory descriptor memory
+ * that is big enough to hold EFI memory map. Make sure this
+ * descriptor is atleast granule sized so it does not get trimmed
+ */
+struct kern_memdesc *
+find_memmap_space (void)
+{
+        u64     contig_low=0, contig_high=0;
+        u64     as = 0, ae;
+        void *efi_map_start, *efi_map_end, *p, *q;
+        efi_memory_desc_t *md, *pmd = NULL, *check_md;
+        u64     space_needed, efi_desc_size;
+        unsigned long total_mem = 0;
+
+        efi_map_start = __va(ia64_boot_param->efi_memmap);
+        efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
+        efi_desc_size = ia64_boot_param->efi_memdesc_size;
+
+        /*
+         * Worst case: we need 3 kernel descriptors for each efi descriptor
+         * (if every entry has a WB part in the middle, and UC head and tail),
+         * plus one for the end marker.
+         */
+        space_needed = sizeof(kern_memdesc_t) *
+                (3 * (ia64_boot_param->efi_memmap_size/efi_desc_size) + 1);
+
+        for (p = efi_map_start; p < efi_map_end; pmd = md, p += efi_desc_size) {
+                md = p;
+                if (!efi_wb(md)) {
+                        continue;
+                }
+                if (pmd == NULL || !efi_wb(pmd) || efi_md_end(pmd) != md->phys_addr) {
+                        contig_low = GRANULEROUNDUP(md->phys_addr);
+                        contig_high = efi_md_end(md);
+                        for (q = p + efi_desc_size; q < efi_map_end; q += efi_desc_size) {
+                                check_md = q;
+                                if (!efi_wb(check_md))
+                                        break;
+                                if (contig_high != check_md->phys_addr)
+                                        break;
+                                contig_high = efi_md_end(check_md);
+                        }
+                        contig_high = GRANULEROUNDDOWN(contig_high);
+                }
+                if (!is_available_memory(md) || md->type == EFI_LOADER_DATA)
+                        continue;
+
+                /* Round ends inward to granule boundaries */
+                as = max(contig_low, md->phys_addr);
+                ae = min(contig_high, efi_md_end(md));
+
+                /* keep within max_addr= command line arg */
+                ae = min(ae, max_addr);
+                if (ae <= as)
+                        continue;
+
+                /* avoid going over mem= command line arg */
+                if (total_mem + (ae - as) > mem_limit)
+                        ae -= total_mem + (ae - as) - mem_limit;
+
+                if (ae <= as)
+                        continue;
+
+                if (ae - as > space_needed)
+                        break;
+        }
+        if (p >= efi_map_end)
+                panic("Can't allocate space for kernel memory descriptors");
+
+        return __va(as);
+}
+
+/*
+ * Walk the EFI memory map and gather all memory available for kernel
+ * to use.  We can allocate partial granules only if the unavailable
+ * parts exist, and are WB.
+ */
+void
+efi_memmap_init(unsigned long *s, unsigned long *e)
+{
+        struct kern_memdesc *k, *prev = 0;
+        u64     contig_low=0, contig_high=0;
+        u64     as, ae, lim;
+        void *efi_map_start, *efi_map_end, *p, *q;
+        efi_memory_desc_t *md, *pmd = NULL, *check_md;
+        u64     efi_desc_size;
+        unsigned long total_mem = 0;
+
+        k = kern_memmap = find_memmap_space();
+
+        efi_map_start = __va(ia64_boot_param->efi_memmap);
+        efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
+        efi_desc_size = ia64_boot_param->efi_memdesc_size;
+
+        for (p = efi_map_start; p < efi_map_end; pmd = md, p += efi_desc_size) {
+                md = p;
+                if (!efi_wb(md)) {
+                        if (efi_uc(md) && (md->type == EFI_CONVENTIONAL_MEMORY ||
+                                           md->type == EFI_BOOT_SERVICES_DATA)) {
+                                k->attribute = EFI_MEMORY_UC;
+                                k->start = md->phys_addr;
+                                k->num_pages = md->num_pages;
+                                k++;
+                        }
+                        continue;
+                }
+                if (pmd == NULL || !efi_wb(pmd) || efi_md_end(pmd) != md->phys_addr) {
+                        contig_low = GRANULEROUNDUP(md->phys_addr);
+                        contig_high = efi_md_end(md);
+                        for (q = p + efi_desc_size; q < efi_map_end; q += efi_desc_size) {
+                                check_md = q;
+                                if (!efi_wb(check_md))
+                                        break;
+                                if (contig_high != check_md->phys_addr)
+                                        break;
+                                contig_high = efi_md_end(check_md);
+                        }
+                        contig_high = GRANULEROUNDDOWN(contig_high);
+                }
+                if (!is_available_memory(md))
+                        continue;
+
+                /*
+                 * Round ends inward to granule boundaries
+                 * Give trimmings to uncached allocator
+                 */
+                if (md->phys_addr < contig_low) {
+                        lim = min(efi_md_end(md), contig_low);
+                        if (efi_uc(md)) {
+                                if (k > kern_memmap && (k-1)->attribute == EFI_MEMORY_UC &&
+                                    kmd_end(k-1) == md->phys_addr) {
+                                        (k-1)->num_pages += (lim - md->phys_addr) >> EFI_PAGE_SHIFT;
+                                } else {
+                                        k->attribute = EFI_MEMORY_UC;
+                                        k->start = md->phys_addr;
+                                        k->num_pages = (lim - md->phys_addr) >> EFI_PAGE_SHIFT;
+                                        k++;
+                                }
+                        }
+                        as = contig_low;
+                } else
+                        as = md->phys_addr;
+
+                if (efi_md_end(md) > contig_high) {
+                        lim = max(md->phys_addr, contig_high);
+                        if (efi_uc(md)) {
+                                if (lim == md->phys_addr && k > kern_memmap &&
+                                    (k-1)->attribute == EFI_MEMORY_UC &&
+                                    kmd_end(k-1) == md->phys_addr) {
+                                        (k-1)->num_pages += md->num_pages;
+                                } else {
+                                        k->attribute = EFI_MEMORY_UC;
+                                        k->start = lim;
+                                        k->num_pages = (efi_md_end(md) - lim) >> EFI_PAGE_SHIFT;
+                                        k++;
+                                }
+                        }
+                        ae = contig_high;
+                } else
+                        ae = efi_md_end(md);
+
+                /* keep within max_addr= command line arg */
+                ae = min(ae, max_addr);
+                if (ae <= as)
+                        continue;
+
+                /* avoid going over mem= command line arg */
+                if (total_mem + (ae - as) > mem_limit)
+                        ae -= total_mem + (ae - as) - mem_limit;
+
+                if (ae <= as)
+                        continue;
+                if (prev && kmd_end(prev) == md->phys_addr) {
+                        prev->num_pages += (ae - as) >> EFI_PAGE_SHIFT;
+                        total_mem += ae - as;
+                        continue;
+                }
+                k->attribute = EFI_MEMORY_WB;
+                k->start = as;
+                k->num_pages = (ae - as) >> EFI_PAGE_SHIFT;
+                total_mem += ae - as;
+                prev = k++;
+        }
+        k->start = ~0L; /* end-marker */
+
+        /* reserve the memory we are using for kern_memmap */
+        *s = (u64)kern_memmap;
+        *e = (u64)++k;
+}
+
+void
+efi_initialize_iomem_resources(struct resource *code_resource,
+                               struct resource *data_resource)
+{
+        struct resource *res;
+        void *efi_map_start, *efi_map_end, *p;
+        efi_memory_desc_t *md;
+        u64 efi_desc_size;
+        char *name;
+        unsigned long flags;
+
+        efi_map_start = __va(ia64_boot_param->efi_memmap);
+        efi_map_end   = efi_map_start + ia64_boot_param->efi_memmap_size;
+        efi_desc_size = ia64_boot_param->efi_memdesc_size;
+
+        res = NULL;
+
+        for (p = efi_map_start; p < efi_map_end; p += efi_desc_size) {
+                md = p;
+
+                if (md->num_pages == 0) /* should not happen */
+                        continue;
+
+                flags = IORESOURCE_MEM;
+                switch (md->type) {
+
+                        case EFI_MEMORY_MAPPED_IO:
+                        case EFI_MEMORY_MAPPED_IO_PORT_SPACE:
+                                continue;
+
+                        case EFI_LOADER_CODE:
+                        case EFI_LOADER_DATA:
+                        case EFI_BOOT_SERVICES_DATA:
+                        case EFI_BOOT_SERVICES_CODE:
+                        case EFI_CONVENTIONAL_MEMORY:
+                                if (md->attribute & EFI_MEMORY_WP) {
+                                        name = "System ROM";
+                                        flags |= IORESOURCE_READONLY;
+                                } else {
+                                        name = "System RAM";
+                                }
+                                break;
+
+                        case EFI_ACPI_MEMORY_NVS:
+                                name = "ACPI Non-volatile Storage";
+                                flags |= IORESOURCE_BUSY;
+                                break;
+
+                        case EFI_UNUSABLE_MEMORY:
+                                name = "reserved";
+                                flags |= IORESOURCE_BUSY | IORESOURCE_DISABLED;
+                                break;
+
+                        case EFI_RESERVED_TYPE:
+                        case EFI_RUNTIME_SERVICES_CODE:
+                        case EFI_RUNTIME_SERVICES_DATA:
+                        case EFI_ACPI_RECLAIM_MEMORY:
+                        default:
+                                name = "reserved";
+                                flags |= IORESOURCE_BUSY;
+                                break;
+                }
+
+                if ((res = kcalloc(1, sizeof(struct resource), GFP_KERNEL)) == NULL) {
+                        printk(KERN_ERR "failed to alocate resource for iomem\n");
+                        return;
+                }
+
+                res->name = name;
+                res->start = md->phys_addr;
+                res->end = md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) - 1;
+                res->flags = flags;
+
+                if (insert_resource(&iomem_resource, res) < 0)
+                        kfree(res);
+                else {
+                        /*
+                         * We don't know which region contains
+                         * kernel data so we try it repeatedly and
+                         * let the resource manager test it.
+                         */
+                        insert_resource(res, code_resource);
+                        insert_resource(res, data_resource);
+                }
+        }
+}
diff --git a/arch/ia64/kernel/irq.c b/arch/ia64/kernel/irq.c
index 205d98028261..d33244c32759 100644
--- a/arch/ia64/kernel/irq.c
+++ b/arch/ia64/kernel/irq.c
@@ -57,9 +57,9 @@ int show_interrupts(struct seq_file *p, void *v)
 
         if (i == 0) {
                 seq_printf(p, "           ");
-                for (j=0; j<NR_CPUS; j++)
-                        if (cpu_online(j))
-                                seq_printf(p, "CPU%d       ",j);
+                for_each_online_cpu(j) {
+                        seq_printf(p, "CPU%d       ",j);
+                }
                 seq_putc(p, '\n');
         }
 
@@ -72,9 +72,9 @@ int show_interrupts(struct seq_file *p, void *v)
 #ifndef CONFIG_SMP
                 seq_printf(p, "%10u ", kstat_irqs(i));
 #else
-                for (j = 0; j < NR_CPUS; j++)
-                        if (cpu_online(j))
-                                seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
+                for_each_online_cpu(j) {
+                        seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
+                }
 #endif
                 seq_printf(p, " %14s", irq_desc[i].handler->typename);
                 seq_printf(p, "  %s", action->name);
diff --git a/arch/ia64/kernel/mca.c b/arch/ia64/kernel/mca.c
index d0a5106fba24..52c47da17246 100644
--- a/arch/ia64/kernel/mca.c
+++ b/arch/ia64/kernel/mca.c
@@ -508,9 +508,7 @@ ia64_mca_wakeup_all(void)
         int cpu;
 
         /* Clear the Rendez checkin flag for all cpus */
-        for(cpu = 0; cpu < NR_CPUS; cpu++) {
-                if (!cpu_online(cpu))
-                        continue;
+        for_each_online_cpu(cpu) {
                 if (ia64_mc_info.imi_rendez_checkin[cpu] == IA64_MCA_RENDEZ_CHECKIN_DONE)
                         ia64_mca_wakeup(cpu);
         }
diff --git a/arch/ia64/kernel/module.c b/arch/ia64/kernel/module.c
index f1aca7cffd12..7a2f0a798d12 100644
--- a/arch/ia64/kernel/module.c
+++ b/arch/ia64/kernel/module.c
@@ -947,8 +947,8 @@ void
 percpu_modcopy (void *pcpudst, const void *src, unsigned long size)
 {
         unsigned int i;
-        for (i = 0; i < NR_CPUS; i++)
-                if (cpu_possible(i))
-                        memcpy(pcpudst + __per_cpu_offset[i], src, size);
+        for_each_cpu(i) {
+                memcpy(pcpudst + __per_cpu_offset[i], src, size);
+        }
 }
 #endif /* CONFIG_SMP */
diff --git a/arch/ia64/kernel/patch.c b/arch/ia64/kernel/patch.c
index 367804a605fa..6a4ac7d70b35 100644
--- a/arch/ia64/kernel/patch.c
+++ b/arch/ia64/kernel/patch.c
@@ -64,22 +64,30 @@ ia64_patch (u64 insn_addr, u64 mask, u64 val)
 void
 ia64_patch_imm64 (u64 insn_addr, u64 val)
 {
-        ia64_patch(insn_addr,
+        /* The assembler may generate offset pointing to either slot 1
+           or slot 2 for a long (2-slot) instruction, occupying slots 1
+           and 2.  */
+        insn_addr &= -16UL;
+        ia64_patch(insn_addr + 2,
                    0x01fffefe000UL, (  ((val & 0x8000000000000000UL) >> 27) /* bit 63 -> 36 */
                                      | ((val & 0x0000000000200000UL) <<  0) /* bit 21 -> 21 */
                                      | ((val & 0x00000000001f0000UL) <<  6) /* bit 16 -> 22 */
                                      | ((val & 0x000000000000ff80UL) << 20) /* bit  7 -> 27 */
                                      | ((val & 0x000000000000007fUL) << 13) /* bit  0 -> 13 */));
-        ia64_patch(insn_addr - 1, 0x1ffffffffffUL, val >> 22);
+        ia64_patch(insn_addr + 1, 0x1ffffffffffUL, val >> 22);
 }
 
 void
 ia64_patch_imm60 (u64 insn_addr, u64 val)
 {
-        ia64_patch(insn_addr,
+        /* The assembler may generate offset pointing to either slot 1
+           or slot 2 for a long (2-slot) instruction, occupying slots 1
+           and 2.  */
+        insn_addr &= -16UL;
+        ia64_patch(insn_addr + 2,
                    0x011ffffe000UL, (  ((val & 0x0800000000000000UL) >> 23) /* bit 59 -> 36 */
                                      | ((val & 0x00000000000fffffUL) << 13) /* bit  0 -> 13 */));
-        ia64_patch(insn_addr - 1, 0x1fffffffffcUL, val >> 18);
+        ia64_patch(insn_addr + 1, 0x1fffffffffcUL, val >> 18);
 }
 
 /*
diff --git a/arch/ia64/kernel/ptrace.c b/arch/ia64/kernel/ptrace.c
index bbb8bc7c0552..4b19d0410632 100644
--- a/arch/ia64/kernel/ptrace.c
+++ b/arch/ia64/kernel/ptrace.c
@@ -587,8 +587,9 @@ thread_matches (struct task_struct *thread, unsigned long addr)
 static struct task_struct *
 find_thread_for_addr (struct task_struct *child, unsigned long addr)
 {
-        struct task_struct *g, *p;
+        struct task_struct *p;
         struct mm_struct *mm;
+        struct list_head *this, *next;
         int mm_users;
 
         if (!(mm = get_task_mm(child)))
@@ -600,28 +601,21 @@ find_thread_for_addr (struct task_struct *child, unsigned long addr)
                 goto out;               /* not multi-threaded */
 
         /*
-         * First, traverse the child's thread-list.  Good for scalability with
-         * NPTL-threads.
+         * Traverse the current process' children list.  Every task that
+         * one attaches to becomes a child.  And it is only attached children
+         * of the debugger that are of interest (ptrace_check_attach checks
+         * for this).
          */
-        p = child;
-        do {
-                if (thread_matches(p, addr)) {
-                        child = p;
-                        goto out;
-                }
-                if (mm_users-- <= 1)
-                        goto out;
-        } while ((p = next_thread(p)) != child);
-
-        do_each_thread(g, p) {
-                if (child->mm != mm)
+        list_for_each_safe(this, next, &current->children) {
+                p = list_entry(this, struct task_struct, sibling);
+                if (p->mm != mm)
                         continue;
-
                 if (thread_matches(p, addr)) {
                         child = p;
                         goto out;
                 }
-        } while_each_thread(g, p);
+        }
+
   out:
         mmput(mm);
         return child;
diff --git a/arch/ia64/kernel/setup.c b/arch/ia64/kernel/setup.c
index 1f5c26dbe705..fc56ca2da358 100644
--- a/arch/ia64/kernel/setup.c
+++ b/arch/ia64/kernel/setup.c
@@ -78,6 +78,19 @@ struct screen_info screen_info;
 unsigned long vga_console_iobase;
 unsigned long vga_console_membase;
 
+static struct resource data_resource = {
+        .name   = "Kernel data",
+        .flags  = IORESOURCE_BUSY | IORESOURCE_MEM
+};
+
+static struct resource code_resource = {
+        .name   = "Kernel code",
+        .flags  = IORESOURCE_BUSY | IORESOURCE_MEM
+};
+extern void efi_initialize_iomem_resources(struct resource *,
+                struct resource *);
+extern char _text[], _end[], _etext[];
+
 unsigned long ia64_max_cacheline_size;
 unsigned long ia64_iobase;      /* virtual address for I/O accesses */
 EXPORT_SYMBOL(ia64_iobase);
@@ -171,6 +184,22 @@ sort_regions (struct rsvd_region *rsvd_region, int max)
         }
 }
 
+/*
+ * Request address space for all standard resources
+ */
+static int __init register_memory(void)
+{
+        code_resource.start = ia64_tpa(_text);
+        code_resource.end   = ia64_tpa(_etext) - 1;
+        data_resource.start = ia64_tpa(_etext);
+        data_resource.end   = ia64_tpa(_end) - 1;
+        efi_initialize_iomem_resources(&code_resource, &data_resource);
+
+        return 0;
+}
+
+__initcall(register_memory);
+
 /**
  * reserve_memory - setup reserved memory areas
  *
@@ -211,6 +240,9 @@ reserve_memory (void)
         }
 #endif
 
+        efi_memmap_init(&rsvd_region[n].start, &rsvd_region[n].end);
+        n++;
+
         /* end of memory marker */
         rsvd_region[n].start = ~0UL;
         rsvd_region[n].end   = ~0UL;
@@ -244,28 +276,31 @@ find_initrd (void)
 static void __init
 io_port_init (void)
 {
-        extern unsigned long ia64_iobase;
         unsigned long phys_iobase;
 
         /*
-         *  Set `iobase' to the appropriate address in region 6 (uncached access range).
+         * Set `iobase' based on the EFI memory map or, failing that, the
+         * value firmware left in ar.k0.
          *
-         *  The EFI memory map is the "preferred" location to get the I/O port space base,
-         *  rather the relying on AR.KR0. This should become more clear in future SAL
-         *  specs. We'll fall back to getting it out of AR.KR0 if no appropriate entry is
-         *  found in the memory map.
+         * Note that in ia32 mode, IN/OUT instructions use ar.k0 to compute
+         * the port's virtual address, so ia32_load_state() loads it with a
+         * user virtual address.  But in ia64 mode, glibc uses the
+         * *physical* address in ar.k0 to mmap the appropriate area from
+         * /dev/mem, and the inX()/outX() interfaces use MMIO.  In both
+         * cases, user-mode can only use the legacy 0-64K I/O port space.
+         *
+         * ar.k0 is not involved in kernel I/O port accesses, which can use
+         * any of the I/O port spaces and are done via MMIO using the
+         * virtual mmio_base from the appropriate io_space[].
          */
         phys_iobase = efi_get_iobase();
-        if (phys_iobase)
-                /* set AR.KR0 since this is all we use it for anyway */
-                ia64_set_kr(IA64_KR_IO_BASE, phys_iobase);
-        else {
+        if (!phys_iobase) {
                 phys_iobase = ia64_get_kr(IA64_KR_IO_BASE);
-                printk(KERN_INFO "No I/O port range found in EFI memory map, falling back "
-                       "to AR.KR0\n");
-                printk(KERN_INFO "I/O port base = 0x%lx\n", phys_iobase);
+                printk(KERN_INFO "No I/O port range found in EFI memory map, "
+                        "falling back to AR.KR0 (0x%lx)\n", phys_iobase);
         }
         ia64_iobase = (unsigned long) ioremap(phys_iobase, 0);
+        ia64_set_kr(IA64_KR_IO_BASE, __pa(ia64_iobase));
 
         /* setup legacy IO port space */
         io_space[0].mmio_base = ia64_iobase;
@@ -526,7 +561,7 @@ show_cpuinfo (struct seq_file *m, void *v)
                    c->itc_freq / 1000000, c->itc_freq % 1000000,
                    lpj*HZ/500000, (lpj*HZ/5000) % 100);
 #ifdef CONFIG_SMP
-        seq_printf(m, "siblings   : %u\n", c->num_log);
+        seq_printf(m, "siblings   : %u\n", cpus_weight(cpu_core_map[cpunum]));
         if (c->threads_per_core > 1 || c->cores_per_socket > 1)
                 seq_printf(m,
                            "physical id: %u\n"
diff --git a/arch/ia64/kernel/smp.c b/arch/ia64/kernel/smp.c
index 0166a9847095..657ac99a451c 100644
--- a/arch/ia64/kernel/smp.c
+++ b/arch/ia64/kernel/smp.c
@@ -185,8 +185,8 @@ send_IPI_allbutself (int op)
 {
         unsigned int i;
 
-        for (i = 0; i < NR_CPUS; i++) {
-                if (cpu_online(i) && i != smp_processor_id())
+        for_each_online_cpu(i) {
+                if (i != smp_processor_id())
                         send_IPI_single(i, op);
         }
 }
@@ -199,9 +199,9 @@ send_IPI_all (int op)
 {
         int i;
 
-        for (i = 0; i < NR_CPUS; i++)
-                if (cpu_online(i))
-                        send_IPI_single(i, op);
+        for_each_online_cpu(i) {
+                send_IPI_single(i, op);
+        }
 }
 
 /*
diff --git a/arch/ia64/kernel/smpboot.c b/arch/ia64/kernel/smpboot.c
index 7d72c0d872b3..400a48987124 100644
--- a/arch/ia64/kernel/smpboot.c
+++ b/arch/ia64/kernel/smpboot.c
@@ -694,9 +694,9 @@ smp_cpus_done (unsigned int dummy)
          * Allow the user to impress friends.
          */
 
-        for (cpu = 0; cpu < NR_CPUS; cpu++)
-                if (cpu_online(cpu))
-                        bogosum += cpu_data(cpu)->loops_per_jiffy;
+        for_each_online_cpu(cpu) {
+                bogosum += cpu_data(cpu)->loops_per_jiffy;
+        }
 
         printk(KERN_INFO "Total of %d processors activated (%lu.%02lu BogoMIPS).\n",
                (int)num_online_cpus(), bogosum/(500000/HZ), (bogosum/(5000/HZ))%100);
diff --git a/arch/ia64/kernel/uncached.c b/arch/ia64/kernel/uncached.c
index 4e9d06c48a8b..c6d40446c2c4 100644
--- a/arch/ia64/kernel/uncached.c
+++ b/arch/ia64/kernel/uncached.c
@@ -205,23 +205,18 @@ EXPORT_SYMBOL(uncached_free_page);
 static int __init
 uncached_build_memmap(unsigned long start, unsigned long end, void *arg)
 {
-        long length;
-        unsigned long vstart, vend;
+        long length = end - start;
         int node;
 
-        length = end - start;
-        vstart = start + __IA64_UNCACHED_OFFSET;
-        vend = end + __IA64_UNCACHED_OFFSET;
-
         dprintk(KERN_ERR "uncached_build_memmap(%lx %lx)\n", start, end);
 
-        memset((char *)vstart, 0, length);
+        memset((char *)start, 0, length);
 
-        node = paddr_to_nid(start);
+        node = paddr_to_nid(start - __IA64_UNCACHED_OFFSET);
 
-        for (; vstart < vend ; vstart += PAGE_SIZE) {
-                dprintk(KERN_INFO "sticking %lx into the pool!\n", vstart);
-                gen_pool_free(uncached_pool[node], vstart, PAGE_SIZE);
+        for (; start < end ; start += PAGE_SIZE) {
+                dprintk(KERN_INFO "sticking %lx into the pool!\n", start);
+                gen_pool_free(uncached_pool[node], start, PAGE_SIZE);
         }
 
         return 0;
diff --git a/arch/ia64/lib/swiotlb.c b/arch/ia64/lib/swiotlb.c
index 3ebbb3c8ba36..96edcc0fdcd9 100644
--- a/arch/ia64/lib/swiotlb.c
+++ b/arch/ia64/lib/swiotlb.c
@@ -49,6 +49,15 @@
  */
 #define IO_TLB_SHIFT 11
 
+#define SLABS_PER_PAGE (1 << (PAGE_SHIFT - IO_TLB_SHIFT))
+
+/*
+ * Minimum IO TLB size to bother booting with.  Systems with mainly
+ * 64bit capable cards will only lightly use the swiotlb.  If we can't
+ * allocate a contiguous 1MB, we're probably in trouble anyway.
+ */
+#define IO_TLB_MIN_SLABS ((1<<20) >> IO_TLB_SHIFT)
+
 int swiotlb_force;
 
 /*
@@ -154,6 +163,99 @@ swiotlb_init (void)
         swiotlb_init_with_default_size(64 * (1<<20));   /* default to 64MB */
 }
 
+/*
+ * Systems with larger DMA zones (those that don't support ISA) can
+ * initialize the swiotlb later using the slab allocator if needed.
+ * This should be just like above, but with some error catching.
+ */
+int
+swiotlb_late_init_with_default_size (size_t default_size)
+{
+        unsigned long i, req_nslabs = io_tlb_nslabs;
+        unsigned int order;
+
+        if (!io_tlb_nslabs) {
+                io_tlb_nslabs = (default_size >> IO_TLB_SHIFT);
+                io_tlb_nslabs = ALIGN(io_tlb_nslabs, IO_TLB_SEGSIZE);
+        }
+
+        /*
+         * Get IO TLB memory from the low pages
+         */
+        order = get_order(io_tlb_nslabs * (1 << IO_TLB_SHIFT));
+        io_tlb_nslabs = SLABS_PER_PAGE << order;
+
+        while ((SLABS_PER_PAGE << order) > IO_TLB_MIN_SLABS) {
+                io_tlb_start = (char *)__get_free_pages(GFP_DMA | __GFP_NOWARN,
+                                                        order);
+                if (io_tlb_start)
+                        break;
+                order--;
+        }
+
+        if (!io_tlb_start)
+                goto cleanup1;
+
+        if (order != get_order(io_tlb_nslabs * (1 << IO_TLB_SHIFT))) {
+                printk(KERN_WARNING "Warning: only able to allocate %ld MB "
+                       "for software IO TLB\n", (PAGE_SIZE << order) >> 20);
+                io_tlb_nslabs = SLABS_PER_PAGE << order;
+        }
+        io_tlb_end = io_tlb_start + io_tlb_nslabs * (1 << IO_TLB_SHIFT);
+        memset(io_tlb_start, 0, io_tlb_nslabs * (1 << IO_TLB_SHIFT));
+
+        /*
+         * Allocate and initialize the free list array.  This array is used
+         * to find contiguous free memory regions of size up to IO_TLB_SEGSIZE
+         * between io_tlb_start and io_tlb_end.
+         */
+        io_tlb_list = (unsigned int *)__get_free_pages(GFP_KERNEL,
+                                      get_order(io_tlb_nslabs * sizeof(int)));
+        if (!io_tlb_list)
+                goto cleanup2;
+
+        for (i = 0; i < io_tlb_nslabs; i++)
+                io_tlb_list[i] = IO_TLB_SEGSIZE - OFFSET(i, IO_TLB_SEGSIZE);
+        io_tlb_index = 0;
+
+        io_tlb_orig_addr = (unsigned char **)__get_free_pages(GFP_KERNEL,
+                                   get_order(io_tlb_nslabs * sizeof(char *)));
+        if (!io_tlb_orig_addr)
+                goto cleanup3;
+
+        memset(io_tlb_orig_addr, 0, io_tlb_nslabs * sizeof(char *));
+
+        /*
+         * Get the overflow emergency buffer
+         */
+        io_tlb_overflow_buffer = (void *)__get_free_pages(GFP_DMA,
+                                                  get_order(io_tlb_overflow));
+        if (!io_tlb_overflow_buffer)
+                goto cleanup4;
+
+        printk(KERN_INFO "Placing %ldMB software IO TLB between 0x%lx - "
+               "0x%lx\n", (io_tlb_nslabs * (1 << IO_TLB_SHIFT)) >> 20,
+               virt_to_phys(io_tlb_start), virt_to_phys(io_tlb_end));
+
+        return 0;
+
+cleanup4:
+        free_pages((unsigned long)io_tlb_orig_addr, get_order(io_tlb_nslabs *
+                                                              sizeof(char *)));
+        io_tlb_orig_addr = NULL;
+cleanup3:
+        free_pages((unsigned long)io_tlb_list, get_order(io_tlb_nslabs *
+                                                         sizeof(int)));
+        io_tlb_list = NULL;
+        io_tlb_end = NULL;
+cleanup2:
+        free_pages((unsigned long)io_tlb_start, order);
+        io_tlb_start = NULL;
+cleanup1:
+        io_tlb_nslabs = req_nslabs;
+        return -ENOMEM;
+}
+
 static inline int
 address_needs_mapping(struct device *hwdev, dma_addr_t addr)
 {
diff --git a/arch/ia64/mm/Makefile b/arch/ia64/mm/Makefile
index 7078f67887ec..d78d20f0a0f0 100644
--- a/arch/ia64/mm/Makefile
+++ b/arch/ia64/mm/Makefile
@@ -7,6 +7,5 @@ obj-y := init.o fault.o tlb.o extable.o
 obj-$(CONFIG_HUGETLB_PAGE) += hugetlbpage.o
 obj-$(CONFIG_NUMA)         += numa.o
 obj-$(CONFIG_DISCONTIGMEM) += discontig.o
-ifndef CONFIG_DISCONTIGMEM
-obj-y += contig.o
-endif
+obj-$(CONFIG_SPARSEMEM)    += discontig.o
+obj-$(CONFIG_FLATMEM)      += contig.o
diff --git a/arch/ia64/mm/contig.c b/arch/ia64/mm/contig.c
index 91a055f5731f..acaaec4e4681 100644
--- a/arch/ia64/mm/contig.c
+++ b/arch/ia64/mm/contig.c
@@ -269,7 +269,7 @@ paging_init (void)
         efi_memmap_walk(find_largest_hole, (u64 *)&max_gap);
         if (max_gap < LARGE_GAP) {
                 vmem_map = (struct page *) 0;
-                free_area_init_node(0, &contig_page_data, zones_size, 0,
+                free_area_init_node(0, NODE_DATA(0), zones_size, 0,
                                     zholes_size);
         } else {
                 unsigned long map_size;
@@ -282,7 +282,7 @@ paging_init (void)
                 efi_memmap_walk(create_mem_map_page_table, NULL);
 
                 NODE_DATA(0)->node_mem_map = vmem_map;
-                free_area_init_node(0, &contig_page_data, zones_size,
+                free_area_init_node(0, NODE_DATA(0), zones_size,
                                     0, zholes_size);
 
                 printk("Virtual mem_map starts at 0x%p\n", mem_map);
diff --git a/arch/ia64/mm/discontig.c b/arch/ia64/mm/discontig.c
index b5c90e548195..a3788fb84809 100644
--- a/arch/ia64/mm/discontig.c
+++ b/arch/ia64/mm/discontig.c
@@ -421,6 +421,37 @@ static void __init memory_less_nodes(void)
         return;
 }
 
+#ifdef CONFIG_SPARSEMEM
+/**
+ * register_sparse_mem - notify SPARSEMEM that this memory range exists.
+ * @start: physical start of range
+ * @end: physical end of range
+ * @arg: unused
+ *
+ * Simply calls SPARSEMEM to register memory section(s).
+ */
+static int __init register_sparse_mem(unsigned long start, unsigned long end,
+        void *arg)
+{
+        int nid;
+
+        start = __pa(start) >> PAGE_SHIFT;
+        end = __pa(end) >> PAGE_SHIFT;
+        nid = early_pfn_to_nid(start);
+        memory_present(nid, start, end);
+
+        return 0;
+}
+
+static void __init arch_sparse_init(void)
+{
+        efi_memmap_walk(register_sparse_mem, NULL);
+        sparse_init();
+}
+#else
+#define arch_sparse_init() do {} while (0)
+#endif
+
 /**
  * find_memory - walk the EFI memory map and setup the bootmem allocator
  *
@@ -528,8 +559,10 @@ void show_mem(void)
                 int shared = 0, cached = 0, reserved = 0;
                 printk("Node ID: %d\n", pgdat->node_id);
                 for(i = 0; i < pgdat->node_spanned_pages; i++) {
-                        struct page *page = pgdat_page_nr(pgdat, i);
-                        if (!ia64_pfn_valid(pgdat->node_start_pfn+i))
+                        struct page *page;
+                        if (pfn_valid(pgdat->node_start_pfn + i))
+                                page = pfn_to_page(pgdat->node_start_pfn + i);
+                        else
                                 continue;
                         if (PageReserved(page))
                                 reserved++;
@@ -648,12 +681,16 @@ void __init paging_init(void)
 
         max_dma = virt_to_phys((void *) MAX_DMA_ADDRESS) >> PAGE_SHIFT;
 
+        arch_sparse_init();
+
         efi_memmap_walk(filter_rsvd_memory, count_node_pages);
 
+#ifdef CONFIG_VIRTUAL_MEM_MAP
         vmalloc_end -= PAGE_ALIGN(max_low_pfn * sizeof(struct page));
         vmem_map = (struct page *) vmalloc_end;
         efi_memmap_walk(create_mem_map_page_table, NULL);
         printk("Virtual mem_map starts at 0x%p\n", vmem_map);
+#endif
 
         for_each_online_node(node) {
                 memset(zones_size, 0, sizeof(zones_size));
@@ -690,7 +727,9 @@ void __init paging_init(void)
 
                 pfn_offset = mem_data[node].min_pfn;
 
+#ifdef CONFIG_VIRTUAL_MEM_MAP
                 NODE_DATA(node)->node_mem_map = vmem_map + pfn_offset;
+#endif
                 free_area_init_node(node, NODE_DATA(node), zones_size,
                                     pfn_offset, zholes_size);
         }
diff --git a/arch/ia64/mm/init.c b/arch/ia64/mm/init.c
index 1281c609ee98..98246acd4991 100644
--- a/arch/ia64/mm/init.c
+++ b/arch/ia64/mm/init.c
@@ -593,7 +593,7 @@ mem_init (void)
         platform_dma_init();
 #endif
 
-#ifndef CONFIG_DISCONTIGMEM
+#ifdef CONFIG_FLATMEM
         if (!mem_map)
                 BUG();
         max_mapnr = max_low_pfn;
diff --git a/arch/ia64/mm/numa.c b/arch/ia64/mm/numa.c
index 77118bbf3d8b..4e5c8b36ad93 100644
--- a/arch/ia64/mm/numa.c
+++ b/arch/ia64/mm/numa.c
@@ -47,3 +47,27 @@ paddr_to_nid(unsigned long paddr)
 
         return (i < num_node_memblks) ? node_memblk[i].nid : (num_node_memblks ? -1 : 0);
 }
+
+#if defined(CONFIG_SPARSEMEM) && defined(CONFIG_NUMA)
+/*
+ * Because of holes evaluate on section limits.
+ * If the section of memory exists, then return the node where the section
+ * resides.  Otherwise return node 0 as the default.  This is used by
+ * SPARSEMEM to allocate the SPARSEMEM sectionmap on the NUMA node where
+ * the section resides.
+ */
+int early_pfn_to_nid(unsigned long pfn)
+{
+        int i, section = pfn >> PFN_SECTION_SHIFT, ssec, esec;
+
+        for (i = 0; i < num_node_memblks; i++) {
+                ssec = node_memblk[i].start_paddr >> PA_SECTION_SHIFT;
+                esec = (node_memblk[i].start_paddr + node_memblk[i].size +
+                        ((1L << PA_SECTION_SHIFT) - 1)) >> PA_SECTION_SHIFT;
+                if (section >= ssec && section < esec)
+                        return node_memblk[i].nid;
+        }
+
+        return 0;
+}
+#endif
diff --git a/arch/ia64/mm/tlb.c b/arch/ia64/mm/tlb.c
index 464557e4ed82..c93e0f2b5fea 100644
--- a/arch/ia64/mm/tlb.c
+++ b/arch/ia64/mm/tlb.c
@@ -77,19 +77,25 @@ wrap_mmu_context (struct mm_struct *mm)
         /* can't call flush_tlb_all() here because of race condition with O(1) scheduler [EF] */
         {
                 int cpu = get_cpu(); /* prevent preemption/migration */
-                for (i = 0; i < NR_CPUS; ++i)
-                        if (cpu_online(i) && (i != cpu))
+                for_each_online_cpu(i) {
+                        if (i != cpu)
                                 per_cpu(ia64_need_tlb_flush, i) = 1;
+                }
                 put_cpu();
         }
         local_flush_tlb_all();
 }
 
 void
-ia64_global_tlb_purge (unsigned long start, unsigned long end, unsigned long nbits)
+ia64_global_tlb_purge (struct mm_struct *mm, unsigned long start, unsigned long end, unsigned long nbits)
 {
         static DEFINE_SPINLOCK(ptcg_lock);
 
+        if (mm != current->active_mm) {
+                flush_tlb_all();
+                return;
+        }
+
         /* HW requires global serialization of ptc.ga.  */
         spin_lock(&ptcg_lock);
         {
@@ -135,15 +141,12 @@ flush_tlb_range (struct vm_area_struct *vma, unsigned long start, unsigned long
         unsigned long size = end - start;
         unsigned long nbits;
 
+#ifndef CONFIG_SMP
         if (mm != current->active_mm) {
-                /* this does happen, but perhaps it's not worth optimizing for? */
-#ifdef CONFIG_SMP
-                flush_tlb_all();
-#else
                 mm->context = 0;
-#endif
                 return;
         }
+#endif
 
         nbits = ia64_fls(size + 0xfff);
         while (unlikely (((1UL << nbits) & purge.mask) == 0) && (nbits < purge.max_bits))
@@ -153,7 +156,7 @@ flush_tlb_range (struct vm_area_struct *vma, unsigned long start, unsigned long
         start &= ~((1UL << nbits) - 1);
 
 # ifdef CONFIG_SMP
-        platform_global_tlb_purge(start, end, nbits);
+        platform_global_tlb_purge(mm, start, end, nbits);
 # else
         do {
                 ia64_ptcl(start, (nbits<<2));
diff --git a/arch/ia64/pci/pci.c b/arch/ia64/pci/pci.c
index 9b5de589b82f..017cfc3f4789 100644
--- a/arch/ia64/pci/pci.c
+++ b/arch/ia64/pci/pci.c
@@ -120,29 +120,6 @@ struct pci_ops pci_root_ops = {
         .write = pci_write,
 };
 
-#ifdef CONFIG_NUMA
-extern acpi_status acpi_map_iosapic(acpi_handle, u32, void *, void **);
-static void acpi_map_iosapics(void)
-{
-        acpi_get_devices(NULL, acpi_map_iosapic, NULL, NULL);
-}
-#else
-static void acpi_map_iosapics(void)
-{
-        return;
-}
-#endif /* CONFIG_NUMA */
-
-static int __init
-pci_acpi_init (void)
-{
-        acpi_map_iosapics();
-
-        return 0;
-}
-
-subsys_initcall(pci_acpi_init);
-
 /* Called by ACPI when it finds a new root bus.  */
 
 static struct pci_controller * __devinit
@@ -191,6 +168,29 @@ add_io_space (struct acpi_resource_address64 *addr)
         return IO_SPACE_BASE(i);
 }
 
+static acpi_status __devinit resource_to_window(struct acpi_resource *resource,
+        struct acpi_resource_address64 *addr)
+{
+        acpi_status status;
+
+        /*
+         * We're only interested in _CRS descriptors that are
+         *      - address space descriptors for memory or I/O space
+         *      - non-zero size
+         *      - producers, i.e., the address space is routed downstream,
+         *        not consumed by the bridge itself
+         */
+        status = acpi_resource_to_address64(resource, addr);
+        if (ACPI_SUCCESS(status) &&
+            (addr->resource_type == ACPI_MEMORY_RANGE ||
+             addr->resource_type == ACPI_IO_RANGE) &&
+            addr->address_length &&
+            addr->producer_consumer == ACPI_PRODUCER)
+                return AE_OK;
+
+        return AE_ERROR;
+}
+
 static acpi_status __devinit
 count_window (struct acpi_resource *resource, void *data)
 {
@@ -198,11 +198,9 @@ count_window (struct acpi_resource *resource, void *data)
         struct acpi_resource_address64 addr;
         acpi_status status;
 
-        status = acpi_resource_to_address64(resource, &addr);
+        status = resource_to_window(resource, &addr);
         if (ACPI_SUCCESS(status))
-                if (addr.resource_type == ACPI_MEMORY_RANGE ||
-                    addr.resource_type == ACPI_IO_RANGE)
-                        (*windows)++;
+                (*windows)++;
 
         return AE_OK;
 }
@@ -221,13 +219,11 @@ static __devinit acpi_status add_window(struct acpi_resource *res, void *data)
         unsigned long flags, offset = 0;
         struct resource *root;
 
-        status = acpi_resource_to_address64(res, &addr);
+        /* Return AE_OK for non-window resources to keep scanning for more */
+        status = resource_to_window(res, &addr);
         if (!ACPI_SUCCESS(status))
                 return AE_OK;
 
-        if (!addr.address_length)
-                return AE_OK;
-
         if (addr.resource_type == ACPI_MEMORY_RANGE) {
                 flags = IORESOURCE_MEM;
                 root = &iomem_resource;
diff --git a/arch/ia64/sn/kernel/bte.c b/arch/ia64/sn/kernel/bte.c
index 45854c637e9c..d71f4de44f79 100644
--- a/arch/ia64/sn/kernel/bte.c
+++ b/arch/ia64/sn/kernel/bte.c
@@ -87,7 +87,7 @@ bte_result_t bte_copy(u64 src, u64 dest, u64 len, u64 mode, void *notification)
         unsigned long irq_flags;
         unsigned long itc_end = 0;
         int nasid_to_try[MAX_NODES_TO_TRY];
-        int my_nasid = get_nasid();
+        int my_nasid = cpuid_to_nasid(raw_smp_processor_id());
         int bte_if_index, nasid_index;
         int bte_first, btes_per_node = BTES_PER_NODE;
 
diff --git a/arch/ia64/sn/kernel/io_init.c b/arch/ia64/sn/kernel/io_init.c
index 906622d9f933..b4f5053f5e1b 100644
--- a/arch/ia64/sn/kernel/io_init.c
+++ b/arch/ia64/sn/kernel/io_init.c
@@ -22,8 +22,6 @@
 #include "xtalk/hubdev.h"
 #include "xtalk/xwidgetdev.h"
 
-nasid_t master_nasid = INVALID_NASID;   /* Partition Master */
-
 static struct list_head sn_sysdata_list;
 
 /* sysdata list struct */
@@ -165,7 +163,7 @@ static void sn_fixup_ionodes(void)
          * Get SGI Specific HUB chipset information.
          * Inform Prom that this kernel can support domain bus numbering.
          */
-        for (i = 0; i < numionodes; i++) {
+        for (i = 0; i < num_cnodes; i++) {
                 hubdev = (struct hubdev_info *)(NODEPDA(i)->pdinfo);
                 nasid = cnodeid_to_nasid(i);
                 hubdev->max_segment_number = 0xffffffff;
diff --git a/arch/ia64/sn/kernel/setup.c b/arch/ia64/sn/kernel/setup.c
index 6f8c5883716b..0fb579ef18c2 100644
--- a/arch/ia64/sn/kernel/setup.c
+++ b/arch/ia64/sn/kernel/setup.c
@@ -59,8 +59,6 @@ DEFINE_PER_CPU(struct pda_s, pda_percpu);
 
 #define MAX_PHYS_MEMORY         (1UL << IA64_MAX_PHYS_BITS)     /* Max physical address supported */
 
-lboard_t *root_lboard[MAX_COMPACT_NODES];
-
 extern void bte_init_node(nodepda_t *, cnodeid_t);
 
 extern void sn_timer_init(void);
@@ -97,15 +95,15 @@ u8 sn_region_size;
 EXPORT_SYMBOL(sn_region_size);
 int sn_prom_type;       /* 0=hardware, 1=medusa/realprom, 2=medusa/fakeprom */
 
-short physical_node_map[MAX_PHYSNODE_ID];
+short physical_node_map[MAX_NUMALINK_NODES];
 static unsigned long sn_prom_features[MAX_PROM_FEATURE_SETS];
 
 EXPORT_SYMBOL(physical_node_map);
 
-int numionodes;
+int num_cnodes;
 
 static void sn_init_pdas(char **);
-static void scan_for_ionodes(void);
+static void build_cnode_tables(void);
 
 static nodepda_t *nodepdaindr[MAX_COMPACT_NODES];
 
@@ -140,19 +138,6 @@ char drive_info[4 * 16];
 #endif
 
 /*
- * Get nasid of current cpu early in boot before nodepda is initialized
- */
-static int
-boot_get_nasid(void)
-{
-        int nasid;
-
-        if (ia64_sn_get_sapic_info(get_sapicid(), &nasid, NULL, NULL))
-                BUG();
-        return nasid;
-}
-
-/*
  * This routine can only be used during init, since
  * smp_boot_data is an init data structure.
  * We have to use smp_boot_data.cpu_phys_id to find
@@ -223,7 +208,6 @@ void __init early_sn_setup(void)
 }
 
 extern int platform_intr_list[];
-extern nasid_t master_nasid;
 static int __initdata shub_1_1_found = 0;
 
 /*
@@ -269,7 +253,6 @@ static void __init sn_check_for_wars(void)
 void __init sn_setup(char **cmdline_p)
 {
         long status, ticks_per_sec, drift;
-        int pxm;
         u32 version = sn_sal_rev();
         extern void sn_cpu_init(void);
 
@@ -300,11 +283,10 @@ void __init sn_setup(char **cmdline_p)
 
         MAX_DMA_ADDRESS = PAGE_OFFSET + MAX_PHYS_MEMORY;
 
-        memset(physical_node_map, -1, sizeof(physical_node_map));
-        for (pxm = 0; pxm < MAX_PXM_DOMAINS; pxm++)
-                if (pxm_to_nid_map[pxm] != -1)
-                        physical_node_map[pxm_to_nasid(pxm)] =
-                            pxm_to_nid_map[pxm];
+        /*
+         * Build the tables for managing cnodes.
+         */
+        build_cnode_tables();
 
         /*
          * Old PROMs do not provide an ACPI FADT. Disable legacy keyboard
@@ -319,8 +301,6 @@ void __init sn_setup(char **cmdline_p)
 
         printk("SGI SAL version %x.%02x\n", version >> 8, version & 0x00FF);
 
-        master_nasid = boot_get_nasid();
-
         status =
             ia64_sal_freq_base(SAL_FREQ_BASE_REALTIME_CLOCK, &ticks_per_sec,
                                &drift);
@@ -378,15 +358,6 @@ static void __init sn_init_pdas(char **cmdline_p)
 {
         cnodeid_t cnode;
 
-        memset(sn_cnodeid_to_nasid, -1,
-                        sizeof(__ia64_per_cpu_var(__sn_cnodeid_to_nasid)));
-        for_each_online_node(cnode)
-                sn_cnodeid_to_nasid[cnode] =
-                                pxm_to_nasid(nid_to_pxm_map[cnode]);
-
-        numionodes = num_online_nodes();
-        scan_for_ionodes();
-
         /*
          * Allocate & initalize the nodepda for each node.
          */
@@ -402,7 +373,7 @@ static void __init sn_init_pdas(char **cmdline_p)
         /*
          * Allocate & initialize nodepda for TIOs.  For now, put them on node 0.
          */
-        for (cnode = num_online_nodes(); cnode < numionodes; cnode++) {
+        for (cnode = num_online_nodes(); cnode < num_cnodes; cnode++) {
                 nodepdaindr[cnode] =
                     alloc_bootmem_node(NODE_DATA(0), sizeof(nodepda_t));
                 memset(nodepdaindr[cnode], 0, sizeof(nodepda_t));
@@ -411,7 +382,7 @@ static void __init sn_init_pdas(char **cmdline_p)
         /*
          * Now copy the array of nodepda pointers to each nodepda.
          */
-        for (cnode = 0; cnode < numionodes; cnode++)
+        for (cnode = 0; cnode < num_cnodes; cnode++)
                 memcpy(nodepdaindr[cnode]->pernode_pdaindr, nodepdaindr,
                        sizeof(nodepdaindr));
 
@@ -428,7 +399,7 @@ static void __init sn_init_pdas(char **cmdline_p)
          * Initialize the per node hubdev.  This includes IO Nodes and
          * headless/memless nodes.
          */
-        for (cnode = 0; cnode < numionodes; cnode++) {
+        for (cnode = 0; cnode < num_cnodes; cnode++) {
                 hubdev_init_node(nodepdaindr[cnode], cnode);
         }
 }
@@ -553,87 +524,58 @@ void __init sn_cpu_init(void)
 }
 
 /*
- * Scan klconfig for ionodes.  Add the nasids to the
- * physical_node_map and the pda and increment numionodes.
+ * Build tables for converting between NASIDs and cnodes.
  */
+static inline int __init board_needs_cnode(int type)
+{
+        return (type == KLTYPE_SNIA || type == KLTYPE_TIO);
+}
 
-static void __init scan_for_ionodes(void)
+void __init build_cnode_tables(void)
 {
-        int nasid = 0;
+        int nasid;
+        int node;
         lboard_t *brd;
 
-        /* fakeprom does not support klgraph */
-        if (IS_RUNNING_ON_FAKE_PROM())
-                return;
-
-        /* Setup ionodes with memory */
-        for (nasid = 0; nasid < MAX_PHYSNODE_ID; nasid += 2) {
-                char *klgraph_header;
-                cnodeid_t cnodeid;
-
-                if (physical_node_map[nasid] == -1)
-                        continue;
+        memset(physical_node_map, -1, sizeof(physical_node_map));
+        memset(sn_cnodeid_to_nasid, -1,
+                        sizeof(__ia64_per_cpu_var(__sn_cnodeid_to_nasid)));
 
-                cnodeid = -1;
-                klgraph_header = __va(ia64_sn_get_klconfig_addr(nasid));
-                if (!klgraph_header) {
-                        BUG();  /* All nodes must have klconfig tables! */
-                }
-                cnodeid = nasid_to_cnodeid(nasid);
-                root_lboard[cnodeid] = (lboard_t *)
-                    NODE_OFFSET_TO_LBOARD((nasid),
-                                          ((kl_config_hdr_t
-                                            *) (klgraph_header))->
-                                          ch_board_info);
+        /*
+         * First populate the tables with C/M bricks. This ensures that
+         * cnode == node for all C & M bricks.
+         */
+        for_each_online_node(node) {
+                nasid = pxm_to_nasid(nid_to_pxm_map[node]);
+                sn_cnodeid_to_nasid[node] = nasid;
+                physical_node_map[nasid] = node;
         }
 
-        /* Scan headless/memless IO Nodes. */
-        for (nasid = 0; nasid < MAX_PHYSNODE_ID; nasid += 2) {
-                /* if there's no nasid, don't try to read the klconfig on the node */
-                if (physical_node_map[nasid] == -1)
-                        continue;
-                brd = find_lboard_any((lboard_t *)
-                                      root_lboard[nasid_to_cnodeid(nasid)],
-                                      KLTYPE_SNIA);
-                if (brd) {
-                        brd = KLCF_NEXT_ANY(brd);       /* Skip this node's lboard */
-                        if (!brd)
-                                continue;
-                }
-
-                brd = find_lboard_any(brd, KLTYPE_SNIA);
+        /*
+         * num_cnodes is total number of C/M/TIO bricks. Because of the 256 node
+         * limit on the number of nodes, we can't use the generic node numbers 
+         * for this. Note that num_cnodes is incremented below as TIOs or
+         * headless/memoryless nodes are discovered.
+         */
+        num_cnodes = num_online_nodes();
 
-                while (brd) {
-                        sn_cnodeid_to_nasid[numionodes] = brd->brd_nasid;
-                        physical_node_map[brd->brd_nasid] = numionodes;
-                        root_lboard[numionodes] = brd;
-                        numionodes++;
-                        brd = KLCF_NEXT_ANY(brd);
-                        if (!brd)
-                                break;
-
-                        brd = find_lboard_any(brd, KLTYPE_SNIA);
-                }
-        }
+        /* fakeprom does not support klgraph */
+        if (IS_RUNNING_ON_FAKE_PROM())
+                return;
 
-        /* Scan for TIO nodes. */
-        for (nasid = 0; nasid < MAX_PHYSNODE_ID; nasid += 2) {
-                /* if there's no nasid, don't try to read the klconfig on the node */
-                if (physical_node_map[nasid] == -1)
-                        continue;
-                brd = find_lboard_any((lboard_t *)
-                                      root_lboard[nasid_to_cnodeid(nasid)],
-                                      KLTYPE_TIO);
+        /* Find TIOs & headless/memoryless nodes and add them to the tables */
+        for_each_online_node(node) {
+                kl_config_hdr_t *klgraph_header;
+                nasid = cnodeid_to_nasid(node);
+                if ((klgraph_header = ia64_sn_get_klconfig_addr(nasid)) == NULL)
+                        BUG();
+                brd = NODE_OFFSET_TO_LBOARD(nasid, klgraph_header->ch_board_info);
                 while (brd) {
-                        sn_cnodeid_to_nasid[numionodes] = brd->brd_nasid;
-                        physical_node_map[brd->brd_nasid] = numionodes;
-                        root_lboard[numionodes] = brd;
-                        numionodes++;
-                        brd = KLCF_NEXT_ANY(brd);
-                        if (!brd)
-                                break;
-
-                        brd = find_lboard_any(brd, KLTYPE_TIO);
+                        if (board_needs_cnode(brd->brd_type) && physical_node_map[brd->brd_nasid] < 0) {
+                                sn_cnodeid_to_nasid[num_cnodes] = brd->brd_nasid;
+                                physical_node_map[brd->brd_nasid] = num_cnodes++;
+                        }
+                        brd = find_lboard_next(brd);
                 }
         }
 }
diff --git a/arch/ia64/sn/kernel/sn2/sn2_smp.c b/arch/ia64/sn/kernel/sn2/sn2_smp.c
index 0a4ee50c302f..49b530c39a42 100644
--- a/arch/ia64/sn/kernel/sn2/sn2_smp.c
+++ b/arch/ia64/sn/kernel/sn2/sn2_smp.c
@@ -177,6 +177,7 @@ void sn_tlb_migrate_finish(struct mm_struct *mm)
 
 /**
  * sn2_global_tlb_purge - globally purge translation cache of virtual address range
+ * @mm: mm_struct containing virtual address range
  * @start: start of virtual address range
  * @end: end of virtual address range
  * @nbits: specifies number of bytes to purge per instruction (num = 1<<(nbits & 0xfc))
@@ -188,21 +189,22 @@ void sn_tlb_migrate_finish(struct mm_struct *mm)
  *      - cpu_vm_mask is a bit mask that indicates which cpus have loaded the context.
  *      - cpu_vm_mask is converted into a nodemask of the nodes containing the
  *        cpus in cpu_vm_mask.
- *      - if only one bit is set in cpu_vm_mask & it is the current cpu,
- *        then only the local TLB needs to be flushed. This flushing can be done
- *        using ptc.l. This is the common case & avoids the global spinlock.
+ *      - if only one bit is set in cpu_vm_mask & it is the current cpu & the
+ *        process is purging its own virtual address range, then only the
+ *        local TLB needs to be flushed. This flushing can be done using
+ *        ptc.l. This is the common case & avoids the global spinlock.
  *      - if multiple cpus have loaded the context, then flushing has to be
  *        done with ptc.g/MMRs under protection of the global ptc_lock.
  */
 
 void
-sn2_global_tlb_purge(unsigned long start, unsigned long end,
-                     unsigned long nbits)
+sn2_global_tlb_purge(struct mm_struct *mm, unsigned long start,
+                     unsigned long end, unsigned long nbits)
 {
         int i, opt, shub1, cnode, mynasid, cpu, lcpu = 0, nasid, flushed = 0;
+        int mymm = (mm == current->active_mm);
         volatile unsigned long *ptc0, *ptc1;
-        unsigned long itc, itc2, flags, data0 = 0, data1 = 0;
-        struct mm_struct *mm = current->active_mm;
+        unsigned long itc, itc2, flags, data0 = 0, data1 = 0, rr_value;
         short nasids[MAX_NUMNODES], nix;
         nodemask_t nodes_flushed;
 
@@ -216,9 +218,12 @@ sn2_global_tlb_purge(unsigned long start, unsigned long end,
                 i++;
         }
 
+        if (i == 0)
+                return;
+
         preempt_disable();
 
-        if (likely(i == 1 && lcpu == smp_processor_id())) {
+        if (likely(i == 1 && lcpu == smp_processor_id() && mymm)) {
                 do {
                         ia64_ptcl(start, nbits << 2);
                         start += (1UL << nbits);
@@ -229,7 +234,7 @@ sn2_global_tlb_purge(unsigned long start, unsigned long end,
                 return;
         }
 
-        if (atomic_read(&mm->mm_users) == 1) {
+        if (atomic_read(&mm->mm_users) == 1 && mymm) {
                 flush_tlb_mm(mm);
                 __get_cpu_var(ptcstats).change_rid++;
                 preempt_enable();
@@ -241,11 +246,13 @@ sn2_global_tlb_purge(unsigned long start, unsigned long end,
         for_each_node_mask(cnode, nodes_flushed)
                 nasids[nix++] = cnodeid_to_nasid(cnode);
 
+        rr_value = (mm->context << 3) | REGION_NUMBER(start);
+
         shub1 = is_shub1();
         if (shub1) {
                 data0 = (1UL << SH1_PTC_0_A_SHFT) |
                         (nbits << SH1_PTC_0_PS_SHFT) |
-                        ((ia64_get_rr(start) >> 8) << SH1_PTC_0_RID_SHFT) |
+                        (rr_value << SH1_PTC_0_RID_SHFT) |
                         (1UL << SH1_PTC_0_START_SHFT);
                 ptc0 = (long *)GLOBAL_MMR_PHYS_ADDR(0, SH1_PTC_0);
                 ptc1 = (long *)GLOBAL_MMR_PHYS_ADDR(0, SH1_PTC_1);
@@ -254,7 +261,7 @@ sn2_global_tlb_purge(unsigned long start, unsigned long end,
                         (nbits << SH2_PTC_PS_SHFT) |
                         (1UL << SH2_PTC_START_SHFT);
                 ptc0 = (long *)GLOBAL_MMR_PHYS_ADDR(0, SH2_PTC + 
-                        ((ia64_get_rr(start) >> 8) << SH2_PTC_RID_SHFT) );
+                        (rr_value << SH2_PTC_RID_SHFT));
                 ptc1 = NULL;
         }
         
@@ -275,7 +282,7 @@ sn2_global_tlb_purge(unsigned long start, unsigned long end,
                         data0 = (data0 & ~SH2_PTC_ADDR_MASK) | (start & SH2_PTC_ADDR_MASK);
                 for (i = 0; i < nix; i++) {
                         nasid = nasids[i];
-                        if ((!(sn2_ptctest & 3)) && unlikely(nasid == mynasid)) {
+                        if ((!(sn2_ptctest & 3)) && unlikely(nasid == mynasid && mymm)) {
                                 ia64_ptcga(start, nbits << 2);
                                 ia64_srlz_i();
                         } else {
diff --git a/arch/ia64/sn/kernel/sn2/sn_hwperf.c b/arch/ia64/sn/kernel/sn2/sn_hwperf.c
index 0513aacac8c1..6c6fbca3229c 100644
--- a/arch/ia64/sn/kernel/sn2/sn_hwperf.c
+++ b/arch/ia64/sn/kernel/sn2/sn_hwperf.c
@@ -476,8 +476,8 @@ static int sn_topology_show(struct seq_file *s, void *d)
                                 for_each_online_cpu(j) {
                                         seq_printf(s, j ? ":%d" : ", dist %d",
                                                 node_distance(
-                                                    cpuid_to_cnodeid(i),
-                                                    cpuid_to_cnodeid(j)));
+                                                    cpu_to_node(i),
+                                                    cpu_to_node(j)));
                                 }
                                 seq_putc(s, '\n');
                         }
diff --git a/arch/ia64/sn/kernel/tiocx.c b/arch/ia64/sn/kernel/tiocx.c
index b45db5133f55..0d8592a745a7 100644
--- a/arch/ia64/sn/kernel/tiocx.c
+++ b/arch/ia64/sn/kernel/tiocx.c
@@ -183,11 +183,12 @@ int cx_driver_unregister(struct cx_drv *cx_driver)
  * @part_num: device's part number
  * @mfg_num: device's manufacturer number
  * @hubdev: hub info associated with this device
+ * @bt: board type of the device
  *
  */
 int
 cx_device_register(nasid_t nasid, int part_num, int mfg_num,
-                   struct hubdev_info *hubdev)
+                   struct hubdev_info *hubdev, int bt)
 {
         struct cx_dev *cx_dev;
 
@@ -200,6 +201,7 @@ cx_device_register(nasid_t nasid, int part_num, int mfg_num,
         cx_dev->cx_id.mfg_num = mfg_num;
         cx_dev->cx_id.nasid = nasid;
         cx_dev->hubdev = hubdev;
+        cx_dev->bt = bt;
 
         cx_dev->dev.parent = NULL;
         cx_dev->dev.bus = &tiocx_bus_type;
@@ -238,7 +240,8 @@ static int cx_device_reload(struct cx_dev *cx_dev)
 {
         cx_device_unregister(cx_dev);
         return cx_device_register(cx_dev->cx_id.nasid, cx_dev->cx_id.part_num,
-                                  cx_dev->cx_id.mfg_num, cx_dev->hubdev);
+                                  cx_dev->cx_id.mfg_num, cx_dev->hubdev,
+                                  cx_dev->bt);
 }
 
 static inline uint64_t tiocx_intr_alloc(nasid_t nasid, int widget,
@@ -365,26 +368,20 @@ static void tio_corelet_reset(nasid_t nasid, int corelet)
         udelay(2000);
 }
 
-static int tiocx_btchar_get(int nasid)
+static int is_fpga_tio(int nasid, int *bt)
 {
-        moduleid_t module_id;
-        geoid_t geoid;
-        int cnodeid;
-
-        cnodeid = nasid_to_cnodeid(nasid);
-        geoid = cnodeid_get_geoid(cnodeid);
-        module_id = geo_module(geoid);
-        return MODULE_GET_BTCHAR(module_id);
-}
+        int ioboard_type;
 
-static int is_fpga_brick(int nasid)
-{
-        switch (tiocx_btchar_get(nasid)) {
+        ioboard_type = ia64_sn_sysctl_ioboard_get(nasid);
+
+        switch (ioboard_type) {
         case L1_BRICKTYPE_SA:
         case L1_BRICKTYPE_ATHENA:
-        case L1_BRICKTYPE_DAYTONA:
+        case L1_BOARDTYPE_DAYTONA:
+                *bt = ioboard_type;
                 return 1;
         }
+
         return 0;
 }
 
@@ -407,16 +404,22 @@ static int tiocx_reload(struct cx_dev *cx_dev)
 
         if (bitstream_loaded(nasid)) {
                 uint64_t cx_id;
-
-                cx_id =
-                    *(volatile uint64_t *)(TIO_SWIN_BASE(nasid, TIOCX_CORELET) +
+                int rv;
+
+                rv = ia64_sn_sysctl_tio_clock_reset(nasid);
+                if (rv) {
+                        printk(KERN_ALERT "CX port JTAG reset failed.\n");
+                } else {
+                        cx_id = *(volatile uint64_t *)
+                                (TIO_SWIN_BASE(nasid, TIOCX_CORELET) +
                                           WIDGET_ID);
-                part_num = XWIDGET_PART_NUM(cx_id);
-                mfg_num = XWIDGET_MFG_NUM(cx_id);
-                DBG("part= 0x%x, mfg= 0x%x\n", part_num, mfg_num);
-                /* just ignore it if it's a CE */
-                if (part_num == TIO_CE_ASIC_PARTNUM)
-                        return 0;
+                        part_num = XWIDGET_PART_NUM(cx_id);
+                        mfg_num = XWIDGET_MFG_NUM(cx_id);
+                        DBG("part= 0x%x, mfg= 0x%x\n", part_num, mfg_num);
+                        /* just ignore it if it's a CE */
+                        if (part_num == TIO_CE_ASIC_PARTNUM)
+                                return 0;
+                }
         }
 
         cx_dev->cx_id.part_num = part_num;
@@ -436,10 +439,10 @@ static ssize_t show_cxdev_control(struct device *dev, struct device_attribute *a
 {
         struct cx_dev *cx_dev = to_cx_dev(dev);
 
-        return sprintf(buf, "0x%x 0x%x 0x%x %d\n",
+        return sprintf(buf, "0x%x 0x%x 0x%x 0x%x\n",
                        cx_dev->cx_id.nasid,
                        cx_dev->cx_id.part_num, cx_dev->cx_id.mfg_num,
-                       tiocx_btchar_get(cx_dev->cx_id.nasid));
+                       cx_dev->bt);
 }
 
 static ssize_t store_cxdev_control(struct device *dev, struct device_attribute *attr, const char *buf,
@@ -486,13 +489,13 @@ static int __init tiocx_init(void)
 
         bus_register(&tiocx_bus_type);
 
-        for (cnodeid = 0; cnodeid < MAX_COMPACT_NODES; cnodeid++) {
+        for (cnodeid = 0; cnodeid < num_cnodes; cnodeid++) {
                 nasid_t nasid;
+                int bt;
 
-                if ((nasid = cnodeid_to_nasid(cnodeid)) < 0)
-                        break;  /* No more nasids .. bail out of loop */
+                nasid = cnodeid_to_nasid(cnodeid);
 
-                if ((nasid & 0x1) && is_fpga_brick(nasid)) {
+                if ((nasid & 0x1) && is_fpga_tio(nasid, &bt)) {
                         struct hubdev_info *hubdev;
                         struct xwidget_info *widgetp;
 
@@ -512,7 +515,7 @@ static int __init tiocx_init(void)
 
                         if (cx_device_register
                             (nasid, widgetp->xwi_hwid.part_num,
-                             widgetp->xwi_hwid.mfg_num, hubdev) < 0)
+                             widgetp->xwi_hwid.mfg_num, hubdev, bt) < 0)
                                 return -ENXIO;
                         else
                                 found_tiocx_device++;
diff --git a/arch/ia64/sn/kernel/xpc.h b/arch/ia64/sn/kernel/xpc.h
index e5f5a4e51f70..fbcedc7c27fa 100644
--- a/arch/ia64/sn/kernel/xpc.h
+++ b/arch/ia64/sn/kernel/xpc.h
@@ -57,7 +57,7 @@
 #define XPC_NASID_FROM_W_B(_w, _b) (((_w) * 64 + (_b)) * 2)
 
 #define XPC_HB_DEFAULT_INTERVAL         5       /* incr HB every x secs */
-#define XPC_HB_CHECK_DEFAULT_TIMEOUT    20      /* check HB every x secs */
+#define XPC_HB_CHECK_DEFAULT_INTERVAL   20      /* check HB every x secs */
 
 /* define the process name of HB checker and the CPU it is pinned to */
 #define XPC_HB_CHECK_THREAD_NAME        "xpc_hb"
@@ -67,34 +67,82 @@
 #define XPC_DISCOVERY_THREAD_NAME       "xpc_discovery"
 
 
-#define XPC_HB_ALLOWED(_p, _v)  ((_v)->heartbeating_to_mask & (1UL << (_p)))
-#define XPC_ALLOW_HB(_p, _v)    (_v)->heartbeating_to_mask |= (1UL << (_p))
-#define XPC_DISALLOW_HB(_p, _v) (_v)->heartbeating_to_mask &= (~(1UL << (_p)))
-
-
 /*
- * Reserved Page provided by SAL.
+ * the reserved page
+ *
+ *   SAL reserves one page of memory per partition for XPC. Though a full page
+ *   in length (16384 bytes), its starting address is not page aligned, but it
+ *   is cacheline aligned. The reserved page consists of the following:
+ *
+ *   reserved page header
+ *
+ *     The first cacheline of the reserved page contains the header
+ *     (struct xpc_rsvd_page). Before SAL initialization has completed,
+ *     SAL has set up the following fields of the reserved page header:
+ *     SAL_signature, SAL_version, partid, and nasids_size. The other
+ *     fields are set up by XPC. (xpc_rsvd_page points to the local
+ *     partition's reserved page.)
  *
- * SAL provides one page per partition of reserved memory.  When SAL
- * initialization is complete, SAL_signature, SAL_version, partid,
- * part_nasids, and mach_nasids are set.
+ *   part_nasids mask
+ *   mach_nasids mask
+ *
+ *     SAL also sets up two bitmaps (or masks), one that reflects the actual
+ *     nasids in this partition (part_nasids), and the other that reflects
+ *     the actual nasids in the entire machine (mach_nasids). We're only
+ *     interested in the even numbered nasids (which contain the processors
+ *     and/or memory), so we only need half as many bits to represent the
+ *     nasids. The part_nasids mask is located starting at the first cacheline
+ *     following the reserved page header. The mach_nasids mask follows right
+ *     after the part_nasids mask. The size in bytes of each mask is reflected
+ *     by the reserved page header field 'nasids_size'. (Local partition's
+ *     mask pointers are xpc_part_nasids and xpc_mach_nasids.)
+ *
+ *   vars
+ *   vars part
+ *
+ *     Immediately following the mach_nasids mask are the XPC variables
+ *     required by other partitions. First are those that are generic to all
+ *     partitions (vars), followed on the next available cacheline by those
+ *     which are partition specific (vars part). These are setup by XPC.
+ *     (Local partition's vars pointers are xpc_vars and xpc_vars_part.)
  *
  * Note: Until vars_pa is set, the partition XPC code has not been initialized.
  */
 struct xpc_rsvd_page {
-        u64 SAL_signature;      /* SAL unique signature */
-        u64 SAL_version;        /* SAL specified version */
-        u8 partid;              /* partition ID from SAL */
+        u64 SAL_signature;      /* SAL: unique signature */
+        u64 SAL_version;        /* SAL: version */
+        u8 partid;              /* SAL: partition ID */
         u8 version;
-        u8 pad[6];              /* pad to u64 align */
+        u8 pad1[6];             /* align to next u64 in cacheline */
         volatile u64 vars_pa;
-        u64 part_nasids[XP_NASID_MASK_WORDS] ____cacheline_aligned;
-        u64 mach_nasids[XP_NASID_MASK_WORDS] ____cacheline_aligned;
+        struct timespec stamp;  /* time when reserved page was setup by XPC */
+        u64 pad2[9];            /* align to last u64 in cacheline */
+        u64 nasids_size;        /* SAL: size of each nasid mask in bytes */
 };
-#define XPC_RP_VERSION _XPC_VERSION(1,0) /* version 1.0 of the reserved page */
 
-#define XPC_RSVD_PAGE_ALIGNED_SIZE \
-                        (L1_CACHE_ALIGN(sizeof(struct xpc_rsvd_page)))
+#define XPC_RP_VERSION _XPC_VERSION(1,1) /* version 1.1 of the reserved page */
+
+#define XPC_SUPPORTS_RP_STAMP(_version) \
+                        (_version >= _XPC_VERSION(1,1))
+
+/*
+ * compare stamps - the return value is:
+ *
+ *      < 0,    if stamp1 < stamp2
+ *      = 0,    if stamp1 == stamp2
+ *      > 0,    if stamp1 > stamp2
+ */
+static inline int
+xpc_compare_stamps(struct timespec *stamp1, struct timespec *stamp2)
+{
+        int ret;
+
+
+        if ((ret = stamp1->tv_sec - stamp2->tv_sec) == 0) {
+                ret = stamp1->tv_nsec - stamp2->tv_nsec;
+        }
+        return ret;
+}
 
 
 /*
@@ -121,11 +169,58 @@ struct xpc_vars {
         u64 vars_part_pa;
         u64 amos_page_pa;       /* paddr of page of AMOs from MSPEC driver */
         AMO_t *amos_page;       /* vaddr of page of AMOs from MSPEC driver */
-        AMO_t *act_amos;        /* pointer to the first activation AMO */
 };
-#define XPC_V_VERSION _XPC_VERSION(3,0) /* version 3.0 of the cross vars */
 
-#define XPC_VARS_ALIGNED_SIZE  (L1_CACHE_ALIGN(sizeof(struct xpc_vars)))
+#define XPC_V_VERSION _XPC_VERSION(3,1) /* version 3.1 of the cross vars */
+
+#define XPC_SUPPORTS_DISENGAGE_REQUEST(_version) \
+                        (_version >= _XPC_VERSION(3,1))
+
+
+static inline int
+xpc_hb_allowed(partid_t partid, struct xpc_vars *vars)
+{
+        return ((vars->heartbeating_to_mask & (1UL << partid)) != 0);
+}
+
+static inline void
+xpc_allow_hb(partid_t partid, struct xpc_vars *vars)
+{
+        u64 old_mask, new_mask;
+
+        do {
+                old_mask = vars->heartbeating_to_mask;
+                new_mask = (old_mask | (1UL << partid));
+        } while (cmpxchg(&vars->heartbeating_to_mask, old_mask, new_mask) !=
+                                                        old_mask);
+}
+
+static inline void
+xpc_disallow_hb(partid_t partid, struct xpc_vars *vars)
+{
+        u64 old_mask, new_mask;
+
+        do {
+                old_mask = vars->heartbeating_to_mask;
+                new_mask = (old_mask & ~(1UL << partid));
+        } while (cmpxchg(&vars->heartbeating_to_mask, old_mask, new_mask) !=
+                                                        old_mask);
+}
+
+
+/*
+ * The AMOs page consists of a number of AMO variables which are divided into
+ * four groups, The first two groups are used to identify an IRQ's sender.
+ * These two groups consist of 64 and 128 AMO variables respectively. The last
+ * two groups, consisting of just one AMO variable each, are used to identify
+ * the remote partitions that are currently engaged (from the viewpoint of
+ * the XPC running on the remote partition).
+ */
+#define XPC_NOTIFY_IRQ_AMOS        0
+#define XPC_ACTIVATE_IRQ_AMOS      (XPC_NOTIFY_IRQ_AMOS + XP_MAX_PARTITIONS)
+#define XPC_ENGAGED_PARTITIONS_AMO (XPC_ACTIVATE_IRQ_AMOS + XP_NASID_MASK_WORDS)
+#define XPC_DISENGAGE_REQUEST_AMO  (XPC_ENGAGED_PARTITIONS_AMO + 1)
+
 
 /*
  * The following structure describes the per partition specific variables.
@@ -165,6 +260,16 @@ struct xpc_vars_part {
 #define XPC_VP_MAGIC2   0x0073726176435058L  /* 'XPCvars\0'L (little endian) */
 
 
+/* the reserved page sizes and offsets */
+
+#define XPC_RP_HEADER_SIZE      L1_CACHE_ALIGN(sizeof(struct xpc_rsvd_page))
+#define XPC_RP_VARS_SIZE        L1_CACHE_ALIGN(sizeof(struct xpc_vars))
+
+#define XPC_RP_PART_NASIDS(_rp) (u64 *) ((u8 *) _rp + XPC_RP_HEADER_SIZE)
+#define XPC_RP_MACH_NASIDS(_rp) (XPC_RP_PART_NASIDS(_rp) + xp_nasid_mask_words)
+#define XPC_RP_VARS(_rp)        ((struct xpc_vars *) XPC_RP_MACH_NASIDS(_rp) + xp_nasid_mask_words)
+#define XPC_RP_VARS_PART(_rp)   (struct xpc_vars_part *) ((u8 *) XPC_RP_VARS(rp) + XPC_RP_VARS_SIZE)
+
 
 /*
  * Functions registered by add_timer() or called by kernel_thread() only
@@ -349,6 +454,9 @@ struct xpc_channel {
         atomic_t n_on_msg_allocate_wq;   /* #on msg allocation wait queue */
         wait_queue_head_t msg_allocate_wq; /* msg allocation wait queue */
 
+        u8 delayed_IPI_flags;           /* IPI flags received, but delayed */
+                                        /* action until channel disconnected */
+
         /* queue of msg senders who want to be notified when msg received */
 
         atomic_t n_to_notify;           /* #of msg senders to notify */
@@ -358,7 +466,7 @@ struct xpc_channel {
         void *key;                      /* pointer to user's key */
 
         struct semaphore msg_to_pull_sema; /* next msg to pull serialization */
-        struct semaphore teardown_sema;    /* wait for teardown completion */
+        struct semaphore wdisconnect_sema; /* wait for channel disconnect */
 
         struct xpc_openclose_args *local_openclose_args; /* args passed on */
                                         /* opening or closing of channel */
@@ -410,6 +518,8 @@ struct xpc_channel {
 
 #define XPC_C_DISCONNECTED      0x00002000 /* channel is disconnected */
 #define XPC_C_DISCONNECTING     0x00004000 /* channel is being disconnected */
+#define XPC_C_DISCONNECTCALLOUT 0x00008000 /* chan disconnected callout made */
+#define XPC_C_WDISCONNECT       0x00010000 /* waiting for channel disconnect */
 
 
 
@@ -422,6 +532,8 @@ struct xpc_partition {
 
         /* XPC HB infrastructure */
 
+        u8 remote_rp_version;           /* version# of partition's rsvd pg */
+        struct timespec remote_rp_stamp;/* time when rsvd pg was initialized */
         u64 remote_rp_pa;               /* phys addr of partition's rsvd pg */
         u64 remote_vars_pa;             /* phys addr of partition's vars */
         u64 remote_vars_part_pa;        /* phys addr of partition's vars part */
@@ -432,14 +544,18 @@ struct xpc_partition {
         u32 act_IRQ_rcvd;               /* IRQs since activation */
         spinlock_t act_lock;            /* protect updating of act_state */
         u8 act_state;                   /* from XPC HB viewpoint */
+        u8 remote_vars_version;         /* version# of partition's vars */
         enum xpc_retval reason;         /* reason partition is deactivating */
         int reason_line;                /* line# deactivation initiated from */
         int reactivate_nasid;           /* nasid in partition to reactivate */
 
+        unsigned long disengage_request_timeout; /* timeout in jiffies */
+        struct timer_list disengage_request_timer;
+
 
         /* XPC infrastructure referencing and teardown control */
 
-        volatile u8 setup_state;                        /* infrastructure setup state */
+        volatile u8 setup_state;        /* infrastructure setup state */
         wait_queue_head_t teardown_wq;  /* kthread waiting to teardown infra */
         atomic_t references;            /* #of references to infrastructure */
 
@@ -454,6 +570,7 @@ struct xpc_partition {
 
         u8 nchannels;              /* #of defined channels supported */
         atomic_t nchannels_active; /* #of channels that are not DISCONNECTED */
+        atomic_t nchannels_engaged;/* #of channels engaged with remote part */
         struct xpc_channel *channels;/* array of channel structures */
 
         void *local_GPs_base;     /* base address of kmalloc'd space */
@@ -518,6 +635,7 @@ struct xpc_partition {
 #define XPC_P_TORNDOWN          0x03    /* infrastructure is torndown */
 
 
+
 /*
  * struct xpc_partition IPI_timer #of seconds to wait before checking for
  * dropped IPIs. These occur whenever an IPI amo write doesn't complete until
@@ -526,6 +644,13 @@ struct xpc_partition {
 #define XPC_P_DROPPED_IPI_WAIT  (0.25 * HZ)
 
 
+/* number of seconds to wait for other partitions to disengage */
+#define XPC_DISENGAGE_REQUEST_DEFAULT_TIMELIMIT 90
+
+/* interval in seconds to print 'waiting disengagement' messages */
+#define XPC_DISENGAGE_PRINTMSG_INTERVAL         10
+
+
 #define XPC_PARTID(_p)  ((partid_t) ((_p) - &xpc_partitions[0]))
 
 
@@ -534,24 +659,20 @@ struct xpc_partition {
 extern struct xpc_registration xpc_registrations[];
 
 
-/* >>> found in xpc_main.c only */
+/* found in xpc_main.c */
 extern struct device *xpc_part;
 extern struct device *xpc_chan;
+extern int xpc_disengage_request_timelimit;
 extern irqreturn_t xpc_notify_IRQ_handler(int, void *, struct pt_regs *);
 extern void xpc_dropped_IPI_check(struct xpc_partition *);
+extern void xpc_activate_partition(struct xpc_partition *);
 extern void xpc_activate_kthreads(struct xpc_channel *, int);
 extern void xpc_create_kthreads(struct xpc_channel *, int);
 extern void xpc_disconnect_wait(int);
 
 
-/* found in xpc_main.c and efi-xpc.c */
-extern void xpc_activate_partition(struct xpc_partition *);
-
-
 /* found in xpc_partition.c */
 extern int xpc_exiting;
-extern int xpc_hb_interval;
-extern int xpc_hb_check_interval;
 extern struct xpc_vars *xpc_vars;
 extern struct xpc_rsvd_page *xpc_rsvd_page;
 extern struct xpc_vars_part *xpc_vars_part;
@@ -561,6 +682,7 @@ extern struct xpc_rsvd_page *xpc_rsvd_page_init(void);
 extern void xpc_allow_IPI_ops(void);
 extern void xpc_restrict_IPI_ops(void);
 extern int xpc_identify_act_IRQ_sender(void);
+extern int xpc_partition_disengaged(struct xpc_partition *);
 extern enum xpc_retval xpc_mark_partition_active(struct xpc_partition *);
 extern void xpc_mark_partition_inactive(struct xpc_partition *);
 extern void xpc_discovery(void);
@@ -585,8 +707,8 @@ extern void xpc_connected_callout(struct xpc_channel *);
 extern void xpc_deliver_msg(struct xpc_channel *);
 extern void xpc_disconnect_channel(const int, struct xpc_channel *,
                                         enum xpc_retval, unsigned long *);
-extern void xpc_disconnected_callout(struct xpc_channel *);
-extern void xpc_partition_down(struct xpc_partition *, enum xpc_retval);
+extern void xpc_disconnecting_callout(struct xpc_channel *);
+extern void xpc_partition_going_down(struct xpc_partition *, enum xpc_retval);
 extern void xpc_teardown_infrastructure(struct xpc_partition *);
 
 
@@ -674,6 +796,157 @@ xpc_part_ref(struct xpc_partition *part)
 
 
 /*
+ * This next set of inlines are used to keep track of when a partition is
+ * potentially engaged in accessing memory belonging to another partition.
+ */
+
+static inline void
+xpc_mark_partition_engaged(struct xpc_partition *part)
+{
+        unsigned long irq_flags;
+        AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa +
+                                (XPC_ENGAGED_PARTITIONS_AMO * sizeof(AMO_t)));
+
+
+        local_irq_save(irq_flags);
+
+        /* set bit corresponding to our partid in remote partition's AMO */
+        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_OR,
+                                                (1UL << sn_partition_id));
+        /*
+         * We must always use the nofault function regardless of whether we
+         * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we
+         * didn't, we'd never know that the other partition is down and would
+         * keep sending IPIs and AMOs to it until the heartbeat times out.
+         */
+        (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo->
+                                variable), xp_nofault_PIOR_target));
+
+        local_irq_restore(irq_flags);
+}
+
+static inline void
+xpc_mark_partition_disengaged(struct xpc_partition *part)
+{
+        unsigned long irq_flags;
+        AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa +
+                                (XPC_ENGAGED_PARTITIONS_AMO * sizeof(AMO_t)));
+
+
+        local_irq_save(irq_flags);
+
+        /* clear bit corresponding to our partid in remote partition's AMO */
+        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND,
+                                                ~(1UL << sn_partition_id));
+        /*
+         * We must always use the nofault function regardless of whether we
+         * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we
+         * didn't, we'd never know that the other partition is down and would
+         * keep sending IPIs and AMOs to it until the heartbeat times out.
+         */
+        (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo->
+                                variable), xp_nofault_PIOR_target));
+
+        local_irq_restore(irq_flags);
+}
+
+static inline void
+xpc_request_partition_disengage(struct xpc_partition *part)
+{
+        unsigned long irq_flags;
+        AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa +
+                                (XPC_DISENGAGE_REQUEST_AMO * sizeof(AMO_t)));
+
+
+        local_irq_save(irq_flags);
+
+        /* set bit corresponding to our partid in remote partition's AMO */
+        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_OR,
+                                                (1UL << sn_partition_id));
+        /*
+         * We must always use the nofault function regardless of whether we
+         * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we
+         * didn't, we'd never know that the other partition is down and would
+         * keep sending IPIs and AMOs to it until the heartbeat times out.
+         */
+        (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo->
+                                variable), xp_nofault_PIOR_target));
+
+        local_irq_restore(irq_flags);
+}
+
+static inline void
+xpc_cancel_partition_disengage_request(struct xpc_partition *part)
+{
+        unsigned long irq_flags;
+        AMO_t *amo = (AMO_t *) __va(part->remote_amos_page_pa +
+                                (XPC_DISENGAGE_REQUEST_AMO * sizeof(AMO_t)));
+
+
+        local_irq_save(irq_flags);
+
+        /* clear bit corresponding to our partid in remote partition's AMO */
+        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND,
+                                                ~(1UL << sn_partition_id));
+        /*
+         * We must always use the nofault function regardless of whether we
+         * are on a Shub 1.1 system or a Shub 1.2 slice 0xc processor. If we
+         * didn't, we'd never know that the other partition is down and would
+         * keep sending IPIs and AMOs to it until the heartbeat times out.
+         */
+        (void) xp_nofault_PIOR((u64 *) GLOBAL_MMR_ADDR(NASID_GET(&amo->
+                                variable), xp_nofault_PIOR_target));
+
+        local_irq_restore(irq_flags);
+}
+
+static inline u64
+xpc_partition_engaged(u64 partid_mask)
+{
+        AMO_t *amo = xpc_vars->amos_page + XPC_ENGAGED_PARTITIONS_AMO;
+
+
+        /* return our partition's AMO variable ANDed with partid_mask */
+        return (FETCHOP_LOAD_OP(TO_AMO((u64) &amo->variable), FETCHOP_LOAD) &
+                                                                partid_mask);
+}
+
+static inline u64
+xpc_partition_disengage_requested(u64 partid_mask)
+{
+        AMO_t *amo = xpc_vars->amos_page + XPC_DISENGAGE_REQUEST_AMO;
+
+
+        /* return our partition's AMO variable ANDed with partid_mask */
+        return (FETCHOP_LOAD_OP(TO_AMO((u64) &amo->variable), FETCHOP_LOAD) &
+                                                                partid_mask);
+}
+
+static inline void
+xpc_clear_partition_engaged(u64 partid_mask)
+{
+        AMO_t *amo = xpc_vars->amos_page + XPC_ENGAGED_PARTITIONS_AMO;
+
+
+        /* clear bit(s) based on partid_mask in our partition's AMO */
+        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND,
+                                                                ~partid_mask);
+}
+
+static inline void
+xpc_clear_partition_disengage_request(u64 partid_mask)
+{
+        AMO_t *amo = xpc_vars->amos_page + XPC_DISENGAGE_REQUEST_AMO;
+
+
+        /* clear bit(s) based on partid_mask in our partition's AMO */
+        FETCHOP_STORE_OP(TO_AMO((u64) &amo->variable), FETCHOP_AND,
+                                                                ~partid_mask);
+}
+
+
+
+/*
  * The following set of macros and inlines are used for the sending and
  * receiving of IPIs (also known as IRQs). There are two flavors of IPIs,
  * one that is associated with partition activity (SGI_XPC_ACTIVATE) and
@@ -722,13 +995,13 @@ xpc_IPI_send(AMO_t *amo, u64 flag, int nasid, int phys_cpuid, int vector)
  * Flag the appropriate AMO variable and send an IPI to the specified node.
  */
 static inline void
-xpc_activate_IRQ_send(u64 amos_page, int from_nasid, int to_nasid,
+xpc_activate_IRQ_send(u64 amos_page_pa, int from_nasid, int to_nasid,
                         int to_phys_cpuid)
 {
         int w_index = XPC_NASID_W_INDEX(from_nasid);
         int b_index = XPC_NASID_B_INDEX(from_nasid);
-        AMO_t *amos = (AMO_t *) __va(amos_page +
-                                        (XP_MAX_PARTITIONS * sizeof(AMO_t)));
+        AMO_t *amos = (AMO_t *) __va(amos_page_pa +
+                                (XPC_ACTIVATE_IRQ_AMOS * sizeof(AMO_t)));
 
 
         (void) xpc_IPI_send(&amos[w_index], (1UL << b_index), to_nasid,
@@ -756,6 +1029,13 @@ xpc_IPI_send_reactivate(struct xpc_partition *part)
                                 xpc_vars->act_nasid, xpc_vars->act_phys_cpuid);
 }
 
+static inline void
+xpc_IPI_send_disengage(struct xpc_partition *part)
+{
+        xpc_activate_IRQ_send(part->remote_amos_page_pa, cnodeid_to_nasid(0),
+                        part->remote_act_nasid, part->remote_act_phys_cpuid);
+}
+
 
 /*
  * IPIs associated with SGI_XPC_NOTIFY IRQ.
@@ -836,6 +1116,7 @@ xpc_notify_IRQ_send_local(struct xpc_channel *ch, u8 ipi_flag,
 
 /* given an AMO variable and a channel#, get its associated IPI flags */
 #define XPC_GET_IPI_FLAGS(_amo, _c)     ((u8) (((_amo) >> ((_c) * 8)) & 0xff))
+#define XPC_SET_IPI_FLAGS(_amo, _c, _f) (_amo) |= ((u64) (_f) << ((_c) * 8))
 
 #define XPC_ANY_OPENCLOSE_IPI_FLAGS_SET(_amo) ((_amo) & 0x0f0f0f0f0f0f0f0f)
 #define XPC_ANY_MSG_IPI_FLAGS_SET(_amo)       ((_amo) & 0x1010101010101010)
@@ -903,17 +1184,18 @@ xpc_IPI_send_local_msgrequest(struct xpc_channel *ch)
  * cacheable mapping for the entire region. This will prevent speculative
  * reading of cached copies of our lines from being issued which will cause
  * a PI FSB Protocol error to be generated by the SHUB. For XPC, we need 64
- * (XP_MAX_PARTITIONS) AMO variables for message notification (xpc_main.c)
- * and an additional 16 AMO variables for partition activation (xpc_hb.c).
+ * AMO variables (based on XP_MAX_PARTITIONS) for message notification and an
+ * additional 128 AMO variables (based on XP_NASID_MASK_WORDS) for partition
+ * activation and 2 AMO variables for partition deactivation.
  */
 static inline AMO_t *
-xpc_IPI_init(partid_t partid)
+xpc_IPI_init(int index)
 {
-        AMO_t *part_amo = xpc_vars->amos_page + partid;
+        AMO_t *amo = xpc_vars->amos_page + index;
 
 
-        xpc_IPI_receive(part_amo);
-        return part_amo;
+        (void) xpc_IPI_receive(amo);    /* clear AMO variable */
+        return amo;
 }
 
 
diff --git a/arch/ia64/sn/kernel/xpc_channel.c b/arch/ia64/sn/kernel/xpc_channel.c
index 94698bea7be0..abf4fc2a87bb 100644
--- a/arch/ia64/sn/kernel/xpc_channel.c
+++ b/arch/ia64/sn/kernel/xpc_channel.c
@@ -57,6 +57,7 @@ xpc_initialize_channels(struct xpc_partition *part, partid_t partid)
 
                 spin_lock_init(&ch->lock);
                 sema_init(&ch->msg_to_pull_sema, 1);    /* mutex */
+                sema_init(&ch->wdisconnect_sema, 0);    /* event wait */
 
                 atomic_set(&ch->n_on_msg_allocate_wq, 0);
                 init_waitqueue_head(&ch->msg_allocate_wq);
@@ -166,6 +167,7 @@ xpc_setup_infrastructure(struct xpc_partition *part)
         xpc_initialize_channels(part, partid);
 
         atomic_set(&part->nchannels_active, 0);
+        atomic_set(&part->nchannels_engaged, 0);
 
 
         /* local_IPI_amo were set to 0 by an earlier memset() */
@@ -555,8 +557,6 @@ xpc_allocate_msgqueues(struct xpc_channel *ch)
                 sema_init(&ch->notify_queue[i].sema, 0);
         }
 
-        sema_init(&ch->teardown_sema, 0);       /* event wait */
-
         spin_lock_irqsave(&ch->lock, irq_flags);
         ch->flags |= XPC_C_SETUP;
         spin_unlock_irqrestore(&ch->lock, irq_flags);
@@ -626,6 +626,55 @@ xpc_process_connect(struct xpc_channel *ch, unsigned long *irq_flags)
 
 
 /*
+ * Notify those who wanted to be notified upon delivery of their message.
+ */
+static void
+xpc_notify_senders(struct xpc_channel *ch, enum xpc_retval reason, s64 put)
+{
+        struct xpc_notify *notify;
+        u8 notify_type;
+        s64 get = ch->w_remote_GP.get - 1;
+
+
+        while (++get < put && atomic_read(&ch->n_to_notify) > 0) {
+
+                notify = &ch->notify_queue[get % ch->local_nentries];
+
+                /*
+                 * See if the notify entry indicates it was associated with
+                 * a message who's sender wants to be notified. It is possible
+                 * that it is, but someone else is doing or has done the
+                 * notification.
+                 */
+                notify_type = notify->type;
+                if (notify_type == 0 ||
+                                cmpxchg(&notify->type, notify_type, 0) !=
+                                                                notify_type) {
+                        continue;
+                }
+
+                DBUG_ON(notify_type != XPC_N_CALL);
+
+                atomic_dec(&ch->n_to_notify);
+
+                if (notify->func != NULL) {
+                        dev_dbg(xpc_chan, "notify->func() called, notify=0x%p, "
+                                "msg_number=%ld, partid=%d, channel=%d\n",
+                                (void *) notify, get, ch->partid, ch->number);
+
+                        notify->func(reason, ch->partid, ch->number,
+                                                                notify->key);
+
+                        dev_dbg(xpc_chan, "notify->func() returned, "
+                                "notify=0x%p, msg_number=%ld, partid=%d, "
+                                "channel=%d\n", (void *) notify, get,
+                                ch->partid, ch->number);
+                }
+        }
+}
+
+
+/*
  * Free up message queues and other stuff that were allocated for the specified
  * channel.
  *
@@ -669,9 +718,6 @@ xpc_free_msgqueues(struct xpc_channel *ch)
                 ch->remote_msgqueue = NULL;
                 kfree(ch->notify_queue);
                 ch->notify_queue = NULL;
-
-                /* in case someone is waiting for the teardown to complete */
-                up(&ch->teardown_sema);
         }
 }
 
@@ -683,7 +729,7 @@ static void
 xpc_process_disconnect(struct xpc_channel *ch, unsigned long *irq_flags)
 {
         struct xpc_partition *part = &xpc_partitions[ch->partid];
-        u32 ch_flags = ch->flags;
+        u32 channel_was_connected = (ch->flags & XPC_C_WASCONNECTED);
 
 
         DBUG_ON(!spin_is_locked(&ch->lock));
@@ -701,12 +747,13 @@ xpc_process_disconnect(struct xpc_channel *ch, unsigned long *irq_flags)
         }
         DBUG_ON(atomic_read(&ch->kthreads_assigned) != 0);
 
-        /* it's now safe to free the channel's message queues */
-
-        xpc_free_msgqueues(ch);
-        DBUG_ON(ch->flags & XPC_C_SETUP);
+        if (part->act_state == XPC_P_DEACTIVATING) {
+                /* can't proceed until the other side disengages from us */
+                if (xpc_partition_engaged(1UL << ch->partid)) {
+                        return;
+                }
 
-        if (part->act_state != XPC_P_DEACTIVATING) {
+        } else {
 
                 /* as long as the other side is up do the full protocol */
 
@@ -724,16 +771,42 @@ xpc_process_disconnect(struct xpc_channel *ch, unsigned long *irq_flags)
                 }
         }
 
+        /* wake those waiting for notify completion */
+        if (atomic_read(&ch->n_to_notify) > 0) {
+                /* >>> we do callout while holding ch->lock */
+                xpc_notify_senders(ch, ch->reason, ch->w_local_GP.put);
+        }
+
         /* both sides are disconnected now */
 
-        ch->flags = XPC_C_DISCONNECTED; /* clear all flags, but this one */
+        /* it's now safe to free the channel's message queues */
+        xpc_free_msgqueues(ch);
+
+        /* mark disconnected, clear all other flags except XPC_C_WDISCONNECT */
+        ch->flags = (XPC_C_DISCONNECTED | (ch->flags & XPC_C_WDISCONNECT));
 
         atomic_dec(&part->nchannels_active);
 
-        if (ch_flags & XPC_C_WASCONNECTED) {
+        if (channel_was_connected) {
                 dev_info(xpc_chan, "channel %d to partition %d disconnected, "
                         "reason=%d\n", ch->number, ch->partid, ch->reason);
         }
+
+        if (ch->flags & XPC_C_WDISCONNECT) {
+                spin_unlock_irqrestore(&ch->lock, *irq_flags);
+                up(&ch->wdisconnect_sema);
+                spin_lock_irqsave(&ch->lock, *irq_flags);
+
+        } else if (ch->delayed_IPI_flags) {
+                if (part->act_state != XPC_P_DEACTIVATING) {
+                        /* time to take action on any delayed IPI flags */
+                        spin_lock(&part->IPI_lock);
+                        XPC_SET_IPI_FLAGS(part->local_IPI_amo, ch->number,
+                                                        ch->delayed_IPI_flags);
+                        spin_unlock(&part->IPI_lock);
+                }
+                ch->delayed_IPI_flags = 0;
+        }
 }
 
 
@@ -754,6 +827,19 @@ xpc_process_openclose_IPI(struct xpc_partition *part, int ch_number,
 
         spin_lock_irqsave(&ch->lock, irq_flags);
 
+again:
+
+        if ((ch->flags & XPC_C_DISCONNECTED) &&
+                                        (ch->flags & XPC_C_WDISCONNECT)) {
+                /*
+                 * Delay processing IPI flags until thread waiting disconnect
+                 * has had a chance to see that the channel is disconnected.
+                 */
+                ch->delayed_IPI_flags |= IPI_flags;
+                spin_unlock_irqrestore(&ch->lock, irq_flags);
+                return;
+        }
+
 
         if (IPI_flags & XPC_IPI_CLOSEREQUEST) {
 
@@ -764,7 +850,7 @@ xpc_process_openclose_IPI(struct xpc_partition *part, int ch_number,
                 /*
                  * If RCLOSEREQUEST is set, we're probably waiting for
                  * RCLOSEREPLY. We should find it and a ROPENREQUEST packed
-                 * with this RCLOSEQREUQEST in the IPI_flags.
+                 * with this RCLOSEREQUEST in the IPI_flags.
                  */
 
                 if (ch->flags & XPC_C_RCLOSEREQUEST) {
@@ -779,14 +865,22 @@ xpc_process_openclose_IPI(struct xpc_partition *part, int ch_number,
 
                         /* both sides have finished disconnecting */
                         xpc_process_disconnect(ch, &irq_flags);
+                        DBUG_ON(!(ch->flags & XPC_C_DISCONNECTED));
+                        goto again;
                 }
 
                 if (ch->flags & XPC_C_DISCONNECTED) {
-                        // >>> explain this section
-
                         if (!(IPI_flags & XPC_IPI_OPENREQUEST)) {
-                                DBUG_ON(part->act_state !=
-                                                        XPC_P_DEACTIVATING);
+                                if ((XPC_GET_IPI_FLAGS(part->local_IPI_amo,
+                                         ch_number) & XPC_IPI_OPENREQUEST)) {
+
+                                        DBUG_ON(ch->delayed_IPI_flags != 0);
+                                        spin_lock(&part->IPI_lock);
+                                        XPC_SET_IPI_FLAGS(part->local_IPI_amo,
+                                                        ch_number,
+                                                        XPC_IPI_CLOSEREQUEST);
+                                        spin_unlock(&part->IPI_lock);
+                                }
                                 spin_unlock_irqrestore(&ch->lock, irq_flags);
                                 return;
                         }
@@ -816,9 +910,13 @@ xpc_process_openclose_IPI(struct xpc_partition *part, int ch_number,
                         }
 
                         XPC_DISCONNECT_CHANNEL(ch, reason, &irq_flags);
-                } else {
-                        xpc_process_disconnect(ch, &irq_flags);
+
+                        DBUG_ON(IPI_flags & XPC_IPI_CLOSEREPLY);
+                        spin_unlock_irqrestore(&ch->lock, irq_flags);
+                        return;
                 }
+
+                xpc_process_disconnect(ch, &irq_flags);
         }
 
 
@@ -834,7 +932,20 @@ xpc_process_openclose_IPI(struct xpc_partition *part, int ch_number,
                 }
 
                 DBUG_ON(!(ch->flags & XPC_C_CLOSEREQUEST));
-                DBUG_ON(!(ch->flags & XPC_C_RCLOSEREQUEST));
+
+                if (!(ch->flags & XPC_C_RCLOSEREQUEST)) {
+                        if ((XPC_GET_IPI_FLAGS(part->local_IPI_amo, ch_number)
+                                                & XPC_IPI_CLOSEREQUEST)) {
+
+                                DBUG_ON(ch->delayed_IPI_flags != 0);
+                                spin_lock(&part->IPI_lock);
+                                XPC_SET_IPI_FLAGS(part->local_IPI_amo,
+                                                ch_number, XPC_IPI_CLOSEREPLY);
+                                spin_unlock(&part->IPI_lock);
+                        }
+                        spin_unlock_irqrestore(&ch->lock, irq_flags);
+                        return;
+                }
 
                 ch->flags |= XPC_C_RCLOSEREPLY;
 
@@ -852,8 +963,14 @@ xpc_process_openclose_IPI(struct xpc_partition *part, int ch_number,
                         "channel=%d\n", args->msg_size, args->local_nentries,
                         ch->partid, ch->number);
 
-                if ((ch->flags & XPC_C_DISCONNECTING) ||
-                                        part->act_state == XPC_P_DEACTIVATING) {
+                if (part->act_state == XPC_P_DEACTIVATING ||
+                                        (ch->flags & XPC_C_ROPENREQUEST)) {
+                        spin_unlock_irqrestore(&ch->lock, irq_flags);
+                        return;
+                }
+
+                if (ch->flags & (XPC_C_DISCONNECTING | XPC_C_WDISCONNECT)) {
+                        ch->delayed_IPI_flags |= XPC_IPI_OPENREQUEST;
                         spin_unlock_irqrestore(&ch->lock, irq_flags);
                         return;
                 }
@@ -867,8 +984,11 @@ xpc_process_openclose_IPI(struct xpc_partition *part, int ch_number,
                  *      msg_size = size of channel's messages in bytes
                  *      local_nentries = remote partition's local_nentries
                  */
-                DBUG_ON(args->msg_size == 0);
-                DBUG_ON(args->local_nentries == 0);
+                if (args->msg_size == 0 || args->local_nentries == 0) {
+                        /* assume OPENREQUEST was delayed by mistake */
+                        spin_unlock_irqrestore(&ch->lock, irq_flags);
+                        return;
+                }
 
                 ch->flags |= (XPC_C_ROPENREQUEST | XPC_C_CONNECTING);
                 ch->remote_nentries = args->local_nentries;
@@ -906,7 +1026,13 @@ xpc_process_openclose_IPI(struct xpc_partition *part, int ch_number,
                         spin_unlock_irqrestore(&ch->lock, irq_flags);
                         return;
                 }
-                DBUG_ON(!(ch->flags & XPC_C_OPENREQUEST));
+                if (!(ch->flags & XPC_C_OPENREQUEST)) {
+                        XPC_DISCONNECT_CHANNEL(ch, xpcOpenCloseError,
+                                                                &irq_flags);
+                        spin_unlock_irqrestore(&ch->lock, irq_flags);
+                        return;
+                }
+
                 DBUG_ON(!(ch->flags & XPC_C_ROPENREQUEST));
                 DBUG_ON(ch->flags & XPC_C_CONNECTED);
 
@@ -960,8 +1086,8 @@ xpc_connect_channel(struct xpc_channel *ch)
         struct xpc_registration *registration = &xpc_registrations[ch->number];
 
 
-        if (down_interruptible(&registration->sema) != 0) {
-                return xpcInterrupted;
+        if (down_trylock(&registration->sema) != 0) {
+                return xpcRetry;
         }
 
         if (!XPC_CHANNEL_REGISTERED(ch->number)) {
@@ -1040,55 +1166,6 @@ xpc_connect_channel(struct xpc_channel *ch)
 
 
 /*
- * Notify those who wanted to be notified upon delivery of their message.
- */
-static void
-xpc_notify_senders(struct xpc_channel *ch, enum xpc_retval reason, s64 put)
-{
-        struct xpc_notify *notify;
-        u8 notify_type;
-        s64 get = ch->w_remote_GP.get - 1;
-
-
-        while (++get < put && atomic_read(&ch->n_to_notify) > 0) {
-
-                notify = &ch->notify_queue[get % ch->local_nentries];
-
-                /*
-                 * See if the notify entry indicates it was associated with
-                 * a message who's sender wants to be notified. It is possible
-                 * that it is, but someone else is doing or has done the
-                 * notification.
-                 */
-                notify_type = notify->type;
-                if (notify_type == 0 ||
-                                cmpxchg(&notify->type, notify_type, 0) !=
-                                                                notify_type) {
-                        continue;
-                }
-
-                DBUG_ON(notify_type != XPC_N_CALL);
-
-                atomic_dec(&ch->n_to_notify);
-
-                if (notify->func != NULL) {
-                        dev_dbg(xpc_chan, "notify->func() called, notify=0x%p, "
-                                "msg_number=%ld, partid=%d, channel=%d\n",
-                                (void *) notify, get, ch->partid, ch->number);
-
-                        notify->func(reason, ch->partid, ch->number,
-                                                                notify->key);
-
-                        dev_dbg(xpc_chan, "notify->func() returned, "
-                                "notify=0x%p, msg_number=%ld, partid=%d, "
-                                "channel=%d\n", (void *) notify, get,
-                                ch->partid, ch->number);
-                }
-        }
-}
-
-
-/*
  * Clear some of the msg flags in the local message queue.
  */
 static inline void
@@ -1240,6 +1317,7 @@ xpc_process_channel_activity(struct xpc_partition *part)
         u64 IPI_amo, IPI_flags;
         struct xpc_channel *ch;
         int ch_number;
+        u32 ch_flags;
 
 
         IPI_amo = xpc_get_IPI_flags(part);
@@ -1266,8 +1344,9 @@ xpc_process_channel_activity(struct xpc_partition *part)
                         xpc_process_openclose_IPI(part, ch_number, IPI_flags);
                 }
 
+                ch_flags = ch->flags;   /* need an atomic snapshot of flags */
 
-                if (ch->flags & XPC_C_DISCONNECTING) {
+                if (ch_flags & XPC_C_DISCONNECTING) {
                         spin_lock_irqsave(&ch->lock, irq_flags);
                         xpc_process_disconnect(ch, &irq_flags);
                         spin_unlock_irqrestore(&ch->lock, irq_flags);
@@ -1278,9 +1357,9 @@ xpc_process_channel_activity(struct xpc_partition *part)
                         continue;
                 }
 
-                if (!(ch->flags & XPC_C_CONNECTED)) {
-                        if (!(ch->flags & XPC_C_OPENREQUEST)) {
-                                DBUG_ON(ch->flags & XPC_C_SETUP);
+                if (!(ch_flags & XPC_C_CONNECTED)) {
+                        if (!(ch_flags & XPC_C_OPENREQUEST)) {
+                                DBUG_ON(ch_flags & XPC_C_SETUP);
                                 (void) xpc_connect_channel(ch);
                         } else {
                                 spin_lock_irqsave(&ch->lock, irq_flags);
@@ -1305,8 +1384,8 @@ xpc_process_channel_activity(struct xpc_partition *part)
 
 
 /*
- * XPC's heartbeat code calls this function to inform XPC that a partition has
- * gone down.  XPC responds by tearing down the XPartition Communication
+ * XPC's heartbeat code calls this function to inform XPC that a partition is
+ * going down.  XPC responds by tearing down the XPartition Communication
  * infrastructure used for the just downed partition.
  *
  * XPC's heartbeat code will never call this function and xpc_partition_up()
@@ -1314,7 +1393,7 @@ xpc_process_channel_activity(struct xpc_partition *part)
  * at the same time.
  */
 void
-xpc_partition_down(struct xpc_partition *part, enum xpc_retval reason)
+xpc_partition_going_down(struct xpc_partition *part, enum xpc_retval reason)
 {
         unsigned long irq_flags;
         int ch_number;
@@ -1330,12 +1409,11 @@ xpc_partition_down(struct xpc_partition *part, enum xpc_retval reason)
         }
 
 
-        /* disconnect all channels associated with the downed partition */
+        /* disconnect channels associated with the partition going down */
 
         for (ch_number = 0; ch_number < part->nchannels; ch_number++) {
                 ch = &part->channels[ch_number];
 
-
                 xpc_msgqueue_ref(ch);
                 spin_lock_irqsave(&ch->lock, irq_flags);
 
@@ -1370,6 +1448,7 @@ xpc_teardown_infrastructure(struct xpc_partition *part)
          * this partition.
          */
 
+        DBUG_ON(atomic_read(&part->nchannels_engaged) != 0);
         DBUG_ON(atomic_read(&part->nchannels_active) != 0);
         DBUG_ON(part->setup_state != XPC_P_SETUP);
         part->setup_state = XPC_P_WTEARDOWN;
@@ -1428,19 +1507,11 @@ xpc_initiate_connect(int ch_number)
                 if (xpc_part_ref(part)) {
                         ch = &part->channels[ch_number];
 
-                        if (!(ch->flags & XPC_C_DISCONNECTING)) {
-                                DBUG_ON(ch->flags & XPC_C_OPENREQUEST);
-                                DBUG_ON(ch->flags & XPC_C_CONNECTED);
-                                DBUG_ON(ch->flags & XPC_C_SETUP);
-
-                                /*
-                                 * Initiate the establishment of a connection
-                                 * on the newly registered channel to the
-                                 * remote partition.
-                                 */
-                                xpc_wakeup_channel_mgr(part);
-                        }
-
+                        /*
+                         * Initiate the establishment of a connection on the
+                         * newly registered channel to the remote partition.
+                         */
+                        xpc_wakeup_channel_mgr(part);
                         xpc_part_deref(part);
                 }
         }
@@ -1450,9 +1521,6 @@ xpc_initiate_connect(int ch_number)
 void
 xpc_connected_callout(struct xpc_channel *ch)
 {
-        unsigned long irq_flags;
-
-
         /* let the registerer know that a connection has been established */
 
         if (ch->func != NULL) {
@@ -1465,10 +1533,6 @@ xpc_connected_callout(struct xpc_channel *ch)
                 dev_dbg(xpc_chan, "ch->func() returned, reason=xpcConnected, "
                         "partid=%d, channel=%d\n", ch->partid, ch->number);
         }
-
-        spin_lock_irqsave(&ch->lock, irq_flags);
-        ch->flags |= XPC_C_CONNECTCALLOUT;
-        spin_unlock_irqrestore(&ch->lock, irq_flags);
 }
 
 
@@ -1506,8 +1570,12 @@ xpc_initiate_disconnect(int ch_number)
 
                         spin_lock_irqsave(&ch->lock, irq_flags);
 
-                        XPC_DISCONNECT_CHANNEL(ch, xpcUnregistering,
+                        if (!(ch->flags & XPC_C_DISCONNECTED)) {
+                                ch->flags |= XPC_C_WDISCONNECT;
+
+                                XPC_DISCONNECT_CHANNEL(ch, xpcUnregistering,
                                                                 &irq_flags);
+                        }
 
                         spin_unlock_irqrestore(&ch->lock, irq_flags);
 
@@ -1523,8 +1591,9 @@ xpc_initiate_disconnect(int ch_number)
 /*
  * To disconnect a channel, and reflect it back to all who may be waiting.
  *
- * >>> An OPEN is not allowed until XPC_C_DISCONNECTING is cleared by
- * >>> xpc_free_msgqueues().
+ * An OPEN is not allowed until XPC_C_DISCONNECTING is cleared by
+ * xpc_process_disconnect(), and if set, XPC_C_WDISCONNECT is cleared by
+ * xpc_disconnect_wait().
  *
  * THE CHANNEL IS TO BE LOCKED BY THE CALLER AND WILL REMAIN LOCKED UPON RETURN.
  */
@@ -1532,7 +1601,7 @@ void
 xpc_disconnect_channel(const int line, struct xpc_channel *ch,
                         enum xpc_retval reason, unsigned long *irq_flags)
 {
-        u32 flags;
+        u32 channel_was_connected = (ch->flags & XPC_C_CONNECTED);
 
 
         DBUG_ON(!spin_is_locked(&ch->lock));
@@ -1547,61 +1616,53 @@ xpc_disconnect_channel(const int line, struct xpc_channel *ch,
 
         XPC_SET_REASON(ch, reason, line);
 
-        flags = ch->flags;
+        ch->flags |= (XPC_C_CLOSEREQUEST | XPC_C_DISCONNECTING);
         /* some of these may not have been set */
         ch->flags &= ~(XPC_C_OPENREQUEST | XPC_C_OPENREPLY |
                         XPC_C_ROPENREQUEST | XPC_C_ROPENREPLY |
                         XPC_C_CONNECTING | XPC_C_CONNECTED);
 
-        ch->flags |= (XPC_C_CLOSEREQUEST | XPC_C_DISCONNECTING);
         xpc_IPI_send_closerequest(ch, irq_flags);
 
-        if (flags & XPC_C_CONNECTED) {
+        if (channel_was_connected) {
                 ch->flags |= XPC_C_WASCONNECTED;
         }
 
+        spin_unlock_irqrestore(&ch->lock, *irq_flags);
+
+        /* wake all idle kthreads so they can exit */
         if (atomic_read(&ch->kthreads_idle) > 0) {
-                /* wake all idle kthreads so they can exit */
                 wake_up_all(&ch->idle_wq);
         }
 
-        spin_unlock_irqrestore(&ch->lock, *irq_flags);
-
-
         /* wake those waiting to allocate an entry from the local msg queue */
-
         if (atomic_read(&ch->n_on_msg_allocate_wq) > 0) {
                 wake_up(&ch->msg_allocate_wq);
         }
 
-        /* wake those waiting for notify completion */
-
-        if (atomic_read(&ch->n_to_notify) > 0) {
-                xpc_notify_senders(ch, reason, ch->w_local_GP.put);
-        }
-
         spin_lock_irqsave(&ch->lock, *irq_flags);
 }
 
 
 void
-xpc_disconnected_callout(struct xpc_channel *ch)
+xpc_disconnecting_callout(struct xpc_channel *ch)
 {
         /*
-         * Let the channel's registerer know that the channel is now
+         * Let the channel's registerer know that the channel is being
          * disconnected. We don't want to do this if the registerer was never
-         * informed of a connection being made, unless the disconnect was for
-         * abnormal reasons.
+         * informed of a connection being made.
          */
 
         if (ch->func != NULL) {
-                dev_dbg(xpc_chan, "ch->func() called, reason=%d, partid=%d, "
-                        "channel=%d\n", ch->reason, ch->partid, ch->number);
+                dev_dbg(xpc_chan, "ch->func() called, reason=xpcDisconnecting,"
+                        " partid=%d, channel=%d\n", ch->partid, ch->number);
 
-                ch->func(ch->reason, ch->partid, ch->number, NULL, ch->key);
+                ch->func(xpcDisconnecting, ch->partid, ch->number, NULL,
+                                                                ch->key);
 
-                dev_dbg(xpc_chan, "ch->func() returned, reason=%d, partid=%d, "
-                        "channel=%d\n", ch->reason, ch->partid, ch->number);
+                dev_dbg(xpc_chan, "ch->func() returned, reason="
+                        "xpcDisconnecting, partid=%d, channel=%d\n",
+                        ch->partid, ch->number);
         }
 }
 
@@ -1848,7 +1909,7 @@ xpc_send_msg(struct xpc_channel *ch, struct xpc_msg *msg, u8 notify_type,
                         xpc_notify_func func, void *key)
 {
         enum xpc_retval ret = xpcSuccess;
-        struct xpc_notify *notify = NULL;   // >>> to keep the compiler happy!!
+        struct xpc_notify *notify = notify;
         s64 put, msg_number = msg->number;
 
 
diff --git a/arch/ia64/sn/kernel/xpc_main.c b/arch/ia64/sn/kernel/xpc_main.c
index ed7c21586e98..cece3c7c69be 100644
--- a/arch/ia64/sn/kernel/xpc_main.c
+++ b/arch/ia64/sn/kernel/xpc_main.c
@@ -54,6 +54,7 @@
 #include <linux/interrupt.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
+#include <linux/reboot.h>
 #include <asm/sn/intr.h>
 #include <asm/sn/sn_sal.h>
 #include <asm/uaccess.h>
@@ -82,11 +83,17 @@ struct device *xpc_chan = &xpc_chan_dbg_subname;
 
 /* systune related variables for /proc/sys directories */
 
-static int xpc_hb_min = 1;
-static int xpc_hb_max = 10;
+static int xpc_hb_interval = XPC_HB_DEFAULT_INTERVAL;
+static int xpc_hb_min_interval = 1;
+static int xpc_hb_max_interval = 10;
 
-static int xpc_hb_check_min = 10;
-static int xpc_hb_check_max = 120;
+static int xpc_hb_check_interval = XPC_HB_CHECK_DEFAULT_INTERVAL;
+static int xpc_hb_check_min_interval = 10;
+static int xpc_hb_check_max_interval = 120;
+
+int xpc_disengage_request_timelimit = XPC_DISENGAGE_REQUEST_DEFAULT_TIMELIMIT;
+static int xpc_disengage_request_min_timelimit = 0;
+static int xpc_disengage_request_max_timelimit = 120;
 
 static ctl_table xpc_sys_xpc_hb_dir[] = {
         {
@@ -99,7 +106,8 @@ static ctl_table xpc_sys_xpc_hb_dir[] = {
                 &proc_dointvec_minmax,
                 &sysctl_intvec,
                 NULL,
-                &xpc_hb_min, &xpc_hb_max
+                &xpc_hb_min_interval,
+                &xpc_hb_max_interval
         },
         {
                 2,
@@ -111,7 +119,8 @@ static ctl_table xpc_sys_xpc_hb_dir[] = {
                 &proc_dointvec_minmax,
                 &sysctl_intvec,
                 NULL,
-                &xpc_hb_check_min, &xpc_hb_check_max
+                &xpc_hb_check_min_interval,
+                &xpc_hb_check_max_interval
         },
         {0}
 };
@@ -124,6 +133,19 @@ static ctl_table xpc_sys_xpc_dir[] = {
                 0555,
                 xpc_sys_xpc_hb_dir
         },
+        {
+                2,
+                "disengage_request_timelimit",
+                &xpc_disengage_request_timelimit,
+                sizeof(int),
+                0644,
+                NULL,
+                &proc_dointvec_minmax,
+                &sysctl_intvec,
+                NULL,
+                &xpc_disengage_request_min_timelimit,
+                &xpc_disengage_request_max_timelimit
+        },
         {0}
 };
 static ctl_table xpc_sys_dir[] = {
@@ -148,10 +170,10 @@ static DECLARE_WAIT_QUEUE_HEAD(xpc_act_IRQ_wq);
 
 static unsigned long xpc_hb_check_timeout;
 
-/* xpc_hb_checker thread exited notification */
+/* notification that the xpc_hb_checker thread has exited */
 static DECLARE_MUTEX_LOCKED(xpc_hb_checker_exited);
 
-/* xpc_discovery thread exited notification */
+/* notification that the xpc_discovery thread has exited */
 static DECLARE_MUTEX_LOCKED(xpc_discovery_exited);
 
 
@@ -161,6 +183,30 @@ static struct timer_list xpc_hb_timer;
 static void xpc_kthread_waitmsgs(struct xpc_partition *, struct xpc_channel *);
 
 
+static int xpc_system_reboot(struct notifier_block *, unsigned long, void *);
+static struct notifier_block xpc_reboot_notifier = {
+        .notifier_call = xpc_system_reboot,
+};
+
+
+/*
+ * Timer function to enforce the timelimit on the partition disengage request.
+ */
+static void
+xpc_timeout_partition_disengage_request(unsigned long data)
+{
+        struct xpc_partition *part = (struct xpc_partition *) data;
+
+
+        DBUG_ON(jiffies < part->disengage_request_timeout);
+
+        (void) xpc_partition_disengaged(part);
+
+        DBUG_ON(part->disengage_request_timeout != 0);
+        DBUG_ON(xpc_partition_engaged(1UL << XPC_PARTID(part)) != 0);
+}
+
+
 /*
  * Notify the heartbeat check thread that an IRQ has been received.
  */
@@ -214,12 +260,6 @@ xpc_hb_checker(void *ignore)
 
         while (!(volatile int) xpc_exiting) {
 
-                /* wait for IRQ or timeout */
-                (void) wait_event_interruptible(xpc_act_IRQ_wq,
-                            (last_IRQ_count < atomic_read(&xpc_act_IRQ_rcvd) ||
-                                        jiffies >= xpc_hb_check_timeout ||
-                                                (volatile int) xpc_exiting));
-
                 dev_dbg(xpc_part, "woke up with %d ticks rem; %d IRQs have "
                         "been received\n",
                         (int) (xpc_hb_check_timeout - jiffies),
@@ -240,6 +280,7 @@ xpc_hb_checker(void *ignore)
                 }
 
 
+                /* check for outstanding IRQs */
                 new_IRQ_count = atomic_read(&xpc_act_IRQ_rcvd);
                 if (last_IRQ_count < new_IRQ_count || force_IRQ != 0) {
                         force_IRQ = 0;
@@ -257,12 +298,18 @@ xpc_hb_checker(void *ignore)
                         xpc_hb_check_timeout = jiffies +
                                            (xpc_hb_check_interval * HZ);
                 }
+
+                /* wait for IRQ or timeout */
+                (void) wait_event_interruptible(xpc_act_IRQ_wq,
+                            (last_IRQ_count < atomic_read(&xpc_act_IRQ_rcvd) ||
+                                        jiffies >= xpc_hb_check_timeout ||
+                                                (volatile int) xpc_exiting));
         }
 
         dev_dbg(xpc_part, "heartbeat checker is exiting\n");
 
 
-        /* mark this thread as inactive */
+        /* mark this thread as having exited */
         up(&xpc_hb_checker_exited);
         return 0;
 }
@@ -282,7 +329,7 @@ xpc_initiate_discovery(void *ignore)
 
         dev_dbg(xpc_part, "discovery thread is exiting\n");
 
-        /* mark this thread as inactive */
+        /* mark this thread as having exited */
         up(&xpc_discovery_exited);
         return 0;
 }
@@ -309,7 +356,7 @@ xpc_make_first_contact(struct xpc_partition *part)
                         "partition %d\n", XPC_PARTID(part));
 
                 /* wait a 1/4 of a second or so */
-                msleep_interruptible(250);
+                (void) msleep_interruptible(250);
 
                 if (part->act_state == XPC_P_DEACTIVATING) {
                         return part->reason;
@@ -336,7 +383,8 @@ static void
 xpc_channel_mgr(struct xpc_partition *part)
 {
         while (part->act_state != XPC_P_DEACTIVATING ||
-                                atomic_read(&part->nchannels_active) > 0) {
+                        atomic_read(&part->nchannels_active) > 0 ||
+                                        !xpc_partition_disengaged(part)) {
 
                 xpc_process_channel_activity(part);
 
@@ -360,7 +408,8 @@ xpc_channel_mgr(struct xpc_partition *part)
                                 (volatile u64) part->local_IPI_amo != 0 ||
                                 ((volatile u8) part->act_state ==
                                                         XPC_P_DEACTIVATING &&
-                                atomic_read(&part->nchannels_active) == 0)));
+                                atomic_read(&part->nchannels_active) == 0 &&
+                                xpc_partition_disengaged(part))));
                 atomic_set(&part->channel_mgr_requests, 1);
 
                 // >>> Does it need to wakeup periodically as well? In case we
@@ -482,7 +531,7 @@ xpc_activating(void *__partid)
                 return 0;
         }
 
-        XPC_ALLOW_HB(partid, xpc_vars);
+        xpc_allow_hb(partid, xpc_vars);
         xpc_IPI_send_activated(part);
 
 
@@ -492,6 +541,7 @@ xpc_activating(void *__partid)
          */
         (void) xpc_partition_up(part);
 
+        xpc_disallow_hb(partid, xpc_vars);
         xpc_mark_partition_inactive(part);
 
         if (part->reason == xpcReactivating) {
@@ -670,6 +720,7 @@ xpc_daemonize_kthread(void *args)
         struct xpc_partition *part = &xpc_partitions[partid];
         struct xpc_channel *ch;
         int n_needed;
+        unsigned long irq_flags;
 
 
         daemonize("xpc%02dc%d", partid, ch_number);
@@ -680,11 +731,14 @@ xpc_daemonize_kthread(void *args)
         ch = &part->channels[ch_number];
 
         if (!(ch->flags & XPC_C_DISCONNECTING)) {
-                DBUG_ON(!(ch->flags & XPC_C_CONNECTED));
 
                 /* let registerer know that connection has been established */
 
-                if (atomic_read(&ch->kthreads_assigned) == 1) {
+                spin_lock_irqsave(&ch->lock, irq_flags);
+                if (!(ch->flags & XPC_C_CONNECTCALLOUT)) {
+                        ch->flags |= XPC_C_CONNECTCALLOUT;
+                        spin_unlock_irqrestore(&ch->lock, irq_flags);
+
                         xpc_connected_callout(ch);
 
                         /*
@@ -699,16 +753,28 @@ xpc_daemonize_kthread(void *args)
                                         !(ch->flags & XPC_C_DISCONNECTING)) {
                                 xpc_activate_kthreads(ch, n_needed);
                         }
+                } else {
+                        spin_unlock_irqrestore(&ch->lock, irq_flags);
                 }
 
                 xpc_kthread_waitmsgs(part, ch);
         }
 
-        if (atomic_dec_return(&ch->kthreads_assigned) == 0 &&
-                        ((ch->flags & XPC_C_CONNECTCALLOUT) ||
-                                (ch->reason != xpcUnregistering &&
-                                        ch->reason != xpcOtherUnregistering))) {
-                xpc_disconnected_callout(ch);
+        if (atomic_dec_return(&ch->kthreads_assigned) == 0) {
+                spin_lock_irqsave(&ch->lock, irq_flags);
+                if ((ch->flags & XPC_C_CONNECTCALLOUT) &&
+                                !(ch->flags & XPC_C_DISCONNECTCALLOUT)) {
+                        ch->flags |= XPC_C_DISCONNECTCALLOUT;
+                        spin_unlock_irqrestore(&ch->lock, irq_flags);
+
+                        xpc_disconnecting_callout(ch);
+                } else {
+                        spin_unlock_irqrestore(&ch->lock, irq_flags);
+                }
+                if (atomic_dec_return(&part->nchannels_engaged) == 0) {
+                        xpc_mark_partition_disengaged(part);
+                        xpc_IPI_send_disengage(part);
+                }
         }
 
 
@@ -740,12 +806,33 @@ xpc_create_kthreads(struct xpc_channel *ch, int needed)
         unsigned long irq_flags;
         pid_t pid;
         u64 args = XPC_PACK_ARGS(ch->partid, ch->number);
+        struct xpc_partition *part = &xpc_partitions[ch->partid];
 
 
         while (needed-- > 0) {
+
+                /*
+                 * The following is done on behalf of the newly created
+                 * kthread. That kthread is responsible for doing the
+                 * counterpart to the following before it exits.
+                 */
+                (void) xpc_part_ref(part);
+                xpc_msgqueue_ref(ch);
+                if (atomic_inc_return(&ch->kthreads_assigned) == 1 &&
+                    atomic_inc_return(&part->nchannels_engaged) == 1) {
+                        xpc_mark_partition_engaged(part);
+                }
+
                 pid = kernel_thread(xpc_daemonize_kthread, (void *) args, 0);
                 if (pid < 0) {
                         /* the fork failed */
+                        if (atomic_dec_return(&ch->kthreads_assigned) == 0 &&
+                            atomic_dec_return(&part->nchannels_engaged) == 0) {
+                                xpc_mark_partition_disengaged(part);
+                                xpc_IPI_send_disengage(part);
+                        }
+                        xpc_msgqueue_deref(ch);
+                        xpc_part_deref(part);
 
                         if (atomic_read(&ch->kthreads_assigned) <
                                                 ch->kthreads_idle_limit) {
@@ -765,14 +852,6 @@ xpc_create_kthreads(struct xpc_channel *ch, int needed)
                         break;
                 }
 
-                /*
-                 * The following is done on behalf of the newly created
-                 * kthread. That kthread is responsible for doing the
-                 * counterpart to the following before it exits.
-                 */
-                (void) xpc_part_ref(&xpc_partitions[ch->partid]);
-                xpc_msgqueue_ref(ch);
-                atomic_inc(&ch->kthreads_assigned);
                 ch->kthreads_created++; // >>> temporary debug only!!!
         }
 }
@@ -781,87 +860,142 @@ xpc_create_kthreads(struct xpc_channel *ch, int needed)
 void
 xpc_disconnect_wait(int ch_number)
 {
+        unsigned long irq_flags;
         partid_t partid;
         struct xpc_partition *part;
         struct xpc_channel *ch;
+        int wakeup_channel_mgr;
 
 
         /* now wait for all callouts to the caller's function to cease */
         for (partid = 1; partid < XP_MAX_PARTITIONS; partid++) {
                 part = &xpc_partitions[partid];
 
-                if (xpc_part_ref(part)) {
-                        ch = &part->channels[ch_number];
+                if (!xpc_part_ref(part)) {
+                        continue;
+                }
 
-// >>> how do we keep from falling into the window between our check and going
-// >>> down and coming back up where sema is re-inited?
-                        if (ch->flags & XPC_C_SETUP) {
-                                (void) down(&ch->teardown_sema);
-                        }
+                ch = &part->channels[ch_number];
 
+                if (!(ch->flags & XPC_C_WDISCONNECT)) {
                         xpc_part_deref(part);
+                        continue;
+                }
+
+                (void) down(&ch->wdisconnect_sema);
+
+                spin_lock_irqsave(&ch->lock, irq_flags);
+                DBUG_ON(!(ch->flags & XPC_C_DISCONNECTED));
+                wakeup_channel_mgr = 0;
+
+                if (ch->delayed_IPI_flags) {
+                        if (part->act_state != XPC_P_DEACTIVATING) {
+                                spin_lock(&part->IPI_lock);
+                                XPC_SET_IPI_FLAGS(part->local_IPI_amo,
+                                        ch->number, ch->delayed_IPI_flags);
+                                spin_unlock(&part->IPI_lock);
+                                wakeup_channel_mgr = 1;
+                        }
+                        ch->delayed_IPI_flags = 0;
                 }
+
+                ch->flags &= ~XPC_C_WDISCONNECT;
+                spin_unlock_irqrestore(&ch->lock, irq_flags);
+
+                if (wakeup_channel_mgr) {
+                        xpc_wakeup_channel_mgr(part);
+                }
+
+                xpc_part_deref(part);
         }
 }
 
 
 static void
-xpc_do_exit(void)
+xpc_do_exit(enum xpc_retval reason)
 {
         partid_t partid;
         int active_part_count;
         struct xpc_partition *part;
+        unsigned long printmsg_time;
 
 
-        /* now it's time to eliminate our heartbeat */
-        del_timer_sync(&xpc_hb_timer);
-        xpc_vars->heartbeating_to_mask = 0;
-
-        /* indicate to others that our reserved page is uninitialized */
-        xpc_rsvd_page->vars_pa = 0;
-
-        /*
-         * Ignore all incoming interrupts. Without interupts the heartbeat
-         * checker won't activate any new partitions that may come up.
-         */
-        free_irq(SGI_XPC_ACTIVATE, NULL);
+        /* a 'rmmod XPC' and a 'reboot' cannot both end up here together */
+        DBUG_ON(xpc_exiting == 1);
 
         /*
-         * Cause the heartbeat checker and the discovery threads to exit.
-         * We don't want them attempting to activate new partitions as we
-         * try to deactivate the existing ones.
+         * Let the heartbeat checker thread and the discovery thread
+         * (if one is running) know that they should exit. Also wake up
+         * the heartbeat checker thread in case it's sleeping.
          */
         xpc_exiting = 1;
         wake_up_interruptible(&xpc_act_IRQ_wq);
 
-        /* wait for the heartbeat checker thread to mark itself inactive */
-        down(&xpc_hb_checker_exited);
+        /* ignore all incoming interrupts */
+        free_irq(SGI_XPC_ACTIVATE, NULL);
 
-        /* wait for the discovery thread to mark itself inactive */
+        /* wait for the discovery thread to exit */
         down(&xpc_discovery_exited);
 
+        /* wait for the heartbeat checker thread to exit */
+        down(&xpc_hb_checker_exited);
 
-        msleep_interruptible(300);
+
+        /* sleep for a 1/3 of a second or so */
+        (void) msleep_interruptible(300);
 
 
         /* wait for all partitions to become inactive */
 
+        printmsg_time = jiffies;
+
         do {
                 active_part_count = 0;
 
                 for (partid = 1; partid < XP_MAX_PARTITIONS; partid++) {
                         part = &xpc_partitions[partid];
-                        if (part->act_state != XPC_P_INACTIVE) {
-                                active_part_count++;
 
-                                XPC_DEACTIVATE_PARTITION(part, xpcUnloading);
+                        if (xpc_partition_disengaged(part) &&
+                                        part->act_state == XPC_P_INACTIVE) {
+                                continue;
                         }
+
+                        active_part_count++;
+
+                        XPC_DEACTIVATE_PARTITION(part, reason);
                 }
 
-                if (active_part_count)
-                        msleep_interruptible(300);
-        } while (active_part_count > 0);
+                if (active_part_count == 0) {
+                        break;
+                }
 
+                if (jiffies >= printmsg_time) {
+                        dev_info(xpc_part, "waiting for partitions to "
+                                "deactivate/disengage, active count=%d, remote "
+                                "engaged=0x%lx\n", active_part_count,
+                                xpc_partition_engaged(1UL << partid));
+
+                        printmsg_time = jiffies +
+                                        (XPC_DISENGAGE_PRINTMSG_INTERVAL * HZ);
+                }
+
+                /* sleep for a 1/3 of a second or so */
+                (void) msleep_interruptible(300);
+
+        } while (1);
+
+        DBUG_ON(xpc_partition_engaged(-1UL));
+
+
+        /* indicate to others that our reserved page is uninitialized */
+        xpc_rsvd_page->vars_pa = 0;
+
+        /* now it's time to eliminate our heartbeat */
+        del_timer_sync(&xpc_hb_timer);
+        DBUG_ON(xpc_vars->heartbeating_to_mask != 0);
+
+        /* take ourselves off of the reboot_notifier_list */
+        (void) unregister_reboot_notifier(&xpc_reboot_notifier);
 
         /* close down protections for IPI operations */
         xpc_restrict_IPI_ops();
@@ -876,6 +1010,34 @@ xpc_do_exit(void)
 }
 
 
+/*
+ * This function is called when the system is being rebooted.
+ */
+static int
+xpc_system_reboot(struct notifier_block *nb, unsigned long event, void *unused)
+{
+        enum xpc_retval reason;
+
+
+        switch (event) {
+        case SYS_RESTART:
+                reason = xpcSystemReboot;
+                break;
+        case SYS_HALT:
+                reason = xpcSystemHalt;
+                break;
+        case SYS_POWER_OFF:
+                reason = xpcSystemPoweroff;
+                break;
+        default:
+                reason = xpcSystemGoingDown;
+        }
+
+        xpc_do_exit(reason);
+        return NOTIFY_DONE;
+}
+
+
 int __init
 xpc_init(void)
 {
@@ -891,11 +1053,11 @@ xpc_init(void)
 
         /*
          * xpc_remote_copy_buffer is used as a temporary buffer for bte_copy'ng
-         * both a partition's reserved page and its XPC variables. Its size was
-         * based on the size of a reserved page. So we need to ensure that the
-         * XPC variables will fit as well.
+         * various portions of a partition's reserved page. Its size is based
+         * on the size of the reserved page header and part_nasids mask. So we
+         * need to ensure that the other items will fit as well.
          */
-        if (XPC_VARS_ALIGNED_SIZE > XPC_RSVD_PAGE_ALIGNED_SIZE) {
+        if (XPC_RP_VARS_SIZE > XPC_RP_HEADER_SIZE + XP_NASID_MASK_BYTES) {
                 dev_err(xpc_part, "xpc_remote_copy_buffer is not big enough\n");
                 return -EPERM;
         }
@@ -924,6 +1086,12 @@ xpc_init(void)
                 spin_lock_init(&part->act_lock);
                 part->act_state = XPC_P_INACTIVE;
                 XPC_SET_REASON(part, 0, 0);
+
+                init_timer(&part->disengage_request_timer);
+                part->disengage_request_timer.function =
+                                xpc_timeout_partition_disengage_request;
+                part->disengage_request_timer.data = (unsigned long) part;
+
                 part->setup_state = XPC_P_UNSET;
                 init_waitqueue_head(&part->teardown_wq);
                 atomic_set(&part->references, 0);
@@ -980,6 +1148,13 @@ xpc_init(void)
         }
 
 
+        /* add ourselves to the reboot_notifier_list */
+        ret = register_reboot_notifier(&xpc_reboot_notifier);
+        if (ret != 0) {
+                dev_warn(xpc_part, "can't register reboot notifier\n");
+        }
+
+
         /*
          * Set the beating to other partitions into motion.  This is
          * the last requirement for other partitions' discovery to
@@ -1001,6 +1176,9 @@ xpc_init(void)
                 /* indicate to others that our reserved page is uninitialized */
                 xpc_rsvd_page->vars_pa = 0;
 
+                /* take ourselves off of the reboot_notifier_list */
+                (void) unregister_reboot_notifier(&xpc_reboot_notifier);
+
                 del_timer_sync(&xpc_hb_timer);
                 free_irq(SGI_XPC_ACTIVATE, NULL);
                 xpc_restrict_IPI_ops();
@@ -1024,7 +1202,7 @@ xpc_init(void)
                 /* mark this new thread as a non-starter */
                 up(&xpc_discovery_exited);
 
-                xpc_do_exit();
+                xpc_do_exit(xpcUnloading);
                 return -EBUSY;
         }
 
@@ -1043,7 +1221,7 @@ module_init(xpc_init);
 void __exit
 xpc_exit(void)
 {
-        xpc_do_exit();
+        xpc_do_exit(xpcUnloading);
 }
 module_exit(xpc_exit);
 
@@ -1060,3 +1238,7 @@ module_param(xpc_hb_check_interval, int, 0);
 MODULE_PARM_DESC(xpc_hb_check_interval, "Number of seconds between "
                 "heartbeat checks.");
 
+module_param(xpc_disengage_request_timelimit, int, 0);
+MODULE_PARM_DESC(xpc_disengage_request_timelimit, "Number of seconds to wait "
+                "for disengage request to complete.");
+
diff --git a/arch/ia64/sn/kernel/xpc_partition.c b/arch/ia64/sn/kernel/xpc_partition.c
index 578265ea9e67..581e113d2d37 100644
--- a/arch/ia64/sn/kernel/xpc_partition.c
+++ b/arch/ia64/sn/kernel/xpc_partition.c
@@ -44,16 +44,19 @@ static u64 xpc_sh2_IPI_access3;
 
 
 /* original protection values for each node */
-u64 xpc_prot_vec[MAX_COMPACT_NODES];
+u64 xpc_prot_vec[MAX_NUMNODES];
 
 
-/* this partition's reserved page */
+/* this partition's reserved page pointers */
 struct xpc_rsvd_page *xpc_rsvd_page;
-
-/* this partition's XPC variables (within the reserved page) */
+static u64 *xpc_part_nasids;
+static u64 *xpc_mach_nasids;
 struct xpc_vars *xpc_vars;
 struct xpc_vars_part *xpc_vars_part;
 
+static int xp_nasid_mask_bytes; /* actual size in bytes of nasid mask */
+static int xp_nasid_mask_words; /* actual size in words of nasid mask */
+
 
 /*
  * For performance reasons, each entry of xpc_partitions[] is cacheline
@@ -65,20 +68,16 @@ struct xpc_partition xpc_partitions[XP_MAX_PARTITIONS + 1];
 
 
 /*
- * Generic buffer used to store a local copy of the remote partitions
- * reserved page or XPC variables.
+ * Generic buffer used to store a local copy of portions of a remote
+ * partition's reserved page (either its header and part_nasids mask,
+ * or its vars).
  *
  * xpc_discovery runs only once and is a seperate thread that is
  * very likely going to be processing in parallel with receiving
  * interrupts.
  */
-char ____cacheline_aligned
-                xpc_remote_copy_buffer[XPC_RSVD_PAGE_ALIGNED_SIZE];
-
-
-/* systune related variables */
-int xpc_hb_interval = XPC_HB_DEFAULT_INTERVAL;
-int xpc_hb_check_interval = XPC_HB_CHECK_DEFAULT_TIMEOUT;
+char ____cacheline_aligned xpc_remote_copy_buffer[XPC_RP_HEADER_SIZE +
+                                                        XP_NASID_MASK_BYTES];
 
 
 /*
@@ -86,13 +85,16 @@ int xpc_hb_check_interval = XPC_HB_CHECK_DEFAULT_TIMEOUT;
  * for that nasid. This function returns 0 on any error.
  */
 static u64
-xpc_get_rsvd_page_pa(int nasid, u64 buf, u64 buf_size)
+xpc_get_rsvd_page_pa(int nasid)
 {
         bte_result_t bte_res;
         s64 status;
         u64 cookie = 0;
         u64 rp_pa = nasid;      /* seed with nasid */
         u64 len = 0;
+        u64 buf = buf;
+        u64 buf_len = 0;
+        void *buf_base = NULL;
 
 
         while (1) {
@@ -108,13 +110,22 @@ xpc_get_rsvd_page_pa(int nasid, u64 buf, u64 buf_size)
                         break;
                 }
 
-                if (len > buf_size) {
-                        dev_err(xpc_part, "len (=0x%016lx) > buf_size\n", len);
-                        status = SALRET_ERROR;
-                        break;
+                if (L1_CACHE_ALIGN(len) > buf_len) {
+                        if (buf_base != NULL) {
+                                kfree(buf_base);
+                        }
+                        buf_len = L1_CACHE_ALIGN(len);
+                        buf = (u64) xpc_kmalloc_cacheline_aligned(buf_len,
+                                                        GFP_KERNEL, &buf_base);
+                        if (buf_base == NULL) {
+                                dev_err(xpc_part, "unable to kmalloc "
+                                        "len=0x%016lx\n", buf_len);
+                                status = SALRET_ERROR;
+                                break;
+                        }
                 }
 
-                bte_res = xp_bte_copy(rp_pa, ia64_tpa(buf), buf_size,
+                bte_res = xp_bte_copy(rp_pa, ia64_tpa(buf), buf_len,
                                         (BTE_NOTIFY | BTE_WACQUIRE), NULL);
                 if (bte_res != BTE_SUCCESS) {
                         dev_dbg(xpc_part, "xp_bte_copy failed %i\n", bte_res);
@@ -123,6 +134,10 @@ xpc_get_rsvd_page_pa(int nasid, u64 buf, u64 buf_size)
                 }
         }
 
+        if (buf_base != NULL) {
+                kfree(buf_base);
+        }
+
         if (status != SALRET_OK) {
                 rp_pa = 0;
         }
@@ -141,15 +156,15 @@ xpc_rsvd_page_init(void)
 {
         struct xpc_rsvd_page *rp;
         AMO_t *amos_page;
-        u64 rp_pa, next_cl, nasid_array = 0;
+        u64 rp_pa, nasid_array = 0;
         int i, ret;
 
 
         /* get the local reserved page's address */
 
-        rp_pa = xpc_get_rsvd_page_pa(cnodeid_to_nasid(0),
-                                        (u64) xpc_remote_copy_buffer,
-                                                XPC_RSVD_PAGE_ALIGNED_SIZE);
+        preempt_disable();
+        rp_pa = xpc_get_rsvd_page_pa(cpuid_to_nasid(smp_processor_id()));
+        preempt_enable();
         if (rp_pa == 0) {
                 dev_err(xpc_part, "SAL failed to locate the reserved page\n");
                 return NULL;
@@ -164,12 +179,19 @@ xpc_rsvd_page_init(void)
 
         rp->version = XPC_RP_VERSION;
 
-        /*
-         * Place the XPC variables on the cache line following the
-         * reserved page structure.
-         */
-        next_cl = (u64) rp + XPC_RSVD_PAGE_ALIGNED_SIZE;
-        xpc_vars = (struct xpc_vars *) next_cl;
+        /* establish the actual sizes of the nasid masks */
+        if (rp->SAL_version == 1) {
+                /* SAL_version 1 didn't set the nasids_size field */
+                rp->nasids_size = 128;
+        }
+        xp_nasid_mask_bytes = rp->nasids_size;
+        xp_nasid_mask_words = xp_nasid_mask_bytes / 8;
+
+        /* setup the pointers to the various items in the reserved page */
+        xpc_part_nasids = XPC_RP_PART_NASIDS(rp);
+        xpc_mach_nasids = XPC_RP_MACH_NASIDS(rp);
+        xpc_vars = XPC_RP_VARS(rp);
+        xpc_vars_part = XPC_RP_VARS_PART(rp);
 
         /*
          * Before clearing xpc_vars, see if a page of AMOs had been previously
@@ -221,33 +243,32 @@ xpc_rsvd_page_init(void)
                 amos_page = (AMO_t *) TO_AMO((u64) amos_page);
         }
 
+        /* clear xpc_vars */
         memset(xpc_vars, 0, sizeof(struct xpc_vars));
 
-        /*
-         * Place the XPC per partition specific variables on the cache line
-         * following the XPC variables structure.
-         */
-        next_cl += XPC_VARS_ALIGNED_SIZE;
-        memset((u64 *) next_cl, 0, sizeof(struct xpc_vars_part) *
-                                                        XP_MAX_PARTITIONS);
-        xpc_vars_part = (struct xpc_vars_part *) next_cl;
-        xpc_vars->vars_part_pa = __pa(next_cl);
-
         xpc_vars->version = XPC_V_VERSION;
         xpc_vars->act_nasid = cpuid_to_nasid(0);
         xpc_vars->act_phys_cpuid = cpu_physical_id(0);
+        xpc_vars->vars_part_pa = __pa(xpc_vars_part);
+        xpc_vars->amos_page_pa = ia64_tpa((u64) amos_page);
         xpc_vars->amos_page = amos_page;  /* save for next load of XPC */
 
 
-        /*
-         * Initialize the activation related AMO variables.
-         */
-        xpc_vars->act_amos = xpc_IPI_init(XP_MAX_PARTITIONS);
-        for (i = 1; i < XP_NASID_MASK_WORDS; i++) {
-                xpc_IPI_init(i + XP_MAX_PARTITIONS);
+        /* clear xpc_vars_part */
+        memset((u64 *) xpc_vars_part, 0, sizeof(struct xpc_vars_part) *
+                                                        XP_MAX_PARTITIONS);
+
+        /* initialize the activate IRQ related AMO variables */
+        for (i = 0; i < xp_nasid_mask_words; i++) {
+                (void) xpc_IPI_init(XPC_ACTIVATE_IRQ_AMOS + i);
         }
-        /* export AMO page's physical address to other partitions */
-        xpc_vars->amos_page_pa = ia64_tpa((u64) xpc_vars->amos_page);
+
+        /* initialize the engaged remote partitions related AMO variables */
+        (void) xpc_IPI_init(XPC_ENGAGED_PARTITIONS_AMO);
+        (void) xpc_IPI_init(XPC_DISENGAGE_REQUEST_AMO);
+
+        /* timestamp of when reserved page was setup by XPC */
+        rp->stamp = CURRENT_TIME;
 
         /*
          * This signifies to the remote partition that our reserved
@@ -387,6 +408,11 @@ xpc_check_remote_hb(void)
         remote_vars = (struct xpc_vars *) xpc_remote_copy_buffer;
 
         for (partid = 1; partid < XP_MAX_PARTITIONS; partid++) {
+
+                if (xpc_exiting) {
+                        break;
+                }
+
                 if (partid == sn_partition_id) {
                         continue;
                 }
@@ -401,7 +427,7 @@ xpc_check_remote_hb(void)
                 /* pull the remote_hb cache line */
                 bres = xp_bte_copy(part->remote_vars_pa,
                                         ia64_tpa((u64) remote_vars),
-                                        XPC_VARS_ALIGNED_SIZE,
+                                        XPC_RP_VARS_SIZE,
                                         (BTE_NOTIFY | BTE_WACQUIRE), NULL);
                 if (bres != BTE_SUCCESS) {
                         XPC_DEACTIVATE_PARTITION(part,
@@ -417,7 +443,7 @@ xpc_check_remote_hb(void)
 
                 if (((remote_vars->heartbeat == part->last_heartbeat) &&
                         (remote_vars->kdb_status == 0)) ||
-                             !XPC_HB_ALLOWED(sn_partition_id, remote_vars)) {
+                             !xpc_hb_allowed(sn_partition_id, remote_vars)) {
 
                         XPC_DEACTIVATE_PARTITION(part, xpcNoHeartbeat);
                         continue;
@@ -429,31 +455,31 @@ xpc_check_remote_hb(void)
 
 
 /*
- * Get a copy of the remote partition's rsvd page.
+ * Get a copy of a portion of the remote partition's rsvd page.
  *
  * remote_rp points to a buffer that is cacheline aligned for BTE copies and
- * assumed to be of size XPC_RSVD_PAGE_ALIGNED_SIZE.
+ * is large enough to contain a copy of their reserved page header and
+ * part_nasids mask.
  */
 static enum xpc_retval
 xpc_get_remote_rp(int nasid, u64 *discovered_nasids,
-                struct xpc_rsvd_page *remote_rp, u64 *remote_rsvd_page_pa)
+                struct xpc_rsvd_page *remote_rp, u64 *remote_rp_pa)
 {
         int bres, i;
 
 
         /* get the reserved page's physical address */
 
-        *remote_rsvd_page_pa = xpc_get_rsvd_page_pa(nasid, (u64) remote_rp,
-                                                XPC_RSVD_PAGE_ALIGNED_SIZE);
-        if (*remote_rsvd_page_pa == 0) {
+        *remote_rp_pa = xpc_get_rsvd_page_pa(nasid);
+        if (*remote_rp_pa == 0) {
                 return xpcNoRsvdPageAddr;
         }
 
 
-        /* pull over the reserved page structure */
+        /* pull over the reserved page header and part_nasids mask */
 
-        bres = xp_bte_copy(*remote_rsvd_page_pa, ia64_tpa((u64) remote_rp),
-                                XPC_RSVD_PAGE_ALIGNED_SIZE,
+        bres = xp_bte_copy(*remote_rp_pa, ia64_tpa((u64) remote_rp),
+                                XPC_RP_HEADER_SIZE + xp_nasid_mask_bytes,
                                 (BTE_NOTIFY | BTE_WACQUIRE), NULL);
         if (bres != BTE_SUCCESS) {
                 return xpc_map_bte_errors(bres);
@@ -461,8 +487,11 @@ xpc_get_remote_rp(int nasid, u64 *discovered_nasids,
 
 
         if (discovered_nasids != NULL) {
-                for (i = 0; i < XP_NASID_MASK_WORDS; i++) {
-                        discovered_nasids[i] |= remote_rp->part_nasids[i];
+                u64 *remote_part_nasids = XPC_RP_PART_NASIDS(remote_rp);
+
+
+                for (i = 0; i < xp_nasid_mask_words; i++) {
+                        discovered_nasids[i] |= remote_part_nasids[i];
                 }
         }
 
@@ -489,10 +518,10 @@ xpc_get_remote_rp(int nasid, u64 *discovered_nasids,
 
 
 /*
- * Get a copy of the remote partition's XPC variables.
+ * Get a copy of the remote partition's XPC variables from the reserved page.
  *
  * remote_vars points to a buffer that is cacheline aligned for BTE copies and
- * assumed to be of size XPC_VARS_ALIGNED_SIZE.
+ * assumed to be of size XPC_RP_VARS_SIZE.
  */
 static enum xpc_retval
 xpc_get_remote_vars(u64 remote_vars_pa, struct xpc_vars *remote_vars)
@@ -508,7 +537,7 @@ xpc_get_remote_vars(u64 remote_vars_pa, struct xpc_vars *remote_vars)
         /* pull over the cross partition variables */
 
         bres = xp_bte_copy(remote_vars_pa, ia64_tpa((u64) remote_vars),
-                                XPC_VARS_ALIGNED_SIZE,
+                                XPC_RP_VARS_SIZE,
                                 (BTE_NOTIFY | BTE_WACQUIRE), NULL);
         if (bres != BTE_SUCCESS) {
                 return xpc_map_bte_errors(bres);
@@ -524,7 +553,56 @@ xpc_get_remote_vars(u64 remote_vars_pa, struct xpc_vars *remote_vars)
 
 
 /*
- * Prior code has determine the nasid which generated an IPI.  Inspect
+ * Update the remote partition's info.
+ */
+static void
+xpc_update_partition_info(struct xpc_partition *part, u8 remote_rp_version,
+                struct timespec *remote_rp_stamp, u64 remote_rp_pa,
+                u64 remote_vars_pa, struct xpc_vars *remote_vars)
+{
+        part->remote_rp_version = remote_rp_version;
+        dev_dbg(xpc_part, "  remote_rp_version = 0x%016lx\n",
+                part->remote_rp_version);
+
+        part->remote_rp_stamp = *remote_rp_stamp;
+        dev_dbg(xpc_part, "  remote_rp_stamp (tv_sec = 0x%lx tv_nsec = 0x%lx\n",
+                part->remote_rp_stamp.tv_sec, part->remote_rp_stamp.tv_nsec);
+
+        part->remote_rp_pa = remote_rp_pa;
+        dev_dbg(xpc_part, "  remote_rp_pa = 0x%016lx\n", part->remote_rp_pa);
+
+        part->remote_vars_pa = remote_vars_pa;
+        dev_dbg(xpc_part, "  remote_vars_pa = 0x%016lx\n",
+                part->remote_vars_pa);
+
+        part->last_heartbeat = remote_vars->heartbeat;
+        dev_dbg(xpc_part, "  last_heartbeat = 0x%016lx\n",
+                part->last_heartbeat);
+
+        part->remote_vars_part_pa = remote_vars->vars_part_pa;
+        dev_dbg(xpc_part, "  remote_vars_part_pa = 0x%016lx\n",
+                part->remote_vars_part_pa);
+
+        part->remote_act_nasid = remote_vars->act_nasid;
+        dev_dbg(xpc_part, "  remote_act_nasid = 0x%x\n",
+                part->remote_act_nasid);
+
+        part->remote_act_phys_cpuid = remote_vars->act_phys_cpuid;
+        dev_dbg(xpc_part, "  remote_act_phys_cpuid = 0x%x\n",
+                part->remote_act_phys_cpuid);
+
+        part->remote_amos_page_pa = remote_vars->amos_page_pa;
+        dev_dbg(xpc_part, "  remote_amos_page_pa = 0x%lx\n",
+                part->remote_amos_page_pa);
+
+        part->remote_vars_version = remote_vars->version;
+        dev_dbg(xpc_part, "  remote_vars_version = 0x%x\n",
+                part->remote_vars_version);
+}
+
+
+/*
+ * Prior code has determined the nasid which generated an IPI.  Inspect
  * that nasid to determine if its partition needs to be activated or
  * deactivated.
  *
@@ -542,8 +620,12 @@ xpc_identify_act_IRQ_req(int nasid)
 {
         struct xpc_rsvd_page *remote_rp;
         struct xpc_vars *remote_vars;
-        u64 remote_rsvd_page_pa;
+        u64 remote_rp_pa;
         u64 remote_vars_pa;
+        int remote_rp_version;
+        int reactivate = 0;
+        int stamp_diff;
+        struct timespec remote_rp_stamp = { 0, 0 };
         partid_t partid;
         struct xpc_partition *part;
         enum xpc_retval ret;
@@ -553,7 +635,7 @@ xpc_identify_act_IRQ_req(int nasid)
 
         remote_rp = (struct xpc_rsvd_page *) xpc_remote_copy_buffer;
 
-        ret = xpc_get_remote_rp(nasid, NULL, remote_rp, &remote_rsvd_page_pa);
+        ret = xpc_get_remote_rp(nasid, NULL, remote_rp, &remote_rp_pa);
         if (ret != xpcSuccess) {
                 dev_warn(xpc_part, "unable to get reserved page from nasid %d, "
                         "which sent interrupt, reason=%d\n", nasid, ret);
@@ -561,6 +643,10 @@ xpc_identify_act_IRQ_req(int nasid)
         }
 
         remote_vars_pa = remote_rp->vars_pa;
+        remote_rp_version = remote_rp->version;
+        if (XPC_SUPPORTS_RP_STAMP(remote_rp_version)) {
+                remote_rp_stamp = remote_rp->stamp;
+        }
         partid = remote_rp->partid;
         part = &xpc_partitions[partid];
 
@@ -586,44 +672,117 @@ xpc_identify_act_IRQ_req(int nasid)
                 "%ld:0x%lx\n", (int) nasid, (int) partid, part->act_IRQ_rcvd,
                 remote_vars->heartbeat, remote_vars->heartbeating_to_mask);
 
+        if (xpc_partition_disengaged(part) &&
+                                        part->act_state == XPC_P_INACTIVE) {
 
-        if (part->act_state == XPC_P_INACTIVE) {
+                xpc_update_partition_info(part, remote_rp_version,
+                                        &remote_rp_stamp, remote_rp_pa,
+                                        remote_vars_pa, remote_vars);
 
-                part->remote_rp_pa = remote_rsvd_page_pa;
-                dev_dbg(xpc_part, "  remote_rp_pa = 0x%016lx\n",
-                        part->remote_rp_pa);
+                if (XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version)) {
+                        if (xpc_partition_disengage_requested(1UL << partid)) {
+                                /*
+                                 * Other side is waiting on us to disengage,
+                                 * even though we already have.
+                                 */
+                                return;
+                        }
+                } else {
+                        /* other side doesn't support disengage requests */
+                        xpc_clear_partition_disengage_request(1UL << partid);
+                }
 
-                part->remote_vars_pa = remote_vars_pa;
-                dev_dbg(xpc_part, "  remote_vars_pa = 0x%016lx\n",
-                        part->remote_vars_pa);
+                xpc_activate_partition(part);
+                return;
+        }
 
-                part->last_heartbeat = remote_vars->heartbeat;
-                dev_dbg(xpc_part, "  last_heartbeat = 0x%016lx\n",
-                        part->last_heartbeat);
+        DBUG_ON(part->remote_rp_version == 0);
+        DBUG_ON(part->remote_vars_version == 0);
+
+        if (!XPC_SUPPORTS_RP_STAMP(part->remote_rp_version)) {
+                DBUG_ON(XPC_SUPPORTS_DISENGAGE_REQUEST(part->
+                                                        remote_vars_version));
+
+                if (!XPC_SUPPORTS_RP_STAMP(remote_rp_version)) {
+                        DBUG_ON(XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars->
+                                                                version));
+                        /* see if the other side rebooted */
+                        if (part->remote_amos_page_pa ==
+                                remote_vars->amos_page_pa &&
+                                        xpc_hb_allowed(sn_partition_id,
+                                                                remote_vars)) {
+                                /* doesn't look that way, so ignore the IPI */
+                                return;
+                        }
+                }
 
-                part->remote_vars_part_pa = remote_vars->vars_part_pa;
-                dev_dbg(xpc_part, "  remote_vars_part_pa = 0x%016lx\n",
-                        part->remote_vars_part_pa);
+                /*
+                 * Other side rebooted and previous XPC didn't support the
+                 * disengage request, so we don't need to do anything special.
+                 */
 
-                part->remote_act_nasid = remote_vars->act_nasid;
-                dev_dbg(xpc_part, "  remote_act_nasid = 0x%x\n",
-                        part->remote_act_nasid);
+                xpc_update_partition_info(part, remote_rp_version,
+                                                &remote_rp_stamp, remote_rp_pa,
+                                                remote_vars_pa, remote_vars);
+                part->reactivate_nasid = nasid;
+                XPC_DEACTIVATE_PARTITION(part, xpcReactivating);
+                return;
+        }
 
-                part->remote_act_phys_cpuid = remote_vars->act_phys_cpuid;
-                dev_dbg(xpc_part, "  remote_act_phys_cpuid = 0x%x\n",
-                        part->remote_act_phys_cpuid);
+        DBUG_ON(!XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version));
 
-                part->remote_amos_page_pa = remote_vars->amos_page_pa;
-                dev_dbg(xpc_part, "  remote_amos_page_pa = 0x%lx\n",
-                        part->remote_amos_page_pa);
+        if (!XPC_SUPPORTS_RP_STAMP(remote_rp_version)) {
+                DBUG_ON(!XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars->version));
 
-                xpc_activate_partition(part);
+                /*
+                 * Other side rebooted and previous XPC did support the
+                 * disengage request, but the new one doesn't.
+                 */
+
+                xpc_clear_partition_engaged(1UL << partid);
+                xpc_clear_partition_disengage_request(1UL << partid);
 
-        } else if (part->remote_amos_page_pa != remote_vars->amos_page_pa ||
-                        !XPC_HB_ALLOWED(sn_partition_id, remote_vars)) {
+                xpc_update_partition_info(part, remote_rp_version,
+                                                &remote_rp_stamp, remote_rp_pa,
+                                                remote_vars_pa, remote_vars);
+                reactivate = 1;
+
+        } else {
+                DBUG_ON(!XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars->version));
 
+                stamp_diff = xpc_compare_stamps(&part->remote_rp_stamp,
+                                                        &remote_rp_stamp);
+                if (stamp_diff != 0) {
+                        DBUG_ON(stamp_diff >= 0);
+
+                        /*
+                         * Other side rebooted and the previous XPC did support
+                         * the disengage request, as does the new one.
+                         */
+
+                        DBUG_ON(xpc_partition_engaged(1UL << partid));
+                        DBUG_ON(xpc_partition_disengage_requested(1UL <<
+                                                                partid));
+
+                        xpc_update_partition_info(part, remote_rp_version,
+                                                &remote_rp_stamp, remote_rp_pa,
+                                                remote_vars_pa, remote_vars);
+                        reactivate = 1;
+                }
+        }
+
+        if (!xpc_partition_disengaged(part)) {
+                /* still waiting on other side to disengage from us */
+                return;
+        }
+
+        if (reactivate) {
                 part->reactivate_nasid = nasid;
                 XPC_DEACTIVATE_PARTITION(part, xpcReactivating);
+
+        } else if (XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version) &&
+                        xpc_partition_disengage_requested(1UL << partid)) {
+                XPC_DEACTIVATE_PARTITION(part, xpcOtherGoingDown);
         }
 }
 
@@ -643,14 +802,17 @@ xpc_identify_act_IRQ_sender(void)
         u64 nasid;                      /* remote nasid */
         int n_IRQs_detected = 0;
         AMO_t *act_amos;
-        struct xpc_rsvd_page *rp = (struct xpc_rsvd_page *) xpc_rsvd_page;
 
 
-        act_amos = xpc_vars->act_amos;
+        act_amos = xpc_vars->amos_page + XPC_ACTIVATE_IRQ_AMOS;
 
 
         /* scan through act AMO variable looking for non-zero entries */
-        for (word = 0; word < XP_NASID_MASK_WORDS; word++) {
+        for (word = 0; word < xp_nasid_mask_words; word++) {
+
+                if (xpc_exiting) {
+                        break;
+                }
 
                 nasid_mask = xpc_IPI_receive(&act_amos[word]);
                 if (nasid_mask == 0) {
@@ -668,7 +830,7 @@ xpc_identify_act_IRQ_sender(void)
                  * remote nasid in our reserved pages machine mask.
                  * This is used in the event of module reload.
                  */
-                rp->mach_nasids[word] |= nasid_mask;
+                xpc_mach_nasids[word] |= nasid_mask;
 
 
                 /* locate the nasid(s) which sent interrupts */
@@ -688,6 +850,55 @@ xpc_identify_act_IRQ_sender(void)
 
 
 /*
+ * See if the other side has responded to a partition disengage request
+ * from us.
+ */
+int
+xpc_partition_disengaged(struct xpc_partition *part)
+{
+        partid_t partid = XPC_PARTID(part);
+        int disengaged;
+
+
+        disengaged = (xpc_partition_engaged(1UL << partid) == 0);
+        if (part->disengage_request_timeout) {
+                if (!disengaged) {
+                        if (jiffies < part->disengage_request_timeout) {
+                                /* timelimit hasn't been reached yet */
+                                return 0;
+                        }
+
+                        /*
+                         * Other side hasn't responded to our disengage
+                         * request in a timely fashion, so assume it's dead.
+                         */
+
+                        xpc_clear_partition_engaged(1UL << partid);
+                        disengaged = 1;
+                }
+                part->disengage_request_timeout = 0;
+
+                /* cancel the timer function, provided it's not us */
+                if (!in_interrupt()) {
+                        del_singleshot_timer_sync(&part->
+                                                      disengage_request_timer);
+                }
+
+                DBUG_ON(part->act_state != XPC_P_DEACTIVATING &&
+                                        part->act_state != XPC_P_INACTIVE);
+                if (part->act_state != XPC_P_INACTIVE) {
+                        xpc_wakeup_channel_mgr(part);
+                }
+
+                if (XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version)) {
+                        xpc_cancel_partition_disengage_request(part);
+                }
+        }
+        return disengaged;
+}
+
+
+/*
  * Mark specified partition as active.
  */
 enum xpc_retval
@@ -721,7 +932,6 @@ xpc_deactivate_partition(const int line, struct xpc_partition *part,
                                 enum xpc_retval reason)
 {
         unsigned long irq_flags;
-        partid_t partid = XPC_PARTID(part);
 
 
         spin_lock_irqsave(&part->act_lock, irq_flags);
@@ -749,17 +959,27 @@ xpc_deactivate_partition(const int line, struct xpc_partition *part,
 
         spin_unlock_irqrestore(&part->act_lock, irq_flags);
 
-        XPC_DISALLOW_HB(partid, xpc_vars);
+        if (XPC_SUPPORTS_DISENGAGE_REQUEST(part->remote_vars_version)) {
+                xpc_request_partition_disengage(part);
+                xpc_IPI_send_disengage(part);
 
-        dev_dbg(xpc_part, "bringing partition %d down, reason = %d\n", partid,
-                reason);
+                /* set a timelimit on the disengage request */
+                part->disengage_request_timeout = jiffies +
+                                        (xpc_disengage_request_timelimit * HZ);
+                part->disengage_request_timer.expires =
+                                        part->disengage_request_timeout;
+                add_timer(&part->disengage_request_timer);
+        }
+
+        dev_dbg(xpc_part, "bringing partition %d down, reason = %d\n",
+                XPC_PARTID(part), reason);
 
-        xpc_partition_down(part, reason);
+        xpc_partition_going_down(part, reason);
 }
 
 
 /*
- * Mark specified partition as active.
+ * Mark specified partition as inactive.
  */
 void
 xpc_mark_partition_inactive(struct xpc_partition *part)
@@ -792,9 +1012,10 @@ xpc_discovery(void)
         void *remote_rp_base;
         struct xpc_rsvd_page *remote_rp;
         struct xpc_vars *remote_vars;
-        u64 remote_rsvd_page_pa;
+        u64 remote_rp_pa;
         u64 remote_vars_pa;
         int region;
+        int region_size;
         int max_regions;
         int nasid;
         struct xpc_rsvd_page *rp;
@@ -804,7 +1025,8 @@ xpc_discovery(void)
         enum xpc_retval ret;
 
 
-        remote_rp = xpc_kmalloc_cacheline_aligned(XPC_RSVD_PAGE_ALIGNED_SIZE,
+        remote_rp = xpc_kmalloc_cacheline_aligned(XPC_RP_HEADER_SIZE +
+                                                xp_nasid_mask_bytes,
                                                 GFP_KERNEL, &remote_rp_base);
         if (remote_rp == NULL) {
                 return;
@@ -812,13 +1034,13 @@ xpc_discovery(void)
         remote_vars = (struct xpc_vars *) remote_rp;
 
 
-        discovered_nasids = kmalloc(sizeof(u64) * XP_NASID_MASK_WORDS,
+        discovered_nasids = kmalloc(sizeof(u64) * xp_nasid_mask_words,
                                                         GFP_KERNEL);
         if (discovered_nasids == NULL) {
                 kfree(remote_rp_base);
                 return;
         }
-        memset(discovered_nasids, 0, sizeof(u64) * XP_NASID_MASK_WORDS);
+        memset(discovered_nasids, 0, sizeof(u64) * xp_nasid_mask_words);
 
         rp = (struct xpc_rsvd_page *) xpc_rsvd_page;
 
@@ -827,11 +1049,19 @@ xpc_discovery(void)
          * nodes that can comprise an access protection grouping. The access
          * protection is in regards to memory, IOI and IPI.
          */
-//>>> move the next two #defines into either include/asm-ia64/sn/arch.h or
-//>>> include/asm-ia64/sn/addrs.h
-#define SH1_MAX_REGIONS         64
-#define SH2_MAX_REGIONS         256
-        max_regions = is_shub2() ? SH2_MAX_REGIONS : SH1_MAX_REGIONS;
+        max_regions = 64;
+        region_size = sn_region_size;
+
+        switch (region_size) {
+        case 128:
+                max_regions *= 2;
+        case 64:
+                max_regions *= 2;
+        case 32:
+                max_regions *= 2;
+                region_size = 16;
+                DBUG_ON(!is_shub2());
+        }
 
         for (region = 0; region < max_regions; region++) {
 
@@ -841,8 +1071,8 @@ xpc_discovery(void)
 
                 dev_dbg(xpc_part, "searching region %d\n", region);
 
-                for (nasid = (region * sn_region_size * 2);
-                     nasid < ((region + 1) * sn_region_size * 2);
+                for (nasid = (region * region_size * 2);
+                     nasid < ((region + 1) * region_size * 2);
                      nasid += 2) {
 
                         if ((volatile int) xpc_exiting) {
@@ -852,14 +1082,14 @@ xpc_discovery(void)
                         dev_dbg(xpc_part, "checking nasid %d\n", nasid);
 
 
-                        if (XPC_NASID_IN_ARRAY(nasid, rp->part_nasids)) {
+                        if (XPC_NASID_IN_ARRAY(nasid, xpc_part_nasids)) {
                                 dev_dbg(xpc_part, "PROM indicates Nasid %d is "
                                         "part of the local partition; skipping "
                                         "region\n", nasid);
                                 break;
                         }
 
-                        if (!(XPC_NASID_IN_ARRAY(nasid, rp->mach_nasids))) {
+                        if (!(XPC_NASID_IN_ARRAY(nasid, xpc_mach_nasids))) {
                                 dev_dbg(xpc_part, "PROM indicates Nasid %d was "
                                         "not on Numa-Link network at reset\n",
                                         nasid);
@@ -877,7 +1107,7 @@ xpc_discovery(void)
                         /* pull over the reserved page structure */
 
                         ret = xpc_get_remote_rp(nasid, discovered_nasids,
-                                              remote_rp, &remote_rsvd_page_pa);
+                                              remote_rp, &remote_rp_pa);
                         if (ret != xpcSuccess) {
                                 dev_dbg(xpc_part, "unable to get reserved page "
                                         "from nasid %d, reason=%d\n", nasid,
@@ -948,6 +1178,13 @@ xpc_discovery(void)
                                 remote_vars->act_nasid,
                                 remote_vars->act_phys_cpuid);
 
+                        if (XPC_SUPPORTS_DISENGAGE_REQUEST(remote_vars->
+                                                                version)) {
+                                part->remote_amos_page_pa =
+                                                remote_vars->amos_page_pa;
+                                xpc_mark_partition_disengaged(part);
+                                xpc_cancel_partition_disengage_request(part);
+                        }
                         xpc_IPI_send_activate(remote_vars);
                 }
         }
@@ -974,12 +1211,12 @@ xpc_initiate_partid_to_nasids(partid_t partid, void *nasid_mask)
                 return xpcPartitionDown;
         }
 
-        part_nasid_pa = part->remote_rp_pa +
-                (u64) &((struct xpc_rsvd_page *) 0)->part_nasids;
+        memset(nasid_mask, 0, XP_NASID_MASK_BYTES);
+
+        part_nasid_pa = (u64) XPC_RP_PART_NASIDS(part->remote_rp_pa);
 
         bte_res = xp_bte_copy(part_nasid_pa, ia64_tpa((u64) nasid_mask),
-                                L1_CACHE_ALIGN(XP_NASID_MASK_BYTES),
-                                (BTE_NOTIFY | BTE_WACQUIRE), NULL);
+                        xp_nasid_mask_bytes, (BTE_NOTIFY | BTE_WACQUIRE), NULL);
 
         return xpc_map_bte_errors(bte_res);
 }
diff --git a/arch/ia64/sn/pci/pci_dma.c b/arch/ia64/sn/pci/pci_dma.c
index 75e6e874bebf..9bf9f23b9a1f 100644
--- a/arch/ia64/sn/pci/pci_dma.c
+++ b/arch/ia64/sn/pci/pci_dma.c
@@ -326,6 +326,29 @@ int sn_pci_legacy_read(struct pci_bus *bus, u16 port, u32 *val, u8 size)
 {
         unsigned long addr;
         int ret;
+        struct ia64_sal_retval isrv;
+
+        /*
+         * First, try the SN_SAL_IOIF_PCI_SAFE SAL call which can work
+         * around hw issues at the pci bus level.  SGI proms older than
+         * 4.10 don't implment this.
+         */
+
+        SAL_CALL(isrv, SN_SAL_IOIF_PCI_SAFE,
+                pci_domain_nr(bus), bus->number,
+                0, /* io */
+                0, /* read */
+                port, size, __pa(val));
+
+        if (isrv.status == 0)
+                return size;
+
+        /*
+         * If the above failed, retry using the SAL_PROBE call which should
+         * be present in all proms (but which cannot work round PCI chipset
+         * bugs).  This code is retained for compatability with old
+         * pre-4.10 proms, and should be removed at some point in the future.
+         */
 
         if (!SN_PCIBUS_BUSSOFT(bus))
                 return -ENODEV;
@@ -349,6 +372,29 @@ int sn_pci_legacy_write(struct pci_bus *bus, u16 port, u32 val, u8 size)
         int ret = size;
         unsigned long paddr;
         unsigned long *addr;
+        struct ia64_sal_retval isrv;
+
+        /*
+         * First, try the SN_SAL_IOIF_PCI_SAFE SAL call which can work
+         * around hw issues at the pci bus level.  SGI proms older than
+         * 4.10 don't implment this.
+         */
+
+        SAL_CALL(isrv, SN_SAL_IOIF_PCI_SAFE,
+                pci_domain_nr(bus), bus->number,
+                0, /* io */
+                1, /* write */
+                port, size, __pa(&val));
+
+        if (isrv.status == 0)
+                return size;
+
+        /*
+         * If the above failed, retry using the SAL_PROBE call which should
+         * be present in all proms (but which cannot work round PCI chipset
+         * bugs).  This code is retained for compatability with old
+         * pre-4.10 proms, and should be removed at some point in the future.
+         */
 
         if (!SN_PCIBUS_BUSSOFT(bus)) {
                 ret = -ENODEV;
diff --git a/arch/ia64/sn/pci/pcibr/pcibr_reg.c b/arch/ia64/sn/pci/pcibr/pcibr_reg.c
index 21426d02fbe6..4f718c3e93d3 100644
--- a/arch/ia64/sn/pci/pcibr/pcibr_reg.c
+++ b/arch/ia64/sn/pci/pcibr/pcibr_reg.c
@@ -8,6 +8,7 @@
 
 #include <linux/interrupt.h>
 #include <linux/types.h>
+#include <asm/sn/io.h>
 #include <asm/sn/pcibr_provider.h>
 #include <asm/sn/pcibus_provider_defs.h>
 #include <asm/sn/pcidev.h>
@@ -29,10 +30,10 @@ void pcireg_control_bit_clr(struct pcibus_info *pcibus_info, uint64_t bits)
         if (pcibus_info) {
                 switch (pcibus_info->pbi_bridge_type) {
                 case PCIBR_BRIDGETYPE_TIOCP:
-                        ptr->tio.cp_control &= ~bits;
+                        __sn_clrq_relaxed(&ptr->tio.cp_control, bits);
                         break;
                 case PCIBR_BRIDGETYPE_PIC:
-                        ptr->pic.p_wid_control &= ~bits;
+                        __sn_clrq_relaxed(&ptr->pic.p_wid_control, bits);
                         break;
                 default:
                         panic
@@ -49,10 +50,10 @@ void pcireg_control_bit_set(struct pcibus_info *pcibus_info, uint64_t bits)
         if (pcibus_info) {
                 switch (pcibus_info->pbi_bridge_type) {
                 case PCIBR_BRIDGETYPE_TIOCP:
-                        ptr->tio.cp_control |= bits;
+                        __sn_setq_relaxed(&ptr->tio.cp_control, bits);
                         break;
                 case PCIBR_BRIDGETYPE_PIC:
-                        ptr->pic.p_wid_control |= bits;
+                        __sn_setq_relaxed(&ptr->pic.p_wid_control, bits);
                         break;
                 default:
                         panic
@@ -73,10 +74,10 @@ uint64_t pcireg_tflush_get(struct pcibus_info *pcibus_info)
         if (pcibus_info) {
                 switch (pcibus_info->pbi_bridge_type) {
                 case PCIBR_BRIDGETYPE_TIOCP:
-                        ret = ptr->tio.cp_tflush;
+                        ret = __sn_readq_relaxed(&ptr->tio.cp_tflush);
                         break;
                 case PCIBR_BRIDGETYPE_PIC:
-                        ret = ptr->pic.p_wid_tflush;
+                        ret = __sn_readq_relaxed(&ptr->pic.p_wid_tflush);
                         break;
                 default:
                         panic
@@ -103,10 +104,10 @@ uint64_t pcireg_intr_status_get(struct pcibus_info * pcibus_info)
         if (pcibus_info) {
                 switch (pcibus_info->pbi_bridge_type) {
                 case PCIBR_BRIDGETYPE_TIOCP:
-                        ret = ptr->tio.cp_int_status;
+                        ret = __sn_readq_relaxed(&ptr->tio.cp_int_status);
                         break;
                 case PCIBR_BRIDGETYPE_PIC:
-                        ret = ptr->pic.p_int_status;
+                        ret = __sn_readq_relaxed(&ptr->pic.p_int_status);
                         break;
                 default:
                         panic
@@ -127,10 +128,10 @@ void pcireg_intr_enable_bit_clr(struct pcibus_info *pcibus_info, uint64_t bits)
         if (pcibus_info) {
                 switch (pcibus_info->pbi_bridge_type) {
                 case PCIBR_BRIDGETYPE_TIOCP:
-                        ptr->tio.cp_int_enable &= ~bits;
+                        __sn_clrq_relaxed(&ptr->tio.cp_int_enable, bits);
                         break;
                 case PCIBR_BRIDGETYPE_PIC:
-                        ptr->pic.p_int_enable &= ~bits;
+                        __sn_clrq_relaxed(&ptr->pic.p_int_enable, ~bits);
                         break;
                 default:
                         panic
@@ -147,10 +148,10 @@ void pcireg_intr_enable_bit_set(struct pcibus_info *pcibus_info, uint64_t bits)
         if (pcibus_info) {
                 switch (pcibus_info->pbi_bridge_type) {
                 case PCIBR_BRIDGETYPE_TIOCP:
-                        ptr->tio.cp_int_enable |= bits;
+                        __sn_setq_relaxed(&ptr->tio.cp_int_enable, bits);
                         break;
                 case PCIBR_BRIDGETYPE_PIC:
-                        ptr->pic.p_int_enable |= bits;
+                        __sn_setq_relaxed(&ptr->pic.p_int_enable, bits);
                         break;
                 default:
                         panic
@@ -171,14 +172,16 @@ void pcireg_intr_addr_addr_set(struct pcibus_info *pcibus_info, int int_n,
         if (pcibus_info) {
                 switch (pcibus_info->pbi_bridge_type) {
                 case PCIBR_BRIDGETYPE_TIOCP:
-                        ptr->tio.cp_int_addr[int_n] &= ~TIOCP_HOST_INTR_ADDR;
-                        ptr->tio.cp_int_addr[int_n] |=
-                            (addr & TIOCP_HOST_INTR_ADDR);
+                        __sn_clrq_relaxed(&ptr->tio.cp_int_addr[int_n],
+                            TIOCP_HOST_INTR_ADDR);
+                        __sn_setq_relaxed(&ptr->tio.cp_int_addr[int_n],
+                            (addr & TIOCP_HOST_INTR_ADDR));
                         break;
                 case PCIBR_BRIDGETYPE_PIC:
-                        ptr->pic.p_int_addr[int_n] &= ~PIC_HOST_INTR_ADDR;
-                        ptr->pic.p_int_addr[int_n] |=
-                            (addr & PIC_HOST_INTR_ADDR);
+                        __sn_clrq_relaxed(&ptr->pic.p_int_addr[int_n],
+                            PIC_HOST_INTR_ADDR);
+                        __sn_setq_relaxed(&ptr->pic.p_int_addr[int_n],
+                            (addr & PIC_HOST_INTR_ADDR));
                         break;
                 default:
                         panic
@@ -198,10 +201,10 @@ void pcireg_force_intr_set(struct pcibus_info *pcibus_info, int int_n)
         if (pcibus_info) {
                 switch (pcibus_info->pbi_bridge_type) {
                 case PCIBR_BRIDGETYPE_TIOCP:
-                        ptr->tio.cp_force_pin[int_n] = 1;
+                        writeq(1, &ptr->tio.cp_force_pin[int_n]);
                         break;
                 case PCIBR_BRIDGETYPE_PIC:
-                        ptr->pic.p_force_pin[int_n] = 1;
+                        writeq(1, &ptr->pic.p_force_pin[int_n]);
                         break;
                 default:
                         panic
@@ -222,10 +225,12 @@ uint64_t pcireg_wrb_flush_get(struct pcibus_info *pcibus_info, int device)
         if (pcibus_info) {
                 switch (pcibus_info->pbi_bridge_type) {
                 case PCIBR_BRIDGETYPE_TIOCP:
-                        ret = ptr->tio.cp_wr_req_buf[device];
+                        ret =
+                            __sn_readq_relaxed(&ptr->tio.cp_wr_req_buf[device]);
                         break;
                 case PCIBR_BRIDGETYPE_PIC:
-                        ret = ptr->pic.p_wr_req_buf[device];
+                        ret =
+                            __sn_readq_relaxed(&ptr->pic.p_wr_req_buf[device]);
                         break;
                 default:
                       panic("pcireg_wrb_flush_get: unknown bridgetype bridge 0x%p", (void *)ptr);
@@ -244,10 +249,10 @@ void pcireg_int_ate_set(struct pcibus_info *pcibus_info, int ate_index,
         if (pcibus_info) {
                 switch (pcibus_info->pbi_bridge_type) {
                 case PCIBR_BRIDGETYPE_TIOCP:
-                        ptr->tio.cp_int_ate_ram[ate_index] = (uint64_t) val;
+                        writeq(val, &ptr->tio.cp_int_ate_ram[ate_index]);
                         break;
                 case PCIBR_BRIDGETYPE_PIC:
-                        ptr->pic.p_int_ate_ram[ate_index] = (uint64_t) val;
+                        writeq(val, &ptr->pic.p_int_ate_ram[ate_index]);
                         break;
                 default:
                         panic
@@ -265,12 +270,10 @@ uint64_t *pcireg_int_ate_addr(struct pcibus_info *pcibus_info, int ate_index)
         if (pcibus_info) {
                 switch (pcibus_info->pbi_bridge_type) {
                 case PCIBR_BRIDGETYPE_TIOCP:
-                        ret =
-                            (uint64_t *) & (ptr->tio.cp_int_ate_ram[ate_index]);
+                        ret = &ptr->tio.cp_int_ate_ram[ate_index];
                         break;
                 case PCIBR_BRIDGETYPE_PIC:
-                        ret =
-                            (uint64_t *) & (ptr->pic.p_int_ate_ram[ate_index]);
+                        ret = &ptr->pic.p_int_ate_ram[ate_index];
                         break;
                 default:
                         panic
diff --git a/arch/ia64/sn/pci/tioca_provider.c b/arch/ia64/sn/pci/tioca_provider.c
index 19bced34d5f1..46b646a6d345 100644
--- a/arch/ia64/sn/pci/tioca_provider.c
+++ b/arch/ia64/sn/pci/tioca_provider.c
@@ -11,6 +11,7 @@
 #include <linux/pci.h>
 #include <asm/sn/sn_sal.h>
 #include <asm/sn/addrs.h>
+#include <asm/sn/io.h>
 #include <asm/sn/pcidev.h>
 #include <asm/sn/pcibus_provider_defs.h>
 #include <asm/sn/tioca_provider.h>
@@ -37,7 +38,7 @@ tioca_gart_init(struct tioca_kernel *tioca_kern)
         uint64_t offset;
         struct page *tmp;
         struct tioca_common *tioca_common;
-        volatile struct tioca *ca_base;
+        struct tioca *ca_base;
 
         tioca_common = tioca_kern->ca_common;
         ca_base = (struct tioca *)tioca_common->ca_common.bs_base;
@@ -174,27 +175,29 @@ tioca_gart_init(struct tioca_kernel *tioca_kern)
          *      DISABLE GART PREFETCHING due to hw bug tracked in SGI PV930029
          */
 
-        ca_base->ca_control1 |= CA_AGPDMA_OP_ENB_COMBDELAY;     /* PV895469 ? */
-        ca_base->ca_control2 &= ~(CA_GART_MEM_PARAM);
-        ca_base->ca_control2 |= (0x2ull << CA_GART_MEM_PARAM_SHFT);
+        __sn_setq_relaxed(&ca_base->ca_control1,
+                        CA_AGPDMA_OP_ENB_COMBDELAY);    /* PV895469 ? */
+        __sn_clrq_relaxed(&ca_base->ca_control2, CA_GART_MEM_PARAM);
+        __sn_setq_relaxed(&ca_base->ca_control2,
+                        (0x2ull << CA_GART_MEM_PARAM_SHFT));
         tioca_kern->ca_gart_iscoherent = 1;
-        ca_base->ca_control2 &=
-            ~(CA_GART_WR_PREFETCH_ENB | CA_GART_RD_PREFETCH_ENB);
+        __sn_clrq_relaxed(&ca_base->ca_control2,
+                        (CA_GART_WR_PREFETCH_ENB | CA_GART_RD_PREFETCH_ENB));
 
         /*
          * Unmask GART fetch error interrupts.  Clear residual errors first.
          */
 
-        ca_base->ca_int_status_alias = CA_GART_FETCH_ERR;
-        ca_base->ca_mult_error_alias = CA_GART_FETCH_ERR;
-        ca_base->ca_int_mask &= ~CA_GART_FETCH_ERR;
+        writeq(CA_GART_FETCH_ERR, &ca_base->ca_int_status_alias);
+        writeq(CA_GART_FETCH_ERR, &ca_base->ca_mult_error_alias);
+        __sn_clrq_relaxed(&ca_base->ca_int_mask, CA_GART_FETCH_ERR);
 
         /*
          * Program the aperature and gart registers in TIOCA
          */
 
-        ca_base->ca_gart_aperature = ap_reg;
-        ca_base->ca_gart_ptr_table = tioca_kern->ca_gart_coretalk_addr | 1;
+        writeq(ap_reg, &ca_base->ca_gart_aperature);
+        writeq(tioca_kern->ca_gart_coretalk_addr|1, &ca_base->ca_gart_ptr_table);
 
         return 0;
 }
@@ -211,7 +214,6 @@ void
 tioca_fastwrite_enable(struct tioca_kernel *tioca_kern)
 {
         int cap_ptr;
-        uint64_t ca_control1;
         uint32_t reg;
         struct tioca *tioca_base;
         struct pci_dev *pdev;
@@ -256,9 +258,7 @@ tioca_fastwrite_enable(struct tioca_kernel *tioca_kern)
          */
 
         tioca_base = (struct tioca *)common->ca_common.bs_base;
-        ca_control1 = tioca_base->ca_control1;
-        ca_control1 |= CA_AGP_FW_ENABLE;
-        tioca_base->ca_control1 = ca_control1;
+        __sn_setq_relaxed(&tioca_base->ca_control1, CA_AGP_FW_ENABLE);
 }
 
 EXPORT_SYMBOL(tioca_fastwrite_enable);  /* used by agp-sgi */
@@ -345,7 +345,7 @@ tioca_dma_d48(struct pci_dev *pdev, uint64_t paddr)
                 return 0;
         }
 
-        agp_dma_extn = ca_base->ca_agp_dma_addr_extn;
+        agp_dma_extn = __sn_readq_relaxed(&ca_base->ca_agp_dma_addr_extn);
         if (node_upper != (agp_dma_extn >> CA_AGP_DMA_NODE_ID_SHFT)) {
                 printk(KERN_ERR "%s:  coretalk upper node (%u) "
                        "mismatch with ca_agp_dma_addr_extn (%lu)\n",
diff --git a/arch/ia64/sn/pci/tioce_provider.c b/arch/ia64/sn/pci/tioce_provider.c
index 8e75db2b825d..9f03d4e5121c 100644
--- a/arch/ia64/sn/pci/tioce_provider.c
+++ b/arch/ia64/sn/pci/tioce_provider.c
@@ -11,6 +11,7 @@
 #include <linux/pci.h>
 #include <asm/sn/sn_sal.h>
 #include <asm/sn/addrs.h>
+#include <asm/sn/io.h>
 #include <asm/sn/pcidev.h>
 #include <asm/sn/pcibus_provider_defs.h>
 #include <asm/sn/tioce_provider.h>
@@ -227,7 +228,7 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
 
                 ate = ATE_MAKE(addr, pagesize);
                 ate_shadow[i + j] = ate;
-                ate_reg[i + j] = ate;
+                writeq(ate, &ate_reg[i + j]);
                 addr += pagesize;
         }
 
@@ -268,10 +269,10 @@ tioce_dma_d32(struct pci_dev *pdev, uint64_t ct_addr)
         pcidev_to_tioce(pdev, &ce_mmr, &ce_kern, &port);
 
         if (ce_kern->ce_port[port].dirmap_refcnt == 0) {
-                volatile uint64_t tmp;
+                uint64_t tmp;
 
                 ce_kern->ce_port[port].dirmap_shadow = ct_upper;
-                ce_mmr->ce_ure_dir_map[port] = ct_upper;
+                writeq(ct_upper, &ce_mmr->ce_ure_dir_map[port]);
                 tmp = ce_mmr->ce_ure_dir_map[port];
                 dma_ok = 1;
         } else
@@ -343,7 +344,7 @@ tioce_dma_unmap(struct pci_dev *pdev, dma_addr_t bus_addr, int dir)
         if (TIOCE_D32_ADDR(bus_addr)) {
                 if (--ce_kern->ce_port[port].dirmap_refcnt == 0) {
                         ce_kern->ce_port[port].dirmap_shadow = 0;
-                        ce_mmr->ce_ure_dir_map[port] = 0;
+                        writeq(0, &ce_mmr->ce_ure_dir_map[port]);
                 }
         } else {
                 struct tioce_dmamap *map;
@@ -582,18 +583,18 @@ tioce_kern_init(struct tioce_common *tioce_common)
          */
 
         tioce_mmr = (struct tioce *)tioce_common->ce_pcibus.bs_base;
-        tioce_mmr->ce_ure_page_map &= ~CE_URE_PAGESIZE_MASK;
-        tioce_mmr->ce_ure_page_map |= CE_URE_256K_PAGESIZE;
+        __sn_clrq_relaxed(&tioce_mmr->ce_ure_page_map, CE_URE_PAGESIZE_MASK);
+        __sn_setq_relaxed(&tioce_mmr->ce_ure_page_map, CE_URE_256K_PAGESIZE);
         tioce_kern->ce_ate3240_pagesize = KB(256);
 
         for (i = 0; i < TIOCE_NUM_M40_ATES; i++) {
                 tioce_kern->ce_ate40_shadow[i] = 0;
-                tioce_mmr->ce_ure_ate40[i] = 0;
+                writeq(0, &tioce_mmr->ce_ure_ate40[i]);
         }
 
         for (i = 0; i < TIOCE_NUM_M3240_ATES; i++) {
                 tioce_kern->ce_ate3240_shadow[i] = 0;
-                tioce_mmr->ce_ure_ate3240[i] = 0;
+                writeq(0, &tioce_mmr->ce_ure_ate3240[i]);
         }
 
         return tioce_kern;
@@ -665,7 +666,7 @@ tioce_force_interrupt(struct sn_irq_info *sn_irq_info)
         default:
                 return;
         }
-        ce_mmr->ce_adm_force_int = force_int_val;
+        writeq(force_int_val, &ce_mmr->ce_adm_force_int);
 }
 
 /**
@@ -686,6 +687,7 @@ tioce_target_interrupt(struct sn_irq_info *sn_irq_info)
         struct tioce_common *ce_common;
         struct tioce *ce_mmr;
         int bit;
+        uint64_t vector;
 
         pcidev_info = (struct pcidev_info *)sn_irq_info->irq_pciioinfo;
         if (!pcidev_info)
@@ -696,11 +698,11 @@ tioce_target_interrupt(struct sn_irq_info *sn_irq_info)
 
         bit = sn_irq_info->irq_int_bit;
 
-        ce_mmr->ce_adm_int_mask |= (1UL << bit);
-        ce_mmr->ce_adm_int_dest[bit] =
-                ((uint64_t)sn_irq_info->irq_irq << INTR_VECTOR_SHFT) |
-                           sn_irq_info->irq_xtalkaddr;
-        ce_mmr->ce_adm_int_mask &= ~(1UL << bit);
+        __sn_setq_relaxed(&ce_mmr->ce_adm_int_mask, (1UL << bit));
+        vector = (uint64_t)sn_irq_info->irq_irq << INTR_VECTOR_SHFT;
+        vector |= sn_irq_info->irq_xtalkaddr;
+        writeq(vector, &ce_mmr->ce_adm_int_dest[bit]);
+        __sn_clrq_relaxed(&ce_mmr->ce_adm_int_mask, (1UL << bit));
 
         tioce_force_interrupt(sn_irq_info);
 }
diff --git a/drivers/Makefile b/drivers/Makefile
index 1a109a6dd953..65670be6ff1a 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -5,7 +5,7 @@
 # Rewritten to use lists instead of if-statements.
 #
 
-obj-$(CONFIG_PCI)               += pci/
+obj-$(CONFIG_PCI)               += pci/ usb/
 obj-$(CONFIG_PARISC)            += parisc/
 obj-y                           += video/
 obj-$(CONFIG_ACPI)              += acpi/
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 15e6a8f951f1..0d2e101e4f15 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -30,23 +30,6 @@ LIST_HEAD(dpm_off_irq);
 DECLARE_MUTEX(dpm_sem);
 DECLARE_MUTEX(dpm_list_sem);
 
-/*
- * PM Reference Counting.
- */
-
-static inline void device_pm_hold(struct device * dev)
-{
-        if (dev)
-                atomic_inc(&dev->power.pm_users);
-}
-
-static inline void device_pm_release(struct device * dev)
-{
-        if (dev)
-                atomic_dec(&dev->power.pm_users);
-}
-
-
 /**
  *      device_pm_set_parent - Specify power dependency.
  *      @dev:           Device who needs power.
@@ -62,10 +45,8 @@ static inline void device_pm_release(struct device * dev)
 
 void device_pm_set_parent(struct device * dev, struct device * parent)
 {
-        struct device * old_parent = dev->power.pm_parent;
-        device_pm_release(old_parent);
-        dev->power.pm_parent = parent;
-        device_pm_hold(parent);
+        put_device(dev->power.pm_parent);
+        dev->power.pm_parent = get_device(parent);
 }
 EXPORT_SYMBOL_GPL(device_pm_set_parent);
 
@@ -75,7 +56,6 @@ int device_pm_add(struct device * dev)
 
         pr_debug("PM: Adding info for %s:%s\n",
                  dev->bus ? dev->bus->name : "No Bus", dev->kobj.name);
-        atomic_set(&dev->power.pm_users, 0);
         down(&dpm_list_sem);
         list_add_tail(&dev->power.entry, &dpm_active);
         device_pm_set_parent(dev, dev->parent);
@@ -91,7 +71,7 @@ void device_pm_remove(struct device * dev)
                  dev->bus ? dev->bus->name : "No Bus", dev->kobj.name);
         down(&dpm_list_sem);
         dpm_sysfs_remove(dev);
-        device_pm_release(dev->power.pm_parent);
+        put_device(dev->power.pm_parent);
         list_del_init(&dev->power.entry);
         up(&dpm_list_sem);
 }
diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
index 2e700d795cf1..fb3d35a9e101 100644
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -67,9 +67,6 @@ extern int suspend_device(struct device *, pm_message_t);
  * runtime.c
  */
 
-extern int dpm_runtime_suspend(struct device *, pm_message_t);
-extern void dpm_runtime_resume(struct device *);
-
 #else /* CONFIG_PM */
 
 
@@ -82,14 +79,4 @@ static inline void device_pm_remove(struct device * dev)
 
 }
 
-static inline int dpm_runtime_suspend(struct device * dev, pm_message_t state)
-{
-        return 0;
-}
-
-static inline void dpm_runtime_resume(struct device * dev)
-{
-
-}
-
 #endif
diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
index e8f0519f5dfa..adbc3148c039 100644
--- a/drivers/base/power/runtime.c
+++ b/drivers/base/power/runtime.c
@@ -36,6 +36,7 @@ void dpm_runtime_resume(struct device * dev)
         runtime_resume(dev);
         up(&dpm_sem);
 }
+EXPORT_SYMBOL(dpm_runtime_resume);
 
 
 /**
diff --git a/drivers/block/ub.c b/drivers/block/ub.c
index ed4d5006fe62..bfb23d543ff7 100644
--- a/drivers/block/ub.c
+++ b/drivers/block/ub.c
@@ -1512,7 +1512,7 @@ static void ub_state_sense(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
         scmd->nsg = 1;
         sg = &scmd->sgv[0];
         sg->page = virt_to_page(sc->top_sense);
-        sg->offset = (unsigned int)sc->top_sense & (PAGE_SIZE-1);
+        sg->offset = (unsigned long)sc->top_sense & (PAGE_SIZE-1);
         sg->length = UB_SENSE_SIZE;
         scmd->len = UB_SENSE_SIZE;
         scmd->lun = cmd->lun;
@@ -1891,7 +1891,7 @@ static int ub_sync_read_cap(struct ub_dev *sc, struct ub_lun *lun,
         cmd->nsg = 1;
         sg = &cmd->sgv[0];
         sg->page = virt_to_page(p);
-        sg->offset = (unsigned int)p & (PAGE_SIZE-1);
+        sg->offset = (unsigned long)p & (PAGE_SIZE-1);
         sg->length = 8;
         cmd->len = 8;
         cmd->lun = lun;
diff --git a/drivers/char/agp/sgi-agp.c b/drivers/char/agp/sgi-agp.c
index d3aa159c9dec..7957fc91f6ad 100644
--- a/drivers/char/agp/sgi-agp.c
+++ b/drivers/char/agp/sgi-agp.c
@@ -17,6 +17,7 @@
 #include <linux/init.h>
 #include <linux/agp_backend.h>
 #include <asm/sn/addrs.h>
+#include <asm/sn/io.h>
 #include <asm/sn/pcidev.h>
 #include <asm/sn/pcibus_provider_defs.h>
 #include <asm/sn/tioca_provider.h>
diff --git a/drivers/char/mmtimer.c b/drivers/char/mmtimer.c
index 12006182f575..78c89a3e7825 100644
--- a/drivers/char/mmtimer.c
+++ b/drivers/char/mmtimer.c
@@ -441,7 +441,7 @@ static irqreturn_t
 mmtimer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
         int i;
-        mmtimer_t *base = timers + cpuid_to_cnodeid(smp_processor_id()) *
+        mmtimer_t *base = timers + cpu_to_node(smp_processor_id()) *
                                                 NUM_COMPARATORS;
         unsigned long expires = 0;
         int result = IRQ_NONE;
@@ -608,7 +608,7 @@ static int sgi_timer_set(struct k_itimer *timr, int flags,
          */
         preempt_disable();
 
-        nodeid =  cpuid_to_cnodeid(smp_processor_id());
+        nodeid =  cpu_to_node(smp_processor_id());
         base = timers + nodeid * NUM_COMPARATORS;
 retry:
         /* Don't use an allocated timer, or a deleted one that's pending */
diff --git a/drivers/char/snsc.c b/drivers/char/snsc.c
index 1758a83327e5..0e7d216e7eb0 100644
--- a/drivers/char/snsc.c
+++ b/drivers/char/snsc.c
@@ -377,7 +377,7 @@ scdrv_init(void)
         dev_t first_dev, dev;
         nasid_t event_nasid = ia64_sn_get_console_nasid();
 
-        if (alloc_chrdev_region(&first_dev, 0, numionodes,
+        if (alloc_chrdev_region(&first_dev, 0, num_cnodes,
                                 SYSCTL_BASENAME) < 0) {
                 printk("%s: failed to register SN system controller device\n",
                        __FUNCTION__);
@@ -385,7 +385,7 @@ scdrv_init(void)
         }
         snsc_class = class_create(THIS_MODULE, SYSCTL_BASENAME);
 
-        for (cnode = 0; cnode < numionodes; cnode++) {
+        for (cnode = 0; cnode < num_cnodes; cnode++) {
                         geoid = cnodeid_get_geoid(cnode);
                         devnamep = devname;
                         format_module_id(devnamep, geo_module(geoid),
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index ee1605906a3e..bbd9c2323d8c 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -7,6 +7,9 @@
  *
  *  Copyright (c) 1999 Martin Mares <mj@ucw.cz>
  *
+ *  Init/reset quirks for USB host controllers should be in the
+ *  USB quirks file, where their drivers can access reuse it.
+ *
  *  The bridge optimization stuff has been removed. If you really
  *  have a silly BIOS which is unable to set your host bridge right,
  *  use the PowerTweak utility (see http://powertweak.sourceforge.net).
@@ -645,28 +648,6 @@ static void quirk_via_irq(struct pci_dev *dev)
 DECLARE_PCI_FIXUP_ENABLE(PCI_VENDOR_ID_VIA, PCI_ANY_ID, quirk_via_irq);
 
 /*
- * PIIX3 USB: We have to disable USB interrupts that are
- * hardwired to PIRQD# and may be shared with an
- * external device.
- *
- * Legacy Support Register (LEGSUP):
- *     bit13:  USB PIRQ Enable (USBPIRQDEN),
- *     bit4:   Trap/SMI On IRQ Enable (USBSMIEN).
- *
- * We mask out all r/wc bits, too.
- */
-static void __devinit quirk_piix3_usb(struct pci_dev *dev)
-{
-        u16 legsup;
-
-        pci_read_config_word(dev, 0xc0, &legsup);
-        legsup &= 0x50ef;
-        pci_write_config_word(dev, 0xc0, legsup);
-}
-DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL,   PCI_DEVICE_ID_INTEL_82371SB_2,  quirk_piix3_usb );
-DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL,   PCI_DEVICE_ID_INTEL_82371AB_2,  quirk_piix3_usb );
-
-/*
  * VIA VT82C598 has its device ID settable and many BIOSes
  * set it to the ID of VT82C597 for backward compatibility.
  * We need to switch it off to be able to recognize the real
@@ -1039,234 +1020,6 @@ static void __init quirk_sis_96x_smbus(struct pci_dev *dev)
         pci_read_config_byte(dev, 0x77, &val);
 }
 
-
-#define UHCI_USBLEGSUP          0xc0            /* legacy support */
-#define UHCI_USBCMD             0               /* command register */
-#define UHCI_USBSTS             2               /* status register */
-#define UHCI_USBINTR            4               /* interrupt register */
-#define UHCI_USBLEGSUP_DEFAULT  0x2000          /* only PIRQ enable set */
-#define UHCI_USBCMD_RUN         (1 << 0)        /* RUN/STOP bit */
-#define UHCI_USBCMD_GRESET      (1 << 2)        /* Global reset */
-#define UHCI_USBCMD_CONFIGURE   (1 << 6)        /* config semaphore */
-#define UHCI_USBSTS_HALTED      (1 << 5)        /* HCHalted bit */
-
-#define OHCI_CONTROL            0x04
-#define OHCI_CMDSTATUS          0x08
-#define OHCI_INTRSTATUS         0x0c
-#define OHCI_INTRENABLE         0x10
-#define OHCI_INTRDISABLE        0x14
-#define OHCI_OCR                (1 << 3)        /* ownership change request */
-#define OHCI_CTRL_IR            (1 << 8)        /* interrupt routing */
-#define OHCI_INTR_OC            (1 << 30)       /* ownership change */
-
-#define EHCI_HCC_PARAMS         0x08            /* extended capabilities */
-#define EHCI_USBCMD             0               /* command register */
-#define EHCI_USBCMD_RUN         (1 << 0)        /* RUN/STOP bit */
-#define EHCI_USBSTS             4               /* status register */
-#define EHCI_USBSTS_HALTED      (1 << 12)       /* HCHalted bit */
-#define EHCI_USBINTR            8               /* interrupt register */
-#define EHCI_USBLEGSUP          0               /* legacy support register */
-#define EHCI_USBLEGSUP_BIOS     (1 << 16)       /* BIOS semaphore */
-#define EHCI_USBLEGSUP_OS       (1 << 24)       /* OS semaphore */
-#define EHCI_USBLEGCTLSTS       4               /* legacy control/status */
-#define EHCI_USBLEGCTLSTS_SOOE  (1 << 13)       /* SMI on ownership change */
-
-int usb_early_handoff __devinitdata = 0;
-static int __init usb_handoff_early(char *str)
-{
-        usb_early_handoff = 1;
-        return 0;
-}
-__setup("usb-handoff", usb_handoff_early);
-
-static void __devinit quirk_usb_handoff_uhci(struct pci_dev *pdev)
-{
-        unsigned long base = 0;
-        int wait_time, delta;
-        u16 val, sts;
-        int i;
-
-        for (i = 0; i < PCI_ROM_RESOURCE; i++)
-                if ((pci_resource_flags(pdev, i) & IORESOURCE_IO)) {
-                        base = pci_resource_start(pdev, i);
-                        break;
-                }
-
-        if (!base)
-                return;
-
-        /*
-         * stop controller
-         */
-        sts = inw(base + UHCI_USBSTS);
-        val = inw(base + UHCI_USBCMD);
-        val &= ~(u16)(UHCI_USBCMD_RUN | UHCI_USBCMD_CONFIGURE);
-        outw(val, base + UHCI_USBCMD);
-
-        /*
-         * wait while it stops if it was running
-         */
-        if ((sts & UHCI_USBSTS_HALTED) == 0)
-        {
-                wait_time = 1000;
-                delta = 100;
-
-                do {
-                        outw(0x1f, base + UHCI_USBSTS);
-                        udelay(delta);
-                        wait_time -= delta;
-                        val = inw(base + UHCI_USBSTS);
-                        if (val & UHCI_USBSTS_HALTED)
-                                break;
-                } while (wait_time > 0);
-        }
-
-        /*
-         * disable interrupts & legacy support
-         */
-        outw(0, base + UHCI_USBINTR);
-        outw(0x1f, base + UHCI_USBSTS);
-        pci_read_config_word(pdev, UHCI_USBLEGSUP, &val);
-        if (val & 0xbf) 
-                pci_write_config_word(pdev, UHCI_USBLEGSUP, UHCI_USBLEGSUP_DEFAULT);
-                
-}
-
-static void __devinit quirk_usb_handoff_ohci(struct pci_dev *pdev)
-{
-        void __iomem *base;
-        int wait_time;
-
-        base = ioremap_nocache(pci_resource_start(pdev, 0),
-                                     pci_resource_len(pdev, 0));
-        if (base == NULL) return;
-
-        if (readl(base + OHCI_CONTROL) & OHCI_CTRL_IR) {
-                wait_time = 500; /* 0.5 seconds */
-                writel(OHCI_INTR_OC, base + OHCI_INTRENABLE);
-                writel(OHCI_OCR, base + OHCI_CMDSTATUS);
-                while (wait_time > 0 && 
-                                readl(base + OHCI_CONTROL) & OHCI_CTRL_IR) {
-                        wait_time -= 10;
-                        msleep(10);
-                }
-        }
-
-        /*
-         * disable interrupts
-         */
-        writel(~(u32)0, base + OHCI_INTRDISABLE);
-        writel(~(u32)0, base + OHCI_INTRSTATUS);
-
-        iounmap(base);
-}
-
-static void __devinit quirk_usb_disable_ehci(struct pci_dev *pdev)
-{
-        int wait_time, delta;
-        void __iomem *base, *op_reg_base;
-        u32 hcc_params, val, temp;
-        u8 cap_length;
-
-        base = ioremap_nocache(pci_resource_start(pdev, 0),
-                                pci_resource_len(pdev, 0));
-        if (base == NULL) return;
-
-        cap_length = readb(base);
-        op_reg_base = base + cap_length;
-        hcc_params = readl(base + EHCI_HCC_PARAMS);
-        hcc_params = (hcc_params >> 8) & 0xff;
-        if (hcc_params) {
-                pci_read_config_dword(pdev, 
-                                        hcc_params + EHCI_USBLEGSUP,
-                                        &val);
-                if (((val & 0xff) == 1) && (val & EHCI_USBLEGSUP_BIOS)) {
-                        /*
-                         * Ok, BIOS is in smm mode, try to hand off...
-                         */
-                        pci_read_config_dword(pdev,
-                                                hcc_params + EHCI_USBLEGCTLSTS,
-                                                &temp);
-                        pci_write_config_dword(pdev,
-                                                hcc_params + EHCI_USBLEGCTLSTS,
-                                                temp | EHCI_USBLEGCTLSTS_SOOE);
-                        val |= EHCI_USBLEGSUP_OS;
-                        pci_write_config_dword(pdev, 
-                                                hcc_params + EHCI_USBLEGSUP, 
-                                                val);
-
-                        wait_time = 500;
-                        do {
-                                msleep(10);
-                                wait_time -= 10;
-                                pci_read_config_dword(pdev,
-                                                hcc_params + EHCI_USBLEGSUP,
-                                                &val);
-                        } while (wait_time && (val & EHCI_USBLEGSUP_BIOS));
-                        if (!wait_time) {
-                                /*
-                                 * well, possibly buggy BIOS...
-                                 */
-                                printk(KERN_WARNING "EHCI early BIOS handoff "
-                                                "failed (BIOS bug ?)\n");
-                                pci_write_config_dword(pdev,
-                                                hcc_params + EHCI_USBLEGSUP,
-                                                EHCI_USBLEGSUP_OS);
-                                pci_write_config_dword(pdev,
-                                                hcc_params + EHCI_USBLEGCTLSTS,
-                                                0);
-                        }
-                }
-        }
-
-        /*
-         * halt EHCI & disable its interrupts in any case
-         */
-        val = readl(op_reg_base + EHCI_USBSTS);
-        if ((val & EHCI_USBSTS_HALTED) == 0) {
-                val = readl(op_reg_base + EHCI_USBCMD);
-                val &= ~EHCI_USBCMD_RUN;
-                writel(val, op_reg_base + EHCI_USBCMD);
-
-                wait_time = 2000;
-                delta = 100;
-                do {
-                        writel(0x3f, op_reg_base + EHCI_USBSTS);
-                        udelay(delta);
-                        wait_time -= delta;
-                        val = readl(op_reg_base + EHCI_USBSTS);
-                        if ((val == ~(u32)0) || (val & EHCI_USBSTS_HALTED)) {
-                                break;
-                        }
-                } while (wait_time > 0);
-        }
-        writel(0, op_reg_base + EHCI_USBINTR);
-        writel(0x3f, op_reg_base + EHCI_USBSTS);
-
-        iounmap(base);
-
-        return;
-}
-
-
-
-static void __devinit quirk_usb_early_handoff(struct pci_dev *pdev)
-{
-        if (!usb_early_handoff)
-                return;
-
-        if (pdev->class == ((PCI_CLASS_SERIAL_USB << 8) | 0x00)) { /* UHCI */
-                quirk_usb_handoff_uhci(pdev);
-        } else if (pdev->class == ((PCI_CLASS_SERIAL_USB << 8) | 0x10)) { /* OHCI */
-                quirk_usb_handoff_ohci(pdev);
-        } else if (pdev->class == ((PCI_CLASS_SERIAL_USB << 8) | 0x20)) { /* EHCI */
-                quirk_usb_disable_ehci(pdev);
-        }
-
-        return;
-}
-DECLARE_PCI_FIXUP_HEADER(PCI_ANY_ID, PCI_ANY_ID, quirk_usb_early_handoff);
-
 /*
  * ... This is further complicated by the fact that some SiS96x south
  * bridges pretend to be 85C503/5513 instead.  In that case see if we
diff --git a/drivers/usb/Makefile b/drivers/usb/Makefile
index df014c2a7c54..a50c2bc506f2 100644
--- a/drivers/usb/Makefile
+++ b/drivers/usb/Makefile
@@ -8,6 +8,7 @@ obj-$(CONFIG_USB)		+= core/
 
 obj-$(CONFIG_USB_MON)           += mon/
 
+obj-$(CONFIG_PCI)               += host/
 obj-$(CONFIG_USB_EHCI_HCD)      += host/
 obj-$(CONFIG_USB_ISP116X_HCD)   += host/
 obj-$(CONFIG_USB_OHCI_HCD)      += host/
@@ -17,7 +18,6 @@ obj-$(CONFIG_ETRAX_USB_HOST)	+= host/
 
 obj-$(CONFIG_USB_ACM)           += class/
 obj-$(CONFIG_USB_AUDIO)         += class/
-obj-$(CONFIG_USB_BLUETOOTH_TTY) += class/
 obj-$(CONFIG_USB_MIDI)          += class/
 obj-$(CONFIG_USB_PRINTER)       += class/
 
diff --git a/drivers/usb/class/Kconfig b/drivers/usb/class/Kconfig
index 333e39bb105f..ef105a92a7bd 100644
--- a/drivers/usb/class/Kconfig
+++ b/drivers/usb/class/Kconfig
@@ -28,29 +28,6 @@ config USB_AUDIO
           To compile this driver as a module, choose M here: the
           module will be called audio.
 
-comment "USB Bluetooth TTY can only be used with disabled Bluetooth subsystem"
-        depends on USB && BT
-
-config USB_BLUETOOTH_TTY
-        tristate "USB Bluetooth TTY support"
-        depends on USB && BT=n
-        ---help---
-          This driver implements a nonstandard tty interface to a Bluetooth
-          device that can be used only by specialized Bluetooth HCI software.
-
-          Say Y here if you want to use OpenBT Bluetooth stack (available
-          at <http://developer.axis.com/software>), or other TTY based
-          Bluetooth stacks, and want to connect a USB Bluetooth device
-          to your computer's USB port.
-
-          Do *not* enable this driver if you want to use generic Linux
-          Bluetooth support.
-
-          If in doubt, say N here.
-
-          To compile this driver as a module, choose M here: the
-          module will be called bluetty.
-
 config USB_MIDI
         tristate "USB MIDI support"
         depends on USB && SOUND && OBSOLETE_OSS_USB_DRIVER
diff --git a/drivers/usb/class/Makefile b/drivers/usb/class/Makefile
index 971e5497a3fd..229471247751 100644
--- a/drivers/usb/class/Makefile
+++ b/drivers/usb/class/Makefile
@@ -5,6 +5,5 @@
 
 obj-$(CONFIG_USB_ACM)           += cdc-acm.o
 obj-$(CONFIG_USB_AUDIO)         += audio.o
-obj-$(CONFIG_USB_BLUETOOTH_TTY) += bluetty.o
 obj-$(CONFIG_USB_MIDI)          += usb-midi.o
 obj-$(CONFIG_USB_PRINTER)       += usblp.o
diff --git a/drivers/usb/class/bluetty.c b/drivers/usb/class/bluetty.c
deleted file mode 100644
index 524023327c49..000000000000
--- a/drivers/usb/class/bluetty.c
+++ /dev/null
@@ -1,1279 +0,0 @@
-/*
- * bluetty.c   Version 0.13
- *
- * Copyright (C) 2000, 2001 Greg Kroah-Hartman  <greg@kroah.com>
- * Copyright (C) 2000 Mark Douglas Corner       <mcorner@umich.edu>
- *
- * USB Bluetooth TTY driver, based on the Bluetooth Spec version 1.0B
- * 
- * (2001/11/30) Version 0.13 gkh
- *      - added locking patch from Masoodur Rahman <rmasoodu@in.ibm.com>
- *      - removed active variable, as open_count will do.
- *
- * (2001/07/09) Version 0.12 gkh
- *      - removed in_interrupt() call, as it doesn't make sense to do 
- *        that anymore.
- *
- * (2001/06/05) Version 0.11 gkh
- *      - Fixed problem with read urb status saying that we have shutdown,
- *        and that we shouldn't resubmit the urb.  Patch from unknown.
- *
- * (2001/05/28) Version 0.10 gkh
- *      - Fixed problem with using data from userspace in the bluetooth_write
- *        function as found by the CHECKER project.
- *      - Added a buffer to the write_urb_pool which reduces the number of
- *        buffers being created and destroyed for ever write.  Also cleans
- *        up the logic a bit.
- *      - Added a buffer to the control_urb_pool which fixes a memory leak
- *        when the device is removed from the system.
- *
- * (2001/05/28) Version 0.9 gkh
- *      Fixed problem with bluetooth==NULL for bluetooth_read_bulk_callback
- *      which was found by both the CHECKER project and Mikko Rahkonen.
- *
- * (08/04/2001) gb
- *      Identify version on module load.
- *
- * (2001/03/10) Version 0.8 gkh
- *      Fixed problem with not unlinking interrupt urb on device close
- *      and resubmitting the read urb on error with bluetooth struct.
- *      Thanks to Narayan Mohanram <narayan@RovingNetworks.com> for the
- *      fixes.
- *
- * (11/29/2000) Version 0.7 gkh
- *      Fixed problem with overrunning the tty flip buffer.
- *      Removed unneeded NULL pointer initialization.
- *
- * (10/05/2000) Version 0.6 gkh
- *      Fixed bug with urb->dev not being set properly, now that the usb
- *      core needs it.
- *      Got a real major id number and name.
- *
- * (08/06/2000) Version 0.5 gkh
- *      Fixed problem of not resubmitting the bulk read urb if there is
- *      an error in the callback.  Ericsson devices seem to need this.
- *
- * (07/11/2000) Version 0.4 gkh
- *      Fixed bug in disconnect for when we call tty_hangup
- *      Fixed bug in bluetooth_ctrl_msg where the bluetooth struct was not
- *      getting attached to the control urb properly.
- *      Fixed bug in bluetooth_write where we pay attention to the result
- *      of bluetooth_ctrl_msg.
- *
- * (08/03/2000) Version 0.3 gkh mdc
- *      Merged in Mark's changes to make the driver play nice with the Axis
- *      stack.
- *      Made the write bulk use an urb pool to enable larger transfers with
- *      fewer calls to the driver.
- *      Fixed off by one bug in acl pkt receive
- *      Made packet counters specific to each bluetooth device 
- *      Added checks for zero length callbacks
- *      Added buffers for int and bulk packets.  Had to do this otherwise 
- *      packet types could intermingle.
- *      Made a control urb pool for the control messages.
- *
- * (07/11/2000) Version 0.2 gkh
- *      Fixed a small bug found by Nils Faerber in the usb_bluetooth_probe 
- *      function.
- *
- * (07/09/2000) Version 0.1 gkh
- *      Initial release. Has support for sending ACL data (which is really just
- *      a HCI frame.) Raw HCI commands and HCI events are not supported.
- *      A ioctl will probably be needed for the HCI commands and events in the
- *      future. All isoch endpoints are ignored at this time also.
- *      This driver should work for all currently shipping USB Bluetooth 
- *      devices at this time :)
- * 
- */
-
-/*
- * 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-
-
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/tty.h>
-#include <linux/tty_driver.h>
-#include <linux/tty_flip.h>
-#include <linux/module.h>
-#include <asm/uaccess.h>
-
-#define DEBUG
-#include <linux/usb.h>
-
-/*
- * Version Information
- */
-#define DRIVER_VERSION "v0.13"
-#define DRIVER_AUTHOR "Greg Kroah-Hartman, Mark Douglas Corner"
-#define DRIVER_DESC "USB Bluetooth tty driver"
-
-/* define this if you have hardware that is not good */
-/*#define       BTBUGGYHARDWARE */
-
-/* Class, SubClass, and Protocol codes that describe a Bluetooth device */
-#define WIRELESS_CLASS_CODE                     0xe0
-#define RF_SUBCLASS_CODE                        0x01
-#define BLUETOOTH_PROGRAMMING_PROTOCOL_CODE     0x01
-
-
-#define BLUETOOTH_TTY_MAJOR     216     /* real device node major id */
-#define BLUETOOTH_TTY_MINORS    256     /* whole lotta bluetooth devices */
-
-#define USB_BLUETOOTH_MAGIC     0x6d02  /* magic number for bluetooth struct */
-
-#define BLUETOOTH_CONTROL_REQUEST_TYPE  0x20
-
-/* Bluetooth packet types */
-#define CMD_PKT                 0x01
-#define ACL_PKT                 0x02
-#define SCO_PKT                 0x03
-#define EVENT_PKT               0x04
-#define ERROR_PKT               0x05
-#define NEG_PKT                 0x06
-
-/* Message sizes */
-#define MAX_EVENT_SIZE          0xFF
-#define EVENT_HDR_SIZE          3       /* 2 for the header + 1 for the type indicator */
-#define EVENT_BUFFER_SIZE       (MAX_EVENT_SIZE + EVENT_HDR_SIZE)
-
-#define MAX_ACL_SIZE            0xFFFF
-#define ACL_HDR_SIZE            5       /* 4 for the header + 1 for the type indicator */
-#define ACL_BUFFER_SIZE         (MAX_ACL_SIZE + ACL_HDR_SIZE)
-
-/* parity check flag */
-#define RELEVANT_IFLAG(iflag)   (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
-
-#define CHAR2INT16(c1,c0)       (((u32)((c1) & 0xff) << 8) + (u32)((c0) & 0xff))
-
-#define NUM_BULK_URBS           24
-#define NUM_CONTROL_URBS        16
-
-struct usb_bluetooth {
-        int                     magic;
-        struct usb_device *     dev;
-        struct tty_driver *     tty_driver;     /* the tty_driver for this device */
-        struct tty_struct *     tty;            /* the corresponding tty for this port */
-
-        unsigned char           minor;          /* the starting minor number for this device */
-        int                     throttle;       /* throttled by tty layer */
-        int                     open_count;
-        
-        __u8                    control_out_bInterfaceNum;
-        struct urb *            control_urb_pool[NUM_CONTROL_URBS];
-        struct usb_ctrlrequest  dr[NUM_CONTROL_URBS];
-
-        unsigned char *         interrupt_in_buffer;
-        struct urb *            interrupt_in_urb;
-        __u8                    interrupt_in_endpointAddress;
-        __u8                    interrupt_in_interval;
-        int                     interrupt_in_buffer_size;
-
-        unsigned char *         bulk_in_buffer;
-        struct urb *            read_urb;
-        __u8                    bulk_in_endpointAddress;
-        int                     bulk_in_buffer_size;
-
-        int                     bulk_out_buffer_size;
-        __u8                    bulk_out_endpointAddress;
-
-        wait_queue_head_t       write_wait;
-
-        struct work_struct                      work;   /* work queue entry for line discipline waking up */
-        
-        unsigned int            int_packet_pos;
-        unsigned char           int_buffer[EVENT_BUFFER_SIZE];
-        unsigned int            bulk_packet_pos;
-        unsigned char           bulk_buffer[ACL_BUFFER_SIZE];   /* 64k preallocated, fix? */
-        struct semaphore        lock;
-};
-
-
-/* local function prototypes */
-static int  bluetooth_open              (struct tty_struct *tty, struct file *filp);
-static void bluetooth_close             (struct tty_struct *tty, struct file *filp);
-static int  bluetooth_write             (struct tty_struct *tty, const unsigned char *buf, int count);
-static int  bluetooth_write_room        (struct tty_struct *tty);
-static int  bluetooth_chars_in_buffer   (struct tty_struct *tty);
-static void bluetooth_throttle          (struct tty_struct *tty);
-static void bluetooth_unthrottle        (struct tty_struct *tty);
-static int  bluetooth_ioctl             (struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg);
-static void bluetooth_set_termios       (struct tty_struct *tty, struct termios *old);
-
-static void bluetooth_int_callback              (struct urb *urb, struct pt_regs *regs);
-static void bluetooth_ctrl_callback             (struct urb *urb, struct pt_regs *regs);
-static void bluetooth_read_bulk_callback        (struct urb *urb, struct pt_regs *regs);
-static void bluetooth_write_bulk_callback       (struct urb *urb, struct pt_regs *regs);
-
-static int usb_bluetooth_probe (struct usb_interface *intf, 
-                                const struct usb_device_id *id);
-static void usb_bluetooth_disconnect    (struct usb_interface *intf);
-
-
-static struct usb_device_id usb_bluetooth_ids [] = {
-        { USB_DEVICE_INFO(WIRELESS_CLASS_CODE, RF_SUBCLASS_CODE, BLUETOOTH_PROGRAMMING_PROTOCOL_CODE) },
-        { }                                             /* Terminating entry */
-};
-
-MODULE_DEVICE_TABLE (usb, usb_bluetooth_ids);
-
-static struct usb_driver usb_bluetooth_driver = {
-        .owner =        THIS_MODULE,
-        .name =         "bluetty",
-        .probe =        usb_bluetooth_probe,
-        .disconnect =   usb_bluetooth_disconnect,
-        .id_table =     usb_bluetooth_ids,
-};
-
-static struct tty_driver        *bluetooth_tty_driver;
-static struct usb_bluetooth     *bluetooth_table[BLUETOOTH_TTY_MINORS];
-
-
-static inline int bluetooth_paranoia_check (struct usb_bluetooth *bluetooth, const char *function)
-{
-        if (!bluetooth) {
-                dbg("%s - bluetooth == NULL", function);
-                return -1;
-        }
-        if (bluetooth->magic != USB_BLUETOOTH_MAGIC) {
-                dbg("%s - bad magic number for bluetooth", function);
-                return -1;
-        }
-
-        return 0;
-}
-
-
-static inline struct usb_bluetooth* get_usb_bluetooth (struct usb_bluetooth *bluetooth, const char *function)
-{
-        if (!bluetooth || 
-            bluetooth_paranoia_check (bluetooth, function)) { 
-                /* then say that we don't have a valid usb_bluetooth thing, which will
-                 * end up generating -ENODEV return values */
-                return NULL;
-        }
-
-        return bluetooth;
-}
-
-
-static inline struct usb_bluetooth *get_bluetooth_by_index (int index)
-{
-        return bluetooth_table[index];
-}
-
-
-static int bluetooth_ctrl_msg (struct usb_bluetooth *bluetooth, int request, int value, const unsigned char *buf, int len)
-{
-        struct urb *urb = NULL;
-        struct usb_ctrlrequest *dr = NULL;
-        int i;
-        int status;
-
-        dbg ("%s", __FUNCTION__);
-
-        /* try to find a free urb in our list */
-        for (i = 0; i < NUM_CONTROL_URBS; ++i) {
-                if (bluetooth->control_urb_pool[i]->status != -EINPROGRESS) {
-                        urb = bluetooth->control_urb_pool[i];
-                        dr = &bluetooth->dr[i];
-                        break;
-                }
-        }
-        if (urb == NULL) {
-                dbg ("%s - no free urbs", __FUNCTION__);
-                return -ENOMEM;
-        }
-
-        /* keep increasing the urb transfer buffer to fit the size of the message */
-        if (urb->transfer_buffer == NULL) {
-                urb->transfer_buffer = kmalloc (len, GFP_KERNEL);
-                if (urb->transfer_buffer == NULL) {
-                        err ("%s - out of memory", __FUNCTION__);
-                        return -ENOMEM;
-                }
-        }
-        if (urb->transfer_buffer_length < len) {
-                kfree(urb->transfer_buffer);
-                urb->transfer_buffer = kmalloc (len, GFP_KERNEL);
-                if (urb->transfer_buffer == NULL) {
-                        err ("%s - out of memory", __FUNCTION__);
-                        return -ENOMEM;
-                }
-        }
-        memcpy (urb->transfer_buffer, buf, len);
-
-        dr->bRequestType= BLUETOOTH_CONTROL_REQUEST_TYPE;
-        dr->bRequest = request;
-        dr->wValue = cpu_to_le16((u16) value);
-        dr->wIndex = cpu_to_le16((u16) bluetooth->control_out_bInterfaceNum);
-        dr->wLength = cpu_to_le16((u16) len);
-        
-        usb_fill_control_urb (urb, bluetooth->dev, usb_sndctrlpipe(bluetooth->dev, 0),
-                          (unsigned char*)dr, urb->transfer_buffer, len, bluetooth_ctrl_callback, bluetooth);
-
-        /* send it down the pipe */
-        status = usb_submit_urb(urb, GFP_KERNEL);
-        if (status)
-                dbg("%s - usb_submit_urb(control) failed with status = %d", __FUNCTION__, status);
-        
-        return status;
-}
-
-
-
-
-
-/*****************************************************************************
- * Driver tty interface functions
- *****************************************************************************/
-static int bluetooth_open (struct tty_struct *tty, struct file * filp)
-{
-        struct usb_bluetooth *bluetooth;
-        int result;
-
-        dbg("%s", __FUNCTION__);
-
-        /* initialize the pointer incase something fails */
-        tty->driver_data = NULL;
-
-        /* get the bluetooth object associated with this tty pointer */
-        bluetooth = get_bluetooth_by_index (tty->index);
-
-        if (bluetooth_paranoia_check (bluetooth, __FUNCTION__)) {
-                return -ENODEV;
-        }
-
-        down (&bluetooth->lock);
- 
-        ++bluetooth->open_count;
-        if (bluetooth->open_count == 1) {
-                /* set up our structure making the tty driver remember our object, and us it */
-                tty->driver_data = bluetooth;
-                bluetooth->tty = tty;
-
-                /* force low_latency on so that our tty_push actually forces the data through, 
-                * otherwise it is scheduled, and with high data rates (like with OHCI) data
-                * can get lost. */
-                bluetooth->tty->low_latency = 1;
-        
-                /* Reset the packet position counters */
-                bluetooth->int_packet_pos = 0;
-                bluetooth->bulk_packet_pos = 0;
-
-#ifndef BTBUGGYHARDWARE
-                /* Start reading from the device */
-                usb_fill_bulk_urb (bluetooth->read_urb, bluetooth->dev, 
-                               usb_rcvbulkpipe(bluetooth->dev, bluetooth->bulk_in_endpointAddress),
-                               bluetooth->bulk_in_buffer,
-                               bluetooth->bulk_in_buffer_size,
-                               bluetooth_read_bulk_callback, bluetooth);
-                result = usb_submit_urb(bluetooth->read_urb, GFP_KERNEL);
-                if (result)
-                        dbg("%s - usb_submit_urb(read bulk) failed with status %d", __FUNCTION__, result);
-#endif
-                usb_fill_int_urb (bluetooth->interrupt_in_urb, bluetooth->dev,
-                              usb_rcvintpipe(bluetooth->dev, bluetooth->interrupt_in_endpointAddress),
-                              bluetooth->interrupt_in_buffer,
-                              bluetooth->interrupt_in_buffer_size,
-                              bluetooth_int_callback, bluetooth,
-                              bluetooth->interrupt_in_interval);
-                result = usb_submit_urb(bluetooth->interrupt_in_urb, GFP_KERNEL);
-                if (result)
-                        dbg("%s - usb_submit_urb(interrupt in) failed with status %d", __FUNCTION__, result);
-        }
-        
-        up(&bluetooth->lock);
-
-        return 0;
-}
-
-
-static void bluetooth_close (struct tty_struct *tty, struct file * filp)
-{
-        struct usb_bluetooth *bluetooth = get_usb_bluetooth ((struct usb_bluetooth *)tty->driver_data, __FUNCTION__);
-
-        if (!bluetooth) {
-                return;
-        }
-
-        dbg("%s", __FUNCTION__);
-
-        if (!bluetooth->open_count) {
-                dbg ("%s - device not opened", __FUNCTION__);
-                return;
-        }
-
-        down (&bluetooth->lock);
- 
-        --bluetooth->open_count;
-        if (bluetooth->open_count <= 0) {
-                bluetooth->open_count = 0;
-
-                /* shutdown any in-flight urbs that we know about */
-                usb_kill_urb (bluetooth->read_urb);
-                usb_kill_urb (bluetooth->interrupt_in_urb);
-        }
-        up(&bluetooth->lock);
-}
-
-
-static int bluetooth_write (struct tty_struct * tty, const unsigned char *buf, int count)
-{
-        struct usb_bluetooth *bluetooth = get_usb_bluetooth ((struct usb_bluetooth *)tty->driver_data, __FUNCTION__);
-        struct urb *urb = NULL;
-        unsigned char *temp_buffer = NULL;
-        const unsigned char *current_buffer;
-        unsigned char *urb_buffer;
-        int i;
-        int retval = 0;
-
-        if (!bluetooth) {
-                return -ENODEV;
-        }
-
-        dbg("%s - %d byte(s)", __FUNCTION__, count);
-
-        if (!bluetooth->open_count) {
-                dbg ("%s - device not opened", __FUNCTION__);
-                return -EINVAL;
-        }
-
-        if (count == 0) {
-                dbg("%s - write request of 0 bytes", __FUNCTION__);
-                return 0;
-        }
-        if (count == 1) {
-                dbg("%s - write request only included type %d", __FUNCTION__, buf[0]);
-                return 1;
-        }
-
-#ifdef DEBUG
-        printk (KERN_DEBUG __FILE__ ": %s - length = %d, data = ", __FUNCTION__, count);
-        for (i = 0; i < count; ++i) {
-                printk ("%.2x ", buf[i]);
-        }
-        printk ("\n");
-#endif
-
-        current_buffer = buf;
-
-        switch (*current_buffer) {
-                /* First byte indicates the type of packet */
-                case CMD_PKT:
-                        /* dbg("%s- Send cmd_pkt len:%d", __FUNCTION__, count);*/
-
-                        retval = bluetooth_ctrl_msg (bluetooth, 0x00, 0x00, &current_buffer[1], count-1);
-                        if (retval) {
-                                goto exit;
-                        }
-                        retval = count;
-                        break;
-
-                case ACL_PKT:
-                        ++current_buffer;
-                        --count;
-
-                        urb_buffer = kmalloc (count, GFP_ATOMIC);
-                        if (!urb_buffer) {
-                                dev_err(&bluetooth->dev->dev, "out of memory\n");
-                                retval = -ENOMEM;
-                                goto exit;
-                        }
-
-                        urb = usb_alloc_urb(0, GFP_ATOMIC);
-                        if (!urb) {
-                                dev_err(&bluetooth->dev->dev, "no more free urbs\n");
-                                kfree(urb_buffer);
-                                retval = -ENOMEM;
-                                goto exit;
-                        }
-                        memcpy (urb_buffer, current_buffer, count);
-
-                        /* build up our urb */
-                        usb_fill_bulk_urb(urb, bluetooth->dev, 
-                                          usb_sndbulkpipe(bluetooth->dev,
-                                                          bluetooth->bulk_out_endpointAddress),
-                                          urb_buffer,
-                                          count,
-                                          bluetooth_write_bulk_callback,
-                                          bluetooth);
-
-
-                        /* send it down the pipe */
-                        retval = usb_submit_urb(urb, GFP_KERNEL);
-                        if (retval) {
-                                dbg("%s - usb_submit_urb(write bulk) failed with error = %d", __FUNCTION__, retval);
-                                goto exit;
-                        }
-
-                        /* we are done with this urb, so let the host driver
-                         * really free it when it is finished with it */
-                        usb_free_urb (urb);
-                        retval = count + 1;
-                        break;
-                
-                default :
-                        dbg("%s - unsupported (at this time) write type", __FUNCTION__);
-                        retval = -EINVAL;
-                        break;
-        }
-
-exit:
-        kfree(temp_buffer);
-
-        return retval;
-} 
-
-
-static int bluetooth_write_room (struct tty_struct *tty) 
-{
-        dbg("%s", __FUNCTION__);
-
-        /*
-         * We really can take anything the user throws at us
-         * but let's pick a nice big number to tell the tty
-         * layer that we have lots of free space
-         */
-        return 2048;
-}
-
-
-static int bluetooth_chars_in_buffer (struct tty_struct *tty) 
-{
-        dbg("%s", __FUNCTION__);
-
-        /* 
-         * We can't really account for how much data we
-         * have sent out, but hasn't made it through to the
-         * device, so just tell the tty layer that everything
-         * is flushed.
-         */
-        return 0;
-}
-
-
-static void bluetooth_throttle (struct tty_struct * tty)
-{
-        struct usb_bluetooth *bluetooth = get_usb_bluetooth ((struct usb_bluetooth *)tty->driver_data, __FUNCTION__);
-
-        if (!bluetooth) {
-                return;
-        }
-
-        dbg("%s", __FUNCTION__);
-
-        if (!bluetooth->open_count) {
-                dbg ("%s - device not open", __FUNCTION__);
-                return;
-        }
-        
-        dbg("%s unsupported (at this time)", __FUNCTION__);
-
-        return;
-}
-
-
-static void bluetooth_unthrottle (struct tty_struct * tty)
-{
-        struct usb_bluetooth *bluetooth = get_usb_bluetooth ((struct usb_bluetooth *)tty->driver_data, __FUNCTION__);
-
-        if (!bluetooth) {
-                return;
-        }
-
-        dbg("%s", __FUNCTION__);
-
-        if (!bluetooth->open_count) {
-                dbg ("%s - device not open", __FUNCTION__);
-                return;
-        }
-
-        dbg("%s unsupported (at this time)", __FUNCTION__);
-}
-
-
-static int bluetooth_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
-{
-        struct usb_bluetooth *bluetooth = get_usb_bluetooth ((struct usb_bluetooth *)tty->driver_data, __FUNCTION__);
-
-        if (!bluetooth) {
-                return -ENODEV;
-        }
-
-        dbg("%s - cmd 0x%.4x", __FUNCTION__, cmd);
-
-        if (!bluetooth->open_count) {
-                dbg ("%s - device not open", __FUNCTION__);
-                return -ENODEV;
-        }
-
-        /* FIXME!!! */
-        return -ENOIOCTLCMD;
-}
-
-
-static void bluetooth_set_termios (struct tty_struct *tty, struct termios * old)
-{
-        struct usb_bluetooth *bluetooth = get_usb_bluetooth ((struct usb_bluetooth *)tty->driver_data, __FUNCTION__);
-
-        if (!bluetooth) {
-                return;
-        }
-
-        dbg("%s", __FUNCTION__);
-
-        if (!bluetooth->open_count) {
-                dbg ("%s - device not open", __FUNCTION__);
-                return;
-        }
-
-        /* FIXME!!! */
-
-        return;
-}
-
-
-#ifdef BTBUGGYHARDWARE
-void btusb_enable_bulk_read(struct tty_struct *tty){
-        struct usb_bluetooth *bluetooth = get_usb_bluetooth ((struct usb_bluetooth *)tty->driver_data, __FUNCTION__);
-        int result;
-
-        if (!bluetooth) {
-                return;
-        }
-
-        dbg("%s", __FUNCTION__);
-
-        if (!bluetooth->open_count) {
-                dbg ("%s - device not open", __FUNCTION__);
-                return;
-        }
-
-        if (bluetooth->read_urb) {
-                usb_fill_bulk_urb(bluetooth->read_urb, bluetooth->dev, 
-                              usb_rcvbulkpipe(bluetooth->dev, bluetooth->bulk_in_endpointAddress),
-                              bluetooth->bulk_in_buffer, bluetooth->bulk_in_buffer_size, 
-                              bluetooth_read_bulk_callback, bluetooth);
-                result = usb_submit_urb(bluetooth->read_urb, GFP_KERNEL);
-                if (result)
-                        err ("%s - failed submitting read urb, error %d", __FUNCTION__, result);
-        }
-}
-
-void btusb_disable_bulk_read(struct tty_struct *tty){
-        struct usb_bluetooth *bluetooth = get_usb_bluetooth ((struct usb_bluetooth *)tty->driver_data, __FUNCTION__);
-
-        if (!bluetooth) {
-                return;
-        }
-
-        dbg("%s", __FUNCTION__);
-
-        if (!bluetooth->open_count) {
-                dbg ("%s - device not open", __FUNCTION__);
-                return;
-        }
-
-        if ((bluetooth->read_urb) && (bluetooth->read_urb->actual_length))
-                usb_kill_urb(bluetooth->read_urb);
-}
-#endif
-
-
-/*****************************************************************************
- * urb callback functions
- *****************************************************************************/
-
-
-static void bluetooth_int_callback (struct urb *urb, struct pt_regs *regs)
-{
-        struct usb_bluetooth *bluetooth = get_usb_bluetooth ((struct usb_bluetooth *)urb->context, __FUNCTION__);
-        unsigned char *data = urb->transfer_buffer;
-        unsigned int i;
-        unsigned int count = urb->actual_length;
-        unsigned int packet_size;
-        int status;
-
-        dbg("%s", __FUNCTION__);
-
-        if (!bluetooth) {
-                dbg("%s - bad bluetooth pointer, exiting", __FUNCTION__);
-                return;
-        }
-
-        switch (urb->status) {
-        case 0:
-                /* success */
-                break;
-        case -ECONNRESET:
-        case -ENOENT:
-        case -ESHUTDOWN:
-                /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
-                return;
-        default:
-                dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
-                goto exit;
-        }
-
-        if (!count) {
-                dbg("%s - zero length int", __FUNCTION__);
-                goto exit;
-        }
-
-
-#ifdef DEBUG
-        if (count) {
-                printk (KERN_DEBUG __FILE__ ": %s- length = %d, data = ", __FUNCTION__, count);
-                for (i = 0; i < count; ++i) {
-                        printk ("%.2x ", data[i]);
-                }
-                printk ("\n");
-        }
-#endif
-
-#ifdef BTBUGGYHARDWARE
-        if ((count >= 2) && (data[0] == 0xFF) && (data[1] == 0x00)) {
-                data += 2;
-                count -= 2;
-        }
-        if (count == 0) {
-                urb->actual_length = 0;
-                goto exit;
-        }
-#endif
-        /* We add  a packet type identifier to the beginning of each
-           HCI frame.  This makes the data in the tty look like a
-           serial USB devices.  Each HCI frame can be broken across
-           multiple URBs so we buffer them until we have a full hci
-           packet */
-
-        if (!bluetooth->int_packet_pos) {
-                bluetooth->int_buffer[0] = EVENT_PKT;
-                bluetooth->int_packet_pos++;
-        }
-        
-        if (bluetooth->int_packet_pos + count > EVENT_BUFFER_SIZE) {
-                err("%s - exceeded EVENT_BUFFER_SIZE", __FUNCTION__);
-                bluetooth->int_packet_pos = 0;
-                goto exit;
-        }
-
-        memcpy (&bluetooth->int_buffer[bluetooth->int_packet_pos],
-                urb->transfer_buffer, count);
-        bluetooth->int_packet_pos += count;
-        urb->actual_length = 0;
-
-        if (bluetooth->int_packet_pos >= EVENT_HDR_SIZE)
-                packet_size = bluetooth->int_buffer[2];
-        else
-                goto exit;
-
-        if (packet_size + EVENT_HDR_SIZE < bluetooth->int_packet_pos) {
-                err("%s - packet was too long", __FUNCTION__);
-                bluetooth->int_packet_pos = 0;
-                goto exit;
-        }
-
-        if (packet_size + EVENT_HDR_SIZE == bluetooth->int_packet_pos) {
-                for (i = 0; i < bluetooth->int_packet_pos; ++i) {
-                        /* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them */
-                        if (bluetooth->tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                                tty_flip_buffer_push(bluetooth->tty);
-                        }
-                        tty_insert_flip_char(bluetooth->tty, bluetooth->int_buffer[i], 0);
-                }
-                tty_flip_buffer_push(bluetooth->tty);
-
-                bluetooth->int_packet_pos = 0;
-        }
-
-exit:
-        status = usb_submit_urb (urb, GFP_ATOMIC);
-        if (status)
-                err ("%s - usb_submit_urb failed with result %d",
-                     __FUNCTION__, status);
-}
-
-
-static void bluetooth_ctrl_callback (struct urb *urb, struct pt_regs *regs)
-{
-        struct usb_bluetooth *bluetooth = get_usb_bluetooth ((struct usb_bluetooth *)urb->context, __FUNCTION__);
-
-        dbg("%s", __FUNCTION__);
-
-        if (!bluetooth) {
-                dbg("%s - bad bluetooth pointer, exiting", __FUNCTION__);
-                return;
-        }
-
-        if (urb->status) {
-                dbg("%s - nonzero read bulk status received: %d", __FUNCTION__, urb->status);
-                return;
-        }
-}
-
-
-static void bluetooth_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
-{
-        struct usb_bluetooth *bluetooth = get_usb_bluetooth ((struct usb_bluetooth *)urb->context, __FUNCTION__);
-        unsigned char *data = urb->transfer_buffer;
-        unsigned int count = urb->actual_length;
-        unsigned int i;
-        unsigned int packet_size;
-        int result;
-
-
-        dbg("%s", __FUNCTION__);
-
-        if (!bluetooth) {
-                dbg("%s - bad bluetooth pointer, exiting", __FUNCTION__);
-                return;
-        }
-
-        if (urb->status) {
-                dbg("%s - nonzero read bulk status received: %d", __FUNCTION__, urb->status);
-                if (urb->status == -ENOENT) {                   
-                        dbg("%s - URB canceled, won't reschedule", __FUNCTION__);
-                        return;
-                }
-                goto exit;
-        }
-
-        if (!count) {
-                dbg("%s - zero length read bulk", __FUNCTION__);
-                goto exit;
-        }
-
-#ifdef DEBUG
-        if (count) {
-                printk (KERN_DEBUG __FILE__ ": %s- length = %d, data = ", __FUNCTION__, count);
-                for (i = 0; i < count; ++i) {
-                        printk ("%.2x ", data[i]);
-                }
-                printk ("\n");
-        }
-#endif
-#ifdef BTBUGGYHARDWARE
-        if ((count == 4) && (data[0] == 0x00) && (data[1] == 0x00)
-            && (data[2] == 0x00) && (data[3] == 0x00)) {
-                urb->actual_length = 0;
-                usb_fill_bulk_urb(bluetooth->read_urb, bluetooth->dev, 
-                              usb_rcvbulkpipe(bluetooth->dev, bluetooth->bulk_in_endpointAddress),
-                              bluetooth->bulk_in_buffer, bluetooth->bulk_in_buffer_size, 
-                              bluetooth_read_bulk_callback, bluetooth);
-                result = usb_submit_urb(bluetooth->read_urb, GFP_KERNEL);
-                if (result)
-                        err ("%s - failed resubmitting read urb, error %d", __FUNCTION__, result);
-
-                return;
-        }
-#endif
-        /* We add  a packet type identifier to the beginning of each
-           HCI frame.  This makes the data in the tty look like a
-           serial USB devices.  Each HCI frame can be broken across
-           multiple URBs so we buffer them until we have a full hci
-           packet */
-        
-        if (!bluetooth->bulk_packet_pos) {
-                bluetooth->bulk_buffer[0] = ACL_PKT;
-                bluetooth->bulk_packet_pos++;
-        }
-
-        if (bluetooth->bulk_packet_pos + count > ACL_BUFFER_SIZE) {
-                err("%s - exceeded ACL_BUFFER_SIZE", __FUNCTION__);
-                bluetooth->bulk_packet_pos = 0;
-                goto exit;
-        }
-
-        memcpy (&bluetooth->bulk_buffer[bluetooth->bulk_packet_pos],
-                urb->transfer_buffer, count);
-        bluetooth->bulk_packet_pos += count;
-        urb->actual_length = 0;
-
-        if (bluetooth->bulk_packet_pos >= ACL_HDR_SIZE) {
-                packet_size = CHAR2INT16(bluetooth->bulk_buffer[4],bluetooth->bulk_buffer[3]);
-        } else {
-                goto exit;
-        }
-
-        if (packet_size + ACL_HDR_SIZE < bluetooth->bulk_packet_pos) {
-                err("%s - packet was too long", __FUNCTION__);
-                bluetooth->bulk_packet_pos = 0;
-                goto exit;
-        }
-
-        if (packet_size + ACL_HDR_SIZE == bluetooth->bulk_packet_pos) {
-                for (i = 0; i < bluetooth->bulk_packet_pos; ++i) {
-                        /* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */
-                        if (bluetooth->tty->flip.count >= TTY_FLIPBUF_SIZE) {
-                                tty_flip_buffer_push(bluetooth->tty);
-                        }
-                        tty_insert_flip_char(bluetooth->tty, bluetooth->bulk_buffer[i], 0);
-                }
-                tty_flip_buffer_push(bluetooth->tty);
-                bluetooth->bulk_packet_pos = 0;
-        }       
-
-exit:
-        if (!bluetooth || !bluetooth->open_count)
-                return;
-
-        usb_fill_bulk_urb(bluetooth->read_urb, bluetooth->dev, 
-                      usb_rcvbulkpipe(bluetooth->dev, bluetooth->bulk_in_endpointAddress),
-                      bluetooth->bulk_in_buffer, bluetooth->bulk_in_buffer_size, 
-                      bluetooth_read_bulk_callback, bluetooth);
-        result = usb_submit_urb(bluetooth->read_urb, GFP_KERNEL);
-        if (result)
-                err ("%s - failed resubmitting read urb, error %d", __FUNCTION__, result);
-
-        return;
-}
-
-
-static void bluetooth_write_bulk_callback (struct urb *urb, struct pt_regs *regs)
-{
-        struct usb_bluetooth *bluetooth = get_usb_bluetooth ((struct usb_bluetooth *)urb->context, __FUNCTION__);
-
-        dbg("%s", __FUNCTION__);
-
-        /* free up the transfer buffer, as usb_free_urb() does not do this */
-        kfree(urb->transfer_buffer);
-
-        if (!bluetooth) {
-                dbg("%s - bad bluetooth pointer, exiting", __FUNCTION__);
-                return;
-        }
-
-        if (urb->status) {
-                dbg("%s - nonzero write bulk status received: %d", __FUNCTION__, urb->status);
-                return;
-        }
-
-        /* wake up our little function to let the tty layer know that something happened */
-        schedule_work(&bluetooth->work);
-}
-
-
-static void bluetooth_softint(void *private)
-{
-        struct usb_bluetooth *bluetooth = get_usb_bluetooth ((struct usb_bluetooth *)private, __FUNCTION__);
-
-        dbg("%s", __FUNCTION__);
-
-        if (!bluetooth)
-                return;
-
-        tty_wakeup(bluetooth->tty);
-}
-
-
-static int usb_bluetooth_probe (struct usb_interface *intf, 
-                                const struct usb_device_id *id)
-{
-        struct usb_device *dev = interface_to_usbdev (intf);
-        struct usb_bluetooth *bluetooth = NULL;
-        struct usb_host_interface *interface;
-        struct usb_endpoint_descriptor *endpoint;
-        struct usb_endpoint_descriptor *interrupt_in_endpoint[8];
-        struct usb_endpoint_descriptor *bulk_in_endpoint[8];
-        struct usb_endpoint_descriptor *bulk_out_endpoint[8];
-        int control_out_endpoint;
-
-        int minor;
-        int buffer_size;
-        int i;
-        int num_interrupt_in = 0;
-        int num_bulk_in = 0;
-        int num_bulk_out = 0;
-
-        interface = intf->cur_altsetting;
-        control_out_endpoint = interface->desc.bInterfaceNumber;
-
-        /* find the endpoints that we need */
-        for (i = 0; i < interface->desc.bNumEndpoints; ++i) {
-                endpoint = &interface->endpoint[i].desc;
-
-                if ((endpoint->bEndpointAddress & 0x80) &&
-                    ((endpoint->bmAttributes & 3) == 0x02)) {
-                        /* we found a bulk in endpoint */
-                        dbg("found bulk in");
-                        bulk_in_endpoint[num_bulk_in] = endpoint;
-                        ++num_bulk_in;
-                }
-
-                if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
-                    ((endpoint->bmAttributes & 3) == 0x02)) {
-                        /* we found a bulk out endpoint */
-                        dbg("found bulk out");
-                        bulk_out_endpoint[num_bulk_out] = endpoint;
-                        ++num_bulk_out;
-                }
-
-                if ((endpoint->bEndpointAddress & 0x80) &&
-                    ((endpoint->bmAttributes & 3) == 0x03)) {
-                        /* we found a interrupt in endpoint */
-                        dbg("found interrupt in");
-                        interrupt_in_endpoint[num_interrupt_in] = endpoint;
-                        ++num_interrupt_in;
-                }
-        }
-
-        /* according to the spec, we can only have 1 bulk_in, 1 bulk_out, and 1 interrupt_in endpoints */
-        if ((num_bulk_in != 1) ||
-            (num_bulk_out != 1) ||
-            (num_interrupt_in != 1)) {
-                dbg ("%s - improper number of endpoints. Bluetooth driver not bound.", __FUNCTION__);
-                return -EIO;
-        }
-
-        info("USB Bluetooth converter detected");
-
-        for (minor = 0; minor < BLUETOOTH_TTY_MINORS && bluetooth_table[minor]; ++minor)
-                ;
-        if (bluetooth_table[minor]) {
-                err("No more free Bluetooth devices");
-                return -ENODEV;
-        }
-
-        if (!(bluetooth = kmalloc(sizeof(struct usb_bluetooth), GFP_KERNEL))) {
-                err("Out of memory");
-                return -ENOMEM;
-        }
-
-        memset(bluetooth, 0, sizeof(struct usb_bluetooth));
-
-        bluetooth->magic = USB_BLUETOOTH_MAGIC;
-        bluetooth->dev = dev;
-        bluetooth->minor = minor;
-        INIT_WORK(&bluetooth->work, bluetooth_softint, bluetooth);
-        init_MUTEX(&bluetooth->lock);
-
-        /* record the interface number for the control out */
-        bluetooth->control_out_bInterfaceNum = control_out_endpoint;
-        
-        /* create our control out urb pool */ 
-        for (i = 0; i < NUM_CONTROL_URBS; ++i) {
-                struct urb  *urb = usb_alloc_urb(0, GFP_KERNEL);
-                if (urb == NULL) {
-                        err("No free urbs available");
-                        goto probe_error;
-                }
-                urb->transfer_buffer = NULL;
-                bluetooth->control_urb_pool[i] = urb;
-        }
-
-        /* set up the endpoint information */
-        endpoint = bulk_in_endpoint[0];
-        bluetooth->read_urb = usb_alloc_urb (0, GFP_KERNEL);
-        if (!bluetooth->read_urb) {
-                err("No free urbs available");
-                goto probe_error;
-        }
-        bluetooth->bulk_in_buffer_size = buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
-        bluetooth->bulk_in_endpointAddress = endpoint->bEndpointAddress;
-        bluetooth->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
-        if (!bluetooth->bulk_in_buffer) {
-                err("Couldn't allocate bulk_in_buffer");
-                goto probe_error;
-        }
-        usb_fill_bulk_urb(bluetooth->read_urb, dev, usb_rcvbulkpipe(dev, endpoint->bEndpointAddress),
-                      bluetooth->bulk_in_buffer, buffer_size, bluetooth_read_bulk_callback, bluetooth);
-
-        endpoint = bulk_out_endpoint[0];
-        bluetooth->bulk_out_endpointAddress = endpoint->bEndpointAddress;
-        bluetooth->bulk_out_buffer_size = le16_to_cpu(endpoint->wMaxPacketSize) * 2;
-
-        endpoint = interrupt_in_endpoint[0];
-        bluetooth->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
-        if (!bluetooth->interrupt_in_urb) {
-                err("No free urbs available");
-                goto probe_error;
-        }
-        bluetooth->interrupt_in_buffer_size = buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
-        bluetooth->interrupt_in_endpointAddress = endpoint->bEndpointAddress;
-        bluetooth->interrupt_in_interval = endpoint->bInterval;
-        bluetooth->interrupt_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
-        if (!bluetooth->interrupt_in_buffer) {
-                err("Couldn't allocate interrupt_in_buffer");
-                goto probe_error;
-        }
-        usb_fill_int_urb(bluetooth->interrupt_in_urb, dev, usb_rcvintpipe(dev, endpoint->bEndpointAddress),
-                     bluetooth->interrupt_in_buffer, buffer_size, bluetooth_int_callback,
-                     bluetooth, endpoint->bInterval);
-
-        /* initialize the devfs nodes for this device and let the user know what bluetooths we are bound to */
-        tty_register_device (bluetooth_tty_driver, minor, &intf->dev);
-        info("Bluetooth converter now attached to ttyUB%d (or usb/ttub/%d for devfs)", minor, minor);
-
-        bluetooth_table[minor] = bluetooth;
-
-        /* success */
-        usb_set_intfdata (intf, bluetooth);
-        return 0;
-
-probe_error:
-        if (bluetooth->read_urb)
-                usb_free_urb (bluetooth->read_urb);
-        if (bluetooth->bulk_in_buffer)
-                kfree (bluetooth->bulk_in_buffer);
-        if (bluetooth->interrupt_in_urb)
-                usb_free_urb (bluetooth->interrupt_in_urb);
-        if (bluetooth->interrupt_in_buffer)
-                kfree (bluetooth->interrupt_in_buffer);
-        for (i = 0; i < NUM_CONTROL_URBS; ++i) 
-                if (bluetooth->control_urb_pool[i]) {
-                        if (bluetooth->control_urb_pool[i]->transfer_buffer)
-                                kfree (bluetooth->control_urb_pool[i]->transfer_buffer);
-                        usb_free_urb (bluetooth->control_urb_pool[i]);
-                }
-
-        bluetooth_table[minor] = NULL;
-
-        /* free up any memory that we allocated */
-        kfree (bluetooth);
-        return -EIO;
-}
-
-
-static void usb_bluetooth_disconnect(struct usb_interface *intf)
-{
-        struct usb_bluetooth *bluetooth = usb_get_intfdata (intf);
-        int i;
-
-        usb_set_intfdata (intf, NULL);
-        if (bluetooth) {
-                if ((bluetooth->open_count) && (bluetooth->tty))
-                        tty_hangup(bluetooth->tty);
-
-                bluetooth->open_count = 0;
-
-                if (bluetooth->read_urb) {
-                        usb_kill_urb (bluetooth->read_urb);
-                        usb_free_urb (bluetooth->read_urb);
-                }
-                if (bluetooth->bulk_in_buffer)
-                        kfree (bluetooth->bulk_in_buffer);
-
-                if (bluetooth->interrupt_in_urb) {
-                        usb_kill_urb (bluetooth->interrupt_in_urb);
-                        usb_free_urb (bluetooth->interrupt_in_urb);
-                }
-                if (bluetooth->interrupt_in_buffer)
-                        kfree (bluetooth->interrupt_in_buffer);
-
-                tty_unregister_device (bluetooth_tty_driver, bluetooth->minor);
-
-                for (i = 0; i < NUM_CONTROL_URBS; ++i) {
-                        if (bluetooth->control_urb_pool[i]) {
-                                usb_kill_urb (bluetooth->control_urb_pool[i]);
-                                if (bluetooth->control_urb_pool[i]->transfer_buffer)
-                                        kfree (bluetooth->control_urb_pool[i]->transfer_buffer);
-                                usb_free_urb (bluetooth->control_urb_pool[i]);
-                        }
-                }
-                
-                info("Bluetooth converter now disconnected from ttyUB%d", bluetooth->minor);
-
-                bluetooth_table[bluetooth->minor] = NULL;
-
-                /* free up any memory that we allocated */
-                kfree (bluetooth);
-        } else {
-                info("device disconnected");
-        }
-}
-
-static struct tty_operations bluetooth_ops = {
-        .open =                 bluetooth_open,
-        .close =                bluetooth_close,
-        .write =                bluetooth_write,
-        .write_room =           bluetooth_write_room,
-        .ioctl =                bluetooth_ioctl,
-        .set_termios =          bluetooth_set_termios,
-        .throttle =             bluetooth_throttle,
-        .unthrottle =           bluetooth_unthrottle,
-        .chars_in_buffer =      bluetooth_chars_in_buffer,
-};
-
-static int usb_bluetooth_init(void)
-{
-        int i;
-        int result;
-
-        /* Initialize our global data */
-        for (i = 0; i < BLUETOOTH_TTY_MINORS; ++i) {
-                bluetooth_table[i] = NULL;
-        }
-
-        info ("USB Bluetooth support registered");
-
-        bluetooth_tty_driver = alloc_tty_driver(BLUETOOTH_TTY_MINORS);
-        if (!bluetooth_tty_driver)
-                return -ENOMEM;
-
-        bluetooth_tty_driver->owner = THIS_MODULE;
-        bluetooth_tty_driver->driver_name = "usb-bluetooth";
-        bluetooth_tty_driver->name = "ttyUB";
-        bluetooth_tty_driver->devfs_name = "usb/ttub/";
-        bluetooth_tty_driver->major = BLUETOOTH_TTY_MAJOR;
-        bluetooth_tty_driver->minor_start = 0;
-        bluetooth_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
-        bluetooth_tty_driver->subtype = SERIAL_TYPE_NORMAL;
-        bluetooth_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS;
-        bluetooth_tty_driver->init_termios = tty_std_termios;
-        bluetooth_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
-        tty_set_operations(bluetooth_tty_driver, &bluetooth_ops);
-        if (tty_register_driver (bluetooth_tty_driver)) {
-                err("%s - failed to register tty driver", __FUNCTION__);
-                put_tty_driver(bluetooth_tty_driver);
-                return -1;
-        }
-
-        /* register the USB driver */
-        result = usb_register(&usb_bluetooth_driver);
-        if (result < 0) {
-                tty_unregister_driver(bluetooth_tty_driver);
-                put_tty_driver(bluetooth_tty_driver);
-                err("usb_register failed for the USB bluetooth driver. Error number %d", result);
-                return -1;
-        }
-
-        info(DRIVER_DESC " " DRIVER_VERSION);
-
-        return 0;
-}
-
-
-static void usb_bluetooth_exit(void)
-{
-        usb_deregister(&usb_bluetooth_driver);
-        tty_unregister_driver(bluetooth_tty_driver);
-        put_tty_driver(bluetooth_tty_driver);
-}
-
-
-module_init(usb_bluetooth_init);
-module_exit(usb_bluetooth_exit);
-
-/* Module information */
-MODULE_AUTHOR( DRIVER_AUTHOR );
-MODULE_DESCRIPTION( DRIVER_DESC );
-MODULE_LICENSE("GPL");
-
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 16ecad30e29c..1b4751412970 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -827,11 +827,10 @@ skip_normal_probe:
                 return -ENODEV;
         }
 
-        if (!(acm = kmalloc(sizeof(struct acm), GFP_KERNEL))) {
-                dev_dbg(&intf->dev, "out of memory (acm kmalloc)\n");
+        if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
+                dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
                 goto alloc_fail;
         }
-        memset(acm, 0, sizeof(struct acm));
 
         ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
         readsize = le16_to_cpu(epread->wMaxPacketSize);
diff --git a/drivers/usb/class/usblp.c b/drivers/usb/class/usblp.c
index e195709c9c7f..357e75335f17 100644
--- a/drivers/usb/class/usblp.c
+++ b/drivers/usb/class/usblp.c
@@ -844,9 +844,8 @@ static struct file_operations usblp_fops = {
 };
 
 static struct usb_class_driver usblp_class = {
-        .name =         "usb/lp%d",
+        .name =         "lp%d",
         .fops =         &usblp_fops,
-        .mode =         S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
         .minor_base =   USBLP_MINOR_BASE,
 };
 
diff --git a/drivers/usb/core/Kconfig b/drivers/usb/core/Kconfig
index 1a9ff6184943..ff03184da403 100644
--- a/drivers/usb/core/Kconfig
+++ b/drivers/usb/core/Kconfig
@@ -61,14 +61,17 @@ config USB_DYNAMIC_MINORS
           If you are unsure about this, say N here.
 
 config USB_SUSPEND
-        bool "USB suspend/resume (EXPERIMENTAL)"
+        bool "USB selective suspend/resume and wakeup (EXPERIMENTAL)"
         depends on USB && PM && EXPERIMENTAL
         help
           If you say Y here, you can use driver calls or the sysfs
           "power/state" file to suspend or resume individual USB
-          peripherals.  There are many related features, such as
-          remote wakeup and driver-specific suspend processing, that
-          may not yet work as expected.
+          peripherals.
+
+          Also, USB "remote wakeup" signaling is supported, whereby some
+          USB devices (like keyboards and network adapters) can wake up
+          their parent hub.  That wakeup cascades up the USB tree, and
+          could wake the system from states like suspend-to-RAM.
 
           If you are unsure about this, say N here.
 
diff --git a/drivers/usb/core/Makefile b/drivers/usb/core/Makefile
index d5503cf0bf74..dd1c4d2a0c31 100644
--- a/drivers/usb/core/Makefile
+++ b/drivers/usb/core/Makefile
@@ -3,7 +3,7 @@
 #
 
 usbcore-objs    := usb.o hub.o hcd.o urb.o message.o \
-                        config.o file.o buffer.o sysfs.o devio.o
+                        config.o file.o buffer.o sysfs.o devio.o notify.o
 
 ifeq ($(CONFIG_PCI),y)
         usbcore-objs    += hcd-pci.o
diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c
index 99595e07b653..993019500cc3 100644
--- a/drivers/usb/core/config.c
+++ b/drivers/usb/core/config.c
@@ -112,8 +112,12 @@ void usb_release_interface_cache(struct kref *ref)
         struct usb_interface_cache *intfc = ref_to_usb_interface_cache(ref);
         int j;
 
-        for (j = 0; j < intfc->num_altsetting; j++)
-                kfree(intfc->altsetting[j].endpoint);
+        for (j = 0; j < intfc->num_altsetting; j++) {
+                struct usb_host_interface *alt = &intfc->altsetting[j];
+
+                kfree(alt->endpoint);
+                kfree(alt->string);
+        }
         kfree(intfc);
 }
 
@@ -188,10 +192,9 @@ static int usb_parse_interface(struct device *ddev, int cfgno,
         }
 
         len = sizeof(struct usb_host_endpoint) * num_ep;
-        alt->endpoint = kmalloc(len, GFP_KERNEL);
+        alt->endpoint = kzalloc(len, GFP_KERNEL);
         if (!alt->endpoint)
                 return -ENOMEM;
-        memset(alt->endpoint, 0, len);
 
         /* Parse all the endpoint descriptors */
         n = 0;
@@ -353,10 +356,9 @@ static int usb_parse_configuration(struct device *ddev, int cfgidx,
                 }
 
                 len = sizeof(*intfc) + sizeof(struct usb_host_interface) * j;
-                config->intf_cache[i] = intfc = kmalloc(len, GFP_KERNEL);
+                config->intf_cache[i] = intfc = kzalloc(len, GFP_KERNEL);
                 if (!intfc)
                         return -ENOMEM;
-                memset(intfc, 0, len);
                 kref_init(&intfc->ref);
         }
 
@@ -422,8 +424,6 @@ void usb_destroy_configuration(struct usb_device *dev)
                 struct usb_host_config *cf = &dev->config[c];
 
                 kfree(cf->string);
-                cf->string = NULL;
-
                 for (i = 0; i < cf->desc.bNumInterfaces; i++) {
                         if (cf->intf_cache[i])
                                 kref_put(&cf->intf_cache[i]->ref, 
@@ -459,16 +459,14 @@ int usb_get_configuration(struct usb_device *dev)
         }
 
         length = ncfg * sizeof(struct usb_host_config);
-        dev->config = kmalloc(length, GFP_KERNEL);
+        dev->config = kzalloc(length, GFP_KERNEL);
         if (!dev->config)
                 goto err2;
-        memset(dev->config, 0, length);
 
         length = ncfg * sizeof(char *);
-        dev->rawdescriptors = kmalloc(length, GFP_KERNEL);
+        dev->rawdescriptors = kzalloc(length, GFP_KERNEL);
         if (!dev->rawdescriptors)
                 goto err2;
-        memset(dev->rawdescriptors, 0, length);
 
         buffer = kmalloc(USB_DT_CONFIG_SIZE, GFP_KERNEL);
         if (!buffer)
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index befe0c7f63d1..942cd437dc48 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -46,6 +46,7 @@
 #include <linux/usb.h>
 #include <linux/usbdevice_fs.h>
 #include <linux/cdev.h>
+#include <linux/notifier.h>
 #include <asm/uaccess.h>
 #include <asm/byteorder.h>
 #include <linux/moduleparam.h>
@@ -209,10 +210,10 @@ err:
 static struct async *alloc_async(unsigned int numisoframes)
 {
         unsigned int assize = sizeof(struct async) + numisoframes * sizeof(struct usb_iso_packet_descriptor);
-        struct async *as = kmalloc(assize, GFP_KERNEL);
+        struct async *as = kzalloc(assize, GFP_KERNEL);
+
         if (!as)
                 return NULL;
-        memset(as, 0, assize);
         as->urb = usb_alloc_urb(numisoframes, GFP_KERNEL);
         if (!as->urb) {
                 kfree(as);
@@ -279,6 +280,28 @@ static inline struct async *async_getpending(struct dev_state *ps, void __user *
         return NULL;
 }
 
+static void snoop_urb(struct urb *urb, void __user *userurb)
+{
+        int j;
+        unsigned char *data = urb->transfer_buffer;
+
+        if (!usbfs_snoop)
+                return;
+
+        if (urb->pipe & USB_DIR_IN)
+                dev_info(&urb->dev->dev, "direction=IN\n");
+        else
+                dev_info(&urb->dev->dev, "direction=OUT\n");
+        dev_info(&urb->dev->dev, "userurb=%p\n", userurb);
+        dev_info(&urb->dev->dev, "transfer_buffer_length=%d\n",
+                 urb->transfer_buffer_length);
+        dev_info(&urb->dev->dev, "actual_length=%d\n", urb->actual_length);
+        dev_info(&urb->dev->dev, "data: ");
+        for (j = 0; j < urb->transfer_buffer_length; ++j)
+                printk ("%02x ", data[j]);
+        printk("\n");
+}
+
 static void async_completed(struct urb *urb, struct pt_regs *regs)
 {
         struct async *as = (struct async *)urb->context;
@@ -296,7 +319,9 @@ static void async_completed(struct urb *urb, struct pt_regs *regs)
                 kill_proc_info_as_uid(as->signr, &sinfo, as->pid, as->uid, 
                                       as->euid);
         }
-        wake_up(&ps->wait);
+        snoop(&urb->dev->dev, "urb complete\n");
+        snoop_urb(urb, as->userurb);
+        wake_up(&ps->wait);
 }
 
 static void destroy_async (struct dev_state *ps, struct list_head *list)
@@ -493,6 +518,23 @@ static int check_ctrlrecip(struct dev_state *ps, unsigned int requesttype, unsig
         return ret;
 }
 
+static struct usb_device *usbdev_lookup_minor(int minor)
+{
+        struct class_device *class_dev;
+        struct usb_device *dev = NULL;
+
+        down(&usb_device_class->sem);
+        list_for_each_entry(class_dev, &usb_device_class->children, node) {
+                if (class_dev->devt == MKDEV(USB_DEVICE_MAJOR, minor)) {
+                        dev = class_dev->class_data;
+                        break;
+                }
+        }
+        up(&usb_device_class->sem);
+
+        return dev;
+};
+
 /*
  * file operations
  */
@@ -601,7 +643,7 @@ static int proc_control(struct dev_state *ps, void __user *arg)
                         if (usbfs_snoop) {
                                 dev_info(&dev->dev, "control read: data ");
                                 for (j = 0; j < i; ++j)
-                                        printk ("%02x ", (unsigned char)(tbuf)[j]);
+                                        printk("%02x ", (unsigned char)(tbuf)[j]);
                                 printk("\n");
                         }
                         if (copy_to_user(ctrl.data, tbuf, i)) {
@@ -624,7 +666,7 @@ static int proc_control(struct dev_state *ps, void __user *arg)
                 if (usbfs_snoop) {
                         dev_info(&dev->dev, "control write: data: ");
                         for (j = 0; j < ctrl.wLength; ++j)
-                                printk ("%02x ", (unsigned char)(tbuf)[j]);
+                                printk("%02x ", (unsigned char)(tbuf)[j]);
                         printk("\n");
                 }
                 usb_unlock_device(dev);
@@ -649,7 +691,7 @@ static int proc_bulk(struct dev_state *ps, void __user *arg)
         unsigned int tmo, len1, pipe;
         int len2;
         unsigned char *tbuf;
-        int i, ret;
+        int i, j, ret;
 
         if (copy_from_user(&bulk, arg, sizeof(bulk)))
                 return -EFAULT;
@@ -674,10 +716,18 @@ static int proc_bulk(struct dev_state *ps, void __user *arg)
                         kfree(tbuf);
                         return -EINVAL;
                 }
+                snoop(&dev->dev, "bulk read: len=0x%02x timeout=%04d\n",
+                        bulk.len, bulk.timeout);
                 usb_unlock_device(dev);
                 i = usb_bulk_msg(dev, pipe, tbuf, len1, &len2, tmo);
                 usb_lock_device(dev);
                 if (!i && len2) {
+                        if (usbfs_snoop) {
+                                dev_info(&dev->dev, "bulk read: data ");
+                                for (j = 0; j < len2; ++j)
+                                        printk("%02x ", (unsigned char)(tbuf)[j]);
+                                printk("\n");
+                        }
                         if (copy_to_user(bulk.data, tbuf, len2)) {
                                 kfree(tbuf);
                                 return -EFAULT;
@@ -690,6 +740,14 @@ static int proc_bulk(struct dev_state *ps, void __user *arg)
                                 return -EFAULT;
                         }
                 }
+                snoop(&dev->dev, "bulk write: len=0x%02x timeout=%04d\n",
+                        bulk.len, bulk.timeout);
+                if (usbfs_snoop) {
+                        dev_info(&dev->dev, "bulk write: data: ");
+                        for (j = 0; j < len1; ++j)
+                                printk("%02x ", (unsigned char)(tbuf)[j]);
+                        printk("\n");
+                }
                 usb_unlock_device(dev);
                 i = usb_bulk_msg(dev, pipe, tbuf, len1, &len2, tmo);
                 usb_lock_device(dev);
@@ -835,7 +893,6 @@ static int proc_setconfig(struct dev_state *ps, void __user *arg)
         return status;
 }
 
-
 static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                              struct usbdevfs_iso_packet_desc __user *iso_frame_desc,
                              void __user *arg)
@@ -896,6 +953,7 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                         kfree(dr);
                         return -EFAULT;
                 }
+                snoop(&ps->dev->dev, "control urb\n");
                 break;
 
         case USBDEVFS_URB_TYPE_BULK:
@@ -910,6 +968,7 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                         return -EINVAL;
                 if (!access_ok((uurb->endpoint & USB_DIR_IN) ? VERIFY_WRITE : VERIFY_READ, uurb->buffer, uurb->buffer_length))
                         return -EFAULT;
+                snoop(&ps->dev->dev, "bulk urb\n");
                 break;
 
         case USBDEVFS_URB_TYPE_ISO:
@@ -939,6 +998,7 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                         return -EINVAL;
                 }
                 uurb->buffer_length = totlen;
+                snoop(&ps->dev->dev, "iso urb\n");
                 break;
 
         case USBDEVFS_URB_TYPE_INTERRUPT:
@@ -954,6 +1014,7 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                         return -EINVAL;
                 if (!access_ok((uurb->endpoint & USB_DIR_IN) ? VERIFY_WRITE : VERIFY_READ, uurb->buffer, uurb->buffer_length))
                         return -EFAULT;
+                snoop(&ps->dev->dev, "interrupt urb\n");
                 break;
 
         default:
@@ -1003,6 +1064,8 @@ static int proc_do_submiturb(struct dev_state *ps, struct usbdevfs_urb *uurb,
                         return -EFAULT;
                 }
         }
+        snoop(&as->urb->dev->dev, "submit urb\n");
+        snoop_urb(as->urb, as->userurb);
         async_newpending(as);
         if ((ret = usb_submit_urb(as->urb, GFP_KERNEL))) {
                 dev_printk(KERN_DEBUG, &ps->dev->dev, "usbfs: usb_submit_urb returned %d\n", ret);
@@ -1238,23 +1301,20 @@ static int proc_releaseinterface(struct dev_state *ps, void __user *arg)
         return 0;
 }
 
-static int proc_ioctl (struct dev_state *ps, void __user *arg)
+static int proc_ioctl(struct dev_state *ps, struct usbdevfs_ioctl *ctl)
 {
-        struct usbdevfs_ioctl   ctrl;
         int                     size;
         void                    *buf = NULL;
         int                     retval = 0;
         struct usb_interface    *intf = NULL;
         struct usb_driver       *driver = NULL;
 
-        /* get input parameters and alloc buffer */
-        if (copy_from_user(&ctrl, arg, sizeof (ctrl)))
-                return -EFAULT;
-        if ((size = _IOC_SIZE (ctrl.ioctl_code)) > 0) {
+        /* alloc buffer */
+        if ((size = _IOC_SIZE (ctl->ioctl_code)) > 0) {
                 if ((buf = kmalloc (size, GFP_KERNEL)) == NULL)
                         return -ENOMEM;
-                if ((_IOC_DIR(ctrl.ioctl_code) & _IOC_WRITE)) {
-                        if (copy_from_user (buf, ctrl.data, size)) {
+                if ((_IOC_DIR(ctl->ioctl_code) & _IOC_WRITE)) {
+                        if (copy_from_user (buf, ctl->data, size)) {
                                 kfree(buf);
                                 return -EFAULT;
                         }
@@ -1270,9 +1330,9 @@ static int proc_ioctl (struct dev_state *ps, void __user *arg)
 
         if (ps->dev->state != USB_STATE_CONFIGURED)
                 retval = -EHOSTUNREACH;
-        else if (!(intf = usb_ifnum_to_if (ps->dev, ctrl.ifno)))
+        else if (!(intf = usb_ifnum_to_if (ps->dev, ctl->ifno)))
                retval = -EINVAL;
-        else switch (ctrl.ioctl_code) {
+        else switch (ctl->ioctl_code) {
 
         /* disconnect kernel driver from interface */
         case USBDEVFS_DISCONNECT:
@@ -1304,7 +1364,7 @@ static int proc_ioctl (struct dev_state *ps, void __user *arg)
                 if (driver == NULL || driver->ioctl == NULL) {
                         retval = -ENOTTY;
                 } else {
-                        retval = driver->ioctl (intf, ctrl.ioctl_code, buf);
+                        retval = driver->ioctl (intf, ctl->ioctl_code, buf);
                         if (retval == -ENOIOCTLCMD)
                                 retval = -ENOTTY;
                 }
@@ -1313,15 +1373,42 @@ static int proc_ioctl (struct dev_state *ps, void __user *arg)
 
         /* cleanup and return */
         if (retval >= 0
-                        && (_IOC_DIR (ctrl.ioctl_code) & _IOC_READ) != 0
+                        && (_IOC_DIR (ctl->ioctl_code) & _IOC_READ) != 0
                         && size > 0
-                        && copy_to_user (ctrl.data, buf, size) != 0)
+                        && copy_to_user (ctl->data, buf, size) != 0)
                 retval = -EFAULT;
 
         kfree(buf);
         return retval;
 }
 
+static int proc_ioctl_default(struct dev_state *ps, void __user *arg)
+{
+        struct usbdevfs_ioctl   ctrl;
+
+        if (copy_from_user(&ctrl, arg, sizeof (ctrl)))
+                return -EFAULT;
+        return proc_ioctl(ps, &ctrl);
+}
+
+#ifdef CONFIG_COMPAT
+static int proc_ioctl_compat(struct dev_state *ps, void __user *arg)
+{
+        struct usbdevfs_ioctl32 __user *uioc;
+        struct usbdevfs_ioctl ctrl;
+        u32 udata;
+
+        uioc = compat_ptr(arg);
+        if (get_user(ctrl.ifno, &uioc->ifno) ||
+            get_user(ctrl.ioctl_code, &uioc->ioctl_code) ||
+            __get_user(udata, &uioc->data))
+                return -EFAULT;
+        ctrl.data = compat_ptr(udata);
+
+        return proc_ioctl(ps, &ctrl);
+}
+#endif
+
 /*
  * NOTE:  All requests here that have interface numbers as parameters
  * are assuming that somehow the configuration has been prevented from
@@ -1422,6 +1509,10 @@ static int usbdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd
                 ret = proc_reapurbnonblock_compat(ps, p);
                 break;
 
+        case USBDEVFS_IOCTL32:
+                snoop(&dev->dev, "%s: IOCTL\n", __FUNCTION__);
+                ret = proc_ioctl_compat(ps, p);
+                break;
 #endif
 
         case USBDEVFS_DISCARDURB:
@@ -1456,7 +1547,7 @@ static int usbdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd
 
         case USBDEVFS_IOCTL:
                 snoop(&dev->dev, "%s: IOCTL\n", __FUNCTION__);
-                ret = proc_ioctl(ps, p);
+                ret = proc_ioctl_default(ps, p);
                 break;
         }
         usb_unlock_device(dev);
@@ -1488,24 +1579,7 @@ struct file_operations usbfs_device_file_operations = {
         .release =      usbdev_release,
 };
 
-struct usb_device *usbdev_lookup_minor(int minor)
-{
-        struct class_device *class_dev;
-        struct usb_device *dev = NULL;
-
-        down(&usb_device_class->sem);
-        list_for_each_entry(class_dev, &usb_device_class->children, node) {
-                if (class_dev->devt == MKDEV(USB_DEVICE_MAJOR, minor)) {
-                        dev = class_dev->class_data;
-                        break;
-                }
-        }
-        up(&usb_device_class->sem);
-
-        return dev;
-};
-
-void usbdev_add(struct usb_device *dev)
+static void usbdev_add(struct usb_device *dev)
 {
         int minor = ((dev->bus->busnum-1) * 128) + (dev->devnum-1);
 
@@ -1516,11 +1590,29 @@ void usbdev_add(struct usb_device *dev)
         dev->class_dev->class_data = dev;
 }
 
-void usbdev_remove(struct usb_device *dev)
+static void usbdev_remove(struct usb_device *dev)
 {
         class_device_unregister(dev->class_dev);
 }
 
+static int usbdev_notify(struct notifier_block *self, unsigned long action,
+                         void *dev)
+{
+        switch (action) {
+        case USB_DEVICE_ADD:
+                usbdev_add(dev);
+                break;
+        case USB_DEVICE_REMOVE:
+                usbdev_remove(dev);
+                break;
+        }
+        return NOTIFY_OK;
+}
+
+static struct notifier_block usbdev_nb = {
+        .notifier_call =        usbdev_notify,
+};
+
 static struct cdev usb_device_cdev = {
         .kobj   = {.name = "usb_device", },
         .owner  = THIS_MODULE,
@@ -1540,24 +1632,32 @@ int __init usbdev_init(void)
         retval = cdev_add(&usb_device_cdev, USB_DEVICE_DEV, USB_DEVICE_MAX);
         if (retval) {
                 err("unable to get usb_device major %d", USB_DEVICE_MAJOR);
-                unregister_chrdev_region(USB_DEVICE_DEV, USB_DEVICE_MAX);
-                goto out;
+                goto error_cdev;
         }
         usb_device_class = class_create(THIS_MODULE, "usb_device");
         if (IS_ERR(usb_device_class)) {
                 err("unable to register usb_device class");
                 retval = PTR_ERR(usb_device_class);
-                usb_device_class = NULL;
-                cdev_del(&usb_device_cdev);
-                unregister_chrdev_region(USB_DEVICE_DEV, USB_DEVICE_MAX);
+                goto error_class;
         }
 
+        usb_register_notify(&usbdev_nb);
+
 out:
         return retval;
+
+error_class:
+        usb_device_class = NULL;
+        cdev_del(&usb_device_cdev);
+
+error_cdev:
+        unregister_chrdev_region(USB_DEVICE_DEV, USB_DEVICE_MAX);
+        goto out;
 }
 
 void usbdev_cleanup(void)
 {
+        usb_unregister_notify(&usbdev_nb);
         class_destroy(usb_device_class);
         cdev_del(&usb_device_cdev);
         unregister_chrdev_region(USB_DEVICE_DEV, USB_DEVICE_MAX);
diff --git a/drivers/usb/core/file.c b/drivers/usb/core/file.c
index 78cb4be9529f..e695308095ae 100644
--- a/drivers/usb/core/file.c
+++ b/drivers/usb/core/file.c
@@ -17,7 +17,6 @@
 
 #include <linux/config.h>
 #include <linux/module.h>
-#include <linux/devfs_fs_kernel.h>
 #include <linux/spinlock.h>
 #include <linux/errno.h>
 
@@ -88,8 +87,6 @@ int usb_major_init(void)
                 goto out;
         }
 
-        devfs_mk_dir("usb");
-
 out:
         return error;
 }
@@ -97,7 +94,6 @@ out:
 void usb_major_cleanup(void)
 {
         class_destroy(usb_class);
-        devfs_remove("usb");
         unregister_chrdev(USB_MAJOR, "usb");
 }
 
@@ -112,8 +108,7 @@ void usb_major_cleanup(void)
  * enabled, the minor number will be based on the next available free minor,
  * starting at the class_driver->minor_base.
  *
- * This function also creates the devfs file for the usb device, if devfs
- * is enabled, and creates a usb class device in the sysfs tree.
+ * This function also creates a usb class device in the sysfs tree.
  *
  * usb_deregister_dev() must be called when the driver is done with
  * the minor numbers given out by this function.
@@ -162,11 +157,8 @@ int usb_register_dev(struct usb_interface *intf,
 
         intf->minor = minor;
 
-        /* handle the devfs registration */
-        snprintf(name, BUS_ID_SIZE, class_driver->name, minor - minor_base);
-        devfs_mk_cdev(MKDEV(USB_MAJOR, minor), class_driver->mode, name);
-
         /* create a usb class device for this usb interface */
+        snprintf(name, BUS_ID_SIZE, class_driver->name, minor - minor_base);
         temp = strrchr(name, '/');
         if (temp && (temp[1] != 0x00))
                 ++temp;
@@ -179,7 +171,6 @@ int usb_register_dev(struct usb_interface *intf,
                 spin_lock (&minor_lock);
                 usb_minors[intf->minor] = NULL;
                 spin_unlock (&minor_lock);
-                devfs_remove (name);
                 retval = PTR_ERR(intf->class_dev);
         }
 exit:
@@ -197,9 +188,8 @@ EXPORT_SYMBOL(usb_register_dev);
  * call to usb_register_dev() (usually when the device is disconnected
  * from the system.)
  *
- * This function also cleans up the devfs file for the usb device, if devfs
- * is enabled, and removes the usb class device from the sysfs tree.
- * 
+ * This function also removes the usb class device from the sysfs tree.
+ *
  * This should be called by all drivers that use the USB major number.
  */
 void usb_deregister_dev(struct usb_interface *intf,
@@ -222,7 +212,6 @@ void usb_deregister_dev(struct usb_interface *intf,
         spin_unlock (&minor_lock);
 
         snprintf(name, BUS_ID_SIZE, class_driver->name, intf->minor - minor_base);
-        devfs_remove (name);
         class_device_destroy(usb_class, MKDEV(USB_MAJOR, intf->minor));
         intf->class_dev = NULL;
         intf->minor = -1;
diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c
index 6385d1a99b60..84d9e69329bb 100644
--- a/drivers/usb/core/hcd-pci.c
+++ b/drivers/usb/core/hcd-pci.c
@@ -30,6 +30,8 @@
 #include <asm/io.h>
 #include <asm/irq.h>
 #include <linux/usb.h>
+
+#include "usb.h"
 #include "hcd.h"
 
 
@@ -197,6 +199,26 @@ int usb_hcd_pci_suspend (struct pci_dev *dev, pm_message_t message)
 
         hcd = pci_get_drvdata(dev);
 
+        /* Root hub suspend should have stopped all downstream traffic,
+         * and all bus master traffic.  And done so for both the interface
+         * and the stub usb_device (which we check here).  But maybe it
+         * didn't; writing sysfs power/state files ignores such rules...
+         *
+         * We must ignore the FREEZE vs SUSPEND distinction here, because
+         * otherwise the swsusp will save (and restore) garbage state.
+         */
+        if (hcd->self.root_hub->dev.power.power_state.event == PM_EVENT_ON)
+                return -EBUSY;
+
+        if (hcd->driver->suspend) {
+                retval = hcd->driver->suspend(hcd, message);
+                if (retval) {
+                        dev_dbg (&dev->dev, "PCI pre-suspend fail, %d\n",
+                                retval);
+                        goto done;
+                }
+        }
+
         /* FIXME until the generic PM interfaces change a lot more, this
          * can't use PCI D1 and D2 states.  For example, the confusion
          * between messages and states will need to vanish, and messages
@@ -215,31 +237,13 @@ int usb_hcd_pci_suspend (struct pci_dev *dev, pm_message_t message)
          */
         has_pci_pm = pci_find_capability(dev, PCI_CAP_ID_PM);
 
-        switch (hcd->state) {
-
-        /* entry if root hub wasn't yet suspended ... from sysfs,
-         * without autosuspend, or if USB_SUSPEND isn't configured.
+        /* Downstream ports from this root hub should already be quiesced, so
+         * there will be no DMA activity.  Now we can shut down the upstream
+         * link (except maybe for PME# resume signaling) and enter some PCI
+         * low power state, if the hardware allows.
          */
-        case HC_STATE_RUNNING:
-                hcd->state = HC_STATE_QUIESCING;
-                retval = hcd->driver->suspend (hcd, message);
-                if (retval) {
-                        dev_dbg (hcd->self.controller, 
-                                        "suspend fail, retval %d\n",
-                                        retval);
-                        break;
-                }
-                hcd->state = HC_STATE_SUSPENDED;
-                /* FALLTHROUGH */
+        if (hcd->state == HC_STATE_SUSPENDED) {
 
-        /* entry with CONFIG_USB_SUSPEND, or hcds that autosuspend: the
-         * controller and/or root hub will already have been suspended,
-         * but it won't be ready for a PCI resume call.
-         *
-         * FIXME only CONFIG_USB_SUSPEND guarantees hub_suspend() will
-         * have been called, otherwise root hub timers still run ...
-         */
-        case HC_STATE_SUSPENDED:
                 /* no DMA or IRQs except when HC is active */
                 if (dev->current_state == PCI_D0) {
                         pci_save_state (dev);
@@ -248,7 +252,7 @@ int usb_hcd_pci_suspend (struct pci_dev *dev, pm_message_t message)
 
                 if (!has_pci_pm) {
                         dev_dbg (hcd->self.controller, "--> PCI D0/legacy\n");
-                        break;
+                        goto done;
                 }
 
                 /* NOTE:  dev->current_state becomes nonzero only here, and
@@ -259,28 +263,29 @@ int usb_hcd_pci_suspend (struct pci_dev *dev, pm_message_t message)
                 retval = pci_set_power_state (dev, PCI_D3hot);
                 if (retval == 0) {
                         dev_dbg (hcd->self.controller, "--> PCI D3\n");
-                        retval = pci_enable_wake (dev, PCI_D3hot, hcd->remote_wakeup);
-                        if (retval)
-                                break;
-                        retval = pci_enable_wake (dev, PCI_D3cold, hcd->remote_wakeup);
-                } else if (retval < 0) {
+
+                        /* Ignore these return values.  We rely on pci code to
+                         * reject requests the hardware can't implement, rather
+                         * than coding the same thing.
+                         */
+                        (void) pci_enable_wake (dev, PCI_D3hot, hcd->remote_wakeup);
+                        (void) pci_enable_wake (dev, PCI_D3cold, hcd->remote_wakeup);
+                } else {
                         dev_dbg (&dev->dev, "PCI D3 suspend fail, %d\n",
                                         retval);
                         (void) usb_hcd_pci_resume (dev);
-                        break;
                 }
-                break;
-        default:
+
+        } else {
                 dev_dbg (hcd->self.controller, "hcd state %d; not suspended\n",
                         hcd->state);
                 WARN_ON(1);
                 retval = -EINVAL;
-                break;
         }
 
-        /* update power_state **ONLY** to make sysfs happier */
+done:
         if (retval == 0)
-                dev->dev.power.power_state = message;
+                dev->dev.power.power_state = PMSG_SUSPEND;
         return retval;
 }
 EXPORT_SYMBOL (usb_hcd_pci_suspend);
@@ -336,20 +341,9 @@ int usb_hcd_pci_resume (struct pci_dev *dev)
                                 dev->current_state);
                 }
 #endif
-                retval = pci_enable_wake (dev, dev->current_state, 0);
-                if (retval) {
-                        dev_err(hcd->self.controller,
-                                "can't enable_wake to %d, %d!\n",
-                                dev->current_state, retval);
-                        return retval;
-                }
-                retval = pci_enable_wake (dev, PCI_D3cold, 0);
-                if (retval) {
-                        dev_err(hcd->self.controller,
-                                "can't enable_wake to %d, %d!\n",
-                                PCI_D3cold, retval);
-                        return retval;
-                }
+                /* yes, ignore these results too... */
+                (void) pci_enable_wake (dev, dev->current_state, 0);
+                (void) pci_enable_wake (dev, PCI_D3cold, 0);
         } else {
                 /* Same basic cases: clean (powered/not), dirty */
                 dev_dbg(hcd->self.controller, "PCI legacy resume\n");
@@ -371,17 +365,17 @@ int usb_hcd_pci_resume (struct pci_dev *dev)
 
         dev->dev.power.power_state = PMSG_ON;
 
-        hcd->state = HC_STATE_RESUMING;
         hcd->saw_irq = 0;
 
-        retval = hcd->driver->resume (hcd);
-        if (!HC_IS_RUNNING (hcd->state)) {
-                dev_dbg (hcd->self.controller, 
-                                "resume fail, retval %d\n", retval);
-                usb_hc_died (hcd);
+        if (hcd->driver->resume) {
+                retval = hcd->driver->resume(hcd);
+                if (retval) {
+                        dev_err (hcd->self.controller,
+                                "PCI post-resume error %d!\n", retval);
+                        usb_hc_died (hcd);
+                }
         }
 
-        retval = pci_enable_device(dev);
         return retval;
 }
 EXPORT_SYMBOL (usb_hcd_pci_resume);
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 14c47a10da86..6c7ca5b08cd6 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -130,7 +130,7 @@ static const u8 usb2_rh_dev_descriptor [18] = {
         0x09,       /*  __u8  bDeviceClass; HUB_CLASSCODE */
         0x00,       /*  __u8  bDeviceSubClass; */
         0x01,       /*  __u8  bDeviceProtocol; [ usb 2.0 single TT ]*/
-        0x08,       /*  __u8  bMaxPacketSize0; 8 Bytes */
+        0x40,       /*  __u8  bMaxPacketSize0; 64 Bytes */
 
         0x00, 0x00, /*  __le16 idVendor; */
         0x00, 0x00, /*  __le16 idProduct; */
@@ -153,7 +153,7 @@ static const u8 usb11_rh_dev_descriptor [18] = {
         0x09,       /*  __u8  bDeviceClass; HUB_CLASSCODE */
         0x00,       /*  __u8  bDeviceSubClass; */
         0x00,       /*  __u8  bDeviceProtocol; [ low/full speeds only ] */
-        0x08,       /*  __u8  bMaxPacketSize0; 8 Bytes */
+        0x40,       /*  __u8  bMaxPacketSize0; 64 Bytes */
 
         0x00, 0x00, /*  __le16 idVendor; */
         0x00, 0x00, /*  __le16 idProduct; */
@@ -458,22 +458,18 @@ static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
 
         default:
                 /* non-generic request */
-                if (HC_IS_SUSPENDED (hcd->state))
-                        status = -EAGAIN;
-                else {
-                        switch (typeReq) {
-                        case GetHubStatus:
-                        case GetPortStatus:
-                                len = 4;
-                                break;
-                        case GetHubDescriptor:
-                                len = sizeof (struct usb_hub_descriptor);
-                                break;
-                        }
-                        status = hcd->driver->hub_control (hcd,
-                                typeReq, wValue, wIndex,
-                                tbuf, wLength);
+                switch (typeReq) {
+                case GetHubStatus:
+                case GetPortStatus:
+                        len = 4;
+                        break;
+                case GetHubDescriptor:
+                        len = sizeof (struct usb_hub_descriptor);
+                        break;
                 }
+                status = hcd->driver->hub_control (hcd,
+                        typeReq, wValue, wIndex,
+                        tbuf, wLength);
                 break;
 error:
                 /* "protocol stall" on error */
@@ -487,7 +483,7 @@ error:
                                 "CTRL: TypeReq=0x%x val=0x%x "
                                 "idx=0x%x len=%d ==> %d\n",
                                 typeReq, wValue, wIndex,
-                                wLength, urb->status);
+                                wLength, status);
                 }
         }
         if (len) {
@@ -748,10 +744,9 @@ struct usb_bus *usb_alloc_bus (struct usb_operations *op)
 {
         struct usb_bus *bus;
 
-        bus = kmalloc (sizeof *bus, GFP_KERNEL);
+        bus = kzalloc (sizeof *bus, GFP_KERNEL);
         if (!bus)
                 return NULL;
-        memset(bus, 0, sizeof(struct usb_bus));
         usb_bus_init (bus);
         bus->op = op;
         return bus;
@@ -796,8 +791,7 @@ static int usb_register_bus(struct usb_bus *bus)
         list_add (&bus->bus_list, &usb_bus_list);
         up (&usb_bus_list_lock);
 
-        usbfs_add_bus (bus);
-        usbmon_notify_bus_add (bus);
+        usb_notify_add_bus(bus);
 
         dev_info (bus->controller, "new USB bus registered, assigned bus number %d\n", bus->busnum);
         return 0;
@@ -824,8 +818,7 @@ static void usb_deregister_bus (struct usb_bus *bus)
         list_del (&bus->bus_list);
         up (&usb_bus_list_lock);
 
-        usbmon_notify_bus_remove (bus);
-        usbfs_remove_bus (bus);
+        usb_notify_remove_bus(bus);
 
         clear_bit (bus->busnum, busmap.busmap);
 
@@ -1143,10 +1136,20 @@ static int hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
         else switch (hcd->state) {
         case HC_STATE_RUNNING:
         case HC_STATE_RESUMING:
+doit:
                 usb_get_dev (urb->dev);
                 list_add_tail (&urb->urb_list, &ep->urb_list);
                 status = 0;
                 break;
+        case HC_STATE_SUSPENDED:
+                /* HC upstream links (register access, wakeup signaling) can work
+                 * even when the downstream links (and DMA etc) are quiesced; let
+                 * usbcore talk to the root hub.
+                 */
+                if (hcd->self.controller->power.power_state.event == PM_EVENT_ON
+                                && urb->dev->parent == NULL)
+                        goto doit;
+                /* FALL THROUGH */
         default:
                 status = -ESHUTDOWN;
                 break;
@@ -1294,12 +1297,6 @@ static int hcd_unlink_urb (struct urb *urb, int status)
                 goto done;
         }
 
-        /* running ~= hc unlink handshake works (irq, timer, etc)
-         * halted ~= no unlink handshake is needed
-         * suspended, resuming == should never happen
-         */
-        WARN_ON (!HC_IS_RUNNING (hcd->state) && hcd->state != HC_STATE_HALT);
-
         /* insist the urb is still queued */
         list_for_each(tmp, &ep->urb_list) {
                 if (tmp == &urb->urb_list)
@@ -1431,28 +1428,92 @@ rescan:
 
 /*-------------------------------------------------------------------------*/
 
-#ifdef  CONFIG_USB_SUSPEND
+#ifdef  CONFIG_PM
 
-static int hcd_hub_suspend (struct usb_bus *bus)
+int hcd_bus_suspend (struct usb_bus *bus)
 {
         struct usb_hcd          *hcd;
+        int                     status;
 
         hcd = container_of (bus, struct usb_hcd, self);
-        if (hcd->driver->hub_suspend)
-                return hcd->driver->hub_suspend (hcd);
-        return 0;
+        if (!hcd->driver->bus_suspend)
+                return -ENOENT;
+        hcd->state = HC_STATE_QUIESCING;
+        status = hcd->driver->bus_suspend (hcd);
+        if (status == 0)
+                hcd->state = HC_STATE_SUSPENDED;
+        else
+                dev_dbg(&bus->root_hub->dev, "%s fail, err %d\n",
+                                "suspend", status);
+        return status;
 }
 
-static int hcd_hub_resume (struct usb_bus *bus)
+int hcd_bus_resume (struct usb_bus *bus)
 {
         struct usb_hcd          *hcd;
+        int                     status;
 
         hcd = container_of (bus, struct usb_hcd, self);
-        if (hcd->driver->hub_resume)
-                return hcd->driver->hub_resume (hcd);
-        return 0;
+        if (!hcd->driver->bus_resume)
+                return -ENOENT;
+        if (hcd->state == HC_STATE_RUNNING)
+                return 0;
+        hcd->state = HC_STATE_RESUMING;
+        status = hcd->driver->bus_resume (hcd);
+        if (status == 0)
+                hcd->state = HC_STATE_RUNNING;
+        else {
+                dev_dbg(&bus->root_hub->dev, "%s fail, err %d\n",
+                                "resume", status);
+                usb_hc_died(hcd);
+        }
+        return status;
 }
 
+/*
+ * usb_hcd_suspend_root_hub - HCD autosuspends downstream ports
+ * @hcd: host controller for this root hub
+ *
+ * This call arranges that usb_hcd_resume_root_hub() is safe to call later;
+ * that the HCD's root hub polling is deactivated; and that the root's hub
+ * driver is suspended.  HCDs may call this to autosuspend when their root
+ * hub's downstream ports are all inactive:  unpowered, disconnected,
+ * disabled, or suspended.
+ *
+ * The HCD will autoresume on device connect change detection (using SRP
+ * or a D+/D- pullup).  The HCD also autoresumes on remote wakeup signaling
+ * from any ports that are suspended (if that is enabled).  In most cases,
+ * overcurrent signaling (on powered ports) will also start autoresume.
+ *
+ * Always called with IRQs blocked.
+ */
+void usb_hcd_suspend_root_hub (struct usb_hcd *hcd)
+{
+        struct urb      *urb;
+
+        spin_lock (&hcd_root_hub_lock);
+        usb_suspend_root_hub (hcd->self.root_hub);
+
+        /* force status urb to complete/unlink while suspended */
+        if (hcd->status_urb) {
+                urb = hcd->status_urb;
+                urb->status = -ECONNRESET;
+                urb->hcpriv = NULL;
+                urb->actual_length = 0;
+
+                del_timer (&hcd->rh_timer);
+                hcd->poll_pending = 0;
+                hcd->status_urb = NULL;
+        } else
+                urb = NULL;
+        spin_unlock (&hcd_root_hub_lock);
+        hcd->state = HC_STATE_SUSPENDED;
+
+        if (urb)
+                usb_hcd_giveback_urb (hcd, urb, NULL);
+}
+EXPORT_SYMBOL_GPL(usb_hcd_suspend_root_hub);
+
 /**
  * usb_hcd_resume_root_hub - called by HCD to resume its root hub 
  * @hcd: host controller for this root hub
@@ -1460,7 +1521,7 @@ static int hcd_hub_resume (struct usb_bus *bus)
  * The USB host controller calls this function when its root hub is
  * suspended (with the remote wakeup feature enabled) and a remote
  * wakeup request is received.  It queues a request for khubd to
- * resume the root hub.
+ * resume the root hub (that is, manage its downstream ports again).
  */
 void usb_hcd_resume_root_hub (struct usb_hcd *hcd)
 {
@@ -1471,13 +1532,9 @@ void usb_hcd_resume_root_hub (struct usb_hcd *hcd)
                 usb_resume_root_hub (hcd->self.root_hub);
         spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
 }
+EXPORT_SYMBOL_GPL(usb_hcd_resume_root_hub);
 
-#else
-void usb_hcd_resume_root_hub (struct usb_hcd *hcd)
-{
-}
 #endif
-EXPORT_SYMBOL_GPL(usb_hcd_resume_root_hub);
 
 /*-------------------------------------------------------------------------*/
 
@@ -1530,10 +1587,6 @@ static struct usb_operations usb_hcd_operations = {
         .buffer_alloc =         hcd_buffer_alloc,
         .buffer_free =          hcd_buffer_free,
         .disable =              hcd_endpoint_disable,
-#ifdef  CONFIG_USB_SUSPEND
-        .hub_suspend =          hcd_hub_suspend,
-        .hub_resume =           hcd_hub_resume,
-#endif
 };
 
 /*-------------------------------------------------------------------------*/
diff --git a/drivers/usb/core/hcd.h b/drivers/usb/core/hcd.h
index 1f1ed6211af8..24a62a2ff86d 100644
--- a/drivers/usb/core/hcd.h
+++ b/drivers/usb/core/hcd.h
@@ -154,10 +154,6 @@ struct usb_operations {
 
         void (*disable)(struct usb_device *udev,
                         struct usb_host_endpoint *ep);
-
-        /* global suspend/resume of bus */
-        int (*hub_suspend)(struct usb_bus *);
-        int (*hub_resume)(struct usb_bus *);
 };
 
 /* each driver provides one of these, and hardware init support */
@@ -182,12 +178,12 @@ struct hc_driver {
         int     (*start) (struct usb_hcd *hcd);
 
         /* NOTE:  these suspend/resume calls relate to the HC as
-         * a whole, not just the root hub; they're for bus glue.
+         * a whole, not just the root hub; they're for PCI bus glue.
          */
-        /* called after all devices were suspended */
+        /* called after suspending the hub, before entering D3 etc */
         int     (*suspend) (struct usb_hcd *hcd, pm_message_t message);
 
-        /* called before any devices get resumed */
+        /* called after entering D0 (etc), before resuming the hub */
         int     (*resume) (struct usb_hcd *hcd);
 
         /* cleanly make HCD stop writing memory and doing I/O */
@@ -212,8 +208,8 @@ struct hc_driver {
         int             (*hub_control) (struct usb_hcd *hcd,
                                 u16 typeReq, u16 wValue, u16 wIndex,
                                 char *buf, u16 wLength);
-        int             (*hub_suspend)(struct usb_hcd *);
-        int             (*hub_resume)(struct usb_hcd *);
+        int             (*bus_suspend)(struct usb_hcd *);
+        int             (*bus_resume)(struct usb_hcd *);
         int             (*start_port_reset)(struct usb_hcd *, unsigned port_num);
         void            (*hub_irq_enable)(struct usb_hcd *);
                 /* Needed only if port-change IRQs are level-triggered */
@@ -355,8 +351,6 @@ extern long usb_calc_bus_time (int speed, int is_input,
 
 extern struct usb_bus *usb_alloc_bus (struct usb_operations *);
 
-extern void usb_hcd_resume_root_hub (struct usb_hcd *hcd);
-
 extern void usb_set_device_state(struct usb_device *udev,
                 enum usb_device_state new_state);
 
@@ -378,6 +372,33 @@ extern int usb_find_interface_driver (struct usb_device *dev,
 
 #define usb_endpoint_out(ep_dir)        (!((ep_dir) & USB_DIR_IN))
 
+#ifdef CONFIG_PM
+extern void usb_hcd_suspend_root_hub (struct usb_hcd *hcd);
+extern void usb_hcd_resume_root_hub (struct usb_hcd *hcd);
+extern int hcd_bus_suspend (struct usb_bus *bus);
+extern int hcd_bus_resume (struct usb_bus *bus);
+#else
+static inline void usb_hcd_suspend_root_hub(struct usb_hcd *hcd)
+{
+        return;
+}
+
+static inline void usb_hcd_resume_root_hub(struct usb_hcd *hcd)
+{
+        return;
+}
+
+static inline int hcd_bus_suspend(struct usb_bus *bus)
+{
+        return 0;
+}
+
+static inline int hcd_bus_resume (struct usb_bus *bus)
+{
+        return 0;
+}
+#endif /* CONFIG_PM */
+
 /*
  * USB device fs stuff
  */
@@ -388,23 +409,13 @@ extern int usb_find_interface_driver (struct usb_device *dev,
  * these are expected to be called from the USB core/hub thread
  * with the kernel lock held
  */
-extern void usbfs_add_bus(struct usb_bus *bus);
-extern void usbfs_remove_bus(struct usb_bus *bus);
-extern void usbfs_add_device(struct usb_device *dev);
-extern void usbfs_remove_device(struct usb_device *dev);
 extern void usbfs_update_special (void);
-
 extern int usbfs_init(void);
 extern void usbfs_cleanup(void);
 
 #else /* CONFIG_USB_DEVICEFS */
 
-static inline void usbfs_add_bus(struct usb_bus *bus) {}
-static inline void usbfs_remove_bus(struct usb_bus *bus) {}
-static inline void usbfs_add_device(struct usb_device *dev) {}
-static inline void usbfs_remove_device(struct usb_device *dev) {}
 static inline void usbfs_update_special (void) {}
-
 static inline int usbfs_init(void) { return 0; }
 static inline void usbfs_cleanup(void) { }
 
@@ -419,8 +430,6 @@ struct usb_mon_operations {
         void (*urb_submit_error)(struct usb_bus *bus, struct urb *urb, int err);
         void (*urb_complete)(struct usb_bus *bus, struct urb *urb);
         /* void (*urb_unlink)(struct usb_bus *bus, struct urb *urb); */
-        void (*bus_add)(struct usb_bus *bus);
-        void (*bus_remove)(struct usb_bus *bus);
 };
 
 extern struct usb_mon_operations *mon_ops;
@@ -443,18 +452,6 @@ static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb)
         if (bus->monitored)
                 (*mon_ops->urb_complete)(bus, urb);
 }
- 
-static inline void usbmon_notify_bus_add(struct usb_bus *bus)
-{
-        if (mon_ops)
-                (*mon_ops->bus_add)(bus);
-}
-
-static inline void usbmon_notify_bus_remove(struct usb_bus *bus)
-{
-        if (mon_ops)
-                (*mon_ops->bus_remove)(bus);
-}
 
 int usb_mon_register(struct usb_mon_operations *ops);
 void usb_mon_deregister(void);
@@ -465,8 +462,6 @@ static inline void usbmon_urb_submit(struct usb_bus *bus, struct urb *urb) {}
 static inline void usbmon_urb_submit_error(struct usb_bus *bus, struct urb *urb,
     int error) {}
 static inline void usbmon_urb_complete(struct usb_bus *bus, struct urb *urb) {}
-static inline void usbmon_notify_bus_add(struct usb_bus *bus) {}
-static inline void usbmon_notify_bus_remove(struct usb_bus *bus) {}
 
 #endif /* CONFIG_USB_MON */
 
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index c3e2024c4347..256d9f698715 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -436,9 +436,10 @@ static void hub_power_on(struct usb_hub *hub)
 {
         int port1;
         unsigned pgood_delay = hub->descriptor->bPwrOn2PwrGood * 2;
+        u16 wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
 
         /* if hub supports power switching, enable power on each port */
-        if ((hub->descriptor->wHubCharacteristics & HUB_CHAR_LPSM) < 2) {
+        if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2) {
                 dev_dbg(hub->intfdev, "enabling power on all ports\n");
                 for (port1 = 1; port1 <= hub->descriptor->bNbrPorts; port1++)
                         set_port_feature(hub->hdev, port1,
@@ -449,10 +450,18 @@ static void hub_power_on(struct usb_hub *hub)
         msleep(max(pgood_delay, (unsigned) 100));
 }
 
-static void hub_quiesce(struct usb_hub *hub)
+static inline void __hub_quiesce(struct usb_hub *hub)
 {
-        /* stop khubd and related activity */
+        /* (nonblocking) khubd and related activity won't re-trigger */
         hub->quiescing = 1;
+        hub->activating = 0;
+        hub->resume_root_hub = 0;
+}
+
+static void hub_quiesce(struct usb_hub *hub)
+{
+        /* (blocking) stop khubd and related activity */
+        __hub_quiesce(hub);
         usb_kill_urb(hub->urb);
         if (hub->has_indicators)
                 cancel_delayed_work(&hub->leds);
@@ -466,6 +475,7 @@ static void hub_activate(struct usb_hub *hub)
 
         hub->quiescing = 0;
         hub->activating = 1;
+        hub->resume_root_hub = 0;
         status = usb_submit_urb(hub->urb, GFP_NOIO);
         if (status < 0)
                 dev_err(hub->intfdev, "activate --> %d\n", status);
@@ -516,6 +526,7 @@ static int hub_configure(struct usb_hub *hub,
         struct usb_device *hdev = hub->hdev;
         struct device *hub_dev = hub->intfdev;
         u16 hubstatus, hubchange;
+        u16 wHubCharacteristics;
         unsigned int pipe;
         int maxp, ret;
         char *message;
@@ -561,9 +572,9 @@ static int hub_configure(struct usb_hub *hub,
         dev_info (hub_dev, "%d port%s detected\n", hdev->maxchild,
                 (hdev->maxchild == 1) ? "" : "s");
 
-        le16_to_cpus(&hub->descriptor->wHubCharacteristics);
+        wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
 
-        if (hub->descriptor->wHubCharacteristics & HUB_CHAR_COMPOUND) {
+        if (wHubCharacteristics & HUB_CHAR_COMPOUND) {
                 int     i;
                 char    portstr [USB_MAXCHILDREN + 1];
 
@@ -576,7 +587,7 @@ static int hub_configure(struct usb_hub *hub,
         } else
                 dev_dbg(hub_dev, "standalone hub\n");
 
-        switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_LPSM) {
+        switch (wHubCharacteristics & HUB_CHAR_LPSM) {
                 case 0x00:
                         dev_dbg(hub_dev, "ganged power switching\n");
                         break;
@@ -589,7 +600,7 @@ static int hub_configure(struct usb_hub *hub,
                         break;
         }
 
-        switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_OCPM) {
+        switch (wHubCharacteristics & HUB_CHAR_OCPM) {
                 case 0x00:
                         dev_dbg(hub_dev, "global over-current protection\n");
                         break;
@@ -629,7 +640,7 @@ static int hub_configure(struct usb_hub *hub,
         }
 
         /* Note 8 FS bit times == (8 bits / 12000000 bps) ~= 666ns */
-        switch (hub->descriptor->wHubCharacteristics & HUB_CHAR_TTTT) {
+        switch (wHubCharacteristics & HUB_CHAR_TTTT) {
                 case HUB_TTTT_8_BITS:
                         if (hdev->descriptor.bDeviceProtocol != 0) {
                                 hub->tt.think_time = 666;
@@ -659,7 +670,7 @@ static int hub_configure(struct usb_hub *hub,
         }
 
         /* probe() zeroes hub->indicator[] */
-        if (hub->descriptor->wHubCharacteristics & HUB_CHAR_PORTIND) {
+        if (wHubCharacteristics & HUB_CHAR_PORTIND) {
                 hub->has_indicators = 1;
                 dev_dbg(hub_dev, "Port indicators are supported\n");
         }
@@ -704,7 +715,7 @@ static int hub_configure(struct usb_hub *hub,
                         (hubstatus & HUB_STATUS_LOCAL_POWER)
                         ? "lost (inactive)" : "good");
 
-        if ((hub->descriptor->wHubCharacteristics & HUB_CHAR_OCPM) == 0)
+        if ((wHubCharacteristics & HUB_CHAR_OCPM) == 0)
                 dev_dbg(hub_dev, "%sover-current condition exists\n",
                         (hubstatus & HUB_STATUS_OVERCURRENT) ? "" : "no ");
 
@@ -854,14 +865,12 @@ descriptor_error:
         /* We found a hub */
         dev_info (&intf->dev, "USB hub found\n");
 
-        hub = kmalloc(sizeof(*hub), GFP_KERNEL);
+        hub = kzalloc(sizeof(*hub), GFP_KERNEL);
         if (!hub) {
                 dev_dbg (&intf->dev, "couldn't kmalloc hub struct\n");
                 return -ENOMEM;
         }
 
-        memset(hub, 0, sizeof(*hub));
-
         INIT_LIST_HEAD(&hub->event_list);
         hub->intfdev = &intf->dev;
         hub->hdev = hdev;
@@ -1117,14 +1126,14 @@ void usb_disconnect(struct usb_device **pdev)
          */
         usb_disable_device(udev, 0);
 
+        usb_notify_remove_device(udev);
+
         /* Free the device number, remove the /proc/bus/usb entry and
          * the sysfs attributes, and delete the parent's children[]
          * (or root_hub) pointer.
          */
         dev_dbg (&udev->dev, "unregistering device\n");
         release_address(udev);
-        usbfs_remove_device(udev);
-        usbdev_remove(udev);
         usb_remove_sysfs_dev_files(udev);
 
         /* Avoid races with recursively_mark_NOTATTACHED() */
@@ -1195,21 +1204,6 @@ static inline void show_string(struct usb_device *udev, char *id, char *string)
 {}
 #endif
 
-static void get_string(struct usb_device *udev, char **string, int index)
-{
-        char *buf;
-
-        if (!index)
-                return;
-        buf = kmalloc(256, GFP_KERNEL);
-        if (!buf)
-                return;
-        if (usb_string(udev, index, buf, 256) > 0)
-                *string = buf;
-        else
-                kfree(buf);
-}
-
 
 #ifdef  CONFIG_USB_OTG
 #include "otg_whitelist.h"
@@ -1248,9 +1242,10 @@ int usb_new_device(struct usb_device *udev)
         }
 
         /* read the standard strings and cache them if present */
-        get_string(udev, &udev->product, udev->descriptor.iProduct);
-        get_string(udev, &udev->manufacturer, udev->descriptor.iManufacturer);
-        get_string(udev, &udev->serial, udev->descriptor.iSerialNumber);
+        udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
+        udev->manufacturer = usb_cache_string(udev,
+                        udev->descriptor.iManufacturer);
+        udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
 
         /* Tell the world! */
         dev_dbg(&udev->dev, "new device strings: Mfr=%d, Product=%d, "
@@ -1322,11 +1317,9 @@ int usb_new_device(struct usb_device *udev)
                  * (Includes HNP test device.)
                  */
                 if (udev->bus->b_hnp_enable || udev->bus->is_b_host) {
-                        static int __usb_suspend_device (struct usb_device *,
-                                                int port1, pm_message_t state);
-                        err = __usb_suspend_device(udev,
-                                        udev->bus->otg_port,
-                                        PMSG_SUSPEND);
+                        static int __usb_suspend_device(struct usb_device *,
+                                                int port1);
+                        err = __usb_suspend_device(udev, udev->bus->otg_port);
                         if (err < 0)
                                 dev_dbg(&udev->dev, "HNP fail, %d\n", err);
                 }
@@ -1362,10 +1355,8 @@ int usb_new_device(struct usb_device *udev)
         }
 
         /* USB device state == configured ... usable */
+        usb_notify_add_device(udev);
 
-        /* add a /proc/bus/usb entry */
-        usbdev_add(udev);
-        usbfs_add_device(udev);
         return 0;
 
 fail:
@@ -1516,7 +1507,7 @@ static void hub_port_logical_disconnect(struct usb_hub *hub, int port1)
         /* FIXME let caller ask to power down the port:
          *  - some devices won't enumerate without a VBUS power cycle
          *  - SRP saves power that way
-         *  - usb_suspend_device(dev, PMSG_SUSPEND)
+         *  - ... new call, TBD ...
          * That's easy if this hub can switch power per-port, and
          * khubd reactivates the port later (timer, SRP, etc).
          * Powerdown must be optional, because of reset/DFU.
@@ -1598,11 +1589,14 @@ static int hub_port_suspend(struct usb_hub *hub, int port1,
  * Other than re-initializing the hub (plug/unplug, except for root hubs),
  * Linux (2.6) currently has NO mechanisms to initiate that:  no khubd
  * timer, no SRP, no requests through sysfs.
+ *
+ * If CONFIG_USB_SUSPEND isn't enabled, devices only really suspend when
+ * the root hub for their bus goes into global suspend ... so we don't
+ * (falsely) update the device power state to say it suspended.
  */
-static int __usb_suspend_device (struct usb_device *udev, int port1,
-                                 pm_message_t state)
+static int __usb_suspend_device (struct usb_device *udev, int port1)
 {
-        int     status;
+        int     status = 0;
 
         /* caller owns the udev device lock */
         if (port1 < 0)
@@ -1613,95 +1607,39 @@ static int __usb_suspend_device (struct usb_device *udev, int port1,
                 return 0;
         }
 
-        /* suspend interface drivers; if this is a hub, it
-         * suspends the child devices
-         */
+        /* all interfaces must already be suspended */
         if (udev->actconfig) {
                 int     i;
 
                 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
                         struct usb_interface    *intf;
-                        struct usb_driver       *driver;
 
                         intf = udev->actconfig->interface[i];
-                        if (state.event <= intf->dev.power.power_state.event)
-                                continue;
-                        if (!intf->dev.driver)
-                                continue;
-                        driver = to_usb_driver(intf->dev.driver);
-
-                        if (driver->suspend) {
-                                status = driver->suspend(intf, state);
-                                if (intf->dev.power.power_state.event != state.event
-                                                || status)
-                                        dev_err(&intf->dev,
-                                                "suspend %d fail, code %d\n",
-                                                state.event, status);
-                        }
-
-                        /* only drivers with suspend() can ever resume();
-                         * and after power loss, even they won't.
-                         * bus_rescan_devices() can rebind drivers later.
-                         *
-                         * FIXME the PM core self-deadlocks when unbinding
-                         * drivers during suspend/resume ... everything grabs
-                         * dpm_sem (not a spinlock, ugh).  we want to unbind,
-                         * since we know every driver's probe/disconnect works
-                         * even for drivers that can't suspend.
-                         */
-                        if (!driver->suspend || state.event > PM_EVENT_FREEZE) {
-#if 1
-                                dev_warn(&intf->dev, "resume is unsafe!\n");
-#else
-                                down_write(&usb_bus_type.rwsem);
-                                device_release_driver(&intf->dev);
-                                up_write(&usb_bus_type.rwsem);
-#endif
+                        if (is_active(intf)) {
+                                dev_dbg(&intf->dev, "nyet suspended\n");
+                                return -EBUSY;
                         }
                 }
         }
 
-        /*
-         * FIXME this needs port power off call paths too, to help force
-         * USB into the "generic" PM model.  At least for devices on
-         * ports that aren't using ganged switching (usually root hubs).
-         *
-         * NOTE: SRP-capable links should adopt more aggressive poweroff
-         * policies (when HNP doesn't apply) once we have mechanisms to
-         * turn power back on!  (Likely not before 2.7...)
+        /* we only change a device's upstream USB link.
+         * root hubs have no upstream USB link.
          */
-        if (state.event > PM_EVENT_FREEZE) {
-                dev_warn(&udev->dev, "no poweroff yet, suspending instead\n");
-        }
-
-        /* "global suspend" of the HC-to-USB interface (root hub), or
-         * "selective suspend" of just one hub-device link.
-         */
-        if (!udev->parent) {
-                struct usb_bus  *bus = udev->bus;
-                if (bus && bus->op->hub_suspend) {
-                        status = bus->op->hub_suspend (bus);
-                        if (status == 0) {
-                                dev_dbg(&udev->dev, "usb suspend\n");
-                                usb_set_device_state(udev,
-                                                USB_STATE_SUSPENDED);
-                        }
-                } else
-                        status = -EOPNOTSUPP;
-        } else
+        if (udev->parent)
                 status = hub_port_suspend(hdev_to_hub(udev->parent), port1,
                                 udev);
 
         if (status == 0)
-                udev->dev.power.power_state = state;
+                udev->dev.power.power_state = PMSG_SUSPEND;
         return status;
 }
 
-/**
+#endif
+
+/*
  * usb_suspend_device - suspend a usb device
  * @udev: device that's no longer in active use
- * @state: PMSG_SUSPEND to suspend
- * Context: must be able to sleep; device not locked
+ * Context: must be able to sleep; device not locked; pm locks held
  *
  * Suspends a USB device that isn't in active use, conserving power.
  * Devices may wake out of a suspend, if anything important happens,
@@ -1709,37 +1647,50 @@ static int __usb_suspend_device (struct usb_device *udev, int port1,
  * suspend by the host, using usb_resume_device().  It's also routine
  * to disconnect devices while they are suspended.
  *
+ * This only affects the USB hardware for a device; its interfaces
+ * (and, for hubs, child devices) must already have been suspended.
+ *
  * Suspending OTG devices may trigger HNP, if that's been enabled
  * between a pair of dual-role devices.  That will change roles, such
  * as from A-Host to A-Peripheral or from B-Host back to B-Peripheral.
  *
  * Returns 0 on success, else negative errno.
  */
-int usb_suspend_device(struct usb_device *udev, pm_message_t state)
+int usb_suspend_device(struct usb_device *udev)
 {
+#ifdef  CONFIG_USB_SUSPEND
         int     port1, status;
 
         port1 = locktree(udev);
         if (port1 < 0)
                 return port1;
 
-        status = __usb_suspend_device(udev, port1, state);
+        status = __usb_suspend_device(udev, port1);
         usb_unlock_device(udev);
         return status;
+#else
+        /* NOTE:  udev->state unchanged, it's not lying ... */
+        udev->dev.power.power_state = PMSG_SUSPEND;
+        return 0;
+#endif
 }
+EXPORT_SYMBOL_GPL(usb_suspend_device);
 
 /*
+ * If the USB "suspend" state is in use (rather than "global suspend"),
+ * many devices will be individually taken out of suspend state using
+ * special" resume" signaling.  These routines kick in shortly after
  * hardware resume signaling is finished, either because of selective
  * resume (by host) or remote wakeup (by device) ... now see what changed
  * in the tree that's rooted at this device.
  */
-static int finish_port_resume(struct usb_device *udev)
+static int finish_device_resume(struct usb_device *udev)
 {
         int     status;
         u16     devstatus;
 
         /* caller owns the udev device lock */
-        dev_dbg(&udev->dev, "usb resume\n");
+        dev_dbg(&udev->dev, "finish resume\n");
 
         /* usb ch9 identifies four variants of SUSPENDED, based on what
          * state the device resumes to.  Linux currently won't see the
@@ -1749,7 +1700,6 @@ static int finish_port_resume(struct usb_device *udev)
         usb_set_device_state(udev, udev->actconfig
                         ? USB_STATE_CONFIGURED
                         : USB_STATE_ADDRESS);
-        udev->dev.power.power_state = PMSG_ON;
 
         /* 10.5.4.5 says be sure devices in the tree are still there.
          * For now let's assume the device didn't go crazy on resume,
@@ -1762,9 +1712,11 @@ static int finish_port_resume(struct usb_device *udev)
                         status);
         else if (udev->actconfig) {
                 unsigned        i;
+                int             (*resume)(struct device *);
 
                 le16_to_cpus(&devstatus);
-                if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP)) {
+                if (devstatus & (1 << USB_DEVICE_REMOTE_WAKEUP)
+                                && udev->parent) {
                         status = usb_control_msg(udev,
                                         usb_sndctrlpipe(udev, 0),
                                         USB_REQ_CLEAR_FEATURE,
@@ -1780,33 +1732,11 @@ static int finish_port_resume(struct usb_device *udev)
                 }
 
                 /* resume interface drivers; if this is a hub, it
-                 * resumes the child devices
+                 * may have a child resume event to deal with soon
                  */
-                for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
-                        struct usb_interface    *intf;
-                        struct usb_driver       *driver;
-
-                        intf = udev->actconfig->interface[i];
-                        if (intf->dev.power.power_state.event == PM_EVENT_ON)
-                                continue;
-                        if (!intf->dev.driver) {
-                                /* FIXME maybe force to alt 0 */
-                                continue;
-                        }
-                        driver = to_usb_driver(intf->dev.driver);
-
-                        /* bus_rescan_devices() may rebind drivers */
-                        if (!driver->resume)
-                                continue;
-
-                        /* can we do better than just logging errors? */
-                        status = driver->resume(intf);
-                        if (intf->dev.power.power_state.event != PM_EVENT_ON
-                                        || status)
-                                dev_dbg(&intf->dev,
-                                        "resume fail, state %d code %d\n",
-                                        intf->dev.power.power_state.event, status);
-                }
+                resume = udev->dev.bus->resume;
+                for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++)
+                        (void) resume(&udev->actconfig->interface[i]->dev);
                 status = 0;
 
         } else if (udev->devnum <= 0) {
@@ -1816,6 +1746,8 @@ static int finish_port_resume(struct usb_device *udev)
         return status;
 }
 
+#ifdef  CONFIG_USB_SUSPEND
+
 static int
 hub_port_resume(struct usb_hub *hub, int port1, struct usb_device *udev)
 {
@@ -1861,7 +1793,7 @@ hub_port_resume(struct usb_hub *hub, int port1, struct usb_device *udev)
                         /* TRSMRCY = 10 msec */
                         msleep(10);
                         if (udev)
-                                status = finish_port_resume(udev);
+                                status = finish_device_resume(udev);
                 }
         }
         if (status < 0)
@@ -1870,12 +1802,12 @@ hub_port_resume(struct usb_hub *hub, int port1, struct usb_device *udev)
         return status;
 }
 
-static int hub_resume (struct usb_interface *intf);
+#endif
 
-/**
+/*
  * usb_resume_device - re-activate a suspended usb device
  * @udev: device to re-activate
- * Context: must be able to sleep; device not locked
+ * Context: must be able to sleep; device not locked; pm locks held
  *
  * This will re-activate the suspended device, increasing power usage
  * while letting drivers communicate again with its endpoints.
@@ -1893,35 +1825,22 @@ int usb_resume_device(struct usb_device *udev)
         if (port1 < 0)
                 return port1;
 
-        /* "global resume" of the HC-to-USB interface (root hub), or
-         * selective resume of one hub-to-device port
-         */
-        if (!udev->parent) {
-                struct usb_bus  *bus = udev->bus;
-                if (bus && bus->op->hub_resume) {
-                        status = bus->op->hub_resume (bus);
+#ifdef  CONFIG_USB_SUSPEND
+        /* selective resume of one downstream hub-to-device port */
+        if (udev->parent) {
+                if (udev->state == USB_STATE_SUSPENDED) {
+                        // NOTE swsusp may bork us, device state being wrong...
+                        // NOTE this fails if parent is also suspended...
+                        status = hub_port_resume(hdev_to_hub(udev->parent),
+                                        port1, udev);
                 } else
-                        status = -EOPNOTSUPP;
-                if (status == 0) {
-                        dev_dbg(&udev->dev, "usb resume\n");
-                        /* TRSMRCY = 10 msec */
-                        msleep(10);
-                        usb_set_device_state (udev, USB_STATE_CONFIGURED);
-                        udev->dev.power.power_state = PMSG_ON;
-                        status = hub_resume (udev
-                                        ->actconfig->interface[0]);
-                }
-        } else if (udev->state == USB_STATE_SUSPENDED) {
-                // NOTE this fails if parent is also suspended...
-                status = hub_port_resume(hdev_to_hub(udev->parent),
-                                port1, udev);
-        } else {
-                status = 0;
-        }
-        if (status < 0) {
+                        status = 0;
+        } else
+#endif
+                status = finish_device_resume(udev);
+        if (status < 0)
                 dev_dbg(&udev->dev, "can't resume, status %d\n",
                         status);
-        }
 
         usb_unlock_device(udev);
 
@@ -1938,6 +1857,8 @@ static int remote_wakeup(struct usb_device *udev)
 {
         int     status = 0;
 
+#ifdef  CONFIG_USB_SUSPEND
+
         /* don't repeat RESUME sequence if this device
          * was already woken up by some other task
          */
@@ -1946,38 +1867,52 @@ static int remote_wakeup(struct usb_device *udev)
                 dev_dbg(&udev->dev, "RESUME (wakeup)\n");
                 /* TRSMRCY = 10 msec */
                 msleep(10);
-                status = finish_port_resume(udev);
+                status = finish_device_resume(udev);
         }
         up(&udev->serialize);
+#endif
         return status;
 }
 
-static int hub_suspend(struct usb_interface *intf, pm_message_t state)
+static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
 {
         struct usb_hub          *hub = usb_get_intfdata (intf);
         struct usb_device       *hdev = hub->hdev;
         unsigned                port1;
-        int                     status;
-
-        /* stop khubd and related activity */
-        hub_quiesce(hub);
 
-        /* then suspend every port */
+        /* fail if children aren't already suspended */
         for (port1 = 1; port1 <= hdev->maxchild; port1++) {
                 struct usb_device       *udev;
 
                 udev = hdev->children [port1-1];
-                if (!udev)
-                        continue;
-                down(&udev->serialize);
-                status = __usb_suspend_device(udev, port1, state);
-                up(&udev->serialize);
-                if (status < 0)
-                        dev_dbg(&intf->dev, "suspend port %d --> %d\n",
-                                port1, status);
+                if (udev && (udev->dev.power.power_state.event
+                                        == PM_EVENT_ON
+#ifdef  CONFIG_USB_SUSPEND
+                                || udev->state != USB_STATE_SUSPENDED
+#endif
+                                )) {
+                        dev_dbg(&intf->dev, "port %d nyet suspended\n", port1);
+                        return -EBUSY;
+                }
         }
 
-        intf->dev.power.power_state = state;
+        /* "global suspend" of the downstream HC-to-USB interface */
+        if (!hdev->parent) {
+                struct usb_bus  *bus = hdev->bus;
+                if (bus) {
+                        int     status = hcd_bus_suspend (bus);
+
+                        if (status != 0) {
+                                dev_dbg(&hdev->dev, "'global' suspend %d\n",
+                                        status);
+                                return status;
+                        }
+                } else
+                        return -EOPNOTSUPP;
+        }
+
+        /* stop khubd and related activity */
+        hub_quiesce(hub);
         return 0;
 }
 
@@ -1985,11 +1920,35 @@ static int hub_resume(struct usb_interface *intf)
 {
         struct usb_device       *hdev = interface_to_usbdev(intf);
         struct usb_hub          *hub = usb_get_intfdata (intf);
-        unsigned                port1;
         int                     status;
 
-        if (intf->dev.power.power_state.event == PM_EVENT_ON)
-                return 0;
+        /* "global resume" of the downstream HC-to-USB interface */
+        if (!hdev->parent) {
+                struct usb_bus  *bus = hdev->bus;
+                if (bus) {
+                        status = hcd_bus_resume (bus);
+                        if (status) {
+                                dev_dbg(&intf->dev, "'global' resume %d\n",
+                                        status);
+                                return status;
+                        }
+                } else
+                        return -EOPNOTSUPP;
+                if (status == 0) {
+                        /* TRSMRCY = 10 msec */
+                        msleep(10);
+                }
+        }
+
+        hub_activate(hub);
+
+        /* REVISIT:  this recursion probably shouldn't exist.  Remove
+         * this code sometime, after retesting with different root and
+         * external hubs.
+         */
+#ifdef  CONFIG_USB_SUSPEND
+        {
+        unsigned                port1;
 
         for (port1 = 1; port1 <= hdev->maxchild; port1++) {
                 struct usb_device       *udev;
@@ -2015,7 +1974,7 @@ static int hub_resume(struct usb_interface *intf)
                 if (portstat & USB_PORT_STAT_SUSPEND)
                         status = hub_port_resume(hub, port1, udev);
                 else {
-                        status = finish_port_resume(udev);
+                        status = finish_device_resume(udev);
                         if (status < 0) {
                                 dev_dbg(&intf->dev, "resume port %d --> %d\n",
                                         port1, status);
@@ -2024,43 +1983,31 @@ static int hub_resume(struct usb_interface *intf)
                 }
                 up(&udev->serialize);
         }
-        intf->dev.power.power_state = PMSG_ON;
-
-        hub->resume_root_hub = 0;
-        hub_activate(hub);
+        }
+#endif
         return 0;
 }
 
-void usb_resume_root_hub(struct usb_device *hdev)
+void usb_suspend_root_hub(struct usb_device *hdev)
 {
         struct usb_hub *hub = hdev_to_hub(hdev);
 
-        hub->resume_root_hub = 1;
-        kick_khubd(hub);
+        /* This also makes any led blinker stop retriggering.  We're called
+         * from irq, so the blinker might still be scheduled.  Caller promises
+         * that the root hub status URB will be canceled.
+         */
+        __hub_quiesce(hub);
+        mark_quiesced(to_usb_interface(hub->intfdev));
 }
 
-#else   /* !CONFIG_USB_SUSPEND */
-
-int usb_suspend_device(struct usb_device *udev, pm_message_t state)
+void usb_resume_root_hub(struct usb_device *hdev)
 {
-        return 0;
-}
+        struct usb_hub *hub = hdev_to_hub(hdev);
 
-int usb_resume_device(struct usb_device *udev)
-{
-        return 0;
+        hub->resume_root_hub = 1;
+        kick_khubd(hub);
 }
 
-#define hub_suspend             NULL
-#define hub_resume              NULL
-#define remote_wakeup(x)        0
-
-#endif  /* CONFIG_USB_SUSPEND */
-
-EXPORT_SYMBOL(usb_suspend_device);
-EXPORT_SYMBOL(usb_resume_device);
-
-
 
 /* USB 2.0 spec, 7.1.7.3 / fig 7-29:
  *
@@ -2469,6 +2416,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
 {
         struct usb_device *hdev = hub->hdev;
         struct device *hub_dev = hub->intfdev;
+        u16 wHubCharacteristics = le16_to_cpu(hub->descriptor->wHubCharacteristics);
         int status, i;
  
         dev_dbg (hub_dev,
@@ -2506,8 +2454,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
         if (!(portstatus & USB_PORT_STAT_CONNECTION)) {
 
                 /* maybe switch power back on (e.g. root hub was reset) */
-                if ((hub->descriptor->wHubCharacteristics
-                                        & HUB_CHAR_LPSM) < 2
+                if ((wHubCharacteristics & HUB_CHAR_LPSM) < 2
                                 && !(portstatus & (1 << USB_PORT_FEAT_POWER)))
                         set_port_feature(hdev, port1, USB_PORT_FEAT_POWER);
  
@@ -2686,21 +2633,28 @@ static void hub_events(void)
                 intf = to_usb_interface(hub->intfdev);
                 hub_dev = &intf->dev;
 
-                dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x\n",
+                i = hub->resume_root_hub;
+
+                dev_dbg(hub_dev, "state %d ports %d chg %04x evt %04x%s\n",
                                 hdev->state, hub->descriptor
                                         ? hub->descriptor->bNbrPorts
                                         : 0,
                                 /* NOTE: expects max 15 ports... */
                                 (u16) hub->change_bits[0],
-                                (u16) hub->event_bits[0]);
+                                (u16) hub->event_bits[0],
+                                i ? ", resume root" : "");
 
                 usb_get_intf(intf);
-                i = hub->resume_root_hub;
                 spin_unlock_irq(&hub_event_lock);
 
-                /* Is this is a root hub wanting to be resumed? */
-                if (i)
-                        usb_resume_device(hdev);
+                /* Is this is a root hub wanting to reactivate the downstream
+                 * ports?  If so, be sure the interface resumes even if its
+                 * stub "device" node was never suspended.
+                 */
+                if (i) {
+                        dpm_runtime_resume(&hdev->dev);
+                        dpm_runtime_resume(&intf->dev);
+                }
 
                 /* Lock the device, then check to see if we were
                  * disconnected while waiting for the lock to succeed. */
diff --git a/drivers/usb/core/hub.h b/drivers/usb/core/hub.h
index e7fa9b5a521e..bf23f8978024 100644
--- a/drivers/usb/core/hub.h
+++ b/drivers/usb/core/hub.h
@@ -131,7 +131,7 @@ struct usb_hub_descriptor {
         __u8  bDescLength;
         __u8  bDescriptorType;
         __u8  bNbrPorts;
-        __u16 wHubCharacteristics;
+        __le16 wHubCharacteristics;
         __u8  bPwrOn2PwrGood;
         __u8  bHubContrCurrent;
                 /* add 1 bit for hub status change; round to bytes */
diff --git a/drivers/usb/core/inode.c b/drivers/usb/core/inode.c
index d07bba01995b..12f490fdee8f 100644
--- a/drivers/usb/core/inode.c
+++ b/drivers/usb/core/inode.c
@@ -39,6 +39,7 @@
 #include <linux/usbdevice_fs.h>
 #include <linux/smp_lock.h>
 #include <linux/parser.h>
+#include <linux/notifier.h>
 #include <asm/byteorder.h>
 #include "usb.h"
 #include "hcd.h"
@@ -619,7 +620,7 @@ void usbfs_update_special (void)
         }
 }
 
-void usbfs_add_bus(struct usb_bus *bus)
+static void usbfs_add_bus(struct usb_bus *bus)
 {
         struct dentry *parent;
         char name[8];
@@ -642,12 +643,9 @@ void usbfs_add_bus(struct usb_bus *bus)
                 err ("error creating usbfs bus entry");
                 return;
         }
-
-        usbfs_update_special();
-        usbfs_conn_disc_event();
 }
 
-void usbfs_remove_bus(struct usb_bus *bus)
+static void usbfs_remove_bus(struct usb_bus *bus)
 {
         if (bus->usbfs_dentry) {
                 fs_remove_file (bus->usbfs_dentry);
@@ -659,12 +657,9 @@ void usbfs_remove_bus(struct usb_bus *bus)
                 remove_special_files();
                 num_buses = 0;
         }
-
-        usbfs_update_special();
-        usbfs_conn_disc_event();
 }
 
-void usbfs_add_device(struct usb_device *dev)
+static void usbfs_add_device(struct usb_device *dev)
 {
         char name[8];
         int i;
@@ -690,12 +685,9 @@ void usbfs_add_device(struct usb_device *dev)
         }
         if (dev->usbfs_dentry->d_inode)
                 dev->usbfs_dentry->d_inode->i_size = i_size;
-
-        usbfs_update_special();
-        usbfs_conn_disc_event();
 }
 
-void usbfs_remove_device(struct usb_device *dev)
+static void usbfs_remove_device(struct usb_device *dev)
 {
         struct dev_state *ds;
         struct siginfo sinfo;
@@ -716,10 +708,33 @@ void usbfs_remove_device(struct usb_device *dev)
                         kill_proc_info_as_uid(ds->discsignr, &sinfo, ds->disc_pid, ds->disc_uid, ds->disc_euid);
                 }
         }
+}
+
+static int usbfs_notify(struct notifier_block *self, unsigned long action, void *dev)
+{
+        switch (action) {
+        case USB_DEVICE_ADD:
+                usbfs_add_device(dev);
+                break;
+        case USB_DEVICE_REMOVE:
+                usbfs_remove_device(dev);
+                break;
+        case USB_BUS_ADD:
+                usbfs_add_bus(dev);
+                break;
+        case USB_BUS_REMOVE:
+                usbfs_remove_bus(dev);
+        }
+
         usbfs_update_special();
         usbfs_conn_disc_event();
+        return NOTIFY_OK;
 }
 
+static struct notifier_block usbfs_nb = {
+        .notifier_call =        usbfs_notify,
+};
+
 /* --------------------------------------------------------------------- */
 
 static struct proc_dir_entry *usbdir = NULL;
@@ -732,6 +747,8 @@ int __init usbfs_init(void)
         if (retval)
                 return retval;
 
+        usb_register_notify(&usbfs_nb);
+
         /* create mount point for usbfs */
         usbdir = proc_mkdir("usb", proc_bus);
 
@@ -740,6 +757,7 @@ int __init usbfs_init(void)
 
 void usbfs_cleanup(void)
 {
+        usb_unregister_notify(&usbfs_nb);
         unregister_filesystem(&usb_fs_type);
         if (usbdir)
                 remove_proc_entry("usb", proc_bus);
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index f9a81e84dbdf..644a3d4f12aa 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -187,21 +187,37 @@ int usb_control_msg(struct usb_device *dev, unsigned int pipe, __u8 request, __u
  *      If a thread in your driver uses this call, make sure your disconnect()
  *      method can wait for it to complete.  Since you don't have a handle on
  *      the URB used, you can't cancel the request.
+ *
+ *      Because there is no usb_interrupt_msg() and no USBDEVFS_INTERRUPT
+ *      ioctl, users are forced to abuse this routine by using it to submit
+ *      URBs for interrupt endpoints.  We will take the liberty of creating
+ *      an interrupt URB (with the default interval) if the target is an
+ *      interrupt endpoint.
  */
 int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe, 
                         void *data, int len, int *actual_length, int timeout)
 {
         struct urb *urb;
+        struct usb_host_endpoint *ep;
 
-        if (len < 0)
+        ep = (usb_pipein(pipe) ? usb_dev->ep_in : usb_dev->ep_out)
+                        [usb_pipeendpoint(pipe)];
+        if (!ep || len < 0)
                 return -EINVAL;
 
-        urb=usb_alloc_urb(0, GFP_KERNEL);
+        urb = usb_alloc_urb(0, GFP_KERNEL);
         if (!urb)
                 return -ENOMEM;
 
-        usb_fill_bulk_urb(urb, usb_dev, pipe, data, len,
-                          usb_api_blocking_completion, NULL);
+        if ((ep->desc.bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
+                        USB_ENDPOINT_XFER_INT) {
+                pipe = (pipe & ~(3 << 30)) | (PIPE_INTERRUPT << 30);
+                usb_fill_int_urb(urb, usb_dev, pipe, data, len,
+                                usb_api_blocking_completion, NULL,
+                                ep->desc.bInterval);
+        } else
+                usb_fill_bulk_urb(urb, usb_dev, pipe, data, len,
+                                usb_api_blocking_completion, NULL);
 
         return usb_start_wait_urb(urb, timeout, actual_length);
 }
@@ -771,6 +787,31 @@ int usb_string(struct usb_device *dev, int index, char *buf, size_t size)
         return err;
 }
 
+/**
+ * usb_cache_string - read a string descriptor and cache it for later use
+ * @udev: the device whose string descriptor is being read
+ * @index: the descriptor index
+ *
+ * Returns a pointer to a kmalloc'ed buffer containing the descriptor string,
+ * or NULL if the index is 0 or the string could not be read.
+ */
+char *usb_cache_string(struct usb_device *udev, int index)
+{
+        char *buf;
+        char *smallbuf = NULL;
+        int len;
+
+        if (index > 0 && (buf = kmalloc(256, GFP_KERNEL)) != NULL) {
+                if ((len = usb_string(udev, index, buf, 256)) > 0) {
+                        if ((smallbuf = kmalloc(++len, GFP_KERNEL)) == NULL)
+                                return buf;
+                        memcpy(smallbuf, buf, len);
+                }
+                kfree(buf);
+        }
+        return smallbuf;
+}
+
 /*
  * usb_get_device_descriptor - (re)reads the device descriptor (usbcore)
  * @dev: the device whose device descriptor is being updated
@@ -992,8 +1033,6 @@ void usb_disable_device(struct usb_device *dev, int skip_ep0)
                         dev_dbg (&dev->dev, "unregistering interface %s\n",
                                 interface->dev.bus_id);
                         usb_remove_sysfs_intf_files(interface);
-                        kfree(interface->cur_altsetting->string);
-                        interface->cur_altsetting->string = NULL;
                         device_del (&interface->dev);
                 }
 
@@ -1133,6 +1172,8 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
          */
 
         /* prevent submissions using previous endpoint settings */
+        if (device_is_registered(&iface->dev))
+                usb_remove_sysfs_intf_files(iface);
         usb_disable_interface(dev, iface);
 
         iface->cur_altsetting = alt;
@@ -1168,6 +1209,8 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate)
          * (Likewise, EP0 never "halts" on well designed devices.)
          */
         usb_enable_interface(dev, iface);
+        if (device_is_registered(&iface->dev))
+                usb_create_sysfs_intf_files(iface);
 
         return 0;
 }
@@ -1217,10 +1260,8 @@ int usb_reset_configuration(struct usb_device *dev)
                         USB_REQ_SET_CONFIGURATION, 0,
                         config->desc.bConfigurationValue, 0,
                         NULL, 0, USB_CTRL_SET_TIMEOUT);
-        if (retval < 0) {
-                usb_set_device_state(dev, USB_STATE_ADDRESS);
+        if (retval < 0)
                 return retval;
-        }
 
         dev->toggle[0] = dev->toggle[1] = 0;
 
@@ -1229,6 +1270,8 @@ int usb_reset_configuration(struct usb_device *dev)
                 struct usb_interface *intf = config->interface[i];
                 struct usb_host_interface *alt;
 
+                if (device_is_registered(&intf->dev))
+                        usb_remove_sysfs_intf_files(intf);
                 alt = usb_altnum_to_altsetting(intf, 0);
 
                 /* No altsetting 0?  We'll assume the first altsetting.
@@ -1241,6 +1284,8 @@ int usb_reset_configuration(struct usb_device *dev)
 
                 intf->cur_altsetting = alt;
                 usb_enable_interface(dev, intf);
+                if (device_is_registered(&intf->dev))
+                        usb_create_sysfs_intf_files(intf);
         }
         return 0;
 }
@@ -1328,7 +1373,7 @@ int usb_set_configuration(struct usb_device *dev, int configuration)
                 }
 
                 for (; n < nintf; ++n) {
-                        new_interfaces[n] = kmalloc(
+                        new_interfaces[n] = kzalloc(
                                         sizeof(struct usb_interface),
                                         GFP_KERNEL);
                         if (!new_interfaces[n]) {
@@ -1369,7 +1414,6 @@ free_interfaces:
                         struct usb_host_interface *alt;
 
                         cp->interface[i] = intf = new_interfaces[i];
-                        memset(intf, 0, sizeof(*intf));
                         intfc = cp->intf_cache[i];
                         intf->altsetting = intfc->altsetting;
                         intf->num_altsetting = intfc->num_altsetting;
@@ -1393,6 +1437,7 @@ free_interfaces:
                         intf->dev.dma_mask = dev->dev.dma_mask;
                         intf->dev.release = release_interface;
                         device_initialize (&intf->dev);
+                        mark_quiesced(intf);
                         sprintf (&intf->dev.bus_id[0], "%d-%s:%d.%d",
                                  dev->bus->busnum, dev->devpath,
                                  configuration,
@@ -1400,12 +1445,9 @@ free_interfaces:
                 }
                 kfree(new_interfaces);
 
-                if ((cp->desc.iConfiguration) &&
-                    (cp->string == NULL)) {
-                        cp->string = kmalloc(256, GFP_KERNEL);
-                        if (cp->string)
-                                usb_string(dev, cp->desc.iConfiguration, cp->string, 256);
-                }
+                if (cp->string == NULL)
+                        cp->string = usb_cache_string(dev,
+                                        cp->desc.iConfiguration);
 
                 /* Now that all the interfaces are set up, register them
                  * to trigger binding of drivers to interfaces.  probe()
@@ -1415,13 +1457,12 @@ free_interfaces:
                  */
                 for (i = 0; i < nintf; ++i) {
                         struct usb_interface *intf = cp->interface[i];
-                        struct usb_interface_descriptor *desc;
+                        struct usb_host_interface *alt = intf->cur_altsetting;
 
-                        desc = &intf->altsetting [0].desc;
                         dev_dbg (&dev->dev,
                                 "adding %s (config #%d, interface %d)\n",
                                 intf->dev.bus_id, configuration,
-                                desc->bInterfaceNumber);
+                                alt->desc.bInterfaceNumber);
                         ret = device_add (&intf->dev);
                         if (ret != 0) {
                                 dev_err(&dev->dev,
@@ -1430,13 +1471,6 @@ free_interfaces:
                                         ret);
                                 continue;
                         }
-                        if ((intf->cur_altsetting->desc.iInterface) &&
-                            (intf->cur_altsetting->string == NULL)) {
-                                intf->cur_altsetting->string = kmalloc(256, GFP_KERNEL);
-                                if (intf->cur_altsetting->string)
-                                        usb_string(dev, intf->cur_altsetting->desc.iInterface,
-                                                   intf->cur_altsetting->string, 256);
-                        }
                         usb_create_sysfs_intf_files (intf);
                 }
         }
diff --git a/drivers/usb/core/notify.c b/drivers/usb/core/notify.c
new file mode 100644
index 000000000000..37da059eced7
--- /dev/null
+++ b/drivers/usb/core/notify.c
@@ -0,0 +1,120 @@
+/*
+ * All the USB notify logic
+ *
+ * (C) Copyright 2005 Greg Kroah-Hartman <gregkh@suse.de>
+ *
+ * notifier functions originally based on those in kernel/sys.c
+ * but fixed up to not be so broken.
+ *
+ */
+
+
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/notifier.h>
+#ifdef CONFIG_USB_DEBUG
+        #define DEBUG
+#else
+        #undef DEBUG
+#endif
+#include <linux/usb.h>
+
+#include "usb.h"
+
+
+static struct notifier_block *usb_notifier_list;
+static DECLARE_MUTEX(usb_notifier_lock);
+
+static void usb_notifier_chain_register(struct notifier_block **list,
+                                        struct notifier_block *n)
+{
+        down(&usb_notifier_lock);
+        while (*list) {
+                if (n->priority > (*list)->priority)
+                        break;
+                list = &((*list)->next);
+        }
+        n->next = *list;
+        *list = n;
+        up(&usb_notifier_lock);
+}
+
+static void usb_notifier_chain_unregister(struct notifier_block **nl,
+                                   struct notifier_block *n)
+{
+        down(&usb_notifier_lock);
+        while ((*nl)!=NULL) {
+                if ((*nl)==n) {
+                        *nl = n->next;
+                        goto exit;
+                }
+                nl=&((*nl)->next);
+        }
+exit:
+        up(&usb_notifier_lock);
+}
+
+static int usb_notifier_call_chain(struct notifier_block **n,
+                                   unsigned long val, void *v)
+{
+        int ret=NOTIFY_DONE;
+        struct notifier_block *nb = *n;
+
+        down(&usb_notifier_lock);
+        while (nb) {
+                ret = nb->notifier_call(nb,val,v);
+                if (ret&NOTIFY_STOP_MASK) {
+                        goto exit;
+                }
+                nb = nb->next;
+        }
+exit:
+        up(&usb_notifier_lock);
+        return ret;
+}
+
+/**
+ * usb_register_notify - register a notifier callback whenever a usb change happens
+ * @nb: pointer to the notifier block for the callback events.
+ *
+ * These changes are either USB devices or busses being added or removed.
+ */
+void usb_register_notify(struct notifier_block *nb)
+{
+        usb_notifier_chain_register(&usb_notifier_list, nb);
+}
+EXPORT_SYMBOL_GPL(usb_register_notify);
+
+/**
+ * usb_unregister_notify - unregister a notifier callback
+ * @nb: pointer to the notifier block for the callback events.
+ *
+ * usb_register_notifier() must have been previously called for this function
+ * to work properly.
+ */
+void usb_unregister_notify(struct notifier_block *nb)
+{
+        usb_notifier_chain_unregister(&usb_notifier_list, nb);
+}
+EXPORT_SYMBOL_GPL(usb_unregister_notify);
+
+
+void usb_notify_add_device(struct usb_device *udev)
+{
+        usb_notifier_call_chain(&usb_notifier_list, USB_DEVICE_ADD, udev);
+}
+
+void usb_notify_remove_device(struct usb_device *udev)
+{
+        usb_notifier_call_chain(&usb_notifier_list, USB_DEVICE_REMOVE, udev);
+}
+
+void usb_notify_add_bus(struct usb_bus *ubus)
+{
+        usb_notifier_call_chain(&usb_notifier_list, USB_BUS_ADD, ubus);
+}
+
+void usb_notify_remove_bus(struct usb_bus *ubus)
+{
+        usb_notifier_call_chain(&usb_notifier_list, USB_BUS_REMOVE, ubus);
+}
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 00297f113849..edd83e014452 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -22,9 +22,207 @@
 
 #include "usb.h"
 
+/* endpoint stuff */
+struct ep_object {
+        struct usb_endpoint_descriptor *desc;
+        struct usb_device *udev;
+        struct kobject kobj;
+};
+#define to_ep_object(_kobj) \
+        container_of(_kobj, struct ep_object, kobj)
+
+struct ep_attribute {
+        struct attribute attr;
+        ssize_t (*show)(struct usb_device *,
+                        struct usb_endpoint_descriptor *, char *);
+};
+#define to_ep_attribute(_attr) \
+        container_of(_attr, struct ep_attribute, attr)
+
+#define EP_ATTR(_name)                                          \
+struct ep_attribute ep_##_name = {                              \
+        .attr = {.name = #_name, .owner = THIS_MODULE,          \
+                        .mode = S_IRUGO},                       \
+        .show = show_ep_##_name}
+
+#define usb_ep_attr(field, format_string)                       \
+static ssize_t show_ep_##field(struct usb_device *udev,         \
+                struct usb_endpoint_descriptor *desc,           \
+                char *buf)                                      \
+{                                                               \
+        return sprintf(buf, format_string, desc->field);        \
+}                                                               \
+static EP_ATTR(field);
+
+usb_ep_attr(bLength, "%02x\n")
+usb_ep_attr(bEndpointAddress, "%02x\n")
+usb_ep_attr(bmAttributes, "%02x\n")
+usb_ep_attr(bInterval, "%02x\n")
+
+static ssize_t show_ep_wMaxPacketSize(struct usb_device *udev,
+                struct usb_endpoint_descriptor *desc, char *buf)
+{
+        return sprintf(buf, "%04x\n",
+                        le16_to_cpu(desc->wMaxPacketSize) & 0x07ff);
+}
+static EP_ATTR(wMaxPacketSize);
+
+static ssize_t show_ep_type(struct usb_device *udev,
+                struct usb_endpoint_descriptor *desc, char *buf)
+{
+        char *type = "unknown";
+
+        switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+        case USB_ENDPOINT_XFER_CONTROL:
+                type = "Control";
+                break;
+        case USB_ENDPOINT_XFER_ISOC:
+                type = "Isoc";
+                break;
+        case USB_ENDPOINT_XFER_BULK:
+                type = "Bulk";
+                break;
+        case USB_ENDPOINT_XFER_INT:
+                type = "Interrupt";
+                break;
+        }
+        return sprintf(buf, "%s\n", type);
+}
+static EP_ATTR(type);
+
+static ssize_t show_ep_interval(struct usb_device *udev,
+                struct usb_endpoint_descriptor *desc, char *buf)
+{
+        char unit;
+        unsigned interval = 0;
+        unsigned in;
+
+        in = (desc->bEndpointAddress & USB_DIR_IN);
+
+        switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+        case USB_ENDPOINT_XFER_CONTROL:
+                if (udev->speed == USB_SPEED_HIGH)      /* uframes per NAK */
+                        interval = desc->bInterval;
+                break;
+        case USB_ENDPOINT_XFER_ISOC:
+                interval = 1 << (desc->bInterval - 1);
+                break;
+        case USB_ENDPOINT_XFER_BULK:
+                if (udev->speed == USB_SPEED_HIGH && !in) /* uframes per NAK */
+                        interval = desc->bInterval;
+                break;
+        case USB_ENDPOINT_XFER_INT:
+                if (udev->speed == USB_SPEED_HIGH)
+                        interval = 1 << (desc->bInterval - 1);
+                else
+                        interval = desc->bInterval;
+                break;
+        }
+        interval *= (udev->speed == USB_SPEED_HIGH) ? 125 : 1000;
+        if (interval % 1000)
+                unit = 'u';
+        else {
+                unit = 'm';
+                interval /= 1000;
+        }
+
+        return sprintf(buf, "%d%cs\n", interval, unit);
+}
+static EP_ATTR(interval);
+
+static ssize_t show_ep_direction(struct usb_device *udev,
+                struct usb_endpoint_descriptor *desc, char *buf)
+{
+        char *direction;
+
+        if ((desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
+                        USB_ENDPOINT_XFER_CONTROL)
+                direction = "both";
+        else if (desc->bEndpointAddress & USB_DIR_IN)
+                direction = "in";
+        else
+                direction = "out";
+        return sprintf(buf, "%s\n", direction);
+}
+static EP_ATTR(direction);
+
+static struct attribute *ep_attrs[] = {
+        &ep_bLength.attr,
+        &ep_bEndpointAddress.attr,
+        &ep_bmAttributes.attr,
+        &ep_bInterval.attr,
+        &ep_wMaxPacketSize.attr,
+        &ep_type.attr,
+        &ep_interval.attr,
+        &ep_direction.attr,
+        NULL,
+};
+
+static void ep_object_release(struct kobject *kobj)
+{
+        kfree(to_ep_object(kobj));
+}
+
+static ssize_t ep_object_show(struct kobject *kobj, struct attribute *attr,
+                char *buf)
+{
+        struct ep_object *ep_obj = to_ep_object(kobj);
+        struct ep_attribute *ep_attr = to_ep_attribute(attr);
+
+        return (ep_attr->show)(ep_obj->udev, ep_obj->desc, buf);
+}
+
+static struct sysfs_ops ep_object_sysfs_ops = {
+        .show =                 ep_object_show,
+};
+
+static struct kobj_type ep_object_ktype = {
+        .release =              ep_object_release,
+        .sysfs_ops =            &ep_object_sysfs_ops,
+        .default_attrs =        ep_attrs,
+};
+
+static void usb_create_ep_files(struct kobject *parent,
+                struct usb_host_endpoint *endpoint,
+                struct usb_device *udev)
+{
+        struct ep_object *ep_obj;
+        struct kobject *kobj;
+
+        ep_obj = kzalloc(sizeof(struct ep_object), GFP_KERNEL);
+        if (!ep_obj)
+                return;
+
+        ep_obj->desc = &endpoint->desc;
+        ep_obj->udev = udev;
+
+        kobj = &ep_obj->kobj;
+        kobject_set_name(kobj, "ep_%02x", endpoint->desc.bEndpointAddress);
+        kobj->parent = parent;
+        kobj->ktype = &ep_object_ktype;
+
+        /* Don't use kobject_register, because it generates a hotplug event */
+        kobject_init(kobj);
+        if (kobject_add(kobj) == 0)
+                endpoint->kobj = kobj;
+        else
+                kobject_put(kobj);
+}
+
+static void usb_remove_ep_files(struct usb_host_endpoint *endpoint)
+{
+
+        if (endpoint->kobj) {
+                kobject_del(endpoint->kobj);
+                kobject_put(endpoint->kobj);
+                endpoint->kobj = NULL;
+        }
+}
+
 /* Active configuration fields */
 #define usb_actconfig_show(field, multiplier, format_string)            \
-static ssize_t  show_##field (struct device *dev, struct device_attribute *attr, char *buf)             \
+static ssize_t  show_##field (struct device *dev,                       \
+                struct device_attribute *attr, char *buf)               \
 {                                                                       \
         struct usb_device *udev;                                        \
         struct usb_host_config *actconfig;                              \
@@ -46,22 +244,17 @@ usb_actconfig_attr (bNumInterfaces, 1, "%2d\n")
 usb_actconfig_attr (bmAttributes, 1, "%2x\n")
 usb_actconfig_attr (bMaxPower, 2, "%3dmA\n")
 
-static ssize_t show_configuration_string(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t show_configuration_string(struct device *dev,
+                struct device_attribute *attr, char *buf)
 {
         struct usb_device *udev;
         struct usb_host_config *actconfig;
-        int len;
 
         udev = to_usb_device (dev);
         actconfig = udev->actconfig;
         if ((!actconfig) || (!actconfig->string))
                 return 0;
-        len = sprintf(buf, actconfig->string, PAGE_SIZE);
-        if (len < 0)
-                return 0;
-        buf[len] = '\n';
-        buf[len+1] = 0;
-        return len+1;
+        return sprintf(buf, "%s\n", actconfig->string);
 }
 static DEVICE_ATTR(configuration, S_IRUGO, show_configuration_string, NULL);
 
@@ -69,7 +262,8 @@ static DEVICE_ATTR(configuration, S_IRUGO, show_configuration_string, NULL);
 usb_actconfig_show(bConfigurationValue, 1, "%u\n");
 
 static ssize_t
-set_bConfigurationValue (struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
+set_bConfigurationValue (struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
 {
         struct usb_device       *udev = udev = to_usb_device (dev);
         int                     config, value;
@@ -87,18 +281,13 @@ static DEVICE_ATTR(bConfigurationValue, S_IRUGO | S_IWUSR,
 
 /* String fields */
 #define usb_string_attr(name)                                           \
-static ssize_t  show_##name(struct device *dev, struct device_attribute *attr, char *buf)               \
+static ssize_t  show_##name(struct device *dev,                         \
+                struct device_attribute *attr, char *buf)               \
 {                                                                       \
         struct usb_device *udev;                                        \
-        int len;                                                        \
                                                                         \
         udev = to_usb_device (dev);                                     \
-        len = snprintf(buf, 256, "%s", udev->name);                     \
-        if (len < 0)                                                    \
-                return 0;                                               \
-        buf[len] = '\n';                                                \
-        buf[len+1] = 0;                                                 \
-        return len+1;                                                   \
+        return sprintf(buf, "%s\n", udev->name);                        \
 }                                                                       \
 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
 
@@ -167,7 +356,8 @@ static DEVICE_ATTR(maxchild, S_IRUGO, show_maxchild, NULL);
 /* Descriptor fields */
 #define usb_descriptor_attr_le16(field, format_string)                  \
 static ssize_t                                                          \
-show_##field (struct device *dev, struct device_attribute *attr, char *buf)                             \
+show_##field (struct device *dev, struct device_attribute *attr,        \
+                char *buf)                                              \
 {                                                                       \
         struct usb_device *udev;                                        \
                                                                         \
@@ -183,7 +373,8 @@ usb_descriptor_attr_le16(bcdDevice, "%04x\n")
 
 #define usb_descriptor_attr(field, format_string)                       \
 static ssize_t                                                          \
-show_##field (struct device *dev, struct device_attribute *attr, char *buf)                             \
+show_##field (struct device *dev, struct device_attribute *attr,        \
+                char *buf)                                              \
 {                                                                       \
         struct usb_device *udev;                                        \
                                                                         \
@@ -236,19 +427,21 @@ void usb_create_sysfs_dev_files (struct usb_device *udev)
         if (udev->serial)
                 device_create_file (dev, &dev_attr_serial);
         device_create_file (dev, &dev_attr_configuration);
+        usb_create_ep_files(&dev->kobj, &udev->ep0, udev);
 }
 
 void usb_remove_sysfs_dev_files (struct usb_device *udev)
 {
         struct device *dev = &udev->dev;
 
+        usb_remove_ep_files(&udev->ep0);
         sysfs_remove_group(&dev->kobj, &dev_attr_grp);
 
-        if (udev->descriptor.iManufacturer)
+        if (udev->manufacturer)
                 device_remove_file(dev, &dev_attr_manufacturer);
-        if (udev->descriptor.iProduct)
+        if (udev->product)
                 device_remove_file(dev, &dev_attr_product);
-        if (udev->descriptor.iSerialNumber)
+        if (udev->serial)
                 device_remove_file(dev, &dev_attr_serial);
         device_remove_file (dev, &dev_attr_configuration);
 }
@@ -256,11 +449,13 @@ void usb_remove_sysfs_dev_files (struct usb_device *udev)
 /* Interface fields */
 #define usb_intf_attr(field, format_string)                             \
 static ssize_t                                                          \
-show_##field (struct device *dev, struct device_attribute *attr, char *buf)                             \
+show_##field (struct device *dev, struct device_attribute *attr,        \
+                char *buf)                                              \
 {                                                                       \
         struct usb_interface *intf = to_usb_interface (dev);            \
                                                                         \
-        return sprintf (buf, format_string, intf->cur_altsetting->desc.field); \
+        return sprintf (buf, format_string,                             \
+                        intf->cur_altsetting->desc.field);              \
 }                                                                       \
 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
 
@@ -271,7 +466,8 @@ usb_intf_attr (bInterfaceClass, "%02x\n")
 usb_intf_attr (bInterfaceSubClass, "%02x\n")
 usb_intf_attr (bInterfaceProtocol, "%02x\n")
 
-static ssize_t show_interface_string(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t show_interface_string(struct device *dev,
+                struct device_attribute *attr, char *buf)
 {
         struct usb_interface *intf;
         struct usb_device *udev;
@@ -288,34 +484,28 @@ static ssize_t show_interface_string(struct device *dev, struct device_attribute
 }
 static DEVICE_ATTR(interface, S_IRUGO, show_interface_string, NULL);
 
-static ssize_t show_modalias(struct device *dev, struct device_attribute *attr, char *buf)
+static ssize_t show_modalias(struct device *dev,
+                struct device_attribute *attr, char *buf)
 {
         struct usb_interface *intf;
         struct usb_device *udev;
-        int len;
+        struct usb_host_interface *alt;
 
         intf = to_usb_interface(dev);
         udev = interface_to_usbdev(intf);
-
-        len = sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic",
-                               le16_to_cpu(udev->descriptor.idVendor),
-                               le16_to_cpu(udev->descriptor.idProduct),
-                               le16_to_cpu(udev->descriptor.bcdDevice),
-                               udev->descriptor.bDeviceClass,
-                               udev->descriptor.bDeviceSubClass,
-                               udev->descriptor.bDeviceProtocol);
-        buf += len;
-
-        if (udev->descriptor.bDeviceClass == 0) {
-                struct usb_host_interface *alt = intf->cur_altsetting;
-
-                return len + sprintf(buf, "%02Xisc%02Xip%02X\n",
-                               alt->desc.bInterfaceClass,
-                               alt->desc.bInterfaceSubClass,
-                               alt->desc.bInterfaceProtocol);
-        } else {
-                return len + sprintf(buf, "*isc*ip*\n");
-        }
+        alt = intf->cur_altsetting;
+
+        return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
+                        "ic%02Xisc%02Xip%02X\n",
+                        le16_to_cpu(udev->descriptor.idVendor),
+                        le16_to_cpu(udev->descriptor.idProduct),
+                        le16_to_cpu(udev->descriptor.bcdDevice),
+                        udev->descriptor.bDeviceClass,
+                        udev->descriptor.bDeviceSubClass,
+                        udev->descriptor.bDeviceProtocol,
+                        alt->desc.bInterfaceClass,
+                        alt->desc.bInterfaceSubClass,
+                        alt->desc.bInterfaceProtocol);
 }
 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
 
@@ -333,20 +523,47 @@ static struct attribute_group intf_attr_grp = {
         .attrs = intf_attrs,
 };
 
+static inline void usb_create_intf_ep_files(struct usb_interface *intf,
+                struct usb_device *udev)
+{
+        struct usb_host_interface *iface_desc;
+        int i;
+
+        iface_desc = intf->cur_altsetting;
+        for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i)
+                usb_create_ep_files(&intf->dev.kobj, &iface_desc->endpoint[i],
+                                udev);
+}
+
+static inline void usb_remove_intf_ep_files(struct usb_interface *intf)
+{
+        struct usb_host_interface *iface_desc;
+        int i;
+
+        iface_desc = intf->cur_altsetting;
+        for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i)
+                usb_remove_ep_files(&iface_desc->endpoint[i]);
+}
+
 void usb_create_sysfs_intf_files (struct usb_interface *intf)
 {
+        struct usb_device *udev = interface_to_usbdev(intf);
+        struct usb_host_interface *alt = intf->cur_altsetting;
+
         sysfs_create_group(&intf->dev.kobj, &intf_attr_grp);
 
-        if (intf->cur_altsetting->string)
+        if (alt->string == NULL)
+                alt->string = usb_cache_string(udev, alt->desc.iInterface);
+        if (alt->string)
                 device_create_file(&intf->dev, &dev_attr_interface);
-                
+        usb_create_intf_ep_files(intf, udev);
 }
 
 void usb_remove_sysfs_intf_files (struct usb_interface *intf)
 {
+        usb_remove_intf_ep_files(intf);
         sysfs_remove_group(&intf->dev.kobj, &intf_attr_grp);
 
         if (intf->cur_altsetting->string)
                 device_remove_file(&intf->dev, &dev_attr_interface);
-
 }
diff --git a/drivers/usb/core/urb.c b/drivers/usb/core/urb.c
index b32898e0a27d..f2a1fed2a802 100644
--- a/drivers/usb/core/urb.c
+++ b/drivers/usb/core/urb.c
@@ -237,7 +237,8 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
             (dev->state < USB_STATE_DEFAULT) ||
             (!dev->bus) || (dev->devnum <= 0))
                 return -ENODEV;
-        if (dev->state == USB_STATE_SUSPENDED)
+        if (dev->bus->controller->power.power_state.event != PM_EVENT_ON
+                        || dev->state == USB_STATE_SUSPENDED)
                 return -EHOSTUNREACH;
         if (!(op = dev->bus->op) || !op->submit_urb)
                 return -ENODEV;
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index 4c57f3f649ed..0eefff7bcb3c 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -107,10 +107,19 @@ static int usb_probe_interface(struct device *dev)
         id = usb_match_id (intf, driver->id_table);
         if (id) {
                 dev_dbg (dev, "%s - got id\n", __FUNCTION__);
+
+                /* Interface "power state" doesn't correspond to any hardware
+                 * state whatsoever.  We use it to record when it's bound to
+                 * a driver that may start I/0:  it's not frozen/quiesced.
+                 */
+                mark_active(intf);
                 intf->condition = USB_INTERFACE_BINDING;
                 error = driver->probe (intf, id);
-                intf->condition = error ? USB_INTERFACE_UNBOUND :
-                                USB_INTERFACE_BOUND;
+                if (error) {
+                        mark_quiesced(intf);
+                        intf->condition = USB_INTERFACE_UNBOUND;
+                } else
+                        intf->condition = USB_INTERFACE_BOUND;
         }
 
         return error;
@@ -136,6 +145,7 @@ static int usb_unbind_interface(struct device *dev)
                         0);
         usb_set_intfdata(intf, NULL);
         intf->condition = USB_INTERFACE_UNBOUND;
+        mark_quiesced(intf);
 
         return 0;
 }
@@ -299,6 +309,7 @@ int usb_driver_claim_interface(struct usb_driver *driver,
         dev->driver = &driver->driver;
         usb_set_intfdata(iface, priv);
         iface->condition = USB_INTERFACE_BOUND;
+        mark_active(iface);
 
         /* if interface was already added, bind now; else let
          * the future device_add() bind it, bypassing probe()
@@ -345,6 +356,7 @@ void usb_driver_release_interface(struct usb_driver *driver,
         dev->driver = NULL;
         usb_set_intfdata(iface, NULL);
         iface->condition = USB_INTERFACE_UNBOUND;
+        mark_quiesced(iface);
 }
 
 /**
@@ -557,6 +569,7 @@ static int usb_hotplug (struct device *dev, char **envp, int num_envp,
 {
         struct usb_interface *intf;
         struct usb_device *usb_dev;
+        struct usb_host_interface *alt;
         int i = 0;
         int length = 0;
 
@@ -573,7 +586,8 @@ static int usb_hotplug (struct device *dev, char **envp, int num_envp,
 
         intf = to_usb_interface(dev);
         usb_dev = interface_to_usbdev (intf);
-        
+        alt = intf->cur_altsetting;
+
         if (usb_dev->devnum < 0) {
                 pr_debug ("usb %s: already deleted?\n", dev->bus_id);
                 return -ENODEV;
@@ -615,46 +629,27 @@ static int usb_hotplug (struct device *dev, char **envp, int num_envp,
                                 usb_dev->descriptor.bDeviceProtocol))
                 return -ENOMEM;
 
-        if (usb_dev->descriptor.bDeviceClass == 0) {
-                struct usb_host_interface *alt = intf->cur_altsetting;
+        if (add_hotplug_env_var(envp, num_envp, &i,
+                                buffer, buffer_size, &length,
+                                "INTERFACE=%d/%d/%d",
+                                alt->desc.bInterfaceClass,
+                                alt->desc.bInterfaceSubClass,
+                                alt->desc.bInterfaceProtocol))
+                return -ENOMEM;
 
-                /* 2.4 only exposed interface zero.  in 2.5, hotplug
-                 * agents are called for all interfaces, and can use
-                 * $DEVPATH/bInterfaceNumber if necessary.
-                 */
-                if (add_hotplug_env_var(envp, num_envp, &i,
-                                        buffer, buffer_size, &length,
-                                        "INTERFACE=%d/%d/%d",
-                                        alt->desc.bInterfaceClass,
-                                        alt->desc.bInterfaceSubClass,
-                                        alt->desc.bInterfaceProtocol))
-                        return -ENOMEM;
-
-                if (add_hotplug_env_var(envp, num_envp, &i,
-                                        buffer, buffer_size, &length,
-                                        "MODALIAS=usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic%02Xisc%02Xip%02X",
-                                        le16_to_cpu(usb_dev->descriptor.idVendor),
-                                        le16_to_cpu(usb_dev->descriptor.idProduct),
-                                        le16_to_cpu(usb_dev->descriptor.bcdDevice),
-                                        usb_dev->descriptor.bDeviceClass,
-                                        usb_dev->descriptor.bDeviceSubClass,
-                                        usb_dev->descriptor.bDeviceProtocol,
-                                        alt->desc.bInterfaceClass,
-                                        alt->desc.bInterfaceSubClass,
-                                        alt->desc.bInterfaceProtocol))
-                        return -ENOMEM;
-        } else {
-                if (add_hotplug_env_var(envp, num_envp, &i,
-                                        buffer, buffer_size, &length,
-                                        "MODALIAS=usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic*isc*ip*",
-                                        le16_to_cpu(usb_dev->descriptor.idVendor),
-                                        le16_to_cpu(usb_dev->descriptor.idProduct),
-                                        le16_to_cpu(usb_dev->descriptor.bcdDevice),
-                                        usb_dev->descriptor.bDeviceClass,
-                                        usb_dev->descriptor.bDeviceSubClass,
-                                        usb_dev->descriptor.bDeviceProtocol))
-                        return -ENOMEM;
-        }
+        if (add_hotplug_env_var(envp, num_envp, &i,
+                                buffer, buffer_size, &length,
+                                "MODALIAS=usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic%02Xisc%02Xip%02X",
+                                le16_to_cpu(usb_dev->descriptor.idVendor),
+                                le16_to_cpu(usb_dev->descriptor.idProduct),
+                                le16_to_cpu(usb_dev->descriptor.bcdDevice),
+                                usb_dev->descriptor.bDeviceClass,
+                                usb_dev->descriptor.bDeviceSubClass,
+                                usb_dev->descriptor.bDeviceProtocol,
+                                alt->desc.bInterfaceClass,
+                                alt->desc.bInterfaceSubClass,
+                                alt->desc.bInterfaceProtocol))
+                return -ENOMEM;
 
         envp[i] = NULL;
 
@@ -709,12 +704,10 @@ usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1)
 {
         struct usb_device *dev;
 
-        dev = kmalloc(sizeof(*dev), GFP_KERNEL);
+        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
         if (!dev)
                 return NULL;
 
-        memset(dev, 0, sizeof(*dev));
-
         bus = usb_bus_get(bus);
         if (!bus) {
                 kfree(dev);
@@ -1402,13 +1395,30 @@ void usb_buffer_unmap_sg (struct usb_device *dev, unsigned pipe,
                         usb_pipein (pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
 }
 
+static int verify_suspended(struct device *dev, void *unused)
+{
+        return (dev->power.power_state.event == PM_EVENT_ON) ? -EBUSY : 0;
+}
+
 static int usb_generic_suspend(struct device *dev, pm_message_t message)
 {
-        struct usb_interface *intf;
-        struct usb_driver *driver;
+        struct usb_interface    *intf;
+        struct usb_driver       *driver;
+        int                     status;
 
-        if (dev->driver == &usb_generic_driver)
-                return usb_suspend_device (to_usb_device(dev), message);
+        /* USB devices enter SUSPEND state through their hubs, but can be
+         * marked for FREEZE as soon as their children are already idled.
+         * But those semantics are useless, so we equate the two (sigh).
+         */
+        if (dev->driver == &usb_generic_driver) {
+                if (dev->power.power_state.event == message.event)
+                        return 0;
+                /* we need to rule out bogus requests through sysfs */
+                status = device_for_each_child(dev, NULL, verify_suspended);
+                if (status)
+                        return status;
+                return usb_suspend_device (to_usb_device(dev));
+        }
 
         if ((dev->driver == NULL) ||
             (dev->driver_data == &usb_generic_driver_data))
@@ -1417,23 +1427,44 @@ static int usb_generic_suspend(struct device *dev, pm_message_t message)
         intf = to_usb_interface(dev);
         driver = to_usb_driver(dev->driver);
 
-        /* there's only one USB suspend state */
-        if (intf->dev.power.power_state.event)
+        /* with no hardware, USB interfaces only use FREEZE and ON states */
+        if (!is_active(intf))
                 return 0;
 
-        if (driver->suspend)
-                return driver->suspend(intf, message);
-        return 0;
+        if (driver->suspend && driver->resume) {
+                status = driver->suspend(intf, message);
+                if (status)
+                        dev_err(dev, "%s error %d\n", "suspend", status);
+                else
+                        mark_quiesced(intf);
+        } else {
+                // FIXME else if there's no suspend method, disconnect...
+                dev_warn(dev, "no %s?\n", "suspend");
+                status = 0;
+        }
+        return status;
 }
 
 static int usb_generic_resume(struct device *dev)
 {
-        struct usb_interface *intf;
-        struct usb_driver *driver;
+        struct usb_interface    *intf;
+        struct usb_driver       *driver;
+        struct usb_device       *udev;
+        int                     status;
 
-        /* devices resume through their hub */
-        if (dev->driver == &usb_generic_driver)
+        if (dev->power.power_state.event == PM_EVENT_ON)
+                return 0;
+
+        /* mark things as "on" immediately, no matter what errors crop up */
+        dev->power.power_state.event = PM_EVENT_ON;
+
+        /* devices resume through their hubs */
+        if (dev->driver == &usb_generic_driver) {
+                udev = to_usb_device(dev);
+                if (udev->state == USB_STATE_NOTATTACHED)
+                        return 0;
                 return usb_resume_device (to_usb_device(dev));
+        }
 
         if ((dev->driver == NULL) ||
             (dev->driver_data == &usb_generic_driver_data))
@@ -1442,8 +1473,22 @@ static int usb_generic_resume(struct device *dev)
         intf = to_usb_interface(dev);
         driver = to_usb_driver(dev->driver);
 
-        if (driver->resume)
-                return driver->resume(intf);
+        udev = interface_to_usbdev(intf);
+        if (udev->state == USB_STATE_NOTATTACHED)
+                return 0;
+
+        /* if driver was suspended, it has a resume method;
+         * however, sysfs can wrongly mark things as suspended
+         * (on the "no suspend method" FIXME path above)
+         */
+        if (driver->resume) {
+                status = driver->resume(intf);
+                if (status) {
+                        dev_err(dev, "%s error %d\n", "resume", status);
+                        mark_quiesced(intf);
+                }
+        } else
+                dev_warn(dev, "no %s?\n", "resume");
         return 0;
 }
 
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index e6504f3370ad..1c4a68499dce 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -13,12 +13,14 @@ extern void usb_disable_device (struct usb_device *dev, int skip_ep0);
 
 extern int usb_get_device_descriptor(struct usb_device *dev,
                 unsigned int size);
+extern char *usb_cache_string(struct usb_device *udev, int index);
 extern int usb_set_configuration(struct usb_device *dev, int configuration);
 
 extern void usb_lock_all_devices(void);
 extern void usb_unlock_all_devices(void);
 
 extern void usb_kick_khubd(struct usb_device *dev);
+extern void usb_suspend_root_hub(struct usb_device *hdev);
 extern void usb_resume_root_hub(struct usb_device *dev);
 
 extern int  usb_hub_init(void);
@@ -28,6 +30,28 @@ extern void usb_major_cleanup(void);
 extern int usb_host_init(void);
 extern void usb_host_cleanup(void);
 
+extern int usb_suspend_device(struct usb_device *dev);
+extern int usb_resume_device(struct usb_device *dev);
+
+
+/* Interfaces and their "power state" are owned by usbcore */
+
+static inline void mark_active(struct usb_interface *f)
+{
+        f->dev.power.power_state.event = PM_EVENT_ON;
+}
+
+static inline void mark_quiesced(struct usb_interface *f)
+{
+        f->dev.power.power_state.event = PM_EVENT_FREEZE;
+}
+
+static inline int is_active(struct usb_interface *f)
+{
+        return f->dev.power.power_state.event == PM_EVENT_ON;
+}
+
+
 /* for labeling diagnostics */
 extern const char *usbcore_name;
 
@@ -39,9 +63,6 @@ extern void usbfs_conn_disc_event(void);
 
 extern int usbdev_init(void);
 extern void usbdev_cleanup(void);
-extern void usbdev_add(struct usb_device *dev);
-extern void usbdev_remove(struct usb_device *dev);
-extern struct usb_device *usbdev_lookup_minor(int minor);
 
 struct dev_state {
         struct list_head list;      /* state list */
@@ -58,3 +79,9 @@ struct dev_state {
         unsigned long ifclaimed;
 };
 
+/* internal notify stuff */
+extern void usb_notify_add_device(struct usb_device *udev);
+extern void usb_notify_remove_device(struct usb_device *udev);
+extern void usb_notify_add_bus(struct usb_bus *ubus);
+extern void usb_notify_remove_bus(struct usb_bus *ubus);
+
diff --git a/drivers/usb/gadget/dummy_hcd.c b/drivers/usb/gadget/dummy_hcd.c
index 503201764f6b..02106bebd5c1 100644
--- a/drivers/usb/gadget/dummy_hcd.c
+++ b/drivers/usb/gadget/dummy_hcd.c
@@ -967,6 +967,7 @@ static int dummy_udc_resume (struct device *dev)
 
 static struct device_driver dummy_udc_driver = {
         .name           = (char *) gadget_name,
+        .owner          = THIS_MODULE,
         .bus            = &platform_bus_type,
         .probe          = dummy_udc_probe,
         .remove         = dummy_udc_remove,
@@ -1751,7 +1752,7 @@ static int dummy_hub_control (
         return retval;
 }
 
-static int dummy_hub_suspend (struct usb_hcd *hcd)
+static int dummy_bus_suspend (struct usb_hcd *hcd)
 {
         struct dummy *dum = hcd_to_dummy (hcd);
 
@@ -1762,7 +1763,7 @@ static int dummy_hub_suspend (struct usb_hcd *hcd)
         return 0;
 }
 
-static int dummy_hub_resume (struct usb_hcd *hcd)
+static int dummy_bus_resume (struct usb_hcd *hcd)
 {
         struct dummy *dum = hcd_to_dummy (hcd);
 
@@ -1894,8 +1895,8 @@ static const struct hc_driver dummy_hcd = {
 
         .hub_status_data =      dummy_hub_status,
         .hub_control =          dummy_hub_control,
-        .hub_suspend =          dummy_hub_suspend,
-        .hub_resume =           dummy_hub_resume,
+        .bus_suspend =          dummy_bus_suspend,
+        .bus_resume =           dummy_bus_resume,
 };
 
 static int dummy_hcd_probe (struct device *dev)
@@ -1936,13 +1937,6 @@ static int dummy_hcd_suspend (struct device *dev, pm_message_t state)
         dev_dbg (dev, "%s\n", __FUNCTION__);
         hcd = dev_get_drvdata (dev);
 
-#ifndef CONFIG_USB_SUSPEND
-        /* Otherwise this would never happen */
-        usb_lock_device (hcd->self.root_hub);
-        dummy_hub_suspend (hcd);
-        usb_unlock_device (hcd->self.root_hub);
-#endif
-
         hcd->state = HC_STATE_SUSPENDED;
         return 0;
 }
@@ -1955,19 +1949,13 @@ static int dummy_hcd_resume (struct device *dev)
         hcd = dev_get_drvdata (dev);
         hcd->state = HC_STATE_RUNNING;
 
-#ifndef CONFIG_USB_SUSPEND
-        /* Otherwise this would never happen */
-        usb_lock_device (hcd->self.root_hub);
-        dummy_hub_resume (hcd);
-        usb_unlock_device (hcd->self.root_hub);
-#endif
-
         usb_hcd_poll_rh_status (hcd);
         return 0;
 }
 
 static struct device_driver dummy_hcd_driver = {
         .name           = (char *) driver_name,
+        .owner          = THIS_MODULE,
         .bus            = &platform_bus_type,
         .probe          = dummy_hcd_probe,
         .remove         = dummy_hcd_remove,
diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
index f1024e804d5c..8f402f85e1ca 100644
--- a/drivers/usb/gadget/ether.c
+++ b/drivers/usb/gadget/ether.c
@@ -2533,6 +2533,7 @@ static struct usb_gadget_driver eth_driver = {
 
         .driver         = {
                 .name           = (char *) shortname,
+                .owner          = THIS_MODULE,
                 // .shutdown = ...
                 // .suspend = ...
                 // .resume = ...
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index a41d9d4baee3..ea09aaa3cab6 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -224,6 +224,7 @@
 #include <linux/fs.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
+#include <linux/kthread.h>
 #include <linux/limits.h>
 #include <linux/list.h>
 #include <linux/module.h>
@@ -669,7 +670,6 @@ struct fsg_dev {
         wait_queue_head_t       thread_wqh;
         int                     thread_wakeup_needed;
         struct completion       thread_notifier;
-        int                     thread_pid;
         struct task_struct      *thread_task;
         sigset_t                thread_signal_mask;
 
@@ -1084,7 +1084,6 @@ static void wakeup_thread(struct fsg_dev *fsg)
 static void raise_exception(struct fsg_dev *fsg, enum fsg_state new_state)
 {
         unsigned long           flags;
-        struct task_struct      *thread_task;
 
         /* Do nothing if a higher-priority exception is already in progress.
          * If a lower-or-equal priority exception is in progress, preempt it
@@ -1093,9 +1092,9 @@ static void raise_exception(struct fsg_dev *fsg, enum fsg_state new_state)
         if (fsg->state <= new_state) {
                 fsg->exception_req_tag = fsg->ep0_req_tag;
                 fsg->state = new_state;
-                thread_task = fsg->thread_task;
-                if (thread_task)
-                        send_sig_info(SIGUSR1, SEND_SIG_FORCED, thread_task);
+                if (fsg->thread_task)
+                        send_sig_info(SIGUSR1, SEND_SIG_FORCED,
+                                        fsg->thread_task);
         }
         spin_unlock_irqrestore(&fsg->lock, flags);
 }
@@ -3383,11 +3382,6 @@ static int fsg_main_thread(void *fsg_)
 {
         struct fsg_dev          *fsg = (struct fsg_dev *) fsg_;
 
-        fsg->thread_task = current;
-
-        /* Release all our userspace resources */
-        daemonize("file-storage-gadget");
-
         /* Allow the thread to be killed by a signal, but set the signal mask
          * to block everything but INT, TERM, KILL, and USR1. */
         siginitsetinv(&fsg->thread_signal_mask, sigmask(SIGINT) |
@@ -3400,9 +3394,6 @@ static int fsg_main_thread(void *fsg_)
          * that expects a __user pointer and it will work okay. */
         set_fs(get_ds());
 
-        /* Wait for the gadget registration to finish up */
-        wait_for_completion(&fsg->thread_notifier);
-
         /* The main loop */
         while (fsg->state != FSG_STATE_TERMINATED) {
                 if (exception_in_progress(fsg) || signal_pending(current)) {
@@ -3440,8 +3431,9 @@ static int fsg_main_thread(void *fsg_)
                 spin_unlock_irq(&fsg->lock);
                 }
 
+        spin_lock_irq(&fsg->lock);
         fsg->thread_task = NULL;
-        flush_signals(current);
+        spin_unlock_irq(&fsg->lock);
 
         /* In case we are exiting because of a signal, unregister the
          * gadget driver and close the backing file. */
@@ -3831,12 +3823,11 @@ static int __init fsg_bind(struct usb_gadget *gadget)
 
         /* Create the LUNs, open their backing files, and register the
          * LUN devices in sysfs. */
-        fsg->luns = kmalloc(i * sizeof(struct lun), GFP_KERNEL);
+        fsg->luns = kzalloc(i * sizeof(struct lun), GFP_KERNEL);
         if (!fsg->luns) {
                 rc = -ENOMEM;
                 goto out;
         }
-        memset(fsg->luns, 0, i * sizeof(struct lun));
         fsg->nluns = i;
 
         for (i = 0; i < fsg->nluns; ++i) {
@@ -3959,10 +3950,12 @@ static int __init fsg_bind(struct usb_gadget *gadget)
                 sprintf(&serial[i], "%02X", c);
         }
 
-        if ((rc = kernel_thread(fsg_main_thread, fsg, (CLONE_VM | CLONE_FS |
-                        CLONE_FILES))) < 0)
+        fsg->thread_task = kthread_create(fsg_main_thread, fsg,
+                        "file-storage-gadget");
+        if (IS_ERR(fsg->thread_task)) {
+                rc = PTR_ERR(fsg->thread_task);
                 goto out;
-        fsg->thread_pid = rc;
+        }
 
         INFO(fsg, DRIVER_DESC ", version: " DRIVER_VERSION "\n");
         INFO(fsg, "Number of LUNs=%d\n", fsg->nluns);
@@ -3994,7 +3987,12 @@ static int __init fsg_bind(struct usb_gadget *gadget)
         DBG(fsg, "removable=%d, stall=%d, buflen=%u\n",
                         mod_data.removable, mod_data.can_stall,
                         mod_data.buflen);
-        DBG(fsg, "I/O thread pid: %d\n", fsg->thread_pid);
+        DBG(fsg, "I/O thread pid: %d\n", fsg->thread_task->pid);
+
+        set_bit(REGISTERED, &fsg->atomic_bitflags);
+
+        /* Tell the thread to start working */
+        wake_up_process(fsg->thread_task);
         return 0;
 
 autoconf_fail:
@@ -4046,6 +4044,7 @@ static struct usb_gadget_driver		fsg_driver = {
 
         .driver         = {
                 .name           = (char *) shortname,
+                .owner          = THIS_MODULE,
                 // .release = ...
                 // .suspend = ...
                 // .resume = ...
@@ -4057,10 +4056,9 @@ static int __init fsg_alloc(void)
 {
         struct fsg_dev          *fsg;
 
-        fsg = kmalloc(sizeof *fsg, GFP_KERNEL);
+        fsg = kzalloc(sizeof *fsg, GFP_KERNEL);
         if (!fsg)
                 return -ENOMEM;
-        memset(fsg, 0, sizeof *fsg);
         spin_lock_init(&fsg->lock);
         init_rwsem(&fsg->filesem);
         init_waitqueue_head(&fsg->thread_wqh);
@@ -4086,15 +4084,9 @@ static int __init fsg_init(void)
         if ((rc = fsg_alloc()) != 0)
                 return rc;
         fsg = the_fsg;
-        if ((rc = usb_gadget_register_driver(&fsg_driver)) != 0) {
+        if ((rc = usb_gadget_register_driver(&fsg_driver)) != 0)
                 fsg_free(fsg);
-                return rc;
-        }
-        set_bit(REGISTERED, &fsg->atomic_bitflags);
-
-        /* Tell the thread to start working */
-        complete(&fsg->thread_notifier);
-        return 0;
+        return rc;
 }
 module_init(fsg_init);
 
diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
index b0f3cd63e3b9..654469778ab5 100644
--- a/drivers/usb/gadget/goku_udc.c
+++ b/drivers/usb/gadget/goku_udc.c
@@ -1970,6 +1970,7 @@ MODULE_DEVICE_TABLE (pci, pci_ids);
 static struct pci_driver goku_pci_driver = {
         .name =         (char *) driver_name,
         .id_table =     pci_ids,
+        .owner =        THIS_MODULE,
 
         .probe =        goku_probe,
         .remove =       goku_remove,
diff --git a/drivers/usb/gadget/lh7a40x_udc.c b/drivers/usb/gadget/lh7a40x_udc.c
index 012d1e5f1524..9b3673904daf 100644
--- a/drivers/usb/gadget/lh7a40x_udc.c
+++ b/drivers/usb/gadget/lh7a40x_udc.c
@@ -2140,6 +2140,7 @@ static int lh7a40x_udc_remove(struct device *_dev)
 
 static struct device_driver udc_driver = {
         .name = (char *)driver_name,
+        .owner = THIS_MODULE,
         .bus = &platform_bus_type,
         .probe = lh7a40x_udc_probe,
         .remove = lh7a40x_udc_remove
diff --git a/drivers/usb/gadget/net2280.c b/drivers/usb/gadget/net2280.c
index c32e1f7476da..0dc6bb00bf72 100644
--- a/drivers/usb/gadget/net2280.c
+++ b/drivers/usb/gadget/net2280.c
@@ -2948,6 +2948,7 @@ MODULE_DEVICE_TABLE (pci, pci_ids);
 static struct pci_driver net2280_pci_driver = {
         .name =         (char *) driver_name,
         .id_table =     pci_ids,
+        .owner =        THIS_MODULE,
 
         .probe =        net2280_probe,
         .remove =       net2280_remove,
diff --git a/drivers/usb/gadget/omap_udc.c b/drivers/usb/gadget/omap_udc.c
index b7885dc0f42f..41c96b0afbb3 100644
--- a/drivers/usb/gadget/omap_udc.c
+++ b/drivers/usb/gadget/omap_udc.c
@@ -691,7 +691,7 @@ static void next_out_dma(struct omap_ep *ep, struct omap_req *req)
 }
 
 static void
-finish_out_dma(struct omap_ep *ep, struct omap_req *req, int status)
+finish_out_dma(struct omap_ep *ep, struct omap_req *req, int status, int one)
 {
         u16     count;
 
@@ -699,6 +699,8 @@ finish_out_dma(struct omap_ep *ep, struct omap_req *req, int status)
                 ep->dma_counter = (u16) (req->req.dma + req->req.actual);
         count = dma_dest_len(ep, req->req.dma + req->req.actual);
         count += req->req.actual;
+        if (one)
+                count--;
         if (count <= req->req.length)
                 req->req.actual = count;
 
@@ -747,7 +749,7 @@ static void dma_irq(struct omap_udc *udc, u16 irq_src)
                 if (!list_empty(&ep->queue)) {
                         req = container_of(ep->queue.next,
                                         struct omap_req, queue);
-                        finish_out_dma(ep, req, 0);
+                        finish_out_dma(ep, req, 0, dman_stat & UDC_DMA_RX_SB);
                 }
                 UDC_IRQ_SRC_REG = UDC_RXN_EOT;
 
@@ -925,7 +927,7 @@ static void dma_channel_release(struct omap_ep *ep)
                 while (UDC_RXDMA_CFG_REG & mask)
                         udelay(10);
                 if (req)
-                        finish_out_dma(ep, req, -ECONNRESET);
+                        finish_out_dma(ep, req, -ECONNRESET, 0);
         }
         omap_free_dma(ep->lch);
         ep->dma_channel = 0;
@@ -1786,8 +1788,12 @@ static void devstate_irq(struct omap_udc *udc, u16 irq_src)
                                         udc->driver->suspend(&udc->gadget);
                                         spin_lock(&udc->lock);
                                 }
+                                if (udc->transceiver)
+                                        otg_set_suspend(udc->transceiver, 1);
                         } else {
                                 VDBG("resume\n");
+                                if (udc->transceiver)
+                                        otg_set_suspend(udc->transceiver, 0);
                                 if (udc->gadget.speed == USB_SPEED_FULL
                                                 && udc->driver->resume) {
                                         spin_unlock(&udc->lock);
@@ -2943,6 +2949,7 @@ static int omap_udc_resume(struct device *dev)
 
 static struct device_driver udc_driver = {
         .name           = (char *) driver_name,
+        .owner          = THIS_MODULE,
         .bus            = &platform_bus_type,
         .probe          = omap_udc_probe,
         .remove         = __exit_p(omap_udc_remove),
diff --git a/drivers/usb/gadget/pxa2xx_udc.c b/drivers/usb/gadget/pxa2xx_udc.c
index 647028590b23..f83a9262f953 100644
--- a/drivers/usb/gadget/pxa2xx_udc.c
+++ b/drivers/usb/gadget/pxa2xx_udc.c
@@ -2631,6 +2631,7 @@ static int pxa2xx_udc_resume(struct device *dev)
 
 static struct device_driver udc_driver = {
         .name           = "pxa2xx-udc",
+        .owner          = THIS_MODULE,
         .bus            = &platform_bus_type,
         .probe          = pxa2xx_udc_probe,
         .shutdown       = pxa2xx_udc_shutdown,
diff --git a/drivers/usb/gadget/zero.c b/drivers/usb/gadget/zero.c
index ec9c424f1d97..6c58636e914b 100644
--- a/drivers/usb/gadget/zero.c
+++ b/drivers/usb/gadget/zero.c
@@ -1302,6 +1302,7 @@ static struct usb_gadget_driver zero_driver = {
 
         .driver         = {
                 .name           = (char *) shortname,
+                .owner          = THIS_MODULE,
                 // .shutdown = ...
                 // .suspend = ...
                 // .resume = ...
diff --git a/drivers/usb/host/Makefile b/drivers/usb/host/Makefile
index 350d14fc1cc9..58321d3f314c 100644
--- a/drivers/usb/host/Makefile
+++ b/drivers/usb/host/Makefile
@@ -1,8 +1,9 @@
 #
-# Makefile for USB Host Controller Driver
-# framework and drivers
+# Makefile for USB Host Controller Drivers
 #
 
+obj-$(CONFIG_PCI)               += pci-quirks.o
+
 obj-$(CONFIG_USB_EHCI_HCD)      += ehci-hcd.o
 obj-$(CONFIG_USB_ISP116X_HCD)   += isp116x-hcd.o
 obj-$(CONFIG_USB_OHCI_HCD)      += ohci-hcd.o
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index f5eb9e7b5b18..af3c05eb86fc 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -182,6 +182,9 @@ static int ehci_halt (struct ehci_hcd *ehci)
 {
         u32     temp = readl (&ehci->regs->status);
 
+        /* disable any irqs left enabled by previous code */
+        writel (0, &ehci->regs->intr_enable);
+
         if ((temp & STS_HALT) != 0)
                 return 0;
 
@@ -297,50 +300,17 @@ static void ehci_watchdog (unsigned long param)
         spin_unlock_irqrestore (&ehci->lock, flags);
 }
 
-#ifdef  CONFIG_PCI
-
-/* EHCI 0.96 (and later) section 5.1 says how to kick BIOS/SMM/...
- * off the controller (maybe it can boot from highspeed USB disks).
+/* Reboot notifiers kick in for silicon on any bus (not just pci, etc).
+ * This forcibly disables dma and IRQs, helping kexec and other cases
+ * where the next system software may expect clean state.
  */
-static int bios_handoff (struct ehci_hcd *ehci, int where, u32 cap)
-{
-        struct pci_dev *pdev = to_pci_dev(ehci_to_hcd(ehci)->self.controller);
-
-        /* always say Linux will own the hardware */
-        pci_write_config_byte(pdev, where + 3, 1);
-
-        /* maybe wait a while for BIOS to respond */
-        if (cap & (1 << 16)) {
-                int msec = 5000;
-
-                do {
-                        msleep(10);
-                        msec -= 10;
-                        pci_read_config_dword(pdev, where, &cap);
-                } while ((cap & (1 << 16)) && msec);
-                if (cap & (1 << 16)) {
-                        ehci_err(ehci, "BIOS handoff failed (%d, %08x)\n",
-                                where, cap);
-                        // some BIOS versions seem buggy...
-                        // return 1;
-                        ehci_warn (ehci, "continuing after BIOS bug...\n");
-                        /* disable all SMIs, and clear "BIOS owns" flag */
-                        pci_write_config_dword(pdev, where + 4, 0);
-                        pci_write_config_byte(pdev, where + 2, 0);
-                } else
-                        ehci_dbg(ehci, "BIOS handoff succeeded\n");
-        }
-        return 0;
-}
-
-#endif
-
 static int
 ehci_reboot (struct notifier_block *self, unsigned long code, void *null)
 {
         struct ehci_hcd         *ehci;
 
         ehci = container_of (self, struct ehci_hcd, reboot_notifier);
+        (void) ehci_halt (ehci);
 
         /* make BIOS/etc use companion controller during reboot */
         writel (0, &ehci->regs->configured_flag);
@@ -363,156 +333,90 @@ static void ehci_port_power (struct ehci_hcd *ehci, int is_on)
         msleep(20);
 }
 
+/*-------------------------------------------------------------------------*/
+
+/*
+ * ehci_work is called from some interrupts, timers, and so on.
+ * it calls driver completion functions, after dropping ehci->lock.
+ */
+static void ehci_work (struct ehci_hcd *ehci, struct pt_regs *regs)
+{
+        timer_action_done (ehci, TIMER_IO_WATCHDOG);
+        if (ehci->reclaim_ready)
+                end_unlink_async (ehci, regs);
+
+        /* another CPU may drop ehci->lock during a schedule scan while
+         * it reports urb completions.  this flag guards against bogus
+         * attempts at re-entrant schedule scanning.
+         */
+        if (ehci->scanning)
+                return;
+        ehci->scanning = 1;
+        scan_async (ehci, regs);
+        if (ehci->next_uframe != -1)
+                scan_periodic (ehci, regs);
+        ehci->scanning = 0;
 
-/* called by khubd or root hub init threads */
+        /* the IO watchdog guards against hardware or driver bugs that
+         * misplace IRQs, and should let us run completely without IRQs.
+         * such lossage has been observed on both VT6202 and VT8235.
+         */
+        if (HC_IS_RUNNING (ehci_to_hcd(ehci)->state) &&
+                        (ehci->async->qh_next.ptr != NULL ||
+                         ehci->periodic_sched != 0))
+                timer_action (ehci, TIMER_IO_WATCHDOG);
+}
 
-static int ehci_hc_reset (struct usb_hcd *hcd)
+static void ehci_stop (struct usb_hcd *hcd)
 {
         struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
-        u32                     temp;
-        unsigned                count = 256/4;
 
-        spin_lock_init (&ehci->lock);
+        ehci_dbg (ehci, "stop\n");
 
-        ehci->caps = hcd->regs;
-        ehci->regs = hcd->regs + HC_LENGTH (readl (&ehci->caps->hc_capbase));
-        dbg_hcs_params (ehci, "reset");
-        dbg_hcc_params (ehci, "reset");
+        /* Turn off port power on all root hub ports. */
+        ehci_port_power (ehci, 0);
 
-        /* cache this readonly data; minimize chip reads */
-        ehci->hcs_params = readl (&ehci->caps->hcs_params);
+        /* no more interrupts ... */
+        del_timer_sync (&ehci->watchdog);
 
-#ifdef  CONFIG_PCI
-        if (hcd->self.controller->bus == &pci_bus_type) {
-                struct pci_dev  *pdev = to_pci_dev(hcd->self.controller);
+        spin_lock_irq(&ehci->lock);
+        if (HC_IS_RUNNING (hcd->state))
+                ehci_quiesce (ehci);
 
-                switch (pdev->vendor) {
-                case PCI_VENDOR_ID_TDI:
-                        if (pdev->device == PCI_DEVICE_ID_TDI_EHCI) {
-                                ehci->is_tdi_rh_tt = 1;
-                                tdi_reset (ehci);
-                        }
-                        break;
-                case PCI_VENDOR_ID_AMD:
-                        /* AMD8111 EHCI doesn't work, according to AMD errata */
-                        if (pdev->device == 0x7463) {
-                                ehci_info (ehci, "ignoring AMD8111 (errata)\n");
-                                return -EIO;
-                        }
-                        break;
-                case PCI_VENDOR_ID_NVIDIA:
-                        /* NVidia reports that certain chips don't handle
-                         * QH, ITD, or SITD addresses above 2GB.  (But TD,
-                         * data buffer, and periodic schedule are normal.)
-                         */
-                        switch (pdev->device) {
-                        case 0x003c:    /* MCP04 */
-                        case 0x005b:    /* CK804 */
-                        case 0x00d8:    /* CK8 */
-                        case 0x00e8:    /* CK8S */
-                                if (pci_set_consistent_dma_mask(pdev,
-                                                        DMA_31BIT_MASK) < 0)
-                                        ehci_warn (ehci, "can't enable NVidia "
-                                                "workaround for >2GB RAM\n");
-                                break;
-                        }
-                        break;
-                }
+        ehci_reset (ehci);
+        writel (0, &ehci->regs->intr_enable);
+        spin_unlock_irq(&ehci->lock);
 
-                /* optional debug port, normally in the first BAR */
-                temp = pci_find_capability (pdev, 0x0a);
-                if (temp) {
-                        pci_read_config_dword(pdev, temp, &temp);
-                        temp >>= 16;
-                        if ((temp & (3 << 13)) == (1 << 13)) {
-                                temp &= 0x1fff;
-                                ehci->debug = hcd->regs + temp;
-                                temp = readl (&ehci->debug->control);
-                                ehci_info (ehci, "debug port %d%s\n",
-                                        HCS_DEBUG_PORT(ehci->hcs_params),
-                                        (temp & DBGP_ENABLED)
-                                                ? " IN USE"
-                                                : "");
-                                if (!(temp & DBGP_ENABLED))
-                                        ehci->debug = NULL;
-                        }
-                }
+        /* let companion controllers work when we aren't */
+        writel (0, &ehci->regs->configured_flag);
+        unregister_reboot_notifier (&ehci->reboot_notifier);
 
-                temp = HCC_EXT_CAPS (readl (&ehci->caps->hcc_params));
-        } else
-                temp = 0;
-
-        /* EHCI 0.96 and later may have "extended capabilities" */
-        while (temp && count--) {
-                u32             cap;
-
-                pci_read_config_dword (to_pci_dev(hcd->self.controller),
-                                temp, &cap);
-                ehci_dbg (ehci, "capability %04x at %02x\n", cap, temp);
-                switch (cap & 0xff) {
-                case 1:                 /* BIOS/SMM/... handoff */
-                        if (bios_handoff (ehci, temp, cap) != 0)
-                                return -EOPNOTSUPP;
-                        break;
-                case 0:                 /* illegal reserved capability */
-                        ehci_warn (ehci, "illegal capability!\n");
-                        cap = 0;
-                        /* FALLTHROUGH */
-                default:                /* unknown */
-                        break;
-                }
-                temp = (cap >> 8) & 0xff;
-        }
-        if (!count) {
-                ehci_err (ehci, "bogus capabilities ... PCI problems!\n");
-                return -EIO;
-        }
-        if (ehci_is_TDI(ehci))
-                ehci_reset (ehci);
-#endif
+        remove_debug_files (ehci);
 
-        ehci_port_power (ehci, 0);
+        /* root hub is shut down separately (first, when possible) */
+        spin_lock_irq (&ehci->lock);
+        if (ehci->async)
+                ehci_work (ehci, NULL);
+        spin_unlock_irq (&ehci->lock);
+        ehci_mem_cleanup (ehci);
 
-        /* at least the Genesys GL880S needs fixup here */
-        temp = HCS_N_CC(ehci->hcs_params) * HCS_N_PCC(ehci->hcs_params);
-        temp &= 0x0f;
-        if (temp && HCS_N_PORTS(ehci->hcs_params) > temp) {
-                ehci_dbg (ehci, "bogus port configuration: "
-                        "cc=%d x pcc=%d < ports=%d\n",
-                        HCS_N_CC(ehci->hcs_params),
-                        HCS_N_PCC(ehci->hcs_params),
-                        HCS_N_PORTS(ehci->hcs_params));
-
-#ifdef  CONFIG_PCI
-                if (hcd->self.controller->bus == &pci_bus_type) {
-                        struct pci_dev  *pdev;
-
-                        pdev = to_pci_dev(hcd->self.controller);
-                        switch (pdev->vendor) {
-                        case 0x17a0:            /* GENESYS */
-                                /* GL880S: should be PORTS=2 */
-                                temp |= (ehci->hcs_params & ~0xf);
-                                ehci->hcs_params = temp;
-                                break;
-                        case PCI_VENDOR_ID_NVIDIA:
-                                /* NF4: should be PCC=10 */
-                                break;
-                        }
-                }
+#ifdef  EHCI_STATS
+        ehci_dbg (ehci, "irq normal %ld err %ld reclaim %ld (lost %ld)\n",
+                ehci->stats.normal, ehci->stats.error, ehci->stats.reclaim,
+                ehci->stats.lost_iaa);
+        ehci_dbg (ehci, "complete %ld unlink %ld\n",
+                ehci->stats.complete, ehci->stats.unlink);
 #endif
-        }
 
-        /* force HC to halt state */
-        return ehci_halt (ehci);
+        dbg_status (ehci, "ehci_stop completed", readl (&ehci->regs->status));
 }
 
-static int ehci_start (struct usb_hcd *hcd)
+static int ehci_run (struct usb_hcd *hcd)
 {
         struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
         u32                     temp;
         int                     retval;
         u32                     hcc_params;
-        u8                      sbrn = 0;
         int                     first;
 
         /* skip some things on restart paths */
@@ -551,27 +455,6 @@ static int ehci_start (struct usb_hcd *hcd)
         }
         writel (ehci->periodic_dma, &ehci->regs->frame_list);
 
-#ifdef  CONFIG_PCI
-        if (hcd->self.controller->bus == &pci_bus_type) {
-                struct pci_dev          *pdev;
-                u16                     port_wake;
-
-                pdev = to_pci_dev(hcd->self.controller);
-
-                /* Serial Bus Release Number is at PCI 0x60 offset */
-                pci_read_config_byte(pdev, 0x60, &sbrn);
-
-                /* port wake capability, reported by boot firmware */
-                pci_read_config_word(pdev, 0x62, &port_wake);
-                hcd->can_wakeup = (port_wake & 1) != 0;
-
-                /* help hc dma work well with cachelines */
-                retval = pci_set_mwi(pdev);
-                if (retval)
-                        ehci_dbg(ehci, "unable to enable MWI - not fatal.\n");
-        }
-#endif
-
         /*
          * dedicate a qh for the async ring head, since we couldn't unlink
          * a 'real' qh without stopping the async schedule [4.8].  use it
@@ -667,7 +550,7 @@ static int ehci_start (struct usb_hcd *hcd)
         temp = HC_VERSION(readl (&ehci->caps->hc_capbase));
         ehci_info (ehci,
                 "USB %x.%x %s, EHCI %x.%02x, driver %s\n",
-                ((sbrn & 0xf0)>>4), (sbrn & 0x0f),
+                ((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f),
                 first ? "initialized" : "restarted",
                 temp >> 8, temp & 0xff, DRIVER_VERSION);
 
@@ -679,188 +562,6 @@ static int ehci_start (struct usb_hcd *hcd)
         return 0;
 }
 
-/* always called by thread; normally rmmod */
-
-static void ehci_stop (struct usb_hcd *hcd)
-{
-        struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
-
-        ehci_dbg (ehci, "stop\n");
-
-        /* Turn off port power on all root hub ports. */
-        ehci_port_power (ehci, 0);
-
-        /* no more interrupts ... */
-        del_timer_sync (&ehci->watchdog);
-
-        spin_lock_irq(&ehci->lock);
-        if (HC_IS_RUNNING (hcd->state))
-                ehci_quiesce (ehci);
-
-        ehci_reset (ehci);
-        writel (0, &ehci->regs->intr_enable);
-        spin_unlock_irq(&ehci->lock);
-
-        /* let companion controllers work when we aren't */
-        writel (0, &ehci->regs->configured_flag);
-        unregister_reboot_notifier (&ehci->reboot_notifier);
-
-        remove_debug_files (ehci);
-
-        /* root hub is shut down separately (first, when possible) */
-        spin_lock_irq (&ehci->lock);
-        if (ehci->async)
-                ehci_work (ehci, NULL);
-        spin_unlock_irq (&ehci->lock);
-        ehci_mem_cleanup (ehci);
-
-#ifdef  EHCI_STATS
-        ehci_dbg (ehci, "irq normal %ld err %ld reclaim %ld (lost %ld)\n",
-                ehci->stats.normal, ehci->stats.error, ehci->stats.reclaim,
-                ehci->stats.lost_iaa);
-        ehci_dbg (ehci, "complete %ld unlink %ld\n",
-                ehci->stats.complete, ehci->stats.unlink);
-#endif
-
-        dbg_status (ehci, "ehci_stop completed", readl (&ehci->regs->status));
-}
-
-static int ehci_get_frame (struct usb_hcd *hcd)
-{
-        struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
-        return (readl (&ehci->regs->frame_index) >> 3) % ehci->periodic_size;
-}
-
-/*-------------------------------------------------------------------------*/
-
-#ifdef  CONFIG_PM
-
-/* suspend/resume, section 4.3 */
-
-/* These routines rely on the bus (pci, platform, etc)
- * to handle powerdown and wakeup, and currently also on
- * transceivers that don't need any software attention to set up
- * the right sort of wakeup.  
- */
-
-static int ehci_suspend (struct usb_hcd *hcd, pm_message_t message)
-{
-        struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
-
-        if (time_before (jiffies, ehci->next_statechange))
-                msleep (100);
-
-#ifdef  CONFIG_USB_SUSPEND
-        (void) usb_suspend_device (hcd->self.root_hub, message);
-#else
-        usb_lock_device (hcd->self.root_hub);
-        (void) ehci_hub_suspend (hcd);
-        usb_unlock_device (hcd->self.root_hub);
-#endif
-
-        // save (PCI) FLADJ in case of Vaux power loss
-        // ... we'd only use it to handle clock skew
-
-        return 0;
-}
-
-static int ehci_resume (struct usb_hcd *hcd)
-{
-        struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
-        unsigned                port;
-        struct usb_device       *root = hcd->self.root_hub;
-        int                     retval = -EINVAL;
-
-        // maybe restore (PCI) FLADJ
-
-        if (time_before (jiffies, ehci->next_statechange))
-                msleep (100);
-
-        /* If any port is suspended (or owned by the companion),
-         * we know we can/must resume the HC (and mustn't reset it).
-         */
-        for (port = HCS_N_PORTS (ehci->hcs_params); port > 0; ) {
-                u32     status;
-                port--;
-                status = readl (&ehci->regs->port_status [port]);
-                if (!(status & PORT_POWER))
-                        continue;
-                if (status & (PORT_SUSPEND | PORT_OWNER)) {
-                        down (&hcd->self.root_hub->serialize);
-                        retval = ehci_hub_resume (hcd);
-                        up (&hcd->self.root_hub->serialize);
-                        break;
-                }
-                if (!root->children [port])
-                        continue;
-                dbg_port (ehci, __FUNCTION__, port + 1, status);
-                usb_set_device_state (root->children[port],
-                                        USB_STATE_NOTATTACHED);
-        }
-
-        /* Else reset, to cope with power loss or flush-to-storage
-         * style "resume" having activated BIOS during reboot.
-         */
-        if (port == 0) {
-                (void) ehci_halt (ehci);
-                (void) ehci_reset (ehci);
-                (void) ehci_hc_reset (hcd);
-
-                /* emptying the schedule aborts any urbs */
-                spin_lock_irq (&ehci->lock);
-                if (ehci->reclaim)
-                        ehci->reclaim_ready = 1;
-                ehci_work (ehci, NULL);
-                spin_unlock_irq (&ehci->lock);
-
-                /* restart; khubd will disconnect devices */
-                retval = ehci_start (hcd);
-
-                /* here we "know" root ports should always stay powered;
-                 * but some controllers may lose all power.
-                 */
-                ehci_port_power (ehci, 1);
-        }
-
-        return retval;
-}
-
-#endif
-
-/*-------------------------------------------------------------------------*/
-
-/*
- * ehci_work is called from some interrupts, timers, and so on.
- * it calls driver completion functions, after dropping ehci->lock.
- */
-static void ehci_work (struct ehci_hcd *ehci, struct pt_regs *regs)
-{
-        timer_action_done (ehci, TIMER_IO_WATCHDOG);
-        if (ehci->reclaim_ready)
-                end_unlink_async (ehci, regs);
-
-        /* another CPU may drop ehci->lock during a schedule scan while
-         * it reports urb completions.  this flag guards against bogus
-         * attempts at re-entrant schedule scanning.
-         */
-        if (ehci->scanning)
-                return;
-        ehci->scanning = 1;
-        scan_async (ehci, regs);
-        if (ehci->next_uframe != -1)
-                scan_periodic (ehci, regs);
-        ehci->scanning = 0;
-
-        /* the IO watchdog guards against hardware or driver bugs that
-         * misplace IRQs, and should let us run completely without IRQs.
-         * such lossage has been observed on both VT6202 and VT8235. 
-         */
-        if (HC_IS_RUNNING (ehci_to_hcd(ehci)->state) &&
-                        (ehci->async->qh_next.ptr != NULL ||
-                         ehci->periodic_sched != 0))
-                timer_action (ehci, TIMER_IO_WATCHDOG);
-}
-
 /*-------------------------------------------------------------------------*/
 
 static irqreturn_t ehci_irq (struct usb_hcd *hcd, struct pt_regs *regs)
@@ -1171,106 +872,24 @@ done:
         return;
 }
 
-/*-------------------------------------------------------------------------*/
-
-static const struct hc_driver ehci_driver = {
-        .description =          hcd_name,
-        .product_desc =         "EHCI Host Controller",
-        .hcd_priv_size =        sizeof(struct ehci_hcd),
-
-        /*
-         * generic hardware linkage
-         */
-        .irq =                  ehci_irq,
-        .flags =                HCD_MEMORY | HCD_USB2,
-
-        /*
-         * basic lifecycle operations
-         */
-        .reset =                ehci_hc_reset,
-        .start =                ehci_start,
-#ifdef  CONFIG_PM
-        .suspend =              ehci_suspend,
-        .resume =               ehci_resume,
-#endif
-        .stop =                 ehci_stop,
-
-        /*
-         * managing i/o requests and associated device resources
-         */
-        .urb_enqueue =          ehci_urb_enqueue,
-        .urb_dequeue =          ehci_urb_dequeue,
-        .endpoint_disable =     ehci_endpoint_disable,
-
-        /*
-         * scheduling support
-         */
-        .get_frame_number =     ehci_get_frame,
-
-        /*
-         * root hub support
-         */
-        .hub_status_data =      ehci_hub_status_data,
-        .hub_control =          ehci_hub_control,
-        .hub_suspend =          ehci_hub_suspend,
-        .hub_resume =           ehci_hub_resume,
-};
+static int ehci_get_frame (struct usb_hcd *hcd)
+{
+        struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
+        return (readl (&ehci->regs->frame_index) >> 3) % ehci->periodic_size;
+}
 
 /*-------------------------------------------------------------------------*/
 
-/* EHCI 1.0 doesn't require PCI */
-
-#ifdef  CONFIG_PCI
-
-/* PCI driver selection metadata; PCI hotplugging uses this */
-static const struct pci_device_id pci_ids [] = { {
-        /* handle any USB 2.0 EHCI controller */
-        PCI_DEVICE_CLASS(((PCI_CLASS_SERIAL_USB << 8) | 0x20), ~0),
-        .driver_data =  (unsigned long) &ehci_driver,
-        },
-        { /* end: all zeroes */ }
-};
-MODULE_DEVICE_TABLE (pci, pci_ids);
-
-/* pci driver glue; this is a "new style" PCI driver module */
-static struct pci_driver ehci_pci_driver = {
-        .name =         (char *) hcd_name,
-        .id_table =     pci_ids,
-
-        .probe =        usb_hcd_pci_probe,
-        .remove =       usb_hcd_pci_remove,
-
-#ifdef  CONFIG_PM
-        .suspend =      usb_hcd_pci_suspend,
-        .resume =       usb_hcd_pci_resume,
-#endif
-};
-
-#endif  /* PCI */
-
-
 #define DRIVER_INFO DRIVER_VERSION " " DRIVER_DESC
 
 MODULE_DESCRIPTION (DRIVER_INFO);
 MODULE_AUTHOR (DRIVER_AUTHOR);
 MODULE_LICENSE ("GPL");
 
-static int __init init (void) 
-{
-        if (usb_disabled())
-                return -ENODEV;
-
-        pr_debug ("%s: block sizes: qh %Zd qtd %Zd itd %Zd sitd %Zd\n",
-                hcd_name,
-                sizeof (struct ehci_qh), sizeof (struct ehci_qtd),
-                sizeof (struct ehci_itd), sizeof (struct ehci_sitd));
-
-        return pci_register_driver (&ehci_pci_driver);
-}
-module_init (init);
+#ifdef CONFIG_PCI
+#include "ehci-pci.c"
+#endif
 
-static void __exit cleanup (void) 
-{       
-        pci_unregister_driver (&ehci_pci_driver);
-}
-module_exit (cleanup);
+#if !defined(CONFIG_PCI)
+#error "missing bus glue for ehci-hcd"
+#endif
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index 18d3f2270316..88cb4ada686e 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -30,7 +30,7 @@
 
 #ifdef  CONFIG_PM
 
-static int ehci_hub_suspend (struct usb_hcd *hcd)
+static int ehci_bus_suspend (struct usb_hcd *hcd)
 {
         struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
         int                     port;
@@ -83,7 +83,7 @@ static int ehci_hub_suspend (struct usb_hcd *hcd)
 
 
 /* caller has locked the root hub, and should reset/reinit on error */
-static int ehci_hub_resume (struct usb_hcd *hcd)
+static int ehci_bus_resume (struct usb_hcd *hcd)
 {
         struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
         u32                     temp;
@@ -159,8 +159,8 @@ static int ehci_hub_resume (struct usb_hcd *hcd)
 
 #else
 
-#define ehci_hub_suspend        NULL
-#define ehci_hub_resume         NULL
+#define ehci_bus_suspend        NULL
+#define ehci_bus_resume         NULL
 
 #endif  /* CONFIG_PM */
 
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
new file mode 100644
index 000000000000..145008853966
--- /dev/null
+++ b/drivers/usb/host/ehci-pci.c
@@ -0,0 +1,415 @@
+/*
+ * EHCI HCD (Host Controller Driver) PCI Bus Glue.
+ *
+ * Copyright (c) 2000-2004 by David Brownell
+ *
+ * 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 CONFIG_PCI
+#error "This file is PCI bus glue.  CONFIG_PCI must be defined."
+#endif
+
+/*-------------------------------------------------------------------------*/
+
+/* EHCI 0.96 (and later) section 5.1 says how to kick BIOS/SMM/...
+ * off the controller (maybe it can boot from highspeed USB disks).
+ */
+static int bios_handoff (struct ehci_hcd *ehci, int where, u32 cap)
+{
+        struct pci_dev *pdev = to_pci_dev(ehci_to_hcd(ehci)->self.controller);
+
+        /* always say Linux will own the hardware */
+        pci_write_config_byte(pdev, where + 3, 1);
+
+        /* maybe wait a while for BIOS to respond */
+        if (cap & (1 << 16)) {
+                int msec = 5000;
+
+                do {
+                        msleep(10);
+                        msec -= 10;
+                        pci_read_config_dword(pdev, where, &cap);
+                } while ((cap & (1 << 16)) && msec);
+                if (cap & (1 << 16)) {
+                        ehci_err(ehci, "BIOS handoff failed (%d, %08x)\n",
+                                where, cap);
+                        // some BIOS versions seem buggy...
+                        // return 1;
+                        ehci_warn (ehci, "continuing after BIOS bug...\n");
+                        /* disable all SMIs, and clear "BIOS owns" flag */
+                        pci_write_config_dword(pdev, where + 4, 0);
+                        pci_write_config_byte(pdev, where + 2, 0);
+                } else
+                        ehci_dbg(ehci, "BIOS handoff succeeded\n");
+        }
+        return 0;
+}
+
+/* called by khubd or root hub init threads */
+static int ehci_pci_reset (struct usb_hcd *hcd)
+{
+        struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
+        u32                     temp;
+        unsigned                count = 256/4;
+
+        spin_lock_init (&ehci->lock);
+
+        ehci->caps = hcd->regs;
+        ehci->regs = hcd->regs + HC_LENGTH (readl (&ehci->caps->hc_capbase));
+        dbg_hcs_params (ehci, "reset");
+        dbg_hcc_params (ehci, "reset");
+
+        /* cache this readonly data; minimize chip reads */
+        ehci->hcs_params = readl (&ehci->caps->hcs_params);
+
+        if (hcd->self.controller->bus == &pci_bus_type) {
+                struct pci_dev  *pdev = to_pci_dev(hcd->self.controller);
+
+                switch (pdev->vendor) {
+                case PCI_VENDOR_ID_TDI:
+                        if (pdev->device == PCI_DEVICE_ID_TDI_EHCI) {
+                                ehci->is_tdi_rh_tt = 1;
+                                tdi_reset (ehci);
+                        }
+                        break;
+                case PCI_VENDOR_ID_AMD:
+                        /* AMD8111 EHCI doesn't work, according to AMD errata */
+                        if (pdev->device == 0x7463) {
+                                ehci_info (ehci, "ignoring AMD8111 (errata)\n");
+                                return -EIO;
+                        }
+                        break;
+                case PCI_VENDOR_ID_NVIDIA:
+                        /* NVidia reports that certain chips don't handle
+                         * QH, ITD, or SITD addresses above 2GB.  (But TD,
+                         * data buffer, and periodic schedule are normal.)
+                         */
+                        switch (pdev->device) {
+                        case 0x003c:    /* MCP04 */
+                        case 0x005b:    /* CK804 */
+                        case 0x00d8:    /* CK8 */
+                        case 0x00e8:    /* CK8S */
+                                if (pci_set_consistent_dma_mask(pdev,
+                                                        DMA_31BIT_MASK) < 0)
+                                        ehci_warn (ehci, "can't enable NVidia "
+                                                "workaround for >2GB RAM\n");
+                                break;
+                        }
+                        break;
+                }
+
+                /* optional debug port, normally in the first BAR */
+                temp = pci_find_capability (pdev, 0x0a);
+                if (temp) {
+                        pci_read_config_dword(pdev, temp, &temp);
+                        temp >>= 16;
+                        if ((temp & (3 << 13)) == (1 << 13)) {
+                                temp &= 0x1fff;
+                                ehci->debug = hcd->regs + temp;
+                                temp = readl (&ehci->debug->control);
+                                ehci_info (ehci, "debug port %d%s\n",
+                                        HCS_DEBUG_PORT(ehci->hcs_params),
+                                        (temp & DBGP_ENABLED)
+                                                ? " IN USE"
+                                                : "");
+                                if (!(temp & DBGP_ENABLED))
+                                        ehci->debug = NULL;
+                        }
+                }
+
+                temp = HCC_EXT_CAPS (readl (&ehci->caps->hcc_params));
+        } else
+                temp = 0;
+
+        /* EHCI 0.96 and later may have "extended capabilities" */
+        while (temp && count--) {
+                u32             cap;
+
+                pci_read_config_dword (to_pci_dev(hcd->self.controller),
+                                temp, &cap);
+                ehci_dbg (ehci, "capability %04x at %02x\n", cap, temp);
+                switch (cap & 0xff) {
+                case 1:                 /* BIOS/SMM/... handoff */
+                        if (bios_handoff (ehci, temp, cap) != 0)
+                                return -EOPNOTSUPP;
+                        break;
+                case 0:                 /* illegal reserved capability */
+                        ehci_warn (ehci, "illegal capability!\n");
+                        cap = 0;
+                        /* FALLTHROUGH */
+                default:                /* unknown */
+                        break;
+                }
+                temp = (cap >> 8) & 0xff;
+        }
+        if (!count) {
+                ehci_err (ehci, "bogus capabilities ... PCI problems!\n");
+                return -EIO;
+        }
+        if (ehci_is_TDI(ehci))
+                ehci_reset (ehci);
+
+        ehci_port_power (ehci, 0);
+
+        /* at least the Genesys GL880S needs fixup here */
+        temp = HCS_N_CC(ehci->hcs_params) * HCS_N_PCC(ehci->hcs_params);
+        temp &= 0x0f;
+        if (temp && HCS_N_PORTS(ehci->hcs_params) > temp) {
+                ehci_dbg (ehci, "bogus port configuration: "
+                        "cc=%d x pcc=%d < ports=%d\n",
+                        HCS_N_CC(ehci->hcs_params),
+                        HCS_N_PCC(ehci->hcs_params),
+                        HCS_N_PORTS(ehci->hcs_params));
+
+                if (hcd->self.controller->bus == &pci_bus_type) {
+                        struct pci_dev  *pdev;
+
+                        pdev = to_pci_dev(hcd->self.controller);
+                        switch (pdev->vendor) {
+                        case 0x17a0:            /* GENESYS */
+                                /* GL880S: should be PORTS=2 */
+                                temp |= (ehci->hcs_params & ~0xf);
+                                ehci->hcs_params = temp;
+                                break;
+                        case PCI_VENDOR_ID_NVIDIA:
+                                /* NF4: should be PCC=10 */
+                                break;
+                        }
+                }
+        }
+
+        /* force HC to halt state */
+        return ehci_halt (ehci);
+}
+
+static int ehci_pci_start (struct usb_hcd *hcd)
+{
+        struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
+        int result = 0;
+
+        if (hcd->self.controller->bus == &pci_bus_type) {
+                struct pci_dev          *pdev;
+                u16                     port_wake;
+
+                pdev = to_pci_dev(hcd->self.controller);
+
+                /* Serial Bus Release Number is at PCI 0x60 offset */
+                pci_read_config_byte(pdev, 0x60, &ehci->sbrn);
+
+                /* port wake capability, reported by boot firmware */
+                pci_read_config_word(pdev, 0x62, &port_wake);
+                hcd->can_wakeup = (port_wake & 1) != 0;
+
+                /* help hc dma work well with cachelines */
+                result = pci_set_mwi(pdev);
+                if (result)
+                        ehci_dbg(ehci, "unable to enable MWI - not fatal.\n");
+        }
+
+        return ehci_run (hcd);
+}
+
+/* always called by thread; normally rmmod */
+
+static void ehci_pci_stop (struct usb_hcd *hcd)
+{
+        ehci_stop (hcd);
+}
+
+/*-------------------------------------------------------------------------*/
+
+#ifdef  CONFIG_PM
+
+/* suspend/resume, section 4.3 */
+
+/* These routines rely on the bus (pci, platform, etc)
+ * to handle powerdown and wakeup, and currently also on
+ * transceivers that don't need any software attention to set up
+ * the right sort of wakeup.
+ */
+
+static int ehci_pci_suspend (struct usb_hcd *hcd, pm_message_t message)
+{
+        struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
+
+        if (time_before (jiffies, ehci->next_statechange))
+                msleep (100);
+
+#ifdef  CONFIG_USB_SUSPEND
+        (void) usb_suspend_device (hcd->self.root_hub);
+#else
+        usb_lock_device (hcd->self.root_hub);
+        (void) ehci_bus_suspend (hcd);
+        usb_unlock_device (hcd->self.root_hub);
+#endif
+
+        // save (PCI) FLADJ in case of Vaux power loss
+        // ... we'd only use it to handle clock skew
+
+        return 0;
+}
+
+static int ehci_pci_resume (struct usb_hcd *hcd)
+{
+        struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
+        unsigned                port;
+        struct usb_device       *root = hcd->self.root_hub;
+        int                     retval = -EINVAL;
+
+        // maybe restore (PCI) FLADJ
+
+        if (time_before (jiffies, ehci->next_statechange))
+                msleep (100);
+
+        /* If any port is suspended (or owned by the companion),
+         * we know we can/must resume the HC (and mustn't reset it).
+         */
+        for (port = HCS_N_PORTS (ehci->hcs_params); port > 0; ) {
+                u32     status;
+                port--;
+                status = readl (&ehci->regs->port_status [port]);
+                if (!(status & PORT_POWER))
+                        continue;
+                if (status & (PORT_SUSPEND | PORT_OWNER)) {
+                        down (&hcd->self.root_hub->serialize);
+                        retval = ehci_bus_resume (hcd);
+                        up (&hcd->self.root_hub->serialize);
+                        break;
+                }
+                if (!root->children [port])
+                        continue;
+                dbg_port (ehci, __FUNCTION__, port + 1, status);
+                usb_set_device_state (root->children[port],
+                                        USB_STATE_NOTATTACHED);
+        }
+
+        /* Else reset, to cope with power loss or flush-to-storage
+         * style "resume" having activated BIOS during reboot.
+         */
+        if (port == 0) {
+                (void) ehci_halt (ehci);
+                (void) ehci_reset (ehci);
+                (void) ehci_pci_reset (hcd);
+
+                /* emptying the schedule aborts any urbs */
+                spin_lock_irq (&ehci->lock);
+                if (ehci->reclaim)
+                        ehci->reclaim_ready = 1;
+                ehci_work (ehci, NULL);
+                spin_unlock_irq (&ehci->lock);
+
+                /* restart; khubd will disconnect devices */
+                retval = ehci_run (hcd);
+
+                /* here we "know" root ports should always stay powered;
+                 * but some controllers may lose all power.
+                 */
+                ehci_port_power (ehci, 1);
+        }
+
+        return retval;
+}
+#endif
+
+static const struct hc_driver ehci_pci_hc_driver = {
+        .description =          hcd_name,
+        .product_desc =         "EHCI Host Controller",
+        .hcd_priv_size =        sizeof(struct ehci_hcd),
+
+        /*
+         * generic hardware linkage
+         */
+        .irq =                  ehci_irq,
+        .flags =                HCD_MEMORY | HCD_USB2,
+
+        /*
+         * basic lifecycle operations
+         */
+        .reset =                ehci_pci_reset,
+        .start =                ehci_pci_start,
+#ifdef  CONFIG_PM
+        .suspend =              ehci_pci_suspend,
+        .resume =               ehci_pci_resume,
+#endif
+        .stop =                 ehci_pci_stop,
+
+        /*
+         * managing i/o requests and associated device resources
+         */
+        .urb_enqueue =          ehci_urb_enqueue,
+        .urb_dequeue =          ehci_urb_dequeue,
+        .endpoint_disable =     ehci_endpoint_disable,
+
+        /*
+         * scheduling support
+         */
+        .get_frame_number =     ehci_get_frame,
+
+        /*
+         * root hub support
+         */
+        .hub_status_data =      ehci_hub_status_data,
+        .hub_control =          ehci_hub_control,
+        .bus_suspend =          ehci_bus_suspend,
+        .bus_resume =           ehci_bus_resume,
+};
+
+/*-------------------------------------------------------------------------*/
+
+/* PCI driver selection metadata; PCI hotplugging uses this */
+static const struct pci_device_id pci_ids [] = { {
+        /* handle any USB 2.0 EHCI controller */
+        PCI_DEVICE_CLASS(((PCI_CLASS_SERIAL_USB << 8) | 0x20), ~0),
+        .driver_data =  (unsigned long) &ehci_pci_hc_driver,
+        },
+        { /* end: all zeroes */ }
+};
+MODULE_DEVICE_TABLE (pci, pci_ids);
+
+/* pci driver glue; this is a "new style" PCI driver module */
+static struct pci_driver ehci_pci_driver = {
+        .name =         (char *) hcd_name,
+        .id_table =     pci_ids,
+        .owner =        THIS_MODULE,
+
+        .probe =        usb_hcd_pci_probe,
+        .remove =       usb_hcd_pci_remove,
+
+#ifdef  CONFIG_PM
+        .suspend =      usb_hcd_pci_suspend,
+        .resume =       usb_hcd_pci_resume,
+#endif
+};
+
+static int __init ehci_hcd_pci_init (void)
+{
+        if (usb_disabled())
+                return -ENODEV;
+
+        pr_debug ("%s: block sizes: qh %Zd qtd %Zd itd %Zd sitd %Zd\n",
+                hcd_name,
+                sizeof (struct ehci_qh), sizeof (struct ehci_qtd),
+                sizeof (struct ehci_itd), sizeof (struct ehci_sitd));
+
+        return pci_register_driver (&ehci_pci_driver);
+}
+module_init (ehci_hcd_pci_init);
+
+static void __exit ehci_hcd_pci_cleanup (void)
+{
+        pci_unregister_driver (&ehci_pci_driver);
+}
+module_exit (ehci_hcd_pci_cleanup);
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index f34a0516d35f..18e257c2bdb5 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -97,6 +97,7 @@ struct ehci_hcd {			/* one per controller */
 #else
 #       define COUNT(x) do {} while (0)
 #endif
+        u8                      sbrn;           /* packed release number */
 };
 
 /* convert between an HCD pointer and the corresponding EHCI_HCD */ 
diff --git a/drivers/usb/host/isp116x-hcd.c b/drivers/usb/host/isp116x-hcd.c
index 642f35068ce2..ddb8fc591466 100644
--- a/drivers/usb/host/isp116x-hcd.c
+++ b/drivers/usb/host/isp116x-hcd.c
@@ -638,7 +638,7 @@ static irqreturn_t isp116x_irq(struct usb_hcd *hcd, struct pt_regs *regs)
                                   + msecs_to_jiffies(20) + 1);
                 if (intstat & HCINT_RD) {
                         DBG("---- remote wakeup\n");
-                        schedule_work(&isp116x->rh_resume);
+                        usb_hcd_resume_root_hub(hcd);
                         ret = IRQ_HANDLED;
                 }
                 irqstat &= ~HCuPINT_OPR;
@@ -1160,7 +1160,7 @@ static int isp116x_hub_control(struct usb_hcd *hcd,
 
 #ifdef  CONFIG_PM
 
-static int isp116x_hub_suspend(struct usb_hcd *hcd)
+static int isp116x_bus_suspend(struct usb_hcd *hcd)
 {
         struct isp116x *isp116x = hcd_to_isp116x(hcd);
         unsigned long flags;
@@ -1200,7 +1200,7 @@ static int isp116x_hub_suspend(struct usb_hcd *hcd)
         return ret;
 }
 
-static int isp116x_hub_resume(struct usb_hcd *hcd)
+static int isp116x_bus_resume(struct usb_hcd *hcd)
 {
         struct isp116x *isp116x = hcd_to_isp116x(hcd);
         u32 val;
@@ -1263,21 +1263,11 @@ static int isp116x_hub_resume(struct usb_hcd *hcd)
         return 0;
 }
 
-static void isp116x_rh_resume(void *_hcd)
-{
-        struct usb_hcd *hcd = _hcd;
-
-        usb_resume_device(hcd->self.root_hub);
-}
 
 #else
 
-#define isp116x_hub_suspend     NULL
-#define isp116x_hub_resume      NULL
-
-static void isp116x_rh_resume(void *_hcd)
-{
-}
+#define isp116x_bus_suspend     NULL
+#define isp116x_bus_resume      NULL
 
 #endif
 
@@ -1636,8 +1626,8 @@ static struct hc_driver isp116x_hc_driver = {
 
         .hub_status_data = isp116x_hub_status_data,
         .hub_control = isp116x_hub_control,
-        .hub_suspend = isp116x_hub_suspend,
-        .hub_resume = isp116x_hub_resume,
+        .bus_suspend = isp116x_bus_suspend,
+        .bus_resume = isp116x_bus_resume,
 };
 
 /*----------------------------------------------------------------*/
@@ -1732,7 +1722,6 @@ static int __init isp116x_probe(struct device *dev)
         isp116x->addr_reg = addr_reg;
         spin_lock_init(&isp116x->lock);
         INIT_LIST_HEAD(&isp116x->async);
-        INIT_WORK(&isp116x->rh_resume, isp116x_rh_resume, hcd);
         isp116x->board = dev->platform_data;
 
         if (!isp116x->board) {
@@ -1777,16 +1766,10 @@ static int __init isp116x_probe(struct device *dev)
 static int isp116x_suspend(struct device *dev, pm_message_t state)
 {
         int ret = 0;
-        struct usb_hcd *hcd = dev_get_drvdata(dev);
 
         VDBG("%s: state %x\n", __func__, state);
 
-        ret = usb_suspend_device(hcd->self.root_hub, state);
-        if (!ret) {
-                dev->power.power_state = state;
-                INFO("%s suspended\n", hcd_name);
-        } else
-                ERR("%s suspend failed\n", hcd_name);
+        dev->power.power_state = state;
 
         return ret;
 }
@@ -1797,15 +1780,11 @@ static int isp116x_suspend(struct device *dev, pm_message_t state)
 static int isp116x_resume(struct device *dev)
 {
         int ret = 0;
-        struct usb_hcd *hcd = dev_get_drvdata(dev);
 
         VDBG("%s:  state %x\n", __func__, dev->power.power_state);
 
-        ret = usb_resume_device(hcd->self.root_hub);
-        if (!ret) {
-                dev->power.power_state = PMSG_ON;
-                VDBG("%s resumed\n", (char *)hcd_name);
-        }
+        dev->power.power_state = PMSG_ON;
+
         return ret;
 }
 
diff --git a/drivers/usb/host/isp116x.h b/drivers/usb/host/isp116x.h
index 58873470dcf5..c6fec96785fe 100644
--- a/drivers/usb/host/isp116x.h
+++ b/drivers/usb/host/isp116x.h
@@ -253,7 +253,6 @@ static const int cc_to_error[16] = {
 
 struct isp116x {
         spinlock_t lock;
-        struct work_struct rh_resume;
 
         void __iomem *addr_reg;
         void __iomem *data_reg;
diff --git a/drivers/usb/host/ohci-au1xxx.c b/drivers/usb/host/ohci-au1xxx.c
index 3981bf15c8c7..a277e258eb6c 100644
--- a/drivers/usb/host/ohci-au1xxx.c
+++ b/drivers/usb/host/ohci-au1xxx.c
@@ -214,6 +214,11 @@ static const struct hc_driver ohci_au1xxx_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
+#ifdef  CONFIG_PM
+        .bus_suspend =          ohci_bus_suspend,
+        .bus_resume =           ohci_bus_resume,
+#endif
+        .start_port_reset =     ohci_start_port_reset,
 };
 
 /*-------------------------------------------------------------------------*/
@@ -259,6 +264,7 @@ static int ohci_hcd_au1xxx_drv_resume(struct device *dev)
 
 static struct device_driver ohci_hcd_au1xxx_driver = {
         .name           = "au1xxx-ohci",
+        .owner          = THIS_MODULE,
         .bus            = &platform_bus_type,
         .probe          = ohci_hcd_au1xxx_drv_probe,
         .remove         = ohci_hcd_au1xxx_drv_remove,
diff --git a/drivers/usb/host/ohci-dbg.c b/drivers/usb/host/ohci-dbg.c
index 7924c74f958e..7bfffcbbd226 100644
--- a/drivers/usb/host/ohci-dbg.c
+++ b/drivers/usb/host/ohci-dbg.c
@@ -193,10 +193,6 @@ ohci_dump_status (struct ohci_hcd *controller, char **next, unsigned *size)
 
         maybe_print_eds (controller, "donehead",
                         ohci_readl (controller, &regs->donehead), next, size);
-
-        /* broken fminterval means traffic won't flow! */ 
-        ohci_dbg (controller, "fminterval %08x\n", 
-                        ohci_readl (controller, &regs->fminterval));
 }
 
 #define dbg_port_sw(hc,num,value,next,size) \
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index f8da8c7af7c6..5c0c6c8a7a82 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -723,7 +723,7 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd, struct pt_regs *ptregs)
                 ohci_vdbg (ohci, "resume detect\n");
                 ohci_writel (ohci, OHCI_INTR_RD, &regs->intrstatus);
                 if (hcd->state != HC_STATE_QUIESCING)
-                        schedule_work(&ohci->rh_resume);
+                        usb_hcd_resume_root_hub(hcd);
         }
 
         if (ints & OHCI_INTR_WDH) {
@@ -791,7 +791,7 @@ static void ohci_stop (struct usb_hcd *hcd)
 
 /* must not be called from interrupt context */
 
-#if     defined(CONFIG_USB_SUSPEND) || defined(CONFIG_PM)
+#ifdef  CONFIG_PM
 
 static int ohci_restart (struct ohci_hcd *ohci)
 {
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index ce7b28da7a15..e01e77bc324b 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -36,7 +36,7 @@
 
 /*-------------------------------------------------------------------------*/
 
-#if     defined(CONFIG_USB_SUSPEND) || defined(CONFIG_PM)
+#ifdef  CONFIG_PM
 
 #define OHCI_SCHED_ENABLES \
         (OHCI_CTRL_CLE|OHCI_CTRL_BLE|OHCI_CTRL_PLE|OHCI_CTRL_IE)
@@ -45,7 +45,7 @@ static void dl_done_list (struct ohci_hcd *, struct pt_regs *);
 static void finish_unlinks (struct ohci_hcd *, u16 , struct pt_regs *);
 static int ohci_restart (struct ohci_hcd *ohci);
 
-static int ohci_hub_suspend (struct usb_hcd *hcd)
+static int ohci_bus_suspend (struct usb_hcd *hcd)
 {
         struct ohci_hcd         *ohci = hcd_to_ohci (hcd);
         int                     status = 0;
@@ -73,7 +73,6 @@ static int ohci_hub_suspend (struct usb_hcd *hcd)
         ohci_dbg (ohci, "suspend root hub\n");
 
         /* First stop any processing */
-        hcd->state = HC_STATE_QUIESCING;
         if (ohci->hc_control & OHCI_SCHED_ENABLES) {
                 int             limit;
 
@@ -108,7 +107,9 @@ static int ohci_hub_suspend (struct usb_hcd *hcd)
         else
                 ohci->hc_control &= ~OHCI_CTRL_RWE;
 
-        /* Suspend hub */
+        /* Suspend hub ... this is the "global (to this bus) suspend" mode,
+         * which doesn't imply ports will first be individually suspended.
+         */
         ohci->hc_control &= ~OHCI_CTRL_HCFS;
         ohci->hc_control |= OHCI_USB_SUSPEND;
         ohci_writel (ohci, ohci->hc_control, &ohci->regs->control);
@@ -118,8 +119,9 @@ static int ohci_hub_suspend (struct usb_hcd *hcd)
         ohci->next_statechange = jiffies + msecs_to_jiffies (5);
 
 done:
+        /* external suspend vs self autosuspend ... same effect */
         if (status == 0)
-                hcd->state = HC_STATE_SUSPENDED;
+                usb_hcd_suspend_root_hub(hcd);
         spin_unlock_irqrestore (&ohci->lock, flags);
         return status;
 }
@@ -133,7 +135,7 @@ static inline struct ed *find_head (struct ed *ed)
 }
 
 /* caller has locked the root hub */
-static int ohci_hub_resume (struct usb_hcd *hcd)
+static int ohci_bus_resume (struct usb_hcd *hcd)
 {
         struct ohci_hcd         *ohci = hcd_to_ohci (hcd);
         u32                     temp, enables;
@@ -146,7 +148,7 @@ static int ohci_hub_resume (struct usb_hcd *hcd)
         ohci->hc_control = ohci_readl (ohci, &ohci->regs->control);
 
         if (ohci->hc_control & (OHCI_CTRL_IR | OHCI_SCHED_ENABLES)) {
-                /* this can happen after suspend-to-disk */
+                /* this can happen after resuming a swsusp snapshot */
                 if (hcd->state == HC_STATE_RESUMING) {
                         ohci_dbg (ohci, "BIOS/SMM active, control %03x\n",
                                         ohci->hc_control);
@@ -169,11 +171,12 @@ static int ohci_hub_resume (struct usb_hcd *hcd)
                 ohci_info (ohci, "wakeup\n");
                 break;
         case OHCI_USB_OPER:
-                ohci_dbg (ohci, "already resumed\n");
-                status = 0;
+                /* this can happen after resuming a swsusp snapshot */
+                ohci_dbg (ohci, "snapshot resume? reinit\n");
+                status = -EBUSY;
                 break;
         default:                /* RESET, we lost power */
-                ohci_dbg (ohci, "root hub hardware reset\n");
+                ohci_dbg (ohci, "lost power\n");
                 status = -EBUSY;
         }
         spin_unlock_irq (&ohci->lock);
@@ -198,8 +201,7 @@ static int ohci_hub_resume (struct usb_hcd *hcd)
         }
 
         /* Some controllers (lucent erratum) need extra-long delays */
-        hcd->state = HC_STATE_RESUMING;
-        mdelay (20 /* usb 11.5.1.10 */ + 15);
+        msleep (20 /* usb 11.5.1.10 */ + 12 /* 32 msec counter */ + 1);
 
         temp = ohci_readl (ohci, &ohci->regs->control);
         temp &= OHCI_CTRL_HCFS;
@@ -273,28 +275,10 @@ static int ohci_hub_resume (struct usb_hcd *hcd)
                 (void) ohci_readl (ohci, &ohci->regs->control);
         }
 
-        hcd->state = HC_STATE_RUNNING;
         return 0;
 }
 
-static void ohci_rh_resume (void *_hcd)
-{
-        struct usb_hcd  *hcd = _hcd;
-
-        usb_lock_device (hcd->self.root_hub);
-        (void) ohci_hub_resume (hcd);
-        usb_unlock_device (hcd->self.root_hub);
-}
-
-#else
-
-static void ohci_rh_resume (void *_hcd)
-{
-        struct ohci_hcd *ohci = hcd_to_ohci (_hcd);
-        ohci_dbg(ohci, "rh_resume ??\n");
-}
-
-#endif  /* CONFIG_USB_SUSPEND || CONFIG_PM */
+#endif  /* CONFIG_PM */
 
 /*-------------------------------------------------------------------------*/
 
@@ -367,7 +351,6 @@ done:
 #ifdef CONFIG_PM
         /* save power by suspending idle root hubs;
          * INTR_RD wakes us when there's work
-         * NOTE: if we can do this, we don't need a root hub timer!
          */
         if (can_suspend
                         && !changed
@@ -379,8 +362,7 @@ done:
                         && usb_trylock_device (hcd->self.root_hub)
                         ) {
                 ohci_vdbg (ohci, "autosuspend\n");
-                (void) ohci_hub_suspend (hcd);
-                hcd->state = HC_STATE_RUNNING;
+                (void) ohci_bus_suspend (hcd);
                 usb_unlock_device (hcd->self.root_hub);
         }
 #endif
@@ -554,7 +536,7 @@ static int ohci_hub_control (
                         temp = RH_PS_POCI;
                         if ((ohci->hc_control & OHCI_CTRL_HCFS)
                                         != OHCI_USB_OPER)
-                                schedule_work (&ohci->rh_resume);
+                                usb_hcd_resume_root_hub(hcd);
                         break;
                 case USB_PORT_FEAT_C_SUSPEND:
                         temp = RH_PS_PSSC;
diff --git a/drivers/usb/host/ohci-lh7a404.c b/drivers/usb/host/ohci-lh7a404.c
index 859aca7be753..238fa4ade615 100644
--- a/drivers/usb/host/ohci-lh7a404.c
+++ b/drivers/usb/host/ohci-lh7a404.c
@@ -193,6 +193,11 @@ static const struct hc_driver ohci_lh7a404_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
+#ifdef  CONFIG_PM
+        .bus_suspend =          ohci_bus_suspend,
+        .bus_resume =           ohci_bus_resume,
+#endif
+        .start_port_reset =     ohci_start_port_reset,
 };
 
 /*-------------------------------------------------------------------------*/
@@ -239,6 +244,7 @@ static int ohci_hcd_lh7a404_drv_resume(struct device *dev)
 
 static struct device_driver ohci_hcd_lh7a404_driver = {
         .name           = "lh7a404-ohci",
+        .owner          = THIS_MODULE,
         .bus            = &platform_bus_type,
         .probe          = ohci_hcd_lh7a404_drv_probe,
         .remove         = ohci_hcd_lh7a404_drv_remove,
diff --git a/drivers/usb/host/ohci-mem.c b/drivers/usb/host/ohci-mem.c
index 9fb83dfb1eb4..bfbe328a4788 100644
--- a/drivers/usb/host/ohci-mem.c
+++ b/drivers/usb/host/ohci-mem.c
@@ -28,7 +28,6 @@ static void ohci_hcd_init (struct ohci_hcd *ohci)
         ohci->next_statechange = jiffies;
         spin_lock_init (&ohci->lock);
         INIT_LIST_HEAD (&ohci->pending);
-        INIT_WORK (&ohci->rh_resume, ohci_rh_resume, ohci_to_hcd(ohci));
         ohci->reboot_notifier.notifier_call = ohci_reboot;
 }
 
diff --git a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c
index a574216625a0..45efeed1fcc3 100644
--- a/drivers/usb/host/ohci-omap.c
+++ b/drivers/usb/host/ohci-omap.c
@@ -420,9 +420,9 @@ static const struct hc_driver ohci_omap_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
-#ifdef  CONFIG_USB_SUSPEND
-        .hub_suspend =          ohci_hub_suspend,
-        .hub_resume =           ohci_hub_resume,
+#ifdef  CONFIG_PM
+        .bus_suspend =          ohci_bus_suspend,
+        .bus_resume =           ohci_bus_resume,
 #endif
         .start_port_reset =     ohci_start_port_reset,
 };
@@ -458,41 +458,29 @@ static int ohci_hcd_omap_drv_remove(struct device *dev)
 static int ohci_omap_suspend(struct device *dev, pm_message_t message)
 {
         struct ohci_hcd *ohci = hcd_to_ohci(dev_get_drvdata(dev));
-        int             status = -EINVAL;
-
-        down(&ohci_to_hcd(ohci)->self.root_hub->serialize);
-        status = ohci_hub_suspend(ohci_to_hcd(ohci));
-        if (status == 0) {
-                omap_ohci_clock_power(0);
-                ohci_to_hcd(ohci)->self.root_hub->state =
-                        USB_STATE_SUSPENDED;
-                ohci_to_hcd(ohci)->state = HC_STATE_SUSPENDED;
-                dev->power.power_state = PMSG_SUSPEND;
-        }
-        up(&ohci_to_hcd(ohci)->self.root_hub->serialize);
-        return status;
+
+        if (time_before(jiffies, ohci->next_statechange))
+                msleep(5);
+        ohci->next_statechange = jiffies;
+
+        omap_ohci_clock_power(0);
+        ohci_to_hcd(ohci)->state = HC_STATE_SUSPENDED;
+        dev->power.power_state = PMSG_SUSPEND;
+        return 0;
 }
 
 static int ohci_omap_resume(struct device *dev)
 {
         struct ohci_hcd *ohci = hcd_to_ohci(dev_get_drvdata(dev));
-        int             status = 0;
 
         if (time_before(jiffies, ohci->next_statechange))
                 msleep(5);
         ohci->next_statechange = jiffies;
+
         omap_ohci_clock_power(1);
-#ifdef  CONFIG_USB_SUSPEND
-        /* get extra cleanup even if remote wakeup isn't in use */
-        status = usb_resume_device(ohci_to_hcd(ohci)->self.root_hub);
-#else
-        down(&ohci_to_hcd(ohci)->self.root_hub->serialize);
-        status = ohci_hub_resume(ohci_to_hcd(ohci));
-        up(&ohci_to_hcd(ohci)->self.root_hub->serialize);
-#endif
-        if (status == 0)
-                dev->power.power_state = PMSG_ON;
-        return status;
+        dev->power.power_state = PMSG_ON;
+        usb_hcd_resume_root_hub(dev_get_drvdata(dev));
+        return 0;
 }
 
 #endif
@@ -504,6 +492,7 @@ static int ohci_omap_resume(struct device *dev)
  */
 static struct device_driver ohci_hcd_omap_driver = {
         .name           = "ohci",
+        .owner          = THIS_MODULE,
         .bus            = &platform_bus_type,
         .probe          = ohci_hcd_omap_drv_probe,
         .remove         = ohci_hcd_omap_drv_remove,
diff --git a/drivers/usb/host/ohci-pci.c b/drivers/usb/host/ohci-pci.c
index eede6be098d2..bf1d5ab4aa3a 100644
--- a/drivers/usb/host/ohci-pci.c
+++ b/drivers/usb/host/ohci-pci.c
@@ -112,23 +112,13 @@ ohci_pci_start (struct usb_hcd *hcd)
 
 static int ohci_pci_suspend (struct usb_hcd *hcd, pm_message_t message)
 {
-        struct ohci_hcd         *ohci = hcd_to_ohci (hcd);
-
-        /* suspend root hub, hoping it keeps power during suspend */
-        if (time_before (jiffies, ohci->next_statechange))
-                msleep (100);
-
-#ifdef  CONFIG_USB_SUSPEND
-        (void) usb_suspend_device (hcd->self.root_hub, message);
-#else
-        usb_lock_device (hcd->self.root_hub);
-        (void) ohci_hub_suspend (hcd);
-        usb_unlock_device (hcd->self.root_hub);
-#endif
+        /* root hub was already suspended */
 
-        /* let things settle down a bit */
-        msleep (100);
-        
+        /* FIXME these PMAC things get called in the wrong places.  ASIC
+         * clocks should be turned off AFTER entering D3, and on BEFORE
+         * trying to enter D0.  Evidently the PCI layer doesn't currently
+         * provide the right sort of platform hooks for this ...
+         */
 #ifdef CONFIG_PPC_PMAC
         if (_machine == _MACH_Pmac) {
                 struct device_node      *of_node;
@@ -145,9 +135,6 @@ static int ohci_pci_suspend (struct usb_hcd *hcd, pm_message_t message)
 
 static int ohci_pci_resume (struct usb_hcd *hcd)
 {
-        struct ohci_hcd         *ohci = hcd_to_ohci (hcd);
-        int                     retval = 0;
-
 #ifdef CONFIG_PPC_PMAC
         if (_machine == _MACH_Pmac) {
                 struct device_node *of_node;
@@ -159,19 +146,8 @@ static int ohci_pci_resume (struct usb_hcd *hcd)
         }
 #endif /* CONFIG_PPC_PMAC */
 
-        /* resume root hub */
-        if (time_before (jiffies, ohci->next_statechange))
-                msleep (100);
-#ifdef  CONFIG_USB_SUSPEND
-        /* get extra cleanup even if remote wakeup isn't in use */
-        retval = usb_resume_device (hcd->self.root_hub);
-#else
-        usb_lock_device (hcd->self.root_hub);
-        retval = ohci_hub_resume (hcd);
-        usb_unlock_device (hcd->self.root_hub);
-#endif
-
-        return retval;
+        usb_hcd_resume_root_hub(hcd);
+        return 0;
 }
 
 #endif  /* CONFIG_PM */
@@ -218,9 +194,9 @@ static const struct hc_driver ohci_pci_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
-#ifdef  CONFIG_USB_SUSPEND
-        .hub_suspend =          ohci_hub_suspend,
-        .hub_resume =           ohci_hub_resume,
+#ifdef  CONFIG_PM
+        .bus_suspend =          ohci_bus_suspend,
+        .bus_resume =           ohci_bus_resume,
 #endif
         .start_port_reset =     ohci_start_port_reset,
 };
@@ -240,6 +216,7 @@ MODULE_DEVICE_TABLE (pci, pci_ids);
 static struct pci_driver ohci_pci_driver = {
         .name =         (char *) hcd_name,
         .id_table =     pci_ids,
+        .owner =        THIS_MODULE,
 
         .probe =        usb_hcd_pci_probe,
         .remove =       usb_hcd_pci_remove,
diff --git a/drivers/usb/host/ohci-ppc-soc.c b/drivers/usb/host/ohci-ppc-soc.c
index 251533363028..4832e57ae579 100644
--- a/drivers/usb/host/ohci-ppc-soc.c
+++ b/drivers/usb/host/ohci-ppc-soc.c
@@ -163,9 +163,9 @@ static const struct hc_driver ohci_ppc_soc_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
-#ifdef  CONFIG_USB_SUSPEND
-        .hub_suspend =          ohci_hub_suspend,
-        .hub_resume =           ohci_hub_resume,
+#ifdef  CONFIG_PM
+        .bus_suspend =          ohci_bus_suspend,
+        .bus_resume =           ohci_bus_resume,
 #endif
         .start_port_reset =     ohci_start_port_reset,
 };
@@ -193,10 +193,11 @@ static int ohci_hcd_ppc_soc_drv_remove(struct device *dev)
 
 static struct device_driver ohci_hcd_ppc_soc_driver = {
         .name           = "ppc-soc-ohci",
+        .owner          = THIS_MODULE,
         .bus            = &platform_bus_type,
         .probe          = ohci_hcd_ppc_soc_drv_probe,
         .remove         = ohci_hcd_ppc_soc_drv_remove,
-#if     defined(CONFIG_USB_SUSPEND) || defined(CONFIG_PM)
+#ifdef  CONFIG_PM
         /*.suspend      = ohci_hcd_ppc_soc_drv_suspend,*/
         /*.resume       = ohci_hcd_ppc_soc_drv_resume,*/
 #endif
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index f042261ecb8e..d287dcccd415 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -278,10 +278,11 @@ static const struct hc_driver ohci_pxa27x_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
-#ifdef  CONFIG_USB_SUSPEND
-        .hub_suspend =          ohci_hub_suspend,
-        .hub_resume =           ohci_hub_resume,
+#ifdef  CONFIG_PM
+        .bus_suspend =          ohci_bus_suspend,
+        .bus_resume =           ohci_bus_resume,
 #endif
+        .start_port_reset =     ohci_start_port_reset,
 };
 
 /*-------------------------------------------------------------------------*/
diff --git a/drivers/usb/host/ohci-s3c2410.c b/drivers/usb/host/ohci-s3c2410.c
index da7d5478f74d..fab420a2ce71 100644
--- a/drivers/usb/host/ohci-s3c2410.c
+++ b/drivers/usb/host/ohci-s3c2410.c
@@ -448,11 +448,11 @@ static const struct hc_driver ohci_s3c2410_hc_driver = {
          */
         .hub_status_data =      ohci_s3c2410_hub_status_data,
         .hub_control =          ohci_s3c2410_hub_control,
-
-#if defined(CONFIG_USB_SUSPEND) && 0
-        .hub_suspend =          ohci_hub_suspend,
-        .hub_resume =           ohci_hub_resume,
+#ifdef  CONFIG_PM
+        .bus_suspend =          ohci_bus_suspend,
+        .bus_resume =           ohci_bus_resume,
 #endif
+        .start_port_reset =     ohci_start_port_reset,
 };
 
 /* device driver */
@@ -474,6 +474,7 @@ static int ohci_hcd_s3c2410_drv_remove(struct device *dev)
 
 static struct device_driver ohci_hcd_s3c2410_driver = {
         .name           = "s3c2410-ohci",
+        .owner          = THIS_MODULE,
         .bus            = &platform_bus_type,
         .probe          = ohci_hcd_s3c2410_drv_probe,
         .remove         = ohci_hcd_s3c2410_drv_remove,
diff --git a/drivers/usb/host/ohci-sa1111.c b/drivers/usb/host/ohci-sa1111.c
index 814d2be4ee7b..fb3221ebbb29 100644
--- a/drivers/usb/host/ohci-sa1111.c
+++ b/drivers/usb/host/ohci-sa1111.c
@@ -235,10 +235,11 @@ static const struct hc_driver ohci_sa1111_hc_driver = {
          */
         .hub_status_data =      ohci_hub_status_data,
         .hub_control =          ohci_hub_control,
-#ifdef  CONFIG_USB_SUSPEND
-        .hub_suspend =          ohci_hub_suspend,
-        .hub_resume =           ohci_hub_resume,
+#ifdef  CONFIG_PM
+        .bus_suspend =          ohci_bus_suspend,
+        .bus_resume =           ohci_bus_resume,
 #endif
+        .start_port_reset =     ohci_start_port_reset,
 };
 
 /*-------------------------------------------------------------------------*/
diff --git a/drivers/usb/host/ohci.h b/drivers/usb/host/ohci.h
index 8a9b9d9209e9..caacf14371f5 100644
--- a/drivers/usb/host/ohci.h
+++ b/drivers/usb/host/ohci.h
@@ -389,7 +389,6 @@ struct ohci_hcd {
         unsigned long           next_statechange;       /* suspend/resume */
         u32                     fminterval;             /* saved register */
 
-        struct work_struct      rh_resume;
         struct notifier_block   reboot_notifier;
 
         unsigned long           flags;          /* for HC bugs */
diff --git a/drivers/usb/host/pci-quirks.c b/drivers/usb/host/pci-quirks.c
new file mode 100644
index 000000000000..b7fd3f644e1e
--- /dev/null
+++ b/drivers/usb/host/pci-quirks.c
@@ -0,0 +1,296 @@
+/*
+ * This file contains code to reset and initialize USB host controllers.
+ * Some of it includes work-arounds for PCI hardware and BIOS quirks.
+ * It may need to run early during booting -- before USB would normally
+ * initialize -- to ensure that Linux doesn't use any legacy modes.
+ *
+ *  Copyright (c) 1999 Martin Mares <mj@ucw.cz>
+ *  (and others)
+ */
+
+#include <linux/config.h>
+#ifdef CONFIG_USB_DEBUG
+#define DEBUG
+#else
+#undef DEBUG
+#endif
+
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/acpi.h>
+
+
+#define UHCI_USBLEGSUP          0xc0            /* legacy support */
+#define UHCI_USBCMD             0               /* command register */
+#define UHCI_USBINTR            4               /* interrupt register */
+#define UHCI_USBLEGSUP_RWC      0x8f00          /* the R/WC bits */
+#define UHCI_USBLEGSUP_RO       0x5040          /* R/O and reserved bits */
+#define UHCI_USBCMD_RUN         0x0001          /* RUN/STOP bit */
+#define UHCI_USBCMD_HCRESET     0x0002          /* Host Controller reset */
+#define UHCI_USBCMD_EGSM        0x0008          /* Global Suspend Mode */
+#define UHCI_USBCMD_CONFIGURE   0x0040          /* Config Flag */
+#define UHCI_USBINTR_RESUME     0x0002          /* Resume interrupt enable */
+
+#define OHCI_CONTROL            0x04
+#define OHCI_CMDSTATUS          0x08
+#define OHCI_INTRSTATUS         0x0c
+#define OHCI_INTRENABLE         0x10
+#define OHCI_INTRDISABLE        0x14
+#define OHCI_OCR                (1 << 3)        /* ownership change request */
+#define OHCI_CTRL_RWC           (1 << 9)        /* remote wakeup connected */
+#define OHCI_CTRL_IR            (1 << 8)        /* interrupt routing */
+#define OHCI_INTR_OC            (1 << 30)       /* ownership change */
+
+#define EHCI_HCC_PARAMS         0x08            /* extended capabilities */
+#define EHCI_USBCMD             0               /* command register */
+#define EHCI_USBCMD_RUN         (1 << 0)        /* RUN/STOP bit */
+#define EHCI_USBSTS             4               /* status register */
+#define EHCI_USBSTS_HALTED      (1 << 12)       /* HCHalted bit */
+#define EHCI_USBINTR            8               /* interrupt register */
+#define EHCI_USBLEGSUP          0               /* legacy support register */
+#define EHCI_USBLEGSUP_BIOS     (1 << 16)       /* BIOS semaphore */
+#define EHCI_USBLEGSUP_OS       (1 << 24)       /* OS semaphore */
+#define EHCI_USBLEGCTLSTS       4               /* legacy control/status */
+#define EHCI_USBLEGCTLSTS_SOOE  (1 << 13)       /* SMI on ownership change */
+
+
+/*
+ * Make sure the controller is completely inactive, unable to
+ * generate interrupts or do DMA.
+ */
+void uhci_reset_hc(struct pci_dev *pdev, unsigned long base)
+{
+        /* Turn off PIRQ enable and SMI enable.  (This also turns off the
+         * BIOS's USB Legacy Support.)  Turn off all the R/WC bits too.
+         */
+        pci_write_config_word(pdev, UHCI_USBLEGSUP, UHCI_USBLEGSUP_RWC);
+
+        /* Reset the HC - this will force us to get a
+         * new notification of any already connected
+         * ports due to the virtual disconnect that it
+         * implies.
+         */
+        outw(UHCI_USBCMD_HCRESET, base + UHCI_USBCMD);
+        mb();
+        udelay(5);
+        if (inw(base + UHCI_USBCMD) & UHCI_USBCMD_HCRESET)
+                dev_warn(&pdev->dev, "HCRESET not completed yet!\n");
+
+        /* Just to be safe, disable interrupt requests and
+         * make sure the controller is stopped.
+         */
+        outw(0, base + UHCI_USBINTR);
+        outw(0, base + UHCI_USBCMD);
+}
+EXPORT_SYMBOL_GPL(uhci_reset_hc);
+
+/*
+ * Initialize a controller that was newly discovered or has just been
+ * resumed.  In either case we can't be sure of its previous state.
+ *
+ * Returns: 1 if the controller was reset, 0 otherwise.
+ */
+int uhci_check_and_reset_hc(struct pci_dev *pdev, unsigned long base)
+{
+        u16 legsup;
+        unsigned int cmd, intr;
+
+        /*
+         * When restarting a suspended controller, we expect all the
+         * settings to be the same as we left them:
+         *
+         *      PIRQ and SMI disabled, no R/W bits set in USBLEGSUP;
+         *      Controller is stopped and configured with EGSM set;
+         *      No interrupts enabled except possibly Resume Detect.
+         *
+         * If any of these conditions are violated we do a complete reset.
+         */
+        pci_read_config_word(pdev, UHCI_USBLEGSUP, &legsup);
+        if (legsup & ~(UHCI_USBLEGSUP_RO | UHCI_USBLEGSUP_RWC)) {
+                dev_dbg(&pdev->dev, "%s: legsup = 0x%04x\n",
+                                __FUNCTION__, legsup);
+                goto reset_needed;
+        }
+
+        cmd = inw(base + UHCI_USBCMD);
+        if ((cmd & UHCI_USBCMD_RUN) || !(cmd & UHCI_USBCMD_CONFIGURE) ||
+                        !(cmd & UHCI_USBCMD_EGSM)) {
+                dev_dbg(&pdev->dev, "%s: cmd = 0x%04x\n",
+                                __FUNCTION__, cmd);
+                goto reset_needed;
+        }
+
+        intr = inw(base + UHCI_USBINTR);
+        if (intr & (~UHCI_USBINTR_RESUME)) {
+                dev_dbg(&pdev->dev, "%s: intr = 0x%04x\n",
+                                __FUNCTION__, intr);
+                goto reset_needed;
+        }
+        return 0;
+
+reset_needed:
+        dev_dbg(&pdev->dev, "Performing full reset\n");
+        uhci_reset_hc(pdev, base);
+        return 1;
+}
+EXPORT_SYMBOL_GPL(uhci_check_and_reset_hc);
+
+static void __devinit quirk_usb_handoff_uhci(struct pci_dev *pdev)
+{
+        unsigned long base = 0;
+        int i;
+
+        for (i = 0; i < PCI_ROM_RESOURCE; i++)
+                if ((pci_resource_flags(pdev, i) & IORESOURCE_IO)) {
+                        base = pci_resource_start(pdev, i);
+                        break;
+                }
+
+        if (base)
+                uhci_check_and_reset_hc(pdev, base);
+}
+
+static void __devinit quirk_usb_handoff_ohci(struct pci_dev *pdev)
+{
+        void __iomem *base;
+        int wait_time;
+        u32 control;
+
+        base = ioremap_nocache(pci_resource_start(pdev, 0),
+                                     pci_resource_len(pdev, 0));
+        if (base == NULL) return;
+
+/* On PA-RISC, PDC can leave IR set incorrectly; ignore it there. */
+#ifndef __hppa__
+        control = readl(base + OHCI_CONTROL);
+        if (control & OHCI_CTRL_IR) {
+                wait_time = 500; /* arbitrary; 5 seconds */
+                writel(OHCI_INTR_OC, base + OHCI_INTRENABLE);
+                writel(OHCI_OCR, base + OHCI_CMDSTATUS);
+                while (wait_time > 0 &&
+                                readl(base + OHCI_CONTROL) & OHCI_CTRL_IR) {
+                        wait_time -= 10;
+                        msleep(10);
+                }
+                if (wait_time <= 0)
+                        printk(KERN_WARNING "%s %s: early BIOS handoff "
+                                        "failed (BIOS bug ?)\n",
+                                        pdev->dev.bus_id, "OHCI");
+
+                /* reset controller, preserving RWC */
+                writel(control & OHCI_CTRL_RWC, base + OHCI_CONTROL);
+        }
+#endif
+
+        /*
+         * disable interrupts
+         */
+        writel(~(u32)0, base + OHCI_INTRDISABLE);
+        writel(~(u32)0, base + OHCI_INTRSTATUS);
+
+        iounmap(base);
+}
+
+static void __devinit quirk_usb_disable_ehci(struct pci_dev *pdev)
+{
+        int wait_time, delta;
+        void __iomem *base, *op_reg_base;
+        u32 hcc_params, val, temp;
+        u8 cap_length;
+
+        base = ioremap_nocache(pci_resource_start(pdev, 0),
+                                pci_resource_len(pdev, 0));
+        if (base == NULL) return;
+
+        cap_length = readb(base);
+        op_reg_base = base + cap_length;
+        hcc_params = readl(base + EHCI_HCC_PARAMS);
+        hcc_params = (hcc_params >> 8) & 0xff;
+        if (hcc_params) {
+                pci_read_config_dword(pdev,
+                                        hcc_params + EHCI_USBLEGSUP,
+                                        &val);
+                if (((val & 0xff) == 1) && (val & EHCI_USBLEGSUP_BIOS)) {
+                        /*
+                         * Ok, BIOS is in smm mode, try to hand off...
+                         */
+                        pci_read_config_dword(pdev,
+                                                hcc_params + EHCI_USBLEGCTLSTS,
+                                                &temp);
+                        pci_write_config_dword(pdev,
+                                                hcc_params + EHCI_USBLEGCTLSTS,
+                                                temp | EHCI_USBLEGCTLSTS_SOOE);
+                        val |= EHCI_USBLEGSUP_OS;
+                        pci_write_config_dword(pdev,
+                                                hcc_params + EHCI_USBLEGSUP,
+                                                val);
+
+                        wait_time = 500;
+                        do {
+                                msleep(10);
+                                wait_time -= 10;
+                                pci_read_config_dword(pdev,
+                                                hcc_params + EHCI_USBLEGSUP,
+                                                &val);
+                        } while (wait_time && (val & EHCI_USBLEGSUP_BIOS));
+                        if (!wait_time) {
+                                /*
+                                 * well, possibly buggy BIOS...
+                                 */
+                                printk(KERN_WARNING "%s %s: early BIOS handoff "
+                                                "failed (BIOS bug ?)\n",
+                                        pdev->dev.bus_id, "EHCI");
+                                pci_write_config_dword(pdev,
+                                                hcc_params + EHCI_USBLEGSUP,
+                                                EHCI_USBLEGSUP_OS);
+                                pci_write_config_dword(pdev,
+                                                hcc_params + EHCI_USBLEGCTLSTS,
+                                                0);
+                        }
+                }
+        }
+
+        /*
+         * halt EHCI & disable its interrupts in any case
+         */
+        val = readl(op_reg_base + EHCI_USBSTS);
+        if ((val & EHCI_USBSTS_HALTED) == 0) {
+                val = readl(op_reg_base + EHCI_USBCMD);
+                val &= ~EHCI_USBCMD_RUN;
+                writel(val, op_reg_base + EHCI_USBCMD);
+
+                wait_time = 2000;
+                delta = 100;
+                do {
+                        writel(0x3f, op_reg_base + EHCI_USBSTS);
+                        udelay(delta);
+                        wait_time -= delta;
+                        val = readl(op_reg_base + EHCI_USBSTS);
+                        if ((val == ~(u32)0) || (val & EHCI_USBSTS_HALTED)) {
+                                break;
+                        }
+                } while (wait_time > 0);
+        }
+        writel(0, op_reg_base + EHCI_USBINTR);
+        writel(0x3f, op_reg_base + EHCI_USBSTS);
+
+        iounmap(base);
+
+        return;
+}
+
+
+
+static void __devinit quirk_usb_early_handoff(struct pci_dev *pdev)
+{
+        if (pdev->class == PCI_CLASS_SERIAL_USB_UHCI)
+                quirk_usb_handoff_uhci(pdev);
+        else if (pdev->class == PCI_CLASS_SERIAL_USB_OHCI)
+                quirk_usb_handoff_ohci(pdev);
+        else if (pdev->class == PCI_CLASS_SERIAL_USB_EHCI)
+                quirk_usb_disable_ehci(pdev);
+}
+DECLARE_PCI_FIXUP_HEADER(PCI_ANY_ID, PCI_ANY_ID, quirk_usb_early_handoff);
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index b5e7a478bc01..40169d9cf2b1 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -1363,7 +1363,7 @@ error:
 #ifdef  CONFIG_PM
 
 static int
-sl811h_hub_suspend(struct usb_hcd *hcd)
+sl811h_bus_suspend(struct usb_hcd *hcd)
 {
         // SOFs off
         DBG("%s\n", __FUNCTION__);
@@ -1371,7 +1371,7 @@ sl811h_hub_suspend(struct usb_hcd *hcd)
 }
 
 static int
-sl811h_hub_resume(struct usb_hcd *hcd)
+sl811h_bus_resume(struct usb_hcd *hcd)
 {
         // SOFs on
         DBG("%s\n", __FUNCTION__);
@@ -1380,8 +1380,8 @@ sl811h_hub_resume(struct usb_hcd *hcd)
 
 #else
 
-#define sl811h_hub_suspend      NULL
-#define sl811h_hub_resume       NULL
+#define sl811h_bus_suspend      NULL
+#define sl811h_bus_resume       NULL
 
 #endif
 
@@ -1623,8 +1623,8 @@ static struct hc_driver sl811h_hc_driver = {
          */
         .hub_status_data =      sl811h_hub_status_data,
         .hub_control =          sl811h_hub_control,
-        .hub_suspend =          sl811h_hub_suspend,
-        .hub_resume =           sl811h_hub_resume,
+        .bus_suspend =          sl811h_bus_suspend,
+        .bus_resume =           sl811h_bus_resume,
 };
 
 /*-------------------------------------------------------------------------*/
@@ -1791,7 +1791,7 @@ sl811h_suspend(struct device *dev, pm_message_t state)
         int             retval = 0;
 
         if (state.event == PM_EVENT_FREEZE)
-                retval = sl811h_hub_suspend(hcd);
+                retval = sl811h_bus_suspend(hcd);
         else if (state.event == PM_EVENT_SUSPEND)
                 port_power(sl811, 0);
         if (retval == 0)
@@ -1816,7 +1816,7 @@ sl811h_resume(struct device *dev)
         }
 
         dev->power.power_state = PMSG_ON;
-        return sl811h_hub_resume(hcd);
+        return sl811h_bus_resume(hcd);
 }
 
 #else
@@ -1831,6 +1831,7 @@ sl811h_resume(struct device *dev)
 struct device_driver sl811h_driver = {
         .name =         (char *) hcd_name,
         .bus =          &platform_bus_type,
+        .owner =        THIS_MODULE,
 
         .probe =        sl811h_probe,
         .remove =       __devexit_p(sl811h_remove),
diff --git a/drivers/usb/host/uhci-debug.c b/drivers/usb/host/uhci-debug.c
index 4538a98b6f9d..151154df37fa 100644
--- a/drivers/usb/host/uhci-debug.c
+++ b/drivers/usb/host/uhci-debug.c
@@ -348,7 +348,6 @@ static int uhci_show_urbp(struct uhci_hcd *uhci, struct urb_priv *urbp, char *bu
 
         if (urbp->urb->status != -EINPROGRESS)
                 out += sprintf(out, "Status=%d ", urbp->urb->status);
-        //out += sprintf(out, "Inserttime=%lx ",urbp->inserttime);
         //out += sprintf(out, "FSBRtime=%lx ",urbp->fsbrtime);
 
         count = 0;
@@ -446,11 +445,11 @@ static int uhci_sprint_schedule(struct uhci_hcd *uhci, char *buf, int len)
         out += sprintf(out, "Frame List\n");
         for (i = 0; i < UHCI_NUMFRAMES; ++i) {
                 int shown = 0;
-                td = uhci->fl->frame_cpu[i];
+                td = uhci->frame_cpu[i];
                 if (!td)
                         continue;
 
-                if (td->dma_handle != (dma_addr_t)uhci->fl->frame[i]) {
+                if (td->dma_handle != (dma_addr_t)uhci->frame[i]) {
                         show_frame_num();
                         out += sprintf(out, "    frame list does not match td->dma_handle!\n");
                 }
diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c
index 0c024898cbea..15e0a511069b 100644
--- a/drivers/usb/host/uhci-hcd.c
+++ b/drivers/usb/host/uhci-hcd.c
@@ -101,37 +101,16 @@ static void uhci_get_current_frame_number(struct uhci_hcd *uhci);
 #include "uhci-q.c"
 #include "uhci-hub.c"
 
+extern void uhci_reset_hc(struct pci_dev *pdev, unsigned long base);
+extern int uhci_check_and_reset_hc(struct pci_dev *pdev, unsigned long base);
+
 /*
- * Make sure the controller is completely inactive, unable to
- * generate interrupts or do DMA.
+ * Finish up a host controller reset and update the recorded state.
  */
-static void reset_hc(struct uhci_hcd *uhci)
+static void finish_reset(struct uhci_hcd *uhci)
 {
         int port;
 
-        /* Turn off PIRQ enable and SMI enable.  (This also turns off the
-         * BIOS's USB Legacy Support.)  Turn off all the R/WC bits too.
-         */
-        pci_write_config_word(to_pci_dev(uhci_dev(uhci)), USBLEGSUP,
-                        USBLEGSUP_RWC);
-
-        /* Reset the HC - this will force us to get a
-         * new notification of any already connected
-         * ports due to the virtual disconnect that it
-         * implies.
-         */
-        outw(USBCMD_HCRESET, uhci->io_addr + USBCMD);
-        mb();
-        udelay(5);
-        if (inw(uhci->io_addr + USBCMD) & USBCMD_HCRESET)
-                dev_warn(uhci_dev(uhci), "HCRESET not completed yet!\n");
-
-        /* Just to be safe, disable interrupt requests and
-         * make sure the controller is stopped.
-         */
-        outw(0, uhci->io_addr + USBINTR);
-        outw(0, uhci->io_addr + USBCMD);
-
         /* HCRESET doesn't affect the Suspend, Reset, and Resume Detect
          * bits in the port status and control registers.
          * We have to clear them by hand.
@@ -153,7 +132,8 @@ static void reset_hc(struct uhci_hcd *uhci)
  */
 static void hc_died(struct uhci_hcd *uhci)
 {
-        reset_hc(uhci);
+        uhci_reset_hc(to_pci_dev(uhci_dev(uhci)), uhci->io_addr);
+        finish_reset(uhci);
         uhci->hc_inaccessible = 1;
 }
 
@@ -163,44 +143,8 @@ static void hc_died(struct uhci_hcd *uhci)
  */
 static void check_and_reset_hc(struct uhci_hcd *uhci)
 {
-        u16 legsup;
-        unsigned int cmd, intr;
-
-        /*
-         * When restarting a suspended controller, we expect all the
-         * settings to be the same as we left them:
-         *
-         *      PIRQ and SMI disabled, no R/W bits set in USBLEGSUP;
-         *      Controller is stopped and configured with EGSM set;
-         *      No interrupts enabled except possibly Resume Detect.
-         *
-         * If any of these conditions are violated we do a complete reset.
-         */
-        pci_read_config_word(to_pci_dev(uhci_dev(uhci)), USBLEGSUP, &legsup);
-        if (legsup & ~(USBLEGSUP_RO | USBLEGSUP_RWC)) {
-                dev_dbg(uhci_dev(uhci), "%s: legsup = 0x%04x\n",
-                                __FUNCTION__, legsup);
-                goto reset_needed;
-        }
-
-        cmd = inw(uhci->io_addr + USBCMD);
-        if ((cmd & USBCMD_RS) || !(cmd & USBCMD_CF) || !(cmd & USBCMD_EGSM)) {
-                dev_dbg(uhci_dev(uhci), "%s: cmd = 0x%04x\n",
-                                __FUNCTION__, cmd);
-                goto reset_needed;
-        }
-
-        intr = inw(uhci->io_addr + USBINTR);
-        if (intr & (~USBINTR_RESUME)) {
-                dev_dbg(uhci_dev(uhci), "%s: intr = 0x%04x\n",
-                                __FUNCTION__, intr);
-                goto reset_needed;
-        }
-        return;
-
-reset_needed:
-        dev_dbg(uhci_dev(uhci), "Performing full reset\n");
-        reset_hc(uhci);
+        if (uhci_check_and_reset_hc(to_pci_dev(uhci_dev(uhci)), uhci->io_addr))
+                finish_reset(uhci);
 }
 
 /*
@@ -212,13 +156,13 @@ static void configure_hc(struct uhci_hcd *uhci)
         outb(USBSOF_DEFAULT, uhci->io_addr + USBSOF);
 
         /* Store the frame list base address */
-        outl(uhci->fl->dma_handle, uhci->io_addr + USBFLBASEADD);
+        outl(uhci->frame_dma_handle, uhci->io_addr + USBFLBASEADD);
 
         /* Set the current frame number */
         outw(uhci->frame_number, uhci->io_addr + USBFRNUM);
 
-        /* Mark controller as running before we enable interrupts */
-        uhci_to_hcd(uhci)->state = HC_STATE_RUNNING;
+        /* Mark controller as not halted before we enable interrupts */
+        uhci_to_hcd(uhci)->state = HC_STATE_SUSPENDED;
         mb();
 
         /* Enable PIRQ */
@@ -319,6 +263,7 @@ __acquires(uhci->lock)
 
 static void start_rh(struct uhci_hcd *uhci)
 {
+        uhci_to_hcd(uhci)->state = HC_STATE_RUNNING;
         uhci->is_stopped = 0;
         smp_wmb();
 
@@ -437,36 +382,21 @@ static void release_uhci(struct uhci_hcd *uhci)
         int i;
 
         for (i = 0; i < UHCI_NUM_SKELQH; i++)
-                if (uhci->skelqh[i]) {
-                        uhci_free_qh(uhci, uhci->skelqh[i]);
-                        uhci->skelqh[i] = NULL;
-                }
+                uhci_free_qh(uhci, uhci->skelqh[i]);
 
-        if (uhci->term_td) {
-                uhci_free_td(uhci, uhci->term_td);
-                uhci->term_td = NULL;
-        }
+        uhci_free_td(uhci, uhci->term_td);
 
-        if (uhci->qh_pool) {
-                dma_pool_destroy(uhci->qh_pool);
-                uhci->qh_pool = NULL;
-        }
+        dma_pool_destroy(uhci->qh_pool);
 
-        if (uhci->td_pool) {
-                dma_pool_destroy(uhci->td_pool);
-                uhci->td_pool = NULL;
-        }
+        dma_pool_destroy(uhci->td_pool);
 
-        if (uhci->fl) {
-                dma_free_coherent(uhci_dev(uhci), sizeof(*uhci->fl),
-                                uhci->fl, uhci->fl->dma_handle);
-                uhci->fl = NULL;
-        }
+        kfree(uhci->frame_cpu);
 
-        if (uhci->dentry) {
-                debugfs_remove(uhci->dentry);
-                uhci->dentry = NULL;
-        }
+        dma_free_coherent(uhci_dev(uhci),
+                        UHCI_NUMFRAMES * sizeof(*uhci->frame),
+                        uhci->frame, uhci->frame_dma_handle);
+
+        debugfs_remove(uhci->dentry);
 }
 
 static int uhci_reset(struct usb_hcd *hcd)
@@ -545,7 +475,6 @@ static int uhci_start(struct usb_hcd *hcd)
         struct uhci_hcd *uhci = hcd_to_uhci(hcd);
         int retval = -EBUSY;
         int i;
-        dma_addr_t dma_handle;
         struct dentry *dentry;
 
         hcd->uses_new_polling = 1;
@@ -579,17 +508,23 @@ static int uhci_start(struct usb_hcd *hcd)
 
         init_waitqueue_head(&uhci->waitqh);
 
-        uhci->fl = dma_alloc_coherent(uhci_dev(uhci), sizeof(*uhci->fl),
-                        &dma_handle, 0);
-        if (!uhci->fl) {
+        uhci->frame = dma_alloc_coherent(uhci_dev(uhci),
+                        UHCI_NUMFRAMES * sizeof(*uhci->frame),
+                        &uhci->frame_dma_handle, 0);
+        if (!uhci->frame) {
                 dev_err(uhci_dev(uhci), "unable to allocate "
                                 "consistent memory for frame list\n");
-                goto err_alloc_fl;
+                goto err_alloc_frame;
         }
+        memset(uhci->frame, 0, UHCI_NUMFRAMES * sizeof(*uhci->frame));
 
-        memset((void *)uhci->fl, 0, sizeof(*uhci->fl));
-
-        uhci->fl->dma_handle = dma_handle;
+        uhci->frame_cpu = kcalloc(UHCI_NUMFRAMES, sizeof(*uhci->frame_cpu),
+                        GFP_KERNEL);
+        if (!uhci->frame_cpu) {
+                dev_err(uhci_dev(uhci), "unable to allocate "
+                                "memory for frame pointers\n");
+                goto err_alloc_frame_cpu;
+        }
 
         uhci->td_pool = dma_pool_create("uhci_td", uhci_dev(uhci),
                         sizeof(struct uhci_td), 16, 0);
@@ -672,7 +607,7 @@ static int uhci_start(struct usb_hcd *hcd)
                         irq = 7;
 
                 /* Only place we don't use the frame list routines */
-                uhci->fl->frame[i] = UHCI_PTR_QH |
+                uhci->frame[i] = UHCI_PTR_QH |
                                 cpu_to_le32(uhci->skelqh[irq]->dma_handle);
         }
 
@@ -690,31 +625,29 @@ static int uhci_start(struct usb_hcd *hcd)
  * error exits:
  */
 err_alloc_skelqh:
-        for (i = 0; i < UHCI_NUM_SKELQH; i++)
-                if (uhci->skelqh[i]) {
+        for (i = 0; i < UHCI_NUM_SKELQH; i++) {
+                if (uhci->skelqh[i])
                         uhci_free_qh(uhci, uhci->skelqh[i]);
-                        uhci->skelqh[i] = NULL;
-                }
+        }
 
         uhci_free_td(uhci, uhci->term_td);
-        uhci->term_td = NULL;
 
 err_alloc_term_td:
         dma_pool_destroy(uhci->qh_pool);
-        uhci->qh_pool = NULL;
 
 err_create_qh_pool:
         dma_pool_destroy(uhci->td_pool);
-        uhci->td_pool = NULL;
 
 err_create_td_pool:
-        dma_free_coherent(uhci_dev(uhci), sizeof(*uhci->fl),
-                        uhci->fl, uhci->fl->dma_handle);
-        uhci->fl = NULL;
+        kfree(uhci->frame_cpu);
+
+err_alloc_frame_cpu:
+        dma_free_coherent(uhci_dev(uhci),
+                        UHCI_NUMFRAMES * sizeof(*uhci->frame),
+                        uhci->frame, uhci->frame_dma_handle);
 
-err_alloc_fl:
+err_alloc_frame:
         debugfs_remove(uhci->dentry);
-        uhci->dentry = NULL;
 
 err_create_debug_entry:
         return retval;
@@ -726,7 +659,7 @@ static void uhci_stop(struct usb_hcd *hcd)
 
         spin_lock_irq(&uhci->lock);
         if (!uhci->hc_inaccessible)
-                reset_hc(uhci);
+                hc_died(uhci);
         uhci_scan_schedule(uhci, NULL);
         spin_unlock_irq(&uhci->lock);
 
@@ -774,14 +707,8 @@ static int uhci_suspend(struct usb_hcd *hcd, pm_message_t message)
         if (uhci->hc_inaccessible)      /* Dead or already suspended */
                 goto done;
 
-#ifndef CONFIG_USB_SUSPEND
-        /* Otherwise this would never happen */
-        suspend_rh(uhci, UHCI_RH_SUSPENDED);
-#endif
-
         if (uhci->rh_state > UHCI_RH_SUSPENDED) {
                 dev_warn(uhci_dev(uhci), "Root hub isn't suspended!\n");
-                hcd->state = HC_STATE_RUNNING;
                 rc = -EBUSY;
                 goto done;
         };
@@ -820,10 +747,6 @@ static int uhci_resume(struct usb_hcd *hcd)
         check_and_reset_hc(uhci);
         configure_hc(uhci);
 
-#ifndef CONFIG_USB_SUSPEND
-        /* Otherwise this would never happen */
-        wakeup_rh(uhci);
-#endif
         if (uhci->rh_state == UHCI_RH_RESET)
                 suspend_rh(uhci, UHCI_RH_SUSPENDED);
 
@@ -881,8 +804,8 @@ static const struct hc_driver uhci_driver = {
 #ifdef CONFIG_PM
         .suspend =              uhci_suspend,
         .resume =               uhci_resume,
-        .hub_suspend =          uhci_rh_suspend,
-        .hub_resume =           uhci_rh_resume,
+        .bus_suspend =          uhci_rh_suspend,
+        .bus_resume =           uhci_rh_resume,
 #endif
         .stop =                 uhci_stop,
 
@@ -908,6 +831,7 @@ MODULE_DEVICE_TABLE(pci, uhci_pci_ids);
 static struct pci_driver uhci_pci_driver = {
         .name =         (char *)hcd_name,
         .id_table =     uhci_pci_ids,
+        .owner =        THIS_MODULE,
 
         .probe =        usb_hcd_pci_probe,
         .remove =       usb_hcd_pci_remove,
diff --git a/drivers/usb/host/uhci-hcd.h b/drivers/usb/host/uhci-hcd.h
index 282f40b75881..e576db57a926 100644
--- a/drivers/usb/host/uhci-hcd.h
+++ b/drivers/usb/host/uhci-hcd.h
@@ -7,6 +7,7 @@
 #define usb_packetid(pipe)      (usb_pipein(pipe) ? USB_PID_IN : USB_PID_OUT)
 #define PIPE_DEVEP_MASK         0x0007ff00
 
+
 /*
  * Universal Host Controller Interface data structures and defines
  */
@@ -82,15 +83,10 @@
 #define UHCI_MAX_SOF_NUMBER     2047    /* in an SOF packet */
 #define CAN_SCHEDULE_FRAMES     1000    /* how far future frames can be scheduled */
 
-struct uhci_frame_list {
-        __le32 frame[UHCI_NUMFRAMES];
-
-        void *frame_cpu[UHCI_NUMFRAMES];
-
-        dma_addr_t dma_handle;
-};
 
-struct urb_priv;
+/*
+ *      Queue Headers
+ */
 
 /*
  * One role of a QH is to hold a queue of TDs for some endpoint.  Each QH is
@@ -116,13 +112,13 @@ struct uhci_qh {
 
         struct urb_priv *urbp;
 
-        struct list_head list;          /* P: uhci->frame_list_lock */
-        struct list_head remove_list;   /* P: uhci->remove_list_lock */
+        struct list_head list;
+        struct list_head remove_list;
 } __attribute__((aligned(16)));
 
 /*
  * We need a special accessor for the element pointer because it is
- * subject to asynchronous updates by the controller
+ * subject to asynchronous updates by the controller.
  */
 static __le32 inline qh_element(struct uhci_qh *qh) {
         __le32 element = qh->element;
@@ -131,6 +127,11 @@ static __le32 inline qh_element(struct uhci_qh *qh) {
         return element;
 }
 
+
+/*
+ *      Transfer Descriptors
+ */
+
 /*
  * for TD <status>:
  */
@@ -183,17 +184,10 @@ static __le32 inline qh_element(struct uhci_qh *qh) {
  *
  * That's silly, the hardware doesn't care. The hardware only cares that
  * the hardware words are 16-byte aligned, and we can have any amount of
- * sw space after the TD entry as far as I can tell.
- *
- * But let's just go with the documentation, at least for 32-bit machines.
- * On 64-bit machines we probably want to take advantage of the fact that
- * hw doesn't really care about the size of the sw-only area.
- *
- * Alas, not anymore, we have more than 4 words for software, woops.
- * Everything still works tho, surprise! -jerdfelt
+ * sw space after the TD entry.
  *
  * td->link points to either another TD (not necessarily for the same urb or
- * even the same endpoint), or nothing (PTR_TERM), or a QH (for queued urbs)
+ * even the same endpoint), or nothing (PTR_TERM), or a QH (for queued urbs).
  */
 struct uhci_td {
         /* Hardware fields */
@@ -205,18 +199,16 @@ struct uhci_td {
         /* Software fields */
         dma_addr_t dma_handle;
 
-        struct urb *urb;
-
-        struct list_head list;          /* P: urb->lock */
-        struct list_head remove_list;   /* P: uhci->td_remove_list_lock */
+        struct list_head list;
+        struct list_head remove_list;
 
         int frame;                      /* for iso: what frame? */
-        struct list_head fl_list;       /* P: uhci->frame_list_lock */
+        struct list_head fl_list;
 } __attribute__((aligned(16)));
 
 /*
  * We need a special accessor for the control/status word because it is
- * subject to asynchronous updates by the controller
+ * subject to asynchronous updates by the controller.
  */
 static u32 inline td_status(struct uhci_td *td) {
         __le32 status = td->status;
@@ -227,6 +219,10 @@ static u32 inline td_status(struct uhci_td *td) {
 
 
 /*
+ *      Skeleton Queue Headers
+ */
+
+/*
  * The UHCI driver places Interrupt, Control and Bulk into QH's both
  * to group together TD's for one transfer, and also to faciliate queuing
  * of URB's. To make it easy to insert entries into the schedule, we have
@@ -256,15 +252,15 @@ static u32 inline td_status(struct uhci_td *td) {
  *
  * The terminating QH is used for 2 reasons:
  * - To place a terminating TD which is used to workaround a PIIX bug
- *   (see Intel errata for explanation)
+ *   (see Intel errata for explanation), and
  * - To loop back to the full-speed control queue for full-speed bandwidth
- *   reclamation
+ *   reclamation.
  *
  * Isochronous transfers are stored before the start of the skeleton
  * schedule and don't use QH's. While the UHCI spec doesn't forbid the
- * use of QH's for Isochronous, it doesn't use them either. Since we don't
- * need to use them either, we follow the spec diagrams in hope that it'll
- * be more compatible with future UHCI implementations.
+ * use of QH's for Isochronous, it doesn't use them either. And the spec
+ * says that queues never advance on an error completion status, which
+ * makes them totally unsuitable for Isochronous transfers.
  */
 
 #define UHCI_NUM_SKELQH         12
@@ -314,8 +310,13 @@ static inline int __interval_to_skel(int interval)
         return 0;                               /* int128 for 128-255 ms (Max.) */
 }
 
+
+/*
+ *      The UHCI controller and root hub
+ */
+
 /*
- * States for the root hub.
+ * States for the root hub:
  *
  * To prevent "bouncing" in the presence of electrical noise,
  * when there are no devices attached we delay for 1 second in the
@@ -326,7 +327,7 @@ static inline int __interval_to_skel(int interval)
  */
 enum uhci_rh_state {
         /* In the following states the HC must be halted.
-         * These two must come first */
+         * These two must come first. */
         UHCI_RH_RESET,
         UHCI_RH_SUSPENDED,
 
@@ -338,13 +339,13 @@ enum uhci_rh_state {
         UHCI_RH_SUSPENDING,
 
         /* In the following states it's an error if the HC is halted.
-         * These two must come last */
+         * These two must come last. */
         UHCI_RH_RUNNING,                /* The normal state */
         UHCI_RH_RUNNING_NODEVS,         /* Running with no devices attached */
 };
 
 /*
- * This describes the full uhci information.
+ * The full UHCI controller information:
  */
 struct uhci_hcd {
 
@@ -361,7 +362,11 @@ struct uhci_hcd {
         struct uhci_qh *skelqh[UHCI_NUM_SKELQH];        /* Skeleton QH's */
 
         spinlock_t lock;
-        struct uhci_frame_list *fl;             /* P: uhci->lock */
+
+        dma_addr_t frame_dma_handle;            /* Hardware frame list */
+        __le32 *frame;
+        void **frame_cpu;                       /* CPU's frame list */
+
         int fsbr;                               /* Full-speed bandwidth reclamation */
         unsigned long fsbrtimeout;              /* FSBR delay */
 
@@ -385,22 +390,22 @@ struct uhci_hcd {
         unsigned long ports_timeout;            /* Time to stop signalling */
 
         /* Main list of URB's currently controlled by this HC */
-        struct list_head urb_list;              /* P: uhci->lock */
+        struct list_head urb_list;
 
         /* List of QH's that are done, but waiting to be unlinked (race) */
-        struct list_head qh_remove_list;        /* P: uhci->lock */
+        struct list_head qh_remove_list;
         unsigned int qh_remove_age;             /* Age in frames */
 
         /* List of TD's that are done, but waiting to be freed (race) */
-        struct list_head td_remove_list;        /* P: uhci->lock */
+        struct list_head td_remove_list;
         unsigned int td_remove_age;             /* Age in frames */
 
         /* List of asynchronously unlinked URB's */
-        struct list_head urb_remove_list;       /* P: uhci->lock */
+        struct list_head urb_remove_list;
         unsigned int urb_remove_age;            /* Age in frames */
 
         /* List of URB's awaiting completion callback */
-        struct list_head complete_list;         /* P: uhci->lock */
+        struct list_head complete_list;
 
         int rh_numports;                        /* Number of root-hub ports */
 
@@ -419,13 +424,17 @@ static inline struct usb_hcd *uhci_to_hcd(struct uhci_hcd *uhci)
 
 #define uhci_dev(u)     (uhci_to_hcd(u)->self.controller)
 
+
+/*
+ *      Private per-URB data
+ */
 struct urb_priv {
         struct list_head urb_list;
 
         struct urb *urb;
 
         struct uhci_qh *qh;             /* QH for this URB */
-        struct list_head td_list;       /* P: urb->lock */
+        struct list_head td_list;
 
         unsigned fsbr : 1;              /* URB turned on FSBR */
         unsigned fsbr_timeout : 1;      /* URB timed out on FSBR */
@@ -434,12 +443,12 @@ struct urb_priv {
                                                 /*  a control transfer, retrigger */
                                                 /*  the status phase */
 
-        unsigned long inserttime;       /* In jiffies */
         unsigned long fsbrtime;         /* In jiffies */
 
-        struct list_head queue_list;    /* P: uhci->frame_list_lock */
+        struct list_head queue_list;
 };
 
+
 /*
  * Locking in uhci.c
  *
@@ -459,6 +468,5 @@ struct urb_priv {
 
 #define PCI_VENDOR_ID_GENESYS           0x17a0
 #define PCI_DEVICE_ID_GL880S_UHCI       0x8083
-#define PCI_DEVICE_ID_GL880S_EHCI       0x8084
 
 #endif
diff --git a/drivers/usb/host/uhci-q.c b/drivers/usb/host/uhci-q.c
index 4e0fbe2c1a9a..7e46887d9e12 100644
--- a/drivers/usb/host/uhci-q.c
+++ b/drivers/usb/host/uhci-q.c
@@ -89,10 +89,10 @@ static void uhci_insert_td_frame_list(struct uhci_hcd *uhci, struct uhci_td *td,
         td->frame = framenum;
 
         /* Is there a TD already mapped there? */
-        if (uhci->fl->frame_cpu[framenum]) {
+        if (uhci->frame_cpu[framenum]) {
                 struct uhci_td *ftd, *ltd;
 
-                ftd = uhci->fl->frame_cpu[framenum];
+                ftd = uhci->frame_cpu[framenum];
                 ltd = list_entry(ftd->fl_list.prev, struct uhci_td, fl_list);
 
                 list_add_tail(&td->fl_list, &ftd->fl_list);
@@ -101,29 +101,32 @@ static void uhci_insert_td_frame_list(struct uhci_hcd *uhci, struct uhci_td *td,
                 wmb();
                 ltd->link = cpu_to_le32(td->dma_handle);
         } else {
-                td->link = uhci->fl->frame[framenum];
+                td->link = uhci->frame[framenum];
                 wmb();
-                uhci->fl->frame[framenum] = cpu_to_le32(td->dma_handle);
-                uhci->fl->frame_cpu[framenum] = td;
+                uhci->frame[framenum] = cpu_to_le32(td->dma_handle);
+                uhci->frame_cpu[framenum] = td;
         }
 }
 
-static void uhci_remove_td(struct uhci_hcd *uhci, struct uhci_td *td)
+static inline void uhci_remove_td_frame_list(struct uhci_hcd *uhci,
+                struct uhci_td *td)
 {
         /* If it's not inserted, don't remove it */
-        if (td->frame == -1 && list_empty(&td->fl_list))
+        if (td->frame == -1) {
+                WARN_ON(!list_empty(&td->fl_list));
                 return;
+        }
 
-        if (td->frame != -1 && uhci->fl->frame_cpu[td->frame] == td) {
+        if (uhci->frame_cpu[td->frame] == td) {
                 if (list_empty(&td->fl_list)) {
-                        uhci->fl->frame[td->frame] = td->link;
-                        uhci->fl->frame_cpu[td->frame] = NULL;
+                        uhci->frame[td->frame] = td->link;
+                        uhci->frame_cpu[td->frame] = NULL;
                 } else {
                         struct uhci_td *ntd;
 
                         ntd = list_entry(td->fl_list.next, struct uhci_td, fl_list);
-                        uhci->fl->frame[td->frame] = cpu_to_le32(ntd->dma_handle);
-                        uhci->fl->frame_cpu[td->frame] = ntd;
+                        uhci->frame[td->frame] = cpu_to_le32(ntd->dma_handle);
+                        uhci->frame_cpu[td->frame] = ntd;
                 }
         } else {
                 struct uhci_td *ptd;
@@ -132,13 +135,20 @@ static void uhci_remove_td(struct uhci_hcd *uhci, struct uhci_td *td)
                 ptd->link = td->link;
         }
 
-        wmb();
-        td->link = UHCI_PTR_TERM;
-
         list_del_init(&td->fl_list);
         td->frame = -1;
 }
 
+static void unlink_isochronous_tds(struct uhci_hcd *uhci, struct urb *urb)
+{
+        struct urb_priv *urbp = (struct urb_priv *) urb->hcpriv;
+        struct uhci_td *td;
+
+        list_for_each_entry(td, &urbp->td_list, list)
+                uhci_remove_td_frame_list(uhci, td);
+        wmb();
+}
+
 /*
  * Inserts a td list into qh.
  */
@@ -443,7 +453,6 @@ static struct urb_priv *uhci_alloc_urb_priv(struct uhci_hcd *uhci, struct urb *u
 
         memset((void *)urbp, 0, sizeof(*urbp));
 
-        urbp->inserttime = jiffies;
         urbp->fsbrtime = jiffies;
         urbp->urb = urb;
         
@@ -462,8 +471,6 @@ static void uhci_add_td_to_urb(struct urb *urb, struct uhci_td *td)
 {
         struct urb_priv *urbp = (struct urb_priv *)urb->hcpriv;
 
-        td->urb = urb;
-
         list_add_tail(&td->list, &urbp->td_list);
 }
 
@@ -473,8 +480,6 @@ static void uhci_remove_td_from_urb(struct uhci_td *td)
                 return;
 
         list_del_init(&td->list);
-
-        td->urb = NULL;
 }
 
 static void uhci_destroy_urb_priv(struct uhci_hcd *uhci, struct urb *urb)
@@ -503,7 +508,6 @@ static void uhci_destroy_urb_priv(struct uhci_hcd *uhci, struct urb *urb)
 
         list_for_each_entry_safe(td, tmp, &urbp->td_list, list) {
                 uhci_remove_td_from_urb(td);
-                uhci_remove_td(uhci, td);
                 list_add(&td->remove_list, &uhci->td_remove_list);
         }
 
@@ -1073,6 +1077,7 @@ static int uhci_submit_isochronous(struct uhci_hcd *uhci, struct urb *urb)
         struct uhci_td *td;
         int i, ret, frame;
         int status, destination;
+        struct urb_priv *urbp = (struct urb_priv *) urb->hcpriv;
 
         status = TD_CTRL_ACTIVE | TD_CTRL_IOS;
         destination = (urb->pipe & PIPE_DEVEP_MASK) | usb_packetid(urb->pipe);
@@ -1081,11 +1086,7 @@ static int uhci_submit_isochronous(struct uhci_hcd *uhci, struct urb *urb)
         if (ret)
                 return ret;
 
-        frame = urb->start_frame;
-        for (i = 0; i < urb->number_of_packets; i++, frame += urb->interval) {
-                if (!urb->iso_frame_desc[i].length)
-                        continue;
-
+        for (i = 0; i < urb->number_of_packets; i++) {
                 td = uhci_alloc_td(uhci);
                 if (!td)
                         return -ENOMEM;
@@ -1096,8 +1097,12 @@ static int uhci_submit_isochronous(struct uhci_hcd *uhci, struct urb *urb)
 
                 if (i + 1 >= urb->number_of_packets)
                         td->status |= cpu_to_le32(TD_CTRL_IOC);
+        }
 
+        frame = urb->start_frame;
+        list_for_each_entry(td, &urbp->td_list, list) {
                 uhci_insert_td_frame_list(uhci, td, frame);
+                frame += urb->interval;
         }
 
         return -EINPROGRESS;
@@ -1110,7 +1115,7 @@ static int uhci_result_isochronous(struct uhci_hcd *uhci, struct urb *urb)
         int status;
         int i, ret = 0;
 
-        urb->actual_length = 0;
+        urb->actual_length = urb->error_count = 0;
 
         i = 0;
         list_for_each_entry(td, &urbp->td_list, list) {
@@ -1134,6 +1139,7 @@ static int uhci_result_isochronous(struct uhci_hcd *uhci, struct urb *urb)
 
                 i++;
         }
+        unlink_isochronous_tds(uhci, urb);
 
         return ret;
 }
@@ -1366,6 +1372,8 @@ static int uhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb)
                 goto done;
         list_del_init(&urbp->urb_list);
 
+        if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS)
+                unlink_isochronous_tds(uhci, urb);
         uhci_unlink_generic(uhci, urb);
 
         uhci_get_current_frame_number(uhci);
diff --git a/drivers/usb/image/mdc800.c b/drivers/usb/image/mdc800.c
index a330a4b50e16..1d973bcf56aa 100644
--- a/drivers/usb/image/mdc800.c
+++ b/drivers/usb/image/mdc800.c
@@ -425,9 +425,8 @@ static void mdc800_usb_download_notify (struct urb *urb, struct pt_regs *res)
 static struct usb_driver mdc800_usb_driver;
 static struct file_operations mdc800_device_ops;
 static struct usb_class_driver mdc800_class = {
-        .name =         "usb/mdc800%d",
+        .name =         "mdc800%d",
         .fops =         &mdc800_device_ops,
-        .mode =         S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
         .minor_base =   MDC800_DEVICE_MINOR_BASE,
 };
 
@@ -976,13 +975,13 @@ static struct usb_driver mdc800_usb_driver =
         Init and Cleanup this driver (Main Functions)
 *************************************************************************/
 
-#define try(A)           if (!(A)) goto cleanup_on_fail;
-
 static int __init usb_mdc800_init (void)
 {
         int retval = -ENODEV;
         /* Allocate Memory */
-        try (mdc800=kmalloc (sizeof (struct mdc800_data), GFP_KERNEL));
+        mdc800=kmalloc (sizeof (struct mdc800_data), GFP_KERNEL);
+        if (!mdc800)
+                goto cleanup_on_fail;
 
         memset(mdc800, 0, sizeof(struct mdc800_data));
         mdc800->dev = NULL;
@@ -998,13 +997,25 @@ static int __init usb_mdc800_init (void)
         mdc800->downloaded = 0;
         mdc800->written = 0;
 
-        try (mdc800->irq_urb_buffer=kmalloc (8, GFP_KERNEL));
-        try (mdc800->write_urb_buffer=kmalloc (8, GFP_KERNEL));
-        try (mdc800->download_urb_buffer=kmalloc (64, GFP_KERNEL));
+        mdc800->irq_urb_buffer=kmalloc (8, GFP_KERNEL);
+        if (!mdc800->irq_urb_buffer)
+                goto cleanup_on_fail;
+        mdc800->write_urb_buffer=kmalloc (8, GFP_KERNEL);
+        if (!mdc800->write_urb_buffer)
+                goto cleanup_on_fail;
+        mdc800->download_urb_buffer=kmalloc (64, GFP_KERNEL);
+        if (!mdc800->download_urb_buffer)
+                goto cleanup_on_fail;
 
-        try (mdc800->irq_urb=usb_alloc_urb (0, GFP_KERNEL));
-        try (mdc800->download_urb=usb_alloc_urb (0, GFP_KERNEL));
-        try (mdc800->write_urb=usb_alloc_urb (0, GFP_KERNEL));
+        mdc800->irq_urb=usb_alloc_urb (0, GFP_KERNEL);
+        if (!mdc800->irq_urb)
+                goto cleanup_on_fail;
+        mdc800->download_urb=usb_alloc_urb (0, GFP_KERNEL);
+        if (!mdc800->download_urb)
+                goto cleanup_on_fail;
+        mdc800->write_urb=usb_alloc_urb (0, GFP_KERNEL);
+        if (!mdc800->write_urb)
+                goto cleanup_on_fail;
 
         /* Register the driver */
         retval = usb_register(&mdc800_usb_driver);
diff --git a/drivers/usb/image/microtek.c b/drivers/usb/image/microtek.c
index c84e1486054f..c89d0769b3da 100644
--- a/drivers/usb/image/microtek.c
+++ b/drivers/usb/image/microtek.c
@@ -773,11 +773,10 @@ static int mts_usb_probe(struct usb_interface *intf,
         }
         
         
-        new_desc = kmalloc(sizeof(struct mts_desc), GFP_KERNEL);
+        new_desc = kzalloc(sizeof(struct mts_desc), GFP_KERNEL);
         if (!new_desc)
                 goto out;
 
-        memset(new_desc, 0, sizeof(*new_desc));
         new_desc->urb = usb_alloc_urb(0, GFP_KERNEL);
         if (!new_desc->urb)
                 goto out_kfree;
diff --git a/drivers/usb/input/aiptek.c b/drivers/usb/input/aiptek.c
index 1c5205321d83..1c3b472a3bca 100644
--- a/drivers/usb/input/aiptek.c
+++ b/drivers/usb/input/aiptek.c
@@ -2154,7 +2154,7 @@ aiptek_probe(struct usb_interface *intf, const struct usb_device_id *id)
          * input_handles associated with this input device.
          * What identifies an evdev input_handler is that it begins
          * with 'event', continues with a digit, and that in turn
-         * is mapped to /{devfs}/input/eventN.
+         * is mapped to input/eventN.
          */
         list_for_each_safe(node, next, &inputdev->h_list) {
                 inputhandle = to_handle(node);
diff --git a/drivers/usb/input/hid-core.c b/drivers/usb/input/hid-core.c
index 411a0645a7a3..79ddce4555ab 100644
--- a/drivers/usb/input/hid-core.c
+++ b/drivers/usb/input/hid-core.c
@@ -1784,6 +1784,9 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
         hid->urbctrl->transfer_dma = hid->ctrlbuf_dma;
         hid->urbctrl->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP);
 
+        /* May be needed for some devices */
+        usb_clear_halt(hid->dev, hid->urbin->pipe);
+
         return hid;
 
 fail:
@@ -1887,7 +1890,6 @@ static int hid_suspend(struct usb_interface *intf, pm_message_t message)
         struct hid_device *hid = usb_get_intfdata (intf);
 
         usb_kill_urb(hid->urbin);
-        intf->dev.power.power_state = PMSG_SUSPEND;
         dev_dbg(&intf->dev, "suspend\n");
         return 0;
 }
@@ -1897,7 +1899,6 @@ static int hid_resume(struct usb_interface *intf)
         struct hid_device *hid = usb_get_intfdata (intf);
         int status;
 
-        intf->dev.power.power_state = PMSG_ON;
         if (hid->open)
                 status = usb_submit_urb(hid->urbin, GFP_NOIO);
         else
diff --git a/drivers/usb/input/hiddev.c b/drivers/usb/input/hiddev.c
index d32427818af7..440377c7a0da 100644
--- a/drivers/usb/input/hiddev.c
+++ b/drivers/usb/input/hiddev.c
@@ -732,9 +732,8 @@ static struct file_operations hiddev_fops = {
 };
 
 static struct usb_class_driver hiddev_class = {
-        .name =         "usb/hid/hiddev%d",
+        .name =         "hiddev%d",
         .fops =         &hiddev_fops,
-        .mode =         S_IFCHR | S_IRUGO | S_IWUSR,
         .minor_base =   HIDDEV_MINOR_BASE,
 };
 
diff --git a/drivers/usb/input/map_to_7segment.h b/drivers/usb/input/map_to_7segment.h
index 52ff27f15127..a424094d9fe2 100644
--- a/drivers/usb/input/map_to_7segment.h
+++ b/drivers/usb/input/map_to_7segment.h
@@ -79,7 +79,7 @@ struct seg7_conversion_map {
 
 static inline int map_to_seg7(struct seg7_conversion_map *map, int c)
 {
-        return c & 0x7f ? map->table[c] : -EINVAL;
+        return c >= 0 && c < sizeof(map->table) ? map->table[c] : -EINVAL;
 }
 
 #define SEG7_CONVERSION_MAP(_name, _map)        \
diff --git a/drivers/usb/input/touchkitusb.c b/drivers/usb/input/touchkitusb.c
index 3766ccc271be..0043e6ebcd1f 100644
--- a/drivers/usb/input/touchkitusb.c
+++ b/drivers/usb/input/touchkitusb.c
@@ -75,7 +75,9 @@ struct touchkit_usb {
 
 static struct usb_device_id touchkit_devices[] = {
         {USB_DEVICE(0x3823, 0x0001)},
+        {USB_DEVICE(0x0123, 0x0001)},
         {USB_DEVICE(0x0eef, 0x0001)},
+        {USB_DEVICE(0x0eef, 0x0002)},
         {}
 };
 
diff --git a/drivers/usb/media/dabusb.c b/drivers/usb/media/dabusb.c
index 6ca2fae99d2d..27b23c55bbc7 100644
--- a/drivers/usb/media/dabusb.c
+++ b/drivers/usb/media/dabusb.c
@@ -707,9 +707,8 @@ static struct file_operations dabusb_fops =
 };
 
 static struct usb_class_driver dabusb_class = {
-        .name =         "usb/dabusb%d",
+        .name =         "dabusb%d",
         .fops =         &dabusb_fops,
-        .mode =         S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
         .minor_base =   DABUSB_MINOR,
 };
 
diff --git a/drivers/usb/misc/auerswald.c b/drivers/usb/misc/auerswald.c
index ae4681f9f0ea..5f33f7c64885 100644
--- a/drivers/usb/misc/auerswald.c
+++ b/drivers/usb/misc/auerswald.c
@@ -1873,9 +1873,8 @@ static struct file_operations auerswald_fops =
 };
 
 static struct usb_class_driver auerswald_class = {
-        .name =         "usb/auer%d",
+        .name =         "auer%d",
         .fops =         &auerswald_fops,
-        .mode =         S_IFCHR | S_IRUGO | S_IWUGO,
         .minor_base =   AUER_MINOR_BASE,
 };
 
diff --git a/drivers/usb/misc/idmouse.c b/drivers/usb/misc/idmouse.c
index 733acc213726..3944a55ed74c 100644
--- a/drivers/usb/misc/idmouse.c
+++ b/drivers/usb/misc/idmouse.c
@@ -105,11 +105,10 @@ static struct file_operations idmouse_fops = {
         .release = idmouse_release,
 };
 
-/* class driver information for devfs */
+/* class driver information */
 static struct usb_class_driver idmouse_class = {
-        .name = "usb/idmouse%d",
+        .name = "idmouse%d",
         .fops = &idmouse_fops,
-        .mode = S_IFCHR | S_IRUSR | S_IRGRP | S_IROTH, /* filemode (char, 444) */
         .minor_base = USB_IDMOUSE_MINOR_BASE,
 };
 
diff --git a/drivers/usb/misc/legousbtower.c b/drivers/usb/misc/legousbtower.c
index 7d06105763d4..2703e205bc8f 100644
--- a/drivers/usb/misc/legousbtower.c
+++ b/drivers/usb/misc/legousbtower.c
@@ -271,12 +271,11 @@ static struct file_operations tower_fops = {
 
 /*
  * usb class driver info in order to get a minor number from the usb core,
- * and to have the device registered with devfs and the driver core
+ * and to have the device registered with the driver core
  */
 static struct usb_class_driver tower_class = {
-        .name =         "usb/legousbtower%d",
+        .name =         "legousbtower%d",
         .fops =         &tower_fops,
-        .mode =         S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH,
         .minor_base =   LEGO_USB_TOWER_MINOR_BASE,
 };
 
diff --git a/drivers/usb/misc/rio500.c b/drivers/usb/misc/rio500.c
index 26f77e29c7a6..7d02d8ec6b1a 100644
--- a/drivers/usb/misc/rio500.c
+++ b/drivers/usb/misc/rio500.c
@@ -443,9 +443,8 @@ file_operations usb_rio_fops = {
 };
 
 static struct usb_class_driver usb_rio_class = {
-        .name =         "usb/rio500%d",
+        .name =         "rio500%d",
         .fops =         &usb_rio_fops,
-        .mode =         S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
         .minor_base =   RIO_MINOR,
 };
 
diff --git a/drivers/usb/misc/sisusbvga/sisusb.c b/drivers/usb/misc/sisusbvga/sisusb.c
index 39db3155723a..c946c9a538a0 100644
--- a/drivers/usb/misc/sisusbvga/sisusb.c
+++ b/drivers/usb/misc/sisusbvga/sisusb.c
@@ -2440,7 +2440,7 @@ int
 sisusb_reset_text_mode(struct sisusb_usb_data *sisusb, int init)
 {
         int ret = 0, slot = sisusb->font_slot, i;
-        struct font_desc *myfont;
+        const struct font_desc *myfont;
         u8 *tempbuf;
         u16 *tempbufb;
         size_t written;
@@ -3239,12 +3239,7 @@ static struct file_operations usb_sisusb_fops = {
 };
 
 static struct usb_class_driver usb_sisusb_class = {
-#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,13)
-        .name =         "usb/sisusbvga%d",
-        .mode =         S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
-#else
         .name =         "sisusbvga%d",
-#endif
         .fops =         &usb_sisusb_fops,
         .minor_base =   SISUSB_MINOR
 };
diff --git a/drivers/usb/misc/usblcd.c b/drivers/usb/misc/usblcd.c
index 096ab3029676..85f3725334b0 100644
--- a/drivers/usb/misc/usblcd.c
+++ b/drivers/usb/misc/usblcd.c
@@ -251,13 +251,12 @@ static struct file_operations lcd_fops = {
 };
 
 /*
- *  * usb class driver info in order to get a minor number from the usb core,
- *   * and to have the device registered with devfs and the driver core
- *    */
+ * usb class driver info in order to get a minor number from the usb core,
+ * and to have the device registered with the driver core
+ */
 static struct usb_class_driver lcd_class = {
-        .name =         "usb/lcd%d",
+        .name =         "lcd%d",
         .fops =         &lcd_fops,
-        .mode =         S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH,
         .minor_base =   USBLCD_MINOR,
 };
 
diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c
index 54799eb0bc60..90a96257d6ce 100644
--- a/drivers/usb/misc/usbtest.c
+++ b/drivers/usb/misc/usbtest.c
@@ -983,6 +983,7 @@ test_ctrl_queue (struct usbtest_dev *dev, struct usbtest_param *param)
                 reqp->number = i % NUM_SUBCASES;
                 reqp->expected = expected;
                 u->setup_packet = (char *) &reqp->setup;
+                u->transfer_flags |= URB_NO_SETUP_DMA_MAP;
 
                 u->context = &context;
                 u->complete = ctrl_complete;
@@ -1948,21 +1949,11 @@ usbtest_probe (struct usb_interface *intf, const struct usb_device_id *id)
 
 static int usbtest_suspend (struct usb_interface *intf, pm_message_t message)
 {
-        struct usbtest_dev      *dev = usb_get_intfdata (intf);
-
-        down (&dev->sem);
-        intf->dev.power.power_state = PMSG_SUSPEND;
-        up (&dev->sem);
         return 0;
 }
 
 static int usbtest_resume (struct usb_interface *intf)
 {
-        struct usbtest_dev      *dev = usb_get_intfdata (intf);
-
-        down (&dev->sem);
-        intf->dev.power.power_state = PMSG_ON;
-        up (&dev->sem);
         return 0;
 }
 
diff --git a/drivers/usb/mon/mon_main.c b/drivers/usb/mon/mon_main.c
index 508a21028db4..c34944c75047 100644
--- a/drivers/usb/mon/mon_main.c
+++ b/drivers/usb/mon/mon_main.c
@@ -11,6 +11,7 @@
 #include <linux/usb.h>
 #include <linux/debugfs.h>
 #include <linux/smp_lock.h>
+#include <linux/notifier.h>
 
 #include "usb_mon.h"
 #include "../core/hcd.h"
@@ -205,6 +206,23 @@ static void mon_bus_remove(struct usb_bus *ubus)
         up(&mon_lock);
 }
 
+static int mon_notify(struct notifier_block *self, unsigned long action,
+                      void *dev)
+{
+        switch (action) {
+        case USB_BUS_ADD:
+                mon_bus_add(dev);
+                break;
+        case USB_BUS_REMOVE:
+                mon_bus_remove(dev);
+        }
+        return NOTIFY_OK;
+}
+
+static struct notifier_block mon_nb = {
+        .notifier_call =        mon_notify,
+};
+
 /*
  * Ops
  */
@@ -212,8 +230,6 @@ static struct usb_mon_operations mon_ops_0 = {
         .urb_submit =   mon_submit,
         .urb_submit_error = mon_submit_error,
         .urb_complete = mon_complete,
-        .bus_add =      mon_bus_add,
-        .bus_remove =   mon_bus_remove,
 };
 
 /*
@@ -329,6 +345,8 @@ static int __init mon_init(void)
         }
         // MOD_INC_USE_COUNT(which_module?);
 
+        usb_register_notify(&mon_nb);
+
         down(&usb_bus_list_lock);
         list_for_each_entry (ubus, &usb_bus_list, bus_list) {
                 mon_bus_init(mondir, ubus);
@@ -342,6 +360,7 @@ static void __exit mon_exit(void)
         struct mon_bus *mbus;
         struct list_head *p;
 
+        usb_unregister_notify(&mon_nb);
         usb_mon_deregister();
 
         down(&mon_lock);
diff --git a/drivers/usb/net/Kconfig b/drivers/usb/net/Kconfig
index 8c010bb44eb8..efd6ca7e4ac5 100644
--- a/drivers/usb/net/Kconfig
+++ b/drivers/usb/net/Kconfig
@@ -294,7 +294,7 @@ config USB_NET_ZAURUS
           This also supports some related device firmware, as used in some
           PDAs from Olympus and some cell phones from Motorola.
 
-          If you install an alternate ROM image, such as the Linux 2.6 based
+          If you install an alternate image, such as the Linux 2.6 based
           versions of OpenZaurus, you should no longer need to support this
           protocol.  Only the "eth-fd" or "net_fd" drivers in these devices
           really need this non-conformant variant of CDC Ethernet (or in
diff --git a/drivers/usb/net/kaweth.c b/drivers/usb/net/kaweth.c
index c82655d3d448..6bef1be6b36c 100644
--- a/drivers/usb/net/kaweth.c
+++ b/drivers/usb/net/kaweth.c
@@ -469,7 +469,7 @@ static int kaweth_reset(struct kaweth_device *kaweth)
                                 0,
                                 KAWETH_CONTROL_TIMEOUT);
 
-        udelay(10000);
+        mdelay(10);
 
         kaweth_dbg("kaweth_reset() returns %d.",result);
 
diff --git a/drivers/usb/net/pegasus.c b/drivers/usb/net/pegasus.c
index 6a4ffe6c3977..537eb181d985 100644
--- a/drivers/usb/net/pegasus.c
+++ b/drivers/usb/net/pegasus.c
@@ -1384,7 +1384,6 @@ static int pegasus_suspend (struct usb_interface *intf, pm_message_t message)
                 usb_kill_urb(pegasus->rx_urb);
                 usb_kill_urb(pegasus->intr_urb);
         }
-        intf->dev.power.power_state = PMSG_SUSPEND;
         return 0;
 }
 
@@ -1392,7 +1391,6 @@ static int pegasus_resume (struct usb_interface *intf)
 {
         struct pegasus *pegasus = usb_get_intfdata(intf);
 
-        intf->dev.power.power_state = PMSG_ON;
         netif_device_attach (pegasus->net);
         if (netif_running(pegasus->net)) {
                 pegasus->rx_urb->status = 0;
diff --git a/drivers/usb/net/pegasus.h b/drivers/usb/net/pegasus.h
index b98f2a833442..9fbd59b55cb6 100644
--- a/drivers/usb/net/pegasus.h
+++ b/drivers/usb/net/pegasus.h
@@ -181,6 +181,8 @@ PEGASUS_DEV( "Accton USB 10/100 Ethernet Adapter", VENDOR_ACCTON, 0x1046,
                 DEFAULT_GPIO_RESET )
 PEGASUS_DEV( "SpeedStream USB 10/100 Ethernet", VENDOR_ACCTON, 0x5046,
                 DEFAULT_GPIO_RESET | PEGASUS_II )
+PEGASUS_DEV( "Philips USB 10/100 Ethernet", VENDOR_ACCTON, 0xb004,
+                DEFAULT_GPIO_RESET | PEGASUS_II )
 PEGASUS_DEV( "ADMtek ADM8511 \"Pegasus II\" USB Ethernet",
                 VENDOR_ADMTEK, 0x8511,
                 DEFAULT_GPIO_RESET | PEGASUS_II | HAS_HOME_PNA )
diff --git a/drivers/usb/net/rtl8150.c b/drivers/usb/net/rtl8150.c
index c3d4e3589e30..787dd3591d6a 100644
--- a/drivers/usb/net/rtl8150.c
+++ b/drivers/usb/net/rtl8150.c
@@ -909,6 +909,7 @@ static void rtl8150_disconnect(struct usb_interface *intf)
         usb_set_intfdata(intf, NULL);
         if (dev) {
                 set_bit(RTL8150_UNPLUG, &dev->flags);
+                tasklet_disable(&dev->tl);
                 unregister_netdev(dev->netdev);
                 unlink_all_urbs(dev);
                 free_all_urbs(dev);
diff --git a/drivers/usb/net/usbnet.c b/drivers/usb/net/usbnet.c
index fce81d738933..74f05c9c84d5 100644
--- a/drivers/usb/net/usbnet.c
+++ b/drivers/usb/net/usbnet.c
@@ -1185,7 +1185,6 @@ int usbnet_suspend (struct usb_interface *intf, pm_message_t message)
         netif_device_detach (dev->net);
         (void) unlink_urbs (dev, &dev->rxq);
         (void) unlink_urbs (dev, &dev->txq);
-        intf->dev.power.power_state = PMSG_SUSPEND;
         return 0;
 }
 EXPORT_SYMBOL_GPL(usbnet_suspend);
@@ -1194,7 +1193,6 @@ int usbnet_resume (struct usb_interface *intf)
 {
         struct usbnet           *dev = usb_get_intfdata(intf);
 
-        intf->dev.power.power_state = PMSG_ON;
         netif_device_attach (dev->net);
         tasklet_schedule (&dev->bh);
         return 0;
diff --git a/drivers/usb/serial/ChangeLog.old b/drivers/usb/serial/ChangeLog.old
new file mode 100644
index 000000000000..c1b279939bbf
--- /dev/null
+++ b/drivers/usb/serial/ChangeLog.old
@@ -0,0 +1,730 @@
+This is the contents of some of the drivers/usb/serial/ files that had  old
+changelog comments.  They were quite old, and out of date, and we don't keep
+them anymore, so I've put them here, away from the source files, in case
+people still care to see them.
+
+- Greg Kroah-Hartman <greg@kroah.com> October 20, 2005
+
+-----------------------------------------------------------------------
+usb-serial.h Change Log comments:
+
+ (03/26/2002) gkh
+        removed the port->tty check from port_paranoia_check() due to serial
+        consoles not having a tty device assigned to them.
+
+ (12/03/2001) gkh
+        removed active from the port structure.
+        added documentation to the usb_serial_device_type structure
+
+ (10/10/2001) gkh
+        added vendor and product to serial structure.  Needed to determine device
+        owner when the device is disconnected.
+
+ (05/30/2001) gkh
+        added sem to port structure and removed port_lock
+
+ (10/05/2000) gkh
+        Added interrupt_in_endpointAddress and bulk_in_endpointAddress to help
+        fix bug with urb->dev not being set properly, now that the usb core
+        needs it.
+
+ (09/11/2000) gkh
+        Added usb_serial_debug_data function to help get rid of #DEBUG in the
+        drivers.
+
+ (08/28/2000) gkh
+        Added port_lock to port structure.
+
+ (08/08/2000) gkh
+        Added open_count to port structure.
+
+ (07/23/2000) gkh
+        Added bulk_out_endpointAddress to port structure.
+
+ (07/19/2000) gkh, pberger, and borchers
+        Modifications to allow usb-serial drivers to be modules.
+
+-----------------------------------------------------------------------
+usb-serial.c Change Log comments:
+
+ (12/10/2002) gkh
+        Split the ports off into their own struct device, and added a
+        usb-serial bus driver.
+
+ (11/19/2002) gkh
+        removed a few #ifdefs for the generic code and cleaned up the failure
+        logic in initialization.
+
+ (10/02/2002) gkh
+        moved the console code to console.c and out of this file.
+
+ (06/05/2002) gkh
+        moved location of startup() call in serial_probe() until after all
+        of the port information and endpoints are initialized.  This makes
+        things easier for some drivers.
+
+ (04/10/2002) gkh
+        added serial_read_proc function which creates a
+        /proc/tty/driver/usb-serial file.
+
+ (03/27/2002) gkh
+        Got USB serial console code working properly and merged into the main
+        version of the tree.  Thanks to Randy Dunlap for the initial version
+        of this code, and for pushing me to finish it up.
+        The USB serial console works with any usb serial driver device.
+
+ (03/21/2002) gkh
+        Moved all manipulation of port->open_count into the core.  Now the
+        individual driver's open and close functions are called only when the
+        first open() and last close() is called.  Making the drivers a bit
+        smaller and simpler.
+        Fixed a bug if a driver didn't have the owner field set.
+
+ (02/26/2002) gkh
+        Moved all locking into the main serial_* functions, instead of having
+        the individual drivers have to grab the port semaphore.  This should
+        reduce races.
+        Reworked the MOD_INC logic a bit to always increment and decrement, even
+        if the generic driver is being used.
+
+ (10/10/2001) gkh
+        usb_serial_disconnect() now sets the serial->dev pointer is to NULL to
+        help prevent child drivers from accessing the device since it is now
+        gone.
+
+ (09/13/2001) gkh
+        Moved generic driver initialize after we have registered with the USB
+        core.  Thanks to Randy Dunlap for pointing this problem out.
+
+ (07/03/2001) gkh
+        Fixed module paramater size.  Thanks to John Brockmeyer for the pointer.
+        Fixed vendor and product getting defined through the MODULE_PARM macro
+        if the Generic driver wasn't compiled in.
+        Fixed problem with generic_shutdown() not being called for drivers that
+        don't have a shutdown() function.
+
+ (06/06/2001) gkh
+        added evil hack that is needed for the prolific pl2303 device due to the
+        crazy way its endpoints are set up.
+
+ (05/30/2001) gkh
+        switched from using spinlock to a semaphore, which fixes lots of problems.
+
+ (04/08/2001) gb
+        Identify version on module load.
+
+ 2001_02_05 gkh
+        Fixed buffer overflows bug with the generic serial driver.  Thanks to
+        Todd Squires <squirest@ct0.com> for fixing this.
+
+ (01/10/2001) gkh
+        Fixed bug where the generic serial adaptor grabbed _any_ device that was
+        offered to it.
+
+ (12/12/2000) gkh
+        Removed MOD_INC and MOD_DEC from poll and disconnect functions, and
+        moved them to the serial_open and serial_close functions.
+        Also fixed bug with there not being a MOD_DEC for the generic driver
+        (thanks to Gary Brubaker for finding this.)
+
+ (11/29/2000) gkh
+        Small NULL pointer initialization cleanup which saves a bit of disk image
+
+ (11/01/2000) Adam J. Richter
+        instead of using idVendor/idProduct pairs, usb serial drivers
+        now identify their hardware interest with usb_device_id tables,
+        which they usually have anyhow for use with MODULE_DEVICE_TABLE.
+
+ (10/05/2000) gkh
+        Fixed bug with urb->dev not being set properly, now that the usb
+        core needs it.
+
+ (09/11/2000) gkh
+        Removed DEBUG #ifdefs with call to usb_serial_debug_data
+
+ (08/28/2000) gkh
+        Added port_lock to port structure.
+        Added locks for SMP safeness to generic driver
+        Fixed the ability to open a generic device's port more than once.
+
+ (07/23/2000) gkh
+        Added bulk_out_endpointAddress to port structure.
+
+ (07/19/2000) gkh, pberger, and borchers
+        Modifications to allow usb-serial drivers to be modules.
+
+ (07/03/2000) gkh
+        Added more debugging to serial_ioctl call
+
+ (06/25/2000) gkh
+        Changed generic_write_bulk_callback to not call wake_up_interruptible
+        directly, but to have port_softint do it at a safer time.
+
+ (06/23/2000) gkh
+        Cleaned up debugging statements in a quest to find UHCI timeout bug.
+
+ (05/22/2000) gkh
+        Changed the makefile, enabling the big CONFIG_USB_SERIAL_SOMTHING to be
+        removed from the individual device source files.
+
+ (05/03/2000) gkh
+        Added the Digi Acceleport driver from Al Borchers and Peter Berger.
+
+ (05/02/2000) gkh
+        Changed devfs and tty register code to work properly now. This was based on
+        the ACM driver changes by Vojtech Pavlik.
+
+ (04/27/2000) Ryan VanderBijl
+        Put calls to *_paranoia_checks into one function.
+
+ (04/23/2000) gkh
+        Fixed bug that Randy Dunlap found for Generic devices with no bulk out ports.
+        Moved when the startup code printed out the devices that are supported.
+
+ (04/19/2000) gkh
+        Added driver for ZyXEL omni.net lcd plus ISDN TA
+        Made startup info message specify which drivers were compiled in.
+
+ (04/03/2000) gkh
+        Changed the probe process to remove the module unload races.
+        Changed where the tty layer gets initialized to have devfs work nicer.
+        Added initial devfs support.
+
+ (03/26/2000) gkh
+        Split driver up into device specific pieces.
+
+ (03/19/2000) gkh
+        Fixed oops that could happen when device was removed while a program
+        was talking to the device.
+        Removed the static urbs and now all urbs are created and destroyed
+        dynamically.
+        Reworked the internal interface. Now everything is based on the
+        usb_serial_port structure instead of the larger usb_serial structure.
+        This fixes the bug that a multiport device could not have more than
+        one port open at one time.
+
+ (03/17/2000) gkh
+        Added config option for debugging messages.
+        Added patch for keyspan pda from Brian Warner.
+
+ (03/06/2000) gkh
+        Added the keyspan pda code from Brian Warner <warner@lothar.com>
+        Moved a bunch of the port specific stuff into its own structure. This
+        is in anticipation of the true multiport devices (there's a bug if you
+        try to access more than one port of any multiport device right now)
+
+ (02/21/2000) gkh
+        Made it so that any serial devices only have to specify which functions
+        they want to overload from the generic function calls (great,
+        inheritance in C, in a driver, just what I wanted...)
+        Added support for set_termios and ioctl function calls. No drivers take
+        advantage of this yet.
+        Removed the #ifdef MODULE, now there is no module specific code.
+        Cleaned up a few comments in usb-serial.h that were wrong (thanks again
+        to Miles Lott).
+        Small fix to get_free_serial.
+
+ (02/14/2000) gkh
+        Removed the Belkin and Peracom functionality from the driver due to
+        the lack of support from the vendor, and me not wanting people to
+        accidenatly buy the device, expecting it to work with Linux.
+        Added read_bulk_callback and write_bulk_callback to the type structure
+        for the needs of the FTDI and WhiteHEAT driver.
+        Changed all reverences to FTDI to FTDI_SIO at the request of Bill
+        Ryder.
+        Changed the output urb size back to the max endpoint size to make
+        the ftdi_sio driver have it easier, and due to the fact that it didn't
+        really increase the speed any.
+
+ (02/11/2000) gkh
+        Added VISOR_FUNCTION_CONSOLE to the visor startup function. This was a
+        patch from Miles Lott (milos@insync.net).
+        Fixed bug with not restoring the minor range that a device grabs, if
+        the startup function fails (thanks Miles for finding this).
+
+ (02/05/2000) gkh
+        Added initial framework for the Keyspan PDA serial converter so that
+        Brian Warner has a place to put his code.
+        Made the ezusb specific functions generic enough that different
+        devices can use them (whiteheat and keyspan_pda both need them).
+        Split out a whole bunch of structure and other stuff to a separate
+        usb-serial.h file.
+        Made the Visor connection messages a little more understandable, now
+        that Miles Lott (milos@insync.net) has gotten the Generic channel to
+        work. Also made them always show up in the log file.
+
+ (01/25/2000) gkh
+        Added initial framework for FTDI serial converter so that Bill Ryder
+        has a place to put his code.
+        Added the vendor specific info from Handspring. Now we can print out
+        informational debug messages as well as understand what is happening.
+
+ (01/23/2000) gkh
+        Fixed problem of crash when trying to open a port that didn't have a
+        device assigned to it. Made the minor node finding a little smarter,
+        now it looks to find a continuous space for the new device.
+
+ (01/21/2000) gkh
+        Fixed bug in visor_startup with patch from Miles Lott (milos@insync.net)
+        Fixed get_serial_by_minor which was all messed up for multi port
+        devices. Fixed multi port problem for generic devices. Now the number
+        of ports is determined by the number of bulk out endpoints for the
+        generic device.
+
+ (01/19/2000) gkh
+        Removed lots of cruft that was around from the old (pre urb) driver
+        interface.
+        Made the serial_table dynamic. This should save lots of memory when
+        the number of minor nodes goes up to 256.
+        Added initial support for devices that have more than one port.
+        Added more debugging comments for the Visor, and added a needed
+        set_configuration call.
+
+ (01/17/2000) gkh
+        Fixed the WhiteHEAT firmware (my processing tool had a bug)
+        and added new debug loader firmware for it.
+        Removed the put_char function as it isn't really needed.
+        Added visor startup commands as found by the Win98 dump.
+
+ (01/13/2000) gkh
+        Fixed the vendor id for the generic driver to the one I meant it to be.
+
+ (01/12/2000) gkh
+        Forget the version numbering...that's pretty useless...
+        Made the driver able to be compiled so that the user can select which
+        converter they want to use. This allows people who only want the Visor
+        support to not pay the memory size price of the WhiteHEAT.
+        Fixed bug where the generic driver (idVendor=0000 and idProduct=0000)
+        grabbed the root hub. Not good.
+
+ version 0.4.0 (01/10/2000) gkh
+        Added whiteheat.h containing the firmware for the ConnectTech WhiteHEAT
+        device. Added startup function to allow firmware to be downloaded to
+        a device if it needs to be.
+        Added firmware download logic to the WhiteHEAT device.
+        Started to add #defines to split up the different drivers for potential
+        configuration option.
+
+ version 0.3.1 (12/30/99) gkh
+      Fixed problems with urb for bulk out.
+      Added initial support for multiple sets of endpoints. This enables
+      the Handspring Visor to be attached successfully. Only the first
+      bulk in / bulk out endpoint pair is being used right now.
+
+ version 0.3.0 (12/27/99) gkh
+        Added initial support for the Handspring Visor based on a patch from
+        Miles Lott (milos@sneety.insync.net)
+        Cleaned up the code a bunch and converted over to using urbs only.
+
+ version 0.2.3 (12/21/99) gkh
+        Added initial support for the Connect Tech WhiteHEAT converter.
+        Incremented the number of ports in expectation of getting the
+        WhiteHEAT to work properly (4 ports per connection).
+        Added notification on insertion and removal of what port the
+        device is/was connected to (and what kind of device it was).
+
+ version 0.2.2 (12/16/99) gkh
+        Changed major number to the new allocated number. We're legal now!
+
+ version 0.2.1 (12/14/99) gkh
+        Fixed bug that happens when device node is opened when there isn't a
+        device attached to it. Thanks to marek@webdesign.no for noticing this.
+
+ version 0.2.0 (11/10/99) gkh
+        Split up internals to make it easier to add different types of serial
+        converters to the code.
+        Added a "generic" driver that gets it's vendor and product id
+        from when the module is loaded. Thanks to David E. Nelson (dnelson@jump.net)
+        for the idea and sample code (from the usb scanner driver.)
+        Cleared up any licensing questions by releasing it under the GNU GPL.
+
+ version 0.1.2 (10/25/99) gkh
+        Fixed bug in detecting device.
+
+ version 0.1.1 (10/05/99) gkh
+        Changed the major number to not conflict with anything else.
+
+ version 0.1 (09/28/99) gkh
+        Can recognize the two different devices and start up a read from
+        device when asked to. Writes also work. No control signals yet, this
+        all is vendor specific data (i.e. no spec), also no control for
+        different baud rates or other bit settings.
+        Currently we are using the same devid as the acm driver. This needs
+        to change.
+
+-----------------------------------------------------------------------
+visor.c Change Log comments:
+
+ (06/03/2003) Judd Montgomery <judd at jpilot.org>
+     Added support for module parameter options for untested/unknown
+     devices.
+
+ (03/09/2003) gkh
+        Added support for the Sony Clie NZ90V device.  Thanks to Martin Brachtl
+        <brachtl@redgrep.cz> for the information.
+
+ (03/05/2003) gkh
+        Think Treo support is now working.
+
+ (04/03/2002) gkh
+        Added support for the Sony OS 4.1 devices.  Thanks to Hiroyuki ARAKI
+        <hiro@zob.ne.jp> for the information.
+
+ (03/27/2002) gkh
+        Removed assumptions that port->tty was always valid (is not true
+        for usb serial console devices.)
+
+ (03/23/2002) gkh
+        Added support for the Palm i705 device, thanks to Thomas Riemer
+        <tom@netmech.com> for the information.
+
+ (03/21/2002) gkh
+        Added support for the Palm m130 device, thanks to Udo Eisenbarth
+        <udo.eisenbarth@web.de> for the information.
+
+ (02/27/2002) gkh
+        Reworked the urb handling logic.  We have no more pool, but dynamically
+        allocate the urb and the transfer buffer on the fly.  In testing this
+        does not incure any measurable overhead.  This also relies on the fact
+        that we have proper reference counting logic for urbs.
+
+ (02/21/2002) SilaS
+  Added initial support for the Palm m515 devices.
+
+ (02/14/2002) gkh
+        Added support for the Clie S-360 device.
+
+ (12/18/2001) gkh
+        Added better Clie support for 3.5 devices.  Thanks to Geoffrey Levand
+        for the patch.
+
+ (11/11/2001) gkh
+        Added support for the m125 devices, and added check to prevent oopses
+        for Clié devices that lie about the number of ports they have.
+
+ (08/30/2001) gkh
+        Added support for the Clie devices, both the 3.5 and 4.0 os versions.
+        Many thanks to Daniel Burke, and Bryan Payne for helping with this.
+
+ (08/23/2001) gkh
+        fixed a few potential bugs pointed out by Oliver Neukum.
+
+ (05/30/2001) gkh
+        switched from using spinlock to a semaphore, which fixes lots of problems.
+
+ (05/28/2000) gkh
+        Added initial support for the Palm m500 and Palm m505 devices.
+
+ (04/08/2001) gb
+        Identify version on module load.
+
+ (01/21/2000) gkh
+        Added write_room and chars_in_buffer, as they were previously using the
+        generic driver versions which is all wrong now that we are using an urb
+        pool.  Thanks to Wolfgang Grandegger for pointing this out to me.
+        Removed count assignment in the write function, which was not needed anymore
+        either.  Thanks to Al Borchers for pointing this out.
+
+ (12/12/2000) gkh
+        Moved MOD_DEC to end of visor_close to be nicer, as the final write
+        message can sleep.
+
+ (11/12/2000) gkh
+        Fixed bug with data being dropped on the floor by forcing tty->low_latency
+        to be on.  Hopefully this fixes the OHCI issue!
+
+ (11/01/2000) Adam J. Richter
+        usb_device_id table support
+
+ (10/05/2000) gkh
+        Fixed bug with urb->dev not being set properly, now that the usb
+        core needs it.
+
+ (09/11/2000) gkh
+        Got rid of always calling kmalloc for every urb we wrote out to the
+        device.
+        Added visor_read_callback so we can keep track of bytes in and out for
+        those people who like to know the speed of their device.
+        Removed DEBUG #ifdefs with call to usb_serial_debug_data
+
+ (09/06/2000) gkh
+        Fixed oops in visor_exit.  Need to uncomment usb_unlink_urb call _after_
+        the host controller drivers set urb->dev = NULL when the urb is finished.
+
+ (08/28/2000) gkh
+        Added locks for SMP safeness.
+
+ (08/08/2000) gkh
+        Fixed endian problem in visor_startup.
+        Fixed MOD_INC and MOD_DEC logic and the ability to open a port more
+        than once.
+
+ (07/23/2000) gkh
+        Added pool of write urbs to speed up transfers to the visor.
+
+ (07/19/2000) gkh
+        Added module_init and module_exit functions to handle the fact that this
+        driver is a loadable module now.
+
+ (07/03/2000) gkh
+        Added visor_set_ioctl and visor_set_termios functions (they don't do much
+        of anything, but are good for debugging.)
+
+ (06/25/2000) gkh
+        Fixed bug in visor_unthrottle that should help with the disconnect in PPP
+        bug that people have been reporting.
+
+ (06/23/2000) gkh
+        Cleaned up debugging statements in a quest to find UHCI timeout bug.
+
+ (04/27/2000) Ryan VanderBijl
+        Fixed memory leak in visor_close
+
+ (03/26/2000) gkh
+        Split driver up into device specific pieces.
+
+-----------------------------------------------------------------------
+pl2303.c Change Log comments:
+
+ 2002_Mar_26 gkh
+        allowed driver to work properly if there is no tty assigned to a port
+        (this happens for serial console devices.)
+
+ 2001_Oct_06 gkh
+        Added RTS and DTR line control.  Thanks to joe@bndlg.de for parts of it.
+
+ 2001_Sep_19 gkh
+        Added break support.
+
+ 2001_Aug_30 gkh
+        fixed oops in write_bulk_callback.
+
+ 2001_Aug_28 gkh
+        reworked buffer logic to be like other usb-serial drivers.  Hopefully
+        removing some reported problems.
+
+ 2001_Jun_06 gkh
+        finished porting to 2.4 format.
+
+
+-----------------------------------------------------------------------
+io_edgeport.c Change Log comments:
+
+ 2003_04_03 al borchers
+  - fixed a bug (that shows up with dosemu) where the tty struct is
+    used in a callback after it has been freed
+
+ 2.3 2002_03_08 greg kroah-hartman
+        - fixed bug when multiple devices were attached at the same time.
+
+ 2.2 2001_11_14 greg kroah-hartman
+        - fixed bug in edge_close that kept the port from being used more
+          than once.
+        - fixed memory leak on device removal.
+        - fixed potential double free of memory when command urb submitting
+          failed.
+        - other small cleanups when the device is removed
+
+ 2.1 2001_07_09 greg kroah-hartman
+        - added support for TIOCMBIS and TIOCMBIC.
+
+     (04/08/2001) gb
+        - Identify version on module load.
+
+ 2.0 2001_03_05 greg kroah-hartman
+        - reworked entire driver to fit properly in with the other usb-serial
+          drivers.  Occasional oopses still happen, but it's a good start.
+
+ 1.2.3 (02/23/2001) greg kroah-hartman
+        - changed device table to work properly for 2.4.x final format.
+        - fixed problem with dropping data at high data rates.
+
+ 1.2.2 (11/27/2000) greg kroah-hartman
+        - cleaned up more NTisms.
+        - Added device table for 2.4.0-test11
+
+ 1.2.1 (11/08/2000) greg kroah-hartman
+        - Started to clean up NTisms.
+        - Fixed problem with dev field of urb for kernels >= 2.4.0-test9
+
+ 1.2 (10/17/2000) David Iacovelli
+        Remove all EPIC code and GPL source
+  Fix RELEVANT_IFLAG macro to include flow control
+  changes port configuration changes.
+  Fix redefinition of SERIAL_MAGIC
+  Change all timeout values to 5 seconds
+  Tried to fix the UHCI multiple urb submission, but failed miserably.
+  it seems to work fine with OHCI.
+  ( Greg take a look at the #if 0 at end of WriteCmdUsb() we must
+    find a way to work arount this UHCI bug )
+
+ 1.1 (10/11/2000) David Iacovelli
+  Fix XON/XOFF flow control to support both IXON and IXOFF
+
+ 0.9.27 (06/30/2000) David Iacovelli
+  Added transmit queue and now allocate urb for command writes.
+
+ 0.9.26 (06/29/2000) David Iacovelli
+  Add support for 80251 based edgeport
+
+ 0.9.25 (06/27/2000) David Iacovelli
+  Do not close the port if it has multiple opens.
+
+ 0.9.24 (05/26/2000) David Iacovelli
+  Add IOCTLs to support RXTX and JAVA POS
+  and first cut at running BlackBox Demo
+
+ 0.9.23 (05/24/2000) David Iacovelli
+  Add IOCTLs to support RXTX and JAVA POS
+
+ 0.9.22 (05/23/2000) David Iacovelli
+  fixed bug in enumeration.  If epconfig turns on mapping by
+  path after a device is already plugged in, we now update
+  the mapping correctly
+
+ 0.9.21 (05/16/2000) David Iacovelli
+  Added BlockUntilChaseResp() to also wait for txcredits
+  Updated the way we allocate and handle write URBs
+        Add debug code to dump buffers
+
+ 0.9.20 (05/01/2000) David Iacovelli
+        change driver to use usb/tts/
+
+ 0.9.19 (05/01/2000) David Iacovelli
+  Update code to compile if DEBUG is off
+
+ 0.9.18 (04/28/2000) David Iacovelli
+  cleanup and test tty_register with devfs
+
+ 0.9.17 (04/27/2000) greg kroah-hartman
+        changed tty_register around to be like the way it
+        was before, but now it works properly with devfs.
+
+ 0.9.16 (04/26/2000) david iacovelli
+  Fixed bug in GetProductInfo()
+
+ 0.9.15 (04/25/2000) david iacovelli
+        Updated enumeration
+
+ 0.9.14 (04/24/2000) david iacovelli
+  Removed all config/status IOCTLS and
+  converted to using /proc/edgeport
+  still playing with devfs
+
+ 0.9.13 (04/24/2000) david iacovelli
+  Removed configuration based on ttyUSB0
+  Added support for configuration using /prod/edgeport
+  first attempt at using devfs (not working yet!)
+  Added IOCTL to GetProductInfo()
+  Added support for custom baud rates
+        Add support for random port numbers
+
+ 0.9.12 (04/18/2000) david iacovelli
+        added additional configuration IOCTLs
+  use ttyUSB0 for configuration
+
+ 0.9.11 (04/17/2000) greg kroah-hartman
+        fixed module initialization race conditions.
+        made all urbs dynamically allocated.
+        made driver devfs compatible. now it only registers the tty device
+        when the device is actually plugged in.
+
+ 0.9.10 (04/13/2000) greg kroah-hartman
+        added proc interface framework.
+
+ 0.9.9 (04/13/2000) david iacovelli
+        added enumeration code and ioctls to configure the device
+
+ 0.9.8 (04/12/2000) david iacovelli
+  Change interrupt read start when device is plugged in
+  and stop when device is removed
+        process interrupt reads when all ports are closed
+  (keep value of rxBytesAvail consistent with the edgeport)
+  set the USB_BULK_QUEUE flag so that we can shove a bunch
+  of urbs at once down the pipe
+
+ 0.9.7 (04/10/2000) david iacovelli
+        start to add enumeration code.
+  generate serial number for epic devices
+  add support for kdb
+
+ 0.9.6 (03/30/2000) david iacovelli
+  add IOCTL to get string, manufacture, and boot descriptors
+
+ 0.9.5 (03/14/2000) greg kroah-hartman
+        more error checking added to SerialOpen to try to fix UHCI open problem
+
+ 0.9.4 (03/09/2000) greg kroah-hartman
+        added more error checking to handle oops when data is hanging
+        around and tty is abruptly closed.
+
+ 0.9.3 (03/09/2000) david iacovelli
+        Add epic support for xon/xoff chars
+        play with performance
+
+ 0.9.2 (03/08/2000) greg kroah-hartman
+        changed most "info" calls to "dbg"
+        implemented flow control properly in the termios call
+
+ 0.9.1 (03/08/2000) david iacovelli
+        added EPIC support
+        enabled bootloader update
+
+ 0.9 (03/08/2000) greg kroah-hartman
+        Release to IO networks.
+        Integrated changes that David made
+  made getting urbs for writing SMP safe
+
+ 0.8 (03/07/2000) greg kroah-hartman
+        Release to IO networks.
+        Fixed problems that were seen in code by David.
+  Now both Edgeport/4 and Edgeport/2 works properly.
+  Changed most of the functions to use port instead of serial.
+
+ 0.7 (02/27/2000) greg kroah-hartman
+        Milestone 3 release.
+        Release to IO Networks
+        ioctl for waiting on line change implemented.
+        ioctl for getting statistics implemented.
+        multiport support working.
+        lsr and msr registers are now handled properly.
+        change break now hooked up and working.
+        support for all known Edgeport devices.
+
+ 0.6 (02/22/2000) greg kroah-hartman
+        Release to IO networks.
+        CHASE is implemented correctly when port is closed.
+        SerialOpen now blocks correctly until port is fully opened.
+
+ 0.5 (02/20/2000) greg kroah-hartman
+        Release to IO networks.
+        Known problems:
+                modem status register changes are not sent on to the user
+                CHASE is not implemented when the port is closed.
+
+ 0.4 (02/16/2000) greg kroah-hartman
+        Second cut at the CeBit demo.
+        Doesn't leak memory on every write to the port
+        Still small leaks on startup.
+        Added support for Edgeport/2 and Edgeport/8
+
+ 0.3 (02/15/2000) greg kroah-hartman
+        CeBit demo release.
+        Force the line settings to 4800, 8, 1, e for the demo.
+        Warning! This version leaks memory like crazy!
+
+ 0.2 (01/30/2000) greg kroah-hartman
+        Milestone 1 release.
+        Device is found by USB subsystem, enumerated, fimware is downloaded
+        and the descriptors are printed to the debug log, config is set, and
+        green light starts to blink. Open port works, and data can be sent
+        and received at the default settings of the UART. Loopback connector
+        and debug log confirms this.
+
+ 0.1 (01/23/2000) greg kroah-hartman
+        Initial release to help IO Networks try to set up their test system.
+        Edgeport4 is recognized, firmware is downloaded, config is set so
+        device blinks green light every 3 sec. Port is bound, but opening,
+        closing, and sending data do not work properly.
+
+
diff --git a/drivers/usb/serial/Kconfig b/drivers/usb/serial/Kconfig
index 9438909e87a5..7b5e8e4ee2bb 100644
--- a/drivers/usb/serial/Kconfig
+++ b/drivers/usb/serial/Kconfig
@@ -394,6 +394,15 @@ config USB_SERIAL_MCT_U232
           To compile this driver as a module, choose M here: the
           module will be called mct_u232.
 
+config USB_SERIAL_NOKIA_DKU2
+        tristate "USB Nokia DKU2 Driver"
+        depends on USB_SERIAL
+        help
+          Say Y here if you want to use a Nokia DKU2 device.
+
+          To compile this driver as a module, choose M here: the
+          module will be called nokia_dku2.
+
 config USB_SERIAL_PL2303
         tristate "USB Prolific 2303 Single Port Serial Driver"
         depends on USB_SERIAL
diff --git a/drivers/usb/serial/Makefile b/drivers/usb/serial/Makefile
index 6c7cdcc99a9e..55fd461793b7 100644
--- a/drivers/usb/serial/Makefile
+++ b/drivers/usb/serial/Makefile
@@ -31,6 +31,7 @@ obj-$(CONFIG_USB_SERIAL_KEYSPAN_PDA)		+= keyspan_pda.o
 obj-$(CONFIG_USB_SERIAL_KLSI)                   += kl5kusb105.o
 obj-$(CONFIG_USB_SERIAL_KOBIL_SCT)              += kobil_sct.o
 obj-$(CONFIG_USB_SERIAL_MCT_U232)               += mct_u232.o
+obj-$(CONFIG_USB_SERIAL_NOKIA_DKU2)             += nokia_dku2.o
 obj-$(CONFIG_USB_SERIAL_OMNINET)                += omninet.o
 obj-$(CONFIG_USB_SERIAL_OPTION)                 += option.o
 obj-$(CONFIG_USB_SERIAL_PL2303)                 += pl2303.o
diff --git a/drivers/usb/serial/airprime.c b/drivers/usb/serial/airprime.c
index 926d4c2c1600..1f29d8837327 100644
--- a/drivers/usb/serial/airprime.c
+++ b/drivers/usb/serial/airprime.c
@@ -30,9 +30,11 @@ static struct usb_driver airprime_driver = {
         .id_table =     id_table,
 };
 
-static struct usb_serial_device_type airprime_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "airprime",
+static struct usb_serial_driver airprime_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "airprime",
+        },
         .id_table =             id_table,
         .num_interrupt_in =     NUM_DONT_CARE,
         .num_bulk_in =          NUM_DONT_CARE,
diff --git a/drivers/usb/serial/belkin_sa.c b/drivers/usb/serial/belkin_sa.c
index abb1b2c543bb..84bc0ee4f061 100644
--- a/drivers/usb/serial/belkin_sa.c
+++ b/drivers/usb/serial/belkin_sa.c
@@ -121,10 +121,12 @@ static struct usb_driver belkin_driver = {
 };
 
 /* All of the device info needed for the serial converters */
-static struct usb_serial_device_type belkin_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "Belkin / Peracom / GoHubs USB Serial Adapter",
-        .short_name =           "belkin",
+static struct usb_serial_driver belkin_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "belkin",
+        },
+        .description =          "Belkin / Peracom / GoHubs USB Serial Adapter",
         .id_table =             id_table_combined,
         .num_interrupt_in =     1,
         .num_bulk_in =          1,
diff --git a/drivers/usb/serial/bus.c b/drivers/usb/serial/bus.c
index 2f612c2d894b..664139afcfa9 100644
--- a/drivers/usb/serial/bus.c
+++ b/drivers/usb/serial/bus.c
@@ -18,7 +18,7 @@
 
 static int usb_serial_device_match (struct device *dev, struct device_driver *drv)
 {
-        struct usb_serial_device_type *driver;
+        struct usb_serial_driver *driver;
         const struct usb_serial_port *port;
 
         /*
@@ -44,7 +44,7 @@ struct bus_type usb_serial_bus_type = {
 
 static int usb_serial_device_probe (struct device *dev)
 {
-        struct usb_serial_device_type *driver;
+        struct usb_serial_driver *driver;
         struct usb_serial_port *port;
         int retval = 0;
         int minor;
@@ -57,13 +57,13 @@ static int usb_serial_device_probe (struct device *dev)
 
         driver = port->serial->type;
         if (driver->port_probe) {
-                if (!try_module_get(driver->owner)) {
+                if (!try_module_get(driver->driver.owner)) {
                         dev_err(dev, "module get failed, exiting\n");
                         retval = -EIO;
                         goto exit;
                 }
                 retval = driver->port_probe (port);
-                module_put(driver->owner);
+                module_put(driver->driver.owner);
                 if (retval)
                         goto exit;
         }
@@ -72,7 +72,7 @@ static int usb_serial_device_probe (struct device *dev)
         tty_register_device (usb_serial_tty_driver, minor, dev);
         dev_info(&port->serial->dev->dev, 
                  "%s converter now attached to ttyUSB%d\n",
-                 driver->name, minor);
+                 driver->description, minor);
 
 exit:
         return retval;
@@ -80,7 +80,7 @@ exit:
 
 static int usb_serial_device_remove (struct device *dev)
 {
-        struct usb_serial_device_type *driver;
+        struct usb_serial_driver *driver;
         struct usb_serial_port *port;
         int retval = 0;
         int minor;
@@ -92,43 +92,38 @@ static int usb_serial_device_remove (struct device *dev)
 
         driver = port->serial->type;
         if (driver->port_remove) {
-                if (!try_module_get(driver->owner)) {
+                if (!try_module_get(driver->driver.owner)) {
                         dev_err(dev, "module get failed, exiting\n");
                         retval = -EIO;
                         goto exit;
                 }
                 retval = driver->port_remove (port);
-                module_put(driver->owner);
+                module_put(driver->driver.owner);
         }
 exit:
         minor = port->number;
         tty_unregister_device (usb_serial_tty_driver, minor);
         dev_info(dev, "%s converter now disconnected from ttyUSB%d\n",
-                 driver->name, minor);
+                 driver->description, minor);
 
         return retval;
 }
 
-int usb_serial_bus_register(struct usb_serial_device_type *device)
+int usb_serial_bus_register(struct usb_serial_driver *driver)
 {
         int retval;
 
-        if (device->short_name)
-                device->driver.name = (char *)device->short_name;
-        else
-                device->driver.name = (char *)device->name;
-        device->driver.bus = &usb_serial_bus_type;
-        device->driver.probe = usb_serial_device_probe;
-        device->driver.remove = usb_serial_device_remove;
-        device->driver.owner = device->owner;
+        driver->driver.bus = &usb_serial_bus_type;
+        driver->driver.probe = usb_serial_device_probe;
+        driver->driver.remove = usb_serial_device_remove;
 
-        retval = driver_register(&device->driver);
+        retval = driver_register(&driver->driver);
 
         return retval;
 }
 
-void usb_serial_bus_deregister(struct usb_serial_device_type *device)
+void usb_serial_bus_deregister(struct usb_serial_driver *driver)
 {
-        driver_unregister (&device->driver);
+        driver_unregister(&driver->driver);
 }
 
diff --git a/drivers/usb/serial/cp2101.c b/drivers/usb/serial/cp2101.c
index 97c78c21e8d1..c5334dd89b12 100644
--- a/drivers/usb/serial/cp2101.c
+++ b/drivers/usb/serial/cp2101.c
@@ -67,15 +67,17 @@ MODULE_DEVICE_TABLE (usb, id_table);
 
 static struct usb_driver cp2101_driver = {
         .owner          = THIS_MODULE,
-        .name           = "CP2101",
+        .name           = "cp2101",
         .probe          = usb_serial_probe,
         .disconnect     = usb_serial_disconnect,
         .id_table       = id_table,
 };
 
-static struct usb_serial_device_type cp2101_device = {
-        .owner                  = THIS_MODULE,
-        .name                   = "CP2101",
+static struct usb_serial_driver cp2101_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "cp2101",
+        },
         .id_table               = id_table,
         .num_interrupt_in       = 0,
         .num_bulk_in            = 0,
diff --git a/drivers/usb/serial/cyberjack.c b/drivers/usb/serial/cyberjack.c
index b5b431067b08..e581e4ae8483 100644
--- a/drivers/usb/serial/cyberjack.c
+++ b/drivers/usb/serial/cyberjack.c
@@ -83,10 +83,12 @@ static struct usb_driver cyberjack_driver = {
         .id_table =     id_table,
 };
 
-static struct usb_serial_device_type cyberjack_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "Reiner SCT Cyberjack USB card reader",
-        .short_name =           "cyberjack",
+static struct usb_serial_driver cyberjack_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "cyberjack",
+        },
+        .description =          "Reiner SCT Cyberjack USB card reader",
         .id_table =             id_table,
         .num_interrupt_in =     1,
         .num_bulk_in =          1,
diff --git a/drivers/usb/serial/cypress_m8.c b/drivers/usb/serial/cypress_m8.c
index 9ee1aaff2fcd..af9290ed257b 100644
--- a/drivers/usb/serial/cypress_m8.c
+++ b/drivers/usb/serial/cypress_m8.c
@@ -176,10 +176,12 @@ static unsigned int	  cypress_buf_put(struct cypress_buf *cb, const char *buf, u
 static unsigned int       cypress_buf_get(struct cypress_buf *cb, char *buf, unsigned int count);
 
 
-static struct usb_serial_device_type cypress_earthmate_device = {
-        .owner =                        THIS_MODULE,
-        .name =                         "DeLorme Earthmate USB",
-        .short_name =                   "earthmate",
+static struct usb_serial_driver cypress_earthmate_device = {
+        .driver = {
+                .owner =                THIS_MODULE,
+                .name =                 "earthmate",
+        },
+        .description =                  "DeLorme Earthmate USB",
         .id_table =                     id_table_earthmate,
         .num_interrupt_in =             1,
         .num_interrupt_out =            1,
@@ -203,10 +205,12 @@ static struct usb_serial_device_type cypress_earthmate_device = {
         .write_int_callback =           cypress_write_int_callback,
 };
 
-static struct usb_serial_device_type cypress_hidcom_device = {
-        .owner =                        THIS_MODULE,
-        .name =                         "HID->COM RS232 Adapter",
-        .short_name =                   "cyphidcom",
+static struct usb_serial_driver cypress_hidcom_device = {
+        .driver = {
+                .owner =                THIS_MODULE,
+                .name =                 "cyphidcom",
+        },
+        .description =                  "HID->COM RS232 Adapter",
         .id_table =                     id_table_cyphidcomrs232,
         .num_interrupt_in =             1,
         .num_interrupt_out =            1,
diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c
index a19a47f6cf12..dc74644a603d 100644
--- a/drivers/usb/serial/digi_acceleport.c
+++ b/drivers/usb/serial/digi_acceleport.c
@@ -503,10 +503,12 @@ static struct usb_driver digi_driver = {
 
 /* device info needed for the Digi serial converter */
 
-static struct usb_serial_device_type digi_acceleport_2_device = {
-        .owner =                        THIS_MODULE,
-        .name =                         "Digi 2 port USB adapter",
-        .short_name =                   "digi_2",
+static struct usb_serial_driver digi_acceleport_2_device = {
+        .driver = {
+                .owner =                THIS_MODULE,
+                .name =                 "digi_2",
+        },
+        .description =                  "Digi 2 port USB adapter",
         .id_table =                     id_table_2,
         .num_interrupt_in =             0,
         .num_bulk_in =                  4,
@@ -530,10 +532,12 @@ static struct usb_serial_device_type digi_acceleport_2_device = {
         .shutdown =                     digi_shutdown,
 };
 
-static struct usb_serial_device_type digi_acceleport_4_device = {
-        .owner =                        THIS_MODULE,
-        .name =                         "Digi 4 port USB adapter",
-        .short_name =                   "digi_4",
+static struct usb_serial_driver digi_acceleport_4_device = {
+        .driver = {
+                .owner =                THIS_MODULE,
+                .name =                 "digi_4",
+        },
+        .description =                  "Digi 4 port USB adapter",
         .id_table =                     id_table_4,
         .num_interrupt_in =             0,
         .num_bulk_in =                  5,
diff --git a/drivers/usb/serial/empeg.c b/drivers/usb/serial/empeg.c
index 8d562ab454a8..0b0546dcc7b9 100644
--- a/drivers/usb/serial/empeg.c
+++ b/drivers/usb/serial/empeg.c
@@ -112,9 +112,11 @@ static struct usb_driver empeg_driver = {
         .id_table =     id_table,
 };
 
-static struct usb_serial_device_type empeg_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "Empeg",
+static struct usb_serial_driver empeg_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "empeg",
+        },
         .id_table =             id_table,
         .num_interrupt_in =     0,
         .num_bulk_in =          1,
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 5a8631c8a4a7..61204bf7cd78 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -411,6 +411,8 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_ELV_UM100_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_UR100_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_ALC8500_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_PYRAMID_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1000PC_PID) },
         /*
          * These will probably use user-space drivers.  Uncomment them if
          * you need them or use the user-specified vendor/product module
@@ -428,7 +430,6 @@ static struct usb_device_id id_table_combined [] = {
         /* { USB_DEVICE(FTDI_VID, FTDI_ELV_T1100_PID) }, */
         /* { USB_DEVICE(FTDI_VID, FTDI_ELV_PCD200_PID) }, */
         /* { USB_DEVICE(FTDI_VID, FTDI_ELV_ULA200_PID) }, */
-        /* { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1000PC_PID) }, */
         /* { USB_DEVICE(FTDI_VID, FTDI_ELV_CSI8_PID) }, */
         /* { USB_DEVICE(FTDI_VID, FTDI_ELV_EM1000DL_PID) }, */
         /* { USB_DEVICE(FTDI_VID, FTDI_ELV_PCK100_PID) }, */
@@ -471,6 +472,9 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y6_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y8_PID) },
         { USB_DEVICE(EVOLUTION_VID, EVOLUTION_ER1_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ARTEMIS_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16HR_PID) },
         { },                                    /* Optional parameter entry */
         { }                                     /* Terminating entry */
 };
@@ -558,10 +562,12 @@ static unsigned short int ftdi_232am_baud_to_divisor (int baud);
 static __u32 ftdi_232bm_baud_base_to_divisor (int baud, int base);
 static __u32 ftdi_232bm_baud_to_divisor (int baud);
 
-static struct usb_serial_device_type ftdi_sio_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "FTDI USB Serial Device",
-        .short_name =           "ftdi_sio",
+static struct usb_serial_driver ftdi_sio_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "ftdi_sio",
+        },
+        .description =          "FTDI USB Serial Device",
         .id_table =             id_table_combined,
         .num_interrupt_in =     0,
         .num_bulk_in =          1,
diff --git a/drivers/usb/serial/ftdi_sio.h b/drivers/usb/serial/ftdi_sio.h
index 2c35d74cc6d6..ddb63df31ce6 100644
--- a/drivers/usb/serial/ftdi_sio.h
+++ b/drivers/usb/serial/ftdi_sio.h
@@ -199,6 +199,19 @@
 #define FTDI_PIEGROUP_PID       0xF208  /* Product Id */
 
 /*
+ * Definitions for Artemis astronomical USB based cameras
+ * Check it at http://www.artemisccd.co.uk/
+ */
+#define FTDI_ARTEMIS_PID        0xDF28  /* All Artemis Cameras */
+
+/*
+ * Definitions for ATIK Instruments astronomical USB based cameras
+ * Check it at http://www.atik-instruments.com/
+ */
+#define FTDI_ATIK_ATK16_PID     0xDF30  /* ATIK ATK-16 Camera */
+#define FTDI_ATIK_ATK16HR_PID   0xDF31  /* ATIK ATK-16HR Camera */
+
+/*
  * Protego product ids
  */
 #define PROTEGO_SPECIAL_1       0xFC70  /* special/unknown device */
@@ -329,6 +342,9 @@
 #define EVOLUTION_VID           0xDEEE  /* Vendor ID */
 #define EVOLUTION_ER1_PID       0x0300  /* ER1 Control Module */
 
+/* Pyramid Computer GmbH */
+#define FTDI_PYRAMID_PID        0xE6C8  /* Pyramid Appliance Display */
+
 /* Commands */
 #define FTDI_SIO_RESET          0 /* Reset the port */
 #define FTDI_SIO_MODEM_CTRL     1 /* Set the modem control register */
diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c
index 2ef614d5c8f2..35820bda7ae1 100644
--- a/drivers/usb/serial/garmin_gps.c
+++ b/drivers/usb/serial/garmin_gps.c
@@ -1468,16 +1468,13 @@ static void garmin_shutdown (struct usb_serial *serial)
 }
 
 
-
-
-
-
-
 /* All of the device info needed */
-static struct usb_serial_device_type garmin_device = {
-        .owner               = THIS_MODULE,
-        .name                = "Garmin GPS usb/tty",
-        .short_name          = "garmin_gps",
+static struct usb_serial_driver garmin_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "garmin_gps",
+        },
+        .description =          "Garmin GPS usb/tty",
         .id_table            = id_table,
         .num_interrupt_in    = 1,
         .num_bulk_in         = 1,
diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c
index 5f7d3193d355..8909208f506a 100644
--- a/drivers/usb/serial/generic.c
+++ b/drivers/usb/serial/generic.c
@@ -36,10 +36,11 @@ MODULE_PARM_DESC(product, "User specified USB idProduct");
 static struct usb_device_id generic_device_ids[2]; /* Initially all zeroes. */
 
 /* All of the device info needed for the Generic Serial Converter */
-struct usb_serial_device_type usb_serial_generic_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "Generic",
-        .short_name =           "generic",
+struct usb_serial_driver usb_serial_generic_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "generic",
+        },
         .id_table =             generic_device_ids,
         .num_interrupt_in =     NUM_DONT_CARE,
         .num_bulk_in =          NUM_DONT_CARE,
diff --git a/drivers/usb/serial/hp4x.c b/drivers/usb/serial/hp4x.c
index 64d55fbd206e..8eadfb705601 100644
--- a/drivers/usb/serial/hp4x.c
+++ b/drivers/usb/serial/hp4x.c
@@ -38,15 +38,17 @@ MODULE_DEVICE_TABLE(usb, id_table);
 
 static struct usb_driver hp49gp_driver = {
         .owner =        THIS_MODULE,
-        .name =         "HP4X",
+        .name =         "hp4X",
         .probe =        usb_serial_probe,
         .disconnect =   usb_serial_disconnect,
         .id_table =     id_table,
 };
 
-static struct usb_serial_device_type hp49gp_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "HP4X",
+static struct usb_serial_driver hp49gp_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "hp4X",
+        },
         .id_table =             id_table,
         .num_interrupt_in =     NUM_DONT_CARE,
         .num_bulk_in =          NUM_DONT_CARE,
diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c
index 04bfe279d763..dc4c498bd1ed 100644
--- a/drivers/usb/serial/io_edgeport.c
+++ b/drivers/usb/serial/io_edgeport.c
@@ -27,225 +27,6 @@
  * Networks technical support, or Peter Berger <pberger@brimson.com>,
  * or Al Borchers <alborchers@steinerpoint.com>.
  *
- * Version history:
- * 
- * 2003_04_03 al borchers
- *  - fixed a bug (that shows up with dosemu) where the tty struct is
- *    used in a callback after it has been freed
- *
- * 2.3 2002_03_08 greg kroah-hartman
- *      - fixed bug when multiple devices were attached at the same time.
- *
- * 2.2 2001_11_14 greg kroah-hartman
- *      - fixed bug in edge_close that kept the port from being used more
- *        than once.
- *      - fixed memory leak on device removal.
- *      - fixed potential double free of memory when command urb submitting
- *        failed.
- *      - other small cleanups when the device is removed
- *      
- * 2.1 2001_07_09 greg kroah-hartman
- *      - added support for TIOCMBIS and TIOCMBIC.
- *
- *     (04/08/2001) gb
- *      - Identify version on module load.
- *
- * 2.0 2001_03_05 greg kroah-hartman
- *      - reworked entire driver to fit properly in with the other usb-serial
- *        drivers.  Occasional oopses still happen, but it's a good start.
- *
- * 1.2.3 (02/23/2001) greg kroah-hartman
- *      - changed device table to work properly for 2.4.x final format.
- *      - fixed problem with dropping data at high data rates.
- *
- * 1.2.2 (11/27/2000) greg kroah-hartman
- *      - cleaned up more NTisms.
- *      - Added device table for 2.4.0-test11
- *
- * 1.2.1 (11/08/2000) greg kroah-hartman
- *      - Started to clean up NTisms.
- *      - Fixed problem with dev field of urb for kernels >= 2.4.0-test9
- *
- * 1.2 (10/17/2000) David Iacovelli
- *      Remove all EPIC code and GPL source
- *  Fix RELEVANT_IFLAG macro to include flow control 
- *  changes port configuration changes.
- *  Fix redefinition of SERIAL_MAGIC
- *  Change all timeout values to 5 seconds
- *  Tried to fix the UHCI multiple urb submission, but failed miserably.
- *  it seems to work fine with OHCI.
- *  ( Greg take a look at the #if 0 at end of WriteCmdUsb() we must 
- *    find a way to work arount this UHCI bug )
- *
- * 1.1 (10/11/2000) David Iacovelli
- *  Fix XON/XOFF flow control to support both IXON and IXOFF
- *
- * 0.9.27 (06/30/2000) David Iacovelli
- *  Added transmit queue and now allocate urb for command writes.
- *
- * 0.9.26 (06/29/2000) David Iacovelli
- *  Add support for 80251 based edgeport
- *
- * 0.9.25 (06/27/2000) David Iacovelli
- *  Do not close the port if it has multiple opens.
- *
- * 0.9.24 (05/26/2000) David Iacovelli
- *  Add IOCTLs to support RXTX and JAVA POS 
- *  and first cut at running BlackBox Demo
- *
- * 0.9.23 (05/24/2000) David Iacovelli
- *  Add IOCTLs to support RXTX and JAVA POS
- *
- * 0.9.22 (05/23/2000) David Iacovelli
- *  fixed bug in enumeration.  If epconfig turns on mapping by
- *  path after a device is already plugged in, we now update
- *  the mapping correctly
- *
- * 0.9.21 (05/16/2000) David Iacovelli
- *  Added BlockUntilChaseResp() to also wait for txcredits
- *  Updated the way we allocate and handle write URBs 
- *      Add debug code to dump buffers
- *
- * 0.9.20 (05/01/2000) David Iacovelli
- *      change driver to use usb/tts/
- *
- * 0.9.19 (05/01/2000) David Iacovelli
- *  Update code to compile if DEBUG is off
- *
- * 0.9.18 (04/28/2000) David Iacovelli
- *  cleanup and test tty_register with devfs
- *
- * 0.9.17 (04/27/2000) greg kroah-hartman
- *      changed tty_register around to be like the way it
- *      was before, but now it works properly with devfs.
- *
- * 0.9.16 (04/26/2000) david iacovelli
- *  Fixed bug in GetProductInfo()
- *
- * 0.9.15 (04/25/2000) david iacovelli
- *      Updated enumeration
- *
- * 0.9.14 (04/24/2000) david iacovelli
- *  Removed all config/status IOCTLS and 
- *  converted to using /proc/edgeport
- *  still playing with devfs
- *
- * 0.9.13 (04/24/2000) david iacovelli
- *  Removed configuration based on ttyUSB0
- *  Added support for configuration using /prod/edgeport
- *  first attempt at using devfs (not working yet!)
- *  Added IOCTL to GetProductInfo()
- *  Added support for custom baud rates
- *      Add support for random port numbers
- *
- * 0.9.12 (04/18/2000) david iacovelli
- *      added additional configuration IOCTLs
- *  use ttyUSB0 for configuration
- *
- * 0.9.11 (04/17/2000) greg kroah-hartman
- *      fixed module initialization race conditions.
- *      made all urbs dynamically allocated.
- *      made driver devfs compatible. now it only registers the tty device
- *      when the device is actually plugged in.
- *
- * 0.9.10 (04/13/2000) greg kroah-hartman
- *      added proc interface framework.
- *
- * 0.9.9 (04/13/2000) david iacovelli
- *      added enumeration code and ioctls to configure the device
- *
- * 0.9.8 (04/12/2000) david iacovelli
- *  Change interrupt read start when device is plugged in
- *  and stop when device is removed
- *      process interrupt reads when all ports are closed 
- *  (keep value of rxBytesAvail consistent with the edgeport)
- *  set the USB_BULK_QUEUE flag so that we can shove a bunch 
- *  of urbs at once down the pipe 
- *
- * 0.9.7 (04/10/2000) david iacovelli
- *      start to add enumeration code.
- *  generate serial number for epic devices
- *  add support for kdb
- *
- * 0.9.6 (03/30/2000) david iacovelli
- *  add IOCTL to get string, manufacture, and boot descriptors
- *
- * 0.9.5 (03/14/2000) greg kroah-hartman
- *      more error checking added to SerialOpen to try to fix UHCI open problem
- *
- * 0.9.4 (03/09/2000) greg kroah-hartman
- *      added more error checking to handle oops when data is hanging
- *      around and tty is abruptly closed.
- *
- * 0.9.3 (03/09/2000) david iacovelli
- *      Add epic support for xon/xoff chars
- *      play with performance
- *
- * 0.9.2 (03/08/2000) greg kroah-hartman
- *      changed most "info" calls to "dbg"
- *      implemented flow control properly in the termios call
- *
- * 0.9.1 (03/08/2000) david iacovelli
- *      added EPIC support
- *      enabled bootloader update
- *
- * 0.9 (03/08/2000) greg kroah-hartman
- *      Release to IO networks.
- *      Integrated changes that David made
- *  made getting urbs for writing SMP safe
- *
- * 0.8 (03/07/2000) greg kroah-hartman
- *      Release to IO networks.
- *      Fixed problems that were seen in code by David.
- *  Now both Edgeport/4 and Edgeport/2 works properly.
- *  Changed most of the functions to use port instead of serial.
- *
- * 0.7 (02/27/2000) greg kroah-hartman
- *      Milestone 3 release.
- *      Release to IO Networks
- *      ioctl for waiting on line change implemented.
- *      ioctl for getting statistics implemented.
- *      multiport support working.
- *      lsr and msr registers are now handled properly.
- *      change break now hooked up and working.
- *      support for all known Edgeport devices.
- *
- * 0.6 (02/22/2000) greg kroah-hartman
- *      Release to IO networks.
- *      CHASE is implemented correctly when port is closed.
- *      SerialOpen now blocks correctly until port is fully opened.
- *
- * 0.5 (02/20/2000) greg kroah-hartman
- *      Release to IO networks.
- *      Known problems:
- *              modem status register changes are not sent on to the user
- *              CHASE is not implemented when the port is closed.
- *
- * 0.4 (02/16/2000) greg kroah-hartman
- *      Second cut at the CeBit demo.
- *      Doesn't leak memory on every write to the port
- *      Still small leaks on startup.
- *      Added support for Edgeport/2 and Edgeport/8
- *
- * 0.3 (02/15/2000) greg kroah-hartman
- *      CeBit demo release.
- *      Force the line settings to 4800, 8, 1, e for the demo.
- *      Warning! This version leaks memory like crazy!
- *
- * 0.2 (01/30/2000) greg kroah-hartman
- *      Milestone 1 release.
- *      Device is found by USB subsystem, enumerated, fimware is downloaded
- *      and the descriptors are printed to the debug log, config is set, and
- *      green light starts to blink. Open port works, and data can be sent
- *      and received at the default settings of the UART. Loopback connector
- *      and debug log confirms this.
- * 
- * 0.1 (01/23/2000) greg kroah-hartman
- *      Initial release to help IO Networks try to set up their test system. 
- *      Edgeport4 is recognized, firmware is downloaded, config is set so 
- *      device blinks green light every 3 sec. Port is bound, but opening,
- *      closing, and sending data do not work properly.
- * 
  */
 
 #include <linux/config.h>
diff --git a/drivers/usb/serial/io_tables.h b/drivers/usb/serial/io_tables.h
index e7ffe02408bd..fad561c04c76 100644
--- a/drivers/usb/serial/io_tables.h
+++ b/drivers/usb/serial/io_tables.h
@@ -75,10 +75,12 @@ static struct usb_device_id id_table_combined [] = {
 
 MODULE_DEVICE_TABLE (usb, id_table_combined);
 
-static struct usb_serial_device_type edgeport_2port_device = {
-        .owner                  = THIS_MODULE,
-        .name                   = "Edgeport 2 port adapter",
-        .short_name             = "edgeport_2",
+static struct usb_serial_driver edgeport_2port_device = {
+        .driver = {
+                .owner          = THIS_MODULE,
+                .name           = "edgeport_2",
+        },
+        .description            = "Edgeport 2 port adapter",
         .id_table               = edgeport_2port_id_table,
         .num_interrupt_in       = 1,
         .num_bulk_in            = 1,
@@ -103,10 +105,12 @@ static struct usb_serial_device_type edgeport_2port_device = {
         .write_bulk_callback    = edge_bulk_out_data_callback,
 };
 
-static struct usb_serial_device_type edgeport_4port_device = {
-        .owner                  = THIS_MODULE,
-        .name                   = "Edgeport 4 port adapter",
-        .short_name             = "edgeport_4",
+static struct usb_serial_driver edgeport_4port_device = {
+        .driver = {
+                .owner          = THIS_MODULE,
+                .name           = "edgeport_4",
+        },
+        .description            = "Edgeport 4 port adapter",
         .id_table               = edgeport_4port_id_table,
         .num_interrupt_in       = 1,
         .num_bulk_in            = 1,
@@ -131,10 +135,12 @@ static struct usb_serial_device_type edgeport_4port_device = {
         .write_bulk_callback    = edge_bulk_out_data_callback,
 };
 
-static struct usb_serial_device_type edgeport_8port_device = {
-        .owner                  = THIS_MODULE,
-        .name                   = "Edgeport 8 port adapter",
-        .short_name             = "edgeport_8",
+static struct usb_serial_driver edgeport_8port_device = {
+        .driver = {
+                .owner          = THIS_MODULE,
+                .name           = "edgeport_8",
+        },
+        .description            = "Edgeport 8 port adapter",
         .id_table               = edgeport_8port_id_table,
         .num_interrupt_in       = 1,
         .num_bulk_in            = 1,
diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c
index ebf9967f7c86..832b6d6734c0 100644
--- a/drivers/usb/serial/io_ti.c
+++ b/drivers/usb/serial/io_ti.c
@@ -2982,10 +2982,12 @@ static unsigned int edge_buf_get(struct edge_buf *eb, char *buf,
 }
 
 
-static struct usb_serial_device_type edgeport_1port_device = {
-        .owner                  = THIS_MODULE,
-        .name                   = "Edgeport TI 1 port adapter",
-        .short_name             = "edgeport_ti_1",
+static struct usb_serial_driver edgeport_1port_device = {
+        .driver = {
+                .owner          = THIS_MODULE,
+                .name           = "edgeport_ti_1",
+        },
+        .description            = "Edgeport TI 1 port adapter",
         .id_table               = edgeport_1port_id_table,
         .num_interrupt_in       = 1,
         .num_bulk_in            = 1,
@@ -3010,10 +3012,12 @@ static struct usb_serial_device_type edgeport_1port_device = {
         .write_bulk_callback    = edge_bulk_out_callback,
 };
 
-static struct usb_serial_device_type edgeport_2port_device = {
-        .owner                  = THIS_MODULE,
-        .name                   = "Edgeport TI 2 port adapter",
-        .short_name             = "edgeport_ti_2",
+static struct usb_serial_driver edgeport_2port_device = {
+        .driver = {
+                .owner          = THIS_MODULE,
+                .name           = "edgeport_ti_2",
+        },
+        .description            = "Edgeport TI 2 port adapter",
         .id_table               = edgeport_2port_id_table,
         .num_interrupt_in       = 1,
         .num_bulk_in            = 2,
diff --git a/drivers/usb/serial/ipaq.c b/drivers/usb/serial/ipaq.c
index c05c2a2a0f31..d5d066488100 100644
--- a/drivers/usb/serial/ipaq.c
+++ b/drivers/usb/serial/ipaq.c
@@ -92,24 +92,7 @@ static void ipaq_destroy_lists(struct usb_serial_port *port);
 static struct usb_device_id ipaq_id_table [] = {
         /* The first entry is a placeholder for the insmod-specified device */
         { USB_DEVICE(0x049F, 0x0003) },
-        { USB_DEVICE(0x1690, 0x0601) }, /* Askey USB Sync */
-        { USB_DEVICE(0x0960, 0x0065) }, /* BCOM USB Sync 0065 */
-        { USB_DEVICE(0x0960, 0x0066) }, /* BCOM USB Sync 0066 */
-        { USB_DEVICE(0x0960, 0x0067) }, /* BCOM USB Sync 0067 */
-        { USB_DEVICE(0x07CF, 0x2001) }, /* CASIO USB Sync 2001 */
-        { USB_DEVICE(0x07CF, 0x2002) }, /* CASIO USB Sync 2002 */
-        { USB_DEVICE(0x07CF, 0x2003) }, /* CASIO USB Sync 2003 */
-        { USB_DEVICE(0x049F, 0x0003) }, /* Compaq iPAQ USB Sync */
-        { USB_DEVICE(0x049F, 0x0032) }, /* Compaq iPAQ USB Sync */
-        { USB_DEVICE(0x413C, 0x4001) }, /* Dell Axim USB Sync */
-        { USB_DEVICE(0x413C, 0x4002) }, /* Dell Axim USB Sync */
-        { USB_DEVICE(0x413C, 0x4003) }, /* Dell Axim USB Sync */
-        { USB_DEVICE(0x413C, 0x4004) }, /* Dell Axim USB Sync */
-        { USB_DEVICE(0x413C, 0x4005) }, /* Dell Axim USB Sync */
-        { USB_DEVICE(0x413C, 0x4006) }, /* Dell Axim USB Sync */
-        { USB_DEVICE(0x413C, 0x4007) }, /* Dell Axim USB Sync */
-        { USB_DEVICE(0x413C, 0x4008) }, /* Dell Axim USB Sync */
-        { USB_DEVICE(0x413C, 0x4009) }, /* Dell Axim USB Sync */
+        { USB_DEVICE(0x0104, 0x00BE) }, /* Socket USB Sync */
         { USB_DEVICE(0x03F0, 0x1016) }, /* HP USB Sync */
         { USB_DEVICE(0x03F0, 0x1116) }, /* HP USB Sync 1611 */
         { USB_DEVICE(0x03F0, 0x1216) }, /* HP USB Sync 1612 */
@@ -125,7 +108,13 @@ static struct usb_device_id ipaq_id_table [] = {
         { USB_DEVICE(0x03F0, 0x5016) }, /* HP USB Sync 1650 */
         { USB_DEVICE(0x03F0, 0x5116) }, /* HP USB Sync 1651 */
         { USB_DEVICE(0x03F0, 0x5216) }, /* HP USB Sync 1652 */
-        { USB_DEVICE(0x094B, 0x0001) }, /* Linkup Systems USB Sync */
+        { USB_DEVICE(0x0409, 0x00D5) }, /* NEC USB Sync */
+        { USB_DEVICE(0x0409, 0x00D6) }, /* NEC USB Sync */
+        { USB_DEVICE(0x0409, 0x00D7) }, /* NEC USB Sync */
+        { USB_DEVICE(0x0409, 0x8024) }, /* NEC USB Sync */
+        { USB_DEVICE(0x0409, 0x8025) }, /* NEC USB Sync */
+        { USB_DEVICE(0x043E, 0x9C01) }, /* LGE USB Sync */
+        { USB_DEVICE(0x045E, 0x00CE) }, /* Microsoft USB Sync */
         { USB_DEVICE(0x045E, 0x0400) }, /* Windows Powered Pocket PC 2002 */
         { USB_DEVICE(0x045E, 0x0401) }, /* Windows Powered Pocket PC 2002 */
         { USB_DEVICE(0x045E, 0x0402) }, /* Windows Powered Pocket PC 2002 */
@@ -251,17 +240,81 @@ static struct usb_device_id ipaq_id_table [] = {
         { USB_DEVICE(0x045E, 0x04E8) }, /* Windows Powered Smartphone 2003 */
         { USB_DEVICE(0x045E, 0x04E9) }, /* Windows Powered Smartphone 2003 */
         { USB_DEVICE(0x045E, 0x04EA) }, /* Windows Powered Smartphone 2003 */
-        { USB_DEVICE(0x0961, 0x0010) }, /* Portatec USB Sync */
-        { USB_DEVICE(0x5E04, 0xCE00) }, /* SAGEM Wireless Assistant */
-        { USB_DEVICE(0x0104, 0x00BE) }, /* Socket USB Sync */
+        { USB_DEVICE(0x049F, 0x0003) }, /* Compaq iPAQ USB Sync */
+        { USB_DEVICE(0x049F, 0x0032) }, /* Compaq iPAQ USB Sync */
+        { USB_DEVICE(0x04A4, 0x0014) }, /* Hitachi USB Sync */
+        { USB_DEVICE(0x04AD, 0x0301) }, /* USB Sync 0301 */
+        { USB_DEVICE(0x04AD, 0x0302) }, /* USB Sync 0302 */
+        { USB_DEVICE(0x04AD, 0x0303) }, /* USB Sync 0303 */
+        { USB_DEVICE(0x04C5, 0x1058) }, /* FUJITSU USB Sync */
+        { USB_DEVICE(0x04C5, 0x1079) }, /* FUJITSU USB Sync */
+        { USB_DEVICE(0x04DA, 0x2500) }, /* Panasonic USB Sync */
+        { USB_DEVICE(0x04E8, 0x5F00) }, /* Samsung NEXiO USB Sync */
+        { USB_DEVICE(0x04E8, 0x5F01) }, /* Samsung NEXiO USB Sync */
+        { USB_DEVICE(0x04E8, 0x5F02) }, /* Samsung NEXiO USB Sync */
+        { USB_DEVICE(0x04E8, 0x5F03) }, /* Samsung NEXiO USB Sync */
+        { USB_DEVICE(0x04E8, 0x5F04) }, /* Samsung NEXiO USB Sync */
+        { USB_DEVICE(0x04E8, 0x6611) }, /* Samsung MITs USB Sync */
+        { USB_DEVICE(0x04E8, 0x6613) }, /* Samsung MITs USB Sync */
+        { USB_DEVICE(0x04E8, 0x6615) }, /* Samsung MITs USB Sync */
+        { USB_DEVICE(0x04E8, 0x6617) }, /* Samsung MITs USB Sync */
+        { USB_DEVICE(0x04E8, 0x6619) }, /* Samsung MITs USB Sync */
+        { USB_DEVICE(0x04E8, 0x661B) }, /* Samsung MITs USB Sync */
+        { USB_DEVICE(0x04E8, 0x662E) }, /* Samsung MITs USB Sync */
+        { USB_DEVICE(0x04E8, 0x6630) }, /* Samsung MITs USB Sync */
+        { USB_DEVICE(0x04E8, 0x6632) }, /* Samsung MITs USB Sync */
+        { USB_DEVICE(0x04f1, 0x3011) }, /* JVC USB Sync */
+        { USB_DEVICE(0x04F1, 0x3012) }, /* JVC USB Sync */
+        { USB_DEVICE(0x0502, 0x1631) }, /* c10 Series */
+        { USB_DEVICE(0x0502, 0x1632) }, /* c20 Series */
+        { USB_DEVICE(0x0502, 0x16E1) }, /* Acer n10 Handheld USB Sync */
+        { USB_DEVICE(0x0502, 0x16E2) }, /* Acer n20 Handheld USB Sync */
+        { USB_DEVICE(0x0502, 0x16E3) }, /* Acer n30 Handheld USB Sync */
+        { USB_DEVICE(0x0536, 0x01A0) }, /* HHP PDT */
+        { USB_DEVICE(0x0543, 0x0ED9) }, /* ViewSonic Color Pocket PC V35 */
+        { USB_DEVICE(0x0543, 0x1527) }, /* ViewSonic Color Pocket PC V36 */
+        { USB_DEVICE(0x0543, 0x1529) }, /* ViewSonic Color Pocket PC V37 */
+        { USB_DEVICE(0x0543, 0x152B) }, /* ViewSonic Color Pocket PC V38 */
+        { USB_DEVICE(0x0543, 0x152E) }, /* ViewSonic Pocket PC */
+        { USB_DEVICE(0x0543, 0x1921) }, /* ViewSonic Communicator Pocket PC */
+        { USB_DEVICE(0x0543, 0x1922) }, /* ViewSonic Smartphone */
+        { USB_DEVICE(0x0543, 0x1923) }, /* ViewSonic Pocket PC V30 */
+        { USB_DEVICE(0x05E0, 0x2000) }, /* Symbol USB Sync */
+        { USB_DEVICE(0x05E0, 0x2001) }, /* Symbol USB Sync 0x2001 */
+        { USB_DEVICE(0x05E0, 0x2002) }, /* Symbol USB Sync 0x2002 */
+        { USB_DEVICE(0x05E0, 0x2003) }, /* Symbol USB Sync 0x2003 */
+        { USB_DEVICE(0x05E0, 0x2004) }, /* Symbol USB Sync 0x2004 */
+        { USB_DEVICE(0x05E0, 0x2005) }, /* Symbol USB Sync 0x2005 */
+        { USB_DEVICE(0x05E0, 0x2006) }, /* Symbol USB Sync 0x2006 */
+        { USB_DEVICE(0x05E0, 0x2007) }, /* Symbol USB Sync 0x2007 */
+        { USB_DEVICE(0x05E0, 0x2008) }, /* Symbol USB Sync 0x2008 */
+        { USB_DEVICE(0x05E0, 0x2009) }, /* Symbol USB Sync 0x2009 */
+        { USB_DEVICE(0x05E0, 0x200A) }, /* Symbol USB Sync 0x200A */
+        { USB_DEVICE(0x067E, 0x1001) }, /* Intermec Mobile Computer */
+        { USB_DEVICE(0x07CF, 0x2001) }, /* CASIO USB Sync 2001 */
+        { USB_DEVICE(0x07CF, 0x2002) }, /* CASIO USB Sync 2002 */
+        { USB_DEVICE(0x07CF, 0x2003) }, /* CASIO USB Sync 2003 */
         { USB_DEVICE(0x0930, 0x0700) }, /* TOSHIBA USB Sync 0700 */
         { USB_DEVICE(0x0930, 0x0705) }, /* TOSHIBA Pocket PC e310 */
+        { USB_DEVICE(0x0930, 0x0706) }, /* TOSHIBA Pocket PC e740 */
         { USB_DEVICE(0x0930, 0x0707) }, /* TOSHIBA Pocket PC e330 Series */
         { USB_DEVICE(0x0930, 0x0708) }, /* TOSHIBA Pocket PC e350 Series */
-        { USB_DEVICE(0x0930, 0x0706) }, /* TOSHIBA Pocket PC e740 */
         { USB_DEVICE(0x0930, 0x0709) }, /* TOSHIBA Pocket PC e750 Series */
         { USB_DEVICE(0x0930, 0x070A) }, /* TOSHIBA Pocket PC e400 Series */
         { USB_DEVICE(0x0930, 0x070B) }, /* TOSHIBA Pocket PC e800 Series */
+        { USB_DEVICE(0x094B, 0x0001) }, /* Linkup Systems USB Sync */
+        { USB_DEVICE(0x0960, 0x0065) }, /* BCOM USB Sync 0065 */
+        { USB_DEVICE(0x0960, 0x0066) }, /* BCOM USB Sync 0066 */
+        { USB_DEVICE(0x0960, 0x0067) }, /* BCOM USB Sync 0067 */
+        { USB_DEVICE(0x0961, 0x0010) }, /* Portatec USB Sync */
+        { USB_DEVICE(0x099E, 0x0052) }, /* Trimble GeoExplorer */
+        { USB_DEVICE(0x099E, 0x4000) }, /* TDS Data Collector */
+        { USB_DEVICE(0x0B05, 0x4200) }, /* ASUS USB Sync */
+        { USB_DEVICE(0x0B05, 0x4201) }, /* ASUS USB Sync */
+        { USB_DEVICE(0x0B05, 0x4202) }, /* ASUS USB Sync */
+        { USB_DEVICE(0x0B05, 0x420F) }, /* ASUS USB Sync */
+        { USB_DEVICE(0x0B05, 0x9200) }, /* ASUS USB Sync */
+        { USB_DEVICE(0x0B05, 0x9202) }, /* ASUS USB Sync */
         { USB_DEVICE(0x0BB4, 0x00CE) }, /* HTC USB Sync */
         { USB_DEVICE(0x0BB4, 0x0A01) }, /* PocketPC USB Sync */
         { USB_DEVICE(0x0BB4, 0x0A02) }, /* PocketPC USB Sync */
@@ -422,116 +475,67 @@ static struct usb_device_id ipaq_id_table [] = {
         { USB_DEVICE(0x0BB4, 0x0A9D) }, /* SmartPhone USB Sync */
         { USB_DEVICE(0x0BB4, 0x0A9E) }, /* SmartPhone USB Sync */
         { USB_DEVICE(0x0BB4, 0x0A9F) }, /* SmartPhone USB Sync */
-        { USB_DEVICE(0x0409, 0x00D5) }, /* NEC USB Sync */
-        { USB_DEVICE(0x0409, 0x00D6) }, /* NEC USB Sync */
-        { USB_DEVICE(0x0409, 0x00D7) }, /* NEC USB Sync */
-        { USB_DEVICE(0x0409, 0x8024) }, /* NEC USB Sync */
-        { USB_DEVICE(0x0409, 0x8025) }, /* NEC USB Sync */
-        { USB_DEVICE(0x04A4, 0x0014) }, /* Hitachi USB Sync */
         { USB_DEVICE(0x0BF8, 0x1001) }, /* Fujitsu Siemens Computers USB Sync */
-        { USB_DEVICE(0x0F98, 0x0201) }, /* Cyberbank USB Sync */
-        { USB_DEVICE(0x0502, 0x16E1) }, /* Acer n10 Handheld USB Sync */
-        { USB_DEVICE(0x0502, 0x16E3) }, /* Acer n30 Handheld USB Sync */
-        { USB_DEVICE(0x0502, 0x16E2) }, /* Acer n20 Handheld USB Sync */
-        { USB_DEVICE(0x0502, 0x1631) }, /* c10 Series */
-        { USB_DEVICE(0x0502, 0x1632) }, /* c20 Series */
-        { USB_DEVICE(0x0B05, 0x9202) }, /* ASUS USB Sync */
-        { USB_DEVICE(0x0B05, 0x420F) }, /* ASUS USB Sync */
-        { USB_DEVICE(0x0B05, 0x4200) }, /* ASUS USB Sync */
-        { USB_DEVICE(0x0B05, 0x4201) }, /* ASUS USB Sync */
-        { USB_DEVICE(0x0B05, 0x4202) }, /* ASUS USB Sync */
-        { USB_DEVICE(0x0B05, 0x9200) }, /* ASUS USB Sync */
+        { USB_DEVICE(0x0C44, 0x03A2) }, /* Motorola iDEN Smartphone */
         { USB_DEVICE(0x0C8E, 0x6000) }, /* Cesscom Luxian Series */
-        { USB_DEVICE(0x04AD, 0x0301) }, /* USB Sync 0301 */
-        { USB_DEVICE(0x04AD, 0x0302) }, /* USB Sync 0302 */
-        { USB_DEVICE(0x04AD, 0x0303) }, /* USB Sync 0303 */
+        { USB_DEVICE(0x0CAD, 0x9001) }, /* Motorola PowerPad Pocket PC Device */
+        { USB_DEVICE(0x0F4E, 0x0200) }, /* Freedom Scientific USB Sync */
+        { USB_DEVICE(0x0F98, 0x0201) }, /* Cyberbank USB Sync */
+        { USB_DEVICE(0x0FB8, 0x3001) }, /* Wistron USB Sync */
+        { USB_DEVICE(0x0FB8, 0x3002) }, /* Wistron USB Sync */
+        { USB_DEVICE(0x0FB8, 0x3003) }, /* Wistron USB Sync */
+        { USB_DEVICE(0x0FB8, 0x4001) }, /* Wistron USB Sync */
+        { USB_DEVICE(0x1066, 0x00CE) }, /* E-TEN USB Sync */
         { USB_DEVICE(0x1066, 0x0300) }, /* E-TEN P3XX Pocket PC */
         { USB_DEVICE(0x1066, 0x0500) }, /* E-TEN P5XX Pocket PC */
         { USB_DEVICE(0x1066, 0x0600) }, /* E-TEN P6XX Pocket PC */
         { USB_DEVICE(0x1066, 0x0700) }, /* E-TEN P7XX Pocket PC */
-        { USB_DEVICE(0x1066, 0x00CE) }, /* E-TEN USB Sync */
-        { USB_DEVICE(0x0F4E, 0x0200) }, /* Freedom Scientific USB Sync */
-        { USB_DEVICE(0x04C5, 0x1058) }, /* FUJITSU USB Sync */
-        { USB_DEVICE(0x04C5, 0x1079) }, /* FUJITSU USB Sync */
-        { USB_DEVICE(0x067E, 0x1001) }, /* Intermec Mobile Computer */
-        { USB_DEVICE(0x04f1, 0x3011) }, /* JVC USB Sync */
-        { USB_DEVICE(0x04F1, 0x3012) }, /* JVC USB Sync */
-        { USB_DEVICE(0x3708, 0x20CE) }, /* Legend USB Sync */
-        { USB_DEVICE(0x3708, 0x21CE) }, /* Lenovo USB Sync */
-        { USB_DEVICE(0x043E, 0x9C01) }, /* LGE USB Sync */
-        { USB_DEVICE(0x04DA, 0x2500) }, /* Panasonic USB Sync */
-        { USB_DEVICE(0x3340, 0x0B1C) }, /* Generic PPC StrongARM */
-        { USB_DEVICE(0x3340, 0x0E3A) }, /* Generic PPC USB Sync */
-        { USB_DEVICE(0x3340, 0x0F3A) }, /* Generic SmartPhone USB Sync */
-        { USB_DEVICE(0x3340, 0x0F1C) }, /* Itautec USB Sync */
-        { USB_DEVICE(0x3340, 0x1326) }, /* Itautec USB Sync */
-        { USB_DEVICE(0x3340, 0x3326) }, /* MEDION Winodws Moble USB Sync */
+        { USB_DEVICE(0x1114, 0x0001) }, /* Psion Teklogix Sync 753x */
+        { USB_DEVICE(0x1114, 0x0004) }, /* Psion Teklogix Sync netBookPro */
+        { USB_DEVICE(0x1114, 0x0006) }, /* Psion Teklogix Sync 7525 */
+        { USB_DEVICE(0x1182, 0x1388) }, /* VES USB Sync */
+        { USB_DEVICE(0x11D9, 0x1002) }, /* Rugged Pocket PC 2003 */
+        { USB_DEVICE(0x11D9, 0x1003) }, /* Rugged Pocket PC 2003 */
+        { USB_DEVICE(0x1231, 0xCE01) }, /* USB Sync 03 */
+        { USB_DEVICE(0x1231, 0xCE02) }, /* USB Sync 03 */
+        { USB_DEVICE(0x1690, 0x0601) }, /* Askey USB Sync */
+        { USB_DEVICE(0x22B8, 0x4204) }, /* Motorola MPx200 Smartphone */
+        { USB_DEVICE(0x22B8, 0x4214) }, /* Motorola MPc GSM */
+        { USB_DEVICE(0x22B8, 0x4224) }, /* Motorola MPx220 Smartphone */
+        { USB_DEVICE(0x22B8, 0x4234) }, /* Motorola MPc CDMA */
+        { USB_DEVICE(0x22B8, 0x4244) }, /* Motorola MPx100 Smartphone */
+        { USB_DEVICE(0x3340, 0x011C) }, /* Mio DigiWalker PPC StrongARM */
         { USB_DEVICE(0x3340, 0x0326) }, /* Mio DigiWalker 338 */
         { USB_DEVICE(0x3340, 0x0426) }, /* Mio DigiWalker 338 */
-        { USB_DEVICE(0x3340, 0x011C) }, /* Mio DigiWalker PPC StrongARM */
-        { USB_DEVICE(0x3340, 0x053A) }, /* Mio DigiWalker SmartPhone USB Sync */
         { USB_DEVICE(0x3340, 0x043A) }, /* Mio DigiWalker USB Sync */
-        { USB_DEVICE(0x3340, 0x071C) }, /* MiTAC USB Sync */
         { USB_DEVICE(0x3340, 0x051C) }, /* MiTAC USB Sync 528 */
-        { USB_DEVICE(0x3340, 0x2326) }, /* Vobis USB Sync */
+        { USB_DEVICE(0x3340, 0x053A) }, /* Mio DigiWalker SmartPhone USB Sync */
+        { USB_DEVICE(0x3340, 0x071C) }, /* MiTAC USB Sync */
+        { USB_DEVICE(0x3340, 0x0B1C) }, /* Generic PPC StrongARM */
+        { USB_DEVICE(0x3340, 0x0E3A) }, /* Generic PPC USB Sync */
+        { USB_DEVICE(0x3340, 0x0F1C) }, /* Itautec USB Sync */
+        { USB_DEVICE(0x3340, 0x0F3A) }, /* Generic SmartPhone USB Sync */
+        { USB_DEVICE(0x3340, 0x1326) }, /* Itautec USB Sync */
         { USB_DEVICE(0x3340, 0x191C) }, /* YAKUMO USB Sync */
+        { USB_DEVICE(0x3340, 0x2326) }, /* Vobis USB Sync */
+        { USB_DEVICE(0x3340, 0x3326) }, /* MEDION Winodws Moble USB Sync */
+        { USB_DEVICE(0x3708, 0x20CE) }, /* Legend USB Sync */
+        { USB_DEVICE(0x3708, 0x21CE) }, /* Lenovo USB Sync */
         { USB_DEVICE(0x4113, 0x0210) }, /* Mobile Media Technology USB Sync */
         { USB_DEVICE(0x4113, 0x0211) }, /* Mobile Media Technology USB Sync */
         { USB_DEVICE(0x4113, 0x0400) }, /* Mobile Media Technology USB Sync */
         { USB_DEVICE(0x4113, 0x0410) }, /* Mobile Media Technology USB Sync */
-        { USB_DEVICE(0x0CAD, 0x9001) }, /* Motorola PowerPad Pocket PC Device */
-        { USB_DEVICE(0x0C44, 0x03A2) }, /* Motorola iDEN Smartphone */
-        { USB_DEVICE(0x04E8, 0x6611) }, /* Samsung MITs USB Sync */
-        { USB_DEVICE(0x04E8, 0x6613) }, /* Samsung MITs USB Sync */
-        { USB_DEVICE(0x04E8, 0x6615) }, /* Samsung MITs USB Sync */
-        { USB_DEVICE(0x04E8, 0x6617) }, /* Samsung MITs USB Sync */
-        { USB_DEVICE(0x04E8, 0x6619) }, /* Samsung MITs USB Sync */
-        { USB_DEVICE(0x04E8, 0x661B) }, /* Samsung MITs USB Sync */
-        { USB_DEVICE(0x04E8, 0x5F00) }, /* Samsung NEXiO USB Sync */
-        { USB_DEVICE(0x04E8, 0x5F01) }, /* Samsung NEXiO USB Sync */
-        { USB_DEVICE(0x04E8, 0x5F02) }, /* Samsung NEXiO USB Sync */
-        { USB_DEVICE(0x04E8, 0x5F03) }, /* Samsung NEXiO USB Sync */
-        { USB_DEVICE(0x04E8, 0x5F04) }, /* Samsung NEXiO USB Sync */
-        { USB_DEVICE(0x04E8, 0x662E) }, /* Samsung MITs USB Sync */
-        { USB_DEVICE(0x04E8, 0x6630) }, /* Samsung MITs USB Sync */
-        { USB_DEVICE(0x04E8, 0x6632) }, /* Samsung MITs USB Sync */
+        { USB_DEVICE(0x413C, 0x4001) }, /* Dell Axim USB Sync */
+        { USB_DEVICE(0x413C, 0x4002) }, /* Dell Axim USB Sync */
+        { USB_DEVICE(0x413C, 0x4003) }, /* Dell Axim USB Sync */
+        { USB_DEVICE(0x413C, 0x4004) }, /* Dell Axim USB Sync */
+        { USB_DEVICE(0x413C, 0x4005) }, /* Dell Axim USB Sync */
+        { USB_DEVICE(0x413C, 0x4006) }, /* Dell Axim USB Sync */
+        { USB_DEVICE(0x413C, 0x4007) }, /* Dell Axim USB Sync */
+        { USB_DEVICE(0x413C, 0x4008) }, /* Dell Axim USB Sync */
+        { USB_DEVICE(0x413C, 0x4009) }, /* Dell Axim USB Sync */
         { USB_DEVICE(0x4505, 0x0010) }, /* Smartphone */
-        { USB_DEVICE(0x05E0, 0x2000) }, /* Symbol USB Sync */
-        { USB_DEVICE(0x05E0, 0x2001) }, /* Symbol USB Sync 0x2001 */
-        { USB_DEVICE(0x05E0, 0x2002) }, /* Symbol USB Sync 0x2002 */
-        { USB_DEVICE(0x05E0, 0x2003) }, /* Symbol USB Sync 0x2003 */
-        { USB_DEVICE(0x05E0, 0x2004) }, /* Symbol USB Sync 0x2004 */
-        { USB_DEVICE(0x05E0, 0x2005) }, /* Symbol USB Sync 0x2005 */
-        { USB_DEVICE(0x05E0, 0x2006) }, /* Symbol USB Sync 0x2006 */
-        { USB_DEVICE(0x05E0, 0x2007) }, /* Symbol USB Sync 0x2007 */
-        { USB_DEVICE(0x05E0, 0x2008) }, /* Symbol USB Sync 0x2008 */
-        { USB_DEVICE(0x05E0, 0x2009) }, /* Symbol USB Sync 0x2009 */
-        { USB_DEVICE(0x05E0, 0x200A) }, /* Symbol USB Sync 0x200A */
-        { USB_DEVICE(0x1182, 0x1388) }, /* VES USB Sync */
-        { USB_DEVICE(0x0543, 0x0ED9) }, /* ViewSonic Color Pocket PC V35 */
-        { USB_DEVICE(0x0543, 0x1527) }, /* ViewSonic Color Pocket PC V36 */
-        { USB_DEVICE(0x0543, 0x1529) }, /* ViewSonic Color Pocket PC V37 */
-        { USB_DEVICE(0x0543, 0x152B) }, /* ViewSonic Color Pocket PC V38 */
-        { USB_DEVICE(0x0543, 0x152E) }, /* ViewSonic Pocket PC */
-        { USB_DEVICE(0x0543, 0x1921) }, /* ViewSonic Communicator Pocket PC */
-        { USB_DEVICE(0x0543, 0x1922) }, /* ViewSonic Smartphone */
-        { USB_DEVICE(0x0543, 0x1923) }, /* ViewSonic Pocket PC V30 */
-        { USB_DEVICE(0x0536, 0x01A0) }, /* HHP PDT */
-        { USB_DEVICE(0x099E, 0x0052) }, /* Trimble GeoExplorer */
-        { USB_DEVICE(0x099E, 0x4000) }, /* TDS Data Collector */
-        { USB_DEVICE(0x0FB8, 0x3001) }, /* Wistron USB Sync */
-        { USB_DEVICE(0x0FB8, 0x3002) }, /* Wistron USB Sync */
-        { USB_DEVICE(0x0FB8, 0x3003) }, /* Wistron USB Sync */
-        { USB_DEVICE(0x0FB8, 0x4001) }, /* Wistron USB Sync */
-        { USB_DEVICE(0x11D9, 0x1003) }, /* Rugged Pocket PC 2003 */
-        { USB_DEVICE(0x11D9, 0x1002) }, /* Rugged Pocket PC 2003 */
-        { USB_DEVICE(0x22B8, 0x4204) }, /* Motorola MPx200 Smartphone */
-        { USB_DEVICE(0x22B8, 0x4214) }, /* Motorola MPc GSM */
-        { USB_DEVICE(0x22B8, 0x4224) }, /* Motorola MPx220 Smartphone */
-        { USB_DEVICE(0x22B8, 0x4234) }, /* Motorola MPc CDMA */
-        { USB_DEVICE(0x22B8, 0x4244) }, /* Motorola MPx100 Smartphone */
-        { USB_DEVICE(0x1231, 0xCE01) }, /* USB Sync 03 */
-        { USB_DEVICE(0x1231, 0xCE02) }, /* USB Sync 03 */
+        { USB_DEVICE(0x5E04, 0xCE00) }, /* SAGEM Wireless Assistant */
         { }                             /* Terminating entry */
 };
 
@@ -547,9 +551,12 @@ static struct usb_driver ipaq_driver = {
 
 
 /* All of the device info needed for the Compaq iPAQ */
-static struct usb_serial_device_type ipaq_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "PocketPC PDA",
+static struct usb_serial_driver ipaq_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "ipaq",
+        },
+        .description =          "PocketPC PDA",
         .id_table =             ipaq_id_table,
         .num_interrupt_in =     NUM_DONT_CARE,
         .num_bulk_in =          1,
diff --git a/drivers/usb/serial/ipw.c b/drivers/usb/serial/ipw.c
index 85e242459c27..a02fada85362 100644
--- a/drivers/usb/serial/ipw.c
+++ b/drivers/usb/serial/ipw.c
@@ -443,10 +443,12 @@ static int ipw_disconnect(struct usb_serial_port *port)
         return 0;
 }
 
-static struct usb_serial_device_type ipw_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "IPWireless converter",
-        .short_name =           "ipw",
+static struct usb_serial_driver ipw_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "ipw",
+        },
+        .description =          "IPWireless converter",
         .id_table =             usb_ipw_ids,
         .num_interrupt_in =     NUM_DONT_CARE,
         .num_bulk_in =          1,
diff --git a/drivers/usb/serial/ir-usb.c b/drivers/usb/serial/ir-usb.c
index 937b2fdd7171..19f329e9bdcf 100644
--- a/drivers/usb/serial/ir-usb.c
+++ b/drivers/usb/serial/ir-usb.c
@@ -133,9 +133,12 @@ static struct usb_driver ir_driver = {
 };
 
 
-static struct usb_serial_device_type ir_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "IR Dongle",
+static struct usb_serial_driver ir_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "ir-usb",
+        },
+        .description =          "IR Dongle",
         .id_table =             id_table,
         .num_interrupt_in =     1,
         .num_bulk_in =          1,
diff --git a/drivers/usb/serial/keyspan.h b/drivers/usb/serial/keyspan.h
index e9b45b768aca..5cfc13b5e56f 100644
--- a/drivers/usb/serial/keyspan.h
+++ b/drivers/usb/serial/keyspan.h
@@ -570,10 +570,12 @@ static struct usb_device_id keyspan_4port_ids[] = {
 };
 
 /* Structs for the devices, pre and post renumeration. */
-static struct usb_serial_device_type keyspan_pre_device = {
-        .owner                  = THIS_MODULE,
-        .name                   = "Keyspan - (without firmware)",
-        .short_name             = "keyspan_no_firm",
+static struct usb_serial_driver keyspan_pre_device = {
+        .driver = {
+                .owner          = THIS_MODULE,
+                .name           = "keyspan_no_firm",
+        },
+        .description            = "Keyspan - (without firmware)",
         .id_table               = keyspan_pre_ids,
         .num_interrupt_in       = NUM_DONT_CARE,
         .num_bulk_in            = NUM_DONT_CARE,
@@ -582,10 +584,12 @@ static struct usb_serial_device_type keyspan_pre_device = {
         .attach                 = keyspan_fake_startup,
 };
 
-static struct usb_serial_device_type keyspan_1port_device = {
-        .owner                  = THIS_MODULE,
-        .name                   = "Keyspan 1 port adapter",
-        .short_name             = "keyspan_1",
+static struct usb_serial_driver keyspan_1port_device = {
+        .driver = {
+                .owner          = THIS_MODULE,
+                .name           = "keyspan_1",
+        },
+        .description            = "Keyspan 1 port adapter",
         .id_table               = keyspan_1port_ids,
         .num_interrupt_in       = NUM_DONT_CARE,
         .num_bulk_in            = NUM_DONT_CARE,
@@ -607,10 +611,12 @@ static struct usb_serial_device_type keyspan_1port_device = {
         .shutdown               = keyspan_shutdown,
 };
 
-static struct usb_serial_device_type keyspan_2port_device = {
-        .owner                  = THIS_MODULE,
-        .name                   = "Keyspan 2 port adapter",
-        .short_name             = "keyspan_2",
+static struct usb_serial_driver keyspan_2port_device = {
+        .driver = {
+                .owner          = THIS_MODULE,
+                .name           = "keyspan_2",
+        },
+        .description            = "Keyspan 2 port adapter",
         .id_table               = keyspan_2port_ids,
         .num_interrupt_in       = NUM_DONT_CARE,
         .num_bulk_in            = NUM_DONT_CARE,
@@ -632,10 +638,12 @@ static struct usb_serial_device_type keyspan_2port_device = {
         .shutdown               = keyspan_shutdown,
 };
 
-static struct usb_serial_device_type keyspan_4port_device = {
-        .owner                  = THIS_MODULE,
-        .name                   = "Keyspan 4 port adapter",
-        .short_name             = "keyspan_4",
+static struct usb_serial_driver keyspan_4port_device = {
+        .driver = {
+                .owner          = THIS_MODULE,
+                .name           = "keyspan_4",
+        },
+        .description            = "Keyspan 4 port adapter",
         .id_table               = keyspan_4port_ids,
         .num_interrupt_in       = NUM_DONT_CARE,
         .num_bulk_in            = 5,
diff --git a/drivers/usb/serial/keyspan_pda.c b/drivers/usb/serial/keyspan_pda.c
index 635c384cb15a..cd4f48bd83b6 100644
--- a/drivers/usb/serial/keyspan_pda.c
+++ b/drivers/usb/serial/keyspan_pda.c
@@ -783,10 +783,12 @@ static void keyspan_pda_shutdown (struct usb_serial *serial)
 }
 
 #ifdef KEYSPAN
-static struct usb_serial_device_type keyspan_pda_fake_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "Keyspan PDA - (prerenumeration)",
-        .short_name =           "keyspan_pda_pre",
+static struct usb_serial_driver keyspan_pda_fake_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "keyspan_pda_pre",
+        },
+        .description =          "Keyspan PDA - (prerenumeration)",
         .id_table =             id_table_fake,
         .num_interrupt_in =     NUM_DONT_CARE,
         .num_bulk_in =          NUM_DONT_CARE,
@@ -797,10 +799,12 @@ static struct usb_serial_device_type keyspan_pda_fake_device = {
 #endif
 
 #ifdef XIRCOM
-static struct usb_serial_device_type xircom_pgs_fake_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "Xircom / Entregra PGS - (prerenumeration)",
-        .short_name =           "xircom_no_firm",
+static struct usb_serial_driver xircom_pgs_fake_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "xircom_no_firm",
+        },
+        .description =          "Xircom / Entregra PGS - (prerenumeration)",
         .id_table =             id_table_fake_xircom,
         .num_interrupt_in =     NUM_DONT_CARE,
         .num_bulk_in =          NUM_DONT_CARE,
@@ -810,10 +814,12 @@ static struct usb_serial_device_type xircom_pgs_fake_device = {
 };
 #endif
 
-static struct usb_serial_device_type keyspan_pda_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "Keyspan PDA",
-        .short_name =           "keyspan_pda",
+static struct usb_serial_driver keyspan_pda_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "keyspan_pda",
+        },
+        .description =          "Keyspan PDA",
         .id_table =             id_table_std,
         .num_interrupt_in =     1,
         .num_bulk_in =          0,
diff --git a/drivers/usb/serial/kl5kusb105.c b/drivers/usb/serial/kl5kusb105.c
index a11e829e38c8..a8951c0fd020 100644
--- a/drivers/usb/serial/kl5kusb105.c
+++ b/drivers/usb/serial/kl5kusb105.c
@@ -123,10 +123,12 @@ static struct usb_driver kl5kusb105d_driver = {
         .id_table =     id_table,
 };
 
-static struct usb_serial_device_type kl5kusb105d_device = {
-        .owner =             THIS_MODULE,
-        .name =              "KL5KUSB105D / PalmConnect",
-        .short_name =        "kl5kusb105d",
+static struct usb_serial_driver kl5kusb105d_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "kl5kusb105d",
+        },
+        .description =       "KL5KUSB105D / PalmConnect",
         .id_table =          id_table,
         .num_interrupt_in =  1,
         .num_bulk_in =       1,
diff --git a/drivers/usb/serial/kobil_sct.c b/drivers/usb/serial/kobil_sct.c
index fe4c98a75171..9456dd9dd136 100644
--- a/drivers/usb/serial/kobil_sct.c
+++ b/drivers/usb/serial/kobil_sct.c
@@ -105,9 +105,12 @@ static struct usb_driver kobil_driver = {
 };
 
 
-static struct usb_serial_device_type kobil_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "KOBIL USB smart card terminal",
+static struct usb_serial_driver kobil_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "kobil",
+        },
+        .description =          "KOBIL USB smart card terminal",
         .id_table =             id_table,
         .num_interrupt_in =     NUM_DONT_CARE,
         .num_bulk_in =          0,
diff --git a/drivers/usb/serial/mct_u232.c b/drivers/usb/serial/mct_u232.c
index 50b6369647d2..ca5dbadb9b7e 100644
--- a/drivers/usb/serial/mct_u232.c
+++ b/drivers/usb/serial/mct_u232.c
@@ -132,10 +132,12 @@ static struct usb_driver mct_u232_driver = {
         .id_table =     id_table_combined,
 };
 
-static struct usb_serial_device_type mct_u232_device = {
-        .owner =             THIS_MODULE,
-        .name =              "MCT U232",
-        .short_name =        "mct_u232",
+static struct usb_serial_driver mct_u232_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "mct_u232",
+        },
+        .description =       "MCT U232",
         .id_table =          id_table_combined,
         .num_interrupt_in =  2,
         .num_bulk_in =       0,
diff --git a/drivers/usb/serial/nokia_dku2.c b/drivers/usb/serial/nokia_dku2.c
new file mode 100644
index 000000000000..fad01bef3a64
--- /dev/null
+++ b/drivers/usb/serial/nokia_dku2.c
@@ -0,0 +1,142 @@
+/*
+ *  Nokia DKU2 USB driver
+ *
+ *  Copyright (C) 2004
+ *  Author: C Kemp
+ *
+ *  This program is largely derived from work by the linux-usb group
+ *  and associated source files.  Please see the usb/serial files for
+ *  individual credits and copyrights.
+ *
+ *  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.
+ *
+ *  20.09.2005 - Matthias Blaesing <matthias.blaesing@rwth-aachen.de>
+ *  Added short name to device structure to make driver load into kernel 2.6.13
+ *
+ *  20.09.2005 - Matthias Blaesing <matthias.blaesing@rwth-aachen.de>
+ *  Added usb_deregister to exit code - to allow remove and reinsert of module
+ */
+
+
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/tty.h>
+#include <linux/tty_driver.h>
+#include <linux/tty_flip.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include "usb-serial.h"
+
+
+#define NOKIA_VENDOR_ID         0x0421
+#define NOKIA7600_PRODUCT_ID    0x0400
+#define NOKIA6230_PRODUCT_ID    0x040f
+#define NOKIA6170_PRODUCT_ID    0x0416
+#define NOKIA6670_PRODUCT_ID    0x041d
+#define NOKIA6680_PRODUCT_ID    0x041e
+#define NOKIA6230i_PRODUCT_ID   0x0428
+
+#define NOKIA_AT_PORT   0x82
+#define NOKIA_FBUS_PORT 0x86
+
+/*
+ * Version Information
+ */
+#define DRIVER_VERSION  "v0.2"
+#define DRIVER_AUTHOR   "C Kemp"
+#define DRIVER_DESC     "Nokia DKU2 Driver"
+
+static struct usb_device_id id_table [] = {
+        { USB_DEVICE(NOKIA_VENDOR_ID, NOKIA7600_PRODUCT_ID) },
+        { USB_DEVICE(NOKIA_VENDOR_ID, NOKIA6230_PRODUCT_ID) },
+        { USB_DEVICE(NOKIA_VENDOR_ID, NOKIA6170_PRODUCT_ID) },
+        { USB_DEVICE(NOKIA_VENDOR_ID, NOKIA6670_PRODUCT_ID) },
+        { USB_DEVICE(NOKIA_VENDOR_ID, NOKIA6680_PRODUCT_ID) },
+        { USB_DEVICE(NOKIA_VENDOR_ID, NOKIA6230i_PRODUCT_ID) },
+        { }                     /* Terminating entry */
+};
+MODULE_DEVICE_TABLE(usb, id_table);
+
+/* The only thing which makes this device different from a generic
+ * device is that we have to set an alternative configuration to make
+ * the relevant endpoints available. In 2.6 this is really easy... */
+static int nokia_probe(struct usb_serial *serial,
+                       const struct usb_device_id *id)
+{
+        int retval = -ENODEV;
+
+        if (serial->interface->altsetting[0].endpoint[0].desc.bEndpointAddress == NOKIA_AT_PORT) {
+                /* the AT port */
+                dev_info(&serial->dev->dev, "Nokia AT Port:\n");
+                retval = 0;
+        } else if (serial->interface->num_altsetting == 2 &&
+                   serial->interface->altsetting[1].endpoint[0].desc.bEndpointAddress == NOKIA_FBUS_PORT) {
+                /* the FBUS port */
+                dev_info(&serial->dev->dev, "Nokia FBUS Port:\n");
+                usb_set_interface(serial->dev, 10, 1);
+                retval = 0;
+        }
+
+        return retval;
+}
+
+static struct usb_driver nokia_driver = {
+        .owner =        THIS_MODULE,
+        .name =         "nokia_dku2",
+        .probe =        usb_serial_probe,
+        .disconnect =   usb_serial_disconnect,
+        .id_table =     id_table,
+};
+
+static struct usb_serial_driver nokia_serial_driver = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "nokia_dku2",
+        },
+        .description =          "Nokia 7600/6230(i)/6170/66x0 DKU2 driver",
+        .id_table =             id_table,
+        .num_interrupt_in =     1,
+        .num_bulk_in =          1,
+        .num_bulk_out =         1,
+        .num_ports =            1,
+        .probe =                nokia_probe,
+};
+
+static int __init nokia_init(void)
+{
+        int retval;
+
+        retval = usb_serial_register(&nokia_serial_driver);
+        if (retval)
+                return retval;
+
+        retval = usb_register(&nokia_driver);
+        if (retval) {
+                usb_serial_deregister(&nokia_serial_driver);
+                return retval;
+        }
+
+        info(DRIVER_VERSION " " DRIVER_AUTHOR);
+        info(DRIVER_DESC);
+
+        return retval;
+}
+
+static void __exit nokia_exit(void)
+{
+        usb_deregister(&nokia_driver);
+        usb_serial_deregister(&nokia_serial_driver);
+}
+
+module_init(nokia_init);
+module_exit(nokia_exit);
+
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
diff --git a/drivers/usb/serial/omninet.c b/drivers/usb/serial/omninet.c
index 6a99ae192df1..3caf97072ac0 100644
--- a/drivers/usb/serial/omninet.c
+++ b/drivers/usb/serial/omninet.c
@@ -88,10 +88,12 @@ static struct usb_driver omninet_driver = {
 };
 
 
-static struct usb_serial_device_type zyxel_omninet_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "ZyXEL - omni.net lcd plus usb",
-        .short_name =           "omninet",
+static struct usb_serial_driver zyxel_omninet_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "omninet",
+        },
+        .description =          "ZyXEL - omni.net lcd plus usb",
         .id_table =             id_table,
         .num_interrupt_in =     1,
         .num_bulk_in =          1,
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 4989e5740d18..7716000045b7 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -105,10 +105,12 @@ static struct usb_driver option_driver = {
 /* The card has three separate interfaces, wich the serial driver
  * recognizes separately, thus num_port=1.
  */
-static struct usb_serial_device_type option_3port_device = {
-        .owner             = THIS_MODULE,
-        .name              = "Option 3G data card",
-        .short_name        = "option",
+static struct usb_serial_driver option_3port_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "option",
+        },
+        .description       = "Option 3G data card",
         .id_table          = option_ids,
         .num_interrupt_in  = NUM_DONT_CARE,
         .num_bulk_in       = NUM_DONT_CARE,
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index 3cf245bdda54..165c119bf10e 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -8,31 +8,10 @@
  *
  *      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.
+ *      the Free Software Foundation; either version 2 of the License.
  *
  * See Documentation/usb/usb-serial.txt for more information on using this driver
  *
- * 2002_Mar_26 gkh
- *      allowed driver to work properly if there is no tty assigned to a port
- *      (this happens for serial console devices.)
- *
- * 2001_Oct_06 gkh
- *      Added RTS and DTR line control.  Thanks to joe@bndlg.de for parts of it.
- *
- * 2001_Sep_19 gkh
- *      Added break support.
- *
- * 2001_Aug_30 gkh
- *      fixed oops in write_bulk_callback.
- *
- * 2001_Aug_28 gkh
- *      reworked buffer logic to be like other usb-serial drivers.  Hopefully
- *      removing some reported problems.
- *
- * 2001_Jun_06 gkh
- *      finished porting to 2.4 format.
- * 
  */
 
 #include <linux/config.h>
@@ -55,7 +34,6 @@
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v0.12"
 #define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver"
 
 static int debug;
@@ -175,9 +153,11 @@ static unsigned int pl2303_buf_get(struct pl2303_buf *pb, char *buf,
 
 
 /* All of the device info needed for the PL2303 SIO serial converter */
-static struct usb_serial_device_type pl2303_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "PL-2303",
+static struct usb_serial_driver pl2303_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "pl2303",
+        },
         .id_table =             id_table,
         .num_interrupt_in =     NUM_DONT_CARE,
         .num_bulk_in =          1,
@@ -1195,7 +1175,7 @@ static int __init pl2303_init (void)
         retval = usb_register(&pl2303_driver);
         if (retval)
                 goto failed_usb_register;
-        info(DRIVER_DESC " " DRIVER_VERSION);
+        info(DRIVER_DESC);
         return 0;
 failed_usb_register:
         usb_serial_deregister(&pl2303_device);
@@ -1215,7 +1195,6 @@ module_init(pl2303_init);
 module_exit(pl2303_exit);
 
 MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_VERSION(DRIVER_VERSION);
 MODULE_LICENSE("GPL");
 
 module_param(debug, bool, S_IRUGO | S_IWUSR);
diff --git a/drivers/usb/serial/safe_serial.c b/drivers/usb/serial/safe_serial.c
index 96a17568cbf1..c22bdc0c4dfd 100644
--- a/drivers/usb/serial/safe_serial.c
+++ b/drivers/usb/serial/safe_serial.c
@@ -92,7 +92,7 @@ MODULE_DESCRIPTION (DRIVER_DESC);
 MODULE_LICENSE("GPL");
 
 #if defined(CONFIG_USBD_SAFE_SERIAL_VENDOR) && !defined(CONFIG_USBD_SAFE_SERIAL_PRODUCT)
-#abort "SAFE_SERIAL_VENDOR defined without SAFE_SERIAL_PRODUCT"
+#error "SAFE_SERIAL_VENDOR defined without SAFE_SERIAL_PRODUCT"
 #endif
 
 #if ! defined(CONFIG_USBD_SAFE_SERIAL_VENDOR)
@@ -397,9 +397,11 @@ static int safe_startup (struct usb_serial *serial)
         return 0;
 }
 
-static struct usb_serial_device_type safe_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "Safe",
+static struct usb_serial_driver safe_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "safe_serial",
+        },
         .id_table =             id_table,
         .num_interrupt_in =     NUM_DONT_CARE,
         .num_bulk_in =          NUM_DONT_CARE,
diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c
index 59c88de3e7ae..205dbf7201da 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.c
+++ b/drivers/usb/serial/ti_usb_3410_5052.c
@@ -255,9 +255,12 @@ static struct usb_driver ti_usb_driver = {
         .id_table               = ti_id_table_combined,
 };
 
-static struct usb_serial_device_type ti_1port_device = {
-        .owner                  = THIS_MODULE,
-        .name                   = "TI USB 3410 1 port adapter",
+static struct usb_serial_driver ti_1port_device = {
+        .driver = {
+                .owner          = THIS_MODULE,
+                .name           = "ti_usb_3410_5052_1",
+        },
+        .description            = "TI USB 3410 1 port adapter",
         .id_table               = ti_id_table_3410,
         .num_interrupt_in       = 1,
         .num_bulk_in            = 1,
@@ -282,9 +285,12 @@ static struct usb_serial_device_type ti_1port_device = {
         .write_bulk_callback    = ti_bulk_out_callback,
 };
 
-static struct usb_serial_device_type ti_2port_device = {
-        .owner                  = THIS_MODULE,
-        .name                   = "TI USB 5052 2 port adapter",
+static struct usb_serial_driver ti_2port_device = {
+        .driver = {
+                .owner          = THIS_MODULE,
+                .name           = "ti_usb_3410_5052_2",
+        },
+        .description            = "TI USB 5052 2 port adapter",
         .id_table               = ti_id_table_5052,
         .num_interrupt_in       = 1,
         .num_bulk_in            = 2,
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index e77fbdfc782d..0c4881d18cd5 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -1,7 +1,7 @@
 /*
  * USB Serial Converter driver
  *
- * Copyright (C) 1999 - 2004 Greg Kroah-Hartman (greg@kroah.com)
+ * Copyright (C) 1999 - 2005 Greg Kroah-Hartman (greg@kroah.com)
  * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
  * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com)
  *
@@ -9,316 +9,11 @@
  *      modify it under the terms of the GNU General Public License version
  *      2 as published by the Free Software Foundation.
  *
- * This driver was originally based on the ACM driver by Armin Fuerst (which was 
+ * This driver was originally based on the ACM driver by Armin Fuerst (which was
  * based on a driver by Brad Keryan)
  *
  * See Documentation/usb/usb-serial.txt for more information on using this driver
  *
- * (12/10/2002) gkh
- *      Split the ports off into their own struct device, and added a
- *      usb-serial bus driver.
- *
- * (11/19/2002) gkh
- *      removed a few #ifdefs for the generic code and cleaned up the failure
- *      logic in initialization.
- *
- * (10/02/2002) gkh
- *      moved the console code to console.c and out of this file.
- *
- * (06/05/2002) gkh
- *      moved location of startup() call in serial_probe() until after all
- *      of the port information and endpoints are initialized.  This makes
- *      things easier for some drivers.
- *
- * (04/10/2002) gkh
- *      added serial_read_proc function which creates a
- *      /proc/tty/driver/usb-serial file.
- *
- * (03/27/2002) gkh
- *      Got USB serial console code working properly and merged into the main
- *      version of the tree.  Thanks to Randy Dunlap for the initial version
- *      of this code, and for pushing me to finish it up.
- *      The USB serial console works with any usb serial driver device.
- *
- * (03/21/2002) gkh
- *      Moved all manipulation of port->open_count into the core.  Now the
- *      individual driver's open and close functions are called only when the
- *      first open() and last close() is called.  Making the drivers a bit
- *      smaller and simpler.
- *      Fixed a bug if a driver didn't have the owner field set.
- *
- * (02/26/2002) gkh
- *      Moved all locking into the main serial_* functions, instead of having 
- *      the individual drivers have to grab the port semaphore.  This should
- *      reduce races.
- *      Reworked the MOD_INC logic a bit to always increment and decrement, even
- *      if the generic driver is being used.
- *
- * (10/10/2001) gkh
- *      usb_serial_disconnect() now sets the serial->dev pointer is to NULL to
- *      help prevent child drivers from accessing the device since it is now
- *      gone.
- *
- * (09/13/2001) gkh
- *      Moved generic driver initialize after we have registered with the USB
- *      core.  Thanks to Randy Dunlap for pointing this problem out.
- *
- * (07/03/2001) gkh
- *      Fixed module paramater size.  Thanks to John Brockmeyer for the pointer.
- *      Fixed vendor and product getting defined through the MODULE_PARM macro
- *      if the Generic driver wasn't compiled in.
- *      Fixed problem with generic_shutdown() not being called for drivers that
- *      don't have a shutdown() function.
- *
- * (06/06/2001) gkh
- *      added evil hack that is needed for the prolific pl2303 device due to the
- *      crazy way its endpoints are set up.
- *
- * (05/30/2001) gkh
- *      switched from using spinlock to a semaphore, which fixes lots of problems.
- *
- * (04/08/2001) gb
- *      Identify version on module load.
- *
- * 2001_02_05 gkh
- *      Fixed buffer overflows bug with the generic serial driver.  Thanks to
- *      Todd Squires <squirest@ct0.com> for fixing this.
- *
- * (01/10/2001) gkh
- *      Fixed bug where the generic serial adaptor grabbed _any_ device that was
- *      offered to it.
- *
- * (12/12/2000) gkh
- *      Removed MOD_INC and MOD_DEC from poll and disconnect functions, and
- *      moved them to the serial_open and serial_close functions.
- *      Also fixed bug with there not being a MOD_DEC for the generic driver
- *      (thanks to Gary Brubaker for finding this.)
- *
- * (11/29/2000) gkh
- *      Small NULL pointer initialization cleanup which saves a bit of disk image
- *
- * (11/01/2000) Adam J. Richter
- *      instead of using idVendor/idProduct pairs, usb serial drivers
- *      now identify their hardware interest with usb_device_id tables,
- *      which they usually have anyhow for use with MODULE_DEVICE_TABLE.
- *
- * (10/05/2000) gkh
- *      Fixed bug with urb->dev not being set properly, now that the usb
- *      core needs it.
- * 
- * (09/11/2000) gkh
- *      Removed DEBUG #ifdefs with call to usb_serial_debug_data
- *
- * (08/28/2000) gkh
- *      Added port_lock to port structure.
- *      Added locks for SMP safeness to generic driver
- *      Fixed the ability to open a generic device's port more than once.
- *
- * (07/23/2000) gkh
- *      Added bulk_out_endpointAddress to port structure.
- *
- * (07/19/2000) gkh, pberger, and borchers
- *      Modifications to allow usb-serial drivers to be modules.
- *
- * (07/03/2000) gkh
- *      Added more debugging to serial_ioctl call
- * 
- * (06/25/2000) gkh
- *      Changed generic_write_bulk_callback to not call wake_up_interruptible
- *      directly, but to have port_softint do it at a safer time.
- *
- * (06/23/2000) gkh
- *      Cleaned up debugging statements in a quest to find UHCI timeout bug.
- *
- * (05/22/2000) gkh
- *      Changed the makefile, enabling the big CONFIG_USB_SERIAL_SOMTHING to be 
- *      removed from the individual device source files.
- *
- * (05/03/2000) gkh
- *      Added the Digi Acceleport driver from Al Borchers and Peter Berger.
- * 
- * (05/02/2000) gkh
- *      Changed devfs and tty register code to work properly now. This was based on
- *      the ACM driver changes by Vojtech Pavlik.
- *
- * (04/27/2000) Ryan VanderBijl
- *      Put calls to *_paranoia_checks into one function.
- * 
- * (04/23/2000) gkh
- *      Fixed bug that Randy Dunlap found for Generic devices with no bulk out ports.
- *      Moved when the startup code printed out the devices that are supported.
- *
- * (04/19/2000) gkh
- *      Added driver for ZyXEL omni.net lcd plus ISDN TA
- *      Made startup info message specify which drivers were compiled in.
- *
- * (04/03/2000) gkh
- *      Changed the probe process to remove the module unload races.
- *      Changed where the tty layer gets initialized to have devfs work nicer.
- *      Added initial devfs support.
- *
- * (03/26/2000) gkh
- *      Split driver up into device specific pieces.
- * 
- * (03/19/2000) gkh
- *      Fixed oops that could happen when device was removed while a program
- *      was talking to the device.
- *      Removed the static urbs and now all urbs are created and destroyed
- *      dynamically.
- *      Reworked the internal interface. Now everything is based on the 
- *      usb_serial_port structure instead of the larger usb_serial structure.
- *      This fixes the bug that a multiport device could not have more than
- *      one port open at one time.
- *
- * (03/17/2000) gkh
- *      Added config option for debugging messages.
- *      Added patch for keyspan pda from Brian Warner.
- *
- * (03/06/2000) gkh
- *      Added the keyspan pda code from Brian Warner <warner@lothar.com>
- *      Moved a bunch of the port specific stuff into its own structure. This
- *      is in anticipation of the true multiport devices (there's a bug if you
- *      try to access more than one port of any multiport device right now)
- *
- * (02/21/2000) gkh
- *      Made it so that any serial devices only have to specify which functions
- *      they want to overload from the generic function calls (great, 
- *      inheritance in C, in a driver, just what I wanted...)
- *      Added support for set_termios and ioctl function calls. No drivers take
- *      advantage of this yet.
- *      Removed the #ifdef MODULE, now there is no module specific code.
- *      Cleaned up a few comments in usb-serial.h that were wrong (thanks again
- *      to Miles Lott).
- *      Small fix to get_free_serial.
- *
- * (02/14/2000) gkh
- *      Removed the Belkin and Peracom functionality from the driver due to
- *      the lack of support from the vendor, and me not wanting people to 
- *      accidenatly buy the device, expecting it to work with Linux.
- *      Added read_bulk_callback and write_bulk_callback to the type structure
- *      for the needs of the FTDI and WhiteHEAT driver.
- *      Changed all reverences to FTDI to FTDI_SIO at the request of Bill
- *      Ryder.
- *      Changed the output urb size back to the max endpoint size to make
- *      the ftdi_sio driver have it easier, and due to the fact that it didn't
- *      really increase the speed any.
- *
- * (02/11/2000) gkh
- *      Added VISOR_FUNCTION_CONSOLE to the visor startup function. This was a
- *      patch from Miles Lott (milos@insync.net).
- *      Fixed bug with not restoring the minor range that a device grabs, if
- *      the startup function fails (thanks Miles for finding this).
- *
- * (02/05/2000) gkh
- *      Added initial framework for the Keyspan PDA serial converter so that
- *      Brian Warner has a place to put his code.
- *      Made the ezusb specific functions generic enough that different
- *      devices can use them (whiteheat and keyspan_pda both need them).
- *      Split out a whole bunch of structure and other stuff to a separate
- *      usb-serial.h file.
- *      Made the Visor connection messages a little more understandable, now
- *      that Miles Lott (milos@insync.net) has gotten the Generic channel to
- *      work. Also made them always show up in the log file.
- * 
- * (01/25/2000) gkh
- *      Added initial framework for FTDI serial converter so that Bill Ryder
- *      has a place to put his code.
- *      Added the vendor specific info from Handspring. Now we can print out
- *      informational debug messages as well as understand what is happening.
- *
- * (01/23/2000) gkh
- *      Fixed problem of crash when trying to open a port that didn't have a
- *      device assigned to it. Made the minor node finding a little smarter,
- *      now it looks to find a continuous space for the new device.
- *
- * (01/21/2000) gkh
- *      Fixed bug in visor_startup with patch from Miles Lott (milos@insync.net)
- *      Fixed get_serial_by_minor which was all messed up for multi port 
- *      devices. Fixed multi port problem for generic devices. Now the number
- *      of ports is determined by the number of bulk out endpoints for the
- *      generic device.
- *
- * (01/19/2000) gkh
- *      Removed lots of cruft that was around from the old (pre urb) driver 
- *      interface.
- *      Made the serial_table dynamic. This should save lots of memory when
- *      the number of minor nodes goes up to 256.
- *      Added initial support for devices that have more than one port. 
- *      Added more debugging comments for the Visor, and added a needed 
- *      set_configuration call.
- *
- * (01/17/2000) gkh
- *      Fixed the WhiteHEAT firmware (my processing tool had a bug)
- *      and added new debug loader firmware for it.
- *      Removed the put_char function as it isn't really needed.
- *      Added visor startup commands as found by the Win98 dump.
- * 
- * (01/13/2000) gkh
- *      Fixed the vendor id for the generic driver to the one I meant it to be.
- *
- * (01/12/2000) gkh
- *      Forget the version numbering...that's pretty useless...
- *      Made the driver able to be compiled so that the user can select which
- *      converter they want to use. This allows people who only want the Visor
- *      support to not pay the memory size price of the WhiteHEAT.
- *      Fixed bug where the generic driver (idVendor=0000 and idProduct=0000)
- *      grabbed the root hub. Not good.
- * 
- * version 0.4.0 (01/10/2000) gkh
- *      Added whiteheat.h containing the firmware for the ConnectTech WhiteHEAT
- *      device. Added startup function to allow firmware to be downloaded to
- *      a device if it needs to be.
- *      Added firmware download logic to the WhiteHEAT device.
- *      Started to add #defines to split up the different drivers for potential
- *      configuration option.
- *      
- * version 0.3.1 (12/30/99) gkh
- *      Fixed problems with urb for bulk out.
- *      Added initial support for multiple sets of endpoints. This enables
- *      the Handspring Visor to be attached successfully. Only the first
- *      bulk in / bulk out endpoint pair is being used right now.
- *
- * version 0.3.0 (12/27/99) gkh
- *      Added initial support for the Handspring Visor based on a patch from
- *      Miles Lott (milos@sneety.insync.net)
- *      Cleaned up the code a bunch and converted over to using urbs only.
- *
- * version 0.2.3 (12/21/99) gkh
- *      Added initial support for the Connect Tech WhiteHEAT converter.
- *      Incremented the number of ports in expectation of getting the
- *      WhiteHEAT to work properly (4 ports per connection).
- *      Added notification on insertion and removal of what port the
- *      device is/was connected to (and what kind of device it was).
- *
- * version 0.2.2 (12/16/99) gkh
- *      Changed major number to the new allocated number. We're legal now!
- *
- * version 0.2.1 (12/14/99) gkh
- *      Fixed bug that happens when device node is opened when there isn't a
- *      device attached to it. Thanks to marek@webdesign.no for noticing this.
- *
- * version 0.2.0 (11/10/99) gkh
- *      Split up internals to make it easier to add different types of serial 
- *      converters to the code.
- *      Added a "generic" driver that gets it's vendor and product id
- *      from when the module is loaded. Thanks to David E. Nelson (dnelson@jump.net)
- *      for the idea and sample code (from the usb scanner driver.)
- *      Cleared up any licensing questions by releasing it under the GNU GPL.
- *
- * version 0.1.2 (10/25/99) gkh
- *      Fixed bug in detecting device.
- *
- * version 0.1.1 (10/05/99) gkh
- *      Changed the major number to not conflict with anything else.
- *
- * version 0.1 (09/28/99) gkh
- *      Can recognize the two different devices and start up a read from
- *      device when asked to. Writes also work. No control signals yet, this
- *      all is vendor specific data (i.e. no spec), also no control for
- *      different baud rates or other bit settings.
- *      Currently we are using the same devid as the acm driver. This needs
- *      to change.
- * 
  */
 
 #include <linux/config.h>
@@ -342,7 +37,6 @@
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v2.0"
 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
 #define DRIVER_DESC "USB Serial Driver core"
 
@@ -427,7 +121,7 @@ static void destroy_serial(struct kref *kref)
 
         serial = to_usb_serial(kref);
 
-        dbg ("%s - %s", __FUNCTION__, serial->type->name);
+        dbg("%s - %s", __FUNCTION__, serial->type->description);
 
         serial->type->shutdown(serial);
 
@@ -507,7 +201,7 @@ static int serial_open (struct tty_struct *tty, struct file * filp)
                 /* lock this module before we call it
                  * this may fail, which means we must bail out,
                  * safe because we are called with BKL held */
-                if (!try_module_get(serial->type->owner)) {
+                if (!try_module_get(serial->type->driver.owner)) {
                         retval = -ENODEV;
                         goto bailout_kref_put;
                 }
@@ -522,7 +216,7 @@ static int serial_open (struct tty_struct *tty, struct file * filp)
         return 0;
 
 bailout_module_put:
-        module_put(serial->type->owner);
+        module_put(serial->type->driver.owner);
 bailout_kref_put:
         kref_put(&serial->kref, destroy_serial);
         port->open_count = 0;
@@ -553,7 +247,7 @@ static void serial_close(struct tty_struct *tty, struct file * filp)
                         port->tty = NULL;
                 }
 
-                module_put(port->serial->type->owner);
+                module_put(port->serial->type->driver.owner);
         }
 
         kref_put(&port->serial->kref, destroy_serial);
@@ -711,16 +405,16 @@ static int serial_read_proc (char *page, char **start, off_t off, int count, int
         char tmp[40];
 
         dbg("%s", __FUNCTION__);
-        length += sprintf (page, "usbserinfo:1.0 driver:%s\n", DRIVER_VERSION);
+        length += sprintf (page, "usbserinfo:1.0 driver:2.0\n");
         for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) {
                 serial = usb_serial_get_by_index(i);
                 if (serial == NULL)
                         continue;
 
                 length += sprintf (page+length, "%d:", i);
-                if (serial->type->owner)
-                        length += sprintf (page+length, " module:%s", module_name(serial->type->owner));
-                length += sprintf (page+length, " name:\"%s\"", serial->type->name);
+                if (serial->type->driver.owner)
+                        length += sprintf (page+length, " module:%s", module_name(serial->type->driver.owner));
+                length += sprintf (page+length, " name:\"%s\"", serial->type->description);
                 length += sprintf (page+length, " vendor:%04x product:%04x", 
                                    le16_to_cpu(serial->dev->descriptor.idVendor), 
                                    le16_to_cpu(serial->dev->descriptor.idProduct));
@@ -823,7 +517,7 @@ static void port_release(struct device *dev)
 
 static struct usb_serial * create_serial (struct usb_device *dev, 
                                           struct usb_interface *interface,
-                                          struct usb_serial_device_type *type)
+                                          struct usb_serial_driver *driver)
 {
         struct usb_serial *serial;
 
@@ -834,22 +528,22 @@ static struct usb_serial * create_serial (struct usb_device *dev,
         }
         memset (serial, 0, sizeof(*serial));
         serial->dev = usb_get_dev(dev);
-        serial->type = type;
+        serial->type = driver;
         serial->interface = interface;
         kref_init(&serial->kref);
 
         return serial;
 }
 
-static struct usb_serial_device_type *search_serial_device(struct usb_interface *iface)
+static struct usb_serial_driver *search_serial_device(struct usb_interface *iface)
 {
         struct list_head *p;
         const struct usb_device_id *id;
-        struct usb_serial_device_type *t;
+        struct usb_serial_driver *t;
 
         /* List trough know devices and see if the usb id matches */
         list_for_each(p, &usb_serial_driver_list) {
-                t = list_entry(p, struct usb_serial_device_type, driver_list);
+                t = list_entry(p, struct usb_serial_driver, driver_list);
                 id = usb_match_id(iface, t->id_table);
                 if (id != NULL) {
                         dbg("descriptor matches");
@@ -872,7 +566,7 @@ int usb_serial_probe(struct usb_interface *interface,
         struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
         struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
         struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
-        struct usb_serial_device_type *type = NULL;
+        struct usb_serial_driver *type = NULL;
         int retval;
         int minor;
         int buffer_size;
@@ -900,7 +594,7 @@ int usb_serial_probe(struct usb_interface *interface,
         if (type->probe) {
                 const struct usb_device_id *id;
 
-                if (!try_module_get(type->owner)) {
+                if (!try_module_get(type->driver.owner)) {
                         dev_err(&interface->dev, "module get failed, exiting\n");
                         kfree (serial);
                         return -EIO;
@@ -908,7 +602,7 @@ int usb_serial_probe(struct usb_interface *interface,
 
                 id = usb_match_id(interface, type->id_table);
                 retval = type->probe(serial, id);
-                module_put(type->owner);
+                module_put(type->driver.owner);
 
                 if (retval) {
                         dbg ("sub driver rejected device");
@@ -992,7 +686,7 @@ int usb_serial_probe(struct usb_interface *interface,
 #endif
 
         /* found all that we need */
-        dev_info(&interface->dev, "%s converter detected\n", type->name);
+        dev_info(&interface->dev, "%s converter detected\n", type->description);
 
 #ifdef CONFIG_USB_SERIAL_GENERIC
         if (type == &usb_serial_generic_device) {
@@ -1007,13 +701,13 @@ int usb_serial_probe(struct usb_interface *interface,
         if (!num_ports) {
                 /* if this device type has a calc_num_ports function, call it */
                 if (type->calc_num_ports) {
-                        if (!try_module_get(type->owner)) {
+                        if (!try_module_get(type->driver.owner)) {
                                 dev_err(&interface->dev, "module get failed, exiting\n");
                                 kfree (serial);
                                 return -EIO;
                         }
                         num_ports = type->calc_num_ports (serial);
-                        module_put(type->owner);
+                        module_put(type->driver.owner);
                 }
                 if (!num_ports)
                         num_ports = type->num_ports;
@@ -1158,12 +852,12 @@ int usb_serial_probe(struct usb_interface *interface,
         
         /* if this device type has an attach function, call it */
         if (type->attach) {
-                if (!try_module_get(type->owner)) {
+                if (!try_module_get(type->driver.owner)) {
                         dev_err(&interface->dev, "module get failed, exiting\n");
                         goto probe_error;
                 }
                 retval = type->attach (serial);
-                module_put(type->owner);
+                module_put(type->driver.owner);
                 if (retval < 0)
                         goto probe_error;
                 if (retval > 0) {
@@ -1330,7 +1024,7 @@ static int __init usb_serial_init(void)
                 goto exit_generic;
         }
 
-        info(DRIVER_DESC " " DRIVER_VERSION);
+        info(DRIVER_DESC);
 
         return result;
 
@@ -1375,7 +1069,7 @@ module_exit(usb_serial_exit);
                         }                                               \
         } while (0)
 
-static void fixup_generic(struct usb_serial_device_type *device)
+static void fixup_generic(struct usb_serial_driver *device)
 {
         set_to_generic_if_null(device, open);
         set_to_generic_if_null(device, write);
@@ -1387,30 +1081,33 @@ static void fixup_generic(struct usb_serial_device_type *device)
         set_to_generic_if_null(device, shutdown);
 }
 
-int usb_serial_register(struct usb_serial_device_type *new_device)
+int usb_serial_register(struct usb_serial_driver *driver)
 {
         int retval;
 
-        fixup_generic(new_device);
+        fixup_generic(driver);
+
+        if (!driver->description)
+                driver->description = driver->driver.name;
 
         /* Add this device to our list of devices */
-        list_add(&new_device->driver_list, &usb_serial_driver_list);
+        list_add(&driver->driver_list, &usb_serial_driver_list);
 
-        retval = usb_serial_bus_register(new_device);
+        retval = usb_serial_bus_register(driver);
         if (retval) {
-                err("problem %d when registering driver %s", retval, new_device->name);
-                list_del(&new_device->driver_list);
+                err("problem %d when registering driver %s", retval, driver->description);
+                list_del(&driver->driver_list);
         }
         else
-                info("USB Serial support registered for %s", new_device->name);
+                info("USB Serial support registered for %s", driver->description);
 
         return retval;
 }
 
 
-void usb_serial_deregister(struct usb_serial_device_type *device)
+void usb_serial_deregister(struct usb_serial_driver *device)
 {
-        info("USB Serial deregistering driver %s", device->name);
+        info("USB Serial deregistering driver %s", device->description);
         list_del(&device->driver_list);
         usb_serial_bus_deregister(device);
 }
@@ -1429,7 +1126,6 @@ EXPORT_SYMBOL_GPL(usb_serial_port_softint);
 /* Module information */
 MODULE_AUTHOR( DRIVER_AUTHOR );
 MODULE_DESCRIPTION( DRIVER_DESC );
-MODULE_VERSION( DRIVER_VERSION );
 MODULE_LICENSE("GPL");
 
 module_param(debug, bool, S_IRUGO | S_IWUSR);
diff --git a/drivers/usb/serial/usb-serial.h b/drivers/usb/serial/usb-serial.h
index 57f92f054c75..238a5a871ed6 100644
--- a/drivers/usb/serial/usb-serial.h
+++ b/drivers/usb/serial/usb-serial.h
@@ -1,53 +1,13 @@
 /*
  * USB Serial Converter driver
  *
- *      Copyright (C) 1999 - 2004
+ *      Copyright (C) 1999 - 2005
  *          Greg Kroah-Hartman (greg@kroah.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.
+ *      the Free Software Foundation; either version 2 of the License.
  *
- * See Documentation/usb/usb-serial.txt for more information on using this driver
- *
- * (03/26/2002) gkh
- *      removed the port->tty check from port_paranoia_check() due to serial
- *      consoles not having a tty device assigned to them.
- *
- * (12/03/2001) gkh
- *      removed active from the port structure.
- *      added documentation to the usb_serial_device_type structure
- *
- * (10/10/2001) gkh
- *      added vendor and product to serial structure.  Needed to determine device
- *      owner when the device is disconnected.
- *
- * (05/30/2001) gkh
- *      added sem to port structure and removed port_lock
- *
- * (10/05/2000) gkh
- *      Added interrupt_in_endpointAddress and bulk_in_endpointAddress to help
- *      fix bug with urb->dev not being set properly, now that the usb core
- *      needs it.
- * 
- * (09/11/2000) gkh
- *      Added usb_serial_debug_data function to help get rid of #DEBUG in the
- *      drivers.
- *
- * (08/28/2000) gkh
- *      Added port_lock to port structure.
- *
- * (08/08/2000) gkh
- *      Added open_count to port structure.
- *
- * (07/23/2000) gkh
- *      Added bulk_out_endpointAddress to port structure.
- *
- * (07/19/2000) gkh, pberger, and borchers
- *      Modifications to allow usb-serial drivers to be modules.
- *
- * 
  */
 
 
@@ -143,7 +103,7 @@ static inline void usb_set_serial_port_data (struct usb_serial_port *port, void
 /**
  * usb_serial - structure used by the usb-serial core for a device
  * @dev: pointer to the struct usb_device for this device
- * @type: pointer to the struct usb_serial_device_type for this device
+ * @type: pointer to the struct usb_serial_driver for this device
  * @interface: pointer to the struct usb_interface for this device
  * @minor: the starting minor number for this device
  * @num_ports: the number of ports this device has
@@ -159,7 +119,7 @@ static inline void usb_set_serial_port_data (struct usb_serial_port *port, void
  */
 struct usb_serial {
         struct usb_device *             dev;
-        struct usb_serial_device_type * type;
+        struct usb_serial_driver *      type;
         struct usb_interface *          interface;
         unsigned char                   minor;
         unsigned char                   num_ports;
@@ -188,13 +148,9 @@ static inline void usb_set_serial_data (struct usb_serial *serial, void *data)
 }
 
 /**
- * usb_serial_device_type - a structure that defines a usb serial device
- * @owner: pointer to the module that owns this device.
- * @name: pointer to a string that describes this device.  This string used
+ * usb_serial_driver - describes a usb serial driver
+ * @description: pointer to a string that describes this driver.  This string used
  *      in the syslog messages when a device is inserted or removed.
- * @short_name: a pointer to a string that describes this device in
- *      KOBJ_NAME_LEN characters or less.  This is used for the sysfs interface
- *      to describe the driver.
  * @id_table: pointer to a list of usb_device_id structures that define all
  *      of the devices this structure can support.
  * @num_interrupt_in: the number of interrupt in endpoints this device will
@@ -221,16 +177,19 @@ static inline void usb_set_serial_data (struct usb_serial *serial, void *data)
  * @shutdown: pointer to the driver's shutdown function.  This will be
  *      called when the device is removed from the system.
  *
- * This structure is defines a USB Serial device.  It provides all of
+ * This structure is defines a USB Serial driver.  It provides all of
  * the information that the USB serial core code needs.  If the function
  * pointers are defined, then the USB serial core code will call them when
  * the corresponding tty port functions are called.  If they are not
  * called, the generic serial function will be used instead.
+ *
+ * The driver.owner field should be set to the module owner of this driver.
+ * The driver.name field should be set to the name of this driver (remember
+ * it will show up in sysfs, so it needs to be short and to the point.
+ * Useing the module name is a good idea.)
  */
-struct usb_serial_device_type {
-        struct module *owner;
-        char    *name;
-        char    *short_name;
+struct usb_serial_driver {
+        const char *description;
         const struct usb_device_id *id_table;
         char    num_interrupt_in;
         char    num_interrupt_out;
@@ -269,10 +228,10 @@ struct usb_serial_device_type {
         void (*read_bulk_callback)(struct urb *urb, struct pt_regs *regs);
         void (*write_bulk_callback)(struct urb *urb, struct pt_regs *regs);
 };
-#define to_usb_serial_driver(d) container_of(d, struct usb_serial_device_type, driver)
+#define to_usb_serial_driver(d) container_of(d, struct usb_serial_driver, driver)
 
-extern int  usb_serial_register(struct usb_serial_device_type *new_device);
-extern void usb_serial_deregister(struct usb_serial_device_type *device);
+extern int  usb_serial_register(struct usb_serial_driver *driver);
+extern void usb_serial_deregister(struct usb_serial_driver *driver);
 extern void usb_serial_port_softint(void *private);
 
 extern int usb_serial_probe(struct usb_interface *iface, const struct usb_device_id *id);
@@ -303,10 +262,10 @@ extern void usb_serial_generic_shutdown (struct usb_serial *serial);
 extern int usb_serial_generic_register (int debug);
 extern void usb_serial_generic_deregister (void);
 
-extern int usb_serial_bus_register (struct usb_serial_device_type *device);
-extern void usb_serial_bus_deregister (struct usb_serial_device_type *device);
+extern int usb_serial_bus_register (struct usb_serial_driver *device);
+extern void usb_serial_bus_deregister (struct usb_serial_driver *device);
 
-extern struct usb_serial_device_type usb_serial_generic_device;
+extern struct usb_serial_driver usb_serial_generic_device;
 extern struct bus_type usb_serial_bus_type;
 extern struct tty_driver *usb_serial_tty_driver;
 
diff --git a/drivers/usb/serial/visor.c b/drivers/usb/serial/visor.c
index 31c57adcb623..a473c1c34559 100644
--- a/drivers/usb/serial/visor.c
+++ b/drivers/usb/serial/visor.c
@@ -7,139 +7,10 @@
  *
  *      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.
+ *      the Free Software Foundation; either version 2 of the License.
  *
  * See Documentation/usb/usb-serial.txt for more information on using this driver
  *
- * (06/03/2003) Judd Montgomery <judd at jpilot.org>
- *     Added support for module parameter options for untested/unknown
- *     devices.
- *
- * (03/09/2003) gkh
- *      Added support for the Sony Clie NZ90V device.  Thanks to Martin Brachtl
- *      <brachtl@redgrep.cz> for the information.
- *
- * (03/05/2003) gkh
- *      Think Treo support is now working.
- *
- * (04/03/2002) gkh
- *      Added support for the Sony OS 4.1 devices.  Thanks to Hiroyuki ARAKI
- *      <hiro@zob.ne.jp> for the information.
- *
- * (03/27/2002) gkh
- *      Removed assumptions that port->tty was always valid (is not true
- *      for usb serial console devices.)
- *
- * (03/23/2002) gkh
- *      Added support for the Palm i705 device, thanks to Thomas Riemer
- *      <tom@netmech.com> for the information.
- *
- * (03/21/2002) gkh
- *      Added support for the Palm m130 device, thanks to Udo Eisenbarth
- *      <udo.eisenbarth@web.de> for the information.
- *
- * (02/27/2002) gkh
- *      Reworked the urb handling logic.  We have no more pool, but dynamically
- *      allocate the urb and the transfer buffer on the fly.  In testing this
- *      does not incure any measurable overhead.  This also relies on the fact
- *      that we have proper reference counting logic for urbs.
- *
- * (02/21/2002) SilaS
- *  Added initial support for the Palm m515 devices.
- *
- * (02/14/2002) gkh
- *      Added support for the Clie S-360 device.
- *
- * (12/18/2001) gkh
- *      Added better Clie support for 3.5 devices.  Thanks to Geoffrey Levand
- *      for the patch.
- *
- * (11/11/2001) gkh
- *      Added support for the m125 devices, and added check to prevent oopses
- *      for Clié devices that lie about the number of ports they have.
- *
- * (08/30/2001) gkh
- *      Added support for the Clie devices, both the 3.5 and 4.0 os versions.
- *      Many thanks to Daniel Burke, and Bryan Payne for helping with this.
- *
- * (08/23/2001) gkh
- *      fixed a few potential bugs pointed out by Oliver Neukum.
- *
- * (05/30/2001) gkh
- *      switched from using spinlock to a semaphore, which fixes lots of problems.
- *
- * (05/28/2000) gkh
- *      Added initial support for the Palm m500 and Palm m505 devices.
- *
- * (04/08/2001) gb
- *      Identify version on module load.
- *
- * (01/21/2000) gkh
- *      Added write_room and chars_in_buffer, as they were previously using the
- *      generic driver versions which is all wrong now that we are using an urb
- *      pool.  Thanks to Wolfgang Grandegger for pointing this out to me.
- *      Removed count assignment in the write function, which was not needed anymore
- *      either.  Thanks to Al Borchers for pointing this out.
- *
- * (12/12/2000) gkh
- *      Moved MOD_DEC to end of visor_close to be nicer, as the final write 
- *      message can sleep.
- * 
- * (11/12/2000) gkh
- *      Fixed bug with data being dropped on the floor by forcing tty->low_latency
- *      to be on.  Hopefully this fixes the OHCI issue!
- *
- * (11/01/2000) Adam J. Richter
- *      usb_device_id table support
- * 
- * (10/05/2000) gkh
- *      Fixed bug with urb->dev not being set properly, now that the usb
- *      core needs it.
- * 
- * (09/11/2000) gkh
- *      Got rid of always calling kmalloc for every urb we wrote out to the
- *      device.
- *      Added visor_read_callback so we can keep track of bytes in and out for
- *      those people who like to know the speed of their device.
- *      Removed DEBUG #ifdefs with call to usb_serial_debug_data
- *
- * (09/06/2000) gkh
- *      Fixed oops in visor_exit.  Need to uncomment usb_unlink_urb call _after_
- *      the host controller drivers set urb->dev = NULL when the urb is finished.
- *
- * (08/28/2000) gkh
- *      Added locks for SMP safeness.
- *
- * (08/08/2000) gkh
- *      Fixed endian problem in visor_startup.
- *      Fixed MOD_INC and MOD_DEC logic and the ability to open a port more 
- *      than once.
- * 
- * (07/23/2000) gkh
- *      Added pool of write urbs to speed up transfers to the visor.
- * 
- * (07/19/2000) gkh
- *      Added module_init and module_exit functions to handle the fact that this
- *      driver is a loadable module now.
- *
- * (07/03/2000) gkh
- *      Added visor_set_ioctl and visor_set_termios functions (they don't do much
- *      of anything, but are good for debugging.)
- * 
- * (06/25/2000) gkh
- *      Fixed bug in visor_unthrottle that should help with the disconnect in PPP
- *      bug that people have been reporting.
- *
- * (06/23/2000) gkh
- *      Cleaned up debugging statements in a quest to find UHCI timeout bug.
- *
- * (04/27/2000) Ryan VanderBijl
- *      Fixed memory leak in visor_close
- *
- * (03/26/2000) gkh
- *      Split driver up into device specific pieces.
- * 
  */
 
 #include <linux/config.h>
@@ -161,7 +32,6 @@
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v2.1"
 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>"
 #define DRIVER_DESC "USB HandSpring Visor / Palm OS driver"
 
@@ -311,10 +181,12 @@ static struct usb_driver visor_driver = {
 };
 
 /* All of the device info needed for the Handspring Visor, and Palm 4.0 devices */
-static struct usb_serial_device_type handspring_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "Handspring Visor / Palm OS",
-        .short_name =           "visor",
+static struct usb_serial_driver handspring_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "visor",
+        },
+        .description =          "Handspring Visor / Palm OS",
         .id_table =             id_table,
         .num_interrupt_in =     NUM_DONT_CARE,
         .num_bulk_in =          2,
@@ -339,10 +211,12 @@ static struct usb_serial_device_type handspring_device = {
 };
 
 /* All of the device info needed for the Clie UX50, TH55 Palm 5.0 devices */
-static struct usb_serial_device_type clie_5_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "Sony Clie 5.0",
-        .short_name =           "clie_5",
+static struct usb_serial_driver clie_5_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "clie_5",
+        },
+        .description =          "Sony Clie 5.0",
         .id_table =             clie_id_5_table,
         .num_interrupt_in =     NUM_DONT_CARE,
         .num_bulk_in =          2,
@@ -367,10 +241,12 @@ static struct usb_serial_device_type clie_5_device = {
 };
 
 /* device info for the Sony Clie OS version 3.5 */
-static struct usb_serial_device_type clie_3_5_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "Sony Clie 3.5",
-        .short_name =           "clie_3.5",
+static struct usb_serial_driver clie_3_5_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "clie_3.5",
+        },
+        .description =          "Sony Clie 3.5",
         .id_table =             clie_id_3_5_table,
         .num_interrupt_in =     0,
         .num_bulk_in =          1,
@@ -782,7 +658,7 @@ static int palm_os_3_probe (struct usb_serial *serial, const struct usb_device_i
                                         break;
                         }
                         dev_info(dev, "%s: port %d, is for %s use\n",
-                                serial->type->name,
+                                serial->type->description,
                                 connection_info->connections[i].port, string);
                 }
         }
@@ -791,11 +667,11 @@ static int palm_os_3_probe (struct usb_serial *serial, const struct usb_device_i
         */
         if (num_ports == 0 || num_ports > 2) {
                 dev_warn (dev, "%s: No valid connect info available\n",
-                        serial->type->name);
+                        serial->type->description);
                 num_ports = 2;
         }
   
-        dev_info(dev, "%s: Number of ports: %d\n", serial->type->name,
+        dev_info(dev, "%s: Number of ports: %d\n", serial->type->description,
                 num_ports);
 
         /*
@@ -1125,7 +1001,7 @@ static int __init visor_init (void)
         retval = usb_register(&visor_driver);
         if (retval) 
                 goto failed_usb_register;
-        info(DRIVER_DESC " " DRIVER_VERSION);
+        info(DRIVER_DESC);
 
         return 0;
 failed_usb_register:
diff --git a/drivers/usb/serial/whiteheat.c b/drivers/usb/serial/whiteheat.c
index cf3bc30675a1..18c3183be769 100644
--- a/drivers/usb/serial/whiteheat.c
+++ b/drivers/usb/serial/whiteheat.c
@@ -156,10 +156,12 @@ static void whiteheat_unthrottle	(struct usb_serial_port *port);
 static void whiteheat_read_callback     (struct urb *urb, struct pt_regs *regs);
 static void whiteheat_write_callback    (struct urb *urb, struct pt_regs *regs);
 
-static struct usb_serial_device_type whiteheat_fake_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "Connect Tech - WhiteHEAT - (prerenumeration)",
-        .short_name =           "whiteheatnofirm",
+static struct usb_serial_driver whiteheat_fake_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "whiteheatnofirm",
+        },
+        .description =          "Connect Tech - WhiteHEAT - (prerenumeration)",
         .id_table =             id_table_prerenumeration,
         .num_interrupt_in =     NUM_DONT_CARE,
         .num_bulk_in =          NUM_DONT_CARE,
@@ -169,10 +171,12 @@ static struct usb_serial_device_type whiteheat_fake_device = {
         .attach =               whiteheat_firmware_attach,
 };
 
-static struct usb_serial_device_type whiteheat_device = {
-        .owner =                THIS_MODULE,
-        .name =                 "Connect Tech - WhiteHEAT",
-        .short_name =           "whiteheat",
+static struct usb_serial_driver whiteheat_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "whiteheat",
+        },
+        .description =          "Connect Tech - WhiteHEAT",
         .id_table =             id_table_std,
         .num_interrupt_in =     NUM_DONT_CARE,
         .num_bulk_in =          NUM_DONT_CARE,
@@ -382,10 +386,10 @@ static int whiteheat_attach (struct usb_serial *serial)
         usb_clear_halt(serial->dev, pipe);
         ret = usb_bulk_msg (serial->dev, pipe, command, 2, &alen, COMMAND_TIMEOUT_MS);
         if (ret) {
-                err("%s: Couldn't send command [%d]", serial->type->name, ret);
+                err("%s: Couldn't send command [%d]", serial->type->description, ret);
                 goto no_firmware;
         } else if (alen != sizeof(command)) {
-                err("%s: Send command incomplete [%d]", serial->type->name, alen);
+                err("%s: Send command incomplete [%d]", serial->type->description, alen);
                 goto no_firmware;
         }
 
@@ -394,19 +398,19 @@ static int whiteheat_attach (struct usb_serial *serial)
         usb_clear_halt(serial->dev, pipe);
         ret = usb_bulk_msg (serial->dev, pipe, result, sizeof(*hw_info) + 1, &alen, COMMAND_TIMEOUT_MS);
         if (ret) {
-                err("%s: Couldn't get results [%d]", serial->type->name, ret);
+                err("%s: Couldn't get results [%d]", serial->type->description, ret);
                 goto no_firmware;
         } else if (alen != sizeof(result)) {
-                err("%s: Get results incomplete [%d]", serial->type->name, alen);
+                err("%s: Get results incomplete [%d]", serial->type->description, alen);
                 goto no_firmware;
         } else if (result[0] != command[0]) {
-                err("%s: Command failed [%d]", serial->type->name, result[0]);
+                err("%s: Command failed [%d]", serial->type->description, result[0]);
                 goto no_firmware;
         }
 
         hw_info = (struct whiteheat_hw_info *)&result[1];
 
-        info("%s: Driver %s: Firmware v%d.%02d", serial->type->name,
+        info("%s: Driver %s: Firmware v%d.%02d", serial->type->description,
              DRIVER_VERSION, hw_info->sw_major_rev, hw_info->sw_minor_rev);
 
         for (i = 0; i < serial->num_ports; i++) {
@@ -414,7 +418,7 @@ static int whiteheat_attach (struct usb_serial *serial)
 
                 info = (struct whiteheat_private *)kmalloc(sizeof(struct whiteheat_private), GFP_KERNEL);
                 if (info == NULL) {
-                        err("%s: Out of memory for port structures\n", serial->type->name);
+                        err("%s: Out of memory for port structures\n", serial->type->description);
                         goto no_private;
                 }
 
@@ -484,7 +488,7 @@ static int whiteheat_attach (struct usb_serial *serial)
 
         command_info = (struct whiteheat_command_private *)kmalloc(sizeof(struct whiteheat_command_private), GFP_KERNEL);
         if (command_info == NULL) {
-                err("%s: Out of memory for port structures\n", serial->type->name);
+                err("%s: Out of memory for port structures\n", serial->type->description);
                 goto no_command_private;
         }
 
@@ -501,9 +505,9 @@ static int whiteheat_attach (struct usb_serial *serial)
 
 no_firmware:
         /* Firmware likely not running */
-        err("%s: Unable to retrieve firmware version, try replugging\n", serial->type->name);
-        err("%s: If the firmware is not running (status led not blinking)\n", serial->type->name);
-        err("%s: please contact support@connecttech.com\n", serial->type->name);
+        err("%s: Unable to retrieve firmware version, try replugging\n", serial->type->description);
+        err("%s: If the firmware is not running (status led not blinking)\n", serial->type->description);
+        err("%s: please contact support@connecttech.com\n", serial->type->description);
         return -ENODEV;
 
 no_command_private:
diff --git a/drivers/usb/storage/Kconfig b/drivers/usb/storage/Kconfig
index bb9819cc8826..1a9679f76f5a 100644
--- a/drivers/usb/storage/Kconfig
+++ b/drivers/usb/storage/Kconfig
@@ -2,7 +2,8 @@
 # USB Storage driver configuration
 #
 
-comment "NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support' may also be needed; see USB_STORAGE Help for more information"
+comment "NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'"
+comment "may also be needed; see USB_STORAGE Help for more information"
         depends on USB
 
 config USB_STORAGE
diff --git a/drivers/usb/storage/shuttle_usbat.c b/drivers/usb/storage/shuttle_usbat.c
index 356342c6e7a2..33c55a6261bb 100644
--- a/drivers/usb/storage/shuttle_usbat.c
+++ b/drivers/usb/storage/shuttle_usbat.c
@@ -1,4 +1,4 @@
-/* Driver for SCM Microsystems USB-ATAPI cable
+/* Driver for SCM Microsystems (a.k.a. Shuttle) USB-ATAPI cable
  *
  * $Id: shuttle_usbat.c,v 1.17 2002/04/22 03:39:43 mdharm Exp $
  *
@@ -67,10 +67,10 @@ static int usbat_flash_transport(struct scsi_cmnd * srb, struct us_data *us);
 static int usbat_hp8200e_transport(struct scsi_cmnd *srb, struct us_data *us);
 
 /*
- * Convenience function to produce an ATAPI read/write sectors command
+ * Convenience function to produce an ATA read/write sectors command
  * Use cmd=0x20 for read, cmd=0x30 for write
  */
-static void usbat_pack_atapi_sector_cmd(unsigned char *buf,
+static void usbat_pack_ata_sector_cmd(unsigned char *buf,
                                         unsigned char thistime,
                                         u32 sector, unsigned char cmd)
 {
@@ -196,10 +196,12 @@ static int usbat_check_status(struct us_data *us)
         if (rc != USB_STOR_XFER_GOOD)
                 return USB_STOR_TRANSPORT_FAILED;
 
-        if (*reply & 0x01 && *reply != 0x51) // error/check condition (0x51 is ok)
+        /* error/check condition (0x51 is ok) */
+        if (*reply & 0x01 && *reply != 0x51)
                 return USB_STOR_TRANSPORT_FAILED;
 
-        if (*reply & 0x20) // device fault
+        /* device fault */
+        if (*reply & 0x20)
                 return USB_STOR_TRANSPORT_FAILED;
 
         return USB_STOR_TRANSPORT_GOOD;
@@ -222,29 +224,39 @@ static int usbat_set_shuttle_features(struct us_data *us,
         command[0] = 0x40;
         command[1] = USBAT_CMD_SET_FEAT;
 
-        // The only bit relevant to ATA access is bit 6
-        // which defines 8 bit data access (set) or 16 bit (unset)
+        /*
+         * The only bit relevant to ATA access is bit 6
+         * which defines 8 bit data access (set) or 16 bit (unset)
+         */
         command[2] = epp_control;
 
-        // If FCQ is set in the qualifier (defined in R/W cmd), then bits U0, U1,
-        // ET1 and ET2 define an external event to be checked for on event of a
-        // _read_blocks or _write_blocks operation. The read/write will not take
-        // place unless the defined trigger signal is active.
+        /*
+         * If FCQ is set in the qualifier (defined in R/W cmd), then bits U0, U1,
+         * ET1 and ET2 define an external event to be checked for on event of a
+         * _read_blocks or _write_blocks operation. The read/write will not take
+         * place unless the defined trigger signal is active.
+         */
         command[3] = external_trigger;
 
-        // The resultant byte of the mask operation (see mask_byte) is compared for
-        // equivalence with this test pattern. If equal, the read/write will take
-        // place.
+        /*
+         * The resultant byte of the mask operation (see mask_byte) is compared for
+         * equivalence with this test pattern. If equal, the read/write will take
+         * place.
+         */
         command[4] = test_pattern;
 
-        // This value is logically ANDed with the status register field specified
-        // in the read/write command.
+        /*
+         * This value is logically ANDed with the status register field specified
+         * in the read/write command.
+         */
         command[5] = mask_byte;
 
-        // If ALQ is set in the qualifier, this field contains the address of the
-        // registers where the byte count should be read for transferring the data.
-        // If ALQ is not set, then this field contains the number of bytes to be
-        // transferred.
+        /*
+         * If ALQ is set in the qualifier, this field contains the address of the
+         * registers where the byte count should be read for transferring the data.
+         * If ALQ is not set, then this field contains the number of bytes to be
+         * transferred.
+         */
         command[6] = subcountL;
         command[7] = subcountH;
 
@@ -273,26 +285,26 @@ static int usbat_wait_not_busy(struct us_data *us, int minutes)
 
                 if (result!=USB_STOR_XFER_GOOD)
                         return USB_STOR_TRANSPORT_ERROR;
-                if (*status & 0x01) { // check condition
+                if (*status & 0x01) { /* check condition */
                         result = usbat_read(us, USBAT_ATA, 0x10, status);
                         return USB_STOR_TRANSPORT_FAILED;
                 }
-                if (*status & 0x20) // device fault
+                if (*status & 0x20) /* device fault */
                         return USB_STOR_TRANSPORT_FAILED;
 
-                if ((*status & 0x80)==0x00) { // not busy
+                if ((*status & 0x80)==0x00) { /* not busy */
                         US_DEBUGP("Waited not busy for %d steps\n", i);
                         return USB_STOR_TRANSPORT_GOOD;
                 }
 
                 if (i<500)
-                        msleep(10); // 5 seconds
+                        msleep(10); /* 5 seconds */
                 else if (i<700)
-                        msleep(50); // 10 seconds
+                        msleep(50); /* 10 seconds */
                 else if (i<1200)
-                        msleep(100); // 50 seconds
+                        msleep(100); /* 50 seconds */
                 else
-                        msleep(1000); // X minutes
+                        msleep(1000); /* X minutes */
         }
 
         US_DEBUGP("Waited not busy for %d minutes, timing out.\n",
@@ -412,9 +424,12 @@ static int usbat_hp8200e_rw_block_test(struct us_data *us,
 
                 if (i==0) {
                         cmdlen = 16;
-                        // Write to multiple registers
-                        // Not really sure the 0x07, 0x17, 0xfc, 0xe7 is necessary here,
-                        // but that's what came out of the trace every single time.
+                        /*
+                         * Write to multiple registers
+                         * Not really sure the 0x07, 0x17, 0xfc, 0xe7 is
+                         * necessary here, but that's what came out of the
+                         * trace every single time.
+                         */
                         command[0] = 0x40;
                         command[1] = access | USBAT_CMD_WRITE_REGS;
                         command[2] = 0x07;
@@ -426,7 +441,7 @@ static int usbat_hp8200e_rw_block_test(struct us_data *us,
                 } else
                         cmdlen = 8;
 
-                // Conditionally read or write blocks
+                /* Conditionally read or write blocks */
                 command[cmdlen-8] = (direction==DMA_TO_DEVICE ? 0x40 : 0xC0);
                 command[cmdlen-7] = access |
                                 (direction==DMA_TO_DEVICE ?
@@ -456,11 +471,6 @@ static int usbat_hp8200e_rw_block_test(struct us_data *us,
 
                 }
 
-
-                //US_DEBUGP("Transfer %s %d bytes, sg buffers %d\n",
-                //      direction == DMA_TO_DEVICE ? "out" : "in",
-                //      len, use_sg);
-
                 result = usb_stor_bulk_transfer_sg(us,
                         pipe, content, len, use_sg, NULL);
 
@@ -508,9 +518,9 @@ static int usbat_hp8200e_rw_block_test(struct us_data *us,
 
                         if (result!=USB_STOR_XFER_GOOD)
                                 return USB_STOR_TRANSPORT_ERROR;
-                        if (*status & 0x01) // check condition
+                        if (*status & 0x01) /* check condition */
                                 return USB_STOR_TRANSPORT_FAILED;
-                        if (*status & 0x20) // device fault
+                        if (*status & 0x20) /* device fault */
                                 return USB_STOR_TRANSPORT_FAILED;
 
                         US_DEBUGP("Redoing %s\n",
@@ -547,32 +557,32 @@ static int usbat_multiple_write(struct us_data *us,
 
         BUG_ON(num_registers > US_IOBUF_SIZE/2);
 
-        // Write to multiple registers, ATA access
+        /* Write to multiple registers, ATA access */
         command[0] = 0x40;
         command[1] = USBAT_ATA | USBAT_CMD_WRITE_REGS;
 
-        // No relevance
+        /* No relevance */
         command[2] = 0;
         command[3] = 0;
         command[4] = 0;
         command[5] = 0;
 
-        // Number of bytes to be transferred (incl. addresses and data)
+        /* Number of bytes to be transferred (incl. addresses and data) */
         command[6] = LSB_of(num_registers*2);
         command[7] = MSB_of(num_registers*2);
 
-        // The setup command
+        /* The setup command */
         result = usbat_execute_command(us, command, 8);
         if (result != USB_STOR_XFER_GOOD)
                 return USB_STOR_TRANSPORT_ERROR;
 
-        // Create the reg/data, reg/data sequence
+        /* Create the reg/data, reg/data sequence */
         for (i=0; i<num_registers; i++) {
                 data[i<<1] = registers[i];
                 data[1+(i<<1)] = data_out[i];
         }
 
-        // Send the data
+        /* Send the data */
         result = usbat_bulk_write(us, data, num_registers*2);
         if (result != USB_STOR_XFER_GOOD)
                 return USB_STOR_TRANSPORT_ERROR;
@@ -606,17 +616,17 @@ static int usbat_read_blocks(struct us_data *us,
         command[1] = USBAT_ATA | USBAT_CMD_COND_READ_BLOCK;
         command[2] = USBAT_ATA_DATA;
         command[3] = USBAT_ATA_STATUS;
-        command[4] = 0xFD; // Timeout (ms);
+        command[4] = 0xFD; /* Timeout (ms); */
         command[5] = USBAT_QUAL_FCQ;
         command[6] = LSB_of(len);
         command[7] = MSB_of(len);
 
-        // Multiple block read setup command
+        /* Multiple block read setup command */
         result = usbat_execute_command(us, command, 8);
         if (result != USB_STOR_XFER_GOOD)
                 return USB_STOR_TRANSPORT_FAILED;
         
-        // Read the blocks we just asked for
+        /* Read the blocks we just asked for */
         result = usbat_bulk_read(us, buffer, len);
         if (result != USB_STOR_XFER_GOOD)
                 return USB_STOR_TRANSPORT_FAILED;
@@ -647,17 +657,17 @@ static int usbat_write_blocks(struct us_data *us,
         command[1] = USBAT_ATA | USBAT_CMD_COND_WRITE_BLOCK;
         command[2] = USBAT_ATA_DATA;
         command[3] = USBAT_ATA_STATUS;
-        command[4] = 0xFD; // Timeout (ms)
+        command[4] = 0xFD; /* Timeout (ms) */
         command[5] = USBAT_QUAL_FCQ;
         command[6] = LSB_of(len);
         command[7] = MSB_of(len);
 
-        // Multiple block write setup command
+        /* Multiple block write setup command */
         result = usbat_execute_command(us, command, 8);
         if (result != USB_STOR_XFER_GOOD)
                 return USB_STOR_TRANSPORT_FAILED;
         
-        // Write the data
+        /* Write the data */
         result = usbat_bulk_write(us, buffer, len);
         if (result != USB_STOR_XFER_GOOD)
                 return USB_STOR_TRANSPORT_FAILED;
@@ -711,16 +721,20 @@ static int usbat_device_reset(struct us_data *us)
 {
         int rc;
 
-        // Reset peripheral, enable peripheral control signals
-        // (bring reset signal up)
+        /*
+         * Reset peripheral, enable peripheral control signals
+         * (bring reset signal up)
+         */
         rc = usbat_write_user_io(us,
                                                          USBAT_UIO_DRVRST | USBAT_UIO_OE1 | USBAT_UIO_OE0,
                                                          USBAT_UIO_EPAD | USBAT_UIO_1);
         if (rc != USB_STOR_XFER_GOOD)
                 return USB_STOR_TRANSPORT_ERROR;
                         
-        // Enable peripheral control signals
-        // (bring reset signal down)
+        /*
+         * Enable peripheral control signals
+         * (bring reset signal down)
+         */
         rc = usbat_write_user_io(us,
                                                          USBAT_UIO_OE1  | USBAT_UIO_OE0,
                                                          USBAT_UIO_EPAD | USBAT_UIO_1);
@@ -737,7 +751,7 @@ static int usbat_device_enable_cdt(struct us_data *us)
 {
         int rc;
 
-        // Enable peripheral control signals and card detect
+        /* Enable peripheral control signals and card detect */
         rc = usbat_write_user_io(us,
                                                          USBAT_UIO_ACKD | USBAT_UIO_OE1  | USBAT_UIO_OE0,
                                                          USBAT_UIO_EPAD | USBAT_UIO_1);
@@ -786,7 +800,7 @@ static int usbat_flash_check_media(struct us_data *us,
         if (rc != USB_STOR_XFER_GOOD)
                 return USB_STOR_TRANSPORT_ERROR;
 
-        // Check for media existence
+        /* Check for media existence */
         rc = usbat_flash_check_media_present(uio);
         if (rc == USBAT_FLASH_MEDIA_NONE) {
                 info->sense_key = 0x02;
@@ -795,11 +809,11 @@ static int usbat_flash_check_media(struct us_data *us,
                 return USB_STOR_TRANSPORT_FAILED;
         }
 
-        // Check for media change
+        /* Check for media change */
         rc = usbat_flash_check_media_changed(uio);
         if (rc == USBAT_FLASH_MEDIA_CHANGED) {
 
-                // Reset and re-enable card detect
+                /* Reset and re-enable card detect */
                 rc = usbat_device_reset(us);
                 if (rc != USB_STOR_TRANSPORT_GOOD)
                         return rc;
@@ -855,15 +869,15 @@ static int usbat_identify_device(struct us_data *us,
         if (rc != USB_STOR_XFER_GOOD)
                 return USB_STOR_TRANSPORT_ERROR;
 
-        // Check for error bit
-        if (status & 0x01) {
-                 // Device is a CompactFlash reader/writer
-                US_DEBUGP("usbat_identify_device: Detected Flash reader/writer\n");
-                info->devicetype = USBAT_DEV_FLASH;
-        } else {
-                // Device is HP 8200
+        /* Check for error bit, or if the command 'fell through' */
+        if (status == 0xA1 || !(status & 0x01)) {
+                /* Device is HP 8200 */
                 US_DEBUGP("usbat_identify_device: Detected HP8200 CDRW\n");
                 info->devicetype = USBAT_DEV_HP8200;
+        } else {
+                /* Device is a CompactFlash reader/writer */
+                US_DEBUGP("usbat_identify_device: Detected Flash reader/writer\n");
+                info->devicetype = USBAT_DEV_FLASH;
         }
 
         return USB_STOR_TRANSPORT_GOOD;
@@ -916,7 +930,7 @@ static int usbat_flash_get_sector_count(struct us_data *us,
         if (!reply)
                 return USB_STOR_TRANSPORT_ERROR;
 
-        // ATAPI command : IDENTIFY DEVICE
+        /* ATA command : IDENTIFY DEVICE */
         rc = usbat_multiple_write(us, registers, command, 3);
         if (rc != USB_STOR_XFER_GOOD) {
                 US_DEBUGP("usbat_flash_get_sector_count: Gah! identify_device failed\n");
@@ -924,7 +938,7 @@ static int usbat_flash_get_sector_count(struct us_data *us,
                 goto leave;
         }
 
-        // Read device status
+        /* Read device status */
         if (usbat_get_status(us, &status) != USB_STOR_XFER_GOOD) {
                 rc = USB_STOR_TRANSPORT_ERROR;
                 goto leave;
@@ -932,7 +946,7 @@ static int usbat_flash_get_sector_count(struct us_data *us,
 
         msleep(100);
 
-        // Read the device identification data
+        /* Read the device identification data */
         rc = usbat_read_block(us, reply, 512);
         if (rc != USB_STOR_TRANSPORT_GOOD)
                 goto leave;
@@ -977,19 +991,23 @@ static int usbat_flash_read_data(struct us_data *us,
         if (result != USB_STOR_TRANSPORT_GOOD)
                 return result;
 
-        // we're working in LBA mode.  according to the ATA spec,
-        // we can support up to 28-bit addressing.  I don't know if Jumpshot
-        // supports beyond 24-bit addressing.  It's kind of hard to test
-        // since it requires > 8GB CF card.
+        /*
+         * we're working in LBA mode.  according to the ATA spec,
+         * we can support up to 28-bit addressing.  I don't know if Jumpshot
+         * supports beyond 24-bit addressing.  It's kind of hard to test
+         * since it requires > 8GB CF card.
+         */
 
         if (sector > 0x0FFFFFFF)
                 return USB_STOR_TRANSPORT_ERROR;
 
         totallen = sectors * info->ssize;
 
-        // Since we don't read more than 64 KB at a time, we have to create
-        // a bounce buffer and move the data a piece at a time between the
-        // bounce buffer and the actual transfer buffer.
+        /*
+         * Since we don't read more than 64 KB at a time, we have to create
+         * a bounce buffer and move the data a piece at a time between the
+         * bounce buffer and the actual transfer buffer.
+         */
 
         alloclen = min(totallen, 65536u);
         buffer = kmalloc(alloclen, GFP_NOIO);
@@ -997,27 +1015,29 @@ static int usbat_flash_read_data(struct us_data *us,
                 return USB_STOR_TRANSPORT_ERROR;
 
         do {
-                // loop, never allocate or transfer more than 64k at once
-                // (min(128k, 255*info->ssize) is the real limit)
+                /*
+                 * loop, never allocate or transfer more than 64k at once
+                 * (min(128k, 255*info->ssize) is the real limit)
+                 */
                 len = min(totallen, alloclen);
                 thistime = (len / info->ssize) & 0xff;
  
-                // ATAPI command 0x20 (READ SECTORS)
-                usbat_pack_atapi_sector_cmd(command, thistime, sector, 0x20);
+                /* ATA command 0x20 (READ SECTORS) */
+                usbat_pack_ata_sector_cmd(command, thistime, sector, 0x20);
 
-                // Write/execute ATAPI read command
+                /* Write/execute ATA read command */
                 result = usbat_multiple_write(us, registers, command, 7);
                 if (result != USB_STOR_TRANSPORT_GOOD)
                         goto leave;
 
-                // Read the data we just requested
+                /* Read the data we just requested */
                 result = usbat_read_blocks(us, buffer, len);
                 if (result != USB_STOR_TRANSPORT_GOOD)
                         goto leave;
          
                 US_DEBUGP("usbat_flash_read_data:  %d bytes\n", len);
         
-                // Store the data in the transfer buffer
+                /* Store the data in the transfer buffer */
                 usb_stor_access_xfer_buf(buffer, len, us->srb,
                                          &sg_idx, &sg_offset, TO_XFER_BUF);
 
@@ -1061,19 +1081,23 @@ static int usbat_flash_write_data(struct us_data *us,
         if (result != USB_STOR_TRANSPORT_GOOD)
                 return result;
 
-        // we're working in LBA mode.  according to the ATA spec,
-        // we can support up to 28-bit addressing.  I don't know if Jumpshot
-        // supports beyond 24-bit addressing.  It's kind of hard to test
-        // since it requires > 8GB CF card.
+        /*
+         * we're working in LBA mode.  according to the ATA spec,
+         * we can support up to 28-bit addressing.  I don't know if the device
+         * supports beyond 24-bit addressing.  It's kind of hard to test
+         * since it requires > 8GB media.
+         */
 
         if (sector > 0x0FFFFFFF)
                 return USB_STOR_TRANSPORT_ERROR;
 
         totallen = sectors * info->ssize;
 
-        // Since we don't write more than 64 KB at a time, we have to create
-        // a bounce buffer and move the data a piece at a time between the
-        // bounce buffer and the actual transfer buffer.
+        /*
+         * Since we don't write more than 64 KB at a time, we have to create
+         * a bounce buffer and move the data a piece at a time between the
+         * bounce buffer and the actual transfer buffer.
+         */
 
         alloclen = min(totallen, 65536u);
         buffer = kmalloc(alloclen, GFP_NOIO);
@@ -1081,24 +1105,26 @@ static int usbat_flash_write_data(struct us_data *us,
                 return USB_STOR_TRANSPORT_ERROR;
 
         do {
-                // loop, never allocate or transfer more than 64k at once
-                // (min(128k, 255*info->ssize) is the real limit)
+                /*
+                 * loop, never allocate or transfer more than 64k at once
+                 * (min(128k, 255*info->ssize) is the real limit)
+                 */
                 len = min(totallen, alloclen);
                 thistime = (len / info->ssize) & 0xff;
 
-                // Get the data from the transfer buffer
+                /* Get the data from the transfer buffer */
                 usb_stor_access_xfer_buf(buffer, len, us->srb,
                                          &sg_idx, &sg_offset, FROM_XFER_BUF);
 
-                // ATAPI command 0x30 (WRITE SECTORS)
-                usbat_pack_atapi_sector_cmd(command, thistime, sector, 0x30);           
+                /* ATA command 0x30 (WRITE SECTORS) */
+                usbat_pack_ata_sector_cmd(command, thistime, sector, 0x30);
 
-                // Write/execute ATAPI write command
+                /* Write/execute ATA write command */
                 result = usbat_multiple_write(us, registers, command, 7);
                 if (result != USB_STOR_TRANSPORT_GOOD)
                         goto leave;
 
-                // Write the data
+                /* Write the data */
                 result = usbat_write_blocks(us, buffer, len);
                 if (result != USB_STOR_TRANSPORT_GOOD)
                         goto leave;
@@ -1169,42 +1195,44 @@ static int usbat_hp8200e_handle_read10(struct us_data *us,
                         srb->transfersize);
         }
 
-        // Since we only read in one block at a time, we have to create
-        // a bounce buffer and move the data a piece at a time between the
-        // bounce buffer and the actual transfer buffer.
+        /*
+         * Since we only read in one block at a time, we have to create
+         * a bounce buffer and move the data a piece at a time between the
+         * bounce buffer and the actual transfer buffer.
+         */
 
         len = (65535/srb->transfersize) * srb->transfersize;
         US_DEBUGP("Max read is %d bytes\n", len);
         len = min(len, srb->request_bufflen);
         buffer = kmalloc(len, GFP_NOIO);
-        if (buffer == NULL) // bloody hell!
+        if (buffer == NULL) /* bloody hell! */
                 return USB_STOR_TRANSPORT_FAILED;
         sector = short_pack(data[7+3], data[7+2]);
         sector <<= 16;
         sector |= short_pack(data[7+5], data[7+4]);
         transferred = 0;
 
-        sg_segment = 0; // for keeping track of where we are in
-        sg_offset = 0;  // the scatter/gather list
+        sg_segment = 0; /* for keeping track of where we are in */
+        sg_offset = 0;  /* the scatter/gather list */
 
         while (transferred != srb->request_bufflen) {
 
                 if (len > srb->request_bufflen - transferred)
                         len = srb->request_bufflen - transferred;
 
-                data[3] = len&0xFF;       // (cylL) = expected length (L)
-                data[4] = (len>>8)&0xFF;  // (cylH) = expected length (H)
+                data[3] = len&0xFF;       /* (cylL) = expected length (L) */
+                data[4] = (len>>8)&0xFF;  /* (cylH) = expected length (H) */
 
-                // Fix up the SCSI command sector and num sectors
+                /* Fix up the SCSI command sector and num sectors */
 
-                data[7+2] = MSB_of(sector>>16); // SCSI command sector
+                data[7+2] = MSB_of(sector>>16); /* SCSI command sector */
                 data[7+3] = LSB_of(sector>>16);
                 data[7+4] = MSB_of(sector&0xFFFF);
                 data[7+5] = LSB_of(sector&0xFFFF);
                 if (data[7+0] == GPCMD_READ_CD)
                         data[7+6] = 0;
-                data[7+7] = MSB_of(len / srb->transfersize); // SCSI command
-                data[7+8] = LSB_of(len / srb->transfersize); // num sectors
+                data[7+7] = MSB_of(len / srb->transfersize); /* SCSI command */
+                data[7+8] = LSB_of(len / srb->transfersize); /* num sectors */
 
                 result = usbat_hp8200e_rw_block_test(us, USBAT_ATA, 
                         registers, data, 19,
@@ -1217,16 +1245,16 @@ static int usbat_hp8200e_handle_read10(struct us_data *us,
                 if (result != USB_STOR_TRANSPORT_GOOD)
                         break;
 
-                // Store the data in the transfer buffer
+                /* Store the data in the transfer buffer */
                 usb_stor_access_xfer_buf(buffer, len, srb,
                                  &sg_segment, &sg_offset, TO_XFER_BUF);
 
-                // Update the amount transferred and the sector number
+                /* Update the amount transferred and the sector number */
 
                 transferred += len;
                 sector += len / srb->transfersize;
 
-        } // while transferred != srb->request_bufflen
+        } /* while transferred != srb->request_bufflen */
 
         kfree(buffer);
         return result;
@@ -1237,7 +1265,7 @@ static int usbat_select_and_test_registers(struct us_data *us)
         int selector;
         unsigned char *status = us->iobuf;
 
-        // try device = master, then device = slave.
+        /* try device = master, then device = slave. */
         for (selector = 0xA0; selector <= 0xB0; selector += 0x10) {
                 if (usbat_write(us, USBAT_ATA, USBAT_ATA_DEVICE, selector) !=
                                 USB_STOR_XFER_GOOD)
@@ -1298,7 +1326,7 @@ int init_usbat(struct us_data *us)
         memset(us->extra, 0, sizeof(struct usbat_info));
         info = (struct usbat_info *) (us->extra);
 
-        // Enable peripheral control signals
+        /* Enable peripheral control signals */
         rc = usbat_write_user_io(us,
                                  USBAT_UIO_OE1 | USBAT_UIO_OE0,
                                  USBAT_UIO_EPAD | USBAT_UIO_1);
@@ -1337,7 +1365,7 @@ int init_usbat(struct us_data *us)
 
         US_DEBUGP("INIT 5\n");
 
-        // Enable peripheral control signals and card detect
+        /* Enable peripheral control signals and card detect */
         rc = usbat_device_enable_cdt(us);
         if (rc != USB_STOR_TRANSPORT_GOOD)
                 return rc;
@@ -1364,7 +1392,7 @@ int init_usbat(struct us_data *us)
 
         US_DEBUGP("INIT 9\n");
 
-        // At this point, we need to detect which device we are using
+        /* At this point, we need to detect which device we are using */
         if (usbat_set_transport(us, info))
                 return USB_STOR_TRANSPORT_ERROR;
 
@@ -1414,10 +1442,10 @@ static int usbat_hp8200e_transport(struct scsi_cmnd *srb, struct us_data *us)
         data[0] = 0x00;
         data[1] = 0x00;
         data[2] = 0x00;
-        data[3] = len&0xFF;             // (cylL) = expected length (L)
-        data[4] = (len>>8)&0xFF;        // (cylH) = expected length (H)
-        data[5] = 0xB0;                 // (device sel) = slave
-        data[6] = 0xA0;                 // (command) = ATA PACKET COMMAND
+        data[3] = len&0xFF;             /* (cylL) = expected length (L) */
+        data[4] = (len>>8)&0xFF;        /* (cylH) = expected length (H) */
+        data[5] = 0xB0;                 /* (device sel) = slave */
+        data[6] = 0xA0;                 /* (command) = ATA PACKET COMMAND */
 
         for (i=7; i<19; i++) {
                 registers[i] = 0x10;
@@ -1466,13 +1494,15 @@ static int usbat_hp8200e_transport(struct scsi_cmnd *srb, struct us_data *us)
                 return result;
         }
 
-        // Write the 12-byte command header.
-
-        // If the command is BLANK then set the timer for 75 minutes.
-        // Otherwise set it for 10 minutes.
-
-        // NOTE: THE 8200 DOCUMENTATION STATES THAT BLANKING A CDRW
-        // AT SPEED 4 IS UNRELIABLE!!!
+        /*
+         * Write the 12-byte command header.
+         *
+         * If the command is BLANK then set the timer for 75 minutes.
+         * Otherwise set it for 10 minutes.
+         *
+         * NOTE: THE 8200 DOCUMENTATION STATES THAT BLANKING A CDRW
+         * AT SPEED 4 IS UNRELIABLE!!!
+         */
 
         if ( (result = usbat_write_block(us, 
                         USBAT_ATA, srb->cmnd, 12,
@@ -1481,19 +1511,18 @@ static int usbat_hp8200e_transport(struct scsi_cmnd *srb, struct us_data *us)
                 return result;
         }
 
-        // If there is response data to be read in 
-        // then do it here.
+        /* If there is response data to be read in then do it here. */
 
         if (len != 0 && (srb->sc_data_direction == DMA_FROM_DEVICE)) {
 
-                // How many bytes to read in? Check cylL register
+                /* How many bytes to read in? Check cylL register */
 
                 if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_ME, status) != 
                         USB_STOR_XFER_GOOD) {
                         return USB_STOR_TRANSPORT_ERROR;
                 }
 
-                if (len > 0xFF) { // need to read cylH also
+                if (len > 0xFF) { /* need to read cylH also */
                         len = *status;
                         if (usbat_read(us, USBAT_ATA, USBAT_ATA_LBA_HI, status) !=
                                     USB_STOR_XFER_GOOD) {
@@ -1556,13 +1585,16 @@ static int usbat_flash_transport(struct scsi_cmnd * srb, struct us_data *us)
                 if (rc != USB_STOR_TRANSPORT_GOOD)
                         return rc;
 
-                info->ssize = 0x200;  // hard coded 512 byte sectors as per ATA spec
+                /* hard coded 512 byte sectors as per ATA spec */
+                info->ssize = 0x200;
                 US_DEBUGP("usbat_flash_transport: READ_CAPACITY: %ld sectors, %ld bytes per sector\n",
                           info->sectors, info->ssize);
 
-                // build the reply
-                // note: must return the sector number of the last sector,
-                // *not* the total number of sectors
+                /*
+                 * build the reply
+                 * note: must return the sector number of the last sector,
+                 * *not* the total number of sectors
+                 */
                 ((__be32 *) ptr)[0] = cpu_to_be32(info->sectors - 1);
                 ((__be32 *) ptr)[1] = cpu_to_be32(info->ssize);
                 usb_stor_set_xfer_buf(ptr, 8, srb);
@@ -1586,7 +1618,9 @@ static int usbat_flash_transport(struct scsi_cmnd * srb, struct us_data *us)
         }
 
         if (srb->cmnd[0] == READ_12) {
-                // I don't think we'll ever see a READ_12 but support it anyway...
+                /*
+                 * I don't think we'll ever see a READ_12 but support it anyway
+                 */
                 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
                         ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
 
@@ -1608,7 +1642,9 @@ static int usbat_flash_transport(struct scsi_cmnd * srb, struct us_data *us)
         }
 
         if (srb->cmnd[0] == WRITE_12) {
-                // I don't think we'll ever see a WRITE_12 but support it anyway...
+                /*
+                 * I don't think we'll ever see a WRITE_12 but support it anyway
+                 */
                 block = ((u32)(srb->cmnd[2]) << 24) | ((u32)(srb->cmnd[3]) << 16) |
                         ((u32)(srb->cmnd[4]) <<  8) | ((u32)(srb->cmnd[5]));
 
@@ -1645,8 +1681,10 @@ static int usbat_flash_transport(struct scsi_cmnd * srb, struct us_data *us)
         }
 
         if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) {
-                // sure.  whatever.  not like we can stop the user from popping
-                // the media out of the device (no locking doors, etc)
+                /*
+                 * sure.  whatever.  not like we can stop the user from popping
+                 * the media out of the device (no locking doors, etc)
+                 */
                 return USB_STOR_TRANSPORT_GOOD;
         }
 
diff --git a/drivers/usb/storage/shuttle_usbat.h b/drivers/usb/storage/shuttle_usbat.h
index 5b8e867e2ae5..25e7d8b340b8 100644
--- a/drivers/usb/storage/shuttle_usbat.h
+++ b/drivers/usb/storage/shuttle_usbat.h
@@ -55,8 +55,8 @@
 #define USBAT_UIO_WRITE 0
 
 /* Qualifier bits */
-#define USBAT_QUAL_FCQ  0x20 // full compare
-#define USBAT_QUAL_ALQ  0x10 // auto load subcount
+#define USBAT_QUAL_FCQ  0x20    /* full compare */
+#define USBAT_QUAL_ALQ  0x10    /* auto load subcount */
 
 /* USBAT Flash Media status types */
 #define USBAT_FLASH_MEDIA_NONE  0
@@ -67,39 +67,39 @@
 #define USBAT_FLASH_MEDIA_CHANGED       1
 
 /* USBAT ATA registers */
-#define USBAT_ATA_DATA      0x10  // read/write data (R/W)
-#define USBAT_ATA_FEATURES  0x11  // set features (W)
-#define USBAT_ATA_ERROR     0x11  // error (R)
-#define USBAT_ATA_SECCNT    0x12  // sector count (R/W)
-#define USBAT_ATA_SECNUM    0x13  // sector number (R/W)
-#define USBAT_ATA_LBA_ME    0x14  // cylinder low (R/W)
-#define USBAT_ATA_LBA_HI    0x15  // cylinder high (R/W)
-#define USBAT_ATA_DEVICE    0x16  // head/device selection (R/W)
-#define USBAT_ATA_STATUS    0x17  // device status (R)
-#define USBAT_ATA_CMD       0x17  // device command (W)
-#define USBAT_ATA_ALTSTATUS 0x0E  // status (no clear IRQ) (R)
+#define USBAT_ATA_DATA      0x10  /* read/write data (R/W) */
+#define USBAT_ATA_FEATURES  0x11  /* set features (W) */
+#define USBAT_ATA_ERROR     0x11  /* error (R) */
+#define USBAT_ATA_SECCNT    0x12  /* sector count (R/W) */
+#define USBAT_ATA_SECNUM    0x13  /* sector number (R/W) */
+#define USBAT_ATA_LBA_ME    0x14  /* cylinder low (R/W) */
+#define USBAT_ATA_LBA_HI    0x15  /* cylinder high (R/W) */
+#define USBAT_ATA_DEVICE    0x16  /* head/device selection (R/W) */
+#define USBAT_ATA_STATUS    0x17  /* device status (R) */
+#define USBAT_ATA_CMD       0x17  /* device command (W) */
+#define USBAT_ATA_ALTSTATUS 0x0E  /* status (no clear IRQ) (R) */
 
 /* USBAT User I/O Data registers */
-#define USBAT_UIO_EPAD          0x80 // Enable Peripheral Control Signals
-#define USBAT_UIO_CDT           0x40 // Card Detect (Read Only)
-                                     // CDT = ACKD & !UI1 & !UI0
-#define USBAT_UIO_1             0x20 // I/O 1
-#define USBAT_UIO_0             0x10 // I/O 0
-#define USBAT_UIO_EPP_ATA       0x08 // 1=EPP mode, 0=ATA mode
-#define USBAT_UIO_UI1           0x04 // Input 1
-#define USBAT_UIO_UI0           0x02 // Input 0
-#define USBAT_UIO_INTR_ACK      0x01 // Interrupt (ATA & ISA)/Acknowledge (EPP)
+#define USBAT_UIO_EPAD          0x80 /* Enable Peripheral Control Signals */
+#define USBAT_UIO_CDT           0x40 /* Card Detect (Read Only) */
+                                     /* CDT = ACKD & !UI1 & !UI0 */
+#define USBAT_UIO_1             0x20 /* I/O 1 */
+#define USBAT_UIO_0             0x10 /* I/O 0 */
+#define USBAT_UIO_EPP_ATA       0x08 /* 1=EPP mode, 0=ATA mode */
+#define USBAT_UIO_UI1           0x04 /* Input 1 */
+#define USBAT_UIO_UI0           0x02 /* Input 0 */
+#define USBAT_UIO_INTR_ACK      0x01 /* Interrupt (ATA/ISA)/Acknowledge (EPP) */
 
 /* USBAT User I/O Enable registers */
-#define USBAT_UIO_DRVRST        0x80 // Reset Peripheral
-#define USBAT_UIO_ACKD          0x40 // Enable Card Detect
-#define USBAT_UIO_OE1           0x20 // I/O 1 set=output/clr=input
-                                     // If ACKD=1, set OE1 to 1 also.
-#define USBAT_UIO_OE0           0x10 // I/O 0 set=output/clr=input
-#define USBAT_UIO_ADPRST        0x01 // Reset SCM chip
+#define USBAT_UIO_DRVRST        0x80 /* Reset Peripheral */
+#define USBAT_UIO_ACKD          0x40 /* Enable Card Detect */
+#define USBAT_UIO_OE1           0x20 /* I/O 1 set=output/clr=input */
+                                     /* If ACKD=1, set OE1 to 1 also. */
+#define USBAT_UIO_OE0           0x10 /* I/O 0 set=output/clr=input */
+#define USBAT_UIO_ADPRST        0x01 /* Reset SCM chip */
 
 /* USBAT Features */
-#define USBAT_FEAT_ETEN 0x80 // External trigger enable
+#define USBAT_FEAT_ETEN 0x80    /* External trigger enable */
 #define USBAT_FEAT_U1   0x08
 #define USBAT_FEAT_U0   0x04
 #define USBAT_FEAT_ET1  0x02
@@ -112,12 +112,12 @@ struct usbat_info {
         int devicetype;
 
         /* Used for Flash readers only */
-        unsigned long sectors;     // total sector count
-        unsigned long ssize;       // sector size in bytes
+        unsigned long sectors;     /* total sector count */
+        unsigned long ssize;       /* sector size in bytes */
 
         unsigned char sense_key;
-        unsigned long sense_asc;   // additional sense code
-        unsigned long sense_ascq;  // additional sense code qualifier
+        unsigned long sense_asc;   /* additional sense code */
+        unsigned long sense_ascq;  /* additional sense code qualifier */
 };
 
 #endif
diff --git a/drivers/usb/storage/transport.c b/drivers/usb/storage/transport.c
index c1ba5301ebfc..7ca896a342e3 100644
--- a/drivers/usb/storage/transport.c
+++ b/drivers/usb/storage/transport.c
@@ -636,11 +636,11 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
 
                 /* use the new buffer we have */
                 old_request_buffer = srb->request_buffer;
-                srb->request_buffer = srb->sense_buffer;
+                srb->request_buffer = us->sensebuf;
 
                 /* set the buffer length for transfer */
                 old_request_bufflen = srb->request_bufflen;
-                srb->request_bufflen = 18;
+                srb->request_bufflen = US_SENSE_SIZE;
 
                 /* set up for no scatter-gather use */
                 old_sg = srb->use_sg;
@@ -652,6 +652,7 @@ void usb_stor_invoke_transport(struct scsi_cmnd *srb, struct us_data *us)
                 temp_result = us->transport(us->srb, us);
 
                 /* let's clean up right away */
+                memcpy(srb->sense_buffer, us->sensebuf, US_SENSE_SIZE);
                 srb->resid = old_resid;
                 srb->request_buffer = old_request_buffer;
                 srb->request_bufflen = old_request_bufflen;
@@ -923,6 +924,7 @@ int usb_stor_Bulk_max_lun(struct us_data *us)
         int result;
 
         /* issue the command */
+        us->iobuf[0] = 0;
         result = usb_stor_control_msg(us, us->recv_ctrl_pipe,
                                  US_BULK_GET_MAX_LUN, 
                                  USB_DIR_IN | USB_TYPE_CLASS | 
diff --git a/drivers/usb/storage/transport.h b/drivers/usb/storage/transport.h
index 8d9e0663f8fe..0a362cc781ad 100644
--- a/drivers/usb/storage/transport.h
+++ b/drivers/usb/storage/transport.h
@@ -50,7 +50,7 @@
 #define US_PR_CB        0x01            /* Control/Bulk w/o interrupt */
 #define US_PR_BULK      0x50            /* bulk only */
 #ifdef CONFIG_USB_STORAGE_USBAT
-#define US_PR_SCM_ATAPI 0x80            /* SCM-ATAPI bridge */
+#define US_PR_USBAT     0x80            /* SCM-ATAPI bridge */
 #endif
 #ifdef CONFIG_USB_STORAGE_SDDR09
 #define US_PR_EUSB_SDDR09       0x81    /* SCM-SCSI bridge for SDDR-09 */
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index b79dad1b598c..9e926a8f2116 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -71,12 +71,12 @@ UNUSUAL_DEV(  0x03f0, 0x0107, 0x0200, 0x0200,
 UNUSUAL_DEV(  0x03f0, 0x0207, 0x0001, 0x0001, 
                 "HP",
                 "CD-Writer+ 8200e",
-                US_SC_8070, US_PR_SCM_ATAPI, init_usbat, 0), 
+                US_SC_8070, US_PR_USBAT, init_usbat, 0),
 
 UNUSUAL_DEV(  0x03f0, 0x0307, 0x0001, 0x0001, 
                 "HP",
                 "CD-Writer+ CD-4e",
-                US_SC_8070, US_PR_SCM_ATAPI, init_usbat, 0), 
+                US_SC_8070, US_PR_USBAT, init_usbat, 0),
 #endif
 
 /* Patch submitted by Mihnea-Costin Grigore <mihnea@zulu.ro> */
@@ -106,6 +106,13 @@ UNUSUAL_DEV(  0x0411, 0x001c, 0x0113, 0x0113,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_FIX_INQUIRY ),
 
+/* Reported by Stefan Werner <dustbln@gmx.de> */
+UNUSUAL_DEV(  0x0419, 0xaaf6, 0x0100, 0x0100,
+                "TrekStor",
+                "i.Beat Joy 2.0",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_IGNORE_RESIDUE ),
+
 /* Reported by Olaf Hering <olh@suse.de> from novell bug #105878 */
 UNUSUAL_DEV(  0x0424, 0x0fdc, 0x0210, 0x0210,
                 "SMSC",
@@ -244,6 +251,13 @@ UNUSUAL_DEV(  0x04da, 0x2372, 0x0000, 0x9999,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY | US_FL_NOT_LOCKABLE ),
 
+/* Reported by Simeon Simeonov <simeonov_2000@yahoo.com> */
+UNUSUAL_DEV(  0x04da, 0x2373, 0x0000, 0x9999,
+                "LEICA",
+                "D-LUX Camera",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_FIX_CAPACITY | US_FL_NOT_LOCKABLE ),
+
 /* Most of the following entries were developed with the help of
  * Shuttle/SCM directly.
  */
@@ -333,9 +347,9 @@ UNUSUAL_DEV(  0x04fc, 0x80c2, 0x0100, 0x0100,
 
 #ifdef CONFIG_USB_STORAGE_USBAT
 UNUSUAL_DEV(  0x04e6, 0x1010, 0x0000, 0x9999,
-                "SCM",
-                "SCM USBAT-02",
-                US_SC_SCSI, US_PR_SCM_ATAPI, init_usbat,
+                "Shuttle/SCM",
+                "USBAT-02",
+                US_SC_SCSI, US_PR_USBAT, init_usbat,
                 US_FL_SINGLE_LUN),
 #endif
 
@@ -598,6 +612,16 @@ UNUSUAL_DEV( 0x05ac, 0x1205, 0x0000, 0x9999,
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
                 US_FL_FIX_CAPACITY ),
 
+/*
+ * Reported by Tyson Vinson <lornoss@gmail.com>
+ * This particular productId is the iPod Nano
+ */
+UNUSUAL_DEV( 0x05ac, 0x120a, 0x0000, 0x9999,
+                "Apple",
+                "iPod",
+                US_SC_DEVICE, US_PR_DEVICE, NULL,
+                US_FL_FIX_CAPACITY ),
+
 #ifdef CONFIG_USB_STORAGE_JUMPSHOT
 UNUSUAL_DEV(  0x05dc, 0x0001, 0x0000, 0x0001,
                 "Lexar",
@@ -702,6 +726,14 @@ UNUSUAL_DEV(  0x0781, 0x0001, 0x0200, 0x0200,
                 US_SC_SCSI, US_PR_CB, NULL,
                 US_FL_SINGLE_LUN ),
 
+#ifdef CONFIG_USB_STORAGE_USBAT
+UNUSUAL_DEV(  0x0781, 0x0005, 0x0005, 0x0005,
+                "Sandisk",
+                "ImageMate SDDR-05b",
+                US_SC_SCSI, US_PR_USBAT, init_usbat,
+                US_FL_SINGLE_LUN ),
+#endif
+
 UNUSUAL_DEV(  0x0781, 0x0100, 0x0100, 0x0100,
                 "Sandisk",
                 "ImageMate SDDR-12",
@@ -724,7 +756,7 @@ UNUSUAL_DEV(  0x07ab, 0xfc01, 0x0000, 0x9999,
 #endif
 
 /* Reported by Eero Volotinen <eero@ping-viini.org> */
-UNUSUAL_DEV(  0x07ab, 0xfccd, 0x0406, 0x0406,
+UNUSUAL_DEV(  0x07ab, 0xfccd, 0x0000, 0x9999,
                 "Freecom Technologies",
                 "FHD-Classic",
                 US_SC_DEVICE, US_PR_DEVICE, NULL,
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index f9a9bfa1aef5..3847ebed2aa4 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -54,6 +54,7 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/slab.h>
+#include <linux/kthread.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
@@ -111,11 +112,6 @@ static atomic_t total_threads = ATOMIC_INIT(0);
 static DECLARE_COMPLETION(threads_gone);
 
 
-static int storage_probe(struct usb_interface *iface,
-                         const struct usb_device_id *id);
-
-static void storage_disconnect(struct usb_interface *iface);
-
 /* The entries in this table, except for final ones here
  * (USB_MASS_STORAGE_CLASS and the empty entry), correspond,
  * line for line with the entries of us_unsuaul_dev_list[].
@@ -233,13 +229,40 @@ static struct us_unusual_dev us_unusual_dev_list[] = {
         { NULL }
 };
 
-static struct usb_driver usb_storage_driver = {
-        .owner =        THIS_MODULE,
-        .name =         "usb-storage",
-        .probe =        storage_probe,
-        .disconnect =   storage_disconnect,
-        .id_table =     storage_usb_ids,
-};
+
+#ifdef CONFIG_PM        /* Minimal support for suspend and resume */
+
+static int storage_suspend(struct usb_interface *iface, pm_message_t message)
+{
+        struct us_data *us = usb_get_intfdata(iface);
+
+        /* Wait until no command is running */
+        down(&us->dev_semaphore);
+
+        US_DEBUGP("%s\n", __FUNCTION__);
+        iface->dev.power.power_state.event = message.event;
+
+        /* When runtime PM is working, we'll set a flag to indicate
+         * whether we should autoresume when a SCSI request arrives. */
+
+        up(&us->dev_semaphore);
+        return 0;
+}
+
+static int storage_resume(struct usb_interface *iface)
+{
+        struct us_data *us = usb_get_intfdata(iface);
+
+        down(&us->dev_semaphore);
+
+        US_DEBUGP("%s\n", __FUNCTION__);
+        iface->dev.power.power_state.event = PM_EVENT_ON;
+
+        up(&us->dev_semaphore);
+        return 0;
+}
+
+#endif /* CONFIG_PM */
 
 /*
  * fill_inquiry_response takes an unsigned char array (which must
@@ -288,22 +311,7 @@ static int usb_stor_control_thread(void * __us)
         struct us_data *us = (struct us_data *)__us;
         struct Scsi_Host *host = us_to_host(us);
 
-        lock_kernel();
-
-        /*
-         * This thread doesn't need any user-level access,
-         * so get rid of all our resources.
-         */
-        daemonize("usb-storage");
         current->flags |= PF_NOFREEZE;
-        unlock_kernel();
-
-        /* acquire a reference to the host, so it won't be deallocated
-         * until we're ready to exit */
-        scsi_host_get(host);
-
-        /* signal that we've started the thread */
-        complete(&(us->notify));
 
         for(;;) {
                 US_DEBUGP("*** thread sleeping.\n");
@@ -467,6 +475,12 @@ static int associate_dev(struct us_data *us, struct usb_interface *intf)
                 US_DEBUGP("I/O buffer allocation failed\n");
                 return -ENOMEM;
         }
+
+        us->sensebuf = kmalloc(US_SENSE_SIZE, GFP_KERNEL);
+        if (!us->sensebuf) {
+                US_DEBUGP("Sense buffer allocation failed\n");
+                return -ENOMEM;
+        }
         return 0;
 }
 
@@ -555,8 +569,8 @@ static int get_transport(struct us_data *us)
                 break;
 
 #ifdef CONFIG_USB_STORAGE_USBAT
-        case US_PR_SCM_ATAPI:
-                us->transport_name = "SCM/ATAPI";
+        case US_PR_USBAT:
+                us->transport_name = "Shuttle USBAT";
                 us->transport = usbat_transport;
                 us->transport_reset = usb_stor_CB_reset;
                 us->max_lun = 1;
@@ -740,6 +754,7 @@ static int get_pipes(struct us_data *us)
 static int usb_stor_acquire_resources(struct us_data *us)
 {
         int p;
+        struct task_struct *th;
 
         us->current_urb = usb_alloc_urb(0, GFP_KERNEL);
         if (!us->current_urb) {
@@ -747,38 +762,28 @@ static int usb_stor_acquire_resources(struct us_data *us)
                 return -ENOMEM;
         }
 
-        /* Lock the device while we carry out the next two operations */
-        down(&us->dev_semaphore);
-
-        /* For bulk-only devices, determine the max LUN value */
-        if (us->protocol == US_PR_BULK) {
-                p = usb_stor_Bulk_max_lun(us);
-                if (p < 0) {
-                        up(&us->dev_semaphore);
-                        return p;
-                }
-                us->max_lun = p;
-        }
-
         /* Just before we start our control thread, initialize
          * the device if it needs initialization */
-        if (us->unusual_dev->initFunction)
-                us->unusual_dev->initFunction(us);
-
-        up(&us->dev_semaphore);
+        if (us->unusual_dev->initFunction) {
+                p = us->unusual_dev->initFunction(us);
+                if (p)
+                        return p;
+        }
 
         /* Start up our control thread */
-        p = kernel_thread(usb_stor_control_thread, us, CLONE_VM);
-        if (p < 0) {
+        th = kthread_create(usb_stor_control_thread, us, "usb-storage");
+        if (IS_ERR(th)) {
                 printk(KERN_WARNING USB_STORAGE 
                        "Unable to start control thread\n");
-                return p;
+                return PTR_ERR(th);
         }
-        us->pid = p;
-        atomic_inc(&total_threads);
 
-        /* Wait for the thread to start */
-        wait_for_completion(&(us->notify));
+        /* Take a reference to the host for the control thread and
+         * count it among all the threads we have launched.  Then
+         * start it up. */
+        scsi_host_get(us_to_host(us));
+        atomic_inc(&total_threads);
+        wake_up_process(th);
 
         return 0;
 }
@@ -812,6 +817,8 @@ static void dissociate_dev(struct us_data *us)
 {
         US_DEBUGP("-- %s\n", __FUNCTION__);
 
+        kfree(us->sensebuf);
+
         /* Free the device-related DMA-mapped buffers */
         if (us->cr)
                 usb_buffer_free(us->pusb_dev, sizeof(*us->cr), us->cr,
@@ -872,21 +879,6 @@ static int usb_stor_scan_thread(void * __us)
 {
         struct us_data *us = (struct us_data *)__us;
 
-        /*
-         * This thread doesn't need any user-level access,
-         * so get rid of all our resources.
-         */
-        lock_kernel();
-        daemonize("usb-stor-scan");
-        unlock_kernel();
-
-        /* Acquire a reference to the host, so it won't be deallocated
-         * until we're ready to exit */
-        scsi_host_get(us_to_host(us));
-
-        /* Signal that we've started the thread */
-        complete(&(us->notify));
-
         printk(KERN_DEBUG
                 "usb-storage: device found at %d\n", us->pusb_dev->devnum);
 
@@ -904,6 +896,14 @@ retry:
 
         /* If the device is still connected, perform the scanning */
         if (!test_bit(US_FLIDX_DISCONNECTING, &us->flags)) {
+
+                /* For bulk-only devices, determine the max LUN value */
+                if (us->protocol == US_PR_BULK &&
+                                !(us->flags & US_FL_SINGLE_LUN)) {
+                        down(&us->dev_semaphore);
+                        us->max_lun = usb_stor_Bulk_max_lun(us);
+                        up(&us->dev_semaphore);
+                }
                 scsi_scan_host(us_to_host(us));
                 printk(KERN_DEBUG "usb-storage: device scan complete\n");
 
@@ -923,6 +923,7 @@ static int storage_probe(struct usb_interface *intf,
         struct us_data *us;
         const int id_index = id - storage_usb_ids; 
         int result;
+        struct task_struct *th;
 
         US_DEBUGP("USB Mass Storage device detected\n");
 
@@ -1003,17 +1004,21 @@ static int storage_probe(struct usb_interface *intf,
         }
 
         /* Start up the thread for delayed SCSI-device scanning */
-        result = kernel_thread(usb_stor_scan_thread, us, CLONE_VM);
-        if (result < 0) {
+        th = kthread_create(usb_stor_scan_thread, us, "usb-stor-scan");
+        if (IS_ERR(th)) {
                 printk(KERN_WARNING USB_STORAGE 
                        "Unable to start the device-scanning thread\n");
                 quiesce_and_remove_host(us);
+                result = PTR_ERR(th);
                 goto BadDevice;
         }
-        atomic_inc(&total_threads);
 
-        /* Wait for the thread to start */
-        wait_for_completion(&(us->notify));
+        /* Take a reference to the host for the scanning thread and
+         * count it among all the threads we have launched.  Then
+         * start it up. */
+        scsi_host_get(us_to_host(us));
+        atomic_inc(&total_threads);
+        wake_up_process(th);
 
         return 0;
 
@@ -1038,6 +1043,18 @@ static void storage_disconnect(struct usb_interface *intf)
  * Initialization and registration
  ***********************************************************************/
 
+static struct usb_driver usb_storage_driver = {
+        .owner =        THIS_MODULE,
+        .name =         "usb-storage",
+        .probe =        storage_probe,
+        .disconnect =   storage_disconnect,
+#ifdef CONFIG_PM
+        .suspend =      storage_suspend,
+        .resume =       storage_resume,
+#endif
+        .id_table =     storage_usb_ids,
+};
+
 static int __init usb_stor_init(void)
 {
         int retval;
diff --git a/drivers/usb/storage/usb.h b/drivers/usb/storage/usb.h
index a195adae57b6..98b09711a739 100644
--- a/drivers/usb/storage/usb.h
+++ b/drivers/usb/storage/usb.h
@@ -117,6 +117,7 @@ enum { US_DO_ALL_FLAGS };
  */
 
 #define US_IOBUF_SIZE           64      /* Size of the DMA-mapped I/O buffer */
+#define US_SENSE_SIZE           18      /* Size of the autosense data buffer */
 
 typedef int (*trans_cmnd)(struct scsi_cmnd *, struct us_data*);
 typedef int (*trans_reset)(struct us_data*);
@@ -160,14 +161,12 @@ struct us_data {
         struct scsi_cmnd        *srb;            /* current srb         */
         unsigned int            tag;             /* current dCBWTag     */
 
-        /* thread information */
-        int                     pid;             /* control thread       */
-
         /* control and bulk communications data */
         struct urb              *current_urb;    /* USB requests         */
         struct usb_ctrlrequest  *cr;             /* control requests     */
         struct usb_sg_request   current_sg;      /* scatter-gather req.  */
         unsigned char           *iobuf;          /* I/O buffer           */
+        unsigned char           *sensebuf;       /* sense data buffer    */
         dma_addr_t              cr_dma;          /* buffer DMA addresses */
         dma_addr_t              iobuf_dma;
 
diff --git a/drivers/usb/usb-skeleton.c b/drivers/usb/usb-skeleton.c
index 353f24d45bc1..6c3a53f8f26c 100644
--- a/drivers/usb/usb-skeleton.c
+++ b/drivers/usb/usb-skeleton.c
@@ -223,9 +223,8 @@ static struct file_operations skel_fops = {
  * and to have the device registered with devfs and the driver core
  */
 static struct usb_class_driver skel_class = {
-        .name =         "usb/skel%d",
+        .name =         "skel%d",
         .fops =         &skel_fops,
-        .mode =         S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH,
         .minor_base =   USB_SKEL_MINOR_BASE,
 };
 
diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c
index e28a74203f3b..a327e03753ac 100644
--- a/fs/compat_ioctl.c
+++ b/fs/compat_ioctl.c
@@ -3050,6 +3050,7 @@ HANDLE_IOCTL(TIOCSSERIAL, serial_struct_ioctl)
 HANDLE_IOCTL(USBDEVFS_CONTROL32, do_usbdevfs_control)
 HANDLE_IOCTL(USBDEVFS_BULK32, do_usbdevfs_bulk)
 HANDLE_IOCTL(USBDEVFS_DISCSIGNAL32, do_usbdevfs_discsignal)
+COMPATIBLE_IOCTL(USBDEVFS_IOCTL32)
 /* i2c */
 HANDLE_IOCTL(I2C_FUNCS, w_long)
 HANDLE_IOCTL(I2C_RDWR, do_i2c_rdwr_ioctl)
diff --git a/include/asm-i386/mach-summit/mach_mpparse.h b/include/asm-i386/mach-summit/mach_mpparse.h
index 2b9e6d55bef1..1cce2b924a80 100644
--- a/include/asm-i386/mach-summit/mach_mpparse.h
+++ b/include/asm-i386/mach-summit/mach_mpparse.h
@@ -22,7 +22,6 @@ static inline void mpc_oem_pci_bus(struct mpc_config_bus *m,
 {
 }
 
-extern int usb_early_handoff;
 static inline int mps_oem_check(struct mp_config_table *mpc, char *oem, 
                 char *productid)
 {
@@ -32,7 +31,6 @@ static inline int mps_oem_check(struct mp_config_table *mpc, char *oem,
                          || !strncmp(productid, "RUTHLESS SMP", 12))){
                 use_cyclone = 1; /*enable cyclone-timer*/
                 setup_summit();
-                usb_early_handoff = 1;
                 return 1;
         }
         return 0;
@@ -46,7 +44,6 @@ static inline int acpi_madt_oem_check(char *oem_id, char *oem_table_id)
              || !strncmp(oem_table_id, "EXA", 3))){
                 use_cyclone = 1; /*enable cyclone-timer*/
                 setup_summit();
-                usb_early_handoff = 1;
                 return 1;
         }
         return 0;
diff --git a/include/asm-ia64/machvec.h b/include/asm-ia64/machvec.h
index a2f6ac5aef7d..ca5ea994d688 100644
--- a/include/asm-ia64/machvec.h
+++ b/include/asm-ia64/machvec.h
@@ -26,7 +26,7 @@ typedef void ia64_mv_cpu_init_t (void);
 typedef void ia64_mv_irq_init_t (void);
 typedef void ia64_mv_send_ipi_t (int, int, int, int);
 typedef void ia64_mv_timer_interrupt_t (int, void *, struct pt_regs *);
-typedef void ia64_mv_global_tlb_purge_t (unsigned long, unsigned long, unsigned long);
+typedef void ia64_mv_global_tlb_purge_t (struct mm_struct *, unsigned long, unsigned long, unsigned long);
 typedef void ia64_mv_tlb_migrate_finish_t (struct mm_struct *);
 typedef unsigned int ia64_mv_local_vector_to_irq (u8);
 typedef char *ia64_mv_pci_get_legacy_mem_t (struct pci_bus *);
diff --git a/include/asm-ia64/machvec_hpzx1.h b/include/asm-ia64/machvec_hpzx1.h
index daafe504c5f4..e90daf9ce340 100644
--- a/include/asm-ia64/machvec_hpzx1.h
+++ b/include/asm-ia64/machvec_hpzx1.h
@@ -1,8 +1,7 @@
 #ifndef _ASM_IA64_MACHVEC_HPZX1_h
 #define _ASM_IA64_MACHVEC_HPZX1_h
 
-extern ia64_mv_setup_t dig_setup;
-extern ia64_mv_setup_t                  sba_setup;
+extern ia64_mv_setup_t                  dig_setup;
 extern ia64_mv_dma_alloc_coherent       sba_alloc_coherent;
 extern ia64_mv_dma_free_coherent        sba_free_coherent;
 extern ia64_mv_dma_map_single           sba_map_single;
@@ -19,15 +18,15 @@ extern ia64_mv_dma_mapping_error	sba_dma_mapping_error;
  * platform's machvec structure.  When compiling a non-generic kernel,
  * the macros are used directly.
  */
-#define platform_name                   "hpzx1"
-#define platform_setup                  sba_setup
-#define platform_dma_init               machvec_noop
-#define platform_dma_alloc_coherent     sba_alloc_coherent
-#define platform_dma_free_coherent      sba_free_coherent
-#define platform_dma_map_single         sba_map_single
-#define platform_dma_unmap_single       sba_unmap_single
-#define platform_dma_map_sg             sba_map_sg
-#define platform_dma_unmap_sg           sba_unmap_sg
+#define platform_name                           "hpzx1"
+#define platform_setup                          dig_setup
+#define platform_dma_init                       machvec_noop
+#define platform_dma_alloc_coherent             sba_alloc_coherent
+#define platform_dma_free_coherent              sba_free_coherent
+#define platform_dma_map_single                 sba_map_single
+#define platform_dma_unmap_single               sba_unmap_single
+#define platform_dma_map_sg                     sba_map_sg
+#define platform_dma_unmap_sg                   sba_unmap_sg
 #define platform_dma_sync_single_for_cpu        machvec_dma_sync_single
 #define platform_dma_sync_sg_for_cpu            machvec_dma_sync_sg
 #define platform_dma_sync_single_for_device     machvec_dma_sync_single
diff --git a/include/asm-ia64/machvec_hpzx1_swiotlb.h b/include/asm-ia64/machvec_hpzx1_swiotlb.h
index 9924b1b00a6c..f00a34a148ff 100644
--- a/include/asm-ia64/machvec_hpzx1_swiotlb.h
+++ b/include/asm-ia64/machvec_hpzx1_swiotlb.h
@@ -2,7 +2,6 @@
 #define _ASM_IA64_MACHVEC_HPZX1_SWIOTLB_h
 
 extern ia64_mv_setup_t                          dig_setup;
-extern ia64_mv_dma_init                         hwsw_init;
 extern ia64_mv_dma_alloc_coherent               hwsw_alloc_coherent;
 extern ia64_mv_dma_free_coherent                hwsw_free_coherent;
 extern ia64_mv_dma_map_single                   hwsw_map_single;
@@ -26,7 +25,7 @@ extern ia64_mv_dma_sync_sg_for_device		hwsw_sync_sg_for_device;
 #define platform_name                           "hpzx1_swiotlb"
 
 #define platform_setup                          dig_setup
-#define platform_dma_init                       hwsw_init
+#define platform_dma_init                       machvec_noop
 #define platform_dma_alloc_coherent             hwsw_alloc_coherent
 #define platform_dma_free_coherent              hwsw_free_coherent
 #define platform_dma_map_single                 hwsw_map_single
diff --git a/include/asm-ia64/meminit.h b/include/asm-ia64/meminit.h
index 1590dc65b30b..46501b01a5c5 100644
--- a/include/asm-ia64/meminit.h
+++ b/include/asm-ia64/meminit.h
@@ -16,10 +16,11 @@
  *      - initrd (optional)
  *      - command line string
  *      - kernel code & data
+ *      - Kernel memory map built from EFI memory map
  *
  * More could be added if necessary
  */
-#define IA64_MAX_RSVD_REGIONS 5
+#define IA64_MAX_RSVD_REGIONS 6
 
 struct rsvd_region {
         unsigned long start;    /* virtual address of beginning of element */
@@ -33,6 +34,7 @@ extern void find_memory (void);
 extern void reserve_memory (void);
 extern void find_initrd (void);
 extern int filter_rsvd_memory (unsigned long start, unsigned long end, void *arg);
+extern void efi_memmap_init(unsigned long *, unsigned long *);
 
 /*
  * For rounding an address to the next IA64_GRANULE_SIZE or order
@@ -41,7 +43,7 @@ extern int filter_rsvd_memory (unsigned long start, unsigned long end, void *arg
 #define GRANULEROUNDUP(n)       (((n)+IA64_GRANULE_SIZE-1) & ~(IA64_GRANULE_SIZE-1))
 #define ORDERROUNDDOWN(n)       ((n) & ~((PAGE_SIZE<<MAX_ORDER)-1))
 
-#ifdef CONFIG_DISCONTIGMEM
+#ifdef CONFIG_NUMA
   extern void call_pernode_memory (unsigned long start, unsigned long len, void *func);
 #else
 # define call_pernode_memory(start, len, func)  (*func)(start, len, 0)
diff --git a/include/asm-ia64/mmzone.h b/include/asm-ia64/mmzone.h
index d32f51e3d6c2..34efe88eb849 100644
--- a/include/asm-ia64/mmzone.h
+++ b/include/asm-ia64/mmzone.h
@@ -15,7 +15,7 @@
 #include <asm/page.h>
 #include <asm/meminit.h>
 
-#ifdef CONFIG_DISCONTIGMEM
+#ifdef CONFIG_NUMA
 
 static inline int pfn_to_nid(unsigned long pfn)
 {
@@ -31,6 +31,10 @@ static inline int pfn_to_nid(unsigned long pfn)
 #endif
 }
 
+#ifdef CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID
+extern int early_pfn_to_nid(unsigned long pfn);
+#endif
+
 #ifdef CONFIG_IA64_DIG /* DIG systems are small */
 # define MAX_PHYSNODE_ID        8
 # define NR_NODE_MEMBLKS        (MAX_NUMNODES * 8)
@@ -39,8 +43,8 @@ static inline int pfn_to_nid(unsigned long pfn)
 # define NR_NODE_MEMBLKS        (MAX_NUMNODES * 4)
 #endif
 
-#else /* CONFIG_DISCONTIGMEM */
+#else /* CONFIG_NUMA */
 # define NR_NODE_MEMBLKS        (MAX_NUMNODES * 4)
-#endif /* CONFIG_DISCONTIGMEM */
+#endif /* CONFIG_NUMA */
 
 #endif /* _ASM_IA64_MMZONE_H */
diff --git a/include/asm-ia64/nodedata.h b/include/asm-ia64/nodedata.h
index 6b0f3ed89b7e..9978c7ce7549 100644
--- a/include/asm-ia64/nodedata.h
+++ b/include/asm-ia64/nodedata.h
@@ -17,7 +17,7 @@
 #include <asm/percpu.h>
 #include <asm/mmzone.h>
 
-#ifdef CONFIG_DISCONTIGMEM
+#ifdef CONFIG_NUMA
 
 /*
  * Node Data. One of these structures is located on each node of a NUMA system.
@@ -47,6 +47,6 @@ struct ia64_node_data {
  */
 #define NODE_DATA(nid)          (local_node_data->pg_data_ptrs[nid])
 
-#endif /* CONFIG_DISCONTIGMEM */
+#endif /* CONFIG_NUMA */
 
 #endif /* _ASM_IA64_NODEDATA_H */
diff --git a/include/asm-ia64/page.h b/include/asm-ia64/page.h
index 9edffad8c28b..ef436b9d06ad 100644
--- a/include/asm-ia64/page.h
+++ b/include/asm-ia64/page.h
@@ -102,15 +102,15 @@ do {						\
 
 #ifdef CONFIG_VIRTUAL_MEM_MAP
 extern int ia64_pfn_valid (unsigned long pfn);
-#else
+#elif defined(CONFIG_FLATMEM)
 # define ia64_pfn_valid(pfn) 1
 #endif
 
-#ifndef CONFIG_DISCONTIGMEM
+#ifdef CONFIG_FLATMEM
 # define pfn_valid(pfn)         (((pfn) < max_mapnr) && ia64_pfn_valid(pfn))
 # define page_to_pfn(page)      ((unsigned long) (page - mem_map))
 # define pfn_to_page(pfn)       (mem_map + (pfn))
-#else
+#elif defined(CONFIG_DISCONTIGMEM)
 extern struct page *vmem_map;
 extern unsigned long max_low_pfn;
 # define pfn_valid(pfn)         (((pfn) < max_low_pfn) && ia64_pfn_valid(pfn))
diff --git a/include/asm-ia64/sn/arch.h b/include/asm-ia64/sn/arch.h
index ab827d298569..1a3831c04af6 100644
--- a/include/asm-ia64/sn/arch.h
+++ b/include/asm-ia64/sn/arch.h
@@ -18,6 +18,32 @@
 #include <asm/sn/sn_cpuid.h>
 
 /*
+ * This is the maximum number of NUMALINK nodes that can be part of a single
+ * SSI kernel. This number includes C-brick, M-bricks, and TIOs. Nodes in
+ * remote partitions are NOT included in this number.
+ * The number of compact nodes cannot exceed size of a coherency domain.
+ * The purpose of this define is to specify a node count that includes
+ * all C/M/TIO nodes in an SSI system.
+ *
+ * SGI system can currently support up to 256 C/M nodes plus additional TIO nodes.
+ *
+ *      Note: ACPI20 has an architectural limit of 256 nodes. When we upgrade
+ *      to ACPI3.0, this limit will be removed. The notion of "compact nodes"
+ *      should be deleted and TIOs should be included in MAX_NUMNODES.
+ */
+#define MAX_COMPACT_NODES       512
+
+/*
+ * Maximum number of nodes in all partitions and in all coherency domains.
+ * This is the total number of nodes accessible in the numalink fabric. It
+ * includes all C & M bricks, plus all TIOs.
+ *
+ * This value is also the value of the maximum number of NASIDs in the numalink
+ * fabric.
+ */
+#define MAX_NUMALINK_NODES      16384
+
+/*
  * The following defines attributes of the HUB chip. These attributes are
  * frequently referenced. They are kept in the per-cpu data areas of each cpu.
  * They are kept together in a struct to minimize cache misses.
@@ -41,15 +67,6 @@ DECLARE_PER_CPU(struct sn_hub_info_s, __sn_hub_info);
 
 
 /*
- * This is the maximum number of nodes that can be part of a kernel.
- * Effectively, it's the maximum number of compact node ids (cnodeid_t).
- * This is not necessarily the same as MAX_NASIDS.
- */
-#define MAX_COMPACT_NODES       2048
-#define CPUS_PER_NODE           4
-
-
-/*
  * Compact node ID to nasid mappings kept in the per-cpu data areas of each
  * cpu.
  */
@@ -57,7 +74,6 @@ DECLARE_PER_CPU(short, __sn_cnodeid_to_nasid[MAX_NUMNODES]);
 #define sn_cnodeid_to_nasid     (&__get_cpu_var(__sn_cnodeid_to_nasid[0]))
 
 
-
 extern u8 sn_partition_id;
 extern u8 sn_system_size;
 extern u8 sn_sharing_domain_size;
diff --git a/include/asm-ia64/sn/io.h b/include/asm-ia64/sn/io.h
index 42209733f6b1..41c73a735628 100644
--- a/include/asm-ia64/sn/io.h
+++ b/include/asm-ia64/sn/io.h
@@ -14,7 +14,7 @@
 extern void * sn_io_addr(unsigned long port) __attribute_const__; /* Forward definition */
 extern void __sn_mmiowb(void); /* Forward definition */
 
-extern int numionodes;
+extern int num_cnodes;
 
 #define __sn_mf_a()   ia64_mfa()
 
@@ -36,6 +36,15 @@ extern void sn_dma_flush(unsigned long);
 #define __sn_readq_relaxed ___sn_readq_relaxed
 
 /*
+ * Convenience macros for setting/clearing bits using the above accessors
+ */
+
+#define __sn_setq_relaxed(addr, val) \
+        writeq((__sn_readq_relaxed(addr) | (val)), (addr))
+#define __sn_clrq_relaxed(addr, val) \
+        writeq((__sn_readq_relaxed(addr) & ~(val)), (addr))
+
+/*
  * The following routines are SN Platform specific, called when
  * a reference is made to inX/outX set macros.  SN Platform
  * inX set of macros ensures that Posted DMA writes on the
diff --git a/include/asm-ia64/sn/klconfig.h b/include/asm-ia64/sn/klconfig.h
index 9f920c70a62a..bcbf209d63be 100644
--- a/include/asm-ia64/sn/klconfig.h
+++ b/include/asm-ia64/sn/klconfig.h
@@ -208,19 +208,6 @@ typedef struct lboard_s {
         klconf_off_t    brd_next_same;    /* Next BOARD with same nasid */
 } lboard_t;
 
-#define KLCF_NUM_COMPS(_brd)    ((_brd)->brd_numcompts)
-#define NODE_OFFSET_TO_KLINFO(n,off)    ((klinfo_t*) TO_NODE_CAC(n,off))
-#define KLCF_NEXT(_brd)         \
-        ((_brd)->brd_next_same ?     \
-         (NODE_OFFSET_TO_LBOARD((_brd)->brd_next_same_host, (_brd)->brd_next_same)): NULL)
-#define KLCF_NEXT_ANY(_brd)         \
-        ((_brd)->brd_next_any ?     \
-         (NODE_OFFSET_TO_LBOARD(NASID_GET(_brd), (_brd)->brd_next_any)): NULL)
-#define KLCF_COMP(_brd, _ndx)   \
-                ((((_brd)->brd_compts[(_ndx)]) == 0) ? 0 : \
-                        (NODE_OFFSET_TO_KLINFO(NASID_GET(_brd), (_brd)->brd_compts[(_ndx)])))
-
-
 /*
  * Generic info structure. This stores common info about a 
  * component.
@@ -249,24 +236,11 @@ typedef struct klinfo_s {                  /* Generic info */
 } klinfo_t ;
 
 
-static inline lboard_t *find_lboard_any(lboard_t * start, unsigned char brd_type)
+static inline lboard_t *find_lboard_next(lboard_t * brd)
 {
-        /* Search all boards stored on this node. */
-
-        while (start) {
-                if (start->brd_type == brd_type)
-                        return start;
-                start = KLCF_NEXT_ANY(start);
-        }
-        /* Didn't find it. */
-        return (lboard_t *) NULL;
+        if (brd && brd->brd_next_any)
+                return NODE_OFFSET_TO_LBOARD(NASID_GET(brd), brd->brd_next_any);
+        return NULL;
 }
 
-
-/* external declarations of Linux kernel functions. */
-
-extern lboard_t *root_lboard[];
-extern klinfo_t *find_component(lboard_t *brd, klinfo_t *kli, unsigned char type);
-extern klinfo_t *find_first_component(lboard_t *brd, unsigned char type);
-
 #endif /* _ASM_IA64_SN_KLCONFIG_H */
diff --git a/include/asm-ia64/sn/l1.h b/include/asm-ia64/sn/l1.h
index 2e5f0aa38889..e3b819110d47 100644
--- a/include/asm-ia64/sn/l1.h
+++ b/include/asm-ia64/sn/l1.h
@@ -35,4 +35,16 @@
 #define L1_BRICKTYPE_ATHENA     0x2b            /* + */
 #define L1_BRICKTYPE_DAYTONA    0x7a            /* z */
 
+/* board type response codes */
+#define L1_BOARDTYPE_IP69       0x0100          /* CA */
+#define L1_BOARDTYPE_IP63       0x0200          /* CB */
+#define L1_BOARDTYPE_BASEIO     0x0300          /* IB */
+#define L1_BOARDTYPE_PCIE2SLOT  0x0400          /* IC */
+#define L1_BOARDTYPE_PCIX3SLOT  0x0500          /* ID */
+#define L1_BOARDTYPE_PCIXPCIE4SLOT 0x0600       /* IE */
+#define L1_BOARDTYPE_ABACUS     0x0700          /* AB */
+#define L1_BOARDTYPE_DAYTONA    0x0800          /* AD */
+#define L1_BOARDTYPE_INVAL      (-1)            /* invalid brick type */
+
+
 #endif /* _ASM_IA64_SN_L1_H */
diff --git a/include/asm-ia64/sn/nodepda.h b/include/asm-ia64/sn/nodepda.h
index 47bb8100fd00..6f6d69e39ff5 100644
--- a/include/asm-ia64/sn/nodepda.h
+++ b/include/asm-ia64/sn/nodepda.h
@@ -55,7 +55,6 @@ struct nodepda_s {
          */
         struct phys_cpuid       phys_cpuid[NR_CPUS];
         spinlock_t              ptc_lock ____cacheline_aligned_in_smp;
-        spinlock_t              bist_lock;
 };
 
 typedef struct nodepda_s nodepda_t;
diff --git a/include/asm-ia64/sn/sn_cpuid.h b/include/asm-ia64/sn/sn_cpuid.h
index d2c1d34dcce4..749deb2ca6c1 100644
--- a/include/asm-ia64/sn/sn_cpuid.h
+++ b/include/asm-ia64/sn/sn_cpuid.h
@@ -105,7 +105,6 @@ extern short physical_node_map[];	/* indexed by nasid to get cnode */
 #define cpuid_to_nasid(cpuid)           (sn_nodepda->phys_cpuid[cpuid].nasid)
 #define cpuid_to_subnode(cpuid)         (sn_nodepda->phys_cpuid[cpuid].subnode)
 #define cpuid_to_slice(cpuid)           (sn_nodepda->phys_cpuid[cpuid].slice)
-#define cpuid_to_cnodeid(cpuid)         (physical_node_map[cpuid_to_nasid(cpuid)])
 
 
 /*
@@ -113,8 +112,6 @@ extern short physical_node_map[];	/* indexed by nasid to get cnode */
  * of potentially large tables.
  */
 extern int nasid_slice_to_cpuid(int, int);
-#define nasid_slice_to_cpu_physical_id(nasid, slice)                    \
-        cpu_physical_id(nasid_slice_to_cpuid(nasid, slice))
 
 /*
  * cnodeid_to_nasid - convert a cnodeid to a NASID
diff --git a/include/asm-ia64/sn/sn_sal.h b/include/asm-ia64/sn/sn_sal.h
index fea35b33d4e4..3f7564dc0aa9 100644
--- a/include/asm-ia64/sn/sn_sal.h
+++ b/include/asm-ia64/sn/sn_sal.h
@@ -47,6 +47,7 @@
 #define  SN_SAL_CONSOLE_PUTB                       0x02000028
 #define  SN_SAL_CONSOLE_XMIT_CHARS                 0x0200002a
 #define  SN_SAL_CONSOLE_READC                      0x0200002b
+#define  SN_SAL_SYSCTL_OP                          0x02000030
 #define  SN_SAL_SYSCTL_MODID_GET                   0x02000031
 #define  SN_SAL_SYSCTL_GET                         0x02000032
 #define  SN_SAL_SYSCTL_IOBRICK_MODULE_GET          0x02000033
@@ -67,7 +68,7 @@
 #define  SN_SAL_IOIF_INTERRUPT                     0x0200004a
 #define  SN_SAL_HWPERF_OP                          0x02000050   // lock
 #define  SN_SAL_IOIF_ERROR_INTERRUPT               0x02000051
-
+#define  SN_SAL_IOIF_PCI_SAFE                      0x02000052
 #define  SN_SAL_IOIF_SLOT_ENABLE                   0x02000053
 #define  SN_SAL_IOIF_SLOT_DISABLE                  0x02000054
 #define  SN_SAL_IOIF_GET_HUBDEV_INFO               0x02000055
@@ -101,6 +102,13 @@
 #define SAL_INTR_FREE           2
 
 /*
+ * operations available on the generic SN_SAL_SYSCTL_OP
+ * runtime service
+ */
+#define SAL_SYSCTL_OP_IOBOARD           0x0001  /*  retrieve board type */
+#define SAL_SYSCTL_OP_TIO_JLCK_RST      0x0002  /* issue TIO clock reset */
+
+/*
  * IRouter (i.e. generalized system controller) operations
  */
 #define SAL_IROUTER_OPEN        0       /* open a subchannel */
@@ -198,26 +206,16 @@ ia64_sn_get_master_baseio_nasid(void)
         return ret_stuff.v0;
 }
 
-static inline char *
+static inline void *
 ia64_sn_get_klconfig_addr(nasid_t nasid)
 {
         struct ia64_sal_retval ret_stuff;
-        int cnodeid;
 
-        cnodeid = nasid_to_cnodeid(nasid);
         ret_stuff.status = 0;
         ret_stuff.v0 = 0;
         ret_stuff.v1 = 0;
         ret_stuff.v2 = 0;
         SAL_CALL(ret_stuff, SN_SAL_GET_KLCONFIG_ADDR, (u64)nasid, 0, 0, 0, 0, 0, 0);
-
-        /*
-         * We should panic if a valid cnode nasid does not produce
-         * a klconfig address.
-         */
-        if (ret_stuff.status != 0) {
-                panic("ia64_sn_get_klconfig_addr: Returned error %lx\n", ret_stuff.status);
-        }
         return ret_stuff.v0 ? __va(ret_stuff.v0) : NULL;
 }
 
@@ -694,12 +692,10 @@ sn_change_memprotect(u64 paddr, u64 len, u64 perms, u64 *nasid_array)
         unsigned long irq_flags;
 
         cnodeid = nasid_to_cnodeid(get_node_number(paddr));
-        // spin_lock(&NODEPDA(cnodeid)->bist_lock);
         local_irq_save(irq_flags);
         ia64_sal_oemcall_nolock(&ret_stuff, SN_SAL_MEMPROTECT, paddr, len,
                                 (u64)nasid_array, perms, 0, 0, 0);
         local_irq_restore(irq_flags);
-        // spin_unlock(&NODEPDA(cnodeid)->bist_lock);
         return ret_stuff.status;
 }
 #define SN_MEMPROT_ACCESS_CLASS_0               0x14a080
@@ -873,6 +869,41 @@ ia64_sn_sysctl_event_init(nasid_t nasid)
         return (int) rv.v0;
 }
 
+/*
+ * Ask the system controller on the specified nasid to reset
+ * the CX corelet clock.  Only valid on TIO nodes.
+ */
+static inline int
+ia64_sn_sysctl_tio_clock_reset(nasid_t nasid)
+{
+        struct ia64_sal_retval rv;
+        SAL_CALL_REENTRANT(rv, SN_SAL_SYSCTL_OP, SAL_SYSCTL_OP_TIO_JLCK_RST,
+                        nasid, 0, 0, 0, 0, 0);
+        if (rv.status != 0)
+                return (int)rv.status;
+        if (rv.v0 != 0)
+                return (int)rv.v0;
+
+        return 0;
+}
+
+/*
+ * Get the associated ioboard type for a given nasid.
+ */
+static inline int
+ia64_sn_sysctl_ioboard_get(nasid_t nasid)
+{
+        struct ia64_sal_retval rv;
+        SAL_CALL_REENTRANT(rv, SN_SAL_SYSCTL_OP, SAL_SYSCTL_OP_IOBOARD,
+                        nasid, 0, 0, 0, 0, 0);
+        if (rv.v0 != 0)
+                return (int)rv.v0;
+        if (rv.v1 != 0)
+                return (int)rv.v1;
+
+        return 0;
+}
+
 /**
  * ia64_sn_get_fit_compt - read a FIT entry from the PROM header
  * @nasid: NASID of node to read
diff --git a/include/asm-ia64/sn/tioca_provider.h b/include/asm-ia64/sn/tioca_provider.h
index 5ccec608d325..b532ef6148ed 100644
--- a/include/asm-ia64/sn/tioca_provider.h
+++ b/include/asm-ia64/sn/tioca_provider.h
@@ -182,11 +182,11 @@ tioca_tlbflush(struct tioca_kernel *tioca_kernel)
                          * touch every CL aligned GART entry.
                          */
 
-                        ca_base->ca_control2 &= ~(CA_GART_MEM_PARAM);
-                        ca_base->ca_control2 |= CA_GART_FLUSH_TLB;
-                        ca_base->ca_control2 |=
-                            (0x2ull << CA_GART_MEM_PARAM_SHFT);
-                        tmp = ca_base->ca_control2;
+                        __sn_clrq_relaxed(&ca_base->ca_control2, CA_GART_MEM_PARAM);
+                        __sn_setq_relaxed(&ca_base->ca_control2, CA_GART_FLUSH_TLB);
+                        __sn_setq_relaxed(&ca_base->ca_control2,
+                            (0x2ull << CA_GART_MEM_PARAM_SHFT));
+                        tmp = __sn_readq_relaxed(&ca_base->ca_control2);
                 }
 
                 return;
@@ -196,8 +196,8 @@ tioca_tlbflush(struct tioca_kernel *tioca_kernel)
          * Gart in uncached mode ... need an explicit flush.
          */
 
-        ca_base->ca_control2 |= CA_GART_FLUSH_TLB;
-        tmp = ca_base->ca_control2;
+        __sn_setq_relaxed(&ca_base->ca_control2, CA_GART_FLUSH_TLB);
+        tmp = __sn_readq_relaxed(&ca_base->ca_control2);
 }
 
 extern uint32_t tioca_gart_found;
diff --git a/include/asm-ia64/sn/tiocx.h b/include/asm-ia64/sn/tiocx.h
index c5447a504509..5699e75e5024 100644
--- a/include/asm-ia64/sn/tiocx.h
+++ b/include/asm-ia64/sn/tiocx.h
@@ -19,6 +19,7 @@ struct cx_id_s {
 
 struct cx_dev {
         struct cx_id_s cx_id;
+        int bt;                         /* board/blade type */
         void *soft;                     /* driver specific */
         struct hubdev_info *hubdev;
         struct device dev;
@@ -59,7 +60,7 @@ struct cx_drv {
 extern struct sn_irq_info *tiocx_irq_alloc(nasid_t, int, int, nasid_t, int);
 extern void tiocx_irq_free(struct sn_irq_info *);
 extern int cx_device_unregister(struct cx_dev *);
-extern int cx_device_register(nasid_t, int, int, struct hubdev_info *);
+extern int cx_device_register(nasid_t, int, int, struct hubdev_info *, int);
 extern int cx_driver_unregister(struct cx_drv *);
 extern int cx_driver_register(struct cx_drv *);
 extern uint64_t tiocx_dma_addr(uint64_t addr);
diff --git a/include/asm-ia64/sn/xp.h b/include/asm-ia64/sn/xp.h
index 1df1c9f61a65..49faf8f26430 100644
--- a/include/asm-ia64/sn/xp.h
+++ b/include/asm-ia64/sn/xp.h
@@ -49,7 +49,7 @@
  * C-brick nasids, thus the need for bitmaps which don't account for
  * odd-numbered (non C-brick) nasids.
  */
-#define XP_MAX_PHYSNODE_ID      (MAX_PHYSNODE_ID / 2)
+#define XP_MAX_PHYSNODE_ID      (MAX_NUMALINK_NODES / 2)
 #define XP_NASID_MASK_BYTES     ((XP_MAX_PHYSNODE_ID + 7) / 8)
 #define XP_NASID_MASK_WORDS     ((XP_MAX_PHYSNODE_ID + 63) / 64)
 
@@ -217,7 +217,17 @@ enum xpc_retval {
         xpcInvalidPartid,       /* 42: invalid partition ID */
         xpcLocalPartid,         /* 43: local partition ID */
 
-        xpcUnknownReason        /* 44: unknown reason -- must be last in list */
+        xpcOtherGoingDown,      /* 44: other side going down, reason unknown */
+        xpcSystemGoingDown,     /* 45: system is going down, reason unknown */
+        xpcSystemHalt,          /* 46: system is being halted */
+        xpcSystemReboot,        /* 47: system is being rebooted */
+        xpcSystemPoweroff,      /* 48: system is being powered off */
+
+        xpcDisconnecting,       /* 49: channel disconnecting (closing) */
+
+        xpcOpenCloseError,      /* 50: channel open/close protocol error */
+
+        xpcUnknownReason        /* 51: unknown reason -- must be last in list */
 };
 
 
@@ -342,7 +352,7 @@ typedef void (*xpc_notify_func)(enum xpc_retval reason, partid_t partid,
  *
  * The 'func' field points to the function to call when aynchronous
  * notification is required for such events as: a connection established/lost,
- * or an incomming message received, or an error condition encountered. A
+ * or an incoming message received, or an error condition encountered. A
  * non-NULL 'func' field indicates that there is an active registration for
  * the channel.
  */
diff --git a/include/asm-ia64/sparsemem.h b/include/asm-ia64/sparsemem.h
new file mode 100644
index 000000000000..67a7c40ec27f
--- /dev/null
+++ b/include/asm-ia64/sparsemem.h
@@ -0,0 +1,20 @@
+#ifndef _ASM_IA64_SPARSEMEM_H
+#define _ASM_IA64_SPARSEMEM_H
+
+#ifdef CONFIG_SPARSEMEM
+/*
+ * SECTION_SIZE_BITS            2^N: how big each section will be
+ * MAX_PHYSMEM_BITS             2^N: how much memory we can have in that space
+ */
+
+#define SECTION_SIZE_BITS       (30)
+#define MAX_PHYSMEM_BITS        (50)
+#ifdef CONFIG_FORCE_MAX_ZONEORDER
+#if ((CONFIG_FORCE_MAX_ZONEORDER - 1 + PAGE_SHIFT) > SECTION_SIZE_BITS)
+#undef SECTION_SIZE_BITS
+#define SECTION_SIZE_BITS (CONFIG_FORCE_MAX_ZONEORDER - 1 + PAGE_SHIFT)
+#endif
+#endif
+
+#endif /* CONFIG_SPARSEMEM */
+#endif /* _ASM_IA64_SPARSEMEM_H */
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 7d300f7469e3..467a096c3b81 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -96,6 +96,9 @@
 #define PCI_CLASS_SERIAL_ACCESS         0x0c01
 #define PCI_CLASS_SERIAL_SSA            0x0c02
 #define PCI_CLASS_SERIAL_USB            0x0c03
+#define PCI_CLASS_SERIAL_USB_UHCI       0x0c0300
+#define PCI_CLASS_SERIAL_USB_OHCI       0x0c0310
+#define PCI_CLASS_SERIAL_USB_EHCI       0x0c0320
 #define PCI_CLASS_SERIAL_FIBER          0x0c04
 #define PCI_CLASS_SERIAL_SMBUS          0x0c05
 
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 7897cf500c51..c61d5de837ef 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -224,7 +224,6 @@ struct dev_pm_info {
         unsigned                should_wakeup:1;
         pm_message_t            prev_state;
         void                    * saved_state;
-        atomic_t                pm_users;
         struct device           * pm_parent;
         struct list_head        entry;
 #endif
@@ -244,6 +243,9 @@ extern int device_suspend(pm_message_t state);
 #define device_may_wakeup(dev) \
         (device_can_wakeup(dev) && (dev)->power.should_wakeup)
 
+extern int dpm_runtime_suspend(struct device *, pm_message_t);
+extern void dpm_runtime_resume(struct device *);
+
 #else /* !CONFIG_PM */
 
 static inline int device_suspend(pm_message_t state)
@@ -254,6 +256,16 @@ static inline int device_suspend(pm_message_t state)
 #define device_set_wakeup_enable(dev,val)       do{}while(0)
 #define device_may_wakeup(dev)                  (0)
 
+static inline int dpm_runtime_suspend(struct device * dev, pm_message_t state)
+{
+        return 0;
+}
+
+static inline void dpm_runtime_resume(struct device * dev)
+{
+
+}
+
 #endif
 
 /* changes to device_may_wakeup take effect on the next pm state change.
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 8f731e8f2821..748d04385256 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -57,6 +57,7 @@ struct usb_host_endpoint {
         struct usb_endpoint_descriptor  desc;
         struct list_head                urb_list;
         void                            *hcpriv;
+        struct kobject                  *kobj;  /* For sysfs info */
 
         unsigned char *extra;   /* Extra descriptors */
         int extralen;
@@ -136,7 +137,8 @@ struct usb_interface {
                                          * active alternate setting */
         unsigned num_altsetting;        /* number of alternate settings */
 
-        int minor;                      /* minor number this interface is bound to */
+        int minor;                      /* minor number this interface is
+                                         * bound to */
         enum usb_interface_condition condition;         /* state of binding */
         struct device dev;              /* interface specific device info */
         struct class_device *class_dev;
@@ -229,7 +231,7 @@ struct usb_interface_cache {
 struct usb_host_config {
         struct usb_config_descriptor    desc;
 
-        char *string;
+        char *string;           /* iConfiguration string, if present */
         /* the interfaces associated with this configuration,
          * stored in no particular order */
         struct usb_interface *interface[USB_MAXINTERFACES];
@@ -248,7 +250,7 @@ int __usb_get_extra_descriptor(char *buffer, unsigned size,
         __usb_get_extra_descriptor((ifpoint)->extra,(ifpoint)->extralen,\
                 type,(void**)ptr)
 
-/* -------------------------------------------------------------------------- */
+/* ----------------------------------------------------------------------- */
 
 struct usb_operations;
 
@@ -268,7 +270,8 @@ struct usb_bus {
         unsigned is_b_host:1;           /* true during some HNP roleswitches */
         unsigned b_hnp_enable:1;        /* OTG: did A-Host enable HNP? */
 
-        int devnum_next;                /* Next open device number in round-robin allocation */
+        int devnum_next;                /* Next open device number in
+                                         * round-robin allocation */
 
         struct usb_devmap devmap;       /* device address allocation map */
         struct usb_operations *op;      /* Operations (specific to the HC) */
@@ -289,15 +292,16 @@ struct usb_bus {
         struct dentry *usbfs_dentry;    /* usbfs dentry entry for the bus */
 
         struct class_device *class_dev; /* class device for this bus */
-        struct kref kref;               /* handles reference counting this bus */
-        void (*release)(struct usb_bus *bus);   /* function to destroy this bus's memory */
+        struct kref kref;               /* reference counting for this bus */
+        void (*release)(struct usb_bus *bus);
+
 #if defined(CONFIG_USB_MON)
         struct mon_bus *mon_bus;        /* non-null when associated */
         int monitored;                  /* non-zero when monitored */
 #endif
 };
 
-/* -------------------------------------------------------------------------- */
+/* ----------------------------------------------------------------------- */
 
 /* This is arbitrary.
  * From USB 2.0 spec Table 11-13, offset 7, a hub can
@@ -326,7 +330,8 @@ struct usb_device {
 
         struct semaphore serialize;
 
-        unsigned int toggle[2];         /* one bit for each endpoint ([0] = IN, [1] = OUT) */
+        unsigned int toggle[2];         /* one bit for each endpoint
+                                         * ([0] = IN, [1] = OUT) */
 
         struct usb_device *parent;      /* our hub, unless we're the root */
         struct usb_bus *bus;            /* Bus we're part of */
@@ -343,12 +348,14 @@ struct usb_device {
 
         char **rawdescriptors;          /* Raw descriptors for each config */
 
-        int have_langid;                /* whether string_langid is valid yet */
+        int have_langid;                /* whether string_langid is valid */
         int string_langid;              /* language ID for strings */
 
-        char *product;
-        char *manufacturer;
-        char *serial;                   /* static strings from the device */
+        /* static strings from the device */
+        char *product;                  /* iProduct string, if present */
+        char *manufacturer;             /* iManufacturer string, if present */
+        char *serial;                   /* iSerialNumber string, if present */
+
         struct list_head filelist;
         struct class_device *class_dev;
         struct dentry *usbfs_dentry;    /* usbfs dentry entry for the device */
@@ -440,22 +447,31 @@ extern struct usb_host_interface *usb_altnum_to_altsetting(
  * USB 2.0 root hubs (EHCI host controllers) will get one path ID if they are
  * high speed, and a different one if they are full or low speed.
  */
-static inline int usb_make_path (struct usb_device *dev, char *buf, size_t size)
+static inline int usb_make_path (struct usb_device *dev, char *buf,
+                size_t size)
 {
         int actual;
-        actual = snprintf (buf, size, "usb-%s-%s", dev->bus->bus_name, dev->devpath);
+        actual = snprintf (buf, size, "usb-%s-%s", dev->bus->bus_name,
+                        dev->devpath);
         return (actual >= (int)size) ? -1 : actual;
 }
 
 /*-------------------------------------------------------------------------*/
 
-#define USB_DEVICE_ID_MATCH_DEVICE              (USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT)
-#define USB_DEVICE_ID_MATCH_DEV_RANGE           (USB_DEVICE_ID_MATCH_DEV_LO | USB_DEVICE_ID_MATCH_DEV_HI)
-#define USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION  (USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_RANGE)
+#define USB_DEVICE_ID_MATCH_DEVICE \
+                (USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT)
+#define USB_DEVICE_ID_MATCH_DEV_RANGE \
+                (USB_DEVICE_ID_MATCH_DEV_LO | USB_DEVICE_ID_MATCH_DEV_HI)
+#define USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION \
+                (USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_RANGE)
 #define USB_DEVICE_ID_MATCH_DEV_INFO \
-        (USB_DEVICE_ID_MATCH_DEV_CLASS | USB_DEVICE_ID_MATCH_DEV_SUBCLASS | USB_DEVICE_ID_MATCH_DEV_PROTOCOL)
+                (USB_DEVICE_ID_MATCH_DEV_CLASS | \
+                USB_DEVICE_ID_MATCH_DEV_SUBCLASS | \
+                USB_DEVICE_ID_MATCH_DEV_PROTOCOL)
 #define USB_DEVICE_ID_MATCH_INT_INFO \
-        (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS | USB_DEVICE_ID_MATCH_INT_PROTOCOL)
+                (USB_DEVICE_ID_MATCH_INT_CLASS | \
+                USB_DEVICE_ID_MATCH_INT_SUBCLASS | \
+                USB_DEVICE_ID_MATCH_INT_PROTOCOL)
 
 /**
  * USB_DEVICE - macro used to describe a specific usb device
@@ -466,9 +482,11 @@ static inline int usb_make_path (struct usb_device *dev, char *buf, size_t size)
  * specific device.
  */
 #define USB_DEVICE(vend,prod) \
-        .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = (vend), .idProduct = (prod)
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE, .idVendor = (vend), \
+                        .idProduct = (prod)
 /**
- * USB_DEVICE_VER - macro used to describe a specific usb device with a version range
+ * USB_DEVICE_VER - macro used to describe a specific usb device with a
+ *              version range
  * @vend: the 16 bit USB Vendor ID
  * @prod: the 16 bit USB Product ID
  * @lo: the bcdDevice_lo value
@@ -478,7 +496,9 @@ static inline int usb_make_path (struct usb_device *dev, char *buf, size_t size)
  * specific device, with a version range.
  */
 #define USB_DEVICE_VER(vend,prod,lo,hi) \
-        .match_flags = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION, .idVendor = (vend), .idProduct = (prod), .bcdDevice_lo = (lo), .bcdDevice_hi = (hi)
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION, \
+        .idVendor = (vend), .idProduct = (prod), \
+        .bcdDevice_lo = (lo), .bcdDevice_hi = (hi)
 
 /**
  * USB_DEVICE_INFO - macro used to describe a class of usb devices
@@ -490,7 +510,8 @@ static inline int usb_make_path (struct usb_device *dev, char *buf, size_t size)
  * specific class of devices.
  */
 #define USB_DEVICE_INFO(cl,sc,pr) \
-        .match_flags = USB_DEVICE_ID_MATCH_DEV_INFO, .bDeviceClass = (cl), .bDeviceSubClass = (sc), .bDeviceProtocol = (pr)
+        .match_flags = USB_DEVICE_ID_MATCH_DEV_INFO, .bDeviceClass = (cl), \
+        .bDeviceSubClass = (sc), .bDeviceProtocol = (pr)
 
 /**
  * USB_INTERFACE_INFO - macro used to describe a class of usb interfaces 
@@ -502,9 +523,10 @@ static inline int usb_make_path (struct usb_device *dev, char *buf, size_t size)
  * specific class of interfaces.
  */
 #define USB_INTERFACE_INFO(cl,sc,pr) \
-        .match_flags = USB_DEVICE_ID_MATCH_INT_INFO, .bInterfaceClass = (cl), .bInterfaceSubClass = (sc), .bInterfaceProtocol = (pr)
+        .match_flags = USB_DEVICE_ID_MATCH_INT_INFO, .bInterfaceClass = (cl), \
+        .bInterfaceSubClass = (sc), .bInterfaceProtocol = (pr)
 
-/* -------------------------------------------------------------------------- */
+/* ----------------------------------------------------------------------- */
 
 /**
  * struct usb_driver - identifies USB driver to usbcore
@@ -557,7 +579,8 @@ struct usb_driver {
 
         void (*disconnect) (struct usb_interface *intf);
 
-        int (*ioctl) (struct usb_interface *intf, unsigned int code, void *buf);
+        int (*ioctl) (struct usb_interface *intf, unsigned int code,
+                        void *buf);
 
         int (*suspend) (struct usb_interface *intf, pm_message_t message);
         int (*resume) (struct usb_interface *intf);
@@ -572,10 +595,8 @@ extern struct bus_type usb_bus_type;
 
 /**
  * struct usb_class_driver - identifies a USB driver that wants to use the USB major number
- * @name: devfs name for this driver.  Will also be used by the driver
- *      class code to create a usb class device.
+ * @name: the usb class device name for this driver.  Will show up in sysfs.
  * @fops: pointer to the struct file_operations of this driver.
- * @mode: the mode for the devfs file to be created for this driver.
  * @minor_base: the start of the minor range for this driver.
  *
  * This structure is used for the usb_register_dev() and
@@ -585,8 +606,7 @@ extern struct bus_type usb_bus_type;
 struct usb_class_driver {
         char *name;
         struct file_operations *fops;
-        mode_t mode;
-        int minor_base; 
+        int minor_base;
 };
 
 /*
@@ -603,7 +623,7 @@ extern void usb_deregister_dev(struct usb_interface *intf,
 
 extern int usb_disabled(void);
 
-/* -------------------------------------------------------------------------- */
+/* ----------------------------------------------------------------------- */
 
 /*
  * URB support, for asynchronous request completions
@@ -613,12 +633,14 @@ extern int usb_disabled(void);
  * urb->transfer_flags:
  */
 #define URB_SHORT_NOT_OK        0x0001  /* report short reads as errors */
-#define URB_ISO_ASAP            0x0002  /* iso-only, urb->start_frame ignored */
+#define URB_ISO_ASAP            0x0002  /* iso-only, urb->start_frame
+                                         * ignored */
 #define URB_NO_TRANSFER_DMA_MAP 0x0004  /* urb->transfer_dma valid on submit */
 #define URB_NO_SETUP_DMA_MAP    0x0008  /* urb->setup_dma valid on submit */
 #define URB_NO_FSBR             0x0020  /* UHCI-specific */
-#define URB_ZERO_PACKET         0x0040  /* Finish bulk OUTs with short packet */
-#define URB_NO_INTERRUPT        0x0080  /* HINT: no non-error interrupt needed */
+#define URB_ZERO_PACKET         0x0040  /* Finish bulk OUT with short packet */
+#define URB_NO_INTERRUPT        0x0080  /* HINT: no non-error interrupt
+                                         * needed */
 
 struct usb_iso_packet_descriptor {
         unsigned int offset;
@@ -806,7 +828,8 @@ struct urb
         u8 reject;                      /* submissions will fail */
 
         /* public, documented fields in the urb that can be used by drivers */
-        struct list_head urb_list;      /* list head for use by the urb owner */
+        struct list_head urb_list;      /* list head for use by the urb's
+                                         * current owner */
         struct usb_device *dev;         /* (in) pointer to associated device */
         unsigned int pipe;              /* (in) pipe information */
         int status;                     /* (return) non-ISO status */
@@ -819,14 +842,16 @@ struct urb
         dma_addr_t setup_dma;           /* (in) dma addr for setup_packet */
         int start_frame;                /* (modify) start frame (ISO) */
         int number_of_packets;          /* (in) number of ISO packets */
-        int interval;                   /* (modify) transfer interval (INT/ISO) */
+        int interval;                   /* (modify) transfer interval
+                                         * (INT/ISO) */
         int error_count;                /* (return) number of ISO errors */
         void *context;                  /* (in) context for completion */
         usb_complete_t complete;        /* (in) completion routine */
-        struct usb_iso_packet_descriptor iso_frame_desc[0];     /* (in) ISO ONLY */
+        struct usb_iso_packet_descriptor iso_frame_desc[0];
+                                        /* (in) ISO ONLY */
 };
 
-/* -------------------------------------------------------------------------- */
+/* ----------------------------------------------------------------------- */
 
 /**
  * usb_fill_control_urb - initializes a control urb
@@ -974,11 +999,6 @@ extern int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe,
         void *data, int len, int *actual_length,
         int timeout);
 
-/* selective suspend/resume */
-extern int usb_suspend_device(struct usb_device *dev, pm_message_t message);
-extern int usb_resume_device(struct usb_device *dev);
-
-
 /* wrappers around usb_control_msg() for the most common standard requests */
 extern int usb_get_descriptor(struct usb_device *dev, unsigned char desctype,
         unsigned char descindex, void *buf, int size);
@@ -1056,7 +1076,7 @@ void usb_sg_cancel (struct usb_sg_request *io);
 void usb_sg_wait (struct usb_sg_request *io);
 
 
-/* -------------------------------------------------------------------------- */
+/* ----------------------------------------------------------------------- */
 
 /*
  * For various legacy reasons, Linux has a small cookie that's paired with
@@ -1097,23 +1117,34 @@ void usb_sg_wait (struct usb_sg_request *io);
 /* The D0/D1 toggle bits ... USE WITH CAUTION (they're almost hcd-internal) */
 #define usb_gettoggle(dev, ep, out) (((dev)->toggle[out] >> (ep)) & 1)
 #define usb_dotoggle(dev, ep, out)  ((dev)->toggle[out] ^= (1 << (ep)))
-#define usb_settoggle(dev, ep, out, bit) ((dev)->toggle[out] = ((dev)->toggle[out] & ~(1 << (ep))) | ((bit) << (ep)))
+#define usb_settoggle(dev, ep, out, bit) \
+                ((dev)->toggle[out] = ((dev)->toggle[out] & ~(1 << (ep))) | \
+                 ((bit) << (ep)))
 
 
-static inline unsigned int __create_pipe(struct usb_device *dev, unsigned int endpoint)
+static inline unsigned int __create_pipe(struct usb_device *dev,
+                unsigned int endpoint)
 {
         return (dev->devnum << 8) | (endpoint << 15);
 }
 
 /* Create various pipes... */
-#define usb_sndctrlpipe(dev,endpoint)   ((PIPE_CONTROL << 30) | __create_pipe(dev,endpoint))
-#define usb_rcvctrlpipe(dev,endpoint)   ((PIPE_CONTROL << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
-#define usb_sndisocpipe(dev,endpoint)   ((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev,endpoint))
-#define usb_rcvisocpipe(dev,endpoint)   ((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
-#define usb_sndbulkpipe(dev,endpoint)   ((PIPE_BULK << 30) | __create_pipe(dev,endpoint))
-#define usb_rcvbulkpipe(dev,endpoint)   ((PIPE_BULK << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
-#define usb_sndintpipe(dev,endpoint)    ((PIPE_INTERRUPT << 30) | __create_pipe(dev,endpoint))
-#define usb_rcvintpipe(dev,endpoint)    ((PIPE_INTERRUPT << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
+#define usb_sndctrlpipe(dev,endpoint)   \
+        ((PIPE_CONTROL << 30) | __create_pipe(dev,endpoint))
+#define usb_rcvctrlpipe(dev,endpoint)   \
+        ((PIPE_CONTROL << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
+#define usb_sndisocpipe(dev,endpoint)   \
+        ((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev,endpoint))
+#define usb_rcvisocpipe(dev,endpoint)   \
+        ((PIPE_ISOCHRONOUS << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
+#define usb_sndbulkpipe(dev,endpoint)   \
+        ((PIPE_BULK << 30) | __create_pipe(dev,endpoint))
+#define usb_rcvbulkpipe(dev,endpoint)   \
+        ((PIPE_BULK << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
+#define usb_sndintpipe(dev,endpoint)    \
+        ((PIPE_INTERRUPT << 30) | __create_pipe(dev,endpoint))
+#define usb_rcvintpipe(dev,endpoint)    \
+        ((PIPE_INTERRUPT << 30) | __create_pipe(dev,endpoint) | USB_DIR_IN)
 
 /*-------------------------------------------------------------------------*/
 
@@ -1137,17 +1168,29 @@ usb_maxpacket(struct usb_device *udev, int pipe, int is_out)
         return le16_to_cpu(ep->desc.wMaxPacketSize);
 }
 
-/* -------------------------------------------------------------------------- */
+/* ----------------------------------------------------------------------- */
+
+/* Events from the usb core */
+#define USB_DEVICE_ADD          0x0001
+#define USB_DEVICE_REMOVE       0x0002
+#define USB_BUS_ADD             0x0003
+#define USB_BUS_REMOVE          0x0004
+extern void usb_register_notify(struct notifier_block *nb);
+extern void usb_unregister_notify(struct notifier_block *nb);
 
 #ifdef DEBUG
-#define dbg(format, arg...) printk(KERN_DEBUG "%s: " format "\n" , __FILE__ , ## arg)
+#define dbg(format, arg...) printk(KERN_DEBUG "%s: " format "\n" , \
+        __FILE__ , ## arg)
 #else
 #define dbg(format, arg...) do {} while (0)
 #endif
 
-#define err(format, arg...) printk(KERN_ERR "%s: " format "\n" , __FILE__ , ## arg)
-#define info(format, arg...) printk(KERN_INFO "%s: " format "\n" , __FILE__ , ## arg)
-#define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n" , __FILE__ , ## arg)
+#define err(format, arg...) printk(KERN_ERR "%s: " format "\n" , \
+        __FILE__ , ## arg)
+#define info(format, arg...) printk(KERN_INFO "%s: " format "\n" , \
+        __FILE__ , ## arg)
+#define warn(format, arg...) printk(KERN_WARNING "%s: " format "\n" , \
+        __FILE__ , ## arg)
 
 
 #endif  /* __KERNEL__ */
diff --git a/include/linux/usb_otg.h b/include/linux/usb_otg.h
index c6683146e9b0..f827f6e203c2 100644
--- a/include/linux/usb_otg.h
+++ b/include/linux/usb_otg.h
@@ -63,6 +63,10 @@ struct otg_transceiver {
         int     (*set_power)(struct otg_transceiver *otg,
                                 unsigned mA);
 
+        /* for non-OTG B devices: set transceiver into suspend mode */
+        int     (*set_suspend)(struct otg_transceiver *otg,
+                                int suspend);
+
         /* for B devices only:  start session with A-Host */
         int     (*start_srp)(struct otg_transceiver *otg);
 
@@ -108,6 +112,15 @@ otg_set_power(struct otg_transceiver *otg, unsigned mA)
 }
 
 static inline int
+otg_set_suspend(struct otg_transceiver *otg, int suspend)
+{
+        if (otg->set_suspend != NULL)
+                return otg->set_suspend(otg, suspend);
+        else
+                return 0;
+}
+
+static inline int
 otg_start_srp(struct otg_transceiver *otg)
 {
         return otg->start_srp(otg);
diff --git a/include/linux/usbdevice_fs.h b/include/linux/usbdevice_fs.h
index 9facf733800c..8859f0b41543 100644
--- a/include/linux/usbdevice_fs.h
+++ b/include/linux/usbdevice_fs.h
@@ -140,6 +140,12 @@ struct usbdevfs_urb32 {
         compat_caddr_t usercontext; /* unused */
         struct usbdevfs_iso_packet_desc iso_frame_desc[0];
 };
+
+struct usbdevfs_ioctl32 {
+        s32 ifno;
+        s32 ioctl_code;
+        compat_caddr_t data;
+};
 #endif
 
 #define USBDEVFS_CONTROL           _IOWR('U', 0, struct usbdevfs_ctrltransfer)
@@ -160,6 +166,7 @@ struct usbdevfs_urb32 {
 #define USBDEVFS_RELEASEINTERFACE  _IOR('U', 16, unsigned int)
 #define USBDEVFS_CONNECTINFO       _IOW('U', 17, struct usbdevfs_connectinfo)
 #define USBDEVFS_IOCTL             _IOWR('U', 18, struct usbdevfs_ioctl)
+#define USBDEVFS_IOCTL32           _IOWR('U', 18, struct usbdevfs_ioctl32)
 #define USBDEVFS_HUB_PORTINFO      _IOR('U', 19, struct usbdevfs_hub_portinfo)
 #define USBDEVFS_RESET             _IO('U', 20)
 #define USBDEVFS_CLEAR_HALT        _IOR('U', 21, unsigned int)