170 files changed, 3694 insertions, 8628 deletions

diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index b2361667839f..a13d69b2217d 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -422,7 +422,8 @@ and is between 256 and 4096 characters. It is defined in the file
         hpet=           [X86-32,HPET] option to control HPET usage
                         Format: { enable (default) | disable | force }
                         disable: disable HPET and use PIT instead
-                        force: allow force enabled of undocumented chips (ICH4, VIA)
+                        force: allow force enabled of undocumented chips (ICH4,
+                        VIA, nVidia)
 
         com20020=       [HW,NET] ARCnet - COM20020 chipset
                         Format:
diff --git a/Documentation/scsi/sym53c8xx_2.txt b/Documentation/scsi/sym53c8xx_2.txt
index 3d9f06bb3d00..49ea5c58c6bc 100644
--- a/Documentation/scsi/sym53c8xx_2.txt
+++ b/Documentation/scsi/sym53c8xx_2.txt
@@ -449,25 +449,14 @@ options as above.
         cmd_per_lun=#tags (#tags > 1) tagged command queuing enabled
   #tags will be truncated to the max queued commands configuration parameter.
 
-10.2.2  Detailed control of tagged commands
-  This option allows you to specify a command queue depth for each device 
-  that supports tagged command queueing.
-  Example:
-      tag_ctrl=10/t2t3q16-t5q24/t1u2q32
-  will set devices queue depth as follow:
-      - controller #0 target #2 and target #3                  -> 16 commands,
-      - controller #0 target #5                                -> 24 commands,
-      - controller #1 target #1 logical unit #2                -> 32 commands,
-      - all other logical units (all targets, all controllers) -> 10 commands.
-
-10.2.3 Burst max
+10.2.2 Burst max
         burst=0    burst disabled
         burst=255  get burst length from initial IO register settings.
         burst=#x   burst enabled (1<<#x burst transfers max)
   #x is an integer value which is log base 2 of the burst transfers max.
   By default the driver uses the maximum value supported by the chip.
 
-10.2.4 LED support
+10.2.3 LED support
         led=1      enable  LED support
         led=0      disable LED support
   Do not enable LED support if your scsi board does not use SDMS BIOS.
@@ -560,9 +549,9 @@ Previously, the sym2 driver accepted arguments of the form
         sym53c8xx=tags:4,sync:10,debug:0x200
 
 As a result of the new module parameters, this is no longer available.
-Most of the options have remained the same, but tags has split into
-cmd_per_lun and tag_ctrl for its two different purposes.  The sample above
-would be specified as:
+Most of the options have remained the same, but tags has become
+cmd_per_lun to reflect its different purposes.  The sample above would
+be specified as:
         modprobe sym53c8xx cmd_per_lun=4 sync=10 debug=0x200
 
 or on the kernel boot line as:
diff --git a/Documentation/watchdog/src/watchdog-simple.c b/Documentation/watchdog/src/watchdog-simple.c
index 47801bc7e742..4cf72f3fa8e9 100644
--- a/Documentation/watchdog/src/watchdog-simple.c
+++ b/Documentation/watchdog/src/watchdog-simple.c
@@ -3,15 +3,25 @@
 #include <unistd.h>
 #include <fcntl.h>
 
-int main(int argc, const char *argv[]) {
+int main(void)
+{
         int fd = open("/dev/watchdog", O_WRONLY);
+        int ret = 0;
         if (fd == -1) {
                 perror("watchdog");
-                exit(1);
+                exit(EXIT_FAILURE);
         }
         while (1) {
-                write(fd, "\0", 1);
-                fsync(fd);
+                ret = write(fd, "\0", 1);
+                if (ret != 1) {
+                        ret = -1;
+                        break;
+                }
+                ret = fsync(fd);
+                if (ret)
+                        break;
                 sleep(10);
         }
+        close(fd);
+        return ret;
 }
diff --git a/MAINTAINERS b/MAINTAINERS
index 9d0ae8d2915f..76b857157866 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -314,6 +314,12 @@ M:	Juergen Fischer <fischer@norbit.de>
 L:      linux-scsi@vger.kernel.org
 S:      Maintained
 
+AIC7XXX / AIC79XX SCSI DRIVER
+P:      Hannes Reinecke
+M:      hare@suse.de
+L:      linux-scsi@vger.kernel.org
+S:      Maintained
+
 ALCATEL SPEEDTOUCH USB DRIVER
 P:      Duncan Sands
 M:      duncan.sands@free.fr
diff --git a/arch/arm/mach-pxa/pxa300.c b/arch/arm/mach-pxa/pxa300.c
index 5363b1322652..7a34231f3172 100644
--- a/arch/arm/mach-pxa/pxa300.c
+++ b/arch/arm/mach-pxa/pxa300.c
@@ -23,8 +23,10 @@ static struct pxa3xx_mfp_addr_map pxa300_mfp_addr_map[] __initdata = {
 
         MFP_ADDR_X(GPIO0,   GPIO2,   0x00b4),
         MFP_ADDR_X(GPIO3,   GPIO26,  0x027c),
-        MFP_ADDR_X(GPIO27,  GPIO127, 0x0400),
-        MFP_ADDR_X(GPIO0_2, GPIO6_2, 0x02ec),
+        MFP_ADDR_X(GPIO27,  GPIO98,  0x0400),
+        MFP_ADDR_X(GPIO99,  GPIO127, 0x0600),
+        MFP_ADDR_X(GPIO0_2, GPIO1_2, 0x0674),
+        MFP_ADDR_X(GPIO2_2, GPIO6_2, 0x02dc),
 
         MFP_ADDR(nBE0, 0x0204),
         MFP_ADDR(nBE1, 0x0208),
diff --git a/arch/arm/vfp/vfpdouble.c b/arch/arm/vfp/vfpdouble.c
index 74e89f8fb3ab..190a09ad18eb 100644
--- a/arch/arm/vfp/vfpdouble.c
+++ b/arch/arm/vfp/vfpdouble.c
@@ -1132,7 +1132,7 @@ u32 vfp_double_cpdo(u32 inst, u32 fpscr)
         unsigned int vecitr, veclen, vecstride;
         struct op *fop;
 
-        vecstride = (1 + ((fpscr & FPSCR_STRIDE_MASK) == FPSCR_STRIDE_MASK)) * 2;
+        vecstride = (1 + ((fpscr & FPSCR_STRIDE_MASK) == FPSCR_STRIDE_MASK));
 
         fop = (op == FOP_EXT) ? &fops_ext[FEXT_TO_IDX(inst)] : &fops[FOP_TO_IDX(op)];
 
@@ -1184,10 +1184,10 @@ u32 vfp_double_cpdo(u32 inst, u32 fpscr)
                  * CHECK: It appears to be undefined whether we stop when
                  * we encounter an exception.  We continue.
                  */
-                dest = FREG_BANK(dest) + ((FREG_IDX(dest) + vecstride) & 6);
-                dn = FREG_BANK(dn) + ((FREG_IDX(dn) + vecstride) & 6);
+                dest = FREG_BANK(dest) + ((FREG_IDX(dest) + vecstride) & 3);
+                dn = FREG_BANK(dn) + ((FREG_IDX(dn) + vecstride) & 3);
                 if (FREG_BANK(dm) != 0)
-                        dm = FREG_BANK(dm) + ((FREG_IDX(dm) + vecstride) & 6);
+                        dm = FREG_BANK(dm) + ((FREG_IDX(dm) + vecstride) & 3);
         }
         return exceptions;
 
diff --git a/arch/arm/vfp/vfpmodule.c b/arch/arm/vfp/vfpmodule.c
index eea3f50743d5..b4e210df92f2 100644
--- a/arch/arm/vfp/vfpmodule.c
+++ b/arch/arm/vfp/vfpmodule.c
@@ -229,7 +229,7 @@ void VFP9_bounce(u32 trigger, u32 fpexc, struct pt_regs *regs)
         /*
          * Enable access to the VFP so we can handle the bounce.
          */
-        fmxr(FPEXC, fpexc & ~(FPEXC_EX|FPEXC_INV|FPEXC_UFC|FPEXC_IOC));
+        fmxr(FPEXC, fpexc & ~(FPEXC_EX|FPEXC_FPV2|FPEXC_INV|FPEXC_UFC|FPEXC_OFC|FPEXC_IOC));
 
         orig_fpscr = fpscr = fmrx(FPSCR);
 
diff --git a/arch/i386/Kconfig b/arch/i386/Kconfig
index 5bed8be34ba5..b4437ce0f973 100644
--- a/arch/i386/Kconfig
+++ b/arch/i386/Kconfig
@@ -1270,6 +1270,8 @@ source "drivers/Kconfig"
 
 source "fs/Kconfig"
 
+source "kernel/Kconfig.instrumentation"
+
 source "arch/i386/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/i386/Makefile b/arch/i386/Makefile
index b81cb64d48e5..f5b9a37def8b 100644
--- a/arch/i386/Makefile
+++ b/arch/i386/Makefile
@@ -20,6 +20,12 @@
 # Fill in SRCARCH
 SRCARCH := x86
 
+# BITS is used as extension for files which are available in a 32 bit
+# and a 64 bit version to simplify shared Makefiles.
+# e.g.: obj-y += foo_$(BITS).o
+BITS := 32
+export BITS
+
 HAS_BIARCH      := $(call cc-option-yn, -m32)
 ifeq ($(HAS_BIARCH),y)
 AS              := $(AS) --32
diff --git a/arch/sparc64/Kconfig b/arch/sparc64/Kconfig
index 03c4e5c1b94a..bd59ab0760b3 100644
--- a/arch/sparc64/Kconfig
+++ b/arch/sparc64/Kconfig
@@ -460,8 +460,6 @@ source "drivers/Kconfig"
 
 source "drivers/sbus/char/Kconfig"
 
-source "drivers/fc4/Kconfig"
-
 source "fs/Kconfig"
 
 source "kernel/Kconfig.instrumentation"
diff --git a/arch/x86/boot/boot.h b/arch/x86/boot/boot.h
index 20bab9431acb..5f9a2e72a731 100644
--- a/arch/x86/boot/boot.h
+++ b/arch/x86/boot/boot.h
@@ -23,7 +23,7 @@
 #include <linux/types.h>
 #include <linux/edd.h>
 #include <asm/boot.h>
-#include <asm/bootparam.h>
+#include <asm/setup.h>
 
 /* Useful macros */
 #define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
diff --git a/arch/x86/boot/compressed/relocs.c b/arch/x86/boot/compressed/relocs.c
index 2d77ee728f92..7a0d00b2cf28 100644
--- a/arch/x86/boot/compressed/relocs.c
+++ b/arch/x86/boot/compressed/relocs.c
@@ -38,11 +38,9 @@ static const char* safe_abs_relocs[] = {
 
 static int is_safe_abs_reloc(const char* sym_name)
 {
-        int i, array_size;
-
-        array_size = sizeof(safe_abs_relocs)/sizeof(char*);
+        int i;
 
-        for(i = 0; i < array_size; i++) {
+        for(i = 0; i < ARRAY_SIZE(safe_abs_relocs); i++) {
                 if (!strcmp(sym_name, safe_abs_relocs[i]))
                         /* Match found */
                         return 1;
diff --git a/arch/x86/boot/main.c b/arch/x86/boot/main.c
index 0eeef3989a17..1f95750ede28 100644
--- a/arch/x86/boot/main.c
+++ b/arch/x86/boot/main.c
@@ -26,8 +26,6 @@ char *heap_end = _end;		/* Default end of heap = no heap */
  * screws up the old-style command line protocol, adjust by
  * filling in the new-style command line pointer instead.
  */
-#define OLD_CL_MAGIC    0xA33F
-#define OLD_CL_ADDRESS  0x20
 
 static void copy_boot_params(void)
 {
diff --git a/arch/x86/crypto/Makefile b/arch/x86/crypto/Makefile
index 18dcdc6fb7aa..46bb609e2444 100644
--- a/arch/x86/crypto/Makefile
+++ b/arch/x86/crypto/Makefile
@@ -1,5 +1,15 @@
-ifeq ($(CONFIG_X86_32),y)
-include ${srctree}/arch/x86/crypto/Makefile_32
-else
-include ${srctree}/arch/x86/crypto/Makefile_64
-endif
+#
+# Arch-specific CryptoAPI modules.
+#
+
+obj-$(CONFIG_CRYPTO_AES_586) += aes-i586.o
+obj-$(CONFIG_CRYPTO_TWOFISH_586) += twofish-i586.o
+
+obj-$(CONFIG_CRYPTO_AES_X86_64) += aes-x86_64.o
+obj-$(CONFIG_CRYPTO_TWOFISH_X86_64) += twofish-x86_64.o
+
+aes-i586-y := aes-i586-asm_32.o aes_32.o
+twofish-i586-y := twofish-i586-asm_32.o twofish_32.o
+
+aes-x86_64-y := aes-x86_64-asm_64.o aes_64.o
+twofish-x86_64-y := twofish-x86_64-asm_64.o twofish_64.o
diff --git a/arch/x86/crypto/Makefile_32 b/arch/x86/crypto/Makefile_32
deleted file mode 100644
index 2d873a2388ed..000000000000
--- a/arch/x86/crypto/Makefile_32
+++ /dev/null
@@ -1,12 +0,0 @@
-# 
-# x86/crypto/Makefile 
-# 
-# Arch-specific CryptoAPI modules.
-# 
-
-obj-$(CONFIG_CRYPTO_AES_586) += aes-i586.o
-obj-$(CONFIG_CRYPTO_TWOFISH_586) += twofish-i586.o
-
-aes-i586-y := aes-i586-asm_32.o aes_32.o
-twofish-i586-y := twofish-i586-asm_32.o twofish_32.o
-
diff --git a/arch/x86/crypto/Makefile_64 b/arch/x86/crypto/Makefile_64
deleted file mode 100644
index b40896276e93..000000000000
--- a/arch/x86/crypto/Makefile_64
+++ /dev/null
@@ -1,12 +0,0 @@
-# 
-# x86/crypto/Makefile 
-# 
-# Arch-specific CryptoAPI modules.
-# 
-
-obj-$(CONFIG_CRYPTO_AES_X86_64) += aes-x86_64.o
-obj-$(CONFIG_CRYPTO_TWOFISH_X86_64) += twofish-x86_64.o
-
-aes-x86_64-y := aes-x86_64-asm_64.o aes_64.o
-twofish-x86_64-y := twofish-x86_64-asm_64.o twofish_64.o
-
diff --git a/arch/x86/kernel/Makefile_32 b/arch/x86/kernel/Makefile_32
index ccea590bbb92..b9d679820306 100644
--- a/arch/x86/kernel/Makefile_32
+++ b/arch/x86/kernel/Makefile_32
@@ -26,7 +26,7 @@ obj-$(CONFIG_X86_MPPARSE)	+= mpparse_32.o
 obj-$(CONFIG_X86_LOCAL_APIC)    += apic_32.o nmi_32.o
 obj-$(CONFIG_X86_IO_APIC)       += io_apic_32.o
 obj-$(CONFIG_X86_REBOOTFIXUPS)  += reboot_fixups_32.o
-obj-$(CONFIG_KEXEC)             += machine_kexec_32.o relocate_kernel_32.o crash_32.o
+obj-$(CONFIG_KEXEC)             += machine_kexec_32.o relocate_kernel_32.o crash.o
 obj-$(CONFIG_CRASH_DUMP)        += crash_dump_32.o
 obj-$(CONFIG_X86_NUMAQ)         += numaq_32.o
 obj-$(CONFIG_X86_SUMMIT_NUMA)   += summit_32.o
diff --git a/arch/x86/kernel/Makefile_64 b/arch/x86/kernel/Makefile_64
index dec06e769281..466337ae9a1e 100644
--- a/arch/x86/kernel/Makefile_64
+++ b/arch/x86/kernel/Makefile_64
@@ -9,25 +9,21 @@ obj-y	:= process_64.o signal_64.o entry_64.o traps_64.o irq_64.o \
                 x8664_ksyms_64.o i387_64.o syscall_64.o vsyscall_64.o \
                 setup64.o bootflag.o e820_64.o reboot_64.o quirks.o i8237.o \
                 pci-dma_64.o pci-nommu_64.o alternative.o hpet.o tsc_64.o bugs_64.o \
-                perfctr-watchdog.o i8253.o
+                i8253.o
 
 obj-$(CONFIG_STACKTRACE)        += stacktrace.o
-obj-$(CONFIG_X86_MCE)           += mce_64.o therm_throt.o
-obj-$(CONFIG_X86_MCE_INTEL)     += mce_intel_64.o
-obj-$(CONFIG_X86_MCE_AMD)       += mce_amd_64.o
-obj-$(CONFIG_MTRR)              += cpu/mtrr/
-obj-$(CONFIG_ACPI)              += acpi/
+obj-y                           += cpu/
+obj-y                           += acpi/
 obj-$(CONFIG_X86_MSR)           += msr.o
 obj-$(CONFIG_MICROCODE)         += microcode.o
 obj-$(CONFIG_X86_CPUID)         += cpuid.o
 obj-$(CONFIG_SMP)               += smp_64.o smpboot_64.o trampoline_64.o tsc_sync.o
 obj-y                           += apic_64.o  nmi_64.o
 obj-y                           += io_apic_64.o mpparse_64.o genapic_64.o genapic_flat_64.o
-obj-$(CONFIG_KEXEC)             += machine_kexec_64.o relocate_kernel_64.o crash_64.o
+obj-$(CONFIG_KEXEC)             += machine_kexec_64.o relocate_kernel_64.o crash.o
 obj-$(CONFIG_CRASH_DUMP)        += crash_dump_64.o
 obj-$(CONFIG_PM)                += suspend_64.o
 obj-$(CONFIG_HIBERNATION)       += suspend_asm_64.o
-obj-$(CONFIG_CPU_FREQ)          += cpu/cpufreq/
 obj-$(CONFIG_EARLY_PRINTK)      += early_printk.o
 obj-$(CONFIG_IOMMU)             += pci-gart_64.o aperture_64.o
 obj-$(CONFIG_CALGARY_IOMMU)     += pci-calgary_64.o tce_64.o
@@ -42,13 +38,6 @@ obj-$(CONFIG_MODULES)		+= module_64.o
 obj-$(CONFIG_PCI)               += early-quirks.o
 
 obj-y                           += topology.o
-obj-y                           += intel_cacheinfo.o
-obj-y                           += addon_cpuid_features.o
 obj-y                           += pcspeaker.o
 
 CFLAGS_vsyscall_64.o            := $(PROFILING) -g0
-
-therm_throt-y                   += cpu/mcheck/therm_throt.o
-intel_cacheinfo-y               += cpu/intel_cacheinfo.o
-addon_cpuid_features-y          += cpu/addon_cpuid_features.o
-perfctr-watchdog-y              += cpu/perfctr-watchdog.o
diff --git a/arch/x86/kernel/acpi/Makefile b/arch/x86/kernel/acpi/Makefile
index 3d5671939542..1351c3982ee4 100644
--- a/arch/x86/kernel/acpi/Makefile
+++ b/arch/x86/kernel/acpi/Makefile
@@ -1,5 +1,7 @@
-ifeq ($(CONFIG_X86_32),y)
-include ${srctree}/arch/x86/kernel/acpi/Makefile_32
-else
-include ${srctree}/arch/x86/kernel/acpi/Makefile_64
+obj-$(CONFIG_ACPI)              += boot.o
+obj-$(CONFIG_ACPI_SLEEP)        += sleep_$(BITS).o wakeup_$(BITS).o
+
+ifneq ($(CONFIG_ACPI_PROCESSOR),)
+obj-y                           += cstate.o processor.o
 endif
+
diff --git a/arch/x86/kernel/acpi/Makefile_32 b/arch/x86/kernel/acpi/Makefile_32
deleted file mode 100644
index 045dd54b33e0..000000000000
--- a/arch/x86/kernel/acpi/Makefile_32
+++ /dev/null
@@ -1,7 +0,0 @@
-obj-$(CONFIG_ACPI)              += boot.o
-obj-$(CONFIG_ACPI_SLEEP)        += sleep_32.o wakeup_32.o
-
-ifneq ($(CONFIG_ACPI_PROCESSOR),)
-obj-y                           += cstate.o processor.o
-endif
-
diff --git a/arch/x86/kernel/acpi/Makefile_64 b/arch/x86/kernel/acpi/Makefile_64
deleted file mode 100644
index 629425bc002d..000000000000
--- a/arch/x86/kernel/acpi/Makefile_64
+++ /dev/null
@@ -1,7 +0,0 @@
-obj-y                   := boot.o
-obj-$(CONFIG_ACPI_SLEEP)        += sleep_64.o wakeup_64.o
-
-ifneq ($(CONFIG_ACPI_PROCESSOR),)
-obj-y                   += processor.o cstate.o
-endif
-
diff --git a/arch/x86/kernel/acpi/wakeup_64.S b/arch/x86/kernel/acpi/wakeup_64.S
index 55608ec2ed72..5ed3bc5c61d7 100644
--- a/arch/x86/kernel/acpi/wakeup_64.S
+++ b/arch/x86/kernel/acpi/wakeup_64.S
@@ -4,6 +4,7 @@
 #include <asm/pgtable.h>
 #include <asm/page.h>
 #include <asm/msr.h>
+#include <asm/asm-offsets.h>
 
 # Copyright 2003 Pavel Machek <pavel@suse.cz>, distribute under GPLv2
 #
@@ -342,31 +343,32 @@ do_suspend_lowlevel:
         xorl    %eax, %eax
         call    save_processor_state
 
-        movq %rsp, saved_context_esp(%rip)
-        movq %rax, saved_context_eax(%rip)
-        movq %rbx, saved_context_ebx(%rip)
-        movq %rcx, saved_context_ecx(%rip)
-        movq %rdx, saved_context_edx(%rip)
-        movq %rbp, saved_context_ebp(%rip)
-        movq %rsi, saved_context_esi(%rip)
-        movq %rdi, saved_context_edi(%rip)
-        movq %r8,  saved_context_r08(%rip)
-        movq %r9,  saved_context_r09(%rip)
-        movq %r10, saved_context_r10(%rip)
-        movq %r11, saved_context_r11(%rip)
-        movq %r12, saved_context_r12(%rip)
-        movq %r13, saved_context_r13(%rip)
-        movq %r14, saved_context_r14(%rip)
-        movq %r15, saved_context_r15(%rip)
-        pushfq ; popq saved_context_eflags(%rip)
+        movq    $saved_context, %rax
+        movq    %rsp, pt_regs_rsp(%rax)
+        movq    %rbp, pt_regs_rbp(%rax)
+        movq    %rsi, pt_regs_rsi(%rax)
+        movq    %rdi, pt_regs_rdi(%rax)
+        movq    %rbx, pt_regs_rbx(%rax)
+        movq    %rcx, pt_regs_rcx(%rax)
+        movq    %rdx, pt_regs_rdx(%rax)
+        movq    %r8, pt_regs_r8(%rax)
+        movq    %r9, pt_regs_r9(%rax)
+        movq    %r10, pt_regs_r10(%rax)
+        movq    %r11, pt_regs_r11(%rax)
+        movq    %r12, pt_regs_r12(%rax)
+        movq    %r13, pt_regs_r13(%rax)
+        movq    %r14, pt_regs_r14(%rax)
+        movq    %r15, pt_regs_r15(%rax)
+        pushfq
+        popq    pt_regs_eflags(%rax)
 
         movq    $.L97, saved_rip(%rip)
 
-        movq %rsp,saved_rsp
-        movq %rbp,saved_rbp
-        movq %rbx,saved_rbx
-        movq %rdi,saved_rdi
-        movq %rsi,saved_rsi
+        movq    %rsp, saved_rsp
+        movq    %rbp, saved_rbp
+        movq    %rbx, saved_rbx
+        movq    %rdi, saved_rdi
+        movq    %rsi, saved_rsi
 
         addq    $8, %rsp
         movl    $3, %edi
@@ -377,32 +379,35 @@ do_suspend_lowlevel:
 .L99:
         .align 4
         movl    $24, %eax
-        movw %ax, %ds
-        movq    saved_context+58(%rip), %rax
-        movq %rax, %cr4
-        movq    saved_context+50(%rip), %rax
-        movq %rax, %cr3
-        movq    saved_context+42(%rip), %rax
-        movq %rax, %cr2
-        movq    saved_context+34(%rip), %rax
-        movq %rax, %cr0
-        pushq saved_context_eflags(%rip) ; popfq
-        movq saved_context_esp(%rip), %rsp
-        movq saved_context_ebp(%rip), %rbp
-        movq saved_context_eax(%rip), %rax
-        movq saved_context_ebx(%rip), %rbx
-        movq saved_context_ecx(%rip), %rcx
-        movq saved_context_edx(%rip), %rdx
-        movq saved_context_esi(%rip), %rsi
-        movq saved_context_edi(%rip), %rdi
-        movq saved_context_r08(%rip), %r8
-        movq saved_context_r09(%rip), %r9
-        movq saved_context_r10(%rip), %r10
-        movq saved_context_r11(%rip), %r11
-        movq saved_context_r12(%rip), %r12
-        movq saved_context_r13(%rip), %r13
-        movq saved_context_r14(%rip), %r14
-        movq saved_context_r15(%rip), %r15
+        movw    %ax, %ds
+
+        /* We don't restore %rax, it must be 0 anyway */
+        movq    $saved_context, %rax
+        movq    saved_context_cr4(%rax), %rbx
+        movq    %rbx, %cr4
+        movq    saved_context_cr3(%rax), %rbx
+        movq    %rbx, %cr3
+        movq    saved_context_cr2(%rax), %rbx
+        movq    %rbx, %cr2
+        movq    saved_context_cr0(%rax), %rbx
+        movq    %rbx, %cr0
+        pushq   pt_regs_eflags(%rax)
+        popfq
+        movq    pt_regs_rsp(%rax), %rsp
+        movq    pt_regs_rbp(%rax), %rbp
+        movq    pt_regs_rsi(%rax), %rsi
+        movq    pt_regs_rdi(%rax), %rdi
+        movq    pt_regs_rbx(%rax), %rbx
+        movq    pt_regs_rcx(%rax), %rcx
+        movq    pt_regs_rdx(%rax), %rdx
+        movq    pt_regs_r8(%rax), %r8
+        movq    pt_regs_r9(%rax), %r9
+        movq    pt_regs_r10(%rax), %r10
+        movq    pt_regs_r11(%rax), %r11
+        movq    pt_regs_r12(%rax), %r12
+        movq    pt_regs_r13(%rax), %r13
+        movq    pt_regs_r14(%rax), %r14
+        movq    pt_regs_r15(%rax), %r15
 
         xorl    %eax, %eax
         addq    $8, %rsp
diff --git a/arch/x86/kernel/apic_64.c b/arch/x86/kernel/apic_64.c
index f47bc493dba9..f28ccb588fba 100644
--- a/arch/x86/kernel/apic_64.c
+++ b/arch/x86/kernel/apic_64.c
@@ -287,6 +287,20 @@ void disable_local_APIC(void)
         apic_write(APIC_SPIV, value);
 }
 
+void lapic_shutdown(void)
+{
+        unsigned long flags;
+
+        if (!cpu_has_apic)
+                return;
+
+        local_irq_save(flags);
+
+        disable_local_APIC();
+
+        local_irq_restore(flags);
+}
+
 /*
  * This is to verify that we're looking at a real local APIC.
  * Check these against your board if the CPUs aren't getting
diff --git a/arch/x86/kernel/asm-offsets_64.c b/arch/x86/kernel/asm-offsets_64.c
index 778953bc636c..7e50bda565b4 100644
--- a/arch/x86/kernel/asm-offsets_64.c
+++ b/arch/x86/kernel/asm-offsets_64.c
@@ -76,6 +76,34 @@ int main(void)
         DEFINE(pbe_orig_address, offsetof(struct pbe, orig_address));
         DEFINE(pbe_next, offsetof(struct pbe, next));
         BLANK();
+#define ENTRY(entry) DEFINE(pt_regs_ ## entry, offsetof(struct pt_regs, entry))
+        ENTRY(rbx);
+        ENTRY(rbx);
+        ENTRY(rcx);
+        ENTRY(rdx);
+        ENTRY(rsp);
+        ENTRY(rbp);
+        ENTRY(rsi);
+        ENTRY(rdi);
+        ENTRY(r8);
+        ENTRY(r9);
+        ENTRY(r10);
+        ENTRY(r11);
+        ENTRY(r12);
+        ENTRY(r13);
+        ENTRY(r14);
+        ENTRY(r15);
+        ENTRY(eflags);
+        BLANK();
+#undef ENTRY
+#define ENTRY(entry) DEFINE(saved_context_ ## entry, offsetof(struct saved_context, entry))
+        ENTRY(cr0);
+        ENTRY(cr2);
+        ENTRY(cr3);
+        ENTRY(cr4);
+        ENTRY(cr8);
+        BLANK();
+#undef ENTRY
         DEFINE(TSS_ist, offsetof(struct tss_struct, ist));
         BLANK();
         DEFINE(crypto_tfm_ctx_offset, offsetof(struct crypto_tfm, __crt_ctx));
diff --git a/arch/x86/kernel/cpu/Makefile b/arch/x86/kernel/cpu/Makefile
index 778396c78d65..cfdb2f3bd763 100644
--- a/arch/x86/kernel/cpu/Makefile
+++ b/arch/x86/kernel/cpu/Makefile
@@ -2,19 +2,19 @@
 # Makefile for x86-compatible CPU details and quirks
 #
 
-obj-y   :=      common.o proc.o bugs.o
+obj-y                   := intel_cacheinfo.o addon_cpuid_features.o
 
-obj-y   +=      amd.o
-obj-y   +=      cyrix.o
-obj-y   +=      centaur.o
-obj-y   +=      transmeta.o
-obj-y   +=      intel.o intel_cacheinfo.o addon_cpuid_features.o
-obj-y   +=      nexgen.o
-obj-y   +=      umc.o
+obj-$(CONFIG_X86_32)    += common.o proc.o bugs.o
+obj-$(CONFIG_X86_32)    += amd.o
+obj-$(CONFIG_X86_32)    += cyrix.o
+obj-$(CONFIG_X86_32)    += centaur.o
+obj-$(CONFIG_X86_32)    += transmeta.o
+obj-$(CONFIG_X86_32)    += intel.o
+obj-$(CONFIG_X86_32)    += nexgen.o
+obj-$(CONFIG_X86_32)    += umc.o
 
-obj-$(CONFIG_X86_MCE)   +=      mcheck/
-
-obj-$(CONFIG_MTRR)      +=      mtrr/
-obj-$(CONFIG_CPU_FREQ)  +=      cpufreq/
+obj-$(CONFIG_X86_MCE)   += mcheck/
+obj-$(CONFIG_MTRR)      += mtrr/
+obj-$(CONFIG_CPU_FREQ)  += cpufreq/
 
 obj-$(CONFIG_X86_LOCAL_APIC) += perfctr-watchdog.o
diff --git a/arch/x86/kernel/cpu/mcheck/Makefile b/arch/x86/kernel/cpu/mcheck/Makefile
index f1ebe1c1c17a..d7d2323bbb69 100644
--- a/arch/x86/kernel/cpu/mcheck/Makefile
+++ b/arch/x86/kernel/cpu/mcheck/Makefile
@@ -1,2 +1,6 @@
-obj-y   =       mce.o k7.o p4.o p5.o p6.o winchip.o therm_throt.o
-obj-$(CONFIG_X86_MCE_NONFATAL)  +=      non-fatal.o
+obj-y                           =  mce_$(BITS).o therm_throt.o
+
+obj-$(CONFIG_X86_32)            += k7.o p4.o p5.o p6.o winchip.o
+obj-$(CONFIG_X86_MCE_INTEL)     += mce_intel_64.o
+obj-$(CONFIG_X86_MCE_AMD)       += mce_amd_64.o
+obj-$(CONFIG_X86_MCE_NONFATAL)  += non-fatal.o
diff --git a/arch/x86/kernel/cpu/mcheck/mce.c b/arch/x86/kernel/cpu/mcheck/mce_32.c
index 34c781eddee4..34c781eddee4 100644
--- a/arch/x86/kernel/cpu/mcheck/mce.c
+++ b/arch/x86/kernel/cpu/mcheck/mce_32.c
diff --git a/arch/x86/kernel/mce_64.c b/arch/x86/kernel/cpu/mcheck/mce_64.c
index 07bbfe7aa7f7..b9f802e35209 100644
--- a/arch/x86/kernel/mce_64.c
+++ b/arch/x86/kernel/cpu/mcheck/mce_64.c
@@ -1,8 +1,8 @@
 /*
  * Machine check handler.
  * K8 parts Copyright 2002,2003 Andi Kleen, SuSE Labs.
- * Rest from unknown author(s). 
- * 2004 Andi Kleen. Rewrote most of it. 
+ * Rest from unknown author(s).
+ * 2004 Andi Kleen. Rewrote most of it.
  */
 
 #include <linux/init.h>
@@ -23,7 +23,7 @@
 #include <linux/ctype.h>
 #include <linux/kmod.h>
 #include <linux/kdebug.h>
-#include <asm/processor.h> 
+#include <asm/processor.h>
 #include <asm/msr.h>
 #include <asm/mce.h>
 #include <asm/uaccess.h>
@@ -63,10 +63,10 @@ static DECLARE_WAIT_QUEUE_HEAD(mce_wait);
  * separate MCEs from kernel messages to avoid bogus bug reports.
  */
 
-struct mce_log mcelog = { 
+struct mce_log mcelog = {
         MCE_LOG_SIGNATURE,
         MCE_LOG_LEN,
-}; 
+};
 
 void mce_log(struct mce *mce)
 {
@@ -111,42 +111,42 @@ static void print_mce(struct mce *m)
                "CPU %d: Machine Check Exception: %16Lx Bank %d: %016Lx\n",
                m->cpu, m->mcgstatus, m->bank, m->status);
         if (m->rip) {
-                printk(KERN_EMERG 
-                       "RIP%s %02x:<%016Lx> ",
+                printk(KERN_EMERG "RIP%s %02x:<%016Lx> ",
                        !(m->mcgstatus & MCG_STATUS_EIPV) ? " !INEXACT!" : "",
                        m->cs, m->rip);
                 if (m->cs == __KERNEL_CS)
                         print_symbol("{%s}", m->rip);
                 printk("\n");
         }
-        printk(KERN_EMERG "TSC %Lx ", m->tsc); 
+        printk(KERN_EMERG "TSC %Lx ", m->tsc);
         if (m->addr)
                 printk("ADDR %Lx ", m->addr);
         if (m->misc)
-                printk("MISC %Lx ", m->misc);   
+                printk("MISC %Lx ", m->misc);
         printk("\n");
         printk(KERN_EMERG "This is not a software problem!\n");
-        printk(KERN_EMERG
-    "Run through mcelog --ascii to decode and contact your hardware vendor\n");
+        printk(KERN_EMERG "Run through mcelog --ascii to decode "
+               "and contact your hardware vendor\n");
 }
 
 static void mce_panic(char *msg, struct mce *backup, unsigned long start)
-{ 
+{
         int i;
 
         oops_begin();
         for (i = 0; i < MCE_LOG_LEN; i++) {
                 unsigned long tsc = mcelog.entry[i].tsc;
+
                 if (time_before(tsc, start))
                         continue;
-                print_mce(&mcelog.entry[i]); 
+                print_mce(&mcelog.entry[i]);
                 if (backup && mcelog.entry[i].tsc == backup->tsc)
                         backup = NULL;
         }
         if (backup)
                 print_mce(backup);
         panic(msg);
-} 
+}
 
 static int mce_available(struct cpuinfo_x86 *c)
 {
@@ -170,10 +170,9 @@ static inline void mce_get_rip(struct mce *m, struct pt_regs *regs)
         }
 }
 
-/* 
+/*
  * The actual machine check handler
  */
-
 void do_machine_check(struct pt_regs * regs, long error_code)
 {
         struct mce m, panicm;
@@ -194,7 +193,8 @@ void do_machine_check(struct pt_regs * regs, long error_code)
         atomic_inc(&mce_entry);
 
         if (regs)
-                notify_die(DIE_NMI, "machine check", regs, error_code, 18, SIGKILL);
+                notify_die(DIE_NMI, "machine check", regs, error_code, 18,
+                           SIGKILL);
         if (!banks)
                 goto out2;
 
@@ -204,15 +204,15 @@ void do_machine_check(struct pt_regs * regs, long error_code)
         /* if the restart IP is not valid, we're done for */
         if (!(m.mcgstatus & MCG_STATUS_RIPV))
                 no_way_out = 1;
-        
+
         rdtscll(mcestart);
         barrier();
 
         for (i = 0; i < banks; i++) {
                 if (!bank[i])
                         continue;
-                
-                m.misc = 0; 
+
+                m.misc = 0;
                 m.addr = 0;
                 m.bank = i;
                 m.tsc = 0;
@@ -372,7 +372,7 @@ static void mcheck_timer(struct work_struct *work)
         if (mce_notify_user()) {
                 next_interval = max(next_interval/2, HZ/100);
         } else {
-                next_interval = min(next_interval*2,
+                next_interval = min(next_interval * 2,
                                 (int)round_jiffies_relative(check_interval*HZ));
         }
 
@@ -423,18 +423,18 @@ static struct notifier_block mce_idle_notifier = {
 };
 
 static __init int periodic_mcheck_init(void)
-{ 
+{
         next_interval = check_interval * HZ;
         if (next_interval)
                 schedule_delayed_work(&mcheck_work,
                                       round_jiffies_relative(next_interval));
         idle_notifier_register(&mce_idle_notifier);
         return 0;
-} 
+}
 __initcall(periodic_mcheck_init);
 
 
-/* 
+/*
  * Initialize Machine Checks for a CPU.
  */
 static void mce_init(void *dummy)
@@ -444,9 +444,9 @@ static void mce_init(void *dummy)
 
         rdmsrl(MSR_IA32_MCG_CAP, cap);
         banks = cap & 0xff;
-        if (banks > NR_BANKS) { 
+        if (banks > NR_BANKS) {
                 printk(KERN_INFO "MCE: warning: using only %d banks\n", banks);
-                banks = NR_BANKS; 
+                banks = NR_BANKS;
         }
         /* Use accurate RIP reporting if available. */
         if ((cap & (1<<9)) && ((cap >> 16) & 0xff) >= 9)
@@ -464,15 +464,15 @@ static void mce_init(void *dummy)
         for (i = 0; i < banks; i++) {
                 wrmsrl(MSR_IA32_MC0_CTL+4*i, bank[i]);
                 wrmsrl(MSR_IA32_MC0_STATUS+4*i, 0);
-        }       
+        }
 }
 
 /* Add per CPU specific workarounds here */
 static void __cpuinit mce_cpu_quirks(struct cpuinfo_x86 *c)
-{ 
+{
         /* This should be disabled by the BIOS, but isn't always */
         if (c->x86_vendor == X86_VENDOR_AMD && c->x86 == 15) {
-                /* disable GART TBL walk error reporting, which trips off 
+                /* disable GART TBL walk error reporting, which trips off
                    incorrectly with the IOMMU & 3ware & Cerberus. */
                 clear_bit(10, &bank[4]);
                 /* Lots of broken BIOS around that don't clear them
@@ -480,7 +480,7 @@ static void __cpuinit mce_cpu_quirks(struct cpuinfo_x86 *c)
                 mce_bootlog = 0;
         }
 
-}                       
+}
 
 static void __cpuinit mce_cpu_features(struct cpuinfo_x86 *c)
 {
@@ -496,15 +496,15 @@ static void __cpuinit mce_cpu_features(struct cpuinfo_x86 *c)
         }
 }
 
-/* 
+/*
  * Called for each booted CPU to set up machine checks.
- * Must be called with preempt off. 
+ * Must be called with preempt off.
  */
 void __cpuinit mcheck_init(struct cpuinfo_x86 *c)
 {
         static cpumask_t mce_cpus = CPU_MASK_NONE;
 
-        mce_cpu_quirks(c); 
+        mce_cpu_quirks(c);
 
         if (mce_dont_init ||
             cpu_test_and_set(smp_processor_id(), mce_cpus) ||
@@ -553,13 +553,15 @@ static int mce_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static void collect_tscs(void *data) 
-{ 
+static void collect_tscs(void *data)
+{
         unsigned long *cpu_tsc = (unsigned long *)data;
+
         rdtscll(cpu_tsc[smp_processor_id()]);
-} 
+}
 
-static ssize_t mce_read(struct file *filp, char __user *ubuf, size_t usize, loff_t *off)
+static ssize_t mce_read(struct file *filp, char __user *ubuf, size_t usize,
+                        loff_t *off)
 {
         unsigned long *cpu_tsc;
         static DECLARE_MUTEX(mce_read_sem);
@@ -571,19 +573,20 @@ static ssize_t mce_read(struct file *filp, char __user *ubuf, size_t usize, loff
         if (!cpu_tsc)
                 return -ENOMEM;
 
-        down(&mce_read_sem); 
+        down(&mce_read_sem);
         next = rcu_dereference(mcelog.next);
 
         /* Only supports full reads right now */
-        if (*off != 0 || usize < MCE_LOG_LEN*sizeof(struct mce)) { 
+        if (*off != 0 || usize < MCE_LOG_LEN*sizeof(struct mce)) {
                 up(&mce_read_sem);
                 kfree(cpu_tsc);
                 return -EINVAL;
         }
 
         err = 0;
-        for (i = 0; i < next; i++) {            
+        for (i = 0; i < next; i++) {
                 unsigned long start = jiffies;
+
                 while (!mcelog.entry[i].finished) {
                         if (time_after_eq(jiffies, start + 2)) {
                                 memset(mcelog.entry + i,0, sizeof(struct mce));
@@ -593,31 +596,34 @@ static ssize_t mce_read(struct file *filp, char __user *ubuf, size_t usize, loff
                 }
                 smp_rmb();
                 err |= copy_to_user(buf, mcelog.entry + i, sizeof(struct mce));
-                buf += sizeof(struct mce); 
+                buf += sizeof(struct mce);
  timeout:
                 ;
-        } 
+        }
 
         memset(mcelog.entry, 0, next * sizeof(struct mce));
         mcelog.next = 0;
 
         synchronize_sched();
 
-        /* Collect entries that were still getting written before the synchronize. */
-
+        /*
+         * Collect entries that were still getting written before the
+         * synchronize.
+         */
         on_each_cpu(collect_tscs, cpu_tsc, 1, 1);
-        for (i = next; i < MCE_LOG_LEN; i++) { 
-                if (mcelog.entry[i].finished && 
-                    mcelog.entry[i].tsc < cpu_tsc[mcelog.entry[i].cpu]) {  
-                        err |= copy_to_user(buf, mcelog.entry+i, sizeof(struct mce));
+        for (i = next; i < MCE_LOG_LEN; i++) {
+                if (mcelog.entry[i].finished &&
+                    mcelog.entry[i].tsc < cpu_tsc[mcelog.entry[i].cpu]) {
+                        err |= copy_to_user(buf, mcelog.entry+i,
+                                            sizeof(struct mce));
                         smp_rmb();
                         buf += sizeof(struct mce);
                         memset(&mcelog.entry[i], 0, sizeof(struct mce));
                 }
-        }       
+        }
         up(&mce_read_sem);
         kfree(cpu_tsc);
-        return err ? -EFAULT : buf - ubuf; 
+        return err ? -EFAULT : buf - ubuf;
 }
 
 static unsigned int mce_poll(struct file *file, poll_table *wait)
@@ -628,26 +634,29 @@ static unsigned int mce_poll(struct file *file, poll_table *wait)
         return 0;
 }
 
-static int mce_ioctl(struct inode *i, struct file *f,unsigned int cmd, unsigned long arg)
+static int mce_ioctl(struct inode *i, struct file *f,unsigned int cmd,
+                     unsigned long arg)
 {
         int __user *p = (int __user *)arg;
+
         if (!capable(CAP_SYS_ADMIN))
-                return -EPERM; 
+                return -EPERM;
         switch (cmd) {
-        case MCE_GET_RECORD_LEN: 
+        case MCE_GET_RECORD_LEN:
                 return put_user(sizeof(struct mce), p);
         case MCE_GET_LOG_LEN:
-                return put_user(MCE_LOG_LEN, p);                
+                return put_user(MCE_LOG_LEN, p);
         case MCE_GETCLEAR_FLAGS: {
                 unsigned flags;
-                do { 
+
+                do {
                         flags = mcelog.flags;
-                } while (cmpxchg(&mcelog.flags, flags, 0) != flags); 
-                return put_user(flags, p); 
+                } while (cmpxchg(&mcelog.flags, flags, 0) != flags);
+                return put_user(flags, p);
         }
         default:
-                return -ENOTTY; 
-        } 
+                return -ENOTTY;
+        }
 }
 
 static const struct file_operations mce_chrdev_ops = {
@@ -678,10 +687,9 @@ void __init restart_mce(void)
                 set_in_cr4(X86_CR4_MCE);
 }
 
-/* 
- * Old style boot options parsing. Only for compatibility. 
+/*
+ * Old style boot options parsing. Only for compatibility.
  */
-
 static int __init mcheck_disable(char *str)
 {
         mce_dont_init = 1;
@@ -702,16 +710,16 @@ static int __init mcheck_enable(char *str)
         else if (isdigit(str[0]))
                 get_option(&str, &tolerant);
         else
-                printk("mce= argument %s ignored. Please use /sys", str); 
+                printk("mce= argument %s ignored. Please use /sys", str);
         return 1;
 }
 
 __setup("nomce", mcheck_disable);
 __setup("mce=", mcheck_enable);
 
-/* 
+/*
  * Sysfs support
- */ 
+ */
 
 /* On resume clear all MCE state. Don't want to see leftovers from the BIOS.
    Only one CPU is active at this time, the others get readded later using
@@ -723,12 +731,12 @@ static int mce_resume(struct sys_device *dev)
 }
 
 /* Reinit MCEs after user configuration changes */
-static void mce_restart(void) 
-{ 
+static void mce_restart(void)
+{
         if (next_interval)
                 cancel_delayed_work(&mcheck_work);
         /* Timer race is harmless here */
-        on_each_cpu(mce_init, NULL, 1, 1);       
+        on_each_cpu(mce_init, NULL, 1, 1);
         next_interval = check_interval * HZ;
         if (next_interval)
                 schedule_delayed_work(&mcheck_work,
@@ -744,17 +752,17 @@ DEFINE_PER_CPU(struct sys_device, device_mce);
 
 /* Why are there no generic functions for this? */
 #define ACCESSOR(name, var, start) \
-        static ssize_t show_ ## name(struct sys_device *s, char *buf) {                    \
-                return sprintf(buf, "%lx\n", (unsigned long)var);                  \
-        }                                                                          \
+        static ssize_t show_ ## name(struct sys_device *s, char *buf) { \
+                return sprintf(buf, "%lx\n", (unsigned long)var);       \
+        }                                                               \
         static ssize_t set_ ## name(struct sys_device *s,const char *buf,size_t siz) { \
-                char *end;                                                         \
-                unsigned long new = simple_strtoul(buf, &end, 0);                  \
-                if (end == buf) return -EINVAL;                                    \
-                var = new;                                                         \
-                start;                                                             \
-                return end-buf;                                                    \
-        }                                                                          \
+                char *end;                                              \
+                unsigned long new = simple_strtoul(buf, &end, 0);       \
+                if (end == buf) return -EINVAL;                         \
+                var = new;                                              \
+                start;                                                  \
+                return end-buf;                                         \
+        }                                                               \
         static SYSDEV_ATTR(name, 0644, show_ ## name, set_ ## name);
 
 /* TBD should generate these dynamically based on number of available banks */
diff --git a/arch/x86/kernel/mce_amd_64.c b/arch/x86/kernel/cpu/mcheck/mce_amd_64.c
index 752fb16a817d..752fb16a817d 100644
--- a/arch/x86/kernel/mce_amd_64.c
+++ b/arch/x86/kernel/cpu/mcheck/mce_amd_64.c
diff --git a/arch/x86/kernel/mce_intel_64.c b/arch/x86/kernel/cpu/mcheck/mce_intel_64.c
index c17eaf5dd6dd..c17eaf5dd6dd 100644
--- a/arch/x86/kernel/mce_intel_64.c
+++ b/arch/x86/kernel/cpu/mcheck/mce_intel_64.c
diff --git a/arch/x86/kernel/crash_32.c b/arch/x86/kernel/crash.c
index 53589d1b1a05..af0253f94a9a 100644
--- a/arch/x86/kernel/crash_32.c
+++ b/arch/x86/kernel/crash.c
@@ -1,5 +1,5 @@
 /*
- * Architecture specific (i386) functions for kexec based crash dumps.
+ * Architecture specific (i386/x86_64) functions for kexec based crash dumps.
  *
  * Created by: Hariprasad Nellitheertha (hari@in.ibm.com)
  *
@@ -25,8 +25,11 @@
 #include <linux/kdebug.h>
 #include <asm/smp.h>
 
+#ifdef X86_32
 #include <mach_ipi.h>
-
+#else
+#include <asm/mach_apic.h>
+#endif
 
 /* This keeps a track of which one is crashing cpu. */
 static int crashing_cpu;
@@ -38,7 +41,9 @@ static int crash_nmi_callback(struct notifier_block *self,
                         unsigned long val, void *data)
 {
         struct pt_regs *regs;
+#ifdef X86_32
         struct pt_regs fixed_regs;
+#endif
         int cpu;
 
         if (val != DIE_NMI_IPI)
@@ -55,10 +60,12 @@ static int crash_nmi_callback(struct notifier_block *self,
                 return NOTIFY_STOP;
         local_irq_disable();
 
+#ifdef X86_32
         if (!user_mode_vm(regs)) {
                 crash_fixup_ss_esp(&fixed_regs, regs);
                 regs = &fixed_regs;
         }
+#endif
         crash_save_cpu(regs, cpu);
         disable_local_APIC();
         atomic_dec(&waiting_for_crash_ipi);
diff --git a/arch/x86/kernel/crash_64.c b/arch/x86/kernel/crash_64.c
deleted file mode 100644
index 13432a1ae904..000000000000
--- a/arch/x86/kernel/crash_64.c
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Architecture specific (x86_64) functions for kexec based crash dumps.
- *
- * Created by: Hariprasad Nellitheertha (hari@in.ibm.com)
- *
- * Copyright (C) IBM Corporation, 2004. All rights reserved.
- *
- */
-
-#include <linux/init.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/smp.h>
-#include <linux/irq.h>
-#include <linux/reboot.h>
-#include <linux/kexec.h>
-#include <linux/delay.h>
-#include <linux/elf.h>
-#include <linux/elfcore.h>
-#include <linux/kdebug.h>
-
-#include <asm/processor.h>
-#include <asm/hardirq.h>
-#include <asm/nmi.h>
-#include <asm/hw_irq.h>
-#include <asm/mach_apic.h>
-
-/* This keeps a track of which one is crashing cpu. */
-static int crashing_cpu;
-
-#ifdef CONFIG_SMP
-static atomic_t waiting_for_crash_ipi;
-
-static int crash_nmi_callback(struct notifier_block *self,
-                                unsigned long val, void *data)
-{
-        struct pt_regs *regs;
-        int cpu;
-
-        if (val != DIE_NMI_IPI)
-                return NOTIFY_OK;
-
-        regs = ((struct die_args *)data)->regs;
-        cpu = raw_smp_processor_id();
-
-        /*
-         * Don't do anything if this handler is invoked on crashing cpu.
-         * Otherwise, system will completely hang. Crashing cpu can get
-         * an NMI if system was initially booted with nmi_watchdog parameter.
-         */
-        if (cpu == crashing_cpu)
-                return NOTIFY_STOP;
-        local_irq_disable();
-
-        crash_save_cpu(regs, cpu);
-        disable_local_APIC();
-        atomic_dec(&waiting_for_crash_ipi);
-        /* Assume hlt works */
-        for(;;)
-                halt();
-
-        return 1;
-}
-
-static void smp_send_nmi_allbutself(void)
-{
-        send_IPI_allbutself(NMI_VECTOR);
-}
-
-/*
- * This code is a best effort heuristic to get the
- * other cpus to stop executing. So races with
- * cpu hotplug shouldn't matter.
- */
-
-static struct notifier_block crash_nmi_nb = {
-        .notifier_call = crash_nmi_callback,
-};
-
-static void nmi_shootdown_cpus(void)
-{
-        unsigned long msecs;
-
-        atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1);
-        if (register_die_notifier(&crash_nmi_nb))
-                return;         /* return what? */
-
-        /*
-         * Ensure the new callback function is set before sending
-         * out the NMI
-         */
-        wmb();
-
-        smp_send_nmi_allbutself();
-
-        msecs = 1000; /* Wait at most a second for the other cpus to stop */
-        while ((atomic_read(&waiting_for_crash_ipi) > 0) && msecs) {
-                mdelay(1);
-                msecs--;
-        }
-        /* Leave the nmi callback set */
-        disable_local_APIC();
-}
-#else
-static void nmi_shootdown_cpus(void)
-{
-        /* There are no cpus to shootdown */
-}
-#endif
-
-void machine_crash_shutdown(struct pt_regs *regs)
-{
-        /*
-         * This function is only called after the system
-         * has panicked or is otherwise in a critical state.
-         * The minimum amount of code to allow a kexec'd kernel
-         * to run successfully needs to happen here.
-         *
-         * In practice this means shooting down the other cpus in
-         * an SMP system.
-         */
-        /* The kernel is broken so disable interrupts */
-        local_irq_disable();
-
-        /* Make a note of crashing cpu. Will be used in NMI callback.*/
-        crashing_cpu = smp_processor_id();
-        nmi_shootdown_cpus();
-
-        if(cpu_has_apic)
-                 disable_local_APIC();
-
-        disable_IO_APIC();
-
-        crash_save_cpu(regs, smp_processor_id());
-}
diff --git a/arch/x86/kernel/head_32.S b/arch/x86/kernel/head_32.S
index 00b1c2c56454..374b7ece8961 100644
--- a/arch/x86/kernel/head_32.S
+++ b/arch/x86/kernel/head_32.S
@@ -124,12 +124,7 @@ ENTRY(startup_32)
         movsl
         movl boot_params - __PAGE_OFFSET + NEW_CL_POINTER,%esi
         andl %esi,%esi
-        jnz 2f                  # New command line protocol
-        cmpw $(OLD_CL_MAGIC),OLD_CL_MAGIC_ADDR
-        jne 1f
-        movzwl OLD_CL_OFFSET,%esi
-        addl $(OLD_CL_BASE_ADDR),%esi
-2:
+        jz 1f                   # No comand line
         movl $(boot_command_line - __PAGE_OFFSET),%edi
         movl $(COMMAND_LINE_SIZE/4),%ecx
         rep
diff --git a/arch/x86/kernel/quirks.c b/arch/x86/kernel/quirks.c
index a4ce1911efdf..fab30e134836 100644
--- a/arch/x86/kernel/quirks.c
+++ b/arch/x86/kernel/quirks.c
@@ -60,7 +60,8 @@ static enum {
         NONE_FORCE_HPET_RESUME,
         OLD_ICH_FORCE_HPET_RESUME,
         ICH_FORCE_HPET_RESUME,
-        VT8237_FORCE_HPET_RESUME
+        VT8237_FORCE_HPET_RESUME,
+        NVIDIA_FORCE_HPET_RESUME,
 } force_hpet_resume_type;
 
 static void __iomem *rcba_base;
@@ -321,6 +322,55 @@ DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8235,
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8237,
                          vt8237_force_enable_hpet);
 
+/*
+ * Undocumented chipset feature taken from LinuxBIOS.
+ */
+static void nvidia_force_hpet_resume(void)
+{
+        pci_write_config_dword(cached_dev, 0x44, 0xfed00001);
+        printk(KERN_DEBUG "Force enabled HPET at resume\n");
+}
+
+static void nvidia_force_enable_hpet(struct pci_dev *dev)
+{
+        u32 uninitialized_var(val);
+
+        if (!hpet_force_user || hpet_address || force_hpet_address)
+                return;
+
+        pci_write_config_dword(dev, 0x44, 0xfed00001);
+        pci_read_config_dword(dev, 0x44, &val);
+        force_hpet_address = val & 0xfffffffe;
+        force_hpet_resume_type = NVIDIA_FORCE_HPET_RESUME;
+        printk(KERN_DEBUG "Force enabled HPET at base address 0x%lx\n",
+                force_hpet_address);
+        cached_dev = dev;
+        return;
+}
+
+/* ISA Bridges */
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0050,
+                        nvidia_force_enable_hpet);
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0051,
+                        nvidia_force_enable_hpet);
+
+/* LPC bridges */
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0360,
+                        nvidia_force_enable_hpet);
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0361,
+                        nvidia_force_enable_hpet);
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0362,
+                        nvidia_force_enable_hpet);
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0363,
+                        nvidia_force_enable_hpet);
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0364,
+                        nvidia_force_enable_hpet);
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0365,
+                        nvidia_force_enable_hpet);
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0366,
+                        nvidia_force_enable_hpet);
+DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_NVIDIA, 0x0367,
+                        nvidia_force_enable_hpet);
 
 void force_hpet_resume(void)
 {
@@ -334,6 +384,9 @@ void force_hpet_resume(void)
             case VT8237_FORCE_HPET_RESUME:
                 return vt8237_force_hpet_resume();
 
+            case NVIDIA_FORCE_HPET_RESUME:
+                return nvidia_force_hpet_resume();
+
             default:
                 break;
         }
diff --git a/arch/x86/kernel/smpboot_64.c b/arch/x86/kernel/smpboot_64.c
index b7e768dd87c9..500670c93d81 100644
--- a/arch/x86/kernel/smpboot_64.c
+++ b/arch/x86/kernel/smpboot_64.c
@@ -388,7 +388,7 @@ static void inquire_remote_apic(int apicid)
 
         printk(KERN_INFO "Inquiring remote APIC #%d...\n", apicid);
 
-        for (i = 0; i < sizeof(regs) / sizeof(*regs); i++) {
+        for (i = 0; i < ARRAY_SIZE(regs); i++) {
                 printk("... APIC #%d %s: ", apicid, names[i]);
 
                 /*
diff --git a/arch/x86/kernel/suspend_64.c b/arch/x86/kernel/suspend_64.c
index bc9f59c246fd..db284ef44d53 100644
--- a/arch/x86/kernel/suspend_64.c
+++ b/arch/x86/kernel/suspend_64.c
@@ -19,12 +19,6 @@ extern const void __nosave_begin, __nosave_end;
 
 struct saved_context saved_context;
 
-unsigned long saved_context_eax, saved_context_ebx, saved_context_ecx, saved_context_edx;
-unsigned long saved_context_esp, saved_context_ebp, saved_context_esi, saved_context_edi;
-unsigned long saved_context_r08, saved_context_r09, saved_context_r10, saved_context_r11;
-unsigned long saved_context_r12, saved_context_r13, saved_context_r14, saved_context_r15;
-unsigned long saved_context_eflags;
-
 void __save_processor_state(struct saved_context *ctxt)
 {
         kernel_fpu_begin();
diff --git a/arch/x86/kernel/suspend_asm_64.S b/arch/x86/kernel/suspend_asm_64.S
index 48344b666d2c..72f952103e50 100644
--- a/arch/x86/kernel/suspend_asm_64.S
+++ b/arch/x86/kernel/suspend_asm_64.S
@@ -17,24 +17,24 @@
 #include <asm/asm-offsets.h>
 
 ENTRY(swsusp_arch_suspend)
-
-        movq %rsp, saved_context_esp(%rip)
-        movq %rax, saved_context_eax(%rip)
-        movq %rbx, saved_context_ebx(%rip)
-        movq %rcx, saved_context_ecx(%rip)
-        movq %rdx, saved_context_edx(%rip)
-        movq %rbp, saved_context_ebp(%rip)
-        movq %rsi, saved_context_esi(%rip)
-        movq %rdi, saved_context_edi(%rip)
-        movq %r8,  saved_context_r08(%rip)
-        movq %r9,  saved_context_r09(%rip)
-        movq %r10, saved_context_r10(%rip)
-        movq %r11, saved_context_r11(%rip)
-        movq %r12, saved_context_r12(%rip)
-        movq %r13, saved_context_r13(%rip)
-        movq %r14, saved_context_r14(%rip)
-        movq %r15, saved_context_r15(%rip)
-        pushfq ; popq saved_context_eflags(%rip)
+        movq    $saved_context, %rax
+        movq    %rsp, pt_regs_rsp(%rax)
+        movq    %rbp, pt_regs_rbp(%rax)
+        movq    %rsi, pt_regs_rsi(%rax)
+        movq    %rdi, pt_regs_rdi(%rax)
+        movq    %rbx, pt_regs_rbx(%rax)
+        movq    %rcx, pt_regs_rcx(%rax)
+        movq    %rdx, pt_regs_rdx(%rax)
+        movq    %r8, pt_regs_r8(%rax)
+        movq    %r9, pt_regs_r9(%rax)
+        movq    %r10, pt_regs_r10(%rax)
+        movq    %r11, pt_regs_r11(%rax)
+        movq    %r12, pt_regs_r12(%rax)
+        movq    %r13, pt_regs_r13(%rax)
+        movq    %r14, pt_regs_r14(%rax)
+        movq    %r15, pt_regs_r15(%rax)
+        pushfq
+        popq    pt_regs_eflags(%rax)
 
         /* save the address of restore_registers */
         movq    $restore_registers, %rax
@@ -113,23 +113,25 @@ ENTRY(restore_registers)
         movq    %rcx, %cr3
         movq    %rax, %cr4;  # turn PGE back on
 
-        movq saved_context_esp(%rip), %rsp
-        movq saved_context_ebp(%rip), %rbp
-        /* restore GPRs (we don't restore %rax, it must be 0 anyway) */
-        movq saved_context_ebx(%rip), %rbx
-        movq saved_context_ecx(%rip), %rcx
-        movq saved_context_edx(%rip), %rdx
-        movq saved_context_esi(%rip), %rsi
-        movq saved_context_edi(%rip), %rdi
-        movq saved_context_r08(%rip), %r8
-        movq saved_context_r09(%rip), %r9
-        movq saved_context_r10(%rip), %r10
-        movq saved_context_r11(%rip), %r11
-        movq saved_context_r12(%rip), %r12
-        movq saved_context_r13(%rip), %r13
-        movq saved_context_r14(%rip), %r14
-        movq saved_context_r15(%rip), %r15
-        pushq saved_context_eflags(%rip) ; popfq
+        /* We don't restore %rax, it must be 0 anyway */
+        movq    $saved_context, %rax
+        movq    pt_regs_rsp(%rax), %rsp
+        movq    pt_regs_rbp(%rax), %rbp
+        movq    pt_regs_rsi(%rax), %rsi
+        movq    pt_regs_rdi(%rax), %rdi
+        movq    pt_regs_rbx(%rax), %rbx
+        movq    pt_regs_rcx(%rax), %rcx
+        movq    pt_regs_rdx(%rax), %rdx
+        movq    pt_regs_r8(%rax), %r8
+        movq    pt_regs_r9(%rax), %r9
+        movq    pt_regs_r10(%rax), %r10
+        movq    pt_regs_r11(%rax), %r11
+        movq    pt_regs_r12(%rax), %r12
+        movq    pt_regs_r13(%rax), %r13
+        movq    pt_regs_r14(%rax), %r14
+        movq    pt_regs_r15(%rax), %r15
+        pushq   pt_regs_eflags(%rax)
+        popfq
 
         xorq    %rax, %rax
 
diff --git a/arch/x86/kernel/tsc_32.c b/arch/x86/kernel/tsc_32.c
index d78444c788a3..9ebc0dab66b4 100644
--- a/arch/x86/kernel/tsc_32.c
+++ b/arch/x86/kernel/tsc_32.c
@@ -131,38 +131,43 @@ unsigned long native_calculate_cpu_khz(void)
 {
         unsigned long long start, end;
         unsigned long count;
-        u64 delta64;
+        u64 delta64 = (u64)ULLONG_MAX;
         int i;
         unsigned long flags;
 
         local_irq_save(flags);
 
-        /* run 3 times to ensure the cache is warm */
+        /* run 3 times to ensure the cache is warm and to get an accurate reading */
         for (i = 0; i < 3; i++) {
                 mach_prepare_counter();
                 rdtscll(start);
                 mach_countup(&count);
                 rdtscll(end);
-        }
-        /*
-         * Error: ECTCNEVERSET
-         * The CTC wasn't reliable: we got a hit on the very first read,
-         * or the CPU was so fast/slow that the quotient wouldn't fit in
-         * 32 bits..
-         */
-        if (count <= 1)
-                goto err;
 
-        delta64 = end - start;
+                /*
+                 * Error: ECTCNEVERSET
+                 * The CTC wasn't reliable: we got a hit on the very first read,
+                 * or the CPU was so fast/slow that the quotient wouldn't fit in
+                 * 32 bits..
+                 */
+                if (count <= 1)
+                        continue;
+
+                /* cpu freq too slow: */
+                if ((end - start) <= CALIBRATE_TIME_MSEC)
+                        continue;
+
+                /*
+                 * We want the minimum time of all runs in case one of them
+                 * is inaccurate due to SMI or other delay
+                 */
+                delta64 = min(delta64, (end - start));
+        }
 
-        /* cpu freq too fast: */
+        /* cpu freq too fast (or every run was bad): */
         if (delta64 > (1ULL<<32))
                 goto err;
 
-        /* cpu freq too slow: */
-        if (delta64 <= CALIBRATE_TIME_MSEC)
-                goto err;
-
         delta64 += CALIBRATE_TIME_MSEC/2; /* round for do_div */
         do_div(delta64,CALIBRATE_TIME_MSEC);
 
diff --git a/arch/x86/oprofile/Kconfig b/arch/x86/oprofile/Kconfig
deleted file mode 100644
index d8a84088471a..000000000000
--- a/arch/x86/oprofile/Kconfig
+++ /dev/null
@@ -1,17 +0,0 @@
-config PROFILING
-        bool "Profiling support (EXPERIMENTAL)"
-        help
-          Say Y here to enable the extended profiling support mechanisms used
-          by profilers such as OProfile.
-          
-
-config OPROFILE
-        tristate "OProfile system profiling (EXPERIMENTAL)"
-        depends on PROFILING
-        help
-          OProfile is a profiling system capable of profiling the
-          whole system, include the kernel, kernel modules, libraries,
-          and applications.
-
-          If unsure, say N.
-
diff --git a/arch/x86_64/Kconfig b/arch/x86_64/Kconfig
index c2d24991bb2b..308970aa5382 100644
--- a/arch/x86_64/Kconfig
+++ b/arch/x86_64/Kconfig
@@ -833,6 +833,8 @@ source "drivers/firmware/Kconfig"
 
 source fs/Kconfig
 
+source "kernel/Kconfig.instrumentation"
+
 source "arch/x86_64/Kconfig.debug"
 
 source "security/Kconfig"
diff --git a/arch/x86_64/Makefile b/arch/x86_64/Makefile
index 6d89ab762ffc..20eb69bd5a6d 100644
--- a/arch/x86_64/Makefile
+++ b/arch/x86_64/Makefile
@@ -24,6 +24,12 @@
 # Fill in SRCARCH
 SRCARCH := x86
 
+# BITS is used as extension for files which are available in a 32 bit
+# and a 64 bit version to simplify shared Makefiles.
+# e.g.: obj-y += foo_$(BITS).o
+BITS := 64
+export BITS
+
 LDFLAGS         := -m elf_x86_64
 OBJCOPYFLAGS    := -O binary -R .note -R .comment -S
 LDFLAGS_vmlinux :=
diff --git a/drivers/Makefile b/drivers/Makefile
index 560496b43306..8cb37e3557d4 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -34,7 +34,6 @@ obj-$(CONFIG_NUBUS)		+= nubus/
 obj-$(CONFIG_ATM)               += atm/
 obj-y                           += macintosh/
 obj-$(CONFIG_IDE)               += ide/
-obj-$(CONFIG_FC4)               += fc4/
 obj-$(CONFIG_SCSI)              += scsi/
 obj-$(CONFIG_ATA)               += ata/
 obj-$(CONFIG_FUSION)            += message/
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index 47c806040524..95229e77bffe 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -227,7 +227,7 @@ struct ahci_port_priv {
 
 static int ahci_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val);
 static int ahci_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val);
-static int ahci_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
+static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
 static unsigned int ahci_qc_issue(struct ata_queued_cmd *qc);
 static void ahci_irq_clear(struct ata_port *ap);
 static int ahci_port_start(struct ata_port *ap);
@@ -729,7 +729,7 @@ static int ahci_stop_engine(struct ata_port *ap)
 
         /* wait for engine to stop. This could be as long as 500 msec */
         tmp = ata_wait_register(port_mmio + PORT_CMD,
-                                PORT_CMD_LIST_ON, PORT_CMD_LIST_ON, 1, 500);
+                                PORT_CMD_LIST_ON, PORT_CMD_LIST_ON, 1, 500);
         if (tmp & PORT_CMD_LIST_ON)
                 return -EIO;
 
@@ -1564,9 +1564,9 @@ static irqreturn_t ahci_interrupt(int irq, void *dev_instance)
         if (!irq_stat)
                 return IRQ_NONE;
 
-        spin_lock(&host->lock);
+        spin_lock(&host->lock);
 
-        for (i = 0; i < host->n_ports; i++) {
+        for (i = 0; i < host->n_ports; i++) {
                 struct ata_port *ap;
 
                 if (!(irq_stat & (1 << i)))
@@ -1829,9 +1829,9 @@ static int ahci_port_start(struct ata_port *ap)
         pp->cmd_tbl_dma = mem_dma;
 
         /*
-         * Save off initial list of interrupts to be enabled.
-         * This could be changed later
-         */
+         * Save off initial list of interrupts to be enabled.
+         * This could be changed later
+         */
         pp->intr_mask = DEF_PORT_IRQ;
 
         ap->private_data = pp;
@@ -1918,12 +1918,12 @@ static void ahci_print_info(struct ata_host *host)
         dev_printk(KERN_INFO, &pdev->dev,
                 "AHCI %02x%02x.%02x%02x "
                 "%u slots %u ports %s Gbps 0x%x impl %s mode\n"
-                ,
+                ,
 
-                (vers >> 24) & 0xff,
-                (vers >> 16) & 0xff,
-                (vers >> 8) & 0xff,
-                vers & 0xff,
+                (vers >> 24) & 0xff,
+                (vers >> 16) & 0xff,
+                (vers >> 8) & 0xff,
+                vers & 0xff,
 
                 ((cap >> 8) & 0x1f) + 1,
                 (cap & 0x1f) + 1,
@@ -1935,7 +1935,7 @@ static void ahci_print_info(struct ata_host *host)
                 "flags: "
                 "%s%s%s%s%s%s%s"
                 "%s%s%s%s%s%s%s\n"
-                ,
+                ,
 
                 cap & (1 << 31) ? "64bit " : "",
                 cap & (1 << 30) ? "ncq " : "",
diff --git a/drivers/ata/ata_piix.c b/drivers/ata/ata_piix.c
index 3c6f43e381f4..a4b2cb29f46c 100644
--- a/drivers/ata/ata_piix.c
+++ b/drivers/ata/ata_piix.c
@@ -157,12 +157,12 @@ struct piix_host_priv {
         const int *map;
 };
 
-static int piix_init_one (struct pci_dev *pdev,
-                                    const struct pci_device_id *ent);
+static int piix_init_one(struct pci_dev *pdev,
+                         const struct pci_device_id *ent);
 static void piix_pata_error_handler(struct ata_port *ap);
-static void piix_set_piomode (struct ata_port *ap, struct ata_device *adev);
-static void piix_set_dmamode (struct ata_port *ap, struct ata_device *adev);
-static void ich_set_dmamode (struct ata_port *ap, struct ata_device *adev);
+static void piix_set_piomode(struct ata_port *ap, struct ata_device *adev);
+static void piix_set_dmamode(struct ata_port *ap, struct ata_device *adev);
+static void ich_set_dmamode(struct ata_port *ap, struct ata_device *adev);
 static int ich_pata_cable_detect(struct ata_port *ap);
 #ifdef CONFIG_PM
 static int piix_pci_device_suspend(struct pci_dev *pdev, pm_message_t mesg);
@@ -650,9 +650,9 @@ static int ich_pata_cable_detect(struct ata_port *ap)
         while (lap->device) {
                 if (lap->device == pdev->device &&
                     lap->subvendor == pdev->subsystem_vendor &&
-                    lap->subdevice == pdev->subsystem_device) {
+                    lap->subdevice == pdev->subsystem_device)
                         return ATA_CBL_PATA40_SHORT;
-                }
+
                 lap++;
         }
 
@@ -699,7 +699,7 @@ static void piix_pata_error_handler(struct ata_port *ap)
  *      None (inherited from caller).
  */
 
-static void piix_set_piomode (struct ata_port *ap, struct ata_device *adev)
+static void piix_set_piomode(struct ata_port *ap, struct ata_device *adev)
 {
         unsigned int pio        = adev->pio_mode - XFER_PIO_0;
         struct pci_dev *dev     = to_pci_dev(ap->host->dev);
@@ -786,7 +786,7 @@ static void piix_set_piomode (struct ata_port *ap, struct ata_device *adev)
  *      None (inherited from caller).
  */
 
-static void do_pata_set_dmamode (struct ata_port *ap, struct ata_device *adev, int isich)
+static void do_pata_set_dmamode(struct ata_port *ap, struct ata_device *adev, int isich)
 {
         struct pci_dev *dev     = to_pci_dev(ap->host->dev);
         u8 master_port          = ap->port_no ? 0x42 : 0x40;
@@ -813,7 +813,7 @@ static void do_pata_set_dmamode (struct ata_port *ap, struct ata_device *adev, i
                 int u_clock, u_speed;
 
                 /*
-                 * UDMA is handled by a combination of clock switching and
+                 * UDMA is handled by a combination of clock switching and
                  * selection of dividers
                  *
                  * Handy rule: Odd modes are UDMATIMx 01, even are 02
@@ -905,7 +905,7 @@ static void do_pata_set_dmamode (struct ata_port *ap, struct ata_device *adev, i
  *      None (inherited from caller).
  */
 
-static void piix_set_dmamode (struct ata_port *ap, struct ata_device *adev)
+static void piix_set_dmamode(struct ata_port *ap, struct ata_device *adev)
 {
         do_pata_set_dmamode(ap, adev, 0);
 }
@@ -921,7 +921,7 @@ static void piix_set_dmamode (struct ata_port *ap, struct ata_device *adev)
  *      None (inherited from caller).
  */
 
-static void ich_set_dmamode (struct ata_port *ap, struct ata_device *adev)
+static void ich_set_dmamode(struct ata_port *ap, struct ata_device *adev)
 {
         do_pata_set_dmamode(ap, adev, 1);
 }
@@ -1106,8 +1106,7 @@ static int __devinit piix_check_450nx_errata(struct pci_dev *ata_dev)
         u16 cfg;
         int no_piix_dma = 0;
 
-        while((pdev = pci_get_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82454NX, pdev)) != NULL)
-        {
+        while ((pdev = pci_get_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82454NX, pdev)) != NULL) {
                 /* Look for 450NX PXB. Check for problem configurations
                    A PCI quirk checks bit 6 already */
                 pci_read_config_word(pdev, 0x41, &cfg);
@@ -1241,7 +1240,7 @@ static void piix_iocfg_bit18_quirk(struct pci_dev *pdev)
  *      Zero on success, or -ERRNO value.
  */
 
-static int piix_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
+static int piix_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
         static int printed_version;
         struct device *dev = &pdev->dev;
diff --git a/drivers/ata/libata-acpi.c b/drivers/ata/libata-acpi.c
index 3f7533589041..08a52dd45fb6 100644
--- a/drivers/ata/libata-acpi.c
+++ b/drivers/ata/libata-acpi.c
@@ -26,7 +26,7 @@
 #include <acpi/actypes.h>
 
 #define NO_PORT_MULT            0xffff
-#define SATA_ADR(root,pmp)      (((root) << 16) | (pmp))
+#define SATA_ADR(root, pmp)     (((root) << 16) | (pmp))
 
 #define REGS_PER_GTF            7
 struct ata_acpi_gtf {
@@ -96,8 +96,8 @@ static void ata_acpi_associate_ide_port(struct ata_port *ap)
         }
 }
 
-static void ata_acpi_handle_hotplug (struct ata_port *ap, struct kobject *kobj,
-                                     u32 event)
+static void ata_acpi_handle_hotplug(struct ata_port *ap, struct kobject *kobj,
+                                    u32 event)
 {
         char event_string[12];
         char *envp[] = { event_string, NULL };
@@ -114,7 +114,7 @@ static void ata_acpi_handle_hotplug (struct ata_port *ap, struct kobject *kobj,
         }
 
         if (kobj) {
-                sprintf(event_string, "BAY_EVENT=%d", event);
+                sprintf(event_string, "BAY_EVENT=%d", event);
                 kobject_uevent_env(kobj, KOBJ_CHANGE, envp);
         }
 }
@@ -127,14 +127,14 @@ static void ata_acpi_dev_notify(acpi_handle handle, u32 event, void *data)
         if (dev->sdev)
                 kobj = &dev->sdev->sdev_gendev.kobj;
 
-        ata_acpi_handle_hotplug (dev->link->ap, kobj, event);
+        ata_acpi_handle_hotplug(dev->link->ap, kobj, event);
 }
 
 static void ata_acpi_ap_notify(acpi_handle handle, u32 event, void *data)
 {
         struct ata_port *ap = data;
 
-        ata_acpi_handle_hotplug (ap, &ap->dev->kobj, event);
+        ata_acpi_handle_hotplug(ap, &ap->dev->kobj, event);
 }
 
 /**
@@ -398,11 +398,11 @@ int ata_acpi_cbl_80wire(struct ata_port *ap)
 {
         struct ata_acpi_gtm gtm;
         int valid = 0;
-        
+
         /* No _GTM data, no information */
         if (ata_acpi_gtm(ap, &gtm) < 0)
                 return 0;
-                
+
         /* Split timing, DMA enabled */
         if ((gtm.flags & 0x11) == 0x11 && gtm.drive[0].dma < 55)
                 valid |= 1;
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 69092bce1ada..2d147b51c978 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -49,11 +49,11 @@
 #include <linux/workqueue.h>
 #include <linux/jiffies.h>
 #include <linux/scatterlist.h>
+#include <linux/io.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_host.h>
 #include <linux/libata.h>
-#include <asm/io.h>
 #include <asm/semaphore.h>
 #include <asm/byteorder.h>
 
@@ -93,7 +93,7 @@ int libata_fua = 0;
 module_param_named(fua, libata_fua, int, 0444);
 MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");
 
-static int ata_ignore_hpa = 0;
+static int ata_ignore_hpa;
 module_param_named(ignore_hpa, ata_ignore_hpa, int, 0644);
 MODULE_PARM_DESC(ignore_hpa, "Ignore HPA limit (0=keep BIOS limits, 1=ignore limits, using full disk)");
 
@@ -713,7 +713,7 @@ unsigned int ata_dev_classify(const struct ata_taskfile *tf)
         }
 
         if ((tf->lbam == 0x3c) && (tf->lbah == 0xc3)) {
-                printk("ata: SEMB device ignored\n");
+                printk(KERN_INFO "ata: SEMB device ignored\n");
                 return ATA_DEV_SEMB_UNSUP; /* not yet */
         }
 
@@ -939,7 +939,7 @@ static int ata_read_native_max_address(struct ata_device *dev, u64 *max_sectors)
                 *max_sectors = ata_tf_to_lba48(&tf);
         else
                 *max_sectors = ata_tf_to_lba(&tf);
-        if (dev->horkage & ATA_HORKAGE_HPA_SIZE)
+        if (dev->horkage & ATA_HORKAGE_HPA_SIZE)
                 (*max_sectors)--;
         return 0;
 }
@@ -1151,7 +1151,7 @@ void ata_id_to_dma_mode(struct ata_device *dev, u8 unknown)
  *      LOCKING:
  *      caller.
  */
-void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
+void ata_noop_dev_select(struct ata_port *ap, unsigned int device)
 {
 }
 
@@ -1171,7 +1171,7 @@ void ata_noop_dev_select (struct ata_port *ap, unsigned int device)
  *      caller.
  */
 
-void ata_std_dev_select (struct ata_port *ap, unsigned int device)
+void ata_std_dev_select(struct ata_port *ap, unsigned int device)
 {
         u8 tmp;
 
@@ -1292,7 +1292,7 @@ static unsigned int ata_id_xfermask(const u16 *id)
                  */
                 u8 mode = (id[ATA_ID_OLD_PIO_MODES] >> 8) & 0xFF;
                 if (mode < 5)   /* Valid PIO range */
-                        pio_mask = (2 << mode) - 1;
+                        pio_mask = (2 << mode) - 1;
                 else
                         pio_mask = 1;
 
@@ -1693,7 +1693,7 @@ static u32 ata_pio_mask_no_iordy(const struct ata_device *adev)
  *      for pre-ATA4 drives.
  *
  *      FIXME: ATA_CMD_ID_ATA is optional for early drives and right
- *      now we abort if we hit that case. 
+ *      now we abort if we hit that case.
  *
  *      LOCKING:
  *      Kernel thread context (may sleep)
@@ -1979,9 +1979,8 @@ int ata_dev_configure(struct ata_device *dev)
                                                "supports DRM functions and may "
                                                "not be fully accessable.\n");
                         snprintf(revbuf, 7, "CFA");
-                }
-                else
-                        snprintf(revbuf, 7, "ATA-%d",  ata_id_major_version(id));
+                } else
+                        snprintf(revbuf, 7, "ATA-%d", ata_id_major_version(id));
 
                 dev->n_sectors = ata_id_n_sectors(id);
 
@@ -2110,7 +2109,7 @@ int ata_dev_configure(struct ata_device *dev)
                 /* Let the user know. We don't want to disallow opens for
                    rescue purposes, or in case the vendor is just a blithering
                    idiot */
-                if (print_info) {
+                if (print_info) {
                         ata_dev_printk(dev, KERN_WARNING,
 "Drive reports diagnostics failure. This may indicate a drive\n");
                         ata_dev_printk(dev, KERN_WARNING,
@@ -2667,8 +2666,8 @@ static const struct ata_timing ata_timing[] = {
         { 0xFF }
 };
 
-#define ENOUGH(v,unit)          (((v)-1)/(unit)+1)
-#define EZ(v,unit)              ((v)?ENOUGH(v,unit):0)
+#define ENOUGH(v, unit)         (((v)-1)/(unit)+1)
+#define EZ(v, unit)             ((v)?ENOUGH(v, unit):0)
 
 static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT)
 {
@@ -2695,7 +2694,7 @@ void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
         if (what & ATA_TIMING_UDMA   ) m->udma    = max(a->udma,    b->udma);
 }
 
-static const struct ata_timing* ata_timing_find_mode(unsigned short speed)
+static const struct ata_timing *ata_timing_find_mode(unsigned short speed)
 {
         const struct ata_timing *t;
 
@@ -2727,10 +2726,10 @@ int ata_timing_compute(struct ata_device *adev, unsigned short speed,
 
         if (adev->id[ATA_ID_FIELD_VALID] & 2) { /* EIDE drive */
                 memset(&p, 0, sizeof(p));
-                if(speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) {
+                if (speed >= XFER_PIO_0 && speed <= XFER_SW_DMA_0) {
                         if (speed <= XFER_PIO_2) p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO];
                                             else p.cycle = p.cyc8b = adev->id[ATA_ID_EIDE_PIO_IORDY];
-                } else if(speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) {
+                } else if (speed >= XFER_MW_DMA_0 && speed <= XFER_MW_DMA_2) {
                         p.cycle = adev->id[ATA_ID_EIDE_DMA_MIN];
                 }
                 ata_timing_merge(&p, t, t, ATA_TIMING_CYCLE | ATA_TIMING_CYC8B);
@@ -2876,14 +2875,17 @@ static int ata_dev_set_mode(struct ata_device *dev)
                 dev->flags |= ATA_DFLAG_PIO;
 
         err_mask = ata_dev_set_xfermode(dev);
+
         /* Old CFA may refuse this command, which is just fine */
         if (dev->xfer_shift == ATA_SHIFT_PIO && ata_id_is_cfa(dev->id))
-                err_mask &= ~AC_ERR_DEV;
+                err_mask &= ~AC_ERR_DEV;
+
         /* Some very old devices and some bad newer ones fail any kind of
            SET_XFERMODE request but support PIO0-2 timings and no IORDY */
         if (dev->xfer_shift == ATA_SHIFT_PIO && !ata_id_has_iordy(dev->id) &&
                         dev->pio_mode <= XFER_PIO_2)
                 err_mask &= ~AC_ERR_DEV;
+
         if (err_mask) {
                 ata_dev_printk(dev, KERN_ERR, "failed to set xfermode "
                                "(err_mask=0x%x)\n", err_mask);
@@ -3265,7 +3267,7 @@ static int ata_bus_softreset(struct ata_port *ap, unsigned int devmask,
          * the bus shows 0xFF because the odd clown forgets the D7
          * pulldown resistor.
          */
-        if (ata_check_status(ap) == 0xFF)
+        if (ata_chk_status(ap) == 0xFF)
                 return -ENODEV;
 
         return ata_bus_post_reset(ap, devmask, deadline);
@@ -3943,7 +3945,7 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
         { "SAMSUNG CD-ROM SC",  NULL,           ATA_HORKAGE_NODMA },
         { "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,ATA_HORKAGE_NODMA },
         { "_NEC DV5800A",       NULL,           ATA_HORKAGE_NODMA },
-        { "SAMSUNG CD-ROM SN-124","N001",       ATA_HORKAGE_NODMA },
+        { "SAMSUNG CD-ROM SN-124", "N001",      ATA_HORKAGE_NODMA },
         { "Seagate STT20000A", NULL,            ATA_HORKAGE_NODMA },
         { "IOMEGA  ZIP 250       ATAPI", NULL,  ATA_HORKAGE_NODMA }, /* temporary fix */
         { "IOMEGA  ZIP 250       ATAPI       Floppy",
@@ -3959,7 +3961,7 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
 
         /* Devices where NCQ should be avoided */
         /* NCQ is slow */
-        { "WDC WD740ADFD-00",   NULL,           ATA_HORKAGE_NONCQ },
+        { "WDC WD740ADFD-00",   NULL,           ATA_HORKAGE_NONCQ },
         /* http://thread.gmane.org/gmane.linux.ide/14907 */
         { "FUJITSU MHT2060BH",  NULL,           ATA_HORKAGE_NONCQ },
         /* NCQ is broken */
@@ -3979,6 +3981,7 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = {
         { "HTS541612J9SA00",    "SBDIC7JP",     ATA_HORKAGE_NONCQ, },
         { "HDT722516DLA380",    "V43OA96A",     ATA_HORKAGE_NONCQ, },
         { "Hitachi HTS541616J9SA00", "SB4OC70P", ATA_HORKAGE_NONCQ, },
+        { "Hitachi HTS542525K9SA00", "BBFOC31P", ATA_HORKAGE_NONCQ, },
         { "WDC WD740ADFD-00NLR1", NULL,         ATA_HORKAGE_NONCQ, },
         { "WDC WD3200AAJS-00RYA0", "12.01B01",  ATA_HORKAGE_NONCQ, },
         { "FUJITSU MHV2080BH",  "00840028",     ATA_HORKAGE_NONCQ, },
@@ -4106,7 +4109,7 @@ static void ata_dev_xfermask(struct ata_device *dev)
         }
 
         if ((host->flags & ATA_HOST_SIMPLEX) &&
-            host->simplex_claimed && host->simplex_claimed != ap) {
+            host->simplex_claimed && host->simplex_claimed != ap) {
                 xfer_mask &= ~(ATA_MASK_MWDMA | ATA_MASK_UDMA);
                 ata_dev_printk(dev, KERN_WARNING, "simplex DMA is claimed by "
                                "other device, disabling DMA\n");
@@ -4128,11 +4131,11 @@ static void ata_dev_xfermask(struct ata_device *dev)
          */
         if (xfer_mask & (0xF8 << ATA_SHIFT_UDMA))
                 /* UDMA/44 or higher would be available */
-                if((ap->cbl == ATA_CBL_PATA40) ||
-                    (ata_drive_40wire(dev->id) &&
-                     (ap->cbl == ATA_CBL_PATA_UNK ||
-                     ap->cbl == ATA_CBL_PATA80))) {
-                        ata_dev_printk(dev, KERN_WARNING,
+                if ((ap->cbl == ATA_CBL_PATA40) ||
+                    (ata_drive_40wire(dev->id) &&
+                    (ap->cbl == ATA_CBL_PATA_UNK ||
+                     ap->cbl == ATA_CBL_PATA80))) {
+                        ata_dev_printk(dev, KERN_WARNING,
                                  "limited to UDMA/33 due to 40-wire cable\n");
                         xfer_mask &= ~(0xF8 << ATA_SHIFT_UDMA);
                 }
@@ -4395,7 +4398,7 @@ static void ata_fill_sg_dumb(struct ata_queued_cmd *qc)
                 u32 addr, offset;
                 u32 sg_len, len, blen;
 
-                /* determine if physical DMA addr spans 64K boundary.
+                /* determine if physical DMA addr spans 64K boundary.
                  * Note h/w doesn't support 64-bit, so we unconditionally
                  * truncate dma_addr_t to u32.
                  */
@@ -4980,7 +4983,7 @@ next_sg:
                                        "%u bytes trailing data\n", bytes);
 
                 for (i = 0; i < words; i++)
-                        ap->ops->data_xfer(qc->dev, (unsigned char*)pad_buf, 2, do_write);
+                        ap->ops->data_xfer(qc->dev, (unsigned char *)pad_buf, 2, do_write);
 
                 ap->hsm_task_state = HSM_ST_LAST;
                 return;
@@ -5908,8 +5911,8 @@ unsigned int ata_qc_issue_prot(struct ata_queued_cmd *qc)
  *      One if interrupt was handled, zero if not (shared irq).
  */
 
-inline unsigned int ata_host_intr (struct ata_port *ap,
-                                   struct ata_queued_cmd *qc)
+inline unsigned int ata_host_intr(struct ata_port *ap,
+                                  struct ata_queued_cmd *qc)
 {
         struct ata_eh_info *ehi = &ap->link.eh_info;
         u8 status, host_stat = 0;
@@ -6009,7 +6012,7 @@ idle_irq:
  *      IRQ_NONE or IRQ_HANDLED.
  */
 
-irqreturn_t ata_interrupt (int irq, void *dev_instance)
+irqreturn_t ata_interrupt(int irq, void *dev_instance)
 {
         struct ata_host *host = dev_instance;
         unsigned int i;
@@ -6212,7 +6215,7 @@ int ata_flush_cache(struct ata_device *dev)
 
         /* This is wrong. On a failed flush we get back the LBA of the lost
            sector and we should (assuming it wasn't aborted as unknown) issue
-           a further flush command to continue the writeback until it 
+           a further flush command to continue the writeback until it
            does not error */
         err_mask = ata_do_simple_cmd(dev, cmd);
         if (err_mask) {
diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index 2eaa39fc65d0..93e2b545b439 100644
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -1197,7 +1197,7 @@ void ata_eh_done(struct ata_link *link, struct ata_device *dev,
  *      RETURNS:
  *      Descriptive string for @err_mask
  */
-static const char * ata_err_string(unsigned int err_mask)
+static const char *ata_err_string(unsigned int err_mask)
 {
         if (err_mask & AC_ERR_HOST_BUS)
                 return "host bus error";
@@ -1934,7 +1934,7 @@ static void ata_eh_link_report(struct ata_link *link)
                   ehc->i.serror & SERR_LINK_SEQ_ERR ? "LinkSeq " : "",
                   ehc->i.serror & SERR_TRANS_ST_ERROR ? "TrStaTrns " : "",
                   ehc->i.serror & SERR_UNRECOG_FIS ? "UnrecFIS " : "",
-                  ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : "" );
+                  ehc->i.serror & SERR_DEV_XCHG ? "DevExch " : "");
 
         for (tag = 0; tag < ATA_MAX_QUEUE; tag++) {
                 static const char *dma_str[] = {
@@ -1969,17 +1969,17 @@ static void ata_eh_link_report(struct ata_link *link)
                         qc->err_mask & AC_ERR_NCQ ? " <F>" : "");
 
                 if (res->command & (ATA_BUSY | ATA_DRDY | ATA_DF | ATA_DRQ |
-                                    ATA_ERR) ) {
+                                    ATA_ERR)) {
                         if (res->command & ATA_BUSY)
                                 ata_dev_printk(qc->dev, KERN_ERR,
-                                  "status: { Busy }\n" );
+                                  "status: { Busy }\n");
                         else
                                 ata_dev_printk(qc->dev, KERN_ERR,
                                   "status: { %s%s%s%s}\n",
                                   res->command & ATA_DRDY ? "DRDY " : "",
                                   res->command & ATA_DF ? "DF " : "",
                                   res->command & ATA_DRQ ? "DRQ " : "",
-                                  res->command & ATA_ERR ? "ERR " : "" );
+                                  res->command & ATA_ERR ? "ERR " : "");
                 }
 
                 if (cmd->command != ATA_CMD_PACKET &&
@@ -1990,7 +1990,7 @@ static void ata_eh_link_report(struct ata_link *link)
                           res->feature & ATA_ICRC ? "ICRC " : "",
                           res->feature & ATA_UNC ? "UNC " : "",
                           res->feature & ATA_IDNF ? "IDNF " : "",
-                          res->feature & ATA_ABORTED ? "ABRT " : "" );
+                          res->feature & ATA_ABORTED ? "ABRT " : "");
         }
 }
 
@@ -2611,7 +2611,7 @@ int ata_eh_recover(struct ata_port *ap, ata_prereset_fn_t prereset,
                 ehc->i.flags = 0;
                 continue;
 
-        dev_fail:
+dev_fail:
                 nr_failed_devs++;
                 if (ata_eh_handle_dev_fail(dev, rc))
                         nr_disabled_devs++;
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index 5b758b9ad0b8..f5d5420a1ba2 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -45,7 +45,7 @@
 #include <scsi/scsi_transport.h>
 #include <linux/libata.h>
 #include <linux/hdreg.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 
 #include "libata.h"
 
@@ -53,9 +53,9 @@
 
 typedef unsigned int (*ata_xlat_func_t)(struct ata_queued_cmd *qc);
 
-static struct ata_device * __ata_scsi_find_dev(struct ata_port *ap,
+static struct ata_device *__ata_scsi_find_dev(struct ata_port *ap,
                                         const struct scsi_device *scsidev);
-static struct ata_device * ata_scsi_find_dev(struct ata_port *ap,
+static struct ata_device *ata_scsi_find_dev(struct ata_port *ap,
                                             const struct scsi_device *scsidev);
 static int ata_scsi_user_scan(struct Scsi_Host *shost, unsigned int channel,
                               unsigned int id, unsigned int lun);
@@ -228,7 +228,7 @@ int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
 
                 scsi_cmd[1]  = (4 << 1); /* PIO Data-in */
                 scsi_cmd[2]  = 0x0e;     /* no off.line or cc, read from dev,
-                                            block count in sector count field */
+                                            block count in sector count field */
                 data_dir = DMA_FROM_DEVICE;
         } else {
                 scsi_cmd[1]  = (3 << 1); /* Non-data */
@@ -252,7 +252,7 @@ int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
         /* Good values for timeout and retries?  Values below
            from scsi_ioctl_send_command() for default case... */
         cmd_result = scsi_execute(scsidev, scsi_cmd, data_dir, argbuf, argsize,
-                                  sensebuf, (10*HZ), 5, 0);
+                                  sensebuf, (10*HZ), 5, 0);
 
         if (driver_byte(cmd_result) == DRIVER_SENSE) {/* sense data available */
                 u8 *desc = sensebuf + 8;
@@ -263,18 +263,18 @@ int ata_cmd_ioctl(struct scsi_device *scsidev, void __user *arg)
                 if (cmd_result & SAM_STAT_CHECK_CONDITION) {
                         struct scsi_sense_hdr sshdr;
                         scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE,
-                                              &sshdr);
-                        if (sshdr.sense_key==0 &&
-                            sshdr.asc==0 && sshdr.ascq==0)
+                                             &sshdr);
+                        if (sshdr.sense_key == 0 &&
+                            sshdr.asc == 0 && sshdr.ascq == 0)
                                 cmd_result &= ~SAM_STAT_CHECK_CONDITION;
                 }
 
                 /* Send userspace a few ATA registers (same as drivers/ide) */
-                if (sensebuf[0] == 0x72 &&     /* format is "descriptor" */
-                    desc[0] == 0x09 ) {        /* code is "ATA Descriptor" */
-                        args[0] = desc[13];    /* status */
-                        args[1] = desc[3];     /* error */
-                        args[2] = desc[5];     /* sector count (0:7) */
+                if (sensebuf[0] == 0x72 &&      /* format is "descriptor" */
+                    desc[0] == 0x09) {          /* code is "ATA Descriptor" */
+                        args[0] = desc[13];     /* status */
+                        args[1] = desc[3];      /* error */
+                        args[2] = desc[5];      /* sector count (0:7) */
                         if (copy_to_user(arg, args, sizeof(args)))
                                 rc = -EFAULT;
                 }
@@ -350,8 +350,8 @@ int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
                         struct scsi_sense_hdr sshdr;
                         scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE,
                                                 &sshdr);
-                        if (sshdr.sense_key==0 &&
-                                sshdr.asc==0 && sshdr.ascq==0)
+                        if (sshdr.sense_key == 0 &&
+                                sshdr.asc == 0 && sshdr.ascq == 0)
                                 cmd_result &= ~SAM_STAT_CHECK_CONDITION;
                 }
 
@@ -975,7 +975,7 @@ static unsigned int ata_scsi_start_stop_xlat(struct ata_queued_cmd *qc)
                 if ((qc->dev->flags & ATA_DFLAG_SPUNDOWN) &&
                     (system_state == SYSTEM_HALT ||
                      system_state == SYSTEM_POWER_OFF)) {
-                        static unsigned long warned = 0;
+                        static unsigned long warned;
 
                         if (!test_and_set_bit(0, &warned)) {
                                 ata_dev_printk(qc->dev, KERN_WARNING,
@@ -1364,7 +1364,7 @@ static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
         struct ata_eh_info *ehi = &qc->dev->link->eh_info;
         struct scsi_cmnd *cmd = qc->scsicmd;
         u8 *cdb = cmd->cmnd;
-        int need_sense = (qc->err_mask != 0);
+        int need_sense = (qc->err_mask != 0);
 
         /* We snoop the SET_FEATURES - Write Cache ON/OFF command, and
          * schedule EH_REVALIDATE operation to update the IDENTIFY DEVICE
@@ -1396,7 +1396,7 @@ static void ata_scsi_qc_complete(struct ata_queued_cmd *qc)
          * was no error, SK, ASC and ASCQ will all be zero.
          */
         if (((cdb[0] == ATA_16) || (cdb[0] == ATA_12)) &&
-            ((cdb[2] & 0x20) || need_sense)) {
+            ((cdb[2] & 0x20) || need_sense)) {
                 ata_gen_passthru_sense(qc);
         } else {
                 if (!need_sense) {
@@ -1500,7 +1500,7 @@ static int ata_scsi_translate(struct ata_device *dev, struct scsi_cmnd *cmd,
         return 0;
 
 early_finish:
-        ata_qc_free(qc);
+        ata_qc_free(qc);
         qc->scsidone(cmd);
         DPRINTK("EXIT - early finish (good or error)\n");
         return 0;
@@ -1590,8 +1590,8 @@ static inline void ata_scsi_rbuf_put(struct scsi_cmnd *cmd, u8 *buf)
  */
 
 void ata_scsi_rbuf_fill(struct ata_scsi_args *args,
-                        unsigned int (*actor) (struct ata_scsi_args *args,
-                                           u8 *rbuf, unsigned int buflen))
+                        unsigned int (*actor) (struct ata_scsi_args *args,
+                                               u8 *rbuf, unsigned int buflen))
 {
         u8 *rbuf;
         unsigned int buflen, rc;
@@ -2140,7 +2140,7 @@ saving_not_supp:
  *      None.
  */
 unsigned int ata_scsiop_read_cap(struct ata_scsi_args *args, u8 *rbuf,
-                                unsigned int buflen)
+                                 unsigned int buflen)
 {
         u64 last_lba = args->dev->n_sectors - 1; /* LBA of the last block */
 
@@ -2464,7 +2464,7 @@ static unsigned int atapi_xlat(struct ata_queued_cmd *qc)
         return 0;
 }
 
-static struct ata_device * ata_find_dev(struct ata_port *ap, int devno)
+static struct ata_device *ata_find_dev(struct ata_port *ap, int devno)
 {
         if (ap->nr_pmp_links == 0) {
                 if (likely(devno < ata_link_max_devices(&ap->link)))
@@ -2477,8 +2477,8 @@ static struct ata_device * ata_find_dev(struct ata_port *ap, int devno)
         return NULL;
 }
 
-static struct ata_device * __ata_scsi_find_dev(struct ata_port *ap,
-                                        const struct scsi_device *scsidev)
+static struct ata_device *__ata_scsi_find_dev(struct ata_port *ap,
+                                              const struct scsi_device *scsidev)
 {
         int devno;
 
@@ -2564,27 +2564,27 @@ static u8
 ata_scsi_map_proto(u8 byte1)
 {
         switch((byte1 & 0x1e) >> 1) {
-                case 3:         /* Non-data */
-                        return ATA_PROT_NODATA;
-
-                case 6:         /* DMA */
-                case 10:        /* UDMA Data-in */
-                case 11:        /* UDMA Data-Out */
-                        return ATA_PROT_DMA;
-
-                case 4:         /* PIO Data-in */
-                case 5:         /* PIO Data-out */
-                        return ATA_PROT_PIO;
-
-                case 0:         /* Hard Reset */
-                case 1:         /* SRST */
-                case 8:         /* Device Diagnostic */
-                case 9:         /* Device Reset */
-                case 7:         /* DMA Queued */
-                case 12:        /* FPDMA */
-                case 15:        /* Return Response Info */
-                default:        /* Reserved */
-                        break;
+        case 3:         /* Non-data */
+                return ATA_PROT_NODATA;
+
+        case 6:         /* DMA */
+        case 10:        /* UDMA Data-in */
+        case 11:        /* UDMA Data-Out */
+                return ATA_PROT_DMA;
+
+        case 4:         /* PIO Data-in */
+        case 5:         /* PIO Data-out */
+                return ATA_PROT_PIO;
+
+        case 0:         /* Hard Reset */
+        case 1:         /* SRST */
+        case 8:         /* Device Diagnostic */
+        case 9:         /* Device Reset */
+        case 7:         /* DMA Queued */
+        case 12:        /* FPDMA */
+        case 15:        /* Return Response Info */
+        default:        /* Reserved */
+                break;
         }
 
         return ATA_PROT_UNKNOWN;
@@ -2919,94 +2919,94 @@ void ata_scsi_simulate(struct ata_device *dev, struct scsi_cmnd *cmd,
         args.done = done;
 
         switch(scsicmd[0]) {
-                /* TODO: worth improving? */
-                case FORMAT_UNIT:
+        /* TODO: worth improving? */
+        case FORMAT_UNIT:
+                ata_scsi_invalid_field(cmd, done);
+                break;
+
+        case INQUIRY:
+                if (scsicmd[1] & 2)                /* is CmdDt set?  */
                         ata_scsi_invalid_field(cmd, done);
+                else if ((scsicmd[1] & 1) == 0)    /* is EVPD clear? */
+                        ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
+                else switch (scsicmd[2]) {
+                case 0x00:
+                        ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
                         break;
-
-                case INQUIRY:
-                        if (scsicmd[1] & 2)                /* is CmdDt set?  */
-                                ata_scsi_invalid_field(cmd, done);
-                        else if ((scsicmd[1] & 1) == 0)    /* is EVPD clear? */
-                                ata_scsi_rbuf_fill(&args, ata_scsiop_inq_std);
-                        else switch (scsicmd[2]) {
-                        case 0x00:
-                                ata_scsi_rbuf_fill(&args, ata_scsiop_inq_00);
-                                break;
-                        case 0x80:
-                                ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
-                                break;
-                        case 0x83:
-                                ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
-                                break;
-                        case 0x89:
-                                ata_scsi_rbuf_fill(&args, ata_scsiop_inq_89);
-                                break;
-                        default:
-                                ata_scsi_invalid_field(cmd, done);
-                                break;
-                        }
+                case 0x80:
+                        ata_scsi_rbuf_fill(&args, ata_scsiop_inq_80);
                         break;
-
-                case MODE_SENSE:
-                case MODE_SENSE_10:
-                        ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
+                case 0x83:
+                        ata_scsi_rbuf_fill(&args, ata_scsiop_inq_83);
                         break;
-
-                case MODE_SELECT:       /* unconditionally return */
-                case MODE_SELECT_10:    /* bad-field-in-cdb */
+                case 0x89:
+                        ata_scsi_rbuf_fill(&args, ata_scsiop_inq_89);
+                        break;
+                default:
                         ata_scsi_invalid_field(cmd, done);
                         break;
+                }
+                break;
+
+        case MODE_SENSE:
+        case MODE_SENSE_10:
+                ata_scsi_rbuf_fill(&args, ata_scsiop_mode_sense);
+                break;
 
-                case READ_CAPACITY:
+        case MODE_SELECT:       /* unconditionally return */
+        case MODE_SELECT_10:    /* bad-field-in-cdb */
+                ata_scsi_invalid_field(cmd, done);
+                break;
+
+        case READ_CAPACITY:
+                ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
+                break;
+
+        case SERVICE_ACTION_IN:
+                if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
                         ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
-                        break;
+                else
+                        ata_scsi_invalid_field(cmd, done);
+                break;
 
-                case SERVICE_ACTION_IN:
-                        if ((scsicmd[1] & 0x1f) == SAI_READ_CAPACITY_16)
-                                ata_scsi_rbuf_fill(&args, ata_scsiop_read_cap);
-                        else
-                                ata_scsi_invalid_field(cmd, done);
-                        break;
+        case REPORT_LUNS:
+                ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
+                break;
 
-                case REPORT_LUNS:
-                        ata_scsi_rbuf_fill(&args, ata_scsiop_report_luns);
-                        break;
+        case REQUEST_SENSE:
+                ata_scsi_set_sense(cmd, 0, 0, 0);
+                cmd->result = (DRIVER_SENSE << 24);
+                done(cmd);
+                break;
 
-                case REQUEST_SENSE:
-                        ata_scsi_set_sense(cmd, 0, 0, 0);
-                        cmd->result = (DRIVER_SENSE << 24);
-                        done(cmd);
-                        break;
+        /* if we reach this, then writeback caching is disabled,
+         * turning this into a no-op.
+         */
+        case SYNCHRONIZE_CACHE:
+                /* fall through */
+
+        /* no-op's, complete with success */
+        case REZERO_UNIT:
+        case SEEK_6:
+        case SEEK_10:
+        case TEST_UNIT_READY:
+                ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
+                break;
 
-                /* if we reach this, then writeback caching is disabled,
-                 * turning this into a no-op.
-                 */
-                case SYNCHRONIZE_CACHE:
-                        /* fall through */
-
-                /* no-op's, complete with success */
-                case REZERO_UNIT:
-                case SEEK_6:
-                case SEEK_10:
-                case TEST_UNIT_READY:
+        case SEND_DIAGNOSTIC:
+                tmp8 = scsicmd[1] & ~(1 << 3);
+                if ((tmp8 == 0x4) && (!scsicmd[3]) && (!scsicmd[4]))
                         ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
-                        break;
-
-                case SEND_DIAGNOSTIC:
-                        tmp8 = scsicmd[1] & ~(1 << 3);
-                        if ((tmp8 == 0x4) && (!scsicmd[3]) && (!scsicmd[4]))
-                                ata_scsi_rbuf_fill(&args, ata_scsiop_noop);
-                        else
-                                ata_scsi_invalid_field(cmd, done);
-                        break;
+                else
+                        ata_scsi_invalid_field(cmd, done);
+                break;
 
-                /* all other commands */
-                default:
-                        ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, 0x20, 0x0);
-                        /* "Invalid command operation code" */
-                        done(cmd);
-                        break;
+        /* all other commands */
+        default:
+                ata_scsi_set_sense(cmd, ILLEGAL_REQUEST, 0x20, 0x0);
+                /* "Invalid command operation code" */
+                done(cmd);
+                break;
         }
 }
 
diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index 8227c45109ec..48acc09dab96 100644
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -248,7 +248,7 @@ void ata_bmdma_setup(struct ata_queued_cmd *qc)
  *      LOCKING:
  *      spin_lock_irqsave(host lock)
  */
-void ata_bmdma_start (struct ata_queued_cmd *qc)
+void ata_bmdma_start(struct ata_queued_cmd *qc)
 {
         struct ata_port *ap = qc->ap;
         u8 dmactl;
diff --git a/drivers/ata/pata_ns87415.c b/drivers/ata/pata_ns87415.c
index bb97ef583f9b..b9a17eb100d0 100644
--- a/drivers/ata/pata_ns87415.c
+++ b/drivers/ata/pata_ns87415.c
@@ -17,7 +17,7 @@
  *    TODO:
  *      Test PARISC SuperIO
  *      Get someone to test on SPARC
- *      Implement lazy pio/dma switching for better performance 
+ *      Implement lazy pio/dma switching for better performance
  *      8bit shared timing.
  *      See if we need to kill the FIFO for ATAPI
  */
@@ -60,10 +60,10 @@ static void ns87415_set_mode(struct ata_port *ap, struct ata_device *adev, u8 mo
         u16 clocking;
         u8 iordy;
         u8 status;
-        
+
         /* Timing register format is 17 - low nybble read timing with
            the high nybble being 16 - x for recovery time in PCI clocks */
-   
+
         ata_timing_compute(adev, adev->pio_mode, &t, T, 0);
 
         clocking = 17 - FIT(t.active, 2, 17);
@@ -71,7 +71,7 @@ static void ns87415_set_mode(struct ata_port *ap, struct ata_device *adev, u8 mo
         /* Use the same timing for read and write bytes */
         clocking |= (clocking << 8);
         pci_write_config_word(dev, timing, clocking);
-        
+
         /* Set the IORDY enable versus DMA enable on or off properly */
         pci_read_config_byte(dev, 0x42, &iordy);
         iordy &= ~(1 << (4 + unit));
@@ -185,7 +185,7 @@ static void ns87415_bmdma_irq_clear(struct ata_port *ap)
 
         if (!mmio)
                 return;
-        iowrite8((ioread8(mmio + ATA_DMA_CMD) | ATA_DMA_INTR | ATA_DMA_ERR), 
+        iowrite8((ioread8(mmio + ATA_DMA_CMD) | ATA_DMA_INTR | ATA_DMA_ERR),
                         mmio + ATA_DMA_CMD);
 }
 
diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index 7f1b13e89cf7..b39648f0914b 100644
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -845,7 +845,7 @@ static int __mv_stop_dma(struct ata_port *ap)
                 pp->pp_flags &= ~MV_PP_FLAG_EDMA_EN;
         } else {
                 WARN_ON(EDMA_EN & readl(port_mmio + EDMA_CMD_OFS));
-        }
+        }
 
         /* now properly wait for the eDMA to stop */
         for (i = 1000; i > 0; i--) {
@@ -883,7 +883,7 @@ static void mv_dump_mem(void __iomem *start, unsigned bytes)
         for (b = 0; b < bytes; ) {
                 DPRINTK("%p: ", start + b);
                 for (w = 0; b < bytes && w < 4; w++) {
-                        printk("%08x ",readl(start + b));
+                        printk("%08x ", readl(start + b));
                         b += sizeof(u32);
                 }
                 printk("\n");
@@ -899,8 +899,8 @@ static void mv_dump_pci_cfg(struct pci_dev *pdev, unsigned bytes)
         for (b = 0; b < bytes; ) {
                 DPRINTK("%02x: ", b);
                 for (w = 0; b < bytes && w < 4; w++) {
-                        (void) pci_read_config_dword(pdev,b,&dw);
-                        printk("%08x ",dw);
+                        (void) pci_read_config_dword(pdev, b, &dw);
+                        printk("%08x ", dw);
                         b += sizeof(u32);
                 }
                 printk("\n");
@@ -944,9 +944,9 @@ static void mv_dump_all_regs(void __iomem *mmio_base, int port,
         }
         for (p = start_port; p < start_port + num_ports; p++) {
                 port_base = mv_port_base(mmio_base, p);
-                DPRINTK("EDMA regs (port %i):\n",p);
+                DPRINTK("EDMA regs (port %i):\n", p);
                 mv_dump_mem(port_base, 0x54);
-                DPRINTK("SATA regs (port %i):\n",p);
+                DPRINTK("SATA regs (port %i):\n", p);
                 mv_dump_mem(port_base+0x300, 0x60);
         }
 #endif
@@ -1184,7 +1184,7 @@ static void mv_qc_prep(struct ata_queued_cmd *qc)
         u16 flags = 0;
         unsigned in_index;
 
-        if (qc->tf.protocol != ATA_PROT_DMA)
+        if (qc->tf.protocol != ATA_PROT_DMA)
                 return;
 
         /* Fill in command request block
@@ -1276,7 +1276,7 @@ static void mv_qc_prep_iie(struct ata_queued_cmd *qc)
         unsigned in_index;
         u32 flags = 0;
 
-        if (qc->tf.protocol != ATA_PROT_DMA)
+        if (qc->tf.protocol != ATA_PROT_DMA)
                 return;
 
         /* Fill in Gen IIE command request block
@@ -1606,7 +1606,7 @@ static void mv_host_intr(struct ata_host *host, u32 relevant, unsigned int hc)
         writelfl(~hc_irq_cause, hc_mmio + HC_IRQ_CAUSE_OFS);
 
         VPRINTK("ENTER, hc%u relevant=0x%08x HC IRQ cause=0x%08x\n",
-                hc,relevant,hc_irq_cause);
+                hc, relevant, hc_irq_cause);
 
         for (port = port0; port < port0 + MV_PORTS_PER_HC; port++) {
                 struct ata_port *ap = host->ports[port];
@@ -1983,9 +1983,8 @@ static int mv6_reset_hc(struct mv_host_priv *hpriv, void __iomem *mmio,
         for (i = 0; i < 1000; i++) {
                 udelay(1);
                 t = readl(reg);
-                if (PCI_MASTER_EMPTY & t) {
+                if (PCI_MASTER_EMPTY & t)
                         break;
-                }
         }
         if (!(PCI_MASTER_EMPTY & t)) {
                 printk(KERN_ERR DRV_NAME ": PCI master won't flush\n");
@@ -2668,7 +2667,7 @@ static void mv_print_info(struct ata_host *host)
  */
 static int mv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
-        static int printed_version = 0;
+        static int printed_version;
         unsigned int board_idx = (unsigned int)ent->driver_data;
         const struct ata_port_info *ppi[] = { &mv_port_info[board_idx], NULL };
         struct ata_host *host;
diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index 240a8920d0bd..2e0279fdd7aa 100644
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -163,7 +163,7 @@ enum {
         NV_ADMA_STAT_STOPPED            = (1 << 10),
         NV_ADMA_STAT_DONE               = (1 << 12),
         NV_ADMA_STAT_ERR                = NV_ADMA_STAT_CPBERR |
-                                          NV_ADMA_STAT_TIMEOUT,
+                                          NV_ADMA_STAT_TIMEOUT,
 
         /* port flags */
         NV_ADMA_PORT_REGISTER_MODE      = (1 << 0),
@@ -228,7 +228,7 @@ struct nv_adma_cpb {
         u8                      reserved1;     /* 1 */
         u8                      ctl_flags;     /* 2 */
         /* len is length of taskfile in 64 bit words */
-        u8                      len;           /* 3  */
+        u8                      len;            /* 3  */
         u8                      tag;           /* 4 */
         u8                      next_cpb_idx;  /* 5 */
         __le16                  reserved2;     /* 6-7 */
@@ -244,9 +244,9 @@ struct nv_adma_port_priv {
         dma_addr_t              cpb_dma;
         struct nv_adma_prd      *aprd;
         dma_addr_t              aprd_dma;
-        void __iomem *          ctl_block;
-        void __iomem *          gen_block;
-        void __iomem *          notifier_clear_block;
+        void __iomem            *ctl_block;
+        void __iomem            *gen_block;
+        void __iomem            *notifier_clear_block;
         u8                      flags;
         int                     last_issue_ncq;
 };
@@ -293,7 +293,7 @@ struct nv_swncq_port_priv {
 
 #define NV_ADMA_CHECK_INTR(GCTL, PORT) ((GCTL) & ( 1 << (19 + (12 * (PORT)))))
 
-static int nv_init_one (struct pci_dev *pdev, const struct pci_device_id *ent);
+static int nv_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
 #ifdef CONFIG_PM
 static int nv_pci_device_resume(struct pci_dev *pdev);
 #endif
@@ -301,8 +301,8 @@ static void nv_ck804_host_stop(struct ata_host *host);
 static irqreturn_t nv_generic_interrupt(int irq, void *dev_instance);
 static irqreturn_t nv_nf2_interrupt(int irq, void *dev_instance);
 static irqreturn_t nv_ck804_interrupt(int irq, void *dev_instance);
-static int nv_scr_read (struct ata_port *ap, unsigned int sc_reg, u32 *val);
-static int nv_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
+static int nv_scr_read(struct ata_port *ap, unsigned int sc_reg, u32 *val);
+static int nv_scr_write(struct ata_port *ap, unsigned int sc_reg, u32 val);
 
 static void nv_nf2_freeze(struct ata_port *ap);
 static void nv_nf2_thaw(struct ata_port *ap);
@@ -653,12 +653,12 @@ static void nv_adma_register_mode(struct ata_port *ap)
                 return;
 
         status = readw(mmio + NV_ADMA_STAT);
-        while(!(status & NV_ADMA_STAT_IDLE) && count < 20) {
+        while (!(status & NV_ADMA_STAT_IDLE) && count < 20) {
                 ndelay(50);
                 status = readw(mmio + NV_ADMA_STAT);
                 count++;
         }
-        if(count == 20)
+        if (count == 20)
                 ata_port_printk(ap, KERN_WARNING,
                         "timeout waiting for ADMA IDLE, stat=0x%hx\n",
                         status);
@@ -668,12 +668,12 @@ static void nv_adma_register_mode(struct ata_port *ap)
 
         count = 0;
         status = readw(mmio + NV_ADMA_STAT);
-        while(!(status & NV_ADMA_STAT_LEGACY) && count < 20) {
+        while (!(status & NV_ADMA_STAT_LEGACY) && count < 20) {
                 ndelay(50);
                 status = readw(mmio + NV_ADMA_STAT);
                 count++;
         }
-        if(count == 20)
+        if (count == 20)
                 ata_port_printk(ap, KERN_WARNING,
                          "timeout waiting for ADMA LEGACY, stat=0x%hx\n",
                          status);
@@ -697,13 +697,13 @@ static void nv_adma_mode(struct ata_port *ap)
         writew(tmp | NV_ADMA_CTL_GO, mmio + NV_ADMA_CTL);
 
         status = readw(mmio + NV_ADMA_STAT);
-        while(((status & NV_ADMA_STAT_LEGACY) ||
+        while (((status & NV_ADMA_STAT_LEGACY) ||
               !(status & NV_ADMA_STAT_IDLE)) && count < 20) {
                 ndelay(50);
                 status = readw(mmio + NV_ADMA_STAT);
                 count++;
         }
-        if(count == 20)
+        if (count == 20)
                 ata_port_printk(ap, KERN_WARNING,
                         "timeout waiting for ADMA LEGACY clear and IDLE, stat=0x%hx\n",
                         status);
@@ -747,8 +747,7 @@ static int nv_adma_slave_config(struct scsi_device *sdev)
                    on the port. */
                 adma_enable = 0;
                 nv_adma_register_mode(ap);
-        }
-        else {
+        } else {
                 bounce_limit = *ap->dev->dma_mask;
                 segment_boundary = NV_ADMA_DMA_BOUNDARY;
                 sg_tablesize = NV_ADMA_SGTBL_TOTAL_LEN;
@@ -757,23 +756,22 @@ static int nv_adma_slave_config(struct scsi_device *sdev)
 
         pci_read_config_dword(pdev, NV_MCP_SATA_CFG_20, &current_reg);
 
-        if(ap->port_no == 1)
+        if (ap->port_no == 1)
                 config_mask = NV_MCP_SATA_CFG_20_PORT1_EN |
                               NV_MCP_SATA_CFG_20_PORT1_PWB_EN;
         else
                 config_mask = NV_MCP_SATA_CFG_20_PORT0_EN |
                               NV_MCP_SATA_CFG_20_PORT0_PWB_EN;
 
-        if(adma_enable) {
+        if (adma_enable) {
                 new_reg = current_reg | config_mask;
                 pp->flags &= ~NV_ADMA_ATAPI_SETUP_COMPLETE;
-        }
-        else {
+        } else {
                 new_reg = current_reg & ~config_mask;
                 pp->flags |= NV_ADMA_ATAPI_SETUP_COMPLETE;
         }
 
-        if(current_reg != new_reg)
+        if (current_reg != new_reg)
                 pci_write_config_dword(pdev, NV_MCP_SATA_CFG_20, new_reg);
 
         blk_queue_bounce_limit(sdev->request_queue, bounce_limit);
@@ -807,7 +805,7 @@ static unsigned int nv_adma_tf_to_cpb(struct ata_taskfile *tf, __le16 *cpb)
 {
         unsigned int idx = 0;
 
-        if(tf->flags & ATA_TFLAG_ISADDR) {
+        if (tf->flags & ATA_TFLAG_ISADDR) {
                 if (tf->flags & ATA_TFLAG_LBA48) {
                         cpb[idx++] = cpu_to_le16((ATA_REG_ERR   << 8) | tf->hob_feature | WNB);
                         cpb[idx++] = cpu_to_le16((ATA_REG_NSECT << 8) | tf->hob_nsect);
@@ -824,12 +822,12 @@ static unsigned int nv_adma_tf_to_cpb(struct ata_taskfile *tf, __le16 *cpb)
                 cpb[idx++] = cpu_to_le16((ATA_REG_LBAH   << 8) | tf->lbah);
         }
 
-        if(tf->flags & ATA_TFLAG_DEVICE)
+        if (tf->flags & ATA_TFLAG_DEVICE)
                 cpb[idx++] = cpu_to_le16((ATA_REG_DEVICE << 8) | tf->device);
 
         cpb[idx++] = cpu_to_le16((ATA_REG_CMD    << 8) | tf->command | CMDEND);
 
-        while(idx < 12)
+        while (idx < 12)
                 cpb[idx++] = cpu_to_le16(IGN);
 
         return idx;
@@ -850,7 +848,7 @@ static int nv_adma_check_cpb(struct ata_port *ap, int cpb_num, int force_err)
                 int freeze = 0;
 
                 ata_ehi_clear_desc(ehi);
-                __ata_ehi_push_desc(ehi, "CPB resp_flags 0x%x: ", flags );
+                __ata_ehi_push_desc(ehi, "CPB resp_flags 0x%x: ", flags);
                 if (flags & NV_CPB_RESP_ATA_ERR) {
                         ata_ehi_push_desc(ehi, "ATA error");
                         ehi->err_mask |= AC_ERR_DEV;
@@ -879,7 +877,7 @@ static int nv_adma_check_cpb(struct ata_port *ap, int cpb_num, int force_err)
                 struct ata_queued_cmd *qc = ata_qc_from_tag(ap, cpb_num);
                 VPRINTK("CPB flags done, flags=0x%x\n", flags);
                 if (likely(qc)) {
-                        DPRINTK("Completing qc from tag %d\n",cpb_num);
+                        DPRINTK("Completing qc from tag %d\n", cpb_num);
                         ata_qc_complete(qc);
                 } else {
                         struct ata_eh_info *ehi = &ap->link.eh_info;
@@ -952,7 +950,7 @@ static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
                         if (pp->flags & NV_ADMA_PORT_REGISTER_MODE) {
                                 u8 irq_stat = readb(host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804)
                                         >> (NV_INT_PORT_SHIFT * i);
-                                if(ata_tag_valid(ap->link.active_tag))
+                                if (ata_tag_valid(ap->link.active_tag))
                                         /** NV_INT_DEV indication seems unreliable at times
                                             at least in ADMA mode. Force it on always when a
                                             command is active, to prevent losing interrupts. */
@@ -966,7 +964,7 @@ static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
 
                         gen_ctl = readl(pp->gen_block + NV_ADMA_GEN_CTL);
 
-                        if( !NV_ADMA_CHECK_INTR(gen_ctl, ap->port_no) && !notifier &&
+                        if (!NV_ADMA_CHECK_INTR(gen_ctl, ap->port_no) && !notifier &&
                             !notifier_error)
                                 /* Nothing to do */
                                 continue;
@@ -990,7 +988,7 @@ static irqreturn_t nv_adma_interrupt(int irq, void *dev_instance)
                                 struct ata_eh_info *ehi = &ap->link.eh_info;
 
                                 ata_ehi_clear_desc(ehi);
-                                __ata_ehi_push_desc(ehi, "ADMA status 0x%08x: ", status );
+                                __ata_ehi_push_desc(ehi, "ADMA status 0x%08x: ", status);
                                 if (status & NV_ADMA_STAT_TIMEOUT) {
                                         ehi->err_mask |= AC_ERR_SYSTEM;
                                         ata_ehi_push_desc(ehi, "timeout");
@@ -1056,14 +1054,14 @@ static void nv_adma_freeze(struct ata_port *ap)
                 return;
 
         /* clear any outstanding CK804 notifications */
-        writeb( NV_INT_ALL << (ap->port_no * NV_INT_PORT_SHIFT),
+        writeb(NV_INT_ALL << (ap->port_no * NV_INT_PORT_SHIFT),
                 ap->host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804);
 
         /* Disable interrupt */
         tmp = readw(mmio + NV_ADMA_CTL);
-        writew( tmp & ~(NV_ADMA_CTL_AIEN | NV_ADMA_CTL_HOTPLUG_IEN),
+        writew(tmp & ~(NV_ADMA_CTL_AIEN | NV_ADMA_CTL_HOTPLUG_IEN),
                 mmio + NV_ADMA_CTL);
-        readw( mmio + NV_ADMA_CTL );    /* flush posted write */
+        readw(mmio + NV_ADMA_CTL );     /* flush posted write */
 }
 
 static void nv_adma_thaw(struct ata_port *ap)
@@ -1079,9 +1077,9 @@ static void nv_adma_thaw(struct ata_port *ap)
 
         /* Enable interrupt */
         tmp = readw(mmio + NV_ADMA_CTL);
-        writew( tmp | (NV_ADMA_CTL_AIEN | NV_ADMA_CTL_HOTPLUG_IEN),
+        writew(tmp | (NV_ADMA_CTL_AIEN | NV_ADMA_CTL_HOTPLUG_IEN),
                 mmio + NV_ADMA_CTL);
-        readw( mmio + NV_ADMA_CTL );    /* flush posted write */
+        readw(mmio + NV_ADMA_CTL );     /* flush posted write */
 }
 
 static void nv_adma_irq_clear(struct ata_port *ap)
@@ -1096,7 +1094,7 @@ static void nv_adma_irq_clear(struct ata_port *ap)
         }
 
         /* clear any outstanding CK804 notifications */
-        writeb( NV_INT_ALL << (ap->port_no * NV_INT_PORT_SHIFT),
+        writeb(NV_INT_ALL << (ap->port_no * NV_INT_PORT_SHIFT),
                 ap->host->iomap[NV_MMIO_BAR] + NV_INT_STATUS_CK804);
 
         /* clear ADMA status */
diff --git a/drivers/ata/sata_sx4.c b/drivers/ata/sata_sx4.c
index 9f9f7b30654a..b6026bceccd1 100644
--- a/drivers/ata/sata_sx4.c
+++ b/drivers/ata/sata_sx4.c
@@ -62,13 +62,13 @@
                 submit ATA packet to hardware
                 hardware executes ATA WRITE command, w/ data in DIMM
                 hardware raises interrupt
-        
+
         and each READ looks like this:
 
                 submit ATA packet to hardware
                 hardware executes ATA READ command, w/ data in DIMM
                 hardware raises interrupt
-        
+
                 submit HDMA packet to hardware
                 hardware copies data from DIMM to system memory
                 hardware raises interrupt
diff --git a/drivers/fc4/Kconfig b/drivers/fc4/Kconfig
deleted file mode 100644
index 345dbe6f10df..000000000000
--- a/drivers/fc4/Kconfig
+++ /dev/null
@@ -1,81 +0,0 @@
-#
-# FC4 device configuration
-#
-
-menu "Fibre Channel support"
-
-config FC4
-        tristate "Fibre Channel and FC4 SCSI support"
-        ---help---
-          Fibre Channel is a high speed serial protocol mainly used to
-          connect large storage devices to the computer; it is compatible with
-          and intended to replace SCSI.
-
-          This is an experimental support for storage arrays connected to your
-          computer using optical fibre cables and the "X3.269-199X Fibre
-          Channel Protocol for SCSI" specification. If you want to use this,
-          you need to say Y here and to "SCSI support" as well as to the
-          drivers for the storage array itself and for the interface adapter
-          such as SOC or SOC+. This subsystem could even serve for IP
-          networking, with some code extensions.
-
-          If unsure, say N.
-
-comment "FC4 drivers"
-        depends on FC4
-
-config FC4_SOC
-        tristate "Sun SOC/Sbus"
-        depends on FC4!=n && SPARC
-        help
-          Serial Optical Channel is an interface card with one or two Fibre
-          Optic ports, each of which can be connected to a disk array. Note
-          that if you have older firmware in the card, you'll need the
-          microcode from the Solaris driver to make it work.
-
-          To compile this support as a module, choose M here: the module will
-          be called soc.
-
-config FC4_SOCAL
-        tristate "Sun SOC+ (aka SOCAL)"
-        depends on FC4!=n && SPARC
-        ---help---
-          Serial Optical Channel Plus is an interface card with up to two
-          Fibre Optic ports. This card supports FC Arbitrated Loop (usually
-          A5000 or internal FC disks in E[3-6]000 machines through the
-          Interface Board). You'll probably need the microcode from the
-          Solaris driver to make it work.
-
-          To compile this support as a module, choose M here: the module will
-          be called socal.
-
-comment "FC4 targets"
-        depends on FC4
-
-config SCSI_PLUTO
-        tristate "SparcSTORAGE Array 100 and 200 series"
-        depends on FC4!=n && SCSI
-        help
-          If you never bought a disk array made by Sun, go with N.
-
-          To compile this support as a module, choose M here: the module will
-          be called pluto.
-
-config SCSI_FCAL
-        tristate "Sun Enterprise Network Array (A5000 and EX500)" if SPARC
-        depends on FC4!=n && SCSI
-        help
-          This driver drives FC-AL disks connected through a Fibre Channel
-          card using the drivers/fc4 layer (currently only SOCAL). The most
-          common is either A5000 array or internal disks in E[3-6]000
-          machines.
-
-          To compile this support as a module, choose M here: the module will
-          be called fcal.
-
-config SCSI_FCAL
-        prompt "Generic FC-AL disk driver"
-        depends on FC4!=n && SCSI && !SPARC
-
-endmenu
-
diff --git a/drivers/fc4/Makefile b/drivers/fc4/Makefile
deleted file mode 100644
index 0db3fbb553e9..000000000000
--- a/drivers/fc4/Makefile
+++ /dev/null
@@ -1,9 +0,0 @@
-#
-# Makefile for the Linux Fibre Channel device drivers.
-#
-
-fc4-objs := fc.o fc_syms.o
-
-obj-$(CONFIG_FC4) += fc4.o
-obj-$(CONFIG_FC4_SOC) += soc.o
-obj-$(CONFIG_FC4_SOCAL) += socal.o
diff --git a/drivers/fc4/fc-al.h b/drivers/fc4/fc-al.h
deleted file mode 100644
index 62d3ca436d72..000000000000
--- a/drivers/fc4/fc-al.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/* fc-al.h: Definitions for Fibre Channel Arbitrated Loop topology.
- *
- * Copyright (C) 1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
- *
- * Sources:
- *      Fibre Channel Arbitrated Loop (FC-AL), ANSI, Rev. 4.5, 1995
- */
-
-#ifndef __FC_AL_H
-#define __FC_AL_H
-
-/* Loop initialization payloads */
-#define FC_AL_LISM      0x11010000      /* Select Master, 12B payload */
-#define FC_AL_LIFA      0x11020000      /* Fabric Assign AL_PA bitmap, 20B payload */
-#define FC_AL_LIPA      0x11030000      /* Previously Acquired AL_PA bitmap, 20B payload */
-#define FC_AL_LIHA      0x11040000      /* Hard Assigned AL_PA bitmap, 20B payload */
-#define FC_AL_LISA      0x11050000      /* Soft Assigned AL_PA bitmap, 20B payload */
-#define FC_AL_LIRP      0x11060000      /* Report AL_PA position map, 132B payload */
-#define FC_AL_LILP      0x11070000      /* Loop AL_PA position map, 132B payload */
-
-typedef struct {
-        u32     magic;
-        u8      len;
-        u8      alpa[127];
-} fc_al_posmap;
-
-#endif /* !(__FC_H) */
diff --git a/drivers/fc4/fc.c b/drivers/fc4/fc.c
deleted file mode 100644
index 82de9e1adb1e..000000000000
--- a/drivers/fc4/fc.c
+++ /dev/null
@@ -1,1146 +0,0 @@
-/* fc.c: Generic Fibre Channel and FC4 SCSI driver.
- *
- * Copyright (C) 1997,1998,1999 Jakub Jelinek (jj@ultra.linux.cz)
- * Copyright (C) 1997,1998 Jirka Hanika (geo@ff.cuni.cz)
- *
- * There are two kinds of Fibre Channel adapters used in Linux. Either
- * the adapter is "smart" and does all FC bookkeeping by itself and
- * just presents a standard SCSI interface to the operating system
- * (that's e.g. the case with Qlogic FC cards), or leaves most of the FC
- * bookkeeping to the OS (e.g. soc, socal). Drivers for the former adapters
- * will look like normal SCSI drivers (with the exception of max_id will be
- * usually 127), the latter on the other side allows SCSI, IP over FC and other
- * protocols. This driver tree is for the latter adapters.
- *
- * This file should support both Point-to-Point and Arbitrated Loop topologies.
- *
- * Sources:
- *      Fibre Channel Physical & Signaling Interface (FC-PH), dpANS, 1994
- *      dpANS Fibre Channel Protocol for SCSI (X3.269-199X), Rev. 012, 1995
- *      Fibre Channel Arbitrated Loop (FC-AL), Rev. 4.5, 1995
- *      Fibre Channel Private Loop SCSI Direct Attach (FC-PLDA), Rev. 2.1, 1997
- */
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/jiffies.h>
-#include <linux/types.h>
-#include <linux/fcntl.h>
-#include <linux/interrupt.h>
-#include <linux/ptrace.h>
-#include <linux/ioport.h>
-#include <linux/in.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/init.h>
-
-#include <asm/pgtable.h>
-#include <asm/irq.h>
-#include <asm/semaphore.h>
-#include "fcp_impl.h"
-#include <scsi/scsi_host.h>
-
-/* #define FCDEBUG */
-
-#define fc_printk printk ("%s: ", fc->name); printk 
-
-#ifdef FCDEBUG
-#define FCD(x)  fc_printk x;
-#define FCND(x) printk ("FC: "); printk x;
-#else
-#define FCD(x)
-#define FCND(x)
-#endif
-
-#ifdef __sparc__
-#define dma_alloc_consistent(d,s,p) sbus_alloc_consistent(d,s,p)
-#define dma_free_consistent(d,s,v,h) sbus_free_consistent(d,s,v,h)
-#define dma_map_single(d,v,s,dir) sbus_map_single(d,v,s,dir)
-#define dma_unmap_single(d,h,s,dir) sbus_unmap_single(d,h,s,dir)
-#define dma_map_sg(d,s,n,dir) sbus_map_sg(d,s,n,dir)
-#define dma_unmap_sg(d,s,n,dir) sbus_unmap_sg(d,s,n,dir)
-#else
-#define dma_alloc_consistent(d,s,p) pci_alloc_consistent(d,s,p)
-#define dma_free_consistent(d,s,v,h) pci_free_consistent(d,s,v,h)
-#define dma_map_single(d,v,s,dir) pci_map_single(d,v,s,dir)
-#define dma_unmap_single(d,h,s,dir) pci_unmap_single(d,h,s,dir)
-#define dma_map_sg(d,s,n,dir) pci_map_sg(d,s,n,dir)
-#define dma_unmap_sg(d,s,n,dir) pci_unmap_sg(d,s,n,dir)
-#endif                                                         
-
-#define FCP_CMND(SCpnt) ((fcp_cmnd *)&(SCpnt->SCp))
-#define FC_SCMND(SCpnt) ((fc_channel *)(SCpnt->device->host->hostdata[0]))
-#define SC_FCMND(fcmnd) ((struct scsi_cmnd *)((long)fcmnd - (long)&(((struct scsi_cmnd *)0)->SCp)))
-
-static int fcp_scsi_queue_it(fc_channel *, struct scsi_cmnd *, fcp_cmnd *, int);
-void fcp_queue_empty(fc_channel *);
-
-static void fcp_scsi_insert_queue (fc_channel *fc, fcp_cmnd *fcmd)
-{
-        if (!fc->scsi_que) {
-                fc->scsi_que = fcmd;
-                fcmd->next = fcmd;
-                fcmd->prev = fcmd;
-        } else {
-                fc->scsi_que->prev->next = fcmd;
-                fcmd->prev = fc->scsi_que->prev;
-                fc->scsi_que->prev = fcmd;
-                fcmd->next = fc->scsi_que;
-        }
-}
-
-static void fcp_scsi_remove_queue (fc_channel *fc, fcp_cmnd *fcmd)
-{
-        if (fcmd == fcmd->next) {
-                fc->scsi_que = NULL;
-                return;
-        }
-        if (fcmd == fc->scsi_que)
-                fc->scsi_que = fcmd->next;
-        fcmd->prev->next = fcmd->next;
-        fcmd->next->prev = fcmd->prev;
-}
-
-fc_channel *fc_channels = NULL;
-
-#define LSMAGIC 620829043
-typedef struct {
-        /* Must be first */
-        struct semaphore sem;
-        int magic;
-        int count;
-        logi *logi;
-        fcp_cmnd *fcmds;
-        atomic_t todo;
-        struct timer_list timer;
-        unsigned char grace[0];
-} ls;
-
-#define LSOMAGIC 654907799
-typedef struct {
-        /* Must be first */
-        struct semaphore sem;
-        int magic;
-        int count;
-        fcp_cmnd *fcmds;
-        atomic_t todo;
-        struct timer_list timer;
-} lso;
-
-#define LSEMAGIC 84482456
-typedef struct {
-        /* Must be first */
-        struct semaphore sem;
-        int magic;
-        int status;
-        struct timer_list timer;
-} lse;
-
-static void fcp_login_timeout(unsigned long data)
-{
-        ls *l = (ls *)data;
-        FCND(("Login timeout\n"))
-        up(&l->sem);
-}
-
-static void fcp_login_done(fc_channel *fc, int i, int status)
-{
-        fcp_cmnd *fcmd;
-        logi *plogi;
-        fc_hdr *fch;
-        ls *l = (ls *)fc->ls;
-        
-        FCD(("Login done %d %d\n", i, status))
-        if (i < l->count) {
-                if (fc->state == FC_STATE_FPORT_OK) {
-                        FCD(("Additional FPORT_OK received with status %d\n", status))
-                        return;
-                }
-                switch (status) {
-                case FC_STATUS_OK: /* Oh, we found a fabric */
-                case FC_STATUS_P_RJT: /* Oh, we haven't found any */
-                        fc->state = FC_STATE_FPORT_OK;
-                        fcmd = l->fcmds + i;
-                        plogi = l->logi + 3 * i;
-                        dma_unmap_single (fc->dev, fcmd->cmd, 3 * sizeof(logi),
-                                          DMA_BIDIRECTIONAL);
-                        plogi->code = LS_PLOGI;
-                        memcpy (&plogi->nport_wwn, &fc->wwn_nport, sizeof(fc_wwn));
-                        memcpy (&plogi->node_wwn, &fc->wwn_node, sizeof(fc_wwn));
-                        memcpy (&plogi->common, fc->common_svc, sizeof(common_svc_parm));
-                        memcpy (&plogi->class1, fc->class_svcs, 3*sizeof(svc_parm));
-                        fch = &fcmd->fch;
-                        fcmd->token += l->count;
-                        FILL_FCHDR_RCTL_DID(fch, R_CTL_ELS_REQ, fc->did);
-                        FILL_FCHDR_SID(fch, fc->sid);
-#ifdef FCDEBUG
-                        {
-                                int i;
-                                unsigned *x = (unsigned *)plogi;
-                                printk ("logi: ");
-                                for (i = 0; i < 21; i++)
-                                        printk ("%08x ", x[i]);
-                                printk ("\n");
-                        }
-#endif                  
-                        fcmd->cmd = dma_map_single (fc->dev, plogi, 3 * sizeof(logi),
-                                                    DMA_BIDIRECTIONAL);
-                        fcmd->rsp = fcmd->cmd + 2 * sizeof(logi);
-                        if (fc->hw_enque (fc, fcmd))
-                                printk ("FC: Cannot enque PLOGI packet on %s\n", fc->name);
-                        break;
-                case FC_STATUS_ERR_OFFLINE:
-                        fc->state = FC_STATE_MAYBEOFFLINE;
-                        FCD (("FC is offline %d\n", l->grace[i]))
-                        break;
-                default:
-                        printk ("FLOGI failed for %s with status %d\n", fc->name, status);
-                        /* Do some sort of error recovery here */
-                        break;
-                }
-        } else {
-                i -= l->count;
-                if (fc->state != FC_STATE_FPORT_OK) {
-                        FCD(("Unexpected N-PORT rsp received"))
-                        return;
-                }
-                switch (status) {
-                case FC_STATUS_OK:
-                        plogi = l->logi + 3 * i;
-                        dma_unmap_single (fc->dev, l->fcmds[i].cmd, 3 * sizeof(logi),
-                                          DMA_BIDIRECTIONAL);
-                        if (!fc->wwn_dest.lo && !fc->wwn_dest.hi) {
-                                memcpy (&fc->wwn_dest, &plogi[1].node_wwn, sizeof(fc_wwn)); 
-                                FCD(("Dest WWN %08x%08x\n", *(u32 *)&fc->wwn_dest, fc->wwn_dest.lo))
-                        } else if (fc->wwn_dest.lo != plogi[1].node_wwn.lo ||
-                                   fc->wwn_dest.hi != plogi[1].node_wwn.hi) {
-                                printk ("%s: mismatch in wwns. Got %08x%08x, expected %08x%08x\n",
-                                        fc->name,
-                                        *(u32 *)&plogi[1].node_wwn, plogi[1].node_wwn.lo,
-                                        *(u32 *)&fc->wwn_dest, fc->wwn_dest.lo);
-                        }
-                        fc->state = FC_STATE_ONLINE;
-                        printk ("%s: ONLINE\n", fc->name);
-                        if (atomic_dec_and_test (&l->todo))
-                                up(&l->sem);
-                        break;
-                case FC_STATUS_ERR_OFFLINE:
-                        fc->state = FC_STATE_OFFLINE;
-                        dma_unmap_single (fc->dev, l->fcmds[i].cmd, 3 * sizeof(logi),
-                                          DMA_BIDIRECTIONAL);
-                        printk ("%s: FC is offline\n", fc->name);
-                        if (atomic_dec_and_test (&l->todo))
-                                up(&l->sem);
-                        break;
-                default:
-                        printk ("PLOGI failed for %s with status %d\n", fc->name, status);
-                        /* Do some sort of error recovery here */
-                        break;
-                }
-        }
-}
-
-static void fcp_report_map_done(fc_channel *fc, int i, int status)
-{
-        fcp_cmnd *fcmd;
-        fc_hdr *fch;
-        unsigned char j;
-        ls *l = (ls *)fc->ls;
-        fc_al_posmap *p;
-        
-        FCD(("Report map done %d %d\n", i, status))
-        switch (status) {
-        case FC_STATUS_OK: /* Ok, let's have a fun on a loop */
-                dma_unmap_single (fc->dev, l->fcmds[i].cmd, 3 * sizeof(logi),
-                                  DMA_BIDIRECTIONAL);
-                p = (fc_al_posmap *)(l->logi + 3 * i);
-#ifdef FCDEBUG
-                {
-                u32 *u = (u32 *)p;
-                FCD(("%08x\n", u[0]))
-                u ++;
-                FCD(("%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x\n", u[0],u[1],u[2],u[3],u[4],u[5],u[6],u[7]))
-                }
-#endif          
-                if ((p->magic & 0xffff0000) != FC_AL_LILP || !p->len) {
-                        printk ("FC: Bad magic from REPORT_AL_MAP on %s - %08x\n", fc->name, p->magic);
-                        fc->state = FC_STATE_OFFLINE;
-                } else {
-                        fc->posmap = kzalloc(sizeof(fcp_posmap)+p->len, GFP_KERNEL);
-                        if (!fc->posmap) {
-                                printk("FC: Not enough memory, offlining channel\n");
-                                fc->state = FC_STATE_OFFLINE;
-                        } else {
-                                int k;
-                                /* FIXME: This is where SOCAL transfers our AL-PA.
-                                   Keep it here till we found out what other cards do... */
-                                fc->sid = (p->magic & 0xff);
-                                for (i = 0; i < p->len; i++)
-                                        if (p->alpa[i] == fc->sid)
-                                                break;
-                                k = p->len;
-                                if (i == p->len)
-                                        i = 0;
-                                else {
-                                        p->len--;
-                                        i++;
-                                }
-                                fc->posmap->len = p->len;
-                                for (j = 0; j < p->len; j++) {
-                                        if (i == k) i = 0;
-                                        fc->posmap->list[j] = p->alpa[i++];
-                                }
-                                fc->state = FC_STATE_ONLINE;
-                        }
-                }
-                printk ("%s: ONLINE\n", fc->name);
-                if (atomic_dec_and_test (&l->todo))
-                        up(&l->sem);
-                break;
-        case FC_STATUS_POINTTOPOINT: /* We're Point-to-Point, no AL... */
-                FCD(("SID %d DID %d\n", fc->sid, fc->did))
-                fcmd = l->fcmds + i;
-                dma_unmap_single(fc->dev, fcmd->cmd, 3 * sizeof(logi),
-                                 DMA_BIDIRECTIONAL);
-                fch = &fcmd->fch;
-                memset(l->logi + 3 * i, 0, 3 * sizeof(logi));
-                FILL_FCHDR_RCTL_DID(fch, R_CTL_ELS_REQ, FS_FABRIC_F_PORT);
-                FILL_FCHDR_SID(fch, 0);
-                FILL_FCHDR_TYPE_FCTL(fch, TYPE_EXTENDED_LS, F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE);
-                FILL_FCHDR_SEQ_DF_SEQ(fch, 0, 0, 0);
-                FILL_FCHDR_OXRX(fch, 0xffff, 0xffff);
-                fch->param = 0;
-                l->logi [3 * i].code = LS_FLOGI;
-                fcmd->cmd = dma_map_single (fc->dev, l->logi + 3 * i, 3 * sizeof(logi),
-                                            DMA_BIDIRECTIONAL);
-                fcmd->rsp = fcmd->cmd + sizeof(logi);
-                fcmd->cmdlen = sizeof(logi);
-                fcmd->rsplen = sizeof(logi);
-                fcmd->data = (dma_addr_t)NULL;
-                fcmd->class = FC_CLASS_SIMPLE;
-                fcmd->proto = TYPE_EXTENDED_LS;
-                if (fc->hw_enque (fc, fcmd))
-                        printk ("FC: Cannot enque FLOGI packet on %s\n", fc->name);
-                break;
-        case FC_STATUS_ERR_OFFLINE:
-                fc->state = FC_STATE_MAYBEOFFLINE;
-                FCD (("FC is offline %d\n", l->grace[i]))
-                break;
-        default:
-                printk ("FLOGI failed for %s with status %d\n", fc->name, status);
-                /* Do some sort of error recovery here */
-                break;
-        }
-}
-
-void fcp_register(fc_channel *fc, u8 type, int unregister)
-{
-        int size, i;
-        int slots = (fc->can_queue * 3) >> 1;
-
-        FCND(("Going to %sregister\n", unregister ? "un" : ""))
-
-        if (type == TYPE_SCSI_FCP) {
-                if (!unregister) {
-                        fc->scsi_cmd_pool = (fcp_cmd *)
-                                dma_alloc_consistent (fc->dev,
-                                                      slots * (sizeof (fcp_cmd) + fc->rsp_size),
-                                                      &fc->dma_scsi_cmd);
-                        fc->scsi_rsp_pool = (char *)(fc->scsi_cmd_pool + slots);
-                        fc->dma_scsi_rsp = fc->dma_scsi_cmd + slots * sizeof (fcp_cmd);
-                        fc->scsi_bitmap_end = (slots + 63) & ~63;
-                        size = fc->scsi_bitmap_end / 8;
-                        fc->scsi_bitmap = kzalloc (size, GFP_KERNEL);
-                        set_bit (0, fc->scsi_bitmap);
-                        for (i = fc->can_queue; i < fc->scsi_bitmap_end; i++)
-                                set_bit (i, fc->scsi_bitmap);
-                        fc->scsi_free = fc->can_queue;
-                        fc->cmd_slots = kzalloc(slots * sizeof(fcp_cmnd*), GFP_KERNEL);
-                        fc->abort_count = 0;
-                } else {
-                        fc->scsi_name[0] = 0;
-                        kfree (fc->scsi_bitmap);
-                        kfree (fc->cmd_slots);
-                        FCND(("Unregistering\n"));
-#if 0
-                        if (fc->rst_pkt) {
-                                if (fc->rst_pkt->eh_state == SCSI_STATE_UNUSED)
-                                        kfree(fc->rst_pkt);
-                                else {
-                                        /* Can't happen. Some memory would be lost. */
-                                        printk("FC: Reset in progress. Now?!");
-                                }
-                        }
-#endif
-                        FCND(("Unregistered\n"));
-                }
-        } else
-                printk ("FC: %segistering unknown type %02x\n", unregister ? "Unr" : "R", type);
-}
-
-static void fcp_scsi_done(struct scsi_cmnd *SCpnt);
-
-static inline void fcp_scsi_receive(fc_channel *fc, int token, int status, fc_hdr *fch)
-{
-        fcp_cmnd *fcmd;
-        fcp_rsp  *rsp;
-        int host_status;
-        struct scsi_cmnd *SCpnt;
-        int sense_len;
-        int rsp_status;
-
-        fcmd = fc->cmd_slots[token];
-        if (!fcmd) return;
-        rsp = (fcp_rsp *) (fc->scsi_rsp_pool + fc->rsp_size * token);
-        SCpnt = SC_FCMND(fcmd);
-
-        if (SCpnt->done != fcp_scsi_done)
-                return;
-
-        rsp_status = rsp->fcp_status;
-        FCD(("rsp_status %08x status %08x\n", rsp_status, status))
-        switch (status) {
-        case FC_STATUS_OK:
-                host_status=DID_OK;
-                
-                if (rsp_status & FCP_STATUS_RESID) {
-#ifdef FCDEBUG
-                        FCD(("Resid %d\n", rsp->fcp_resid))
-                        {
-                                fcp_cmd *cmd = fc->scsi_cmd_pool + token;
-                                int i;
-                                
-                                printk ("Command ");
-                                for (i = 0; i < sizeof(fcp_cmd); i+=4)
-                                        printk ("%08x ", *(u32 *)(((char *)cmd)+i));
-                                printk ("\nResponse ");
-                                for (i = 0; i < fc->rsp_size; i+=4)
-                                        printk ("%08x ", *(u32 *)(((char *)rsp)+i));
-                                printk ("\n");
-                        }
-#endif                  
-                }
-
-                if (rsp_status & FCP_STATUS_SENSE_LEN) {
-                        sense_len = rsp->fcp_sense_len;
-                        if (sense_len > sizeof(SCpnt->sense_buffer)) sense_len = sizeof(SCpnt->sense_buffer);
-                        memcpy(SCpnt->sense_buffer, ((char *)(rsp+1)), sense_len);
-                }
-                
-                if (fcmd->data)
-                        dma_unmap_sg(fc->dev, scsi_sglist(SCpnt),
-                                     scsi_sg_count(SCpnt),
-                                     SCpnt->sc_data_direction);
-                break;
-        default:
-                host_status=DID_ERROR; /* FIXME */
-                FCD(("Wrong FC status %d for token %d\n", status, token))
-                break;
-        }
-
-        if (status_byte(rsp_status) == QUEUE_FULL) {
-                printk ("%s: (%d,%d) Received rsp_status 0x%x\n", fc->name, SCpnt->device->channel, SCpnt->device->id, rsp_status);
-        }       
-        
-        SCpnt->result = (host_status << 16) | (rsp_status & 0xff);
-#ifdef FCDEBUG  
-        if (host_status || SCpnt->result || rsp_status) printk("FC: host_status %d, packet status %d\n",
-                        host_status, SCpnt->result);
-#endif
-        SCpnt->done = fcmd->done;
-        fcmd->done=NULL;
-        clear_bit(token, fc->scsi_bitmap);
-        fc->scsi_free++;
-        FCD(("Calling scsi_done with %08x\n", SCpnt->result))
-        SCpnt->scsi_done(SCpnt);
-}
-
-void fcp_receive_solicited(fc_channel *fc, int proto, int token, int status, fc_hdr *fch)
-{
-        int magic;
-        FCD(("receive_solicited %d %d %d\n", proto, token, status))
-        switch (proto) {
-        case TYPE_SCSI_FCP:
-                fcp_scsi_receive(fc, token, status, fch); break;
-        case TYPE_EXTENDED_LS:
-        case PROTO_REPORT_AL_MAP:
-                magic = 0;
-                if (fc->ls)
-                        magic = ((ls *)(fc->ls))->magic;
-                if (magic == LSMAGIC) {
-                        ls *l = (ls *)fc->ls;
-                        int i = (token >= l->count) ? token - l->count : token;
-
-                        /* Let's be sure */
-                        if ((unsigned)i < l->count && l->fcmds[i].fc == fc) {
-                                if (proto == TYPE_EXTENDED_LS)
-                                        fcp_login_done(fc, token, status);
-                                else
-                                        fcp_report_map_done(fc, token, status);
-                                break;
-                        }
-                }
-                FCD(("fc %p fc->ls %p fc->cmd_slots %p\n", fc, fc->ls, fc->cmd_slots))
-                if (proto == TYPE_EXTENDED_LS && !fc->ls && fc->cmd_slots) {
-                        fcp_cmnd *fcmd;
-                        
-                        fcmd = fc->cmd_slots[token];
-                        if (fcmd && fcmd->ls && ((ls *)(fcmd->ls))->magic == LSEMAGIC) {
-                                lse *l = (lse *)fcmd->ls;
-                                
-                                l->status = status;
-                                up (&l->sem);
-                        }
-                }
-                break;
-        case PROTO_OFFLINE:
-                if (fc->ls && ((lso *)(fc->ls))->magic == LSOMAGIC) {
-                        lso *l = (lso *)fc->ls;
-
-                        if ((unsigned)token < l->count && l->fcmds[token].fc == fc) {
-                                /* Wow, OFFLINE response arrived :) */
-                                FCD(("OFFLINE Response arrived\n"))
-                                fc->state = FC_STATE_OFFLINE;
-                                if (atomic_dec_and_test (&l->todo))
-                                        up(&l->sem);
-                        }
-                }
-                break;
-                
-        default:
-                break;
-        }
-}
-
-void fcp_state_change(fc_channel *fc, int state)
-{
-        FCD(("state_change %d %d\n", state, fc->state))
-        if (state == FC_STATE_ONLINE && fc->state == FC_STATE_MAYBEOFFLINE)
-                fc->state = FC_STATE_UNINITED;
-        else if (state == FC_STATE_ONLINE)
-                printk (KERN_WARNING "%s: state change to ONLINE\n", fc->name);
-        else
-                printk (KERN_ERR "%s: state change to OFFLINE\n", fc->name);
-}
-
-int fcp_initialize(fc_channel *fcchain, int count)
-{
-        fc_channel *fc;
-        fcp_cmnd *fcmd;
-        int i, retry, ret;
-        ls *l;
-
-        FCND(("fcp_inititialize %08lx\n", (long)fcp_init))
-        FCND(("fc_channels %08lx\n", (long)fc_channels))
-        FCND((" SID %d DID %d\n", fcchain->sid, fcchain->did))
-        l = kzalloc(sizeof (ls) + count, GFP_KERNEL);
-        if (!l) {
-                printk ("FC: Cannot allocate memory for initialization\n");
-                return -ENOMEM;
-        }
-        l->magic = LSMAGIC;
-        l->count = count;
-        FCND(("FCP Init for %d channels\n", count))
-        init_MUTEX_LOCKED(&l->sem);
-        init_timer(&l->timer);
-        l->timer.function = fcp_login_timeout;
-        l->timer.data = (unsigned long)l;
-        atomic_set (&l->todo, count);
-        l->logi = kzalloc (count * 3 * sizeof(logi), GFP_KERNEL);
-        l->fcmds = kzalloc (count * sizeof(fcp_cmnd), GFP_KERNEL);
-        if (!l->logi || !l->fcmds) {
-                kfree (l->logi);
-                kfree (l->fcmds);
-                kfree (l);
-                printk ("FC: Cannot allocate DMA memory for initialization\n");
-                return -ENOMEM;
-        }
-        for (fc = fcchain, i = 0; fc && i < count; fc = fc->next, i++) {
-                fc->state = FC_STATE_UNINITED;
-                fc->rst_pkt = NULL;     /* kmalloc when first used */
-        }
-        /* First try if we are in a AL topology */
-        FCND(("Initializing REPORT_MAP packets\n"))
-        for (fc = fcchain, i = 0; fc && i < count; fc = fc->next, i++) {
-                fcmd = l->fcmds + i;
-                fc->login = fcmd;
-                fc->ls = (void *)l;
-                /* Assumes sizeof(fc_al_posmap) < 3 * sizeof(logi), which is true */
-                fcmd->cmd = dma_map_single (fc->dev, l->logi + 3 * i, 3 * sizeof(logi),
-                                            DMA_BIDIRECTIONAL);
-                fcmd->proto = PROTO_REPORT_AL_MAP;
-                fcmd->token = i;
-                fcmd->fc = fc;
-        }
-        for (retry = 0; retry < 8; retry++) {
-                int nqueued = 0;
-                FCND(("Sending REPORT_MAP/FLOGI/PLOGI packets\n"))
-                for (fc = fcchain, i = 0; fc && i < count; fc = fc->next, i++) {
-                        if (fc->state == FC_STATE_ONLINE || fc->state == FC_STATE_OFFLINE)
-                                continue;
-                        disable_irq(fc->irq);
-                        if (fc->state == FC_STATE_MAYBEOFFLINE) {
-                                if (!l->grace[i]) {
-                                        l->grace[i]++;
-                                        FCD(("Grace\n"))
-                                } else {
-                                        fc->state = FC_STATE_OFFLINE;
-                                        enable_irq(fc->irq);
-                                        dma_unmap_single (fc->dev, l->fcmds[i].cmd, 3 * sizeof(logi), DMA_BIDIRECTIONAL);
-                                        if (atomic_dec_and_test (&l->todo))
-                                                goto all_done;
-                                }
-                        }
-                        ret = fc->hw_enque (fc, fc->login);
-                        enable_irq(fc->irq);
-                        if (!ret) {
-                                nqueued++;
-                                continue;
-                        }
-                        if (ret == -ENOSYS && fc->login->proto == PROTO_REPORT_AL_MAP) {
-                                /* Oh yes, this card handles Point-to-Point only, so let's try that. */
-                                fc_hdr *fch;
-
-                                FCD(("SID %d DID %d\n", fc->sid, fc->did))
-                                fcmd = l->fcmds + i;
-                                dma_unmap_single(fc->dev, fcmd->cmd, 3 * sizeof(logi), DMA_BIDIRECTIONAL);
-                                fch = &fcmd->fch;
-                                FILL_FCHDR_RCTL_DID(fch, R_CTL_ELS_REQ, FS_FABRIC_F_PORT);
-                                FILL_FCHDR_SID(fch, 0);
-                                FILL_FCHDR_TYPE_FCTL(fch, TYPE_EXTENDED_LS, F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE);
-                                FILL_FCHDR_SEQ_DF_SEQ(fch, 0, 0, 0);
-                                FILL_FCHDR_OXRX(fch, 0xffff, 0xffff);
-                                fch->param = 0;
-                                l->logi [3 * i].code = LS_FLOGI;
-                                fcmd->cmd = dma_map_single (fc->dev, l->logi + 3 * i, 3 * sizeof(logi), DMA_BIDIRECTIONAL);
-                                fcmd->rsp = fcmd->cmd + sizeof(logi);
-                                fcmd->cmdlen = sizeof(logi);
-                                fcmd->rsplen = sizeof(logi);
-                                fcmd->data = (dma_addr_t)NULL;
-                                fcmd->class = FC_CLASS_SIMPLE;
-                                fcmd->proto = TYPE_EXTENDED_LS;
-                        } else
-                                printk ("FC: Cannot enque FLOGI/REPORT_MAP packet on %s\n", fc->name);
-                }
-                
-                if (nqueued) {
-                        l->timer.expires = jiffies + 5 * HZ;
-                        add_timer(&l->timer);
-
-                        down(&l->sem);
-                        if (!atomic_read(&l->todo)) {
-                                FCND(("All channels answered in time\n"))
-                                break; /* All fc channels have answered us */
-                        }
-                }
-        }
-all_done:
-        for (fc = fcchain, i = 0; fc && i < count; fc = fc->next, i++) {
-                fc->ls = NULL;
-                switch (fc->state) {
-                case FC_STATE_ONLINE: break;
-                case FC_STATE_OFFLINE: break;
-                default: dma_unmap_single (fc->dev, l->fcmds[i].cmd, 3 * sizeof(logi), DMA_BIDIRECTIONAL);
-                        break;
-                }
-        }
-        del_timer(&l->timer);
-        kfree (l->logi);
-        kfree (l->fcmds);
-        kfree (l);
-        return 0;
-}
-
-int fcp_forceoffline(fc_channel *fcchain, int count)
-{
-        fc_channel *fc;
-        fcp_cmnd *fcmd;
-        int i, ret;
-        lso l;
-
-        memset (&l, 0, sizeof(lso));
-        l.count = count;
-        l.magic = LSOMAGIC;
-        FCND(("FCP Force Offline for %d channels\n", count))
-        init_MUTEX_LOCKED(&l.sem);
-        init_timer(&l.timer);
-        l.timer.function = fcp_login_timeout;
-        l.timer.data = (unsigned long)&l;
-        atomic_set (&l.todo, count);
-        l.fcmds = kzalloc (count * sizeof(fcp_cmnd), GFP_KERNEL);
-        if (!l.fcmds) {
-                printk ("FC: Cannot allocate memory for forcing offline\n");
-                return -ENOMEM;
-        }
-        FCND(("Initializing OFFLINE packets\n"))
-        for (fc = fcchain, i = 0; fc && i < count; fc = fc->next, i++) {
-                fc->state = FC_STATE_UNINITED;
-                fcmd = l.fcmds + i;
-                fc->login = fcmd;
-                fc->ls = (void *)&l;
-                fcmd->did = fc->did;
-                fcmd->class = FC_CLASS_OFFLINE;
-                fcmd->proto = PROTO_OFFLINE;
-                fcmd->token = i;
-                fcmd->fc = fc;
-                disable_irq(fc->irq);
-                ret = fc->hw_enque (fc, fc->login);
-                enable_irq(fc->irq);
-                if (ret) printk ("FC: Cannot enque OFFLINE packet on %s\n", fc->name);
-        }
-                
-        l.timer.expires = jiffies + 5 * HZ;
-        add_timer(&l.timer);
-        down(&l.sem);
-        del_timer(&l.timer);
-        
-        for (fc = fcchain, i = 0; fc && i < count; fc = fc->next, i++)
-                fc->ls = NULL;
-        kfree (l.fcmds);
-        return 0;
-}
-
-int fcp_init(fc_channel *fcchain)
-{
-        fc_channel *fc;
-        int count=0;
-        int ret;
-        
-        for (fc = fcchain; fc; fc = fc->next) {
-                fc->fcp_register = fcp_register;
-                count++;
-        }
-
-        ret = fcp_initialize (fcchain, count);
-        if (ret)
-                return ret;
-                
-        if (!fc_channels)
-                fc_channels = fcchain;
-        else {
-                for (fc = fc_channels; fc->next; fc = fc->next);
-                fc->next = fcchain;
-        }
-        return ret;
-}
-
-void fcp_release(fc_channel *fcchain, int count)  /* count must > 0 */
-{
-        fc_channel *fc;
-        fc_channel *fcx;
-
-        for (fc = fcchain; --count && fc->next; fc = fc->next);
-        if (count) {
-                printk("FC: nothing to release\n");
-                return;
-        }
-        
-        if (fc_channels == fcchain)
-                fc_channels = fc->next;
-        else {
-                for (fcx = fc_channels; fcx->next != fcchain; fcx = fcx->next);
-                fcx->next = fc->next;
-        }
-        fc->next = NULL;
-
-        /*
-         *  We've just grabbed fcchain out of the fc_channel list
-         *  and zero-terminated it, while destroying the count.
-         *
-         *  Freeing the fc's is the low level driver's responsibility.
-         */
-}
-
-
-static void fcp_scsi_done(struct scsi_cmnd *SCpnt)
-{
-        if (FCP_CMND(SCpnt)->done)
-                FCP_CMND(SCpnt)->done(SCpnt);
-}
-
-static int fcp_scsi_queue_it(fc_channel *fc, struct scsi_cmnd *SCpnt,
-                             fcp_cmnd *fcmd, int prepare)
-{
-        long i;
-        fcp_cmd *cmd;
-        u32 fcp_cntl;
-        if (prepare) {
-                i = find_first_zero_bit (fc->scsi_bitmap, fc->scsi_bitmap_end);
-                set_bit (i, fc->scsi_bitmap);
-                fcmd->token = i;
-                cmd = fc->scsi_cmd_pool + i;
-
-                if (fc->encode_addr (SCpnt, cmd->fcp_addr, fc, fcmd)) {
-                        /* Invalid channel/id/lun and couldn't map it into fcp_addr */
-                        clear_bit (i, fc->scsi_bitmap);
-                        SCpnt->result = (DID_BAD_TARGET << 16);
-                        SCpnt->scsi_done(SCpnt);
-                        return 0;
-                }
-                fc->scsi_free--;
-                fc->cmd_slots[fcmd->token] = fcmd;
-
-                if (SCpnt->device->tagged_supported) {
-                        if (jiffies - fc->ages[SCpnt->device->channel * fc->targets + SCpnt->device->id] > (5 * 60 * HZ)) {
-                                fc->ages[SCpnt->device->channel * fc->targets + SCpnt->device->id] = jiffies;
-                                fcp_cntl = FCP_CNTL_QTYPE_ORDERED;
-                        } else
-                                fcp_cntl = FCP_CNTL_QTYPE_SIMPLE;
-                } else
-                        fcp_cntl = FCP_CNTL_QTYPE_UNTAGGED;
-
-                if (!scsi_bufflen(SCpnt)) {
-                        cmd->fcp_cntl = fcp_cntl;
-                        fcmd->data = (dma_addr_t)NULL;
-                } else {
-                        struct scatterlist *sg;
-                        int nents;
-
-                        switch (SCpnt->cmnd[0]) {
-                        case WRITE_6:
-                        case WRITE_10:
-                        case WRITE_12:
-                                cmd->fcp_cntl = (FCP_CNTL_WRITE | fcp_cntl); break;
-                        default:
-                                cmd->fcp_cntl = (FCP_CNTL_READ | fcp_cntl); break;
-                        }
-
-                        sg = scsi_sglist(SCpnt);
-                        nents = dma_map_sg(fc->dev, sg, scsi_sg_count(SCpnt),
-                                           SCpnt->sc_data_direction);
-                        fcmd->data = sg_dma_address(sg);
-                        cmd->fcp_data_len = sg_dma_len(sg);
-                }
-                memcpy (cmd->fcp_cdb, SCpnt->cmnd, SCpnt->cmd_len);
-                memset (cmd->fcp_cdb+SCpnt->cmd_len, 0, sizeof(cmd->fcp_cdb)-SCpnt->cmd_len);
-                FCD(("XXX: %04x.%04x.%04x.%04x - %08x%08x%08x\n", cmd->fcp_addr[0], cmd->fcp_addr[1], cmd->fcp_addr[2], cmd->fcp_addr[3], *(u32 *)SCpnt->cmnd, *(u32 *)(SCpnt->cmnd+4), *(u32 *)(SCpnt->cmnd+8)))
-        }
-        FCD(("Trying to enque %p\n", fcmd))
-        if (!fc->scsi_que) {
-                if (!fc->hw_enque (fc, fcmd)) {
-                        FCD(("hw_enque succeeded for %p\n", fcmd))
-                        return 0;
-                }
-        }
-        FCD(("Putting into que1 %p\n", fcmd))
-        fcp_scsi_insert_queue (fc, fcmd);
-        return 0;
-}
-
-int fcp_scsi_queuecommand(struct scsi_cmnd *SCpnt,
-                          void (* done)(struct scsi_cmnd *))
-{
-        fcp_cmnd *fcmd = FCP_CMND(SCpnt);
-        fc_channel *fc = FC_SCMND(SCpnt);
-        
-        FCD(("Entering SCSI queuecommand %p\n", fcmd))
-        if (SCpnt->done != fcp_scsi_done) {
-                fcmd->done = SCpnt->done;
-                SCpnt->done = fcp_scsi_done;
-                SCpnt->scsi_done = done;
-                fcmd->proto = TYPE_SCSI_FCP;
-                if (!fc->scsi_free) {
-                        FCD(("FC: !scsi_free, putting cmd on ML queue\n"))
-#if (FCP_SCSI_USE_NEW_EH_CODE == 0)
-                        printk("fcp_scsi_queue_command: queue full, losing cmd, bad\n");
-#endif
-                        return 1;
-                }
-                return fcp_scsi_queue_it(fc, SCpnt, fcmd, 1);
-        }
-        return fcp_scsi_queue_it(fc, SCpnt, fcmd, 0);
-}
-
-void fcp_queue_empty(fc_channel *fc)
-{
-        fcp_cmnd *fcmd;
-        
-        FCD(("Queue empty\n"))
-        while ((fcmd = fc->scsi_que)) {
-                /* The hw told us we can try again queue some packet */
-                if (fc->hw_enque (fc, fcmd))
-                        break;
-                fcp_scsi_remove_queue (fc, fcmd);
-        }
-}
-
-int fcp_scsi_abort(struct scsi_cmnd *SCpnt)
-{
-        /* Internal bookkeeping only. Lose 1 cmd_slots slot. */
-        fcp_cmnd *fcmd = FCP_CMND(SCpnt);
-        fc_channel *fc = FC_SCMND(SCpnt);
-        
-        /*
-         * We react to abort requests by simply forgetting
-         * about the command and pretending everything's sweet.
-         * This may or may not be silly. We can't, however,
-         * immediately reuse the command's cmd_slots slot,
-         * as its result may arrive later and we cannot
-         * check whether it is the aborted one, can't we?
-         *
-         * Therefore, after the first few aborts are done,
-         * we tell the scsi error handler to do something clever.
-         * It will eventually call host reset, refreshing
-         * cmd_slots for us.
-         *
-         * There is a theoretical chance that we sometimes allow
-         * more than can_queue packets to the jungle this way,
-         * but the worst outcome possible is a series of
-         * more aborts and eventually the dev_reset catharsis.
-         */
-
-        if (++fc->abort_count < (fc->can_queue >> 1)) {
-                SCpnt->result = DID_ABORT;
-                fcmd->done(SCpnt);
-                printk("FC: soft abort\n");
-                return SUCCESS;
-        } else {
-                printk("FC: hard abort refused\n");
-                return FAILED;
-        }
-}
-
-#if 0
-void fcp_scsi_reset_done(struct scsi_cmnd *SCpnt)
-{
-        fc_channel *fc = FC_SCMND(SCpnt);
-
-        fc->rst_pkt->eh_state = SCSI_STATE_FINISHED;
-        up(fc->rst_pkt->device->host->eh_action);
-}
-#endif
-
-#define FCP_RESET_TIMEOUT (2*HZ)
-
-int fcp_scsi_dev_reset(struct scsi_cmnd *SCpnt)
-{
-#if 0 /* broken junk, but if davem wants to compile this driver, let him.. */
-        unsigned long flags;
-        fcp_cmd *cmd;
-        fcp_cmnd *fcmd;
-        fc_channel *fc = FC_SCMND(SCpnt);
-        DECLARE_MUTEX_LOCKED(sem);
-
-        if (!fc->rst_pkt) {
-                fc->rst_pkt = kmalloc(sizeof(SCpnt), GFP_KERNEL);
-                if (!fc->rst_pkt) return FAILED;
-                
-                fcmd = FCP_CMND(fc->rst_pkt);
-
-
-                fcmd->token = 0;
-                cmd = fc->scsi_cmd_pool + 0;
-                FCD(("Preparing rst packet\n"))
-                fc->encode_addr (SCpnt, cmd->fcp_addr, fc, fcmd);
-                fc->rst_pkt->device = SCpnt->device;
-                fc->rst_pkt->cmd_len = 0;
-                
-                fc->cmd_slots[0] = fcmd;
-
-                cmd->fcp_cntl = FCP_CNTL_QTYPE_ORDERED | FCP_CNTL_RESET;
-                fcmd->data = (dma_addr_t)NULL;
-                fcmd->proto = TYPE_SCSI_FCP;
-
-                memcpy (cmd->fcp_cdb, SCpnt->cmnd, SCpnt->cmd_len);
-                memset (cmd->fcp_cdb+SCpnt->cmd_len, 0, sizeof(cmd->fcp_cdb)-SCpnt->cmd_len);
-                FCD(("XXX: %04x.%04x.%04x.%04x - %08x%08x%08x\n", cmd->fcp_addr[0], cmd->fcp_addr[1], cmd->fcp_addr[2], cmd->fcp_addr[3], *(u32 *)SCpnt->cmnd, *(u32 *)(SCpnt->cmnd+4), *(u32 *)(SCpnt->cmnd+8)))
-        } else {
-                fcmd = FCP_CMND(fc->rst_pkt);
-                if (fc->rst_pkt->eh_state == SCSI_STATE_QUEUED)
-                        return FAILED; /* or SUCCESS. Only these */
-        }
-        fc->rst_pkt->done = NULL;
-
-
-        fc->rst_pkt->eh_state = SCSI_STATE_QUEUED;
-        init_timer(&fc->rst_pkt->eh_timeout);
-        fc->rst_pkt->eh_timeout.data = (unsigned long) fc->rst_pkt;
-        fc->rst_pkt->eh_timeout.expires = jiffies + FCP_RESET_TIMEOUT;
-        fc->rst_pkt->eh_timeout.function = (void (*)(unsigned long))fcp_scsi_reset_done;
-
-        add_timer(&fc->rst_pkt->eh_timeout);
-
-        /*
-         * Set up the semaphore so we wait for the command to complete.
-         */
-
-        fc->rst_pkt->device->host->eh_action = &sem;
-
-        fc->rst_pkt->done = fcp_scsi_reset_done;
-
-        spin_lock_irqsave(SCpnt->device->host->host_lock, flags);
-        fcp_scsi_queue_it(fc, fc->rst_pkt, fcmd, 0);
-        spin_unlock_irqrestore(SCpnt->device->host->host_lock, flags);
-        
-        down(&sem);
-
-        fc->rst_pkt->device->host->eh_action = NULL;
-        del_timer(&fc->rst_pkt->eh_timeout);
-
-        /*
-         * See if timeout.  If so, tell the host to forget about it.
-         * In other words, we don't want a callback any more.
-         */
-        if (fc->rst_pkt->eh_state == SCSI_STATE_TIMEOUT ) {
-                fc->rst_pkt->eh_state = SCSI_STATE_UNUSED;
-                return FAILED;
-        }
-        fc->rst_pkt->eh_state = SCSI_STATE_UNUSED;
-#endif
-        return SUCCESS;
-}
-
-static int __fcp_scsi_host_reset(struct scsi_cmnd *SCpnt)
-{
-        fc_channel *fc = FC_SCMND(SCpnt);
-        fcp_cmnd *fcmd = FCP_CMND(SCpnt);
-        int i;
-
-        printk ("FC: host reset\n");
-
-        for (i=0; i < fc->can_queue; i++) {
-                if (fc->cmd_slots[i] && SCpnt->result != DID_ABORT) {
-                        SCpnt->result = DID_RESET;
-                        fcmd->done(SCpnt);
-                        fc->cmd_slots[i] = NULL;
-                }
-        }
-        fc->reset(fc);
-        fc->abort_count = 0;
-        if (fcp_initialize(fc, 1)) return SUCCESS;
-        else return FAILED;
-}
-
-int fcp_scsi_host_reset(struct scsi_cmnd *SCpnt)
-{
-        unsigned long flags;
-        int rc;
-
-        spin_lock_irqsave(SCpnt->device->host->host_lock, flags);
-        rc = __fcp_scsi_host_reset(SCpnt);
-        spin_unlock_irqrestore(SCpnt->device->host->host_lock, flags);
-
-        return rc;
-}
-
-static int fcp_els_queue_it(fc_channel *fc, fcp_cmnd *fcmd)
-{
-        long i;
-
-        i = find_first_zero_bit (fc->scsi_bitmap, fc->scsi_bitmap_end);
-        set_bit (i, fc->scsi_bitmap);
-        fcmd->token = i;
-        fc->scsi_free--;
-        fc->cmd_slots[fcmd->token] = fcmd;
-        return fcp_scsi_queue_it(fc, NULL, fcmd, 0);
-}
-
-static int fc_do_els(fc_channel *fc, unsigned int alpa, void *data, int len)
-{
-        fcp_cmnd _fcmd, *fcmd;
-        fc_hdr *fch;
-        lse l;
-        int i;
-
-        fcmd = &_fcmd;
-        memset(fcmd, 0, sizeof(fcp_cmnd));
-        FCD(("PLOGI SID %d DID %d\n", fc->sid, alpa))
-        fch = &fcmd->fch;
-        FILL_FCHDR_RCTL_DID(fch, R_CTL_ELS_REQ, alpa);
-        FILL_FCHDR_SID(fch, fc->sid);
-        FILL_FCHDR_TYPE_FCTL(fch, TYPE_EXTENDED_LS, F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE);
-        FILL_FCHDR_SEQ_DF_SEQ(fch, 0, 0, 0);
-        FILL_FCHDR_OXRX(fch, 0xffff, 0xffff);
-        fch->param = 0;
-        fcmd->cmd = dma_map_single (fc->dev, data, 2 * len, DMA_BIDIRECTIONAL);
-        fcmd->rsp = fcmd->cmd + len;
-        fcmd->cmdlen = len;
-        fcmd->rsplen = len;
-        fcmd->data = (dma_addr_t)NULL;
-        fcmd->fc = fc;
-        fcmd->class = FC_CLASS_SIMPLE;
-        fcmd->proto = TYPE_EXTENDED_LS;
-        
-        memset (&l, 0, sizeof(lse));
-        l.magic = LSEMAGIC;
-        init_MUTEX_LOCKED(&l.sem);
-        l.timer.function = fcp_login_timeout;
-        l.timer.data = (unsigned long)&l;
-        l.status = FC_STATUS_TIMED_OUT;
-        fcmd->ls = (void *)&l;
-
-        disable_irq(fc->irq);   
-        fcp_els_queue_it(fc, fcmd);
-        enable_irq(fc->irq);
-
-        for (i = 0;;) {
-                l.timer.expires = jiffies + 5 * HZ;
-                add_timer(&l.timer);
-                down(&l.sem);
-                del_timer(&l.timer);
-                if (l.status != FC_STATUS_TIMED_OUT) break;
-                if (++i == 3) break;
-                disable_irq(fc->irq);
-                fcp_scsi_queue_it(fc, NULL, fcmd, 0);
-                enable_irq(fc->irq);
-        }
-        
-        clear_bit(fcmd->token, fc->scsi_bitmap);
-        fc->scsi_free++;
-        dma_unmap_single (fc->dev, fcmd->cmd, 2 * len, DMA_BIDIRECTIONAL);
-        return l.status;
-}
-
-int fc_do_plogi(fc_channel *fc, unsigned char alpa, fc_wwn *node, fc_wwn *nport)
-{
-        logi *l;
-        int status;
-
-        l = kzalloc(2 * sizeof(logi), GFP_KERNEL);
-        if (!l) return -ENOMEM;
-        l->code = LS_PLOGI;
-        memcpy (&l->nport_wwn, &fc->wwn_nport, sizeof(fc_wwn));
-        memcpy (&l->node_wwn, &fc->wwn_node, sizeof(fc_wwn));
-        memcpy (&l->common, fc->common_svc, sizeof(common_svc_parm));
-        memcpy (&l->class1, fc->class_svcs, 3*sizeof(svc_parm));
-        status = fc_do_els(fc, alpa, l, sizeof(logi));
-        if (status == FC_STATUS_OK) {
-                if (l[1].code == LS_ACC) {
-#ifdef FCDEBUG
-                        u32 *u = (u32 *)&l[1].nport_wwn;
-                        FCD(("AL-PA %02x: Port WWN %08x%08x Node WWN %08x%08x\n", alpa, 
-                                u[0], u[1], u[2], u[3]))
-#endif
-                        memcpy(nport, &l[1].nport_wwn, sizeof(fc_wwn));
-                        memcpy(node, &l[1].node_wwn, sizeof(fc_wwn));
-                } else
-                        status = FC_STATUS_BAD_RSP;
-        }
-        kfree(l);
-        return status;
-}
-
-typedef struct {
-        unsigned int code;
-        unsigned params[4];
-} prli;
-
-int fc_do_prli(fc_channel *fc, unsigned char alpa)
-{
-        prli *p;
-        int status;
-
-        p = kzalloc(2 * sizeof(prli), GFP_KERNEL);
-        if (!p) return -ENOMEM;
-        p->code = LS_PRLI;
-        p->params[0] = 0x08002000;
-        p->params[3] = 0x00000022;
-        status = fc_do_els(fc, alpa, p, sizeof(prli));
-        if (status == FC_STATUS_OK && p[1].code != LS_PRLI_ACC && p[1].code != LS_ACC)
-                status = FC_STATUS_BAD_RSP;
-        kfree(p);
-        return status;
-}
-
-MODULE_LICENSE("GPL");
-
diff --git a/drivers/fc4/fc.h b/drivers/fc4/fc.h
deleted file mode 100644
index 13f89d4c8cb9..000000000000
--- a/drivers/fc4/fc.h
+++ /dev/null
@@ -1,230 +0,0 @@
-/* fc.h: Definitions for Fibre Channel Physical and Signaling Interface.
- *
- * Copyright (C) 1996-1997,1999 Jakub Jelinek (jj@ultra.linux.cz)
- *
- * Sources:
- *      Fibre Channel Physical & Signaling Interface (FC-PH), dpANS, 1994
- *      dpANS Fibre Channel Protocol for SCSI (X3.269-199X), Rev. 012, 1995
- */
-
-#ifndef __FC_H
-#define __FC_H
-
-/* World Wide Name */
-#define NAAID_IEEE              1
-#define NAAID_IEEE_EXT          2
-#define NAAID_LOCAL             3
-#define NAAID_IP                4
-#define NAAID_IEEE_REG          5
-#define NAAID_IEEE_REG_EXT      6
-#define NAAID_CCITT             12
-#define NAAID_CCITT_GRP         14
-
-/* This is NAAID_IEEE_EXT scheme */
-typedef struct {
-        u32     naaid:4;
-        u32     nportid:12;
-        u32     hi:16;
-        u32     lo;
-} fc_wwn;
-
-/* Frame header for FC-PH frames */
-
-/* r_ctl field */
-#define R_CTL_DEVICE_DATA       0x00    /* FC4 Device_Data frame */
-#define R_CTL_EXTENDED_SVC      0x20    /* Extended Link_Data frame */
-#define R_CTL_FC4_SVC           0x30    /* FC4 Link_Data frame */
-#define R_CTL_VIDEO             0x40    /* Video_Data frame */
-#define R_CTL_BASIC_SVC         0x80    /* Basic Link_Data frame */
-#define R_CTL_LINK_CTL          0xc0    /* Link_Control frame */
-/* FC4 Device_Data frames */
-#define R_CTL_UNCATEGORIZED     0x00
-#define R_CTL_SOLICITED_DATA    0x01
-#define R_CTL_UNSOL_CONTROL     0x02
-#define R_CTL_SOLICITED_CONTROL 0x03
-#define R_CTL_UNSOL_DATA        0x04
-#define R_CTL_XFER_RDY          0x05
-#define R_CTL_COMMAND           0x06
-#define R_CTL_STATUS            0x07
-/* Basic Link_Data frames */
-#define R_CTL_LS_NOP            0x80
-#define R_CTL_LS_ABTS           0x81
-#define R_CTL_LS_RMC            0x82
-#define R_CTL_LS_BA_ACC         0x84
-#define R_CTL_LS_BA_RJT         0x85
-/* Extended Link_Data frames */
-#define R_CTL_ELS_REQ           0x22
-#define R_CTL_ELS_RSP           0x23
-/* Link_Control frames */
-#define R_CTL_ACK_1             0xc0
-#define R_CTL_ACK_N             0xc1
-#define R_CTL_P_RJT             0xc2
-#define R_CTL_F_RJT             0xc3
-#define R_CTL_P_BSY             0xc4
-#define R_CTL_F_BSY_DF          0xc5
-#define R_CTL_F_BSY_LC          0xc6
-#define R_CTL_LCR               0xc7
-
-/* type field */
-#define TYPE_BASIC_LS           0x00
-#define TYPE_EXTENDED_LS        0x01
-#define TYPE_IS8802             0x04
-#define TYPE_IS8802_SNAP        0x05
-#define TYPE_SCSI_FCP           0x08
-#define TYPE_SCSI_GPP           0x09
-#define TYPE_HIPP_FP            0x0a
-#define TYPE_IPI3_MASTER        0x11
-#define TYPE_IPI3_SLAVE         0x12
-#define TYPE_IPI3_PEER          0x13
-
-/* f_ctl field */
-#define F_CTL_FILL_BYTES        0x000003
-#define F_CTL_XCHG_REASSEMBLE   0x000004
-#define F_CTL_RO_PRESENT        0x000008
-#define F_CTL_ABORT_SEQ         0x000030
-#define F_CTL_CONTINUE_SEQ      0x0000c0
-#define F_CTL_INVALIDATE_XID    0x004000
-#define F_CTL_XID_REASSIGNED    0x008000
-#define F_CTL_SEQ_INITIATIVE    0x010000
-#define F_CTL_CHAINED_SEQ       0x020000
-#define F_CTL_END_CONNECT       0x040000
-#define F_CTL_END_SEQ           0x080000
-#define F_CTL_LAST_SEQ          0x100000
-#define F_CTL_FIRST_SEQ         0x200000
-#define F_CTL_SEQ_CONTEXT       0x400000
-#define F_CTL_XCHG_CONTEXT      0x800000
-
-typedef struct {
-        u32     r_ctl:8,        did:24;
-        u32     xxx1:8,         sid:24;
-        u32     type:8,         f_ctl:24;
-        u32     seq_id:8,       df_ctl:8,       seq_cnt:16;
-        u16     ox_id,          rx_id;
-        u32     param;
-} fc_hdr;
-/* The following are ugly macros to make setup of this structure faster */
-#define FILL_FCHDR_RCTL_DID(fch, r_ctl, did) *(u32 *)(fch) = ((r_ctl) << 24) | (did);
-#define FILL_FCHDR_SID(fch, sid) *((u32 *)(fch)+1) = (sid);
-#define FILL_FCHDR_TYPE_FCTL(fch, type, f_ctl) *((u32 *)(fch)+2) = ((type) << 24) | (f_ctl);
-#define FILL_FCHDR_SEQ_DF_SEQ(fch, seq_id, df_ctl, seq_cnt) *((u32 *)(fch)+3) = ((seq_id) << 24) | ((df_ctl) << 16) | (seq_cnt);
-#define FILL_FCHDR_OXRX(fch, ox_id, rx_id) *((u32 *)(fch)+4) = ((ox_id) << 16) | (rx_id);
-
-/* Well known addresses */
-#define FS_GENERAL_MULTICAST    0xfffff7
-#define FS_WELL_KNOWN_MULTICAST 0xfffff8
-#define FS_HUNT_GROUP           0xfffff9
-#define FS_MANAGEMENT_SERVER    0xfffffa
-#define FS_TIME_SERVER          0xfffffb
-#define FS_NAME_SERVER          0xfffffc
-#define FS_FABRIC_CONTROLLER    0xfffffd
-#define FS_FABRIC_F_PORT        0xfffffe
-#define FS_BROADCAST            0xffffff
-
-/* Reject frames */
-/* The param field should be cast to this structure */
-typedef struct {
-        u8      action;
-        u8      reason;
-        u8      xxx;
-        u8      vendor_unique;
-} rjt_param;
-
-/* Reject action codes */
-#define RJT_RETRY                       0x01
-#define RJT_NONRETRY                    0x02
-
-/* Reject reason codes */
-#define RJT_INVALID_DID                 0x01
-#define RJT_INVALID_SID                 0x02
-#define RJT_NPORT_NOT_AVAIL_TEMP        0x03
-#define RJT_NPORT_NOT_AVAIL_PERM        0x04
-#define RJT_CLASS_NOT_SUPPORTED         0x05
-#define RJT_DELIMITER_ERROR             0x06
-#define RJT_TYPE_NOT_SUPPORTED          0x07
-#define RJT_INVALID_LINK_CONTROL        0x08
-#define RJT_INVALID_R_CTL               0x09
-#define RJT_INVALID_F_CTL               0x0a
-#define RJT_INVALID_OX_ID               0x0b
-#define RJT_INVALID_RX_ID               0x0c
-#define RJT_INVALID_SEQ_ID              0x0d
-#define RJT_INVALID_DF_CTL              0x0e
-#define RJT_INVALID_SEQ_CNT             0x0f
-#define RJT_INVALID_PARAMETER           0x10
-#define RJT_EXCHANGE_ERROR              0x11
-#define RJT_PROTOCOL_ERROR              0x12
-#define RJT_INCORRECT_LENGTH            0x13
-#define RJT_UNEXPECTED_ACK              0x14
-#define RJT_UNEXPECTED_LINK_RESP        0x15
-#define RJT_LOGIN_REQUIRED              0x16
-#define RJT_EXCESSIVE_SEQUENCES         0x17
-#define RJT_CANT_ESTABLISH_EXCHANGE     0x18
-#define RJT_SECURITY_NOT_SUPPORTED      0x19
-#define RJT_FABRIC_NA                   0x1a
-#define RJT_VENDOR_UNIQUE               0xff
-
-
-#define SP_F_PORT_LOGIN                 0x10
-
-/* Extended SVC commands */
-#define LS_RJT                  0x01000000
-#define LS_ACC                  0x02000000
-#define LS_PRLI_ACC             0x02100014
-#define LS_PLOGI                0x03000000
-#define LS_FLOGI                0x04000000
-#define LS_LOGO                 0x05000000
-#define LS_ABTX                 0x06000000
-#define LS_RCS                  0x07000000
-#define LS_RES                  0x08000000
-#define LS_RSS                  0x09000000
-#define LS_RSI                  0x0a000000
-#define LS_ESTS                 0x0b000000
-#define LS_ESTC                 0x0c000000
-#define LS_ADVC                 0x0d000000
-#define LS_RTV                  0x0e000000
-#define LS_RLS                  0x0f000000
-#define LS_ECHO                 0x10000000
-#define LS_TEST                 0x11000000
-#define LS_RRQ                  0x12000000
-#define LS_IDENT                0x20000000
-#define LS_PRLI                 0x20100014
-#define LS_DISPLAY              0x21000000
-#define LS_PRLO                 0x21100014
-#define LS_PDISC                0x50000000
-#define LS_ADISC                0x52000000
-
-typedef struct {
-        u8      fcph_hi, fcph_lo;
-        u16     buf2buf_credit;
-        u8      common_features;
-        u8      xxx1;
-        u16     buf2buf_size;
-        u8      xxx2;
-        u8      total_concurrent;
-        u16     off_by_info;
-        u32     e_d_tov;
-} common_svc_parm;
-
-typedef struct {
-        u16     serv_opts;
-        u16     initiator_ctl;
-        u16     rcpt_ctl;
-        u16     recv_size;
-        u8      xxx1;
-        u8      concurrent_seqs;
-        u16     end2end_credit;
-        u16     open_seqs_per_xchg;
-        u16     xxx2;
-} svc_parm;
-
-/* Login */
-typedef struct {
-        u32             code;
-        common_svc_parm common;
-        fc_wwn          nport_wwn;
-        fc_wwn          node_wwn;
-        svc_parm        class1;
-        svc_parm        class2;
-        svc_parm        class3;
-} logi;
-
-#endif /* !(__FC_H) */
diff --git a/drivers/fc4/fc_syms.c b/drivers/fc4/fc_syms.c
deleted file mode 100644
index bd3918ddf7ac..000000000000
--- a/drivers/fc4/fc_syms.c
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * We should not even be trying to compile this if we are not doing
- * a module.
- */
-#include <linux/module.h>
-
-#ifdef CONFIG_MODULES
-
-#include <linux/types.h>
-#include <linux/string.h>
-#include <linux/kernel.h>
-
-#include "fcp_impl.h"
-
-EXPORT_SYMBOL(fcp_init);
-EXPORT_SYMBOL(fcp_release);
-EXPORT_SYMBOL(fcp_queue_empty);
-EXPORT_SYMBOL(fcp_receive_solicited);
-EXPORT_SYMBOL(fc_channels);
-EXPORT_SYMBOL(fcp_state_change);
-EXPORT_SYMBOL(fc_do_plogi);
-EXPORT_SYMBOL(fc_do_prli);
-
-/* SCSI stuff */
-EXPORT_SYMBOL(fcp_scsi_queuecommand);
-EXPORT_SYMBOL(fcp_scsi_abort);
-EXPORT_SYMBOL(fcp_scsi_dev_reset);
-EXPORT_SYMBOL(fcp_scsi_host_reset);
-
-#endif /* CONFIG_MODULES */
diff --git a/drivers/fc4/fcp.h b/drivers/fc4/fcp.h
deleted file mode 100644
index 6aa34a7a4c11..000000000000
--- a/drivers/fc4/fcp.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/* fcp.h: Definitions for Fibre Channel Protocol.
- *
- * Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
- *
- */
-
-#ifndef __FCP_H
-#define __FCP_H
-
-/* FCP addressing is hierarchical with up to 4 layers, MS first.
-   Exact meaning of the addresses is up to the vendor */
-
-/* fcp_cntl field */   
-#define FCP_CNTL_WRITE          0x00000001      /* Initiator write */
-#define FCP_CNTL_READ           0x00000002      /* Initiator read */
-#define FCP_CNTL_ABORT_TSK      0x00000200      /* Abort task set */
-#define FCP_CNTL_CLR_TASK       0x00000400      /* Clear task set */
-#define FCP_CNTL_RESET          0x00002000      /* Reset */
-#define FCP_CNTL_CLR_ACA        0x00004000      /* Clear ACA */
-#define FCP_CNTL_KILL_TASK      0x00008000      /* Terminate task */
-#define FCP_CNTL_QTYPE_MASK     0x00070000      /* Tagged queueing type */
-#define         FCP_CNTL_QTYPE_SIMPLE           0x00000000
-#define         FCP_CNTL_QTYPE_HEAD_OF_Q        0x00010000
-#define         FCP_CNTL_QTYPE_ORDERED          0x00020000
-#define         FCP_CNTL_QTYPE_ACA_Q_TAG        0x00040000
-#define         FCP_CNTL_QTYPE_UNTAGGED         0x00050000
-
-typedef struct {
-        u16     fcp_addr[4];
-        u32     fcp_cntl;
-        u8      fcp_cdb[16];
-        u32     fcp_data_len;
-} fcp_cmd;
-
-/* fcp_status field */
-#define FCP_STATUS_MASK         0x000000ff      /* scsi status of command */
-#define FCP_STATUS_RSP_LEN      0x00000100      /* response_len != 0 */
-#define FCP_STATUS_SENSE_LEN    0x00000200      /* sense_len != 0 */
-#define FCP_STATUS_RESID        0x00000400      /* resid != 0 */
-
-typedef struct {
-        u32     xxx[2];
-        u32     fcp_status;
-        u32     fcp_resid;
-        u32     fcp_sense_len;
-        u32     fcp_response_len;
-        /* u8   fcp_sense[fcp_sense_len]; */
-        /* u8   fcp_response[fcp_response_len]; */
-} fcp_rsp;
-
-/* fcp errors */
-
-/* rsp_info_type field */
-#define FCP_RSP_SCSI_BUS_ERR    0x01
-#define FCP_RSP_SCSI_PORT_ERR   0x02
-#define FCP_RSP_CARD_ERR        0x03
-
-/* isp_status field */
-#define FCP_RSP_CMD_COMPLETE    0x0000
-#define FCP_RSP_CMD_INCOMPLETE  0x0001
-#define FCP_RSP_CMD_DMA_ERR     0x0002
-#define FCP_RSP_CMD_TRAN_ERR    0x0003
-#define FCP_RSP_CMD_RESET       0x0004
-#define FCP_RSP_CMD_ABORTED     0x0005
-#define FCP_RSP_CMD_TIMEOUT     0x0006
-#define FCP_RSP_CMD_OVERRUN     0x0007
-
-/* isp_state_flags field */
-#define FCP_RSP_ST_GOT_BUS      0x0100
-#define FCP_RSP_ST_GOT_TARGET   0x0200
-#define FCP_RSP_ST_SENT_CMD     0x0400
-#define FCP_RSP_ST_XFRD_DATA    0x0800
-#define FCP_RSP_ST_GOT_STATUS   0x1000
-#define FCP_RSP_ST_GOT_SENSE    0x2000
-
-/* isp_stat_flags field */
-#define FCP_RSP_STAT_DISC       0x0001
-#define FCP_RSP_STAT_SYNC       0x0002
-#define FCP_RSP_STAT_PERR       0x0004
-#define FCP_RSP_STAT_BUS_RESET  0x0008
-#define FCP_RSP_STAT_DEV_RESET  0x0010
-#define FCP_RSP_STAT_ABORTED    0x0020
-#define FCP_RSP_STAT_TIMEOUT    0x0040
-#define FCP_RSP_STAT_NEGOTIATE  0x0080
-
-typedef struct {
-        u8      rsp_info_type;
-        u8      xxx;
-        u16     isp_status;
-        u16     isp_state_flags;
-        u16     isp_stat_flags;
-} fcp_scsi_err;
-
-#endif /* !(__FCP_H) */
diff --git a/drivers/fc4/fcp_impl.h b/drivers/fc4/fcp_impl.h
deleted file mode 100644
index 506338a461ba..000000000000
--- a/drivers/fc4/fcp_impl.h
+++ /dev/null
@@ -1,164 +0,0 @@
-/* fcp_impl.h: Generic SCSI on top of FC4 - our interface defines.
- *
- * Copyright (C) 1997-1999 Jakub Jelinek (jj@ultra.linux.cz)
- * Copyright (C) 1998 Jirka Hanika (geo@ff.cuni.cz)
- */
-
-#ifndef _FCP_SCSI_H
-#define _FCP_SCSI_H
-
-#include <linux/types.h>
-#include "../scsi/scsi.h"
-
-#include "fc.h"
-#include "fcp.h"
-#include "fc-al.h"
-
-#include <asm/io.h>
-#ifdef __sparc__
-#include <asm/sbus.h>
-#endif
-
-/* 0 or 1 */
-#define FCP_SCSI_USE_NEW_EH_CODE        0
-
-#define FC_CLASS_OUTBOUND       0x01
-#define FC_CLASS_INBOUND        0x02
-#define FC_CLASS_SIMPLE         0x03
-#define FC_CLASS_IO_WRITE       0x04
-#define FC_CLASS_IO_READ        0x05
-#define FC_CLASS_UNSOLICITED    0x06
-#define FC_CLASS_OFFLINE        0x08
-
-#define PROTO_OFFLINE           0x02
-#define PROTO_REPORT_AL_MAP     0x03
-#define PROTO_FORCE_LIP         0x06
-
-struct _fc_channel; 
-
-typedef struct fcp_cmnd {
-        struct fcp_cmnd         *next;
-        struct fcp_cmnd         *prev;
-        void                    (*done)(struct scsi_cmnd *);
-        unsigned short          proto;
-        unsigned short          token;
-        unsigned int            did;
-        /* FCP SCSI stuff */
-        dma_addr_t              data;
-        /* From now on this cannot be touched for proto == TYPE_SCSI_FCP */
-        fc_hdr                  fch;
-        dma_addr_t              cmd;
-        dma_addr_t              rsp;
-        int                     cmdlen;
-        int                     rsplen;
-        int                     class;
-        int                     datalen;
-        /* This is just used as a verification during login */
-        struct _fc_channel      *fc;
-        void                    *ls;
-} fcp_cmnd;
-
-typedef struct {
-        unsigned int            len;
-        unsigned char           list[0];
-} fcp_posmap;
-
-typedef struct _fc_channel {
-        struct _fc_channel      *next;
-        int                     irq;
-        int                     state;
-        int                     sid;
-        int                     did;
-        char                    name[16];
-        void                    (*fcp_register)(struct _fc_channel *, u8, int);
-        void                    (*reset)(struct _fc_channel *);
-        int                     (*hw_enque)(struct _fc_channel *, fcp_cmnd *);
-        fc_wwn                  wwn_node;
-        fc_wwn                  wwn_nport;
-        fc_wwn                  wwn_dest;
-        common_svc_parm         *common_svc;
-        svc_parm                *class_svcs;
-#ifdef __sparc__        
-        struct sbus_dev         *dev;
-#else
-        struct pci_dev          *dev;
-#endif
-        struct module           *module;
-        /* FCP SCSI stuff */
-        short                   can_queue;
-        short                   abort_count;
-        int                     rsp_size;
-        fcp_cmd                 *scsi_cmd_pool;
-        char                    *scsi_rsp_pool;
-        dma_addr_t              dma_scsi_cmd, dma_scsi_rsp;
-        unsigned long           *scsi_bitmap;
-        long                    scsi_bitmap_end;
-        int                     scsi_free;
-        int                     (*encode_addr)(struct scsi_cmnd *, u16 *, struct _fc_channel *, fcp_cmnd *);
-        fcp_cmnd                *scsi_que;
-        char                    scsi_name[4];
-        fcp_cmnd                **cmd_slots;
-        int                     channels;
-        int                     targets;
-        long                    *ages;
-        struct scsi_cmnd        *rst_pkt;
-        fcp_posmap              *posmap;
-        /* LOGIN stuff */
-        fcp_cmnd                *login;
-        void                    *ls;
-} fc_channel;
-
-extern fc_channel *fc_channels;
-
-#define FC_STATE_UNINITED       0
-#define FC_STATE_ONLINE         1
-#define FC_STATE_OFFLINE        2
-#define FC_STATE_RESETING       3
-#define FC_STATE_FPORT_OK       4
-#define FC_STATE_MAYBEOFFLINE   5
-
-#define FC_STATUS_OK                    0
-#define FC_STATUS_P_RJT                 2
-#define FC_STATUS_F_RJT                 3
-#define FC_STATUS_P_BSY                 4
-#define FC_STATUS_F_BSY                 5
-#define FC_STATUS_ERR_OFFLINE           0x11
-#define FC_STATUS_TIMEOUT               0x12
-#define FC_STATUS_ERR_OVERRUN           0x13
-#define FC_STATUS_POINTTOPOINT          0x15
-#define FC_STATUS_AL                    0x16
-#define FC_STATUS_UNKNOWN_CQ_TYPE       0x20
-#define FC_STATUS_BAD_SEG_CNT           0x21
-#define FC_STATUS_MAX_XCHG_EXCEEDED     0x22
-#define FC_STATUS_BAD_XID               0x23
-#define FC_STATUS_XCHG_BUSY             0x24
-#define FC_STATUS_BAD_POOL_ID           0x25
-#define FC_STATUS_INSUFFICIENT_CQES     0x26
-#define FC_STATUS_ALLOC_FAIL            0x27
-#define FC_STATUS_BAD_SID               0x28
-#define FC_STATUS_NO_SEQ_INIT           0x29
-#define FC_STATUS_TIMED_OUT             -1
-#define FC_STATUS_BAD_RSP               -2
-
-void fcp_queue_empty(fc_channel *);
-int fcp_init(fc_channel *);
-void fcp_release(fc_channel *fc_chain, int count);
-void fcp_receive_solicited(fc_channel *, int, int, int, fc_hdr *);
-void fcp_state_change(fc_channel *, int);
-int fc_do_plogi(fc_channel *, unsigned char, fc_wwn *, fc_wwn *);
-int fc_do_prli(fc_channel *, unsigned char);
-
-#define for_each_fc_channel(fc)                         \
-        for (fc = fc_channels; fc; fc = fc->next)
-        
-#define for_each_online_fc_channel(fc)                  \
-        for_each_fc_channel(fc)                         \
-                if (fc->state == FC_STATE_ONLINE)
-
-int fcp_scsi_queuecommand(struct scsi_cmnd *,
-                          void (* done) (struct scsi_cmnd *));
-int fcp_scsi_abort(struct scsi_cmnd *);
-int fcp_scsi_dev_reset(struct scsi_cmnd *);
-int fcp_scsi_host_reset(struct scsi_cmnd *);
-
-#endif /* !(_FCP_SCSI_H) */
diff --git a/drivers/fc4/soc.c b/drivers/fc4/soc.c
deleted file mode 100644
index d517734462e6..000000000000
--- a/drivers/fc4/soc.c
+++ /dev/null
@@ -1,764 +0,0 @@
-/* soc.c: Sparc SUNW,soc (Serial Optical Channel) Fibre Channel Sbus adapter support.
- *
- * Copyright (C) 1996,1997,1999 Jakub Jelinek (jj@ultra.linux.cz)
- * Copyright (C) 1997,1998 Jirka Hanika (geo@ff.cuni.cz)
- *
- * Sources:
- *      Fibre Channel Physical & Signaling Interface (FC-PH), dpANS, 1994
- *      dpANS Fibre Channel Protocol for SCSI (X3.269-199X), Rev. 012, 1995
- *
- * Supported hardware:
- *      Tested on SOC sbus card bought with SS1000 in Linux running on SS5 and Ultra1. 
- *      For SOC sbus cards, you have to make sure your FCode is 1.52 or later.
- *      If you have older FCode, you should try to upgrade or get SOC microcode from Sun
- *      (the microcode is present in Solaris soc driver as well). In that case you need
- *      to #define HAVE_SOC_UCODE and format the microcode into soc_asm.c. For the exact
- *      format mail me and I will tell you. I cannot offer you the actual microcode though,
- *      unless Sun confirms they don't mind.
- */
-
-static char *version =
-        "soc.c:v1.3 9/Feb/99 Jakub Jelinek (jj@ultra.linux.cz), Jirka Hanika (geo@ff.cuni.cz)\n";
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/fcntl.h>
-#include <linux/interrupt.h>
-#include <linux/ptrace.h>
-#include <linux/ioport.h>
-#include <linux/in.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/init.h>
-#include <linux/bitops.h>
-#include <asm/io.h>
-#include <asm/dma.h>
-#include <linux/errno.h>
-#include <asm/byteorder.h>
-
-#include <asm/openprom.h>
-#include <asm/oplib.h>
-#include <asm/pgtable.h>
-#include <asm/irq.h>
-
-/* #define SOCDEBUG */
-/* #define HAVE_SOC_UCODE */
-
-#include "fcp_impl.h"
-#include "soc.h"
-#ifdef HAVE_SOC_UCODE
-#include "soc_asm.h"
-#endif
-
-#define soc_printk printk ("soc%d: ", s->soc_no); printk 
-
-#ifdef SOCDEBUG
-#define SOD(x)  soc_printk x;
-#else
-#define SOD(x)
-#endif
-
-#define for_each_soc(s) for (s = socs; s; s = s->next)
-struct soc *socs = NULL;
-
-static inline void soc_disable(struct soc *s)
-{
-        sbus_writel(0, s->regs + IMASK);
-        sbus_writel(SOC_CMD_SOFT_RESET, s->regs + CMD);
-}
-
-static inline void soc_enable(struct soc *s)
-{
-        SOD(("enable %08x\n", s->cfg))
-        sbus_writel(0, s->regs + SAE);
-        sbus_writel(s->cfg, s->regs + CFG);
-        sbus_writel(SOC_CMD_RSP_QALL, s->regs + CMD);
-        SOC_SETIMASK(s, SOC_IMASK_RSP_QALL | SOC_IMASK_SAE);
-        SOD(("imask %08lx %08lx\n", s->imask, sbus_readl(s->regs + IMAK)));
-}
-
-static void soc_reset(fc_channel *fc)
-{
-        soc_port *port = (soc_port *)fc;
-        struct soc *s = port->s;
-        
-        /* FIXME */
-        soc_disable(s);
-        s->req[0].seqno = 1;
-        s->req[1].seqno = 1;
-        s->rsp[0].seqno = 1;
-        s->rsp[1].seqno = 1;
-        s->req[0].in = 0;
-        s->req[1].in = 0;
-        s->rsp[0].in = 0;
-        s->rsp[1].in = 0;
-        s->req[0].out = 0;
-        s->req[1].out = 0;
-        s->rsp[0].out = 0;
-        s->rsp[1].out = 0;
-
-        /* FIXME */
-        soc_enable(s);
-}
-
-static inline void soc_solicited (struct soc *s)
-{
-        fc_hdr fchdr;
-        soc_rsp __iomem *hwrsp;
-        soc_cq_rsp *sw_cq;
-        int token;
-        int status;
-        fc_channel *fc;
-
-        sw_cq = &s->rsp[SOC_SOLICITED_RSP_Q];
-
-        if (sw_cq->pool == NULL)
-                sw_cq->pool = (soc_req __iomem *)
-                        (s->xram + xram_get_32low ((xram_p)&sw_cq->hw_cq->address));
-        sw_cq->in = xram_get_8 ((xram_p)&sw_cq->hw_cq->in);
-        SOD (("soc_solicited, %d pkts arrived\n", (sw_cq->in-sw_cq->out) & sw_cq->last))
-        for (;;) {
-                hwrsp = (soc_rsp __iomem *)sw_cq->pool + sw_cq->out;
-                token = xram_get_32low ((xram_p)&hwrsp->shdr.token);
-                status = xram_get_32low ((xram_p)&hwrsp->status);
-                fc = (fc_channel *)(&s->port[(token >> 11) & 1]);
-                
-                if (status == SOC_OK) {
-                        fcp_receive_solicited(fc, token >> 12,
-                                              token & ((1 << 11) - 1),
-                                              FC_STATUS_OK, NULL);
-                } else {
-                        xram_copy_from(&fchdr, (xram_p)&hwrsp->fchdr, sizeof(fchdr));
-                        /* We have intentionally defined FC_STATUS_* constants
-                         * to match SOC_* constants, otherwise we'd have to
-                         * translate status.
-                         */
-                        fcp_receive_solicited(fc, token >> 12,
-                                              token & ((1 << 11) - 1),
-                                              status, &fchdr);
-                }
-                        
-                if (++sw_cq->out > sw_cq->last) {
-                        sw_cq->seqno++;
-                        sw_cq->out = 0;
-                }
-                
-                if (sw_cq->out == sw_cq->in) {
-                        sw_cq->in = xram_get_8 ((xram_p)&sw_cq->hw_cq->in);
-                        if (sw_cq->out == sw_cq->in) {
-                                /* Tell the hardware about it */
-                                sbus_writel((sw_cq->out << 24) |
-                                            (SOC_CMD_RSP_QALL &
-                                             ~(SOC_CMD_RSP_Q0 << SOC_SOLICITED_RSP_Q)),
-                                            s->regs + CMD);
-
-                                /* Read it, so that we're sure it has been updated */
-                                sbus_readl(s->regs + CMD);
-                                sw_cq->in = xram_get_8 ((xram_p)&sw_cq->hw_cq->in);
-                                if (sw_cq->out == sw_cq->in)
-                                        break;
-                        }
-                }
-        }
-}
-
-static inline void soc_request (struct soc *s, u32 cmd)
-{
-        SOC_SETIMASK(s, s->imask & ~(cmd & SOC_CMD_REQ_QALL));
-        SOD(("imask %08lx %08lx\n", s->imask, sbus_readl(s->regs + IMASK)));
-
-        SOD(("Queues available %08x OUT %X %X\n", cmd,
-             xram_get_8((xram_p)&s->req[0].hw_cq->out),
-             xram_get_8((xram_p)&s->req[0].hw_cq->out)))
-        if (s->port[s->curr_port].fc.state != FC_STATE_OFFLINE) {
-                fcp_queue_empty ((fc_channel *)&(s->port[s->curr_port]));
-                if (((s->req[1].in + 1) & s->req[1].last) != (s->req[1].out))
-                        fcp_queue_empty ((fc_channel *)&(s->port[1 - s->curr_port]));
-        } else {
-                fcp_queue_empty ((fc_channel *)&(s->port[1 - s->curr_port]));
-        }
-        if (s->port[1 - s->curr_port].fc.state != FC_STATE_OFFLINE)
-                s->curr_port ^= 1;
-}
-
-static inline void soc_unsolicited (struct soc *s)
-{
-        soc_rsp __iomem *hwrsp, *hwrspc;
-        soc_cq_rsp *sw_cq;
-        int count;
-        int status;
-        int flags;
-        fc_channel *fc;
-
-        sw_cq = &s->rsp[SOC_UNSOLICITED_RSP_Q];
-        if (sw_cq->pool == NULL)
-                sw_cq->pool = (soc_req __iomem *)
-                        (s->xram + (xram_get_32low ((xram_p)&sw_cq->hw_cq->address)));
-
-        sw_cq->in = xram_get_8 ((xram_p)&sw_cq->hw_cq->in);
-        SOD (("soc_unsolicited, %d packets arrived\n", (sw_cq->in - sw_cq->out) & sw_cq->last))
-        while (sw_cq->in != sw_cq->out) {
-                /* ...real work per entry here... */
-                hwrsp = (soc_rsp __iomem *)sw_cq->pool + sw_cq->out;
-
-                hwrspc = NULL;
-                flags = xram_get_16 ((xram_p)&hwrsp->shdr.flags);
-                count = xram_get_8 ((xram_p)&hwrsp->count);
-                fc = (fc_channel *)&s->port[flags & SOC_PORT_B];
-                SOD(("FC %08lx fcp_state_change %08lx\n",
-                     (long)fc, (long)fc->fcp_state_change))
-                
-                if (count != 1) {
-                        /* Ugh, continuation entries */
-                        u8 in;
-
-                        if (count != 2) {
-                                printk("%s: Too many continuations entries %d\n",
-                                       fc->name, count);
-                                goto update_out;
-                        }
-                        
-                        in = sw_cq->in;
-                        if (in < sw_cq->out) in += sw_cq->last + 1;
-                        if (in < sw_cq->out + 2) {
-                                /* Ask the hardware if they haven't arrived yet. */
-                                sbus_writel((sw_cq->out << 24) |
-                                            (SOC_CMD_RSP_QALL &
-                                             ~(SOC_CMD_RSP_Q0 << SOC_UNSOLICITED_RSP_Q)),
-                                            s->regs + CMD);
-
-                                /* Read it, so that we're sure it has been updated */
-                                sbus_readl(s->regs + CMD);
-                                sw_cq->in = xram_get_8 ((xram_p)&sw_cq->hw_cq->in);
-                                in = sw_cq->in;
-                                if (in < sw_cq->out)
-                                        in += sw_cq->last + 1;
-                                if (in < sw_cq->out + 2) /* Nothing came, let us wait */
-                                        return;
-                        }
-                        if (sw_cq->out == sw_cq->last)
-                                hwrspc = (soc_rsp __iomem *)sw_cq->pool;
-                        else
-                                hwrspc = hwrsp + 1;
-                }
-                
-                switch (flags & ~SOC_PORT_B) {
-                case SOC_STATUS:
-                        status = xram_get_32low ((xram_p)&hwrsp->status);
-                        switch (status) {
-                        case SOC_ONLINE:
-                                SOD(("State change to ONLINE\n"));
-                                fcp_state_change(fc, FC_STATE_ONLINE);
-                                break;
-                        case SOC_OFFLINE:
-                                SOD(("State change to OFFLINE\n"));
-                                fcp_state_change(fc, FC_STATE_OFFLINE);
-                                break;
-                        default:
-                                printk ("%s: Unknown STATUS no %d\n",
-                                        fc->name, status);
-                                break;
-                        }
-                        break;
-                case (SOC_UNSOLICITED|SOC_FC_HDR):
-                        {
-                                int r_ctl = xram_get_8 ((xram_p)&hwrsp->fchdr);
-                                unsigned len;
-                                char buf[64];
-                                
-                                if ((r_ctl & 0xf0) == R_CTL_EXTENDED_SVC) {
-                                        len = xram_get_32 ((xram_p)&hwrsp->shdr.bytecnt);
-                                        if (len < 4 || !hwrspc) {
-                                                printk ("%s: Invalid R_CTL %02x "
-                                                        "continuation entries\n",
-                                                        fc->name, r_ctl);
-                                        } else {
-                                                if (len > 60)
-                                                        len = 60;
-                                                xram_copy_from (buf, (xram_p)hwrspc,
-                                                                (len + 3) & ~3);
-                                                if (*(u32 *)buf == LS_DISPLAY) {
-                                                        int i;
-                                                        
-                                                        for (i = 4; i < len; i++)
-                                                                if (buf[i] == '\n')
-                                                                        buf[i] = ' ';
-                                                        buf[len] = 0;
-                                                        printk ("%s message: %s\n",
-                                                                fc->name, buf + 4);
-                                                } else {
-                                                        printk ("%s: Unknown LS_CMD "
-                                                                "%02x\n", fc->name,
-                                                                buf[0]);
-                                                }
-                                        }
-                                } else {
-                                        printk ("%s: Unsolicited R_CTL %02x "
-                                                "not handled\n", fc->name, r_ctl);
-                                }
-                        }
-                        break;
-                default:
-                        printk ("%s: Unexpected flags %08x\n", fc->name, flags);
-                        break;
-                };
-update_out:
-                if (++sw_cq->out > sw_cq->last) {
-                        sw_cq->seqno++;
-                        sw_cq->out = 0;
-                }
-                
-                if (hwrspc) {
-                        if (++sw_cq->out > sw_cq->last) {
-                                sw_cq->seqno++;
-                                sw_cq->out = 0;
-                        }
-                }
-                
-                if (sw_cq->out == sw_cq->in) {
-                        sw_cq->in = xram_get_8 ((xram_p)&sw_cq->hw_cq->in);
-                        if (sw_cq->out == sw_cq->in) {
-                                /* Tell the hardware about it */
-                                sbus_writel((sw_cq->out << 24) |
-                                            (SOC_CMD_RSP_QALL &
-                                             ~(SOC_CMD_RSP_Q0 << SOC_UNSOLICITED_RSP_Q)),
-                                            s->regs + CMD);
-
-                                /* Read it, so that we're sure it has been updated */
-                                sbus_readl(s->regs + CMD);
-                                sw_cq->in = xram_get_8 ((xram_p)&sw_cq->hw_cq->in);
-                        }
-                }
-        }
-}
-
-static irqreturn_t soc_intr(int irq, void *dev_id)
-{
-        u32 cmd;
-        unsigned long flags;
-        register struct soc *s = (struct soc *)dev_id;
-
-        spin_lock_irqsave(&s->lock, flags);
-        cmd = sbus_readl(s->regs + CMD);
-        for (; (cmd = SOC_INTR (s, cmd)); cmd = sbus_readl(s->regs + CMD)) {
-                if (cmd & SOC_CMD_RSP_Q1) soc_unsolicited (s);
-                if (cmd & SOC_CMD_RSP_Q0) soc_solicited (s);
-                if (cmd & SOC_CMD_REQ_QALL) soc_request (s, cmd);
-        }
-        spin_unlock_irqrestore(&s->lock, flags);
-
-        return IRQ_HANDLED;
-}
-
-#define TOKEN(proto, port, token) (((proto)<<12)|(token)|(port))
-
-static int soc_hw_enque (fc_channel *fc, fcp_cmnd *fcmd)
-{
-        soc_port *port = (soc_port *)fc;
-        struct soc *s = port->s;
-        int qno;
-        soc_cq_req *sw_cq;
-        int cq_next_in;
-        soc_req *request;
-        fc_hdr *fch;
-        int i;
-
-        if (fcmd->proto == TYPE_SCSI_FCP)
-                qno = 1;
-        else
-                qno = 0;
-        SOD(("Putting a FCP packet type %d into hw queue %d\n", fcmd->proto, qno))
-        if (s->imask & (SOC_IMASK_REQ_Q0 << qno)) {
-                SOD(("EIO %08x\n", s->imask))
-                return -EIO;
-        }
-        sw_cq = s->req + qno;
-        cq_next_in = (sw_cq->in + 1) & sw_cq->last;
-        
-        if (cq_next_in == sw_cq->out &&
-            cq_next_in == (sw_cq->out = xram_get_8((xram_p)&sw_cq->hw_cq->out))) {
-                SOD(("%d IN %d OUT %d LAST %d\n", qno, sw_cq->in, sw_cq->out, sw_cq->last))
-                SOC_SETIMASK(s, s->imask | (SOC_IMASK_REQ_Q0 << qno));
-                SOD(("imask %08lx %08lx\n", s->imask, sbus_readl(s->regs + IMASK)));
-                /* If queue is full, just say NO */
-                return -EBUSY;
-        }
-        
-        request = sw_cq->pool + sw_cq->in;
-        fch = &request->fchdr;
-        
-        switch (fcmd->proto) {
-        case TYPE_SCSI_FCP:
-                request->shdr.token = TOKEN(TYPE_SCSI_FCP, port->mask, fcmd->token); 
-                request->data[0].base = fc->dma_scsi_cmd + fcmd->token * sizeof(fcp_cmd);
-                request->data[0].count = sizeof(fcp_cmd);
-                request->data[1].base = fc->dma_scsi_rsp + fcmd->token * fc->rsp_size;
-                request->data[1].count = fc->rsp_size;
-                if (fcmd->data) {
-                        request->shdr.segcnt = 3;
-                        i = fc->scsi_cmd_pool[fcmd->token].fcp_data_len;
-                        request->shdr.bytecnt = i;
-                        request->data[2].base = fcmd->data;
-                        request->data[2].count = i;
-                        request->type =
-                            (fc->scsi_cmd_pool[fcmd->token].fcp_cntl & FCP_CNTL_WRITE) ?
-                                SOC_CQTYPE_IO_WRITE : SOC_CQTYPE_IO_READ;
-                } else {
-                        request->shdr.segcnt = 2;
-                        request->shdr.bytecnt = 0;
-                        request->data[2].base = 0;
-                        request->data[2].count = 0;
-                        request->type = SOC_CQTYPE_SIMPLE;
-                }
-                FILL_FCHDR_RCTL_DID(fch, R_CTL_COMMAND, fc->did);
-                FILL_FCHDR_SID(fch, fc->sid);
-                FILL_FCHDR_TYPE_FCTL(fch, TYPE_SCSI_FCP,
-                                     F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE);
-                FILL_FCHDR_SEQ_DF_SEQ(fch, 0, 0, 0);
-                FILL_FCHDR_OXRX(fch, 0xffff, 0xffff);
-                fch->param = 0;
-                request->shdr.flags = port->flags;
-                request->shdr.class = 2;
-                break;
-                
-        case PROTO_OFFLINE:
-                memset (request, 0, sizeof(*request));
-                request->shdr.token = TOKEN(PROTO_OFFLINE, port->mask, fcmd->token); 
-                request->type = SOC_CQTYPE_OFFLINE;
-                FILL_FCHDR_RCTL_DID(fch, R_CTL_COMMAND, fc->did);
-                FILL_FCHDR_SID(fch, fc->sid);
-                FILL_FCHDR_TYPE_FCTL(fch, TYPE_SCSI_FCP,
-                                     F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE);
-                FILL_FCHDR_SEQ_DF_SEQ(fch, 0, 0, 0);
-                FILL_FCHDR_OXRX(fch, 0xffff, 0xffff);
-                request->shdr.flags = port->flags;
-                break;
-                
-        case PROTO_REPORT_AL_MAP:
-                /* SOC only supports Point-to-Point topology, no FC-AL, sorry... */
-                return -ENOSYS;
-
-        default: 
-                request->shdr.token = TOKEN(fcmd->proto, port->mask, fcmd->token);
-                request->shdr.class = 2;
-                request->shdr.flags = port->flags;
-                memcpy (fch, &fcmd->fch, sizeof(fc_hdr));
-                request->data[0].count = fcmd->cmdlen;
-                request->data[1].count = fcmd->rsplen;
-                request->type = fcmd->class;
-                switch (fcmd->class) {
-                case FC_CLASS_OUTBOUND:
-                        request->data[0].base = fcmd->cmd;
-                        request->data[0].count = fcmd->cmdlen;
-                        request->type = SOC_CQTYPE_OUTBOUND;
-                        request->shdr.bytecnt = fcmd->cmdlen;
-                        request->shdr.segcnt = 1;
-                        break;
-                case FC_CLASS_INBOUND:
-                        request->data[0].base = fcmd->rsp;
-                        request->data[0].count = fcmd->rsplen;
-                        request->type = SOC_CQTYPE_INBOUND;
-                        request->shdr.bytecnt = 0;
-                        request->shdr.segcnt = 1;
-                        break;
-                case FC_CLASS_SIMPLE:
-                        request->data[0].base = fcmd->cmd;
-                        request->data[1].base = fcmd->rsp;
-                        request->data[0].count = fcmd->cmdlen;
-                        request->data[1].count = fcmd->rsplen;
-                        request->type = SOC_CQTYPE_SIMPLE;
-                        request->shdr.bytecnt = fcmd->cmdlen;
-                        request->shdr.segcnt = 2;
-                        break;
-                case FC_CLASS_IO_READ:
-                case FC_CLASS_IO_WRITE:
-                        request->data[0].base = fcmd->cmd;
-                        request->data[1].base = fcmd->rsp;
-                        request->data[0].count = fcmd->cmdlen;
-                        request->data[1].count = fcmd->rsplen;
-                        request->type =
-                              (fcmd->class == FC_CLASS_IO_READ) ?
-                                SOC_CQTYPE_IO_READ : SOC_CQTYPE_IO_WRITE;
-                        if (fcmd->data) {
-                                request->data[2].base = fcmd->data;
-                                request->data[2].count = fcmd->datalen;
-                                request->shdr.bytecnt = fcmd->datalen;
-                                request->shdr.segcnt = 3;
-                        } else {
-                                request->shdr.bytecnt = 0;
-                                request->shdr.segcnt = 2;
-                        }
-                        break;
-                };
-                break;
-        };
-
-        request->count = 1;
-        request->flags = 0;
-        request->seqno = sw_cq->seqno;
-        
-        /* And now tell the SOC about it */
-
-        if (++sw_cq->in > sw_cq->last) {
-                sw_cq->in = 0;
-                sw_cq->seqno++;
-        }
-        
-        SOD(("Putting %08x into cmd\n",
-             SOC_CMD_RSP_QALL | (sw_cq->in << 24) | (SOC_CMD_REQ_Q0 << qno)))
-        
-        sbus_writel(SOC_CMD_RSP_QALL | (sw_cq->in << 24) | (SOC_CMD_REQ_Q0 << qno),
-                    s->regs + CMD);
-
-        /* Read so that command is completed. */        
-        sbus_readl(s->regs + CMD);
-        
-        return 0;
-}
-
-static inline void soc_download_fw(struct soc *s)
-{
-#ifdef HAVE_SOC_UCODE
-        xram_copy_to (s->xram, soc_ucode, sizeof(soc_ucode));
-        xram_bzero (s->xram + sizeof(soc_ucode), 32768 - sizeof(soc_ucode));
-#endif
-}
-
-/* Check for what the best SBUS burst we can use happens
- * to be on this machine.
- */
-static inline void soc_init_bursts(struct soc *s, struct sbus_dev *sdev)
-{
-        int bsizes, bsizes_more;
-
-        bsizes = (prom_getintdefault(sdev->prom_node,"burst-sizes",0xff) & 0xff);
-        bsizes_more = (prom_getintdefault(sdev->bus->prom_node, "burst-sizes", 0xff) & 0xff);
-        bsizes &= bsizes_more;
-        if ((bsizes & 0x7f) == 0x7f)
-                s->cfg = SOC_CFG_BURST_64;
-        else if ((bsizes & 0x3f) == 0x3f) 
-                s->cfg = SOC_CFG_BURST_32;
-        else if ((bsizes & 0x1f) == 0x1f)
-                s->cfg = SOC_CFG_BURST_16;
-        else
-                s->cfg = SOC_CFG_BURST_4;
-}
-
-static inline void soc_init(struct sbus_dev *sdev, int no)
-{
-        unsigned char tmp[60];
-        int propl;
-        struct soc *s;
-        static int version_printed = 0;
-        soc_hw_cq cq[8];
-        int size, i;
-        int irq;
-        
-        s = kzalloc (sizeof (struct soc), GFP_KERNEL);
-        if (s == NULL)
-                return;
-        spin_lock_init(&s->lock);
-        s->soc_no = no;
-
-        SOD(("socs %08lx soc_intr %08lx soc_hw_enque %08x\n",
-             (long)socs, (long)soc_intr, (long)soc_hw_enque))   
-        if (version_printed++ == 0)
-                printk (version);
-
-        s->port[0].fc.module = THIS_MODULE;
-        s->port[1].fc.module = THIS_MODULE;
-
-        s->next = socs;
-        socs = s;
-        s->port[0].fc.dev = sdev;
-        s->port[1].fc.dev = sdev;
-        s->port[0].s = s;
-        s->port[1].s = s;
-
-        s->port[0].fc.next = &s->port[1].fc;
-
-        /* World Wide Name of SOC */
-        propl = prom_getproperty (sdev->prom_node, "soc-wwn", tmp, sizeof(tmp));
-        if (propl != sizeof (fc_wwn)) {
-                s->wwn.naaid = NAAID_IEEE;
-                s->wwn.lo = 0x12345678;
-        } else
-                memcpy (&s->wwn, tmp, sizeof (fc_wwn));
-                
-        propl = prom_getproperty (sdev->prom_node, "port-wwns", tmp, sizeof(tmp));
-        if (propl != 2 * sizeof (fc_wwn)) {
-                s->port[0].fc.wwn_nport.naaid = NAAID_IEEE_EXT;
-                s->port[0].fc.wwn_nport.hi = s->wwn.hi;
-                s->port[0].fc.wwn_nport.lo = s->wwn.lo;
-                s->port[1].fc.wwn_nport.naaid = NAAID_IEEE_EXT;
-                s->port[1].fc.wwn_nport.nportid = 1;
-                s->port[1].fc.wwn_nport.hi = s->wwn.hi;
-                s->port[1].fc.wwn_nport.lo = s->wwn.lo;
-        } else {
-                memcpy (&s->port[0].fc.wwn_nport, tmp, sizeof (fc_wwn));
-                memcpy (&s->port[1].fc.wwn_nport, tmp + sizeof (fc_wwn), sizeof (fc_wwn));
-        }
-        memcpy (&s->port[0].fc.wwn_node, &s->wwn, sizeof (fc_wwn));
-        memcpy (&s->port[1].fc.wwn_node, &s->wwn, sizeof (fc_wwn));
-        SOD(("Got wwns %08x%08x ports %08x%08x and %08x%08x\n", 
-             *(u32 *)&s->port[0].fc.wwn_nport, s->port[0].fc.wwn_nport.lo,
-             *(u32 *)&s->port[0].fc.wwn_nport, s->port[0].fc.wwn_nport.lo,
-             *(u32 *)&s->port[1].fc.wwn_nport, s->port[1].fc.wwn_nport.lo))
-                
-        s->port[0].fc.sid = 1;
-        s->port[1].fc.sid = 17;
-        s->port[0].fc.did = 2;
-        s->port[1].fc.did = 18;
-        
-        s->port[0].fc.reset = soc_reset;
-        s->port[1].fc.reset = soc_reset;
-        
-        if (sdev->num_registers == 1) {
-                /* Probably SunFire onboard SOC */
-                s->xram = sbus_ioremap(&sdev->resource[0], 0,
-                                       0x10000UL, "soc xram");
-                s->regs = sbus_ioremap(&sdev->resource[0], 0x10000UL,
-                                       0x10UL, "soc regs");
-        } else {
-                /* Probably SOC sbus card */
-                s->xram = sbus_ioremap(&sdev->resource[1], 0,
-                                       sdev->reg_addrs[1].reg_size, "soc xram");
-                s->regs = sbus_ioremap(&sdev->resource[2], 0,
-                                       sdev->reg_addrs[2].reg_size, "soc regs");
-        }
-        
-        soc_init_bursts(s, sdev);
-        
-        SOD(("Disabling SOC\n"))
-        
-        soc_disable (s);
-        
-        irq = sdev->irqs[0];
-
-        if (request_irq (irq, soc_intr, IRQF_SHARED, "SOC", (void *)s)) {
-                soc_printk ("Cannot order irq %d to go\n", irq);
-                socs = s->next;
-                return;
-        }
-
-        SOD(("SOC uses IRQ %d\n", irq))
-        
-        s->port[0].fc.irq = irq;
-        s->port[1].fc.irq = irq;
-        
-        sprintf (s->port[0].fc.name, "soc%d port A", no);
-        sprintf (s->port[1].fc.name, "soc%d port B", no);
-        s->port[0].flags = SOC_FC_HDR | SOC_PORT_A;
-        s->port[1].flags = SOC_FC_HDR | SOC_PORT_B;
-        s->port[1].mask = (1 << 11);
-        
-        s->port[0].fc.hw_enque = soc_hw_enque;
-        s->port[1].fc.hw_enque = soc_hw_enque;
-        
-        soc_download_fw (s);
-        
-        SOD(("Downloaded firmware\n"))
-
-        /* Now setup xram circular queues */
-        memset (cq, 0, sizeof(cq));
-        
-        size = (SOC_CQ_REQ0_SIZE + SOC_CQ_REQ1_SIZE) * sizeof(soc_req);
-        s->req_cpu = sbus_alloc_consistent(sdev, size, &s->req_dvma);
-        s->req[0].pool = s->req_cpu;
-        cq[0].address = s->req_dvma;
-        s->req[1].pool = s->req[0].pool + SOC_CQ_REQ0_SIZE;
-        
-        s->req[0].hw_cq = (soc_hw_cq __iomem *)(s->xram + SOC_CQ_REQ_OFFSET);
-        s->req[1].hw_cq = (soc_hw_cq __iomem *)(s->xram + SOC_CQ_REQ_OFFSET + sizeof(soc_hw_cq));
-        s->rsp[0].hw_cq = (soc_hw_cq __iomem *)(s->xram + SOC_CQ_RSP_OFFSET);
-        s->rsp[1].hw_cq = (soc_hw_cq __iomem *)(s->xram + SOC_CQ_RSP_OFFSET + sizeof(soc_hw_cq));
-        
-        cq[1].address = cq[0].address + (SOC_CQ_REQ0_SIZE * sizeof(soc_req));
-        cq[4].address = 1;
-        cq[5].address = 1;
-        cq[0].last = SOC_CQ_REQ0_SIZE - 1;
-        cq[1].last = SOC_CQ_REQ1_SIZE - 1;
-        cq[4].last = SOC_CQ_RSP0_SIZE - 1;
-        cq[5].last = SOC_CQ_RSP1_SIZE - 1;
-        for (i = 0; i < 8; i++)
-                cq[i].seqno = 1;
-        
-        s->req[0].last = SOC_CQ_REQ0_SIZE - 1;
-        s->req[1].last = SOC_CQ_REQ1_SIZE - 1;
-        s->rsp[0].last = SOC_CQ_RSP0_SIZE - 1;
-        s->rsp[1].last = SOC_CQ_RSP1_SIZE - 1;
-        
-        s->req[0].seqno = 1;
-        s->req[1].seqno = 1;
-        s->rsp[0].seqno = 1;
-        s->rsp[1].seqno = 1;
-
-        xram_copy_to (s->xram + SOC_CQ_REQ_OFFSET, cq, sizeof(cq));
-        
-        /* Make our sw copy of SOC service parameters */
-        xram_copy_from (s->serv_params, s->xram + 0x140, sizeof (s->serv_params));
-        
-        s->port[0].fc.common_svc = (common_svc_parm *)s->serv_params;
-        s->port[0].fc.class_svcs = (svc_parm *)(s->serv_params + 0x20);
-        s->port[1].fc.common_svc = (common_svc_parm *)&s->serv_params;
-        s->port[1].fc.class_svcs = (svc_parm *)(s->serv_params + 0x20);
-        
-        soc_enable (s);
-        
-        SOD(("Enabled SOC\n"))
-}
-
-static int __init soc_probe(void)
-{
-        struct sbus_bus *sbus;
-        struct sbus_dev *sdev = NULL;
-        struct soc *s;
-        int cards = 0;
-
-        for_each_sbus(sbus) {
-                for_each_sbusdev(sdev, sbus) {
-                        if(!strcmp(sdev->prom_name, "SUNW,soc")) {
-                                soc_init(sdev, cards);
-                                cards++;
-                        }
-                }
-        }
-        if (!cards) return -EIO;
-
-        for_each_soc(s)
-                if (s->next)
-                        s->port[1].fc.next = &s->next->port[0].fc;
-        fcp_init (&socs->port[0].fc);
-        return 0;
-}
-
-static void __exit soc_cleanup(void)
-{
-        struct soc *s;
-        int irq;
-        struct sbus_dev *sdev;
-        
-        for_each_soc(s) {
-                irq = s->port[0].fc.irq;
-                free_irq (irq, s);
-
-                fcp_release(&(s->port[0].fc), 2);
-
-                sdev = s->port[0].fc.dev;
-                if (sdev->num_registers == 1) {
-                        sbus_iounmap(s->xram, 0x10000UL);
-                        sbus_iounmap(s->regs, 0x10UL);
-                } else {
-                        sbus_iounmap(s->xram, sdev->reg_addrs[1].reg_size);
-                        sbus_iounmap(s->regs, sdev->reg_addrs[2].reg_size);
-                }
-                sbus_free_consistent(sdev,
-                                     (SOC_CQ_REQ0_SIZE+SOC_CQ_REQ1_SIZE)*sizeof(soc_req),
-                                     s->req_cpu, s->req_dvma);
-        }
-}
-
-module_init(soc_probe);
-module_exit(soc_cleanup);
-MODULE_LICENSE("GPL");
diff --git a/drivers/fc4/soc.h b/drivers/fc4/soc.h
deleted file mode 100644
index d38cf5b28eed..000000000000
--- a/drivers/fc4/soc.h
+++ /dev/null
@@ -1,301 +0,0 @@
-/* soc.h: Definitions for Sparc SUNW,soc Fibre Channel Sbus driver.
- *
- * Copyright (C) 1996,1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
- */
-
-#ifndef __SOC_H
-#define __SOC_H
-
-#include "fc.h"
-#include "fcp.h"
-#include "fcp_impl.h"
-
-/* Hardware register offsets and constants first {{{ */
-#define CFG     0x00UL          /* Config Register */
-#define SAE     0x04UL          /* Slave Access Error Register */
-#define CMD     0x08UL          /* Command and Status Register */
-#define IMASK   0x0cUL          /* Interrupt Mask Register */
-
-/* Config Register */
-#define SOC_CFG_EXT_RAM_BANK_MASK       0x07000000
-#define SOC_CFG_EEPROM_BANK_MASK        0x00030000
-#define SOC_CFG_BURST64_MASK            0x00000700
-#define SOC_CFG_SBUS_PARITY_TEST        0x00000020
-#define SOC_CFG_SBUS_PARITY_CHECK       0x00000010
-#define SOC_CFG_SBUS_ENHANCED           0x00000008
-#define SOC_CFG_BURST_MASK              0x00000007
-/* Bursts */
-#define SOC_CFG_BURST_4                 0x00000000
-#define SOC_CFG_BURST_16                0x00000004
-#define SOC_CFG_BURST_32                0x00000005
-#define SOC_CFG_BURST_64                0x00000006
-
-/* Slave Access Error Register */
-#define SOC_SAE_ALIGNMENT               0x00000004
-#define SOC_SAE_UNSUPPORTED             0x00000002
-#define SOC_SAE_PARITY                  0x00000001
-
-/* Command & Status Register */
-#define SOC_CMD_RSP_QALL                0x000f0000
-#define SOC_CMD_RSP_Q0                  0x00010000
-#define SOC_CMD_RSP_Q1                  0x00020000
-#define SOC_CMD_RSP_Q2                  0x00040000
-#define SOC_CMD_RSP_Q3                  0x00080000
-#define SOC_CMD_REQ_QALL                0x00000f00
-#define SOC_CMD_REQ_Q0                  0x00000100
-#define SOC_CMD_REQ_Q1                  0x00000200
-#define SOC_CMD_REQ_Q2                  0x00000400
-#define SOC_CMD_REQ_Q3                  0x00000800
-#define SOC_CMD_SAE                     0x00000080
-#define SOC_CMD_INTR_PENDING            0x00000008
-#define SOC_CMD_NON_QUEUED              0x00000004
-#define SOC_CMD_IDLE                    0x00000002
-#define SOC_CMD_SOFT_RESET              0x00000001
-
-/* Interrupt Mask Register */
-#define SOC_IMASK_RSP_QALL              0x000f0000
-#define SOC_IMASK_RSP_Q0                0x00010000
-#define SOC_IMASK_RSP_Q1                0x00020000
-#define SOC_IMASK_RSP_Q2                0x00040000
-#define SOC_IMASK_RSP_Q3                0x00080000
-#define SOC_IMASK_REQ_QALL              0x00000f00
-#define SOC_IMASK_REQ_Q0                0x00000100
-#define SOC_IMASK_REQ_Q1                0x00000200
-#define SOC_IMASK_REQ_Q2                0x00000400
-#define SOC_IMASK_REQ_Q3                0x00000800
-#define SOC_IMASK_SAE                   0x00000080
-#define SOC_IMASK_NON_QUEUED            0x00000004
-
-#define SOC_INTR(s, cmd) \
-        (((cmd & SOC_CMD_RSP_QALL) | ((~cmd) & SOC_CMD_REQ_QALL)) \
-         & s->imask)
-         
-#define SOC_SETIMASK(s, i) \
-do {    (s)->imask = (i); \
-        sbus_writel((i), (s)->regs + IMASK); \
-} while(0)
-
-/* XRAM
- *
- * This is a 64KB register area. It accepts only halfword access.
- * That's why here are the following inline functions...
- */
- 
-typedef void __iomem *xram_p;
-
-/* Get 32bit number from XRAM */
-static inline u32 xram_get_32(xram_p x)
-{
-        return ((sbus_readw(x + 0x00UL) << 16) |
-                (sbus_readw(x + 0x02UL)));
-}
-
-/* Like the above, but when we don't care about the high 16 bits */
-static inline u32 xram_get_32low(xram_p x)
-{
-        return (u32) sbus_readw(x + 0x02UL);
-}
-
-static inline u16 xram_get_16(xram_p x)
-{
-        return sbus_readw(x);
-}
-
-static inline u8 xram_get_8(xram_p x)
-{
-        if ((unsigned long)x & 0x1UL) {
-                x = x - 1;
-                return (u8) sbus_readw(x);
-        } else {
-                return (u8) (sbus_readw(x) >> 8);
-        }
-}
-
-static inline void xram_copy_from(void *p, xram_p x, int len)
-{
-        for (len >>= 2; len > 0; len--, x += sizeof(u32)) {
-                u32 val, *p32 = p;
-
-                val = ((sbus_readw(x + 0x00UL) << 16) |
-                       (sbus_readw(x + 0x02UL)));
-                *p32++ = val;
-                p = p32;
-        }
-}
-
-static inline void xram_copy_to(xram_p x, void *p, int len)
-{
-        for (len >>= 2; len > 0; len--, x += sizeof(u32)) {
-                u32 tmp, *p32 = p;
-
-                tmp = *p32++;
-                p = p32;
-                sbus_writew(tmp >> 16, x + 0x00UL);
-                sbus_writew(tmp, x + 0x02UL);
-        }
-}
-
-static inline void xram_bzero(xram_p x, int len)
-{
-        for (len >>= 1; len > 0; len--, x += sizeof(u16))
-                sbus_writew(0, x);
-}
-
-/* Circular Queue */
-
-#define SOC_CQ_REQ_OFFSET       (0x100 * sizeof(u16))
-#define SOC_CQ_RSP_OFFSET       (0x110 * sizeof(u16))
-
-typedef struct {
-        u32                     address;
-        u8                      in;
-        u8                      out;
-        u8                      last;
-        u8                      seqno;
-} soc_hw_cq;
-
-#define SOC_PORT_A      0x0000  /* From/To Port A */
-#define SOC_PORT_B      0x0001  /* From/To Port A */
-#define SOC_FC_HDR      0x0002  /* Contains FC Header */
-#define SOC_NORSP       0x0004  /* Don't generate response nor interrupt */
-#define SOC_NOINT       0x0008  /* Generate response but not interrupt */
-#define SOC_XFERRDY     0x0010  /* Generate XFERRDY */
-#define SOC_IGNOREPARAM 0x0020  /* Ignore PARAM field in the FC header */
-#define SOC_COMPLETE    0x0040  /* Command completed */
-#define SOC_UNSOLICITED 0x0080  /* For request this is the packet to establish unsolicited pools, */
-                                /* for rsp this is unsolicited packet */
-#define SOC_STATUS      0x0100  /* State change (on/off line) */
-
-typedef struct {
-        u32                     token;
-        u16                     flags;
-        u8                      class;
-        u8                      segcnt;
-        u32                     bytecnt;
-} soc_hdr;
-
-typedef struct {
-        u32                     base;
-        u32                     count;
-} soc_data;
-
-#define SOC_CQTYPE_OUTBOUND     0x01
-#define SOC_CQTYPE_INBOUND      0x02
-#define SOC_CQTYPE_SIMPLE       0x03
-#define SOC_CQTYPE_IO_WRITE     0x04
-#define SOC_CQTYPE_IO_READ      0x05
-#define SOC_CQTYPE_UNSOLICITED  0x06
-#define SOC_CQTYPE_DIAG         0x07
-#define SOC_CQTYPE_OFFLINE      0x08
-#define SOC_CQTYPE_RESPONSE     0x10
-#define SOC_CQTYPE_INLINE       0x20
-
-#define SOC_CQFLAGS_CONT        0x01
-#define SOC_CQFLAGS_FULL        0x02
-#define SOC_CQFLAGS_BADHDR      0x04
-#define SOC_CQFLAGS_BADPKT      0x08
-
-typedef struct {
-        soc_hdr                 shdr;
-        soc_data                data[3];
-        fc_hdr                  fchdr;
-        u8                      count;
-        u8                      type;
-        u8                      flags;
-        u8                      seqno;
-} soc_req;
-
-#define SOC_OK                  0
-#define SOC_P_RJT               2
-#define SOC_F_RJT               3
-#define SOC_P_BSY               4
-#define SOC_F_BSY               5
-#define SOC_ONLINE              0x10
-#define SOC_OFFLINE             0x11
-#define SOC_TIMEOUT             0x12
-#define SOC_OVERRUN             0x13
-#define SOC_UNKOWN_CQ_TYPE      0x20
-#define SOC_BAD_SEG_CNT         0x21
-#define SOC_MAX_XCHG_EXCEEDED   0x22
-#define SOC_BAD_XID             0x23
-#define SOC_XCHG_BUSY           0x24
-#define SOC_BAD_POOL_ID         0x25
-#define SOC_INSUFFICIENT_CQES   0x26
-#define SOC_ALLOC_FAIL          0x27
-#define SOC_BAD_SID             0x28
-#define SOC_NO_SEG_INIT         0x29
-
-typedef struct {
-        soc_hdr                 shdr;
-        u32                     status;
-        soc_data                data;
-        u8                      xxx1[12];
-        fc_hdr                  fchdr;
-        u8                      count;
-        u8                      type;
-        u8                      flags;
-        u8                      seqno;
-} soc_rsp;
-
-/* }}} */
-
-/* Now our software structures and constants we use to drive the beast {{{ */
-
-#define SOC_CQ_REQ0_SIZE        4
-#define SOC_CQ_REQ1_SIZE        64
-#define SOC_CQ_RSP0_SIZE        8
-#define SOC_CQ_RSP1_SIZE        4
-
-#define SOC_SOLICITED_RSP_Q     0
-#define SOC_UNSOLICITED_RSP_Q   1
-
-struct soc;
-
-typedef struct {
-        /* This must come first */
-        fc_channel              fc;
-        struct soc              *s;
-        u16                     flags;
-        u16                     mask;
-} soc_port; 
-
-typedef struct {
-        soc_hw_cq               __iomem *hw_cq; /* Related XRAM cq */
-        soc_req                 __iomem *pool;
-        u8                      in;
-        u8                      out;
-        u8                      last;
-        u8                      seqno;
-} soc_cq_rsp;
-
-typedef struct {
-        soc_hw_cq               __iomem *hw_cq; /* Related XRAM cq */
-        soc_req                 *pool;
-        u8                      in;
-        u8                      out;
-        u8                      last;
-        u8                      seqno;
-} soc_cq_req;
-
-struct soc {
-        spinlock_t              lock;
-        soc_port                port[2]; /* Every SOC has one or two FC ports */
-        soc_cq_req              req[2]; /* Request CQs */
-        soc_cq_rsp              rsp[2]; /* Response CQs */
-        int                     soc_no;
-        void __iomem            *regs;
-        xram_p                  xram;
-        fc_wwn                  wwn;
-        u32                     imask;  /* Our copy of regs->imask */
-        u32                     cfg;    /* Our copy of regs->cfg */
-        char                    serv_params[80];
-        struct soc              *next;
-        int                     curr_port; /* Which port will have priority to fcp_queue_empty */
-
-        soc_req                 *req_cpu;
-        u32                     req_dvma;
-};
-
-/* }}} */
-
-#endif /* !(__SOC_H) */
diff --git a/drivers/fc4/socal.c b/drivers/fc4/socal.c
deleted file mode 100644
index c903ebfab526..000000000000
--- a/drivers/fc4/socal.c
+++ /dev/null
@@ -1,904 +0,0 @@
-/* socal.c: Sparc SUNW,socal (SOC+) Fibre Channel Sbus adapter support.
- *
- * Copyright (C) 1998,1999 Jakub Jelinek (jj@ultra.linux.cz)
- *
- * Sources:
- *      Fibre Channel Physical & Signaling Interface (FC-PH), dpANS, 1994
- *      dpANS Fibre Channel Protocol for SCSI (X3.269-199X), Rev. 012, 1995
- *      SOC+ Programming Guide 0.1
- *      Fibre Channel Arbitrated Loop (FC-AL), dpANS rev. 4.5, 1995
- *
- * Supported hardware:
- *      On-board SOC+ adapters of Ultra Enterprise servers and sun4d.
- */
-
-static char *version =
-        "socal.c: SOC+ driver v1.1 9/Feb/99 Jakub Jelinek (jj@ultra.linux.cz)\n";
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/fcntl.h>
-#include <linux/interrupt.h>
-#include <linux/ptrace.h>
-#include <linux/ioport.h>
-#include <linux/in.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/init.h>
-#include <linux/bitops.h>
-#include <asm/system.h>
-#include <asm/io.h>
-#include <asm/dma.h>
-#include <linux/errno.h>
-#include <asm/byteorder.h>
-
-#include <asm/openprom.h>
-#include <asm/oplib.h>
-#include <asm/pgtable.h>
-#include <asm/irq.h>
-
-/* #define SOCALDEBUG */
-/* #define HAVE_SOCAL_UCODE */
-/* #define USE_64BIT_MODE */
-
-#include "fcp_impl.h"
-#include "socal.h"
-#ifdef HAVE_SOCAL_UCODE
-#include "socal_asm.h"
-#endif
-
-#define socal_printk printk ("socal%d: ", s->socal_no); printk 
-
-#ifdef SOCALDEBUG
-#define SOD(x)  socal_printk x;
-#else
-#define SOD(x)
-#endif
-
-#define for_each_socal(s) for (s = socals; s; s = s->next)
-struct socal *socals = NULL;
-
-static void socal_copy_from_xram(void *d, void __iomem *xram, long size)
-{
-        u32 *dp = (u32 *) d;
-        while (size) {
-                *dp++ = sbus_readl(xram);
-                xram += sizeof(u32);
-                size -= sizeof(u32);
-        }
-}
-
-static void socal_copy_to_xram(void __iomem *xram, void *s, long size)
-{
-        u32 *sp = (u32 *) s;
-        while (size) {
-                u32 val = *sp++;
-                sbus_writel(val, xram);
-                xram += sizeof(u32);
-                size -= sizeof(u32);
-        }
-}
-
-#ifdef HAVE_SOCAL_UCODE
-static void socal_bzero(unsigned long xram, int size)
-{
-        while (size) {
-                sbus_writel(0, xram);
-                xram += sizeof(u32);
-                size -= sizeof(u32);
-        }
-}
-#endif
-
-static inline void socal_disable(struct socal *s)
-{
-        sbus_writel(0, s->regs + IMASK);
-        sbus_writel(SOCAL_CMD_SOFT_RESET, s->regs + CMD);
-}
-
-static inline void socal_enable(struct socal *s)
-{
-        SOD(("enable %08x\n", s->cfg))
-        sbus_writel(0, s->regs + SAE);
-        sbus_writel(s->cfg, s->regs + CFG);
-        sbus_writel(SOCAL_CMD_RSP_QALL, s->regs + CMD);
-        SOCAL_SETIMASK(s, SOCAL_IMASK_RSP_QALL | SOCAL_IMASK_SAE);
-        SOD(("imask %08x %08x\n", s->imask, sbus_readl(s->regs + IMASK)));
-}
-
-static void socal_reset(fc_channel *fc)
-{
-        socal_port *port = (socal_port *)fc;
-        struct socal *s = port->s;
-        
-        /* FIXME */
-        socal_disable(s);
-        s->req[0].seqno = 1;
-        s->req[1].seqno = 1;
-        s->rsp[0].seqno = 1;
-        s->rsp[1].seqno = 1;
-        s->req[0].in = 0;
-        s->req[1].in = 0;
-        s->rsp[0].in = 0;
-        s->rsp[1].in = 0;
-        s->req[0].out = 0;
-        s->req[1].out = 0;
-        s->rsp[0].out = 0;
-        s->rsp[1].out = 0;
-
-        /* FIXME */
-        socal_enable(s);
-}
-
-static inline void socal_solicited(struct socal *s, unsigned long qno)
-{
-        socal_rsp *hwrsp;
-        socal_cq *sw_cq;
-        int token;
-        int status;
-        fc_channel *fc;
-
-        sw_cq = &s->rsp[qno];
-
-        /* Finally an improvement against old SOC :) */
-        sw_cq->in = sbus_readb(s->regs + RESP + qno);
-        SOD (("socal_solicited, %d packets arrived\n",
-              (sw_cq->in - sw_cq->out) & sw_cq->last))
-        for (;;) {
-                hwrsp = (socal_rsp *)sw_cq->pool + sw_cq->out;
-                SOD(("hwrsp %p out %d\n", hwrsp, sw_cq->out))
-                
-#if defined(SOCALDEBUG) && 0
-                {
-                u32 *u = (u32 *)hwrsp;
-                SOD(("%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x\n",
-                     u[0],u[1],u[2],u[3],u[4],u[5],u[6],u[7]))
-                u += 8;
-                SOD(("%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x\n",
-                     u[0],u[1],u[2],u[3],u[4],u[5],u[6],u[7]))
-                u = (u32 *)s->xram;
-                while (u < ((u32 *)s->regs)) {
-                        if (sbus_readl(&u[0]) == 0x00003000 ||
-                            sbus_readl(&u[0]) == 0x00003801) {
-                        SOD(("Found at %04lx\n",
-                             (unsigned long)u - (unsigned long)s->xram))
-                        SOD(("  %08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x\n",
-                             sbus_readl(&u[0]), sbus_readl(&u[1]),
-                             sbus_readl(&u[2]), sbus_readl(&u[3]),
-                             sbus_readl(&u[4]), sbus_readl(&u[5]),
-                             sbus_readl(&u[6]), sbus_readl(&u[7])))
-                        u += 8;
-                        SOD(("  %08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x\n",
-                             sbus_readl(&u[0]), sbus_readl(&u[1]),
-                             sbus_readl(&u[2]), sbus_readl(&u[3]),
-                             sbus_readl(&u[4]), sbus_readl(&u[5]),
-                             sbus_readl(&u[6]), sbus_readl(&u[7])))
-                        u -= 8;
-                        }
-                        u++;
-                }
-                }
-#endif
-
-                token = hwrsp->shdr.token;
-                status = hwrsp->status;
-                fc = (fc_channel *)(&s->port[(token >> 11) & 1]);
-                
-                SOD(("Solicited token %08x status %08x\n", token, status))
-                if (status == SOCAL_OK) {
-                        fcp_receive_solicited(fc, token >> 12,
-                                              token & ((1 << 11) - 1),
-                                              FC_STATUS_OK, NULL);
-                } else {
-                        /* We have intentionally defined FC_STATUS_* constants
-                         * to match SOCAL_* constants, otherwise we'd have to
-                         * translate status.
-                         */
-                        fcp_receive_solicited(fc, token >> 12,
-                                              token & ((1 << 11) - 1), status, &hwrsp->fchdr);
-                }
-                        
-                if (++sw_cq->out > sw_cq->last) {
-                        sw_cq->seqno++;
-                        sw_cq->out = 0;
-                }
-                
-                if (sw_cq->out == sw_cq->in) {
-                        sw_cq->in = sbus_readb(s->regs + RESP + qno);
-                        if (sw_cq->out == sw_cq->in) {
-                                /* Tell the hardware about it */
-                                sbus_writel((sw_cq->out << 24) |
-                                            (SOCAL_CMD_RSP_QALL &
-                                             ~(SOCAL_CMD_RSP_Q0 << qno)),
-                                            s->regs + CMD);
-
-                                /* Read it, so that we're sure it has been updated */
-                                sbus_readl(s->regs + CMD);
-                                sw_cq->in = sbus_readb(s->regs + RESP + qno);
-                                if (sw_cq->out == sw_cq->in)
-                                        break;
-                        }
-                }
-        }
-}
-
-static inline void socal_request (struct socal *s, u32 cmd)
-{
-        SOCAL_SETIMASK(s, s->imask & ~(cmd & SOCAL_CMD_REQ_QALL));
-        SOD(("imask %08x %08x\n", s->imask, sbus_readl(s->regs + IMASK)));
-
-        SOD(("Queues available %08x OUT %X\n", cmd, s->regs->reqpr[0]))
-        if (s->port[s->curr_port].fc.state != FC_STATE_OFFLINE) {
-                fcp_queue_empty ((fc_channel *)&(s->port[s->curr_port]));
-                if (((s->req[1].in + 1) & s->req[1].last) != (s->req[1].out))
-                        fcp_queue_empty ((fc_channel *)&(s->port[1 - s->curr_port]));
-        } else {
-                fcp_queue_empty ((fc_channel *)&(s->port[1 - s->curr_port]));
-        }
-        if (s->port[1 - s->curr_port].fc.state != FC_STATE_OFFLINE)
-                s->curr_port ^= 1;
-}
-
-static inline void socal_unsolicited (struct socal *s, unsigned long qno)
-{
-        socal_rsp *hwrsp, *hwrspc;
-        socal_cq *sw_cq;
-        int count;
-        int status;
-        int flags;
-        fc_channel *fc;
-
-        sw_cq = &s->rsp[qno];
-
-        sw_cq->in = sbus_readb(s->regs + RESP + qno);
-        SOD (("socal_unsolicited, %d packets arrived, in %d\n",
-              (sw_cq->in - sw_cq->out) & sw_cq->last, sw_cq->in))
-        while (sw_cq->in != sw_cq->out) {
-                /* ...real work per entry here... */
-                hwrsp = (socal_rsp *)sw_cq->pool + sw_cq->out;
-                SOD(("hwrsp %p out %d\n", hwrsp, sw_cq->out))
-
-#if defined(SOCALDEBUG) && 0
-                {
-                u32 *u = (u32 *)hwrsp;
-                SOD(("%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x\n",
-                     u[0],u[1],u[2],u[3],u[4],u[5],u[6],u[7]))
-                u += 8;
-                SOD(("%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x\n",
-                     u[0],u[1],u[2],u[3],u[4],u[5],u[6],u[7]))
-                }
-#endif
-
-                hwrspc = NULL;
-                flags = hwrsp->shdr.flags;
-                count = hwrsp->count;
-                fc = (fc_channel *)&s->port[flags & SOCAL_PORT_B];
-                SOD(("FC %08lx\n", (long)fc))
-                
-                if (count != 1) {
-                        /* Ugh, continuation entries */
-                        u8 in;
-
-                        if (count != 2) {
-                                printk("%s: Too many continuations entries %d\n",
-                                       fc->name, count);
-                                goto update_out;
-                        }
-                        
-                        in = sw_cq->in;
-                        if (in < sw_cq->out)
-                                in += sw_cq->last + 1;
-                        if (in < sw_cq->out + 2) {
-                                /* Ask the hardware if they haven't arrived yet. */
-                                sbus_writel((sw_cq->out << 24) |
-                                            (SOCAL_CMD_RSP_QALL &
-                                             ~(SOCAL_CMD_RSP_Q0 << qno)),
-                                            s->regs + CMD);
-
-                                /* Read it, so that we're sure it has been updated */
-                                sbus_readl(s->regs + CMD);
-                                sw_cq->in = sbus_readb(s->regs + RESP + qno);
-                                in = sw_cq->in;
-                                if (in < sw_cq->out)
-                                        in += sw_cq->last + 1;
-                                if (in < sw_cq->out + 2) /* Nothing came, let us wait */
-                                        return;
-                        }
-                        if (sw_cq->out == sw_cq->last)
-                                hwrspc = (socal_rsp *)sw_cq->pool;
-                        else
-                                hwrspc = hwrsp + 1;
-                }
-                
-                switch (flags & ~SOCAL_PORT_B) {
-                case SOCAL_STATUS:
-                        status = hwrsp->status;
-                        switch (status) {
-                        case SOCAL_ONLINE:
-                                SOD(("State change to ONLINE\n"));
-                                fcp_state_change(fc, FC_STATE_ONLINE);
-                                break;
-                        case SOCAL_ONLINE_LOOP:
-                                SOD(("State change to ONLINE_LOOP\n"));
-                                fcp_state_change(fc, FC_STATE_ONLINE);
-                                break;
-                        case SOCAL_OFFLINE:
-                                SOD(("State change to OFFLINE\n"));
-                                fcp_state_change(fc, FC_STATE_OFFLINE);
-                                break;
-                        default:
-                                printk ("%s: Unknown STATUS no %d\n",
-                                        fc->name, status);
-                                break;
-                        };
-
-                        break;
-                case (SOCAL_UNSOLICITED|SOCAL_FC_HDR):
-                        {
-                                int r_ctl = *((u8 *)&hwrsp->fchdr);
-                                unsigned len;
-                                
-                                if ((r_ctl & 0xf0) == R_CTL_EXTENDED_SVC) {
-                                        len = hwrsp->shdr.bytecnt;
-                                        if (len < 4 || !hwrspc) {
-                                                printk ("%s: Invalid R_CTL %02x "
-                                                        "continuation entries\n",
-                                                        fc->name, r_ctl);
-                                        } else {
-                                                if (len > 60)
-                                                        len = 60;
-                                                if (*(u32 *)hwrspc == LS_DISPLAY) {
-                                                        int i;
-                                                        
-                                                        for (i = 4; i < len; i++)
-                                                                if (((u8 *)hwrspc)[i] == '\n')
-                                                                        ((u8 *)hwrspc)[i] = ' ';
-                                                        ((u8 *)hwrspc)[len] = 0;
-                                                        printk ("%s message: %s\n",
-                                                                fc->name, ((u8 *)hwrspc) + 4);
-                                                } else {
-                                                        printk ("%s: Unknown LS_CMD "
-                                                                "%08x\n", fc->name,
-                                                                *(u32 *)hwrspc);
-                                                }
-                                        }
-                                } else {
-                                        printk ("%s: Unsolicited R_CTL %02x "
-                                                "not handled\n", fc->name, r_ctl);
-                                }
-                        }
-                        break;
-                default:
-                        printk ("%s: Unexpected flags %08x\n", fc->name, flags);
-                        break;
-                };
-update_out:
-                if (++sw_cq->out > sw_cq->last) {
-                        sw_cq->seqno++;
-                        sw_cq->out = 0;
-                }
-                
-                if (hwrspc) {
-                        if (++sw_cq->out > sw_cq->last) {
-                                sw_cq->seqno++;
-                                sw_cq->out = 0;
-                        }
-                }
-                
-                if (sw_cq->out == sw_cq->in) {
-                        sw_cq->in = sbus_readb(s->regs + RESP + qno);
-                        if (sw_cq->out == sw_cq->in) {
-                                /* Tell the hardware about it */
-                                sbus_writel((sw_cq->out << 24) |
-                                            (SOCAL_CMD_RSP_QALL &
-                                             ~(SOCAL_CMD_RSP_Q0 << qno)),
-                                            s->regs + CMD);
-
-                                /* Read it, so that we're sure it has been updated */
-                                sbus_readl(s->regs + CMD);
-                                sw_cq->in = sbus_readb(s->regs + RESP + qno);
-                        }
-                }
-        }
-}
-
-static irqreturn_t socal_intr(int irq, void *dev_id)
-{
-        u32 cmd;
-        unsigned long flags;
-        register struct socal *s = (struct socal *)dev_id;
-
-        spin_lock_irqsave(&s->lock, flags);
-        cmd = sbus_readl(s->regs + CMD);
-        for (; (cmd = SOCAL_INTR (s, cmd)); cmd = sbus_readl(s->regs + CMD)) {
-#ifdef SOCALDEBUG
-                static int cnt = 0;
-                if (cnt++ < 50)
-                        printk("soc_intr %08x\n", cmd);
-#endif  
-                if (cmd & SOCAL_CMD_RSP_Q2)
-                        socal_unsolicited (s, SOCAL_UNSOLICITED_RSP_Q);
-                if (cmd & SOCAL_CMD_RSP_Q1)
-                        socal_unsolicited (s, SOCAL_SOLICITED_BAD_RSP_Q);
-                if (cmd & SOCAL_CMD_RSP_Q0)
-                        socal_solicited (s, SOCAL_SOLICITED_RSP_Q);
-                if (cmd & SOCAL_CMD_REQ_QALL)
-                        socal_request (s, cmd);
-        }
-        spin_unlock_irqrestore(&s->lock, flags);
-
-        return IRQ_HANDLED;
-}
-
-#define TOKEN(proto, port, token) (((proto)<<12)|(token)|(port))
-
-static int socal_hw_enque (fc_channel *fc, fcp_cmnd *fcmd)
-{
-        socal_port *port = (socal_port *)fc;
-        struct socal *s = port->s;
-        unsigned long qno;
-        socal_cq *sw_cq;
-        int cq_next_in;
-        socal_req *request;
-        fc_hdr *fch;
-        int i;
-
-        if (fcmd->proto == TYPE_SCSI_FCP)
-                qno = 1;
-        else
-                qno = 0;
-        SOD(("Putting a FCP packet type %d into hw queue %d\n", fcmd->proto, qno))
-        if (s->imask & (SOCAL_IMASK_REQ_Q0 << qno)) {
-                SOD(("EIO %08x\n", s->imask))
-                return -EIO;
-        }
-        sw_cq = s->req + qno;
-        cq_next_in = (sw_cq->in + 1) & sw_cq->last;
-        
-        if (cq_next_in == sw_cq->out &&
-            cq_next_in == (sw_cq->out = sbus_readb(s->regs + REQP + qno))) {
-                SOD(("%d IN %d OUT %d LAST %d\n",
-                     qno, sw_cq->in,
-                     sw_cq->out, sw_cq->last))
-                SOCAL_SETIMASK(s, s->imask | (SOCAL_IMASK_REQ_Q0 << qno));
-                SOD(("imask %08x %08x\n", s->imask, sbus_readl(s->regs + IMASK)));
-
-                /* If queue is full, just say NO. */
-                return -EBUSY;
-        }
-        
-        request = sw_cq->pool + sw_cq->in;
-        fch = &request->fchdr;
-        
-        switch (fcmd->proto) {
-        case TYPE_SCSI_FCP:
-                request->shdr.token = TOKEN(TYPE_SCSI_FCP, port->mask, fcmd->token); 
-                request->data[0].base = fc->dma_scsi_cmd + fcmd->token * sizeof(fcp_cmd);
-                request->data[0].count = sizeof(fcp_cmd);
-                request->data[1].base = fc->dma_scsi_rsp + fcmd->token * fc->rsp_size;
-                request->data[1].count = fc->rsp_size;
-                if (fcmd->data) {
-                        request->shdr.segcnt = 3;
-                        i = fc->scsi_cmd_pool[fcmd->token].fcp_data_len;
-                        request->shdr.bytecnt = i;
-                        request->data[2].base = fcmd->data;
-                        request->data[2].count = i;
-                        request->type = (fc->scsi_cmd_pool[fcmd->token].fcp_cntl & FCP_CNTL_WRITE) ?
-                                SOCAL_CQTYPE_IO_WRITE : SOCAL_CQTYPE_IO_READ;
-                } else {
-                        request->shdr.segcnt = 2;
-                        request->shdr.bytecnt = 0;
-                        request->data[2].base = 0;
-                        request->data[2].count = 0;
-                        request->type = SOCAL_CQTYPE_SIMPLE;
-                }
-                FILL_FCHDR_RCTL_DID(fch, R_CTL_COMMAND, fcmd->did);
-                FILL_FCHDR_SID(fch, fc->sid);
-                FILL_FCHDR_TYPE_FCTL(fch, TYPE_SCSI_FCP, F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE);
-                FILL_FCHDR_SEQ_DF_SEQ(fch, 0, 0, 0);
-                FILL_FCHDR_OXRX(fch, 0xffff, 0xffff);
-                fch->param = 0;
-                request->shdr.flags = port->flags;
-                request->shdr.class = fc->posmap ? 3 : 2;
-                break;
-                
-        case PROTO_OFFLINE:
-                memset (request, 0, sizeof(*request));
-                request->shdr.token = TOKEN(PROTO_OFFLINE, port->mask, fcmd->token); 
-                request->type = SOCAL_CQTYPE_OFFLINE;
-                FILL_FCHDR_RCTL_DID(fch, R_CTL_COMMAND, fcmd->did);
-                FILL_FCHDR_SID(fch, fc->sid);
-                FILL_FCHDR_TYPE_FCTL(fch, TYPE_SCSI_FCP, F_CTL_FIRST_SEQ | F_CTL_SEQ_INITIATIVE);
-                FILL_FCHDR_SEQ_DF_SEQ(fch, 0, 0, 0);
-                FILL_FCHDR_OXRX(fch, 0xffff, 0xffff);
-                request->shdr.flags = port->flags;
-                break;
-                
-        case PROTO_REPORT_AL_MAP:
-                memset (request, 0, sizeof(*request));
-                request->shdr.token = TOKEN(PROTO_REPORT_AL_MAP, port->mask, fcmd->token); 
-                request->type = SOCAL_CQTYPE_REPORT_MAP;
-                request->shdr.flags = port->flags;
-                request->shdr.segcnt = 1;
-                request->shdr.bytecnt = sizeof(fc_al_posmap);
-                request->data[0].base = fcmd->cmd;
-                request->data[0].count = sizeof(fc_al_posmap);
-                break;
-
-        default: 
-                request->shdr.token = TOKEN(fcmd->proto, port->mask, fcmd->token);
-                request->shdr.class = fc->posmap ? 3 : 2;
-                request->shdr.flags = port->flags;
-                memcpy (fch, &fcmd->fch, sizeof(fc_hdr));
-                request->data[0].count = fcmd->cmdlen;
-                request->data[1].count = fcmd->rsplen;
-                request->type = fcmd->class;
-                switch (fcmd->class) {
-                case FC_CLASS_OUTBOUND:
-                        request->data[0].base = fcmd->cmd;
-                        request->data[0].count = fcmd->cmdlen;
-                        request->type = SOCAL_CQTYPE_OUTBOUND;
-                        request->shdr.bytecnt = fcmd->cmdlen;
-                        request->shdr.segcnt = 1;
-                        break;
-                case FC_CLASS_INBOUND:
-                        request->data[0].base = fcmd->rsp;
-                        request->data[0].count = fcmd->rsplen;
-                        request->type = SOCAL_CQTYPE_INBOUND;
-                        request->shdr.bytecnt = 0;
-                        request->shdr.segcnt = 1;
-                        break;
-                case FC_CLASS_SIMPLE:
-                        request->data[0].base = fcmd->cmd;
-                        request->data[1].base = fcmd->rsp;
-                        request->data[0].count = fcmd->cmdlen;
-                        request->data[1].count = fcmd->rsplen;
-                        request->type = SOCAL_CQTYPE_SIMPLE;
-                        request->shdr.bytecnt = fcmd->cmdlen;
-                        request->shdr.segcnt = 2;
-                        break;
-                case FC_CLASS_IO_READ:
-                case FC_CLASS_IO_WRITE:
-                        request->data[0].base = fcmd->cmd;
-                        request->data[1].base = fcmd->rsp;
-                        request->data[0].count = fcmd->cmdlen;
-                        request->data[1].count = fcmd->rsplen;
-                        request->type = (fcmd->class == FC_CLASS_IO_READ) ? SOCAL_CQTYPE_IO_READ : SOCAL_CQTYPE_IO_WRITE;
-                        if (fcmd->data) {
-                                request->data[2].base = fcmd->data;
-                                request->data[2].count = fcmd->datalen;
-                                request->shdr.bytecnt = fcmd->datalen;
-                                request->shdr.segcnt = 3;
-                        } else {
-                                request->shdr.bytecnt = 0;
-                                request->shdr.segcnt = 2;
-                        }
-                        break;
-                }
-                break;
-        }
-
-        request->count = 1;
-        request->flags = 0;
-        request->seqno = sw_cq->seqno;
-        
-        SOD(("queueing token %08x\n", request->shdr.token))
-        
-        /* And now tell the SOCAL about it */
-
-        if (++sw_cq->in > sw_cq->last) {
-                sw_cq->in = 0;
-                sw_cq->seqno++;
-        }
-        
-        SOD(("Putting %08x into cmd\n", SOCAL_CMD_RSP_QALL | (sw_cq->in << 24) | (SOCAL_CMD_REQ_Q0 << qno)))
-        
-        sbus_writel(SOCAL_CMD_RSP_QALL | (sw_cq->in << 24) | (SOCAL_CMD_REQ_Q0 << qno),
-                    s->regs + CMD);
-
-        /* Read so that command is completed */ 
-        sbus_readl(s->regs + CMD);
-        
-        return 0;
-}
-
-static inline void socal_download_fw(struct socal *s)
-{
-#ifdef HAVE_SOCAL_UCODE
-        SOD(("Loading %ld bytes from %p to %p\n", sizeof(socal_ucode), socal_ucode, s->xram))
-        socal_copy_to_xram(s->xram, socal_ucode, sizeof(socal_ucode));
-        SOD(("Clearing the rest of memory\n"))
-        socal_bzero (s->xram + sizeof(socal_ucode), 65536 - sizeof(socal_ucode));
-        SOD(("Done\n"))
-#endif
-}
-
-/* Check for what the best SBUS burst we can use happens
- * to be on this machine.
- */
-static inline void socal_init_bursts(struct socal *s, struct sbus_dev *sdev)
-{
-        int bsizes, bsizes_more;
-        u32 cfg;
-
-        bsizes = (prom_getintdefault(sdev->prom_node,"burst-sizes",0xff) & 0xff);
-        bsizes_more = (prom_getintdefault(sdev->bus->prom_node, "burst-sizes", 0xff) & 0xff);
-        bsizes &= bsizes_more;
-#ifdef USE_64BIT_MODE
-#ifdef __sparc_v9__
-        mmu_set_sbus64(sdev, bsizes >> 16);
-#endif
-#endif
-        if ((bsizes & 0x7f) == 0x7f)
-                cfg = SOCAL_CFG_BURST_64;
-        else if ((bsizes & 0x3f) == 0x3f) 
-                cfg = SOCAL_CFG_BURST_32;
-        else if ((bsizes & 0x1f) == 0x1f)
-                cfg = SOCAL_CFG_BURST_16;
-        else
-                cfg = SOCAL_CFG_BURST_4;
-#ifdef USE_64BIT_MODE
-#ifdef __sparc_v9__
-        /* What is BURST_128? -jj */
-        if ((bsizes & 0x780000) == 0x780000)
-                cfg |= (SOCAL_CFG_BURST_64 << 8) | SOCAL_CFG_SBUS_ENHANCED;
-        else if ((bsizes & 0x380000) == 0x380000) 
-                cfg |= (SOCAL_CFG_BURST_32 << 8) | SOCAL_CFG_SBUS_ENHANCED;
-        else if ((bsizes & 0x180000) == 0x180000)
-                cfg |= (SOCAL_CFG_BURST_16 << 8) | SOCAL_CFG_SBUS_ENHANCED;
-        else
-                cfg |= (SOCAL_CFG_BURST_8 << 8) | SOCAL_CFG_SBUS_ENHANCED;
-#endif
-#endif          
-        s->cfg = cfg;
-}
-
-static inline void socal_init(struct sbus_dev *sdev, int no)
-{
-        unsigned char tmp[60];
-        int propl;
-        struct socal *s;
-        static unsigned version_printed = 0;
-        socal_hw_cq cq[8];
-        int size, i;
-        int irq, node;
-        
-        s = kzalloc (sizeof (struct socal), GFP_KERNEL);
-        if (!s) return;
-        spin_lock_init(&s->lock);
-        s->socal_no = no;
-
-        SOD(("socals %08lx socal_intr %08lx socal_hw_enque %08lx\n",
-             (long)socals, (long)socal_intr, (long)socal_hw_enque))
-        if (version_printed++ == 0)
-                printk (version);
-
-        s->port[0].fc.module = THIS_MODULE;
-        s->port[1].fc.module = THIS_MODULE;
-                                        
-        s->next = socals;
-        socals = s;
-        s->port[0].fc.dev = sdev;
-        s->port[1].fc.dev = sdev;
-        s->port[0].s = s;
-        s->port[1].s = s;
-
-        s->port[0].fc.next = &s->port[1].fc;
-
-        /* World Wide Name of SOCAL */
-        propl = prom_getproperty (sdev->prom_node, "wwn", tmp, sizeof(tmp));
-        if (propl != sizeof (fc_wwn)) {
-                s->wwn.naaid = NAAID_IEEE_REG;
-                s->wwn.nportid = 0x123;
-                s->wwn.hi = 0x1234;
-                s->wwn.lo = 0x12345678;
-        } else
-                memcpy (&s->wwn, tmp, sizeof (fc_wwn));
-        
-        memcpy (&s->port[0].fc.wwn_nport, &s->wwn, sizeof (fc_wwn));
-        s->port[0].fc.wwn_nport.lo++;
-        memcpy (&s->port[1].fc.wwn_nport, &s->wwn, sizeof (fc_wwn));
-        s->port[1].fc.wwn_nport.lo+=2;
-        
-        node = prom_getchild (sdev->prom_node);
-        while (node && (node = prom_searchsiblings (node, "sf"))) {
-                int port;
-                
-                port = prom_getintdefault(node, "port#", -1);
-                switch (port) {
-                case 0:
-                case 1:
-                        if (prom_getproplen(node, "port-wwn") == sizeof (fc_wwn))
-                                prom_getproperty (node, "port-wwn", 
-                                                  (char *)&s->port[port].fc.wwn_nport,
-                                                  sizeof (fc_wwn));
-                        break;
-                default:
-                        break;
-                };
-
-                node = prom_getsibling(node);
-        }
-
-        memcpy (&s->port[0].fc.wwn_node, &s->wwn, sizeof (fc_wwn));
-        memcpy (&s->port[1].fc.wwn_node, &s->wwn, sizeof (fc_wwn));
-        SOD(("Got wwns %08x%08x ports %08x%08x and %08x%08x\n", 
-             *(u32 *)&s->port[0].fc.wwn_node, s->port[0].fc.wwn_node.lo,
-             *(u32 *)&s->port[0].fc.wwn_nport, s->port[0].fc.wwn_nport.lo,
-             *(u32 *)&s->port[1].fc.wwn_nport, s->port[1].fc.wwn_nport.lo))
-                
-        s->port[0].fc.sid = 1;
-        s->port[1].fc.sid = 17;
-        s->port[0].fc.did = 2;
-        s->port[1].fc.did = 18;
-        
-        s->port[0].fc.reset = socal_reset;
-        s->port[1].fc.reset = socal_reset;
-        
-        if (sdev->num_registers == 1) {
-                s->eeprom = sbus_ioremap(&sdev->resource[0], 0,
-                                         sdev->reg_addrs[0].reg_size, "socal xram");
-                if (sdev->reg_addrs[0].reg_size > 0x20000)
-                        s->xram = s->eeprom + 0x10000UL;
-                else
-                        s->xram = s->eeprom;
-                s->regs = (s->xram + 0x10000UL);
-        } else {
-                /* E.g. starfire presents 3 registers for SOCAL */
-                s->xram = sbus_ioremap(&sdev->resource[1], 0,
-                                       sdev->reg_addrs[1].reg_size, "socal xram");
-                s->regs = sbus_ioremap(&sdev->resource[2], 0,
-                                       sdev->reg_addrs[2].reg_size, "socal regs");
-        }
-        
-        socal_init_bursts(s, sdev);
-        
-        SOD(("Disabling SOCAL\n"))
-        
-        socal_disable (s);
-        
-        irq = sdev->irqs[0];
-
-        if (request_irq (irq, socal_intr, IRQF_SHARED, "SOCAL", (void *)s)) {
-                socal_printk ("Cannot order irq %d to go\n", irq);
-                socals = s->next;
-                return;
-        }
-
-        SOD(("SOCAL uses IRQ %d\n", irq))
-        
-        s->port[0].fc.irq = irq;
-        s->port[1].fc.irq = irq;
-        
-        sprintf (s->port[0].fc.name, "socal%d port A", no);
-        sprintf (s->port[1].fc.name, "socal%d port B", no);
-        s->port[0].flags = SOCAL_FC_HDR | SOCAL_PORT_A;
-        s->port[1].flags = SOCAL_FC_HDR | SOCAL_PORT_B;
-        s->port[1].mask = (1 << 11);
-        
-        s->port[0].fc.hw_enque = socal_hw_enque;
-        s->port[1].fc.hw_enque = socal_hw_enque;
-        
-        socal_download_fw (s);
-        
-        SOD(("Downloaded firmware\n"))
-
-        /* Now setup xram circular queues */
-        memset (cq, 0, sizeof(cq));
-
-        size = (SOCAL_CQ_REQ0_SIZE + SOCAL_CQ_REQ1_SIZE +
-                SOCAL_CQ_RSP0_SIZE + SOCAL_CQ_RSP1_SIZE +
-                SOCAL_CQ_RSP2_SIZE) * sizeof(socal_req);
-        s->req_cpu = sbus_alloc_consistent(sdev, size, &s->req_dvma);
-        s->req[0].pool = s->req_cpu;
-        cq[0].address = s->req_dvma;
-        s->req[1].pool = s->req[0].pool + SOCAL_CQ_REQ0_SIZE;
-        s->rsp[0].pool = s->req[1].pool + SOCAL_CQ_REQ1_SIZE;
-        s->rsp[1].pool = s->rsp[0].pool + SOCAL_CQ_RSP0_SIZE;
-        s->rsp[2].pool = s->rsp[1].pool + SOCAL_CQ_RSP1_SIZE;
-        
-        s->req[0].hw_cq = (socal_hw_cq __iomem *)(s->xram + SOCAL_CQ_REQ_OFFSET);
-        s->req[1].hw_cq = (socal_hw_cq __iomem *)(s->xram + SOCAL_CQ_REQ_OFFSET + sizeof(socal_hw_cq));
-        s->rsp[0].hw_cq = (socal_hw_cq __iomem *)(s->xram + SOCAL_CQ_RSP_OFFSET);
-        s->rsp[1].hw_cq = (socal_hw_cq __iomem *)(s->xram + SOCAL_CQ_RSP_OFFSET + sizeof(socal_hw_cq));
-        s->rsp[2].hw_cq = (socal_hw_cq __iomem *)(s->xram + SOCAL_CQ_RSP_OFFSET + 2 * sizeof(socal_hw_cq));
-        
-        cq[1].address = cq[0].address + (SOCAL_CQ_REQ0_SIZE * sizeof(socal_req));
-        cq[4].address = cq[1].address + (SOCAL_CQ_REQ1_SIZE * sizeof(socal_req));
-        cq[5].address = cq[4].address + (SOCAL_CQ_RSP0_SIZE * sizeof(socal_req));
-        cq[6].address = cq[5].address + (SOCAL_CQ_RSP1_SIZE * sizeof(socal_req));
-
-        cq[0].last = SOCAL_CQ_REQ0_SIZE - 1;
-        cq[1].last = SOCAL_CQ_REQ1_SIZE - 1;
-        cq[4].last = SOCAL_CQ_RSP0_SIZE - 1;
-        cq[5].last = SOCAL_CQ_RSP1_SIZE - 1;
-        cq[6].last = SOCAL_CQ_RSP2_SIZE - 1;
-        for (i = 0; i < 8; i++)
-                cq[i].seqno = 1;
-        
-        s->req[0].last = SOCAL_CQ_REQ0_SIZE - 1;
-        s->req[1].last = SOCAL_CQ_REQ1_SIZE - 1;
-        s->rsp[0].last = SOCAL_CQ_RSP0_SIZE - 1;
-        s->rsp[1].last = SOCAL_CQ_RSP1_SIZE - 1;
-        s->rsp[2].last = SOCAL_CQ_RSP2_SIZE - 1;
-        
-        s->req[0].seqno = 1;
-        s->req[1].seqno = 1;
-        s->rsp[0].seqno = 1;
-        s->rsp[1].seqno = 1;
-        s->rsp[2].seqno = 1;
-        
-        socal_copy_to_xram(s->xram + SOCAL_CQ_REQ_OFFSET, cq, sizeof(cq));
-        
-        SOD(("Setting up params\n"))
-        
-        /* Make our sw copy of SOCAL service parameters */
-        socal_copy_from_xram(s->serv_params, s->xram + 0x280, sizeof (s->serv_params));
-        
-        s->port[0].fc.common_svc = (common_svc_parm *)s->serv_params;
-        s->port[0].fc.class_svcs = (svc_parm *)(s->serv_params + 0x20);
-        s->port[1].fc.common_svc = (common_svc_parm *)&s->serv_params;
-        s->port[1].fc.class_svcs = (svc_parm *)(s->serv_params + 0x20);
-        
-        socal_enable (s);
-        
-        SOD(("Enabled SOCAL\n"))
-}
-
-static int __init socal_probe(void)
-{
-        struct sbus_bus *sbus;
-        struct sbus_dev *sdev = NULL;
-        struct socal *s;
-        int cards = 0;
-
-        for_each_sbus(sbus) {
-                for_each_sbusdev(sdev, sbus) {
-                        if(!strcmp(sdev->prom_name, "SUNW,socal")) {
-                                socal_init(sdev, cards);
-                                cards++;
-                        }
-                }
-        }
-        if (!cards)
-                return -EIO;
-
-        for_each_socal(s)
-                if (s->next)
-                        s->port[1].fc.next = &s->next->port[0].fc;
-                        
-        fcp_init (&socals->port[0].fc);
-        return 0;
-}
-
-static void __exit socal_cleanup(void)
-{
-        struct socal *s;
-        int irq;
-        struct sbus_dev *sdev;
-        
-        for_each_socal(s) {
-                irq = s->port[0].fc.irq;
-                free_irq (irq, s);
-
-                fcp_release(&(s->port[0].fc), 2);
-
-                sdev = s->port[0].fc.dev;
-                if (sdev->num_registers == 1) {
-                        sbus_iounmap(s->eeprom, sdev->reg_addrs[0].reg_size);
-                } else {
-                        sbus_iounmap(s->xram, sdev->reg_addrs[1].reg_size);
-                        sbus_iounmap(s->regs, sdev->reg_addrs[2].reg_size);
-                }
-                sbus_free_consistent(sdev,
-                                     (SOCAL_CQ_REQ0_SIZE + SOCAL_CQ_REQ1_SIZE +
-                                      SOCAL_CQ_RSP0_SIZE + SOCAL_CQ_RSP1_SIZE +
-                                      SOCAL_CQ_RSP2_SIZE) * sizeof(socal_req),
-                                     s->req_cpu, s->req_dvma);
-        }
-}
-
-module_init(socal_probe);
-module_exit(socal_cleanup);
-MODULE_LICENSE("GPL");
diff --git a/drivers/fc4/socal.h b/drivers/fc4/socal.h
deleted file mode 100644
index 774edf68e4d2..000000000000
--- a/drivers/fc4/socal.h
+++ /dev/null
@@ -1,314 +0,0 @@
-/* socal.h: Definitions for Sparc SUNW,socal (SOC+) Fibre Channel Sbus driver.
- *
- * Copyright (C) 1998,1999 Jakub Jelinek (jj@ultra.linux.cz)
- */
-
-#ifndef __SOCAL_H
-#define __SOCAL_H
-
-#include "fc.h"
-#include "fcp.h"
-#include "fcp_impl.h"
-
-/* Hardware register offsets and constants first {{{ */
-#define CFG     0x00UL
-#define SAE     0x04UL
-#define CMD     0x08UL
-#define IMASK   0x0cUL
-#define REQP    0x10UL
-#define RESP    0x14UL
-
-/* Config Register */
-#define SOCAL_CFG_EXT_RAM_BANK_MASK     0x07000000
-#define SOCAL_CFG_EEPROM_BANK_MASK      0x00030000
-#define SOCAL_CFG_BURST64_MASK          0x00000700
-#define SOCAL_CFG_SBUS_PARITY_TEST      0x00000020
-#define SOCAL_CFG_SBUS_PARITY_CHECK     0x00000010
-#define SOCAL_CFG_SBUS_ENHANCED         0x00000008
-#define SOCAL_CFG_BURST_MASK            0x00000007
-/* Bursts */
-#define SOCAL_CFG_BURST_4               0x00000000
-#define SOCAL_CFG_BURST_8               0x00000003
-#define SOCAL_CFG_BURST_16              0x00000004
-#define SOCAL_CFG_BURST_32              0x00000005
-#define SOCAL_CFG_BURST_64              0x00000006
-#define SOCAL_CFG_BURST_128             0x00000007
-
-/* Slave Access Error Register */
-#define SOCAL_SAE_ALIGNMENT             0x00000004
-#define SOCAL_SAE_UNSUPPORTED           0x00000002
-#define SOCAL_SAE_PARITY                0x00000001
-
-/* Command & Status Register */
-#define SOCAL_CMD_RSP_QALL              0x000f0000
-#define SOCAL_CMD_RSP_Q0                0x00010000
-#define SOCAL_CMD_RSP_Q1                0x00020000
-#define SOCAL_CMD_RSP_Q2                0x00040000
-#define SOCAL_CMD_RSP_Q3                0x00080000
-#define SOCAL_CMD_REQ_QALL              0x00000f00
-#define SOCAL_CMD_REQ_Q0                0x00000100
-#define SOCAL_CMD_REQ_Q1                0x00000200
-#define SOCAL_CMD_REQ_Q2                0x00000400
-#define SOCAL_CMD_REQ_Q3                0x00000800
-#define SOCAL_CMD_SAE                   0x00000080
-#define SOCAL_CMD_INTR_PENDING          0x00000008
-#define SOCAL_CMD_NON_QUEUED            0x00000004
-#define SOCAL_CMD_IDLE                  0x00000002
-#define SOCAL_CMD_SOFT_RESET            0x00000001
-
-/* Interrupt Mask Register */
-#define SOCAL_IMASK_RSP_QALL            0x000f0000
-#define SOCAL_IMASK_RSP_Q0              0x00010000
-#define SOCAL_IMASK_RSP_Q1              0x00020000
-#define SOCAL_IMASK_RSP_Q2              0x00040000
-#define SOCAL_IMASK_RSP_Q3              0x00080000
-#define SOCAL_IMASK_REQ_QALL            0x00000f00
-#define SOCAL_IMASK_REQ_Q0              0x00000100
-#define SOCAL_IMASK_REQ_Q1              0x00000200
-#define SOCAL_IMASK_REQ_Q2              0x00000400
-#define SOCAL_IMASK_REQ_Q3              0x00000800
-#define SOCAL_IMASK_SAE                 0x00000080
-#define SOCAL_IMASK_NON_QUEUED          0x00000004
-
-#define SOCAL_INTR(s, cmd) \
-        (((cmd & SOCAL_CMD_RSP_QALL) | ((~cmd) & SOCAL_CMD_REQ_QALL)) \
-         & s->imask)
-         
-#define SOCAL_SETIMASK(s, i) \
-do {    (s)->imask = (i); \
-        sbus_writel((i), (s)->regs + IMASK); \
-} while (0)
-        
-#define SOCAL_MAX_EXCHANGES             1024
-
-/* XRAM
- *
- * This is a 64KB register area.
- * From the documentation, it seems like it is finally able to cope
- * at least with 1,2,4 byte accesses for read and 2,4 byte accesses for write.
- */
- 
-/* Circular Queue */
-
-#define SOCAL_CQ_REQ_OFFSET     0x200
-#define SOCAL_CQ_RSP_OFFSET     0x220
-
-typedef struct {
-        u32                     address;
-        u8                      in;
-        u8                      out;
-        u8                      last;
-        u8                      seqno;
-} socal_hw_cq;
-
-#define SOCAL_PORT_A    0x0000  /* From/To Port A */
-#define SOCAL_PORT_B    0x0001  /* From/To Port A */
-#define SOCAL_FC_HDR    0x0002  /* Contains FC Header */
-#define SOCAL_NORSP     0x0004  /* Don't generate response nor interrupt */
-#define SOCAL_NOINT     0x0008  /* Generate response but not interrupt */
-#define SOCAL_XFERRDY   0x0010  /* Generate XFERRDY */
-#define SOCAL_IGNOREPARAM 0x0020 /* Ignore PARAM field in the FC header */
-#define SOCAL_COMPLETE  0x0040  /* Command completed */
-#define SOCAL_UNSOLICITED 0x0080 /* For request this is the packet to establish unsolicited pools, */
-                                /* for rsp this is unsolicited packet */
-#define SOCAL_STATUS    0x0100  /* State change (on/off line) */
-#define SOCAL_RSP_HDR   0x0200  /* Return frame header in any case */
-
-typedef struct {
-        u32                     token;
-        u16                     flags;
-        u8                      class;
-        u8                      segcnt;
-        u32                     bytecnt;
-} socal_hdr;
-
-typedef struct {
-        u32                     base;
-        u32                     count;
-} socal_data;
-
-#define SOCAL_CQTYPE_NOP        0x00
-#define SOCAL_CQTYPE_OUTBOUND   0x01
-#define SOCAL_CQTYPE_INBOUND    0x02
-#define SOCAL_CQTYPE_SIMPLE     0x03
-#define SOCAL_CQTYPE_IO_WRITE   0x04
-#define SOCAL_CQTYPE_IO_READ    0x05
-#define SOCAL_CQTYPE_UNSOLICITED 0x06
-#define SOCAL_CQTYPE_BYPASS_DEV 0x06
-#define SOCAL_CQTYPE_DIAG       0x07
-#define SOCAL_CQTYPE_OFFLINE    0x08
-#define SOCAL_CQTYPE_ADD_POOL   0x09
-#define SOCAL_CQTYPE_DELETE_POOL 0x0a
-#define SOCAL_CQTYPE_ADD_BUFFER 0x0b
-#define SOCAL_CQTYPE_ADD_POOL_BUFFER 0x0c
-#define SOCAL_CQTYPE_REQUEST_ABORT 0x0d
-#define SOCAL_CQTYPE_REQUEST_LIP 0x0e
-#define SOCAL_CQTYPE_REPORT_MAP 0x0f
-#define SOCAL_CQTYPE_RESPONSE   0x10
-#define SOCAL_CQTYPE_INLINE     0x20
-
-#define SOCAL_CQFLAGS_CONT      0x01
-#define SOCAL_CQFLAGS_FULL      0x02
-#define SOCAL_CQFLAGS_BADHDR    0x04
-#define SOCAL_CQFLAGS_BADPKT    0x08
-
-typedef struct {
-        socal_hdr               shdr;
-        socal_data              data[3];
-        fc_hdr                  fchdr;
-        u8                      count;
-        u8                      type;
-        u8                      flags;
-        u8                      seqno;
-} socal_req;
-
-#define SOCAL_OK                0
-#define SOCAL_P_RJT             2
-#define SOCAL_F_RJT             3
-#define SOCAL_P_BSY             4
-#define SOCAL_F_BSY             5
-#define SOCAL_ONLINE            0x10
-#define SOCAL_OFFLINE           0x11
-#define SOCAL_TIMEOUT           0x12
-#define SOCAL_OVERRUN           0x13
-#define SOCAL_ONLINE_LOOP       0x14
-#define SOCAL_OLD_PORT          0x15
-#define SOCAL_AL_PORT           0x16
-#define SOCAL_UNKOWN_CQ_TYPE    0x20
-#define SOCAL_BAD_SEG_CNT       0x21
-#define SOCAL_MAX_XCHG_EXCEEDED 0x22
-#define SOCAL_BAD_XID           0x23
-#define SOCAL_XCHG_BUSY         0x24
-#define SOCAL_BAD_POOL_ID       0x25
-#define SOCAL_INSUFFICIENT_CQES 0x26
-#define SOCAL_ALLOC_FAIL        0x27
-#define SOCAL_BAD_SID           0x28
-#define SOCAL_NO_SEG_INIT       0x29
-#define SOCAL_BAD_DID           0x2a
-#define SOCAL_ABORTED           0x30
-#define SOCAL_ABORT_FAILED      0x31
-
-typedef struct {
-        socal_hdr               shdr;
-        u32                     status;
-        socal_data              data;
-        u8                      xxx1[10];
-        u16                     ncmds;
-        fc_hdr                  fchdr;
-        u8                      count;
-        u8                      type;
-        u8                      flags;
-        u8                      seqno;
-} socal_rsp;
-
-typedef struct {
-        socal_hdr               shdr;
-        u8                      xxx1[48];
-        u8                      count;
-        u8                      type;
-        u8                      flags;
-        u8                      seqno;
-} socal_cmdonly;
-
-#define SOCAL_DIAG_NOP          0x00
-#define SOCAL_DIAG_INT_LOOP     0x01
-#define SOCAL_DIAG_EXT_LOOP     0x02
-#define SOCAL_DIAG_REM_LOOP     0x03
-#define SOCAL_DIAG_XRAM_TEST    0x04
-#define SOCAL_DIAG_SOC_TEST     0x05
-#define SOCAL_DIAG_HCB_TEST     0x06
-#define SOCAL_DIAG_SOCLB_TEST   0x07
-#define SOCAL_DIAG_SRDSLB_TEST  0x08
-#define SOCAL_DIAG_EXTOE_TEST   0x09
-
-typedef struct {
-        socal_hdr               shdr;
-        u32                     cmd;
-        u8                      xxx1[44];
-        u8                      count;
-        u8                      type;
-        u8                      flags;
-        u8                      seqno;
-} socal_diag_req;
-
-#define SOCAL_POOL_MASK_RCTL    0x800000
-#define SOCAL_POOL_MASK_DID     0x700000
-#define SOCAL_POOL_MASK_SID     0x070000
-#define SOCAL_POOL_MASK_TYPE    0x008000
-#define SOCAL_POOL_MASK_F_CTL   0x007000
-#define SOCAL_POOL_MASK_SEQ_ID  0x000800
-#define SOCAL_POOL_MASK_D_CTL   0x000400
-#define SOCAL_POOL_MASK_SEQ_CNT 0x000300
-#define SOCAL_POOL_MASK_OX_ID   0x0000f0
-#define SOCAL_POOL_MASK_PARAM   0x00000f
-
-typedef struct {
-        socal_hdr               shdr;
-        u32                     pool_id;
-        u32                     header_mask;
-        u32                     buf_size;
-        u32                     entries;
-        u8                      xxx1[8];
-        fc_hdr                  fchdr;
-        u8                      count;
-        u8                      type;
-        u8                      flags;
-        u8                      seqno;
-} socal_pool_req;
-
-/* }}} */
-
-/* Now our software structures and constants we use to drive the beast {{{ */
-
-#define SOCAL_CQ_REQ0_SIZE      4
-#define SOCAL_CQ_REQ1_SIZE      256
-#define SOCAL_CQ_RSP0_SIZE      8
-#define SOCAL_CQ_RSP1_SIZE      4
-#define SOCAL_CQ_RSP2_SIZE      4
-
-#define SOCAL_SOLICITED_RSP_Q   0
-#define SOCAL_SOLICITED_BAD_RSP_Q 1
-#define SOCAL_UNSOLICITED_RSP_Q 2
-
-struct socal;
-
-typedef struct {
-        /* This must come first */
-        fc_channel              fc;
-        struct socal            *s;
-        u16                     flags;
-        u16                     mask;
-} socal_port; 
-
-typedef struct {
-        socal_hw_cq             __iomem *hw_cq; /* Related XRAM cq */
-        socal_req               *pool;
-        u8                      in;
-        u8                      out;
-        u8                      last;
-        u8                      seqno;
-} socal_cq;
-
-struct socal {
-        spinlock_t              lock;
-        socal_port              port[2]; /* Every SOCAL has one or two FC ports */
-        socal_cq                req[4]; /* Request CQs */
-        socal_cq                rsp[4]; /* Response CQs */
-        int                     socal_no;
-        void __iomem            *regs;
-        void __iomem            *xram;
-        void __iomem            *eeprom;
-        fc_wwn                  wwn;
-        u32                     imask;  /* Our copy of regs->imask */
-        u32                     cfg;    /* Our copy of regs->cfg */
-        char                    serv_params[80];
-        struct socal            *next;
-        int                     curr_port; /* Which port will have priority to fcp_queue_empty */
-
-        socal_req *             req_cpu;
-        u32                     req_dvma;
-};
-
-/* }}} */
-
-#endif /* !(__SOCAL_H) */
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 59d4da2734c1..d0bb5b9d2120 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -1230,7 +1230,7 @@ static void quirk_jmicron_ata(struct pci_dev *pdev)
         case PCI_DEVICE_ID_JMICRON_JMB363:
                 /* Enable dual function mode, AHCI on fn 0, IDE fn1 */
                 /* Set the class codes correctly and then direct IDE 0 */
-                conf1 |= 0x00C2A102; /* Set 1, 8, 13, 15, 17, 22, 23 */
+                conf1 |= 0x00C2A1B3; /* Set 0, 1, 4, 5, 7, 8, 13, 15, 17, 22, 23 */
                 break;
 
         case PCI_DEVICE_ID_JMICRON_JMB368:
diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
index 6141389dcdb2..2e6129f13d38 100644
--- a/drivers/scsi/Makefile
+++ b/drivers/scsi/Makefile
@@ -115,7 +115,6 @@ obj-$(CONFIG_SCSI_QLOGICPTI)	+= qlogicpti.o
 obj-$(CONFIG_BLK_DEV_IDESCSI)   += ide-scsi.o
 obj-$(CONFIG_SCSI_MESH)         += mesh.o
 obj-$(CONFIG_SCSI_MAC53C94)     += mac53c94.o
-obj-$(CONFIG_SCSI_PLUTO)        += pluto.o
 obj-$(CONFIG_SCSI_DECNCR)       += NCR53C9x.o   dec_esp.o
 obj-$(CONFIG_BLK_DEV_3W_XXXX_RAID) += 3w-xxxx.o
 obj-$(CONFIG_SCSI_3W_9XXX)      += 3w-9xxx.o
@@ -123,7 +122,6 @@ obj-$(CONFIG_SCSI_PPA)		+= ppa.o
 obj-$(CONFIG_SCSI_IMM)          += imm.o
 obj-$(CONFIG_JAZZ_ESP)          += esp_scsi.o   jazz_esp.o
 obj-$(CONFIG_SUN3X_ESP)         += NCR53C9x.o   sun3x_esp.o
-obj-$(CONFIG_SCSI_FCAL)         += fcal.o
 obj-$(CONFIG_SCSI_LASI700)      += 53c700.o lasi700.o
 obj-$(CONFIG_SCSI_SNI_53C710)   += 53c700.o sni_53c710.o
 obj-$(CONFIG_SCSI_NSP32)        += nsp32.o
diff --git a/drivers/scsi/aic7xxx/aic7770.c b/drivers/scsi/aic7xxx/aic7770.c
index c4d17231c828..6d86a9be538f 100644
--- a/drivers/scsi/aic7xxx/aic7770.c
+++ b/drivers/scsi/aic7xxx/aic7770.c
@@ -60,8 +60,6 @@
 #define ID_OLV_274xD    0x04907783 /* Olivetti OEM (Differential) */
 
 static int aic7770_chip_init(struct ahc_softc *ahc);
-static int aic7770_suspend(struct ahc_softc *ahc);
-static int aic7770_resume(struct ahc_softc *ahc);
 static int aha2840_load_seeprom(struct ahc_softc *ahc);
 static ahc_device_setup_t ahc_aic7770_VL_setup;
 static ahc_device_setup_t ahc_aic7770_EISA_setup;
@@ -155,8 +153,6 @@ aic7770_config(struct ahc_softc *ahc, struct aic7770_identity *entry, u_int io)
                 return (error);
 
         ahc->bus_chip_init = aic7770_chip_init;
-        ahc->bus_suspend = aic7770_suspend;
-        ahc->bus_resume = aic7770_resume;
 
         error = ahc_reset(ahc, /*reinit*/FALSE);
         if (error != 0)
@@ -272,18 +268,6 @@ aic7770_chip_init(struct ahc_softc *ahc)
         return (ahc_chip_init(ahc));
 }
 
-static int
-aic7770_suspend(struct ahc_softc *ahc)
-{
-        return (ahc_suspend(ahc));
-}
-
-static int
-aic7770_resume(struct ahc_softc *ahc)
-{
-        return (ahc_resume(ahc));
-}
-
 /*
  * Read the 284x SEEPROM.
  */
diff --git a/drivers/scsi/aic7xxx/aic79xx.h b/drivers/scsi/aic7xxx/aic79xx.h
index 27adbb294ac1..ce638aa6005a 100644
--- a/drivers/scsi/aic7xxx/aic79xx.h
+++ b/drivers/scsi/aic7xxx/aic79xx.h
@@ -1003,8 +1003,15 @@ struct ahd_suspend_channel_state {
         uint8_t seqctl;
 };
 
+struct ahd_suspend_pci_state {
+        uint32_t  devconfig;
+        uint8_t   command;
+        uint8_t   csize_lattime;
+};
+
 struct ahd_suspend_state {
         struct  ahd_suspend_channel_state channel[2];
+        struct  ahd_suspend_pci_state pci_state;
         uint8_t optionmode;
         uint8_t dscommand0;
         uint8_t dspcistatus;
@@ -1333,6 +1340,8 @@ struct	ahd_pci_identity *ahd_find_pci_device(ahd_dev_softc_t);
 int                       ahd_pci_config(struct ahd_softc *,
                                          struct ahd_pci_identity *);
 int     ahd_pci_test_register_access(struct ahd_softc *);
+void    ahd_pci_suspend(struct ahd_softc *);
+void    ahd_pci_resume(struct ahd_softc *);
 
 /************************** SCB and SCB queue management **********************/
 void            ahd_qinfifo_requeue_tail(struct ahd_softc *ahd,
@@ -1343,6 +1352,8 @@ struct ahd_softc	*ahd_alloc(void *platform_arg, char *name);
 int                      ahd_softc_init(struct ahd_softc *);
 void                     ahd_controller_info(struct ahd_softc *ahd, char *buf);
 int                      ahd_init(struct ahd_softc *ahd);
+int                      ahd_suspend(struct ahd_softc *ahd);
+void                     ahd_resume(struct ahd_softc *ahd);
 int                      ahd_default_config(struct ahd_softc *ahd);
 int                      ahd_parse_vpddata(struct ahd_softc *ahd,
                                            struct vpd_config *vpd);
diff --git a/drivers/scsi/aic7xxx/aic79xx_core.c b/drivers/scsi/aic7xxx/aic79xx_core.c
index 05f692bd0adc..a7dd8cdda472 100644
--- a/drivers/scsi/aic7xxx/aic79xx_core.c
+++ b/drivers/scsi/aic7xxx/aic79xx_core.c
@@ -7175,7 +7175,6 @@ ahd_pause_and_flushwork(struct ahd_softc *ahd)
         ahd->flags &= ~AHD_ALL_INTERRUPTS;
 }
 
-#if 0
 int
 ahd_suspend(struct ahd_softc *ahd)
 {
@@ -7189,19 +7188,15 @@ ahd_suspend(struct ahd_softc *ahd)
         ahd_shutdown(ahd);
         return (0);
 }
-#endif  /*  0  */
 
-#if 0
-int
+void
 ahd_resume(struct ahd_softc *ahd)
 {
 
         ahd_reset(ahd, /*reinit*/TRUE);
         ahd_intr_enable(ahd, TRUE); 
         ahd_restart(ahd);
-        return (0);
 }
-#endif  /*  0  */
 
 /************************** Busy Target Table *********************************/
 /*
diff --git a/drivers/scsi/aic7xxx/aic79xx_osm.c b/drivers/scsi/aic7xxx/aic79xx_osm.c
index 42c0f14a262c..2d020405480c 100644
--- a/drivers/scsi/aic7xxx/aic79xx_osm.c
+++ b/drivers/scsi/aic7xxx/aic79xx_osm.c
@@ -315,8 +315,8 @@ uint32_t aic79xx_slowcrc;
  */
 static char *aic79xx = NULL;
 
-MODULE_AUTHOR("Maintainer: Justin T. Gibbs <gibbs@scsiguy.com>");
-MODULE_DESCRIPTION("Adaptec Aic790X U320 SCSI Host Bus Adapter driver");
+MODULE_AUTHOR("Maintainer: Hannes Reinecke <hare@suse.de>");
+MODULE_DESCRIPTION("Adaptec AIC790X U320 SCSI Host Bus Adapter driver");
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_VERSION(AIC79XX_DRIVER_VERSION);
 module_param(aic79xx, charp, 0444);
diff --git a/drivers/scsi/aic7xxx/aic79xx_osm_pci.c b/drivers/scsi/aic7xxx/aic79xx_osm_pci.c
index c62ce41f2793..66f0259edb69 100644
--- a/drivers/scsi/aic7xxx/aic79xx_osm_pci.c
+++ b/drivers/scsi/aic7xxx/aic79xx_osm_pci.c
@@ -50,6 +50,8 @@ static int	ahd_linux_pci_reserve_io_regions(struct ahd_softc *ahd,
 static int      ahd_linux_pci_reserve_mem_region(struct ahd_softc *ahd,
                                                  u_long *bus_addr,
                                                  uint8_t __iomem **maddr);
+static int      ahd_linux_pci_dev_suspend(struct pci_dev *pdev, pm_message_t mesg);
+static int      ahd_linux_pci_dev_resume(struct pci_dev *pdev);
 static void     ahd_linux_pci_dev_remove(struct pci_dev *pdev);
 
 /* Define the macro locally since it's different for different class of chips.
@@ -86,10 +88,58 @@ MODULE_DEVICE_TABLE(pci, ahd_linux_pci_id_table);
 static struct pci_driver aic79xx_pci_driver = {
         .name           = "aic79xx",
         .probe          = ahd_linux_pci_dev_probe,
+#ifdef CONFIG_PM
+        .suspend        = ahd_linux_pci_dev_suspend,
+        .resume         = ahd_linux_pci_dev_resume,
+#endif
         .remove         = ahd_linux_pci_dev_remove,
         .id_table       = ahd_linux_pci_id_table
 };
 
+static int
+ahd_linux_pci_dev_suspend(struct pci_dev *pdev, pm_message_t mesg)
+{
+        struct ahd_softc *ahd = pci_get_drvdata(pdev);
+        int rc;
+
+        if ((rc = ahd_suspend(ahd)))
+                return rc;
+
+        ahd_pci_suspend(ahd);
+
+        pci_save_state(pdev);
+        pci_disable_device(pdev);
+
+        if (mesg.event == PM_EVENT_SUSPEND)
+                pci_set_power_state(pdev, PCI_D3hot);
+
+        return rc;
+}
+
+static int
+ahd_linux_pci_dev_resume(struct pci_dev *pdev)
+{
+        struct ahd_softc *ahd = pci_get_drvdata(pdev);
+        int rc;
+
+        pci_set_power_state(pdev, PCI_D0);
+        pci_restore_state(pdev);
+
+        if ((rc = pci_enable_device(pdev))) {
+                dev_printk(KERN_ERR, &pdev->dev,
+                           "failed to enable device after resume (%d)\n", rc);
+                return rc;
+        }
+
+        pci_set_master(pdev);
+
+        ahd_pci_resume(ahd);
+
+        ahd_resume(ahd);
+
+        return rc;
+}
+
 static void
 ahd_linux_pci_dev_remove(struct pci_dev *pdev)
 {
diff --git a/drivers/scsi/aic7xxx/aic79xx_pci.c b/drivers/scsi/aic7xxx/aic79xx_pci.c
index 0bada0028aa0..7a203a90601a 100644
--- a/drivers/scsi/aic7xxx/aic79xx_pci.c
+++ b/drivers/scsi/aic7xxx/aic79xx_pci.c
@@ -389,6 +389,33 @@ ahd_pci_config(struct ahd_softc *ahd, struct ahd_pci_identity *entry)
         return error;
 }
 
+void
+ahd_pci_suspend(struct ahd_softc *ahd)
+{
+        /*
+         * Save chip register configuration data for chip resets
+         * that occur during runtime and resume events.
+         */
+        ahd->suspend_state.pci_state.devconfig =
+            ahd_pci_read_config(ahd->dev_softc, DEVCONFIG, /*bytes*/4);
+        ahd->suspend_state.pci_state.command =
+            ahd_pci_read_config(ahd->dev_softc, PCIR_COMMAND, /*bytes*/1);
+        ahd->suspend_state.pci_state.csize_lattime =
+            ahd_pci_read_config(ahd->dev_softc, CSIZE_LATTIME, /*bytes*/1);
+
+}
+
+void
+ahd_pci_resume(struct ahd_softc *ahd)
+{
+        ahd_pci_write_config(ahd->dev_softc, DEVCONFIG,
+                             ahd->suspend_state.pci_state.devconfig, /*bytes*/4);
+        ahd_pci_write_config(ahd->dev_softc, PCIR_COMMAND,
+                             ahd->suspend_state.pci_state.command, /*bytes*/1);
+        ahd_pci_write_config(ahd->dev_softc, CSIZE_LATTIME,
+                             ahd->suspend_state.pci_state.csize_lattime, /*bytes*/1);
+}
+
 /*
  * Perform some simple tests that should catch situations where
  * our registers are invalidly mapped.
diff --git a/drivers/scsi/aic7xxx/aic7xxx.h b/drivers/scsi/aic7xxx/aic7xxx.h
index e1bd57b9f23d..3d4e42d90452 100644
--- a/drivers/scsi/aic7xxx/aic7xxx.h
+++ b/drivers/scsi/aic7xxx/aic7xxx.h
@@ -962,16 +962,6 @@ struct ahc_softc {
         ahc_bus_chip_init_t       bus_chip_init;
 
         /*
-         * Bus specific suspend routine.
-         */
-        ahc_bus_suspend_t         bus_suspend;
-
-        /*
-         * Bus specific resume routine.
-         */
-        ahc_bus_resume_t          bus_resume;
-
-        /*
          * Target mode related state kept on a per enabled lun basis.
          * Targets that are not enabled will have null entries.
          * As an initiator, we keep one target entry for our initiator
@@ -1153,6 +1143,7 @@ struct ahc_pci_identity	*ahc_find_pci_device(ahc_dev_softc_t);
 int                      ahc_pci_config(struct ahc_softc *,
                                         struct ahc_pci_identity *);
 int                      ahc_pci_test_register_access(struct ahc_softc *);
+void                     ahc_pci_resume(struct ahc_softc *ahc);
 
 /*************************** EISA/VL Front End ********************************/
 struct aic7770_identity *aic7770_find_device(uint32_t);
diff --git a/drivers/scsi/aic7xxx/aic7xxx_osm.c b/drivers/scsi/aic7xxx/aic7xxx_osm.c
index 7770befbf50c..390b0fc991c5 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_osm.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_osm.c
@@ -335,8 +335,8 @@ static uint32_t aic7xxx_periodic_otag;
  */
 static char *aic7xxx = NULL;
 
-MODULE_AUTHOR("Maintainer: Justin T. Gibbs <gibbs@scsiguy.com>");
-MODULE_DESCRIPTION("Adaptec Aic77XX/78XX SCSI Host Bus Adapter driver");
+MODULE_AUTHOR("Maintainer: Hannes Reinecke <hare@suse.de>");
+MODULE_DESCRIPTION("Adaptec AIC77XX/78XX SCSI Host Bus Adapter driver");
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_VERSION(AIC7XXX_DRIVER_VERSION);
 module_param(aic7xxx, charp, 0444);
diff --git a/drivers/scsi/aic7xxx/aic7xxx_osm_pci.c b/drivers/scsi/aic7xxx/aic7xxx_osm_pci.c
index ea5687df732d..4488946cff2e 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_osm_pci.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_osm_pci.c
@@ -49,6 +49,8 @@ static int	ahc_linux_pci_reserve_io_region(struct ahc_softc *ahc,
 static int      ahc_linux_pci_reserve_mem_region(struct ahc_softc *ahc,
                                                  u_long *bus_addr,
                                                  uint8_t __iomem **maddr);
+static int      ahc_linux_pci_dev_suspend(struct pci_dev *pdev, pm_message_t mesg);
+static int      ahc_linux_pci_dev_resume(struct pci_dev *pdev);
 static void     ahc_linux_pci_dev_remove(struct pci_dev *pdev);
 
 /* Define the macro locally since it's different for different class of chips.
@@ -133,10 +135,54 @@ MODULE_DEVICE_TABLE(pci, ahc_linux_pci_id_table);
 static struct pci_driver aic7xxx_pci_driver = {
         .name           = "aic7xxx",
         .probe          = ahc_linux_pci_dev_probe,
+#ifdef CONFIG_PM
+        .suspend        = ahc_linux_pci_dev_suspend,
+        .resume         = ahc_linux_pci_dev_resume,
+#endif
         .remove         = ahc_linux_pci_dev_remove,
         .id_table       = ahc_linux_pci_id_table
 };
 
+static int
+ahc_linux_pci_dev_suspend(struct pci_dev *pdev, pm_message_t mesg)
+{
+        struct ahc_softc *ahc = pci_get_drvdata(pdev);
+        int rc;
+
+        if ((rc = ahc_suspend(ahc)))
+                return rc;
+
+        pci_save_state(pdev);
+        pci_disable_device(pdev);
+
+        if (mesg.event == PM_EVENT_SUSPEND)
+                pci_set_power_state(pdev, PCI_D3hot);
+
+        return rc;
+}
+
+static int
+ahc_linux_pci_dev_resume(struct pci_dev *pdev)
+{
+        struct ahc_softc *ahc = pci_get_drvdata(pdev);
+        int rc;
+
+        pci_set_power_state(pdev, PCI_D0);
+        pci_restore_state(pdev);
+
+        if ((rc = pci_enable_device(pdev))) {
+                dev_printk(KERN_ERR, &pdev->dev,
+                           "failed to enable device after resume (%d)\n", rc);
+                return rc;
+        }
+
+        pci_set_master(pdev);
+
+        ahc_pci_resume(ahc);
+
+        return (ahc_resume(ahc));
+}
+
 static void
 ahc_linux_pci_dev_remove(struct pci_dev *pdev)
 {
diff --git a/drivers/scsi/aic7xxx/aic7xxx_pci.c b/drivers/scsi/aic7xxx/aic7xxx_pci.c
index 09c8172c9e5e..ae35937b8055 100644
--- a/drivers/scsi/aic7xxx/aic7xxx_pci.c
+++ b/drivers/scsi/aic7xxx/aic7xxx_pci.c
@@ -633,8 +633,6 @@ static void    write_brdctl(struct ahc_softc *ahc, uint8_t value);
 static uint8_t read_brdctl(struct ahc_softc *ahc);
 static void ahc_pci_intr(struct ahc_softc *ahc);
 static int  ahc_pci_chip_init(struct ahc_softc *ahc);
-static int  ahc_pci_suspend(struct ahc_softc *ahc);
-static int  ahc_pci_resume(struct ahc_softc *ahc);
 
 static int
 ahc_9005_subdevinfo_valid(uint16_t device, uint16_t vendor,
@@ -791,8 +789,6 @@ ahc_pci_config(struct ahc_softc *ahc, struct ahc_pci_identity *entry)
 
         ahc->bus_intr = ahc_pci_intr;
         ahc->bus_chip_init = ahc_pci_chip_init;
-        ahc->bus_suspend = ahc_pci_suspend;
-        ahc->bus_resume = ahc_pci_resume;
 
         /* Remeber how the card was setup in case there is no SEEPROM */
         if ((ahc_inb(ahc, HCNTRL) & POWRDN) == 0) {
@@ -2024,18 +2020,9 @@ ahc_pci_chip_init(struct ahc_softc *ahc)
         return (ahc_chip_init(ahc));
 }
 
-static int
-ahc_pci_suspend(struct ahc_softc *ahc)
-{
-        return (ahc_suspend(ahc));
-}
-
-static int
+void
 ahc_pci_resume(struct ahc_softc *ahc)
 {
-
-        pci_set_power_state(ahc->dev_softc, AHC_POWER_STATE_D0);
-
         /*
          * We assume that the OS has restored our register
          * mappings, etc.  Just update the config space registers
@@ -2063,7 +2050,6 @@ ahc_pci_resume(struct ahc_softc *ahc)
                                       &sxfrctl1);
                 ahc_release_seeprom(&sd);
         }
-        return (ahc_resume(ahc));
 }
 
 static int
diff --git a/drivers/scsi/aic7xxx/aicasm/aicasm_macro_scan.l b/drivers/scsi/aic7xxx/aicasm/aicasm_macro_scan.l
index f06e7035cb35..c0457b8c3b77 100644
--- a/drivers/scsi/aic7xxx/aicasm/aicasm_macro_scan.l
+++ b/drivers/scsi/aic7xxx/aicasm/aicasm_macro_scan.l
@@ -66,6 +66,7 @@ static char string_buf[MAX_STR_CONST];
 static char *string_buf_ptr;
 static int  parren_count;
 static char buf[255];
+int  mmlineno;
 %}
 
 WORD            [A-Za-z_][-A-Za-z_0-9]*
@@ -76,7 +77,7 @@ MCARG		[^(), \t]+
 
 %%
 \n                      {
-                                ++yylineno;
+                                ++mmlineno;
                         }
 \r                      ;
 <ARGLIST>{SPACE}        ;
diff --git a/drivers/scsi/aic7xxx_old.c b/drivers/scsi/aic7xxx_old.c
index 4025608d6964..8f8db5f0aef7 100644
--- a/drivers/scsi/aic7xxx_old.c
+++ b/drivers/scsi/aic7xxx_old.c
@@ -8417,7 +8417,7 @@ aic7xxx_alloc(struct scsi_host_template *sht, struct aic7xxx_host *temp)
     p->host = host;
 
     p->scb_data = kzalloc(sizeof(scb_data_type), GFP_ATOMIC);
-    if (!p->scb_data)
+    if (p->scb_data)
     {
       scbq_init (&p->scb_data->free_scbs);
     }
diff --git a/drivers/scsi/fcal.c b/drivers/scsi/fcal.c
deleted file mode 100644
index c4e16c0775de..000000000000
--- a/drivers/scsi/fcal.c
+++ /dev/null
@@ -1,317 +0,0 @@
-/* fcal.c: Fibre Channel Arbitrated Loop SCSI host adapter driver.
- *
- * Copyright (C) 1998,1999 Jakub Jelinek (jj@ultra.linux.cz)
- *
- */
-
-#include <linux/kernel.h>
-#include <linux/delay.h>
-#include <linux/types.h>
-#include <linux/string.h>
-#include <linux/slab.h>
-#include <linux/blkdev.h>
-#include <linux/proc_fs.h>
-#include <linux/stat.h>
-#include <linux/init.h>
-#ifdef CONFIG_KMOD
-#include <linux/kmod.h>
-#endif
-
-#include <asm/irq.h>
-
-#include "scsi.h"
-#include <scsi/scsi_host.h>
-#include "../fc4/fcp_impl.h"
-#include "fcal.h"
-
-#include <linux/module.h>
-
-/* #define FCAL_DEBUG */
-
-#define fcal_printk printk ("FCAL %s: ", fc->name); printk
-
-#ifdef FCAL_DEBUG
-#define FCALD(x)  fcal_printk x;
-#define FCALND(x) printk ("FCAL: "); printk x;
-#else
-#define FCALD(x)
-#define FCALND(x)
-#endif
-
-static unsigned char alpa2target[] = {
-0x7e, 0x7d, 0x7c, 0xff, 0x7b, 0xff, 0xff, 0xff, 0x7a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x79,
-0x78, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x77, 0x76, 0xff, 0xff, 0x75, 0xff, 0x74, 0x73, 0x72,
-0xff, 0xff, 0xff, 0x71, 0xff, 0x70, 0x6f, 0x6e, 0xff, 0x6d, 0x6c, 0x6b, 0x6a, 0x69, 0x68, 0xff,
-0xff, 0x67, 0x66, 0x65, 0x64, 0x63, 0x62, 0xff, 0xff, 0x61, 0x60, 0xff, 0x5f, 0xff, 0xff, 0xff,
-0xff, 0xff, 0xff, 0x5e, 0xff, 0x5d, 0x5c, 0x5b, 0xff, 0x5a, 0x59, 0x58, 0x57, 0x56, 0x55, 0xff,
-0xff, 0x54, 0x53, 0x52, 0x51, 0x50, 0x4f, 0xff, 0xff, 0x4e, 0x4d, 0xff, 0x4c, 0xff, 0xff, 0xff,
-0xff, 0xff, 0xff, 0x4b, 0xff, 0x4a, 0x49, 0x48, 0xff, 0x47, 0x46, 0x45, 0x44, 0x43, 0x42, 0xff,
-0xff, 0x41, 0x40, 0x3f, 0x3e, 0x3d, 0x3c, 0xff, 0xff, 0x3b, 0x3a, 0xff, 0x39, 0xff, 0xff, 0xff,
-0x38, 0x37, 0x36, 0xff, 0x35, 0xff, 0xff, 0xff, 0x34, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x33,
-0x32, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x31, 0x30, 0xff, 0xff, 0x2f, 0xff, 0x2e, 0x2d, 0x2c,
-0xff, 0xff, 0xff, 0x2b, 0xff, 0x2a, 0x29, 0x28, 0xff, 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0xff,
-0xff, 0x21, 0x20, 0x1f, 0x1e, 0x1d, 0x1c, 0xff, 0xff, 0x1b, 0x1a, 0xff, 0x19, 0xff, 0xff, 0xff,
-0xff, 0xff, 0xff, 0x18, 0xff, 0x17, 0x16, 0x15, 0xff, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0f, 0xff,
-0xff, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0xff, 0xff, 0x08, 0x07, 0xff, 0x06, 0xff, 0xff, 0xff,
-0x05, 0x04, 0x03, 0xff, 0x02, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00
-};
-
-static unsigned char target2alpa[] = {
-0xef, 0xe8, 0xe4, 0xe2, 0xe1, 0xe0, 0xdc, 0xda, 0xd9, 0xd6, 0xd5, 0xd4, 0xd3, 0xd2, 0xd1, 0xce,
-0xcd, 0xcc, 0xcb, 0xca, 0xc9, 0xc7, 0xc6, 0xc5, 0xc3, 0xbc, 0xba, 0xb9, 0xb6, 0xb5, 0xb4, 0xb3,
-0xb2, 0xb1, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9, 0xa7, 0xa6, 0xa5, 0xa3, 0x9f, 0x9e, 0x9d, 0x9b,
-0x98, 0x97, 0x90, 0x8f, 0x88, 0x84, 0x82, 0x81, 0x80, 0x7c, 0x7a, 0x79, 0x76, 0x75, 0x74, 0x73,
-0x72, 0x71, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x69, 0x67, 0x66, 0x65, 0x63, 0x5c, 0x5a, 0x59, 0x56,
-0x55, 0x54, 0x53, 0x52, 0x51, 0x4e, 0x4d, 0x4c, 0x4b, 0x4a, 0x49, 0x47, 0x46, 0x45, 0x43, 0x3c,
-0x3a, 0x39, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x27, 0x26,
-0x25, 0x23, 0x1f, 0x1e, 0x1d, 0x1b, 0x18, 0x17, 0x10, 0x0f, 0x08, 0x04, 0x02, 0x01, 0x00
-};
-
-static int fcal_encode_addr(Scsi_Cmnd *SCpnt, u16 *addr, fc_channel *fc, fcp_cmnd *fcmd);
-
-int fcal_slave_configure(struct scsi_device *device)
-{
-        int depth_to_use;
-        
-        if (device->tagged_supported)
-                depth_to_use = /* 254 */ 8;
-        else
-                depth_to_use = 2;
-
-        scsi_adjust_queue_depth(device,
-                                (device->tagged_supported ?
-                                 MSG_SIMPLE_TAG : 0),
-                                depth_to_use);
-
-        return 0;
-}
-
-/* Detect all FC Arbitrated Loops attached to the machine.
-   fc4 module has done all the work for us... */
-int __init fcal_detect(struct scsi_host_template *tpnt)
-{
-        int nfcals = 0;
-        fc_channel *fc;
-        int fcalcount;
-        int i;
-
-        tpnt->proc_name = "fcal";
-        fcalcount = 0;
-        for_each_online_fc_channel(fc)
-                if (fc->posmap)
-                        fcalcount++;
-        FCALND(("%d channels online\n", fcalcount))
-        if (!fcalcount) {
-#if defined(MODULE) && defined(CONFIG_FC4_SOCAL_MODULE) && defined(CONFIG_KMOD)
-                request_module("socal");
-                
-                for_each_online_fc_channel(fc)
-                        if (fc->posmap)
-                                fcalcount++;
-                if (!fcalcount)
-#endif
-                        return 0;
-        }
-        for_each_online_fc_channel(fc) {
-                struct Scsi_Host *host;
-                long *ages;
-                struct fcal *fcal;
-                
-                if (!fc->posmap) continue;
-                
-                /* Strange, this is already registered to some other SCSI host, then it cannot be fcal */
-                if (fc->scsi_name[0]) continue;
-                memcpy (fc->scsi_name, "FCAL", 4);
-                
-                fc->can_queue = FCAL_CAN_QUEUE;
-                fc->rsp_size = 64;
-                fc->encode_addr = fcal_encode_addr;
-                
-                ages = kmalloc (128 * sizeof(long), GFP_KERNEL);
-                if (!ages) continue;
-                                
-                host = scsi_register (tpnt, sizeof (struct fcal));
-                if (!host) 
-                {
-                        kfree(ages);
-                        continue;
-                }
-                                
-                if (!try_module_get(fc->module)) {
-                        kfree(ages);
-                        scsi_unregister(host);
-                        continue;
-                }
-        
-                nfcals++;
-                                
-                fcal = (struct fcal *)host->hostdata;
-                
-                fc->fcp_register(fc, TYPE_SCSI_FCP, 0);
-
-                for (i = 0; i < fc->posmap->len; i++) {
-                        int status, target, alpa;
-
-                        alpa = fc->posmap->list[i];                     
-                        FCALD(("Sending PLOGI to %02x\n", alpa))
-                        target = alpa2target[alpa];
-                        status = fc_do_plogi(fc, alpa, fcal->node_wwn + target, 
-                                             fcal->nport_wwn + target);
-                        FCALD(("PLOGI returned with status %d\n", status))
-                        if (status != FC_STATUS_OK)
-                                continue;
-                        FCALD(("Sending PRLI to %02x\n", alpa))
-                        status = fc_do_prli(fc, alpa);
-                        FCALD(("PRLI returned with status %d\n", status))
-                        if (status == FC_STATUS_OK)
-                                fcal->map[target] = 1;
-                }
-                
-                host->max_id = 127;
-                host->irq = fc->irq;
-#ifdef __sparc_v9__
-                host->unchecked_isa_dma = 1;
-#endif
-
-                fc->channels = 1;
-                fc->targets = 127;
-                fc->ages = ages;
-                memset (ages, 0, 128 * sizeof(long));
-                                
-                fcal->fc = fc;
-                
-                FCALD(("Found FCAL\n"))
-        }
-        if (nfcals)
-#ifdef __sparc__
-                printk ("FCAL: Total of %d Sun Enterprise Network Array (A5000 or EX500) channels found\n", nfcals);
-#else
-                printk ("FCAL: Total of %d Fibre Channel Arbitrated Loops found\n", nfcals);
-#endif
-        return nfcals;
-}
-
-int fcal_release(struct Scsi_Host *host)
-{
-        struct fcal *fcal = (struct fcal *)host->hostdata;
-        fc_channel *fc = fcal->fc;
-
-        module_put(fc->module);
-        
-        fc->fcp_register(fc, TYPE_SCSI_FCP, 1);
-        FCALND((" releasing fcal.\n"));
-        kfree (fc->ages);
-        FCALND(("released fcal!\n"));
-        return 0;
-}
-
-#undef SPRINTF
-#define SPRINTF(args...) { if (pos < (buffer + length)) pos += sprintf (pos, ## args); }
-
-int fcal_proc_info (struct Scsi_Host *host, char *buffer, char **start, off_t offset, int length, int inout)
-{
-        struct fcal *fcal;
-        fc_channel *fc;
-        char *pos = buffer;
-        int i, j;
-
-        if (inout) return length;
-    
-        fcal = (struct fcal *)host->hostdata;
-        fc = fcal->fc;
-
-#ifdef __sparc__
-        SPRINTF ("Sun Enterprise Network Array (A5000 or E?500) on %s PROM node %x\n", fc->name, fc->dev->prom_node);
-#else
-        SPRINTF ("Fibre Channel Arbitrated Loop on %s\n", fc->name);
-#endif
-        SPRINTF ("Initiator AL-PA: %02x\n", fc->sid);
-
-        SPRINTF ("\nAttached devices:\n");
-        
-        for (i = 0; i < fc->posmap->len; i++) {
-                unsigned char alpa = fc->posmap->list[i];
-                unsigned char target;
-                u32 *u1, *u2;
-                
-                target = alpa2target[alpa];
-                u1 = (u32 *)&fcal->nport_wwn[target];
-                u2 = (u32 *)&fcal->node_wwn[target];
-                if (!u1[0] && !u1[1]) {
-                        SPRINTF ("  [AL-PA: %02x] Not responded to PLOGI\n", alpa);
-                } else if (!fcal->map[target]) {
-                        SPRINTF ("  [AL-PA: %02x, Port WWN: %08x%08x, Node WWN: %08x%08x] Not responded to PRLI\n",
-                                 alpa, u1[0], u1[1], u2[0], u2[1]);
-                } else {
-                        struct scsi_device *scd;
-                        shost_for_each_device(scd, host)
-                                if (scd->id == target) {
-                                        SPRINTF ("  [AL-PA: %02x, Id: %02d, Port WWN: %08x%08x, Node WWN: %08x%08x]  ",
-                                                alpa, target, u1[0], u1[1], u2[0], u2[1]);
-                                        SPRINTF ("%s ", scsi_device_type(scd->type));
-
-                                        for (j = 0; (j < 8) && (scd->vendor[j] >= 0x20); j++)
-                                                SPRINTF ("%c", scd->vendor[j]);
-                                        SPRINTF (" ");
-
-                                        for (j = 0; (j < 16) && (scd->model[j] >= 0x20); j++)
-                                                SPRINTF ("%c", scd->model[j]);
-                
-                                        SPRINTF ("\n");
-                                }
-                }
-        }
-        SPRINTF ("\n");
-
-        *start = buffer + offset;
-
-        if ((pos - buffer) < offset)
-                return 0;
-        else if (pos - buffer - offset < length)
-                return pos - buffer - offset;
-        else
-                return length;
-}
-
-/* 
-   For FC-AL, we use a simple addressing: we have just one channel 0,
-   and all AL-PAs are mapped to targets 0..0x7e
- */
-static int fcal_encode_addr(Scsi_Cmnd *SCpnt, u16 *addr, fc_channel *fc, fcp_cmnd *fcmd)
-{
-        struct fcal *f;
-        
-        /* We don't support LUNs yet - I'm not sure if LUN should be in SCSI fcp_cdb, or in second byte of addr[0] */
-        if (SCpnt->cmnd[1] & 0xe0) return -EINVAL;
-        /* FC-PLDA tells us... */
-        memset(addr, 0, 8);
-        f = (struct fcal *)SCpnt->device->host->hostdata;
-        if (!f->map[SCpnt->device->id])
-                return -EINVAL;
-        /* Now, determine DID: It will be Native Identifier, so we zero upper
-           2 bytes of the 3 byte DID, lowest byte will be AL-PA */
-        fcmd->did = target2alpa[SCpnt->device->id];
-        FCALD(("trying DID %06x\n", fcmd->did))
-        return 0;
-}
-
-static struct scsi_host_template driver_template = {
-        .name                   = "Fibre Channel Arbitrated Loop",
-        .detect                 = fcal_detect,
-        .release                = fcal_release, 
-        .proc_info              = fcal_proc_info,
-        .queuecommand           = fcp_scsi_queuecommand,
-        .slave_configure        = fcal_slave_configure,
-        .can_queue              = FCAL_CAN_QUEUE,
-        .this_id                = -1,
-        .sg_tablesize           = 1,
-        .cmd_per_lun            = 1,
-        .use_clustering         = ENABLE_CLUSTERING,
-        .eh_abort_handler       = fcp_scsi_abort,
-        .eh_device_reset_handler = fcp_scsi_dev_reset,
-        .eh_host_reset_handler  = fcp_scsi_host_reset,
-};
-#include "scsi_module.c"
-
-MODULE_LICENSE("GPL");
-
diff --git a/drivers/scsi/fcal.h b/drivers/scsi/fcal.h
deleted file mode 100644
index 7ff2c3494f9e..000000000000
--- a/drivers/scsi/fcal.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/* fcal.h: Generic Fibre Channel Arbitrated Loop SCSI host adapter driver definitions.
- *
- * Copyright (C) 1998,1999 Jakub Jelinek (jj@ultra.linux.cz)
- */
-
-#ifndef _FCAL_H
-#define _FCAL_H
-
-#include "../fc4/fcp_impl.h"
-
-struct fcal {
-        /* fc must be first */
-        fc_channel              *fc;
-        unsigned char           map[128];
-        fc_wwn                  nport_wwn[128];
-        fc_wwn                  node_wwn[128];
-};
-
-/* Arbitrary constant. Cannot be too large, as fc4 layer has limitations
-   for a particular channel */
-#define FCAL_CAN_QUEUE          512
-
-int fcal_detect(struct scsi_host_template *);
-int fcal_release(struct Scsi_Host *);
-int fcal_slave_configure(struct scsi_device *);
-
-#endif /* !(_FCAL_H) */
diff --git a/drivers/scsi/gdth.c b/drivers/scsi/gdth.c
index 5ab3ce762485..b253b8c718d3 100644
--- a/drivers/scsi/gdth.c
+++ b/drivers/scsi/gdth.c
@@ -4734,7 +4734,7 @@ static struct scsi_host_template gdth_template = {
 };
 
 #ifdef CONFIG_ISA
-static int gdth_isa_probe_one(ulong32 isa_bios)
+static int __init gdth_isa_probe_one(ulong32 isa_bios)
 {
         struct Scsi_Host *shp;
         gdth_ha_str *ha;
@@ -4862,7 +4862,7 @@ static int gdth_isa_probe_one(ulong32 isa_bios)
 #endif /* CONFIG_ISA */
 
 #ifdef CONFIG_EISA
-static int gdth_eisa_probe_one(ushort eisa_slot)
+static int __init gdth_eisa_probe_one(ushort eisa_slot)
 {
         struct Scsi_Host *shp;
         gdth_ha_str *ha;
@@ -4991,7 +4991,7 @@ static int gdth_eisa_probe_one(ushort eisa_slot)
 #endif /* CONFIG_EISA */
 
 #ifdef CONFIG_PCI
-static int gdth_pci_probe_one(gdth_pci_str *pcistr, int ctr)
+static int __init gdth_pci_probe_one(gdth_pci_str *pcistr, int ctr)
 {
         struct Scsi_Host *shp;
         gdth_ha_str *ha;
diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c
index 112ab6abe62b..24271a871b8c 100644
--- a/drivers/scsi/hosts.c
+++ b/drivers/scsi/hosts.c
@@ -345,6 +345,12 @@ struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
         shost->active_mode = sht->supported_mode;
         shost->use_sg_chaining = sht->use_sg_chaining;
 
+        if (sht->supported_mode == MODE_UNKNOWN)
+                /* means we didn't set it ... default to INITIATOR */
+                shost->active_mode = MODE_INITIATOR;
+        else
+                shost->active_mode = sht->supported_mode;
+
         if (sht->max_host_blocked)
                 shost->max_host_blocked = sht->max_host_blocked;
         else
diff --git a/drivers/scsi/hptiop.c b/drivers/scsi/hptiop.c
index 8515054cdf70..0844331abb87 100644
--- a/drivers/scsi/hptiop.c
+++ b/drivers/scsi/hptiop.c
@@ -375,8 +375,9 @@ static void hptiop_host_request_callback(struct hptiop_hba *hba, u32 _tag)
                 scp->result = SAM_STAT_CHECK_CONDITION;
                 memset(&scp->sense_buffer,
                                 0, sizeof(scp->sense_buffer));
-                memcpy(&scp->sense_buffer,
-                        &req->sg_list, le32_to_cpu(req->dataxfer_length));
+                memcpy(&scp->sense_buffer, &req->sg_list,
+                                min(sizeof(scp->sense_buffer),
+                                        le32_to_cpu(req->dataxfer_length)));
                 break;
 
         default:
diff --git a/drivers/scsi/initio.c b/drivers/scsi/initio.c
index 22d40fd5845b..4c4465d39a1d 100644
--- a/drivers/scsi/initio.c
+++ b/drivers/scsi/initio.c
@@ -665,7 +665,7 @@ static void initio_init(struct initio_host * host, u8 *bios_addr)
                 host->max_tags[i] = 0xFF;
         }                       /* for                          */
         printk("i91u: PCI Base=0x%04X, IRQ=%d, BIOS=0x%04X0, SCSI ID=%d\n",
-               host->addr, host->irq,
+               host->addr, host->pci_dev->irq,
                host->bios_addr, host->scsi_id);
         /* Reset SCSI Bus */
         if (host->config & HCC_SCSI_RESET) {
@@ -2891,6 +2891,8 @@ static int initio_probe_one(struct pci_dev *pdev,
                 goto out_release_region;
         }
 
+        host->pci_dev = pdev;
+
         host->num_scbs = num_scb;
         host->scb = scb;
         host->next_pending = scb;
@@ -2905,6 +2907,7 @@ static int initio_probe_one(struct pci_dev *pdev,
         host->scb_end = tmp;
         host->first_avail = scb;
         host->last_avail = prev;
+        spin_lock_init(&host->avail_lock);
 
         initio_init(host, phys_to_virt(bios_seg << 4));
 
@@ -2928,7 +2931,6 @@ static int initio_probe_one(struct pci_dev *pdev,
         }
 
         pci_set_drvdata(pdev, shost);
-        host->pci_dev = pdev;
 
         error = scsi_add_host(shost, &pdev->dev);
         if (error)
diff --git a/drivers/scsi/lpfc/lpfc_debugfs.c b/drivers/scsi/lpfc/lpfc_debugfs.c
index 149fdd25f8e8..d6a98bc970ff 100644
--- a/drivers/scsi/lpfc/lpfc_debugfs.c
+++ b/drivers/scsi/lpfc/lpfc_debugfs.c
@@ -901,7 +901,7 @@ lpfc_debugfs_initialize(struct lpfc_vport *vport)
                 }
         }
 
-        vport->disc_trc = kmzlloc(
+        vport->disc_trc = kzalloc(
                 (sizeof(struct lpfc_debugfs_trc) * lpfc_debugfs_max_disc_trc),
                 GFP_KERNEL);
 
diff --git a/drivers/scsi/pluto.c b/drivers/scsi/pluto.c
deleted file mode 100644
index 0363c1cd68c1..000000000000
--- a/drivers/scsi/pluto.c
+++ /dev/null
@@ -1,349 +0,0 @@
-/* pluto.c: SparcSTORAGE Array SCSI host adapter driver.
- *
- * Copyright (C) 1997,1998,1999 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
- *
- */
-
-#include <linux/completion.h>
-#include <linux/kernel.h>
-#include <linux/delay.h>
-#include <linux/types.h>
-#include <linux/string.h>
-#include <linux/slab.h>
-#include <linux/blkdev.h>
-#include <linux/proc_fs.h>
-#include <linux/stat.h>
-#include <linux/init.h>
-#ifdef CONFIG_KMOD
-#include <linux/kmod.h>
-#endif
-
-#include <asm/irq.h>
-
-#include "scsi.h"
-#include <scsi/scsi_host.h>
-#include "../fc4/fcp_impl.h"
-#include "pluto.h"
-
-#include <linux/module.h>
-
-#define RQ_SCSI_BUSY            0xffff
-#define RQ_SCSI_DONE            0xfffe
-
-/* #define PLUTO_DEBUG */
-
-#define pluto_printk printk ("PLUTO %s: ", fc->name); printk
-
-#ifdef PLUTO_DEBUG
-#define PLD(x)  pluto_printk x;
-#define PLND(x) printk ("PLUTO: "); printk x;
-#else
-#define PLD(x)
-#define PLND(x)
-#endif
-
-static struct ctrl_inquiry {
-        struct Scsi_Host host;
-        struct pluto pluto;
-        Scsi_Cmnd cmd;
-        char inquiry[256];
-        fc_channel *fc;
-} *fcs __initdata;
-static int fcscount __initdata = 0;
-static atomic_t fcss __initdata = ATOMIC_INIT(0);
-static DECLARE_COMPLETION(fc_detect_complete);
-
-static int pluto_encode_addr(Scsi_Cmnd *SCpnt, u16 *addr, fc_channel *fc, fcp_cmnd *fcmd);
-
-static void __init pluto_detect_done(Scsi_Cmnd *SCpnt)
-{
-        /* Do nothing */
-}
-
-static void __init pluto_detect_scsi_done(Scsi_Cmnd *SCpnt)
-{
-        PLND(("Detect done %08lx\n", (long)SCpnt))
-        if (atomic_dec_and_test (&fcss))
-                complete(&fc_detect_complete);
-}
-
-int pluto_slave_configure(struct scsi_device *device)
-{
-        int depth_to_use;
-
-        if (device->tagged_supported)
-                depth_to_use = /* 254 */ 8;
-        else
-                depth_to_use = 2;
-
-        scsi_adjust_queue_depth(device,
-                                (device->tagged_supported ?
-                                 MSG_SIMPLE_TAG : 0),
-                                depth_to_use);
-
-        return 0;
-}
-
-/* Detect all SSAs attached to the machine.
-   To be fast, do it on all online FC channels at the same time. */
-int __init pluto_detect(struct scsi_host_template *tpnt)
-{
-        int i, retry, nplutos;
-        fc_channel *fc;
-        struct scsi_device dev;
-
-        tpnt->proc_name = "pluto";
-        fcscount = 0;
-        for_each_online_fc_channel(fc) {
-                if (!fc->posmap)
-                        fcscount++;
-        }
-        PLND(("%d channels online\n", fcscount))
-        if (!fcscount) {
-#if defined(MODULE) && defined(CONFIG_FC4_SOC_MODULE) && defined(CONFIG_KMOD)
-                request_module("soc");
-                
-                for_each_online_fc_channel(fc) {
-                        if (!fc->posmap)
-                                fcscount++;
-                }
-                if (!fcscount)
-#endif
-                        return 0;
-        }
-        fcs = kcalloc(fcscount, sizeof (struct ctrl_inquiry), GFP_DMA);
-        if (!fcs) {
-                printk ("PLUTO: Not enough memory to probe\n");
-                return 0;
-        }
-        
-        memset (&dev, 0, sizeof(dev));
-        atomic_set (&fcss, fcscount);
-        
-        i = 0;
-        for_each_online_fc_channel(fc) {
-                Scsi_Cmnd *SCpnt;
-                struct Scsi_Host *host;
-                struct pluto *pluto;
-
-                if (i == fcscount) break;
-                if (fc->posmap) continue;
-                
-                PLD(("trying to find SSA\n"))
-
-                /* If this is already registered to some other SCSI host, then it cannot be pluto */
-                if (fc->scsi_name[0]) continue;
-                memcpy (fc->scsi_name, "SSA", 4);
-                
-                fcs[i].fc = fc;
-                
-                fc->can_queue = PLUTO_CAN_QUEUE;
-                fc->rsp_size = 64;
-                fc->encode_addr = pluto_encode_addr;
-                
-                fc->fcp_register(fc, TYPE_SCSI_FCP, 0);
-        
-                SCpnt = &(fcs[i].cmd);
-                host = &(fcs[i].host);
-                pluto = (struct pluto *)host->hostdata;
-                
-                pluto->fc = fc;
-        
-                SCpnt->cmnd[0] = INQUIRY;
-                SCpnt->cmnd[4] = 255;
-                
-                /* FC layer requires this, so that SCpnt->device->tagged_supported is initially 0 */
-                SCpnt->device = &dev;
-                dev.host = host;
-                
-                SCpnt->cmd_len = COMMAND_SIZE(INQUIRY);
-        
-                SCpnt->request->cmd_flags &= ~REQ_STARTED;
-                
-                SCpnt->request_bufflen = 256;
-                SCpnt->request_buffer = fcs[i].inquiry;
-                PLD(("set up %d %08lx\n", i, (long)SCpnt))
-                i++;
-        }
-        
-        for (retry = 0; retry < 5; retry++) {
-                for (i = 0; i < fcscount; i++) {
-                        if (!fcs[i].fc) break;
-                        if (!(fcs[i].cmd.request->cmd_flags & REQ_STARTED)) {
-                                fcs[i].cmd.request->cmd_flags |= REQ_STARTED;
-                                disable_irq(fcs[i].fc->irq);
-                                PLND(("queuecommand %d %d\n", retry, i))
-                                fcp_scsi_queuecommand (&(fcs[i].cmd), 
-                                        pluto_detect_scsi_done);
-                                enable_irq(fcs[i].fc->irq);
-                        }
-                }
-            
-                wait_for_completion_timeout(&fc_detect_complete, 10 * HZ);
-                PLND(("Woken up\n"))
-                if (!atomic_read(&fcss))
-                        break; /* All fc channels have answered us */
-        }
-
-        PLND(("Finished search\n"))
-        for (i = 0, nplutos = 0; i < fcscount; i++) {
-                Scsi_Cmnd *SCpnt;
-                
-                if (!(fc = fcs[i].fc)) break;
-        
-                SCpnt = &(fcs[i].cmd);
-                
-                /* Let FC mid-level free allocated resources */
-                pluto_detect_scsi_done(SCpnt);
-                
-                if (!SCpnt->result) {
-                        struct pluto_inquiry *inq;
-                        struct pluto *pluto;
-                        struct Scsi_Host *host;
-                        
-                        inq = (struct pluto_inquiry *)fcs[i].inquiry;
-
-                        if ((inq->dtype & 0x1f) == TYPE_PROCESSOR &&
-                            !strncmp (inq->vendor_id, "SUN", 3) &&
-                            !strncmp (inq->product_id, "SSA", 3)) {
-                                char *p;
-                                long *ages;
-                                
-                                ages = kcalloc((inq->channels + 1) * inq->targets, sizeof(long), GFP_KERNEL);
-                                if (!ages) continue;
-                                
-                                host = scsi_register (tpnt, sizeof (struct pluto));
-                                if(!host)
-                                {
-                                        kfree(ages);
-                                        continue;
-                                }
-                                
-                                if (!try_module_get(fc->module)) {
-                                        kfree(ages);
-                                        scsi_unregister(host);
-                                        continue;
-                                }
-
-                                nplutos++;
-                                
-                                pluto = (struct pluto *)host->hostdata;
-                                
-                                host->max_id = inq->targets;
-                                host->max_channel = inq->channels;
-                                host->irq = fc->irq;
-
-                                fc->channels = inq->channels + 1;
-                                fc->targets = inq->targets;
-                                fc->ages = ages;
-                                
-                                pluto->fc = fc;
-                                memcpy (pluto->rev_str, inq->revision, 4);
-                                pluto->rev_str[4] = 0;
-                                p = strchr (pluto->rev_str, ' ');
-                                if (p) *p = 0;
-                                memcpy (pluto->fw_rev_str, inq->fw_revision, 4);
-                                pluto->fw_rev_str[4] = 0;
-                                p = strchr (pluto->fw_rev_str, ' ');
-                                if (p) *p = 0;
-                                memcpy (pluto->serial_str, inq->serial, 12);
-                                pluto->serial_str[12] = 0;
-                                p = strchr (pluto->serial_str, ' ');
-                                if (p) *p = 0;
-                                
-                                PLD(("Found SSA rev %s fw rev %s serial %s %dx%d\n", pluto->rev_str, pluto->fw_rev_str, pluto->serial_str, host->max_channel, host->max_id))
-                        } else
-                                fc->fcp_register(fc, TYPE_SCSI_FCP, 1);
-                } else
-                        fc->fcp_register(fc, TYPE_SCSI_FCP, 1);
-        }
-        kfree(fcs);
-        if (nplutos)
-                printk ("PLUTO: Total of %d SparcSTORAGE Arrays found\n", nplutos);
-        return nplutos;
-}
-
-int pluto_release(struct Scsi_Host *host)
-{
-        struct pluto *pluto = (struct pluto *)host->hostdata;
-        fc_channel *fc = pluto->fc;
-
-        module_put(fc->module);
-        
-        fc->fcp_register(fc, TYPE_SCSI_FCP, 1);
-        PLND((" releasing pluto.\n"));
-        kfree (fc->ages);
-        PLND(("released pluto!\n"));
-        return 0;
-}
-
-const char *pluto_info(struct Scsi_Host *host)
-{
-        static char buf[128], *p;
-        struct pluto *pluto = (struct pluto *) host->hostdata;
-
-        sprintf(buf, "SUN SparcSTORAGE Array %s fw %s serial %s %dx%d on %s",
-                pluto->rev_str, pluto->fw_rev_str, pluto->serial_str,
-                host->max_channel, host->max_id, pluto->fc->name);
-#ifdef __sparc__
-        p = strchr(buf, 0);
-        sprintf(p, " PROM node %x", pluto->fc->dev->prom_node);
-#endif  
-        return buf;
-}
-
-/* SSA uses this FC4S addressing:
-   switch (addr[0])
-   {
-   case 0: CONTROLLER - All of addr[1]..addr[3] has to be 0
-   case 1: SINGLE DISK - addr[1] channel, addr[2] id, addr[3] 0
-   case 2: DISK GROUP - ???
-   }
-   
-   So that SCSI mid-layer can access to these, we reserve
-   channel 0 id 0 lun 0 for CONTROLLER
-   and channels 1 .. max_channel are normal single disks.
- */
-static int pluto_encode_addr(Scsi_Cmnd *SCpnt, u16 *addr, fc_channel *fc, fcp_cmnd *fcmd)
-{
-        PLND(("encode addr %d %d %d\n", SCpnt->device->channel, SCpnt->device->id, SCpnt->cmnd[1] & 0xe0))
-        /* We don't support LUNs - neither does SSA :) */
-        if (SCpnt->cmnd[1] & 0xe0)
-                return -EINVAL;
-        if (!SCpnt->device->channel) {
-                if (SCpnt->device->id)
-                        return -EINVAL;
-                memset (addr, 0, 4 * sizeof(u16));
-        } else {
-                addr[0] = 1;
-                addr[1] = SCpnt->device->channel - 1;
-                addr[2] = SCpnt->device->id;
-                addr[3] = 0;
-        }
-        /* We're Point-to-Point, so target it to the default DID */
-        fcmd->did = fc->did;
-        PLND(("trying %04x%04x%04x%04x\n", addr[0], addr[1], addr[2], addr[3]))
-        return 0;
-}
-
-static struct scsi_host_template driver_template = {
-        .name                   = "Sparc Storage Array 100/200",
-        .detect                 = pluto_detect,
-        .release                = pluto_release,
-        .info                   = pluto_info,
-        .queuecommand           = fcp_scsi_queuecommand,
-        .slave_configure        = pluto_slave_configure,
-        .can_queue              = PLUTO_CAN_QUEUE,
-        .this_id                = -1,
-        .sg_tablesize           = 1,
-        .cmd_per_lun            = 1,
-        .use_clustering         = ENABLE_CLUSTERING,
-        .eh_abort_handler       = fcp_scsi_abort,
-        .eh_device_reset_handler = fcp_scsi_dev_reset,
-        .eh_host_reset_handler  = fcp_scsi_host_reset,
-};
-
-#include "scsi_module.c"
-
-MODULE_LICENSE("GPL");
-
diff --git a/drivers/scsi/pluto.h b/drivers/scsi/pluto.h
deleted file mode 100644
index 5da20616ac36..000000000000
--- a/drivers/scsi/pluto.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/* pluto.h: SparcSTORAGE Array SCSI host adapter driver definitions.
- *
- * Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
- */
-
-#ifndef _PLUTO_H
-#define _PLUTO_H
-
-#include "../fc4/fcp_impl.h"
-
-struct pluto {
-        /* This must be first */
-        fc_channel      *fc;
-        char            rev_str[5];
-        char            fw_rev_str[5];
-        char            serial_str[13];
-};
-
-struct pluto_inquiry {
-        u8      dtype;
-        u8      removable:1, qualifier:7;
-        u8      iso:2, ecma:3, ansi:3;
-        u8      aenc:1, trmiop:1, :2, rdf:4;
-        u8      len;
-        u8      xxx1;
-        u8      xxx2;
-        u8      reladdr:1, wbus32:1, wbus16:1, sync:1, linked:1, :1, cmdque:1, softreset:1;
-        u8      vendor_id[8];
-        u8      product_id[16];
-        u8      revision[4];
-        u8      fw_revision[4];
-        u8      serial[12];
-        u8      xxx3[2];
-        u8      channels;
-        u8      targets;
-};
-
-/* This is the max number of outstanding SCSI commands per pluto */
-#define PLUTO_CAN_QUEUE         254
-
-int pluto_detect(struct scsi_host_template *);
-int pluto_release(struct Scsi_Host *);
-const char * pluto_info(struct Scsi_Host *);
-int pluto_slave_configure(struct scsi_device *);
-
-#endif /* !(_PLUTO_H) */
-
diff --git a/drivers/scsi/qla1280.c b/drivers/scsi/qla1280.c
index 76089cf55f4e..3aeb68bcb7ac 100644
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -4310,7 +4310,7 @@ qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
                         printk(KERN_WARNING "scsi(%li): Unable to set a "
                                "suitable DMA mask - aborting\n", ha->host_no);
                         error = -ENODEV;
-                        goto error_free_irq;
+                        goto error_put_host;
                 }
         } else
                 dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n",
@@ -4320,7 +4320,7 @@ qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
                 printk(KERN_WARNING "scsi(%li): Unable to set a "
                        "suitable DMA mask - aborting\n", ha->host_no);
                 error = -ENODEV;
-                goto error_free_irq;
+                goto error_put_host;
         }
 #endif
 
diff --git a/drivers/scsi/qla1280.h b/drivers/scsi/qla1280.h
index 59915fb70301..ff2c363ead26 100644
--- a/drivers/scsi/qla1280.h
+++ b/drivers/scsi/qla1280.h
@@ -91,8 +91,8 @@
 #define INVALID_HANDLE                  (MAX_OUTSTANDING_COMMANDS + 2)
 
 /* ISP request and response entry counts (37-65535) */
-#define REQUEST_ENTRY_CNT               256 /* Number of request entries. */
-#define RESPONSE_ENTRY_CNT              16  /* Number of response entries. */
+#define REQUEST_ENTRY_CNT               255 /* Number of request entries. */
+#define RESPONSE_ENTRY_CNT              63  /* Number of response entries. */
 
 /*
  * SCSI Request Block structure  (sp)  that is placed
diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c
index 05fa7796a559..fb388b8c07cf 100644
--- a/drivers/scsi/qla2xxx/qla_attr.c
+++ b/drivers/scsi/qla2xxx/qla_attr.c
@@ -114,7 +114,6 @@ qla2x00_sysfs_write_nvram(struct kobject *kobj,
 {
         struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
             struct device, kobj)));
-        unsigned long   flags;
         uint16_t        cnt;
 
         if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->nvram_size)
@@ -144,11 +143,9 @@ qla2x00_sysfs_write_nvram(struct kobject *kobj,
         }
 
         /* Write NVRAM. */
-        spin_lock_irqsave(&ha->hardware_lock, flags);
         ha->isp_ops->write_nvram(ha, (uint8_t *)buf, ha->nvram_base, count);
         ha->isp_ops->read_nvram(ha, (uint8_t *)ha->nvram, ha->nvram_base,
             count);
-        spin_unlock_irqrestore(&ha->hardware_lock, flags);
 
         set_bit(ISP_ABORT_NEEDED, &ha->dpc_flags);
 
@@ -397,16 +394,13 @@ qla2x00_sysfs_write_vpd(struct kobject *kobj,
 {
         struct scsi_qla_host *ha = shost_priv(dev_to_shost(container_of(kobj,
             struct device, kobj)));
-        unsigned long flags;
 
         if (!capable(CAP_SYS_ADMIN) || off != 0 || count != ha->vpd_size)
                 return 0;
 
         /* Write NVRAM. */
-        spin_lock_irqsave(&ha->hardware_lock, flags);
         ha->isp_ops->write_nvram(ha, (uint8_t *)buf, ha->vpd_base, count);
         ha->isp_ops->read_nvram(ha, (uint8_t *)ha->vpd, ha->vpd_base, count);
-        spin_unlock_irqrestore(&ha->hardware_lock, flags);
 
         return count;
 }
@@ -544,6 +538,9 @@ qla2x00_serial_num_show(struct class_device *cdev, char *buf)
         scsi_qla_host_t *ha = shost_priv(class_to_shost(cdev));
         uint32_t sn;
 
+        if (IS_FWI2_CAPABLE(ha))
+                return snprintf(buf, PAGE_SIZE, "\n");
+
         sn = ((ha->serial0 & 0x1f) << 16) | (ha->serial2 << 8) | ha->serial1;
         return snprintf(buf, PAGE_SIZE, "%c%05d\n", 'A' + sn / 100000,
             sn % 100000);
diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index 1900fbf6cd74..04e8cbca4c0d 100644
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -2271,6 +2271,7 @@ typedef struct scsi_qla_host {
 
         spinlock_t              hardware_lock ____cacheline_aligned;
 
+        int             bars;
         device_reg_t __iomem *iobase;           /* Base I/O address */
         unsigned long   pio_address;
         unsigned long   pio_length;
diff --git a/drivers/scsi/qla2xxx/qla_devtbl.h b/drivers/scsi/qla2xxx/qla_devtbl.h
index dd435410dfa2..d78d35e681ab 100644
--- a/drivers/scsi/qla2xxx/qla_devtbl.h
+++ b/drivers/scsi/qla2xxx/qla_devtbl.h
@@ -1,4 +1,4 @@
-#define QLA_MODEL_NAMES         0x57
+#define QLA_MODEL_NAMES         0x5C
 
 /*
  * Adapter model names and descriptions.
@@ -91,4 +91,9 @@ static char *qla2x00_model_name[QLA_MODEL_NAMES*2] = {
         " ",            " ",                                            /* 0x154 */
         "QLE220",       "PCI-Express to 4Gb FC, Single Channel",        /* 0x155 */
         "QLE220",       "PCI-Express to 4Gb FC, Single Channel",        /* 0x156 */
+        " ",            " ",                                            /* 0x157 */
+        " ",            " ",                                            /* 0x158 */
+        " ",            " ",                                            /* 0x159 */
+        " ",            " ",                                            /* 0x15a */
+        "QME2472",      "Dell BS PCI-Express to 4Gb FC, Dual Channel",  /* 0x15b */
 };
diff --git a/drivers/scsi/qla2xxx/qla_iocb.c b/drivers/scsi/qla2xxx/qla_iocb.c
index 7f6a89bd94f3..024c662ec34d 100644
--- a/drivers/scsi/qla2xxx/qla_iocb.c
+++ b/drivers/scsi/qla2xxx/qla_iocb.c
@@ -525,7 +525,7 @@ qla2x00_req_pkt(scsi_qla_host_t *ha)
 
                 /* Check for pending interrupts. */
                 /* During init we issue marker directly */
-                if (!ha->marker_needed)
+                if (!ha->marker_needed && !ha->flags.init_done)
                         qla2x00_poll(ha);
 
                 spin_lock_irq(&ha->hardware_lock);
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index c4768c4f3990..1104bd2eed40 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -1012,8 +1012,14 @@ qla2x00_status_entry(scsi_qla_host_t *ha, void *pkt)
         case CS_DATA_UNDERRUN:
                 resid = resid_len;
                 /* Use F/W calculated residual length. */
-                if (IS_FWI2_CAPABLE(ha))
+                if (IS_FWI2_CAPABLE(ha)) {
+                        if (scsi_status & SS_RESIDUAL_UNDER &&
+                            resid != fw_resid_len) {
+                                scsi_status &= ~SS_RESIDUAL_UNDER;
+                                lscsi_status = 0;
+                        }
                         resid = fw_resid_len;
+                }
 
                 if (scsi_status & SS_RESIDUAL_UNDER) {
                         scsi_set_resid(cp, resid);
diff --git a/drivers/scsi/qla2xxx/qla_mbx.c b/drivers/scsi/qla2xxx/qla_mbx.c
index c53ec67c47f4..ccd662a6f5dc 100644
--- a/drivers/scsi/qla2xxx/qla_mbx.c
+++ b/drivers/scsi/qla2xxx/qla_mbx.c
@@ -252,7 +252,7 @@ qla2x00_mailbox_command(scsi_qla_host_t *pvha, mbx_cmd_t *mcp)
         /* Clean up */
         ha->mcp = NULL;
 
-        if (!abort_active) {
+        if (abort_active || !io_lock_on) {
                 DEBUG11(printk("%s(%ld): checking for additional resp "
                     "interrupt.\n", __func__, ha->host_no));
 
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 0351d380c2d7..a5bcf1f390b3 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -1482,6 +1482,17 @@ qla2x00_iospace_config(scsi_qla_host_t *ha)
         unsigned long   pio, pio_len, pio_flags;
         unsigned long   mmio, mmio_len, mmio_flags;
 
+        if (pci_request_selected_regions(ha->pdev, ha->bars,
+            QLA2XXX_DRIVER_NAME)) {
+                qla_printk(KERN_WARNING, ha,
+                    "Failed to reserve PIO/MMIO regions (%s)\n",
+                    pci_name(ha->pdev));
+
+                goto iospace_error_exit;
+        }
+        if (!(ha->bars & 1))
+                goto skip_pio;
+
         /* We only need PIO for Flash operations on ISP2312 v2 chips. */
         pio = pci_resource_start(ha->pdev, 0);
         pio_len = pci_resource_len(ha->pdev, 0);
@@ -1499,7 +1510,10 @@ qla2x00_iospace_config(scsi_qla_host_t *ha)
                     pci_name(ha->pdev));
                 pio = 0;
         }
+        ha->pio_address = pio;
+        ha->pio_length = pio_len;
 
+skip_pio:
         /* Use MMIO operations for all accesses. */
         mmio = pci_resource_start(ha->pdev, 1);
         mmio_len = pci_resource_len(ha->pdev, 1);
@@ -1518,16 +1532,6 @@ qla2x00_iospace_config(scsi_qla_host_t *ha)
                 goto iospace_error_exit;
         }
 
-        if (pci_request_regions(ha->pdev, QLA2XXX_DRIVER_NAME)) {
-                qla_printk(KERN_WARNING, ha,
-                    "Failed to reserve PIO/MMIO regions (%s)\n",
-                    pci_name(ha->pdev));
-
-                goto iospace_error_exit;
-        }
-
-        ha->pio_address = pio;
-        ha->pio_length = pio_len;
         ha->iobase = ioremap(mmio, MIN_IOBASE_LEN);
         if (!ha->iobase) {
                 qla_printk(KERN_ERR, ha,
@@ -1579,21 +1583,26 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         char pci_info[30];
         char fw_str[30];
         struct scsi_host_template *sht;
+        int bars;
 
-        if (pci_enable_device(pdev))
-                goto probe_out;
-
-        if (pci_find_aer_capability(pdev))
-                if (pci_enable_pcie_error_reporting(pdev))
-                        goto probe_out;
-
+        bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO);
         sht = &qla2x00_driver_template;
         if (pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2422 ||
             pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2432 ||
             pdev->device == PCI_DEVICE_ID_QLOGIC_ISP5422 ||
             pdev->device == PCI_DEVICE_ID_QLOGIC_ISP5432 ||
-            pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2532)
+            pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2532) {
+                bars = pci_select_bars(pdev, IORESOURCE_MEM);
                 sht = &qla24xx_driver_template;
+        }
+
+        if (pci_enable_device_bars(pdev, bars))
+                goto probe_out;
+
+        if (pci_find_aer_capability(pdev))
+                if (pci_enable_pcie_error_reporting(pdev))
+                        goto probe_out;
+
         host = scsi_host_alloc(sht, sizeof(scsi_qla_host_t));
         if (host == NULL) {
                 printk(KERN_WARNING
@@ -1610,6 +1619,7 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         ha->host_no = host->host_no;
         sprintf(ha->host_str, "%s_%ld", QLA2XXX_DRIVER_NAME, ha->host_no);
         ha->parent = NULL;
+        ha->bars = bars;
 
         /* Set ISP-type information. */
         qla2x00_set_isp_flags(ha);
@@ -1880,7 +1890,7 @@ qla2x00_free_device(scsi_qla_host_t *ha)
         /* release io space registers  */
         if (ha->iobase)
                 iounmap(ha->iobase);
-        pci_release_regions(ha->pdev);
+        pci_release_selected_regions(ha->pdev, ha->bars);
 }
 
 static inline void
@@ -2890,7 +2900,7 @@ qla2xxx_pci_slot_reset(struct pci_dev *pdev)
         pci_ers_result_t ret = PCI_ERS_RESULT_DISCONNECT;
         scsi_qla_host_t *ha = pci_get_drvdata(pdev);
 
-        if (pci_enable_device(pdev)) {
+        if (pci_enable_device_bars(pdev, ha->bars)) {
                 qla_printk(KERN_WARNING, ha,
                     "Can't re-enable PCI device after reset.\n");
 
diff --git a/drivers/scsi/qla2xxx/qla_sup.c b/drivers/scsi/qla2xxx/qla_sup.c
index 40b059fc1981..ad2fa01bd233 100644
--- a/drivers/scsi/qla2xxx/qla_sup.c
+++ b/drivers/scsi/qla2xxx/qla_sup.c
@@ -7,6 +7,7 @@
 #include "qla_def.h"
 
 #include <linux/delay.h>
+#include <linux/vmalloc.h>
 #include <asm/uaccess.h>
 
 static uint16_t qla2x00_nvram_request(scsi_qla_host_t *, uint32_t);
@@ -642,7 +643,7 @@ qla24xx_write_flash_data(scsi_qla_host_t *ha, uint32_t *dwptr, uint32_t faddr,
                 }
 
                 /* Go with burst-write. */
-                if (optrom && (liter + OPTROM_BURST_DWORDS) < dwords) {
+                if (optrom && (liter + OPTROM_BURST_DWORDS) <= dwords) {
                         /* Copy data to DMA'ble buffer. */
                         for (miter = 0, s = optrom, d = dwptr;
                             miter < OPTROM_BURST_DWORDS; miter++, s++, d++)
@@ -656,7 +657,7 @@ qla24xx_write_flash_data(scsi_qla_host_t *ha, uint32_t *dwptr, uint32_t faddr,
                                     "Unable to burst-write optrom segment "
                                     "(%x/%x/%llx).\n", ret,
                                     flash_data_to_access_addr(faddr),
-                                    optrom_dma);
+                                    (unsigned long long)optrom_dma);
                                 qla_printk(KERN_WARNING, ha,
                                     "Reverting to slow-write.\n");
 
@@ -745,9 +746,11 @@ qla2x00_write_nvram_data(scsi_qla_host_t *ha, uint8_t *buf, uint32_t naddr,
         int ret, stat;
         uint32_t i;
         uint16_t *wptr;
+        unsigned long flags;
 
         ret = QLA_SUCCESS;
 
+        spin_lock_irqsave(&ha->hardware_lock, flags);
         qla2x00_lock_nvram_access(ha);
 
         /* Disable NVRAM write-protection. */
@@ -764,6 +767,7 @@ qla2x00_write_nvram_data(scsi_qla_host_t *ha, uint8_t *buf, uint32_t naddr,
         qla2x00_set_nvram_protection(ha, stat);
 
         qla2x00_unlock_nvram_access(ha);
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
 
         return ret;
 }
@@ -776,9 +780,11 @@ qla24xx_write_nvram_data(scsi_qla_host_t *ha, uint8_t *buf, uint32_t naddr,
         uint32_t i;
         uint32_t *dwptr;
         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
+        unsigned long flags;
 
         ret = QLA_SUCCESS;
 
+        spin_lock_irqsave(&ha->hardware_lock, flags);
         /* Enable flash write. */
         WRT_REG_DWORD(&reg->ctrl_status,
             RD_REG_DWORD(&reg->ctrl_status) | CSRX_FLASH_ENABLE);
@@ -812,6 +818,7 @@ qla24xx_write_nvram_data(scsi_qla_host_t *ha, uint8_t *buf, uint32_t naddr,
         WRT_REG_DWORD(&reg->ctrl_status,
             RD_REG_DWORD(&reg->ctrl_status) & ~CSRX_FLASH_ENABLE);
         RD_REG_DWORD(&reg->ctrl_status);        /* PCI Posting. */
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
 
         return ret;
 }
@@ -836,8 +843,20 @@ int
 qla25xx_write_nvram_data(scsi_qla_host_t *ha, uint8_t *buf, uint32_t naddr,
     uint32_t bytes)
 {
-        return qla24xx_write_flash_data(ha, (uint32_t *)buf,
-            FA_VPD_NVRAM_ADDR | naddr, bytes >> 2);
+#define RMW_BUFFER_SIZE (64 * 1024)
+        uint8_t *dbuf;
+
+        dbuf = vmalloc(RMW_BUFFER_SIZE);
+        if (!dbuf)
+                return QLA_MEMORY_ALLOC_FAILED;
+        ha->isp_ops->read_optrom(ha, dbuf, FA_VPD_NVRAM_ADDR << 2,
+            RMW_BUFFER_SIZE);
+        memcpy(dbuf + (naddr << 2), buf, bytes);
+        ha->isp_ops->write_optrom(ha, dbuf, FA_VPD_NVRAM_ADDR << 2,
+            RMW_BUFFER_SIZE);
+        vfree(dbuf);
+
+        return QLA_SUCCESS;
 }
 
 static inline void
@@ -1853,7 +1872,8 @@ qla25xx_read_optrom_data(struct scsi_qla_host *ha, uint8_t *buf,
                         qla_printk(KERN_WARNING, ha,
                             "Unable to burst-read optrom segment "
                             "(%x/%x/%llx).\n", rval,
-                            flash_data_to_access_addr(faddr), optrom_dma);
+                            flash_data_to_access_addr(faddr),
+                            (unsigned long long)optrom_dma);
                         qla_printk(KERN_WARNING, ha,
                             "Reverting to slow-read.\n");
 
diff --git a/drivers/scsi/qla2xxx/qla_version.h b/drivers/scsi/qla2xxx/qla_version.h
index 2d551a3006f6..ae6f7a2fb19f 100644
--- a/drivers/scsi/qla2xxx/qla_version.h
+++ b/drivers/scsi/qla2xxx/qla_version.h
@@ -7,7 +7,7 @@
 /*
  * Driver version
  */
-#define QLA2XXX_VERSION      "8.02.00-k4"
+#define QLA2XXX_VERSION      "8.02.00-k5"
 
 #define QLA_DRIVER_MAJOR_VER    8
 #define QLA_DRIVER_MINOR_VER    2
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index d29f8464b74f..ebaca4ca4a13 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -24,7 +24,6 @@
 #include <linux/interrupt.h>
 #include <linux/blkdev.h>
 #include <linux/delay.h>
-#include <linux/scatterlist.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index daed37df00b1..d531ceeb0d8c 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -209,11 +209,13 @@ show_shost_mode(unsigned int mode, char *buf)
 static ssize_t show_shost_supported_mode(struct class_device *class_dev, char *buf)
 {
         struct Scsi_Host *shost = class_to_shost(class_dev);
+        unsigned int supported_mode = shost->hostt->supported_mode;
 
-        if (shost->hostt->supported_mode == MODE_UNKNOWN)
-                return snprintf(buf, 20, "unknown\n");
-        else
-                return show_shost_mode(shost->hostt->supported_mode, buf);
+        if (supported_mode == MODE_UNKNOWN)
+                /* by default this should be initiator */
+                supported_mode = MODE_INITIATOR;
+
+        return show_shost_mode(supported_mode, buf);
 }
 
 static CLASS_DEVICE_ATTR(supported_mode, S_IRUGO | S_IWUSR, show_shost_supported_mode, NULL);
diff --git a/drivers/scsi/sym53c8xx_2/sym53c8xx.h b/drivers/scsi/sym53c8xx_2/sym53c8xx.h
index 7519728dfc38..62d29cfac9e4 100644
--- a/drivers/scsi/sym53c8xx_2/sym53c8xx.h
+++ b/drivers/scsi/sym53c8xx_2/sym53c8xx.h
@@ -127,7 +127,6 @@ struct sym_driver_setup {
         u_char  settle_delay;
         u_char  use_nvram;
         u_long  excludes[8];
-        char    tag_ctrl[100];
 };
 
 #define SYM_SETUP_MAX_TAG               sym_driver_setup.max_tag
diff --git a/drivers/scsi/sym53c8xx_2/sym_fw.c b/drivers/scsi/sym53c8xx_2/sym_fw.c
index 9916a2a22558..190770bdc194 100644
--- a/drivers/scsi/sym53c8xx_2/sym_fw.c
+++ b/drivers/scsi/sym53c8xx_2/sym_fw.c
@@ -104,8 +104,9 @@ static struct sym_fwz_ofs sym_fw2z_ofs = {
  *  Patch routine for firmware #1.
  */
 static void
-sym_fw1_patch(struct sym_hcb *np)
+sym_fw1_patch(struct Scsi_Host *shost)
 {
+        struct sym_hcb *np = sym_get_hcb(shost);
         struct sym_fw1a_scr *scripta0;
         struct sym_fw1b_scr *scriptb0;
 
@@ -145,8 +146,11 @@ sym_fw1_patch(struct sym_hcb *np)
  *  Patch routine for firmware #2.
  */
 static void
-sym_fw2_patch(struct sym_hcb *np)
+sym_fw2_patch(struct Scsi_Host *shost)
 {
+        struct sym_data *sym_data = shost_priv(shost);
+        struct pci_dev *pdev = sym_data->pdev;
+        struct sym_hcb *np = sym_data->ncb;
         struct sym_fw2a_scr *scripta0;
         struct sym_fw2b_scr *scriptb0;
 
@@ -167,7 +171,7 @@ sym_fw2_patch(struct sym_hcb *np)
          *  Remove useless 64 bit DMA specific SCRIPTS, 
          *  when this feature is not available.
          */
-        if (!np->use_dac) {
+        if (!use_dac(np)) {
                 scripta0->is_dmap_dirty[0] = cpu_to_scr(SCR_NO_OP);
                 scripta0->is_dmap_dirty[1] = 0;
                 scripta0->is_dmap_dirty[2] = cpu_to_scr(SCR_NO_OP);
@@ -205,14 +209,14 @@ sym_fw2_patch(struct sym_hcb *np)
          *  Remove a couple of work-arounds specific to C1010 if 
          *  they are not desirable. See `sym_fw2.h' for more details.
          */
-        if (!(np->device_id == PCI_DEVICE_ID_LSI_53C1010_66 &&
-              np->revision_id < 0x1 &&
+        if (!(pdev->device == PCI_DEVICE_ID_LSI_53C1010_66 &&
+              pdev->revision < 0x1 &&
               np->pciclk_khz < 60000)) {
                 scripta0->datao_phase[0] = cpu_to_scr(SCR_NO_OP);
                 scripta0->datao_phase[1] = cpu_to_scr(0);
         }
-        if (!(np->device_id == PCI_DEVICE_ID_LSI_53C1010_33 &&
-              /* np->revision_id < 0xff */ 1)) {
+        if (!(pdev->device == PCI_DEVICE_ID_LSI_53C1010_33 /* &&
+              pdev->revision < 0xff */)) {
                 scripta0->sel_done[0] = cpu_to_scr(SCR_NO_OP);
                 scripta0->sel_done[1] = cpu_to_scr(0);
         }
diff --git a/drivers/scsi/sym53c8xx_2/sym_fw.h b/drivers/scsi/sym53c8xx_2/sym_fw.h
index 66ec35beab5b..ae7e0f9e93fc 100644
--- a/drivers/scsi/sym53c8xx_2/sym_fw.h
+++ b/drivers/scsi/sym53c8xx_2/sym_fw.h
@@ -143,7 +143,7 @@ struct sym_fw {
                 *z_ofs;         /* Useful offsets in script Z   */
         /* Setup and patch methods for this firmware */
         void    (*setup)(struct sym_hcb *, struct sym_fw *);
-        void    (*patch)(struct sym_hcb *);
+        void    (*patch)(struct Scsi_Host *);
 };
 
 /*
diff --git a/drivers/scsi/sym53c8xx_2/sym_glue.c b/drivers/scsi/sym53c8xx_2/sym_glue.c
index db03c4c8ec1e..0f74aba5b237 100644
--- a/drivers/scsi/sym53c8xx_2/sym_glue.c
+++ b/drivers/scsi/sym53c8xx_2/sym_glue.c
@@ -39,7 +39,6 @@
  */
 #include <linux/ctype.h>
 #include <linux/init.h>
-#include <linux/interrupt.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/spinlock.h>
@@ -54,16 +53,12 @@
 #define NAME53C         "sym53c"
 #define NAME53C8XX      "sym53c8xx"
 
-#define IRQ_FMT "%d"
-#define IRQ_PRM(x) (x)
-
 struct sym_driver_setup sym_driver_setup = SYM_LINUX_DRIVER_SETUP;
 unsigned int sym_debug_flags = 0;
 
 static char *excl_string;
 static char *safe_string;
 module_param_named(cmd_per_lun, sym_driver_setup.max_tag, ushort, 0);
-module_param_string(tag_ctrl, sym_driver_setup.tag_ctrl, 100, 0);
 module_param_named(burst, sym_driver_setup.burst_order, byte, 0);
 module_param_named(led, sym_driver_setup.scsi_led, byte, 0);
 module_param_named(diff, sym_driver_setup.scsi_diff, byte, 0);
@@ -78,7 +73,6 @@ module_param_named(excl, excl_string, charp, 0);
 module_param_named(safe, safe_string, charp, 0);
 
 MODULE_PARM_DESC(cmd_per_lun, "The maximum number of tags to use by default");
-MODULE_PARM_DESC(tag_ctrl, "More detailed control over tags per LUN");
 MODULE_PARM_DESC(burst, "Maximum burst.  0 to disable, 255 to read from registers");
 MODULE_PARM_DESC(led, "Set to 1 to enable LED support");
 MODULE_PARM_DESC(diff, "0 for no differential mode, 1 for BIOS, 2 for always, 3 for not GPIO3");
@@ -134,56 +128,26 @@ static struct scsi_transport_template *sym2_transport_template = NULL;
  *  Driver private area in the SCSI command structure.
  */
 struct sym_ucmd {               /* Override the SCSI pointer structure */
-        dma_addr_t      data_mapping;
-        unsigned char   data_mapped;
-        unsigned char   to_do;                  /* For error handling */
-        void (*old_done)(struct scsi_cmnd *);   /* For error handling */
-        struct completion *eh_done;             /* For error handling */
+        struct completion *eh_done;             /* SCSI error handling */
 };
 
 #define SYM_UCMD_PTR(cmd)  ((struct sym_ucmd *)(&(cmd)->SCp))
 #define SYM_SOFTC_PTR(cmd) sym_get_hcb(cmd->device->host)
 
-static void __unmap_scsi_data(struct pci_dev *pdev, struct scsi_cmnd *cmd)
-{
-        if (SYM_UCMD_PTR(cmd)->data_mapped)
-                scsi_dma_unmap(cmd);
-
-        SYM_UCMD_PTR(cmd)->data_mapped = 0;
-}
-
-static int __map_scsi_sg_data(struct pci_dev *pdev, struct scsi_cmnd *cmd)
-{
-        int use_sg;
-
-        use_sg = scsi_dma_map(cmd);
-        if (use_sg > 0) {
-                SYM_UCMD_PTR(cmd)->data_mapped  = 2;
-                SYM_UCMD_PTR(cmd)->data_mapping = use_sg;
-        }
-
-        return use_sg;
-}
-
-#define unmap_scsi_data(np, cmd)        \
-                __unmap_scsi_data(np->s.device, cmd)
-#define map_scsi_sg_data(np, cmd)       \
-                __map_scsi_sg_data(np->s.device, cmd)
 /*
  *  Complete a pending CAM CCB.
  */
 void sym_xpt_done(struct sym_hcb *np, struct scsi_cmnd *cmd)
 {
-        unmap_scsi_data(np, cmd);
-        cmd->scsi_done(cmd);
-}
+        struct sym_ucmd *ucmd = SYM_UCMD_PTR(cmd);
+        BUILD_BUG_ON(sizeof(struct scsi_pointer) < sizeof(struct sym_ucmd));
 
-static void sym_xpt_done2(struct sym_hcb *np, struct scsi_cmnd *cmd, int cam_status)
-{
-        sym_set_cam_status(cmd, cam_status);
-        sym_xpt_done(np, cmd);
-}
+        if (ucmd->eh_done)
+                complete(ucmd->eh_done);
 
+        scsi_dma_unmap(cmd);
+        cmd->scsi_done(cmd);
+}
 
 /*
  *  Tell the SCSI layer about a BUS RESET.
@@ -199,14 +163,6 @@ void sym_xpt_async_bus_reset(struct sym_hcb *np)
 }
 
 /*
- *  Tell the SCSI layer about a BUS DEVICE RESET message sent.
- */
-void sym_xpt_async_sent_bdr(struct sym_hcb *np, int target)
-{
-        printf_notice("%s: TARGET %d has been reset.\n", sym_name(np), target);
-}
-
-/*
  *  Choose the more appropriate CAM status if 
  *  the IO encountered an extended error.
  */
@@ -307,14 +263,14 @@ static int sym_scatter(struct sym_hcb *np, struct sym_ccb *cp, struct scsi_cmnd
 
         cp->data_len = 0;
 
-        use_sg = map_scsi_sg_data(np, cmd);
+        use_sg = scsi_dma_map(cmd);
         if (use_sg > 0) {
                 struct scatterlist *sg;
                 struct sym_tcb *tp = &np->target[cp->target];
                 struct sym_tblmove *data;
 
                 if (use_sg > SYM_CONF_MAX_SG) {
-                        unmap_scsi_data(np, cmd);
+                        scsi_dma_unmap(cmd);
                         return -1;
                 }
 
@@ -351,15 +307,6 @@ static int sym_queue_command(struct sym_hcb *np, struct scsi_cmnd *cmd)
         int     order;
 
         /*
-         *  Minimal checkings, so that we will not 
-         *  go outside our tables.
-         */
-        if (sdev->id == np->myaddr) {
-                sym_xpt_done2(np, cmd, DID_NO_CONNECT);
-                return 0;
-        }
-
-        /*
          *  Retrieve the target descriptor.
          */
         tp = &np->target[sdev->id];
@@ -433,7 +380,7 @@ int sym_setup_data_and_start(struct sym_hcb *np, struct scsi_cmnd *cmd, struct s
          */
         switch (dir) {
         case DMA_BIDIRECTIONAL:
-                printk("%s: got DMA_BIDIRECTIONAL command", sym_name(np));
+                scmd_printk(KERN_INFO, cmd, "got DMA_BIDIRECTIONAL command");
                 sym_set_cam_status(cmd, DID_ERROR);
                 goto out_abort;
         case DMA_TO_DEVICE:
@@ -542,14 +489,16 @@ static void sym_timer(struct sym_hcb *np)
 /*
  *  PCI BUS error handler.
  */
-void sym_log_bus_error(struct sym_hcb *np)
+void sym_log_bus_error(struct Scsi_Host *shost)
 {
-        u_short pci_sts;
-        pci_read_config_word(np->s.device, PCI_STATUS, &pci_sts);
+        struct sym_data *sym_data = shost_priv(shost);
+        struct pci_dev *pdev = sym_data->pdev;
+        unsigned short pci_sts;
+        pci_read_config_word(pdev, PCI_STATUS, &pci_sts);
         if (pci_sts & 0xf900) {
-                pci_write_config_word(np->s.device, PCI_STATUS, pci_sts);
-                printf("%s: PCI STATUS = 0x%04x\n",
-                        sym_name(np), pci_sts & 0xf900);
+                pci_write_config_word(pdev, PCI_STATUS, pci_sts);
+                shost_printk(KERN_WARNING, shost,
+                        "PCI bus error: status = 0x%04x\n", pci_sts & 0xf900);
         }
 }
 
@@ -564,7 +513,7 @@ static int sym53c8xx_queue_command(struct scsi_cmnd *cmd,
         struct sym_ucmd *ucp = SYM_UCMD_PTR(cmd);
         int sts = 0;
 
-        cmd->scsi_done     = done;
+        cmd->scsi_done = done;
         memset(ucp, 0, sizeof(*ucp));
 
         /*
@@ -593,18 +542,23 @@ static int sym53c8xx_queue_command(struct scsi_cmnd *cmd,
  */
 static irqreturn_t sym53c8xx_intr(int irq, void *dev_id)
 {
-        unsigned long flags;
-        struct sym_hcb *np = (struct sym_hcb *)dev_id;
+        struct Scsi_Host *shost = dev_id;
+        struct sym_data *sym_data = shost_priv(shost);
+        irqreturn_t result;
+
+        /* Avoid spinloop trying to handle interrupts on frozen device */
+        if (pci_channel_offline(sym_data->pdev))
+                return IRQ_NONE;
 
         if (DEBUG_FLAGS & DEBUG_TINY) printf_debug ("[");
 
-        spin_lock_irqsave(np->s.host->host_lock, flags);
-        sym_interrupt(np);
-        spin_unlock_irqrestore(np->s.host->host_lock, flags);
+        spin_lock(shost->host_lock);
+        result = sym_interrupt(shost);
+        spin_unlock(shost->host_lock);
 
         if (DEBUG_FLAGS & DEBUG_TINY) printf_debug ("]\n");
 
-        return IRQ_HANDLED;
+        return result;
 }
 
 /*
@@ -630,59 +584,61 @@ static void sym53c8xx_timer(unsigned long npref)
 #define SYM_EH_HOST_RESET       3
 
 /*
- *  What we will do regarding the involved SCSI command.
- */
-#define SYM_EH_DO_IGNORE        0
-#define SYM_EH_DO_WAIT          2
-
-/*
- *  scsi_done() alias when error recovery is in progress.
- */
-static void sym_eh_done(struct scsi_cmnd *cmd)
-{
-        struct sym_ucmd *ucmd = SYM_UCMD_PTR(cmd);
-        BUILD_BUG_ON(sizeof(struct scsi_pointer) < sizeof(struct sym_ucmd));
-
-        cmd->scsi_done = ucmd->old_done;
-
-        if (ucmd->to_do == SYM_EH_DO_WAIT)
-                complete(ucmd->eh_done);
-}
-
-/*
  *  Generic method for our eh processing.
  *  The 'op' argument tells what we have to do.
  */
 static int sym_eh_handler(int op, char *opname, struct scsi_cmnd *cmd)
 {
-        struct sym_hcb *np = SYM_SOFTC_PTR(cmd);
         struct sym_ucmd *ucmd = SYM_UCMD_PTR(cmd);
-        struct Scsi_Host *host = cmd->device->host;
+        struct Scsi_Host *shost = cmd->device->host;
+        struct sym_data *sym_data = shost_priv(shost);
+        struct pci_dev *pdev = sym_data->pdev;
+        struct sym_hcb *np = sym_data->ncb;
         SYM_QUEHEAD *qp;
-        int to_do = SYM_EH_DO_IGNORE;
+        int cmd_queued = 0;
         int sts = -1;
         struct completion eh_done;
 
-        dev_warn(&cmd->device->sdev_gendev, "%s operation started.\n", opname);
+        scmd_printk(KERN_WARNING, cmd, "%s operation started\n", opname);
+
+        /* We may be in an error condition because the PCI bus
+         * went down. In this case, we need to wait until the
+         * PCI bus is reset, the card is reset, and only then
+         * proceed with the scsi error recovery.  There's no
+         * point in hurrying; take a leisurely wait.
+         */
+#define WAIT_FOR_PCI_RECOVERY   35
+        if (pci_channel_offline(pdev)) {
+                struct completion *io_reset;
+                int finished_reset = 0;
+                init_completion(&eh_done);
+                spin_lock_irq(shost->host_lock);
+                /* Make sure we didn't race */
+                if (pci_channel_offline(pdev)) {
+                        if (!sym_data->io_reset)
+                                sym_data->io_reset = &eh_done;
+                        io_reset = sym_data->io_reset;
+                } else {
+                        finished_reset = 1;
+                }
+                spin_unlock_irq(shost->host_lock);
+                if (!finished_reset)
+                        finished_reset = wait_for_completion_timeout(io_reset,
+                                                WAIT_FOR_PCI_RECOVERY*HZ);
+                if (!finished_reset)
+                        return SCSI_FAILED;
+        }
 
-        spin_lock_irq(host->host_lock);
+        spin_lock_irq(shost->host_lock);
         /* This one is queued in some place -> to wait for completion */
         FOR_EACH_QUEUED_ELEMENT(&np->busy_ccbq, qp) {
                 struct sym_ccb *cp = sym_que_entry(qp, struct sym_ccb, link_ccbq);
                 if (cp->cmd == cmd) {
-                        to_do = SYM_EH_DO_WAIT;
+                        cmd_queued = 1;
                         break;
                 }
         }
 
-        if (to_do == SYM_EH_DO_WAIT) {
-                init_completion(&eh_done);
-                ucmd->old_done = cmd->scsi_done;
-                ucmd->eh_done = &eh_done;
-                wmb();
-                cmd->scsi_done = sym_eh_done;
-        }
-
         /* Try to proceed the operation we have been asked for */
         sts = -1;
         switch(op) {
@@ -698,7 +654,7 @@ static int sym_eh_handler(int op, char *opname, struct scsi_cmnd *cmd)
                 break;
         case SYM_EH_HOST_RESET:
                 sym_reset_scsi_bus(np, 0);
-                sym_start_up (np, 1);
+                sym_start_up(shost, 1);
                 sts = 0;
                 break;
         default:
@@ -706,21 +662,21 @@ static int sym_eh_handler(int op, char *opname, struct scsi_cmnd *cmd)
         }
 
         /* On error, restore everything and cross fingers :) */
-        if (sts) {
-                cmd->scsi_done = ucmd->old_done;
-                to_do = SYM_EH_DO_IGNORE;
-        }
-
-        ucmd->to_do = to_do;
-        spin_unlock_irq(host->host_lock);
+        if (sts)
+                cmd_queued = 0;
 
-        if (to_do == SYM_EH_DO_WAIT) {
+        if (cmd_queued) {
+                init_completion(&eh_done);
+                ucmd->eh_done = &eh_done;
+                spin_unlock_irq(shost->host_lock);
                 if (!wait_for_completion_timeout(&eh_done, 5*HZ)) {
-                        ucmd->to_do = SYM_EH_DO_IGNORE;
-                        wmb();
+                        ucmd->eh_done = NULL;
                         sts = -2;
                 }
+        } else {
+                spin_unlock_irq(shost->host_lock);
         }
+
         dev_warn(&cmd->device->sdev_gendev, "%s operation %s.\n", opname,
                         sts==0 ? "complete" :sts==-2 ? "timed-out" : "failed");
         return sts ? SCSI_FAILED : SCSI_SUCCESS;
@@ -775,59 +731,6 @@ static void sym_tune_dev_queuing(struct sym_tcb *tp, int lun, u_short reqtags)
         }
 }
 
-/*
- *  Linux select queue depths function
- */
-#define DEF_DEPTH       (sym_driver_setup.max_tag)
-#define ALL_TARGETS     -2
-#define NO_TARGET       -1
-#define ALL_LUNS        -2
-#define NO_LUN          -1
-
-static int device_queue_depth(struct sym_hcb *np, int target, int lun)
-{
-        int c, h, t, u, v;
-        char *p = sym_driver_setup.tag_ctrl;
-        char *ep;
-
-        h = -1;
-        t = NO_TARGET;
-        u = NO_LUN;
-        while ((c = *p++) != 0) {
-                v = simple_strtoul(p, &ep, 0);
-                switch(c) {
-                case '/':
-                        ++h;
-                        t = ALL_TARGETS;
-                        u = ALL_LUNS;
-                        break;
-                case 't':
-                        if (t != target)
-                                t = (target == v) ? v : NO_TARGET;
-                        u = ALL_LUNS;
-                        break;
-                case 'u':
-                        if (u != lun)
-                                u = (lun == v) ? v : NO_LUN;
-                        break;
-                case 'q':
-                        if (h == np->s.unit &&
-                                (t == ALL_TARGETS || t == target) &&
-                                (u == ALL_LUNS    || u == lun))
-                                return v;
-                        break;
-                case '-':
-                        t = ALL_TARGETS;
-                        u = ALL_LUNS;
-                        break;
-                default:
-                        break;
-                }
-                p = ep;
-        }
-        return DEF_DEPTH;
-}
-
 static int sym53c8xx_slave_alloc(struct scsi_device *sdev)
 {
         struct sym_hcb *np = sym_get_hcb(sdev->host);
@@ -892,21 +795,16 @@ static int sym53c8xx_slave_configure(struct scsi_device *sdev)
          *  Use at least 2.
          *  Donnot use more than our maximum.
          */
-        reqtags = device_queue_depth(np, sdev->id, sdev->lun);
+        reqtags = sym_driver_setup.max_tag;
         if (reqtags > tp->usrtags)
                 reqtags = tp->usrtags;
         if (!sdev->tagged_supported)
                 reqtags = 0;
-#if 1 /* Avoid to locally queue commands for no good reasons */
         if (reqtags > SYM_CONF_MAX_TAG)
                 reqtags = SYM_CONF_MAX_TAG;
-        depth_to_use = (reqtags ? reqtags : 2);
-#else
-        depth_to_use = (reqtags ? SYM_CONF_MAX_TAG : 2);
-#endif
+        depth_to_use = reqtags ? reqtags : 2;
         scsi_adjust_queue_depth(sdev,
-                                (sdev->tagged_supported ?
-                                 MSG_SIMPLE_TAG : 0),
+                                sdev->tagged_supported ? MSG_SIMPLE_TAG : 0,
                                 depth_to_use);
         lp->s.scdev_depth = depth_to_use;
         sym_tune_dev_queuing(tp, sdev->lun, reqtags);
@@ -1089,8 +987,9 @@ static int is_keyword(char *ptr, int len, char *verb)
  * Parse a control command
  */
 
-static int sym_user_command(struct sym_hcb *np, char *buffer, int length)
+static int sym_user_command(struct Scsi_Host *shost, char *buffer, int length)
 {
+        struct sym_hcb *np = sym_get_hcb(shost);
         char *ptr       = buffer;
         int len         = length;
         struct sym_usrcmd cmd, *uc = &cmd;
@@ -1217,9 +1116,9 @@ printk("sym_user_command: data=%ld\n", uc->data);
         else {
                 unsigned long flags;
 
-                spin_lock_irqsave(np->s.host->host_lock, flags);
-                sym_exec_user_command (np, uc);
-                spin_unlock_irqrestore(np->s.host->host_lock, flags);
+                spin_lock_irqsave(shost->host_lock, flags);
+                sym_exec_user_command(np, uc);
+                spin_unlock_irqrestore(shost->host_lock, flags);
         }
         return length;
 }
@@ -1275,8 +1174,11 @@ static int copy_info(struct info_str *info, char *fmt, ...)
 /*
  *  Copy formatted information into the input buffer.
  */
-static int sym_host_info(struct sym_hcb *np, char *ptr, off_t offset, int len)
+static int sym_host_info(struct Scsi_Host *shost, char *ptr, off_t offset, int len)
 {
+        struct sym_data *sym_data = shost_priv(shost);
+        struct pci_dev *pdev = sym_data->pdev;
+        struct sym_hcb *np = sym_data->ncb;
         struct info_str info;
 
         info.buffer     = ptr;
@@ -1285,10 +1187,10 @@ static int sym_host_info(struct sym_hcb *np, char *ptr, off_t offset, int len)
         info.pos        = 0;
 
         copy_info(&info, "Chip " NAME53C "%s, device id 0x%x, "
-                         "revision id 0x%x\n",
-                         np->s.chip_name, np->device_id, np->revision_id);
-        copy_info(&info, "At PCI address %s, IRQ " IRQ_FMT "\n",
-                pci_name(np->s.device), IRQ_PRM(np->s.irq));
+                         "revision id 0x%x\n", np->s.chip_name,
+                         pdev->device, pdev->revision);
+        copy_info(&info, "At PCI address %s, IRQ %u\n",
+                         pci_name(pdev), pdev->irq);
         copy_info(&info, "Min. period factor %d, %s SCSI BUS%s\n",
                          (int) (np->minsync_dt ? np->minsync_dt : np->minsync),
                          np->maxwide ? "Wide" : "Narrow",
@@ -1307,15 +1209,14 @@ static int sym_host_info(struct sym_hcb *np, char *ptr, off_t offset, int len)
  *  - func = 0 means read  (returns adapter infos)
  *  - func = 1 means write (not yet merget from sym53c8xx)
  */
-static int sym53c8xx_proc_info(struct Scsi_Host *host, char *buffer,
+static int sym53c8xx_proc_info(struct Scsi_Host *shost, char *buffer,
                         char **start, off_t offset, int length, int func)
 {
-        struct sym_hcb *np = sym_get_hcb(host);
         int retv;
 
         if (func) {
 #ifdef  SYM_LINUX_USER_COMMAND_SUPPORT
-                retv = sym_user_command(np, buffer, length);
+                retv = sym_user_command(shost, buffer, length);
 #else
                 retv = -EINVAL;
 #endif
@@ -1323,7 +1224,7 @@ static int sym53c8xx_proc_info(struct Scsi_Host *host, char *buffer,
                 if (start)
                         *start = buffer;
 #ifdef SYM_LINUX_USER_INFO_SUPPORT
-                retv = sym_host_info(np, buffer, offset, length);
+                retv = sym_host_info(shost, buffer, offset, length);
 #else
                 retv = -EINVAL;
 #endif
@@ -1341,8 +1242,8 @@ static void sym_free_resources(struct sym_hcb *np, struct pci_dev *pdev)
         /*
          *  Free O/S specific resources.
          */
-        if (np->s.irq)
-                free_irq(np->s.irq, np);
+        if (pdev->irq)
+                free_irq(pdev->irq, np);
         if (np->s.ioaddr)
                 pci_iounmap(pdev, np->s.ioaddr);
         if (np->s.ramaddr)
@@ -1356,31 +1257,6 @@ static void sym_free_resources(struct sym_hcb *np, struct pci_dev *pdev)
 }
 
 /*
- *  Ask/tell the system about DMA addressing.
- */
-static int sym_setup_bus_dma_mask(struct sym_hcb *np)
-{
-#if SYM_CONF_DMA_ADDRESSING_MODE > 0
-#if   SYM_CONF_DMA_ADDRESSING_MODE == 1
-#define DMA_DAC_MASK    DMA_40BIT_MASK
-#elif SYM_CONF_DMA_ADDRESSING_MODE == 2
-#define DMA_DAC_MASK    DMA_64BIT_MASK
-#endif
-        if ((np->features & FE_DAC) &&
-                        !pci_set_dma_mask(np->s.device, DMA_DAC_MASK)) {
-                np->use_dac = 1;
-                return 0;
-        }
-#endif
-
-        if (!pci_set_dma_mask(np->s.device, DMA_32BIT_MASK))
-                return 0;
-
-        printf_warning("%s: No suitable DMA available\n", sym_name(np));
-        return -1;
-}
-
-/*
  *  Host attach and initialisations.
  *
  *  Allocate host data and ncb structure.
@@ -1392,32 +1268,28 @@ static int sym_setup_bus_dma_mask(struct sym_hcb *np)
 static struct Scsi_Host * __devinit sym_attach(struct scsi_host_template *tpnt,
                 int unit, struct sym_device *dev)
 {
-        struct host_data *host_data;
+        struct sym_data *sym_data;
         struct sym_hcb *np = NULL;
-        struct Scsi_Host *instance = NULL;
+        struct Scsi_Host *shost;
         struct pci_dev *pdev = dev->pdev;
         unsigned long flags;
         struct sym_fw *fw;
 
-        printk(KERN_INFO
-                "sym%d: <%s> rev 0x%x at pci %s irq " IRQ_FMT "\n",
-                unit, dev->chip.name, dev->chip.revision_id,
-                pci_name(pdev), IRQ_PRM(pdev->irq));
+        printk(KERN_INFO "sym%d: <%s> rev 0x%x at pci %s irq %u\n",
+                unit, dev->chip.name, pdev->revision, pci_name(pdev),
+                pdev->irq);
 
         /*
          *  Get the firmware for this chip.
          */
         fw = sym_find_firmware(&dev->chip);
         if (!fw)
-                goto attach_failed;
+                return NULL;
 
-        /*
-         *      Allocate host_data structure
-         */
-        instance = scsi_host_alloc(tpnt, sizeof(*host_data));
-        if (!instance)
-                goto attach_failed;
-        host_data = (struct host_data *) instance->hostdata;
+        shost = scsi_host_alloc(tpnt, sizeof(*sym_data));
+        if (!shost)
+                return NULL;
+        sym_data = shost_priv(shost);
 
         /*
          *  Allocate immediately the host control block, 
@@ -1428,22 +1300,19 @@ static struct Scsi_Host * __devinit sym_attach(struct scsi_host_template *tpnt,
         np = __sym_calloc_dma(&pdev->dev, sizeof(*np), "HCB");
         if (!np)
                 goto attach_failed;
-        np->s.device = pdev;
         np->bus_dmat = &pdev->dev; /* Result in 1 DMA pool per HBA */
-        host_data->ncb = np;
-        np->s.host = instance;
+        sym_data->ncb = np;
+        sym_data->pdev = pdev;
+        np->s.host = shost;
 
-        pci_set_drvdata(pdev, np);
+        pci_set_drvdata(pdev, shost);
 
         /*
          *  Copy some useful infos to the HCB.
          */
         np->hcb_ba      = vtobus(np);
         np->verbose     = sym_driver_setup.verbose;
-        np->s.device    = pdev;
         np->s.unit      = unit;
-        np->device_id   = dev->chip.device_id;
-        np->revision_id = dev->chip.revision_id;
         np->features    = dev->chip.features;
         np->clock_divn  = dev->chip.nr_divisor;
         np->maxoffs     = dev->chip.offset_max;
@@ -1456,8 +1325,13 @@ static struct Scsi_Host * __devinit sym_attach(struct scsi_host_template *tpnt,
         strlcpy(np->s.chip_name, dev->chip.name, sizeof(np->s.chip_name));
         sprintf(np->s.inst_name, "sym%d", np->s.unit);
 
-        if (sym_setup_bus_dma_mask(np))
+        if ((SYM_CONF_DMA_ADDRESSING_MODE > 0) && (np->features & FE_DAC) &&
+                        !pci_set_dma_mask(pdev, DMA_DAC_MASK)) {
+                set_dac(np);
+        } else if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
+                printf_warning("%s: No suitable DMA available\n", sym_name(np));
                 goto attach_failed;
+        }
 
         /*
          *  Try to map the controller chip to
@@ -1466,19 +1340,16 @@ static struct Scsi_Host * __devinit sym_attach(struct scsi_host_template *tpnt,
         np->mmio_ba = (u32)dev->mmio_base;
         np->s.ioaddr    = dev->s.ioaddr;
         np->s.ramaddr   = dev->s.ramaddr;
-        np->s.io_ws = (np->features & FE_IO256) ? 256 : 128;
 
         /*
          *  Map on-chip RAM if present and supported.
          */
         if (!(np->features & FE_RAM))
                 dev->ram_base = 0;
-        if (dev->ram_base) {
+        if (dev->ram_base)
                 np->ram_ba = (u32)dev->ram_base;
-                np->ram_ws = (np->features & FE_RAM8K) ? 8192 : 4096;
-        }
 
-        if (sym_hcb_attach(instance, fw, dev->nvram))
+        if (sym_hcb_attach(shost, fw, dev->nvram))
                 goto attach_failed;
 
         /*
@@ -1486,25 +1357,25 @@ static struct Scsi_Host * __devinit sym_attach(struct scsi_host_template *tpnt,
          *  If we synchonize the C code with SCRIPTS on interrupt, 
          *  we do not want to share the INTR line at all.
          */
-        if (request_irq(pdev->irq, sym53c8xx_intr, IRQF_SHARED, NAME53C8XX, np)) {
-                printf_err("%s: request irq %d failure\n",
+        if (request_irq(pdev->irq, sym53c8xx_intr, IRQF_SHARED, NAME53C8XX,
+                        shost)) {
+                printf_err("%s: request irq %u failure\n",
                         sym_name(np), pdev->irq);
                 goto attach_failed;
         }
-        np->s.irq = pdev->irq;
 
         /*
          *  After SCSI devices have been opened, we cannot
          *  reset the bus safely, so we do it here.
          */
-        spin_lock_irqsave(instance->host_lock, flags);
+        spin_lock_irqsave(shost->host_lock, flags);
         if (sym_reset_scsi_bus(np, 0))
                 goto reset_failed;
 
         /*
          *  Start the SCRIPTS.
          */
-        sym_start_up (np, 1);
+        sym_start_up(shost, 1);
 
         /*
          *  Start the timer daemon
@@ -1519,33 +1390,37 @@ static struct Scsi_Host * __devinit sym_attach(struct scsi_host_template *tpnt,
          *  Fill Linux host instance structure
          *  and return success.
          */
-        instance->max_channel   = 0;
-        instance->this_id       = np->myaddr;
-        instance->max_id        = np->maxwide ? 16 : 8;
-        instance->max_lun       = SYM_CONF_MAX_LUN;
-        instance->unique_id     = pci_resource_start(pdev, 0);
-        instance->cmd_per_lun   = SYM_CONF_MAX_TAG;
-        instance->can_queue     = (SYM_CONF_MAX_START-2);
-        instance->sg_tablesize  = SYM_CONF_MAX_SG;
-        instance->max_cmd_len   = 16;
+        shost->max_channel      = 0;
+        shost->this_id          = np->myaddr;
+        shost->max_id           = np->maxwide ? 16 : 8;
+        shost->max_lun          = SYM_CONF_MAX_LUN;
+        shost->unique_id        = pci_resource_start(pdev, 0);
+        shost->cmd_per_lun      = SYM_CONF_MAX_TAG;
+        shost->can_queue        = (SYM_CONF_MAX_START-2);
+        shost->sg_tablesize     = SYM_CONF_MAX_SG;
+        shost->max_cmd_len      = 16;
         BUG_ON(sym2_transport_template == NULL);
-        instance->transportt    = sym2_transport_template;
+        shost->transportt       = sym2_transport_template;
+
+        /* 53c896 rev 1 errata: DMA may not cross 16MB boundary */
+        if (pdev->device == PCI_DEVICE_ID_NCR_53C896 && pdev->revision < 2)
+                shost->dma_boundary = 0xFFFFFF;
 
-        spin_unlock_irqrestore(instance->host_lock, flags);
+        spin_unlock_irqrestore(shost->host_lock, flags);
 
-        return instance;
+        return shost;
 
  reset_failed:
         printf_err("%s: FATAL ERROR: CHECK SCSI BUS - CABLES, "
                    "TERMINATION, DEVICE POWER etc.!\n", sym_name(np));
-        spin_unlock_irqrestore(instance->host_lock, flags);
+        spin_unlock_irqrestore(shost->host_lock, flags);
  attach_failed:
-        if (!instance)
+        if (!shost)
                 return NULL;
         printf_info("%s: giving up ...\n", sym_name(np));
         if (np)
                 sym_free_resources(np, pdev);
-        scsi_host_put(instance);
+        scsi_host_put(shost);
 
         return NULL;
  }
@@ -1558,7 +1433,6 @@ static struct Scsi_Host * __devinit sym_attach(struct scsi_host_template *tpnt,
 static void __devinit sym_get_nvram(struct sym_device *devp, struct sym_nvram *nvp)
 {
         devp->nvram = nvp;
-        devp->device_id = devp->chip.device_id;
         nvp->type = 0;
 
         sym_read_nvram(devp, nvp);
@@ -1573,7 +1447,6 @@ static int __devinit sym_check_supported(struct sym_device *device)
 {
         struct sym_chip *chip;
         struct pci_dev *pdev = device->pdev;
-        u_char revision;
         unsigned long io_port = pci_resource_start(pdev, 0);
         int i;
 
@@ -1593,14 +1466,12 @@ static int __devinit sym_check_supported(struct sym_device *device)
          * to our device structure so we can make it match the actual device
          * and options.
          */
-        pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
-        chip = sym_lookup_chip_table(pdev->device, revision);
+        chip = sym_lookup_chip_table(pdev->device, pdev->revision);
         if (!chip) {
                 dev_info(&pdev->dev, "device not supported\n");
                 return -ENODEV;
         }
         memcpy(&device->chip, chip, sizeof(device->chip));
-        device->chip.revision_id = revision;
 
         return 0;
 }
@@ -1641,7 +1512,7 @@ static int __devinit sym_set_workarounds(struct sym_device *device)
          *  We must ensure the chip will use WRITE AND INVALIDATE.
          *  The revision number limit is for now arbitrary.
          */
-        if (pdev->device == PCI_DEVICE_ID_NCR_53C896 && chip->revision_id < 0x4) {
+        if (pdev->device == PCI_DEVICE_ID_NCR_53C896 && pdev->revision < 0x4) {
                 chip->features  |= (FE_WRIE | FE_CLSE);
         }
 
@@ -1769,8 +1640,9 @@ static void sym_config_pqs(struct pci_dev *pdev, struct sym_device *sym_dev)
  *  Detach the host.
  *  We have to free resources and halt the NCR chip.
  */
-static int sym_detach(struct sym_hcb *np, struct pci_dev *pdev)
+static int sym_detach(struct Scsi_Host *shost, struct pci_dev *pdev)
 {
+        struct sym_hcb *np = sym_get_hcb(shost);
         printk("%s: detaching ...\n", sym_name(np));
 
         del_timer_sync(&np->s.timer);
@@ -1823,7 +1695,7 @@ static int __devinit sym2_probe(struct pci_dev *pdev,
 {
         struct sym_device sym_dev;
         struct sym_nvram nvram;
-        struct Scsi_Host *instance;
+        struct Scsi_Host *shost;
 
         memset(&sym_dev, 0, sizeof(sym_dev));
         memset(&nvram, 0, sizeof(nvram));
@@ -1850,13 +1722,13 @@ static int __devinit sym2_probe(struct pci_dev *pdev,
 
         sym_get_nvram(&sym_dev, &nvram);
 
-        instance = sym_attach(&sym2_template, attach_count, &sym_dev);
-        if (!instance)
+        shost = sym_attach(&sym2_template, attach_count, &sym_dev);
+        if (!shost)
                 goto free;
 
-        if (scsi_add_host(instance, &pdev->dev))
+        if (scsi_add_host(shost, &pdev->dev))
                 goto detach;
-        scsi_scan_host(instance);
+        scsi_scan_host(shost);
 
         attach_count++;
 
@@ -1874,20 +1746,143 @@ static int __devinit sym2_probe(struct pci_dev *pdev,
 
 static void __devexit sym2_remove(struct pci_dev *pdev)
 {
-        struct sym_hcb *np = pci_get_drvdata(pdev);
-        struct Scsi_Host *host = np->s.host;
-
-        scsi_remove_host(host);
-        scsi_host_put(host);
-
-        sym_detach(np, pdev);
+        struct Scsi_Host *shost = pci_get_drvdata(pdev);
 
+        scsi_remove_host(shost);
+        scsi_host_put(shost);
+        sym_detach(shost, pdev);
         pci_release_regions(pdev);
         pci_disable_device(pdev);
 
         attach_count--;
 }
 
+/**
+ * sym2_io_error_detected() - called when PCI error is detected
+ * @pdev: pointer to PCI device
+ * @state: current state of the PCI slot
+ */
+static pci_ers_result_t sym2_io_error_detected(struct pci_dev *pdev,
+                                         enum pci_channel_state state)
+{
+        /* If slot is permanently frozen, turn everything off */
+        if (state == pci_channel_io_perm_failure) {
+                sym2_remove(pdev);
+                return PCI_ERS_RESULT_DISCONNECT;
+        }
+
+        disable_irq(pdev->irq);
+        pci_disable_device(pdev);
+
+        /* Request that MMIO be enabled, so register dump can be taken. */
+        return PCI_ERS_RESULT_CAN_RECOVER;
+}
+
+/**
+ * sym2_io_slot_dump - Enable MMIO and dump debug registers
+ * @pdev: pointer to PCI device
+ */
+static pci_ers_result_t sym2_io_slot_dump(struct pci_dev *pdev)
+{
+        struct Scsi_Host *shost = pci_get_drvdata(pdev);
+
+        sym_dump_registers(shost);
+
+        /* Request a slot reset. */
+        return PCI_ERS_RESULT_NEED_RESET;
+}
+
+/**
+ * sym2_reset_workarounds - hardware-specific work-arounds
+ *
+ * This routine is similar to sym_set_workarounds(), except
+ * that, at this point, we already know that the device was
+ * succesfully intialized at least once before, and so most
+ * of the steps taken there are un-needed here.
+ */
+static void sym2_reset_workarounds(struct pci_dev *pdev)
+{
+        u_short status_reg;
+        struct sym_chip *chip;
+
+        chip = sym_lookup_chip_table(pdev->device, pdev->revision);
+
+        /* Work around for errant bit in 895A, in a fashion
+         * similar to what is done in sym_set_workarounds().
+         */
+        pci_read_config_word(pdev, PCI_STATUS, &status_reg);
+        if (!(chip->features & FE_66MHZ) && (status_reg & PCI_STATUS_66MHZ)) {
+                status_reg = PCI_STATUS_66MHZ;
+                pci_write_config_word(pdev, PCI_STATUS, status_reg);
+                pci_read_config_word(pdev, PCI_STATUS, &status_reg);
+        }
+}
+
+/**
+ * sym2_io_slot_reset() - called when the pci bus has been reset.
+ * @pdev: pointer to PCI device
+ *
+ * Restart the card from scratch.
+ */
+static pci_ers_result_t sym2_io_slot_reset(struct pci_dev *pdev)
+{
+        struct Scsi_Host *shost = pci_get_drvdata(pdev);
+        struct sym_hcb *np = sym_get_hcb(shost);
+
+        printk(KERN_INFO "%s: recovering from a PCI slot reset\n",
+                  sym_name(np));
+
+        if (pci_enable_device(pdev)) {
+                printk(KERN_ERR "%s: Unable to enable after PCI reset\n",
+                        sym_name(np));
+                return PCI_ERS_RESULT_DISCONNECT;
+        }
+
+        pci_set_master(pdev);
+        enable_irq(pdev->irq);
+
+        /* If the chip can do Memory Write Invalidate, enable it */
+        if (np->features & FE_WRIE) {
+                if (pci_set_mwi(pdev))
+                        return PCI_ERS_RESULT_DISCONNECT;
+        }
+
+        /* Perform work-arounds, analogous to sym_set_workarounds() */
+        sym2_reset_workarounds(pdev);
+
+        /* Perform host reset only on one instance of the card */
+        if (PCI_FUNC(pdev->devfn) == 0) {
+                if (sym_reset_scsi_bus(np, 0)) {
+                        printk(KERN_ERR "%s: Unable to reset scsi host\n",
+                                sym_name(np));
+                        return PCI_ERS_RESULT_DISCONNECT;
+                }
+                sym_start_up(shost, 1);
+        }
+
+        return PCI_ERS_RESULT_RECOVERED;
+}
+
+/**
+ * sym2_io_resume() - resume normal ops after PCI reset
+ * @pdev: pointer to PCI device
+ *
+ * Called when the error recovery driver tells us that its
+ * OK to resume normal operation. Use completion to allow
+ * halted scsi ops to resume.
+ */
+static void sym2_io_resume(struct pci_dev *pdev)
+{
+        struct Scsi_Host *shost = pci_get_drvdata(pdev);
+        struct sym_data *sym_data = shost_priv(shost);
+
+        spin_lock_irq(shost->host_lock);
+        if (sym_data->io_reset)
+                complete_all(sym_data->io_reset);
+        sym_data->io_reset = NULL;
+        spin_unlock_irq(shost->host_lock);
+}
+
 static void sym2_get_signalling(struct Scsi_Host *shost)
 {
         struct sym_hcb *np = sym_get_hcb(shost);
@@ -2050,11 +2045,19 @@ static struct pci_device_id sym2_id_table[] __devinitdata = {
 
 MODULE_DEVICE_TABLE(pci, sym2_id_table);
 
+static struct pci_error_handlers sym2_err_handler = {
+        .error_detected = sym2_io_error_detected,
+        .mmio_enabled   = sym2_io_slot_dump,
+        .slot_reset     = sym2_io_slot_reset,
+        .resume         = sym2_io_resume,
+};
+
 static struct pci_driver sym2_driver = {
         .name           = NAME53C8XX,
         .id_table       = sym2_id_table,
         .probe          = sym2_probe,
         .remove         = __devexit_p(sym2_remove),
+        .err_handler    = &sym2_err_handler,
 };
 
 static int __init sym2_init(void)
diff --git a/drivers/scsi/sym53c8xx_2/sym_glue.h b/drivers/scsi/sym53c8xx_2/sym_glue.h
index 0f097ba4f712..567fbe0b4f09 100644
--- a/drivers/scsi/sym53c8xx_2/sym_glue.h
+++ b/drivers/scsi/sym53c8xx_2/sym_glue.h
@@ -40,7 +40,9 @@
 #ifndef SYM_GLUE_H
 #define SYM_GLUE_H
 
+#include <linux/completion.h>
 #include <linux/delay.h>
+#include <linux/interrupt.h>
 #include <linux/ioport.h>
 #include <linux/pci.h>
 #include <linux/string.h>
@@ -177,14 +179,11 @@ struct sym_shcb {
         int             unit;
         char            inst_name[16];
         char            chip_name[8];
-        struct pci_dev  *device;
 
         struct Scsi_Host *host;
 
         void __iomem *  ioaddr;         /* MMIO kernel io address       */
         void __iomem *  ramaddr;        /* RAM  kernel io address       */
-        u_short         io_ws;          /* IO window size               */
-        int             irq;            /* IRQ number                   */
 
         struct timer_list timer;        /* Timer handler link header    */
         u_long          lasttime;
@@ -212,20 +211,21 @@ struct sym_device {
         } s;
         struct sym_chip chip;
         struct sym_nvram *nvram;
-        u_short device_id;
         u_char host_id;
 };
 
 /*
  *  Driver host data structure.
  */
-struct host_data {
+struct sym_data {
         struct sym_hcb *ncb;
+        struct completion *io_reset;            /* PCI error handling */
+        struct pci_dev *pdev;
 };
 
 static inline struct sym_hcb * sym_get_hcb(struct Scsi_Host *host)
 {
-        return ((struct host_data *)host->hostdata)->ncb;
+        return ((struct sym_data *)host->hostdata)->ncb;
 }
 
 #include "sym_fw.h"
@@ -263,8 +263,8 @@ void sym_set_cam_result_error(struct sym_hcb *np, struct sym_ccb *cp, int resid)
 void sym_xpt_done(struct sym_hcb *np, struct scsi_cmnd *ccb);
 #define sym_print_addr(cmd, arg...) dev_info(&cmd->device->sdev_gendev , ## arg)
 void sym_xpt_async_bus_reset(struct sym_hcb *np);
-void sym_xpt_async_sent_bdr(struct sym_hcb *np, int target);
 int  sym_setup_data_and_start (struct sym_hcb *np, struct scsi_cmnd *csio, struct sym_ccb *cp);
-void sym_log_bus_error(struct sym_hcb *np);
+void sym_log_bus_error(struct Scsi_Host *);
+void sym_dump_registers(struct Scsi_Host *);
 
 #endif /* SYM_GLUE_H */
diff --git a/drivers/scsi/sym53c8xx_2/sym_hipd.c b/drivers/scsi/sym53c8xx_2/sym_hipd.c
index 21cd4c7f5289..463f119f20e9 100644
--- a/drivers/scsi/sym53c8xx_2/sym_hipd.c
+++ b/drivers/scsi/sym53c8xx_2/sym_hipd.c
@@ -52,7 +52,7 @@
  *  Needed function prototypes.
  */
 static void sym_int_ma (struct sym_hcb *np);
-static void sym_int_sir (struct sym_hcb *np);
+static void sym_int_sir(struct sym_hcb *);
 static struct sym_ccb *sym_alloc_ccb(struct sym_hcb *np);
 static struct sym_ccb *sym_ccb_from_dsa(struct sym_hcb *np, u32 dsa);
 static void sym_alloc_lcb_tags (struct sym_hcb *np, u_char tn, u_char ln);
@@ -684,6 +684,8 @@ static void sym_set_bus_mode(struct sym_hcb *np, struct sym_nvram *nvram)
  */
 static int sym_prepare_setting(struct Scsi_Host *shost, struct sym_hcb *np, struct sym_nvram *nvram)
 {
+        struct sym_data *sym_data = shost_priv(shost);
+        struct pci_dev *pdev = sym_data->pdev;
         u_char  burst_max;
         u32     period;
         int i;
@@ -778,19 +780,12 @@ static int sym_prepare_setting(struct Scsi_Host *shost, struct sym_hcb *np, stru
          *  64 bit addressing  (895A/896/1010) ?
          */
         if (np->features & FE_DAC) {
-#if   SYM_CONF_DMA_ADDRESSING_MODE == 0
-                np->rv_ccntl1   |= (DDAC);
-#elif SYM_CONF_DMA_ADDRESSING_MODE == 1
-                if (!np->use_dac)
-                        np->rv_ccntl1   |= (DDAC);
-                else
-                        np->rv_ccntl1   |= (XTIMOD | EXTIBMV);
-#elif SYM_CONF_DMA_ADDRESSING_MODE == 2
-                if (!np->use_dac)
-                        np->rv_ccntl1   |= (DDAC);
-                else
-                        np->rv_ccntl1   |= (0 | EXTIBMV);
-#endif
+                if (!use_dac(np))
+                        np->rv_ccntl1 |= (DDAC);
+                else if (SYM_CONF_DMA_ADDRESSING_MODE == 1)
+                        np->rv_ccntl1 |= (XTIMOD | EXTIBMV);
+                else if (SYM_CONF_DMA_ADDRESSING_MODE == 2)
+                        np->rv_ccntl1 |= (0 | EXTIBMV);
         }
 
         /*
@@ -804,8 +799,8 @@ static int sym_prepare_setting(struct Scsi_Host *shost, struct sym_hcb *np, stru
          *  In dual channel mode, contention occurs if internal cycles
          *  are used. Disable internal cycles.
          */
-        if (np->device_id == PCI_DEVICE_ID_LSI_53C1010_33 &&
-            np->revision_id < 0x1)
+        if (pdev->device == PCI_DEVICE_ID_LSI_53C1010_33 &&
+            pdev->revision < 0x1)
                 np->rv_ccntl0   |=  DILS;
 
         /*
@@ -828,10 +823,10 @@ static int sym_prepare_setting(struct Scsi_Host *shost, struct sym_hcb *np, stru
          *  this driver. The generic ncr driver that does not use 
          *  LOAD/STORE instructions does not need this work-around.
          */
-        if ((np->device_id == PCI_DEVICE_ID_NCR_53C810 &&
-             np->revision_id >= 0x10 && np->revision_id <= 0x11) ||
-            (np->device_id == PCI_DEVICE_ID_NCR_53C860 &&
-             np->revision_id <= 0x1))
+        if ((pdev->device == PCI_DEVICE_ID_NCR_53C810 &&
+             pdev->revision >= 0x10 && pdev->revision <= 0x11) ||
+            (pdev->device == PCI_DEVICE_ID_NCR_53C860 &&
+             pdev->revision <= 0x1))
                 np->features &= ~(FE_WRIE|FE_ERL|FE_ERMP);
 
         /*
@@ -897,7 +892,7 @@ static int sym_prepare_setting(struct Scsi_Host *shost, struct sym_hcb *np, stru
         if ((SYM_SETUP_SCSI_LED || 
              (nvram->type == SYM_SYMBIOS_NVRAM ||
               (nvram->type == SYM_TEKRAM_NVRAM &&
-               np->device_id == PCI_DEVICE_ID_NCR_53C895))) &&
+               pdev->device == PCI_DEVICE_ID_NCR_53C895))) &&
             !(np->features & FE_LEDC) && !(np->sv_gpcntl & 0x01))
                 np->features |= FE_LED0;
 
@@ -1135,8 +1130,9 @@ restart_test:
  *  First 24 register of the chip:
  *      r0..rf
  */
-static void sym_log_hard_error(struct sym_hcb *np, u_short sist, u_char dstat)
+static void sym_log_hard_error(struct Scsi_Host *shost, u_short sist, u_char dstat)
 {
+        struct sym_hcb *np = sym_get_hcb(shost);
         u32     dsp;
         int     script_ofs;
         int     script_size;
@@ -1180,16 +1176,27 @@ static void sym_log_hard_error(struct sym_hcb *np, u_short sist, u_char dstat)
                         scr_to_cpu((int) *(u32 *)(script_base + script_ofs)));
         }
 
-        printf ("%s: regdump:", sym_name(np));
-        for (i=0; i<24;i++)
-            printf (" %02x", (unsigned)INB_OFF(np, i));
-        printf (".\n");
+        printf("%s: regdump:", sym_name(np));
+        for (i = 0; i < 24; i++)
+                printf(" %02x", (unsigned)INB_OFF(np, i));
+        printf(".\n");
 
         /*
          *  PCI BUS error.
          */
         if (dstat & (MDPE|BF))
-                sym_log_bus_error(np);
+                sym_log_bus_error(shost);
+}
+
+void sym_dump_registers(struct Scsi_Host *shost)
+{
+        struct sym_hcb *np = sym_get_hcb(shost);
+        u_short sist;
+        u_char dstat;
+
+        sist = INW(np, nc_sist);
+        dstat = INB(np, nc_dstat);
+        sym_log_hard_error(shost, sist, dstat);
 }
 
 static struct sym_chip sym_dev_table[] = {
@@ -1312,7 +1319,7 @@ int sym_lookup_dmap(struct sym_hcb *np, u32 h, int s)
 {
         int i;
 
-        if (!np->use_dac)
+        if (!use_dac(np))
                 goto weird;
 
         /* Look up existing mappings */
@@ -1519,7 +1526,8 @@ void sym_put_start_queue(struct sym_hcb *np, struct sym_ccb *cp)
         np->squeueput = qidx;
 
         if (DEBUG_FLAGS & DEBUG_QUEUE)
-                printf ("%s: queuepos=%d.\n", sym_name (np), np->squeueput);
+                scmd_printk(KERN_DEBUG, cp->cmd, "queuepos=%d\n",
+                                                        np->squeueput);
 
         /*
          *  Script processor may be waiting for reselect.
@@ -1696,8 +1704,11 @@ static void sym_flush_busy_queue (struct sym_hcb *np, int cam_status)
  *     1: SCSI BUS RESET delivered or received.
  *     2: SCSI BUS MODE changed.
  */
-void sym_start_up (struct sym_hcb *np, int reason)
+void sym_start_up(struct Scsi_Host *shost, int reason)
 {
+        struct sym_data *sym_data = shost_priv(shost);
+        struct pci_dev *pdev = sym_data->pdev;
+        struct sym_hcb *np = sym_data->ncb;
         int     i;
         u32     phys;
 
@@ -1746,7 +1757,7 @@ void sym_start_up (struct sym_hcb *np, int reason)
          *  This also let point to first position the start 
          *  and done queue pointers used from SCRIPTS.
          */
-        np->fw_patch(np);
+        np->fw_patch(shost);
 
         /*
          *  Wakeup all pending jobs.
@@ -1788,7 +1799,7 @@ void sym_start_up (struct sym_hcb *np, int reason)
         /*
          *  For now, disable AIP generation on C1010-66.
          */
-        if (np->device_id == PCI_DEVICE_ID_LSI_53C1010_66)
+        if (pdev->device == PCI_DEVICE_ID_LSI_53C1010_66)
                 OUTB(np, nc_aipcntl1, DISAIP);
 
         /*
@@ -1798,8 +1809,8 @@ void sym_start_up (struct sym_hcb *np, int reason)
          *  that from SCRIPTS for each selection/reselection, but 
          *  I just don't want. :)
          */
-        if (np->device_id == PCI_DEVICE_ID_LSI_53C1010_33 &&
-            np->revision_id < 1)
+        if (pdev->device == PCI_DEVICE_ID_LSI_53C1010_33 &&
+            pdev->revision < 1)
                 OUTB(np, nc_stest1, INB(np, nc_stest1) | 0x30);
 
         /*
@@ -1807,9 +1818,9 @@ void sym_start_up (struct sym_hcb *np, int reason)
          *  Disable overlapped arbitration for some dual function devices, 
          *  regardless revision id (kind of post-chip-design feature. ;-))
          */
-        if (np->device_id == PCI_DEVICE_ID_NCR_53C875)
+        if (pdev->device == PCI_DEVICE_ID_NCR_53C875)
                 OUTB(np, nc_ctest0, (1<<5));
-        else if (np->device_id == PCI_DEVICE_ID_NCR_53C896)
+        else if (pdev->device == PCI_DEVICE_ID_NCR_53C896)
                 np->rv_ccntl0 |= DPR;
 
         /*
@@ -1827,7 +1838,7 @@ void sym_start_up (struct sym_hcb *np, int reason)
          *  Set up scratch C and DRS IO registers to map the 32 bit 
          *  DMA address range our data structures are located in.
          */
-        if (np->use_dac) {
+        if (use_dac(np)) {
                 np->dmap_bah[0] = 0;    /* ??? */
                 OUTL(np, nc_scrx[0], np->dmap_bah[0]);
                 OUTL(np, nc_drs, np->dmap_bah[0]);
@@ -1900,7 +1911,7 @@ void sym_start_up (struct sym_hcb *np, int reason)
                 if (sym_verbose >= 2)
                         printf("%s: Downloading SCSI SCRIPTS.\n", sym_name(np));
                 memcpy_toio(np->s.ramaddr, np->scripta0, np->scripta_sz);
-                if (np->ram_ws == 8192) {
+                if (np->features & FE_RAM8K) {
                         memcpy_toio(np->s.ramaddr + 4096, np->scriptb0, np->scriptb_sz);
                         phys = scr_to_cpu(np->scr_ram_seg);
                         OUTL(np, nc_mmws, phys);
@@ -2214,8 +2225,9 @@ static void sym_int_udc (struct sym_hcb *np)
  *  mode to eight bit asynchronous, etc...
  *  So, just reinitializing all except chip should be enough.
  */
-static void sym_int_sbmc (struct sym_hcb *np)
+static void sym_int_sbmc(struct Scsi_Host *shost)
 {
+        struct sym_hcb *np = sym_get_hcb(shost);
         u_char scsi_mode = INB(np, nc_stest4) & SMODE;
 
         /*
@@ -2228,7 +2240,7 @@ static void sym_int_sbmc (struct sym_hcb *np)
          *  Should suspend command processing for a few seconds and 
          *  reinitialize all except the chip.
          */
-        sym_start_up (np, 2);
+        sym_start_up(shost, 2);
 }
 
 /*
@@ -2756,8 +2768,11 @@ reset_all:
  *  Use at your own decision and risk.
  */
 
-void sym_interrupt (struct sym_hcb *np)
+irqreturn_t sym_interrupt(struct Scsi_Host *shost)
 {
+        struct sym_data *sym_data = shost_priv(shost);
+        struct sym_hcb *np = sym_data->ncb;
+        struct pci_dev *pdev = sym_data->pdev;
         u_char  istat, istatc;
         u_char  dstat;
         u_short sist;
@@ -2782,7 +2797,7 @@ void sym_interrupt (struct sym_hcb *np)
         }
 
         if (!(istat & (SIP|DIP)))
-                return;
+                return (istat & INTF) ? IRQ_HANDLED : IRQ_NONE;
 
 #if 0   /* We should never get this one */
         if (istat & CABRT)
@@ -2809,6 +2824,13 @@ void sym_interrupt (struct sym_hcb *np)
                         dstat |= INB(np, nc_dstat);
                 istatc = INB(np, nc_istat);
                 istat |= istatc;
+
+                /* Prevent deadlock waiting on a condition that may
+                 * never clear. */
+                if (unlikely(sist == 0xffff && dstat == 0xff)) {
+                        if (pci_channel_offline(pdev))
+                                return IRQ_NONE;
+                }
         } while (istatc & (SIP|DIP));
 
         if (DEBUG_FLAGS & DEBUG_TINY)
@@ -2842,10 +2864,10 @@ void sym_interrupt (struct sym_hcb *np)
             !(dstat & (MDPE|BF|ABRT|IID))) {
                 if      (sist & PAR)    sym_int_par (np, sist);
                 else if (sist & MA)     sym_int_ma (np);
-                else if (dstat & SIR)   sym_int_sir (np);
+                else if (dstat & SIR)   sym_int_sir(np);
                 else if (dstat & SSI)   OUTONB_STD();
                 else                    goto unknown_int;
-                return;
+                return IRQ_HANDLED;
         }
 
         /*
@@ -2861,8 +2883,8 @@ void sym_interrupt (struct sym_hcb *np)
          */
         if (sist & RST) {
                 printf("%s: SCSI BUS reset detected.\n", sym_name(np));
-                sym_start_up (np, 1);
-                return;
+                sym_start_up(shost, 1);
+                return IRQ_HANDLED;
         }
 
         OUTB(np, nc_ctest3, np->rv_ctest3 | CLF);       /* clear dma fifo  */
@@ -2870,11 +2892,11 @@ void sym_interrupt (struct sym_hcb *np)
 
         if (!(sist  & (GEN|HTH|SGE)) &&
             !(dstat & (MDPE|BF|ABRT|IID))) {
-                if      (sist & SBMC)   sym_int_sbmc (np);
+                if      (sist & SBMC)   sym_int_sbmc(shost);
                 else if (sist & STO)    sym_int_sto (np);
                 else if (sist & UDC)    sym_int_udc (np);
                 else                    goto unknown_int;
-                return;
+                return IRQ_HANDLED;
         }
 
         /*
@@ -2884,12 +2906,12 @@ void sym_interrupt (struct sym_hcb *np)
          *  Reset everything.
          */
 
-        sym_log_hard_error(np, sist, dstat);
+        sym_log_hard_error(shost, sist, dstat);
 
         if ((sist & (GEN|HTH|SGE)) ||
                 (dstat & (MDPE|BF|ABRT|IID))) {
                 sym_start_reset(np);
-                return;
+                return IRQ_HANDLED;
         }
 
 unknown_int:
@@ -2900,6 +2922,7 @@ unknown_int:
         printf( "%s: unknown interrupt(s) ignored, "
                 "ISTAT=0x%x DSTAT=0x%x SIST=0x%x\n",
                 sym_name(np), istat, dstat, sist);
+        return IRQ_NONE;
 }
 
 /*
@@ -3520,7 +3543,8 @@ static void sym_sir_task_recovery(struct sym_hcb *np, int num)
                  *  If we sent a BDR, make upper layer aware of that.
                  */
                 if (np->abrt_msg[0] == M_RESET)
-                        sym_xpt_async_sent_bdr(np, target);
+                        starget_printk(KERN_NOTICE, starget,
+                                                        "has been reset\n");
                 break;
         }
 
@@ -4304,7 +4328,7 @@ static void sym_nego_rejected(struct sym_hcb *np, struct sym_tcb *tp, struct sym
 /*
  *  chip exception handler for programmed interrupts.
  */
-static void sym_int_sir (struct sym_hcb *np)
+static void sym_int_sir(struct sym_hcb *np)
 {
         u_char  num     = INB(np, nc_dsps);
         u32     dsa     = INL(np, nc_dsa);
@@ -4343,31 +4367,30 @@ static void sym_int_sir (struct sym_hcb *np)
                 return;
         /*
          *  The device didn't go to MSG OUT phase after having 
-         *  been selected with ATN. We donnot want to handle 
-         *  that.
+         *  been selected with ATN.  We do not want to handle that.
          */
         case SIR_SEL_ATN_NO_MSG_OUT:
-                printf ("%s:%d: No MSG OUT phase after selection with ATN.\n",
-                        sym_name (np), target);
+                scmd_printk(KERN_WARNING, cp->cmd,
+                                "No MSG OUT phase after selection with ATN\n");
                 goto out_stuck;
         /*
          *  The device didn't switch to MSG IN phase after 
-         *  having reseleted the initiator.
+         *  having reselected the initiator.
          */
         case SIR_RESEL_NO_MSG_IN:
-                printf ("%s:%d: No MSG IN phase after reselection.\n",
-                        sym_name (np), target);
+                scmd_printk(KERN_WARNING, cp->cmd,
+                                "No MSG IN phase after reselection\n");
                 goto out_stuck;
         /*
          *  After reselection, the device sent a message that wasn't 
          *  an IDENTIFY.
          */
         case SIR_RESEL_NO_IDENTIFY:
-                printf ("%s:%d: No IDENTIFY after reselection.\n",
-                        sym_name (np), target);
+                scmd_printk(KERN_WARNING, cp->cmd,
+                                "No IDENTIFY after reselection\n");
                 goto out_stuck;
         /*
-         *  The device reselected a LUN we donnot know about.
+         *  The device reselected a LUN we do not know about.
          */
         case SIR_RESEL_BAD_LUN:
                 np->msgout[0] = M_RESET;
@@ -4380,8 +4403,7 @@ static void sym_int_sir (struct sym_hcb *np)
                 np->msgout[0] = M_ABORT;
                 goto out;
         /*
-         *  The device reselected for a tagged nexus that we donnot 
-         *  have.
+         * The device reselected for a tagged nexus that we do not have.
          */
         case SIR_RESEL_BAD_I_T_L_Q:
                 np->msgout[0] = M_ABORT_TAG;
@@ -4393,8 +4415,8 @@ static void sym_int_sir (struct sym_hcb *np)
         case SIR_RESEL_ABORTED:
                 np->lastmsg = np->msgout[0];
                 np->msgout[0] = M_NOOP;
-                printf ("%s:%d: message %x sent on bad reselection.\n",
-                        sym_name (np), target, np->lastmsg);
+                scmd_printk(KERN_WARNING, cp->cmd,
+                        "message %x sent on bad reselection\n", np->lastmsg);
                 goto out;
         /*
          *  The SCRIPTS let us know that a message has been 
@@ -5578,16 +5600,13 @@ int sym_hcb_attach(struct Scsi_Host *shost, struct sym_fw *fw, struct sym_nvram
         np->scriptz_ba  = vtobus(np->scriptz0);
 
         if (np->ram_ba) {
-                np->scripta_ba  = np->ram_ba;
+                np->scripta_ba = np->ram_ba;
                 if (np->features & FE_RAM8K) {
-                        np->ram_ws = 8192;
                         np->scriptb_ba = np->scripta_ba + 4096;
 #if 0   /* May get useful for 64 BIT PCI addressing */
                         np->scr_ram_seg = cpu_to_scr(np->scripta_ba >> 32);
 #endif
                 }
-                else
-                        np->ram_ws = 4096;
         }
 
         /*
diff --git a/drivers/scsi/sym53c8xx_2/sym_hipd.h b/drivers/scsi/sym53c8xx_2/sym_hipd.h
index 79ab6a177039..ad078805e62b 100644
--- a/drivers/scsi/sym53c8xx_2/sym_hipd.h
+++ b/drivers/scsi/sym53c8xx_2/sym_hipd.h
@@ -883,10 +883,7 @@ struct sym_hcb {
          *  Physical bus addresses of the chip.
          */
         u32             mmio_ba;        /* MMIO 32 bit BUS address      */
-        int             mmio_ws;        /* MMIO Window size             */
-
         u32             ram_ba;         /* RAM 32 bit BUS address       */
-        int             ram_ws;         /* RAM window size              */
 
         /*
          *  SCRIPTS virtual and physical bus addresses.
@@ -912,14 +909,12 @@ struct sym_hcb {
         struct sym_fwb_ba fwb_bas;      /* Useful SCRIPTB bus addresses */
         struct sym_fwz_ba fwz_bas;      /* Useful SCRIPTZ bus addresses */
         void            (*fw_setup)(struct sym_hcb *np, struct sym_fw *fw);
-        void            (*fw_patch)(struct sym_hcb *np);
+        void            (*fw_patch)(struct Scsi_Host *);
         char            *fw_name;
 
         /*
          *  General controller parameters and configuration.
          */
-        u_short device_id;      /* PCI device id                */
-        u_char  revision_id;    /* PCI device revision id       */
         u_int   features;       /* Chip features map            */
         u_char  myaddr;         /* SCSI id of the adapter       */
         u_char  maxburst;       /* log base 2 of dwords burst   */
@@ -1031,6 +1026,14 @@ struct sym_hcb {
 #endif
 };
 
+#if SYM_CONF_DMA_ADDRESSING_MODE == 0
+#define use_dac(np)     0
+#define set_dac(np)     do { } while (0)
+#else
+#define use_dac(np)     (np)->use_dac
+#define set_dac(np)     (np)->use_dac = 1
+#endif
+
 #define HCB_BA(np, lbl) (np->hcb_ba + offsetof(struct sym_hcb, lbl))
 
 
@@ -1052,8 +1055,8 @@ void sym_start_next_ccbs(struct sym_hcb *np, struct sym_lcb *lp, int maxn);
 #else
 void sym_put_start_queue(struct sym_hcb *np, struct sym_ccb *cp);
 #endif
-void sym_start_up(struct sym_hcb *np, int reason);
-void sym_interrupt(struct sym_hcb *np);
+void sym_start_up(struct Scsi_Host *, int reason);
+irqreturn_t sym_interrupt(struct Scsi_Host *);
 int sym_clear_tasks(struct sym_hcb *np, int cam_status, int target, int lun, int task);
 struct sym_ccb *sym_get_ccb(struct sym_hcb *np, struct scsi_cmnd *cmd, u_char tag_order);
 void sym_free_ccb(struct sym_hcb *np, struct sym_ccb *cp);
@@ -1073,18 +1076,21 @@ int sym_hcb_attach(struct Scsi_Host *shost, struct sym_fw *fw, struct sym_nvram
  */
 
 #if   SYM_CONF_DMA_ADDRESSING_MODE == 0
+#define DMA_DAC_MASK    DMA_32BIT_MASK
 #define sym_build_sge(np, data, badd, len)      \
 do {                                            \
         (data)->addr = cpu_to_scr(badd);        \
         (data)->size = cpu_to_scr(len);         \
 } while (0)
 #elif SYM_CONF_DMA_ADDRESSING_MODE == 1
+#define DMA_DAC_MASK    DMA_40BIT_MASK
 #define sym_build_sge(np, data, badd, len)                              \
 do {                                                                    \
         (data)->addr = cpu_to_scr(badd);                                \
         (data)->size = cpu_to_scr((((badd) >> 8) & 0xff000000) + len);  \
 } while (0)
 #elif SYM_CONF_DMA_ADDRESSING_MODE == 2
+#define DMA_DAC_MASK    DMA_64BIT_MASK
 int sym_lookup_dmap(struct sym_hcb *np, u32 h, int s);
 static __inline void 
 sym_build_sge(struct sym_hcb *np, struct sym_tblmove *data, u64 badd, int len)
diff --git a/drivers/scsi/sym53c8xx_2/sym_nvram.c b/drivers/scsi/sym53c8xx_2/sym_nvram.c
index 15d69298ab6e..5662fbb3ff60 100644
--- a/drivers/scsi/sym53c8xx_2/sym_nvram.c
+++ b/drivers/scsi/sym53c8xx_2/sym_nvram.c
@@ -696,7 +696,7 @@ static int sym_read_Tekram_nvram (struct sym_device *np, Tekram_nvram *nvram)
         u_short csum;
         int x;
 
-        switch (np->device_id) {
+        switch (np->pdev->device) {
         case PCI_DEVICE_ID_NCR_53C885:
         case PCI_DEVICE_ID_NCR_53C895:
         case PCI_DEVICE_ID_NCR_53C896:
diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index 37bddc1802de..81db48f07ca1 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -343,11 +343,12 @@ config IBMASR
           module will be called ibmasr.
 
 config WAFER_WDT
-        tristate "ICP Wafer 5823 Single Board Computer Watchdog"
+        tristate "ICP Single Board Computer Watchdog Timer"
         depends on X86
         help
-          This is a driver for the hardware watchdog on the ICP Wafer 5823
-          Single Board Computer (and probably other similar models).
+          This is a driver for the hardware watchdog on the ICP Single
+          Board Computer. This driver is working on (at least) the following
+          IPC SBC's: Wafer 5823, Rocky 4783, Rocky 3703 and Rocky 3782.
 
           To compile this driver as a module, choose M here: the
           module will be called wafer5823wdt.
@@ -609,6 +610,12 @@ config WDT_RM9K_GPI
           To compile this driver as a module, choose M here: the
           module will be called rm9k_wdt.
 
+config AR7_WDT
+        tristate "TI AR7 Watchdog Timer"
+        depends on AR7
+        help
+          Hardware driver for the TI AR7 Watchdog Timer.
+
 # PARISC Architecture
 
 # POWERPC Architecture
diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
index 389f8b14ccc4..7d9e5734f8bb 100644
--- a/drivers/watchdog/Makefile
+++ b/drivers/watchdog/Makefile
@@ -90,6 +90,7 @@ obj-$(CONFIG_SBC_EPX_C3_WATCHDOG) += sbc_epx_c3.o
 obj-$(CONFIG_INDYDOG) += indydog.o
 obj-$(CONFIG_WDT_MTX1)  += mtx-1_wdt.o
 obj-$(CONFIG_WDT_RM9K_GPI) += rm9k_wdt.o
+obj-$(CONFIG_AR7_WDT) += ar7_wdt.o
 
 # PARISC Architecture
 
diff --git a/drivers/watchdog/ar7_wdt.c b/drivers/watchdog/ar7_wdt.c
new file mode 100644
index 000000000000..cdaab8c3d3d0
--- /dev/null
+++ b/drivers/watchdog/ar7_wdt.c
@@ -0,0 +1,349 @@
+/*
+ * drivers/watchdog/ar7_wdt.c
+ *
+ * Copyright (C) 2007 Nicolas Thill <nico@openwrt.org>
+ * Copyright (c) 2005 Enrik Berkhan <Enrik.Berkhan@akk.org>
+ *
+ * Some code taken from:
+ * National Semiconductor SCx200 Watchdog support
+ * Copyright (c) 2001,2002 Christer Weinigel <wingel@nano-system.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/notifier.h>
+#include <linux/reboot.h>
+#include <linux/fs.h>
+#include <linux/ioport.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
+
+#include <asm/addrspace.h>
+#include <asm/ar7/ar7.h>
+
+#define DRVNAME "ar7_wdt"
+#define LONGNAME "TI AR7 Watchdog Timer"
+
+MODULE_AUTHOR("Nicolas Thill <nico@openwrt.org>");
+MODULE_DESCRIPTION(LONGNAME);
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
+
+static int margin = 60;
+module_param(margin, int, 0);
+MODULE_PARM_DESC(margin, "Watchdog margin in seconds");
+
+static int nowayout = WATCHDOG_NOWAYOUT;
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout, "Disable watchdog shutdown on close");
+
+#define READ_REG(x) readl((void __iomem *)&(x))
+#define WRITE_REG(x, v) writel((v), (void __iomem *)&(x))
+
+struct ar7_wdt {
+        u32 kick_lock;
+        u32 kick;
+        u32 change_lock;
+        u32 change;
+        u32 disable_lock;
+        u32 disable;
+        u32 prescale_lock;
+        u32 prescale;
+};
+
+static struct semaphore open_semaphore;
+static unsigned expect_close;
+
+/* XXX currently fixed, allows max margin ~68.72 secs */
+#define prescale_value 0xffff
+
+/* Offset of the WDT registers */
+static unsigned long ar7_regs_wdt;
+/* Pointer to the remapped WDT IO space */
+static struct ar7_wdt *ar7_wdt;
+static void ar7_wdt_get_regs(void)
+{
+        u16 chip_id = ar7_chip_id();
+        switch (chip_id) {
+        case AR7_CHIP_7100:
+        case AR7_CHIP_7200:
+                ar7_regs_wdt = AR7_REGS_WDT;
+                break;
+        default:
+                ar7_regs_wdt = UR8_REGS_WDT;
+                break;
+        }
+}
+
+
+static void ar7_wdt_kick(u32 value)
+{
+        WRITE_REG(ar7_wdt->kick_lock, 0x5555);
+        if ((READ_REG(ar7_wdt->kick_lock) & 3) == 1) {
+                WRITE_REG(ar7_wdt->kick_lock, 0xaaaa);
+                if ((READ_REG(ar7_wdt->kick_lock) & 3) == 3) {
+                        WRITE_REG(ar7_wdt->kick, value);
+                        return;
+                }
+        }
+        printk(KERN_ERR DRVNAME ": failed to unlock WDT kick reg\n");
+}
+
+static void ar7_wdt_prescale(u32 value)
+{
+        WRITE_REG(ar7_wdt->prescale_lock, 0x5a5a);
+        if ((READ_REG(ar7_wdt->prescale_lock) & 3) == 1) {
+                WRITE_REG(ar7_wdt->prescale_lock, 0xa5a5);
+                if ((READ_REG(ar7_wdt->prescale_lock) & 3) == 3) {
+                        WRITE_REG(ar7_wdt->prescale, value);
+                        return;
+                }
+        }
+        printk(KERN_ERR DRVNAME ": failed to unlock WDT prescale reg\n");
+}
+
+static void ar7_wdt_change(u32 value)
+{
+        WRITE_REG(ar7_wdt->change_lock, 0x6666);
+        if ((READ_REG(ar7_wdt->change_lock) & 3) == 1) {
+                WRITE_REG(ar7_wdt->change_lock, 0xbbbb);
+                if ((READ_REG(ar7_wdt->change_lock) & 3) == 3) {
+                        WRITE_REG(ar7_wdt->change, value);
+                        return;
+                }
+        }
+        printk(KERN_ERR DRVNAME ": failed to unlock WDT change reg\n");
+}
+
+static void ar7_wdt_disable(u32 value)
+{
+        WRITE_REG(ar7_wdt->disable_lock, 0x7777);
+        if ((READ_REG(ar7_wdt->disable_lock) & 3) == 1) {
+                WRITE_REG(ar7_wdt->disable_lock, 0xcccc);
+                if ((READ_REG(ar7_wdt->disable_lock) & 3) == 2) {
+                        WRITE_REG(ar7_wdt->disable_lock, 0xdddd);
+                        if ((READ_REG(ar7_wdt->disable_lock) & 3) == 3) {
+                                WRITE_REG(ar7_wdt->disable, value);
+                                return;
+                        }
+                }
+        }
+        printk(KERN_ERR DRVNAME ": failed to unlock WDT disable reg\n");
+}
+
+static void ar7_wdt_update_margin(int new_margin)
+{
+        u32 change;
+
+        change = new_margin * (ar7_vbus_freq() / prescale_value);
+        if (change < 1) change = 1;
+        if (change > 0xffff) change = 0xffff;
+        ar7_wdt_change(change);
+        margin = change * prescale_value / ar7_vbus_freq();
+        printk(KERN_INFO DRVNAME
+               ": timer margin %d seconds (prescale %d, change %d, freq %d)\n",
+               margin, prescale_value, change, ar7_vbus_freq());
+}
+
+static void ar7_wdt_enable_wdt(void)
+{
+        printk(KERN_DEBUG DRVNAME ": enabling watchdog timer\n");
+        ar7_wdt_disable(1);
+        ar7_wdt_kick(1);
+}
+
+static void ar7_wdt_disable_wdt(void)
+{
+        printk(KERN_DEBUG DRVNAME ": disabling watchdog timer\n");
+        ar7_wdt_disable(0);
+}
+
+static int ar7_wdt_open(struct inode *inode, struct file *file)
+{
+        /* only allow one at a time */
+        if (down_trylock(&open_semaphore))
+                return -EBUSY;
+        ar7_wdt_enable_wdt();
+        expect_close = 0;
+
+        return nonseekable_open(inode, file);
+}
+
+static int ar7_wdt_release(struct inode *inode, struct file *file)
+{
+        if (!expect_close)
+                printk(KERN_WARNING DRVNAME
+                ": watchdog device closed unexpectedly,"
+                "will not disable the watchdog timer\n");
+        else if (!nowayout)
+                ar7_wdt_disable_wdt();
+
+        up(&open_semaphore);
+
+        return 0;
+}
+
+static int ar7_wdt_notify_sys(struct notifier_block *this,
+                              unsigned long code, void *unused)
+{
+        if (code == SYS_HALT || code == SYS_POWER_OFF)
+                if (!nowayout)
+                        ar7_wdt_disable_wdt();
+
+        return NOTIFY_DONE;
+}
+
+static struct notifier_block ar7_wdt_notifier = {
+        .notifier_call = ar7_wdt_notify_sys
+};
+
+static ssize_t ar7_wdt_write(struct file *file, const char *data,
+                             size_t len, loff_t *ppos)
+{
+        /* check for a magic close character */
+        if (len) {
+                size_t i;
+
+                ar7_wdt_kick(1);
+
+                expect_close = 0;
+                for (i = 0; i < len; ++i) {
+                        char c;
+                        if (get_user(c, data+i))
+                                return -EFAULT;
+                        if (c == 'V')
+                                expect_close = 1;
+                }
+
+        }
+        return len;
+}
+
+static int ar7_wdt_ioctl(struct inode *inode, struct file *file,
+                         unsigned int cmd, unsigned long arg)
+{
+        static struct watchdog_info ident = {
+                .identity = LONGNAME,
+                .firmware_version = 1,
+                .options = (WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING),
+        };
+        int new_margin;
+
+        switch (cmd) {
+        default:
+                return -ENOTTY;
+        case WDIOC_GETSUPPORT:
+                if (copy_to_user((struct watchdog_info *)arg, &ident,
+                                sizeof(ident)))
+                        return -EFAULT;
+                return 0;
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                if (put_user(0, (int *)arg))
+                        return -EFAULT;
+                return 0;
+        case WDIOC_KEEPALIVE:
+                ar7_wdt_kick(1);
+                return 0;
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_margin, (int *)arg))
+                        return -EFAULT;
+                if (new_margin < 1)
+                        return -EINVAL;
+
+                ar7_wdt_update_margin(new_margin);
+                ar7_wdt_kick(1);
+
+        case WDIOC_GETTIMEOUT:
+                if (put_user(margin, (int *)arg))
+                        return -EFAULT;
+                return 0;
+        }
+}
+
+static struct file_operations ar7_wdt_fops = {
+        .owner          = THIS_MODULE,
+        .write          = ar7_wdt_write,
+        .ioctl          = ar7_wdt_ioctl,
+        .open           = ar7_wdt_open,
+        .release        = ar7_wdt_release,
+};
+
+static struct miscdevice ar7_wdt_miscdev = {
+        .minor          = WATCHDOG_MINOR,
+        .name           = "watchdog",
+        .fops           = &ar7_wdt_fops,
+};
+
+static int __init ar7_wdt_init(void)
+{
+        int rc;
+
+        ar7_wdt_get_regs();
+
+        if (!request_mem_region(ar7_regs_wdt, sizeof(struct ar7_wdt),
+                                                        LONGNAME)) {
+                printk(KERN_WARNING DRVNAME ": watchdog I/O region busy\n");
+                return -EBUSY;
+        }
+
+        ar7_wdt = (struct ar7_wdt *)
+                        ioremap(ar7_regs_wdt, sizeof(struct ar7_wdt));
+
+        ar7_wdt_disable_wdt();
+        ar7_wdt_prescale(prescale_value);
+        ar7_wdt_update_margin(margin);
+
+        sema_init(&open_semaphore, 1);
+
+        rc = register_reboot_notifier(&ar7_wdt_notifier);
+        if (rc) {
+                printk(KERN_ERR DRVNAME
+                        ": unable to register reboot notifier\n");
+                goto out_alloc;
+        }
+
+        rc = misc_register(&ar7_wdt_miscdev);
+        if (rc) {
+                printk(KERN_ERR DRVNAME ": unable to register misc device\n");
+                goto out_register;
+        }
+        goto out;
+
+out_register:
+        unregister_reboot_notifier(&ar7_wdt_notifier);
+out_alloc:
+        iounmap(ar7_wdt);
+        release_mem_region(ar7_regs_wdt, sizeof(struct ar7_wdt));
+out:
+        return rc;
+}
+
+static void __exit ar7_wdt_cleanup(void)
+{
+        misc_deregister(&ar7_wdt_miscdev);
+        unregister_reboot_notifier(&ar7_wdt_notifier);
+        iounmap(ar7_wdt);
+        release_mem_region(ar7_regs_wdt, sizeof(struct ar7_wdt));
+}
+
+module_init(ar7_wdt_init);
+module_exit(ar7_wdt_cleanup);
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index 32fe97211eea..afcab007a22b 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -549,13 +549,13 @@ static void nfs_direct_write_result(struct rpc_task *task, void *calldata)
 
         spin_lock(&dreq->lock);
 
-        if (unlikely(dreq->error != 0))
-                goto out_unlock;
         if (unlikely(status < 0)) {
-                /* An error has occured, so we should not commit */
+                /* An error has occurred, so we should not commit */
                 dreq->flags = 0;
                 dreq->error = status;
         }
+        if (unlikely(dreq->error != 0))
+                goto out_unlock;
 
         dreq->count += data->res.count;
 
diff --git a/include/asm-x86/Kbuild b/include/asm-x86/Kbuild
index 5e3539c129b9..12db5a1cdd74 100644
--- a/include/asm-x86/Kbuild
+++ b/include/asm-x86/Kbuild
@@ -11,41 +11,16 @@ header-y += sigcontext32.h
 header-y += ucontext.h
 header-y += vsyscall32.h
 
-unifdef-y += a.out_32.h
-unifdef-y += a.out_64.h
-unifdef-y += byteorder_32.h
-unifdef-y += byteorder_64.h
 unifdef-y += e820.h
-unifdef-y += elf_32.h
-unifdef-y += elf_64.h
 unifdef-y += ist.h
 unifdef-y += mce.h
-unifdef-y += msgbuf_32.h
-unifdef-y += msgbuf_64.h
-unifdef-y += msr_32.h
-unifdef-y += msr_64.h
 unifdef-y += msr.h
-unifdef-y += mtrr_32.h
-unifdef-y += mtrr_64.h
 unifdef-y += mtrr.h
 unifdef-y += page_32.h
 unifdef-y += page_64.h
 unifdef-y += posix_types_32.h
 unifdef-y += posix_types_64.h
-unifdef-y += ptrace_32.h
-unifdef-y += ptrace_64.h
-unifdef-y += setup_32.h
-unifdef-y += setup_64.h
-unifdef-y += shmbuf_32.h
-unifdef-y += shmbuf_64.h
-unifdef-y += sigcontext_32.h
-unifdef-y += sigcontext_64.h
-unifdef-y += signal_32.h
-unifdef-y += signal_64.h
-unifdef-y += stat_32.h
-unifdef-y += stat_64.h
-unifdef-y += statfs_32.h
-unifdef-y += statfs_64.h
+unifdef-y += ptrace.h
 unifdef-y += unistd_32.h
 unifdef-y += unistd_64.h
 unifdef-y += user_32.h
diff --git a/include/asm-x86/a.out.h b/include/asm-x86/a.out.h
index 5bc9b1d3b227..a62443e38eb8 100644
--- a/include/asm-x86/a.out.h
+++ b/include/asm-x86/a.out.h
@@ -1,13 +1,30 @@
+#ifndef _ASM_X86_A_OUT_H
+#define _ASM_X86_A_OUT_H
+
+struct exec
+{
+        unsigned int a_info;    /* Use macros N_MAGIC, etc for access */
+        unsigned a_text;        /* length of text, in bytes */
+        unsigned a_data;        /* length of data, in bytes */
+        unsigned a_bss;         /* length of uninitialized data area for file, in bytes */
+        unsigned a_syms;        /* length of symbol table data in file, in bytes */
+        unsigned a_entry;       /* start address */
+        unsigned a_trsize;      /* length of relocation info for text, in bytes */
+        unsigned a_drsize;      /* length of relocation info for data, in bytes */
+};
+
+#define N_TRSIZE(a)     ((a).a_trsize)
+#define N_DRSIZE(a)     ((a).a_drsize)
+#define N_SYMSIZE(a)    ((a).a_syms)
+
 #ifdef __KERNEL__
+# include <linux/thread_info.h>
+# define STACK_TOP      TASK_SIZE
 # ifdef CONFIG_X86_32
-#  include "a.out_32.h"
+#  define STACK_TOP_MAX STACK_TOP
 # else
-#  include "a.out_64.h"
-# endif
-#else
-# ifdef __i386__
-#  include "a.out_32.h"
-# else
-#  include "a.out_64.h"
+#  define STACK_TOP_MAX TASK_SIZE64
 # endif
 #endif
+
+#endif /* _ASM_X86_A_OUT_H */
diff --git a/include/asm-x86/a.out_32.h b/include/asm-x86/a.out_32.h
deleted file mode 100644
index 851a60f8258c..000000000000
--- a/include/asm-x86/a.out_32.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef __I386_A_OUT_H__
-#define __I386_A_OUT_H__
-
-struct exec
-{
-  unsigned long a_info;         /* Use macros N_MAGIC, etc for access */
-  unsigned a_text;              /* length of text, in bytes */
-  unsigned a_data;              /* length of data, in bytes */
-  unsigned a_bss;               /* length of uninitialized data area for file, in bytes */
-  unsigned a_syms;              /* length of symbol table data in file, in bytes */
-  unsigned a_entry;             /* start address */
-  unsigned a_trsize;            /* length of relocation info for text, in bytes */
-  unsigned a_drsize;            /* length of relocation info for data, in bytes */
-};
-
-#define N_TRSIZE(a)     ((a).a_trsize)
-#define N_DRSIZE(a)     ((a).a_drsize)
-#define N_SYMSIZE(a)    ((a).a_syms)
-
-#ifdef __KERNEL__
-
-#define STACK_TOP       TASK_SIZE
-#define STACK_TOP_MAX   STACK_TOP
-
-#endif
-
-#endif /* __A_OUT_GNU_H__ */
diff --git a/include/asm-x86/a.out_64.h b/include/asm-x86/a.out_64.h
deleted file mode 100644
index e789300e41a5..000000000000
--- a/include/asm-x86/a.out_64.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#ifndef __X8664_A_OUT_H__
-#define __X8664_A_OUT_H__
-
-/* 32bit a.out */
-
-struct exec
-{
-  unsigned int a_info;          /* Use macros N_MAGIC, etc for access */
-  unsigned a_text;              /* length of text, in bytes */
-  unsigned a_data;              /* length of data, in bytes */
-  unsigned a_bss;               /* length of uninitialized data area for file, in bytes */
-  unsigned a_syms;              /* length of symbol table data in file, in bytes */
-  unsigned a_entry;             /* start address */
-  unsigned a_trsize;            /* length of relocation info for text, in bytes */
-  unsigned a_drsize;            /* length of relocation info for data, in bytes */
-};
-
-#define N_TRSIZE(a)     ((a).a_trsize)
-#define N_DRSIZE(a)     ((a).a_drsize)
-#define N_SYMSIZE(a)    ((a).a_syms)
-
-#ifdef __KERNEL__
-#include <linux/thread_info.h>
-#define STACK_TOP       TASK_SIZE
-#define STACK_TOP_MAX   TASK_SIZE64
-#endif
-
-#endif /* __A_OUT_GNU_H__ */
diff --git a/include/asm-x86/apic_64.h b/include/asm-x86/apic_64.h
index 3c8f21eef0be..2747a11a2b19 100644
--- a/include/asm-x86/apic_64.h
+++ b/include/asm-x86/apic_64.h
@@ -69,6 +69,7 @@ extern void clear_local_APIC (void);
 extern void connect_bsp_APIC (void);
 extern void disconnect_bsp_APIC (int virt_wire_setup);
 extern void disable_local_APIC (void);
+extern void lapic_shutdown (void);
 extern int verify_local_APIC (void);
 extern void cache_APIC_registers (void);
 extern void sync_Arb_IDs (void);
diff --git a/include/asm-x86/bitops_32.h b/include/asm-x86/bitops_32.h
index 3268a341cf49..36ebb5b02b4f 100644
--- a/include/asm-x86/bitops_32.h
+++ b/include/asm-x86/bitops_32.h
@@ -80,6 +80,20 @@ static inline void clear_bit(int nr, volatile unsigned long * addr)
                 :"Ir" (nr));
 }
 
+/*
+ * clear_bit_unlock - Clears a bit in memory
+ * @nr: Bit to clear
+ * @addr: Address to start counting from
+ *
+ * clear_bit() is atomic and implies release semantics before the memory
+ * operation. It can be used for an unlock.
+ */
+static inline void clear_bit_unlock(unsigned long nr, volatile unsigned long *addr)
+{
+        barrier();
+        clear_bit(nr, addr);
+}
+
 static inline void __clear_bit(int nr, volatile unsigned long * addr)
 {
         __asm__ __volatile__(
@@ -87,6 +101,25 @@ static inline void __clear_bit(int nr, volatile unsigned long * addr)
                 :"+m" (ADDR)
                 :"Ir" (nr));
 }
+
+/*
+ * __clear_bit_unlock - Clears a bit in memory
+ * @nr: Bit to clear
+ * @addr: Address to start counting from
+ *
+ * __clear_bit() is non-atomic and implies release semantics before the memory
+ * operation. It can be used for an unlock if no other CPUs can concurrently
+ * modify other bits in the word.
+ *
+ * No memory barrier is required here, because x86 cannot reorder stores past
+ * older loads. Same principle as spin_unlock.
+ */
+static inline void __clear_bit_unlock(unsigned long nr, volatile unsigned long *addr)
+{
+        barrier();
+        __clear_bit(nr, addr);
+}
+
 #define smp_mb__before_clear_bit()      barrier()
 #define smp_mb__after_clear_bit()       barrier()
 
@@ -146,6 +179,15 @@ static inline int test_and_set_bit(int nr, volatile unsigned long * addr)
 }
 
 /**
+ * test_and_set_bit_lock - Set a bit and return its old value for lock
+ * @nr: Bit to set
+ * @addr: Address to count from
+ *
+ * This is the same as test_and_set_bit on x86
+ */
+#define test_and_set_bit_lock test_and_set_bit
+
+/**
  * __test_and_set_bit - Set a bit and return its old value
  * @nr: Bit to set
  * @addr: Address to count from
@@ -406,7 +448,6 @@ static inline int fls(int x)
 }
 
 #include <asm-generic/bitops/hweight.h>
-#include <asm-generic/bitops/lock.h>
 
 #endif /* __KERNEL__ */
 
diff --git a/include/asm-x86/bitops_64.h b/include/asm-x86/bitops_64.h
index dacaa5f1febc..b4d47940b959 100644
--- a/include/asm-x86/bitops_64.h
+++ b/include/asm-x86/bitops_64.h
@@ -72,6 +72,20 @@ static __inline__ void clear_bit(int nr, volatile void * addr)
                 :"dIr" (nr));
 }
 
+/*
+ * clear_bit_unlock - Clears a bit in memory
+ * @nr: Bit to clear
+ * @addr: Address to start counting from
+ *
+ * clear_bit() is atomic and implies release semantics before the memory
+ * operation. It can be used for an unlock.
+ */
+static inline void clear_bit_unlock(unsigned long nr, volatile unsigned long *addr)
+{
+        barrier();
+        clear_bit(nr, addr);
+}
+
 static __inline__ void __clear_bit(int nr, volatile void * addr)
 {
         __asm__ __volatile__(
@@ -80,6 +94,24 @@ static __inline__ void __clear_bit(int nr, volatile void * addr)
                 :"dIr" (nr));
 }
 
+/*
+ * __clear_bit_unlock - Clears a bit in memory
+ * @nr: Bit to clear
+ * @addr: Address to start counting from
+ *
+ * __clear_bit() is non-atomic and implies release semantics before the memory
+ * operation. It can be used for an unlock if no other CPUs can concurrently
+ * modify other bits in the word.
+ *
+ * No memory barrier is required here, because x86 cannot reorder stores past
+ * older loads. Same principle as spin_unlock.
+ */
+static inline void __clear_bit_unlock(unsigned long nr, volatile unsigned long *addr)
+{
+        barrier();
+        __clear_bit(nr, addr);
+}
+
 #define smp_mb__before_clear_bit()      barrier()
 #define smp_mb__after_clear_bit()       barrier()
 
@@ -137,6 +169,15 @@ static __inline__ int test_and_set_bit(int nr, volatile void * addr)
 }
 
 /**
+ * test_and_set_bit_lock - Set a bit and return its old value for lock
+ * @nr: Bit to set
+ * @addr: Address to count from
+ *
+ * This is the same as test_and_set_bit on x86
+ */
+#define test_and_set_bit_lock test_and_set_bit
+
+/**
  * __test_and_set_bit - Set a bit and return its old value
  * @nr: Bit to set
  * @addr: Address to count from
@@ -412,7 +453,6 @@ static __inline__ int fls(int x)
 #define ARCH_HAS_FAST_MULTIPLIER 1
 
 #include <asm-generic/bitops/hweight.h>
-#include <asm-generic/bitops/lock.h>
 
 #endif /* __KERNEL__ */
 
diff --git a/include/asm-x86/byteorder.h b/include/asm-x86/byteorder.h
index eb14b1870ed7..1f2d6d5bf20d 100644
--- a/include/asm-x86/byteorder.h
+++ b/include/asm-x86/byteorder.h
@@ -1,13 +1,72 @@
-#ifdef __KERNEL__
-# ifdef CONFIG_X86_32
-#  include "byteorder_32.h"
-# else
-#  include "byteorder_64.h"
-# endif
+#ifndef _ASM_X86_BYTEORDER_H
+#define _ASM_X86_BYTEORDER_H
+
+#include <asm/types.h>
+#include <linux/compiler.h>
+
+#ifdef __GNUC__
+
+#ifdef __i386__
+
+static __inline__ __attribute_const__ __u32 ___arch__swab32(__u32 x)
+{
+#ifdef CONFIG_X86_BSWAP
+        __asm__("bswap %0" : "=r" (x) : "0" (x));
 #else
-# ifdef __i386__
-#  include "byteorder_32.h"
-# else
-#  include "byteorder_64.h"
-# endif
+        __asm__("xchgb %b0,%h0\n\t"     /* swap lower bytes     */
+                "rorl $16,%0\n\t"       /* swap words           */
+                "xchgb %b0,%h0"         /* swap higher bytes    */
+                :"=q" (x)
+                : "0" (x));
 #endif
+        return x;
+}
+
+static __inline__ __attribute_const__ __u64 ___arch__swab64(__u64 val)
+{
+        union {
+                struct { __u32 a,b; } s;
+                __u64 u;
+        } v;
+        v.u = val;
+#ifdef CONFIG_X86_BSWAP
+        asm("bswapl %0 ; bswapl %1 ; xchgl %0,%1"
+            : "=r" (v.s.a), "=r" (v.s.b)
+            : "0" (v.s.a), "1" (v.s.b));
+#else
+        v.s.a = ___arch__swab32(v.s.a);
+        v.s.b = ___arch__swab32(v.s.b);
+        asm("xchgl %0,%1" : "=r" (v.s.a), "=r" (v.s.b) : "0" (v.s.a), "1" (v.s.b));
+#endif
+        return v.u;
+}
+
+#else /* __i386__ */
+
+static __inline__ __attribute_const__ __u64 ___arch__swab64(__u64 x)
+{
+        __asm__("bswapq %0" : "=r" (x) : "0" (x));
+        return x;
+}
+
+static __inline__ __attribute_const__ __u32 ___arch__swab32(__u32 x)
+{
+        __asm__("bswapl %0" : "=r" (x) : "0" (x));
+        return x;
+}
+
+#endif
+
+/* Do not define swab16.  Gcc is smart enough to recognize "C" version and
+   convert it into rotation or exhange.  */
+
+#define __arch__swab64(x) ___arch__swab64(x)
+#define __arch__swab32(x) ___arch__swab32(x)
+
+#define __BYTEORDER_HAS_U64__
+
+#endif /* __GNUC__ */
+
+#include <linux/byteorder/little_endian.h>
+
+#endif /* _ASM_X86_BYTEORDER_H */
diff --git a/include/asm-x86/byteorder_32.h b/include/asm-x86/byteorder_32.h
deleted file mode 100644
index a45470a8b74a..000000000000
--- a/include/asm-x86/byteorder_32.h
+++ /dev/null
@@ -1,58 +0,0 @@
-#ifndef _I386_BYTEORDER_H
-#define _I386_BYTEORDER_H
-
-#include <asm/types.h>
-#include <linux/compiler.h>
-
-#ifdef __GNUC__
-
-/* For avoiding bswap on i386 */
-#ifdef __KERNEL__
-#endif
-
-static __inline__ __attribute_const__ __u32 ___arch__swab32(__u32 x)
-{
-#ifdef CONFIG_X86_BSWAP
-        __asm__("bswap %0" : "=r" (x) : "0" (x));
-#else
-        __asm__("xchgb %b0,%h0\n\t"     /* swap lower bytes     */
-                "rorl $16,%0\n\t"       /* swap words           */
-                "xchgb %b0,%h0"         /* swap higher bytes    */
-                :"=q" (x)
-                : "0" (x));
-#endif
-        return x;
-}
-
-static __inline__ __attribute_const__ __u64 ___arch__swab64(__u64 val)
-{ 
-        union { 
-                struct { __u32 a,b; } s;
-                __u64 u;
-        } v;
-        v.u = val;
-#ifdef CONFIG_X86_BSWAP
-        asm("bswapl %0 ; bswapl %1 ; xchgl %0,%1" 
-            : "=r" (v.s.a), "=r" (v.s.b) 
-            : "0" (v.s.a), "1" (v.s.b)); 
-#else
-   v.s.a = ___arch__swab32(v.s.a); 
-        v.s.b = ___arch__swab32(v.s.b); 
-        asm("xchgl %0,%1" : "=r" (v.s.a), "=r" (v.s.b) : "0" (v.s.a), "1" (v.s.b));
-#endif
-        return v.u;     
-} 
-
-/* Do not define swab16.  Gcc is smart enough to recognize "C" version and
-   convert it into rotation or exhange.  */
-
-#define __arch__swab64(x) ___arch__swab64(x)
-#define __arch__swab32(x) ___arch__swab32(x)
-
-#define __BYTEORDER_HAS_U64__
-
-#endif /* __GNUC__ */
-
-#include <linux/byteorder/little_endian.h>
-
-#endif /* _I386_BYTEORDER_H */
diff --git a/include/asm-x86/byteorder_64.h b/include/asm-x86/byteorder_64.h
deleted file mode 100644
index 5e86c868c75e..000000000000
--- a/include/asm-x86/byteorder_64.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef _X86_64_BYTEORDER_H
-#define _X86_64_BYTEORDER_H
-
-#include <asm/types.h>
-#include <linux/compiler.h>
-
-#ifdef __GNUC__
-
-static __inline__ __attribute_const__ __u64 ___arch__swab64(__u64 x)
-{
-        __asm__("bswapq %0" : "=r" (x) : "0" (x));
-        return x;
-}
-
-static __inline__ __attribute_const__ __u32 ___arch__swab32(__u32 x)
-{
-        __asm__("bswapl %0" : "=r" (x) : "0" (x));
-        return x;
-}
-
-/* Do not define swab16.  Gcc is smart enough to recognize "C" version and
-   convert it into rotation or exhange.  */
-
-#define __arch__swab32(x) ___arch__swab32(x)
-#define __arch__swab64(x) ___arch__swab64(x)
-
-#endif /* __GNUC__ */
-
-#define __BYTEORDER_HAS_U64__
-
-#include <linux/byteorder/little_endian.h>
-
-#endif /* _X86_64_BYTEORDER_H */
diff --git a/include/asm-x86/div64.h b/include/asm-x86/div64.h
index 8ac7da6ca284..e98d16e7a37a 100644
--- a/include/asm-x86/div64.h
+++ b/include/asm-x86/div64.h
@@ -1,5 +1,59 @@
+#ifndef _ASM_X86_DIV64_H
+#define _ASM_X86_DIV64_H
+
 #ifdef CONFIG_X86_32
-# include "div64_32.h"
+
+#include <linux/types.h>
+
+/*
+ * do_div() is NOT a C function. It wants to return
+ * two values (the quotient and the remainder), but
+ * since that doesn't work very well in C, what it
+ * does is:
+ *
+ * - modifies the 64-bit dividend _in_place_
+ * - returns the 32-bit remainder
+ *
+ * This ends up being the most efficient "calling
+ * convention" on x86.
+ */
+#define do_div(n,base) ({ \
+        unsigned long __upper, __low, __high, __mod, __base; \
+        __base = (base); \
+        asm("":"=a" (__low), "=d" (__high):"A" (n)); \
+        __upper = __high; \
+        if (__high) { \
+                __upper = __high % (__base); \
+                __high = __high / (__base); \
+        } \
+        asm("divl %2":"=a" (__low), "=d" (__mod):"rm" (__base), "0" (__low), "1" (__upper)); \
+        asm("":"=A" (n):"a" (__low),"d" (__high)); \
+        __mod; \
+})
+
+/*
+ * (long)X = ((long long)divs) / (long)div
+ * (long)rem = ((long long)divs) % (long)div
+ *
+ * Warning, this will do an exception if X overflows.
+ */
+#define div_long_long_rem(a,b,c) div_ll_X_l_rem(a,b,c)
+
+static inline long
+div_ll_X_l_rem(long long divs, long div, long *rem)
+{
+        long dum2;
+      __asm__("divl %2":"=a"(dum2), "=d"(*rem)
+      : "rm"(div), "A"(divs));
+
+        return dum2;
+
+}
+
+extern uint64_t div64_64(uint64_t dividend, uint64_t divisor);
+
 #else
-# include "div64_64.h"
-#endif
+# include <asm-generic/div64.h>
+#endif /* CONFIG_X86_32 */
+
+#endif /* _ASM_X86_DIV64_H */
diff --git a/include/asm-x86/div64_32.h b/include/asm-x86/div64_32.h
deleted file mode 100644
index 438e980068bd..000000000000
--- a/include/asm-x86/div64_32.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#ifndef __I386_DIV64
-#define __I386_DIV64
-
-#include <linux/types.h>
-
-/*
- * do_div() is NOT a C function. It wants to return
- * two values (the quotient and the remainder), but
- * since that doesn't work very well in C, what it
- * does is:
- *
- * - modifies the 64-bit dividend _in_place_
- * - returns the 32-bit remainder
- *
- * This ends up being the most efficient "calling
- * convention" on x86.
- */
-#define do_div(n,base) ({ \
-        unsigned long __upper, __low, __high, __mod, __base; \
-        __base = (base); \
-        asm("":"=a" (__low), "=d" (__high):"A" (n)); \
-        __upper = __high; \
-        if (__high) { \
-                __upper = __high % (__base); \
-                __high = __high / (__base); \
-        } \
-        asm("divl %2":"=a" (__low), "=d" (__mod):"rm" (__base), "0" (__low), "1" (__upper)); \
-        asm("":"=A" (n):"a" (__low),"d" (__high)); \
-        __mod; \
-})
-
-/*
- * (long)X = ((long long)divs) / (long)div
- * (long)rem = ((long long)divs) % (long)div
- *
- * Warning, this will do an exception if X overflows.
- */
-#define div_long_long_rem(a,b,c) div_ll_X_l_rem(a,b,c)
-
-static inline long
-div_ll_X_l_rem(long long divs, long div, long *rem)
-{
-        long dum2;
-      __asm__("divl %2":"=a"(dum2), "=d"(*rem)
-      : "rm"(div), "A"(divs));
-
-        return dum2;
-
-}
-
-extern uint64_t div64_64(uint64_t dividend, uint64_t divisor);
-#endif
diff --git a/include/asm-x86/div64_64.h b/include/asm-x86/div64_64.h
deleted file mode 100644
index 6cd978cefb28..000000000000
--- a/include/asm-x86/div64_64.h
+++ /dev/null
@@ -1 +0,0 @@
-#include <asm-generic/div64.h>
diff --git a/include/asm-x86/elf.h b/include/asm-x86/elf.h
index ed6bb6e546b9..ec42a4d2e83b 100644
--- a/include/asm-x86/elf.h
+++ b/include/asm-x86/elf.h
@@ -1,13 +1,290 @@
-#ifdef __KERNEL__
-# ifdef CONFIG_X86_32
-#  include "elf_32.h"
-# else
-#  include "elf_64.h"
-# endif
+#ifndef _ASM_X86_ELF_H
+#define _ASM_X86_ELF_H
+
+/*
+ * ELF register definitions..
+ */
+
+#include <asm/ptrace.h>
+#include <asm/user.h>
+#include <asm/auxvec.h>
+
+typedef unsigned long elf_greg_t;
+
+#define ELF_NGREG (sizeof (struct user_regs_struct) / sizeof(elf_greg_t))
+typedef elf_greg_t elf_gregset_t[ELF_NGREG];
+
+typedef struct user_i387_struct elf_fpregset_t;
+
+#ifdef __i386__
+
+typedef struct user_fxsr_struct elf_fpxregset_t;
+
+#define R_386_NONE      0
+#define R_386_32        1
+#define R_386_PC32      2
+#define R_386_GOT32     3
+#define R_386_PLT32     4
+#define R_386_COPY      5
+#define R_386_GLOB_DAT  6
+#define R_386_JMP_SLOT  7
+#define R_386_RELATIVE  8
+#define R_386_GOTOFF    9
+#define R_386_GOTPC     10
+#define R_386_NUM       11
+
+/*
+ * These are used to set parameters in the core dumps.
+ */
+#define ELF_CLASS       ELFCLASS32
+#define ELF_DATA        ELFDATA2LSB
+#define ELF_ARCH        EM_386
+
 #else
-# ifdef __i386__
-#  include "elf_32.h"
-# else
-#  include "elf_64.h"
-# endif
+
+/* x86-64 relocation types */
+#define R_X86_64_NONE           0       /* No reloc */
+#define R_X86_64_64             1       /* Direct 64 bit  */
+#define R_X86_64_PC32           2       /* PC relative 32 bit signed */
+#define R_X86_64_GOT32          3       /* 32 bit GOT entry */
+#define R_X86_64_PLT32          4       /* 32 bit PLT address */
+#define R_X86_64_COPY           5       /* Copy symbol at runtime */
+#define R_X86_64_GLOB_DAT       6       /* Create GOT entry */
+#define R_X86_64_JUMP_SLOT      7       /* Create PLT entry */
+#define R_X86_64_RELATIVE       8       /* Adjust by program base */
+#define R_X86_64_GOTPCREL       9       /* 32 bit signed pc relative
+                                           offset to GOT */
+#define R_X86_64_32             10      /* Direct 32 bit zero extended */
+#define R_X86_64_32S            11      /* Direct 32 bit sign extended */
+#define R_X86_64_16             12      /* Direct 16 bit zero extended */
+#define R_X86_64_PC16           13      /* 16 bit sign extended pc relative */
+#define R_X86_64_8              14      /* Direct 8 bit sign extended  */
+#define R_X86_64_PC8            15      /* 8 bit sign extended pc relative */
+
+#define R_X86_64_NUM            16
+
+/*
+ * These are used to set parameters in the core dumps.
+ */
+#define ELF_CLASS       ELFCLASS64
+#define ELF_DATA        ELFDATA2LSB
+#define ELF_ARCH        EM_X86_64
+
+#endif
+
+#ifdef __KERNEL__
+
+#ifdef CONFIG_X86_32
+#include <asm/processor.h>
+#include <asm/system.h>         /* for savesegment */
+#include <asm/desc.h>
+
+/*
+ * This is used to ensure we don't load something for the wrong architecture.
+ */
+#define elf_check_arch(x) \
+        (((x)->e_machine == EM_386) || ((x)->e_machine == EM_486))
+
+/* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program starts %edx
+   contains a pointer to a function which might be registered using `atexit'.
+   This provides a mean for the dynamic linker to call DT_FINI functions for
+   shared libraries that have been loaded before the code runs.
+
+   A value of 0 tells we have no such handler.
+
+   We might as well make sure everything else is cleared too (except for %esp),
+   just to make things more deterministic.
+ */
+#define ELF_PLAT_INIT(_r, load_addr)    do { \
+        _r->ebx = 0; _r->ecx = 0; _r->edx = 0; \
+        _r->esi = 0; _r->edi = 0; _r->ebp = 0; \
+        _r->eax = 0; \
+} while (0)
+
+/* regs is struct pt_regs, pr_reg is elf_gregset_t (which is
+   now struct_user_regs, they are different) */
+
+#define ELF_CORE_COPY_REGS(pr_reg, regs)                \
+        pr_reg[0] = regs->ebx;                          \
+        pr_reg[1] = regs->ecx;                          \
+        pr_reg[2] = regs->edx;                          \
+        pr_reg[3] = regs->esi;                          \
+        pr_reg[4] = regs->edi;                          \
+        pr_reg[5] = regs->ebp;                          \
+        pr_reg[6] = regs->eax;                          \
+        pr_reg[7] = regs->xds & 0xffff;                 \
+        pr_reg[8] = regs->xes & 0xffff;                 \
+        pr_reg[9] = regs->xfs & 0xffff;                 \
+        savesegment(gs,pr_reg[10]);                     \
+        pr_reg[11] = regs->orig_eax;                    \
+        pr_reg[12] = regs->eip;                         \
+        pr_reg[13] = regs->xcs & 0xffff;                \
+        pr_reg[14] = regs->eflags;                      \
+        pr_reg[15] = regs->esp;                         \
+        pr_reg[16] = regs->xss & 0xffff;
+
+#define ELF_PLATFORM    (utsname()->machine)
+#define set_personality_64bit() do { } while (0)
+extern unsigned int vdso_enabled;
+
+#else /* CONFIG_X86_32 */
+
+#include <asm/processor.h>
+
+/*
+ * This is used to ensure we don't load something for the wrong architecture.
+ */
+#define elf_check_arch(x) \
+        ((x)->e_machine == EM_X86_64)
+
+#define ELF_PLAT_INIT(_r, load_addr)    do {              \
+        struct task_struct *cur = current;                \
+        (_r)->rbx = 0; (_r)->rcx = 0; (_r)->rdx = 0;      \
+        (_r)->rsi = 0; (_r)->rdi = 0; (_r)->rbp = 0;      \
+        (_r)->rax = 0;                                    \
+        (_r)->r8 = 0;                                     \
+        (_r)->r9 = 0;                                     \
+        (_r)->r10 = 0;                                    \
+        (_r)->r11 = 0;                                    \
+        (_r)->r12 = 0;                                    \
+        (_r)->r13 = 0;                                    \
+        (_r)->r14 = 0;                                    \
+        (_r)->r15 = 0;                                    \
+        cur->thread.fs = 0; cur->thread.gs = 0;           \
+        cur->thread.fsindex = 0; cur->thread.gsindex = 0; \
+        cur->thread.ds = 0; cur->thread.es = 0;           \
+        clear_thread_flag(TIF_IA32);                      \
+} while (0)
+
+/* regs is struct pt_regs, pr_reg is elf_gregset_t (which is
+   now struct_user_regs, they are different). Assumes current is the process
+   getting dumped. */
+
+#define ELF_CORE_COPY_REGS(pr_reg, regs)  do {                  \
+        unsigned v;                                             \
+        (pr_reg)[0] = (regs)->r15;                              \
+        (pr_reg)[1] = (regs)->r14;                              \
+        (pr_reg)[2] = (regs)->r13;                              \
+        (pr_reg)[3] = (regs)->r12;                              \
+        (pr_reg)[4] = (regs)->rbp;                              \
+        (pr_reg)[5] = (regs)->rbx;                              \
+        (pr_reg)[6] = (regs)->r11;                              \
+        (pr_reg)[7] = (regs)->r10;                              \
+        (pr_reg)[8] = (regs)->r9;                               \
+        (pr_reg)[9] = (regs)->r8;                               \
+        (pr_reg)[10] = (regs)->rax;                             \
+        (pr_reg)[11] = (regs)->rcx;                             \
+        (pr_reg)[12] = (regs)->rdx;                             \
+        (pr_reg)[13] = (regs)->rsi;                             \
+        (pr_reg)[14] = (regs)->rdi;                             \
+        (pr_reg)[15] = (regs)->orig_rax;                        \
+        (pr_reg)[16] = (regs)->rip;                             \
+        (pr_reg)[17] = (regs)->cs;                              \
+        (pr_reg)[18] = (regs)->eflags;                          \
+        (pr_reg)[19] = (regs)->rsp;                             \
+        (pr_reg)[20] = (regs)->ss;                              \
+        (pr_reg)[21] = current->thread.fs;                      \
+        (pr_reg)[22] = current->thread.gs;                      \
+        asm("movl %%ds,%0" : "=r" (v)); (pr_reg)[23] = v;       \
+        asm("movl %%es,%0" : "=r" (v)); (pr_reg)[24] = v;       \
+        asm("movl %%fs,%0" : "=r" (v)); (pr_reg)[25] = v;       \
+        asm("movl %%gs,%0" : "=r" (v)); (pr_reg)[26] = v;       \
+} while(0);
+
+/* I'm not sure if we can use '-' here */
+#define ELF_PLATFORM       ("x86_64")
+extern void set_personality_64bit(void);
+extern int vdso_enabled;
+
+#endif /* !CONFIG_X86_32 */
+
+#define USE_ELF_CORE_DUMP
+#define ELF_EXEC_PAGESIZE       4096
+
+/* This is the location that an ET_DYN program is loaded if exec'ed.  Typical
+   use of this is to invoke "./ld.so someprog" to test out a new version of
+   the loader.  We need to make sure that it is out of the way of the program
+   that it will "exec", and that there is sufficient room for the brk.  */
+
+#define ELF_ET_DYN_BASE         (TASK_SIZE / 3 * 2)
+
+/* This yields a mask that user programs can use to figure out what
+   instruction set this CPU supports.  This could be done in user space,
+   but it's not easy, and we've already done it here.  */
+
+#define ELF_HWCAP               (boot_cpu_data.x86_capability[0])
+
+/* This yields a string that ld.so will use to load implementation
+   specific libraries for optimization.  This is more specific in
+   intent than poking at uname or /proc/cpuinfo.
+
+   For the moment, we have only optimizations for the Intel generations,
+   but that could change... */
+
+#define SET_PERSONALITY(ex, ibcs2) set_personality_64bit()
+
+/*
+ * An executable for which elf_read_implies_exec() returns TRUE will
+ * have the READ_IMPLIES_EXEC personality flag set automatically.
+ */
+#define elf_read_implies_exec(ex, executable_stack)     \
+        (executable_stack != EXSTACK_DISABLE_X)
+
+struct task_struct;
+
+extern int dump_task_regs (struct task_struct *, elf_gregset_t *);
+extern int dump_task_fpu (struct task_struct *, elf_fpregset_t *);
+
+#define ELF_CORE_COPY_TASK_REGS(tsk, elf_regs) dump_task_regs(tsk, elf_regs)
+#define ELF_CORE_COPY_FPREGS(tsk, elf_fpregs) dump_task_fpu(tsk, elf_fpregs)
+
+#ifdef CONFIG_X86_32
+extern int dump_task_extended_fpu (struct task_struct *,
+                                   struct user_fxsr_struct *);
+#define ELF_CORE_COPY_XFPREGS(tsk, elf_xfpregs) \
+        dump_task_extended_fpu(tsk, elf_xfpregs)
+#define ELF_CORE_XFPREG_TYPE NT_PRXFPREG
+
+#define VDSO_HIGH_BASE          (__fix_to_virt(FIX_VDSO))
+#define VDSO_CURRENT_BASE       ((unsigned long)current->mm->context.vdso)
+#define VDSO_PRELINK            0
+
+#define VDSO_SYM(x) \
+                (VDSO_CURRENT_BASE + (unsigned long)(x) - VDSO_PRELINK)
+
+#define VDSO_HIGH_EHDR          ((const struct elfhdr *) VDSO_HIGH_BASE)
+#define VDSO_EHDR               ((const struct elfhdr *) VDSO_CURRENT_BASE)
+
+extern void __kernel_vsyscall;
+
+#define VDSO_ENTRY              VDSO_SYM(&__kernel_vsyscall)
+
+/* update AT_VECTOR_SIZE_ARCH if the number of NEW_AUX_ENT entries changes */
+
+#define ARCH_DLINFO \
+do if (vdso_enabled) {                                                  \
+                NEW_AUX_ENT(AT_SYSINFO, VDSO_ENTRY);                    \
+                NEW_AUX_ENT(AT_SYSINFO_EHDR, VDSO_CURRENT_BASE);        \
+} while (0)
+
+#else /* CONFIG_X86_32 */
+
+/* 1GB for 64bit, 8MB for 32bit */
+#define STACK_RND_MASK (test_thread_flag(TIF_IA32) ? 0x7ff : 0x3fffff)
+
+#define ARCH_DLINFO                                             \
+do if (vdso_enabled) {                                          \
+        NEW_AUX_ENT(AT_SYSINFO_EHDR,(unsigned long)current->mm->context.vdso);\
+} while (0)
+
+#endif /* !CONFIG_X86_32 */
+
+struct linux_binprm;
+
+#define ARCH_HAS_SETUP_ADDITIONAL_PAGES 1
+extern int arch_setup_additional_pages(struct linux_binprm *bprm,
+                                       int executable_stack);
+
+#endif /* __KERNEL__ */
+
 #endif
diff --git a/include/asm-x86/elf_32.h b/include/asm-x86/elf_32.h
deleted file mode 100644
index b3f694eaaf37..000000000000
--- a/include/asm-x86/elf_32.h
+++ /dev/null
@@ -1,165 +0,0 @@
-#ifndef __ASMi386_ELF_H
-#define __ASMi386_ELF_H
-
-/*
- * ELF register definitions..
- */
-
-#include <asm/ptrace.h>
-#include <asm/user.h>
-#include <asm/auxvec.h>
-
-#define R_386_NONE      0
-#define R_386_32        1
-#define R_386_PC32      2
-#define R_386_GOT32     3
-#define R_386_PLT32     4
-#define R_386_COPY      5
-#define R_386_GLOB_DAT  6
-#define R_386_JMP_SLOT  7
-#define R_386_RELATIVE  8
-#define R_386_GOTOFF    9
-#define R_386_GOTPC     10
-#define R_386_NUM       11
-
-typedef unsigned long elf_greg_t;
-
-#define ELF_NGREG (sizeof (struct user_regs_struct) / sizeof(elf_greg_t))
-typedef elf_greg_t elf_gregset_t[ELF_NGREG];
-
-typedef struct user_i387_struct elf_fpregset_t;
-typedef struct user_fxsr_struct elf_fpxregset_t;
-
-/*
- * This is used to ensure we don't load something for the wrong architecture.
- */
-#define elf_check_arch(x) \
-        (((x)->e_machine == EM_386) || ((x)->e_machine == EM_486))
-
-/*
- * These are used to set parameters in the core dumps.
- */
-#define ELF_CLASS       ELFCLASS32
-#define ELF_DATA        ELFDATA2LSB
-#define ELF_ARCH        EM_386
-
-#ifdef __KERNEL__
-
-#include <asm/processor.h>
-#include <asm/system.h>         /* for savesegment */
-#include <asm/desc.h>
-
-/* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program starts %edx
-   contains a pointer to a function which might be registered using `atexit'.
-   This provides a mean for the dynamic linker to call DT_FINI functions for
-   shared libraries that have been loaded before the code runs.
-
-   A value of 0 tells we have no such handler. 
-
-   We might as well make sure everything else is cleared too (except for %esp),
-   just to make things more deterministic.
- */
-#define ELF_PLAT_INIT(_r, load_addr)    do { \
-        _r->ebx = 0; _r->ecx = 0; _r->edx = 0; \
-        _r->esi = 0; _r->edi = 0; _r->ebp = 0; \
-        _r->eax = 0; \
-} while (0)
-
-#define USE_ELF_CORE_DUMP
-#define ELF_EXEC_PAGESIZE       4096
-
-/* This is the location that an ET_DYN program is loaded if exec'ed.  Typical
-   use of this is to invoke "./ld.so someprog" to test out a new version of
-   the loader.  We need to make sure that it is out of the way of the program
-   that it will "exec", and that there is sufficient room for the brk.  */
-
-#define ELF_ET_DYN_BASE         (TASK_SIZE / 3 * 2)
-
-/* regs is struct pt_regs, pr_reg is elf_gregset_t (which is
-   now struct_user_regs, they are different) */
-
-#define ELF_CORE_COPY_REGS(pr_reg, regs)                \
-        pr_reg[0] = regs->ebx;                          \
-        pr_reg[1] = regs->ecx;                          \
-        pr_reg[2] = regs->edx;                          \
-        pr_reg[3] = regs->esi;                          \
-        pr_reg[4] = regs->edi;                          \
-        pr_reg[5] = regs->ebp;                          \
-        pr_reg[6] = regs->eax;                          \
-        pr_reg[7] = regs->xds & 0xffff;                 \
-        pr_reg[8] = regs->xes & 0xffff;                 \
-        pr_reg[9] = regs->xfs & 0xffff;                 \
-        savesegment(gs,pr_reg[10]);                     \
-        pr_reg[11] = regs->orig_eax;                    \
-        pr_reg[12] = regs->eip;                         \
-        pr_reg[13] = regs->xcs & 0xffff;                \
-        pr_reg[14] = regs->eflags;                      \
-        pr_reg[15] = regs->esp;                         \
-        pr_reg[16] = regs->xss & 0xffff;
-
-/* This yields a mask that user programs can use to figure out what
-   instruction set this CPU supports.  This could be done in user space,
-   but it's not easy, and we've already done it here.  */
-
-#define ELF_HWCAP       (boot_cpu_data.x86_capability[0])
-
-/* This yields a string that ld.so will use to load implementation
-   specific libraries for optimization.  This is more specific in
-   intent than poking at uname or /proc/cpuinfo.
-
-   For the moment, we have only optimizations for the Intel generations,
-   but that could change... */
-
-#define ELF_PLATFORM  (utsname()->machine)
-
-#define SET_PERSONALITY(ex, ibcs2) do { } while (0)
-
-/*
- * An executable for which elf_read_implies_exec() returns TRUE will
- * have the READ_IMPLIES_EXEC personality flag set automatically.
- */
-#define elf_read_implies_exec(ex, executable_stack)     (executable_stack != EXSTACK_DISABLE_X)
-
-struct task_struct;
-
-extern int dump_task_regs (struct task_struct *, elf_gregset_t *);
-extern int dump_task_fpu (struct task_struct *, elf_fpregset_t *);
-extern int dump_task_extended_fpu (struct task_struct *, struct user_fxsr_struct *);
-
-#define ELF_CORE_COPY_TASK_REGS(tsk, elf_regs) dump_task_regs(tsk, elf_regs)
-#define ELF_CORE_COPY_FPREGS(tsk, elf_fpregs) dump_task_fpu(tsk, elf_fpregs)
-#define ELF_CORE_COPY_XFPREGS(tsk, elf_xfpregs) dump_task_extended_fpu(tsk, elf_xfpregs)
-#define ELF_CORE_XFPREG_TYPE NT_PRXFPREG
-
-#define VDSO_HIGH_BASE          (__fix_to_virt(FIX_VDSO))
-#define VDSO_CURRENT_BASE       ((unsigned long)current->mm->context.vdso)
-#define VDSO_PRELINK            0
-
-#define VDSO_SYM(x) \
-                (VDSO_CURRENT_BASE + (unsigned long)(x) - VDSO_PRELINK)
-
-#define VDSO_HIGH_EHDR          ((const struct elfhdr *) VDSO_HIGH_BASE)
-#define VDSO_EHDR               ((const struct elfhdr *) VDSO_CURRENT_BASE)
-
-extern void __kernel_vsyscall;
-
-#define VDSO_ENTRY              VDSO_SYM(&__kernel_vsyscall)
-
-struct linux_binprm;
-
-#define ARCH_HAS_SETUP_ADDITIONAL_PAGES
-extern int arch_setup_additional_pages(struct linux_binprm *bprm,
-                                       int executable_stack);
-
-extern unsigned int vdso_enabled;
-
-/* update AT_VECTOR_SIZE_ARCH if the number of NEW_AUX_ENT entries changes */
-#define ARCH_DLINFO                                                     \
-do if (vdso_enabled) {                                                  \
-                NEW_AUX_ENT(AT_SYSINFO, VDSO_ENTRY);                    \
-                NEW_AUX_ENT(AT_SYSINFO_EHDR, VDSO_CURRENT_BASE);        \
-} while (0)
-
-#endif
-
-#endif
diff --git a/include/asm-x86/elf_64.h b/include/asm-x86/elf_64.h
deleted file mode 100644
index b4fbe47f6ccd..000000000000
--- a/include/asm-x86/elf_64.h
+++ /dev/null
@@ -1,180 +0,0 @@
-#ifndef __ASM_X86_64_ELF_H
-#define __ASM_X86_64_ELF_H
-
-/*
- * ELF register definitions..
- */
-
-#include <asm/ptrace.h>
-#include <asm/user.h>
-
-/* x86-64 relocation types */
-#define R_X86_64_NONE           0       /* No reloc */
-#define R_X86_64_64             1       /* Direct 64 bit  */
-#define R_X86_64_PC32           2       /* PC relative 32 bit signed */
-#define R_X86_64_GOT32          3       /* 32 bit GOT entry */
-#define R_X86_64_PLT32          4       /* 32 bit PLT address */
-#define R_X86_64_COPY           5       /* Copy symbol at runtime */
-#define R_X86_64_GLOB_DAT       6       /* Create GOT entry */
-#define R_X86_64_JUMP_SLOT      7       /* Create PLT entry */
-#define R_X86_64_RELATIVE       8       /* Adjust by program base */
-#define R_X86_64_GOTPCREL       9       /* 32 bit signed pc relative
-                                           offset to GOT */
-#define R_X86_64_32             10      /* Direct 32 bit zero extended */
-#define R_X86_64_32S            11      /* Direct 32 bit sign extended */
-#define R_X86_64_16             12      /* Direct 16 bit zero extended */
-#define R_X86_64_PC16           13      /* 16 bit sign extended pc relative */
-#define R_X86_64_8              14      /* Direct 8 bit sign extended  */
-#define R_X86_64_PC8            15      /* 8 bit sign extended pc relative */
-
-#define R_X86_64_NUM            16
-
-typedef unsigned long elf_greg_t;
-
-#define ELF_NGREG (sizeof (struct user_regs_struct) / sizeof(elf_greg_t))
-typedef elf_greg_t elf_gregset_t[ELF_NGREG];
-
-typedef struct user_i387_struct elf_fpregset_t;
-
-/*
- * These are used to set parameters in the core dumps.
- */
-#define ELF_CLASS       ELFCLASS64
-#define ELF_DATA        ELFDATA2LSB
-#define ELF_ARCH        EM_X86_64
-
-#ifdef __KERNEL__
-#include <asm/processor.h>
-
-/*
- * This is used to ensure we don't load something for the wrong architecture.
- */
-#define elf_check_arch(x) \
-        ((x)->e_machine == EM_X86_64)
-
-
-/* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program starts %edx
-   contains a pointer to a function which might be registered using `atexit'.
-   This provides a mean for the dynamic linker to call DT_FINI functions for
-   shared libraries that have been loaded before the code runs.
-
-   A value of 0 tells we have no such handler. 
-
-   We might as well make sure everything else is cleared too (except for %esp),
-   just to make things more deterministic.
- */
-#define ELF_PLAT_INIT(_r, load_addr)    do { \
-        struct task_struct *cur = current; \
-        (_r)->rbx = 0; (_r)->rcx = 0; (_r)->rdx = 0; \
-        (_r)->rsi = 0; (_r)->rdi = 0; (_r)->rbp = 0; \
-        (_r)->rax = 0;                          \
-        (_r)->r8 = 0;                           \
-        (_r)->r9 = 0;                           \
-        (_r)->r10 = 0;                          \
-        (_r)->r11 = 0;                          \
-        (_r)->r12 = 0;                          \
-        (_r)->r13 = 0;                          \
-        (_r)->r14 = 0;                          \
-        (_r)->r15 = 0;                          \
-        cur->thread.fs = 0; cur->thread.gs = 0; \
-        cur->thread.fsindex = 0; cur->thread.gsindex = 0; \
-        cur->thread.ds = 0; cur->thread.es = 0;  \
-        clear_thread_flag(TIF_IA32); \
-} while (0)
-
-#define USE_ELF_CORE_DUMP
-#define ELF_EXEC_PAGESIZE       4096
-
-/* This is the location that an ET_DYN program is loaded if exec'ed.  Typical
-   use of this is to invoke "./ld.so someprog" to test out a new version of
-   the loader.  We need to make sure that it is out of the way of the program
-   that it will "exec", and that there is sufficient room for the brk.  */
-
-#define ELF_ET_DYN_BASE         (2 * TASK_SIZE / 3)
-
-/* regs is struct pt_regs, pr_reg is elf_gregset_t (which is
-   now struct_user_regs, they are different). Assumes current is the process
-   getting dumped. */
-
-#define ELF_CORE_COPY_REGS(pr_reg, regs)  do { \
-        unsigned v;                                             \
-        (pr_reg)[0] = (regs)->r15;                              \
-        (pr_reg)[1] = (regs)->r14;                              \
-        (pr_reg)[2] = (regs)->r13;                              \
-        (pr_reg)[3] = (regs)->r12;                              \
-        (pr_reg)[4] = (regs)->rbp;                              \
-        (pr_reg)[5] = (regs)->rbx;                              \
-        (pr_reg)[6] = (regs)->r11;                              \
-        (pr_reg)[7] = (regs)->r10;                              \
-        (pr_reg)[8] = (regs)->r9;                               \
-        (pr_reg)[9] = (regs)->r8;                               \
-        (pr_reg)[10] = (regs)->rax;                             \
-        (pr_reg)[11] = (regs)->rcx;                             \
-        (pr_reg)[12] = (regs)->rdx;                             \
-        (pr_reg)[13] = (regs)->rsi;                             \
-        (pr_reg)[14] = (regs)->rdi;                             \
-        (pr_reg)[15] = (regs)->orig_rax;                        \
-        (pr_reg)[16] = (regs)->rip;                     \
-        (pr_reg)[17] = (regs)->cs;                      \
-        (pr_reg)[18] = (regs)->eflags;                  \
-        (pr_reg)[19] = (regs)->rsp;                     \
-        (pr_reg)[20] = (regs)->ss;                      \
-        (pr_reg)[21] = current->thread.fs;                      \
-        (pr_reg)[22] = current->thread.gs;                      \
-        asm("movl %%ds,%0" : "=r" (v)); (pr_reg)[23] = v;       \
-        asm("movl %%es,%0" : "=r" (v)); (pr_reg)[24] = v;       \
-        asm("movl %%fs,%0" : "=r" (v)); (pr_reg)[25] = v;       \
-        asm("movl %%gs,%0" : "=r" (v)); (pr_reg)[26] = v;       \
-} while(0);
-
-/* This yields a mask that user programs can use to figure out what
-   instruction set this CPU supports.  This could be done in user space,
-   but it's not easy, and we've already done it here.  */
-
-#define ELF_HWCAP       (boot_cpu_data.x86_capability[0])
-
-/* This yields a string that ld.so will use to load implementation
-   specific libraries for optimization.  This is more specific in
-   intent than poking at uname or /proc/cpuinfo.
-
-   For the moment, we have only optimizations for the Intel generations,
-   but that could change... */
-
-/* I'm not sure if we can use '-' here */
-#define ELF_PLATFORM  ("x86_64")
-
-extern void set_personality_64bit(void);
-#define SET_PERSONALITY(ex, ibcs2) set_personality_64bit()
-/*
- * An executable for which elf_read_implies_exec() returns TRUE will
- * have the READ_IMPLIES_EXEC personality flag set automatically.
- */
-#define elf_read_implies_exec(ex, executable_stack)     (executable_stack != EXSTACK_DISABLE_X)
-
-struct task_struct;
-
-extern int dump_task_regs (struct task_struct *, elf_gregset_t *);
-extern int dump_task_fpu (struct task_struct *, elf_fpregset_t *);
-
-#define ELF_CORE_COPY_TASK_REGS(tsk, elf_regs) dump_task_regs(tsk, elf_regs)
-#define ELF_CORE_COPY_FPREGS(tsk, elf_fpregs) dump_task_fpu(tsk, elf_fpregs)
-
-/* 1GB for 64bit, 8MB for 32bit */
-#define STACK_RND_MASK (test_thread_flag(TIF_IA32) ? 0x7ff : 0x3fffff)
-
-
-#define ARCH_HAS_SETUP_ADDITIONAL_PAGES 1
-struct linux_binprm;
-extern int arch_setup_additional_pages(struct linux_binprm *bprm,
-                                       int executable_stack);
-
-extern int vdso_enabled;
-
-#define ARCH_DLINFO                                             \
-do if (vdso_enabled) {                                          \
-        NEW_AUX_ENT(AT_SYSINFO_EHDR,(unsigned long)current->mm->context.vdso);\
-} while (0)
-
-#endif
-
-#endif
diff --git a/include/asm-x86/mmu.h b/include/asm-x86/mmu.h
index 9c628cd70e23..3f922c8e1c88 100644
--- a/include/asm-x86/mmu.h
+++ b/include/asm-x86/mmu.h
@@ -1,5 +1,23 @@
-#ifdef CONFIG_X86_32
-# include "mmu_32.h"
-#else
-# include "mmu_64.h"
+#ifndef _ASM_X86_MMU_H
+#define _ASM_X86_MMU_H
+
+#include <linux/spinlock.h>
+#include <linux/mutex.h>
+
+/*
+ * The x86 doesn't have a mmu context, but
+ * we put the segment information here.
+ *
+ * cpu_vm_mask is used to optimize ldt flushing.
+ */
+typedef struct { 
+        void *ldt;
+#ifdef CONFIG_X86_64
+        rwlock_t ldtlock; 
 #endif
+        int size;
+        struct mutex lock;
+        void *vdso;
+} mm_context_t;
+
+#endif /* _ASM_X86_MMU_H */
diff --git a/include/asm-x86/mmu_32.h b/include/asm-x86/mmu_32.h
deleted file mode 100644
index 5e249c51ef56..000000000000
--- a/include/asm-x86/mmu_32.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef __i386_MMU_H
-#define __i386_MMU_H
-
-#include <linux/mutex.h>
-/*
- * The i386 doesn't have a mmu context, but
- * we put the segment information here.
- *
- * cpu_vm_mask is used to optimize ldt flushing.
- */
-typedef struct { 
-        int size;
-        struct mutex lock;
-        void *ldt;
-        void *vdso;
-} mm_context_t;
-
-#endif
diff --git a/include/asm-x86/mmu_64.h b/include/asm-x86/mmu_64.h
deleted file mode 100644
index 024357c27222..000000000000
--- a/include/asm-x86/mmu_64.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef __x86_64_MMU_H
-#define __x86_64_MMU_H
-
-#include <linux/spinlock.h>
-#include <linux/mutex.h>
-
-/*
- * The x86_64 doesn't have a mmu context, but
- * we put the segment information here.
- *
- * cpu_vm_mask is used to optimize ldt flushing.
- */
-typedef struct { 
-        void *ldt;
-        rwlock_t ldtlock; 
-        int size;
-        struct mutex lock;
-        void *vdso;
-} mm_context_t;
-
-#endif
diff --git a/include/asm-x86/msgbuf.h b/include/asm-x86/msgbuf.h
index 154f7d64e862..7e4e9481f51c 100644
--- a/include/asm-x86/msgbuf.h
+++ b/include/asm-x86/msgbuf.h
@@ -1,13 +1,39 @@
-#ifdef __KERNEL__
-# ifdef CONFIG_X86_32
-#  include "msgbuf_32.h"
-# else
-#  include "msgbuf_64.h"
-# endif
-#else
-# ifdef __i386__
-#  include "msgbuf_32.h"
-# else
-#  include "msgbuf_64.h"
-# endif
+#ifndef _ASM_X86_MSGBUF_H
+#define _ASM_X86_MSGBUF_H
+
+/*
+ * The msqid64_ds structure for i386 architecture.
+ * Note extra padding because this structure is passed back and forth
+ * between kernel and user space.
+ *
+ * Pad space on i386 is left for:
+ * - 64-bit time_t to solve y2038 problem
+ * - 2 miscellaneous 32-bit values
+ *
+ * Pad space on x8664 is left for:
+ * - 2 miscellaneous 64-bit values
+ */
+struct msqid64_ds {
+        struct ipc64_perm msg_perm;
+        __kernel_time_t msg_stime;      /* last msgsnd time */
+#ifdef __i386__
+        unsigned long   __unused1;
 #endif
+        __kernel_time_t msg_rtime;      /* last msgrcv time */
+#ifdef __i386__
+        unsigned long   __unused2;
+#endif
+        __kernel_time_t msg_ctime;      /* last change time */
+#ifdef __i386__
+        unsigned long   __unused3;
+#endif
+        unsigned long  msg_cbytes;      /* current number of bytes on queue */
+        unsigned long  msg_qnum;        /* number of messages in queue */
+        unsigned long  msg_qbytes;      /* max number of bytes on queue */
+        __kernel_pid_t msg_lspid;       /* pid of last msgsnd */
+        __kernel_pid_t msg_lrpid;       /* last receive pid */
+        unsigned long  __unused4;
+        unsigned long  __unused5;
+};
+
+#endif /* _ASM_X86_MSGBUF_H */
diff --git a/include/asm-x86/msgbuf_32.h b/include/asm-x86/msgbuf_32.h
deleted file mode 100644
index b8d659c157ae..000000000000
--- a/include/asm-x86/msgbuf_32.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef _I386_MSGBUF_H
-#define _I386_MSGBUF_H
-
-/* 
- * The msqid64_ds structure for i386 architecture.
- * Note extra padding because this structure is passed back and forth
- * between kernel and user space.
- *
- * Pad space is left for:
- * - 64-bit time_t to solve y2038 problem
- * - 2 miscellaneous 32-bit values
- */
-
-struct msqid64_ds {
-        struct ipc64_perm msg_perm;
-        __kernel_time_t msg_stime;      /* last msgsnd time */
-        unsigned long   __unused1;
-        __kernel_time_t msg_rtime;      /* last msgrcv time */
-        unsigned long   __unused2;
-        __kernel_time_t msg_ctime;      /* last change time */
-        unsigned long   __unused3;
-        unsigned long  msg_cbytes;      /* current number of bytes on queue */
-        unsigned long  msg_qnum;        /* number of messages in queue */
-        unsigned long  msg_qbytes;      /* max number of bytes on queue */
-        __kernel_pid_t msg_lspid;       /* pid of last msgsnd */
-        __kernel_pid_t msg_lrpid;       /* last receive pid */
-        unsigned long  __unused4;
-        unsigned long  __unused5;
-};
-
-#endif /* _I386_MSGBUF_H */
diff --git a/include/asm-x86/msgbuf_64.h b/include/asm-x86/msgbuf_64.h
deleted file mode 100644
index cd6f95dd54da..000000000000
--- a/include/asm-x86/msgbuf_64.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef _X8664_MSGBUF_H
-#define _X8664_MSGBUF_H
-
-/* 
- * The msqid64_ds structure for x86-64 architecture.
- * Note extra padding because this structure is passed back and forth
- * between kernel and user space.
- *
- * Pad space is left for:
- * - 2 miscellaneous 64-bit values
- */
-
-struct msqid64_ds {
-        struct ipc64_perm msg_perm;
-        __kernel_time_t msg_stime;      /* last msgsnd time */
-        __kernel_time_t msg_rtime;      /* last msgrcv time */
-        __kernel_time_t msg_ctime;      /* last change time */
-        unsigned long  msg_cbytes;      /* current number of bytes on queue */
-        unsigned long  msg_qnum;        /* number of messages in queue */
-        unsigned long  msg_qbytes;      /* max number of bytes on queue */
-        __kernel_pid_t msg_lspid;       /* pid of last msgsnd */
-        __kernel_pid_t msg_lrpid;       /* last receive pid */
-        unsigned long  __unused4;
-        unsigned long  __unused5;
-};
-
-#endif
diff --git a/include/asm-x86/msr.h b/include/asm-x86/msr.h
index 2f87ce007002..ba4b31432120 100644
--- a/include/asm-x86/msr.h
+++ b/include/asm-x86/msr.h
@@ -1,13 +1,350 @@
+#ifndef __ASM_X86_MSR_H_
+#define __ASM_X86_MSR_H_
+
+#include <asm/msr-index.h>
+
+#ifdef __i386__
+
 #ifdef __KERNEL__
-# ifdef CONFIG_X86_32
-#  include "msr_32.h"
-# else
-#  include "msr_64.h"
-# endif
+#ifndef __ASSEMBLY__
+
+#include <asm/errno.h>
+
+static inline unsigned long long native_read_msr(unsigned int msr)
+{
+        unsigned long long val;
+
+        asm volatile("rdmsr" : "=A" (val) : "c" (msr));
+        return val;
+}
+
+static inline unsigned long long native_read_msr_safe(unsigned int msr,
+                                                      int *err)
+{
+        unsigned long long val;
+
+        asm volatile("2: rdmsr ; xorl %0,%0\n"
+                     "1:\n\t"
+                     ".section .fixup,\"ax\"\n\t"
+                     "3:  movl %3,%0 ; jmp 1b\n\t"
+                     ".previous\n\t"
+                     ".section __ex_table,\"a\"\n"
+                     "   .align 4\n\t"
+                     "   .long  2b,3b\n\t"
+                     ".previous"
+                     : "=r" (*err), "=A" (val)
+                     : "c" (msr), "i" (-EFAULT));
+
+        return val;
+}
+
+static inline void native_write_msr(unsigned int msr, unsigned long long val)
+{
+        asm volatile("wrmsr" : : "c" (msr), "A"(val));
+}
+
+static inline int native_write_msr_safe(unsigned int msr,
+                                        unsigned long long val)
+{
+        int err;
+        asm volatile("2: wrmsr ; xorl %0,%0\n"
+                     "1:\n\t"
+                     ".section .fixup,\"ax\"\n\t"
+                     "3:  movl %4,%0 ; jmp 1b\n\t"
+                     ".previous\n\t"
+                     ".section __ex_table,\"a\"\n"
+                     "   .align 4\n\t"
+                     "   .long  2b,3b\n\t"
+                     ".previous"
+                     : "=a" (err)
+                     : "c" (msr), "0" ((u32)val), "d" ((u32)(val>>32)),
+                       "i" (-EFAULT));
+        return err;
+}
+
+static inline unsigned long long native_read_tsc(void)
+{
+        unsigned long long val;
+        asm volatile("rdtsc" : "=A" (val));
+        return val;
+}
+
+static inline unsigned long long native_read_pmc(void)
+{
+        unsigned long long val;
+        asm volatile("rdpmc" : "=A" (val));
+        return val;
+}
+
+#ifdef CONFIG_PARAVIRT
+#include <asm/paravirt.h>
 #else
-# ifdef __i386__
-#  include "msr_32.h"
-# else
-#  include "msr_64.h"
-# endif
+#include <linux/errno.h>
+/*
+ * Access to machine-specific registers (available on 586 and better only)
+ * Note: the rd* operations modify the parameters directly (without using
+ * pointer indirection), this allows gcc to optimize better
+ */
+
+#define rdmsr(msr,val1,val2)                                            \
+        do {                                                            \
+                u64 __val = native_read_msr(msr);                       \
+                (val1) = (u32)__val;                                    \
+                (val2) = (u32)(__val >> 32);                            \
+        } while(0)
+
+static inline void wrmsr(u32 __msr, u32 __low, u32 __high)
+{
+        native_write_msr(__msr, ((u64)__high << 32) | __low);
+}
+
+#define rdmsrl(msr,val)                                                 \
+        ((val) = native_read_msr(msr))
+
+#define wrmsrl(msr,val) native_write_msr(msr, val)
+
+/* wrmsr with exception handling */
+static inline int wrmsr_safe(u32 __msr, u32 __low, u32 __high)
+{
+        return native_write_msr_safe(__msr, ((u64)__high << 32) | __low);
+}
+
+/* rdmsr with exception handling */
+#define rdmsr_safe(msr,p1,p2)                                           \
+        ({                                                              \
+                int __err;                                              \
+                u64 __val = native_read_msr_safe(msr, &__err);          \
+                (*p1) = (u32)__val;                                     \
+                (*p2) = (u32)(__val >> 32);                             \
+                __err;                                                  \
+        })
+
+#define rdtscl(low)                                             \
+        ((low) = (u32)native_read_tsc())
+
+#define rdtscll(val)                                            \
+        ((val) = native_read_tsc())
+
+#define write_tsc(val1,val2) wrmsr(0x10, val1, val2)
+
+#define rdpmc(counter,low,high)                                 \
+        do {                                                    \
+                u64 _l = native_read_pmc();                     \
+                (low)  = (u32)_l;                               \
+                (high) = (u32)(_l >> 32);                       \
+        } while(0)
+#endif  /* !CONFIG_PARAVIRT */
+
+#ifdef CONFIG_SMP
+void rdmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h);
+void wrmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h);
+int rdmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h);
+int wrmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h);
+#else  /*  CONFIG_SMP  */
+static inline void rdmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h)
+{
+        rdmsr(msr_no, *l, *h);
+}
+static inline void wrmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h)
+{
+        wrmsr(msr_no, l, h);
+}
+static inline int rdmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h)
+{
+        return rdmsr_safe(msr_no, l, h);
+}
+static inline int wrmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h)
+{
+        return wrmsr_safe(msr_no, l, h);
+}
+#endif  /*  CONFIG_SMP  */
+#endif  /* ! __ASSEMBLY__ */
+#endif  /* __KERNEL__ */
+
+#else   /* __i386__ */
+
+#ifndef __ASSEMBLY__
+#include <linux/errno.h>
+/*
+ * Access to machine-specific registers (available on 586 and better only)
+ * Note: the rd* operations modify the parameters directly (without using
+ * pointer indirection), this allows gcc to optimize better
+ */
+
+#define rdmsr(msr,val1,val2) \
+       __asm__ __volatile__("rdmsr" \
+                            : "=a" (val1), "=d" (val2) \
+                            : "c" (msr))
+
+
+#define rdmsrl(msr,val) do { unsigned long a__,b__; \
+       __asm__ __volatile__("rdmsr" \
+                            : "=a" (a__), "=d" (b__) \
+                            : "c" (msr)); \
+       val = a__ | (b__<<32); \
+} while(0)
+
+#define wrmsr(msr,val1,val2) \
+     __asm__ __volatile__("wrmsr" \
+                          : /* no outputs */ \
+                          : "c" (msr), "a" (val1), "d" (val2))
+
+#define wrmsrl(msr,val) wrmsr(msr,(__u32)((__u64)(val)),((__u64)(val))>>32)
+
+/* wrmsr with exception handling */
+#define wrmsr_safe(msr,a,b) ({ int ret__;                       \
+        asm volatile("2: wrmsr ; xorl %0,%0\n"                  \
+                     "1:\n\t"                                   \
+                     ".section .fixup,\"ax\"\n\t"               \
+                     "3:  movl %4,%0 ; jmp 1b\n\t"              \
+                     ".previous\n\t"                            \
+                     ".section __ex_table,\"a\"\n"              \
+                     "   .align 8\n\t"                          \
+                     "   .quad  2b,3b\n\t"                      \
+                     ".previous"                                \
+                     : "=a" (ret__)                             \
+                     : "c" (msr), "0" (a), "d" (b), "i" (-EFAULT)); \
+        ret__; })
+
+#define checking_wrmsrl(msr,val) wrmsr_safe(msr,(u32)(val),(u32)((val)>>32))
+
+#define rdmsr_safe(msr,a,b) \
+        ({ int ret__;                                           \
+          asm volatile ("1:       rdmsr\n"                      \
+                        "2:\n"                                  \
+                        ".section .fixup,\"ax\"\n"              \
+                        "3:       movl %4,%0\n"                 \
+                        " jmp 2b\n"                             \
+                        ".previous\n"                           \
+                        ".section __ex_table,\"a\"\n"           \
+                        " .align 8\n"                           \
+                        " .quad 1b,3b\n"                                \
+                        ".previous":"=&bDS" (ret__), "=a"(*(a)), "=d"(*(b)) \
+                        :"c"(msr), "i"(-EIO), "0"(0));                  \
+          ret__; })
+
+#define rdtsc(low,high) \
+     __asm__ __volatile__("rdtsc" : "=a" (low), "=d" (high))
+
+#define rdtscl(low) \
+     __asm__ __volatile__ ("rdtsc" : "=a" (low) : : "edx")
+
+#define rdtscp(low,high,aux) \
+     asm volatile (".byte 0x0f,0x01,0xf9" : "=a" (low), "=d" (high), "=c" (aux))
+
+#define rdtscll(val) do { \
+     unsigned int __a,__d; \
+     asm volatile("rdtsc" : "=a" (__a), "=d" (__d)); \
+     (val) = ((unsigned long)__a) | (((unsigned long)__d)<<32); \
+} while(0)
+
+#define rdtscpll(val, aux) do { \
+     unsigned long __a, __d; \
+     asm volatile (".byte 0x0f,0x01,0xf9" : "=a" (__a), "=d" (__d), "=c" (aux)); \
+     (val) = (__d << 32) | __a; \
+} while (0)
+
+#define write_tsc(val1,val2) wrmsr(0x10, val1, val2)
+
+#define write_rdtscp_aux(val) wrmsr(0xc0000103, val, 0)
+
+#define rdpmc(counter,low,high) \
+     __asm__ __volatile__("rdpmc" \
+                          : "=a" (low), "=d" (high) \
+                          : "c" (counter))
+
+static inline void cpuid(int op, unsigned int *eax, unsigned int *ebx,
+                         unsigned int *ecx, unsigned int *edx)
+{
+        __asm__("cpuid"
+                : "=a" (*eax),
+                  "=b" (*ebx),
+                  "=c" (*ecx),
+                  "=d" (*edx)
+                : "0" (op));
+}
+
+/* Some CPUID calls want 'count' to be placed in ecx */
+static inline void cpuid_count(int op, int count, int *eax, int *ebx, int *ecx,
+                               int *edx)
+{
+        __asm__("cpuid"
+                : "=a" (*eax),
+                  "=b" (*ebx),
+                  "=c" (*ecx),
+                  "=d" (*edx)
+                : "0" (op), "c" (count));
+}
+
+/*
+ * CPUID functions returning a single datum
+ */
+static inline unsigned int cpuid_eax(unsigned int op)
+{
+        unsigned int eax;
+
+        __asm__("cpuid"
+                : "=a" (eax)
+                : "0" (op)
+                : "bx", "cx", "dx");
+        return eax;
+}
+static inline unsigned int cpuid_ebx(unsigned int op)
+{
+        unsigned int eax, ebx;
+
+        __asm__("cpuid"
+                : "=a" (eax), "=b" (ebx)
+                : "0" (op)
+                : "cx", "dx" );
+        return ebx;
+}
+static inline unsigned int cpuid_ecx(unsigned int op)
+{
+        unsigned int eax, ecx;
+
+        __asm__("cpuid"
+                : "=a" (eax), "=c" (ecx)
+                : "0" (op)
+                : "bx", "dx" );
+        return ecx;
+}
+static inline unsigned int cpuid_edx(unsigned int op)
+{
+        unsigned int eax, edx;
+
+        __asm__("cpuid"
+                : "=a" (eax), "=d" (edx)
+                : "0" (op)
+                : "bx", "cx");
+        return edx;
+}
+
+#ifdef CONFIG_SMP
+void rdmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h);
+void wrmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h);
+int rdmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h);
+int wrmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h);
+#else  /*  CONFIG_SMP  */
+static inline void rdmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h)
+{
+        rdmsr(msr_no, *l, *h);
+}
+static inline void wrmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h)
+{
+        wrmsr(msr_no, l, h);
+}
+static inline int rdmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h)
+{
+        return rdmsr_safe(msr_no, l, h);
+}
+static inline int wrmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h)
+{
+        return wrmsr_safe(msr_no, l, h);
+}
+#endif  /* CONFIG_SMP */
+#endif  /* __ASSEMBLY__ */
+
+#endif  /* !__i386__ */
+
 #endif
diff --git a/include/asm-x86/msr_32.h b/include/asm-x86/msr_32.h
deleted file mode 100644
index df21ea049369..000000000000
--- a/include/asm-x86/msr_32.h
+++ /dev/null
@@ -1,161 +0,0 @@
-#ifndef __ASM_MSR_H
-#define __ASM_MSR_H
-
-#include <asm/msr-index.h>
-
-#ifdef __KERNEL__
-#ifndef __ASSEMBLY__
-
-#include <asm/errno.h>
-
-static inline unsigned long long native_read_msr(unsigned int msr)
-{
-        unsigned long long val;
-
-        asm volatile("rdmsr" : "=A" (val) : "c" (msr));
-        return val;
-}
-
-static inline unsigned long long native_read_msr_safe(unsigned int msr,
-                                                      int *err)
-{
-        unsigned long long val;
-
-        asm volatile("2: rdmsr ; xorl %0,%0\n"
-                     "1:\n\t"
-                     ".section .fixup,\"ax\"\n\t"
-                     "3:  movl %3,%0 ; jmp 1b\n\t"
-                     ".previous\n\t"
-                     ".section __ex_table,\"a\"\n"
-                     "   .align 4\n\t"
-                     "   .long  2b,3b\n\t"
-                     ".previous"
-                     : "=r" (*err), "=A" (val)
-                     : "c" (msr), "i" (-EFAULT));
-
-        return val;
-}
-
-static inline void native_write_msr(unsigned int msr, unsigned long long val)
-{
-        asm volatile("wrmsr" : : "c" (msr), "A"(val));
-}
-
-static inline int native_write_msr_safe(unsigned int msr,
-                                        unsigned long long val)
-{
-        int err;
-        asm volatile("2: wrmsr ; xorl %0,%0\n"
-                     "1:\n\t"
-                     ".section .fixup,\"ax\"\n\t"
-                     "3:  movl %4,%0 ; jmp 1b\n\t"
-                     ".previous\n\t"
-                     ".section __ex_table,\"a\"\n"
-                     "   .align 4\n\t"
-                     "   .long  2b,3b\n\t"
-                     ".previous"
-                     : "=a" (err)
-                     : "c" (msr), "0" ((u32)val), "d" ((u32)(val>>32)),
-                       "i" (-EFAULT));
-        return err;
-}
-
-static inline unsigned long long native_read_tsc(void)
-{
-        unsigned long long val;
-        asm volatile("rdtsc" : "=A" (val));
-        return val;
-}
-
-static inline unsigned long long native_read_pmc(void)
-{
-        unsigned long long val;
-        asm volatile("rdpmc" : "=A" (val));
-        return val;
-}
-
-#ifdef CONFIG_PARAVIRT
-#include <asm/paravirt.h>
-#else
-#include <linux/errno.h>
-/*
- * Access to machine-specific registers (available on 586 and better only)
- * Note: the rd* operations modify the parameters directly (without using
- * pointer indirection), this allows gcc to optimize better
- */
-
-#define rdmsr(msr,val1,val2)                                            \
-        do {                                                            \
-                u64 __val = native_read_msr(msr);                       \
-                (val1) = (u32)__val;                                    \
-                (val2) = (u32)(__val >> 32);                            \
-        } while(0)
-
-static inline void wrmsr(u32 __msr, u32 __low, u32 __high)
-{
-        native_write_msr(__msr, ((u64)__high << 32) | __low);
-}
-
-#define rdmsrl(msr,val)                                                 \
-        ((val) = native_read_msr(msr))
-
-#define wrmsrl(msr,val) native_write_msr(msr, val)
-
-/* wrmsr with exception handling */
-static inline int wrmsr_safe(u32 __msr, u32 __low, u32 __high)
-{
-        return native_write_msr_safe(__msr, ((u64)__high << 32) | __low);
-}
-
-/* rdmsr with exception handling */
-#define rdmsr_safe(msr,p1,p2)                                           \
-        ({                                                              \
-                int __err;                                              \
-                u64 __val = native_read_msr_safe(msr, &__err);          \
-                (*p1) = (u32)__val;                                     \
-                (*p2) = (u32)(__val >> 32);                             \
-                __err;                                                  \
-        })
-
-#define rdtscl(low)                                             \
-        ((low) = (u32)native_read_tsc())
-
-#define rdtscll(val)                                            \
-        ((val) = native_read_tsc())
-
-#define write_tsc(val1,val2) wrmsr(0x10, val1, val2)
-
-#define rdpmc(counter,low,high)                                 \
-        do {                                                    \
-                u64 _l = native_read_pmc();                     \
-                (low)  = (u32)_l;                               \
-                (high) = (u32)(_l >> 32);                       \
-        } while(0)
-#endif  /* !CONFIG_PARAVIRT */
-
-#ifdef CONFIG_SMP
-void rdmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h);
-void wrmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h);
-int rdmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h);
-int wrmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h);
-#else  /*  CONFIG_SMP  */
-static inline void rdmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h)
-{
-        rdmsr(msr_no, *l, *h);
-}
-static inline void wrmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h)
-{
-        wrmsr(msr_no, l, h);
-}
-static inline int rdmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h)
-{
-        return rdmsr_safe(msr_no, l, h);
-}
-static inline int wrmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h)
-{
-        return wrmsr_safe(msr_no, l, h);
-}
-#endif  /*  CONFIG_SMP  */
-#endif
-#endif
-#endif /* __ASM_MSR_H */
diff --git a/include/asm-x86/msr_64.h b/include/asm-x86/msr_64.h
deleted file mode 100644
index d5c55b80da54..000000000000
--- a/include/asm-x86/msr_64.h
+++ /dev/null
@@ -1,187 +0,0 @@
-#ifndef X86_64_MSR_H
-#define X86_64_MSR_H 1
-
-#include <asm/msr-index.h>
-
-#ifndef __ASSEMBLY__
-#include <linux/errno.h>
-/*
- * Access to machine-specific registers (available on 586 and better only)
- * Note: the rd* operations modify the parameters directly (without using
- * pointer indirection), this allows gcc to optimize better
- */
-
-#define rdmsr(msr,val1,val2) \
-       __asm__ __volatile__("rdmsr" \
-                            : "=a" (val1), "=d" (val2) \
-                            : "c" (msr))
-
-
-#define rdmsrl(msr,val) do { unsigned long a__,b__; \
-       __asm__ __volatile__("rdmsr" \
-                            : "=a" (a__), "=d" (b__) \
-                            : "c" (msr)); \
-       val = a__ | (b__<<32); \
-} while(0)
-
-#define wrmsr(msr,val1,val2) \
-     __asm__ __volatile__("wrmsr" \
-                          : /* no outputs */ \
-                          : "c" (msr), "a" (val1), "d" (val2))
-
-#define wrmsrl(msr,val) wrmsr(msr,(__u32)((__u64)(val)),((__u64)(val))>>32) 
-
-/* wrmsr with exception handling */
-#define wrmsr_safe(msr,a,b) ({ int ret__;                       \
-        asm volatile("2: wrmsr ; xorl %0,%0\n"                  \
-                     "1:\n\t"                                   \
-                     ".section .fixup,\"ax\"\n\t"               \
-                     "3:  movl %4,%0 ; jmp 1b\n\t"              \
-                     ".previous\n\t"                            \
-                     ".section __ex_table,\"a\"\n"              \
-                     "   .align 8\n\t"                          \
-                     "   .quad  2b,3b\n\t"                      \
-                     ".previous"                                \
-                     : "=a" (ret__)                             \
-                     : "c" (msr), "0" (a), "d" (b), "i" (-EFAULT)); \
-        ret__; })
-
-#define checking_wrmsrl(msr,val) wrmsr_safe(msr,(u32)(val),(u32)((val)>>32))
-
-#define rdmsr_safe(msr,a,b) \
-        ({ int ret__;                                           \
-          asm volatile ("1:       rdmsr\n"                      \
-                      "2:\n"                                    \
-                      ".section .fixup,\"ax\"\n"                \
-                      "3:       movl %4,%0\n"                   \
-                      " jmp 2b\n"                               \
-                      ".previous\n"                             \
-                      ".section __ex_table,\"a\"\n"             \
-                      " .align 8\n"                             \
-                      " .quad 1b,3b\n"                          \
-                      ".previous":"=&bDS" (ret__), "=a"(*(a)), "=d"(*(b))\
-                      :"c"(msr), "i"(-EIO), "0"(0));            \
-          ret__; })             
-
-#define rdtsc(low,high) \
-     __asm__ __volatile__("rdtsc" : "=a" (low), "=d" (high))
-
-#define rdtscl(low) \
-     __asm__ __volatile__ ("rdtsc" : "=a" (low) : : "edx")
-
-#define rdtscp(low,high,aux) \
-     asm volatile (".byte 0x0f,0x01,0xf9" : "=a" (low), "=d" (high), "=c" (aux))
-
-#define rdtscll(val) do { \
-     unsigned int __a,__d; \
-     asm volatile("rdtsc" : "=a" (__a), "=d" (__d)); \
-     (val) = ((unsigned long)__a) | (((unsigned long)__d)<<32); \
-} while(0)
-
-#define rdtscpll(val, aux) do { \
-     unsigned long __a, __d; \
-     asm volatile (".byte 0x0f,0x01,0xf9" : "=a" (__a), "=d" (__d), "=c" (aux)); \
-     (val) = (__d << 32) | __a; \
-} while (0)
-
-#define write_tsc(val1,val2) wrmsr(0x10, val1, val2)
-
-#define write_rdtscp_aux(val) wrmsr(0xc0000103, val, 0)
-
-#define rdpmc(counter,low,high) \
-     __asm__ __volatile__("rdpmc" \
-                          : "=a" (low), "=d" (high) \
-                          : "c" (counter))
-
-static inline void cpuid(int op, unsigned int *eax, unsigned int *ebx,
-                         unsigned int *ecx, unsigned int *edx)
-{
-        __asm__("cpuid"
-                : "=a" (*eax),
-                  "=b" (*ebx),
-                  "=c" (*ecx),
-                  "=d" (*edx)
-                : "0" (op));
-}
-
-/* Some CPUID calls want 'count' to be placed in ecx */
-static inline void cpuid_count(int op, int count, int *eax, int *ebx, int *ecx,
-                int *edx)
-{
-        __asm__("cpuid"
-                : "=a" (*eax),
-                  "=b" (*ebx),
-                  "=c" (*ecx),
-                  "=d" (*edx)
-                : "0" (op), "c" (count));
-}
-
-/*
- * CPUID functions returning a single datum
- */
-static inline unsigned int cpuid_eax(unsigned int op)
-{
-        unsigned int eax;
-
-        __asm__("cpuid"
-                : "=a" (eax)
-                : "0" (op)
-                : "bx", "cx", "dx");
-        return eax;
-}
-static inline unsigned int cpuid_ebx(unsigned int op)
-{
-        unsigned int eax, ebx;
-
-        __asm__("cpuid"
-                : "=a" (eax), "=b" (ebx)
-                : "0" (op)
-                : "cx", "dx" );
-        return ebx;
-}
-static inline unsigned int cpuid_ecx(unsigned int op)
-{
-        unsigned int eax, ecx;
-
-        __asm__("cpuid"
-                : "=a" (eax), "=c" (ecx)
-                : "0" (op)
-                : "bx", "dx" );
-        return ecx;
-}
-static inline unsigned int cpuid_edx(unsigned int op)
-{
-        unsigned int eax, edx;
-
-        __asm__("cpuid"
-                : "=a" (eax), "=d" (edx)
-                : "0" (op)
-                : "bx", "cx");
-        return edx;
-}
-
-#ifdef CONFIG_SMP
-void rdmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h);
-void wrmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h);
-int rdmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h);
-int wrmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h);
-#else  /*  CONFIG_SMP  */
-static inline void rdmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h)
-{
-        rdmsr(msr_no, *l, *h);
-}
-static inline void wrmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h)
-{
-        wrmsr(msr_no, l, h);
-}
-static inline int rdmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h)
-{
-        return rdmsr_safe(msr_no, l, h);
-}
-static inline int wrmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h)
-{
-        return wrmsr_safe(msr_no, l, h);
-}
-#endif  /* CONFIG_SMP */
-#endif /* __ASSEMBLY__ */
-#endif  /* X86_64_MSR_H */
diff --git a/include/asm-x86/mtrr.h b/include/asm-x86/mtrr.h
index 34f633b3e00c..e8320e4e6ca2 100644
--- a/include/asm-x86/mtrr.h
+++ b/include/asm-x86/mtrr.h
@@ -1,13 +1,164 @@
+/*  Generic MTRR (Memory Type Range Register) ioctls.
+
+    Copyright (C) 1997-1999  Richard Gooch
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+    Richard Gooch may be reached by email at  rgooch@atnf.csiro.au
+    The postal address is:
+      Richard Gooch, c/o ATNF, P. O. Box 76, Epping, N.S.W., 2121, Australia.
+*/
+#ifndef _ASM_X86_MTRR_H
+#define _ASM_X86_MTRR_H
+
+#include <linux/ioctl.h>
+#include <linux/errno.h>
+
+#define MTRR_IOCTL_BASE 'M'
+
+struct mtrr_sentry
+{
+    unsigned long base;    /*  Base address     */
+    unsigned int size;    /*  Size of region   */
+    unsigned int type;     /*  Type of region   */
+};
+
+/* Warning: this structure has a different order from i386
+   on x86-64. The 32bit emulation code takes care of that.
+   But you need to use this for 64bit, otherwise your X server
+   will break. */
+
+#ifdef __i386__
+struct mtrr_gentry
+{
+    unsigned int regnum;   /*  Register number  */
+    unsigned long base;    /*  Base address     */
+    unsigned int size;    /*  Size of region   */
+    unsigned int type;     /*  Type of region   */
+};
+
+#else /* __i386__ */
+
+struct mtrr_gentry
+{
+    unsigned long base;    /*  Base address     */
+    unsigned int size;    /*  Size of region   */
+    unsigned int regnum;   /*  Register number  */
+    unsigned int type;     /*  Type of region   */
+};
+#endif /* !__i386__ */
+
+/*  These are the various ioctls  */
+#define MTRRIOC_ADD_ENTRY        _IOW(MTRR_IOCTL_BASE,  0, struct mtrr_sentry)
+#define MTRRIOC_SET_ENTRY        _IOW(MTRR_IOCTL_BASE,  1, struct mtrr_sentry)
+#define MTRRIOC_DEL_ENTRY        _IOW(MTRR_IOCTL_BASE,  2, struct mtrr_sentry)
+#define MTRRIOC_GET_ENTRY        _IOWR(MTRR_IOCTL_BASE, 3, struct mtrr_gentry)
+#define MTRRIOC_KILL_ENTRY       _IOW(MTRR_IOCTL_BASE,  4, struct mtrr_sentry)
+#define MTRRIOC_ADD_PAGE_ENTRY   _IOW(MTRR_IOCTL_BASE,  5, struct mtrr_sentry)
+#define MTRRIOC_SET_PAGE_ENTRY   _IOW(MTRR_IOCTL_BASE,  6, struct mtrr_sentry)
+#define MTRRIOC_DEL_PAGE_ENTRY   _IOW(MTRR_IOCTL_BASE,  7, struct mtrr_sentry)
+#define MTRRIOC_GET_PAGE_ENTRY   _IOWR(MTRR_IOCTL_BASE, 8, struct mtrr_gentry)
+#define MTRRIOC_KILL_PAGE_ENTRY  _IOW(MTRR_IOCTL_BASE,  9, struct mtrr_sentry)
+
+/*  These are the region types  */
+#define MTRR_TYPE_UNCACHABLE 0
+#define MTRR_TYPE_WRCOMB     1
+/*#define MTRR_TYPE_         2*/
+/*#define MTRR_TYPE_         3*/
+#define MTRR_TYPE_WRTHROUGH  4
+#define MTRR_TYPE_WRPROT     5
+#define MTRR_TYPE_WRBACK     6
+#define MTRR_NUM_TYPES       7
+
 #ifdef __KERNEL__
-# ifdef CONFIG_X86_32
-#  include "mtrr_32.h"
-# else
-#  include "mtrr_64.h"
-# endif
-#else
-# ifdef __i386__
-#  include "mtrr_32.h"
-# else
-#  include "mtrr_64.h"
-# endif
-#endif
+
+/*  The following functions are for use by other drivers  */
+# ifdef CONFIG_MTRR
+extern void mtrr_save_fixed_ranges(void *);
+extern void mtrr_save_state(void);
+extern int mtrr_add (unsigned long base, unsigned long size,
+                     unsigned int type, char increment);
+extern int mtrr_add_page (unsigned long base, unsigned long size,
+                     unsigned int type, char increment);
+extern int mtrr_del (int reg, unsigned long base, unsigned long size);
+extern int mtrr_del_page (int reg, unsigned long base, unsigned long size);
+extern void mtrr_centaur_report_mcr(int mcr, u32 lo, u32 hi);
+extern void mtrr_ap_init(void);
+extern void mtrr_bp_init(void);
+#  else
+#define mtrr_save_fixed_ranges(arg) do {} while (0)
+#define mtrr_save_state() do {} while (0)
+static __inline__ int mtrr_add (unsigned long base, unsigned long size,
+                                unsigned int type, char increment)
+{
+    return -ENODEV;
+}
+static __inline__ int mtrr_add_page (unsigned long base, unsigned long size,
+                                unsigned int type, char increment)
+{
+    return -ENODEV;
+}
+static __inline__ int mtrr_del (int reg, unsigned long base,
+                                unsigned long size)
+{
+    return -ENODEV;
+}
+static __inline__ int mtrr_del_page (int reg, unsigned long base,
+                                unsigned long size)
+{
+    return -ENODEV;
+}
+
+static __inline__ void mtrr_centaur_report_mcr(int mcr, u32 lo, u32 hi) {;}
+
+#define mtrr_ap_init() do {} while (0)
+#define mtrr_bp_init() do {} while (0)
+#  endif
+
+#ifdef CONFIG_COMPAT
+#include <linux/compat.h>
+
+struct mtrr_sentry32
+{
+    compat_ulong_t base;    /*  Base address     */
+    compat_uint_t size;    /*  Size of region   */
+    compat_uint_t type;     /*  Type of region   */
+};
+
+struct mtrr_gentry32
+{
+    compat_ulong_t regnum;   /*  Register number  */
+    compat_uint_t base;    /*  Base address     */
+    compat_uint_t size;    /*  Size of region   */
+    compat_uint_t type;     /*  Type of region   */
+};
+
+#define MTRR_IOCTL_BASE 'M'
+
+#define MTRRIOC32_ADD_ENTRY        _IOW(MTRR_IOCTL_BASE,  0, struct mtrr_sentry32)
+#define MTRRIOC32_SET_ENTRY        _IOW(MTRR_IOCTL_BASE,  1, struct mtrr_sentry32)
+#define MTRRIOC32_DEL_ENTRY        _IOW(MTRR_IOCTL_BASE,  2, struct mtrr_sentry32)
+#define MTRRIOC32_GET_ENTRY        _IOWR(MTRR_IOCTL_BASE, 3, struct mtrr_gentry32)
+#define MTRRIOC32_KILL_ENTRY       _IOW(MTRR_IOCTL_BASE,  4, struct mtrr_sentry32)
+#define MTRRIOC32_ADD_PAGE_ENTRY   _IOW(MTRR_IOCTL_BASE,  5, struct mtrr_sentry32)
+#define MTRRIOC32_SET_PAGE_ENTRY   _IOW(MTRR_IOCTL_BASE,  6, struct mtrr_sentry32)
+#define MTRRIOC32_DEL_PAGE_ENTRY   _IOW(MTRR_IOCTL_BASE,  7, struct mtrr_sentry32)
+#define MTRRIOC32_GET_PAGE_ENTRY   _IOWR(MTRR_IOCTL_BASE, 8, struct mtrr_gentry32)
+#define MTRRIOC32_KILL_PAGE_ENTRY  _IOW(MTRR_IOCTL_BASE,  9, struct mtrr_sentry32)
+#endif /* CONFIG_COMPAT */
+
+#endif /* __KERNEL__ */
+
+#endif  /*  _ASM_X86_MTRR_H  */
diff --git a/include/asm-x86/mtrr_32.h b/include/asm-x86/mtrr_32.h
deleted file mode 100644
index 7e9c7ccbdcfe..000000000000
--- a/include/asm-x86/mtrr_32.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/*  Generic MTRR (Memory Type Range Register) ioctls.
-
-    Copyright (C) 1997-1999  Richard Gooch
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library 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
-    Library General Public License for more details.
-
-    You should have received a copy of the GNU Library General Public
-    License along with this library; if not, write to the Free
-    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-    Richard Gooch may be reached by email at  rgooch@atnf.csiro.au
-    The postal address is:
-      Richard Gooch, c/o ATNF, P. O. Box 76, Epping, N.S.W., 2121, Australia.
-*/
-#ifndef _LINUX_MTRR_H
-#define _LINUX_MTRR_H
-
-#include <linux/ioctl.h>
-#include <linux/errno.h>
-
-#define MTRR_IOCTL_BASE 'M'
-
-struct mtrr_sentry
-{
-    unsigned long base;    /*  Base address     */
-    unsigned int size;    /*  Size of region   */
-    unsigned int type;     /*  Type of region   */
-};
-
-struct mtrr_gentry
-{
-    unsigned int regnum;   /*  Register number  */
-    unsigned long base;    /*  Base address     */
-    unsigned int size;    /*  Size of region   */
-    unsigned int type;     /*  Type of region   */
-};
-
-/*  These are the various ioctls  */
-#define MTRRIOC_ADD_ENTRY        _IOW(MTRR_IOCTL_BASE,  0, struct mtrr_sentry)
-#define MTRRIOC_SET_ENTRY        _IOW(MTRR_IOCTL_BASE,  1, struct mtrr_sentry)
-#define MTRRIOC_DEL_ENTRY        _IOW(MTRR_IOCTL_BASE,  2, struct mtrr_sentry)
-#define MTRRIOC_GET_ENTRY        _IOWR(MTRR_IOCTL_BASE, 3, struct mtrr_gentry)
-#define MTRRIOC_KILL_ENTRY       _IOW(MTRR_IOCTL_BASE,  4, struct mtrr_sentry)
-#define MTRRIOC_ADD_PAGE_ENTRY   _IOW(MTRR_IOCTL_BASE,  5, struct mtrr_sentry)
-#define MTRRIOC_SET_PAGE_ENTRY   _IOW(MTRR_IOCTL_BASE,  6, struct mtrr_sentry)
-#define MTRRIOC_DEL_PAGE_ENTRY   _IOW(MTRR_IOCTL_BASE,  7, struct mtrr_sentry)
-#define MTRRIOC_GET_PAGE_ENTRY   _IOWR(MTRR_IOCTL_BASE, 8, struct mtrr_gentry)
-#define MTRRIOC_KILL_PAGE_ENTRY  _IOW(MTRR_IOCTL_BASE,  9, struct mtrr_sentry)
-
-/*  These are the region types  */
-#define MTRR_TYPE_UNCACHABLE 0
-#define MTRR_TYPE_WRCOMB     1
-/*#define MTRR_TYPE_         2*/
-/*#define MTRR_TYPE_         3*/
-#define MTRR_TYPE_WRTHROUGH  4
-#define MTRR_TYPE_WRPROT     5
-#define MTRR_TYPE_WRBACK     6
-#define MTRR_NUM_TYPES       7
-
-#ifdef __KERNEL__
-
-/*  The following functions are for use by other drivers  */
-# ifdef CONFIG_MTRR
-extern void mtrr_save_fixed_ranges(void *);
-extern void mtrr_save_state(void);
-extern int mtrr_add (unsigned long base, unsigned long size,
-                     unsigned int type, char increment);
-extern int mtrr_add_page (unsigned long base, unsigned long size,
-                     unsigned int type, char increment);
-extern int mtrr_del (int reg, unsigned long base, unsigned long size);
-extern int mtrr_del_page (int reg, unsigned long base, unsigned long size);
-extern void mtrr_centaur_report_mcr(int mcr, u32 lo, u32 hi);
-extern void mtrr_ap_init(void);
-extern void mtrr_bp_init(void);
-#  else
-#define mtrr_save_fixed_ranges(arg) do {} while (0)
-#define mtrr_save_state() do {} while (0)
-static __inline__ int mtrr_add (unsigned long base, unsigned long size,
-                                unsigned int type, char increment)
-{
-    return -ENODEV;
-}
-static __inline__ int mtrr_add_page (unsigned long base, unsigned long size,
-                                unsigned int type, char increment)
-{
-    return -ENODEV;
-}
-static __inline__ int mtrr_del (int reg, unsigned long base,
-                                unsigned long size)
-{
-    return -ENODEV;
-}
-static __inline__ int mtrr_del_page (int reg, unsigned long base,
-                                unsigned long size)
-{
-    return -ENODEV;
-}
-
-static __inline__ void mtrr_centaur_report_mcr(int mcr, u32 lo, u32 hi) {;}
-
-#define mtrr_ap_init() do {} while (0)
-#define mtrr_bp_init() do {} while (0)
-#  endif
-
-#endif
-
-#endif  /*  _LINUX_MTRR_H  */
diff --git a/include/asm-x86/mtrr_64.h b/include/asm-x86/mtrr_64.h
deleted file mode 100644
index b557c486bef8..000000000000
--- a/include/asm-x86/mtrr_64.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/*  Generic MTRR (Memory Type Range Register) ioctls.
-
-    Copyright (C) 1997-1999  Richard Gooch
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library 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
-    Library General Public License for more details.
-
-    You should have received a copy of the GNU Library General Public
-    License along with this library; if not, write to the Free
-    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-    Richard Gooch may be reached by email at  rgooch@atnf.csiro.au
-    The postal address is:
-      Richard Gooch, c/o ATNF, P. O. Box 76, Epping, N.S.W., 2121, Australia.
-*/
-#ifndef _LINUX_MTRR_H
-#define _LINUX_MTRR_H
-
-#include <linux/ioctl.h>
-
-#define MTRR_IOCTL_BASE 'M'
-
-struct mtrr_sentry
-{
-    unsigned long base;    /*  Base address     */
-    unsigned int size;    /*  Size of region   */
-    unsigned int type;     /*  Type of region   */
-};
-
-/* Warning: this structure has a different order from i386
-   on x86-64. The 32bit emulation code takes care of that.
-   But you need to use this for 64bit, otherwise your X server
-   will break. */
-struct mtrr_gentry
-{
-    unsigned long base;    /*  Base address     */
-    unsigned int size;    /*  Size of region   */
-    unsigned int regnum;   /*  Register number  */
-    unsigned int type;     /*  Type of region   */
-};
-
-/*  These are the various ioctls  */
-#define MTRRIOC_ADD_ENTRY        _IOW(MTRR_IOCTL_BASE,  0, struct mtrr_sentry)
-#define MTRRIOC_SET_ENTRY        _IOW(MTRR_IOCTL_BASE,  1, struct mtrr_sentry)
-#define MTRRIOC_DEL_ENTRY        _IOW(MTRR_IOCTL_BASE,  2, struct mtrr_sentry)
-#define MTRRIOC_GET_ENTRY        _IOWR(MTRR_IOCTL_BASE, 3, struct mtrr_gentry)
-#define MTRRIOC_KILL_ENTRY       _IOW(MTRR_IOCTL_BASE,  4, struct mtrr_sentry)
-#define MTRRIOC_ADD_PAGE_ENTRY   _IOW(MTRR_IOCTL_BASE,  5, struct mtrr_sentry)
-#define MTRRIOC_SET_PAGE_ENTRY   _IOW(MTRR_IOCTL_BASE,  6, struct mtrr_sentry)
-#define MTRRIOC_DEL_PAGE_ENTRY   _IOW(MTRR_IOCTL_BASE,  7, struct mtrr_sentry)
-#define MTRRIOC_GET_PAGE_ENTRY   _IOWR(MTRR_IOCTL_BASE, 8, struct mtrr_gentry)
-#define MTRRIOC_KILL_PAGE_ENTRY  _IOW(MTRR_IOCTL_BASE,  9, struct mtrr_sentry)
-
-/*  These are the region types  */
-#define MTRR_TYPE_UNCACHABLE 0
-#define MTRR_TYPE_WRCOMB     1
-/*#define MTRR_TYPE_         2*/
-/*#define MTRR_TYPE_         3*/
-#define MTRR_TYPE_WRTHROUGH  4
-#define MTRR_TYPE_WRPROT     5
-#define MTRR_TYPE_WRBACK     6
-#define MTRR_NUM_TYPES       7
-
-#ifdef __KERNEL__
-
-/*  The following functions are for use by other drivers  */
-# ifdef CONFIG_MTRR
-extern int mtrr_add (unsigned long base, unsigned long size,
-                     unsigned int type, char increment);
-extern int mtrr_add_page (unsigned long base, unsigned long size,
-                     unsigned int type, char increment);
-extern int mtrr_del (int reg, unsigned long base, unsigned long size);
-extern int mtrr_del_page (int reg, unsigned long base, unsigned long size);
-#  else
-static __inline__ int mtrr_add (unsigned long base, unsigned long size,
-                                unsigned int type, char increment)
-{
-    return -ENODEV;
-}
-static __inline__ int mtrr_add_page (unsigned long base, unsigned long size,
-                                unsigned int type, char increment)
-{
-    return -ENODEV;
-}
-static __inline__ int mtrr_del (int reg, unsigned long base,
-                                unsigned long size)
-{
-    return -ENODEV;
-}
-static __inline__ int mtrr_del_page (int reg, unsigned long base,
-                                unsigned long size)
-{
-    return -ENODEV;
-}
-
-#endif /* CONFIG_MTRR */
-
-#ifdef CONFIG_COMPAT
-#include <linux/compat.h>
-
-struct mtrr_sentry32
-{
-    compat_ulong_t base;    /*  Base address     */
-    compat_uint_t size;    /*  Size of region   */
-    compat_uint_t type;     /*  Type of region   */
-};
-
-struct mtrr_gentry32
-{
-    compat_ulong_t regnum;   /*  Register number  */
-    compat_uint_t base;    /*  Base address     */
-    compat_uint_t size;    /*  Size of region   */
-    compat_uint_t type;     /*  Type of region   */
-};
-
-#define MTRR_IOCTL_BASE 'M'
-
-#define MTRRIOC32_ADD_ENTRY        _IOW(MTRR_IOCTL_BASE,  0, struct mtrr_sentry32)
-#define MTRRIOC32_SET_ENTRY        _IOW(MTRR_IOCTL_BASE,  1, struct mtrr_sentry32)
-#define MTRRIOC32_DEL_ENTRY        _IOW(MTRR_IOCTL_BASE,  2, struct mtrr_sentry32)
-#define MTRRIOC32_GET_ENTRY        _IOWR(MTRR_IOCTL_BASE, 3, struct mtrr_gentry32)
-#define MTRRIOC32_KILL_ENTRY       _IOW(MTRR_IOCTL_BASE,  4, struct mtrr_sentry32)
-#define MTRRIOC32_ADD_PAGE_ENTRY   _IOW(MTRR_IOCTL_BASE,  5, struct mtrr_sentry32)
-#define MTRRIOC32_SET_PAGE_ENTRY   _IOW(MTRR_IOCTL_BASE,  6, struct mtrr_sentry32)
-#define MTRRIOC32_DEL_PAGE_ENTRY   _IOW(MTRR_IOCTL_BASE,  7, struct mtrr_sentry32)
-#define MTRRIOC32_GET_PAGE_ENTRY   _IOWR(MTRR_IOCTL_BASE, 8, struct mtrr_gentry32)
-#define MTRRIOC32_KILL_PAGE_ENTRY  _IOW(MTRR_IOCTL_BASE,  9, struct mtrr_sentry32)
-
-#endif /* CONFIG_COMPAT */
-
-#ifdef CONFIG_MTRR
-extern void mtrr_ap_init(void);
-extern void mtrr_bp_init(void);
-extern void mtrr_save_fixed_ranges(void *);
-extern void mtrr_save_state(void);
-#else
-#define mtrr_ap_init() do {} while (0)
-#define mtrr_bp_init() do {} while (0)
-#define mtrr_save_fixed_ranges(arg) do {} while (0)
-#define mtrr_save_state() do {} while (0)
-#endif
-
-#endif /* __KERNEL__ */
-
-#endif  /*  _LINUX_MTRR_H  */
diff --git a/include/asm-x86/ptrace.h b/include/asm-x86/ptrace.h
index bc4d64a87689..213c97300cb3 100644
--- a/include/asm-x86/ptrace.h
+++ b/include/asm-x86/ptrace.h
@@ -1,13 +1,142 @@
+#ifndef _ASM_X86_PTRACE_H
+#define _ASM_X86_PTRACE_H
+
+#include <linux/compiler.h>     /* For __user */
+#include <asm/ptrace-abi.h>
+
+#ifndef __ASSEMBLY__
+
+#ifdef __i386__
+/* this struct defines the way the registers are stored on the
+   stack during a system call. */
+
+struct pt_regs {
+        long ebx;
+        long ecx;
+        long edx;
+        long esi;
+        long edi;
+        long ebp;
+        long eax;
+        int  xds;
+        int  xes;
+        int  xfs;
+        /* int  xgs; */
+        long orig_eax;
+        long eip;
+        int  xcs;
+        long eflags;
+        long esp;
+        int  xss;
+};
+
 #ifdef __KERNEL__
-# ifdef CONFIG_X86_32
-#  include "ptrace_32.h"
-# else
-#  include "ptrace_64.h"
-# endif
-#else
-# ifdef __i386__
-#  include "ptrace_32.h"
-# else
-#  include "ptrace_64.h"
-# endif
+
+#include <asm/vm86.h>
+#include <asm/segment.h>
+
+struct task_struct;
+extern void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs, int error_code);
+
+/*
+ * user_mode_vm(regs) determines whether a register set came from user mode.
+ * This is true if V8086 mode was enabled OR if the register set was from
+ * protected mode with RPL-3 CS value.  This tricky test checks that with
+ * one comparison.  Many places in the kernel can bypass this full check
+ * if they have already ruled out V8086 mode, so user_mode(regs) can be used.
+ */
+static inline int user_mode(struct pt_regs *regs)
+{
+        return (regs->xcs & SEGMENT_RPL_MASK) == USER_RPL;
+}
+static inline int user_mode_vm(struct pt_regs *regs)
+{
+        return ((regs->xcs & SEGMENT_RPL_MASK) | (regs->eflags & VM_MASK)) >= USER_RPL;
+}
+static inline int v8086_mode(struct pt_regs *regs)
+{
+        return (regs->eflags & VM_MASK);
+}
+
+#define instruction_pointer(regs) ((regs)->eip)
+#define frame_pointer(regs) ((regs)->ebp)
+#define stack_pointer(regs) ((regs)->esp)
+#define regs_return_value(regs) ((regs)->eax)
+
+extern unsigned long profile_pc(struct pt_regs *regs);
+#endif /* __KERNEL__ */
+
+#else /* __i386__ */
+
+struct pt_regs {
+        unsigned long r15;
+        unsigned long r14;
+        unsigned long r13;
+        unsigned long r12;
+        unsigned long rbp;
+        unsigned long rbx;
+/* arguments: non interrupts/non tracing syscalls only save upto here*/
+        unsigned long r11;
+        unsigned long r10;
+        unsigned long r9;
+        unsigned long r8;
+        unsigned long rax;
+        unsigned long rcx;
+        unsigned long rdx;
+        unsigned long rsi;
+        unsigned long rdi;
+        unsigned long orig_rax;
+/* end of arguments */
+/* cpu exception frame or undefined */
+        unsigned long rip;
+        unsigned long cs;
+        unsigned long eflags;
+        unsigned long rsp;
+        unsigned long ss;
+/* top of stack page */
+};
+
+#ifdef __KERNEL__
+
+#define user_mode(regs) (!!((regs)->cs & 3))
+#define user_mode_vm(regs) user_mode(regs)
+#define instruction_pointer(regs) ((regs)->rip)
+#define frame_pointer(regs) ((regs)->rbp)
+#define stack_pointer(regs) ((regs)->rsp)
+#define regs_return_value(regs) ((regs)->rax)
+
+extern unsigned long profile_pc(struct pt_regs *regs);
+void signal_fault(struct pt_regs *regs, void __user *frame, char *where);
+
+struct task_struct;
+
+extern unsigned long
+convert_rip_to_linear(struct task_struct *child, struct pt_regs *regs);
+
+enum {
+        EF_CF   = 0x00000001,
+        EF_PF   = 0x00000004,
+        EF_AF   = 0x00000010,
+        EF_ZF   = 0x00000040,
+        EF_SF   = 0x00000080,
+        EF_TF   = 0x00000100,
+        EF_IE   = 0x00000200,
+        EF_DF   = 0x00000400,
+        EF_OF   = 0x00000800,
+        EF_IOPL = 0x00003000,
+        EF_IOPL_RING0 = 0x00000000,
+        EF_IOPL_RING1 = 0x00001000,
+        EF_IOPL_RING2 = 0x00002000,
+        EF_NT   = 0x00004000,   /* nested task */
+        EF_RF   = 0x00010000,   /* resume */
+        EF_VM   = 0x00020000,   /* virtual mode */
+        EF_AC   = 0x00040000,   /* alignment */
+        EF_VIF  = 0x00080000,   /* virtual interrupt */
+        EF_VIP  = 0x00100000,   /* virtual interrupt pending */
+        EF_ID   = 0x00200000,   /* id */
+};
+#endif /* __KERNEL__ */
+#endif /* !__i386__ */
+#endif /* !__ASSEMBLY__ */
+
 #endif
diff --git a/include/asm-x86/ptrace_32.h b/include/asm-x86/ptrace_32.h
deleted file mode 100644
index 78d063dabe0a..000000000000
--- a/include/asm-x86/ptrace_32.h
+++ /dev/null
@@ -1,65 +0,0 @@
-#ifndef _I386_PTRACE_H
-#define _I386_PTRACE_H
-
-#include <asm/ptrace-abi.h>
-
-/* this struct defines the way the registers are stored on the 
-   stack during a system call. */
-
-struct pt_regs {
-        long ebx;
-        long ecx;
-        long edx;
-        long esi;
-        long edi;
-        long ebp;
-        long eax;
-        int  xds;
-        int  xes;
-        int  xfs;
-        /* int  xgs; */
-        long orig_eax;
-        long eip;
-        int  xcs;
-        long eflags;
-        long esp;
-        int  xss;
-};
-
-#ifdef __KERNEL__
-
-#include <asm/vm86.h>
-#include <asm/segment.h>
-
-struct task_struct;
-extern void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs, int error_code);
-
-/*
- * user_mode_vm(regs) determines whether a register set came from user mode.
- * This is true if V8086 mode was enabled OR if the register set was from
- * protected mode with RPL-3 CS value.  This tricky test checks that with
- * one comparison.  Many places in the kernel can bypass this full check
- * if they have already ruled out V8086 mode, so user_mode(regs) can be used.
- */
-static inline int user_mode(struct pt_regs *regs)
-{
-        return (regs->xcs & SEGMENT_RPL_MASK) == USER_RPL;
-}
-static inline int user_mode_vm(struct pt_regs *regs)
-{
-        return ((regs->xcs & SEGMENT_RPL_MASK) | (regs->eflags & VM_MASK)) >= USER_RPL;
-}
-static inline int v8086_mode(struct pt_regs *regs)
-{
-        return (regs->eflags & VM_MASK);
-}
-
-#define instruction_pointer(regs) ((regs)->eip)
-#define frame_pointer(regs) ((regs)->ebp)
-#define stack_pointer(regs) ((regs)->esp)
-#define regs_return_value(regs) ((regs)->eax)
-
-extern unsigned long profile_pc(struct pt_regs *regs);
-#endif /* __KERNEL__ */
-
-#endif
diff --git a/include/asm-x86/ptrace_64.h b/include/asm-x86/ptrace_64.h
deleted file mode 100644
index 7bfe61e1b705..000000000000
--- a/include/asm-x86/ptrace_64.h
+++ /dev/null
@@ -1,80 +0,0 @@
-#ifndef _X86_64_PTRACE_H
-#define _X86_64_PTRACE_H
-
-#include <linux/compiler.h>     /* For __user */
-#include <asm/ptrace-abi.h>
-
-#ifndef __ASSEMBLY__
-
-struct pt_regs {
-        unsigned long r15;
-        unsigned long r14;
-        unsigned long r13;
-        unsigned long r12;
-        unsigned long rbp;
-        unsigned long rbx;
-/* arguments: non interrupts/non tracing syscalls only save upto here*/
-        unsigned long r11;
-        unsigned long r10;
-        unsigned long r9;
-        unsigned long r8;
-        unsigned long rax;
-        unsigned long rcx;
-        unsigned long rdx;
-        unsigned long rsi;
-        unsigned long rdi;
-        unsigned long orig_rax;
-/* end of arguments */
-/* cpu exception frame or undefined */
-        unsigned long rip;
-        unsigned long cs;
-        unsigned long eflags;
-        unsigned long rsp;
-        unsigned long ss;
-/* top of stack page */
-};
-
-#endif
-
-#if defined(__KERNEL__) && !defined(__ASSEMBLY__) 
-#define user_mode(regs) (!!((regs)->cs & 3))
-#define user_mode_vm(regs) user_mode(regs)
-#define instruction_pointer(regs) ((regs)->rip)
-#define frame_pointer(regs) ((regs)->rbp)
-#define stack_pointer(regs) ((regs)->rsp)
-#define regs_return_value(regs) ((regs)->rax)
-
-extern unsigned long profile_pc(struct pt_regs *regs);
-void signal_fault(struct pt_regs *regs, void __user *frame, char *where);
-
-struct task_struct;
-
-extern unsigned long
-convert_rip_to_linear(struct task_struct *child, struct pt_regs *regs);
-
-enum {
-        EF_CF   = 0x00000001,
-        EF_PF   = 0x00000004,
-        EF_AF   = 0x00000010,
-        EF_ZF   = 0x00000040,
-        EF_SF   = 0x00000080,
-        EF_TF   = 0x00000100,
-        EF_IE   = 0x00000200,
-        EF_DF   = 0x00000400,
-        EF_OF   = 0x00000800,
-        EF_IOPL = 0x00003000,
-        EF_IOPL_RING0 = 0x00000000,
-        EF_IOPL_RING1 = 0x00001000,
-        EF_IOPL_RING2 = 0x00002000,
-        EF_NT   = 0x00004000,   /* nested task */
-        EF_RF   = 0x00010000,   /* resume */
-        EF_VM   = 0x00020000,   /* virtual mode */
-        EF_AC   = 0x00040000,   /* alignment */
-        EF_VIF  = 0x00080000,   /* virtual interrupt */
-        EF_VIP  = 0x00100000,   /* virtual interrupt pending */
-        EF_ID   = 0x00200000,   /* id */
-};
-
-#endif
-
-#endif
diff --git a/include/asm-x86/required-features.h b/include/asm-x86/required-features.h
index 8b64f3ea2b78..7400d3ad75c6 100644
--- a/include/asm-x86/required-features.h
+++ b/include/asm-x86/required-features.h
@@ -1,5 +1,72 @@
-#ifdef CONFIG_X86_32
-# include "required-features_32.h"
+#ifndef _ASM_REQUIRED_FEATURES_H
+#define _ASM_REQUIRED_FEATURES_H 1
+
+/* Define minimum CPUID feature set for kernel These bits are checked
+   really early to actually display a visible error message before the
+   kernel dies.  Make sure to assign features to the proper mask!
+
+   Some requirements that are not in CPUID yet are also in the
+   CONFIG_X86_MINIMUM_CPU_FAMILY which is checked too.
+
+   The real information is in arch/x86/Kconfig.cpu, this just converts
+   the CONFIGs into a bitmask */
+
+#ifndef CONFIG_MATH_EMULATION
+# define NEED_FPU       (1<<(X86_FEATURE_FPU & 31))
 #else
-# include "required-features_64.h"
+# define NEED_FPU       0
+#endif
+
+#if defined(CONFIG_X86_PAE) || defined(CONFIG_X86_64)
+# define NEED_PAE       (1<<(X86_FEATURE_PAE & 31))
+# define NEED_CX8       (1<<(X86_FEATURE_CX8 & 31))
+#else
+# define NEED_PAE       0
+# define NEED_CX8       0
+#endif
+
+#if defined(CONFIG_X86_CMOV) || defined(CONFIG_X86_64)
+# define NEED_CMOV      (1<<(X86_FEATURE_CMOV & 31))
+#else
+# define NEED_CMOV      0
+#endif
+
+#ifdef CONFIG_X86_USE_3DNOW
+# define NEED_3DNOW     (1<<(X86_FEATURE_3DNOW & 31))
+#else
+# define NEED_3DNOW     0
+#endif
+
+#ifdef CONFIG_X86_64
+#define NEED_PSE        (1<<(X86_FEATURE_PSE & 31))
+#define NEED_MSR        (1<<(X86_FEATURE_MSR & 31))
+#define NEED_PGE        (1<<(X86_FEATURE_PGE & 31))
+#define NEED_FXSR       (1<<(X86_FEATURE_FXSR & 31))
+#define NEED_XMM        (1<<(X86_FEATURE_XMM & 31))
+#define NEED_XMM2       (1<<(X86_FEATURE_XMM2 & 31))
+#define NEED_LM         (1<<(X86_FEATURE_LM & 31))
+#else
+#define NEED_PSE        0
+#define NEED_MSR        0
+#define NEED_PGE        0
+#define NEED_FXSR       0
+#define NEED_XMM        0
+#define NEED_XMM2       0
+#define NEED_LM         0
+#endif
+
+#define REQUIRED_MASK0  (NEED_FPU|NEED_PSE|NEED_MSR|NEED_PAE|\
+                         NEED_CX8|NEED_PGE|NEED_FXSR|NEED_CMOV|\
+                         NEED_XMM|NEED_XMM2)
+#define SSE_MASK        (NEED_XMM|NEED_XMM2)
+
+#define REQUIRED_MASK1  (NEED_LM|NEED_3DNOW)
+
+#define REQUIRED_MASK2  0
+#define REQUIRED_MASK3  0
+#define REQUIRED_MASK4  0
+#define REQUIRED_MASK5  0
+#define REQUIRED_MASK6  0
+#define REQUIRED_MASK7  0
+
 #endif
diff --git a/include/asm-x86/required-features_32.h b/include/asm-x86/required-features_32.h
deleted file mode 100644
index 618feb98f9f5..000000000000
--- a/include/asm-x86/required-features_32.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifndef _ASM_REQUIRED_FEATURES_H
-#define _ASM_REQUIRED_FEATURES_H 1
-
-/* Define minimum CPUID feature set for kernel These bits are checked
-   really early to actually display a visible error message before the
-   kernel dies.  Make sure to assign features to the proper mask!
-
-   Some requirements that are not in CPUID yet are also in the
-   CONFIG_X86_MINIMUM_CPU_FAMILY which is checked too.
-
-   The real information is in arch/i386/Kconfig.cpu, this just converts
-   the CONFIGs into a bitmask */
-
-#ifndef CONFIG_MATH_EMULATION
-# define NEED_FPU       (1<<(X86_FEATURE_FPU & 31))
-#else
-# define NEED_FPU       0
-#endif
-
-#ifdef CONFIG_X86_PAE
-# define NEED_PAE       (1<<(X86_FEATURE_PAE & 31))
-#else
-# define NEED_PAE       0
-#endif
-
-#ifdef CONFIG_X86_CMOV
-# define NEED_CMOV      (1<<(X86_FEATURE_CMOV & 31))
-#else
-# define NEED_CMOV      0
-#endif
-
-#ifdef CONFIG_X86_PAE
-# define NEED_CX8       (1<<(X86_FEATURE_CX8 & 31))
-#else
-# define NEED_CX8       0
-#endif
-
-#define REQUIRED_MASK0  (NEED_FPU|NEED_PAE|NEED_CMOV|NEED_CX8)
-
-#ifdef CONFIG_X86_USE_3DNOW
-# define NEED_3DNOW     (1<<(X86_FEATURE_3DNOW & 31))
-#else
-# define NEED_3DNOW     0
-#endif
-
-#define REQUIRED_MASK1  (NEED_3DNOW)
-
-#define REQUIRED_MASK2  0
-#define REQUIRED_MASK3  0
-#define REQUIRED_MASK4  0
-#define REQUIRED_MASK5  0
-#define REQUIRED_MASK6  0
-#define REQUIRED_MASK7  0
-
-#endif
diff --git a/include/asm-x86/required-features_64.h b/include/asm-x86/required-features_64.h
deleted file mode 100644
index e80d5761b00a..000000000000
--- a/include/asm-x86/required-features_64.h
+++ /dev/null
@@ -1,46 +0,0 @@
-#ifndef _ASM_REQUIRED_FEATURES_H
-#define _ASM_REQUIRED_FEATURES_H 1
-
-/* Define minimum CPUID feature set for kernel These bits are checked
-   really early to actually display a visible error message before the
-   kernel dies.  Make sure to assign features to the proper mask!
-
-   The real information is in arch/x86_64/Kconfig.cpu, this just converts
-   the CONFIGs into a bitmask */
-
-/* x86-64 baseline features */
-#define NEED_FPU        (1<<(X86_FEATURE_FPU & 31))
-#define NEED_PSE        (1<<(X86_FEATURE_PSE & 31))
-#define NEED_MSR        (1<<(X86_FEATURE_MSR & 31))
-#define NEED_PAE        (1<<(X86_FEATURE_PAE & 31))
-#define NEED_CX8        (1<<(X86_FEATURE_CX8 & 31))
-#define NEED_PGE        (1<<(X86_FEATURE_PGE & 31))
-#define NEED_FXSR       (1<<(X86_FEATURE_FXSR & 31))
-#define NEED_CMOV       (1<<(X86_FEATURE_CMOV & 31))
-#define NEED_XMM        (1<<(X86_FEATURE_XMM & 31))
-#define NEED_XMM2       (1<<(X86_FEATURE_XMM2 & 31))
-
-#define REQUIRED_MASK0  (NEED_FPU|NEED_PSE|NEED_MSR|NEED_PAE|\
-                         NEED_CX8|NEED_PGE|NEED_FXSR|NEED_CMOV|\
-                         NEED_XMM|NEED_XMM2)
-#define SSE_MASK        (NEED_XMM|NEED_XMM2)
-
-/* x86-64 baseline features */
-#define NEED_LM         (1<<(X86_FEATURE_LM & 31))
-
-#ifdef CONFIG_X86_USE_3DNOW
-# define NEED_3DNOW     (1<<(X86_FEATURE_3DNOW & 31))
-#else
-# define NEED_3DNOW     0
-#endif
-
-#define REQUIRED_MASK1  (NEED_LM|NEED_3DNOW)
-
-#define REQUIRED_MASK2  0
-#define REQUIRED_MASK3  0
-#define REQUIRED_MASK4  0
-#define REQUIRED_MASK5  0
-#define REQUIRED_MASK6  0
-#define REQUIRED_MASK7  0
-
-#endif
diff --git a/include/asm-x86/setup.h b/include/asm-x86/setup.h
index 81c0d98bb1c8..24d786e07b49 100644
--- a/include/asm-x86/setup.h
+++ b/include/asm-x86/setup.h
@@ -1,13 +1,63 @@
+#ifndef _ASM_X86_SETUP_H
+#define _ASM_X86_SETUP_H
+
+#define COMMAND_LINE_SIZE 2048
+
 #ifdef __KERNEL__
-# ifdef CONFIG_X86_32
-#  include "setup_32.h"
-# else
-#  include "setup_64.h"
-# endif
-#else
-# ifdef __i386__
-#  include "setup_32.h"
-# else
-#  include "setup_64.h"
-# endif
+
+#ifdef __i386__
+
+#include <linux/pfn.h>
+/*
+ * Reserved space for vmalloc and iomap - defined in asm/page.h
+ */
+#define MAXMEM_PFN      PFN_DOWN(MAXMEM)
+#define MAX_NONPAE_PFN  (1 << 20)
+
+#endif /* __i386__ */
+
+#define PARAM_SIZE 4096         /* sizeof(struct boot_params) */
+
+#define OLD_CL_MAGIC            0xA33F
+#define OLD_CL_ADDRESS          0x020   /* Relative to real mode data */
+#define NEW_CL_POINTER          0x228   /* Relative to real mode data */
+
+#ifndef __ASSEMBLY__
+#include <asm/bootparam.h>
+
+#ifndef _SETUP
+
+/*
+ * This is set up by the setup-routine at boot-time
+ */
+extern struct boot_params boot_params;
+
+#ifdef __i386__
+/*
+ * Do NOT EVER look at the BIOS memory size location.
+ * It does not work on many machines.
+ */
+#define LOWMEMSIZE()    (0x9f000)
+
+struct e820entry;
+
+char * __init machine_specific_memory_setup(void);
+char *memory_setup(void);
+
+int __init copy_e820_map(struct e820entry * biosmap, int nr_map);
+int __init sanitize_e820_map(struct e820entry * biosmap, char * pnr_map);
+void __init add_memory_region(unsigned long long start,
+                              unsigned long long size, int type);
+
+extern unsigned long init_pg_tables_end;
+
+#ifndef CONFIG_PARAVIRT
+#define paravirt_post_allocator_init()  do {} while (0)
 #endif
+
+#endif /* __i386__ */
+#endif /* _SETUP */
+#endif /* __ASSEMBLY__ */
+#endif  /*  __KERNEL__  */
+
+#endif /* _ASM_X86_SETUP_H */
diff --git a/include/asm-x86/setup_32.h b/include/asm-x86/setup_32.h
deleted file mode 100644
index 7a57ca8a1793..000000000000
--- a/include/asm-x86/setup_32.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- *      Just a place holder. We don't want to have to test x86 before
- *      we include stuff
- */
-
-#ifndef _i386_SETUP_H
-#define _i386_SETUP_H
-
-#define COMMAND_LINE_SIZE 2048
-
-#ifdef __KERNEL__
-#include <linux/pfn.h>
-
-/*
- * Reserved space for vmalloc and iomap - defined in asm/page.h
- */
-#define MAXMEM_PFN      PFN_DOWN(MAXMEM)
-#define MAX_NONPAE_PFN  (1 << 20)
-
-#define PARAM_SIZE 4096
-
-#define OLD_CL_MAGIC_ADDR       0x90020
-#define OLD_CL_MAGIC            0xA33F
-#define OLD_CL_BASE_ADDR        0x90000
-#define OLD_CL_OFFSET           0x90022
-#define NEW_CL_POINTER          0x228   /* Relative to real mode data */
-
-#ifndef __ASSEMBLY__
-
-#include <asm/bootparam.h>
-
-/*
- * This is set up by the setup-routine at boot-time
- */
-extern struct boot_params boot_params;
-
-/*
- * Do NOT EVER look at the BIOS memory size location.
- * It does not work on many machines.
- */
-#define LOWMEMSIZE()    (0x9f000)
-
-struct e820entry;
-
-char * __init machine_specific_memory_setup(void);
-char *memory_setup(void);
-
-int __init copy_e820_map(struct e820entry * biosmap, int nr_map);
-int __init sanitize_e820_map(struct e820entry * biosmap, char * pnr_map);
-void __init add_memory_region(unsigned long long start,
-                              unsigned long long size, int type);
-
-extern unsigned long init_pg_tables_end;
-
-#ifndef CONFIG_PARAVIRT
-#define paravirt_post_allocator_init()  do {} while (0)
-#endif
-
-#endif /* __ASSEMBLY__ */
-
-#endif  /*  __KERNEL__  */
-
-#endif /* _i386_SETUP_H */
diff --git a/include/asm-x86/setup_64.h b/include/asm-x86/setup_64.h
deleted file mode 100644
index a04aadcccf67..000000000000
--- a/include/asm-x86/setup_64.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#ifndef _x8664_SETUP_H
-#define _x8664_SETUP_H
-
-#define COMMAND_LINE_SIZE       2048
-
-#ifdef __KERNEL__
-
-#ifndef __ASSEMBLY__
-#include <asm/bootparam.h>
-
-/*
- * This is set up by the setup-routine at boot-time
- */
-extern struct boot_params boot_params;
-
-#endif /* not __ASSEMBLY__ */
-#endif /* __KERNEL__ */
-
-#endif
diff --git a/include/asm-x86/shmbuf.h b/include/asm-x86/shmbuf.h
index e85f1cb11217..b51413b74971 100644
--- a/include/asm-x86/shmbuf.h
+++ b/include/asm-x86/shmbuf.h
@@ -1,13 +1,51 @@
-#ifdef __KERNEL__
-# ifdef CONFIG_X86_32
-#  include "shmbuf_32.h"
-# else
-#  include "shmbuf_64.h"
-# endif
-#else
-# ifdef __i386__
-#  include "shmbuf_32.h"
-# else
-#  include "shmbuf_64.h"
-# endif
+#ifndef _ASM_X86_SHMBUF_H
+#define _ASM_X86_SHMBUF_H
+
+/*
+ * The shmid64_ds structure for x86 architecture.
+ * Note extra padding because this structure is passed back and forth
+ * between kernel and user space.
+ *
+ * Pad space on 32 bit is left for:
+ * - 64-bit time_t to solve y2038 problem
+ * - 2 miscellaneous 32-bit values
+ *
+ * Pad space on 64 bit is left for:
+ * - 2 miscellaneous 64-bit values
+ */
+
+struct shmid64_ds {
+        struct ipc64_perm       shm_perm;       /* operation perms */
+        size_t                  shm_segsz;      /* size of segment (bytes) */
+        __kernel_time_t         shm_atime;      /* last attach time */
+#ifdef __i386__
+        unsigned long           __unused1;
 #endif
+        __kernel_time_t         shm_dtime;      /* last detach time */
+#ifdef __i386__
+        unsigned long           __unused2;
+#endif
+        __kernel_time_t         shm_ctime;      /* last change time */
+#ifdef __i386__
+        unsigned long           __unused3;
+#endif
+        __kernel_pid_t          shm_cpid;       /* pid of creator */
+        __kernel_pid_t          shm_lpid;       /* pid of last operator */
+        unsigned long           shm_nattch;     /* no. of current attaches */
+        unsigned long           __unused4;
+        unsigned long           __unused5;
+};
+
+struct shminfo64 {
+        unsigned long   shmmax;
+        unsigned long   shmmin;
+        unsigned long   shmmni;
+        unsigned long   shmseg;
+        unsigned long   shmall;
+        unsigned long   __unused1;
+        unsigned long   __unused2;
+        unsigned long   __unused3;
+        unsigned long   __unused4;
+};
+
+#endif /* _ASM_X86_SHMBUF_H */
diff --git a/include/asm-x86/shmbuf_32.h b/include/asm-x86/shmbuf_32.h
deleted file mode 100644
index d1cdc3cb079b..000000000000
--- a/include/asm-x86/shmbuf_32.h
+++ /dev/null
@@ -1,42 +0,0 @@
-#ifndef _I386_SHMBUF_H
-#define _I386_SHMBUF_H
-
-/* 
- * The shmid64_ds structure for i386 architecture.
- * Note extra padding because this structure is passed back and forth
- * between kernel and user space.
- *
- * Pad space is left for:
- * - 64-bit time_t to solve y2038 problem
- * - 2 miscellaneous 32-bit values
- */
-
-struct shmid64_ds {
-        struct ipc64_perm       shm_perm;       /* operation perms */
-        size_t                  shm_segsz;      /* size of segment (bytes) */
-        __kernel_time_t         shm_atime;      /* last attach time */
-        unsigned long           __unused1;
-        __kernel_time_t         shm_dtime;      /* last detach time */
-        unsigned long           __unused2;
-        __kernel_time_t         shm_ctime;      /* last change time */
-        unsigned long           __unused3;
-        __kernel_pid_t          shm_cpid;       /* pid of creator */
-        __kernel_pid_t          shm_lpid;       /* pid of last operator */
-        unsigned long           shm_nattch;     /* no. of current attaches */
-        unsigned long           __unused4;
-        unsigned long           __unused5;
-};
-
-struct shminfo64 {
-        unsigned long   shmmax;
-        unsigned long   shmmin;
-        unsigned long   shmmni;
-        unsigned long   shmseg;
-        unsigned long   shmall;
-        unsigned long   __unused1;
-        unsigned long   __unused2;
-        unsigned long   __unused3;
-        unsigned long   __unused4;
-};
-
-#endif /* _I386_SHMBUF_H */
diff --git a/include/asm-x86/shmbuf_64.h b/include/asm-x86/shmbuf_64.h
deleted file mode 100644
index 5a6d6dda7c48..000000000000
--- a/include/asm-x86/shmbuf_64.h
+++ /dev/null
@@ -1,38 +0,0 @@
-#ifndef _X8664_SHMBUF_H
-#define _X8664_SHMBUF_H
-
-/* 
- * The shmid64_ds structure for x8664 architecture.
- * Note extra padding because this structure is passed back and forth
- * between kernel and user space.
- *
- * Pad space is left for:
- * - 2 miscellaneous 64-bit values
- */
-
-struct shmid64_ds {
-        struct ipc64_perm       shm_perm;       /* operation perms */
-        size_t                  shm_segsz;      /* size of segment (bytes) */
-        __kernel_time_t         shm_atime;      /* last attach time */
-        __kernel_time_t         shm_dtime;      /* last detach time */
-        __kernel_time_t         shm_ctime;      /* last change time */
-        __kernel_pid_t          shm_cpid;       /* pid of creator */
-        __kernel_pid_t          shm_lpid;       /* pid of last operator */
-        unsigned long           shm_nattch;     /* no. of current attaches */
-        unsigned long           __unused4;
-        unsigned long           __unused5;
-};
-
-struct shminfo64 {
-        unsigned long   shmmax;
-        unsigned long   shmmin;
-        unsigned long   shmmni;
-        unsigned long   shmseg;
-        unsigned long   shmall;
-        unsigned long   __unused1;
-        unsigned long   __unused2;
-        unsigned long   __unused3;
-        unsigned long   __unused4;
-};
-
-#endif
diff --git a/include/asm-x86/sigcontext.h b/include/asm-x86/sigcontext.h
index 0d16ceff1599..c047f9dc3423 100644
--- a/include/asm-x86/sigcontext.h
+++ b/include/asm-x86/sigcontext.h
@@ -1,13 +1,138 @@
-#ifdef __KERNEL__
-# ifdef CONFIG_X86_32
-#  include "sigcontext_32.h"
-# else
-#  include "sigcontext_64.h"
-# endif
-#else
-# ifdef __i386__
-#  include "sigcontext_32.h"
-# else
-#  include "sigcontext_64.h"
-# endif
+#ifndef _ASM_X86_SIGCONTEXT_H
+#define _ASM_X86_SIGCONTEXT_H
+
+#include <linux/compiler.h>
+#include <asm/types.h>
+
+#ifdef __i386__
+/*
+ * As documented in the iBCS2 standard..
+ *
+ * The first part of "struct _fpstate" is just the normal i387
+ * hardware setup, the extra "status" word is used to save the
+ * coprocessor status word before entering the handler.
+ *
+ * Pentium III FXSR, SSE support
+ *      Gareth Hughes <gareth@valinux.com>, May 2000
+ *
+ * The FPU state data structure has had to grow to accommodate the
+ * extended FPU state required by the Streaming SIMD Extensions.
+ * There is no documented standard to accomplish this at the moment.
+ */
+struct _fpreg {
+        unsigned short significand[4];
+        unsigned short exponent;
+};
+
+struct _fpxreg {
+        unsigned short significand[4];
+        unsigned short exponent;
+        unsigned short padding[3];
+};
+
+struct _xmmreg {
+        unsigned long element[4];
+};
+
+struct _fpstate {
+        /* Regular FPU environment */
+        unsigned long   cw;
+        unsigned long   sw;
+        unsigned long   tag;
+        unsigned long   ipoff;
+        unsigned long   cssel;
+        unsigned long   dataoff;
+        unsigned long   datasel;
+        struct _fpreg   _st[8];
+        unsigned short  status;
+        unsigned short  magic;          /* 0xffff = regular FPU data only */
+
+        /* FXSR FPU environment */
+        unsigned long   _fxsr_env[6];   /* FXSR FPU env is ignored */
+        unsigned long   mxcsr;
+        unsigned long   reserved;
+        struct _fpxreg  _fxsr_st[8];    /* FXSR FPU reg data is ignored */
+        struct _xmmreg  _xmm[8];
+        unsigned long   padding[56];
+};
+
+#define X86_FXSR_MAGIC          0x0000
+
+struct sigcontext {
+        unsigned short gs, __gsh;
+        unsigned short fs, __fsh;
+        unsigned short es, __esh;
+        unsigned short ds, __dsh;
+        unsigned long edi;
+        unsigned long esi;
+        unsigned long ebp;
+        unsigned long esp;
+        unsigned long ebx;
+        unsigned long edx;
+        unsigned long ecx;
+        unsigned long eax;
+        unsigned long trapno;
+        unsigned long err;
+        unsigned long eip;
+        unsigned short cs, __csh;
+        unsigned long eflags;
+        unsigned long esp_at_signal;
+        unsigned short ss, __ssh;
+        struct _fpstate __user * fpstate;
+        unsigned long oldmask;
+        unsigned long cr2;
+};
+
+#else /* __i386__ */
+
+/* FXSAVE frame */
+/* Note: reserved1/2 may someday contain valuable data. Always save/restore
+   them when you change signal frames. */
+struct _fpstate {
+        __u16   cwd;
+        __u16   swd;
+        __u16   twd;    /* Note this is not the same as the 32bit/x87/FSAVE twd */
+        __u16   fop;
+        __u64   rip;
+        __u64   rdp;
+        __u32   mxcsr;
+        __u32   mxcsr_mask;
+        __u32   st_space[32];   /* 8*16 bytes for each FP-reg */
+        __u32   xmm_space[64];  /* 16*16 bytes for each XMM-reg  */
+        __u32   reserved2[24];
+};
+
+struct sigcontext {
+        unsigned long r8;
+        unsigned long r9;
+        unsigned long r10;
+        unsigned long r11;
+        unsigned long r12;
+        unsigned long r13;
+        unsigned long r14;
+        unsigned long r15;
+        unsigned long rdi;
+        unsigned long rsi;
+        unsigned long rbp;
+        unsigned long rbx;
+        unsigned long rdx;
+        unsigned long rax;
+        unsigned long rcx;
+        unsigned long rsp;
+        unsigned long rip;
+        unsigned long eflags;           /* RFLAGS */
+        unsigned short cs;
+        unsigned short gs;
+        unsigned short fs;
+        unsigned short __pad0;
+        unsigned long err;
+        unsigned long trapno;
+        unsigned long oldmask;
+        unsigned long cr2;
+        struct _fpstate __user *fpstate;        /* zero when no FPU context */
+        unsigned long reserved1[8];
+};
+
+#endif /* !__i386__ */
+
 #endif
diff --git a/include/asm-x86/sigcontext_32.h b/include/asm-x86/sigcontext_32.h
deleted file mode 100644
index aaef089a7787..000000000000
--- a/include/asm-x86/sigcontext_32.h
+++ /dev/null
@@ -1,85 +0,0 @@
-#ifndef _ASMi386_SIGCONTEXT_H
-#define _ASMi386_SIGCONTEXT_H
-
-#include <linux/compiler.h>
-
-/*
- * As documented in the iBCS2 standard..
- *
- * The first part of "struct _fpstate" is just the normal i387
- * hardware setup, the extra "status" word is used to save the
- * coprocessor status word before entering the handler.
- *
- * Pentium III FXSR, SSE support
- *      Gareth Hughes <gareth@valinux.com>, May 2000
- *
- * The FPU state data structure has had to grow to accommodate the
- * extended FPU state required by the Streaming SIMD Extensions.
- * There is no documented standard to accomplish this at the moment.
- */
-struct _fpreg {
-        unsigned short significand[4];
-        unsigned short exponent;
-};
-
-struct _fpxreg {
-        unsigned short significand[4];
-        unsigned short exponent;
-        unsigned short padding[3];
-};
-
-struct _xmmreg {
-        unsigned long element[4];
-};
-
-struct _fpstate {
-        /* Regular FPU environment */
-        unsigned long   cw;
-        unsigned long   sw;
-        unsigned long   tag;
-        unsigned long   ipoff;
-        unsigned long   cssel;
-        unsigned long   dataoff;
-        unsigned long   datasel;
-        struct _fpreg   _st[8];
-        unsigned short  status;
-        unsigned short  magic;          /* 0xffff = regular FPU data only */
-
-        /* FXSR FPU environment */
-        unsigned long   _fxsr_env[6];   /* FXSR FPU env is ignored */
-        unsigned long   mxcsr;
-        unsigned long   reserved;
-        struct _fpxreg  _fxsr_st[8];    /* FXSR FPU reg data is ignored */
-        struct _xmmreg  _xmm[8];
-        unsigned long   padding[56];
-};
-
-#define X86_FXSR_MAGIC          0x0000
-
-struct sigcontext {
-        unsigned short gs, __gsh;
-        unsigned short fs, __fsh;
-        unsigned short es, __esh;
-        unsigned short ds, __dsh;
-        unsigned long edi;
-        unsigned long esi;
-        unsigned long ebp;
-        unsigned long esp;
-        unsigned long ebx;
-        unsigned long edx;
-        unsigned long ecx;
-        unsigned long eax;
-        unsigned long trapno;
-        unsigned long err;
-        unsigned long eip;
-        unsigned short cs, __csh;
-        unsigned long eflags;
-        unsigned long esp_at_signal;
-        unsigned short ss, __ssh;
-        struct _fpstate __user * fpstate;
-        unsigned long oldmask;
-        unsigned long cr2;
-};
-
-
-#endif
diff --git a/include/asm-x86/sigcontext_64.h b/include/asm-x86/sigcontext_64.h
deleted file mode 100644
index b4e40236666c..000000000000
--- a/include/asm-x86/sigcontext_64.h
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifndef _ASM_X86_64_SIGCONTEXT_H
-#define _ASM_X86_64_SIGCONTEXT_H
-
-#include <asm/types.h>
-#include <linux/compiler.h>
-
-/* FXSAVE frame */
-/* Note: reserved1/2 may someday contain valuable data. Always save/restore
-   them when you change signal frames. */
-struct _fpstate {
-        __u16   cwd;
-        __u16   swd;
-        __u16   twd;    /* Note this is not the same as the 32bit/x87/FSAVE twd */
-        __u16   fop;
-        __u64   rip;
-        __u64   rdp; 
-        __u32   mxcsr;
-        __u32   mxcsr_mask;
-        __u32   st_space[32];   /* 8*16 bytes for each FP-reg */
-        __u32   xmm_space[64];  /* 16*16 bytes for each XMM-reg  */
-        __u32   reserved2[24];
-};
-
-struct sigcontext { 
-        unsigned long r8;
-        unsigned long r9;
-        unsigned long r10;
-        unsigned long r11;
-        unsigned long r12;
-        unsigned long r13;
-        unsigned long r14;
-        unsigned long r15;
-        unsigned long rdi;
-        unsigned long rsi;
-        unsigned long rbp;
-        unsigned long rbx;
-        unsigned long rdx;
-        unsigned long rax;
-        unsigned long rcx;
-        unsigned long rsp;
-        unsigned long rip;
-        unsigned long eflags;           /* RFLAGS */
-        unsigned short cs;
-        unsigned short gs;
-        unsigned short fs;
-        unsigned short __pad0; 
-        unsigned long err;
-        unsigned long trapno;
-        unsigned long oldmask;
-        unsigned long cr2;
-        struct _fpstate __user *fpstate;        /* zero when no FPU context */
-        unsigned long reserved1[8];
-};
-
-#endif
diff --git a/include/asm-x86/signal.h b/include/asm-x86/signal.h
index bf5a63f457da..987a422a2c78 100644
--- a/include/asm-x86/signal.h
+++ b/include/asm-x86/signal.h
@@ -1,13 +1,266 @@
+#ifndef _ASM_X86_SIGNAL_H
+#define _ASM_X86_SIGNAL_H
+
+#ifndef __ASSEMBLY__
+#include <linux/types.h>
+#include <linux/time.h>
+#include <linux/compiler.h>
+
+/* Avoid too many header ordering problems.  */
+struct siginfo;
+
 #ifdef __KERNEL__
-# ifdef CONFIG_X86_32
-#  include "signal_32.h"
-# else
-#  include "signal_64.h"
-# endif
+#include <linux/linkage.h>
+
+/* Most things should be clean enough to redefine this at will, if care
+   is taken to make libc match.  */
+
+#define _NSIG           64
+
+#ifdef __i386__
+# define _NSIG_BPW      32
 #else
-# ifdef __i386__
-#  include "signal_32.h"
-# else
-#  include "signal_64.h"
-# endif
+# define _NSIG_BPW      64
+#endif
+
+#define _NSIG_WORDS     (_NSIG / _NSIG_BPW)
+
+typedef unsigned long old_sigset_t;             /* at least 32 bits */
+
+typedef struct {
+        unsigned long sig[_NSIG_WORDS];
+} sigset_t;
+
+#else
+/* Here we must cater to libcs that poke about in kernel headers.  */
+
+#define NSIG            32
+typedef unsigned long sigset_t;
+
+#endif /* __KERNEL__ */
+#endif /* __ASSEMBLY__ */
+
+#define SIGHUP           1
+#define SIGINT           2
+#define SIGQUIT          3
+#define SIGILL           4
+#define SIGTRAP          5
+#define SIGABRT          6
+#define SIGIOT           6
+#define SIGBUS           7
+#define SIGFPE           8
+#define SIGKILL          9
+#define SIGUSR1         10
+#define SIGSEGV         11
+#define SIGUSR2         12
+#define SIGPIPE         13
+#define SIGALRM         14
+#define SIGTERM         15
+#define SIGSTKFLT       16
+#define SIGCHLD         17
+#define SIGCONT         18
+#define SIGSTOP         19
+#define SIGTSTP         20
+#define SIGTTIN         21
+#define SIGTTOU         22
+#define SIGURG          23
+#define SIGXCPU         24
+#define SIGXFSZ         25
+#define SIGVTALRM       26
+#define SIGPROF         27
+#define SIGWINCH        28
+#define SIGIO           29
+#define SIGPOLL         SIGIO
+/*
+#define SIGLOST         29
+*/
+#define SIGPWR          30
+#define SIGSYS          31
+#define SIGUNUSED       31
+
+/* These should not be considered constants from userland.  */
+#define SIGRTMIN        32
+#define SIGRTMAX        _NSIG
+
+/*
+ * SA_FLAGS values:
+ *
+ * SA_ONSTACK indicates that a registered stack_t will be used.
+ * SA_RESTART flag to get restarting signals (which were the default long ago)
+ * SA_NOCLDSTOP flag to turn off SIGCHLD when children stop.
+ * SA_RESETHAND clears the handler when the signal is delivered.
+ * SA_NOCLDWAIT flag on SIGCHLD to inhibit zombies.
+ * SA_NODEFER prevents the current signal from being masked in the handler.
+ *
+ * SA_ONESHOT and SA_NOMASK are the historical Linux names for the Single
+ * Unix names RESETHAND and NODEFER respectively.
+ */
+#define SA_NOCLDSTOP    0x00000001u
+#define SA_NOCLDWAIT    0x00000002u
+#define SA_SIGINFO      0x00000004u
+#define SA_ONSTACK      0x08000000u
+#define SA_RESTART      0x10000000u
+#define SA_NODEFER      0x40000000u
+#define SA_RESETHAND    0x80000000u
+
+#define SA_NOMASK       SA_NODEFER
+#define SA_ONESHOT      SA_RESETHAND
+
+#define SA_RESTORER     0x04000000
+
+/*
+ * sigaltstack controls
+ */
+#define SS_ONSTACK      1
+#define SS_DISABLE      2
+
+#define MINSIGSTKSZ     2048
+#define SIGSTKSZ        8192
+
+#include <asm-generic/signal.h>
+
+#ifndef __ASSEMBLY__
+
+#ifdef __i386__
+# ifdef __KERNEL__
+struct old_sigaction {
+        __sighandler_t sa_handler;
+        old_sigset_t sa_mask;
+        unsigned long sa_flags;
+        __sigrestore_t sa_restorer;
+};
+
+struct sigaction {
+        __sighandler_t sa_handler;
+        unsigned long sa_flags;
+        __sigrestore_t sa_restorer;
+        sigset_t sa_mask;               /* mask last for extensibility */
+};
+
+struct k_sigaction {
+        struct sigaction sa;
+};
+# else /* __KERNEL__ */
+/* Here we must cater to libcs that poke about in kernel headers.  */
+
+struct sigaction {
+        union {
+          __sighandler_t _sa_handler;
+          void (*_sa_sigaction)(int, struct siginfo *, void *);
+        } _u;
+        sigset_t sa_mask;
+        unsigned long sa_flags;
+        void (*sa_restorer)(void);
+};
+
+#define sa_handler      _u._sa_handler
+#define sa_sigaction    _u._sa_sigaction
+
+# endif /* ! __KERNEL__ */
+#else /* __i386__ */
+
+struct sigaction {
+        __sighandler_t sa_handler;
+        unsigned long sa_flags;
+        __sigrestore_t sa_restorer;
+        sigset_t sa_mask;               /* mask last for extensibility */
+};
+
+struct k_sigaction {
+        struct sigaction sa;
+};
+
+#endif /* !__i386__ */
+
+typedef struct sigaltstack {
+        void __user *ss_sp;
+        int ss_flags;
+        size_t ss_size;
+} stack_t;
+
+#ifdef __KERNEL__
+#include <asm/sigcontext.h>
+
+#ifdef __386__
+
+#define __HAVE_ARCH_SIG_BITOPS
+
+#define sigaddset(set,sig)                 \
+        (__builtin_constantp(sig) ?        \
+         __const_sigaddset((set),(sig)) :  \
+         __gen_sigaddset((set),(sig)))
+
+static __inline__ void __gen_sigaddset(sigset_t *set, int _sig)
+{
+        __asm__("btsl %1,%0" : "+m"(*set) : "Ir"(_sig - 1) : "cc");
+}
+
+static __inline__ void __const_sigaddset(sigset_t *set, int _sig)
+{
+        unsigned long sig = _sig - 1;
+        set->sig[sig / _NSIG_BPW] |= 1 << (sig % _NSIG_BPW);
+}
+
+#define sigdelset(set,sig)                 \
+        (__builtin_constant_p(sig) ?       \
+         __const_sigdelset((set),(sig)) :  \
+         __gen_sigdelset((set),(sig)))
+
+
+static __inline__ void __gen_sigdelset(sigset_t *set, int _sig)
+{
+        __asm__("btrl %1,%0" : "+m"(*set) : "Ir"(_sig - 1) : "cc");
+}
+
+static __inline__ void __const_sigdelset(sigset_t *set, int _sig)
+{
+        unsigned long sig = _sig - 1;
+        set->sig[sig / _NSIG_BPW] &= ~(1 << (sig % _NSIG_BPW));
+}
+
+static __inline__ int __const_sigismember(sigset_t *set, int _sig)
+{
+        unsigned long sig = _sig - 1;
+        return 1 & (set->sig[sig / _NSIG_BPW] >> (sig % _NSIG_BPW));
+}
+
+static __inline__ int __gen_sigismember(sigset_t *set, int _sig)
+{
+        int ret;
+        __asm__("btl %2,%1\n\tsbbl %0,%0"
+                : "=r"(ret) : "m"(*set), "Ir"(_sig-1) : "cc");
+        return ret;
+}
+
+#define sigismember(set,sig)                    \
+        (__builtin_constant_p(sig) ?            \
+         __const_sigismember((set),(sig)) :     \
+         __gen_sigismember((set),(sig)))
+
+static __inline__ int sigfindinword(unsigned long word)
+{
+        __asm__("bsfl %1,%0" : "=r"(word) : "rm"(word) : "cc");
+        return word;
+}
+
+struct pt_regs;
+
+#define ptrace_signal_deliver(regs, cookie)             \
+        do {                                            \
+                if (current->ptrace & PT_DTRACE) {      \
+                        current->ptrace &= ~PT_DTRACE;  \
+                        (regs)->eflags &= ~TF_MASK;     \
+                }                                       \
+        } while (0)
+
+#else /* __i386__ */
+
+#undef __HAVE_ARCH_SIG_BITOPS
+
+#define ptrace_signal_deliver(regs, cookie) do { } while (0)
+
+#endif /* !__i386__ */
+#endif /* __KERNEL__ */
+#endif /* __ASSEMBLY__ */
+
 #endif
diff --git a/include/asm-x86/signal_32.h b/include/asm-x86/signal_32.h
deleted file mode 100644
index c3e8adec5918..000000000000
--- a/include/asm-x86/signal_32.h
+++ /dev/null
@@ -1,232 +0,0 @@
-#ifndef _ASMi386_SIGNAL_H
-#define _ASMi386_SIGNAL_H
-
-#include <linux/types.h>
-#include <linux/time.h>
-#include <linux/compiler.h>
-
-/* Avoid too many header ordering problems.  */
-struct siginfo;
-
-#ifdef __KERNEL__
-
-#include <linux/linkage.h>
-
-/* Most things should be clean enough to redefine this at will, if care
-   is taken to make libc match.  */
-
-#define _NSIG           64
-#define _NSIG_BPW       32
-#define _NSIG_WORDS     (_NSIG / _NSIG_BPW)
-
-typedef unsigned long old_sigset_t;             /* at least 32 bits */
-
-typedef struct {
-        unsigned long sig[_NSIG_WORDS];
-} sigset_t;
-
-#else
-/* Here we must cater to libcs that poke about in kernel headers.  */
-
-#define NSIG            32
-typedef unsigned long sigset_t;
-
-#endif /* __KERNEL__ */
-
-#define SIGHUP           1
-#define SIGINT           2
-#define SIGQUIT          3
-#define SIGILL           4
-#define SIGTRAP          5
-#define SIGABRT          6
-#define SIGIOT           6
-#define SIGBUS           7
-#define SIGFPE           8
-#define SIGKILL          9
-#define SIGUSR1         10
-#define SIGSEGV         11
-#define SIGUSR2         12
-#define SIGPIPE         13
-#define SIGALRM         14
-#define SIGTERM         15
-#define SIGSTKFLT       16
-#define SIGCHLD         17
-#define SIGCONT         18
-#define SIGSTOP         19
-#define SIGTSTP         20
-#define SIGTTIN         21
-#define SIGTTOU         22
-#define SIGURG          23
-#define SIGXCPU         24
-#define SIGXFSZ         25
-#define SIGVTALRM       26
-#define SIGPROF         27
-#define SIGWINCH        28
-#define SIGIO           29
-#define SIGPOLL         SIGIO
-/*
-#define SIGLOST         29
-*/
-#define SIGPWR          30
-#define SIGSYS          31
-#define SIGUNUSED       31
-
-/* These should not be considered constants from userland.  */
-#define SIGRTMIN        32
-#define SIGRTMAX        _NSIG
-
-/*
- * SA_FLAGS values:
- *
- * SA_ONSTACK indicates that a registered stack_t will be used.
- * SA_RESTART flag to get restarting signals (which were the default long ago)
- * SA_NOCLDSTOP flag to turn off SIGCHLD when children stop.
- * SA_RESETHAND clears the handler when the signal is delivered.
- * SA_NOCLDWAIT flag on SIGCHLD to inhibit zombies.
- * SA_NODEFER prevents the current signal from being masked in the handler.
- *
- * SA_ONESHOT and SA_NOMASK are the historical Linux names for the Single
- * Unix names RESETHAND and NODEFER respectively.
- */
-#define SA_NOCLDSTOP    0x00000001u
-#define SA_NOCLDWAIT    0x00000002u
-#define SA_SIGINFO      0x00000004u
-#define SA_ONSTACK      0x08000000u
-#define SA_RESTART      0x10000000u
-#define SA_NODEFER      0x40000000u
-#define SA_RESETHAND    0x80000000u
-
-#define SA_NOMASK       SA_NODEFER
-#define SA_ONESHOT      SA_RESETHAND
-
-#define SA_RESTORER     0x04000000
-
-/* 
- * sigaltstack controls
- */
-#define SS_ONSTACK      1
-#define SS_DISABLE      2
-
-#define MINSIGSTKSZ     2048
-#define SIGSTKSZ        8192
-
-#include <asm-generic/signal.h>
-
-#ifdef __KERNEL__
-struct old_sigaction {
-        __sighandler_t sa_handler;
-        old_sigset_t sa_mask;
-        unsigned long sa_flags;
-        __sigrestore_t sa_restorer;
-};
-
-struct sigaction {
-        __sighandler_t sa_handler;
-        unsigned long sa_flags;
-        __sigrestore_t sa_restorer;
-        sigset_t sa_mask;               /* mask last for extensibility */
-};
-
-struct k_sigaction {
-        struct sigaction sa;
-};
-#else
-/* Here we must cater to libcs that poke about in kernel headers.  */
-
-struct sigaction {
-        union {
-          __sighandler_t _sa_handler;
-          void (*_sa_sigaction)(int, struct siginfo *, void *);
-        } _u;
-        sigset_t sa_mask;
-        unsigned long sa_flags;
-        void (*sa_restorer)(void);
-};
-
-#define sa_handler      _u._sa_handler
-#define sa_sigaction    _u._sa_sigaction
-
-#endif /* __KERNEL__ */
-
-typedef struct sigaltstack {
-        void __user *ss_sp;
-        int ss_flags;
-        size_t ss_size;
-} stack_t;
-
-#ifdef __KERNEL__
-#include <asm/sigcontext.h>
-
-#define __HAVE_ARCH_SIG_BITOPS
-
-#define sigaddset(set,sig)                 \
-        (__builtin_constant_p(sig) ?       \
-        __const_sigaddset((set),(sig)) :   \
-        __gen_sigaddset((set),(sig)))
-
-static __inline__ void __gen_sigaddset(sigset_t *set, int _sig)
-{
-        __asm__("btsl %1,%0" : "+m"(*set) : "Ir"(_sig - 1) : "cc");
-}
-
-static __inline__ void __const_sigaddset(sigset_t *set, int _sig)
-{
-        unsigned long sig = _sig - 1;
-        set->sig[sig / _NSIG_BPW] |= 1 << (sig % _NSIG_BPW);
-}
-
-#define sigdelset(set,sig)                 \
-        (__builtin_constant_p(sig) ?       \
-        __const_sigdelset((set),(sig)) :   \
-        __gen_sigdelset((set),(sig)))
-
-
-static __inline__ void __gen_sigdelset(sigset_t *set, int _sig)
-{
-        __asm__("btrl %1,%0" : "+m"(*set) : "Ir"(_sig - 1) : "cc");
-}
-
-static __inline__ void __const_sigdelset(sigset_t *set, int _sig)
-{
-        unsigned long sig = _sig - 1;
-        set->sig[sig / _NSIG_BPW] &= ~(1 << (sig % _NSIG_BPW));
-}
-
-static __inline__ int __const_sigismember(sigset_t *set, int _sig)
-{
-        unsigned long sig = _sig - 1;
-        return 1 & (set->sig[sig / _NSIG_BPW] >> (sig % _NSIG_BPW));
-}
-
-static __inline__ int __gen_sigismember(sigset_t *set, int _sig)
-{
-        int ret;
-        __asm__("btl %2,%1\n\tsbbl %0,%0"
-                : "=r"(ret) : "m"(*set), "Ir"(_sig-1) : "cc");
-        return ret;
-}
-
-#define sigismember(set,sig)                    \
-        (__builtin_constant_p(sig) ?            \
-         __const_sigismember((set),(sig)) :     \
-         __gen_sigismember((set),(sig)))
-
-static __inline__ int sigfindinword(unsigned long word)
-{
-        __asm__("bsfl %1,%0" : "=r"(word) : "rm"(word) : "cc");
-        return word;
-}
-
-struct pt_regs;
-
-#define ptrace_signal_deliver(regs, cookie)             \
-        do {                                            \
-                if (current->ptrace & PT_DTRACE) {      \
-                        current->ptrace &= ~PT_DTRACE;  \
-                        (regs)->eflags &= ~TF_MASK;     \
-                }                                       \
-        } while (0)
-
-#endif /* __KERNEL__ */
-
-#endif
diff --git a/include/asm-x86/signal_64.h b/include/asm-x86/signal_64.h
deleted file mode 100644
index 4581f978b299..000000000000
--- a/include/asm-x86/signal_64.h
+++ /dev/null
@@ -1,181 +0,0 @@
-#ifndef _ASMx8664_SIGNAL_H
-#define _ASMx8664_SIGNAL_H
-
-#ifndef __ASSEMBLY__
-#include <linux/types.h>
-#include <linux/time.h>
-
-/* Avoid too many header ordering problems.  */
-struct siginfo;
-
-#ifdef __KERNEL__
-#include <linux/linkage.h>
-/* Most things should be clean enough to redefine this at will, if care
-   is taken to make libc match.  */
-
-#define _NSIG           64
-#define _NSIG_BPW       64
-#define _NSIG_WORDS     (_NSIG / _NSIG_BPW)
-
-typedef unsigned long old_sigset_t;             /* at least 32 bits */
-
-typedef struct {
-        unsigned long sig[_NSIG_WORDS];
-} sigset_t;
-
-
-#else
-/* Here we must cater to libcs that poke about in kernel headers.  */
-
-#define NSIG            32
-typedef unsigned long sigset_t;
-
-#endif /* __KERNEL__ */
-#endif
-
-#define SIGHUP           1
-#define SIGINT           2
-#define SIGQUIT          3
-#define SIGILL           4
-#define SIGTRAP          5
-#define SIGABRT          6
-#define SIGIOT           6
-#define SIGBUS           7
-#define SIGFPE           8
-#define SIGKILL          9
-#define SIGUSR1         10
-#define SIGSEGV         11
-#define SIGUSR2         12
-#define SIGPIPE         13
-#define SIGALRM         14
-#define SIGTERM         15
-#define SIGSTKFLT       16
-#define SIGCHLD         17
-#define SIGCONT         18
-#define SIGSTOP         19
-#define SIGTSTP         20
-#define SIGTTIN         21
-#define SIGTTOU         22
-#define SIGURG          23
-#define SIGXCPU         24
-#define SIGXFSZ         25
-#define SIGVTALRM       26
-#define SIGPROF         27
-#define SIGWINCH        28
-#define SIGIO           29
-#define SIGPOLL         SIGIO
-/*
-#define SIGLOST         29
-*/
-#define SIGPWR          30
-#define SIGSYS          31
-#define SIGUNUSED       31
-
-/* These should not be considered constants from userland.  */
-#define SIGRTMIN        32
-#define SIGRTMAX        _NSIG
-
-/*
- * SA_FLAGS values:
- *
- * SA_ONSTACK indicates that a registered stack_t will be used.
- * SA_RESTART flag to get restarting signals (which were the default long ago)
- * SA_NOCLDSTOP flag to turn off SIGCHLD when children stop.
- * SA_RESETHAND clears the handler when the signal is delivered.
- * SA_NOCLDWAIT flag on SIGCHLD to inhibit zombies.
- * SA_NODEFER prevents the current signal from being masked in the handler.
- *
- * SA_ONESHOT and SA_NOMASK are the historical Linux names for the Single
- * Unix names RESETHAND and NODEFER respectively.
- */
-#define SA_NOCLDSTOP    0x00000001
-#define SA_NOCLDWAIT    0x00000002
-#define SA_SIGINFO      0x00000004
-#define SA_ONSTACK      0x08000000
-#define SA_RESTART      0x10000000
-#define SA_NODEFER      0x40000000
-#define SA_RESETHAND    0x80000000
-
-#define SA_NOMASK       SA_NODEFER
-#define SA_ONESHOT      SA_RESETHAND
-
-#define SA_RESTORER     0x04000000
-
-/*
- * sigaltstack controls
- */
-#define SS_ONSTACK      1
-#define SS_DISABLE      2
-
-#define MINSIGSTKSZ     2048
-#define SIGSTKSZ        8192
-
-#include <asm-generic/signal.h>
-
-#ifndef __ASSEMBLY__
-
-struct sigaction {
-        __sighandler_t sa_handler;
-        unsigned long sa_flags;
-        __sigrestore_t sa_restorer;
-        sigset_t sa_mask;               /* mask last for extensibility */
-};
-
-struct k_sigaction {
-        struct sigaction sa;
-};
-
-typedef struct sigaltstack {
-        void __user *ss_sp;
-        int ss_flags;
-        size_t ss_size;
-} stack_t;
-
-#ifdef __KERNEL__
-#include <asm/sigcontext.h>
-
-#undef __HAVE_ARCH_SIG_BITOPS
-#if 0
-
-static inline void sigaddset(sigset_t *set, int _sig)
-{
-        __asm__("btsq %1,%0" : "=m"(*set) : "Ir"(_sig - 1) : "cc");
-}
-
-static inline void sigdelset(sigset_t *set, int _sig)
-{
-        __asm__("btrq %1,%0" : "=m"(*set) : "Ir"(_sig - 1) : "cc");
-}
-
-static inline int __const_sigismember(sigset_t *set, int _sig)
-{
-        unsigned long sig = _sig - 1;
-        return 1 & (set->sig[sig / _NSIG_BPW] >> (sig & ~(_NSIG_BPW-1)));
-}
-
-static inline int __gen_sigismember(sigset_t *set, int _sig)
-{
-        int ret;
-        __asm__("btq %2,%1\n\tsbbq %0,%0"
-                : "=r"(ret) : "m"(*set), "Ir"(_sig-1) : "cc");
-        return ret;
-}
-
-#define sigismember(set,sig)                    \
-        (__builtin_constant_p(sig) ?            \
-         __const_sigismember((set),(sig)) :     \
-         __gen_sigismember((set),(sig)))
-
-static inline int sigfindinword(unsigned long word)
-{
-        __asm__("bsfq %1,%0" : "=r"(word) : "rm"(word) : "cc");
-        return word;
-}
-#endif
-#endif
-
-#define ptrace_signal_deliver(regs, cookie) do { } while (0)
-
-#endif /* __KERNEL__ */
-
-#endif
diff --git a/include/asm-x86/smp_64.h b/include/asm-x86/smp_64.h
index 6f0e0273b646..ab612b0ff270 100644
--- a/include/asm-x86/smp_64.h
+++ b/include/asm-x86/smp_64.h
@@ -76,6 +76,8 @@ extern unsigned __cpuinitdata disabled_cpus;
 
 #endif /* CONFIG_SMP */
 
+#define safe_smp_processor_id()         smp_processor_id()
+
 static inline int hard_smp_processor_id(void)
 {
         /* we don't want to mark this access volatile - bad code generation */
diff --git a/include/asm-x86/stat.h b/include/asm-x86/stat.h
index 3ff6b50ef833..5c22dcb5d17e 100644
--- a/include/asm-x86/stat.h
+++ b/include/asm-x86/stat.h
@@ -1,13 +1,114 @@
-#ifdef __KERNEL__
-# ifdef CONFIG_X86_32
-#  include "stat_32.h"
-# else
-#  include "stat_64.h"
-# endif
+#ifndef _ASM_X86_STAT_H
+#define _ASM_X86_STAT_H
+
+#define STAT_HAVE_NSEC 1
+
+#ifdef __i386__
+struct stat {
+        unsigned long  st_dev;
+        unsigned long  st_ino;
+        unsigned short st_mode;
+        unsigned short st_nlink;
+        unsigned short st_uid;
+        unsigned short st_gid;
+        unsigned long  st_rdev;
+        unsigned long  st_size;
+        unsigned long  st_blksize;
+        unsigned long  st_blocks;
+        unsigned long  st_atime;
+        unsigned long  st_atime_nsec;
+        unsigned long  st_mtime;
+        unsigned long  st_mtime_nsec;
+        unsigned long  st_ctime;
+        unsigned long  st_ctime_nsec;
+        unsigned long  __unused4;
+        unsigned long  __unused5;
+};
+
+#define STAT64_HAS_BROKEN_ST_INO        1
+
+/* This matches struct stat64 in glibc2.1, hence the absolutely
+ * insane amounts of padding around dev_t's.
+ */
+struct stat64 {
+        unsigned long long      st_dev;
+        unsigned char   __pad0[4];
+
+        unsigned long   __st_ino;
+
+        unsigned int    st_mode;
+        unsigned int    st_nlink;
+
+        unsigned long   st_uid;
+        unsigned long   st_gid;
+
+        unsigned long long      st_rdev;
+        unsigned char   __pad3[4];
+
+        long long       st_size;
+        unsigned long   st_blksize;
+
+        /* Number 512-byte blocks allocated. */
+        unsigned long long      st_blocks;
+
+        unsigned long   st_atime;
+        unsigned long   st_atime_nsec;
+
+        unsigned long   st_mtime;
+        unsigned int    st_mtime_nsec;
+
+        unsigned long   st_ctime;
+        unsigned long   st_ctime_nsec;
+
+        unsigned long long      st_ino;
+};
+
+#else /* __i386__ */
+
+struct stat {
+        unsigned long   st_dev;
+        unsigned long   st_ino;
+        unsigned long   st_nlink;
+
+        unsigned int    st_mode;
+        unsigned int    st_uid;
+        unsigned int    st_gid;
+        unsigned int    __pad0;
+        unsigned long   st_rdev;
+        long            st_size;
+        long            st_blksize;
+        long            st_blocks;      /* Number 512-byte blocks allocated. */
+
+        unsigned long   st_atime;
+        unsigned long   st_atime_nsec;
+        unsigned long   st_mtime;
+        unsigned long   st_mtime_nsec;
+        unsigned long   st_ctime;
+        unsigned long   st_ctime_nsec;
+        long            __unused[3];
+};
+#endif
+
+/* for 32bit emulation and 32 bit kernels */
+struct __old_kernel_stat {
+        unsigned short st_dev;
+        unsigned short st_ino;
+        unsigned short st_mode;
+        unsigned short st_nlink;
+        unsigned short st_uid;
+        unsigned short st_gid;
+        unsigned short st_rdev;
+#ifdef __i386__
+        unsigned long  st_size;
+        unsigned long  st_atime;
+        unsigned long  st_mtime;
+        unsigned long  st_ctime;
 #else
-# ifdef __i386__
-#  include "stat_32.h"
-# else
-#  include "stat_64.h"
-# endif
+        unsigned int  st_size;
+        unsigned int  st_atime;
+        unsigned int  st_mtime;
+        unsigned int  st_ctime;
+#endif
+};
+
 #endif
diff --git a/include/asm-x86/stat_32.h b/include/asm-x86/stat_32.h
deleted file mode 100644
index 67eae78323ba..000000000000
--- a/include/asm-x86/stat_32.h
+++ /dev/null
@@ -1,77 +0,0 @@
-#ifndef _I386_STAT_H
-#define _I386_STAT_H
-
-struct __old_kernel_stat {
-        unsigned short st_dev;
-        unsigned short st_ino;
-        unsigned short st_mode;
-        unsigned short st_nlink;
-        unsigned short st_uid;
-        unsigned short st_gid;
-        unsigned short st_rdev;
-        unsigned long  st_size;
-        unsigned long  st_atime;
-        unsigned long  st_mtime;
-        unsigned long  st_ctime;
-};
-
-struct stat {
-        unsigned long  st_dev;
-        unsigned long  st_ino;
-        unsigned short st_mode;
-        unsigned short st_nlink;
-        unsigned short st_uid;
-        unsigned short st_gid;
-        unsigned long  st_rdev;
-        unsigned long  st_size;
-        unsigned long  st_blksize;
-        unsigned long  st_blocks;
-        unsigned long  st_atime;
-        unsigned long  st_atime_nsec;
-        unsigned long  st_mtime;
-        unsigned long  st_mtime_nsec;
-        unsigned long  st_ctime;
-        unsigned long  st_ctime_nsec;
-        unsigned long  __unused4;
-        unsigned long  __unused5;
-};
-
-/* This matches struct stat64 in glibc2.1, hence the absolutely
- * insane amounts of padding around dev_t's.
- */
-struct stat64 {
-        unsigned long long      st_dev;
-        unsigned char   __pad0[4];
-
-#define STAT64_HAS_BROKEN_ST_INO        1
-        unsigned long   __st_ino;
-
-        unsigned int    st_mode;
-        unsigned int    st_nlink;
-
-        unsigned long   st_uid;
-        unsigned long   st_gid;
-
-        unsigned long long      st_rdev;
-        unsigned char   __pad3[4];
-
-        long long       st_size;
-        unsigned long   st_blksize;
-
-        unsigned long long      st_blocks;      /* Number 512-byte blocks allocated. */
-
-        unsigned long   st_atime;
-        unsigned long   st_atime_nsec;
-
-        unsigned long   st_mtime;
-        unsigned int    st_mtime_nsec;
-
-        unsigned long   st_ctime;
-        unsigned long   st_ctime_nsec;
-
-        unsigned long long      st_ino;
-};
-
-#define STAT_HAVE_NSEC 1
-
-#endif
diff --git a/include/asm-x86/stat_64.h b/include/asm-x86/stat_64.h
deleted file mode 100644
index fd9f00d560f8..000000000000
--- a/include/asm-x86/stat_64.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef _ASM_X86_64_STAT_H
-#define _ASM_X86_64_STAT_H
-
-#define STAT_HAVE_NSEC 1
-
-struct stat {
-        unsigned long   st_dev;
-        unsigned long   st_ino;
-        unsigned long   st_nlink;
-
-        unsigned int    st_mode;
-        unsigned int    st_uid;
-        unsigned int    st_gid;
-        unsigned int    __pad0;
-        unsigned long   st_rdev;
-        long            st_size;
-        long            st_blksize;
-        long            st_blocks;      /* Number 512-byte blocks allocated. */
-
-        unsigned long   st_atime;
-        unsigned long   st_atime_nsec; 
-        unsigned long   st_mtime;
-        unsigned long   st_mtime_nsec;
-        unsigned long   st_ctime;
-        unsigned long   st_ctime_nsec;
-        long            __unused[3];
-};
-
-/* For 32bit emulation */
-struct __old_kernel_stat {
-        unsigned short st_dev;
-        unsigned short st_ino;
-        unsigned short st_mode;
-        unsigned short st_nlink;
-        unsigned short st_uid;
-        unsigned short st_gid;
-        unsigned short st_rdev;
-        unsigned int  st_size;
-        unsigned int  st_atime;
-        unsigned int  st_mtime;
-        unsigned int  st_ctime;
-};
-
-#endif
diff --git a/include/asm-x86/statfs.h b/include/asm-x86/statfs.h
index 327fb5d7a148..7c651aa97252 100644
--- a/include/asm-x86/statfs.h
+++ b/include/asm-x86/statfs.h
@@ -1,13 +1,63 @@
-#ifdef __KERNEL__
-# ifdef CONFIG_X86_32
-#  include "statfs_32.h"
-# else
-#  include "statfs_64.h"
-# endif
+#ifndef _ASM_X86_STATFS_H
+#define _ASM_X86_STATFS_H
+
+#ifdef __i386__
+#include <asm-generic/statfs.h>
 #else
-# ifdef __i386__
-#  include "statfs_32.h"
-# else
-#  include "statfs_64.h"
-# endif
+
+#ifndef __KERNEL_STRICT_NAMES
+
+#include <linux/types.h>
+
+typedef __kernel_fsid_t fsid_t;
+
+#endif
+
+/*
+ * This is ugly -- we're already 64-bit clean, so just duplicate the
+ * definitions.
+ */
+struct statfs {
+        long f_type;
+        long f_bsize;
+        long f_blocks;
+        long f_bfree;
+        long f_bavail;
+        long f_files;
+        long f_ffree;
+        __kernel_fsid_t f_fsid;
+        long f_namelen;
+        long f_frsize;
+        long f_spare[5];
+};
+
+struct statfs64 {
+        long f_type;
+        long f_bsize;
+        long f_blocks;
+        long f_bfree;
+        long f_bavail;
+        long f_files;
+        long f_ffree;
+        __kernel_fsid_t f_fsid;
+        long f_namelen;
+        long f_frsize;
+        long f_spare[5];
+};
+
+struct compat_statfs64 {
+        __u32 f_type;
+        __u32 f_bsize;
+        __u64 f_blocks;
+        __u64 f_bfree;
+        __u64 f_bavail;
+        __u64 f_files;
+        __u64 f_ffree;
+        __kernel_fsid_t f_fsid;
+        __u32 f_namelen;
+        __u32 f_frsize;
+        __u32 f_spare[5];
+} __attribute__((packed));
+
+#endif /* !__i386__ */
 #endif
diff --git a/include/asm-x86/statfs_32.h b/include/asm-x86/statfs_32.h
deleted file mode 100644
index 24972c175132..000000000000
--- a/include/asm-x86/statfs_32.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#ifndef _I386_STATFS_H
-#define _I386_STATFS_H
-
-#include <asm-generic/statfs.h>
-
-#endif
diff --git a/include/asm-x86/statfs_64.h b/include/asm-x86/statfs_64.h
deleted file mode 100644
index b3f4718af30b..000000000000
--- a/include/asm-x86/statfs_64.h
+++ /dev/null
@@ -1,58 +0,0 @@
-#ifndef _X86_64_STATFS_H
-#define _X86_64_STATFS_H
-
-#ifndef __KERNEL_STRICT_NAMES
-
-#include <linux/types.h>
-
-typedef __kernel_fsid_t fsid_t;
-
-#endif
-
-/*
- * This is ugly -- we're already 64-bit clean, so just duplicate the 
- * definitions.
- */
-struct statfs {
-        long f_type;
-        long f_bsize;
-        long f_blocks;
-        long f_bfree;
-        long f_bavail;
-        long f_files;
-        long f_ffree;
-        __kernel_fsid_t f_fsid;
-        long f_namelen;
-        long f_frsize;
-        long f_spare[5];
-};
-
-struct statfs64 {
-        long f_type;
-        long f_bsize;
-        long f_blocks;
-        long f_bfree;
-        long f_bavail;
-        long f_files;
-        long f_ffree;
-        __kernel_fsid_t f_fsid;
-        long f_namelen;
-        long f_frsize;
-        long f_spare[5];
-};
-
-struct compat_statfs64 {
-        __u32 f_type;
-        __u32 f_bsize;
-        __u64 f_blocks;
-        __u64 f_bfree;
-        __u64 f_bavail;
-        __u64 f_files;
-        __u64 f_ffree;
-        __kernel_fsid_t f_fsid;
-        __u32 f_namelen;
-        __u32 f_frsize;
-        __u32 f_spare[5];
-} __attribute__((packed));
-
-#endif
diff --git a/include/asm-x86/suspend_64.h b/include/asm-x86/suspend_64.h
index 9440a7a1b99a..c505a76bcf6e 100644
--- a/include/asm-x86/suspend_64.h
+++ b/include/asm-x86/suspend_64.h
@@ -3,6 +3,9 @@
  * Based on code
  * Copyright 2001 Patrick Mochel <mochel@osdl.org>
  */
+#ifndef __ASM_X86_64_SUSPEND_H
+#define __ASM_X86_64_SUSPEND_H
+
 #include <asm/desc.h>
 #include <asm/i387.h>
 
@@ -12,8 +15,9 @@ arch_prepare_suspend(void)
         return 0;
 }
 
-/* Image of the saved processor state. If you touch this, fix acpi_wakeup.S. */
+/* Image of the saved processor state. If you touch this, fix acpi/wakeup.S. */
 struct saved_context {
+        struct pt_regs regs;
         u16 ds, es, fs, gs, ss;
         unsigned long gs_base, gs_kernel_base, fs_base;
         unsigned long cr0, cr2, cr3, cr4, cr8;
@@ -29,29 +33,16 @@ struct saved_context {
         unsigned long tr;
         unsigned long safety;
         unsigned long return_address;
-        unsigned long eflags;
 } __attribute__((packed));
 
-/* We'll access these from assembly, so we'd better have them outside struct */
-extern unsigned long saved_context_eax, saved_context_ebx, saved_context_ecx, saved_context_edx;
-extern unsigned long saved_context_esp, saved_context_ebp, saved_context_esi, saved_context_edi;
-extern unsigned long saved_context_r08, saved_context_r09, saved_context_r10, saved_context_r11;
-extern unsigned long saved_context_r12, saved_context_r13, saved_context_r14, saved_context_r15;
-extern unsigned long saved_context_eflags;
-
 #define loaddebug(thread,register) \
         set_debugreg((thread)->debugreg##register, register)
 
 extern void fix_processor_context(void);
 
-extern unsigned long saved_rip;
-extern unsigned long saved_rsp;
-extern unsigned long saved_rbp;
-extern unsigned long saved_rbx;
-extern unsigned long saved_rsi;
-extern unsigned long saved_rdi;
-
 /* routines for saving/restoring kernel state */
 extern int acpi_save_state_mem(void);
 extern char core_restore_code;
 extern char restore_registers;
+
+#endif /* __ASM_X86_64_SUSPEND_H */
diff --git a/include/linux/ata.h b/include/linux/ata.h
index a4f373f8b798..8263a7b74d34 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -178,8 +178,8 @@ enum {
         ATA_CMD_PACKET          = 0xA0,
         ATA_CMD_VERIFY          = 0x40,
         ATA_CMD_VERIFY_EXT      = 0x42,
-        ATA_CMD_STANDBYNOW1     = 0xE0,
-        ATA_CMD_IDLEIMMEDIATE   = 0xE1,
+        ATA_CMD_STANDBYNOW1     = 0xE0,
+        ATA_CMD_IDLEIMMEDIATE   = 0xE1,
         ATA_CMD_INIT_DEV_PARAMS = 0x91,
         ATA_CMD_READ_NATIVE_MAX = 0xF8,
         ATA_CMD_READ_NATIVE_MAX_EXT = 0x27,
@@ -458,7 +458,7 @@ static inline int ata_id_wcache_enabled(const u16 *id)
  *              ATA-3 introduces word 80 and accurate reporting
  *
  *      The practical impact of this is that ata_id_major_version cannot
- *      reliably report on drives below ATA3. 
+ *      reliably report on drives below ATA3.
  */
 
 static inline unsigned int ata_id_major_version(const u16 *id)
diff --git a/include/linux/libata.h b/include/linux/libata.h
index bc3b6fc7b98d..6fd24e03622e 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -326,7 +326,7 @@ enum {
         ATA_HORKAGE_SKIP_PM     = (1 << 5),     /* Skip PM operations */
         ATA_HORKAGE_HPA_SIZE    = (1 << 6),     /* native size off by one */
 
-         /* DMA mask for user DMA control: User visible values; DO NOT 
+         /* DMA mask for user DMA control: User visible values; DO NOT
             renumber */
         ATA_DMA_MASK_ATA        = (1 << 0),     /* DMA on ATA Disk */
         ATA_DMA_MASK_ATAPI      = (1 << 1),     /* DMA on ATAPI */
@@ -717,7 +717,7 @@ struct ata_timing {
         unsigned short udma;            /* t2CYCTYP/2 */
 };
 
-#define FIT(v,vmin,vmax)        max_t(short,min_t(short,v,vmax),vmin)
+#define FIT(v, vmin, vmax)      max_t(short, min_t(short, v, vmax), vmin)
 
 extern const unsigned long sata_deb_timing_normal[];
 extern const unsigned long sata_deb_timing_hotplug[];
@@ -816,14 +816,14 @@ extern void ata_tf_read(struct ata_port *ap, struct ata_taskfile *tf);
 extern void ata_tf_to_fis(const struct ata_taskfile *tf,
                           u8 pmp, int is_cmd, u8 *fis);
 extern void ata_tf_from_fis(const u8 *fis, struct ata_taskfile *tf);
-extern void ata_noop_dev_select (struct ata_port *ap, unsigned int device);
-extern void ata_std_dev_select (struct ata_port *ap, unsigned int device);
+extern void ata_noop_dev_select(struct ata_port *ap, unsigned int device);
+extern void ata_std_dev_select(struct ata_port *ap, unsigned int device);
 extern u8 ata_check_status(struct ata_port *ap);
 extern u8 ata_altstatus(struct ata_port *ap);
 extern void ata_exec_command(struct ata_port *ap, const struct ata_taskfile *tf);
-extern int ata_port_start (struct ata_port *ap);
-extern int ata_sff_port_start (struct ata_port *ap);
-extern irqreturn_t ata_interrupt (int irq, void *dev_instance);
+extern int ata_port_start(struct ata_port *ap);
+extern int ata_sff_port_start(struct ata_port *ap);
+extern irqreturn_t ata_interrupt(int irq, void *dev_instance);
 extern void ata_data_xfer(struct ata_device *adev, unsigned char *buf,
                           unsigned int buflen, int write_data);
 extern void ata_data_xfer_noirq(struct ata_device *adev, unsigned char *buf,
@@ -844,8 +844,8 @@ extern void ata_id_string(const u16 *id, unsigned char *s,
 extern void ata_id_c_string(const u16 *id, unsigned char *s,
                             unsigned int ofs, unsigned int len);
 extern void ata_id_to_dma_mode(struct ata_device *dev, u8 unknown);
-extern void ata_bmdma_setup (struct ata_queued_cmd *qc);
-extern void ata_bmdma_start (struct ata_queued_cmd *qc);
+extern void ata_bmdma_setup(struct ata_queued_cmd *qc);
+extern void ata_bmdma_start(struct ata_queued_cmd *qc);
 extern void ata_bmdma_stop(struct ata_queued_cmd *qc);
 extern u8   ata_bmdma_status(struct ata_port *ap);
 extern void ata_bmdma_irq_clear(struct ata_port *ap);
@@ -920,9 +920,9 @@ static inline int ata_acpi_cbl_80wire(struct ata_port *ap) { return 0; }
 #ifdef CONFIG_PCI
 struct pci_dev;
 
-extern int ata_pci_init_one (struct pci_dev *pdev,
+extern int ata_pci_init_one(struct pci_dev *pdev,
                              const struct ata_port_info * const * ppi);
-extern void ata_pci_remove_one (struct pci_dev *pdev);
+extern void ata_pci_remove_one(struct pci_dev *pdev);
 #ifdef CONFIG_PM
 extern void ata_pci_device_do_suspend(struct pci_dev *pdev, pm_message_t mesg);
 extern int __must_check ata_pci_device_do_resume(struct pci_dev *pdev);
diff --git a/include/scsi/scsi_eh.h b/include/scsi/scsi_eh.h
index 44224ba4dd90..d21b8913ceb3 100644
--- a/include/scsi/scsi_eh.h
+++ b/include/scsi/scsi_eh.h
@@ -1,6 +1,8 @@
 #ifndef _SCSI_SCSI_EH_H
 #define _SCSI_SCSI_EH_H
 
+#include <linux/scatterlist.h>
+
 #include <scsi/scsi_cmnd.h>
 struct scsi_device;
 struct Scsi_Host;