Merge branch 'master' of /home/trondmy/kernel/linux-2.6/

239 files changed, 3173 insertions, 2232 deletions

diff --git a/Documentation/feature-removal-schedule.txt b/Documentation/feature-removal-schedule.txt
index 027285d0c26c..033ac91da07a 100644
--- a/Documentation/feature-removal-schedule.txt
+++ b/Documentation/feature-removal-schedule.txt
@@ -177,6 +177,16 @@ Who:	Jean Delvare <khali@linux-fr.org>
 
 ---------------------------
 
+What:   Unused EXPORT_SYMBOL/EXPORT_SYMBOL_GPL exports
+        (temporary transition config option provided until then)
+        The transition config option will also be removed at the same time.
+When:   before 2.6.19
+Why:    Unused symbols are both increasing the size of the kernel binary
+        and are often a sign of "wrong API"
+Who:    Arjan van de Ven <arjan@linux.intel.com>
+
+---------------------------
+
 What:   remove EXPORT_SYMBOL(tasklist_lock)
 When:   August 2006
 Files:  kernel/fork.c
diff --git a/Documentation/watchdog/pcwd-watchdog.txt b/Documentation/watchdog/pcwd-watchdog.txt
index 12187a33e310..d9ee6336c1d4 100644
--- a/Documentation/watchdog/pcwd-watchdog.txt
+++ b/Documentation/watchdog/pcwd-watchdog.txt
@@ -22,78 +22,9 @@
  to run the program with an "&" to run it in the background!)
 
  If you want to write a program to be compatible with the PC Watchdog
- driver, simply do the following:
-
--- Snippet of code --
-/*
- * Watchdog Driver Test Program
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/ioctl.h>
-#include <linux/types.h>
-#include <linux/watchdog.h>
-
-int fd;
-
-/*
- * This function simply sends an IOCTL to the driver, which in turn ticks
- * the PC Watchdog card to reset its internal timer so it doesn't trigger
- * a computer reset.
- */
-void keep_alive(void)
-{
-    int dummy;
-
-    ioctl(fd, WDIOC_KEEPALIVE, &dummy);
-}
-
-/*
- * The main program.  Run the program with "-d" to disable the card,
- * or "-e" to enable the card.
- */
-int main(int argc, char *argv[])
-{
-    fd = open("/dev/watchdog", O_WRONLY);
-
-    if (fd == -1) {
-        fprintf(stderr, "Watchdog device not enabled.\n");
-        fflush(stderr);
-        exit(-1);
-    }
-
-    if (argc > 1) {
-        if (!strncasecmp(argv[1], "-d", 2)) {
-            ioctl(fd, WDIOC_SETOPTIONS, WDIOS_DISABLECARD);
-            fprintf(stderr, "Watchdog card disabled.\n");
-            fflush(stderr);
-            exit(0);
-        } else if (!strncasecmp(argv[1], "-e", 2)) {
-            ioctl(fd, WDIOC_SETOPTIONS, WDIOS_ENABLECARD);
-            fprintf(stderr, "Watchdog card enabled.\n");
-            fflush(stderr);
-            exit(0);
-        } else {
-            fprintf(stderr, "-d to disable, -e to enable.\n");
-            fprintf(stderr, "run by itself to tick the card.\n");
-            fflush(stderr);
-            exit(0);
-        }
-    } else {
-        fprintf(stderr, "Watchdog Ticking Away!\n");
-        fflush(stderr);
-    }
-
-    while(1) {
-        keep_alive();
-        sleep(1);
-    }
-}
--- End snippet --
+ driver, simply use of modify the watchdog test program:
+ Documentation/watchdog/src/watchdog-test.c
+
 
  Other IOCTL functions include:
 
diff --git a/Documentation/watchdog/src/watchdog-simple.c b/Documentation/watchdog/src/watchdog-simple.c
new file mode 100644
index 000000000000..85cf17c48669
--- /dev/null
+++ b/Documentation/watchdog/src/watchdog-simple.c
@@ -0,0 +1,15 @@
+#include <stdlib.h>
+#include <fcntl.h>
+
+int main(int argc, const char *argv[]) {
+        int fd = open("/dev/watchdog", O_WRONLY);
+        if (fd == -1) {
+                perror("watchdog");
+                exit(1);
+        }
+        while (1) {
+                write(fd, "\0", 1);
+                fsync(fd);
+                sleep(10);
+        }
+}
diff --git a/Documentation/watchdog/src/watchdog-test.c b/Documentation/watchdog/src/watchdog-test.c
new file mode 100644
index 000000000000..65f6c19cb865
--- /dev/null
+++ b/Documentation/watchdog/src/watchdog-test.c
@@ -0,0 +1,68 @@
+/*
+ * Watchdog Driver Test Program
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <linux/types.h>
+#include <linux/watchdog.h>
+
+int fd;
+
+/*
+ * This function simply sends an IOCTL to the driver, which in turn ticks
+ * the PC Watchdog card to reset its internal timer so it doesn't trigger
+ * a computer reset.
+ */
+void keep_alive(void)
+{
+    int dummy;
+
+    ioctl(fd, WDIOC_KEEPALIVE, &dummy);
+}
+
+/*
+ * The main program.  Run the program with "-d" to disable the card,
+ * or "-e" to enable the card.
+ */
+int main(int argc, char *argv[])
+{
+    fd = open("/dev/watchdog", O_WRONLY);
+
+    if (fd == -1) {
+        fprintf(stderr, "Watchdog device not enabled.\n");
+        fflush(stderr);
+        exit(-1);
+    }
+
+    if (argc > 1) {
+        if (!strncasecmp(argv[1], "-d", 2)) {
+            ioctl(fd, WDIOC_SETOPTIONS, WDIOS_DISABLECARD);
+            fprintf(stderr, "Watchdog card disabled.\n");
+            fflush(stderr);
+            exit(0);
+        } else if (!strncasecmp(argv[1], "-e", 2)) {
+            ioctl(fd, WDIOC_SETOPTIONS, WDIOS_ENABLECARD);
+            fprintf(stderr, "Watchdog card enabled.\n");
+            fflush(stderr);
+            exit(0);
+        } else {
+            fprintf(stderr, "-d to disable, -e to enable.\n");
+            fprintf(stderr, "run by itself to tick the card.\n");
+            fflush(stderr);
+            exit(0);
+        }
+    } else {
+        fprintf(stderr, "Watchdog Ticking Away!\n");
+        fflush(stderr);
+    }
+
+    while(1) {
+        keep_alive();
+        sleep(1);
+    }
+}
diff --git a/Documentation/watchdog/watchdog-api.txt b/Documentation/watchdog/watchdog-api.txt
index 21ed51173662..958ff3d48be3 100644
--- a/Documentation/watchdog/watchdog-api.txt
+++ b/Documentation/watchdog/watchdog-api.txt
@@ -34,22 +34,7 @@ activates as soon as /dev/watchdog is opened and will reboot unless
 the watchdog is pinged within a certain time, this time is called the
 timeout or margin.  The simplest way to ping the watchdog is to write
 some data to the device.  So a very simple watchdog daemon would look
-like this:
-
-#include <stdlib.h>
-#include <fcntl.h>
-
-int main(int argc, const char *argv[]) {
-        int fd=open("/dev/watchdog",O_WRONLY);
-        if (fd==-1) {
-                perror("watchdog");
-                exit(1);
-        }
-        while(1) {
-                write(fd, "\0", 1);
-                sleep(10);
-        }
-}
+like this source file:  see Documentation/watchdog/src/watchdog-simple.c
 
 A more advanced driver could for example check that a HTTP server is
 still responding before doing the write call to ping the watchdog.
@@ -110,7 +95,40 @@ current timeout using the GETTIMEOUT ioctl.
     ioctl(fd, WDIOC_GETTIMEOUT, &timeout);
     printf("The timeout was is %d seconds\n", timeout);
 
-Envinronmental monitoring:
+Pretimeouts:
+
+Some watchdog timers can be set to have a trigger go off before the
+actual time they will reset the system.  This can be done with an NMI,
+interrupt, or other mechanism.  This allows Linux to record useful
+information (like panic information and kernel coredumps) before it
+resets.
+
+    pretimeout = 10;
+    ioctl(fd, WDIOC_SETPRETIMEOUT, &pretimeout);
+
+Note that the pretimeout is the number of seconds before the time
+when the timeout will go off.  It is not the number of seconds until
+the pretimeout.  So, for instance, if you set the timeout to 60 seconds
+and the pretimeout to 10 seconds, the pretimout will go of in 50
+seconds.  Setting a pretimeout to zero disables it.
+
+There is also a get function for getting the pretimeout:
+
+    ioctl(fd, WDIOC_GETPRETIMEOUT, &timeout);
+    printf("The pretimeout was is %d seconds\n", timeout);
+
+Not all watchdog drivers will support a pretimeout.
+
+Get the number of seconds before reboot:
+
+Some watchdog drivers have the ability to report the remaining time
+before the system will reboot. The WDIOC_GETTIMELEFT is the ioctl
+that returns the number of seconds before reboot.
+
+    ioctl(fd, WDIOC_GETTIMELEFT, &timeleft);
+    printf("The timeout was is %d seconds\n", timeleft);
+
+Environmental monitoring:
 
 All watchdog drivers are required return more information about the system,
 some do temperature, fan and power level monitoring, some can tell you
@@ -169,6 +187,10 @@ The watchdog saw a keepalive ping since it was last queried.
 
         WDIOF_SETTIMEOUT        Can set/get the timeout
 
+The watchdog can do pretimeouts.
+
+        WDIOF_PRETIMEOUT        Pretimeout (in seconds), get/set
+
 
 For those drivers that return any bits set in the option field, the
 GETSTATUS and GETBOOTSTATUS ioctls can be used to ask for the current
diff --git a/Documentation/watchdog/watchdog.txt b/Documentation/watchdog/watchdog.txt
index dffda29c8799..4b1ff69cc19a 100644
--- a/Documentation/watchdog/watchdog.txt
+++ b/Documentation/watchdog/watchdog.txt
@@ -65,28 +65,7 @@ The external event interfaces on the WDT boards are not currently supported.
 Minor numbers are however allocated for it.
 
 
-Example Watchdog Driver
------------------------
-
-#include <stdio.h>
-#include <unistd.h>
-#include <fcntl.h>
-
-int main(int argc, const char *argv[])
-{
-        int fd=open("/dev/watchdog",O_WRONLY);
-        if(fd==-1)
-        {
-                perror("watchdog");
-                exit(1);
-        }
-        while(1)
-        {
-                write(fd,"\0",1);
-                fsync(fd);
-                sleep(10);
-        }
-}
+Example Watchdog Driver:  see Documentation/watchdog/src/watchdog-simple.c
 
 
 Contact Information
diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig
index 3d1a3fb7d5fc..f123c7c9fc98 100644
--- a/arch/arm/Kconfig
+++ b/arch/arm/Kconfig
@@ -188,23 +188,27 @@ config ARCH_IMX
 
 config ARCH_IOP3XX
         bool "IOP3xx-based"
+        depends on MMU
         select PCI
         help
           Support for Intel's IOP3XX (XScale) family of processors.
 
 config ARCH_IXP4XX
         bool "IXP4xx-based"
+        depends on MMU
         help
           Support for Intel's IXP4XX (XScale) family of processors.
 
 config ARCH_IXP2000
         bool "IXP2400/2800-based"
+        depends on MMU
         select PCI
         help
           Support for Intel's IXP2400/2800 (XScale) family of processors.
 
 config ARCH_IXP23XX
         bool "IXP23XX-based"
+        depends on MMU
         select PCI
         help
           Support for Intel's IXP23xx (XScale) family of processors.
@@ -229,6 +233,7 @@ config ARCH_PNX4008
 
 config ARCH_PXA
         bool "PXA2xx-based"
+        depends on MMU
         select ARCH_MTD_XIP
         help
           Support for Intel's PXA2XX processor line.
@@ -339,6 +344,10 @@ config XSCALE_PMU
         depends on CPU_XSCALE && !XSCALE_PMU_TIMER
         default y
 
+if !MMU
+source "arch/arm/Kconfig-nommu"
+endif
+
 endmenu
 
 source "arch/arm/common/Kconfig"
diff --git a/arch/arm/kernel/Makefile b/arch/arm/kernel/Makefile
index a601b8b55f35..7cffbaef064b 100644
--- a/arch/arm/kernel/Makefile
+++ b/arch/arm/kernel/Makefile
@@ -22,6 +22,9 @@ obj-$(CONFIG_PCI)		+= bios32.o
 obj-$(CONFIG_SMP)               += smp.o
 obj-$(CONFIG_OABI_COMPAT)       += sys_oabi-compat.o
 
+obj-$(CONFIG_CRUNCH)            += crunch.o crunch-bits.o
+AFLAGS_crunch-bits.o            := -Wa,-mcpu=ep9312
+
 obj-$(CONFIG_IWMMXT)            += iwmmxt.o
 AFLAGS_iwmmxt.o                 := -Wa,-mcpu=iwmmxt
 
diff --git a/arch/arm/kernel/armksyms.c b/arch/arm/kernel/armksyms.c
index c49b5d4d7fca..da69e660574b 100644
--- a/arch/arm/kernel/armksyms.c
+++ b/arch/arm/kernel/armksyms.c
@@ -109,11 +109,13 @@ EXPORT_SYMBOL(memchr);
 EXPORT_SYMBOL(__memzero);
 
         /* user mem (segment) */
-EXPORT_SYMBOL(__arch_copy_from_user);
-EXPORT_SYMBOL(__arch_copy_to_user);
-EXPORT_SYMBOL(__arch_clear_user);
-EXPORT_SYMBOL(__arch_strnlen_user);
-EXPORT_SYMBOL(__arch_strncpy_from_user);
+EXPORT_SYMBOL(__strnlen_user);
+EXPORT_SYMBOL(__strncpy_from_user);
+
+#ifdef CONFIG_MMU
+EXPORT_SYMBOL(__copy_from_user);
+EXPORT_SYMBOL(__copy_to_user);
+EXPORT_SYMBOL(__clear_user);
 
 EXPORT_SYMBOL(__get_user_1);
 EXPORT_SYMBOL(__get_user_2);
@@ -123,6 +125,7 @@ EXPORT_SYMBOL(__put_user_1);
 EXPORT_SYMBOL(__put_user_2);
 EXPORT_SYMBOL(__put_user_4);
 EXPORT_SYMBOL(__put_user_8);
+#endif
 
         /* crypto hash */
 EXPORT_SYMBOL(sha_transform);
diff --git a/arch/arm/kernel/asm-offsets.c b/arch/arm/kernel/asm-offsets.c
index 396efba9bacd..447ede5143a8 100644
--- a/arch/arm/kernel/asm-offsets.c
+++ b/arch/arm/kernel/asm-offsets.c
@@ -60,6 +60,9 @@ int main(void)
 #ifdef CONFIG_IWMMXT
   DEFINE(TI_IWMMXT_STATE,       offsetof(struct thread_info, fpstate.iwmmxt));
 #endif
+#ifdef CONFIG_CRUNCH
+  DEFINE(TI_CRUNCH_STATE,       offsetof(struct thread_info, crunchstate));
+#endif
   BLANK();
   DEFINE(S_R0,                  offsetof(struct pt_regs, ARM_r0));
   DEFINE(S_R1,                  offsetof(struct pt_regs, ARM_r1));
diff --git a/arch/arm/kernel/crunch-bits.S b/arch/arm/kernel/crunch-bits.S
new file mode 100644
index 000000000000..a26886758c67
--- /dev/null
+++ b/arch/arm/kernel/crunch-bits.S
@@ -0,0 +1,305 @@
+/*
+ * arch/arm/kernel/crunch-bits.S
+ * Cirrus MaverickCrunch context switching and handling
+ *
+ * Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
+ *
+ * Shamelessly stolen from the iWMMXt code by Nicolas Pitre, which is
+ * Copyright (c) 2003-2004, MontaVista Software, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/linkage.h>
+#include <asm/ptrace.h>
+#include <asm/thread_info.h>
+#include <asm/asm-offsets.h>
+#include <asm/arch/ep93xx-regs.h>
+
+/*
+ * We can't use hex constants here due to a bug in gas.
+ */
+#define CRUNCH_MVDX0            0
+#define CRUNCH_MVDX1            8
+#define CRUNCH_MVDX2            16
+#define CRUNCH_MVDX3            24
+#define CRUNCH_MVDX4            32
+#define CRUNCH_MVDX5            40
+#define CRUNCH_MVDX6            48
+#define CRUNCH_MVDX7            56
+#define CRUNCH_MVDX8            64
+#define CRUNCH_MVDX9            72
+#define CRUNCH_MVDX10           80
+#define CRUNCH_MVDX11           88
+#define CRUNCH_MVDX12           96
+#define CRUNCH_MVDX13           104
+#define CRUNCH_MVDX14           112
+#define CRUNCH_MVDX15           120
+#define CRUNCH_MVAX0L           128
+#define CRUNCH_MVAX0M           132
+#define CRUNCH_MVAX0H           136
+#define CRUNCH_MVAX1L           140
+#define CRUNCH_MVAX1M           144
+#define CRUNCH_MVAX1H           148
+#define CRUNCH_MVAX2L           152
+#define CRUNCH_MVAX2M           156
+#define CRUNCH_MVAX2H           160
+#define CRUNCH_MVAX3L           164
+#define CRUNCH_MVAX3M           168
+#define CRUNCH_MVAX3H           172
+#define CRUNCH_DSPSC            176
+
+#define CRUNCH_SIZE             184
+
+        .text
+
+/*
+ * Lazy switching of crunch coprocessor context
+ *
+ * r10 = struct thread_info pointer
+ * r9  = ret_from_exception
+ * lr  = undefined instr exit
+ *
+ * called from prefetch exception handler with interrupts disabled
+ */
+ENTRY(crunch_task_enable)
+        ldr     r8, =(EP93XX_APB_VIRT_BASE + 0x00130000)        @ syscon addr
+
+        ldr     r1, [r8, #0x80]
+        tst     r1, #0x00800000                 @ access to crunch enabled?
+        movne   pc, lr                          @ if so no business here
+        mov     r3, #0xaa                       @ unlock syscon swlock
+        str     r3, [r8, #0xc0]
+        orr     r1, r1, #0x00800000             @ enable access to crunch
+        str     r1, [r8, #0x80]
+
+        ldr     r3, =crunch_owner
+        add     r0, r10, #TI_CRUNCH_STATE       @ get task crunch save area
+        ldr     r2, [sp, #60]                   @ current task pc value
+        ldr     r1, [r3]                        @ get current crunch owner
+        str     r0, [r3]                        @ this task now owns crunch
+        sub     r2, r2, #4                      @ adjust pc back
+        str     r2, [sp, #60]
+
+        ldr     r2, [r8, #0x80]
+        mov     r2, r2                          @ flush out enable (@@@)
+
+        teq     r1, #0                          @ test for last ownership
+        mov     lr, r9                          @ normal exit from exception
+        beq     crunch_load                     @ no owner, skip save
+
+crunch_save:
+        cfstr64         mvdx0, [r1, #CRUNCH_MVDX0]      @ save 64b registers
+        cfstr64         mvdx1, [r1, #CRUNCH_MVDX1]
+        cfstr64         mvdx2, [r1, #CRUNCH_MVDX2]
+        cfstr64         mvdx3, [r1, #CRUNCH_MVDX3]
+        cfstr64         mvdx4, [r1, #CRUNCH_MVDX4]
+        cfstr64         mvdx5, [r1, #CRUNCH_MVDX5]
+        cfstr64         mvdx6, [r1, #CRUNCH_MVDX6]
+        cfstr64         mvdx7, [r1, #CRUNCH_MVDX7]
+        cfstr64         mvdx8, [r1, #CRUNCH_MVDX8]
+        cfstr64         mvdx9, [r1, #CRUNCH_MVDX9]
+        cfstr64         mvdx10, [r1, #CRUNCH_MVDX10]
+        cfstr64         mvdx11, [r1, #CRUNCH_MVDX11]
+        cfstr64         mvdx12, [r1, #CRUNCH_MVDX12]
+        cfstr64         mvdx13, [r1, #CRUNCH_MVDX13]
+        cfstr64         mvdx14, [r1, #CRUNCH_MVDX14]
+        cfstr64         mvdx15, [r1, #CRUNCH_MVDX15]
+
+#ifdef __ARMEB__
+#error fix me for ARMEB
+#endif
+
+        cfmv32al        mvfx0, mvax0                    @ save 72b accumulators
+        cfstr32         mvfx0, [r1, #CRUNCH_MVAX0L]
+        cfmv32am        mvfx0, mvax0
+        cfstr32         mvfx0, [r1, #CRUNCH_MVAX0M]
+        cfmv32ah        mvfx0, mvax0
+        cfstr32         mvfx0, [r1, #CRUNCH_MVAX0H]
+        cfmv32al        mvfx0, mvax1
+        cfstr32         mvfx0, [r1, #CRUNCH_MVAX1L]
+        cfmv32am        mvfx0, mvax1
+        cfstr32         mvfx0, [r1, #CRUNCH_MVAX1M]
+        cfmv32ah        mvfx0, mvax1
+        cfstr32         mvfx0, [r1, #CRUNCH_MVAX1H]
+        cfmv32al        mvfx0, mvax2
+        cfstr32         mvfx0, [r1, #CRUNCH_MVAX2L]
+        cfmv32am        mvfx0, mvax2
+        cfstr32         mvfx0, [r1, #CRUNCH_MVAX2M]
+        cfmv32ah        mvfx0, mvax2
+        cfstr32         mvfx0, [r1, #CRUNCH_MVAX2H]
+        cfmv32al        mvfx0, mvax3
+        cfstr32         mvfx0, [r1, #CRUNCH_MVAX3L]
+        cfmv32am        mvfx0, mvax3
+        cfstr32         mvfx0, [r1, #CRUNCH_MVAX3M]
+        cfmv32ah        mvfx0, mvax3
+        cfstr32         mvfx0, [r1, #CRUNCH_MVAX3H]
+
+        cfmv32sc        mvdx0, dspsc                    @ save status word
+        cfstr64         mvdx0, [r1, #CRUNCH_DSPSC]
+
+        teq             r0, #0                          @ anything to load?
+        cfldr64eq       mvdx0, [r1, #CRUNCH_MVDX0]      @ mvdx0 was clobbered
+        moveq           pc, lr
+
+crunch_load:
+        cfldr64         mvdx0, [r0, #CRUNCH_DSPSC]      @ load status word
+        cfmvsc32        dspsc, mvdx0
+
+        cfldr32         mvfx0, [r0, #CRUNCH_MVAX0L]     @ load 72b accumulators
+        cfmval32        mvax0, mvfx0
+        cfldr32         mvfx0, [r0, #CRUNCH_MVAX0M]
+        cfmvam32        mvax0, mvfx0
+        cfldr32         mvfx0, [r0, #CRUNCH_MVAX0H]
+        cfmvah32        mvax0, mvfx0
+        cfldr32         mvfx0, [r0, #CRUNCH_MVAX1L]
+        cfmval32        mvax1, mvfx0
+        cfldr32         mvfx0, [r0, #CRUNCH_MVAX1M]
+        cfmvam32        mvax1, mvfx0
+        cfldr32         mvfx0, [r0, #CRUNCH_MVAX1H]
+        cfmvah32        mvax1, mvfx0
+        cfldr32         mvfx0, [r0, #CRUNCH_MVAX2L]
+        cfmval32        mvax2, mvfx0
+        cfldr32         mvfx0, [r0, #CRUNCH_MVAX2M]
+        cfmvam32        mvax2, mvfx0
+        cfldr32         mvfx0, [r0, #CRUNCH_MVAX2H]
+        cfmvah32        mvax2, mvfx0
+        cfldr32         mvfx0, [r0, #CRUNCH_MVAX3L]
+        cfmval32        mvax3, mvfx0
+        cfldr32         mvfx0, [r0, #CRUNCH_MVAX3M]
+        cfmvam32        mvax3, mvfx0
+        cfldr32         mvfx0, [r0, #CRUNCH_MVAX3H]
+        cfmvah32        mvax3, mvfx0
+
+        cfldr64         mvdx0, [r0, #CRUNCH_MVDX0]      @ load 64b registers
+        cfldr64         mvdx1, [r0, #CRUNCH_MVDX1]
+        cfldr64         mvdx2, [r0, #CRUNCH_MVDX2]
+        cfldr64         mvdx3, [r0, #CRUNCH_MVDX3]
+        cfldr64         mvdx4, [r0, #CRUNCH_MVDX4]
+        cfldr64         mvdx5, [r0, #CRUNCH_MVDX5]
+        cfldr64         mvdx6, [r0, #CRUNCH_MVDX6]
+        cfldr64         mvdx7, [r0, #CRUNCH_MVDX7]
+        cfldr64         mvdx8, [r0, #CRUNCH_MVDX8]
+        cfldr64         mvdx9, [r0, #CRUNCH_MVDX9]
+        cfldr64         mvdx10, [r0, #CRUNCH_MVDX10]
+        cfldr64         mvdx11, [r0, #CRUNCH_MVDX11]
+        cfldr64         mvdx12, [r0, #CRUNCH_MVDX12]
+        cfldr64         mvdx13, [r0, #CRUNCH_MVDX13]
+        cfldr64         mvdx14, [r0, #CRUNCH_MVDX14]
+        cfldr64         mvdx15, [r0, #CRUNCH_MVDX15]
+
+        mov     pc, lr
+
+/*
+ * Back up crunch regs to save area and disable access to them
+ * (mainly for gdb or sleep mode usage)
+ *
+ * r0 = struct thread_info pointer of target task or NULL for any
+ */
+ENTRY(crunch_task_disable)
+        stmfd   sp!, {r4, r5, lr}
+
+        mrs     ip, cpsr
+        orr     r2, ip, #PSR_I_BIT              @ disable interrupts
+        msr     cpsr_c, r2
+
+        ldr     r4, =(EP93XX_APB_VIRT_BASE + 0x00130000)        @ syscon addr
+
+        ldr     r3, =crunch_owner
+        add     r2, r0, #TI_CRUNCH_STATE        @ get task crunch save area
+        ldr     r1, [r3]                        @ get current crunch owner
+        teq     r1, #0                          @ any current owner?
+        beq     1f                              @ no: quit
+        teq     r0, #0                          @ any owner?
+        teqne   r1, r2                          @ or specified one?
+        bne     1f                              @ no: quit
+
+        ldr     r5, [r4, #0x80]                 @ enable access to crunch
+        mov     r2, #0xaa
+        str     r2, [r4, #0xc0]
+        orr     r5, r5, #0x00800000
+        str     r5, [r4, #0x80]
+
+        mov     r0, #0                          @ nothing to load
+        str     r0, [r3]                        @ no more current owner
+        ldr     r2, [r4, #0x80]                 @ flush out enable (@@@)
+        mov     r2, r2
+        bl      crunch_save
+
+        mov     r2, #0xaa                       @ disable access to crunch
+        str     r2, [r4, #0xc0]
+        bic     r5, r5, #0x00800000
+        str     r5, [r4, #0x80]
+        ldr     r5, [r4, #0x80]                 @ flush out enable (@@@)
+        mov     r5, r5
+
+1:      msr     cpsr_c, ip                      @ restore interrupt mode
+        ldmfd   sp!, {r4, r5, pc}
+
+/*
+ * Copy crunch state to given memory address
+ *
+ * r0 = struct thread_info pointer of target task
+ * r1 = memory address where to store crunch state
+ *
+ * this is called mainly in the creation of signal stack frames
+ */
+ENTRY(crunch_task_copy)
+        mrs     ip, cpsr
+        orr     r2, ip, #PSR_I_BIT              @ disable interrupts
+        msr     cpsr_c, r2
+
+        ldr     r3, =crunch_owner
+        add     r2, r0, #TI_CRUNCH_STATE        @ get task crunch save area
+        ldr     r3, [r3]                        @ get current crunch owner
+        teq     r2, r3                          @ does this task own it...
+        beq     1f
+
+        @ current crunch values are in the task save area
+        msr     cpsr_c, ip                      @ restore interrupt mode
+        mov     r0, r1
+        mov     r1, r2
+        mov     r2, #CRUNCH_SIZE
+        b       memcpy
+
+1:      @ this task owns crunch regs -- grab a copy from there
+        mov     r0, #0                          @ nothing to load
+        mov     r3, lr                          @ preserve return address
+        bl      crunch_save
+        msr     cpsr_c, ip                      @ restore interrupt mode
+        mov     pc, r3
+
+/*
+ * Restore crunch state from given memory address
+ *
+ * r0 = struct thread_info pointer of target task
+ * r1 = memory address where to get crunch state from
+ *
+ * this is used to restore crunch state when unwinding a signal stack frame
+ */
+ENTRY(crunch_task_restore)
+        mrs     ip, cpsr
+        orr     r2, ip, #PSR_I_BIT              @ disable interrupts
+        msr     cpsr_c, r2
+
+        ldr     r3, =crunch_owner
+        add     r2, r0, #TI_CRUNCH_STATE        @ get task crunch save area
+        ldr     r3, [r3]                        @ get current crunch owner
+        teq     r2, r3                          @ does this task own it...
+        beq     1f
+
+        @ this task doesn't own crunch regs -- use its save area
+        msr     cpsr_c, ip                      @ restore interrupt mode
+        mov     r0, r2
+        mov     r2, #CRUNCH_SIZE
+        b       memcpy
+
+1:      @ this task owns crunch regs -- load them directly
+        mov     r0, r1
+        mov     r1, #0                          @ nothing to save
+        mov     r3, lr                          @ preserve return address
+        bl      crunch_load
+        msr     cpsr_c, ip                      @ restore interrupt mode
+        mov     pc, r3
diff --git a/arch/arm/kernel/crunch.c b/arch/arm/kernel/crunch.c
new file mode 100644
index 000000000000..748175921f9b
--- /dev/null
+++ b/arch/arm/kernel/crunch.c
@@ -0,0 +1,83 @@
+/*
+ * arch/arm/kernel/crunch.c
+ * Cirrus MaverickCrunch context switching and handling
+ *
+ * Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/config.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/signal.h>
+#include <linux/sched.h>
+#include <linux/init.h>
+#include <asm/arch/ep93xx-regs.h>
+#include <asm/thread_notify.h>
+#include <asm/io.h>
+
+struct crunch_state *crunch_owner;
+
+void crunch_task_release(struct thread_info *thread)
+{
+        local_irq_disable();
+        if (crunch_owner == &thread->crunchstate)
+                crunch_owner = NULL;
+        local_irq_enable();
+}
+
+static int crunch_enabled(u32 devcfg)
+{
+        return !!(devcfg & EP93XX_SYSCON_DEVICE_CONFIG_CRUNCH_ENABLE);
+}
+
+static int crunch_do(struct notifier_block *self, unsigned long cmd, void *t)
+{
+        struct thread_info *thread = (struct thread_info *)t;
+        struct crunch_state *crunch_state;
+        u32 devcfg;
+
+        crunch_state = &thread->crunchstate;
+
+        switch (cmd) {
+        case THREAD_NOTIFY_FLUSH:
+                memset(crunch_state, 0, sizeof(*crunch_state));
+
+                /*
+                 * FALLTHROUGH: Ensure we don't try to overwrite our newly
+                 * initialised state information on the first fault.
+                 */
+
+        case THREAD_NOTIFY_RELEASE:
+                crunch_task_release(thread);
+                break;
+
+        case THREAD_NOTIFY_SWITCH:
+                devcfg = __raw_readl(EP93XX_SYSCON_DEVICE_CONFIG);
+                if (crunch_enabled(devcfg) || crunch_owner == crunch_state) {
+                        devcfg ^= EP93XX_SYSCON_DEVICE_CONFIG_CRUNCH_ENABLE;
+                        __raw_writel(0xaa, EP93XX_SYSCON_SWLOCK);
+                        __raw_writel(devcfg, EP93XX_SYSCON_DEVICE_CONFIG);
+                }
+                break;
+        }
+
+        return NOTIFY_DONE;
+}
+
+static struct notifier_block crunch_notifier_block = {
+        .notifier_call  = crunch_do,
+};
+
+static int __init crunch_init(void)
+{
+        thread_register_notifier(&crunch_notifier_block);
+
+        return 0;
+}
+
+late_initcall(crunch_init);
diff --git a/arch/arm/kernel/entry-armv.S b/arch/arm/kernel/entry-armv.S
index 86c92523a346..6423a38839b8 100644
--- a/arch/arm/kernel/entry-armv.S
+++ b/arch/arm/kernel/entry-armv.S
@@ -492,9 +492,15 @@ call_fpe:
         b       do_fpe                          @ CP#1 (FPE)
         b       do_fpe                          @ CP#2 (FPE)
         mov     pc, lr                          @ CP#3
+#ifdef CONFIG_CRUNCH
+        b       crunch_task_enable              @ CP#4 (MaverickCrunch)
+        b       crunch_task_enable              @ CP#5 (MaverickCrunch)
+        b       crunch_task_enable              @ CP#6 (MaverickCrunch)
+#else
         mov     pc, lr                          @ CP#4
         mov     pc, lr                          @ CP#5
         mov     pc, lr                          @ CP#6
+#endif
         mov     pc, lr                          @ CP#7
         mov     pc, lr                          @ CP#8
         mov     pc, lr                          @ CP#9
diff --git a/arch/arm/kernel/ptrace.c b/arch/arm/kernel/ptrace.c
index a1d1b2906e8d..c40bdc770054 100644
--- a/arch/arm/kernel/ptrace.c
+++ b/arch/arm/kernel/ptrace.c
@@ -634,6 +634,32 @@ static int ptrace_setwmmxregs(struct task_struct *tsk, void __user *ufp)
 
 #endif
 
+#ifdef CONFIG_CRUNCH
+/*
+ * Get the child Crunch state.
+ */
+static int ptrace_getcrunchregs(struct task_struct *tsk, void __user *ufp)
+{
+        struct thread_info *thread = task_thread_info(tsk);
+
+        crunch_task_disable(thread);  /* force it to ram */
+        return copy_to_user(ufp, &thread->crunchstate, CRUNCH_SIZE)
+                ? -EFAULT : 0;
+}
+
+/*
+ * Set the child Crunch state.
+ */
+static int ptrace_setcrunchregs(struct task_struct *tsk, void __user *ufp)
+{
+        struct thread_info *thread = task_thread_info(tsk);
+
+        crunch_task_release(thread);  /* force a reload */
+        return copy_from_user(&thread->crunchstate, ufp, CRUNCH_SIZE)
+                ? -EFAULT : 0;
+}
+#endif
+
 long arch_ptrace(struct task_struct *child, long request, long addr, long data)
 {
         unsigned long tmp;
@@ -765,6 +791,16 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                         child->ptrace_message = data;
                         break;
 
+#ifdef CONFIG_CRUNCH
+                case PTRACE_GETCRUNCHREGS:
+                        ret = ptrace_getcrunchregs(child, (void __user *)data);
+                        break;
+
+                case PTRACE_SETCRUNCHREGS:
+                        ret = ptrace_setcrunchregs(child, (void __user *)data);
+                        break;
+#endif
+
                 default:
                         ret = ptrace_request(child, request, addr, data);
                         break;
diff --git a/arch/arm/kernel/signal.c b/arch/arm/kernel/signal.c
index 1ce05ec086c6..83a8d3c95eb3 100644
--- a/arch/arm/kernel/signal.c
+++ b/arch/arm/kernel/signal.c
@@ -132,6 +132,37 @@ sys_sigaction(int sig, const struct old_sigaction __user *act,
         return ret;
 }
 
+#ifdef CONFIG_CRUNCH
+static int preserve_crunch_context(struct crunch_sigframe *frame)
+{
+        char kbuf[sizeof(*frame) + 8];
+        struct crunch_sigframe *kframe;
+
+        /* the crunch context must be 64 bit aligned */
+        kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
+        kframe->magic = CRUNCH_MAGIC;
+        kframe->size = CRUNCH_STORAGE_SIZE;
+        crunch_task_copy(current_thread_info(), &kframe->storage);
+        return __copy_to_user(frame, kframe, sizeof(*frame));
+}
+
+static int restore_crunch_context(struct crunch_sigframe *frame)
+{
+        char kbuf[sizeof(*frame) + 8];
+        struct crunch_sigframe *kframe;
+
+        /* the crunch context must be 64 bit aligned */
+        kframe = (struct crunch_sigframe *)((unsigned long)(kbuf + 8) & ~7);
+        if (__copy_from_user(kframe, frame, sizeof(*frame)))
+                return -1;
+        if (kframe->magic != CRUNCH_MAGIC ||
+            kframe->size != CRUNCH_STORAGE_SIZE)
+                return -1;
+        crunch_task_restore(current_thread_info(), &kframe->storage);
+        return 0;
+}
+#endif
+
 #ifdef CONFIG_IWMMXT
 
 static int preserve_iwmmxt_context(struct iwmmxt_sigframe *frame)
@@ -214,6 +245,10 @@ static int restore_sigframe(struct pt_regs *regs, struct sigframe __user *sf)
         err |= !valid_user_regs(regs);
 
         aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
+#ifdef CONFIG_CRUNCH
+        if (err == 0)
+                err |= restore_crunch_context(&aux->crunch);
+#endif
 #ifdef CONFIG_IWMMXT
         if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
                 err |= restore_iwmmxt_context(&aux->iwmmxt);
@@ -333,6 +368,10 @@ setup_sigframe(struct sigframe __user *sf, struct pt_regs *regs, sigset_t *set)
         err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(*set));
 
         aux = (struct aux_sigframe __user *) sf->uc.uc_regspace;
+#ifdef CONFIG_CRUNCH
+        if (err == 0)
+                err |= preserve_crunch_context(&aux->crunch);
+#endif
 #ifdef CONFIG_IWMMXT
         if (err == 0 && test_thread_flag(TIF_USING_IWMMXT))
                 err |= preserve_iwmmxt_context(&aux->iwmmxt);
diff --git a/arch/arm/kernel/vmlinux.lds.S b/arch/arm/kernel/vmlinux.lds.S
index 2b254e88595c..2df9688a7028 100644
--- a/arch/arm/kernel/vmlinux.lds.S
+++ b/arch/arm/kernel/vmlinux.lds.S
@@ -80,6 +80,10 @@ SECTIONS
                 *(.exit.text)
                 *(.exit.data)
                 *(.exitcall.exit)
+#ifndef CONFIG_MMU
+                *(.fixup)
+                *(__ex_table)
+#endif
         }
 
         .text : {                       /* Real text segment            */
@@ -87,7 +91,9 @@ SECTIONS
                         *(.text)
                         SCHED_TEXT
                         LOCK_TEXT
+#ifdef CONFIG_MMU
                         *(.fixup)
+#endif
                         *(.gnu.warning)
                         *(.rodata)
                         *(.rodata.*)
@@ -142,7 +148,9 @@ SECTIONS
                  */
                 . = ALIGN(32);
                 __start___ex_table = .;
+#ifdef CONFIG_MMU
                 *(__ex_table)
+#endif
                 __stop___ex_table = .;
 
                 /*
diff --git a/arch/arm/lib/Makefile b/arch/arm/lib/Makefile
index 7b726b627ea5..30351cd4560d 100644
--- a/arch/arm/lib/Makefile
+++ b/arch/arm/lib/Makefile
@@ -6,28 +6,31 @@
 
 lib-y           := backtrace.o changebit.o csumipv6.o csumpartial.o   \
                    csumpartialcopy.o csumpartialcopyuser.o clearbit.o \
-                   copy_page.o delay.o findbit.o memchr.o memcpy.o    \
+                   delay.o findbit.o memchr.o memcpy.o                \
                    memmove.o memset.o memzero.o setbit.o              \
                    strncpy_from_user.o strnlen_user.o                 \
                    strchr.o strrchr.o                                 \
                    testchangebit.o testclearbit.o testsetbit.o        \
-                   getuser.o putuser.o clear_user.o                   \
                    ashldi3.o ashrdi3.o lshrdi3.o muldi3.o             \
                    ucmpdi2.o lib1funcs.o div64.o sha1.o               \
                    io-readsb.o io-writesb.o io-readsl.o io-writesl.o
 
+mmu-y   := clear_user.o copy_page.o getuser.o putuser.o
+
 # the code in uaccess.S is not preemption safe and
 # probably faster on ARMv3 only
 ifeq ($(CONFIG_PREEMPT),y)
-  lib-y += copy_from_user.o copy_to_user.o
+  mmu-y += copy_from_user.o copy_to_user.o
 else
 ifneq ($(CONFIG_CPU_32v3),y)
-  lib-y += copy_from_user.o copy_to_user.o
+  mmu-y += copy_from_user.o copy_to_user.o
 else
-  lib-y += uaccess.o
+  mmu-y += uaccess.o
 endif
 endif
 
+lib-$(CONFIG_MMU) += $(mmu-y)
+
 ifeq ($(CONFIG_CPU_32v3),y)
   lib-y += io-readsw-armv3.o io-writesw-armv3.o
 else
diff --git a/arch/arm/lib/backtrace.S b/arch/arm/lib/backtrace.S
index 058b80d72aa1..91f993f2e9db 100644
--- a/arch/arm/lib/backtrace.S
+++ b/arch/arm/lib/backtrace.S
@@ -97,16 +97,13 @@ ENTRY(c_backtrace)
                 b       1007f
 
 /*
- * Fixup for LDMDB
+ * Fixup for LDMDB.  Note that this must not be in the fixup section.
  */
-                .section .fixup,"ax"
-                .align  0
 1007:           ldr     r0, =.Lbad
                 mov     r1, frame
                 bl      printk
                 ldmfd   sp!, {r4 - r8, pc}
                 .ltorg
-                .previous
                 
                 .section __ex_table,"a"
                 .align  3
diff --git a/arch/arm/lib/clear_user.S b/arch/arm/lib/clear_user.S
index ea435ae2e4a5..ecb28dcdaf7b 100644
--- a/arch/arm/lib/clear_user.S
+++ b/arch/arm/lib/clear_user.S
@@ -12,13 +12,13 @@
 
                 .text
 
-/* Prototype: int __arch_clear_user(void *addr, size_t sz)
+/* Prototype: int __clear_user(void *addr, size_t sz)
  * Purpose  : clear some user memory
  * Params   : addr - user memory address to clear
  *          : sz   - number of bytes to clear
  * Returns  : number of bytes NOT cleared
  */
-ENTRY(__arch_clear_user)
+ENTRY(__clear_user)
                 stmfd   sp!, {r1, lr}
                 mov     r2, #0
                 cmp     r1, #4
diff --git a/arch/arm/lib/copy_from_user.S b/arch/arm/lib/copy_from_user.S
index 7497393a0e81..6b7363ce749c 100644
--- a/arch/arm/lib/copy_from_user.S
+++ b/arch/arm/lib/copy_from_user.S
@@ -16,7 +16,7 @@
 /*
  * Prototype:
  *
- *      size_t __arch_copy_from_user(void *to, const void *from, size_t n)
+ *      size_t __copy_from_user(void *to, const void *from, size_t n)
  *
  * Purpose:
  *
@@ -83,7 +83,7 @@
 
         .text
 
-ENTRY(__arch_copy_from_user)
+ENTRY(__copy_from_user)
 
 #include "copy_template.S"
 
diff --git a/arch/arm/lib/copy_to_user.S b/arch/arm/lib/copy_to_user.S
index 4a6d8ea14022..5224d94688d9 100644
--- a/arch/arm/lib/copy_to_user.S
+++ b/arch/arm/lib/copy_to_user.S
@@ -16,7 +16,7 @@
 /*
  * Prototype:
  *
- *      size_t __arch_copy_to_user(void *to, const void *from, size_t n)
+ *      size_t __copy_to_user(void *to, const void *from, size_t n)
  *
  * Purpose:
  *
@@ -86,7 +86,7 @@
 
         .text
 
-ENTRY(__arch_copy_to_user)
+ENTRY(__copy_to_user)
 
 #include "copy_template.S"
 
diff --git a/arch/arm/lib/strncpy_from_user.S b/arch/arm/lib/strncpy_from_user.S
index 35649f04fcac..36e3741a3772 100644
--- a/arch/arm/lib/strncpy_from_user.S
+++ b/arch/arm/lib/strncpy_from_user.S
@@ -20,7 +20,7 @@
  * returns the number of characters copied (strlen of copied string),
  *  -EFAULT on exception, or "len" if we fill the whole buffer
  */
-ENTRY(__arch_strncpy_from_user)
+ENTRY(__strncpy_from_user)
         mov     ip, r1
 1:      subs    r2, r2, #1
 USER(   ldrplbt r3, [r1], #1)
diff --git a/arch/arm/lib/strnlen_user.S b/arch/arm/lib/strnlen_user.S
index 3668a15991ef..18d8fa4f925a 100644
--- a/arch/arm/lib/strnlen_user.S
+++ b/arch/arm/lib/strnlen_user.S
@@ -14,13 +14,13 @@
         .text
         .align  5
 
-/* Prototype: unsigned long __arch_strnlen_user(const char *str, long n)
+/* Prototype: unsigned long __strnlen_user(const char *str, long n)
  * Purpose  : get length of a string in user memory
  * Params   : str - address of string in user memory
  * Returns  : length of string *including terminator*
  *            or zero on exception, or n + 1 if too long
  */
-ENTRY(__arch_strnlen_user)
+ENTRY(__strnlen_user)
         mov     r2, r0
 1:
 USER(   ldrbt   r3, [r0], #1)
diff --git a/arch/arm/lib/uaccess.S b/arch/arm/lib/uaccess.S
index 1f1545d737be..b48bd6d5fd83 100644
--- a/arch/arm/lib/uaccess.S
+++ b/arch/arm/lib/uaccess.S
@@ -19,7 +19,7 @@
 
 #define PAGE_SHIFT 12
 
-/* Prototype: int __arch_copy_to_user(void *to, const char *from, size_t n)
+/* Prototype: int __copy_to_user(void *to, const char *from, size_t n)
  * Purpose  : copy a block to user memory from kernel memory
  * Params   : to   - user memory
  *          : from - kernel memory
@@ -39,7 +39,7 @@ USER(		strgtbt	r3, [r0], #1)			@ May fault
                 sub     r2, r2, ip
                 b       .Lc2u_dest_aligned
 
-ENTRY(__arch_copy_to_user)
+ENTRY(__copy_to_user)
                 stmfd   sp!, {r2, r4 - r7, lr}
                 cmp     r2, #4
                 blt     .Lc2u_not_enough
@@ -283,7 +283,7 @@ USER(		strgtbt	r3, [r0], #1)			@ May fault
 9001:           ldmfd   sp!, {r0, r4 - r7, pc}
                 .previous
 
-/* Prototype: unsigned long __arch_copy_from_user(void *to,const void *from,unsigned long n);
+/* Prototype: unsigned long __copy_from_user(void *to,const void *from,unsigned long n);
  * Purpose  : copy a block from user memory to kernel memory
  * Params   : to   - kernel memory
  *          : from - user memory
@@ -302,7 +302,7 @@ USER(		ldrgtbt	r3, [r1], #1)			@ May fault
                 sub     r2, r2, ip
                 b       .Lcfu_dest_aligned
 
-ENTRY(__arch_copy_from_user)
+ENTRY(__copy_from_user)
                 stmfd   sp!, {r0, r2, r4 - r7, lr}
                 cmp     r2, #4
                 blt     .Lcfu_not_enough
diff --git a/arch/arm/mach-ep93xx/Kconfig b/arch/arm/mach-ep93xx/Kconfig
index cec5a21ca4e3..e15e4c54a253 100644
--- a/arch/arm/mach-ep93xx/Kconfig
+++ b/arch/arm/mach-ep93xx/Kconfig
@@ -2,8 +2,19 @@ if ARCH_EP93XX
 
 menu "Cirrus EP93xx Implementation Options"
 
+config CRUNCH
+        bool "Support for MaverickCrunch"
+        help
+          Enable kernel support for MaverickCrunch.
+
 comment "EP93xx Platforms"
 
+config MACH_EDB9315
+        bool "Support Cirrus Logic EDB9315"
+        help
+          Say 'Y' here if you want your kernel to support the Cirrus
+          Logic EDB9315 Evaluation Board.
+
 config MACH_GESBC9312
         bool "Support Glomation GESBC-9312-sx"
         help
diff --git a/arch/arm/mach-ep93xx/Makefile b/arch/arm/mach-ep93xx/Makefile
index 05a48a21038e..dfa7e2e8a18b 100644
--- a/arch/arm/mach-ep93xx/Makefile
+++ b/arch/arm/mach-ep93xx/Makefile
@@ -6,5 +6,6 @@ obj-m			:=
 obj-n                   :=
 obj-                    :=
 
+obj-$(CONFIG_MACH_EDB9315)      += edb9315.o
 obj-$(CONFIG_MACH_GESBC9312)    += gesbc9312.o
 obj-$(CONFIG_MACH_TS72XX)       += ts72xx.o
diff --git a/arch/arm/mach-ep93xx/edb9315.c b/arch/arm/mach-ep93xx/edb9315.c
new file mode 100644
index 000000000000..ef7482faad81
--- /dev/null
+++ b/arch/arm/mach-ep93xx/edb9315.c
@@ -0,0 +1,62 @@
+/*
+ * arch/arm/mach-ep93xx/edb9315.c
+ * Cirrus Logic EDB9315 support.
+ *
+ * Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
+ *
+ * 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.
+ */
+
+#include <linux/config.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/mm.h>
+#include <linux/sched.h>
+#include <linux/interrupt.h>
+#include <linux/ioport.h>
+#include <linux/mtd/physmap.h>
+#include <linux/platform_device.h>
+#include <asm/io.h>
+#include <asm/hardware.h>
+#include <asm/mach-types.h>
+#include <asm/mach/arch.h>
+
+static struct physmap_flash_data edb9315_flash_data = {
+        .width          = 4,
+};
+
+static struct resource edb9315_flash_resource = {
+        .start          = 0x60000000,
+        .end            = 0x61ffffff,
+        .flags          = IORESOURCE_MEM,
+};
+
+static struct platform_device edb9315_flash = {
+        .name           = "physmap-flash",
+        .id             = 0,
+        .dev            = {
+                .platform_data  = &edb9315_flash_data,
+        },
+        .num_resources  = 1,
+        .resource       = &edb9315_flash_resource,
+};
+
+static void __init edb9315_init_machine(void)
+{
+        ep93xx_init_devices();
+        platform_device_register(&edb9315_flash);
+}
+
+MACHINE_START(EDB9315, "Cirrus Logic EDB9315 Evaluation Board")
+        /* Maintainer: Lennert Buytenhek <buytenh@wantstofly.org> */
+        .phys_io        = EP93XX_APB_PHYS_BASE,
+        .io_pg_offst    = ((EP93XX_APB_VIRT_BASE) >> 18) & 0xfffc,
+        .boot_params    = 0x00000100,
+        .map_io         = ep93xx_map_io,
+        .init_irq       = ep93xx_init_irq,
+        .timer          = &ep93xx_timer,
+        .init_machine   = edb9315_init_machine,
+MACHINE_END
diff --git a/arch/arm/mach-ep93xx/gesbc9312.c b/arch/arm/mach-ep93xx/gesbc9312.c
index 47cc6c8b7c79..2c28d66d260e 100644
--- a/arch/arm/mach-ep93xx/gesbc9312.c
+++ b/arch/arm/mach-ep93xx/gesbc9312.c
@@ -30,7 +30,7 @@ static struct physmap_flash_data gesbc9312_flash_data = {
 
 static struct resource gesbc9312_flash_resource = {
         .start          = 0x60000000,
-        .end            = 0x60800000,
+        .end            = 0x607fffff,
         .flags          = IORESOURCE_MEM,
 };
 
diff --git a/arch/arm/mach-ep93xx/ts72xx.c b/arch/arm/mach-ep93xx/ts72xx.c
index 6e5a56cd5ae8..0b3b875b1875 100644
--- a/arch/arm/mach-ep93xx/ts72xx.c
+++ b/arch/arm/mach-ep93xx/ts72xx.c
@@ -118,7 +118,7 @@ static struct physmap_flash_data ts72xx_flash_data = {
 
 static struct resource ts72xx_flash_resource = {
         .start          = TS72XX_NOR_PHYS_BASE,
-        .end            = TS72XX_NOR_PHYS_BASE + 0x01000000,
+        .end            = TS72XX_NOR_PHYS_BASE + 0x00ffffff,
         .flags          = IORESOURCE_MEM,
 };
 
diff --git a/arch/arm/mach-ixp23xx/espresso.c b/arch/arm/mach-ixp23xx/espresso.c
index dc5e489c70bc..357351fbb1e2 100644
--- a/arch/arm/mach-ixp23xx/espresso.c
+++ b/arch/arm/mach-ixp23xx/espresso.c
@@ -59,7 +59,7 @@ static struct physmap_flash_data espresso_flash_data = {
 
 static struct resource espresso_flash_resource = {
         .start          = 0x90000000,
-        .end            = 0x92000000,
+        .end            = 0x91ffffff,
         .flags          = IORESOURCE_MEM,
 };
 
diff --git a/arch/arm/mach-ixp23xx/ixdp2351.c b/arch/arm/mach-ixp23xx/ixdp2351.c
index 535b334ee045..e0886871cc77 100644
--- a/arch/arm/mach-ixp23xx/ixdp2351.c
+++ b/arch/arm/mach-ixp23xx/ixdp2351.c
@@ -304,7 +304,7 @@ static struct physmap_flash_data ixdp2351_flash_data = {
 
 static struct resource ixdp2351_flash_resource = {
         .start          = 0x90000000,
-        .end            = 0x94000000,
+        .end            = 0x93ffffff,
         .flags          = IORESOURCE_MEM,
 };
 
diff --git a/arch/arm/mach-ixp23xx/roadrunner.c b/arch/arm/mach-ixp23xx/roadrunner.c
index b9f5d13fcfe1..92ad18f41251 100644
--- a/arch/arm/mach-ixp23xx/roadrunner.c
+++ b/arch/arm/mach-ixp23xx/roadrunner.c
@@ -143,7 +143,7 @@ static struct physmap_flash_data roadrunner_flash_data = {
 
 static struct resource roadrunner_flash_resource = {
         .start          = 0x90000000,
-        .end            = 0x94000000,
+        .end            = 0x93ffffff,
         .flags          = IORESOURCE_MEM,
 };
 
diff --git a/arch/arm/mach-pxa/irq.c b/arch/arm/mach-pxa/irq.c
index 539b596005fc..d9635ff4b10c 100644
--- a/arch/arm/mach-pxa/irq.c
+++ b/arch/arm/mach-pxa/irq.c
@@ -88,8 +88,8 @@ static int pxa_gpio_irq_type(unsigned int irq, unsigned int type)
 
         if (type == IRQT_PROBE) {
             /* Don't mess with enabled GPIOs using preconfigured edges or
-               GPIOs set to alternate function during probe */
-                if ((GPIO_IRQ_rising_edge[idx] | GPIO_IRQ_falling_edge[idx]) &
+               GPIOs set to alternate function or to output during probe */
+                if ((GPIO_IRQ_rising_edge[idx] | GPIO_IRQ_falling_edge[idx] | GPDR(gpio)) &
                     GPIO_bit(gpio))
                         return 0;
                 if (GAFR(gpio) & (0x3 << (((gpio) & 0xf)*2)))
diff --git a/arch/arm/mach-s3c2410/s3c244x.c b/arch/arm/mach-s3c2410/s3c244x.c
index 838bc525e836..9a2258270de9 100644
--- a/arch/arm/mach-s3c2410/s3c244x.c
+++ b/arch/arm/mach-s3c2410/s3c244x.c
@@ -69,6 +69,7 @@ void __init s3c244x_map_io(struct map_desc *mach_desc, int size)
 
         s3c_device_i2c.name  = "s3c2440-i2c";
         s3c_device_nand.name = "s3c2440-nand";
+        s3c_device_usbgadget.name = "s3c2440-usbgadget";
 }
 
 void __init s3c244x_init_clocks(int xtal)
diff --git a/arch/arm/mm/Kconfig b/arch/arm/mm/Kconfig
index ecf5e232a6fc..c4bca753165b 100644
--- a/arch/arm/mm/Kconfig
+++ b/arch/arm/mm/Kconfig
@@ -15,8 +15,8 @@ config CPU_ARM610
         select CPU_32v3
         select CPU_CACHE_V3
         select CPU_CACHE_VIVT
-        select CPU_COPY_V3
-        select CPU_TLB_V3
+        select CPU_COPY_V3 if MMU
+        select CPU_TLB_V3 if MMU
         help
           The ARM610 is the successor to the ARM3 processor
           and was produced by VLSI Technology Inc.
@@ -31,8 +31,8 @@ config CPU_ARM710
         select CPU_32v3
         select CPU_CACHE_V3
         select CPU_CACHE_VIVT
-        select CPU_COPY_V3
-        select CPU_TLB_V3
+        select CPU_COPY_V3 if MMU
+        select CPU_TLB_V3 if MMU
         help
           A 32-bit RISC microprocessor based on the ARM7 processor core
           designed by Advanced RISC Machines Ltd. The ARM710 is the
@@ -50,8 +50,8 @@ config CPU_ARM720T
         select CPU_ABRT_LV4T
         select CPU_CACHE_V4
         select CPU_CACHE_VIVT
-        select CPU_COPY_V4WT
-        select CPU_TLB_V4WT
+        select CPU_COPY_V4WT if MMU
+        select CPU_TLB_V4WT if MMU
         help
           A 32-bit RISC processor with 8kByte Cache, Write Buffer and
           MMU built around an ARM7TDMI core.
@@ -68,8 +68,8 @@ config CPU_ARM920T
         select CPU_ABRT_EV4T
         select CPU_CACHE_V4WT
         select CPU_CACHE_VIVT
-        select CPU_COPY_V4WB
-        select CPU_TLB_V4WBI
+        select CPU_COPY_V4WB if MMU
+        select CPU_TLB_V4WBI if MMU
         help
           The ARM920T is licensed to be produced by numerous vendors,
           and is used in the Maverick EP9312 and the Samsung S3C2410.
@@ -89,8 +89,8 @@ config CPU_ARM922T
         select CPU_ABRT_EV4T
         select CPU_CACHE_V4WT
         select CPU_CACHE_VIVT
-        select CPU_COPY_V4WB
-        select CPU_TLB_V4WBI
+        select CPU_COPY_V4WB if MMU
+        select CPU_TLB_V4WBI if MMU
         help
           The ARM922T is a version of the ARM920T, but with smaller
           instruction and data caches. It is used in Altera's
@@ -108,8 +108,8 @@ config CPU_ARM925T
         select CPU_ABRT_EV4T
         select CPU_CACHE_V4WT
         select CPU_CACHE_VIVT
-        select CPU_COPY_V4WB
-        select CPU_TLB_V4WBI
+        select CPU_COPY_V4WB if MMU
+        select CPU_TLB_V4WBI if MMU
         help
           The ARM925T is a mix between the ARM920T and ARM926T, but with
           different instruction and data caches. It is used in TI's OMAP
@@ -126,8 +126,8 @@ config CPU_ARM926T
         select CPU_32v5
         select CPU_ABRT_EV5TJ
         select CPU_CACHE_VIVT
-        select CPU_COPY_V4WB
-        select CPU_TLB_V4WBI
+        select CPU_COPY_V4WB if MMU
+        select CPU_TLB_V4WBI if MMU
         help
           This is a variant of the ARM920.  It has slightly different
           instruction sequences for cache and TLB operations.  Curiously,
@@ -144,8 +144,8 @@ config CPU_ARM1020
         select CPU_ABRT_EV4T
         select CPU_CACHE_V4WT
         select CPU_CACHE_VIVT
-        select CPU_COPY_V4WB
-        select CPU_TLB_V4WBI
+        select CPU_COPY_V4WB if MMU
+        select CPU_TLB_V4WBI if MMU
         help
           The ARM1020 is the 32K cached version of the ARM10 processor,
           with an addition of a floating-point unit.
@@ -161,8 +161,8 @@ config CPU_ARM1020E
         select CPU_ABRT_EV4T
         select CPU_CACHE_V4WT
         select CPU_CACHE_VIVT
-        select CPU_COPY_V4WB
-        select CPU_TLB_V4WBI
+        select CPU_COPY_V4WB if MMU
+        select CPU_TLB_V4WBI if MMU
         depends on n
 
 # ARM1022E
@@ -172,8 +172,8 @@ config CPU_ARM1022
         select CPU_32v5
         select CPU_ABRT_EV4T
         select CPU_CACHE_VIVT
-        select CPU_COPY_V4WB # can probably do better
-        select CPU_TLB_V4WBI
+        select CPU_COPY_V4WB if MMU # can probably do better
+        select CPU_TLB_V4WBI if MMU
         help
           The ARM1022E is an implementation of the ARMv5TE architecture
           based upon the ARM10 integer core with a 16KiB L1 Harvard cache,
@@ -189,8 +189,8 @@ config CPU_ARM1026
         select CPU_32v5
         select CPU_ABRT_EV5T # But need Jazelle, but EV5TJ ignores bit 10
         select CPU_CACHE_VIVT
-        select CPU_COPY_V4WB # can probably do better
-        select CPU_TLB_V4WBI
+        select CPU_COPY_V4WB if MMU # can probably do better
+        select CPU_TLB_V4WBI if MMU
         help
           The ARM1026EJ-S is an implementation of the ARMv5TEJ architecture
           based upon the ARM10 integer core.
@@ -207,8 +207,8 @@ config CPU_SA110
         select CPU_ABRT_EV4
         select CPU_CACHE_V4WB
         select CPU_CACHE_VIVT
-        select CPU_COPY_V4WB
-        select CPU_TLB_V4WB
+        select CPU_COPY_V4WB if MMU
+        select CPU_TLB_V4WB if MMU
         help
           The Intel StrongARM(R) SA-110 is a 32-bit microprocessor and
           is available at five speeds ranging from 100 MHz to 233 MHz.
@@ -227,7 +227,7 @@ config CPU_SA1100
         select CPU_ABRT_EV4
         select CPU_CACHE_V4WB
         select CPU_CACHE_VIVT
-        select CPU_TLB_V4WB
+        select CPU_TLB_V4WB if MMU
 
 # XScale
 config CPU_XSCALE
@@ -237,7 +237,7 @@ config CPU_XSCALE
         select CPU_32v5
         select CPU_ABRT_EV5T
         select CPU_CACHE_VIVT
-        select CPU_TLB_V4WBI
+        select CPU_TLB_V4WBI if MMU
 
 # XScale Core Version 3
 config CPU_XSC3
@@ -247,7 +247,7 @@ config CPU_XSC3
         select CPU_32v5
         select CPU_ABRT_EV5T
         select CPU_CACHE_VIVT
-        select CPU_TLB_V4WBI
+        select CPU_TLB_V4WBI if MMU
         select IO_36
 
 # ARMv6
@@ -258,8 +258,8 @@ config CPU_V6
         select CPU_ABRT_EV6
         select CPU_CACHE_V6
         select CPU_CACHE_VIPT
-        select CPU_COPY_V6
-        select CPU_TLB_V6
+        select CPU_COPY_V6 if MMU
+        select CPU_TLB_V6 if MMU
 
 # ARMv6k
 config CPU_32v6K
@@ -277,17 +277,17 @@ config CPU_32v6K
 # This defines the compiler instruction set which depends on the machine type.
 config CPU_32v3
         bool
-        select TLS_REG_EMUL if SMP
+        select TLS_REG_EMUL if SMP || !MMU
         select NEEDS_SYSCALL_FOR_CMPXCHG if SMP
 
 config CPU_32v4
         bool
-        select TLS_REG_EMUL if SMP
+        select TLS_REG_EMUL if SMP || !MMU
         select NEEDS_SYSCALL_FOR_CMPXCHG if SMP
 
 config CPU_32v5
         bool
-        select TLS_REG_EMUL if SMP
+        select TLS_REG_EMUL if SMP || !MMU
         select NEEDS_SYSCALL_FOR_CMPXCHG if SMP
 
 config CPU_32v6
@@ -334,6 +334,7 @@ config CPU_CACHE_VIVT
 config CPU_CACHE_VIPT
         bool
 
+if MMU
 # The copy-page model
 config CPU_COPY_V3
         bool
@@ -372,6 +373,8 @@ config CPU_TLB_V4WBI
 config CPU_TLB_V6
         bool
 
+endif
+
 #
 # CPU supports 36-bit I/O
 #
diff --git a/arch/arm/mm/Makefile b/arch/arm/mm/Makefile
index 07a538505784..21a2770226ee 100644
--- a/arch/arm/mm/Makefile
+++ b/arch/arm/mm/Makefile
@@ -2,10 +2,16 @@
 # Makefile for the linux arm-specific parts of the memory manager.
 #
 
-obj-y                           := consistent.o extable.o fault-armv.o \
-                                   fault.o flush.o init.o ioremap.o mmap.o \
+obj-y                           := consistent.o extable.o fault.o init.o \
+                                   iomap.o
+
+obj-$(CONFIG_MMU)               += fault-armv.o flush.o ioremap.o mmap.o \
                                    mm-armv.o
 
+ifneq ($(CONFIG_MMU),y)
+obj-y                           += nommu.o
+endif
+
 obj-$(CONFIG_MODULES)           += proc-syms.o
 
 obj-$(CONFIG_ALIGNMENT_TRAP)    += alignment.o
diff --git a/arch/arm/mm/init.c b/arch/arm/mm/init.c
index 9ea1f87a7079..989fd681c822 100644
--- a/arch/arm/mm/init.c
+++ b/arch/arm/mm/init.c
@@ -26,8 +26,6 @@
 #include <asm/mach/arch.h>
 #include <asm/mach/map.h>
 
-#define TABLE_SIZE      (2 * PTRS_PER_PTE * sizeof(pte_t))
-
 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
 
 extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
diff --git a/arch/arm/mm/iomap.c b/arch/arm/mm/iomap.c
new file mode 100644
index 000000000000..62066f3020c8
--- /dev/null
+++ b/arch/arm/mm/iomap.c
@@ -0,0 +1,55 @@
+/*
+ *  linux/arch/arm/mm/iomap.c
+ *
+ * Map IO port and PCI memory spaces so that {read,write}[bwl] can
+ * be used to access this memory.
+ */
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/ioport.h>
+
+#include <asm/io.h>
+
+#ifdef __io
+void __iomem *ioport_map(unsigned long port, unsigned int nr)
+{
+        return __io(port);
+}
+EXPORT_SYMBOL(ioport_map);
+
+void ioport_unmap(void __iomem *addr)
+{
+}
+EXPORT_SYMBOL(ioport_unmap);
+#endif
+
+#ifdef CONFIG_PCI
+void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen)
+{
+        unsigned long start = pci_resource_start(dev, bar);
+        unsigned long len   = pci_resource_len(dev, bar);
+        unsigned long flags = pci_resource_flags(dev, bar);
+
+        if (!len || !start)
+                return NULL;
+        if (maxlen && len > maxlen)
+                len = maxlen;
+        if (flags & IORESOURCE_IO)
+                return ioport_map(start, len);
+        if (flags & IORESOURCE_MEM) {
+                if (flags & IORESOURCE_CACHEABLE)
+                        return ioremap(start, len);
+                return ioremap_nocache(start, len);
+        }
+        return NULL;
+}
+EXPORT_SYMBOL(pci_iomap);
+
+void pci_iounmap(struct pci_dev *dev, void __iomem *addr)
+{
+        if ((unsigned long)addr >= VMALLOC_START &&
+            (unsigned long)addr < VMALLOC_END)
+                iounmap(addr);
+}
+EXPORT_SYMBOL(pci_iounmap);
+#endif
diff --git a/arch/arm/mm/ioremap.c b/arch/arm/mm/ioremap.c
index c1f7180c7bed..7691cfdba567 100644
--- a/arch/arm/mm/ioremap.c
+++ b/arch/arm/mm/ioremap.c
@@ -176,50 +176,3 @@ void __iounmap(void __iomem *addr)
         vunmap((void *)(PAGE_MASK & (unsigned long)addr));
 }
 EXPORT_SYMBOL(__iounmap);
-
-#ifdef __io
-void __iomem *ioport_map(unsigned long port, unsigned int nr)
-{
-        return __io(port);
-}
-EXPORT_SYMBOL(ioport_map);
-
-void ioport_unmap(void __iomem *addr)
-{
-}
-EXPORT_SYMBOL(ioport_unmap);
-#endif
-
-#ifdef CONFIG_PCI
-#include <linux/pci.h>
-#include <linux/ioport.h>
-
-void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen)
-{
-        unsigned long start = pci_resource_start(dev, bar);
-        unsigned long len   = pci_resource_len(dev, bar);
-        unsigned long flags = pci_resource_flags(dev, bar);
-
-        if (!len || !start)
-                return NULL;
-        if (maxlen && len > maxlen)
-                len = maxlen;
-        if (flags & IORESOURCE_IO)
-                return ioport_map(start, len);
-        if (flags & IORESOURCE_MEM) {
-                if (flags & IORESOURCE_CACHEABLE)
-                        return ioremap(start, len);
-                return ioremap_nocache(start, len);
-        }
-        return NULL;
-}
-EXPORT_SYMBOL(pci_iomap);
-
-void pci_iounmap(struct pci_dev *dev, void __iomem *addr)
-{
-        if ((unsigned long)addr >= VMALLOC_START &&
-            (unsigned long)addr < VMALLOC_END)
-                iounmap(addr);
-}
-EXPORT_SYMBOL(pci_iounmap);
-#endif
diff --git a/arch/arm/mm/nommu.c b/arch/arm/mm/nommu.c
new file mode 100644
index 000000000000..1464ed817b5d
--- /dev/null
+++ b/arch/arm/mm/nommu.c
@@ -0,0 +1,39 @@
+/*
+ *  linux/arch/arm/mm/nommu.c
+ *
+ * ARM uCLinux supporting functions.
+ */
+#include <linux/module.h>
+#include <linux/mm.h>
+#include <linux/pagemap.h>
+
+#include <asm/cacheflush.h>
+#include <asm/io.h>
+#include <asm/page.h>
+
+void flush_dcache_page(struct page *page)
+{
+        __cpuc_flush_dcache_page(page_address(page));
+}
+EXPORT_SYMBOL(flush_dcache_page);
+
+void __iomem *__ioremap_pfn(unsigned long pfn, unsigned long offset,
+                            size_t size, unsigned long flags)
+{
+        if (pfn >= (0x100000000ULL >> PAGE_SHIFT))
+                return NULL;
+        return (void __iomem *) (offset + (pfn << PAGE_SHIFT));
+}
+EXPORT_SYMBOL(__ioremap_pfn);
+
+void __iomem *__ioremap(unsigned long phys_addr, size_t size,
+                        unsigned long flags)
+{
+        return (void __iomem *)phys_addr;
+}
+EXPORT_SYMBOL(__ioremap);
+
+void __iounmap(void __iomem *addr)
+{
+}
+EXPORT_SYMBOL(__iounmap);
diff --git a/arch/arm/mm/proc-arm1020.S b/arch/arm/mm/proc-arm1020.S
index 959588884fa5..b9abbafca812 100644
--- a/arch/arm/mm/proc-arm1020.S
+++ b/arch/arm/mm/proc-arm1020.S
@@ -3,6 +3,7 @@
  *
  *  Copyright (C) 2000 ARM Limited
  *  Copyright (C) 2000 Deep Blue Solutions Ltd.
+ *  hacked for non-paged-MM by Hyok S. Choi, 2003.
  *
  * 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
@@ -101,7 +102,9 @@ ENTRY(cpu_arm1020_reset)
         mov     ip, #0
         mcr     p15, 0, ip, c7, c7, 0           @ invalidate I,D caches
         mcr     p15, 0, ip, c7, c10, 4          @ drain WB
+#ifdef CONFIG_MMU
         mcr     p15, 0, ip, c8, c7, 0           @ invalidate I & D TLBs
+#endif
         mrc     p15, 0, ip, c1, c0, 0           @ ctrl register
         bic     ip, ip, #0x000f                 @ ............wcam
         bic     ip, ip, #0x1100                 @ ...i...s........
@@ -359,6 +362,7 @@ ENTRY(cpu_arm1020_dcache_clean_area)
  */
         .align  5
 ENTRY(cpu_arm1020_switch_mm)
+#ifdef CONFIG_MMU
 #ifndef CONFIG_CPU_DCACHE_DISABLE
         mcr     p15, 0, r3, c7, c10, 4
         mov     r1, #0xF                        @ 16 segments
@@ -383,6 +387,7 @@ ENTRY(cpu_arm1020_switch_mm)
         mcr     p15, 0, r1, c7, c10, 4          @ drain WB
         mcr     p15, 0, r0, c2, c0, 0           @ load page table pointer
         mcr     p15, 0, r1, c8, c7, 0           @ invalidate I & D TLBs
+#endif /* CONFIG_MMU */
         mov     pc, lr
         
 /*
@@ -392,6 +397,7 @@ ENTRY(cpu_arm1020_switch_mm)
  */
         .align  5
 ENTRY(cpu_arm1020_set_pte)
+#ifdef CONFIG_MMU
         str     r1, [r0], #-2048                @ linux version
 
         eor     r1, r1, #L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_WRITE | L_PTE_DIRTY
@@ -421,6 +427,7 @@ ENTRY(cpu_arm1020_set_pte)
         mcr     p15, 0, r0, c7, c10, 1          @ clean D entry
 #endif
         mcr     p15, 0, r0, c7, c10, 4          @ drain WB
+#endif /* CONFIG_MMU */
         mov     pc, lr
 
         __INIT
@@ -430,7 +437,9 @@ __arm1020_setup:
         mov     r0, #0
         mcr     p15, 0, r0, c7, c7              @ invalidate I,D caches on v4
         mcr     p15, 0, r0, c7, c10, 4          @ drain write buffer on v4
+#ifdef CONFIG_MMU
         mcr     p15, 0, r0, c8, c7              @ invalidate I,D TLBs on v4
+#endif
         mrc     p15, 0, r0, c1, c0              @ get control register v4
         ldr     r5, arm1020_cr1_clear
         bic     r0, r0, r5
diff --git a/arch/arm/mm/proc-arm1020e.S b/arch/arm/mm/proc-arm1020e.S
index be6d081ff2b7..bcd5ee022e00 100644
--- a/arch/arm/mm/proc-arm1020e.S
+++ b/arch/arm/mm/proc-arm1020e.S
@@ -3,6 +3,7 @@
  *
  *  Copyright (C) 2000 ARM Limited
  *  Copyright (C) 2000 Deep Blue Solutions Ltd.
+ *  hacked for non-paged-MM by Hyok S. Choi, 2003.
  *
  * 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
@@ -101,7 +102,9 @@ ENTRY(cpu_arm1020e_reset)
         mov     ip, #0
         mcr     p15, 0, ip, c7, c7, 0           @ invalidate I,D caches
         mcr     p15, 0, ip, c7, c10, 4          @ drain WB
+#ifdef CONFIG_MMU
         mcr     p15, 0, ip, c8, c7, 0           @ invalidate I & D TLBs
+#endif
         mrc     p15, 0, ip, c1, c0, 0           @ ctrl register
         bic     ip, ip, #0x000f                 @ ............wcam
         bic     ip, ip, #0x1100                 @ ...i...s........
@@ -344,6 +347,7 @@ ENTRY(cpu_arm1020e_dcache_clean_area)
  */
         .align  5
 ENTRY(cpu_arm1020e_switch_mm)
+#ifdef CONFIG_MMU
 #ifndef CONFIG_CPU_DCACHE_DISABLE
         mcr     p15, 0, r3, c7, c10, 4
         mov     r1, #0xF                        @ 16 segments
@@ -367,6 +371,7 @@ ENTRY(cpu_arm1020e_switch_mm)
         mcr     p15, 0, r1, c7, c10, 4          @ drain WB
         mcr     p15, 0, r0, c2, c0, 0           @ load page table pointer
         mcr     p15, 0, r1, c8, c7, 0           @ invalidate I & D TLBs
+#endif
         mov     pc, lr
         
 /*
@@ -376,6 +381,7 @@ ENTRY(cpu_arm1020e_switch_mm)
  */
         .align  5
 ENTRY(cpu_arm1020e_set_pte)
+#ifdef CONFIG_MMU
         str     r1, [r0], #-2048                @ linux version
 
         eor     r1, r1, #L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_WRITE | L_PTE_DIRTY
@@ -403,6 +409,7 @@ ENTRY(cpu_arm1020e_set_pte)
 #ifndef CONFIG_CPU_DCACHE_DISABLE
         mcr     p15, 0, r0, c7, c10, 1          @ clean D entry
 #endif
+#endif /* CONFIG_MMU */
         mov     pc, lr
 
         __INIT
@@ -412,7 +419,9 @@ __arm1020e_setup:
         mov     r0, #0
         mcr     p15, 0, r0, c7, c7              @ invalidate I,D caches on v4
         mcr     p15, 0, r0, c7, c10, 4          @ drain write buffer on v4
+#ifdef CONFIG_MMU
         mcr     p15, 0, r0, c8, c7              @ invalidate I,D TLBs on v4
+#endif
         mrc     p15, 0, r0, c1, c0              @ get control register v4
         ldr     r5, arm1020e_cr1_clear
         bic     r0, r0, r5
diff --git a/arch/arm/mm/proc-arm1022.S b/arch/arm/mm/proc-arm1022.S
index f778545d57a2..b0ccff4fadd2 100644
--- a/arch/arm/mm/proc-arm1022.S
+++ b/arch/arm/mm/proc-arm1022.S
@@ -3,6 +3,7 @@
  *
  *  Copyright (C) 2000 ARM Limited
  *  Copyright (C) 2000 Deep Blue Solutions Ltd.
+ *  hacked for non-paged-MM by Hyok S. Choi, 2003.
  *
  * 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
@@ -90,7 +91,9 @@ ENTRY(cpu_arm1022_reset)
         mov     ip, #0
         mcr     p15, 0, ip, c7, c7, 0           @ invalidate I,D caches
         mcr     p15, 0, ip, c7, c10, 4          @ drain WB
+#ifdef CONFIG_MMU
         mcr     p15, 0, ip, c8, c7, 0           @ invalidate I & D TLBs
+#endif
         mrc     p15, 0, ip, c1, c0, 0           @ ctrl register
         bic     ip, ip, #0x000f                 @ ............wcam
         bic     ip, ip, #0x1100                 @ ...i...s........
@@ -333,6 +336,7 @@ ENTRY(cpu_arm1022_dcache_clean_area)
  */
         .align  5
 ENTRY(cpu_arm1022_switch_mm)
+#ifdef CONFIG_MMU
 #ifndef CONFIG_CPU_DCACHE_DISABLE
         mov     r1, #(CACHE_DSEGMENTS - 1) << 5 @ 16 segments
 1:      orr     r3, r1, #(CACHE_DENTRIES - 1) << 26 @ 64 entries
@@ -349,6 +353,7 @@ ENTRY(cpu_arm1022_switch_mm)
         mcr     p15, 0, r1, c7, c10, 4          @ drain WB
         mcr     p15, 0, r0, c2, c0, 0           @ load page table pointer
         mcr     p15, 0, r1, c8, c7, 0           @ invalidate I & D TLBs
+#endif
         mov     pc, lr
         
 /*
@@ -358,6 +363,7 @@ ENTRY(cpu_arm1022_switch_mm)
  */
         .align  5
 ENTRY(cpu_arm1022_set_pte)
+#ifdef CONFIG_MMU
         str     r1, [r0], #-2048                @ linux version
 
         eor     r1, r1, #L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_WRITE | L_PTE_DIRTY
@@ -385,6 +391,7 @@ ENTRY(cpu_arm1022_set_pte)
 #ifndef CONFIG_CPU_DCACHE_DISABLE
         mcr     p15, 0, r0, c7, c10, 1          @ clean D entry
 #endif
+#endif /* CONFIG_MMU */
         mov     pc, lr
 
         __INIT
@@ -394,7 +401,9 @@ __arm1022_setup:
         mov     r0, #0
         mcr     p15, 0, r0, c7, c7              @ invalidate I,D caches on v4
         mcr     p15, 0, r0, c7, c10, 4          @ drain write buffer on v4
+#ifdef CONFIG_MMU
         mcr     p15, 0, r0, c8, c7              @ invalidate I,D TLBs on v4
+#endif
         mrc     p15, 0, r0, c1, c0              @ get control register v4
         ldr     r5, arm1022_cr1_clear
         bic     r0, r0, r5
diff --git a/arch/arm/mm/proc-arm1026.S b/arch/arm/mm/proc-arm1026.S
index 148c111fde73..abe850c9a641 100644
--- a/arch/arm/mm/proc-arm1026.S
+++ b/arch/arm/mm/proc-arm1026.S
@@ -3,6 +3,7 @@
  *
  *  Copyright (C) 2000 ARM Limited
  *  Copyright (C) 2000 Deep Blue Solutions Ltd.
+ *  hacked for non-paged-MM by Hyok S. Choi, 2003.
  *
  * 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
@@ -90,7 +91,9 @@ ENTRY(cpu_arm1026_reset)
         mov     ip, #0
         mcr     p15, 0, ip, c7, c7, 0           @ invalidate I,D caches
         mcr     p15, 0, ip, c7, c10, 4          @ drain WB
+#ifdef CONFIG_MMU
         mcr     p15, 0, ip, c8, c7, 0           @ invalidate I & D TLBs
+#endif
         mrc     p15, 0, ip, c1, c0, 0           @ ctrl register
         bic     ip, ip, #0x000f                 @ ............wcam
         bic     ip, ip, #0x1100                 @ ...i...s........
@@ -327,6 +330,7 @@ ENTRY(cpu_arm1026_dcache_clean_area)
  */
         .align  5
 ENTRY(cpu_arm1026_switch_mm)
+#ifdef CONFIG_MMU
         mov     r1, #0
 #ifndef CONFIG_CPU_DCACHE_DISABLE
 1:      mrc     p15, 0, r15, c7, c14, 3         @ test, clean, invalidate
@@ -338,6 +342,7 @@ ENTRY(cpu_arm1026_switch_mm)
         mcr     p15, 0, r1, c7, c10, 4          @ drain WB
         mcr     p15, 0, r0, c2, c0, 0           @ load page table pointer
         mcr     p15, 0, r1, c8, c7, 0           @ invalidate I & D TLBs
+#endif
         mov     pc, lr
         
 /*
@@ -347,6 +352,7 @@ ENTRY(cpu_arm1026_switch_mm)
  */
         .align  5
 ENTRY(cpu_arm1026_set_pte)
+#ifdef CONFIG_MMU
         str     r1, [r0], #-2048                @ linux version
 
         eor     r1, r1, #L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_WRITE | L_PTE_DIRTY
@@ -374,6 +380,7 @@ ENTRY(cpu_arm1026_set_pte)
 #ifndef CONFIG_CPU_DCACHE_DISABLE
         mcr     p15, 0, r0, c7, c10, 1          @ clean D entry
 #endif
+#endif /* CONFIG_MMU */
         mov     pc, lr
 
 
@@ -384,8 +391,10 @@ __arm1026_setup:
         mov     r0, #0
         mcr     p15, 0, r0, c7, c7              @ invalidate I,D caches on v4
         mcr     p15, 0, r0, c7, c10, 4          @ drain write buffer on v4
+#ifdef CONFIG_MMU
         mcr     p15, 0, r0, c8, c7              @ invalidate I,D TLBs on v4
         mcr     p15, 0, r4, c2, c0              @ load page table pointer
+#endif
 #ifdef CONFIG_CPU_DCACHE_WRITETHROUGH
         mov     r0, #4                          @ explicitly disable writeback
         mcr     p15, 7, r0, c15, c0, 0
diff --git a/arch/arm/mm/proc-arm6_7.S b/arch/arm/mm/proc-arm6_7.S
index 540359b475d0..7a705edfa4b2 100644
--- a/arch/arm/mm/proc-arm6_7.S
+++ b/arch/arm/mm/proc-arm6_7.S
@@ -2,6 +2,7 @@
  *  linux/arch/arm/mm/proc-arm6,7.S
  *
  *  Copyright (C) 1997-2000 Russell King
+ *  hacked for non-paged-MM by Hyok S. Choi, 2003.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -199,10 +200,12 @@ ENTRY(cpu_arm7_do_idle)
  */
 ENTRY(cpu_arm6_switch_mm)
 ENTRY(cpu_arm7_switch_mm)
+#ifdef CONFIG_MMU
                 mov     r1, #0
                 mcr     p15, 0, r1, c7, c0, 0           @ flush cache
                 mcr     p15, 0, r0, c2, c0, 0           @ update page table ptr
                 mcr     p15, 0, r1, c5, c0, 0           @ flush TLBs
+#endif
                 mov     pc, lr
 
 /*
@@ -214,6 +217,7 @@ ENTRY(cpu_arm7_switch_mm)
                 .align  5
 ENTRY(cpu_arm6_set_pte)
 ENTRY(cpu_arm7_set_pte)
+#ifdef CONFIG_MMU
                 str     r1, [r0], #-2048                @ linux version
 
                 eor     r1, r1, #L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_WRITE | L_PTE_DIRTY
@@ -232,6 +236,7 @@ ENTRY(cpu_arm7_set_pte)
                 movne   r2, #0
 
                 str     r2, [r0]                        @ hardware version
+#endif /* CONFIG_MMU */
                 mov     pc, lr
 
 /*
@@ -243,7 +248,9 @@ ENTRY(cpu_arm6_reset)
 ENTRY(cpu_arm7_reset)
                 mov     r1, #0
                 mcr     p15, 0, r1, c7, c0, 0           @ flush cache
+#ifdef CONFIG_MMU
                 mcr     p15, 0, r1, c5, c0, 0           @ flush TLB
+#endif
                 mov     r1, #0x30
                 mcr     p15, 0, r1, c1, c0, 0           @ turn off MMU etc
                 mov     pc, r0
@@ -253,19 +260,27 @@ ENTRY(cpu_arm7_reset)
                 .type   __arm6_setup, #function
 __arm6_setup:   mov     r0, #0
                 mcr     p15, 0, r0, c7, c0              @ flush caches on v3
+#ifdef CONFIG_MMU
                 mcr     p15, 0, r0, c5, c0              @ flush TLBs on v3
                 mov     r0, #0x3d                       @ . ..RS BLDP WCAM
                 orr     r0, r0, #0x100                  @ . ..01 0011 1101
+#else
+                mov     r0, #0x3c                       @ . ..RS BLDP WCA.
+#endif
                 mov     pc, lr
                 .size   __arm6_setup, . - __arm6_setup
 
                 .type   __arm7_setup, #function
 __arm7_setup:   mov     r0, #0
                 mcr     p15, 0, r0, c7, c0              @ flush caches on v3
+#ifdef CONFIG_MMU
                 mcr     p15, 0, r0, c5, c0              @ flush TLBs on v3
                 mcr     p15, 0, r0, c3, c0              @ load domain access register
                 mov     r0, #0x7d                       @ . ..RS BLDP WCAM
                 orr     r0, r0, #0x100                  @ . ..01 0111 1101
+#else
+                mov     r0, #0x7c                       @ . ..RS BLDP WCA.
+#endif
                 mov     pc, lr
                 .size   __arm7_setup, . - __arm7_setup
 
diff --git a/arch/arm/mm/proc-arm720.S b/arch/arm/mm/proc-arm720.S
index 26f00ee2ad9a..86102467d37f 100644
--- a/arch/arm/mm/proc-arm720.S
+++ b/arch/arm/mm/proc-arm720.S
@@ -4,6 +4,7 @@
  *  Copyright (C) 2000 Steve Hill (sjhill@cotw.com)
  *                     Rob Scott (rscott@mtrob.fdns.net)
  *  Copyright (C) 2000 ARM Limited, Deep Blue Solutions Ltd.
+ *  hacked for non-paged-MM by Hyok S. Choi, 2004.
  *
  * 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
@@ -29,6 +30,7 @@
  *                      out of 'proc-arm6,7.S' per RMK discussion
  *   07-25-2000 SJH     Added idle function.
  *   08-25-2000 DBS     Updated for integration of ARM Ltd version.
+ *   04-20-2004 HSC     modified for non-paged memory management mode.
  */
 #include <linux/linkage.h>
 #include <linux/init.h>
@@ -75,10 +77,12 @@ ENTRY(cpu_arm720_do_idle)
  *           the new.
  */
 ENTRY(cpu_arm720_switch_mm)
+#ifdef CONFIG_MMU
                 mov     r1, #0
                 mcr     p15, 0, r1, c7, c7, 0           @ invalidate cache
                 mcr     p15, 0, r0, c2, c0, 0           @ update page table ptr
                 mcr     p15, 0, r1, c8, c7, 0           @ flush TLB (v4)
+#endif
                 mov     pc, lr
 
 /*
@@ -89,6 +93,7 @@ ENTRY(cpu_arm720_switch_mm)
  */
                 .align  5
 ENTRY(cpu_arm720_set_pte)
+#ifdef CONFIG_MMU
                 str     r1, [r0], #-2048                @ linux version
 
                 eor     r1, r1, #L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_WRITE | L_PTE_DIRTY
@@ -107,6 +112,7 @@ ENTRY(cpu_arm720_set_pte)
                 movne   r2, #0
 
                 str     r2, [r0]                        @ hardware version
+#endif
                 mov     pc, lr
 
 /*
@@ -117,7 +123,9 @@ ENTRY(cpu_arm720_set_pte)
 ENTRY(cpu_arm720_reset)
                 mov     ip, #0
                 mcr     p15, 0, ip, c7, c7, 0           @ invalidate cache
+#ifdef CONFIG_MMU
                 mcr     p15, 0, ip, c8, c7, 0           @ flush TLB (v4)
+#endif
                 mrc     p15, 0, ip, c1, c0, 0           @ get ctrl register
                 bic     ip, ip, #0x000f                 @ ............wcam
                 bic     ip, ip, #0x2100                 @ ..v....s........
@@ -130,7 +138,9 @@ ENTRY(cpu_arm720_reset)
 __arm710_setup:
         mov     r0, #0
         mcr     p15, 0, r0, c7, c7, 0           @ invalidate caches
+#ifdef CONFIG_MMU
         mcr     p15, 0, r0, c8, c7, 0           @ flush TLB (v4)
+#endif
         mrc     p15, 0, r0, c1, c0              @ get control register
         ldr     r5, arm710_cr1_clear
         bic     r0, r0, r5
@@ -156,7 +166,9 @@ arm710_cr1_set:
 __arm720_setup:
         mov     r0, #0
         mcr     p15, 0, r0, c7, c7, 0           @ invalidate caches
+#ifdef CONFIG_MMU
         mcr     p15, 0, r0, c8, c7, 0           @ flush TLB (v4)
+#endif
         mrc     p15, 0, r0, c1, c0              @ get control register
         ldr     r5, arm720_cr1_clear
         bic     r0, r0, r5
diff --git a/arch/arm/mm/proc-arm920.S b/arch/arm/mm/proc-arm920.S
index a17f79e0199c..31dc839ba07c 100644
--- a/arch/arm/mm/proc-arm920.S
+++ b/arch/arm/mm/proc-arm920.S
@@ -3,6 +3,7 @@
  *
  *  Copyright (C) 1999,2000 ARM Limited
  *  Copyright (C) 2000 Deep Blue Solutions Ltd.
+ *  hacked for non-paged-MM by Hyok S. Choi, 2003.
  *
  * 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
@@ -97,7 +98,9 @@ ENTRY(cpu_arm920_reset)
         mov     ip, #0
         mcr     p15, 0, ip, c7, c7, 0           @ invalidate I,D caches
         mcr     p15, 0, ip, c7, c10, 4          @ drain WB
+#ifdef CONFIG_MMU
         mcr     p15, 0, ip, c8, c7, 0           @ invalidate I & D TLBs
+#endif
         mrc     p15, 0, ip, c1, c0, 0           @ ctrl register
         bic     ip, ip, #0x000f                 @ ............wcam
         bic     ip, ip, #0x1100                 @ ...i...s........
@@ -317,6 +320,7 @@ ENTRY(cpu_arm920_dcache_clean_area)
  */
         .align  5
 ENTRY(cpu_arm920_switch_mm)
+#ifdef CONFIG_MMU
         mov     ip, #0
 #ifdef CONFIG_CPU_DCACHE_WRITETHROUGH
         mcr     p15, 0, ip, c7, c6, 0           @ invalidate D cache
@@ -337,6 +341,7 @@ ENTRY(cpu_arm920_switch_mm)
         mcr     p15, 0, ip, c7, c10, 4          @ drain WB
         mcr     p15, 0, r0, c2, c0, 0           @ load page table pointer
         mcr     p15, 0, ip, c8, c7, 0           @ invalidate I & D TLBs
+#endif
         mov     pc, lr
 
 /*
@@ -346,6 +351,7 @@ ENTRY(cpu_arm920_switch_mm)
  */
         .align  5
 ENTRY(cpu_arm920_set_pte)
+#ifdef CONFIG_MMU
         str     r1, [r0], #-2048                @ linux version
 
         eor     r1, r1, #L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_WRITE | L_PTE_DIRTY
@@ -372,6 +378,7 @@ ENTRY(cpu_arm920_set_pte)
         mov     r0, r0
         mcr     p15, 0, r0, c7, c10, 1          @ clean D entry
         mcr     p15, 0, r0, c7, c10, 4          @ drain WB
+#endif /* CONFIG_MMU */
         mov     pc, lr
 
         __INIT
@@ -381,7 +388,9 @@ __arm920_setup:
         mov     r0, #0
         mcr     p15, 0, r0, c7, c7              @ invalidate I,D caches on v4
         mcr     p15, 0, r0, c7, c10, 4          @ drain write buffer on v4
+#ifdef CONFIG_MMU
         mcr     p15, 0, r0, c8, c7              @ invalidate I,D TLBs on v4
+#endif
         mrc     p15, 0, r0, c1, c0              @ get control register v4
         ldr     r5, arm920_cr1_clear
         bic     r0, r0, r5
diff --git a/arch/arm/mm/proc-arm922.S b/arch/arm/mm/proc-arm922.S
index bbde4a024a48..9e57c34f5c09 100644
--- a/arch/arm/mm/proc-arm922.S
+++ b/arch/arm/mm/proc-arm922.S
@@ -4,6 +4,7 @@
  *  Copyright (C) 1999,2000 ARM Limited
  *  Copyright (C) 2000 Deep Blue Solutions Ltd.
  *  Copyright (C) 2001 Altera Corporation
+ *  hacked for non-paged-MM by Hyok S. Choi, 2003.
  *
  * 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
@@ -99,7 +100,9 @@ ENTRY(cpu_arm922_reset)
         mov     ip, #0
         mcr     p15, 0, ip, c7, c7, 0           @ invalidate I,D caches
         mcr     p15, 0, ip, c7, c10, 4          @ drain WB
+#ifdef CONFIG_MMU
         mcr     p15, 0, ip, c8, c7, 0           @ invalidate I & D TLBs
+#endif
         mrc     p15, 0, ip, c1, c0, 0           @ ctrl register
         bic     ip, ip, #0x000f                 @ ............wcam
         bic     ip, ip, #0x1100                 @ ...i...s........
@@ -321,6 +324,7 @@ ENTRY(cpu_arm922_dcache_clean_area)
  */
         .align  5
 ENTRY(cpu_arm922_switch_mm)
+#ifdef CONFIG_MMU
         mov     ip, #0
 #ifdef CONFIG_CPU_DCACHE_WRITETHROUGH
         mcr     p15, 0, ip, c7, c6, 0           @ invalidate D cache
@@ -341,6 +345,7 @@ ENTRY(cpu_arm922_switch_mm)
         mcr     p15, 0, ip, c7, c10, 4          @ drain WB
         mcr     p15, 0, r0, c2, c0, 0           @ load page table pointer
         mcr     p15, 0, ip, c8, c7, 0           @ invalidate I & D TLBs
+#endif
         mov     pc, lr
 
 /*
@@ -350,6 +355,7 @@ ENTRY(cpu_arm922_switch_mm)
  */
         .align  5
 ENTRY(cpu_arm922_set_pte)
+#ifdef CONFIG_MMU
         str     r1, [r0], #-2048                @ linux version
 
         eor     r1, r1, #L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_WRITE | L_PTE_DIRTY
@@ -376,6 +382,7 @@ ENTRY(cpu_arm922_set_pte)
         mov     r0, r0
         mcr     p15, 0, r0, c7, c10, 1          @ clean D entry
         mcr     p15, 0, r0, c7, c10, 4          @ drain WB
+#endif /* CONFIG_MMU */
         mov     pc, lr
 
         __INIT
@@ -385,7 +392,9 @@ __arm922_setup:
         mov     r0, #0
         mcr     p15, 0, r0, c7, c7              @ invalidate I,D caches on v4
         mcr     p15, 0, r0, c7, c10, 4          @ drain write buffer on v4
+#ifdef CONFIG_MMU
         mcr     p15, 0, r0, c8, c7              @ invalidate I,D TLBs on v4
+#endif
         mrc     p15, 0, r0, c1, c0              @ get control register v4
         ldr     r5, arm922_cr1_clear
         bic     r0, r0, r5
diff --git a/arch/arm/mm/proc-arm925.S b/arch/arm/mm/proc-arm925.S
index 224ce226a01b..8d47c9f3f931 100644
--- a/arch/arm/mm/proc-arm925.S
+++ b/arch/arm/mm/proc-arm925.S
@@ -9,6 +9,8 @@
  *  Update for Linux-2.6 and cache flush improvements
  *  Copyright (C) 2004 Nokia Corporation by Tony Lindgren <tony@atomide.com>
  *
+ *  hacked for non-paged-MM by Hyok S. Choi, 2004.
+ *
  * 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
@@ -122,7 +124,9 @@ ENTRY(cpu_arm925_reset)
         mov     ip, #0
         mcr     p15, 0, ip, c7, c7, 0           @ invalidate I,D caches
         mcr     p15, 0, ip, c7, c10, 4          @ drain WB
+#ifdef CONFIG_MMU
         mcr     p15, 0, ip, c8, c7, 0           @ invalidate I & D TLBs
+#endif
         mrc     p15, 0, ip, c1, c0, 0           @ ctrl register
         bic     ip, ip, #0x000f                 @ ............wcam
         bic     ip, ip, #0x1100                 @ ...i...s........
@@ -369,6 +373,7 @@ ENTRY(cpu_arm925_dcache_clean_area)
  */
         .align  5
 ENTRY(cpu_arm925_switch_mm)
+#ifdef CONFIG_MMU
         mov     ip, #0
 #ifdef CONFIG_CPU_DCACHE_WRITETHROUGH
         mcr     p15, 0, ip, c7, c6, 0           @ invalidate D cache
@@ -383,6 +388,7 @@ ENTRY(cpu_arm925_switch_mm)
         mcr     p15, 0, ip, c7, c10, 4          @ drain WB
         mcr     p15, 0, r0, c2, c0, 0           @ load page table pointer
         mcr     p15, 0, ip, c8, c7, 0           @ invalidate I & D TLBs
+#endif
         mov     pc, lr
 
 /*
@@ -392,6 +398,7 @@ ENTRY(cpu_arm925_switch_mm)
  */
         .align  5
 ENTRY(cpu_arm925_set_pte)
+#ifdef CONFIG_MMU
         str     r1, [r0], #-2048                @ linux version
 
         eor     r1, r1, #L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_WRITE | L_PTE_DIRTY
@@ -420,6 +427,7 @@ ENTRY(cpu_arm925_set_pte)
         mcr     p15, 0, r0, c7, c10, 1          @ clean D entry
 #endif
         mcr     p15, 0, r0, c7, c10, 4          @ drain WB
+#endif /* CONFIG_MMU */
         mov     pc, lr
 
         __INIT
@@ -438,7 +446,9 @@ __arm925_setup:
         mov     r0, #0
         mcr     p15, 0, r0, c7, c7              @ invalidate I,D caches on v4
         mcr     p15, 0, r0, c7, c10, 4          @ drain write buffer on v4
+#ifdef CONFIG_MMU
         mcr     p15, 0, r0, c8, c7              @ invalidate I,D TLBs on v4
+#endif
 
 #ifdef CONFIG_CPU_DCACHE_WRITETHROUGH
         mov     r0, #4                          @ disable write-back on caches explicitly
diff --git a/arch/arm/mm/proc-arm926.S b/arch/arm/mm/proc-arm926.S
index 4e2a087cf388..cb4d8f33d2a3 100644
--- a/arch/arm/mm/proc-arm926.S
+++ b/arch/arm/mm/proc-arm926.S
@@ -3,6 +3,7 @@
  *
  *  Copyright (C) 1999-2001 ARM Limited
  *  Copyright (C) 2000 Deep Blue Solutions Ltd.
+ *  hacked for non-paged-MM by Hyok S. Choi, 2003.
  *
  * 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
@@ -85,7 +86,9 @@ ENTRY(cpu_arm926_reset)
         mov     ip, #0
         mcr     p15, 0, ip, c7, c7, 0           @ invalidate I,D caches
         mcr     p15, 0, ip, c7, c10, 4          @ drain WB
+#ifdef CONFIG_MMU
         mcr     p15, 0, ip, c8, c7, 0           @ invalidate I & D TLBs
+#endif
         mrc     p15, 0, ip, c1, c0, 0           @ ctrl register
         bic     ip, ip, #0x000f                 @ ............wcam
         bic     ip, ip, #0x1100                 @ ...i...s........
@@ -329,6 +332,7 @@ ENTRY(cpu_arm926_dcache_clean_area)
  */
         .align  5
 ENTRY(cpu_arm926_switch_mm)
+#ifdef CONFIG_MMU
         mov     ip, #0
 #ifdef CONFIG_CPU_DCACHE_WRITETHROUGH
         mcr     p15, 0, ip, c7, c6, 0           @ invalidate D cache
@@ -341,6 +345,7 @@ ENTRY(cpu_arm926_switch_mm)
         mcr     p15, 0, ip, c7, c10, 4          @ drain WB
         mcr     p15, 0, r0, c2, c0, 0           @ load page table pointer
         mcr     p15, 0, ip, c8, c7, 0           @ invalidate I & D TLBs
+#endif
         mov     pc, lr
 
 /*
@@ -350,6 +355,7 @@ ENTRY(cpu_arm926_switch_mm)
  */
         .align  5
 ENTRY(cpu_arm926_set_pte)
+#ifdef CONFIG_MMU
         str     r1, [r0], #-2048                @ linux version
 
         eor     r1, r1, #L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_WRITE | L_PTE_DIRTY
@@ -378,6 +384,7 @@ ENTRY(cpu_arm926_set_pte)
         mcr     p15, 0, r0, c7, c10, 1          @ clean D entry
 #endif
         mcr     p15, 0, r0, c7, c10, 4          @ drain WB
+#endif
         mov     pc, lr
 
         __INIT
@@ -387,7 +394,9 @@ __arm926_setup:
         mov     r0, #0
         mcr     p15, 0, r0, c7, c7              @ invalidate I,D caches on v4
         mcr     p15, 0, r0, c7, c10, 4          @ drain write buffer on v4
+#ifdef CONFIG_MMU
         mcr     p15, 0, r0, c8, c7              @ invalidate I,D TLBs on v4
+#endif
 
 
 #ifdef CONFIG_CPU_DCACHE_WRITETHROUGH
diff --git a/arch/arm/mm/proc-sa110.S b/arch/arm/mm/proc-sa110.S
index a2dd5ae1077d..5a760a2c629c 100644
--- a/arch/arm/mm/proc-sa110.S
+++ b/arch/arm/mm/proc-sa110.S
@@ -2,6 +2,7 @@
  *  linux/arch/arm/mm/proc-sa110.S
  *
  *  Copyright (C) 1997-2002 Russell King
+ *  hacked for non-paged-MM by Hyok S. Choi, 2003.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -67,7 +68,9 @@ ENTRY(cpu_sa110_reset)
         mov     ip, #0
         mcr     p15, 0, ip, c7, c7, 0           @ invalidate I,D caches
         mcr     p15, 0, ip, c7, c10, 4          @ drain WB
+#ifdef CONFIG_MMU
         mcr     p15, 0, ip, c8, c7, 0           @ invalidate I & D TLBs
+#endif
         mrc     p15, 0, ip, c1, c0, 0           @ ctrl register
         bic     ip, ip, #0x000f                 @ ............wcam
         bic     ip, ip, #0x1100                 @ ...i...s........
@@ -130,11 +133,15 @@ ENTRY(cpu_sa110_dcache_clean_area)
  */
         .align  5
 ENTRY(cpu_sa110_switch_mm)
+#ifdef CONFIG_MMU
         str     lr, [sp, #-4]!
         bl      v4wb_flush_kern_cache_all       @ clears IP
         mcr     p15, 0, r0, c2, c0, 0           @ load page table pointer
         mcr     p15, 0, ip, c8, c7, 0           @ invalidate I & D TLBs
         ldr     pc, [sp], #4
+#else
+        mov     pc, lr
+#endif
 
 /*
  * cpu_sa110_set_pte(ptep, pte)
@@ -143,6 +150,7 @@ ENTRY(cpu_sa110_switch_mm)
  */
         .align  5
 ENTRY(cpu_sa110_set_pte)
+#ifdef CONFIG_MMU
         str     r1, [r0], #-2048                @ linux version
 
         eor     r1, r1, #L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_WRITE | L_PTE_DIRTY
@@ -164,6 +172,7 @@ ENTRY(cpu_sa110_set_pte)
         mov     r0, r0
         mcr     p15, 0, r0, c7, c10, 1          @ clean D entry
         mcr     p15, 0, r0, c7, c10, 4          @ drain WB
+#endif
         mov     pc, lr
 
         __INIT
@@ -173,7 +182,9 @@ __sa110_setup:
         mov     r10, #0
         mcr     p15, 0, r10, c7, c7             @ invalidate I,D caches on v4
         mcr     p15, 0, r10, c7, c10, 4         @ drain write buffer on v4
+#ifdef CONFIG_MMU
         mcr     p15, 0, r10, c8, c7             @ invalidate I,D TLBs on v4
+#endif
         mrc     p15, 0, r0, c1, c0              @ get control register v4
         ldr     r5, sa110_cr1_clear
         bic     r0, r0, r5
diff --git a/arch/arm/mm/proc-sa1100.S b/arch/arm/mm/proc-sa1100.S
index 777ad99c1439..0a2107ad4c32 100644
--- a/arch/arm/mm/proc-sa1100.S
+++ b/arch/arm/mm/proc-sa1100.S
@@ -2,6 +2,7 @@
  *  linux/arch/arm/mm/proc-sa1100.S
  *
  *  Copyright (C) 1997-2002 Russell King
+ *  hacked for non-paged-MM by Hyok S. Choi, 2003.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -77,7 +78,9 @@ ENTRY(cpu_sa1100_reset)
         mov     ip, #0
         mcr     p15, 0, ip, c7, c7, 0           @ invalidate I,D caches
         mcr     p15, 0, ip, c7, c10, 4          @ drain WB
+#ifdef CONFIG_MMU
         mcr     p15, 0, ip, c8, c7, 0           @ invalidate I & D TLBs
+#endif
         mrc     p15, 0, ip, c1, c0, 0           @ ctrl register
         bic     ip, ip, #0x000f                 @ ............wcam
         bic     ip, ip, #0x1100                 @ ...i...s........
@@ -142,12 +145,16 @@ ENTRY(cpu_sa1100_dcache_clean_area)
  */
         .align  5
 ENTRY(cpu_sa1100_switch_mm)
+#ifdef CONFIG_MMU
         str     lr, [sp, #-4]!
         bl      v4wb_flush_kern_cache_all       @ clears IP
         mcr     p15, 0, ip, c9, c0, 0           @ invalidate RB
         mcr     p15, 0, r0, c2, c0, 0           @ load page table pointer
         mcr     p15, 0, ip, c8, c7, 0           @ invalidate I & D TLBs
         ldr     pc, [sp], #4
+#else
+        mov     pc, lr
+#endif
 
 /*
  * cpu_sa1100_set_pte(ptep, pte)
@@ -156,6 +163,7 @@ ENTRY(cpu_sa1100_switch_mm)
  */
         .align  5
 ENTRY(cpu_sa1100_set_pte)
+#ifdef CONFIG_MMU
         str     r1, [r0], #-2048                @ linux version
 
         eor     r1, r1, #L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_WRITE | L_PTE_DIRTY
@@ -177,6 +185,7 @@ ENTRY(cpu_sa1100_set_pte)
         mov     r0, r0
         mcr     p15, 0, r0, c7, c10, 1          @ clean D entry
         mcr     p15, 0, r0, c7, c10, 4          @ drain WB
+#endif
         mov     pc, lr
 
         __INIT
@@ -186,7 +195,9 @@ __sa1100_setup:
         mov     r0, #0
         mcr     p15, 0, r0, c7, c7              @ invalidate I,D caches on v4
         mcr     p15, 0, r0, c7, c10, 4          @ drain write buffer on v4
+#ifdef CONFIG_MMU
         mcr     p15, 0, r0, c8, c7              @ invalidate I,D TLBs on v4
+#endif
         mrc     p15, 0, r0, c1, c0              @ get control register v4
         ldr     r5, sa1100_cr1_clear
         bic     r0, r0, r5
diff --git a/arch/arm/mm/proc-v6.S b/arch/arm/mm/proc-v6.S
index 09b1a41a6de8..ca13d4d05f65 100644
--- a/arch/arm/mm/proc-v6.S
+++ b/arch/arm/mm/proc-v6.S
@@ -2,6 +2,7 @@
  *  linux/arch/arm/mm/proc-v6.S
  *
  *  Copyright (C) 2001 Deep Blue Solutions Ltd.
+ *  Modified by Catalin Marinas for noMMU support
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -88,6 +89,7 @@ ENTRY(cpu_v6_dcache_clean_area)
  *      - we are not using split page tables
  */
 ENTRY(cpu_v6_switch_mm)
+#ifdef CONFIG_MMU
         mov     r2, #0
         ldr     r1, [r1, #MM_CONTEXT_ID]        @ get mm->context.id
 #ifdef CONFIG_SMP
@@ -97,6 +99,7 @@ ENTRY(cpu_v6_switch_mm)
         mcr     p15, 0, r2, c7, c10, 4          @ drain write buffer
         mcr     p15, 0, r0, c2, c0, 0           @ set TTB 0
         mcr     p15, 0, r1, c13, c0, 1          @ set context ID
+#endif
         mov     pc, lr
 
 /*
@@ -119,6 +122,7 @@ ENTRY(cpu_v6_switch_mm)
  *        1111   0   1   1      r/w     r/w
  */
 ENTRY(cpu_v6_set_pte)
+#ifdef CONFIG_MMU
         str     r1, [r0], #-2048                @ linux version
 
         bic     r2, r1, #0x000003f0
@@ -145,6 +149,7 @@ ENTRY(cpu_v6_set_pte)
 
         str     r2, [r0]
         mcr     p15, 0, r0, c7, c10, 1 @ flush_pte
+#endif
         mov     pc, lr
 
 
@@ -194,12 +199,14 @@ __v6_setup:
         mcr     p15, 0, r0, c7, c5, 0           @ invalidate I cache
         mcr     p15, 0, r0, c7, c15, 0          @ clean+invalidate cache
         mcr     p15, 0, r0, c7, c10, 4          @ drain write buffer
+#ifdef CONFIG_MMU
         mcr     p15, 0, r0, c8, c7, 0           @ invalidate I + D TLBs
         mcr     p15, 0, r0, c2, c0, 2           @ TTB control register
 #ifdef CONFIG_SMP
         orr     r4, r4, #TTB_RGN_WBWA|TTB_S     @ mark PTWs shared, outer cacheable
 #endif
         mcr     p15, 0, r4, c2, c0, 1           @ load TTB1
+#endif /* CONFIG_MMU */
 #ifdef CONFIG_VFP
         mrc     p15, 0, r0, c1, c0, 2
         orr     r0, r0, #(0xf << 20)
diff --git a/arch/i386/kernel/irq.c b/arch/i386/kernel/irq.c
index c703bc7b0880..9eec9435318e 100644
--- a/arch/i386/kernel/irq.c
+++ b/arch/i386/kernel/irq.c
@@ -60,6 +60,12 @@ fastcall unsigned int do_IRQ(struct pt_regs *regs)
         u32 *isp;
 #endif
 
+        if (unlikely((unsigned)irq >= NR_IRQS)) {
+                printk(KERN_EMERG "%s: cannot handle IRQ %d\n",
+                                        __FUNCTION__, irq);
+                BUG();
+        }
+
         irq_enter();
 #ifdef CONFIG_DEBUG_STACKOVERFLOW
         /* Debugging check for stack overflow: is there less than 1KB free? */
diff --git a/arch/ia64/configs/tiger_defconfig b/arch/ia64/configs/tiger_defconfig
index 766bf4955432..9d1cffb57cde 100644
--- a/arch/ia64/configs/tiger_defconfig
+++ b/arch/ia64/configs/tiger_defconfig
@@ -114,7 +114,7 @@ CONFIG_IA64_CYCLONE=y
 CONFIG_IOSAPIC=y
 CONFIG_FORCE_MAX_ZONEORDER=17
 CONFIG_SMP=y
-CONFIG_NR_CPUS=4
+CONFIG_NR_CPUS=16
 CONFIG_HOTPLUG_CPU=y
 CONFIG_PERMIT_BSP_REMOVE=y
 CONFIG_FORCE_CPEI_RETARGET=y
diff --git a/arch/ia64/kernel/palinfo.c b/arch/ia64/kernel/palinfo.c
index 303a9afcf2a1..8a1208419138 100644
--- a/arch/ia64/kernel/palinfo.c
+++ b/arch/ia64/kernel/palinfo.c
@@ -998,7 +998,7 @@ palinfo_init(void)
         }
 
         /* Register for future delivery via notify registration */
-        register_cpu_notifier(&palinfo_cpu_notifier);
+        register_hotcpu_notifier(&palinfo_cpu_notifier);
 
         return 0;
 }
diff --git a/arch/ia64/sn/kernel/setup.c b/arch/ia64/sn/kernel/setup.c
index 93577abae36d..3bfccf354343 100644
--- a/arch/ia64/sn/kernel/setup.c
+++ b/arch/ia64/sn/kernel/setup.c
@@ -458,7 +458,7 @@ void __init sn_setup(char **cmdline_p)
          * support here so we don't have to listen to failed keyboard probe
          * messages.
          */
-        if (version <= 0x0209 && acpi_kbd_controller_present) {
+        if (is_shub1() && version <= 0x0209 && acpi_kbd_controller_present) {
                 printk(KERN_INFO "Disabling legacy keyboard support as prom "
                        "is too old and doesn't provide FADT\n");
                 acpi_kbd_controller_present = 0;
@@ -577,7 +577,8 @@ void __init sn_cpu_init(void)
         int i;
         static int wars_have_been_checked;
 
-        if (smp_processor_id() == 0 && IS_MEDUSA()) {
+        cpuid = smp_processor_id();
+        if (cpuid == 0 && IS_MEDUSA()) {
                 if (ia64_sn_is_fake_prom())
                         sn_prom_type = 2;
                 else
@@ -597,6 +598,12 @@ void __init sn_cpu_init(void)
         sn_hub_info->as_shift = sn_hub_info->nasid_shift - 2;
 
         /*
+         * Don't check status. The SAL call is not supported on all PROMs
+         * but a failure is harmless.
+         */
+        (void) ia64_sn_set_cpu_number(cpuid);
+
+        /*
          * The boot cpu makes this call again after platform initialization is
          * complete.
          */
@@ -607,7 +614,6 @@ void __init sn_cpu_init(void)
                 if (ia64_sn_get_prom_feature_set(i, &sn_prom_features[i]) != 0)
                         break;
 
-        cpuid = smp_processor_id();
         cpuphyid = get_sapicid();
 
         if (ia64_sn_get_sapic_info(cpuphyid, &nasid, &subnode, &slice))
diff --git a/arch/ia64/sn/pci/tioca_provider.c b/arch/ia64/sn/pci/tioca_provider.c
index 20de72791b97..e4aa839d0189 100644
--- a/arch/ia64/sn/pci/tioca_provider.c
+++ b/arch/ia64/sn/pci/tioca_provider.c
@@ -595,7 +595,7 @@ tioca_bus_fixup(struct pcibus_bussoft *prom_bussoft, struct pci_controller *cont
 
         /* sanity check prom rev */
 
-        if (sn_sal_rev() < 0x0406) {
+        if (is_shub1() && sn_sal_rev() < 0x0406) {
                 printk
                     (KERN_ERR "%s:  SGI prom rev 4.06 or greater required "
                      "for tioca support\n", __FUNCTION__);
diff --git a/arch/m68knommu/Kconfig b/arch/m68knommu/Kconfig
index 8b6e723eb82b..e767f2ddae72 100644
--- a/arch/m68knommu/Kconfig
+++ b/arch/m68knommu/Kconfig
@@ -540,6 +540,59 @@ config RAM32BIT
 
 endchoice
 
+comment "ROM configuration"
+
+config ROM
+        bool "Specify ROM linker regions"
+        default n
+        help
+          Define a ROM region for the linker script. This creates a kernel
+          that can be stored in flash, with possibly the text, and data
+          regions being copied out to RAM at startup.
+
+config ROMBASE
+        hex "Address of the base of ROM device"
+        default "0"
+        depends on ROM
+        help
+          Define the address that the ROM region starts at. Some platforms
+          use this to set their chip select region accordingly for the boot
+          device.
+
+config ROMVEC
+        hex "Address of the base of the ROM vectors"
+        default "0"
+        depends on ROM
+        help
+          This is almost always the same as the base of the ROM. Since on all
+          68000 type varients the vectors are at the base of the boot device
+          on system startup.
+
+config ROMVECSIZE
+        hex "Size of ROM vector region (in bytes)"
+        default "0x400"
+        depends on ROM
+        help
+          Define the size of the vector region in ROM. For most 68000
+          varients this would be 0x400 bytes in size. Set to 0 if you do
+          not want a vector region at the start of the ROM.
+
+config ROMSTART
+        hex "Address of the base of system image in ROM"
+        default "0x400"
+        depends on ROM
+        help
+          Define the start address of the system image in ROM. Commonly this
+          is strait after the ROM vectors.
+
+config ROMSIZE
+        hex "Size of the ROM device"
+        default "0x100000"
+        depends on ROM
+        help
+          Size of the ROM device. On some platforms this is used to setup
+          the chip select that controls the boot ROM device.
+
 choice
         prompt "Kernel executes from"
         ---help---
diff --git a/arch/m68knommu/kernel/vmlinux.lds.S b/arch/m68knommu/kernel/vmlinux.lds.S
index 6a2f0c693254..59ced831b792 100644
--- a/arch/m68knommu/kernel/vmlinux.lds.S
+++ b/arch/m68knommu/kernel/vmlinux.lds.S
@@ -3,63 +3,13 @@
  *
  *      (C) Copyright 2002-2006, Greg Ungerer <gerg@snapgear.com>
  *
- *      This ends up looking compilcated, because of the number of
- *      address variations for ram and rom/flash layouts. The real
- *      work of the linker script is all at the end, and reasonably
- *      strait forward.
+ *      This linker script is equiped to build either ROM loaded or RAM
+ *      run kernels.
  */
 
 #include <linux/config.h>
 #include <asm-generic/vmlinux.lds.h>
 
-/*
- *      Original Palm pilot (same for Xcopilot).
- *      There is really only a rom target for this.
- */
-#ifdef CONFIG_PILOT3
-#define ROMVEC_START    0x10c00000
-#define ROMVEC_LENGTH   0x10400
-#define ROM_START       0x10c10400
-#define ROM_LENGTH      0xfec00
-#define ROM_END         0x10d00000
-#define DATA_ADDR       CONFIG_KERNELBASE
-#endif
-
-/*
- *      Same setup on both the uCsimm and uCdimm.
- */
-#if defined(CONFIG_UCSIMM) || defined(CONFIG_UCDIMM)
-#ifdef CONFIG_RAMKERNEL
-#define ROMVEC_START    0x10c10000
-#define ROMVEC_LENGTH   0x400
-#define ROM_START       0x10c10400
-#define ROM_LENGTH      0x1efc00
-#define ROM_END         0x10e00000
-#endif
-#ifdef CONFIG_ROMKERNEL
-#define ROMVEC_START    0x10c10000
-#define ROMVEC_LENGTH   0x400
-#define ROM_START       0x10c10400
-#define ROM_LENGTH      0x1efc00
-#define ROM_END         0x10e00000
-#endif
-#ifdef CONFIG_HIMEMKERNEL
-#define ROMVEC_START    0x00600000
-#define ROMVEC_LENGTH   0x400
-#define ROM_START       0x00600400
-#define ROM_LENGTH      0x1efc00
-#define ROM_END         0x007f0000
-#endif
-#endif
-
-#ifdef CONFIG_UCQUICC
-#define ROMVEC_START    0x00000000
-#define ROMVEC_LENGTH   0x404
-#define ROM_START       0x00000404
-#define ROM_LENGTH      0x1ff6fc
-#define ROM_END         0x00200000
-#endif
-
 #if defined(CONFIG_RAMKERNEL)
 #define RAM_START       CONFIG_KERNELBASE
 #define RAM_LENGTH      (CONFIG_RAMBASE + CONFIG_RAMSIZE - CONFIG_KERNELBASE)
@@ -71,6 +21,10 @@
 #if defined(CONFIG_ROMKERNEL) || defined(CONFIG_HIMEMKERNEL)
 #define RAM_START       CONFIG_RAMBASE
 #define RAM_LENGTH      CONFIG_RAMSIZE
+#define ROMVEC_START    CONFIG_ROMVEC
+#define ROMVEC_LENGTH   CONFIG_ROMVECSIZE
+#define ROM_START       CONFIG_ROMSTART
+#define ROM_LENGTH      CONFIG_ROMSIZE
 #define TEXT            rom
 #define DATA            ram
 #define INIT            ram
@@ -90,7 +44,6 @@ MEMORY {
 #ifdef ROM_START
         romvec  : ORIGIN = ROMVEC_START, LENGTH = ROMVEC_LENGTH
         rom     : ORIGIN = ROM_START, LENGTH = ROM_LENGTH
-        erom    : ORIGIN = ROM_END, LENGTH = 0
 #endif
 }
 
@@ -167,13 +120,6 @@ SECTIONS {
                 _etext = . ;
         } > TEXT
 
-#ifdef ROM_END
-        . = ROM_END ;
-        .erom : {
-                __rom_end = . ;
-        } > erom
-#endif
-
         .data DATA_ADDR : {
                 . = ALIGN(4);
                 _sdata = . ;
diff --git a/arch/m68knommu/platform/68328/Makefile b/arch/m68knommu/platform/68328/Makefile
index 1b3b719e4479..5e5435552d56 100644
--- a/arch/m68knommu/platform/68328/Makefile
+++ b/arch/m68knommu/platform/68328/Makefile
@@ -8,6 +8,7 @@ head-$(CONFIG_DRAGEN2)	= head-de2.o
 
 obj-y                   += entry.o ints.o timers.o
 obj-$(CONFIG_M68328)    += config.o
+obj-$(CONFIG_ROM)       += romvec.o
 
 extra-y                 := head.o
 extra-$(CONFIG_M68328)  += bootlogo.rh head.o
diff --git a/arch/m68knommu/platform/68328/ints.c b/arch/m68knommu/platform/68328/ints.c
index 7437217813d2..2dda7339aae5 100644
--- a/arch/m68knommu/platform/68328/ints.c
+++ b/arch/m68knommu/platform/68328/ints.c
@@ -18,6 +18,7 @@
 
 #include <asm/system.h>
 #include <asm/irq.h>
+#include <asm/irqnode.h>
 #include <asm/traps.h>
 #include <asm/io.h>
 #include <asm/machdep.h>
@@ -82,25 +83,6 @@ unsigned int local_irq_count[NR_CPUS];
 /* irq node variables for the 32 (potential) on chip sources */
 static irq_node_t int_irq_list[NR_IRQS];
 
-#if !defined(CONFIG_DRAGEN2)
-asm (".global _start, __ramend/n/t"
-     ".section .romvec/n"
-     "e_vectors:\n\t"
-     ".long __ramend-4, _start, buserr, trap, trap, trap, trap, trap\n\t"
-     ".long trap, trap, trap, trap, trap, trap, trap, trap\n\t"
-     ".long trap, trap, trap, trap, trap, trap, trap, trap\n\t"
-     ".long trap, trap, trap, trap\n\t"
-     ".long trap, trap, trap, trap\n\t"
-        /*.long inthandler, inthandler, inthandler, inthandler
-        .long inthandler4, inthandler, inthandler, inthandler   */
-        /* TRAP #0-15 */
-     ".long system_call, trap, trap, trap, trap, trap, trap, trap\n\t"
-     ".long trap, trap, trap, trap, trap, trap, trap, trap\n\t"
-     ".long 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n\t"
-     ".text\n"
-     "ignore: rte");
-#endif
-
 /*
  * This function should be called during kernel startup to initialize
  * the IRQ handling routines.
diff --git a/arch/m68knommu/platform/68328/romvec.S b/arch/m68knommu/platform/68328/romvec.S
new file mode 100644
index 000000000000..3e7fe1e14913
--- /dev/null
+++ b/arch/m68knommu/platform/68328/romvec.S
@@ -0,0 +1,37 @@
+/*
+ * linux/arch/m68knommu/platform/68328/romvec.S
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file COPYING in the main directory of this archive
+ * for more details.
+ *
+ * Copyright 1996 Roman Zippel
+ * Copyright 1999 D. Jeff Dionne <jeff@rt-control.com>
+ * Copyright 2006 Greg Ungerer <gerg@snapgear.com>
+ */
+
+#include <linux/config.h>
+
+.global _start
+.global _buserr
+.global trap
+.global system_call
+
+.section .romvec
+
+e_vectors:
+.long CONFIG_RAMBASE+CONFIG_RAMSIZE-4, _start, buserr, trap
+.long trap, trap, trap, trap
+.long trap, trap, trap, trap
+.long trap, trap, trap, trap
+.long trap, trap, trap, trap
+.long trap, trap, trap, trap
+.long trap, trap, trap, trap
+.long trap, trap, trap, trap
+/* TRAP #0-15 */
+.long system_call, trap, trap, trap
+.long trap, trap, trap, trap
+.long trap, trap, trap, trap
+.long trap, trap, trap, trap
+.long 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+
diff --git a/arch/m68knommu/platform/68360/config.c b/arch/m68knommu/platform/68360/config.c
index 3db244625f0f..69c670dfd62b 100644
--- a/arch/m68knommu/platform/68360/config.c
+++ b/arch/m68knommu/platform/68360/config.c
@@ -141,13 +141,13 @@ int BSP_set_clock_mmss (unsigned long nowtime)
 void BSP_reset (void)
 {
   local_irq_disable();
-  asm volatile ("
-    moveal #_start, %a0;
-    moveb #0, 0xFFFFF300;
-    moveal 0(%a0), %sp;
-    moveal 4(%a0), %a0;
-    jmp (%a0);
-    ");
+  asm volatile (
+    "moveal #_start, %a0;\n"
+    "moveb #0, 0xFFFFF300;\n"
+    "moveal 0(%a0), %sp;\n"
+    "moveal 4(%a0), %a0;\n"
+    "jmp (%a0);\n"
+    );
 }
 
 unsigned char *scc1_hwaddr;
diff --git a/arch/m68knommu/platform/68360/ints.c b/arch/m68knommu/platform/68360/ints.c
index ba184db1651b..0245fc4a4781 100644
--- a/arch/m68knommu/platform/68360/ints.c
+++ b/arch/m68knommu/platform/68360/ints.c
@@ -20,6 +20,7 @@
 
 #include <asm/system.h>
 #include <asm/irq.h>
+#include <asm/irqnode.h>
 #include <asm/traps.h>
 #include <asm/io.h>
 #include <asm/machdep.h>
diff --git a/arch/m68knommu/platform/68EZ328/config.c b/arch/m68knommu/platform/68EZ328/config.c
index d8d56e5de310..15a14a67c2bf 100644
--- a/arch/m68knommu/platform/68EZ328/config.c
+++ b/arch/m68knommu/platform/68EZ328/config.c
@@ -42,13 +42,13 @@ void m68328_timer_gettod(int *year, int *mon, int *day, int *hour, int *min, int
 void m68ez328_reset(void)
 {
   local_irq_disable();
-  asm volatile ("
-    moveal #0x10c00000, %a0;
-    moveb #0, 0xFFFFF300;
-    moveal 0(%a0), %sp;
-    moveal 4(%a0), %a0;
-    jmp (%a0);
-    ");
+  asm volatile (
+    "moveal #0x10c00000, %a0;\n"
+    "moveb #0, 0xFFFFF300;\n"
+    "moveal 0(%a0), %sp;\n"
+    "moveal 4(%a0), %a0;\n"
+    "jmp (%a0);\n"
+    );
 }
 
 /***************************************************************************/
diff --git a/arch/m68knommu/platform/68VZ328/config.c b/arch/m68knommu/platform/68VZ328/config.c
index d926524cdf82..4058de5c8fa2 100644
--- a/arch/m68knommu/platform/68VZ328/config.c
+++ b/arch/m68knommu/platform/68VZ328/config.c
@@ -141,13 +141,13 @@ static void init_hardware(char *command, int size)
 static void m68vz328_reset(void)
 {
         local_irq_disable();
-        asm volatile ("
-                moveal #0x10c00000, %a0;
-                moveb #0, 0xFFFFF300;
-                moveal 0(%a0), %sp;
-                moveal 4(%a0), %a0;
-                jmp (%a0);
-        ");
+        asm volatile (
+                "moveal #0x10c00000, %a0;\n\t"
+                "moveb #0, 0xFFFFF300;\n\t"
+                "moveal 0(%a0), %sp;\n\t"
+                "moveal 4(%a0), %a0;\n\t"
+                "jmp (%a0);\n"
+        );
 }
 
 unsigned char *cs8900a_hwaddr;
diff --git a/arch/powerpc/platforms/powermac/backlight.c b/arch/powerpc/platforms/powermac/backlight.c
index 498b042e1837..c7a27eddca6d 100644
--- a/arch/powerpc/platforms/powermac/backlight.c
+++ b/arch/powerpc/platforms/powermac/backlight.c
@@ -119,7 +119,14 @@ int pmac_backlight_set_legacy_brightness(int brightness)
                 down(&pmac_backlight->sem);
                 props = pmac_backlight->props;
                 props->brightness = brightness *
-                        props->max_brightness / OLD_BACKLIGHT_MAX;
+                        (props->max_brightness + 1) /
+                        (OLD_BACKLIGHT_MAX + 1);
+
+                if (props->brightness > props->max_brightness)
+                        props->brightness = props->max_brightness;
+                else if (props->brightness < 0)
+                        props->brightness = 0;
+
                 props->update_status(pmac_backlight);
                 up(&pmac_backlight->sem);
 
@@ -140,8 +147,11 @@ int pmac_backlight_get_legacy_brightness()
 
                 down(&pmac_backlight->sem);
                 props = pmac_backlight->props;
+
                 result = props->brightness *
-                        OLD_BACKLIGHT_MAX / props->max_brightness;
+                        (OLD_BACKLIGHT_MAX + 1) /
+                        (props->max_brightness + 1);
+
                 up(&pmac_backlight->sem);
         }
         mutex_unlock(&pmac_backlight_mutex);
diff --git a/arch/x86_64/kernel/irq.c b/arch/x86_64/kernel/irq.c
index 3be0a7e4bf08..bfa82f52a5cc 100644
--- a/arch/x86_64/kernel/irq.c
+++ b/arch/x86_64/kernel/irq.c
@@ -118,6 +118,12 @@ asmlinkage unsigned int do_IRQ(struct pt_regs *regs)
         /* high bit used in ret_from_ code  */
         unsigned irq = ~regs->orig_rax;
 
+        if (unlikely(irq >= NR_IRQS)) {
+                printk(KERN_EMERG "%s: cannot handle IRQ %d\n",
+                                        __FUNCTION__, irq);
+                BUG();
+        }
+
         exit_idle();
         irq_enter();
 #ifdef CONFIG_DEBUG_STACKOVERFLOW
diff --git a/arch/x86_64/kernel/nmi.c b/arch/x86_64/kernel/nmi.c
index 399489c93132..0ef9cf2bc45e 100644
--- a/arch/x86_64/kernel/nmi.c
+++ b/arch/x86_64/kernel/nmi.c
@@ -607,11 +607,13 @@ void set_nmi_callback(nmi_callback_t callback)
         vmalloc_sync_all();
         rcu_assign_pointer(nmi_callback, callback);
 }
+EXPORT_SYMBOL_GPL(set_nmi_callback);
 
 void unset_nmi_callback(void)
 {
         nmi_callback = dummy_nmi_callback;
 }
+EXPORT_SYMBOL_GPL(unset_nmi_callback);
 
 #ifdef CONFIG_SYSCTL
 
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 3c74ea729fc7..18dd026f470d 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -210,7 +210,7 @@ static int do_lo_send_aops(struct loop_device *lo, struct bio_vec *bvec,
 {
         struct file *file = lo->lo_backing_file; /* kudos to NFsckingS */
         struct address_space *mapping = file->f_mapping;
-        struct address_space_operations *aops = mapping->a_ops;
+        const struct address_space_operations *aops = mapping->a_ops;
         pgoff_t index;
         unsigned offset, bv_offs;
         int len, ret;
@@ -784,7 +784,7 @@ static int loop_set_fd(struct loop_device *lo, struct file *lo_file,
 
         error = -EINVAL;
         if (S_ISREG(inode->i_mode) || S_ISBLK(inode->i_mode)) {
-                struct address_space_operations *aops = mapping->a_ops;
+                const struct address_space_operations *aops = mapping->a_ops;
                 /*
                  * If we can't read - sorry. If we only can't write - well,
                  * it's going to be read-only.
diff --git a/drivers/block/rd.c b/drivers/block/rd.c
index 940bfd7951e5..0378da04cfa2 100644
--- a/drivers/block/rd.c
+++ b/drivers/block/rd.c
@@ -191,7 +191,7 @@ static int ramdisk_set_page_dirty(struct page *page)
         return 0;
 }
 
-static struct address_space_operations ramdisk_aops = {
+static const struct address_space_operations ramdisk_aops = {
         .readpage       = ramdisk_readpage,
         .prepare_write  = ramdisk_prepare_write,
         .commit_write   = ramdisk_commit_write,
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index 83ed6ae466a5..ad26f4b997c5 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -3738,11 +3738,8 @@ static int ipmi_init_msghandler(void)
         proc_ipmi_root->owner = THIS_MODULE;
 #endif /* CONFIG_PROC_FS */
 
-        init_timer(&ipmi_timer);
-        ipmi_timer.data = 0;
-        ipmi_timer.function = ipmi_timeout;
-        ipmi_timer.expires = jiffies + IPMI_TIMEOUT_JIFFIES;
-        add_timer(&ipmi_timer);
+        setup_timer(&ipmi_timer, ipmi_timeout, 0);
+        mod_timer(&ipmi_timer, jiffies + IPMI_TIMEOUT_JIFFIES);
 
         atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
 
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index 101c14b9b26d..bd4f2248b758 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -55,23 +55,6 @@
 #include <linux/mutex.h>
 #include <linux/kthread.h>
 #include <asm/irq.h>
-#ifdef CONFIG_HIGH_RES_TIMERS
-#include <linux/hrtime.h>
-# if defined(schedule_next_int)
-/* Old high-res timer code, do translations. */
-#  define get_arch_cycles(a) quick_update_jiffies_sub(a)
-#  define arch_cycles_per_jiffy cycles_per_jiffies
-# endif
-static inline void add_usec_to_timer(struct timer_list *t, long v)
-{
-        t->arch_cycle_expires += nsec_to_arch_cycle(v * 1000);
-        while (t->arch_cycle_expires >= arch_cycles_per_jiffy)
-        {
-                t->expires++;
-                t->arch_cycle_expires -= arch_cycles_per_jiffy;
-        }
-}
-#endif
 #include <linux/interrupt.h>
 #include <linux/rcupdate.h>
 #include <linux/ipmi_smi.h>
@@ -243,8 +226,6 @@ static int register_xaction_notifier(struct notifier_block * nb)
         return atomic_notifier_chain_register(&xaction_notifier_list, nb);
 }
 
-static void si_restart_short_timer(struct smi_info *smi_info);
-
 static void deliver_recv_msg(struct smi_info *smi_info,
                              struct ipmi_smi_msg *msg)
 {
@@ -768,7 +749,6 @@ static void sender(void                *send_info,
             && (smi_info->curr_msg == NULL))
         {
                 start_next_msg(smi_info);
-                si_restart_short_timer(smi_info);
         }
         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
 }
@@ -833,37 +813,6 @@ static void request_events(void *send_info)
 
 static int initialized = 0;
 
-/* Must be called with interrupts off and with the si_lock held. */
-static void si_restart_short_timer(struct smi_info *smi_info)
-{
-#if defined(CONFIG_HIGH_RES_TIMERS)
-        unsigned long flags;
-        unsigned long jiffies_now;
-        unsigned long seq;
-
-        if (del_timer(&(smi_info->si_timer))) {
-                /* If we don't delete the timer, then it will go off
-                   immediately, anyway.  So we only process if we
-                   actually delete the timer. */
-
-                do {
-                        seq = read_seqbegin_irqsave(&xtime_lock, flags);
-                        jiffies_now = jiffies;
-                        smi_info->si_timer.expires = jiffies_now;
-                        smi_info->si_timer.arch_cycle_expires
-                                = get_arch_cycles(jiffies_now);
-                } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
-
-                add_usec_to_timer(&smi_info->si_timer, SI_SHORT_TIMEOUT_USEC);
-
-                add_timer(&(smi_info->si_timer));
-                spin_lock_irqsave(&smi_info->count_lock, flags);
-                smi_info->timeout_restarts++;
-                spin_unlock_irqrestore(&smi_info->count_lock, flags);
-        }
-#endif
-}
-
 static void smi_timeout(unsigned long data)
 {
         struct smi_info   *smi_info = (struct smi_info *) data;
@@ -904,31 +853,15 @@ static void smi_timeout(unsigned long data)
         /* If the state machine asks for a short delay, then shorten
            the timer timeout. */
         if (smi_result == SI_SM_CALL_WITH_DELAY) {
-#if defined(CONFIG_HIGH_RES_TIMERS)
-                unsigned long seq;
-#endif
                 spin_lock_irqsave(&smi_info->count_lock, flags);
                 smi_info->short_timeouts++;
                 spin_unlock_irqrestore(&smi_info->count_lock, flags);
-#if defined(CONFIG_HIGH_RES_TIMERS)
-                do {
-                        seq = read_seqbegin_irqsave(&xtime_lock, flags);
-                        smi_info->si_timer.expires = jiffies;
-                        smi_info->si_timer.arch_cycle_expires
-                                = get_arch_cycles(smi_info->si_timer.expires);
-                } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
-                add_usec_to_timer(&smi_info->si_timer, SI_SHORT_TIMEOUT_USEC);
-#else
                 smi_info->si_timer.expires = jiffies + 1;
-#endif
         } else {
                 spin_lock_irqsave(&smi_info->count_lock, flags);
                 smi_info->long_timeouts++;
                 spin_unlock_irqrestore(&smi_info->count_lock, flags);
                 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
-#if defined(CONFIG_HIGH_RES_TIMERS)
-                smi_info->si_timer.arch_cycle_expires = 0;
-#endif
         }
 
  do_add_timer:
diff --git a/drivers/char/ipmi/ipmi_watchdog.c b/drivers/char/ipmi/ipmi_watchdog.c
index 8f8867170973..1a0a19c53605 100644
--- a/drivers/char/ipmi/ipmi_watchdog.c
+++ b/drivers/char/ipmi/ipmi_watchdog.c
@@ -949,9 +949,10 @@ static int wdog_reboot_handler(struct notifier_block *this,
                         /* Disable the WDT if we are shutting down. */
                         ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
                         panic_halt_ipmi_set_timeout();
-                } else {
+                } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
                         /* Set a long timer to let the reboot happens, but
-                           reboot if it hangs. */
+                           reboot if it hangs, but only if the watchdog
+                           timer was already running. */
                         timeout = 120;
                         pretimeout = 0;
                         ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
@@ -973,16 +974,17 @@ static int wdog_panic_handler(struct notifier_block *this,
 {
         static int panic_event_handled = 0;
 
-        /* On a panic, if we have a panic timeout, make sure that the thing
-           reboots, even if it hangs during that panic. */
-        if (watchdog_user && !panic_event_handled) {
-                /* Make sure the panic doesn't hang, and make sure we
-                   do this only once. */
+        /* On a panic, if we have a panic timeout, make sure to extend
+           the watchdog timer to a reasonable value to complete the
+           panic, if the watchdog timer is running.  Plus the
+           pretimeout is meaningless at panic time. */
+        if (watchdog_user && !panic_event_handled &&
+            ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
+                /* Make sure we do this only once. */
                 panic_event_handled = 1;
             
                 timeout = 255;
                 pretimeout = 0;
-                ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
                 panic_halt_ipmi_set_timeout();
         }
 
diff --git a/drivers/char/istallion.c b/drivers/char/istallion.c
index ef20c1fc9c4c..216c79256de3 100644
--- a/drivers/char/istallion.c
+++ b/drivers/char/istallion.c
@@ -42,13 +42,12 @@
 #include <linux/devfs_fs_kernel.h>
 #include <linux/device.h>
 #include <linux/wait.h>
+#include <linux/eisa.h>
 
 #include <asm/io.h>
 #include <asm/uaccess.h>
 
-#ifdef CONFIG_PCI
 #include <linux/pci.h>
-#endif
 
 /*****************************************************************************/
 
@@ -137,6 +136,10 @@ static stlconf_t	stli_brdconf[] = {
 
 static int      stli_nrbrds = ARRAY_SIZE(stli_brdconf);
 
+/* stli_lock must NOT be taken holding brd_lock */
+static spinlock_t stli_lock;    /* TTY logic lock */
+static spinlock_t brd_lock;     /* Board logic lock */
+
 /*
  *      There is some experimental EISA board detection code in this driver.
  *      By default it is disabled, but for those that want to try it out,
@@ -173,14 +176,6 @@ static char	*stli_serialname = "ttyE";
 
 static struct tty_driver        *stli_serial;
 
-/*
- *      We will need to allocate a temporary write buffer for chars that
- *      come direct from user space. The problem is that a copy from user
- *      space might cause a page fault (typically on a system that is
- *      swapping!). All ports will share one buffer - since if the system
- *      is already swapping a shared buffer won't make things any worse.
- */
-static char                     *stli_tmpwritebuf;
 
 #define STLI_TXBUFSIZE          4096
 
@@ -419,7 +414,7 @@ static int	stli_eisamempsize = ARRAY_SIZE(stli_eisamemprobeaddrs);
 #endif
 
 static struct pci_device_id istallion_pci_tbl[] = {
-        { PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECRA, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
+        { PCI_DEVICE(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECRA), },
         { 0 }
 };
 MODULE_DEVICE_TABLE(pci, istallion_pci_tbl);
@@ -682,7 +677,7 @@ static int	stli_startbrd(stlibrd_t *brdp);
 static ssize_t  stli_memread(struct file *fp, char __user *buf, size_t count, loff_t *offp);
 static ssize_t  stli_memwrite(struct file *fp, const char __user *buf, size_t count, loff_t *offp);
 static int      stli_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg);
-static void     stli_brdpoll(stlibrd_t *brdp, volatile cdkhdr_t *hdrp);
+static void     stli_brdpoll(stlibrd_t *brdp, cdkhdr_t __iomem *hdrp);
 static void     stli_poll(unsigned long arg);
 static int      stli_hostcmd(stlibrd_t *brdp, stliport_t *portp);
 static int      stli_initopen(stlibrd_t *brdp, stliport_t *portp);
@@ -693,7 +688,8 @@ static void	stli_dohangup(void *arg);
 static int      stli_setport(stliport_t *portp);
 static int      stli_cmdwait(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback);
 static void     stli_sendcmd(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback);
-static void     stli_dodelaycmd(stliport_t *portp, volatile cdkctrl_t *cp);
+static void     __stli_sendcmd(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback);
+static void     stli_dodelaycmd(stliport_t *portp, cdkctrl_t __iomem *cp);
 static void     stli_mkasyport(stliport_t *portp, asyport_t *pp, struct termios *tiosp);
 static void     stli_mkasysigs(asysigs_t *sp, int dtr, int rts);
 static long     stli_mktiocm(unsigned long sigvalue);
@@ -799,18 +795,8 @@ static struct class *istallion_class;
 
 static int __init istallion_module_init(void)
 {
-        unsigned long   flags;
-
-#ifdef DEBUG
-        printk("init_module()\n");
-#endif
-
-        save_flags(flags);
-        cli();
         stli_init();
-        restore_flags(flags);
-
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
@@ -819,33 +805,24 @@ static void __exit istallion_module_exit(void)
 {
         stlibrd_t       *brdp;
         stliport_t      *portp;
-        unsigned long   flags;
         int             i, j;
 
-#ifdef DEBUG
-        printk("cleanup_module()\n");
-#endif
-
         printk(KERN_INFO "Unloading %s: version %s\n", stli_drvtitle,
                 stli_drvversion);
 
-        save_flags(flags);
-        cli();
-
-/*
- *      Free up all allocated resources used by the ports. This includes
- *      memory and interrupts.
- */
+        /*
+         *      Free up all allocated resources used by the ports. This includes
+         *      memory and interrupts.
+         */
         if (stli_timeron) {
                 stli_timeron = 0;
-                del_timer(&stli_timerlist);
+                del_timer_sync(&stli_timerlist);
         }
 
         i = tty_unregister_driver(stli_serial);
         if (i) {
                 printk("STALLION: failed to un-register tty driver, "
                         "errno=%d\n", -i);
-                restore_flags(flags);
                 return;
         }
         put_tty_driver(stli_serial);
@@ -859,16 +836,15 @@ static void __exit istallion_module_exit(void)
                 printk("STALLION: failed to un-register serial memory device, "
                         "errno=%d\n", -i);
 
-        kfree(stli_tmpwritebuf);
         kfree(stli_txcookbuf);
 
         for (i = 0; (i < stli_nrbrds); i++) {
-                if ((brdp = stli_brds[i]) == (stlibrd_t *) NULL)
+                if ((brdp = stli_brds[i]) == NULL)
                         continue;
                 for (j = 0; (j < STL_MAXPORTS); j++) {
                         portp = brdp->ports[j];
-                        if (portp != (stliport_t *) NULL) {
-                                if (portp->tty != (struct tty_struct *) NULL)
+                        if (portp != NULL) {
+                                if (portp->tty != NULL)
                                         tty_hangup(portp->tty);
                                 kfree(portp);
                         }
@@ -878,10 +854,8 @@ static void __exit istallion_module_exit(void)
                 if (brdp->iosize > 0)
                         release_region(brdp->iobase, brdp->iosize);
                 kfree(brdp);
-                stli_brds[i] = (stlibrd_t *) NULL;
+                stli_brds[i] = NULL;
         }
-
-        restore_flags(flags);
 }
 
 module_init(istallion_module_init);
@@ -895,19 +869,15 @@ module_exit(istallion_module_exit);
 
 static void stli_argbrds(void)
 {
-        stlconf_t       conf;
-        stlibrd_t       *brdp;
-        int             i;
-
-#ifdef DEBUG
-        printk("stli_argbrds()\n");
-#endif
+        stlconf_t conf;
+        stlibrd_t *brdp;
+        int i;
 
         for (i = stli_nrbrds; i < ARRAY_SIZE(stli_brdsp); i++) {
                 memset(&conf, 0, sizeof(conf));
                 if (stli_parsebrd(&conf, stli_brdsp[i]) == 0)
                         continue;
-                if ((brdp = stli_allocbrd()) == (stlibrd_t *) NULL)
+                if ((brdp = stli_allocbrd()) == NULL)
                         continue;
                 stli_nrbrds = i + 1;
                 brdp->brdnr = i;
@@ -926,9 +896,9 @@ static void stli_argbrds(void)
 
 static unsigned long stli_atol(char *str)
 {
-        unsigned long   val;
-        int             base, c;
-        char            *sp;
+        unsigned long val;
+        int base, c;
+        char *sp;
 
         val = 0;
         sp = str;
@@ -962,15 +932,11 @@ static unsigned long stli_atol(char *str)
 
 static int stli_parsebrd(stlconf_t *confp, char **argp)
 {
-        char    *sp;
-        int     i;
-
-#ifdef DEBUG
-        printk("stli_parsebrd(confp=%x,argp=%x)\n", (int) confp, (int) argp);
-#endif
+        char *sp;
+        int i;
 
-        if ((argp[0] == (char *) NULL) || (*argp[0] == 0))
-                return(0);
+        if (argp[0] == NULL || *argp[0] == 0)
+                return 0;
 
         for (sp = argp[0], i = 0; ((*sp != 0) && (i < 25)); sp++, i++)
                 *sp = TOLOWER(*sp);
@@ -985,9 +951,9 @@ static int stli_parsebrd(stlconf_t *confp, char **argp)
         }
 
         confp->brdtype = stli_brdstr[i].type;
-        if ((argp[1] != (char *) NULL) && (*argp[1] != 0))
+        if (argp[1] != NULL && *argp[1] != 0)
                 confp->ioaddr1 = stli_atol(argp[1]);
-        if ((argp[2] != (char *) NULL) && (*argp[2] != 0))
+        if (argp[2] !=  NULL && *argp[2] != 0)
                 confp->memaddr = stli_atol(argp[2]);
         return(1);
 }
@@ -998,34 +964,29 @@ static int stli_parsebrd(stlconf_t *confp, char **argp)
 
 static int stli_open(struct tty_struct *tty, struct file *filp)
 {
-        stlibrd_t       *brdp;
-        stliport_t      *portp;
-        unsigned int    minordev;
-        int             brdnr, portnr, rc;
-
-#ifdef DEBUG
-        printk("stli_open(tty=%x,filp=%x): device=%s\n", (int) tty,
-                (int) filp, tty->name);
-#endif
+        stlibrd_t *brdp;
+        stliport_t *portp;
+        unsigned int minordev;
+        int brdnr, portnr, rc;
 
         minordev = tty->index;
         brdnr = MINOR2BRD(minordev);
         if (brdnr >= stli_nrbrds)
-                return(-ENODEV);
+                return -ENODEV;
         brdp = stli_brds[brdnr];
-        if (brdp == (stlibrd_t *) NULL)
-                return(-ENODEV);
+        if (brdp == NULL)
+                return -ENODEV;
         if ((brdp->state & BST_STARTED) == 0)
-                return(-ENODEV);
+                return -ENODEV;
         portnr = MINOR2PORT(minordev);
         if ((portnr < 0) || (portnr > brdp->nrports))
-                return(-ENODEV);
+                return -ENODEV;
 
         portp = brdp->ports[portnr];
-        if (portp == (stliport_t *) NULL)
-                return(-ENODEV);
+        if (portp == NULL)
+                return -ENODEV;
         if (portp->devnr < 1)
-                return(-ENODEV);
+                return -ENODEV;
 
 
 /*
@@ -1037,8 +998,8 @@ static int stli_open(struct tty_struct *tty, struct file *filp)
         if (portp->flags & ASYNC_CLOSING) {
                 interruptible_sleep_on(&portp->close_wait);
                 if (portp->flags & ASYNC_HUP_NOTIFY)
-                        return(-EAGAIN);
-                return(-ERESTARTSYS);
+                        return -EAGAIN;
+                return -ERESTARTSYS;
         }
 
 /*
@@ -1054,7 +1015,7 @@ static int stli_open(struct tty_struct *tty, struct file *filp)
         wait_event_interruptible(portp->raw_wait,
                         !test_bit(ST_INITIALIZING, &portp->state));
         if (signal_pending(current))
-                return(-ERESTARTSYS);
+                return -ERESTARTSYS;
 
         if ((portp->flags & ASYNC_INITIALIZED) == 0) {
                 set_bit(ST_INITIALIZING, &portp->state);
@@ -1065,7 +1026,7 @@ static int stli_open(struct tty_struct *tty, struct file *filp)
                 clear_bit(ST_INITIALIZING, &portp->state);
                 wake_up_interruptible(&portp->raw_wait);
                 if (rc < 0)
-                        return(rc);
+                        return rc;
         }
 
 /*
@@ -1077,8 +1038,8 @@ static int stli_open(struct tty_struct *tty, struct file *filp)
         if (portp->flags & ASYNC_CLOSING) {
                 interruptible_sleep_on(&portp->close_wait);
                 if (portp->flags & ASYNC_HUP_NOTIFY)
-                        return(-EAGAIN);
-                return(-ERESTARTSYS);
+                        return -EAGAIN;
+                return -ERESTARTSYS;
         }
 
 /*
@@ -1088,38 +1049,33 @@ static int stli_open(struct tty_struct *tty, struct file *filp)
  */
         if (!(filp->f_flags & O_NONBLOCK)) {
                 if ((rc = stli_waitcarrier(brdp, portp, filp)) != 0)
-                        return(rc);
+                        return rc;
         }
         portp->flags |= ASYNC_NORMAL_ACTIVE;
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
 
 static void stli_close(struct tty_struct *tty, struct file *filp)
 {
-        stlibrd_t       *brdp;
-        stliport_t      *portp;
-        unsigned long   flags;
-
-#ifdef DEBUG
-        printk("stli_close(tty=%x,filp=%x)\n", (int) tty, (int) filp);
-#endif
+        stlibrd_t *brdp;
+        stliport_t *portp;
+        unsigned long flags;
 
         portp = tty->driver_data;
-        if (portp == (stliport_t *) NULL)
+        if (portp == NULL)
                 return;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&stli_lock, flags);
         if (tty_hung_up_p(filp)) {
-                restore_flags(flags);
+                spin_unlock_irqrestore(&stli_lock, flags);
                 return;
         }
         if ((tty->count == 1) && (portp->refcount != 1))
                 portp->refcount = 1;
         if (portp->refcount-- > 1) {
-                restore_flags(flags);
+                spin_unlock_irqrestore(&stli_lock, flags);
                 return;
         }
 
@@ -1134,6 +1090,8 @@ static void stli_close(struct tty_struct *tty, struct file *filp)
         if (tty == stli_txcooktty)
                 stli_flushchars(tty);
         tty->closing = 1;
+        spin_unlock_irqrestore(&stli_lock, flags);
+
         if (portp->closing_wait != ASYNC_CLOSING_WAIT_NONE)
                 tty_wait_until_sent(tty, portp->closing_wait);
 
@@ -1157,7 +1115,7 @@ static void stli_close(struct tty_struct *tty, struct file *filp)
         stli_flushbuffer(tty);
 
         tty->closing = 0;
-        portp->tty = (struct tty_struct *) NULL;
+        portp->tty = NULL;
 
         if (portp->openwaitcnt) {
                 if (portp->close_delay)
@@ -1167,7 +1125,6 @@ static void stli_close(struct tty_struct *tty, struct file *filp)
 
         portp->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
         wake_up_interruptible(&portp->close_wait);
-        restore_flags(flags);
 }
 
 /*****************************************************************************/
@@ -1182,45 +1139,41 @@ static void stli_close(struct tty_struct *tty, struct file *filp)
 
 static int stli_initopen(stlibrd_t *brdp, stliport_t *portp)
 {
-        struct tty_struct       *tty;
-        asynotify_t             nt;
-        asyport_t               aport;
-        int                     rc;
-
-#ifdef DEBUG
-        printk("stli_initopen(brdp=%x,portp=%x)\n", (int) brdp, (int) portp);
-#endif
+        struct tty_struct *tty;
+        asynotify_t nt;
+        asyport_t aport;
+        int rc;
 
         if ((rc = stli_rawopen(brdp, portp, 0, 1)) < 0)
-                return(rc);
+                return rc;
 
         memset(&nt, 0, sizeof(asynotify_t));
         nt.data = (DT_TXLOW | DT_TXEMPTY | DT_RXBUSY | DT_RXBREAK);
         nt.signal = SG_DCD;
         if ((rc = stli_cmdwait(brdp, portp, A_SETNOTIFY, &nt,
             sizeof(asynotify_t), 0)) < 0)
-                return(rc);
+                return rc;
 
         tty = portp->tty;
-        if (tty == (struct tty_struct *) NULL)
-                return(-ENODEV);
+        if (tty == NULL)
+                return -ENODEV;
         stli_mkasyport(portp, &aport, tty->termios);
         if ((rc = stli_cmdwait(brdp, portp, A_SETPORT, &aport,
             sizeof(asyport_t), 0)) < 0)
-                return(rc);
+                return rc;
 
         set_bit(ST_GETSIGS, &portp->state);
         if ((rc = stli_cmdwait(brdp, portp, A_GETSIGNALS, &portp->asig,
             sizeof(asysigs_t), 1)) < 0)
-                return(rc);
+                return rc;
         if (test_and_clear_bit(ST_GETSIGS, &portp->state))
                 portp->sigs = stli_mktiocm(portp->asig.sigvalue);
         stli_mkasysigs(&portp->asig, 1, 1);
         if ((rc = stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
             sizeof(asysigs_t), 0)) < 0)
-                return(rc);
+                return rc;
 
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
@@ -1234,22 +1187,15 @@ static int stli_initopen(stlibrd_t *brdp, stliport_t *portp)
 
 static int stli_rawopen(stlibrd_t *brdp, stliport_t *portp, unsigned long arg, int wait)
 {
-        volatile cdkhdr_t       *hdrp;
-        volatile cdkctrl_t      *cp;
-        volatile unsigned char  *bits;
-        unsigned long           flags;
-        int                     rc;
-
-#ifdef DEBUG
-        printk("stli_rawopen(brdp=%x,portp=%x,arg=%x,wait=%d)\n",
-                (int) brdp, (int) portp, (int) arg, wait);
-#endif
+        cdkhdr_t __iomem *hdrp;
+        cdkctrl_t __iomem *cp;
+        unsigned char __iomem *bits;
+        unsigned long flags;
+        int rc;
 
 /*
  *      Send a message to the slave to open this port.
  */
-        save_flags(flags);
-        cli();
 
 /*
  *      Slave is already closing this port. This can happen if a hangup
@@ -1260,7 +1206,6 @@ static int stli_rawopen(stlibrd_t *brdp, stliport_t *portp, unsigned long arg, i
         wait_event_interruptible(portp->raw_wait,
                         !test_bit(ST_CLOSING, &portp->state));
         if (signal_pending(current)) {
-                restore_flags(flags);
                 return -ERESTARTSYS;
         }
 
@@ -1269,19 +1214,20 @@ static int stli_rawopen(stlibrd_t *brdp, stliport_t *portp, unsigned long arg, i
  *      memory. Once the message is in set the service bits to say that
  *      this port wants service.
  */
+        spin_lock_irqsave(&brd_lock, flags);
         EBRDENABLE(brdp);
-        cp = &((volatile cdkasy_t *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
-        cp->openarg = arg;
-        cp->open = 1;
-        hdrp = (volatile cdkhdr_t *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
-        bits = ((volatile unsigned char *) hdrp) + brdp->slaveoffset +
+        cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
+        writel(arg, &cp->openarg);
+        writeb(1, &cp->open);
+        hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
+        bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
                 portp->portidx;
-        *bits |= portp->portbit;
+        writeb(readb(bits) | portp->portbit, bits);
         EBRDDISABLE(brdp);
 
         if (wait == 0) {
-                restore_flags(flags);
-                return(0);
+                spin_unlock_irqrestore(&brd_lock, flags);
+                return 0;
         }
 
 /*
@@ -1290,15 +1236,16 @@ static int stli_rawopen(stlibrd_t *brdp, stliport_t *portp, unsigned long arg, i
  */
         rc = 0;
         set_bit(ST_OPENING, &portp->state);
+        spin_unlock_irqrestore(&brd_lock, flags);
+
         wait_event_interruptible(portp->raw_wait,
                         !test_bit(ST_OPENING, &portp->state));
         if (signal_pending(current))
                 rc = -ERESTARTSYS;
-        restore_flags(flags);
 
         if ((rc == 0) && (portp->rc != 0))
                 rc = -EIO;
-        return(rc);
+        return rc;
 }
 
 /*****************************************************************************/
@@ -1311,19 +1258,11 @@ static int stli_rawopen(stlibrd_t *brdp, stliport_t *portp, unsigned long arg, i
 
 static int stli_rawclose(stlibrd_t *brdp, stliport_t *portp, unsigned long arg, int wait)
 {
-        volatile cdkhdr_t       *hdrp;
-        volatile cdkctrl_t      *cp;
-        volatile unsigned char  *bits;
-        unsigned long           flags;
-        int                     rc;
-
-#ifdef DEBUG
-        printk("stli_rawclose(brdp=%x,portp=%x,arg=%x,wait=%d)\n",
-                (int) brdp, (int) portp, (int) arg, wait);
-#endif
-
-        save_flags(flags);
-        cli();
+        cdkhdr_t __iomem *hdrp;
+        cdkctrl_t __iomem *cp;
+        unsigned char __iomem *bits;
+        unsigned long flags;
+        int rc;
 
 /*
  *      Slave is already closing this port. This can happen if a hangup
@@ -1333,7 +1272,6 @@ static int stli_rawclose(stlibrd_t *brdp, stliport_t *portp, unsigned long arg,
                 wait_event_interruptible(portp->raw_wait,
                                 !test_bit(ST_CLOSING, &portp->state));
                 if (signal_pending(current)) {
-                        restore_flags(flags);
                         return -ERESTARTSYS;
                 }
         }
@@ -1341,21 +1279,22 @@ static int stli_rawclose(stlibrd_t *brdp, stliport_t *portp, unsigned long arg,
 /*
  *      Write the close command into shared memory.
  */
+        spin_lock_irqsave(&brd_lock, flags);
         EBRDENABLE(brdp);
-        cp = &((volatile cdkasy_t *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
-        cp->closearg = arg;
-        cp->close = 1;
-        hdrp = (volatile cdkhdr_t *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
-        bits = ((volatile unsigned char *) hdrp) + brdp->slaveoffset +
+        cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
+        writel(arg, &cp->closearg);
+        writeb(1, &cp->close);
+        hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
+        bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
                 portp->portidx;
-        *bits |= portp->portbit;
+        writeb(readb(bits) |portp->portbit, bits);
         EBRDDISABLE(brdp);
 
         set_bit(ST_CLOSING, &portp->state);
-        if (wait == 0) {
-                restore_flags(flags);
-                return(0);
-        }
+        spin_unlock_irqrestore(&brd_lock, flags);
+
+        if (wait == 0)
+                return 0;
 
 /*
  *      Slave is in action, so now we must wait for the open acknowledgment
@@ -1366,11 +1305,10 @@ static int stli_rawclose(stlibrd_t *brdp, stliport_t *portp, unsigned long arg,
                         !test_bit(ST_CLOSING, &portp->state));
         if (signal_pending(current))
                 rc = -ERESTARTSYS;
-        restore_flags(flags);
 
         if ((rc == 0) && (portp->rc != 0))
                 rc = -EIO;
-        return(rc);
+        return rc;
 }
 
 /*****************************************************************************/
@@ -1384,36 +1322,21 @@ static int stli_rawclose(stlibrd_t *brdp, stliport_t *portp, unsigned long arg,
 
 static int stli_cmdwait(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback)
 {
-        unsigned long   flags;
-
-#ifdef DEBUG
-        printk("stli_cmdwait(brdp=%x,portp=%x,cmd=%x,arg=%x,size=%d,"
-                "copyback=%d)\n", (int) brdp, (int) portp, (int) cmd,
-                (int) arg, size, copyback);
-#endif
-
-        save_flags(flags);
-        cli();
         wait_event_interruptible(portp->raw_wait,
                         !test_bit(ST_CMDING, &portp->state));
-        if (signal_pending(current)) {
-                restore_flags(flags);
+        if (signal_pending(current))
                 return -ERESTARTSYS;
-        }
 
         stli_sendcmd(brdp, portp, cmd, arg, size, copyback);
 
         wait_event_interruptible(portp->raw_wait,
                         !test_bit(ST_CMDING, &portp->state));
-        if (signal_pending(current)) {
-                restore_flags(flags);
+        if (signal_pending(current))
                 return -ERESTARTSYS;
-        }
-        restore_flags(flags);
 
         if (portp->rc != 0)
-                return(-EIO);
-        return(0);
+                return -EIO;
+        return 0;
 }
 
 /*****************************************************************************/
@@ -1425,22 +1348,18 @@ static int stli_cmdwait(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, v
 
 static int stli_setport(stliport_t *portp)
 {
-        stlibrd_t       *brdp;
-        asyport_t       aport;
-
-#ifdef DEBUG
-        printk("stli_setport(portp=%x)\n", (int) portp);
-#endif
+        stlibrd_t *brdp;
+        asyport_t aport;
 
-        if (portp == (stliport_t *) NULL)
-                return(-ENODEV);
-        if (portp->tty == (struct tty_struct *) NULL)
-                return(-ENODEV);
-        if ((portp->brdnr < 0) && (portp->brdnr >= stli_nrbrds))
-                return(-ENODEV);
+        if (portp == NULL)
+                return -ENODEV;
+        if (portp->tty == NULL)
+                return -ENODEV;
+        if (portp->brdnr < 0 && portp->brdnr >= stli_nrbrds)
+                return -ENODEV;
         brdp = stli_brds[portp->brdnr];
-        if (brdp == (stlibrd_t *) NULL)
-                return(-ENODEV);
+        if (brdp == NULL)
+                return -ENODEV;
 
         stli_mkasyport(portp, &aport, portp->tty->termios);
         return(stli_cmdwait(brdp, portp, A_SETPORT, &aport, sizeof(asyport_t), 0));
@@ -1455,13 +1374,8 @@ static int stli_setport(stliport_t *portp)
 
 static int stli_waitcarrier(stlibrd_t *brdp, stliport_t *portp, struct file *filp)
 {
-        unsigned long   flags;
-        int             rc, doclocal;
-
-#ifdef DEBUG
-        printk("stli_waitcarrier(brdp=%x,portp=%x,filp=%x)\n",
-                (int) brdp, (int) portp, (int) filp);
-#endif
+        unsigned long flags;
+        int rc, doclocal;
 
         rc = 0;
         doclocal = 0;
@@ -1469,11 +1383,11 @@ static int stli_waitcarrier(stlibrd_t *brdp, stliport_t *portp, struct file *fil
         if (portp->tty->termios->c_cflag & CLOCAL)
                 doclocal++;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&stli_lock, flags);
         portp->openwaitcnt++;
         if (! tty_hung_up_p(filp))
                 portp->refcount--;
+        spin_unlock_irqrestore(&stli_lock, flags);
 
         for (;;) {
                 stli_mkasysigs(&portp->asig, 1, 1);
@@ -1499,12 +1413,13 @@ static int stli_waitcarrier(stlibrd_t *brdp, stliport_t *portp, struct file *fil
                 interruptible_sleep_on(&portp->open_wait);
         }
 
+        spin_lock_irqsave(&stli_lock, flags);
         if (! tty_hung_up_p(filp))
                 portp->refcount++;
         portp->openwaitcnt--;
-        restore_flags(flags);
+        spin_unlock_irqrestore(&stli_lock, flags);
 
-        return(rc);
+        return rc;
 }
 
 /*****************************************************************************/
@@ -1517,46 +1432,38 @@ static int stli_waitcarrier(stlibrd_t *brdp, stliport_t *portp, struct file *fil
 
 static int stli_write(struct tty_struct *tty, const unsigned char *buf, int count)
 {
-        volatile cdkasy_t       *ap;
-        volatile cdkhdr_t       *hdrp;
-        volatile unsigned char  *bits;
-        unsigned char           *shbuf, *chbuf;
-        stliport_t              *portp;
-        stlibrd_t               *brdp;
-        unsigned int            len, stlen, head, tail, size;
-        unsigned long           flags;
-
-#ifdef DEBUG
-        printk("stli_write(tty=%x,buf=%x,count=%d)\n",
-                (int) tty, (int) buf, count);
-#endif
+        cdkasy_t __iomem *ap;
+        cdkhdr_t __iomem *hdrp;
+        unsigned char __iomem *bits;
+        unsigned char __iomem *shbuf;
+        unsigned char *chbuf;
+        stliport_t *portp;
+        stlibrd_t *brdp;
+        unsigned int len, stlen, head, tail, size;
+        unsigned long flags;
 
-        if ((tty == (struct tty_struct *) NULL) ||
-            (stli_tmpwritebuf == (char *) NULL))
-                return(0);
         if (tty == stli_txcooktty)
                 stli_flushchars(tty);
         portp = tty->driver_data;
-        if (portp == (stliport_t *) NULL)
-                return(0);
+        if (portp == NULL)
+                return 0;
         if ((portp->brdnr < 0) || (portp->brdnr >= stli_nrbrds))
-                return(0);
+                return 0;
         brdp = stli_brds[portp->brdnr];
-        if (brdp == (stlibrd_t *) NULL)
-                return(0);
+        if (brdp == NULL)
+                return 0;
         chbuf = (unsigned char *) buf;
 
 /*
  *      All data is now local, shove as much as possible into shared memory.
  */
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         EBRDENABLE(brdp);
-        ap = (volatile cdkasy_t *) EBRDGETMEMPTR(brdp, portp->addr);
-        head = (unsigned int) ap->txq.head;
-        tail = (unsigned int) ap->txq.tail;
-        if (tail != ((unsigned int) ap->txq.tail))
-                tail = (unsigned int) ap->txq.tail;
+        ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
+        head = (unsigned int) readw(&ap->txq.head);
+        tail = (unsigned int) readw(&ap->txq.tail);
+        if (tail != ((unsigned int) readw(&ap->txq.tail)))
+                tail = (unsigned int) readw(&ap->txq.tail);
         size = portp->txsize;
         if (head >= tail) {
                 len = size - (head - tail) - 1;
@@ -1568,11 +1475,11 @@ static int stli_write(struct tty_struct *tty, const unsigned char *buf, int coun
 
         len = MIN(len, count);
         count = 0;
-        shbuf = (char *) EBRDGETMEMPTR(brdp, portp->txoffset);
+        shbuf = (char __iomem *) EBRDGETMEMPTR(brdp, portp->txoffset);
 
         while (len > 0) {
                 stlen = MIN(len, stlen);
-                memcpy((shbuf + head), chbuf, stlen);
+                memcpy_toio(shbuf + head, chbuf, stlen);
                 chbuf += stlen;
                 len -= stlen;
                 count += stlen;
@@ -1583,20 +1490,19 @@ static int stli_write(struct tty_struct *tty, const unsigned char *buf, int coun
                 }
         }
 
-        ap = (volatile cdkasy_t *) EBRDGETMEMPTR(brdp, portp->addr);
-        ap->txq.head = head;
+        ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
+        writew(head, &ap->txq.head);
         if (test_bit(ST_TXBUSY, &portp->state)) {
-                if (ap->changed.data & DT_TXEMPTY)
-                        ap->changed.data &= ~DT_TXEMPTY;
+                if (readl(&ap->changed.data) & DT_TXEMPTY)
+                        writel(readl(&ap->changed.data) & ~DT_TXEMPTY, &ap->changed.data);
         }
-        hdrp = (volatile cdkhdr_t *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
-        bits = ((volatile unsigned char *) hdrp) + brdp->slaveoffset +
+        hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
+        bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
                 portp->portidx;
-        *bits |= portp->portbit;
+        writeb(readb(bits) | portp->portbit, bits);
         set_bit(ST_TXBUSY, &portp->state);
         EBRDDISABLE(brdp);
-
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 
         return(count);
 }
@@ -1613,14 +1519,8 @@ static int stli_write(struct tty_struct *tty, const unsigned char *buf, int coun
 
 static void stli_putchar(struct tty_struct *tty, unsigned char ch)
 {
-#ifdef DEBUG
-        printk("stli_putchar(tty=%x,ch=%x)\n", (int) tty, (int) ch);
-#endif
-
-        if (tty == (struct tty_struct *) NULL)
-                return;
         if (tty != stli_txcooktty) {
-                if (stli_txcooktty != (struct tty_struct *) NULL)
+                if (stli_txcooktty != NULL)
                         stli_flushchars(stli_txcooktty);
                 stli_txcooktty = tty;
         }
@@ -1640,29 +1540,26 @@ static void stli_putchar(struct tty_struct *tty, unsigned char ch)
 
 static void stli_flushchars(struct tty_struct *tty)
 {
-        volatile cdkhdr_t       *hdrp;
-        volatile unsigned char  *bits;
-        volatile cdkasy_t       *ap;
-        struct tty_struct       *cooktty;
-        stliport_t              *portp;
-        stlibrd_t               *brdp;
-        unsigned int            len, stlen, head, tail, size, count, cooksize;
-        unsigned char           *buf, *shbuf;
-        unsigned long           flags;
-
-#ifdef DEBUG
-        printk("stli_flushchars(tty=%x)\n", (int) tty);
-#endif
+        cdkhdr_t __iomem *hdrp;
+        unsigned char __iomem *bits;
+        cdkasy_t __iomem *ap;
+        struct tty_struct *cooktty;
+        stliport_t *portp;
+        stlibrd_t *brdp;
+        unsigned int len, stlen, head, tail, size, count, cooksize;
+        unsigned char *buf;
+        unsigned char __iomem *shbuf;
+        unsigned long flags;
 
         cooksize = stli_txcooksize;
         cooktty = stli_txcooktty;
         stli_txcooksize = 0;
         stli_txcookrealsize = 0;
-        stli_txcooktty = (struct tty_struct *) NULL;
+        stli_txcooktty = NULL;
 
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return;
-        if (cooktty == (struct tty_struct *) NULL)
+        if (cooktty == NULL)
                 return;
         if (tty != cooktty)
                 tty = cooktty;
@@ -1670,23 +1567,22 @@ static void stli_flushchars(struct tty_struct *tty)
                 return;
 
         portp = tty->driver_data;
-        if (portp == (stliport_t *) NULL)
+        if (portp == NULL)
                 return;
         if ((portp->brdnr < 0) || (portp->brdnr >= stli_nrbrds))
                 return;
         brdp = stli_brds[portp->brdnr];
-        if (brdp == (stlibrd_t *) NULL)
+        if (brdp == NULL)
                 return;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         EBRDENABLE(brdp);
 
-        ap = (volatile cdkasy_t *) EBRDGETMEMPTR(brdp, portp->addr);
-        head = (unsigned int) ap->txq.head;
-        tail = (unsigned int) ap->txq.tail;
-        if (tail != ((unsigned int) ap->txq.tail))
-                tail = (unsigned int) ap->txq.tail;
+        ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
+        head = (unsigned int) readw(&ap->txq.head);
+        tail = (unsigned int) readw(&ap->txq.tail);
+        if (tail != ((unsigned int) readw(&ap->txq.tail)))
+                tail = (unsigned int) readw(&ap->txq.tail);
         size = portp->txsize;
         if (head >= tail) {
                 len = size - (head - tail) - 1;
@@ -1703,7 +1599,7 @@ static void stli_flushchars(struct tty_struct *tty)
 
         while (len > 0) {
                 stlen = MIN(len, stlen);
-                memcpy((shbuf + head), buf, stlen);
+                memcpy_toio(shbuf + head, buf, stlen);
                 buf += stlen;
                 len -= stlen;
                 count += stlen;
@@ -1714,73 +1610,66 @@ static void stli_flushchars(struct tty_struct *tty)
                 }
         }
 
-        ap = (volatile cdkasy_t *) EBRDGETMEMPTR(brdp, portp->addr);
-        ap->txq.head = head;
+        ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
+        writew(head, &ap->txq.head);
 
         if (test_bit(ST_TXBUSY, &portp->state)) {
-                if (ap->changed.data & DT_TXEMPTY)
-                        ap->changed.data &= ~DT_TXEMPTY;
+                if (readl(&ap->changed.data) & DT_TXEMPTY)
+                        writel(readl(&ap->changed.data) & ~DT_TXEMPTY, &ap->changed.data);
         }
-        hdrp = (volatile cdkhdr_t *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
-        bits = ((volatile unsigned char *) hdrp) + brdp->slaveoffset +
+        hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
+        bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
                 portp->portidx;
-        *bits |= portp->portbit;
+        writeb(readb(bits) | portp->portbit, bits);
         set_bit(ST_TXBUSY, &portp->state);
 
         EBRDDISABLE(brdp);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
 
 static int stli_writeroom(struct tty_struct *tty)
 {
-        volatile cdkasyrq_t     *rp;
-        stliport_t              *portp;
-        stlibrd_t               *brdp;
-        unsigned int            head, tail, len;
-        unsigned long           flags;
-
-#ifdef DEBUG
-        printk("stli_writeroom(tty=%x)\n", (int) tty);
-#endif
+        cdkasyrq_t __iomem *rp;
+        stliport_t *portp;
+        stlibrd_t *brdp;
+        unsigned int head, tail, len;
+        unsigned long flags;
 
-        if (tty == (struct tty_struct *) NULL)
-                return(0);
         if (tty == stli_txcooktty) {
                 if (stli_txcookrealsize != 0) {
                         len = stli_txcookrealsize - stli_txcooksize;
-                        return(len);
+                        return len;
                 }
         }
 
         portp = tty->driver_data;
-        if (portp == (stliport_t *) NULL)
-                return(0);
+        if (portp == NULL)
+                return 0;
         if ((portp->brdnr < 0) || (portp->brdnr >= stli_nrbrds))
-                return(0);
+                return 0;
         brdp = stli_brds[portp->brdnr];
-        if (brdp == (stlibrd_t *) NULL)
-                return(0);
+        if (brdp == NULL)
+                return 0;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         EBRDENABLE(brdp);
-        rp = &((volatile cdkasy_t *) EBRDGETMEMPTR(brdp, portp->addr))->txq;
-        head = (unsigned int) rp->head;
-        tail = (unsigned int) rp->tail;
-        if (tail != ((unsigned int) rp->tail))
-                tail = (unsigned int) rp->tail;
+        rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->txq;
+        head = (unsigned int) readw(&rp->head);
+        tail = (unsigned int) readw(&rp->tail);
+        if (tail != ((unsigned int) readw(&rp->tail)))
+                tail = (unsigned int) readw(&rp->tail);
         len = (head >= tail) ? (portp->txsize - (head - tail)) : (tail - head);
         len--;
         EBRDDISABLE(brdp);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 
         if (tty == stli_txcooktty) {
                 stli_txcookrealsize = len;
                 len -= stli_txcooksize;
         }
-        return(len);
+        return len;
 }
 
 /*****************************************************************************/
@@ -1795,44 +1684,37 @@ static int stli_writeroom(struct tty_struct *tty)
 
 static int stli_charsinbuffer(struct tty_struct *tty)
 {
-        volatile cdkasyrq_t     *rp;
-        stliport_t              *portp;
-        stlibrd_t               *brdp;
-        unsigned int            head, tail, len;
-        unsigned long           flags;
-
-#ifdef DEBUG
-        printk("stli_charsinbuffer(tty=%x)\n", (int) tty);
-#endif
+        cdkasyrq_t __iomem *rp;
+        stliport_t *portp;
+        stlibrd_t *brdp;
+        unsigned int head, tail, len;
+        unsigned long flags;
 
-        if (tty == (struct tty_struct *) NULL)
-                return(0);
         if (tty == stli_txcooktty)
                 stli_flushchars(tty);
         portp = tty->driver_data;
-        if (portp == (stliport_t *) NULL)
-                return(0);
+        if (portp == NULL)
+                return 0;
         if ((portp->brdnr < 0) || (portp->brdnr >= stli_nrbrds))
-                return(0);
+                return 0;
         brdp = stli_brds[portp->brdnr];
-        if (brdp == (stlibrd_t *) NULL)
-                return(0);
+        if (brdp == NULL)
+                return 0;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         EBRDENABLE(brdp);
-        rp = &((volatile cdkasy_t *) EBRDGETMEMPTR(brdp, portp->addr))->txq;
-        head = (unsigned int) rp->head;
-        tail = (unsigned int) rp->tail;
-        if (tail != ((unsigned int) rp->tail))
-                tail = (unsigned int) rp->tail;
+        rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->txq;
+        head = (unsigned int) readw(&rp->head);
+        tail = (unsigned int) readw(&rp->tail);
+        if (tail != ((unsigned int) readw(&rp->tail)))
+                tail = (unsigned int) readw(&rp->tail);
         len = (head >= tail) ? (head - tail) : (portp->txsize - (tail - head));
         if ((len == 0) && test_bit(ST_TXBUSY, &portp->state))
                 len = 1;
         EBRDDISABLE(brdp);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 
-        return(len);
+        return len;
 }
 
 /*****************************************************************************/
@@ -1843,12 +1725,8 @@ static int stli_charsinbuffer(struct tty_struct *tty)
 
 static int stli_getserial(stliport_t *portp, struct serial_struct __user *sp)
 {
-        struct serial_struct    sio;
-        stlibrd_t               *brdp;
-
-#ifdef DEBUG
-        printk("stli_getserial(portp=%x,sp=%x)\n", (int) portp, (int) sp);
-#endif
+        struct serial_struct sio;
+        stlibrd_t *brdp;
 
         memset(&sio, 0, sizeof(struct serial_struct));
         sio.type = PORT_UNKNOWN;
@@ -1863,7 +1741,7 @@ static int stli_getserial(stliport_t *portp, struct serial_struct __user *sp)
         sio.hub6 = 0;
 
         brdp = stli_brds[portp->brdnr];
-        if (brdp != (stlibrd_t *) NULL)
+        if (brdp != NULL)
                 sio.port = brdp->iobase;
                 
         return copy_to_user(sp, &sio, sizeof(struct serial_struct)) ?
@@ -1880,12 +1758,8 @@ static int stli_getserial(stliport_t *portp, struct serial_struct __user *sp)
 
 static int stli_setserial(stliport_t *portp, struct serial_struct __user *sp)
 {
-        struct serial_struct    sio;
-        int                     rc;
-
-#ifdef DEBUG
-        printk("stli_setserial(portp=%p,sp=%p)\n", portp, sp);
-#endif
+        struct serial_struct sio;
+        int rc;
 
         if (copy_from_user(&sio, sp, sizeof(struct serial_struct)))
                 return -EFAULT;
@@ -1894,7 +1768,7 @@ static int stli_setserial(stliport_t *portp, struct serial_struct __user *sp)
                     (sio.close_delay != portp->close_delay) ||
                     ((sio.flags & ~ASYNC_USR_MASK) !=
                     (portp->flags & ~ASYNC_USR_MASK)))
-                        return(-EPERM);
+                        return -EPERM;
         } 
 
         portp->flags = (portp->flags & ~ASYNC_USR_MASK) |
@@ -1905,8 +1779,8 @@ static int stli_setserial(stliport_t *portp, struct serial_struct __user *sp)
         portp->custom_divisor = sio.custom_divisor;
 
         if ((rc = stli_setport(portp)) < 0)
-                return(rc);
-        return(0);
+                return rc;
+        return 0;
 }
 
 /*****************************************************************************/
@@ -1917,19 +1791,19 @@ static int stli_tiocmget(struct tty_struct *tty, struct file *file)
         stlibrd_t *brdp;
         int rc;
 
-        if (portp == (stliport_t *) NULL)
-                return(-ENODEV);
-        if ((portp->brdnr < 0) || (portp->brdnr >= stli_nrbrds))
-                return(0);
+        if (portp == NULL)
+                return -ENODEV;
+        if (portp->brdnr < 0 || portp->brdnr >= stli_nrbrds)
+                return 0;
         brdp = stli_brds[portp->brdnr];
-        if (brdp == (stlibrd_t *) NULL)
-                return(0);
+        if (brdp == NULL)
+                return 0;
         if (tty->flags & (1 << TTY_IO_ERROR))
-                return(-EIO);
+                return -EIO;
 
         if ((rc = stli_cmdwait(brdp, portp, A_GETSIGNALS,
                                &portp->asig, sizeof(asysigs_t), 1)) < 0)
-                return(rc);
+                return rc;
 
         return stli_mktiocm(portp->asig.sigvalue);
 }
@@ -1941,15 +1815,15 @@ static int stli_tiocmset(struct tty_struct *tty, struct file *file,
         stlibrd_t *brdp;
         int rts = -1, dtr = -1;
 
-        if (portp == (stliport_t *) NULL)
-                return(-ENODEV);
-        if ((portp->brdnr < 0) || (portp->brdnr >= stli_nrbrds))
-                return(0);
+        if (portp == NULL)
+                return -ENODEV;
+        if (portp->brdnr < 0 || portp->brdnr >= stli_nrbrds)
+                return 0;
         brdp = stli_brds[portp->brdnr];
-        if (brdp == (stlibrd_t *) NULL)
-                return(0);
+        if (brdp == NULL)
+                return 0;
         if (tty->flags & (1 << TTY_IO_ERROR))
-                return(-EIO);
+                return -EIO;
 
         if (set & TIOCM_RTS)
                 rts = 1;
@@ -1968,32 +1842,25 @@ static int stli_tiocmset(struct tty_struct *tty, struct file *file,
 
 static int stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
 {
-        stliport_t      *portp;
-        stlibrd_t       *brdp;
-        unsigned int    ival;
-        int             rc;
+        stliport_t *portp;
+        stlibrd_t *brdp;
+        unsigned int ival;
+        int rc;
         void __user *argp = (void __user *)arg;
 
-#ifdef DEBUG
-        printk("stli_ioctl(tty=%x,file=%x,cmd=%x,arg=%x)\n",
-                (int) tty, (int) file, cmd, (int) arg);
-#endif
-
-        if (tty == (struct tty_struct *) NULL)
-                return(-ENODEV);
         portp = tty->driver_data;
-        if (portp == (stliport_t *) NULL)
-                return(-ENODEV);
-        if ((portp->brdnr < 0) || (portp->brdnr >= stli_nrbrds))
-                return(0);
+        if (portp == NULL)
+                return -ENODEV;
+        if (portp->brdnr < 0 || portp->brdnr >= stli_nrbrds)
+                return 0;
         brdp = stli_brds[portp->brdnr];
-        if (brdp == (stlibrd_t *) NULL)
-                return(0);
+        if (brdp == NULL)
+                return 0;
 
         if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
             (cmd != COM_GETPORTSTATS) && (cmd != COM_CLRPORTSTATS)) {
                 if (tty->flags & (1 << TTY_IO_ERROR))
-                        return(-EIO);
+                        return -EIO;
         }
 
         rc = 0;
@@ -2040,7 +1907,7 @@ static int stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cm
                 break;
         }
 
-        return(rc);
+        return rc;
 }
 
 /*****************************************************************************/
@@ -2052,24 +1919,20 @@ static int stli_ioctl(struct tty_struct *tty, struct file *file, unsigned int cm
 
 static void stli_settermios(struct tty_struct *tty, struct termios *old)
 {
-        stliport_t      *portp;
-        stlibrd_t       *brdp;
-        struct termios  *tiosp;
-        asyport_t       aport;
-
-#ifdef DEBUG
-        printk("stli_settermios(tty=%x,old=%x)\n", (int) tty, (int) old);
-#endif
+        stliport_t *portp;
+        stlibrd_t *brdp;
+        struct termios *tiosp;
+        asyport_t aport;
 
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return;
         portp = tty->driver_data;
-        if (portp == (stliport_t *) NULL)
+        if (portp == NULL)
                 return;
-        if ((portp->brdnr < 0) || (portp->brdnr >= stli_nrbrds))
+        if (portp->brdnr < 0 || portp->brdnr >= stli_nrbrds)
                 return;
         brdp = stli_brds[portp->brdnr];
-        if (brdp == (stlibrd_t *) NULL)
+        if (brdp == NULL)
                 return;
 
         tiosp = tty->termios;
@@ -2102,18 +1965,9 @@ static void stli_settermios(struct tty_struct *tty, struct termios *old)
 
 static void stli_throttle(struct tty_struct *tty)
 {
-        stliport_t      *portp;
-
-#ifdef DEBUG
-        printk("stli_throttle(tty=%x)\n", (int) tty);
-#endif
-
-        if (tty == (struct tty_struct *) NULL)
+        stliport_t      *portp = tty->driver_data;
+        if (portp == NULL)
                 return;
-        portp = tty->driver_data;
-        if (portp == (stliport_t *) NULL)
-                return;
-
         set_bit(ST_RXSTOP, &portp->state);
 }
 
@@ -2127,88 +1981,30 @@ static void stli_throttle(struct tty_struct *tty)
 
 static void stli_unthrottle(struct tty_struct *tty)
 {
-        stliport_t      *portp;
-
-#ifdef DEBUG
-        printk("stli_unthrottle(tty=%x)\n", (int) tty);
-#endif
-
-        if (tty == (struct tty_struct *) NULL)
-                return;
-        portp = tty->driver_data;
-        if (portp == (stliport_t *) NULL)
+        stliport_t      *portp = tty->driver_data;
+        if (portp == NULL)
                 return;
-
         clear_bit(ST_RXSTOP, &portp->state);
 }
 
 /*****************************************************************************/
 
 /*
- *      Stop the transmitter. Basically to do this we will just turn TX
- *      interrupts off.
+ *      Stop the transmitter.
  */
 
 static void stli_stop(struct tty_struct *tty)
 {
-        stlibrd_t       *brdp;
-        stliport_t      *portp;
-        asyctrl_t       actrl;
-
-#ifdef DEBUG
-        printk("stli_stop(tty=%x)\n", (int) tty);
-#endif
-
-        if (tty == (struct tty_struct *) NULL)
-                return;
-        portp = tty->driver_data;
-        if (portp == (stliport_t *) NULL)
-                return;
-        if ((portp->brdnr < 0) || (portp->brdnr >= stli_nrbrds))
-                return;
-        brdp = stli_brds[portp->brdnr];
-        if (brdp == (stlibrd_t *) NULL)
-                return;
-
-        memset(&actrl, 0, sizeof(asyctrl_t));
-        actrl.txctrl = CT_STOPFLOW;
-#if 0
-        stli_cmdwait(brdp, portp, A_PORTCTRL, &actrl, sizeof(asyctrl_t), 0);
-#endif
 }
 
 /*****************************************************************************/
 
 /*
- *      Start the transmitter again. Just turn TX interrupts back on.
+ *      Start the transmitter again.
  */
 
 static void stli_start(struct tty_struct *tty)
 {
-        stliport_t      *portp;
-        stlibrd_t       *brdp;
-        asyctrl_t       actrl;
-
-#ifdef DEBUG
-        printk("stli_start(tty=%x)\n", (int) tty);
-#endif
-
-        if (tty == (struct tty_struct *) NULL)
-                return;
-        portp = tty->driver_data;
-        if (portp == (stliport_t *) NULL)
-                return;
-        if ((portp->brdnr < 0) || (portp->brdnr >= stli_nrbrds))
-                return;
-        brdp = stli_brds[portp->brdnr];
-        if (brdp == (stlibrd_t *) NULL)
-                return;
-
-        memset(&actrl, 0, sizeof(asyctrl_t));
-        actrl.txctrl = CT_STARTFLOW;
-#if 0
-        stli_cmdwait(brdp, portp, A_PORTCTRL, &actrl, sizeof(asyctrl_t), 0);
-#endif
 }
 
 /*****************************************************************************/
@@ -2224,22 +2020,9 @@ static void stli_start(struct tty_struct *tty)
 
 static void stli_dohangup(void *arg)
 {
-        stliport_t      *portp;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_dohangup(portp=%x)\n", (int) arg);
-#endif
-
-        /*
-         * FIXME: There's a module removal race here: tty_hangup
-         * calls schedule_work which will call into this
-         * driver later.
-         */
-        portp = (stliport_t *) arg;
-        if (portp != (stliport_t *) NULL) {
-                if (portp->tty != (struct tty_struct *) NULL) {
-                        tty_hangup(portp->tty);
-                }
+        stliport_t *portp = (stliport_t *) arg;
+        if (portp->tty != NULL) {
+                tty_hangup(portp->tty);
         }
 }
 
@@ -2254,31 +2037,25 @@ static void stli_dohangup(void *arg)
 
 static void stli_hangup(struct tty_struct *tty)
 {
-        stliport_t      *portp;
-        stlibrd_t       *brdp;
-        unsigned long   flags;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_hangup(tty=%x)\n", (int) tty);
-#endif
+        stliport_t *portp;
+        stlibrd_t *brdp;
+        unsigned long flags;
 
-        if (tty == (struct tty_struct *) NULL)
-                return;
         portp = tty->driver_data;
-        if (portp == (stliport_t *) NULL)
+        if (portp == NULL)
                 return;
-        if ((portp->brdnr < 0) || (portp->brdnr >= stli_nrbrds))
+        if (portp->brdnr < 0 || portp->brdnr >= stli_nrbrds)
                 return;
         brdp = stli_brds[portp->brdnr];
-        if (brdp == (stlibrd_t *) NULL)
+        if (brdp == NULL)
                 return;
 
         portp->flags &= ~ASYNC_INITIALIZED;
 
-        save_flags(flags);
-        cli();
-        if (! test_bit(ST_CLOSING, &portp->state))
+        if (!test_bit(ST_CLOSING, &portp->state))
                 stli_rawclose(brdp, portp, 0, 0);
+
+        spin_lock_irqsave(&stli_lock, flags);
         if (tty->termios->c_cflag & HUPCL) {
                 stli_mkasysigs(&portp->asig, 0, 0);
                 if (test_bit(ST_CMDING, &portp->state)) {
@@ -2290,14 +2067,15 @@ static void stli_hangup(struct tty_struct *tty)
                                 &portp->asig, sizeof(asysigs_t), 0);
                 }
         }
-        restore_flags(flags);
 
         clear_bit(ST_TXBUSY, &portp->state);
         clear_bit(ST_RXSTOP, &portp->state);
         set_bit(TTY_IO_ERROR, &tty->flags);
-        portp->tty = (struct tty_struct *) NULL;
+        portp->tty = NULL;
         portp->flags &= ~ASYNC_NORMAL_ACTIVE;
         portp->refcount = 0;
+        spin_unlock_irqrestore(&stli_lock, flags);
+
         wake_up_interruptible(&portp->open_wait);
 }
 
@@ -2312,29 +2090,22 @@ static void stli_hangup(struct tty_struct *tty)
 
 static void stli_flushbuffer(struct tty_struct *tty)
 {
-        stliport_t      *portp;
-        stlibrd_t       *brdp;
-        unsigned long   ftype, flags;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_flushbuffer(tty=%x)\n", (int) tty);
-#endif
+        stliport_t *portp;
+        stlibrd_t *brdp;
+        unsigned long ftype, flags;
 
-        if (tty == (struct tty_struct *) NULL)
-                return;
         portp = tty->driver_data;
-        if (portp == (stliport_t *) NULL)
+        if (portp == NULL)
                 return;
-        if ((portp->brdnr < 0) || (portp->brdnr >= stli_nrbrds))
+        if (portp->brdnr < 0 || portp->brdnr >= stli_nrbrds)
                 return;
         brdp = stli_brds[portp->brdnr];
-        if (brdp == (stlibrd_t *) NULL)
+        if (brdp == NULL)
                 return;
 
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
         if (tty == stli_txcooktty) {
-                stli_txcooktty = (struct tty_struct *) NULL;
+                stli_txcooktty = NULL;
                 stli_txcooksize = 0;
                 stli_txcookrealsize = 0;
         }
@@ -2346,15 +2117,10 @@ static void stli_flushbuffer(struct tty_struct *tty)
                         ftype |= FLUSHRX;
                         clear_bit(ST_DOFLUSHRX, &portp->state);
                 }
-                stli_sendcmd(brdp, portp, A_FLUSH, &ftype,
-                        sizeof(unsigned long), 0);
+                __stli_sendcmd(brdp, portp, A_FLUSH, &ftype, sizeof(u32), 0);
         }
-        restore_flags(flags);
-
-        wake_up_interruptible(&tty->write_wait);
-        if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
-            tty->ldisc.write_wakeup)
-                (tty->ldisc.write_wakeup)(tty);
+        spin_unlock_irqrestore(&brd_lock, flags);
+        tty_wakeup(tty);
 }
 
 /*****************************************************************************/
@@ -2364,55 +2130,31 @@ static void stli_breakctl(struct tty_struct *tty, int state)
         stlibrd_t       *brdp;
         stliport_t      *portp;
         long            arg;
-        /* long savestate, savetime; */
 
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_breakctl(tty=%x,state=%d)\n", (int) tty, state);
-#endif
-
-        if (tty == (struct tty_struct *) NULL)
-                return;
         portp = tty->driver_data;
-        if (portp == (stliport_t *) NULL)
+        if (portp == NULL)
                 return;
-        if ((portp->brdnr < 0) || (portp->brdnr >= stli_nrbrds))
+        if (portp->brdnr < 0 || portp->brdnr >= stli_nrbrds)
                 return;
         brdp = stli_brds[portp->brdnr];
-        if (brdp == (stlibrd_t *) NULL)
+        if (brdp == NULL)
                 return;
 
-/*
- *      Due to a bug in the tty send_break() code we need to preserve
- *      the current process state and timeout...
-        savetime = current->timeout;
-        savestate = current->state;
- */
-
         arg = (state == -1) ? BREAKON : BREAKOFF;
         stli_cmdwait(brdp, portp, A_BREAK, &arg, sizeof(long), 0);
-
-/*
- *
-        current->timeout = savetime;
-        current->state = savestate;
- */
 }
 
 /*****************************************************************************/
 
 static void stli_waituntilsent(struct tty_struct *tty, int timeout)
 {
-        stliport_t      *portp;
-        unsigned long   tend;
+        stliport_t *portp;
+        unsigned long tend;
 
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_waituntilsent(tty=%x,timeout=%x)\n", (int) tty, timeout);
-#endif
-
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return;
         portp = tty->driver_data;
-        if (portp == (stliport_t *) NULL)
+        if (portp == NULL)
                 return;
 
         if (timeout == 0)
@@ -2436,19 +2178,13 @@ static void stli_sendxchar(struct tty_struct *tty, char ch)
         stliport_t      *portp;
         asyctrl_t       actrl;
 
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_sendxchar(tty=%x,ch=%x)\n", (int) tty, ch);
-#endif
-
-        if (tty == (struct tty_struct *) NULL)
-                return;
         portp = tty->driver_data;
-        if (portp == (stliport_t *) NULL)
+        if (portp == NULL)
                 return;
-        if ((portp->brdnr < 0) || (portp->brdnr >= stli_nrbrds))
+        if (portp->brdnr < 0 || portp->brdnr >= stli_nrbrds)
                 return;
         brdp = stli_brds[portp->brdnr];
-        if (brdp == (stlibrd_t *) NULL)
+        if (brdp == NULL)
                 return;
 
         memset(&actrl, 0, sizeof(asyctrl_t));
@@ -2460,7 +2196,6 @@ static void stli_sendxchar(struct tty_struct *tty, char ch)
                 actrl.txctrl = CT_SENDCHR;
                 actrl.tximdch = ch;
         }
-
         stli_cmdwait(brdp, portp, A_PORTCTRL, &actrl, sizeof(asyctrl_t), 0);
 }
 
@@ -2476,17 +2211,17 @@ static void stli_sendxchar(struct tty_struct *tty, char ch)
 
 static int stli_portinfo(stlibrd_t *brdp, stliport_t *portp, int portnr, char *pos)
 {
-        char    *sp, *uart;
-        int     rc, cnt;
+        char *sp, *uart;
+        int rc, cnt;
 
         rc = stli_portcmdstats(portp);
 
         uart = "UNKNOWN";
         if (brdp->state & BST_STARTED) {
                 switch (stli_comstats.hwid) {
-                case 0:         uart = "2681"; break;
-                case 1:         uart = "SC26198"; break;
-                default:        uart = "CD1400"; break;
+                case 0: uart = "2681"; break;
+                case 1: uart = "SC26198"; break;
+                default:uart = "CD1400"; break;
                 }
         }
 
@@ -2537,17 +2272,11 @@ static int stli_portinfo(stlibrd_t *brdp, stliport_t *portp, int portnr, char *p
 
 static int stli_readproc(char *page, char **start, off_t off, int count, int *eof, void *data)
 {
-        stlibrd_t       *brdp;
-        stliport_t      *portp;
-        int             brdnr, portnr, totalport;
-        int             curoff, maxoff;
-        char            *pos;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_readproc(page=%x,start=%x,off=%x,count=%d,eof=%x,"
-                "data=%x\n", (int) page, (int) start, (int) off, count,
-                (int) eof, (int) data);
-#endif
+        stlibrd_t *brdp;
+        stliport_t *portp;
+        int brdnr, portnr, totalport;
+        int curoff, maxoff;
+        char *pos;
 
         pos = page;
         totalport = 0;
@@ -2568,7 +2297,7 @@ static int stli_readproc(char *page, char **start, off_t off, int count, int *eo
  */
         for (brdnr = 0; (brdnr < stli_nrbrds); brdnr++) {
                 brdp = stli_brds[brdnr];
-                if (brdp == (stlibrd_t *) NULL)
+                if (brdp == NULL)
                         continue;
                 if (brdp->state == 0)
                         continue;
@@ -2583,7 +2312,7 @@ static int stli_readproc(char *page, char **start, off_t off, int count, int *eo
                 for (portnr = 0; (portnr < brdp->nrports); portnr++,
                     totalport++) {
                         portp = brdp->ports[portnr];
-                        if (portp == (stliport_t *) NULL)
+                        if (portp == NULL)
                                 continue;
                         if (off >= (curoff += MAXLINE))
                                 continue;
@@ -2610,49 +2339,54 @@ stli_readdone:
  *      a poll routine that does not have user context. Therefore you cannot
  *      copy back directly into user space, or to the kernel stack of a
  *      process. This routine does not sleep, so can be called from anywhere.
+ *
+ *      The caller must hold the brd_lock (see also stli_sendcmd the usual
+ *      entry point)
  */
 
-static void stli_sendcmd(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback)
+static void __stli_sendcmd(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback)
 {
-        volatile cdkhdr_t       *hdrp;
-        volatile cdkctrl_t      *cp;
-        volatile unsigned char  *bits;
-        unsigned long           flags;
+        cdkhdr_t __iomem *hdrp;
+        cdkctrl_t __iomem *cp;
+        unsigned char __iomem *bits;
+        unsigned long flags;
 
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_sendcmd(brdp=%x,portp=%x,cmd=%x,arg=%x,size=%d,"
-                "copyback=%d)\n", (int) brdp, (int) portp, (int) cmd,
-                (int) arg, size, copyback);
-#endif
-
-        save_flags(flags);
-        cli();
+        spin_lock_irqsave(&brd_lock, flags);
 
         if (test_bit(ST_CMDING, &portp->state)) {
                 printk(KERN_ERR "STALLION: command already busy, cmd=%x!\n",
                                 (int) cmd);
-                restore_flags(flags);
+                spin_unlock_irqrestore(&brd_lock, flags);
                 return;
         }
 
         EBRDENABLE(brdp);
-        cp = &((volatile cdkasy_t *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
+        cp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->ctrl;
         if (size > 0) {
-                memcpy((void *) &(cp->args[0]), arg, size);
+                memcpy_toio((void __iomem *) &(cp->args[0]), arg, size);
                 if (copyback) {
                         portp->argp = arg;
                         portp->argsize = size;
                 }
         }
-        cp->status = 0;
-        cp->cmd = cmd;
-        hdrp = (volatile cdkhdr_t *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
-        bits = ((volatile unsigned char *) hdrp) + brdp->slaveoffset +
+        writel(0, &cp->status);
+        writel(cmd, &cp->cmd);
+        hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
+        bits = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset +
                 portp->portidx;
-        *bits |= portp->portbit;
+        writeb(readb(bits) | portp->portbit, bits);
         set_bit(ST_CMDING, &portp->state);
         EBRDDISABLE(brdp);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
+}
+
+static void stli_sendcmd(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd, void *arg, int size, int copyback)
+{
+        unsigned long           flags;
+
+        spin_lock_irqsave(&brd_lock, flags);
+        __stli_sendcmd(brdp, portp, cmd, arg, size, copyback);
+        spin_unlock_irqrestore(&brd_lock, flags);
 }
 
 /*****************************************************************************/
@@ -2667,28 +2401,23 @@ static void stli_sendcmd(stlibrd_t *brdp, stliport_t *portp, unsigned long cmd,
 
 static void stli_read(stlibrd_t *brdp, stliport_t *portp)
 {
-        volatile cdkasyrq_t     *rp;
-        volatile char           *shbuf;
+        cdkasyrq_t __iomem *rp;
+        char __iomem *shbuf;
         struct tty_struct       *tty;
-        unsigned int            head, tail, size;
-        unsigned int            len, stlen;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_read(brdp=%x,portp=%d)\n",
-                        (int) brdp, (int) portp);
-#endif
+        unsigned int head, tail, size;
+        unsigned int len, stlen;
 
         if (test_bit(ST_RXSTOP, &portp->state))
                 return;
         tty = portp->tty;
-        if (tty == (struct tty_struct *) NULL)
+        if (tty == NULL)
                 return;
 
-        rp = &((volatile cdkasy_t *) EBRDGETMEMPTR(brdp, portp->addr))->rxq;
-        head = (unsigned int) rp->head;
-        if (head != ((unsigned int) rp->head))
-                head = (unsigned int) rp->head;
-        tail = (unsigned int) rp->tail;
+        rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->rxq;
+        head = (unsigned int) readw(&rp->head);
+        if (head != ((unsigned int) readw(&rp->head)))
+                head = (unsigned int) readw(&rp->head);
+        tail = (unsigned int) readw(&rp->tail);
         size = portp->rxsize;
         if (head >= tail) {
                 len = head - tail;
@@ -2699,12 +2428,15 @@ static void stli_read(stlibrd_t *brdp, stliport_t *portp)
         }
 
         len = tty_buffer_request_room(tty, len);
-        /* FIXME : iomap ? */
-        shbuf = (volatile char *) EBRDGETMEMPTR(brdp, portp->rxoffset);
+
+        shbuf = (char __iomem *) EBRDGETMEMPTR(brdp, portp->rxoffset);
 
         while (len > 0) {
+                unsigned char *cptr;
+
                 stlen = MIN(len, stlen);
-                tty_insert_flip_string(tty, (char *)(shbuf + tail), stlen);
+                tty_prepare_flip_string(tty, &cptr, stlen);
+                memcpy_fromio(cptr, shbuf + tail, stlen);
                 len -= stlen;
                 tail += stlen;
                 if (tail >= size) {
@@ -2712,8 +2444,8 @@ static void stli_read(stlibrd_t *brdp, stliport_t *portp)
                         stlen = head;
                 }
         }
-        rp = &((volatile cdkasy_t *) EBRDGETMEMPTR(brdp, portp->addr))->rxq;
-        rp->tail = tail;
+        rp = &((cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr))->rxq;
+        writew(tail, &rp->tail);
 
         if (head != tail)
                 set_bit(ST_RXING, &portp->state);
@@ -2729,9 +2461,9 @@ static void stli_read(stlibrd_t *brdp, stliport_t *portp)
  *      difficult to deal with them here.
  */
 
-static void stli_dodelaycmd(stliport_t *portp, volatile cdkctrl_t *cp)
+static void stli_dodelaycmd(stliport_t *portp, cdkctrl_t __iomem *cp)
 {
-        int     cmd;
+        int cmd;
 
         if (test_bit(ST_DOSIGS, &portp->state)) {
                 if (test_bit(ST_DOFLUSHTX, &portp->state) &&
@@ -2746,10 +2478,10 @@ static void stli_dodelaycmd(stliport_t *portp, volatile cdkctrl_t *cp)
                 clear_bit(ST_DOFLUSHTX, &portp->state);
                 clear_bit(ST_DOFLUSHRX, &portp->state);
                 clear_bit(ST_DOSIGS, &portp->state);
-                memcpy((void *) &(cp->args[0]), (void *) &portp->asig,
+                memcpy_toio((void __iomem *) &(cp->args[0]), (void *) &portp->asig,
                         sizeof(asysigs_t));
-                cp->status = 0;
-                cp->cmd = cmd;
+                writel(0, &cp->status);
+                writel(cmd, &cp->cmd);
                 set_bit(ST_CMDING, &portp->state);
         } else if (test_bit(ST_DOFLUSHTX, &portp->state) ||
             test_bit(ST_DOFLUSHRX, &portp->state)) {
@@ -2757,9 +2489,9 @@ static void stli_dodelaycmd(stliport_t *portp, volatile cdkctrl_t *cp)
                 cmd |= ((test_bit(ST_DOFLUSHRX, &portp->state)) ? FLUSHRX : 0);
                 clear_bit(ST_DOFLUSHTX, &portp->state);
                 clear_bit(ST_DOFLUSHRX, &portp->state);
-                memcpy((void *) &(cp->args[0]), (void *) &cmd, sizeof(int));
-                cp->status = 0;
-                cp->cmd = A_FLUSH;
+                memcpy_toio((void __iomem *) &(cp->args[0]), (void *) &cmd, sizeof(int));
+                writel(0, &cp->status);
+                writel(A_FLUSH, &cp->cmd);
                 set_bit(ST_CMDING, &portp->state);
         }
 }
@@ -2779,30 +2511,25 @@ static void stli_dodelaycmd(stliport_t *portp, volatile cdkctrl_t *cp)
 
 static int stli_hostcmd(stlibrd_t *brdp, stliport_t *portp)
 {
-        volatile cdkasy_t       *ap;
-        volatile cdkctrl_t      *cp;
-        struct tty_struct       *tty;
-        asynotify_t             nt;
-        unsigned long           oldsigs;
-        int                     rc, donerx;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_hostcmd(brdp=%x,channr=%d)\n",
-                        (int) brdp, channr);
-#endif
-
-        ap = (volatile cdkasy_t *) EBRDGETMEMPTR(brdp, portp->addr);
+        cdkasy_t __iomem *ap;
+        cdkctrl_t __iomem *cp;
+        struct tty_struct *tty;
+        asynotify_t nt;
+        unsigned long oldsigs;
+        int rc, donerx;
+
+        ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
         cp = &ap->ctrl;
 
 /*
  *      Check if we are waiting for an open completion message.
  */
         if (test_bit(ST_OPENING, &portp->state)) {
-                rc = (int) cp->openarg;
-                if ((cp->open == 0) && (rc != 0)) {
+                rc = readl(&cp->openarg);
+                if (readb(&cp->open) == 0 && rc != 0) {
                         if (rc > 0)
                                 rc--;
-                        cp->openarg = 0;
+                        writel(0, &cp->openarg);
                         portp->rc = rc;
                         clear_bit(ST_OPENING, &portp->state);
                         wake_up_interruptible(&portp->raw_wait);
@@ -2813,11 +2540,11 @@ static int stli_hostcmd(stlibrd_t *brdp, stliport_t *portp)
  *      Check if we are waiting for a close completion message.
  */
         if (test_bit(ST_CLOSING, &portp->state)) {
-                rc = (int) cp->closearg;
-                if ((cp->close == 0) && (rc != 0)) {
+                rc = (int) readl(&cp->closearg);
+                if (readb(&cp->close) == 0 && rc != 0) {
                         if (rc > 0)
                                 rc--;
-                        cp->closearg = 0;
+                        writel(0, &cp->closearg);
                         portp->rc = rc;
                         clear_bit(ST_CLOSING, &portp->state);
                         wake_up_interruptible(&portp->raw_wait);
@@ -2829,16 +2556,16 @@ static int stli_hostcmd(stlibrd_t *brdp, stliport_t *portp)
  *      need to copy out the command results associated with this command.
  */
         if (test_bit(ST_CMDING, &portp->state)) {
-                rc = cp->status;
-                if ((cp->cmd == 0) && (rc != 0)) {
+                rc = readl(&cp->status);
+                if (readl(&cp->cmd) == 0 && rc != 0) {
                         if (rc > 0)
                                 rc--;
-                        if (portp->argp != (void *) NULL) {
-                                memcpy(portp->argp, (void *) &(cp->args[0]),
+                        if (portp->argp != NULL) {
+                                memcpy_fromio(portp->argp, (void __iomem *) &(cp->args[0]),
                                         portp->argsize);
-                                portp->argp = (void *) NULL;
+                                portp->argp = NULL;
                         }
-                        cp->status = 0;
+                        writel(0, &cp->status);
                         portp->rc = rc;
                         clear_bit(ST_CMDING, &portp->state);
                         stli_dodelaycmd(portp, cp);
@@ -2877,18 +2604,15 @@ static int stli_hostcmd(stlibrd_t *brdp, stliport_t *portp)
                 if (nt.data & DT_TXEMPTY)
                         clear_bit(ST_TXBUSY, &portp->state);
                 if (nt.data & (DT_TXEMPTY | DT_TXLOW)) {
-                        if (tty != (struct tty_struct *) NULL) {
-                                if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
-                                    tty->ldisc.write_wakeup) {
-                                        (tty->ldisc.write_wakeup)(tty);
-                                        EBRDENABLE(brdp);
-                                }
+                        if (tty != NULL) {
+                                tty_wakeup(tty);
+                                EBRDENABLE(brdp);
                                 wake_up_interruptible(&tty->write_wait);
                         }
                 }
 
                 if ((nt.data & DT_RXBREAK) && (portp->rxmarkmsk & BRKINT)) {
-                        if (tty != (struct tty_struct *) NULL) {
+                        if (tty != NULL) {
                                 tty_insert_flip_char(tty, 0, TTY_BREAK);
                                 if (portp->flags & ASYNC_SAK) {
                                         do_SAK(tty);
@@ -2932,14 +2656,14 @@ static int stli_hostcmd(stlibrd_t *brdp, stliport_t *portp)
  *      at the cdk header structure.
  */
 
-static void stli_brdpoll(stlibrd_t *brdp, volatile cdkhdr_t *hdrp)
+static void stli_brdpoll(stlibrd_t *brdp, cdkhdr_t __iomem *hdrp)
 {
-        stliport_t      *portp;
-        unsigned char   hostbits[(STL_MAXCHANS / 8) + 1];
-        unsigned char   slavebits[(STL_MAXCHANS / 8) + 1];
-        unsigned char   *slavep;
-        int             bitpos, bitat, bitsize;
-        int             channr, nrdevs, slavebitchange;
+        stliport_t *portp;
+        unsigned char hostbits[(STL_MAXCHANS / 8) + 1];
+        unsigned char slavebits[(STL_MAXCHANS / 8) + 1];
+        unsigned char __iomem *slavep;
+        int bitpos, bitat, bitsize;
+        int channr, nrdevs, slavebitchange;
 
         bitsize = brdp->bitsize;
         nrdevs = brdp->nrdevs;
@@ -2951,7 +2675,7 @@ static void stli_brdpoll(stlibrd_t *brdp, volatile cdkhdr_t *hdrp)
  *      8 service bits at a time in the inner loop, so we can bypass
  *      the lot if none of them want service.
  */
-        memcpy(&hostbits[0], (((unsigned char *) hdrp) + brdp->hostoffset),
+        memcpy_fromio(&hostbits[0], (((unsigned char __iomem *) hdrp) + brdp->hostoffset),
                 bitsize);
 
         memset(&slavebits[0], 0, bitsize);
@@ -2978,11 +2702,11 @@ static void stli_brdpoll(stlibrd_t *brdp, volatile cdkhdr_t *hdrp)
  *      service may initiate more slave requests.
  */
         if (slavebitchange) {
-                hdrp = (volatile cdkhdr_t *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
-                slavep = ((unsigned char *) hdrp) + brdp->slaveoffset;
+                hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
+                slavep = ((unsigned char __iomem *) hdrp) + brdp->slaveoffset;
                 for (bitpos = 0; (bitpos < bitsize); bitpos++) {
-                        if (slavebits[bitpos])
-                                slavep[bitpos] &= ~slavebits[bitpos];
+                        if (readb(slavebits + bitpos))
+                                writeb(readb(slavep + bitpos) & ~slavebits[bitpos], slavebits + bitpos);
                 }
         }
 }
@@ -3000,9 +2724,9 @@ static void stli_brdpoll(stlibrd_t *brdp, volatile cdkhdr_t *hdrp)
 
 static void stli_poll(unsigned long arg)
 {
-        volatile cdkhdr_t       *hdrp;
-        stlibrd_t               *brdp;
-        int                     brdnr;
+        cdkhdr_t __iomem *hdrp;
+        stlibrd_t *brdp;
+        int brdnr;
 
         stli_timerlist.expires = STLI_TIMEOUT;
         add_timer(&stli_timerlist);
@@ -3012,16 +2736,18 @@ static void stli_poll(unsigned long arg)
  */
         for (brdnr = 0; (brdnr < stli_nrbrds); brdnr++) {
                 brdp = stli_brds[brdnr];
-                if (brdp == (stlibrd_t *) NULL)
+                if (brdp == NULL)
                         continue;
                 if ((brdp->state & BST_STARTED) == 0)
                         continue;
 
+                spin_lock(&brd_lock);
                 EBRDENABLE(brdp);
-                hdrp = (volatile cdkhdr_t *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
-                if (hdrp->hostreq)
+                hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
+                if (readb(&hdrp->hostreq))
                         stli_brdpoll(brdp, hdrp);
                 EBRDDISABLE(brdp);
+                spin_unlock(&brd_lock);
         }
 }
 
@@ -3034,11 +2760,6 @@ static void stli_poll(unsigned long arg)
 
 static void stli_mkasyport(stliport_t *portp, asyport_t *pp, struct termios *tiosp)
 {
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_mkasyport(portp=%x,pp=%x,tiosp=%d)\n",
-                (int) portp, (int) pp, (int) tiosp);
-#endif
-
         memset(pp, 0, sizeof(asyport_t));
 
 /*
@@ -3157,11 +2878,6 @@ static void stli_mkasyport(stliport_t *portp, asyport_t *pp, struct termios *tio
 
 static void stli_mkasysigs(asysigs_t *sp, int dtr, int rts)
 {
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_mkasysigs(sp=%x,dtr=%d,rts=%d)\n",
-                        (int) sp, dtr, rts);
-#endif
-
         memset(sp, 0, sizeof(asysigs_t));
         if (dtr >= 0) {
                 sp->signal |= SG_DTR;
@@ -3182,13 +2898,7 @@ static void stli_mkasysigs(asysigs_t *sp, int dtr, int rts)
 
 static long stli_mktiocm(unsigned long sigvalue)
 {
-        long    tiocm;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_mktiocm(sigvalue=%x)\n", (int) sigvalue);
-#endif
-
-        tiocm = 0;
+        long    tiocm = 0;
         tiocm |= ((sigvalue & SG_DCD) ? TIOCM_CD : 0);
         tiocm |= ((sigvalue & SG_CTS) ? TIOCM_CTS : 0);
         tiocm |= ((sigvalue & SG_RI) ? TIOCM_RI : 0);
@@ -3210,10 +2920,6 @@ static int stli_initports(stlibrd_t *brdp)
         stliport_t      *portp;
         int             i, panelnr, panelport;
 
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_initports(brdp=%x)\n", (int) brdp);
-#endif
-
         for (i = 0, panelnr = 0, panelport = 0; (i < brdp->nrports); i++) {
                 portp = kzalloc(sizeof(stliport_t), GFP_KERNEL);
                 if (!portp) {
@@ -3240,7 +2946,7 @@ static int stli_initports(stlibrd_t *brdp)
                 brdp->ports[i] = portp;
         }
 
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
@@ -3253,10 +2959,6 @@ static void stli_ecpinit(stlibrd_t *brdp)
 {
         unsigned long   memconf;
 
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_ecpinit(brdp=%d)\n", (int) brdp);
-#endif
-
         outb(ECP_ATSTOP, (brdp->iobase + ECP_ATCONFR));
         udelay(10);
         outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
@@ -3270,9 +2972,6 @@ static void stli_ecpinit(stlibrd_t *brdp)
 
 static void stli_ecpenable(stlibrd_t *brdp)
 {       
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_ecpenable(brdp=%x)\n", (int) brdp);
-#endif
         outb(ECP_ATENABLE, (brdp->iobase + ECP_ATCONFR));
 }
 
@@ -3280,9 +2979,6 @@ static void stli_ecpenable(stlibrd_t *brdp)
 
 static void stli_ecpdisable(stlibrd_t *brdp)
 {       
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_ecpdisable(brdp=%x)\n", (int) brdp);
-#endif
         outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
 }
 
@@ -3290,13 +2986,8 @@ static void stli_ecpdisable(stlibrd_t *brdp)
 
 static char *stli_ecpgetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
 {       
-        void            *ptr;
-        unsigned char   val;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_ecpgetmemptr(brdp=%x,offset=%x)\n", (int) brdp,
-                (int) offset);
-#endif
+        void *ptr;
+        unsigned char val;
 
         if (offset > brdp->memsize) {
                 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
@@ -3316,10 +3007,6 @@ static char *stli_ecpgetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
 
 static void stli_ecpreset(stlibrd_t *brdp)
 {       
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_ecpreset(brdp=%x)\n", (int) brdp);
-#endif
-
         outb(ECP_ATSTOP, (brdp->iobase + ECP_ATCONFR));
         udelay(10);
         outb(ECP_ATDISABLE, (brdp->iobase + ECP_ATCONFR));
@@ -3330,9 +3017,6 @@ static void stli_ecpreset(stlibrd_t *brdp)
 
 static void stli_ecpintr(stlibrd_t *brdp)
 {       
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_ecpintr(brdp=%x)\n", (int) brdp);
-#endif
         outb(0x1, brdp->iobase);
 }
 
@@ -3346,10 +3030,6 @@ static void stli_ecpeiinit(stlibrd_t *brdp)
 {
         unsigned long   memconf;
 
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_ecpeiinit(brdp=%x)\n", (int) brdp);
-#endif
-
         outb(0x1, (brdp->iobase + ECP_EIBRDENAB));
         outb(ECP_EISTOP, (brdp->iobase + ECP_EICONFR));
         udelay(10);
@@ -3383,11 +3063,6 @@ static char *stli_ecpeigetmemptr(stlibrd_t *brdp, unsigned long offset, int line
         void            *ptr;
         unsigned char   val;
 
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_ecpeigetmemptr(brdp=%x,offset=%x,line=%d)\n",
-                (int) brdp, (int) offset, line);
-#endif
-
         if (offset > brdp->memsize) {
                 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
                                 "range at line=%d(%d), brd=%d\n",
@@ -3437,8 +3112,8 @@ static void stli_ecpmcdisable(stlibrd_t *brdp)
 
 static char *stli_ecpmcgetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
 {       
-        void            *ptr;
-        unsigned char   val;
+        void *ptr;
+        unsigned char val;
 
         if (offset > brdp->memsize) {
                 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
@@ -3472,10 +3147,6 @@ static void stli_ecpmcreset(stlibrd_t *brdp)
 
 static void stli_ecppciinit(stlibrd_t *brdp)
 {
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_ecppciinit(brdp=%x)\n", (int) brdp);
-#endif
-
         outb(ECP_PCISTOP, (brdp->iobase + ECP_PCICONFR));
         udelay(10);
         outb(0, (brdp->iobase + ECP_PCICONFR));
@@ -3489,11 +3160,6 @@ static char *stli_ecppcigetmemptr(stlibrd_t *brdp, unsigned long offset, int lin
         void            *ptr;
         unsigned char   val;
 
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_ecppcigetmemptr(brdp=%x,offset=%x,line=%d)\n",
-                (int) brdp, (int) offset, line);
-#endif
-
         if (offset > brdp->memsize) {
                 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
                                 "range at line=%d(%d), board=%d\n",
@@ -3528,10 +3194,6 @@ static void stli_onbinit(stlibrd_t *brdp)
 {
         unsigned long   memconf;
 
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_onbinit(brdp=%d)\n", (int) brdp);
-#endif
-
         outb(ONB_ATSTOP, (brdp->iobase + ONB_ATCONFR));
         udelay(10);
         outb(ONB_ATDISABLE, (brdp->iobase + ONB_ATCONFR));
@@ -3547,9 +3209,6 @@ static void stli_onbinit(stlibrd_t *brdp)
 
 static void stli_onbenable(stlibrd_t *brdp)
 {       
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_onbenable(brdp=%x)\n", (int) brdp);
-#endif
         outb((brdp->enabval | ONB_ATENABLE), (brdp->iobase + ONB_ATCONFR));
 }
 
@@ -3557,9 +3216,6 @@ static void stli_onbenable(stlibrd_t *brdp)
 
 static void stli_onbdisable(stlibrd_t *brdp)
 {       
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_onbdisable(brdp=%x)\n", (int) brdp);
-#endif
         outb((brdp->enabval | ONB_ATDISABLE), (brdp->iobase + ONB_ATCONFR));
 }
 
@@ -3569,11 +3225,6 @@ static char *stli_onbgetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
 {       
         void    *ptr;
 
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_onbgetmemptr(brdp=%x,offset=%x)\n", (int) brdp,
-                (int) offset);
-#endif
-
         if (offset > brdp->memsize) {
                 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
                                 "range at line=%d(%d), brd=%d\n",
@@ -3589,11 +3240,6 @@ static char *stli_onbgetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
 
 static void stli_onbreset(stlibrd_t *brdp)
 {       
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_onbreset(brdp=%x)\n", (int) brdp);
-#endif
-
         outb(ONB_ATSTOP, (brdp->iobase + ONB_ATCONFR));
         udelay(10);
         outb(ONB_ATDISABLE, (brdp->iobase + ONB_ATCONFR));
@@ -3610,10 +3256,6 @@ static void stli_onbeinit(stlibrd_t *brdp)
 {
         unsigned long   memconf;
 
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_onbeinit(brdp=%d)\n", (int) brdp);
-#endif
-
         outb(0x1, (brdp->iobase + ONB_EIBRDENAB));
         outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR));
         udelay(10);
@@ -3632,9 +3274,6 @@ static void stli_onbeinit(stlibrd_t *brdp)
 
 static void stli_onbeenable(stlibrd_t *brdp)
 {       
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_onbeenable(brdp=%x)\n", (int) brdp);
-#endif
         outb(ONB_EIENABLE, (brdp->iobase + ONB_EICONFR));
 }
 
@@ -3642,9 +3281,6 @@ static void stli_onbeenable(stlibrd_t *brdp)
 
 static void stli_onbedisable(stlibrd_t *brdp)
 {       
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_onbedisable(brdp=%x)\n", (int) brdp);
-#endif
         outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
 }
 
@@ -3652,13 +3288,8 @@ static void stli_onbedisable(stlibrd_t *brdp)
 
 static char *stli_onbegetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
 {       
-        void            *ptr;
-        unsigned char   val;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_onbegetmemptr(brdp=%x,offset=%x,line=%d)\n",
-                (int) brdp, (int) offset, line);
-#endif
+        void *ptr;
+        unsigned char val;
 
         if (offset > brdp->memsize) {
                 printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
@@ -3681,11 +3312,6 @@ static char *stli_onbegetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
 
 static void stli_onbereset(stlibrd_t *brdp)
 {       
-
-#ifdef DEBUG
-        printk(KERN_ERR "stli_onbereset(brdp=%x)\n", (int) brdp);
-#endif
-
         outb(ONB_EISTOP, (brdp->iobase + ONB_EICONFR));
         udelay(10);
         outb(ONB_EIDISABLE, (brdp->iobase + ONB_EICONFR));
@@ -3700,11 +3326,6 @@ static void stli_onbereset(stlibrd_t *brdp)
 
 static void stli_bbyinit(stlibrd_t *brdp)
 {
-
-#ifdef DEBUG
-        printk(KERN_ERR "stli_bbyinit(brdp=%d)\n", (int) brdp);
-#endif
-
         outb(BBY_ATSTOP, (brdp->iobase + BBY_ATCONFR));
         udelay(10);
         outb(0, (brdp->iobase + BBY_ATCONFR));
@@ -3717,24 +3338,13 @@ static void stli_bbyinit(stlibrd_t *brdp)
 
 static char *stli_bbygetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
 {       
-        void            *ptr;
-        unsigned char   val;
+        void *ptr;
+        unsigned char val;
 
-#ifdef DEBUG
-        printk(KERN_ERR "stli_bbygetmemptr(brdp=%x,offset=%x)\n", (int) brdp,
-                (int) offset);
-#endif
+        BUG_ON(offset > brdp->memsize);
 
-        if (offset > brdp->memsize) {
-                printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
-                                "range at line=%d(%d), brd=%d\n",
-                                (int) offset, line, __LINE__, brdp->brdnr);
-                ptr = NULL;
-                val = 0;
-        } else {
-                ptr = brdp->membase + (offset % BBY_PAGESIZE);
-                val = (unsigned char) (offset / BBY_PAGESIZE);
-        }
+        ptr = brdp->membase + (offset % BBY_PAGESIZE);
+        val = (unsigned char) (offset / BBY_PAGESIZE);
         outb(val, (brdp->iobase + BBY_ATCONFR));
         return(ptr);
 }
@@ -3743,11 +3353,6 @@ static char *stli_bbygetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
 
 static void stli_bbyreset(stlibrd_t *brdp)
 {       
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_bbyreset(brdp=%x)\n", (int) brdp);
-#endif
-
         outb(BBY_ATSTOP, (brdp->iobase + BBY_ATCONFR));
         udelay(10);
         outb(0, (brdp->iobase + BBY_ATCONFR));
@@ -3762,11 +3367,6 @@ static void stli_bbyreset(stlibrd_t *brdp)
 
 static void stli_stalinit(stlibrd_t *brdp)
 {
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_stalinit(brdp=%d)\n", (int) brdp);
-#endif
-
         outb(0x1, brdp->iobase);
         mdelay(1000);
 }
@@ -3775,36 +3375,18 @@ static void stli_stalinit(stlibrd_t *brdp)
 
 static char *stli_stalgetmemptr(stlibrd_t *brdp, unsigned long offset, int line)
 {       
-        void    *ptr;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_stalgetmemptr(brdp=%x,offset=%x)\n", (int) brdp,
-                (int) offset);
-#endif
-
-        if (offset > brdp->memsize) {
-                printk(KERN_ERR "STALLION: shared memory pointer=%x out of "
-                                "range at line=%d(%d), brd=%d\n",
-                                (int) offset, line, __LINE__, brdp->brdnr);
-                ptr = NULL;
-        } else {
-                ptr = brdp->membase + (offset % STAL_PAGESIZE);
-        }
-        return(ptr);
+        BUG_ON(offset > brdp->memsize);
+        return brdp->membase + (offset % STAL_PAGESIZE);
 }
 
 /*****************************************************************************/
 
 static void stli_stalreset(stlibrd_t *brdp)
 {       
-        volatile unsigned long  *vecp;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_stalreset(brdp=%x)\n", (int) brdp);
-#endif
+        u32 __iomem *vecp;
 
-        vecp = (volatile unsigned long *) (brdp->membase + 0x30);
-        *vecp = 0xffff0000;
+        vecp = (u32 __iomem *) (brdp->membase + 0x30);
+        writel(0xffff0000, vecp);
         outb(0, brdp->iobase);
         mdelay(1000);
 }
@@ -3818,15 +3400,11 @@ static void stli_stalreset(stlibrd_t *brdp)
 
 static int stli_initecp(stlibrd_t *brdp)
 {
-        cdkecpsig_t     sig;
-        cdkecpsig_t     *sigsp;
-        unsigned int    status, nxtid;
-        char            *name;
-        int             panelnr, nrports;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_initecp(brdp=%x)\n", (int) brdp);
-#endif
+        cdkecpsig_t sig;
+        cdkecpsig_t __iomem *sigsp;
+        unsigned int status, nxtid;
+        char *name;
+        int panelnr, nrports;
 
         if (!request_region(brdp->iobase, brdp->iosize, "istallion"))
                 return -EIO;
@@ -3834,7 +3412,7 @@ static int stli_initecp(stlibrd_t *brdp)
         if ((brdp->iobase == 0) || (brdp->memaddr == 0))
         {
                 release_region(brdp->iobase, brdp->iosize);
-                return(-ENODEV);
+                return -ENODEV;
         }
 
         brdp->iosize = ECP_IOSIZE;
@@ -3903,7 +3481,7 @@ static int stli_initecp(stlibrd_t *brdp)
 
         default:
                 release_region(brdp->iobase, brdp->iosize);
-                return(-EINVAL);
+                return -EINVAL;
         }
 
 /*
@@ -3915,10 +3493,10 @@ static int stli_initecp(stlibrd_t *brdp)
         EBRDINIT(brdp);
 
         brdp->membase = ioremap(brdp->memaddr, brdp->memsize);
-        if (brdp->membase == (void *) NULL)
+        if (brdp->membase == NULL)
         {
                 release_region(brdp->iobase, brdp->iosize);
-                return(-ENOMEM);
+                return -ENOMEM;
         }
 
 /*
@@ -3927,23 +3505,14 @@ static int stli_initecp(stlibrd_t *brdp)
  *      this is, and what it is connected to it.
  */
         EBRDENABLE(brdp);
-        sigsp = (cdkecpsig_t *) EBRDGETMEMPTR(brdp, CDK_SIGADDR);
+        sigsp = (cdkecpsig_t __iomem *) EBRDGETMEMPTR(brdp, CDK_SIGADDR);
         memcpy(&sig, sigsp, sizeof(cdkecpsig_t));
         EBRDDISABLE(brdp);
 
-#if 0
-        printk("%s(%d): sig-> magic=%x rom=%x panel=%x,%x,%x,%x,%x,%x,%x,%x\n",
-                __FILE__, __LINE__, (int) sig.magic, sig.romver, sig.panelid[0],
-                (int) sig.panelid[1], (int) sig.panelid[2],
-                (int) sig.panelid[3], (int) sig.panelid[4],
-                (int) sig.panelid[5], (int) sig.panelid[6],
-                (int) sig.panelid[7]);
-#endif
-
-        if (sig.magic != ECP_MAGIC)
+        if (sig.magic != cpu_to_le32(ECP_MAGIC))
         {
                 release_region(brdp->iobase, brdp->iosize);
-                return(-ENODEV);
+                return -ENODEV;
         }
 
 /*
@@ -3967,7 +3536,7 @@ static int stli_initecp(stlibrd_t *brdp)
 
 
         brdp->state |= BST_FOUND;
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
@@ -3979,20 +3548,16 @@ static int stli_initecp(stlibrd_t *brdp)
 
 static int stli_initonb(stlibrd_t *brdp)
 {
-        cdkonbsig_t     sig;
-        cdkonbsig_t     *sigsp;
-        char            *name;
-        int             i;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_initonb(brdp=%x)\n", (int) brdp);
-#endif
+        cdkonbsig_t sig;
+        cdkonbsig_t __iomem *sigsp;
+        char *name;
+        int i;
 
 /*
  *      Do a basic sanity check on the IO and memory addresses.
  */
-        if ((brdp->iobase == 0) || (brdp->memaddr == 0))
-                return(-ENODEV);
+        if (brdp->iobase == 0 || brdp->memaddr == 0)
+                return -ENODEV;
 
         brdp->iosize = ONB_IOSIZE;
         
@@ -4010,7 +3575,6 @@ static int stli_initonb(stlibrd_t *brdp)
         case BRD_ONBOARD2:
         case BRD_ONBOARD2_32:
         case BRD_ONBOARDRS:
-                brdp->membase = (void *) brdp->memaddr;
                 brdp->memsize = ONB_MEMSIZE;
                 brdp->pagesize = ONB_ATPAGESIZE;
                 brdp->init = stli_onbinit;
@@ -4028,7 +3592,6 @@ static int stli_initonb(stlibrd_t *brdp)
                 break;
 
         case BRD_ONBOARDE:
-                brdp->membase = (void *) brdp->memaddr;
                 brdp->memsize = ONB_EIMEMSIZE;
                 brdp->pagesize = ONB_EIPAGESIZE;
                 brdp->init = stli_onbeinit;
@@ -4044,7 +3607,6 @@ static int stli_initonb(stlibrd_t *brdp)
         case BRD_BRUMBY4:
         case BRD_BRUMBY8:
         case BRD_BRUMBY16:
-                brdp->membase = (void *) brdp->memaddr;
                 brdp->memsize = BBY_MEMSIZE;
                 brdp->pagesize = BBY_PAGESIZE;
                 brdp->init = stli_bbyinit;
@@ -4058,7 +3620,6 @@ static int stli_initonb(stlibrd_t *brdp)
                 break;
 
         case BRD_STALLION:
-                brdp->membase = (void *) brdp->memaddr;
                 brdp->memsize = STAL_MEMSIZE;
                 brdp->pagesize = STAL_PAGESIZE;
                 brdp->init = stli_stalinit;
@@ -4073,7 +3634,7 @@ static int stli_initonb(stlibrd_t *brdp)
 
         default:
                 release_region(brdp->iobase, brdp->iosize);
-                return(-EINVAL);
+                return -EINVAL;
         }
 
 /*
@@ -4085,10 +3646,10 @@ static int stli_initonb(stlibrd_t *brdp)
         EBRDINIT(brdp);
 
         brdp->membase = ioremap(brdp->memaddr, brdp->memsize);
-        if (brdp->membase == (void *) NULL)
+        if (brdp->membase == NULL)
         {
                 release_region(brdp->iobase, brdp->iosize);
-                return(-ENOMEM);
+                return -ENOMEM;
         }
 
 /*
@@ -4097,21 +3658,17 @@ static int stli_initonb(stlibrd_t *brdp)
  *      this is, and how many ports.
  */
         EBRDENABLE(brdp);
-        sigsp = (cdkonbsig_t *) EBRDGETMEMPTR(brdp, CDK_SIGADDR);
-        memcpy(&sig, sigsp, sizeof(cdkonbsig_t));
+        sigsp = (cdkonbsig_t __iomem *) EBRDGETMEMPTR(brdp, CDK_SIGADDR);
+        memcpy_fromio(&sig, sigsp, sizeof(cdkonbsig_t));
         EBRDDISABLE(brdp);
 
-#if 0
-        printk("%s(%d): sig-> magic=%x:%x:%x:%x romver=%x amask=%x:%x:%x\n",
-                __FILE__, __LINE__, sig.magic0, sig.magic1, sig.magic2,
-                sig.magic3, sig.romver, sig.amask0, sig.amask1, sig.amask2);
-#endif
-
-        if ((sig.magic0 != ONB_MAGIC0) || (sig.magic1 != ONB_MAGIC1) ||
-            (sig.magic2 != ONB_MAGIC2) || (sig.magic3 != ONB_MAGIC3))
+        if (sig.magic0 != cpu_to_le16(ONB_MAGIC0) ||
+            sig.magic1 != cpu_to_le16(ONB_MAGIC1) ||
+            sig.magic2 != cpu_to_le16(ONB_MAGIC2) ||
+            sig.magic3 != cpu_to_le16(ONB_MAGIC3))
         {
                 release_region(brdp->iobase, brdp->iosize);
-                return(-ENODEV);
+                return -ENODEV;
         }
 
 /*
@@ -4132,7 +3689,7 @@ static int stli_initonb(stlibrd_t *brdp)
 
 
         brdp->state |= BST_FOUND;
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
@@ -4145,31 +3702,25 @@ static int stli_initonb(stlibrd_t *brdp)
 
 static int stli_startbrd(stlibrd_t *brdp)
 {
-        volatile cdkhdr_t       *hdrp;
-        volatile cdkmem_t       *memp;
-        volatile cdkasy_t       *ap;
-        unsigned long           flags;
-        stliport_t              *portp;
-        int                     portnr, nrdevs, i, rc;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_startbrd(brdp=%x)\n", (int) brdp);
-#endif
-
-        rc = 0;
-
-        save_flags(flags);
-        cli();
+        cdkhdr_t __iomem *hdrp;
+        cdkmem_t __iomem *memp;
+        cdkasy_t __iomem *ap;
+        unsigned long flags;
+        stliport_t *portp;
+        int portnr, nrdevs, i, rc = 0;
+        u32 memoff;
+
+        spin_lock_irqsave(&brd_lock, flags);
         EBRDENABLE(brdp);
-        hdrp = (volatile cdkhdr_t *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
+        hdrp = (cdkhdr_t __iomem *) EBRDGETMEMPTR(brdp, CDK_CDKADDR);
         nrdevs = hdrp->nrdevs;
 
 #if 0
         printk("%s(%d): CDK version %d.%d.%d --> "
                 "nrdevs=%d memp=%x hostp=%x slavep=%x\n",
-                 __FILE__, __LINE__, hdrp->ver_release, hdrp->ver_modification,
-                 hdrp->ver_fix, nrdevs, (int) hdrp->memp, (int) hdrp->hostp,
-                 (int) hdrp->slavep);
+                 __FILE__, __LINE__, readb(&hdrp->ver_release), readb(&hdrp->ver_modification),
+                 readb(&hdrp->ver_fix), nrdevs, (int) readl(&hdrp->memp), readl(&hdrp->hostp),
+                 readl(&hdrp->slavep));
 #endif
 
         if (nrdevs < (brdp->nrports + 1)) {
@@ -4181,14 +3732,14 @@ static int stli_startbrd(stlibrd_t *brdp)
         brdp->hostoffset = hdrp->hostp - CDK_CDKADDR;
         brdp->slaveoffset = hdrp->slavep - CDK_CDKADDR;
         brdp->bitsize = (nrdevs + 7) / 8;
-        memp = (volatile cdkmem_t *) hdrp->memp;
-        if (((unsigned long) memp) > brdp->memsize) {
+        memoff = readl(&hdrp->memp);
+        if (memoff > brdp->memsize) {
                 printk(KERN_ERR "STALLION: corrupted shared memory region?\n");
                 rc = -EIO;
                 goto stli_donestartup;
         }
-        memp = (volatile cdkmem_t *) EBRDGETMEMPTR(brdp, (unsigned long) memp);
-        if (memp->dtype != TYP_ASYNCTRL) {
+        memp = (cdkmem_t __iomem *) EBRDGETMEMPTR(brdp, memoff);
+        if (readw(&memp->dtype) != TYP_ASYNCTRL) {
                 printk(KERN_ERR "STALLION: no slave control device found\n");
                 goto stli_donestartup;
         }
@@ -4200,19 +3751,19 @@ static int stli_startbrd(stlibrd_t *brdp)
  *      change pages while reading memory map.
  */
         for (i = 1, portnr = 0; (i < nrdevs); i++, portnr++, memp++) {
-                if (memp->dtype != TYP_ASYNC)
+                if (readw(&memp->dtype) != TYP_ASYNC)
                         break;
                 portp = brdp->ports[portnr];
-                if (portp == (stliport_t *) NULL)
+                if (portp == NULL)
                         break;
                 portp->devnr = i;
-                portp->addr = memp->offset;
+                portp->addr = readl(&memp->offset);
                 portp->reqbit = (unsigned char) (0x1 << (i * 8 / nrdevs));
                 portp->portidx = (unsigned char) (i / 8);
                 portp->portbit = (unsigned char) (0x1 << (i % 8));
         }
 
-        hdrp->slavereq = 0xff;
+        writeb(0xff, &hdrp->slavereq);
 
 /*
  *      For each port setup a local copy of the RX and TX buffer offsets
@@ -4221,22 +3772,22 @@ static int stli_startbrd(stlibrd_t *brdp)
  */
         for (i = 1, portnr = 0; (i < nrdevs); i++, portnr++) {
                 portp = brdp->ports[portnr];
-                if (portp == (stliport_t *) NULL)
+                if (portp == NULL)
                         break;
                 if (portp->addr == 0)
                         break;
-                ap = (volatile cdkasy_t *) EBRDGETMEMPTR(brdp, portp->addr);
-                if (ap != (volatile cdkasy_t *) NULL) {
-                        portp->rxsize = ap->rxq.size;
-                        portp->txsize = ap->txq.size;
-                        portp->rxoffset = ap->rxq.offset;
-                        portp->txoffset = ap->txq.offset;
+                ap = (cdkasy_t __iomem *) EBRDGETMEMPTR(brdp, portp->addr);
+                if (ap != NULL) {
+                        portp->rxsize = readw(&ap->rxq.size);
+                        portp->txsize = readw(&ap->txq.size);
+                        portp->rxoffset = readl(&ap->rxq.offset);
+                        portp->txoffset = readl(&ap->txq.offset);
                 }
         }
 
 stli_donestartup:
         EBRDDISABLE(brdp);
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 
         if (rc == 0)
                 brdp->state |= BST_STARTED;
@@ -4247,7 +3798,7 @@ stli_donestartup:
                 add_timer(&stli_timerlist);
         }
 
-        return(rc);
+        return rc;
 }
 
 /*****************************************************************************/
@@ -4258,10 +3809,6 @@ stli_donestartup:
 
 static int __init stli_brdinit(stlibrd_t *brdp)
 {
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_brdinit(brdp=%x)\n", (int) brdp);
-#endif
-
         stli_brds[brdp->brdnr] = brdp;
 
         switch (brdp->brdtype) {
@@ -4289,11 +3836,11 @@ static int __init stli_brdinit(stlibrd_t *brdp)
         case BRD_ECHPCI:
                 printk(KERN_ERR "STALLION: %s board type not supported in "
                                 "this driver\n", stli_brdnames[brdp->brdtype]);
-                return(ENODEV);
+                return -ENODEV;
         default:
                 printk(KERN_ERR "STALLION: board=%d is unknown board "
                                 "type=%d\n", brdp->brdnr, brdp->brdtype);
-                return(ENODEV);
+                return -ENODEV;
         }
 
         if ((brdp->state & BST_FOUND) == 0) {
@@ -4301,7 +3848,7 @@ static int __init stli_brdinit(stlibrd_t *brdp)
                                 "io=%x mem=%x\n",
                         stli_brdnames[brdp->brdtype], brdp->brdnr,
                         brdp->iobase, (int) brdp->memaddr);
-                return(ENODEV);
+                return -ENODEV;
         }
 
         stli_initports(brdp);
@@ -4309,7 +3856,7 @@ static int __init stli_brdinit(stlibrd_t *brdp)
                 "nrpanels=%d nrports=%d\n", stli_brdnames[brdp->brdtype],
                 brdp->brdnr, brdp->iobase, (int) brdp->memaddr,
                 brdp->nrpanels, brdp->nrports);
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
@@ -4321,14 +3868,10 @@ static int __init stli_brdinit(stlibrd_t *brdp)
 
 static int stli_eisamemprobe(stlibrd_t *brdp)
 {
-        cdkecpsig_t     ecpsig, *ecpsigp;
-        cdkonbsig_t     onbsig, *onbsigp;
+        cdkecpsig_t     ecpsig, __iomem *ecpsigp;
+        cdkonbsig_t     onbsig, __iomem *onbsigp;
         int             i, foundit;
 
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_eisamemprobe(brdp=%x)\n", (int) brdp);
-#endif
-
 /*
  *      First up we reset the board, to get it into a known state. There
  *      is only 2 board types here we need to worry about. Don;t use the
@@ -4352,7 +3895,7 @@ static int stli_eisamemprobe(stlibrd_t *brdp)
                 mdelay(1);
                 stli_onbeenable(brdp);
         } else {
-                return(-ENODEV);
+                return -ENODEV;
         }
 
         foundit = 0;
@@ -4364,25 +3907,24 @@ static int stli_eisamemprobe(stlibrd_t *brdp)
  */
         for (i = 0; (i < stli_eisamempsize); i++) {
                 brdp->memaddr = stli_eisamemprobeaddrs[i];
-                brdp->membase = (void *) brdp->memaddr;
                 brdp->membase = ioremap(brdp->memaddr, brdp->memsize);
-                if (brdp->membase == (void *) NULL)
+                if (brdp->membase == NULL)
                         continue;
 
                 if (brdp->brdtype == BRD_ECPE) {
-                        ecpsigp = (cdkecpsig_t *) stli_ecpeigetmemptr(brdp,
+                        ecpsigp = (cdkecpsig_t __iomem *) stli_ecpeigetmemptr(brdp,
                                 CDK_SIGADDR, __LINE__);
-                        memcpy(&ecpsig, ecpsigp, sizeof(cdkecpsig_t));
-                        if (ecpsig.magic == ECP_MAGIC)
+                        memcpy_fromio(&ecpsig, ecpsigp, sizeof(cdkecpsig_t));
+                        if (ecpsig.magic == cpu_to_le32(ECP_MAGIC))
                                 foundit = 1;
                 } else {
-                        onbsigp = (cdkonbsig_t *) stli_onbegetmemptr(brdp,
+                        onbsigp = (cdkonbsig_t __iomem *) stli_onbegetmemptr(brdp,
                                 CDK_SIGADDR, __LINE__);
-                        memcpy(&onbsig, onbsigp, sizeof(cdkonbsig_t));
-                        if ((onbsig.magic0 == ONB_MAGIC0) &&
-                            (onbsig.magic1 == ONB_MAGIC1) &&
-                            (onbsig.magic2 == ONB_MAGIC2) &&
-                            (onbsig.magic3 == ONB_MAGIC3))
+                        memcpy_fromio(&onbsig, onbsigp, sizeof(cdkonbsig_t));
+                        if ((onbsig.magic0 == cpu_to_le16(ONB_MAGIC0)) &&
+                            (onbsig.magic1 == cpu_to_le16(ONB_MAGIC1)) &&
+                            (onbsig.magic2 == cpu_to_le16(ONB_MAGIC2)) &&
+                            (onbsig.magic3 == cpu_to_le16(ONB_MAGIC3)))
                                 foundit = 1;
                 }
 
@@ -4406,9 +3948,9 @@ static int stli_eisamemprobe(stlibrd_t *brdp)
                 printk(KERN_ERR "STALLION: failed to probe shared memory "
                                 "region for %s in EISA slot=%d\n",
                         stli_brdnames[brdp->brdtype], (brdp->iobase >> 12));
-                return(-ENODEV);
+                return -ENODEV;
         }
-        return(0);
+        return 0;
 }
 
 static int stli_getbrdnr(void)
@@ -4439,22 +3981,16 @@ static int stli_getbrdnr(void)
 
 static int stli_findeisabrds(void)
 {
-        stlibrd_t       *brdp;
-        unsigned int    iobase, eid;
-        int             i;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_findeisabrds()\n");
-#endif
+        stlibrd_t *brdp;
+        unsigned int iobase, eid;
+        int i;
 
 /*
- *      Firstly check if this is an EISA system. Do this by probing for
- *      the system board EISA ID. If this is not an EISA system then
+ *      Firstly check if this is an EISA system.  If this is not an EISA system then
  *      don't bother going any further!
  */
-        outb(0xff, 0xc80);
-        if (inb(0xc80) == 0xff)
-                return(0);
+        if (EISA_bus)
+                return 0;
 
 /*
  *      Looks like an EISA system, so go searching for EISA boards.
@@ -4472,7 +4008,7 @@ static int stli_findeisabrds(void)
  */
                 for (i = 0; (i < STL_MAXBRDS); i++) {
                         brdp = stli_brds[i];
-                        if (brdp == (stlibrd_t *) NULL)
+                        if (brdp == NULL)
                                 continue;
                         if (brdp->iobase == iobase)
                                 break;
@@ -4484,10 +4020,10 @@ static int stli_findeisabrds(void)
  *              We have found a Stallion board and it is not configured already.
  *              Allocate a board structure and initialize it.
  */
-                if ((brdp = stli_allocbrd()) == (stlibrd_t *) NULL)
-                        return(-ENOMEM);
+                if ((brdp = stli_allocbrd()) == NULL)
+                        return -ENOMEM;
                 if ((brdp->brdnr = stli_getbrdnr()) < 0)
-                        return(-ENOMEM);
+                        return -ENOMEM;
                 eid = inb(iobase + 0xc82);
                 if (eid == ECP_EISAID)
                         brdp->brdtype = BRD_ECPE;
@@ -4502,7 +4038,7 @@ static int stli_findeisabrds(void)
                 stli_brdinit(brdp);
         }
 
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
@@ -4523,32 +4059,18 @@ static int stli_findeisabrds(void)
 
 static int stli_initpcibrd(int brdtype, struct pci_dev *devp)
 {
-        stlibrd_t       *brdp;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_initpcibrd(brdtype=%d,busnr=%x,devnr=%x)\n",
-                brdtype, dev->bus->number, dev->devfn);
-#endif
+        stlibrd_t *brdp;
 
         if (pci_enable_device(devp))
-                return(-EIO);
-        if ((brdp = stli_allocbrd()) == (stlibrd_t *) NULL)
-                return(-ENOMEM);
+                return -EIO;
+        if ((brdp = stli_allocbrd()) == NULL)
+                return -ENOMEM;
         if ((brdp->brdnr = stli_getbrdnr()) < 0) {
                 printk(KERN_INFO "STALLION: too many boards found, "
                         "maximum supported %d\n", STL_MAXBRDS);
-                return(0);
+                return 0;
         }
         brdp->brdtype = brdtype;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "%s(%d): BAR[]=%lx,%lx,%lx,%lx\n", __FILE__, __LINE__,
-                pci_resource_start(devp, 0),
-                pci_resource_start(devp, 1),
-                pci_resource_start(devp, 2),
-                pci_resource_start(devp, 3));
-#endif
-
 /*
  *      We have all resources from the board, so lets setup the actual
  *      board structure now.
@@ -4557,7 +4079,7 @@ static int stli_initpcibrd(int brdtype, struct pci_dev *devp)
         brdp->memaddr = pci_resource_start(devp, 2);
         stli_brdinit(brdp);
 
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
@@ -4569,20 +4091,12 @@ static int stli_initpcibrd(int brdtype, struct pci_dev *devp)
 
 static int stli_findpcibrds(void)
 {
-        struct pci_dev  *dev = NULL;
-        int             rc;
-
-#ifdef DEBUG
-        printk("stli_findpcibrds()\n");
-#endif
+        struct pci_dev *dev = NULL;
 
-        while ((dev = pci_find_device(PCI_VENDOR_ID_STALLION,
-            PCI_DEVICE_ID_ECRA, dev))) {
-                if ((rc = stli_initpcibrd(BRD_ECPPCI, dev)))
-                        return(rc);
+        while ((dev = pci_get_device(PCI_VENDOR_ID_STALLION, PCI_DEVICE_ID_ECRA, dev))) {
+                stli_initpcibrd(BRD_ECPPCI, dev);
         }
-
-        return(0);
+        return 0;
 }
 
 #endif
@@ -4595,17 +4109,16 @@ static int stli_findpcibrds(void)
 
 static stlibrd_t *stli_allocbrd(void)
 {
-        stlibrd_t       *brdp;
+        stlibrd_t *brdp;
 
         brdp = kzalloc(sizeof(stlibrd_t), GFP_KERNEL);
         if (!brdp) {
                 printk(KERN_ERR "STALLION: failed to allocate memory "
-                                "(size=%d)\n", sizeof(stlibrd_t));
+                                "(size=%Zd)\n", sizeof(stlibrd_t));
                 return NULL;
         }
-
         brdp->magic = STLI_BOARDMAGIC;
-        return(brdp);
+        return brdp;
 }
 
 /*****************************************************************************/
@@ -4617,13 +4130,9 @@ static stlibrd_t *stli_allocbrd(void)
 
 static int stli_initbrds(void)
 {
-        stlibrd_t       *brdp, *nxtbrdp;
-        stlconf_t       *confp;
-        int             i, j;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_initbrds()\n");
-#endif
+        stlibrd_t *brdp, *nxtbrdp;
+        stlconf_t *confp;
+        int i, j;
 
         if (stli_nrbrds > STL_MAXBRDS) {
                 printk(KERN_INFO "STALLION: too many boards in configuration "
@@ -4638,11 +4147,9 @@ static int stli_initbrds(void)
  */
         for (i = 0; (i < stli_nrbrds); i++) {
                 confp = &stli_brdconf[i];
-#ifdef MODULE
                 stli_parsebrd(confp, stli_brdsp[i]);
-#endif
-                if ((brdp = stli_allocbrd()) == (stlibrd_t *) NULL)
-                        return(-ENOMEM);
+                if ((brdp = stli_allocbrd()) == NULL)
+                        return -ENOMEM;
                 brdp->brdnr = i;
                 brdp->brdtype = confp->brdtype;
                 brdp->iobase = confp->ioaddr1;
@@ -4654,9 +4161,7 @@ static int stli_initbrds(void)
  *      Static configuration table done, so now use dynamic methods to
  *      see if any more boards should be configured.
  */
-#ifdef MODULE
         stli_argbrds();
-#endif
         if (STLI_EISAPROBE)
                 stli_findeisabrds();
 #ifdef CONFIG_PCI
@@ -4672,11 +4177,11 @@ static int stli_initbrds(void)
         if (stli_nrbrds > 1) {
                 for (i = 0; (i < stli_nrbrds); i++) {
                         brdp = stli_brds[i];
-                        if (brdp == (stlibrd_t *) NULL)
+                        if (brdp == NULL)
                                 continue;
                         for (j = i + 1; (j < stli_nrbrds); j++) {
                                 nxtbrdp = stli_brds[j];
-                                if (nxtbrdp == (stlibrd_t *) NULL)
+                                if (nxtbrdp == NULL)
                                         continue;
                                 if ((brdp->membase >= nxtbrdp->membase) &&
                                     (brdp->membase <= (nxtbrdp->membase +
@@ -4691,7 +4196,7 @@ static int stli_initbrds(void)
         if (stli_shared == 0) {
                 for (i = 0; (i < stli_nrbrds); i++) {
                         brdp = stli_brds[i];
-                        if (brdp == (stlibrd_t *) NULL)
+                        if (brdp == NULL)
                                 continue;
                         if (brdp->state & BST_FOUND) {
                                 EBRDENABLE(brdp);
@@ -4701,7 +4206,7 @@ static int stli_initbrds(void)
                 }
         }
 
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
@@ -4714,48 +4219,55 @@ static int stli_initbrds(void)
 
 static ssize_t stli_memread(struct file *fp, char __user *buf, size_t count, loff_t *offp)
 {
-        unsigned long   flags;
-        void            *memptr;
-        stlibrd_t       *brdp;
-        int             brdnr, size, n;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_memread(fp=%x,buf=%x,count=%x,offp=%x)\n",
-                        (int) fp, (int) buf, count, (int) offp);
-#endif
+        unsigned long flags;
+        void *memptr;
+        stlibrd_t *brdp;
+        int brdnr, size, n;
+        void *p;
+        loff_t off = *offp;
 
         brdnr = iminor(fp->f_dentry->d_inode);
         if (brdnr >= stli_nrbrds)
-                return(-ENODEV);
+                return -ENODEV;
         brdp = stli_brds[brdnr];
-        if (brdp == (stlibrd_t *) NULL)
-                return(-ENODEV);
+        if (brdp == NULL)
+                return -ENODEV;
         if (brdp->state == 0)
-                return(-ENODEV);
-        if (fp->f_pos >= brdp->memsize)
-                return(0);
+                return -ENODEV;
+        if (off >= brdp->memsize || off + count < off)
+                return 0;
 
-        size = MIN(count, (brdp->memsize - fp->f_pos));
+        size = MIN(count, (brdp->memsize - off));
+
+        /*
+         *      Copy the data a page at a time
+         */
+
+        p = (void *)__get_free_page(GFP_KERNEL);
+        if(p == NULL)
+                return -ENOMEM;
 
-        save_flags(flags);
-        cli();
-        EBRDENABLE(brdp);
         while (size > 0) {
-                memptr = (void *) EBRDGETMEMPTR(brdp, fp->f_pos);
-                n = MIN(size, (brdp->pagesize - (((unsigned long) fp->f_pos) % brdp->pagesize)));
-                if (copy_to_user(buf, memptr, n)) {
+                spin_lock_irqsave(&brd_lock, flags);
+                EBRDENABLE(brdp);
+                memptr = (void *) EBRDGETMEMPTR(brdp, off);
+                n = MIN(size, (brdp->pagesize - (((unsigned long) off) % brdp->pagesize)));
+                n = MIN(n, PAGE_SIZE);
+                memcpy_fromio(p, memptr, n);
+                EBRDDISABLE(brdp);
+                spin_unlock_irqrestore(&brd_lock, flags);
+                if (copy_to_user(buf, p, n)) {
                         count = -EFAULT;
                         goto out;
                 }
-                fp->f_pos += n;
+                off += n;
                 buf += n;
                 size -= n;
         }
 out:
-        EBRDDISABLE(brdp);
-        restore_flags(flags);
-
-        return(count);
+        *offp = off;
+        free_page((unsigned long)p);
+        return count;
 }
 
 /*****************************************************************************/
@@ -4764,54 +4276,65 @@ out:
  *      Code to handle an "staliomem" write operation. This device is the 
  *      contents of the board shared memory. It is used for down loading
  *      the slave image (and debugging :-)
+ *
+ *      FIXME: copy under lock
  */
 
 static ssize_t stli_memwrite(struct file *fp, const char __user *buf, size_t count, loff_t *offp)
 {
-        unsigned long   flags;
-        void            *memptr;
-        stlibrd_t       *brdp;
-        char            __user *chbuf;
-        int             brdnr, size, n;
-
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_memwrite(fp=%x,buf=%x,count=%x,offp=%x)\n",
-                        (int) fp, (int) buf, count, (int) offp);
-#endif
+        unsigned long flags;
+        void *memptr;
+        stlibrd_t *brdp;
+        char __user *chbuf;
+        int brdnr, size, n;
+        void *p;
+        loff_t off = *offp;
 
         brdnr = iminor(fp->f_dentry->d_inode);
+
         if (brdnr >= stli_nrbrds)
-                return(-ENODEV);
+                return -ENODEV;
         brdp = stli_brds[brdnr];
-        if (brdp == (stlibrd_t *) NULL)
-                return(-ENODEV);
+        if (brdp == NULL)
+                return -ENODEV;
         if (brdp->state == 0)
-                return(-ENODEV);
-        if (fp->f_pos >= brdp->memsize)
-                return(0);
+                return -ENODEV;
+        if (off >= brdp->memsize || off + count < off)
+                return 0;
 
         chbuf = (char __user *) buf;
-        size = MIN(count, (brdp->memsize - fp->f_pos));
+        size = MIN(count, (brdp->memsize - off));
+
+        /*
+         *      Copy the data a page at a time
+         */
+
+        p = (void *)__get_free_page(GFP_KERNEL);
+        if(p == NULL)
+                return -ENOMEM;
 
-        save_flags(flags);
-        cli();
-        EBRDENABLE(brdp);
         while (size > 0) {
-                memptr = (void *) EBRDGETMEMPTR(brdp, fp->f_pos);
-                n = MIN(size, (brdp->pagesize - (((unsigned long) fp->f_pos) % brdp->pagesize)));
-                if (copy_from_user(memptr, chbuf, n)) {
-                        count = -EFAULT;
+                n = MIN(size, (brdp->pagesize - (((unsigned long) off) % brdp->pagesize)));
+                n = MIN(n, PAGE_SIZE);
+                if (copy_from_user(p, chbuf, n)) {
+                        if (count == 0)
+                                count = -EFAULT;
                         goto out;
                 }
-                fp->f_pos += n;
+                spin_lock_irqsave(&brd_lock, flags);
+                EBRDENABLE(brdp);
+                memptr = (void *) EBRDGETMEMPTR(brdp, off);
+                memcpy_toio(memptr, p, n);
+                EBRDDISABLE(brdp);
+                spin_unlock_irqrestore(&brd_lock, flags);
+                off += n;
                 chbuf += n;
                 size -= n;
         }
 out:
-        EBRDDISABLE(brdp);
-        restore_flags(flags);
-
-        return(count);
+        free_page((unsigned long) p);
+        *offp = off;
+        return count;
 }
 
 /*****************************************************************************/
@@ -4822,16 +4345,16 @@ out:
 
 static int stli_getbrdstats(combrd_t __user *bp)
 {
-        stlibrd_t       *brdp;
-        int             i;
+        stlibrd_t *brdp;
+        int i;
 
         if (copy_from_user(&stli_brdstats, bp, sizeof(combrd_t)))
                 return -EFAULT;
         if (stli_brdstats.brd >= STL_MAXBRDS)
-                return(-ENODEV);
+                return -ENODEV;
         brdp = stli_brds[stli_brdstats.brd];
-        if (brdp == (stlibrd_t *) NULL)
-                return(-ENODEV);
+        if (brdp == NULL)
+                return -ENODEV;
 
         memset(&stli_brdstats, 0, sizeof(combrd_t));
         stli_brdstats.brd = brdp->brdnr;
@@ -4850,7 +4373,7 @@ static int stli_getbrdstats(combrd_t __user *bp)
 
         if (copy_to_user(bp, &stli_brdstats, sizeof(combrd_t)))
                 return -EFAULT;
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
@@ -4861,19 +4384,19 @@ static int stli_getbrdstats(combrd_t __user *bp)
 
 static stliport_t *stli_getport(int brdnr, int panelnr, int portnr)
 {
-        stlibrd_t       *brdp;
-        int             i;
+        stlibrd_t *brdp;
+        int i;
 
-        if ((brdnr < 0) || (brdnr >= STL_MAXBRDS))
-                return((stliport_t *) NULL);
+        if (brdnr < 0 || brdnr >= STL_MAXBRDS)
+                return NULL;
         brdp = stli_brds[brdnr];
-        if (brdp == (stlibrd_t *) NULL)
-                return((stliport_t *) NULL);
+        if (brdp == NULL)
+                return NULL;
         for (i = 0; (i < panelnr); i++)
                 portnr += brdp->panels[i];
         if ((portnr < 0) || (portnr >= brdp->nrports))
-                return((stliport_t *) NULL);
-        return(brdp->ports[portnr]);
+                return NULL;
+        return brdp->ports[portnr];
 }
 
 /*****************************************************************************/
@@ -4892,16 +4415,16 @@ static int stli_portcmdstats(stliport_t *portp)
 
         memset(&stli_comstats, 0, sizeof(comstats_t));
 
-        if (portp == (stliport_t *) NULL)
-                return(-ENODEV);
+        if (portp == NULL)
+                return -ENODEV;
         brdp = stli_brds[portp->brdnr];
-        if (brdp == (stlibrd_t *) NULL)
-                return(-ENODEV);
+        if (brdp == NULL)
+                return -ENODEV;
 
         if (brdp->state & BST_STARTED) {
                 if ((rc = stli_cmdwait(brdp, portp, A_GETSTATS,
                     &stli_cdkstats, sizeof(asystats_t), 1)) < 0)
-                        return(rc);
+                        return rc;
         } else {
                 memset(&stli_cdkstats, 0, sizeof(asystats_t));
         }
@@ -4912,13 +4435,12 @@ static int stli_portcmdstats(stliport_t *portp)
         stli_comstats.state = portp->state;
         stli_comstats.flags = portp->flags;
 
-        save_flags(flags);
-        cli();
-        if (portp->tty != (struct tty_struct *) NULL) {
+        spin_lock_irqsave(&brd_lock, flags);
+        if (portp->tty != NULL) {
                 if (portp->tty->driver_data == portp) {
                         stli_comstats.ttystate = portp->tty->flags;
-                        stli_comstats.rxbuffered = -1 /*portp->tty->flip.count*/;
-                        if (portp->tty->termios != (struct termios *) NULL) {
+                        stli_comstats.rxbuffered = -1;
+                        if (portp->tty->termios != NULL) {
                                 stli_comstats.cflags = portp->tty->termios->c_cflag;
                                 stli_comstats.iflags = portp->tty->termios->c_iflag;
                                 stli_comstats.oflags = portp->tty->termios->c_oflag;
@@ -4926,7 +4448,7 @@ static int stli_portcmdstats(stliport_t *portp)
                         }
                 }
         }
-        restore_flags(flags);
+        spin_unlock_irqrestore(&brd_lock, flags);
 
         stli_comstats.txtotal = stli_cdkstats.txchars;
         stli_comstats.rxtotal = stli_cdkstats.rxchars + stli_cdkstats.ringover;
@@ -4948,7 +4470,7 @@ static int stli_portcmdstats(stliport_t *portp)
         stli_comstats.hwid = stli_cdkstats.hwid;
         stli_comstats.signals = stli_mktiocm(stli_cdkstats.signals);
 
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
@@ -4961,8 +4483,8 @@ static int stli_portcmdstats(stliport_t *portp)
 
 static int stli_getportstats(stliport_t *portp, comstats_t __user *cp)
 {
-        stlibrd_t       *brdp;
-        int             rc;
+        stlibrd_t *brdp;
+        int rc;
 
         if (!portp) {
                 if (copy_from_user(&stli_comstats, cp, sizeof(comstats_t)))
@@ -4992,8 +4514,8 @@ static int stli_getportstats(stliport_t *portp, comstats_t __user *cp)
 
 static int stli_clrportstats(stliport_t *portp, comstats_t __user *cp)
 {
-        stlibrd_t       *brdp;
-        int             rc;
+        stlibrd_t *brdp;
+        int rc;
 
         if (!portp) {
                 if (copy_from_user(&stli_comstats, cp, sizeof(comstats_t)))
@@ -5031,7 +4553,7 @@ static int stli_clrportstats(stliport_t *portp, comstats_t __user *cp)
 
 static int stli_getportstruct(stliport_t __user *arg)
 {
-        stliport_t      *portp;
+        stliport_t *portp;
 
         if (copy_from_user(&stli_dummyport, arg, sizeof(stliport_t)))
                 return -EFAULT;
@@ -5052,7 +4574,7 @@ static int stli_getportstruct(stliport_t __user *arg)
 
 static int stli_getbrdstruct(stlibrd_t __user *arg)
 {
-        stlibrd_t       *brdp;
+        stlibrd_t *brdp;
 
         if (copy_from_user(&stli_dummybrd, arg, sizeof(stlibrd_t)))
                 return -EFAULT;
@@ -5076,15 +4598,10 @@ static int stli_getbrdstruct(stlibrd_t __user *arg)
 
 static int stli_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, unsigned long arg)
 {
-        stlibrd_t       *brdp;
-        int             brdnr, rc, done;
+        stlibrd_t *brdp;
+        int brdnr, rc, done;
         void __user *argp = (void __user *)arg;
 
-#ifdef DEBUG
-        printk(KERN_DEBUG "stli_memioctl(ip=%x,fp=%x,cmd=%x,arg=%x)\n",
-                        (int) ip, (int) fp, cmd, (int) arg);
-#endif
-
 /*
  *      First up handle the board independent ioctls.
  */
@@ -5115,7 +4632,7 @@ static int stli_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, un
         }
 
         if (done)
-                return(rc);
+                return rc;
 
 /*
  *      Now handle the board specific ioctls. These all depend on the
@@ -5123,12 +4640,12 @@ static int stli_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, un
  */
         brdnr = iminor(ip);
         if (brdnr >= STL_MAXBRDS)
-                return(-ENODEV);
+                return -ENODEV;
         brdp = stli_brds[brdnr];
         if (!brdp)
-                return(-ENODEV);
+                return -ENODEV;
         if (brdp->state == 0)
-                return(-ENODEV);
+                return -ENODEV;
 
         switch (cmd) {
         case STL_BINTR:
@@ -5152,8 +4669,7 @@ static int stli_memioctl(struct inode *ip, struct file *fp, unsigned int cmd, un
                 rc = -ENOIOCTLCMD;
                 break;
         }
-
-        return(rc);
+        return rc;
 }
 
 static struct tty_operations stli_ops = {
@@ -5187,6 +4703,9 @@ int __init stli_init(void)
         int i;
         printk(KERN_INFO "%s: version %s\n", stli_drvtitle, stli_drvversion);
 
+        spin_lock_init(&stli_lock);
+        spin_lock_init(&brd_lock);
+
         stli_initbrds();
 
         stli_serial = alloc_tty_driver(STL_MAXBRDS * STL_MAXPORTS);
@@ -5196,10 +4715,6 @@ int __init stli_init(void)
 /*
  *      Allocate a temporary write buffer.
  */
-        stli_tmpwritebuf = kmalloc(STLI_TXBUFSIZE, GFP_KERNEL);
-        if (!stli_tmpwritebuf)
-                printk(KERN_ERR "STALLION: failed to allocate memory "
-                                "(size=%d)\n", STLI_TXBUFSIZE);
         stli_txcookbuf = kmalloc(STLI_TXBUFSIZE, GFP_KERNEL);
         if (!stli_txcookbuf)
                 printk(KERN_ERR "STALLION: failed to allocate memory "
@@ -5243,7 +4758,7 @@ int __init stli_init(void)
                 printk(KERN_ERR "STALLION: failed to register serial driver\n");
                 return -EBUSY;
         }
-        return(0);
+        return 0;
 }
 
 /*****************************************************************************/
diff --git a/drivers/char/mxser.c b/drivers/char/mxser.c
index 645d9d713aec..72cfd09091e0 100644
--- a/drivers/char/mxser.c
+++ b/drivers/char/mxser.c
@@ -996,7 +996,6 @@ static int mxser_open(struct tty_struct *tty, struct file *filp)
 
         info->session = current->signal->session;
         info->pgrp = process_group(current);
-        clear_bit(TTY_DONT_FLIP, &tty->flags);
 
         /*
         status = mxser_get_msr(info->base, 0, info->port);
diff --git a/drivers/char/n_tty.c b/drivers/char/n_tty.c
index b9371d5bf790..603b9ade5eb0 100644
--- a/drivers/char/n_tty.c
+++ b/drivers/char/n_tty.c
@@ -1132,7 +1132,7 @@ static inline int input_available_p(struct tty_struct *tty, int amt)
  *      buffer, and once to drain the space from the (physical) beginning of
  *      the buffer to head pointer.
  *
- *      Called under the tty->atomic_read_lock sem and with TTY_DONT_FLIP set
+ *      Called under the tty->atomic_read_lock sem
  *
  */
  
@@ -1271,7 +1271,6 @@ do_it_again:
         }
 
         add_wait_queue(&tty->read_wait, &wait);
-        set_bit(TTY_DONT_FLIP, &tty->flags);
         while (nr) {
                 /* First test for status change. */
                 if (tty->packet && tty->link->ctrl_status) {
@@ -1315,9 +1314,7 @@ do_it_again:
                                 break;
                         }
                         n_tty_set_room(tty);
-                        clear_bit(TTY_DONT_FLIP, &tty->flags);
                         timeout = schedule_timeout(timeout);
-                        set_bit(TTY_DONT_FLIP, &tty->flags);
                         continue;
                 }
                 __set_current_state(TASK_RUNNING);
@@ -1394,7 +1391,6 @@ do_it_again:
                 if (time)
                         timeout = time;
         }
-        clear_bit(TTY_DONT_FLIP, &tty->flags);
         mutex_unlock(&tty->atomic_read_lock);
         remove_wait_queue(&tty->read_wait, &wait);
 
diff --git a/drivers/char/pty.c b/drivers/char/pty.c
index 9b5a2c0e7008..0c17f61549b4 100644
--- a/drivers/char/pty.c
+++ b/drivers/char/pty.c
@@ -101,7 +101,7 @@ static void pty_unthrottle(struct tty_struct * tty)
  *
  * FIXME: Our pty_write method is called with our ldisc lock held but
  * not our partners. We can't just take the other one blindly without
- * risking deadlocks.  There is also the small matter of TTY_DONT_FLIP
+ * risking deadlocks.
  */
 static int pty_write(struct tty_struct * tty, const unsigned char *buf, int count)
 {
diff --git a/drivers/char/stallion.c b/drivers/char/stallion.c
index bf361a5ba70d..00b4a2187164 100644
--- a/drivers/char/stallion.c
+++ b/drivers/char/stallion.c
@@ -3029,6 +3029,9 @@ static int __init stl_init(void)
         int i;
         printk(KERN_INFO "%s: version %s\n", stl_drvtitle, stl_drvversion);
 
+        spin_lock_init(&stallion_lock);
+        spin_lock_init(&brd_lock);
+
         stl_initbrds();
 
         stl_serial = alloc_tty_driver(STL_MAXBRDS * STL_MAXPORTS);
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index bd74e82d8a72..8d19f7281f0b 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -267,7 +267,6 @@ static struct tty_buffer *tty_buffer_alloc(size_t size)
         p->used = 0;
         p->size = size;
         p->next = NULL;
-        p->active = 0;
         p->commit = 0;
         p->read = 0;
         p->char_buf_ptr = (char *)(p->data);
@@ -327,10 +326,9 @@ int tty_buffer_request_room(struct tty_struct *tty, size_t size)
         /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
            remove this conditional if its worth it. This would be invisible
            to the callers */
-        if ((b = tty->buf.tail) != NULL) {
+        if ((b = tty->buf.tail) != NULL)
                 left = b->size - b->used;
-                b->active = 1;
-        } else
+        else
                 left = 0;
 
         if (left < size) {
@@ -338,12 +336,10 @@ int tty_buffer_request_room(struct tty_struct *tty, size_t size)
                 if ((n = tty_buffer_find(tty, size)) != NULL) {
                         if (b != NULL) {
                                 b->next = n;
-                                b->active = 0;
                                 b->commit = b->used;
                         } else
                                 tty->buf.head = n;
                         tty->buf.tail = n;
-                        n->active = 1;
                 } else
                         size = left;
         }
@@ -404,10 +400,8 @@ void tty_schedule_flip(struct tty_struct *tty)
 {
         unsigned long flags;
         spin_lock_irqsave(&tty->buf.lock, flags);
-        if (tty->buf.tail != NULL) {
-                tty->buf.tail->active = 0;
+        if (tty->buf.tail != NULL)
                 tty->buf.tail->commit = tty->buf.tail->used;
-        }
         spin_unlock_irqrestore(&tty->buf.lock, flags);
         schedule_delayed_work(&tty->buf.work, 1);
 }
@@ -784,11 +778,8 @@ restart:
         }
 
         clear_bit(TTY_LDISC, &tty->flags);
-        clear_bit(TTY_DONT_FLIP, &tty->flags);
-        if (o_tty) {
+        if (o_tty)
                 clear_bit(TTY_LDISC, &o_tty->flags);
-                clear_bit(TTY_DONT_FLIP, &o_tty->flags);
-        }
         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 
         /*
@@ -1955,7 +1946,6 @@ static void release_dev(struct file * filp)
          * race with the set_ldisc code path.
          */
         clear_bit(TTY_LDISC, &tty->flags);
-        clear_bit(TTY_DONT_FLIP, &tty->flags);
         cancel_delayed_work(&tty->buf.work);
 
         /*
@@ -2775,8 +2765,7 @@ static void flush_to_ldisc(void *private_)
         struct tty_struct *tty = (struct tty_struct *) private_;
         unsigned long   flags;
         struct tty_ldisc *disc;
-        struct tty_buffer *tbuf;
-        int count;
+        struct tty_buffer *tbuf, *head;
         char *char_buf;
         unsigned char *flag_buf;
 
@@ -2784,32 +2773,37 @@ static void flush_to_ldisc(void *private_)
         if (disc == NULL)       /*  !TTY_LDISC */
                 return;
 
-        if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
-                /*
-                 * Do it after the next timer tick:
-                 */
-                schedule_delayed_work(&tty->buf.work, 1);
-                goto out;
-        }
         spin_lock_irqsave(&tty->buf.lock, flags);
-        while((tbuf = tty->buf.head) != NULL) {
-                while ((count = tbuf->commit - tbuf->read) != 0) {
-                        char_buf = tbuf->char_buf_ptr + tbuf->read;
-                        flag_buf = tbuf->flag_buf_ptr + tbuf->read;
-                        tbuf->read += count;
+        head = tty->buf.head;
+        if (head != NULL) {
+                tty->buf.head = NULL;
+                for (;;) {
+                        int count = head->commit - head->read;
+                        if (!count) {
+                                if (head->next == NULL)
+                                        break;
+                                tbuf = head;
+                                head = head->next;
+                                tty_buffer_free(tty, tbuf);
+                                continue;
+                        }
+                        if (!tty->receive_room) {
+                                schedule_delayed_work(&tty->buf.work, 1);
+                                break;
+                        }
+                        if (count > tty->receive_room)
+                                count = tty->receive_room;
+                        char_buf = head->char_buf_ptr + head->read;
+                        flag_buf = head->flag_buf_ptr + head->read;
+                        head->read += count;
                         spin_unlock_irqrestore(&tty->buf.lock, flags);
                         disc->receive_buf(tty, char_buf, flag_buf, count);
                         spin_lock_irqsave(&tty->buf.lock, flags);
                 }
-                if (tbuf->active)
-                        break;
-                tty->buf.head = tbuf->next;
-                if (tty->buf.head == NULL)
-                        tty->buf.tail = NULL;
-                tty_buffer_free(tty, tbuf);
+                tty->buf.head = head;
         }
         spin_unlock_irqrestore(&tty->buf.lock, flags);
-out:
+
         tty_ldisc_deref(disc);
 }
 
@@ -2902,10 +2896,8 @@ void tty_flip_buffer_push(struct tty_struct *tty)
 {
         unsigned long flags;
         spin_lock_irqsave(&tty->buf.lock, flags);
-        if (tty->buf.tail != NULL) {
-                tty->buf.tail->active = 0;
+        if (tty->buf.tail != NULL)
                 tty->buf.tail->commit = tty->buf.tail->used;
-        }
         spin_unlock_irqrestore(&tty->buf.lock, flags);
 
         if (tty->low_latency)
diff --git a/drivers/char/watchdog/at91_wdt.c b/drivers/char/watchdog/at91_wdt.c
index ac83bc4b019a..00080655533d 100644
--- a/drivers/char/watchdog/at91_wdt.c
+++ b/drivers/char/watchdog/at91_wdt.c
@@ -17,14 +17,15 @@
 #include <linux/miscdevice.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
+#include <linux/platform_device.h>
 #include <linux/types.h>
 #include <linux/watchdog.h>
 #include <asm/bitops.h>
 #include <asm/uaccess.h>
 
 
-#define WDT_DEFAULT_TIME        5       /* 5 seconds */
-#define WDT_MAX_TIME            256     /* 256 seconds */
+#define WDT_DEFAULT_TIME        5       /* seconds */
+#define WDT_MAX_TIME            256     /* seconds */
 
 static int wdt_time = WDT_DEFAULT_TIME;
 static int nowayout = WATCHDOG_NOWAYOUT;
@@ -32,8 +33,10 @@ static int nowayout = WATCHDOG_NOWAYOUT;
 module_param(wdt_time, int, 0);
 MODULE_PARM_DESC(wdt_time, "Watchdog time in seconds. (default="__MODULE_STRING(WDT_DEFAULT_TIME) ")");
 
+#ifdef CONFIG_WATCHDOG_NOWAYOUT
 module_param(nowayout, int, 0);
 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+#endif
 
 
 static unsigned long at91wdt_busy;
@@ -138,7 +141,7 @@ static int at91_wdt_ioctl(struct inode *inode, struct file *file,
                 case WDIOC_SETTIMEOUT:
                         if (get_user(new_value, p))
                                 return -EFAULT;
-                                
+
                         if (at91_wdt_settimeout(new_value))
                                 return -EINVAL;
 
@@ -196,27 +199,84 @@ static struct miscdevice at91wdt_miscdev = {
         .fops           = &at91wdt_fops,
 };
 
-static int __init at91_wdt_init(void)
+static int __init at91wdt_probe(struct platform_device *pdev)
 {
         int res;
 
-        /* Check that the heartbeat value is within range; if not reset to the default */
-        if (at91_wdt_settimeout(wdt_time)) {
-                at91_wdt_settimeout(WDT_DEFAULT_TIME);
-                printk(KERN_INFO "at91_wdt: wdt_time value must be 1 <= wdt_time <= 256, using %d\n", wdt_time);
-        }
+        if (at91wdt_miscdev.dev)
+                return -EBUSY;
+        at91wdt_miscdev.dev = &pdev->dev;
 
         res = misc_register(&at91wdt_miscdev);
         if (res)
                 return res;
 
-        printk("AT91 Watchdog Timer enabled (%d seconds, nowayout=%d)\n", wdt_time, nowayout);
+        printk("AT91 Watchdog Timer enabled (%d seconds%s)\n", wdt_time, nowayout ? ", nowayout" : "");
         return 0;
 }
 
+static int __exit at91wdt_remove(struct platform_device *pdev)
+{
+        int res;
+
+        res = misc_deregister(&at91wdt_miscdev);
+        if (!res)
+                at91wdt_miscdev.dev = NULL;
+
+        return res;
+}
+
+static void at91wdt_shutdown(struct platform_device *pdev)
+{
+        at91_wdt_stop();
+}
+
+#ifdef CONFIG_PM
+
+static int at91wdt_suspend(struct platform_device *pdev, pm_message_t message)
+{
+        at91_wdt_stop();
+        return 0;
+}
+
+static int at91wdt_resume(struct platform_device *pdev)
+{
+        if (at91wdt_busy)
+                at91_wdt_start();
+                return 0;
+}
+
+#else
+#define at91wdt_suspend NULL
+#define at91wdt_resume  NULL
+#endif
+
+static struct platform_driver at91wdt_driver = {
+        .probe          = at91wdt_probe,
+        .remove         = __exit_p(at91wdt_remove),
+        .shutdown       = at91wdt_shutdown,
+        .suspend        = at91wdt_suspend,
+        .resume         = at91wdt_resume,
+        .driver         = {
+                .name   = "at91_wdt",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init at91_wdt_init(void)
+{
+        /* Check that the heartbeat value is within range; if not reset to the default */
+        if (at91_wdt_settimeout(wdt_time)) {
+                at91_wdt_settimeout(WDT_DEFAULT_TIME);
+                pr_info("at91_wdt: wdt_time value must be 1 <= wdt_time <= 256, using %d\n", wdt_time);
+        }
+
+        return platform_driver_register(&at91wdt_driver);
+}
+
 static void __exit at91_wdt_exit(void)
 {
-        misc_deregister(&at91wdt_miscdev);
+        platform_driver_unregister(&at91wdt_driver);
 }
 
 module_init(at91_wdt_init);
diff --git a/drivers/char/watchdog/i8xx_tco.c b/drivers/char/watchdog/i8xx_tco.c
index fa2ba9ebe42a..bfbdbbf3c2f2 100644
--- a/drivers/char/watchdog/i8xx_tco.c
+++ b/drivers/char/watchdog/i8xx_tco.c
@@ -205,6 +205,23 @@ static int tco_timer_set_heartbeat (int t)
         return 0;
 }
 
+static int tco_timer_get_timeleft (int *time_left)
+{
+        unsigned char val;
+
+        spin_lock(&tco_lock);
+
+        /* read the TCO Timer */
+        val = inb (TCO1_RLD);
+        val &= 0x3f;
+
+        spin_unlock(&tco_lock);
+
+        *time_left = (int)((val * 6) / 10);
+
+        return 0;
+}
+
 /*
  *      /dev/watchdog handling
  */
@@ -272,6 +289,7 @@ static int i8xx_tco_ioctl (struct inode *inode, struct file *file,
 {
         int new_options, retval = -EINVAL;
         int new_heartbeat;
+        int time_left;
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
         static struct watchdog_info ident = {
@@ -320,7 +338,7 @@ static int i8xx_tco_ioctl (struct inode *inode, struct file *file,
                                 return -EFAULT;
 
                         if (tco_timer_set_heartbeat(new_heartbeat))
-                            return -EINVAL;
+                                return -EINVAL;
 
                         tco_timer_keepalive ();
                         /* Fall */
@@ -329,6 +347,14 @@ static int i8xx_tco_ioctl (struct inode *inode, struct file *file,
                 case WDIOC_GETTIMEOUT:
                         return put_user(heartbeat, p);
 
+                case WDIOC_GETTIMELEFT:
+                {
+                        if (tco_timer_get_timeleft(&time_left))
+                                return -EINVAL;
+
+                        return put_user(time_left, p);
+                }
+
                 default:
                         return -ENOIOCTLCMD;
         }
diff --git a/drivers/char/watchdog/pcwd_pci.c b/drivers/char/watchdog/pcwd_pci.c
index 2451edbefece..1f40ecefbf72 100644
--- a/drivers/char/watchdog/pcwd_pci.c
+++ b/drivers/char/watchdog/pcwd_pci.c
@@ -21,7 +21,7 @@
  */
 
 /*
- *      A bells and whistles driver is available from: 
+ *      A bells and whistles driver is available from:
  *      http://www.kernel.org/pub/linux/kernel/people/wim/pcwd/pcwd_pci/
  *
  *      More info available at http://www.berkprod.com/ or http://www.pcwatchdog.com/
@@ -390,6 +390,24 @@ static int pcipcwd_get_temperature(int *temperature)
         return 0;
 }
 
+static int pcipcwd_get_timeleft(int *time_left)
+{
+        int msb;
+        int lsb;
+
+        /* Read the time that's left before rebooting */
+        /* Note: if the board is not yet armed then we will read 0xFFFF */
+        send_command(CMD_READ_WATCHDOG_TIMEOUT, &msb, &lsb);
+
+        *time_left = (msb << 8) + lsb;
+
+        if (debug >= VERBOSE)
+                printk(KERN_DEBUG PFX "Time left before next reboot: %d\n",
+                       *time_left);
+
+        return 0;
+}
+
 /*
  *      /dev/watchdog handling
  */
@@ -512,6 +530,16 @@ static int pcipcwd_ioctl(struct inode *inode, struct file *file,
                 case WDIOC_GETTIMEOUT:
                         return put_user(heartbeat, p);
 
+                case WDIOC_GETTIMELEFT:
+                {
+                        int time_left;
+
+                        if (pcipcwd_get_timeleft(&time_left))
+                                return -EFAULT;
+
+                        return put_user(time_left, p);
+                }
+
                 default:
                         return -ENOIOCTLCMD;
         }
diff --git a/drivers/char/watchdog/pcwd_usb.c b/drivers/char/watchdog/pcwd_usb.c
index 3fdfda9324fa..0d072bed501d 100644
--- a/drivers/char/watchdog/pcwd_usb.c
+++ b/drivers/char/watchdog/pcwd_usb.c
@@ -317,6 +317,19 @@ static int usb_pcwd_get_temperature(struct usb_pcwd_private *usb_pcwd, int *temp
         return 0;
 }
 
+static int usb_pcwd_get_timeleft(struct usb_pcwd_private *usb_pcwd, int *time_left)
+{
+        unsigned char msb, lsb;
+
+        /* Read the time that's left before rebooting */
+        /* Note: if the board is not yet armed then we will read 0xFFFF */
+        usb_pcwd_send_command(usb_pcwd, CMD_READ_WATCHDOG_TIMEOUT, &msb, &lsb);
+
+        *time_left = (msb << 8) + lsb;
+
+        return 0;
+}
+
 /*
  *      /dev/watchdog handling
  */
@@ -422,6 +435,16 @@ static int usb_pcwd_ioctl(struct inode *inode, struct file *file,
                 case WDIOC_GETTIMEOUT:
                         return put_user(heartbeat, p);
 
+                case WDIOC_GETTIMELEFT:
+                {
+                        int time_left;
+
+                        if (usb_pcwd_get_timeleft(usb_pcwd_device, &time_left))
+                                return -EFAULT;
+
+                        return put_user(time_left, p);
+                }
+
                 default:
                         return -ENOIOCTLCMD;
         }
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index 935cb2583770..26ceab1e90bb 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -505,7 +505,7 @@ static ide_startstop_t ide_ata_error(ide_drive_t *drive, struct request *rq, u8
                 }
         }
 
-        if ((stat & DRQ_STAT) && rq_data_dir(rq) == READ)
+        if ((stat & DRQ_STAT) && rq_data_dir(rq) == READ && hwif->err_stops_fifo == 0)
                 try_to_flush_leftover_data(drive);
 
         if (hwif->INB(IDE_STATUS_REG) & (BUSY_STAT|DRQ_STAT))
diff --git a/drivers/ide/ide-iops.c b/drivers/ide/ide-iops.c
index 97a49e77a8f1..32117f0ec5c0 100644
--- a/drivers/ide/ide-iops.c
+++ b/drivers/ide/ide-iops.c
@@ -597,6 +597,10 @@ u8 eighty_ninty_three (ide_drive_t *drive)
 {
         if(HWIF(drive)->udma_four == 0)
                 return 0;
+
+        /* Check for SATA but only if we are ATA5 or higher */
+        if (drive->id->hw_config == 0 && (drive->id->major_rev_num & 0x7FE0))
+                return 1;
         if (!(drive->id->hw_config & 0x6000))
                 return 0;
 #ifndef CONFIG_IDEDMA_IVB
diff --git a/drivers/ide/pci/aec62xx.c b/drivers/ide/pci/aec62xx.c
index c743e68c33aa..ff0cdc142f17 100644
--- a/drivers/ide/pci/aec62xx.c
+++ b/drivers/ide/pci/aec62xx.c
@@ -22,7 +22,7 @@ struct chipset_bus_clock_list_entry {
         u8 ultra_settings;
 };
 
-static struct chipset_bus_clock_list_entry aec6xxx_33_base [] = {
+static const struct chipset_bus_clock_list_entry aec6xxx_33_base [] = {
         {       XFER_UDMA_6,    0x31,   0x07    },
         {       XFER_UDMA_5,    0x31,   0x06    },
         {       XFER_UDMA_4,    0x31,   0x05    },
@@ -42,7 +42,7 @@ static struct chipset_bus_clock_list_entry aec6xxx_33_base [] = {
         {       0,              0x00,   0x00    }
 };
 
-static struct chipset_bus_clock_list_entry aec6xxx_34_base [] = {
+static const struct chipset_bus_clock_list_entry aec6xxx_34_base [] = {
         {       XFER_UDMA_6,    0x41,   0x06    },
         {       XFER_UDMA_5,    0x41,   0x05    },
         {       XFER_UDMA_4,    0x41,   0x04    },
@@ -425,12 +425,12 @@ static int __devinit aec62xx_init_one(struct pci_dev *dev, const struct pci_devi
         return d->init_setup(dev, d);
 }
 
-static struct pci_device_id aec62xx_pci_tbl[] = {
-        { PCI_VENDOR_ID_ARTOP, PCI_DEVICE_ID_ARTOP_ATP850UF, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
-        { PCI_VENDOR_ID_ARTOP, PCI_DEVICE_ID_ARTOP_ATP860,   PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
-        { PCI_VENDOR_ID_ARTOP, PCI_DEVICE_ID_ARTOP_ATP860R,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2 },
-        { PCI_VENDOR_ID_ARTOP, PCI_DEVICE_ID_ARTOP_ATP865,   PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3 },
-        { PCI_VENDOR_ID_ARTOP, PCI_DEVICE_ID_ARTOP_ATP865R,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
+static const struct pci_device_id aec62xx_pci_tbl[] = {
+        { PCI_DEVICE(PCI_VENDOR_ID_ARTOP, PCI_DEVICE_ID_ARTOP_ATP850UF), 0 },
+        { PCI_DEVICE(PCI_VENDOR_ID_ARTOP, PCI_DEVICE_ID_ARTOP_ATP860), 1 },
+        { PCI_DEVICE(PCI_VENDOR_ID_ARTOP, PCI_DEVICE_ID_ARTOP_ATP860R), 2 },
+        { PCI_DEVICE(PCI_VENDOR_ID_ARTOP, PCI_DEVICE_ID_ARTOP_ATP865), 3 },
+        { PCI_DEVICE(PCI_VENDOR_ID_ARTOP, PCI_DEVICE_ID_ARTOP_ATP865R), 4 },
         { 0, },
 };
 MODULE_DEVICE_TABLE(pci, aec62xx_pci_tbl);
diff --git a/drivers/ide/pci/cmd64x.c b/drivers/ide/pci/cmd64x.c
index 3d9c7afc8695..92b7b1549b16 100644
--- a/drivers/ide/pci/cmd64x.c
+++ b/drivers/ide/pci/cmd64x.c
@@ -190,14 +190,6 @@ static int cmd64x_get_info (char *buffer, char **addr, off_t offset, int count)
 #endif  /* defined(DISPLAY_CMD64X_TIMINGS) && defined(CONFIG_PROC_FS) */
 
 /*
- * Registers and masks for easy access by drive index:
- */
-#if 0
-static u8 prefetch_regs[4]  = {CNTRL, CNTRL, ARTTIM23, ARTTIM23};
-static u8 prefetch_masks[4] = {CNTRL_DIS_RA0, CNTRL_DIS_RA1, ARTTIM23_DIS_RA2, ARTTIM23_DIS_RA3};
-#endif
-
-/*
  * This routine writes the prepared setup/active/recovery counts
  * for a drive into the cmd646 chipset registers to active them.
  */
@@ -606,13 +598,6 @@ static unsigned int __devinit init_chipset_cmd64x(struct pci_dev *dev, const cha
         pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
         class_rev &= 0xff;
 
-#ifdef __i386__
-        if (dev->resource[PCI_ROM_RESOURCE].start) {
-                pci_write_config_dword(dev, PCI_ROM_ADDRESS, dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
-                printk(KERN_INFO "%s: ROM enabled at 0x%08lx\n", name, dev->resource[PCI_ROM_RESOURCE].start);
-        }
-#endif
-
         switch(dev->device) {
                 case PCI_DEVICE_ID_CMD_643:
                         break;
diff --git a/drivers/ide/pci/pdc202xx_new.c b/drivers/ide/pci/pdc202xx_new.c
index acd63173199b..2c9e938dd1cd 100644
--- a/drivers/ide/pci/pdc202xx_new.c
+++ b/drivers/ide/pci/pdc202xx_new.c
@@ -338,6 +338,8 @@ static void __devinit init_hwif_pdc202new(ide_hwif_t *hwif)
         hwif->ultra_mask = 0x7f;
         hwif->mwdma_mask = 0x07;
 
+        hwif->err_stops_fifo = 1;
+
         hwif->ide_dma_check = &pdcnew_config_drive_xfer_rate;
         hwif->ide_dma_lostirq = &pdcnew_ide_dma_lostirq;
         hwif->ide_dma_timeout = &pdcnew_ide_dma_timeout;
diff --git a/drivers/ide/pci/pdc202xx_old.c b/drivers/ide/pci/pdc202xx_old.c
index 22d17548ecdb..26bc688a1821 100644
--- a/drivers/ide/pci/pdc202xx_old.c
+++ b/drivers/ide/pci/pdc202xx_old.c
@@ -101,31 +101,6 @@ static const char *pdc_quirk_drives[] = {
 #define MC1             0x02    /* DMA"C" timing */
 #define MC0             0x01    /* DMA"C" timing */
 
-#if 0
-        unsigned long bibma  = pci_resource_start(dev, 4);
-        u8 hi = 0, lo = 0;
-
-        u8 sc1c = inb_p((u16)bibma + 0x1c); 
-        u8 sc1e = inb_p((u16)bibma + 0x1e);
-        u8 sc1f = inb_p((u16)bibma + 0x1f);
-
-        p += sprintf(p, "Host Mode                            : %s\n",
-                (sc1f & 0x08) ? "Tri-Stated" : "Normal");
-        p += sprintf(p, "Bus Clocking                         : %s\n",
-                ((sc1f & 0xC0) == 0xC0) ? "100 External" :
-                ((sc1f & 0x80) == 0x80) ? "66 External" :
-                ((sc1f & 0x40) == 0x40) ? "33 External" : "33 PCI Internal");
-        p += sprintf(p, "IO pad select                        : %s mA\n",
-                ((sc1c & 0x03) == 0x03) ? "10" :
-                ((sc1c & 0x02) == 0x02) ? "8" :
-                ((sc1c & 0x01) == 0x01) ? "6" :
-                ((sc1c & 0x00) == 0x00) ? "4" : "??");
-        hi = sc1e >> 4;
-        lo = sc1e & 0xf;
-        p += sprintf(p, "Status Polling Period                : %d\n", hi);
-        p += sprintf(p, "Interrupt Check Status Polling Delay : %d\n", lo);
-#endif
-
 static u8 pdc202xx_ratemask (ide_drive_t *drive)
 {
         u8 mode;
@@ -505,42 +480,13 @@ static void pdc202xx_reset (ide_drive_t *drive)
         
         pdc202xx_reset_host(hwif);
         pdc202xx_reset_host(mate);
-#if 0
-        /*
-         * FIXME: Have to kick all the drives again :-/
-         * What a pain in the ACE!
-         */
-        if (hwif->present) {
-                u16 hunit = 0;
-                for (hunit = 0; hunit < MAX_DRIVES; ++hunit) {
-                        ide_drive_t *hdrive = &hwif->drives[hunit];
-                        if (hdrive->present) {
-                                if (hwif->ide_dma_check)
-                                        hwif->ide_dma_check(hdrive);
-                                else
-                                        hwif->tuneproc(hdrive, 5);
-                        }
-                }
-        }
-        if (mate->present) {
-                u16 munit = 0;
-                for (munit = 0; munit < MAX_DRIVES; ++munit) {
-                        ide_drive_t *mdrive = &mate->drives[munit];
-                        if (mdrive->present) {
-                                if (mate->ide_dma_check) 
-                                        mate->ide_dma_check(mdrive);
-                                else
-                                        mate->tuneproc(mdrive, 5);
-                        }
-                }
-        }
-#else
         hwif->tuneproc(drive, 5);
-#endif
 }
 
-static unsigned int __devinit init_chipset_pdc202xx(struct pci_dev *dev, const char *name)
+static unsigned int __devinit init_chipset_pdc202xx(struct pci_dev *dev,
+                                                        const char *name)
 {
+        /* This doesn't appear needed */
         if (dev->resource[PCI_ROM_RESOURCE].start) {
                 pci_write_config_dword(dev, PCI_ROM_ADDRESS,
                         dev->resource[PCI_ROM_RESOURCE].start | PCI_ROM_ADDRESS_ENABLE);
@@ -548,30 +494,6 @@ static unsigned int __devinit init_chipset_pdc202xx(struct pci_dev *dev, const c
                         name, dev->resource[PCI_ROM_RESOURCE].start);
         }
 
-        /*
-         * software reset -  this is required because the bios
-         * will set UDMA timing on if the hdd supports it. The
-         * user may want to turn udma off. A bug in the pdc20262
-         * is that it cannot handle a downgrade in timing from
-         * UDMA to DMA. Disk accesses after issuing a set
-         * feature command will result in errors. A software
-         * reset leaves the timing registers intact,
-         * but resets the drives.
-         */
-#if 0
-        if ((dev->device == PCI_DEVICE_ID_PROMISE_20267) ||
-            (dev->device == PCI_DEVICE_ID_PROMISE_20265) ||
-            (dev->device == PCI_DEVICE_ID_PROMISE_20263) ||
-            (dev->device == PCI_DEVICE_ID_PROMISE_20262)) {
-                unsigned long high_16   = pci_resource_start(dev, 4);
-                byte udma_speed_flag    = inb(high_16 + 0x001f);
-                outb(udma_speed_flag | 0x10, high_16 + 0x001f);
-                mdelay(100);
-                outb(udma_speed_flag & ~0x10, high_16 + 0x001f);
-                mdelay(2000);   /* 2 seconds ?! */
-        }
-
-#endif
         return dev->irq;
 }
 
@@ -599,6 +521,8 @@ static void __devinit init_hwif_pdc202xx(ide_hwif_t *hwif)
         hwif->mwdma_mask = 0x07;
         hwif->swdma_mask = 0x07;
 
+        hwif->err_stops_fifo = 1;
+
         hwif->ide_dma_check = &pdc202xx_config_drive_xfer_rate;
         hwif->ide_dma_lostirq = &pdc202xx_ide_dma_lostirq;
         hwif->ide_dma_timeout = &pdc202xx_ide_dma_timeout;
@@ -687,19 +611,6 @@ static int __devinit init_setup_pdc202ata4(struct pci_dev *dev,
                                 "mirror fixed.\n", d->name);
                 }
         }
-
-#if 0
-        if (dev->device == PCI_DEVICE_ID_PROMISE_20262)
-        if (e->reg && (pci_read_config_byte(dev, e->reg, &tmp) ||
-             (tmp & e->mask) != e->val))
-
-        if (d->enablebits[0].reg != d->enablebits[1].reg) {
-                d->enablebits[0].reg    = d->enablebits[1].reg;
-                d->enablebits[0].mask   = d->enablebits[1].mask;
-                d->enablebits[0].val    = d->enablebits[1].val;
-        }
-#endif
-
         return ide_setup_pci_device(dev, d);
 }
 
@@ -714,22 +625,6 @@ static int __devinit init_setup_pdc20265(struct pci_dev *dev,
                         "attached to I2O RAID controller.\n");
                 return -ENODEV;
         }
-
-#if 0
-        {
-                u8 pri = 0, sec = 0;
-
-        if (e->reg && (pci_read_config_byte(dev, e->reg, &tmp) ||
-             (tmp & e->mask) != e->val))
-
-        if (d->enablebits[0].reg != d->enablebits[1].reg) {
-                d->enablebits[0].reg    = d->enablebits[1].reg;
-                d->enablebits[0].mask   = d->enablebits[1].mask;
-                d->enablebits[0].val    = d->enablebits[1].val;
-        }
-        }
-#endif
-
         return ide_setup_pci_device(dev, d);
 }
 
diff --git a/drivers/ide/pci/sc1200.c b/drivers/ide/pci/sc1200.c
index 24e21b2838c1..778b82ae964d 100644
--- a/drivers/ide/pci/sc1200.c
+++ b/drivers/ide/pci/sc1200.c
@@ -395,7 +395,6 @@ static int sc1200_resume (struct pci_dev *dev)
 {
         ide_hwif_t      *hwif = NULL;
 
-printk("SC1200: resume\n");
         pci_set_power_state(dev, PCI_D0);       // bring chip back from sleep state
         dev->current_state = PM_EVENT_ON;
         pci_enable_device(dev);
@@ -405,7 +404,6 @@ printk("SC1200: resume\n");
         while ((hwif = lookup_pci_dev(hwif, dev)) != NULL) {
                 unsigned int            basereg, r, d, format;
                 sc1200_saved_state_t    *ss = (sc1200_saved_state_t *)hwif->config_data;
-printk("%s: SC1200: resume\n", hwif->name);
 
                 //
                 // Restore timing registers:  this may be unnecessary if BIOS also does it
@@ -493,7 +491,7 @@ static int __devinit sc1200_init_one(struct pci_dev *dev, const struct pci_devic
 }
 
 static struct pci_device_id sc1200_pci_tbl[] = {
-        { PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_IDE), 0},
         { 0, },
 };
 MODULE_DEVICE_TABLE(pci, sc1200_pci_tbl);
diff --git a/drivers/ide/pci/serverworks.c b/drivers/ide/pci/serverworks.c
index 0d3073f4eab4..5100b827a935 100644
--- a/drivers/ide/pci/serverworks.c
+++ b/drivers/ide/pci/serverworks.c
@@ -123,11 +123,11 @@ static u8 svwks_csb_check (struct pci_dev *dev)
 }
 static int svwks_tune_chipset (ide_drive_t *drive, u8 xferspeed)
 {
-        u8 udma_modes[]         = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
-        u8 dma_modes[]          = { 0x77, 0x21, 0x20 };
-        u8 pio_modes[]          = { 0x5d, 0x47, 0x34, 0x22, 0x20 };
-        u8 drive_pci[]          = { 0x41, 0x40, 0x43, 0x42 };
-        u8 drive_pci2[]         = { 0x45, 0x44, 0x47, 0x46 };
+        static const u8 udma_modes[]            = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
+        static const u8 dma_modes[]             = { 0x77, 0x21, 0x20 };
+        static const u8 pio_modes[]             = { 0x5d, 0x47, 0x34, 0x22, 0x20 };
+        static const u8 drive_pci[]             = { 0x41, 0x40, 0x43, 0x42 };
+        static const u8 drive_pci2[]            = { 0x45, 0x44, 0x47, 0x46 };
 
         ide_hwif_t *hwif        = HWIF(drive);
         struct pci_dev *dev     = hwif->pci_dev;
@@ -392,16 +392,6 @@ static unsigned int __devinit init_chipset_svwks (struct pci_dev *dev, const cha
                         }
                         outb_p(0x06, 0x0c00);
                         dev->irq = inb_p(0x0c01);
-#if 0
-                        printk("%s: device class (0x%04x)\n",
-                                name, dev->class);
-                        if ((dev->class >> 8) != PCI_CLASS_STORAGE_IDE) {
-                                dev->class &= ~0x000F0F00;
-                //              dev->class |= ~0x00000400;
-                                dev->class |= ~0x00010100;
-                                /**/
-                        }
-#endif
                 } else {
                         struct pci_dev * findev = NULL;
                         u8 reg41 = 0;
@@ -452,7 +442,7 @@ static unsigned int __devinit init_chipset_svwks (struct pci_dev *dev, const cha
                 pci_write_config_byte(dev, 0x5A, btr);
         }
 
-        return (dev->irq) ? dev->irq : 0;
+        return dev->irq;
 }
 
 static unsigned int __devinit ata66_svwks_svwks (ide_hwif_t *hwif)
@@ -500,11 +490,6 @@ static unsigned int __devinit ata66_svwks (ide_hwif_t *hwif)
 {
         struct pci_dev *dev = hwif->pci_dev;
 
-        /* Per Specified Design by OEM, and ASIC Architect */
-        if ((dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE) ||
-            (dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2))
-                return 1;
-
         /* Server Works */
         if (dev->subsystem_vendor == PCI_VENDOR_ID_SERVERWORKS)
                 return ata66_svwks_svwks (hwif);
@@ -517,10 +502,14 @@ static unsigned int __devinit ata66_svwks (ide_hwif_t *hwif)
         if (dev->subsystem_vendor == PCI_VENDOR_ID_SUN)
                 return ata66_svwks_cobalt (hwif);
 
+        /* Per Specified Design by OEM, and ASIC Architect */
+        if ((dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE) ||
+            (dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2))
+                return 1;
+
         return 0;
 }
 
-#undef CAN_SW_DMA
 static void __devinit init_hwif_svwks (ide_hwif_t *hwif)
 {
         u8 dma_stat = 0;
@@ -537,9 +526,6 @@ static void __devinit init_hwif_svwks (ide_hwif_t *hwif)
                 hwif->ultra_mask = 0x3f;
 
         hwif->mwdma_mask = 0x07;
-#ifdef CAN_SW_DMA
-        hwif->swdma_mask = 0x07;
-#endif /* CAN_SW_DMA */
 
         hwif->autodma = 0;
 
@@ -562,8 +548,6 @@ static void __devinit init_hwif_svwks (ide_hwif_t *hwif)
         hwif->drives[1].autodma = (dma_stat & 0x40);
         hwif->drives[0].autotune = (!(dma_stat & 0x20));
         hwif->drives[1].autotune = (!(dma_stat & 0x40));
-//      hwif->drives[0].autodma = hwif->autodma;
-//      hwif->drives[1].autodma = hwif->autodma;
 }
 
 /*
@@ -593,11 +577,6 @@ static int __devinit init_setup_csb6 (struct pci_dev *dev, ide_pci_device_t *d)
                 if (dev->resource[0].start == 0x01f1)
                         d->bootable = ON_BOARD;
         }
-#if 0
-        if ((IDE_PCI_DEVID_EQ(d->devid, DEVID_CSB6) &&
-             (!(PCI_FUNC(dev->devfn) & 1)))
-                d->autodma = AUTODMA;
-#endif
 
         d->channels = ((dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE ||
                         dev->device == PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2) &&
@@ -671,11 +650,11 @@ static int __devinit svwks_init_one(struct pci_dev *dev, const struct pci_device
 }
 
 static struct pci_device_id svwks_pci_tbl[] = {
-        { PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_OSB4IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
-        { PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB5IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
-        { PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
-        { PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3},
-        { PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_HT1000IDE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4},
+        { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_OSB4IDE), 0},
+        { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB5IDE), 1},
+        { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6IDE), 2},
+        { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2), 3},
+        { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_HT1000IDE), 4},
         { 0, },
 };
 MODULE_DEVICE_TABLE(pci, svwks_pci_tbl);
diff --git a/drivers/ide/pci/siimage.c b/drivers/ide/pci/siimage.c
index f1ca154dd52c..72dade14c725 100644
--- a/drivers/ide/pci/siimage.c
+++ b/drivers/ide/pci/siimage.c
@@ -38,9 +38,6 @@
 
 #include <asm/io.h>
 
-#undef SIIMAGE_VIRTUAL_DMAPIO
-#undef SIIMAGE_LARGE_DMA
-
 /**
  *      pdev_is_sata            -       check if device is SATA
  *      @pdev:  PCI device to check
@@ -461,36 +458,6 @@ static int siimage_io_ide_dma_test_irq (ide_drive_t *drive)
         return 0;
 }
 
-#if 0
-/**
- *      siimage_mmio_ide_dma_count      -       DMA bytes done
- *      @drive
- *
- *      If we are doing VDMA the CMD680 requires a little bit
- *      of more careful handling and we have to read the counts
- *      off ourselves. For non VDMA life is normal.
- */
- 
-static int siimage_mmio_ide_dma_count (ide_drive_t *drive)
-{
-#ifdef SIIMAGE_VIRTUAL_DMAPIO
-        struct request *rq      = HWGROUP(drive)->rq;
-        ide_hwif_t *hwif        = HWIF(drive);
-        u32 count               = (rq->nr_sectors * SECTOR_SIZE);
-        u32 rcount              = 0;
-        unsigned long addr      = siimage_selreg(hwif, 0x1C);
-
-        hwif->OUTL(count, addr);
-        rcount = hwif->INL(addr);
-
-        printk("\n%s: count = %d, rcount = %d, nr_sectors = %lu\n",
-                drive->name, count, rcount, rq->nr_sectors);
-
-#endif /* SIIMAGE_VIRTUAL_DMAPIO */
-        return __ide_dma_count(drive);
-}
-#endif
-
 /**
  *      siimage_mmio_ide_dma_test_irq   -       check we caused an IRQ
  *      @drive: drive we are testing
@@ -512,12 +479,10 @@ static int siimage_mmio_ide_dma_test_irq (ide_drive_t *drive)
                         u32 sata_error = hwif->INL(SATA_ERROR_REG);
                         hwif->OUTL(sata_error, SATA_ERROR_REG);
                         watchdog = (sata_error & 0x00680000) ? 1 : 0;
-#if 1
                         printk(KERN_WARNING "%s: sata_error = 0x%08x, "
                                 "watchdog = %d, %s\n",
                                 drive->name, sata_error, watchdog,
                                 __FUNCTION__);
-#endif
 
                 } else {
                         watchdog = (ext_stat & 0x8000) ? 1 : 0;
@@ -863,7 +828,7 @@ static unsigned int __devinit init_chipset_siimage(struct pci_dev *dev, const ch
  *      time.
  *
  *      The hardware supports buffered taskfiles and also some rather nice
- *      extended PRD tables. Unfortunately right now we don't.
+ *      extended PRD tables. For better SI3112 support use the libata driver
  */
 
 static void __devinit init_mmio_iops_siimage(ide_hwif_t *hwif)
@@ -900,9 +865,6 @@ static void __devinit init_mmio_iops_siimage(ide_hwif_t *hwif)
          *      so we can't currently use it sanely since we want to
          *      use LBA48 mode.
          */     
-//      base += 0x10;
-//      hwif->no_lba48 = 1;
-
         hw.io_ports[IDE_DATA_OFFSET]    = base;
         hw.io_ports[IDE_ERROR_OFFSET]   = base + 1;
         hw.io_ports[IDE_NSECTOR_OFFSET] = base + 2;
@@ -936,15 +898,8 @@ static void __devinit init_mmio_iops_siimage(ide_hwif_t *hwif)
 
         base = (unsigned long) addr;
 
-#ifdef SIIMAGE_LARGE_DMA
-/* Watch the brackets - even Ken and Dennis get some language design wrong */
-        hwif->dma_base                  = base + (ch ? 0x18 : 0x10);
-        hwif->dma_base2                 = base + (ch ? 0x08 : 0x00);
-        hwif->dma_prdtable              = hwif->dma_base2 + 4;
-#else /* ! SIIMAGE_LARGE_DMA */
         hwif->dma_base                  = base + (ch ? 0x08 : 0x00);
         hwif->dma_base2                 = base + (ch ? 0x18 : 0x10);
-#endif /* SIIMAGE_LARGE_DMA */
         hwif->mmio                      = 2;
 }
 
@@ -1052,9 +1007,16 @@ static void __devinit init_hwif_siimage(ide_hwif_t *hwif)
         hwif->reset_poll = &siimage_reset_poll;
         hwif->pre_reset = &siimage_pre_reset;
 
-        if(is_sata(hwif))
+        if(is_sata(hwif)) {
+                static int first = 1;
+
                 hwif->busproc   = &siimage_busproc;
 
+                if (first) {
+                        printk(KERN_INFO "siimage: For full SATA support you should use the libata sata_sil module.\n");
+                        first = 0;
+                }
+        }
         if (!hwif->dma_base) {
                 hwif->drives[0].autotune = 1;
                 hwif->drives[1].autotune = 1;
@@ -1121,10 +1083,10 @@ static int __devinit siimage_init_one(struct pci_dev *dev, const struct pci_devi
 }
 
 static struct pci_device_id siimage_pci_tbl[] = {
-        { PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_SII_680,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        { PCI_DEVICE(PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_SII_680), 0},
 #ifdef CONFIG_BLK_DEV_IDE_SATA
-        { PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_SII_3112, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
-        { PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_SII_1210SA, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
+        { PCI_DEVICE(PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_SII_3112), 1},
+        { PCI_DEVICE(PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_SII_1210SA), 2},
 #endif
         { 0, },
 };
diff --git a/drivers/ide/pci/sl82c105.c b/drivers/ide/pci/sl82c105.c
index 8a5c7b286b2b..900301e43818 100644
--- a/drivers/ide/pci/sl82c105.c
+++ b/drivers/ide/pci/sl82c105.c
@@ -447,7 +447,6 @@ static void __devinit init_hwif_sl82c105(ide_hwif_t *hwif)
                 printk("    %s: Winbond 553 bridge revision %d, BM-DMA disabled\n",
                        hwif->name, rev);
         } else {
-#ifdef CONFIG_BLK_DEV_IDEDMA
                 dma_state |= 0x60;
 
                 hwif->atapi_dma = 1;
@@ -468,7 +467,6 @@ static void __devinit init_hwif_sl82c105(ide_hwif_t *hwif)
 
                 if (hwif->mate)
                         hwif->serialized = hwif->mate->serialized = 1;
-#endif /* CONFIG_BLK_DEV_IDEDMA */
         }
         hwif->OUTB(dma_state, hwif->dma_base + 2);
 }
@@ -489,7 +487,7 @@ static int __devinit sl82c105_init_one(struct pci_dev *dev, const struct pci_dev
 }
 
 static struct pci_device_id sl82c105_pci_tbl[] = {
-        { PCI_VENDOR_ID_WINBOND, PCI_DEVICE_ID_WINBOND_82C105, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        { PCI_DEVICE(PCI_VENDOR_ID_WINBOND, PCI_DEVICE_ID_WINBOND_82C105), 0},
         { 0, },
 };
 MODULE_DEVICE_TABLE(pci, sl82c105_pci_tbl);
diff --git a/drivers/ide/pci/slc90e66.c b/drivers/ide/pci/slc90e66.c
index 5112c726633b..0968f6bc669a 100644
--- a/drivers/ide/pci/slc90e66.c
+++ b/drivers/ide/pci/slc90e66.c
@@ -72,7 +72,8 @@ static void slc90e66_tune_drive (ide_drive_t *drive, u8 pio)
         u16 master_data;
         u8 slave_data;
                                  /* ISP  RTC */
-        u8 timings[][2] = { { 0, 0 },
+        static const u8 timings[][2]= {
+                                    { 0, 0 },
                                     { 0, 0 },
                                     { 1, 0 },
                                     { 2, 1 },
@@ -119,7 +120,6 @@ static int slc90e66_tune_chipset (ide_drive_t *drive, u8 xferspeed)
         pci_read_config_word(dev, 0x4a, &reg4a);
 
         switch(speed) {
-#ifdef CONFIG_BLK_DEV_IDEDMA
                 case XFER_UDMA_4:       u_speed = 4 << (drive->dn * 4); break;
                 case XFER_UDMA_3:       u_speed = 3 << (drive->dn * 4); break;
                 case XFER_UDMA_2:       u_speed = 2 << (drive->dn * 4); break;
@@ -128,7 +128,6 @@ static int slc90e66_tune_chipset (ide_drive_t *drive, u8 xferspeed)
                 case XFER_MW_DMA_2:
                 case XFER_MW_DMA_1:
                 case XFER_SW_DMA_2:     break;
-#endif /* CONFIG_BLK_DEV_IDEDMA */
                 case XFER_PIO_4:
                 case XFER_PIO_3:
                 case XFER_PIO_2:
@@ -156,7 +155,6 @@ static int slc90e66_tune_chipset (ide_drive_t *drive, u8 xferspeed)
         return (ide_config_drive_speed(drive, speed));
 }
 
-#ifdef CONFIG_BLK_DEV_IDEDMA
 static int slc90e66_config_drive_for_dma (ide_drive_t *drive)
 {
         u8 speed = ide_dma_speed(drive, slc90e66_ratemask(drive));
@@ -194,7 +192,6 @@ fast_ata_pio:
         /* IORDY not supported */
         return 0;
 }
-#endif /* CONFIG_BLK_DEV_IDEDMA */
 
 static void __devinit init_hwif_slc90e66 (ide_hwif_t *hwif)
 {
@@ -222,7 +219,6 @@ static void __devinit init_hwif_slc90e66 (ide_hwif_t *hwif)
         hwif->mwdma_mask = 0x07;
         hwif->swdma_mask = 0x07;
 
-#ifdef CONFIG_BLK_DEV_IDEDMA 
         if (!(hwif->udma_four))
                 /* bit[0(1)]: 0:80, 1:40 */
                 hwif->udma_four = (reg47 & mask) ? 0 : 1;
@@ -232,7 +228,6 @@ static void __devinit init_hwif_slc90e66 (ide_hwif_t *hwif)
                 hwif->autodma = 1;
         hwif->drives[0].autodma = hwif->autodma;
         hwif->drives[1].autodma = hwif->autodma;
-#endif /* !CONFIG_BLK_DEV_IDEDMA */
 }
 
 static ide_pci_device_t slc90e66_chipset __devinitdata = {
@@ -250,7 +245,7 @@ static int __devinit slc90e66_init_one(struct pci_dev *dev, const struct pci_dev
 }
 
 static struct pci_device_id slc90e66_pci_tbl[] = {
-        { PCI_VENDOR_ID_EFAR, PCI_DEVICE_ID_EFAR_SLC90E66_1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        { PCI_DEVICE(PCI_VENDOR_ID_EFAR, PCI_DEVICE_ID_EFAR_SLC90E66_1), 0},
         { 0, },
 };
 MODULE_DEVICE_TABLE(pci, slc90e66_pci_tbl);
diff --git a/drivers/input/joystick/db9.c b/drivers/input/joystick/db9.c
index 6f31f054d1bb..5080e15c6d30 100644
--- a/drivers/input/joystick/db9.c
+++ b/drivers/input/joystick/db9.c
@@ -584,7 +584,7 @@ static struct db9 __init *db9_probe(int parport, int mode)
                 goto err_out;
         }
 
-        if (db9_mode[mode].bidirectional && !(pp->modes & PARPORT_MODE_TRISTATE)) {
+        if (db9_mode->bidirectional && !(pp->modes & PARPORT_MODE_TRISTATE)) {
                 printk(KERN_ERR "db9.c: specified parport is not bidirectional\n");
                 err = -EINVAL;
                 goto err_put_pp;
diff --git a/drivers/input/keyboard/atkbd.c b/drivers/input/keyboard/atkbd.c
index ffde8f86e0fb..ce1f10e8984b 100644
--- a/drivers/input/keyboard/atkbd.c
+++ b/drivers/input/keyboard/atkbd.c
@@ -459,7 +459,7 @@ static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data,
                         }
 
                         input_regs(dev, regs);
-                        input_report_key(dev, keycode, value);
+                        input_event(dev, EV_KEY, keycode, value);
                         input_sync(dev);
 
                         if (value && add_release_event) {
diff --git a/drivers/input/misc/wistron_btns.c b/drivers/input/misc/wistron_btns.c
index e4e5be111c96..ccf0faeee5c1 100644
--- a/drivers/input/misc/wistron_btns.c
+++ b/drivers/input/misc/wistron_btns.c
@@ -285,6 +285,15 @@ static struct key_entry keymap_fujitsu_n3510[] = {
         { KE_END, 0 }
 };
 
+static struct key_entry keymap_wistron_ms2111[] = {
+        { KE_KEY,  0x11, KEY_PROG1 },
+        { KE_KEY,  0x12, KEY_PROG2 },
+        { KE_KEY,  0x13, KEY_PROG3 },
+        { KE_KEY,  0x31, KEY_MAIL },
+        { KE_KEY,  0x36, KEY_WWW },
+        { KE_END,  0 }
+};
+
 static struct key_entry keymap_wistron_ms2141[] = {
         { KE_KEY,  0x11, KEY_PROG1 },
         { KE_KEY,  0x12, KEY_PROG2 },
@@ -326,6 +335,7 @@ static struct key_entry keymap_aopen_1559as[] = {
         { KE_WIFI, 0x30, 0 },
         { KE_KEY,  0x31, KEY_MAIL },
         { KE_KEY,  0x36, KEY_WWW },
+        { KE_END,  0 },
 };
 
 /*
@@ -388,6 +398,15 @@ static struct dmi_system_id dmi_ids[] = {
                 },
                 .driver_data = keymap_aopen_1559as
         },
+        {
+                .callback = dmi_matched,
+                .ident = "Medion MD 9783",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "MEDIONNB"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "MD 9783"),
+                },
+                .driver_data = keymap_wistron_ms2111
+        },
         { NULL, }
 };
 
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index bccff400b198..f2fc81a9074d 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -162,6 +162,16 @@ config RTC_DRV_PCF8583
           This driver can also be built as a module. If so, the module
           will be called rtc-pcf8583.
 
+config RTC_DRV_RS5C348
+        tristate "Ricoh RS5C348A/B"
+        depends on RTC_CLASS && SPI
+        help
+          If you say yes here you get support for the
+          Ricoh RS5C348A and RS5C348B RTC chips.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-rs5c348.
+
 config RTC_DRV_RS5C372
         tristate "Ricoh RS5C372A/B"
         depends on RTC_CLASS && I2C
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 900d210dd1a2..da5e38774e13 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -19,6 +19,7 @@ obj-$(CONFIG_RTC_DRV_DS1742)	+= rtc-ds1742.o
 obj-$(CONFIG_RTC_DRV_PCF8563)   += rtc-pcf8563.o
 obj-$(CONFIG_RTC_DRV_PCF8583)   += rtc-pcf8583.o
 obj-$(CONFIG_RTC_DRV_RS5C372)   += rtc-rs5c372.o
+obj-$(CONFIG_RTC_DRV_RS5C348)   += rtc-rs5c348.o
 obj-$(CONFIG_RTC_DRV_M48T86)    += rtc-m48t86.o
 obj-$(CONFIG_RTC_DRV_DS1553)    += rtc-ds1553.o
 obj-$(CONFIG_RTC_DRV_EP93XX)    += rtc-ep93xx.o
diff --git a/drivers/rtc/rtc-rs5c348.c b/drivers/rtc/rtc-rs5c348.c
new file mode 100644
index 000000000000..0964d1dba925
--- /dev/null
+++ b/drivers/rtc/rtc-rs5c348.c
@@ -0,0 +1,246 @@
+/*
+ * A SPI driver for the Ricoh RS5C348 RTC
+ *
+ * Copyright (C) 2006 Atsushi Nemoto <anemo@mba.ocn.ne.jp>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * The board specific init code should provide characteristics of this
+ * device:
+ *     Mode 1 (High-Active, Shift-Then-Sample), High Avtive CS
+ */
+
+#include <linux/bcd.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/string.h>
+#include <linux/rtc.h>
+#include <linux/workqueue.h>
+#include <linux/spi/spi.h>
+
+#define DRV_VERSION "0.1"
+
+#define RS5C348_REG_SECS        0
+#define RS5C348_REG_MINS        1
+#define RS5C348_REG_HOURS       2
+#define RS5C348_REG_WDAY        3
+#define RS5C348_REG_DAY 4
+#define RS5C348_REG_MONTH       5
+#define RS5C348_REG_YEAR        6
+#define RS5C348_REG_CTL1        14
+#define RS5C348_REG_CTL2        15
+
+#define RS5C348_SECS_MASK       0x7f
+#define RS5C348_MINS_MASK       0x7f
+#define RS5C348_HOURS_MASK      0x3f
+#define RS5C348_WDAY_MASK       0x03
+#define RS5C348_DAY_MASK        0x3f
+#define RS5C348_MONTH_MASK      0x1f
+
+#define RS5C348_BIT_PM  0x20    /* REG_HOURS */
+#define RS5C348_BIT_Y2K 0x80    /* REG_MONTH */
+#define RS5C348_BIT_24H 0x20    /* REG_CTL1 */
+#define RS5C348_BIT_XSTP        0x10    /* REG_CTL2 */
+#define RS5C348_BIT_VDET        0x40    /* REG_CTL2 */
+
+#define RS5C348_CMD_W(addr)     (((addr) << 4) | 0x08)  /* single write */
+#define RS5C348_CMD_R(addr)     (((addr) << 4) | 0x0c)  /* single read */
+#define RS5C348_CMD_MW(addr)    (((addr) << 4) | 0x00)  /* burst write */
+#define RS5C348_CMD_MR(addr)    (((addr) << 4) | 0x04)  /* burst read */
+
+struct rs5c348_plat_data {
+        struct rtc_device *rtc;
+        int rtc_24h;
+};
+
+static int
+rs5c348_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct rs5c348_plat_data *pdata = spi->dev.platform_data;
+        u8 txbuf[5+7], *txp;
+        int ret;
+
+        /* Transfer 5 bytes before writing SEC.  This gives 31us for carry. */
+        txp = txbuf;
+        txbuf[0] = RS5C348_CMD_R(RS5C348_REG_CTL2); /* cmd, ctl2 */
+        txbuf[1] = 0;   /* dummy */
+        txbuf[2] = RS5C348_CMD_R(RS5C348_REG_CTL2); /* cmd, ctl2 */
+        txbuf[3] = 0;   /* dummy */
+        txbuf[4] = RS5C348_CMD_MW(RS5C348_REG_SECS); /* cmd, sec, ... */
+        txp = &txbuf[5];
+        txp[RS5C348_REG_SECS] = BIN2BCD(tm->tm_sec);
+        txp[RS5C348_REG_MINS] = BIN2BCD(tm->tm_min);
+        if (pdata->rtc_24h) {
+                txp[RS5C348_REG_HOURS] = BIN2BCD(tm->tm_hour);
+        } else {
+                /* hour 0 is AM12, noon is PM12 */
+                txp[RS5C348_REG_HOURS] = BIN2BCD((tm->tm_hour + 11) % 12 + 1) |
+                        (tm->tm_hour >= 12 ? RS5C348_BIT_PM : 0);
+        }
+        txp[RS5C348_REG_WDAY] = BIN2BCD(tm->tm_wday);
+        txp[RS5C348_REG_DAY] = BIN2BCD(tm->tm_mday);
+        txp[RS5C348_REG_MONTH] = BIN2BCD(tm->tm_mon + 1) |
+                (tm->tm_year >= 100 ? RS5C348_BIT_Y2K : 0);
+        txp[RS5C348_REG_YEAR] = BIN2BCD(tm->tm_year % 100);
+        /* write in one transfer to avoid data inconsistency */
+        ret = spi_write_then_read(spi, txbuf, sizeof(txbuf), NULL, 0);
+        udelay(62);     /* Tcsr 62us */
+        return ret;
+}
+
+static int
+rs5c348_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct rs5c348_plat_data *pdata = spi->dev.platform_data;
+        u8 txbuf[5], rxbuf[7];
+        int ret;
+
+        /* Transfer 5 byte befores reading SEC.  This gives 31us for carry. */
+        txbuf[0] = RS5C348_CMD_R(RS5C348_REG_CTL2); /* cmd, ctl2 */
+        txbuf[1] = 0;   /* dummy */
+        txbuf[2] = RS5C348_CMD_R(RS5C348_REG_CTL2); /* cmd, ctl2 */
+        txbuf[3] = 0;   /* dummy */
+        txbuf[4] = RS5C348_CMD_MR(RS5C348_REG_SECS); /* cmd, sec, ... */
+
+        /* read in one transfer to avoid data inconsistency */
+        ret = spi_write_then_read(spi, txbuf, sizeof(txbuf),
+                                  rxbuf, sizeof(rxbuf));
+        udelay(62);     /* Tcsr 62us */
+        if (ret < 0)
+                return ret;
+
+        tm->tm_sec = BCD2BIN(rxbuf[RS5C348_REG_SECS] & RS5C348_SECS_MASK);
+        tm->tm_min = BCD2BIN(rxbuf[RS5C348_REG_MINS] & RS5C348_MINS_MASK);
+        tm->tm_hour = BCD2BIN(rxbuf[RS5C348_REG_HOURS] & RS5C348_HOURS_MASK);
+        if (!pdata->rtc_24h) {
+                tm->tm_hour %= 12;
+                if (rxbuf[RS5C348_REG_HOURS] & RS5C348_BIT_PM)
+                        tm->tm_hour += 12;
+        }
+        tm->tm_wday = BCD2BIN(rxbuf[RS5C348_REG_WDAY] & RS5C348_WDAY_MASK);
+        tm->tm_mday = BCD2BIN(rxbuf[RS5C348_REG_DAY] & RS5C348_DAY_MASK);
+        tm->tm_mon =
+                BCD2BIN(rxbuf[RS5C348_REG_MONTH] & RS5C348_MONTH_MASK) - 1;
+        /* year is 1900 + tm->tm_year */
+        tm->tm_year = BCD2BIN(rxbuf[RS5C348_REG_YEAR]) +
+                ((rxbuf[RS5C348_REG_MONTH] & RS5C348_BIT_Y2K) ? 100 : 0);
+
+        if (rtc_valid_tm(tm) < 0) {
+                dev_err(&spi->dev, "retrieved date/time is not valid.\n");
+                rtc_time_to_tm(0, tm);
+        }
+
+        return 0;
+}
+
+static struct rtc_class_ops rs5c348_rtc_ops = {
+        .read_time      = rs5c348_rtc_read_time,
+        .set_time       = rs5c348_rtc_set_time,
+};
+
+static struct spi_driver rs5c348_driver;
+
+static int __devinit rs5c348_probe(struct spi_device *spi)
+{
+        int ret;
+        struct rtc_device *rtc;
+        struct rs5c348_plat_data *pdata;
+
+        pdata = kzalloc(sizeof(struct rs5c348_plat_data), GFP_KERNEL);
+        if (!pdata)
+                return -ENOMEM;
+        spi->dev.platform_data = pdata;
+
+        /* Check D7 of SECOND register */
+        ret = spi_w8r8(spi, RS5C348_CMD_R(RS5C348_REG_SECS));
+        if (ret < 0 || (ret & 0x80)) {
+                dev_err(&spi->dev, "not found.\n");
+                goto kfree_exit;
+        }
+
+        dev_info(&spi->dev, "chip found, driver version " DRV_VERSION "\n");
+        dev_info(&spi->dev, "spiclk %u KHz.\n",
+                 (spi->max_speed_hz + 500) / 1000);
+
+        /* turn RTC on if it was not on */
+        ret = spi_w8r8(spi, RS5C348_CMD_R(RS5C348_REG_CTL2));
+        if (ret < 0)
+                goto kfree_exit;
+        if (ret & (RS5C348_BIT_XSTP | RS5C348_BIT_VDET)) {
+                u8 buf[2];
+                if (ret & RS5C348_BIT_VDET)
+                        dev_warn(&spi->dev, "voltage-low detected.\n");
+                buf[0] = RS5C348_CMD_W(RS5C348_REG_CTL2);
+                buf[1] = 0;
+                ret = spi_write_then_read(spi, buf, sizeof(buf), NULL, 0);
+                if (ret < 0)
+                        goto kfree_exit;
+        }
+
+        ret = spi_w8r8(spi, RS5C348_CMD_R(RS5C348_REG_CTL1));
+        if (ret < 0)
+                goto kfree_exit;
+        if (ret & RS5C348_BIT_24H)
+                pdata->rtc_24h = 1;
+
+        rtc = rtc_device_register(rs5c348_driver.driver.name, &spi->dev,
+                                  &rs5c348_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rtc)) {
+                ret = PTR_ERR(rtc);
+                goto kfree_exit;
+        }
+
+        pdata->rtc = rtc;
+
+        return 0;
+ kfree_exit:
+        kfree(pdata);
+        return ret;
+}
+
+static int __devexit rs5c348_remove(struct spi_device *spi)
+{
+        struct rs5c348_plat_data *pdata = spi->dev.platform_data;
+        struct rtc_device *rtc = pdata->rtc;
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+        kfree(pdata);
+        return 0;
+}
+
+static struct spi_driver rs5c348_driver = {
+        .driver = {
+                .name   = "rs5c348",
+                .bus    = &spi_bus_type,
+                .owner  = THIS_MODULE,
+        },
+        .probe  = rs5c348_probe,
+        .remove = __devexit_p(rs5c348_remove),
+};
+
+static __init int rs5c348_init(void)
+{
+        return spi_register_driver(&rs5c348_driver);
+}
+
+static __exit void rs5c348_exit(void)
+{
+        spi_unregister_driver(&rs5c348_driver);
+}
+
+module_init(rs5c348_init);
+module_exit(rs5c348_exit);
+
+MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
+MODULE_DESCRIPTION("Ricoh RS5C348 RTC driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/serial/68328serial.c b/drivers/serial/68328serial.c
index b88a7c1158af..bff94541991c 100644
--- a/drivers/serial/68328serial.c
+++ b/drivers/serial/68328serial.c
@@ -131,17 +131,6 @@ static int m68328_console_baud    = CONSOLE_BAUD_RATE;
 static int m68328_console_cbaud   = DEFAULT_CBAUD;
 
 
-/*
- * tmp_buf is used as a temporary buffer by serial_write.  We need to
- * lock it in case the memcpy_fromfs blocks while swapping in a page,
- * and some other program tries to do a serial write at the same time.
- * Since the lock will only come under contention when the system is
- * swapping and available memory is low, it makes sense to share one
- * buffer across all the serial ports, since it significantly saves
- * memory if large numbers of serial ports are open.
- */
-static unsigned char tmp_buf[SERIAL_XMIT_SIZE]; /* This is cheating */
-
 static inline int serial_paranoia_check(struct m68k_serial *info,
                                         char *name, const char *routine)
 {
@@ -211,16 +200,16 @@ static void rs_stop(struct tty_struct *tty)
         if (serial_paranoia_check(info, tty->name, "rs_stop"))
                 return;
         
-        save_flags(flags); cli();
+        local_irq_save(flags);
         uart->ustcnt &= ~USTCNT_TXEN;
-        restore_flags(flags);
+        local_irq_restore(flags);
 }
 
 static void rs_put_char(char ch)
 {
         int flags, loops = 0;
 
-        save_flags(flags); cli();
+        local_irq_save(flags);
 
         while (!(UTX & UTX_TX_AVAIL) && (loops < 1000)) {
                 loops++;
@@ -229,7 +218,7 @@ static void rs_put_char(char ch)
 
         UTX_TXDATA = ch;
         udelay(5);
-        restore_flags(flags);
+        local_irq_restore(flags);
 }
 
 static void rs_start(struct tty_struct *tty)
@@ -241,7 +230,7 @@ static void rs_start(struct tty_struct *tty)
         if (serial_paranoia_check(info, tty->name, "rs_start"))
                 return;
         
-        save_flags(flags); cli();
+        local_irq_save(flags);
         if (info->xmit_cnt && info->xmit_buf && !(uart->ustcnt & USTCNT_TXEN)) {
 #ifdef USE_INTS
                 uart->ustcnt |= USTCNT_TXEN | USTCNT_TX_INTR_MASK;
@@ -249,7 +238,7 @@ static void rs_start(struct tty_struct *tty)
                 uart->ustcnt |= USTCNT_TXEN;
 #endif
         }
-        restore_flags(flags);
+        local_irq_restore(flags);
 }
 
 /* Drop into either the boot monitor or kadb upon receiving a break
@@ -327,14 +316,6 @@ static void receive_chars(struct m68k_serial *info, struct pt_regs *regs,
                 if(!tty)
                         goto clear_and_exit;
                 
-                /*
-                 * Make sure that we do not overflow the buffer
-                 */
-                if (tty_request_buffer_room(tty, 1) == 0) {
-                        tty_schedule_flip(tty);
-                        return;
-                }
-
                 flag = TTY_NORMAL;
 
                 if(rx & URX_PARITY_ERROR) {
@@ -473,7 +454,7 @@ static int startup(struct m68k_serial * info)
                         return -ENOMEM;
         }
 
-        save_flags(flags); cli();
+        local_irq_save(flags);
 
         /*
          * Clear the FIFO buffers and disable them
@@ -506,7 +487,7 @@ static int startup(struct m68k_serial * info)
         change_speed(info);
 
         info->flags |= S_INITIALIZED;
-        restore_flags(flags);
+        local_irq_restore(flags);
         return 0;
 }
 
@@ -523,7 +504,7 @@ static void shutdown(struct m68k_serial * info)
         if (!(info->flags & S_INITIALIZED))
                 return;
 
-        save_flags(flags); cli(); /* Disable interrupts */
+        local_irq_save(flags);
         
         if (info->xmit_buf) {
                 free_page((unsigned long) info->xmit_buf);
@@ -534,7 +515,7 @@ static void shutdown(struct m68k_serial * info)
                 set_bit(TTY_IO_ERROR, &info->tty->flags);
         
         info->flags &= ~S_INITIALIZED;
-        restore_flags(flags);
+        local_irq_restore(flags);
 }
 
 struct {
@@ -655,24 +636,24 @@ static void rs_fair_output(void)
         if (info == 0) return;
         if (info->xmit_buf == 0) return;
 
-        save_flags(flags);  cli();
+        local_irq_save(flags);
         left = info->xmit_cnt;
         while (left != 0) {
                 c = info->xmit_buf[info->xmit_tail];
                 info->xmit_tail = (info->xmit_tail+1) & (SERIAL_XMIT_SIZE-1);
                 info->xmit_cnt--;
-                restore_flags(flags);
+                local_irq_restore(flags);
 
                 rs_put_char(c);
 
-                save_flags(flags);  cli();
+                local_irq_save(flags);
                 left = min(info->xmit_cnt, left-1);
         }
 
         /* Last character is being transmitted now (hopefully). */
         udelay(5);
 
-        restore_flags(flags);
+        local_irq_restore(flags);
         return;
 }
 
@@ -720,11 +701,11 @@ static void rs_flush_chars(struct tty_struct *tty)
 #endif
 
         /* Enable transmitter */
-        save_flags(flags); cli();
+        local_irq_save(flags);
 
         if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
                         !info->xmit_buf) {
-                restore_flags(flags);
+                local_irq_restore(flags);
                 return;
         }
 
@@ -749,7 +730,7 @@ static void rs_flush_chars(struct tty_struct *tty)
         while (!(uart->utx.w & UTX_TX_AVAIL)) udelay(5);
         }
 #endif
-        restore_flags(flags);
+        local_irq_restore(flags);
 }
 
 extern void console_printn(const char * b, int count);
@@ -768,18 +749,22 @@ static int rs_write(struct tty_struct * tty,
         if (!tty || !info->xmit_buf)
                 return 0;
 
-        save_flags(flags);
+        local_save_flags(flags);
         while (1) {
-                cli();          
+                local_irq_disable();            
                 c = min_t(int, count, min(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
                                    SERIAL_XMIT_SIZE - info->xmit_head));
+                local_irq_restore(flags);
+
                 if (c <= 0)
                         break;
 
                 memcpy(info->xmit_buf + info->xmit_head, buf, c);
+
+                local_irq_disable();
                 info->xmit_head = (info->xmit_head + c) & (SERIAL_XMIT_SIZE-1);
                 info->xmit_cnt += c;
-                restore_flags(flags);
+                local_irq_restore(flags);
                 buf += c;
                 count -= c;
                 total += c;
@@ -787,7 +772,7 @@ static int rs_write(struct tty_struct * tty,
 
         if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped) {
                 /* Enable transmitter */
-                cli();          
+                local_irq_disable();            
 #ifndef USE_INTS
                 while(info->xmit_cnt) {
 #endif
@@ -807,9 +792,9 @@ static int rs_write(struct tty_struct * tty,
 #ifndef USE_INTS
                 }
 #endif
-                restore_flags(flags);
+                local_irq_restore(flags);
         }
-        restore_flags(flags);
+
         return total;
 }
 
@@ -838,12 +823,13 @@ static int rs_chars_in_buffer(struct tty_struct *tty)
 static void rs_flush_buffer(struct tty_struct *tty)
 {
         struct m68k_serial *info = (struct m68k_serial *)tty->driver_data;
+        unsigned long flags;
                                 
         if (serial_paranoia_check(info, tty->name, "rs_flush_buffer"))
                 return;
-        cli();
+        local_irq_save(flags);
         info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
-        sti();
+        local_irq_restore(flags);
         tty_wakeup(tty);
 }
 
@@ -973,14 +959,15 @@ static int get_lsr_info(struct m68k_serial * info, unsigned int *value)
         m68328_uart *uart = &uart_addr[info->line];
 #endif
         unsigned char status;
+        unsigned long flags;
 
-        cli();
+        local_irq_save(flags);
 #ifdef CONFIG_SERIAL_68328_RTS_CTS
         status = (uart->utx.w & UTX_CTS_STAT) ? 1 : 0;
 #else
         status = 0;
 #endif
-        sti();
+        local_irq_restore(flags);
         put_user(status,value);
         return 0;
 }
@@ -994,14 +981,13 @@ static void send_break(struct m68k_serial * info, unsigned int duration)
         unsigned long flags;
         if (!info->port)
                 return;
-        save_flags(flags);
-        cli();
+        local_irq_save(flags);
 #ifdef USE_INTS 
         uart->utx.w |= UTX_SEND_BREAK;
         msleep_interruptible(duration);
         uart->utx.w &= ~UTX_SEND_BREAK;
 #endif          
-        restore_flags(flags);
+        local_irq_restore(flags);
 }
 
 static int rs_ioctl(struct tty_struct *tty, struct file * file,
@@ -1060,7 +1046,7 @@ static int rs_ioctl(struct tty_struct *tty, struct file * file,
                                                (struct serial_struct *) arg);
                 case TIOCSERGETLSR: /* Get line status register */
                         if (access_ok(VERIFY_WRITE, (void *) arg,
-                                                sizeof(unsigned int));
+                                                sizeof(unsigned int)))
                                 return get_lsr_info(info, (unsigned int *) arg);
                         return -EFAULT;
                 case TIOCSERGSTRUCT:
@@ -1113,10 +1099,10 @@ static void rs_close(struct tty_struct *tty, struct file * filp)
         if (!info || serial_paranoia_check(info, tty->name, "rs_close"))
                 return;
         
-        save_flags(flags); cli();
+        local_irq_save(flags);
         
         if (tty_hung_up_p(filp)) {
-                restore_flags(flags);
+                local_irq_restore(flags);
                 return;
         }
         
@@ -1138,7 +1124,7 @@ static void rs_close(struct tty_struct *tty, struct file * filp)
                 info->count = 0;
         }
         if (info->count) {
-                restore_flags(flags);
+                local_irq_restore(flags);
                 return;
         }
         info->flags |= S_CLOSING;
@@ -1186,7 +1172,7 @@ static void rs_close(struct tty_struct *tty, struct file * filp)
         }
         info->flags &= ~(S_NORMAL_ACTIVE|S_CLOSING);
         wake_up_interruptible(&info->close_wait);
-        restore_flags(flags);
+        local_irq_restore(flags);
 }
 
 /*
@@ -1262,9 +1248,9 @@ static int block_til_ready(struct tty_struct *tty, struct file * filp,
         info->count--;
         info->blocked_open++;
         while (1) {
-                cli();
+                local_irq_disable();
                 m68k_rtsdtr(info, 1);
-                sti();
+                local_irq_enable();
                 current->state = TASK_INTERRUPTIBLE;
                 if (tty_hung_up_p(filp) ||
                     !(info->flags & S_INITIALIZED)) {
@@ -1444,7 +1430,7 @@ rs68328_init(void)
                 return -ENOMEM;
         }
 
-        save_flags(flags); cli();
+        local_irq_save(flags);
 
         for(i=0;i<NR_PORTS;i++) {
 
@@ -1489,7 +1475,7 @@ rs68328_init(void)
                     serial_pm[i]->data = info;
 #endif
         }
-        restore_flags(flags);
+        local_irq_restore(flags);
         return 0;
 }
 
diff --git a/drivers/serial/crisv10.c b/drivers/serial/crisv10.c
index 89700141f87e..5cacc5e74a92 100644
--- a/drivers/serial/crisv10.c
+++ b/drivers/serial/crisv10.c
@@ -2573,12 +2573,6 @@ static void flush_to_flip_buffer(struct e100_serial *info)
 
         DFLIP(
           if (1) {
-
-                  if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
-                          DEBUG_LOG(info->line, "*** TTY_DONT_FLIP set flip.count %i ***\n", tty->flip.count);
-                          DEBUG_LOG(info->line, "*** recv_cnt %i\n", info->recv_cnt);
-                  } else {
-                  }
                   DEBUG_LOG(info->line, "*** rxtot %i\n", info->icount.rx);
                   DEBUG_LOG(info->line, "ldisc %lu\n", tty->ldisc.chars_in_buffer(tty));
                   DEBUG_LOG(info->line, "room  %lu\n", tty->ldisc.receive_room(tty));
diff --git a/drivers/serial/jsm/jsm_tty.c b/drivers/serial/jsm/jsm_tty.c
index 7d823705193c..f8262e6ad8d3 100644
--- a/drivers/serial/jsm/jsm_tty.c
+++ b/drivers/serial/jsm/jsm_tty.c
@@ -589,13 +589,6 @@ void jsm_input(struct jsm_channel *ch)
         ld = tty_ldisc_ref(tp);
 
         /*
-         * If the DONT_FLIP flag is on, don't flush our buffer, and act
-         * like the ld doesn't have any space to put the data right now.
-         */
-        if (test_bit(TTY_DONT_FLIP, &tp->flags))
-                len = 0;
-
-        /*
          * If we were unable to get a reference to the ld,
          * don't flush our buffer, and act like the ld doesn't
          * have any space to put the data right now.
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index 1cea4a6799fe..ed1cdf6ac8f3 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -210,6 +210,7 @@ spi_new_device(struct spi_master *master, struct spi_board_info *chip)
         proxy->master = master;
         proxy->chip_select = chip->chip_select;
         proxy->max_speed_hz = chip->max_speed_hz;
+        proxy->mode = chip->mode;
         proxy->irq = chip->irq;
         proxy->modalias = chip->modalias;
 
diff --git a/drivers/usb/serial/ir-usb.c b/drivers/usb/serial/ir-usb.c
index 9432c7302275..d7f3f736a692 100644
--- a/drivers/usb/serial/ir-usb.c
+++ b/drivers/usb/serial/ir-usb.c
@@ -453,8 +453,7 @@ static void ir_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
                         tty = port->tty;
 
                         /*
-                         *      FIXME: must not do this in IRQ context,
-                         *      must honour TTY_DONT_FLIP
+                         *      FIXME: must not do this in IRQ context
                          */
                         tty->ldisc.receive_buf(
                                 tty,
diff --git a/drivers/video/aty/radeon_backlight.c b/drivers/video/aty/radeon_backlight.c
index 7de66b855d4e..1755dddf1899 100644
--- a/drivers/video/aty/radeon_backlight.c
+++ b/drivers/video/aty/radeon_backlight.c
@@ -40,14 +40,14 @@ static int radeon_bl_get_level_brightness(struct radeon_bl_privdata *pdata,
 
         mutex_unlock(&info->bl_mutex);
 
-        if (pdata->negative)
-                rlevel = MAX_RADEON_LEVEL - rlevel;
-
         if (rlevel < 0)
                 rlevel = 0;
         else if (rlevel > MAX_RADEON_LEVEL)
                 rlevel = MAX_RADEON_LEVEL;
 
+        if (pdata->negative)
+                rlevel = MAX_RADEON_LEVEL - rlevel;
+
         return rlevel;
 }
 
diff --git a/fs/9p/mux.c b/fs/9p/mux.c
index 12e1baa4508d..8d45ed668837 100644
--- a/fs/9p/mux.c
+++ b/fs/9p/mux.c
@@ -932,6 +932,8 @@ v9fs_mux_rpc(struct v9fs_mux_data *m, struct v9fs_fcall *tc,
                                         r.rcall || r.err);
                         } while (!r.rcall && !r.err && err==-ERESTARTSYS &&
                                 m->trans->status==Connected && !m->err);
+
+                        err = -ERESTARTSYS;
                 }
                 sigpending = 1;
         }
diff --git a/fs/9p/v9fs_vfs.h b/fs/9p/v9fs_vfs.h
index f867b8d3e973..450b0c1b385e 100644
--- a/fs/9p/v9fs_vfs.h
+++ b/fs/9p/v9fs_vfs.h
@@ -38,7 +38,7 @@
  */
 
 extern struct file_system_type v9fs_fs_type;
-extern struct address_space_operations v9fs_addr_operations;
+extern const struct address_space_operations v9fs_addr_operations;
 extern const struct file_operations v9fs_file_operations;
 extern const struct file_operations v9fs_dir_operations;
 extern struct dentry_operations v9fs_dentry_operations;
diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c
index efda46fb64d9..d4f0aa3c87f2 100644
--- a/fs/9p/vfs_addr.c
+++ b/fs/9p/vfs_addr.c
@@ -103,6 +103,6 @@ UnmapAndUnlock:
         return retval;
 }
 
-struct address_space_operations v9fs_addr_operations = {
+const struct address_space_operations v9fs_addr_operations = {
       .readpage = v9fs_vfs_readpage,
 };
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index 5c6bdf82146c..2f580a197b8d 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -300,7 +300,7 @@ clunk_fid:
         fid = V9FS_NOFID;
 
 put_fid:
-        if (fid >= 0)
+        if (fid != V9FS_NOFID)
                 v9fs_put_idpool(fid, &v9ses->fidpool);
 
         kfree(fcall);
diff --git a/fs/adfs/inode.c b/fs/adfs/inode.c
index a02802a30798..534f3eecc985 100644
--- a/fs/adfs/inode.c
+++ b/fs/adfs/inode.c
@@ -72,7 +72,7 @@ static sector_t _adfs_bmap(struct address_space *mapping, sector_t block)
         return generic_block_bmap(mapping, block, adfs_get_block);
 }
 
-static struct address_space_operations adfs_aops = {
+static const struct address_space_operations adfs_aops = {
         .readpage       = adfs_readpage,
         .writepage      = adfs_writepage,
         .sync_page      = block_sync_page,
diff --git a/fs/affs/affs.h b/fs/affs/affs.h
index a43a876742b8..0ddd4cc0d1a0 100644
--- a/fs/affs/affs.h
+++ b/fs/affs/affs.h
@@ -195,9 +195,9 @@ extern struct inode_operations   affs_symlink_inode_operations;
 extern const struct file_operations      affs_file_operations;
 extern const struct file_operations      affs_file_operations_ofs;
 extern const struct file_operations      affs_dir_operations;
-extern struct address_space_operations   affs_symlink_aops;
-extern struct address_space_operations   affs_aops;
-extern struct address_space_operations   affs_aops_ofs;
+extern const struct address_space_operations     affs_symlink_aops;
+extern const struct address_space_operations     affs_aops;
+extern const struct address_space_operations     affs_aops_ofs;
 
 extern struct dentry_operations  affs_dentry_operations;
 extern struct dentry_operations  affs_dentry_operations_intl;
diff --git a/fs/affs/file.c b/fs/affs/file.c
index 7076262af39b..3de8590e4f6a 100644
--- a/fs/affs/file.c
+++ b/fs/affs/file.c
@@ -406,7 +406,7 @@ static sector_t _affs_bmap(struct address_space *mapping, sector_t block)
 {
         return generic_block_bmap(mapping,block,affs_get_block);
 }
-struct address_space_operations affs_aops = {
+const struct address_space_operations affs_aops = {
         .readpage = affs_readpage,
         .writepage = affs_writepage,
         .sync_page = block_sync_page,
@@ -759,7 +759,7 @@ out:
         goto done;
 }
 
-struct address_space_operations affs_aops_ofs = {
+const struct address_space_operations affs_aops_ofs = {
         .readpage = affs_readpage_ofs,
         //.writepage = affs_writepage_ofs,
         //.sync_page = affs_sync_page_ofs,
diff --git a/fs/affs/symlink.c b/fs/affs/symlink.c
index 426f0f094f23..f802256a5933 100644
--- a/fs/affs/symlink.c
+++ b/fs/affs/symlink.c
@@ -66,7 +66,7 @@ fail:
         return err;
 }
 
-struct address_space_operations affs_symlink_aops = {
+const struct address_space_operations affs_symlink_aops = {
         .readpage       = affs_symlink_readpage,
 };
 
diff --git a/fs/afs/file.c b/fs/afs/file.c
index 7bb716887e29..67d6634101fd 100644
--- a/fs/afs/file.c
+++ b/fs/afs/file.c
@@ -35,7 +35,7 @@ struct inode_operations afs_file_inode_operations = {
         .getattr        = afs_inode_getattr,
 };
 
-struct address_space_operations afs_fs_aops = {
+const struct address_space_operations afs_fs_aops = {
         .readpage       = afs_file_readpage,
         .sync_page      = block_sync_page,
         .set_page_dirty = __set_page_dirty_nobuffers,
diff --git a/fs/afs/internal.h b/fs/afs/internal.h
index 72febdf9a35a..e88b3b65ae49 100644
--- a/fs/afs/internal.h
+++ b/fs/afs/internal.h
@@ -69,7 +69,7 @@ extern const struct file_operations afs_dir_file_operations;
 /*
  * file.c
  */
-extern struct address_space_operations afs_fs_aops;
+extern const struct address_space_operations afs_fs_aops;
 extern struct inode_operations afs_file_inode_operations;
 
 #ifdef AFS_CACHING_SUPPORT
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index 08201fab26cd..a83e889a97cd 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -73,7 +73,7 @@ static struct inode_operations befs_dir_inode_operations = {
         .lookup         = befs_lookup,
 };
 
-static struct address_space_operations befs_aops = {
+static const struct address_space_operations befs_aops = {
         .readpage       = befs_readpage,
         .sync_page      = block_sync_page,
         .bmap           = befs_bmap,
diff --git a/fs/bfs/bfs.h b/fs/bfs/bfs.h
index 9d791004b21c..31973bbbf057 100644
--- a/fs/bfs/bfs.h
+++ b/fs/bfs/bfs.h
@@ -50,7 +50,7 @@ static inline struct bfs_inode_info *BFS_I(struct inode *inode)
 /* file.c */
 extern struct inode_operations bfs_file_inops;
 extern const struct file_operations bfs_file_operations;
-extern struct address_space_operations bfs_aops;
+extern const struct address_space_operations bfs_aops;
 
 /* dir.c */
 extern struct inode_operations bfs_dir_inops;
diff --git a/fs/bfs/file.c b/fs/bfs/file.c
index d83cd74a2e4e..3d5aca28a0a0 100644
--- a/fs/bfs/file.c
+++ b/fs/bfs/file.c
@@ -153,7 +153,7 @@ static sector_t bfs_bmap(struct address_space *mapping, sector_t block)
         return generic_block_bmap(mapping, block, bfs_get_block);
 }
 
-struct address_space_operations bfs_aops = {
+const struct address_space_operations bfs_aops = {
         .readpage       = bfs_readpage,
         .writepage      = bfs_writepage,
         .sync_page      = block_sync_page,
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 028d9fb9c2d5..7f7600e2381c 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -1095,7 +1095,7 @@ static long block_ioctl(struct file *file, unsigned cmd, unsigned long arg)
         return blkdev_ioctl(file->f_mapping->host, file, cmd, arg);
 }
 
-struct address_space_operations def_blk_aops = {
+const struct address_space_operations def_blk_aops = {
         .readpage       = blkdev_readpage,
         .writepage      = blkdev_writepage,
         .sync_page      = block_sync_page,
diff --git a/fs/buffer.c b/fs/buffer.c
index f23bb647db47..e9994722f4a3 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -2598,7 +2598,7 @@ int nobh_truncate_page(struct address_space *mapping, loff_t from)
         unsigned offset = from & (PAGE_CACHE_SIZE-1);
         unsigned to;
         struct page *page;
-        struct address_space_operations *a_ops = mapping->a_ops;
+        const struct address_space_operations *a_ops = mapping->a_ops;
         char *kaddr;
         int ret = 0;
 
diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
index a6384d83fdef..8f75c6f24701 100644
--- a/fs/cifs/cifsfs.h
+++ b/fs/cifs/cifsfs.h
@@ -32,8 +32,8 @@
 #define TRUE 1
 #endif
 
-extern struct address_space_operations cifs_addr_ops;
-extern struct address_space_operations cifs_addr_ops_smallbuf;
+extern const struct address_space_operations cifs_addr_ops;
+extern const struct address_space_operations cifs_addr_ops_smallbuf;
 
 /* Functions related to super block operations */
 extern struct super_operations cifs_super_ops;
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index e9c1573f6aa7..5861eb42e626 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -1942,7 +1942,7 @@ static int cifs_prepare_write(struct file *file, struct page *page,
         return 0;
 }
 
-struct address_space_operations cifs_addr_ops = {
+const struct address_space_operations cifs_addr_ops = {
         .readpage = cifs_readpage,
         .readpages = cifs_readpages,
         .writepage = cifs_writepage,
@@ -1959,7 +1959,7 @@ struct address_space_operations cifs_addr_ops = {
  * contain the header plus one complete page of data.  Otherwise, we need
  * to leave cifs_readpages out of the address space operations.
  */
-struct address_space_operations cifs_addr_ops_smallbuf = {
+const struct address_space_operations cifs_addr_ops_smallbuf = {
         .readpage = cifs_readpage,
         .writepage = cifs_writepage,
         .writepages = cifs_writepages,
diff --git a/fs/coda/symlink.c b/fs/coda/symlink.c
index b35e5bbd9c99..76e00a65a75b 100644
--- a/fs/coda/symlink.c
+++ b/fs/coda/symlink.c
@@ -50,6 +50,6 @@ fail:
         return error;
 }
 
-struct address_space_operations coda_symlink_aops = {
+const struct address_space_operations coda_symlink_aops = {
         .readpage       = coda_symlink_filler,
 };
diff --git a/fs/configfs/inode.c b/fs/configfs/inode.c
index c153bd9534cb..e14488ca6411 100644
--- a/fs/configfs/inode.c
+++ b/fs/configfs/inode.c
@@ -38,7 +38,7 @@
 
 extern struct super_block * configfs_sb;
 
-static struct address_space_operations configfs_aops = {
+static const struct address_space_operations configfs_aops = {
         .readpage       = simple_readpage,
         .prepare_write  = simple_prepare_write,
         .commit_write   = simple_commit_write
diff --git a/fs/cramfs/inode.c b/fs/cramfs/inode.c
index c45d73860803..223c0431042d 100644
--- a/fs/cramfs/inode.c
+++ b/fs/cramfs/inode.c
@@ -30,7 +30,7 @@
 static struct super_operations cramfs_ops;
 static struct inode_operations cramfs_dir_inode_operations;
 static const struct file_operations cramfs_directory_operations;
-static struct address_space_operations cramfs_aops;
+static const struct address_space_operations cramfs_aops;
 
 static DEFINE_MUTEX(read_mutex);
 
@@ -501,7 +501,7 @@ static int cramfs_readpage(struct file *file, struct page * page)
         return 0;
 }
 
-static struct address_space_operations cramfs_aops = {
+static const struct address_space_operations cramfs_aops = {
         .readpage = cramfs_readpage
 };
 
diff --git a/fs/efs/inode.c b/fs/efs/inode.c
index 180607f9314d..174696f9bf14 100644
--- a/fs/efs/inode.c
+++ b/fs/efs/inode.c
@@ -21,7 +21,7 @@ static sector_t _efs_bmap(struct address_space *mapping, sector_t block)
 {
         return generic_block_bmap(mapping,block,efs_get_block);
 }
-static struct address_space_operations efs_aops = {
+static const struct address_space_operations efs_aops = {
         .readpage = efs_readpage,
         .sync_page = block_sync_page,
         .bmap = _efs_bmap
diff --git a/fs/efs/symlink.c b/fs/efs/symlink.c
index 3d9a350e3e7f..e249cf733a6b 100644
--- a/fs/efs/symlink.c
+++ b/fs/efs/symlink.c
@@ -53,6 +53,6 @@ fail:
         return err;
 }
 
-struct address_space_operations efs_symlink_aops = {
+const struct address_space_operations efs_symlink_aops = {
         .readpage       = efs_symlink_readpage
 };
diff --git a/fs/ext2/ext2.h b/fs/ext2/ext2.h
index 9f74a62be555..e65a019fc7a5 100644
--- a/fs/ext2/ext2.h
+++ b/fs/ext2/ext2.h
@@ -162,9 +162,9 @@ extern const struct file_operations ext2_file_operations;
 extern const struct file_operations ext2_xip_file_operations;
 
 /* inode.c */
-extern struct address_space_operations ext2_aops;
-extern struct address_space_operations ext2_aops_xip;
-extern struct address_space_operations ext2_nobh_aops;
+extern const struct address_space_operations ext2_aops;
+extern const struct address_space_operations ext2_aops_xip;
+extern const struct address_space_operations ext2_nobh_aops;
 
 /* namei.c */
 extern struct inode_operations ext2_dir_inode_operations;
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index 04af9c45dce2..fb4d3220eb8d 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -684,7 +684,7 @@ ext2_writepages(struct address_space *mapping, struct writeback_control *wbc)
         return mpage_writepages(mapping, wbc, ext2_get_block);
 }
 
-struct address_space_operations ext2_aops = {
+const struct address_space_operations ext2_aops = {
         .readpage               = ext2_readpage,
         .readpages              = ext2_readpages,
         .writepage              = ext2_writepage,
@@ -697,12 +697,12 @@ struct address_space_operations ext2_aops = {
         .migratepage            = buffer_migrate_page,
 };
 
-struct address_space_operations ext2_aops_xip = {
+const struct address_space_operations ext2_aops_xip = {
         .bmap                   = ext2_bmap,
         .get_xip_page           = ext2_get_xip_page,
 };
 
-struct address_space_operations ext2_nobh_aops = {
+const struct address_space_operations ext2_nobh_aops = {
         .readpage               = ext2_readpage,
         .readpages              = ext2_readpages,
         .writepage              = ext2_nobh_writepage,
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index 0321e1b9034a..f804d5e9d60c 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -1698,7 +1698,7 @@ static int ext3_journalled_set_page_dirty(struct page *page)
         return __set_page_dirty_nobuffers(page);
 }
 
-static struct address_space_operations ext3_ordered_aops = {
+static const struct address_space_operations ext3_ordered_aops = {
         .readpage       = ext3_readpage,
         .readpages      = ext3_readpages,
         .writepage      = ext3_ordered_writepage,
@@ -1712,7 +1712,7 @@ static struct address_space_operations ext3_ordered_aops = {
         .migratepage    = buffer_migrate_page,
 };
 
-static struct address_space_operations ext3_writeback_aops = {
+static const struct address_space_operations ext3_writeback_aops = {
         .readpage       = ext3_readpage,
         .readpages      = ext3_readpages,
         .writepage      = ext3_writeback_writepage,
@@ -1726,7 +1726,7 @@ static struct address_space_operations ext3_writeback_aops = {
         .migratepage    = buffer_migrate_page,
 };
 
-static struct address_space_operations ext3_journalled_aops = {
+static const struct address_space_operations ext3_journalled_aops = {
         .readpage       = ext3_readpage,
         .readpages      = ext3_readpages,
         .writepage      = ext3_journalled_writepage,
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index 7c35d582ec10..31b7174176ba 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -196,7 +196,7 @@ static sector_t _fat_bmap(struct address_space *mapping, sector_t block)
         return generic_block_bmap(mapping, block, fat_get_block);
 }
 
-static struct address_space_operations fat_aops = {
+static const struct address_space_operations fat_aops = {
         .readpage       = fat_readpage,
         .readpages      = fat_readpages,
         .writepage      = fat_writepage,
diff --git a/fs/freevxfs/vxfs_immed.c b/fs/freevxfs/vxfs_immed.c
index 6f5df1700e95..4e25f3fbed86 100644
--- a/fs/freevxfs/vxfs_immed.c
+++ b/fs/freevxfs/vxfs_immed.c
@@ -56,7 +56,7 @@ struct inode_operations vxfs_immed_symlink_iops = {
 /*
  * Adress space operations for immed files and directories.
  */
-struct address_space_operations vxfs_immed_aops = {
+const struct address_space_operations vxfs_immed_aops = {
         .readpage =             vxfs_immed_readpage,
 };
 
diff --git a/fs/freevxfs/vxfs_inode.c b/fs/freevxfs/vxfs_inode.c
index f544aae9169f..ca6a39714771 100644
--- a/fs/freevxfs/vxfs_inode.c
+++ b/fs/freevxfs/vxfs_inode.c
@@ -41,8 +41,8 @@
 #include "vxfs_extern.h"
 
 
-extern struct address_space_operations vxfs_aops;
-extern struct address_space_operations vxfs_immed_aops;
+extern const struct address_space_operations vxfs_aops;
+extern const struct address_space_operations vxfs_immed_aops;
 
 extern struct inode_operations vxfs_immed_symlink_iops;
 
@@ -295,7 +295,7 @@ vxfs_read_inode(struct inode *ip)
 {
         struct super_block              *sbp = ip->i_sb;
         struct vxfs_inode_info          *vip;
-        struct address_space_operations *aops;
+        const struct address_space_operations   *aops;
         ino_t                           ino = ip->i_ino;
 
         if (!(vip = __vxfs_iget(ino, VXFS_SBI(sbp)->vsi_ilist)))
diff --git a/fs/freevxfs/vxfs_subr.c b/fs/freevxfs/vxfs_subr.c
index c1be118fc067..decac62efe57 100644
--- a/fs/freevxfs/vxfs_subr.c
+++ b/fs/freevxfs/vxfs_subr.c
@@ -42,7 +42,7 @@
 static int              vxfs_readpage(struct file *, struct page *);
 static sector_t         vxfs_bmap(struct address_space *, sector_t);
 
-struct address_space_operations vxfs_aops = {
+const struct address_space_operations vxfs_aops = {
         .readpage =             vxfs_readpage,
         .bmap =                 vxfs_bmap,
         .sync_page =            block_sync_page,
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 28aa81eae2cc..63614ed16336 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -770,7 +770,7 @@ static const struct file_operations fuse_direct_io_file_operations = {
         /* no mmap and sendfile */
 };
 
-static struct address_space_operations fuse_file_aops  = {
+static const struct address_space_operations fuse_file_aops  = {
         .readpage       = fuse_readpage,
         .prepare_write  = fuse_prepare_write,
         .commit_write   = fuse_commit_write,
diff --git a/fs/hfs/hfs_fs.h b/fs/hfs/hfs_fs.h
index 3ed8663a8db1..735332dfd1b8 100644
--- a/fs/hfs/hfs_fs.h
+++ b/fs/hfs/hfs_fs.h
@@ -182,8 +182,8 @@ extern void hfs_file_truncate(struct inode *);
 extern int hfs_get_block(struct inode *, sector_t, struct buffer_head *, int);
 
 /* inode.c */
-extern struct address_space_operations hfs_aops;
-extern struct address_space_operations hfs_btree_aops;
+extern const struct address_space_operations hfs_aops;
+extern const struct address_space_operations hfs_btree_aops;
 
 extern struct inode *hfs_new_inode(struct inode *, struct qstr *, int);
 extern void hfs_inode_write_fork(struct inode *, struct hfs_extent *, __be32 *, __be32 *);
diff --git a/fs/hfs/inode.c b/fs/hfs/inode.c
index 2d4ced22201b..315cf44a90b2 100644
--- a/fs/hfs/inode.c
+++ b/fs/hfs/inode.c
@@ -114,7 +114,7 @@ static int hfs_writepages(struct address_space *mapping,
         return mpage_writepages(mapping, wbc, hfs_get_block);
 }
 
-struct address_space_operations hfs_btree_aops = {
+const struct address_space_operations hfs_btree_aops = {
         .readpage       = hfs_readpage,
         .writepage      = hfs_writepage,
         .sync_page      = block_sync_page,
@@ -124,7 +124,7 @@ struct address_space_operations hfs_btree_aops = {
         .releasepage    = hfs_releasepage,
 };
 
-struct address_space_operations hfs_aops = {
+const struct address_space_operations hfs_aops = {
         .readpage       = hfs_readpage,
         .writepage      = hfs_writepage,
         .sync_page      = block_sync_page,
diff --git a/fs/hfsplus/hfsplus_fs.h b/fs/hfsplus/hfsplus_fs.h
index 7ae393637a0c..8a1ca5ef7ada 100644
--- a/fs/hfsplus/hfsplus_fs.h
+++ b/fs/hfsplus/hfsplus_fs.h
@@ -323,8 +323,8 @@ int hfsplus_file_extend(struct inode *);
 void hfsplus_file_truncate(struct inode *);
 
 /* inode.c */
-extern struct address_space_operations hfsplus_aops;
-extern struct address_space_operations hfsplus_btree_aops;
+extern const struct address_space_operations hfsplus_aops;
+extern const struct address_space_operations hfsplus_btree_aops;
 
 void hfsplus_inode_read_fork(struct inode *, struct hfsplus_fork_raw *);
 void hfsplus_inode_write_fork(struct inode *, struct hfsplus_fork_raw *);
diff --git a/fs/hfsplus/inode.c b/fs/hfsplus/inode.c
index acf66dba3e01..924ecdef8091 100644
--- a/fs/hfsplus/inode.c
+++ b/fs/hfsplus/inode.c
@@ -109,7 +109,7 @@ static int hfsplus_writepages(struct address_space *mapping,
         return mpage_writepages(mapping, wbc, hfsplus_get_block);
 }
 
-struct address_space_operations hfsplus_btree_aops = {
+const struct address_space_operations hfsplus_btree_aops = {
         .readpage       = hfsplus_readpage,
         .writepage      = hfsplus_writepage,
         .sync_page      = block_sync_page,
@@ -119,7 +119,7 @@ struct address_space_operations hfsplus_btree_aops = {
         .releasepage    = hfsplus_releasepage,
 };
 
-struct address_space_operations hfsplus_aops = {
+const struct address_space_operations hfsplus_aops = {
         .readpage       = hfsplus_readpage,
         .writepage      = hfsplus_writepage,
         .sync_page      = block_sync_page,
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index 8e0d37743e7c..b82e3d9c8790 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -54,7 +54,7 @@ static int append = 0;
 
 static struct inode_operations hostfs_iops;
 static struct inode_operations hostfs_dir_iops;
-static struct address_space_operations hostfs_link_aops;
+static const struct address_space_operations hostfs_link_aops;
 
 #ifndef MODULE
 static int __init hostfs_args(char *options, int *add)
@@ -518,7 +518,7 @@ int hostfs_commit_write(struct file *file, struct page *page, unsigned from,
         return(err);
 }
 
-static struct address_space_operations hostfs_aops = {
+static const struct address_space_operations hostfs_aops = {
         .writepage      = hostfs_writepage,
         .readpage       = hostfs_readpage,
         .set_page_dirty = __set_page_dirty_nobuffers,
@@ -935,7 +935,7 @@ int hostfs_link_readpage(struct file *file, struct page *page)
         return(err);
 }
 
-static struct address_space_operations hostfs_link_aops = {
+static const struct address_space_operations hostfs_link_aops = {
         .readpage       = hostfs_link_readpage,
 };
 
diff --git a/fs/hpfs/file.c b/fs/hpfs/file.c
index d3b9fffe45a1..d9eb19b7b8ae 100644
--- a/fs/hpfs/file.c
+++ b/fs/hpfs/file.c
@@ -99,7 +99,7 @@ static sector_t _hpfs_bmap(struct address_space *mapping, sector_t block)
 {
         return generic_block_bmap(mapping,block,hpfs_get_block);
 }
-struct address_space_operations hpfs_aops = {
+const struct address_space_operations hpfs_aops = {
         .readpage = hpfs_readpage,
         .writepage = hpfs_writepage,
         .sync_page = block_sync_page,
diff --git a/fs/hpfs/hpfs_fn.h b/fs/hpfs/hpfs_fn.h
index 29b7a3e55173..f687d54ed442 100644
--- a/fs/hpfs/hpfs_fn.h
+++ b/fs/hpfs/hpfs_fn.h
@@ -268,7 +268,7 @@ void hpfs_set_ea(struct inode *, struct fnode *, char *, char *, int);
 int hpfs_file_fsync(struct file *, struct dentry *, int);
 extern const struct file_operations hpfs_file_ops;
 extern struct inode_operations hpfs_file_iops;
-extern struct address_space_operations hpfs_aops;
+extern const struct address_space_operations hpfs_aops;
 
 /* inode.c */
 
@@ -304,7 +304,7 @@ void hpfs_decide_conv(struct inode *, unsigned char *, unsigned);
 /* namei.c */
 
 extern struct inode_operations hpfs_dir_iops;
-extern struct address_space_operations hpfs_symlink_aops;
+extern const struct address_space_operations hpfs_symlink_aops;
 
 static inline struct hpfs_inode_info *hpfs_i(struct inode *inode)
 {
diff --git a/fs/hpfs/namei.c b/fs/hpfs/namei.c
index a03abb12c610..59e7dc182a0c 100644
--- a/fs/hpfs/namei.c
+++ b/fs/hpfs/namei.c
@@ -538,7 +538,7 @@ fail:
         return err;
 }
 
-struct address_space_operations hpfs_symlink_aops = {
+const struct address_space_operations hpfs_symlink_aops = {
         .readpage       = hpfs_symlink_readpage
 };
         
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index e6410d8edd0e..6449cb697967 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -34,7 +34,7 @@
 #define HUGETLBFS_MAGIC 0x958458f6
 
 static struct super_operations hugetlbfs_ops;
-static struct address_space_operations hugetlbfs_aops;
+static const struct address_space_operations hugetlbfs_aops;
 const struct file_operations hugetlbfs_file_operations;
 static struct inode_operations hugetlbfs_dir_inode_operations;
 static struct inode_operations hugetlbfs_inode_operations;
@@ -547,7 +547,7 @@ static void hugetlbfs_destroy_inode(struct inode *inode)
         kmem_cache_free(hugetlbfs_inode_cachep, HUGETLBFS_I(inode));
 }
 
-static struct address_space_operations hugetlbfs_aops = {
+static const struct address_space_operations hugetlbfs_aops = {
         .readpage       = hugetlbfs_readpage,
         .prepare_write  = hugetlbfs_prepare_write,
         .commit_write   = hugetlbfs_commit_write,
diff --git a/fs/inode.c b/fs/inode.c
index 3a2446a27d2c..f42961eb983b 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -102,7 +102,7 @@ static kmem_cache_t * inode_cachep __read_mostly;
 
 static struct inode *alloc_inode(struct super_block *sb)
 {
-        static struct address_space_operations empty_aops;
+        static const struct address_space_operations empty_aops;
         static struct inode_operations empty_iops;
         static const struct file_operations empty_fops;
         struct inode *inode;
diff --git a/fs/isofs/compress.c b/fs/isofs/compress.c
index 4917315db732..3a39158cca96 100644
--- a/fs/isofs/compress.c
+++ b/fs/isofs/compress.c
@@ -312,7 +312,7 @@ eio:
         return err;
 }
 
-struct address_space_operations zisofs_aops = {
+const struct address_space_operations zisofs_aops = {
         .readpage = zisofs_readpage,
         /* No sync_page operation supported? */
         /* No bmap operation supported */
diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index 3f9c8ba1fa1f..bb11c7fb4019 100644
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -1054,7 +1054,7 @@ static sector_t _isofs_bmap(struct address_space *mapping, sector_t block)
         return generic_block_bmap(mapping,block,isofs_get_block);
 }
 
-static struct address_space_operations isofs_aops = {
+static const struct address_space_operations isofs_aops = {
         .readpage = isofs_readpage,
         .sync_page = block_sync_page,
         .bmap = _isofs_bmap
diff --git a/fs/isofs/isofs.h b/fs/isofs/isofs.h
index b87ba066f5e7..e6308c8b5735 100644
--- a/fs/isofs/isofs.h
+++ b/fs/isofs/isofs.h
@@ -176,5 +176,5 @@ isofs_normalize_block_and_offset(struct iso_directory_record* de,
 
 extern struct inode_operations isofs_dir_inode_operations;
 extern const struct file_operations isofs_dir_operations;
-extern struct address_space_operations isofs_symlink_aops;
+extern const struct address_space_operations isofs_symlink_aops;
 extern struct export_operations isofs_export_ops;
diff --git a/fs/isofs/rock.c b/fs/isofs/rock.c
index 4326cb47f8fa..f3a1db3098de 100644
--- a/fs/isofs/rock.c
+++ b/fs/isofs/rock.c
@@ -754,6 +754,6 @@ error:
         return -EIO;
 }
 
-struct address_space_operations isofs_symlink_aops = {
+const struct address_space_operations isofs_symlink_aops = {
         .readpage = rock_ridge_symlink_readpage
 };
diff --git a/fs/isofs/zisofs.h b/fs/isofs/zisofs.h
index d78485d101c2..273795709155 100644
--- a/fs/isofs/zisofs.h
+++ b/fs/isofs/zisofs.h
@@ -15,7 +15,7 @@
  */
 
 #ifdef CONFIG_ZISOFS
-extern struct address_space_operations zisofs_aops;
+extern const struct address_space_operations zisofs_aops;
 extern int __init zisofs_init(void);
 extern void zisofs_cleanup(void);
 #endif
diff --git a/fs/jffs/inode-v23.c b/fs/jffs/inode-v23.c
index 9e46ea6da752..93068697a9bf 100644
--- a/fs/jffs/inode-v23.c
+++ b/fs/jffs/inode-v23.c
@@ -59,7 +59,7 @@ static const struct file_operations jffs_file_operations;
 static struct inode_operations jffs_file_inode_operations;
 static const struct file_operations jffs_dir_operations;
 static struct inode_operations jffs_dir_inode_operations;
-static struct address_space_operations jffs_address_operations;
+static const struct address_space_operations jffs_address_operations;
 
 kmem_cache_t     *node_cache = NULL;
 kmem_cache_t     *fm_cache = NULL;
@@ -1614,7 +1614,7 @@ jffs_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
 } /* jffs_ioctl()  */
 
 
-static struct address_space_operations jffs_address_operations = {
+static const struct address_space_operations jffs_address_operations = {
         .readpage       = jffs_readpage,
         .prepare_write  = jffs_prepare_write,
         .commit_write   = jffs_commit_write,
diff --git a/fs/jffs2/file.c b/fs/jffs2/file.c
index bb8844f40e48..3ed6e3e120b6 100644
--- a/fs/jffs2/file.c
+++ b/fs/jffs2/file.c
@@ -62,7 +62,7 @@ struct inode_operations jffs2_file_inode_operations =
         .removexattr =  jffs2_removexattr
 };
 
-struct address_space_operations jffs2_file_address_operations =
+const struct address_space_operations jffs2_file_address_operations =
 {
         .readpage =     jffs2_readpage,
         .prepare_write =jffs2_prepare_write,
diff --git a/fs/jffs2/os-linux.h b/fs/jffs2/os-linux.h
index 6b5223565405..9f41fc01a371 100644
--- a/fs/jffs2/os-linux.h
+++ b/fs/jffs2/os-linux.h
@@ -158,7 +158,7 @@ extern struct inode_operations jffs2_dir_inode_operations;
 /* file.c */
 extern const struct file_operations jffs2_file_operations;
 extern struct inode_operations jffs2_file_inode_operations;
-extern struct address_space_operations jffs2_file_address_operations;
+extern const struct address_space_operations jffs2_file_address_operations;
 int jffs2_fsync(struct file *, struct dentry *, int);
 int jffs2_do_readpage_unlock (struct inode *inode, struct page *pg);
 
diff --git a/fs/jfs/inode.c b/fs/jfs/inode.c
index 04eb78f1252e..43e3f566aad6 100644
--- a/fs/jfs/inode.c
+++ b/fs/jfs/inode.c
@@ -305,7 +305,7 @@ static ssize_t jfs_direct_IO(int rw, struct kiocb *iocb,
                                 offset, nr_segs, jfs_get_block, NULL);
 }
 
-struct address_space_operations jfs_aops = {
+const struct address_space_operations jfs_aops = {
         .readpage       = jfs_readpage,
         .readpages      = jfs_readpages,
         .writepage      = jfs_writepage,
diff --git a/fs/jfs/jfs_inode.h b/fs/jfs/jfs_inode.h
index c30072674464..b5c7da6190dc 100644
--- a/fs/jfs/jfs_inode.h
+++ b/fs/jfs/jfs_inode.h
@@ -33,7 +33,7 @@ extern void jfs_free_zero_link(struct inode *);
 extern struct dentry *jfs_get_parent(struct dentry *dentry);
 extern void jfs_set_inode_flags(struct inode *);
 
-extern struct address_space_operations jfs_aops;
+extern const struct address_space_operations jfs_aops;
 extern struct inode_operations jfs_dir_inode_operations;
 extern const struct file_operations jfs_dir_operations;
 extern struct inode_operations jfs_file_inode_operations;
diff --git a/fs/jfs/jfs_metapage.c b/fs/jfs/jfs_metapage.c
index 7f6e88039700..e1e0a6e6ebdf 100644
--- a/fs/jfs/jfs_metapage.c
+++ b/fs/jfs/jfs_metapage.c
@@ -577,7 +577,7 @@ static void metapage_invalidatepage(struct page *page, unsigned long offset)
         metapage_releasepage(page, 0);
 }
 
-struct address_space_operations jfs_metapage_aops = {
+const struct address_space_operations jfs_metapage_aops = {
         .readpage       = metapage_readpage,
         .writepage      = metapage_writepage,
         .sync_page      = block_sync_page,
diff --git a/fs/jfs/jfs_metapage.h b/fs/jfs/jfs_metapage.h
index f0b7d3282b07..d17a3290f5aa 100644
--- a/fs/jfs/jfs_metapage.h
+++ b/fs/jfs/jfs_metapage.h
@@ -139,7 +139,7 @@ static inline void metapage_homeok(struct metapage *mp)
         put_metapage(mp);
 }
 
-extern struct address_space_operations jfs_metapage_aops;
+extern const struct address_space_operations jfs_metapage_aops;
 
 /*
  * This routines invalidate all pages for an extent.
diff --git a/fs/minix/inode.c b/fs/minix/inode.c
index a6fb509b7341..9ea91c5eeb7b 100644
--- a/fs/minix/inode.c
+++ b/fs/minix/inode.c
@@ -335,7 +335,7 @@ static sector_t minix_bmap(struct address_space *mapping, sector_t block)
 {
         return generic_block_bmap(mapping,block,minix_get_block);
 }
-static struct address_space_operations minix_aops = {
+static const struct address_space_operations minix_aops = {
         .readpage = minix_readpage,
         .writepage = minix_writepage,
         .sync_page = block_sync_page,
diff --git a/fs/ncpfs/inode.c b/fs/ncpfs/inode.c
index 90d2ea28f333..6c51c1198464 100644
--- a/fs/ncpfs/inode.c
+++ b/fs/ncpfs/inode.c
@@ -105,7 +105,7 @@ static struct super_operations ncp_sops =
 
 extern struct dentry_operations ncp_root_dentry_operations;
 #if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
-extern struct address_space_operations ncp_symlink_aops;
+extern const struct address_space_operations ncp_symlink_aops;
 extern int ncp_symlink(struct inode*, struct dentry*, const char*);
 #endif
 
diff --git a/fs/ncpfs/symlink.c b/fs/ncpfs/symlink.c
index e935f1b34bc2..f76b1392a012 100644
--- a/fs/ncpfs/symlink.c
+++ b/fs/ncpfs/symlink.c
@@ -99,7 +99,7 @@ fail:
 /*
  * symlinks can't do much...
  */
-struct address_space_operations ncp_symlink_aops = {
+const struct address_space_operations ncp_symlink_aops = {
         .readpage       = ncp_symlink_readpage,
 };
         
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index add289138836..cc2b874ad5a4 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -315,7 +315,7 @@ static int nfs_release_page(struct page *page, gfp_t gfp)
         return !nfs_wb_page(page->mapping->host, page);
 }
 
-struct address_space_operations nfs_file_aops = {
+const struct address_space_operations nfs_file_aops = {
         .readpage = nfs_readpage,
         .readpages = nfs_readpages,
         .set_page_dirty = __set_page_dirty_nobuffers,
diff --git a/fs/ntfs/aops.c b/fs/ntfs/aops.c
index 580412d330cb..bc579bfdfbd8 100644
--- a/fs/ntfs/aops.c
+++ b/fs/ntfs/aops.c
@@ -1544,7 +1544,7 @@ err_out:
 /**
  * ntfs_aops - general address space operations for inodes and attributes
  */
-struct address_space_operations ntfs_aops = {
+const struct address_space_operations ntfs_aops = {
         .readpage       = ntfs_readpage,        /* Fill page with data. */
         .sync_page      = block_sync_page,      /* Currently, just unplugs the
                                                    disk request queue. */
@@ -1560,7 +1560,7 @@ struct address_space_operations ntfs_aops = {
  * ntfs_mst_aops - general address space operations for mst protecteed inodes
  *                 and attributes
  */
-struct address_space_operations ntfs_mst_aops = {
+const struct address_space_operations ntfs_mst_aops = {
         .readpage       = ntfs_readpage,        /* Fill page with data. */
         .sync_page      = block_sync_page,      /* Currently, just unplugs the
                                                    disk request queue. */
diff --git a/fs/ntfs/ntfs.h b/fs/ntfs/ntfs.h
index bf7b3d7c0930..ddd3d503097c 100644
--- a/fs/ntfs/ntfs.h
+++ b/fs/ntfs/ntfs.h
@@ -57,8 +57,8 @@ extern struct kmem_cache *ntfs_attr_ctx_cache;
 extern struct kmem_cache *ntfs_index_ctx_cache;
 
 /* The various operations structs defined throughout the driver files. */
-extern struct address_space_operations ntfs_aops;
-extern struct address_space_operations ntfs_mst_aops;
+extern const struct address_space_operations ntfs_aops;
+extern const struct address_space_operations ntfs_mst_aops;
 
 extern const struct  file_operations ntfs_file_ops;
 extern struct inode_operations ntfs_file_inode_ops;
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index 47152bf9a7f2..cca71317b6d6 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -666,7 +666,7 @@ out:
         return ret;
 }
 
-struct address_space_operations ocfs2_aops = {
+const struct address_space_operations ocfs2_aops = {
         .readpage       = ocfs2_readpage,
         .writepage      = ocfs2_writepage,
         .prepare_write  = ocfs2_prepare_write,
diff --git a/fs/ocfs2/inode.h b/fs/ocfs2/inode.h
index 84c507961287..35140f6cf840 100644
--- a/fs/ocfs2/inode.h
+++ b/fs/ocfs2/inode.h
@@ -114,7 +114,7 @@ static inline struct ocfs2_inode_info *OCFS2_I(struct inode *inode)
 
 extern kmem_cache_t *ocfs2_inode_cache;
 
-extern struct address_space_operations ocfs2_aops;
+extern const struct address_space_operations ocfs2_aops;
 
 struct buffer_head *ocfs2_bread(struct inode *inode, int block,
                                 int *err, int reada);
diff --git a/fs/qnx4/inode.c b/fs/qnx4/inode.c
index 2f24c46f72a1..8bc182a88748 100644
--- a/fs/qnx4/inode.c
+++ b/fs/qnx4/inode.c
@@ -450,7 +450,7 @@ static sector_t qnx4_bmap(struct address_space *mapping, sector_t block)
 {
         return generic_block_bmap(mapping,block,qnx4_get_block);
 }
-static struct address_space_operations qnx4_aops = {
+static const struct address_space_operations qnx4_aops = {
         .readpage       = qnx4_readpage,
         .writepage      = qnx4_writepage,
         .sync_page      = block_sync_page,
diff --git a/fs/ramfs/file-mmu.c b/fs/ramfs/file-mmu.c
index 00a933eb820c..86f14cacf641 100644
--- a/fs/ramfs/file-mmu.c
+++ b/fs/ramfs/file-mmu.c
@@ -26,7 +26,7 @@
 
 #include <linux/fs.h>
 
-struct address_space_operations ramfs_aops = {
+const struct address_space_operations ramfs_aops = {
         .readpage       = simple_readpage,
         .prepare_write  = simple_prepare_write,
         .commit_write   = simple_commit_write
diff --git a/fs/ramfs/file-nommu.c b/fs/ramfs/file-nommu.c
index f443a84b98a5..99fffc9e1bfd 100644
--- a/fs/ramfs/file-nommu.c
+++ b/fs/ramfs/file-nommu.c
@@ -27,7 +27,7 @@
 
 static int ramfs_nommu_setattr(struct dentry *, struct iattr *);
 
-struct address_space_operations ramfs_aops = {
+const struct address_space_operations ramfs_aops = {
         .readpage               = simple_readpage,
         .prepare_write          = simple_prepare_write,
         .commit_write           = simple_commit_write
diff --git a/fs/ramfs/internal.h b/fs/ramfs/internal.h
index 313237631b49..c2bb58e74653 100644
--- a/fs/ramfs/internal.h
+++ b/fs/ramfs/internal.h
@@ -10,6 +10,6 @@
  */
 
 
-extern struct address_space_operations ramfs_aops;
+extern const struct address_space_operations ramfs_aops;
 extern const struct file_operations ramfs_file_operations;
 extern struct inode_operations ramfs_file_inode_operations;
diff --git a/fs/reiserfs/inode.c b/fs/reiserfs/inode.c
index 9857e50f85e7..a24858a632fa 100644
--- a/fs/reiserfs/inode.c
+++ b/fs/reiserfs/inode.c
@@ -2996,7 +2996,7 @@ int reiserfs_setattr(struct dentry *dentry, struct iattr *attr)
         return error;
 }
 
-struct address_space_operations reiserfs_address_space_operations = {
+const struct address_space_operations reiserfs_address_space_operations = {
         .writepage = reiserfs_writepage,
         .readpage = reiserfs_readpage,
         .readpages = reiserfs_readpages,
diff --git a/fs/romfs/inode.c b/fs/romfs/inode.c
index 283fbc6b8eea..22eed61ebf69 100644
--- a/fs/romfs/inode.c
+++ b/fs/romfs/inode.c
@@ -459,7 +459,7 @@ err_out:
 
 /* Mapping from our types to the kernel */
 
-static struct address_space_operations romfs_aops = {
+static const struct address_space_operations romfs_aops = {
         .readpage = romfs_readpage
 };
 
diff --git a/fs/smbfs/file.c b/fs/smbfs/file.c
index ed9a24d19d7d..dae67048baba 100644
--- a/fs/smbfs/file.c
+++ b/fs/smbfs/file.c
@@ -306,7 +306,7 @@ static int smb_commit_write(struct file *file, struct page *page,
         return status;
 }
 
-struct address_space_operations smb_file_aops = {
+const struct address_space_operations smb_file_aops = {
         .readpage = smb_readpage,
         .writepage = smb_writepage,
         .prepare_write = smb_prepare_write,
diff --git a/fs/smbfs/proto.h b/fs/smbfs/proto.h
index 972ed7dad388..34fb462b2379 100644
--- a/fs/smbfs/proto.h
+++ b/fs/smbfs/proto.h
@@ -63,7 +63,7 @@ extern int smb_revalidate_inode(struct dentry *dentry);
 extern int smb_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat);
 extern int smb_notify_change(struct dentry *dentry, struct iattr *attr);
 /* file.c */
-extern struct address_space_operations smb_file_aops;
+extern const struct address_space_operations smb_file_aops;
 extern const struct file_operations smb_file_operations;
 extern struct inode_operations smb_file_inode_operations;
 /* ioctl.c */
diff --git a/fs/sysfs/inode.c b/fs/sysfs/inode.c
index f0b347bd12ca..5e0e31cc46f5 100644
--- a/fs/sysfs/inode.c
+++ b/fs/sysfs/inode.c
@@ -16,7 +16,7 @@
 
 extern struct super_block * sysfs_sb;
 
-static struct address_space_operations sysfs_aops = {
+static const struct address_space_operations sysfs_aops = {
         .readpage       = simple_readpage,
         .prepare_write  = simple_prepare_write,
         .commit_write   = simple_commit_write
diff --git a/fs/sysv/itree.c b/fs/sysv/itree.c
index 86f5f8d43d0f..f2bcccd1d6fc 100644
--- a/fs/sysv/itree.c
+++ b/fs/sysv/itree.c
@@ -465,7 +465,7 @@ static sector_t sysv_bmap(struct address_space *mapping, sector_t block)
 {
         return generic_block_bmap(mapping,block,get_block);
 }
-struct address_space_operations sysv_aops = {
+const struct address_space_operations sysv_aops = {
         .readpage = sysv_readpage,
         .writepage = sysv_writepage,
         .sync_page = block_sync_page,
diff --git a/fs/sysv/sysv.h b/fs/sysv/sysv.h
index 393a480e4deb..9dcc82120935 100644
--- a/fs/sysv/sysv.h
+++ b/fs/sysv/sysv.h
@@ -161,7 +161,7 @@ extern struct inode_operations sysv_dir_inode_operations;
 extern struct inode_operations sysv_fast_symlink_inode_operations;
 extern const struct file_operations sysv_file_operations;
 extern const struct file_operations sysv_dir_operations;
-extern struct address_space_operations sysv_aops;
+extern const struct address_space_operations sysv_aops;
 extern struct super_operations sysv_sops;
 extern struct dentry_operations sysv_dentry_operations;
 
diff --git a/fs/udf/file.c b/fs/udf/file.c
index e34b00e303f1..a59e5f33daf6 100644
--- a/fs/udf/file.c
+++ b/fs/udf/file.c
@@ -95,7 +95,7 @@ static int udf_adinicb_commit_write(struct file *file, struct page *page, unsign
         return 0;
 }
 
-struct address_space_operations udf_adinicb_aops = {
+const struct address_space_operations udf_adinicb_aops = {
         .readpage               = udf_adinicb_readpage,
         .writepage              = udf_adinicb_writepage,
         .sync_page              = block_sync_page,
diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index 2983afd5e7fd..605f5111b6d8 100644
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -132,7 +132,7 @@ static sector_t udf_bmap(struct address_space *mapping, sector_t block)
         return generic_block_bmap(mapping,block,udf_get_block);
 }
 
-struct address_space_operations udf_aops = {
+const struct address_space_operations udf_aops = {
         .readpage               = udf_readpage,
         .writepage              = udf_writepage,
         .sync_page              = block_sync_page,
diff --git a/fs/udf/symlink.c b/fs/udf/symlink.c
index 674bb40edc83..ba068a786563 100644
--- a/fs/udf/symlink.c
+++ b/fs/udf/symlink.c
@@ -113,6 +113,6 @@ out:
 /*
  * symlinks can't do much...
  */
-struct address_space_operations udf_symlink_aops = {
+const struct address_space_operations udf_symlink_aops = {
         .readpage               = udf_symlink_filler,
 };
diff --git a/fs/udf/udfdecl.h b/fs/udf/udfdecl.h
index 023e19ba5a2e..2f992387cc9e 100644
--- a/fs/udf/udfdecl.h
+++ b/fs/udf/udfdecl.h
@@ -47,9 +47,9 @@ extern struct inode_operations udf_dir_inode_operations;
 extern const struct file_operations udf_dir_operations;
 extern struct inode_operations udf_file_inode_operations;
 extern const struct file_operations udf_file_operations;
-extern struct address_space_operations udf_aops;
-extern struct address_space_operations udf_adinicb_aops;
-extern struct address_space_operations udf_symlink_aops;
+extern const struct address_space_operations udf_aops;
+extern const struct address_space_operations udf_adinicb_aops;
+extern const struct address_space_operations udf_symlink_aops;
 
 struct udf_fileident_bh
 {
diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
index 259bd196099d..8e1f90e42040 100644
--- a/fs/ufs/inode.c
+++ b/fs/ufs/inode.c
@@ -574,7 +574,7 @@ static sector_t ufs_bmap(struct address_space *mapping, sector_t block)
 {
         return generic_block_bmap(mapping,block,ufs_getfrag_block);
 }
-struct address_space_operations ufs_aops = {
+const struct address_space_operations ufs_aops = {
         .readpage = ufs_readpage,
         .writepage = ufs_writepage,
         .sync_page = block_sync_page,
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index 3e807b828e22..c40f81ba9b13 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -1454,7 +1454,7 @@ xfs_vm_invalidatepage(
         block_invalidatepage(page, offset);
 }
 
-struct address_space_operations xfs_address_space_operations = {
+const struct address_space_operations xfs_address_space_operations = {
         .readpage               = xfs_vm_readpage,
         .readpages              = xfs_vm_readpages,
         .writepage              = xfs_vm_writepage,
diff --git a/fs/xfs/linux-2.6/xfs_aops.h b/fs/xfs/linux-2.6/xfs_aops.h
index 706d8c781b8a..2244e516b66a 100644
--- a/fs/xfs/linux-2.6/xfs_aops.h
+++ b/fs/xfs/linux-2.6/xfs_aops.h
@@ -40,7 +40,7 @@ typedef struct xfs_ioend {
         struct work_struct      io_work;        /* xfsdatad work queue */
 } xfs_ioend_t;
 
-extern struct address_space_operations xfs_address_space_operations;
+extern const struct address_space_operations xfs_address_space_operations;
 extern int xfs_get_blocks(struct inode *, sector_t, struct buffer_head *, int);
 
 #endif /* __XFS_AOPS_H__ */
diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
index 26fed0756f01..2af528dcfb04 100644
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -1520,7 +1520,7 @@ xfs_mapping_buftarg(
         struct backing_dev_info *bdi;
         struct inode            *inode;
         struct address_space    *mapping;
-        static struct address_space_operations mapping_aops = {
+        static const struct address_space_operations mapping_aops = {
                 .sync_page = block_sync_page,
                 .migratepage = fail_migrate_page,
         };
diff --git a/include/asm-arm/arch-at91rm9200/memory.h b/include/asm-arm/arch-at91rm9200/memory.h
index 3c327c404373..f985069e6d01 100644
--- a/include/asm-arm/arch-at91rm9200/memory.h
+++ b/include/asm-arm/arch-at91rm9200/memory.h
@@ -33,9 +33,7 @@
  * bus_to_virt: Used to convert an address for DMA operations
  *              to an address that the kernel can use.
  */
-#define __virt_to_bus__is_a_macro
 #define __virt_to_bus(x) __virt_to_phys(x)
-#define __bus_to_virt__is_a_macro
 #define __bus_to_virt(x) __phys_to_virt(x)
 
 #endif
diff --git a/include/asm-arm/arch-h720x/memory.h b/include/asm-arm/arch-h720x/memory.h
index 4a1bfd78a0fe..53e923dba76e 100644
--- a/include/asm-arm/arch-h720x/memory.h
+++ b/include/asm-arm/arch-h720x/memory.h
@@ -23,9 +23,7 @@
  * There is something to do here later !, Mar 2000, Jungjun Kim
  */
 
-#define __virt_to_bus__is_a_macro
 #define __virt_to_bus(x)        __virt_to_phys(x)
-#define __bus_to_virt__is_a_macro
 #define __bus_to_virt(x)        __phys_to_virt(x)
 
 #endif
diff --git a/include/asm-arm/arch-imx/memory.h b/include/asm-arm/arch-imx/memory.h
index d09ae32cd2f4..5ad90127915f 100644
--- a/include/asm-arm/arch-imx/memory.h
+++ b/include/asm-arm/arch-imx/memory.h
@@ -30,9 +30,7 @@
  * bus_to_virt: Used to convert an address for DMA operations
  *              to an address that the kernel can use.
  */
-#define __virt_to_bus__is_a_macro
-#define __virt_to_bus(x)        (x - PAGE_OFFSET +  PHYS_OFFSET)
-#define __bus_to_virt__is_a_macro
-#define __bus_to_virt(x)        (x -  PHYS_OFFSET + PAGE_OFFSET)
+#define __virt_to_bus(x)        (x - PAGE_OFFSET + PHYS_OFFSET)
+#define __bus_to_virt(x)        (x - PHYS_OFFSET + PAGE_OFFSET)
 
 #endif
diff --git a/include/asm-arm/arch-ixp23xx/ixp23xx.h b/include/asm-arm/arch-ixp23xx/ixp23xx.h
index d0a72201ee96..3927b1d61b17 100644
--- a/include/asm-arm/arch-ixp23xx/ixp23xx.h
+++ b/include/asm-arm/arch-ixp23xx/ixp23xx.h
@@ -295,15 +295,4 @@
 #define IXP23XX_PCI_CPP_ADDR_BITS       IXP23XX_PCI_CSR(0x0160)
 
 
-#ifndef __ASSEMBLY__
-/*
- * Is system memory on the XSI or CPP bus?
- */
-static inline unsigned ixp23xx_cpp_boot(void)
-{
-        return (*IXP23XX_EXP_CFG0 & IXP23XX_EXP_CFG0_XSI_NOT_PRES);
-}
-#endif
-
-
 #endif
diff --git a/include/asm-arm/arch-ixp23xx/platform.h b/include/asm-arm/arch-ixp23xx/platform.h
index 19a73b39c864..56e16d66645a 100644
--- a/include/asm-arm/arch-ixp23xx/platform.h
+++ b/include/asm-arm/arch-ixp23xx/platform.h
@@ -43,5 +43,15 @@ extern struct sys_timer ixp23xx_timer;
 
 #define IXP23XX_UART_XTAL               14745600
 
+#ifndef __ASSEMBLY__
+/*
+ * Is system memory on the XSI or CPP bus?
+ */
+static inline unsigned ixp23xx_cpp_boot(void)
+{
+        return (*IXP23XX_EXP_CFG0 & IXP23XX_EXP_CFG0_XSI_NOT_PRES);
+}
+#endif
+
 
 #endif
diff --git a/include/asm-arm/arch-ixp23xx/uncompress.h b/include/asm-arm/arch-ixp23xx/uncompress.h
index 013575e6a9a1..16c1110f2304 100644
--- a/include/asm-arm/arch-ixp23xx/uncompress.h
+++ b/include/asm-arm/arch-ixp23xx/uncompress.h
@@ -11,7 +11,7 @@
 #ifndef __ASM_ARCH_UNCOMPRESS_H
 #define __ASM_ARCH_UNCOMPRESS_H
 
-#include <asm/hardware.h>
+#include <asm/arch/ixp23xx.h>
 #include <linux/serial_reg.h>
 
 #define UART_BASE       ((volatile u32 *)IXP23XX_UART1_PHYS)
diff --git a/include/asm-arm/arch-s3c2410/regs-dsc.h b/include/asm-arm/arch-s3c2410/regs-dsc.h
index 84aca61cbaa3..a0a124875164 100644
--- a/include/asm-arm/arch-s3c2410/regs-dsc.h
+++ b/include/asm-arm/arch-s3c2410/regs-dsc.h
@@ -7,25 +7,23 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- * S3C2440 Signal Drive Strength Control
- *
- *  Changelog:
- *    11-Aug-2004     BJD     Created file
- *    25-Aug-2004     BJD     Added the _SELECT_* defs for using with functions
+ * S3C2440/S3C2412 Signal Drive Strength Control
 */
 
 
 #ifndef __ASM_ARCH_REGS_DSC_H
 #define __ASM_ARCH_REGS_DSC_H "2440-dsc"
 
-#ifdef CONFIG_CPU_S3C2440
+#if defined(CONFIG_CPU_S3C2412)
+#define S3C2412_DSC0       S3C2410_GPIOREG(0xdc)
+#define S3C2412_DSC1       S3C2410_GPIOREG(0xe0)
+#endif
+
+#if defined(CONFIG_CPU_S3C2440)
 
 #define S3C2440_DSC0       S3C2410_GPIOREG(0xc4)
 #define S3C2440_DSC1       S3C2410_GPIOREG(0xc8)
 
-#define S3C2412_DSC0       S3C2410_GPIOREG(0xdc)
-#define S3C2412_DSC1       S3C2410_GPIOREG(0xe0)
-
 #define S3C2440_SELECT_DSC0 (0)
 #define S3C2440_SELECT_DSC1 (1<<31)
 
diff --git a/include/asm-arm/bugs.h b/include/asm-arm/bugs.h
index 4c80ec519d45..ca54eb0f12d7 100644
--- a/include/asm-arm/bugs.h
+++ b/include/asm-arm/bugs.h
@@ -10,8 +10,12 @@
 #ifndef __ASM_BUGS_H
 #define __ASM_BUGS_H
 
+#ifdef CONFIG_MMU
 extern void check_writebuffer_bugs(void);
 
 #define check_bugs() check_writebuffer_bugs()
+#else
+#define check_bugs() do { } while (0)
+#endif
 
 #endif
diff --git a/include/asm-arm/domain.h b/include/asm-arm/domain.h
index f8ea2de4848e..4c2885abbe6c 100644
--- a/include/asm-arm/domain.h
+++ b/include/asm-arm/domain.h
@@ -50,6 +50,8 @@
 #define domain_val(dom,type)    ((type) << (2*(dom)))
 
 #ifndef __ASSEMBLY__
+
+#ifdef CONFIG_MMU
 #define set_domain(x)                                   \
         do {                                            \
         __asm__ __volatile__(                           \
@@ -66,5 +68,10 @@
         set_domain(thread->cpu_domain);                         \
         } while (0)
 
+#else
+#define set_domain(x)           do { } while (0)
+#define modify_domain(dom,type) do { } while (0)
+#endif
+
 #endif
 #endif /* !__ASSEMBLY__ */
diff --git a/include/asm-arm/fpstate.h b/include/asm-arm/fpstate.h
index 132c3c5628b2..6af4e6bd1290 100644
--- a/include/asm-arm/fpstate.h
+++ b/include/asm-arm/fpstate.h
@@ -72,6 +72,14 @@ union fp_state {
 
 #define FP_SIZE (sizeof(union fp_state) / sizeof(int))
 
+struct crunch_state {
+        unsigned int    mvdx[16][2];
+        unsigned int    mvax[4][3];
+        unsigned int    dspsc[2];
+};
+
+#define CRUNCH_SIZE     sizeof(struct crunch_state)
+
 #endif
 
 #endif
diff --git a/include/asm-arm/mach/map.h b/include/asm-arm/mach/map.h
index e8ea67c97c73..cef5364ed5fe 100644
--- a/include/asm-arm/mach/map.h
+++ b/include/asm-arm/mach/map.h
@@ -16,8 +16,6 @@ struct map_desc {
         unsigned int type;
 };
 
-struct meminfo;
-
 #define MT_DEVICE               0
 #define MT_CACHECLEAN           1
 #define MT_MINICLEAN            2
@@ -28,7 +26,8 @@ struct meminfo;
 #define MT_IXP2000_DEVICE       7
 #define MT_NONSHARED_DEVICE     8
 
-extern void create_memmap_holes(struct meminfo *);
-extern void memtable_init(struct meminfo *);
+#ifdef CONFIG_MMU
 extern void iotable_init(struct map_desc *, int);
-extern void setup_io_desc(void);
+#else
+#define iotable_init(map,num)   do { } while (0)
+#endif
diff --git a/include/asm-arm/memory.h b/include/asm-arm/memory.h
index 731e321a57d1..94f973b704f1 100644
--- a/include/asm-arm/memory.h
+++ b/include/asm-arm/memory.h
@@ -2,6 +2,7 @@
  *  linux/include/asm-arm/memory.h
  *
  *  Copyright (C) 2000-2002 Russell King
+ *  modification for nommu, Hyok S. Choi, 2004
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -26,6 +27,8 @@
 #include <asm/arch/memory.h>
 #include <asm/sizes.h>
 
+#ifdef CONFIG_MMU
+
 #ifndef TASK_SIZE
 /*
  * TASK_SIZE - the maximum size of a user space task.
@@ -48,6 +51,60 @@
 #endif
 
 /*
+ * The module space lives between the addresses given by TASK_SIZE
+ * and PAGE_OFFSET - it must be within 32MB of the kernel text.
+ */
+#define MODULE_END              (PAGE_OFFSET)
+#define MODULE_START            (MODULE_END - 16*1048576)
+
+#if TASK_SIZE > MODULE_START
+#error Top of user space clashes with start of module space
+#endif
+
+/*
+ * The XIP kernel gets mapped at the bottom of the module vm area.
+ * Since we use sections to map it, this macro replaces the physical address
+ * with its virtual address while keeping offset from the base section.
+ */
+#define XIP_VIRT_ADDR(physaddr)  (MODULE_START + ((physaddr) & 0x000fffff))
+
+#else /* CONFIG_MMU */
+
+/*
+ * The limitation of user task size can grow up to the end of free ram region.
+ * It is difficult to define and perhaps will never meet the original meaning
+ * of this define that was meant to.
+ * Fortunately, there is no reference for this in noMMU mode, for now.
+ */
+#ifndef TASK_SIZE
+#define TASK_SIZE               (CONFIG_DRAM_SIZE)
+#endif
+
+#ifndef TASK_UNMAPPED_BASE
+#define TASK_UNMAPPED_BASE      UL(0x00000000)
+#endif
+
+#ifndef PHYS_OFFSET
+#define PHYS_OFFSET             (CONFIG_DRAM_BASE)
+#endif
+
+#ifndef END_MEM
+#define END_MEM                 (CONFIG_DRAM_BASE + CONFIG_DRAM_SIZE)
+#endif
+
+#ifndef PAGE_OFFSET
+#define PAGE_OFFSET             (PHYS_OFFSET)
+#endif
+
+/*
+ * The module can be at any place in ram in nommu mode.
+ */
+#define MODULE_END              (END_MEM)
+#define MODULE_START            (PHYS_OFFSET)
+
+#endif /* !CONFIG_MMU */
+
+/*
  * Size of DMA-consistent memory region.  Must be multiple of 2M,
  * between 2MB and 14MB inclusive.
  */
@@ -71,24 +128,6 @@
 #define __phys_to_pfn(paddr)    ((paddr) >> PAGE_SHIFT)
 #define __pfn_to_phys(pfn)      ((pfn) << PAGE_SHIFT)
 
-/*
- * The module space lives between the addresses given by TASK_SIZE
- * and PAGE_OFFSET - it must be within 32MB of the kernel text.
- */
-#define MODULE_END      (PAGE_OFFSET)
-#define MODULE_START    (MODULE_END - 16*1048576)
-
-#if TASK_SIZE > MODULE_START
-#error Top of user space clashes with start of module space
-#endif
-
-/*
- * The XIP kernel gets mapped at the bottom of the module vm area.
- * Since we use sections to map it, this macro replaces the physical address
- * with its virtual address while keeping offset from the base section.
- */
-#define XIP_VIRT_ADDR(physaddr)  (MODULE_START + ((physaddr) & 0x000fffff))
-
 #ifndef __ASSEMBLY__
 
 /*
diff --git a/include/asm-arm/mmu.h b/include/asm-arm/mmu.h
index a457cb71984f..23dde52e0945 100644
--- a/include/asm-arm/mmu.h
+++ b/include/asm-arm/mmu.h
@@ -1,6 +1,8 @@
 #ifndef __ARM_MMU_H
 #define __ARM_MMU_H
 
+#ifdef CONFIG_MMU
+
 typedef struct {
 #if __LINUX_ARM_ARCH__ >= 6
         unsigned int id;
@@ -13,4 +15,18 @@ typedef struct {
 #define ASID(mm)        (0)
 #endif
 
+#else
+
+/*
+ * From nommu.h:
+ *  Copyright (C) 2002, David McCullough <davidm@snapgear.com>
+ *  modified for 2.6 by Hyok S. Choi <hyok.choi@samsung.com>
+ */
+typedef struct {
+        struct vm_list_struct   *vmlist;
+        unsigned long           end_brk;
+} mm_context_t;
+
+#endif
+
 #endif
diff --git a/include/asm-arm/mmu_context.h b/include/asm-arm/mmu_context.h
index 81c59facea3b..9fadb01e030d 100644
--- a/include/asm-arm/mmu_context.h
+++ b/include/asm-arm/mmu_context.h
@@ -82,6 +82,7 @@ static inline void
 switch_mm(struct mm_struct *prev, struct mm_struct *next,
           struct task_struct *tsk)
 {
+#ifdef CONFIG_MMU
         unsigned int cpu = smp_processor_id();
 
         if (prev != next) {
@@ -91,6 +92,7 @@ switch_mm(struct mm_struct *prev, struct mm_struct *next,
                 if (cache_is_vivt())
                         cpu_clear(cpu, prev->cpu_vm_mask);
         }
+#endif
 }
 
 #define deactivate_mm(tsk,mm)   do { } while (0)
diff --git a/include/asm-arm/page-nommu.h b/include/asm-arm/page-nommu.h
new file mode 100644
index 000000000000..a1bcad060480
--- /dev/null
+++ b/include/asm-arm/page-nommu.h
@@ -0,0 +1,51 @@
+/*
+ *  linux/include/asm-arm/page-nommu.h
+ *
+ *  Copyright (C) 2004 Hyok S. Choi
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef _ASMARM_PAGE_NOMMU_H
+#define _ASMARM_PAGE_NOMMU_H
+
+#if !defined(CONFIG_SMALL_TASKS) && PAGE_SHIFT < 13
+#define KTHREAD_SIZE (8192)
+#else
+#define KTHREAD_SIZE PAGE_SIZE
+#endif
+ 
+#define get_user_page(vaddr)            __get_free_page(GFP_KERNEL)
+#define free_user_page(page, addr)      free_page(addr)
+
+#define clear_page(page)        memset((page), 0, PAGE_SIZE)
+#define copy_page(to,from)      memcpy((to), (from), PAGE_SIZE)
+
+#define clear_user_page(page, vaddr, pg)        clear_page(page)
+#define copy_user_page(to, from, vaddr, pg)     copy_page(to, from)
+
+/*
+ * These are used to make use of C type-checking..
+ */
+typedef unsigned long pte_t;
+typedef unsigned long pmd_t;
+typedef unsigned long pgd_t[2];
+typedef unsigned long pgprot_t;
+
+#define pte_val(x)      (x)
+#define pmd_val(x)      (x)
+#define pgd_val(x)      ((x)[0])
+#define pgprot_val(x)   (x)
+
+#define __pte(x)        (x)
+#define __pmd(x)        (x)
+#define __pgprot(x)     (x)
+
+/* to align the pointer to the (next) page boundary */
+#define PAGE_ALIGN(addr)        (((addr)+PAGE_SIZE-1)&PAGE_MASK)
+
+extern unsigned long memory_start;
+extern unsigned long memory_end;
+
+#endif
diff --git a/include/asm-arm/page.h b/include/asm-arm/page.h
index 66cfeb5290ea..63d12f0244c5 100644
--- a/include/asm-arm/page.h
+++ b/include/asm-arm/page.h
@@ -23,6 +23,12 @@
 
 #ifndef __ASSEMBLY__
 
+#ifndef CONFIG_MMU
+
+#include "page-nommu.h"
+
+#else
+
 #include <asm/glue.h>
 
 /*
@@ -171,6 +177,8 @@ typedef unsigned long pgprot_t;
 /* the upper-most page table pointer */
 extern pmd_t *top_pmd;
 
+#endif /* CONFIG_MMU */
+
 #include <asm/memory.h>
 
 #endif /* !__ASSEMBLY__ */
diff --git a/include/asm-arm/pgalloc.h b/include/asm-arm/pgalloc.h
index c4ac2e67768d..4d4394552911 100644
--- a/include/asm-arm/pgalloc.h
+++ b/include/asm-arm/pgalloc.h
@@ -16,6 +16,10 @@
 #include <asm/cacheflush.h>
 #include <asm/tlbflush.h>
 
+#define check_pgt_cache()               do { } while (0)
+
+#ifdef CONFIG_MMU
+
 #define _PAGE_USER_TABLE        (PMD_TYPE_TABLE | PMD_BIT4 | PMD_DOMAIN(DOMAIN_USER))
 #define _PAGE_KERNEL_TABLE      (PMD_TYPE_TABLE | PMD_BIT4 | PMD_DOMAIN(DOMAIN_KERNEL))
 
@@ -32,8 +36,6 @@ extern void free_pgd_slow(pgd_t *pgd);
 #define pgd_alloc(mm)                   get_pgd_slow(mm)
 #define pgd_free(pgd)                   free_pgd_slow(pgd)
 
-#define check_pgt_cache()               do { } while (0)
-
 /*
  * Allocate one PTE table.
  *
@@ -126,4 +128,6 @@ pmd_populate(struct mm_struct *mm, pmd_t *pmdp, struct page *ptep)
         __pmd_populate(pmdp, page_to_pfn(ptep) << PAGE_SHIFT | _PAGE_USER_TABLE);
 }
 
+#endif /* CONFIG_MMU */
+
 #endif
diff --git a/include/asm-arm/pgtable-nommu.h b/include/asm-arm/pgtable-nommu.h
new file mode 100644
index 000000000000..b13322dccf41
--- /dev/null
+++ b/include/asm-arm/pgtable-nommu.h
@@ -0,0 +1,123 @@
+/*
+ *  linux/include/asm-arm/pgtable-nommu.h
+ *
+ *  Copyright (C) 1995-2002 Russell King
+ *  Copyright (C) 2004  Hyok S. Choi
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef _ASMARM_PGTABLE_NOMMU_H
+#define _ASMARM_PGTABLE_NOMMU_H
+
+#ifndef __ASSEMBLY__
+
+#include <linux/config.h>
+#include <linux/slab.h>
+#include <asm/processor.h>
+#include <asm/page.h>
+#include <asm/io.h>
+
+/*
+ * Trivial page table functions.
+ */
+#define pgd_present(pgd)        (1)
+#define pgd_none(pgd)           (0)
+#define pgd_bad(pgd)            (0)
+#define pgd_clear(pgdp)
+#define kern_addr_valid(addr)   (1)
+#define pmd_offset(a, b)        ((void *)0)
+/* FIXME */
+/*
+ * PMD_SHIFT determines the size of the area a second-level page table can map
+ * PGDIR_SHIFT determines what a third-level page table entry can map
+ */
+#define PGDIR_SHIFT             21
+
+#define PGDIR_SIZE              (1UL << PGDIR_SHIFT)
+#define PGDIR_MASK              (~(PGDIR_SIZE-1))
+/* FIXME */
+
+#define PAGE_NONE       __pgprot(0)
+#define PAGE_SHARED     __pgprot(0)
+#define PAGE_COPY       __pgprot(0)
+#define PAGE_READONLY   __pgprot(0)
+#define PAGE_KERNEL     __pgprot(0)
+
+//extern void paging_init(struct meminfo *, struct machine_desc *);
+#define swapper_pg_dir ((pgd_t *) 0)
+
+#define __swp_type(x)           (0)
+#define __swp_offset(x)         (0)
+#define __swp_entry(typ,off)    ((swp_entry_t) { ((typ) | ((off) << 7)) })
+#define __pte_to_swp_entry(pte) ((swp_entry_t) { pte_val(pte) })
+#define __swp_entry_to_pte(x)   ((pte_t) { (x).val })
+
+
+typedef pte_t *pte_addr_t;
+
+static inline int pte_file(pte_t pte) { return 0; }
+
+/*
+ * ZERO_PAGE is a global shared page that is always zero: used
+ * for zero-mapped memory areas etc..
+ */
+#define ZERO_PAGE(vaddr)        (virt_to_page(0))
+
+/*
+ * Mark the prot value as uncacheable and unbufferable.
+ */
+#define pgprot_noncached(prot)  __pgprot(0)
+#define pgprot_writecombine(prot) __pgprot(0)
+
+
+/*
+ * These would be in other places but having them here reduces the diffs.
+ */
+extern unsigned int kobjsize(const void *objp);
+extern int is_in_rom(unsigned long);
+
+/*
+ * No page table caches to initialise.
+ */
+#define pgtable_cache_init()    do { } while (0)
+#define io_remap_page_range     remap_page_range
+#define io_remap_pfn_range      remap_pfn_range
+
+#define MK_IOSPACE_PFN(space, pfn)      (pfn)
+#define GET_IOSPACE(pfn)                0
+#define GET_PFN(pfn)                    (pfn)
+
+
+/*
+ * All 32bit addresses are effectively valid for vmalloc...
+ * Sort of meaningless for non-VM targets.
+ */
+#define VMALLOC_START   0
+#define VMALLOC_END     0xffffffff
+
+#define FIRST_USER_ADDRESS      (0)
+
+#else 
+
+/*
+ * dummy tlb and user structures.
+ */
+#define v3_tlb_fns      (0)
+#define v4_tlb_fns      (0)
+#define v4wb_tlb_fns    (0)
+#define v4wbi_tlb_fns   (0)
+#define v6_tlb_fns      (0)
+
+#define v3_user_fns     (0)
+#define v4_user_fns     (0)
+#define v4_mc_user_fns  (0)
+#define v4wb_user_fns   (0)
+#define v4wt_user_fns   (0)
+#define v6_user_fns     (0)
+#define xscale_mc_user_fns (0)
+
+#endif /*__ASSEMBLY__*/
+
+#endif /* _ASMARM_PGTABLE_H */
diff --git a/include/asm-arm/pgtable.h b/include/asm-arm/pgtable.h
index e85c08d78dda..8d3919c6458c 100644
--- a/include/asm-arm/pgtable.h
+++ b/include/asm-arm/pgtable.h
@@ -11,9 +11,15 @@
 #define _ASMARM_PGTABLE_H
 
 #include <asm-generic/4level-fixup.h>
+#include <asm/proc-fns.h>
+
+#ifndef CONFIG_MMU
+
+#include "pgtable-nommu.h"
+
+#else
 
 #include <asm/memory.h>
-#include <asm/proc-fns.h>
 #include <asm/arch/vmalloc.h>
 
 /*
@@ -378,4 +384,6 @@ extern pgd_t swapper_pg_dir[PTRS_PER_PGD];
 
 #endif /* !__ASSEMBLY__ */
 
+#endif /* CONFIG_MMU */
+
 #endif /* _ASMARM_PGTABLE_H */
diff --git a/include/asm-arm/proc-fns.h b/include/asm-arm/proc-fns.h
index e9310895e79d..1bde92cdaebd 100644
--- a/include/asm-arm/proc-fns.h
+++ b/include/asm-arm/proc-fns.h
@@ -165,6 +165,8 @@
 
 #include <asm/memory.h>
 
+#ifdef CONFIG_MMU
+
 #define cpu_switch_mm(pgd,mm) cpu_do_switch_mm(virt_to_phys(pgd),mm)
 
 #define cpu_get_pgd()   \
@@ -176,6 +178,8 @@
                 (pgd_t *)phys_to_virt(pg);              \
         })
 
+#endif
+
 #endif /* __ASSEMBLY__ */
 #endif /* __KERNEL__ */
 #endif /* __ASM_PROCFNS_H */
diff --git a/include/asm-arm/ptrace.h b/include/asm-arm/ptrace.h
index 2bebe3dc0a30..5a8ef787dbf8 100644
--- a/include/asm-arm/ptrace.h
+++ b/include/asm-arm/ptrace.h
@@ -25,6 +25,11 @@
 
 #define PTRACE_SET_SYSCALL      23
 
+/* PTRACE_SYSCALL is 24 */
+
+#define PTRACE_GETCRUNCHREGS    25
+#define PTRACE_SETCRUNCHREGS    26
+
 /*
  * PSR bits
  */
diff --git a/include/asm-arm/thread_info.h b/include/asm-arm/thread_info.h
index cfbccb63c67b..c46b5c84275f 100644
--- a/include/asm-arm/thread_info.h
+++ b/include/asm-arm/thread_info.h
@@ -59,6 +59,7 @@ struct thread_info {
         struct cpu_context_save cpu_context;    /* cpu context */
         __u8                    used_cp[16];    /* thread used copro */
         unsigned long           tp_value;
+        struct crunch_state     crunchstate;
         union fp_state          fpstate __attribute__((aligned(8)));
         union vfp_state         vfpstate;
         struct restart_block    restart_block;
@@ -101,6 +102,11 @@ extern void free_thread_info(struct thread_info *);
 #define thread_saved_fp(tsk)    \
         ((unsigned long)(task_thread_info(tsk)->cpu_context.fp))
 
+extern void crunch_task_disable(struct thread_info *);
+extern void crunch_task_copy(struct thread_info *, void *);
+extern void crunch_task_restore(struct thread_info *, void *);
+extern void crunch_task_release(struct thread_info *);
+
 extern void iwmmxt_task_disable(struct thread_info *);
 extern void iwmmxt_task_copy(struct thread_info *, void *);
 extern void iwmmxt_task_restore(struct thread_info *, void *);
diff --git a/include/asm-arm/uaccess.h b/include/asm-arm/uaccess.h
index 064f0f5e8e2b..87aba57a66c4 100644
--- a/include/asm-arm/uaccess.h
+++ b/include/asm-arm/uaccess.h
@@ -41,15 +41,24 @@ struct exception_table_entry
 extern int fixup_exception(struct pt_regs *regs);
 
 /*
+ * These two are intentionally not defined anywhere - if the kernel
+ * code generates any references to them, that's a bug.
+ */
+extern int __get_user_bad(void);
+extern int __put_user_bad(void);
+
+/*
  * Note that this is actually 0x1,0000,0000
  */
 #define KERNEL_DS       0x00000000
-#define USER_DS         TASK_SIZE
-
 #define get_ds()        (KERNEL_DS)
+
+#ifdef CONFIG_MMU
+
+#define USER_DS         TASK_SIZE
 #define get_fs()        (current_thread_info()->addr_limit)
 
-static inline void set_fs (mm_segment_t fs)
+static inline void set_fs(mm_segment_t fs)
 {
         current_thread_info()->addr_limit = fs;
         modify_domain(DOMAIN_KERNEL, fs ? DOMAIN_CLIENT : DOMAIN_MANAGER);
@@ -75,8 +84,6 @@ static inline void set_fs (mm_segment_t fs)
                 : "cc"); \
         flag; })
 
-#define access_ok(type,addr,size)       (__range_ok(addr,size) == 0)
-
 /*
  * Single-value transfer routines.  They automatically use the right
  * size if we just have the right pointer type.  Note that the functions
@@ -87,20 +94,10 @@ static inline void set_fs (mm_segment_t fs)
  * fixup code, but there are a few places where it intrudes on the
  * main code path.  When we only write to user space, there is no
  * problem.
- *
- * The "__xxx" versions of the user access functions do not verify the
- * address space - it must have been done previously with a separate
- * "access_ok()" call.
- *
- * The "xxx_error" versions set the third argument to EFAULT if an
- * error occurs, and leave it unchanged on success.  Note that these
- * versions are void (ie, don't return a value as such).
  */
-
 extern int __get_user_1(void *);
 extern int __get_user_2(void *);
 extern int __get_user_4(void *);
-extern int __get_user_bad(void);
 
 #define __get_user_x(__r2,__p,__e,__s,__i...)                           \
            __asm__ __volatile__ (                                       \
@@ -131,6 +128,74 @@ extern int __get_user_bad(void);
                 __e;                                                    \
         })
 
+extern int __put_user_1(void *, unsigned int);
+extern int __put_user_2(void *, unsigned int);
+extern int __put_user_4(void *, unsigned int);
+extern int __put_user_8(void *, unsigned long long);
+
+#define __put_user_x(__r2,__p,__e,__s)                                  \
+           __asm__ __volatile__ (                                       \
+                __asmeq("%0", "r0") __asmeq("%2", "r2")                 \
+                "bl     __put_user_" #__s                               \
+                : "=&r" (__e)                                           \
+                : "0" (__p), "r" (__r2)                                 \
+                : "ip", "lr", "cc")
+
+#define put_user(x,p)                                                   \
+        ({                                                              \
+                const register typeof(*(p)) __r2 asm("r2") = (x);       \
+                const register typeof(*(p)) __user *__p asm("r0") = (p);\
+                register int __e asm("r0");                             \
+                switch (sizeof(*(__p))) {                               \
+                case 1:                                                 \
+                        __put_user_x(__r2, __p, __e, 1);                \
+                        break;                                          \
+                case 2:                                                 \
+                        __put_user_x(__r2, __p, __e, 2);                \
+                        break;                                          \
+                case 4:                                                 \
+                        __put_user_x(__r2, __p, __e, 4);                \
+                        break;                                          \
+                case 8:                                                 \
+                        __put_user_x(__r2, __p, __e, 8);                \
+                        break;                                          \
+                default: __e = __put_user_bad(); break;                 \
+                }                                                       \
+                __e;                                                    \
+        })
+
+#else /* CONFIG_MMU */
+
+/*
+ * uClinux has only one addr space, so has simplified address limits.
+ */
+#define USER_DS                 KERNEL_DS
+
+#define segment_eq(a,b)         (1)
+#define __addr_ok(addr)         (1)
+#define __range_ok(addr,size)   (0)
+#define get_fs()                (KERNEL_DS)
+
+static inline void set_fs(mm_segment_t fs)
+{
+}
+
+#define get_user(x,p)   __get_user(x,p)
+#define put_user(x,p)   __put_user(x,p)
+
+#endif /* CONFIG_MMU */
+
+#define access_ok(type,addr,size)       (__range_ok(addr,size) == 0)
+
+/*
+ * The "__xxx" versions of the user access functions do not verify the
+ * address space - it must have been done previously with a separate
+ * "access_ok()" call.
+ *
+ * The "xxx_error" versions set the third argument to EFAULT if an
+ * error occurs, and leave it unchanged on success.  Note that these
+ * versions are void (ie, don't return a value as such).
+ */
 #define __get_user(x,ptr)                                               \
 ({                                                                      \
         long __gu_err = 0;                                              \
@@ -212,43 +277,6 @@ do {									\
         : "r" (addr), "i" (-EFAULT)                             \
         : "cc")
 
-extern int __put_user_1(void *, unsigned int);
-extern int __put_user_2(void *, unsigned int);
-extern int __put_user_4(void *, unsigned int);
-extern int __put_user_8(void *, unsigned long long);
-extern int __put_user_bad(void);
-
-#define __put_user_x(__r2,__p,__e,__s)                                  \
-           __asm__ __volatile__ (                                       \
-                __asmeq("%0", "r0") __asmeq("%2", "r2")                 \
-                "bl     __put_user_" #__s                               \
-                : "=&r" (__e)                                           \
-                : "0" (__p), "r" (__r2)                                 \
-                : "ip", "lr", "cc")
-
-#define put_user(x,p)                                                   \
-        ({                                                              \
-                const register typeof(*(p)) __r2 asm("r2") = (x);       \
-                const register typeof(*(p)) __user *__p asm("r0") = (p);\
-                register int __e asm("r0");                             \
-                switch (sizeof(*(__p))) {                               \
-                case 1:                                                 \
-                        __put_user_x(__r2, __p, __e, 1);                \
-                        break;                                          \
-                case 2:                                                 \
-                        __put_user_x(__r2, __p, __e, 2);                \
-                        break;                                          \
-                case 4:                                                 \
-                        __put_user_x(__r2, __p, __e, 4);                \
-                        break;                                          \
-                case 8:                                                 \
-                        __put_user_x(__r2, __p, __e, 8);                \
-                        break;                                          \
-                default: __e = __put_user_bad(); break;                 \
-                }                                                       \
-                __e;                                                    \
-        })
-
 #define __put_user(x,ptr)                                               \
 ({                                                                      \
         long __pu_err = 0;                                              \
@@ -353,66 +381,54 @@ do {									\
         : "r" (x), "i" (-EFAULT)                                \
         : "cc")
 
-extern unsigned long __arch_copy_from_user(void *to, const void __user *from, unsigned long n);
-extern unsigned long __arch_copy_to_user(void __user *to, const void *from, unsigned long n);
-extern unsigned long __arch_clear_user(void __user *addr, unsigned long n);
-extern unsigned long __arch_strncpy_from_user(char *to, const char __user *from, unsigned long count);
-extern unsigned long __arch_strnlen_user(const char __user *s, long n);
+
+#ifdef CONFIG_MMU
+extern unsigned long __copy_from_user(void *to, const void __user *from, unsigned long n);
+extern unsigned long __copy_to_user(void __user *to, const void *from, unsigned long n);
+extern unsigned long __clear_user(void __user *addr, unsigned long n);
+#else
+#define __copy_from_user(to,from,n)     (memcpy(to, (void __force *)from, n), 0)
+#define __copy_to_user(to,from,n)       (memcpy((void __force *)to, from, n), 0)
+#define __clear_user(addr,n)            (memset((void __force *)addr, 0, n), 0)
+#endif
+
+extern unsigned long __strncpy_from_user(char *to, const char __user *from, unsigned long count);
+extern unsigned long __strnlen_user(const char __user *s, long n);
 
 static inline unsigned long copy_from_user(void *to, const void __user *from, unsigned long n)
 {
         if (access_ok(VERIFY_READ, from, n))
-                n = __arch_copy_from_user(to, from, n);
+                n = __copy_from_user(to, from, n);
         else /* security hole - plug it */
                 memzero(to, n);
         return n;
 }
 
-static inline unsigned long __copy_from_user(void *to, const void __user *from, unsigned long n)
-{
-        return __arch_copy_from_user(to, from, n);
-}
-
 static inline unsigned long copy_to_user(void __user *to, const void *from, unsigned long n)
 {
         if (access_ok(VERIFY_WRITE, to, n))
-                n = __arch_copy_to_user(to, from, n);
+                n = __copy_to_user(to, from, n);
         return n;
 }
 
-static inline unsigned long __copy_to_user(void __user *to, const void *from, unsigned long n)
-{
-        return __arch_copy_to_user(to, from, n);
-}
-
 #define __copy_to_user_inatomic __copy_to_user
 #define __copy_from_user_inatomic __copy_from_user
 
-static inline unsigned long clear_user (void __user *to, unsigned long n)
+static inline unsigned long clear_user(void __user *to, unsigned long n)
 {
         if (access_ok(VERIFY_WRITE, to, n))
-                n = __arch_clear_user(to, n);
+                n = __clear_user(to, n);
         return n;
 }
 
-static inline unsigned long __clear_user (void __user *to, unsigned long n)
-{
-        return __arch_clear_user(to, n);
-}
-
-static inline long strncpy_from_user (char *dst, const char __user *src, long count)
+static inline long strncpy_from_user(char *dst, const char __user *src, long count)
 {
         long res = -EFAULT;
         if (access_ok(VERIFY_READ, src, 1))
-                res = __arch_strncpy_from_user(dst, src, count);
+                res = __strncpy_from_user(dst, src, count);
         return res;
 }
 
-static inline long __strncpy_from_user (char *dst, const char __user *src, long count)
-{
-        return __arch_strncpy_from_user(dst, src, count);
-}
-
 #define strlen_user(s)  strnlen_user(s, ~0UL >> 1)
 
 static inline long strnlen_user(const char __user *s, long n)
@@ -420,7 +436,7 @@ static inline long strnlen_user(const char __user *s, long n)
         unsigned long res = 0;
 
         if (__addr_ok(s))
-                res = __arch_strnlen_user(s, n);
+                res = __strnlen_user(s, n);
 
         return res;
 }
diff --git a/include/asm-arm/ucontext.h b/include/asm-arm/ucontext.h
index 9e6f7ca9f5ae..bf65e9f4525d 100644
--- a/include/asm-arm/ucontext.h
+++ b/include/asm-arm/ucontext.h
@@ -35,6 +35,17 @@ struct ucontext {
  * bytes, to prevent unpredictable padding in the signal frame.
  */
 
+#ifdef CONFIG_CRUNCH
+#define CRUNCH_MAGIC            0x5065cf03
+#define CRUNCH_STORAGE_SIZE     (CRUNCH_SIZE + 8)
+
+struct crunch_sigframe {
+        unsigned long   magic;
+        unsigned long   size;
+        struct crunch_state     storage;
+} __attribute__((__aligned__(8)));
+#endif
+
 #ifdef CONFIG_IWMMXT
 /* iwmmxt_area is 0x98 bytes long, preceeded by 8 bytes of signature */
 #define IWMMXT_MAGIC            0x12ef842a
@@ -74,6 +85,9 @@ struct vfp_sigframe
  * one of these.
  */
 struct aux_sigframe {
+#ifdef CONFIG_CRUNCH
+        struct crunch_sigframe  crunch;
+#endif
 #ifdef CONFIG_IWMMXT
         struct iwmmxt_sigframe  iwmmxt;
 #endif
diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h
index 9d11550b4818..db5a3732f106 100644
--- a/include/asm-generic/vmlinux.lds.h
+++ b/include/asm-generic/vmlinux.lds.h
@@ -58,6 +58,20 @@
                 VMLINUX_SYMBOL(__stop___ksymtab_gpl) = .;               \
         }                                                               \
                                                                         \
+        /* Kernel symbol table: Normal unused symbols */                \
+        __ksymtab_unused  : AT(ADDR(__ksymtab_unused) - LOAD_OFFSET) {  \
+                VMLINUX_SYMBOL(__start___ksymtab_unused) = .;           \
+                *(__ksymtab_unused)                                     \
+                VMLINUX_SYMBOL(__stop___ksymtab_unused) = .;            \
+        }                                                               \
+                                                                        \
+        /* Kernel symbol table: GPL-only unused symbols */              \
+        __ksymtab_unused_gpl : AT(ADDR(__ksymtab_unused_gpl) - LOAD_OFFSET) { \
+                VMLINUX_SYMBOL(__start___ksymtab_unused_gpl) = .;       \
+                *(__ksymtab_unused_gpl)                                 \
+                VMLINUX_SYMBOL(__stop___ksymtab_unused_gpl) = .;        \
+        }                                                               \
+                                                                        \
         /* Kernel symbol table: GPL-future-only symbols */              \
         __ksymtab_gpl_future : AT(ADDR(__ksymtab_gpl_future) - LOAD_OFFSET) { \
                 VMLINUX_SYMBOL(__start___ksymtab_gpl_future) = .;       \
@@ -79,6 +93,20 @@
                 VMLINUX_SYMBOL(__stop___kcrctab_gpl) = .;               \
         }                                                               \
                                                                         \
+        /* Kernel symbol table: Normal unused symbols */                \
+        __kcrctab_unused  : AT(ADDR(__kcrctab_unused) - LOAD_OFFSET) {  \
+                VMLINUX_SYMBOL(__start___kcrctab_unused) = .;           \
+                *(__kcrctab_unused)                                     \
+                VMLINUX_SYMBOL(__stop___kcrctab_unused) = .;            \
+        }                                                               \
+                                                                        \
+        /* Kernel symbol table: GPL-only unused symbols */              \
+        __kcrctab_unused_gpl : AT(ADDR(__kcrctab_unused_gpl) - LOAD_OFFSET) { \
+                VMLINUX_SYMBOL(__start___kcrctab_unused_gpl) = .;       \
+                *(__kcrctab_unused_gpl)                                 \
+                VMLINUX_SYMBOL(__stop___kcrctab_unused_gpl) = .;        \
+        }                                                               \
+                                                                        \
         /* Kernel symbol table: GPL-future-only symbols */              \
         __kcrctab_gpl_future : AT(ADDR(__kcrctab_gpl_future) - LOAD_OFFSET) { \
                 VMLINUX_SYMBOL(__start___kcrctab_gpl_future) = .;       \
diff --git a/include/asm-ia64/sn/sn_sal.h b/include/asm-ia64/sn/sn_sal.h
index cd490b20d592..bd4452bda357 100644
--- a/include/asm-ia64/sn/sn_sal.h
+++ b/include/asm-ia64/sn/sn_sal.h
@@ -85,6 +85,7 @@
 #define  SN_SAL_GET_PROM_FEATURE_SET               0x02000065
 #define  SN_SAL_SET_OS_FEATURE_SET                 0x02000066
 #define  SN_SAL_INJECT_ERROR                       0x02000067
+#define  SN_SAL_SET_CPU_NUMBER                     0x02000068
 
 /*
  * Service-specific constants
@@ -1150,4 +1151,13 @@ sn_inject_error(u64 paddr, u64 *data, u64 *ecc)
         local_irq_restore(irq_flags);
         return ret_stuff.status;
 }
+
+static inline int
+ia64_sn_set_cpu_number(int cpu)
+{
+        struct ia64_sal_retval rv;
+
+        SAL_CALL_NOLOCK(rv, SN_SAL_SET_CPU_NUMBER, cpu, 0, 0, 0, 0, 0, 0);
+        return rv.status;
+}
 #endif /* _ASM_IA64_SN_SN_SAL_H */
diff --git a/include/asm-m68knommu/bootstd.h b/include/asm-m68knommu/bootstd.h
index 3fdc79f06d50..bdc1a4ac4fe9 100644
--- a/include/asm-m68knommu/bootstd.h
+++ b/include/asm-m68knommu/bootstd.h
@@ -52,7 +52,7 @@ type name(void) \
    __asm__ __volatile__ ("trap #2" \
                          : "=g" (__res) \
                          : "0" (__res) \
-                         : "%d0"); \
+                         ); \
    __bsc_return(type,__res); \
 }
 
@@ -64,7 +64,7 @@ type name(atype a) \
    __asm__ __volatile__ ("trap #2" \
                          : "=g" (__res) \
                          : "0" (__res), "d" (__a) \
-                         : "%d0"); \
+                         ); \
    __bsc_return(type,__res); \
 }
 
@@ -77,7 +77,7 @@ type name(atype a, btype b) \
    __asm__ __volatile__ ("trap #2" \
                          : "=g" (__res) \
                          : "0" (__res), "d" (__a), "d" (__b) \
-                         : "%d0"); \
+                         ); \
    __bsc_return(type,__res); \
 }
 
@@ -92,7 +92,7 @@ type name(atype a, btype b, ctype c) \
                          : "=g" (__res) \
                          : "0" (__res), "d" (__a), "d" (__b), \
                            "d" (__c) \
-                         : "%d0"); \
+                         ); \
    __bsc_return(type,__res); \
 }
 
@@ -108,7 +108,7 @@ type name(atype a, btype b, ctype c, dtype d) \
                          : "=g" (__res) \
                          : "0" (__res), "d" (__a), "d" (__b), \
                            "d" (__c), "d" (__d) \
-                         : "%d0"); \
+                         ); \
    __bsc_return(type,__res); \
 }
 
@@ -125,7 +125,7 @@ type name(atype a, btype b, ctype c, dtype d, etype e) \
                          : "=g" (__res) \
                          : "0" (__res), "d" (__a), "d" (__b), \
                            "d" (__c), "d" (__d), "d" (__e) \
-                         : "%d0"); \
+                         ); \
    __bsc_return(type,__res); \
 }
 
diff --git a/include/linux/ac97_codec.h b/include/linux/ac97_codec.h
index c35833824e11..2ed2fd855133 100644
--- a/include/linux/ac97_codec.h
+++ b/include/linux/ac97_codec.h
@@ -259,7 +259,7 @@ struct ac97_codec {
         int type;
         u32 model;
 
-        int modem:1;
+        unsigned int modem:1;
 
         struct ac97_ops *codec_ops;
 
diff --git a/include/linux/coda_linux.h b/include/linux/coda_linux.h
index 7b5c5df5cb69..be512cc98791 100644
--- a/include/linux/coda_linux.h
+++ b/include/linux/coda_linux.h
@@ -27,8 +27,8 @@ extern struct inode_operations coda_dir_inode_operations;
 extern struct inode_operations coda_file_inode_operations;
 extern struct inode_operations coda_ioctl_inode_operations;
 
-extern struct address_space_operations coda_file_aops;
-extern struct address_space_operations coda_symlink_aops;
+extern const struct address_space_operations coda_file_aops;
+extern const struct address_space_operations coda_symlink_aops;
 
 extern const struct file_operations coda_dir_operations;
 extern const struct file_operations coda_file_operations;
diff --git a/include/linux/efs_fs.h b/include/linux/efs_fs.h
index fbfa6b52e2fb..278ef4495819 100644
--- a/include/linux/efs_fs.h
+++ b/include/linux/efs_fs.h
@@ -38,7 +38,7 @@ struct statfs;
 
 extern struct inode_operations efs_dir_inode_operations;
 extern const struct file_operations efs_dir_operations;
-extern struct address_space_operations efs_symlink_aops;
+extern const struct address_space_operations efs_symlink_aops;
 
 extern void efs_read_inode(struct inode *);
 extern efs_block_t efs_map_block(struct inode *, efs_block_t);
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 2d8b348c1192..e04a5cfe874f 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -392,7 +392,7 @@ struct address_space {
         unsigned int            truncate_count; /* Cover race condition with truncate */
         unsigned long           nrpages;        /* number of total pages */
         pgoff_t                 writeback_index;/* writeback starts here */
-        struct address_space_operations *a_ops; /* methods */
+        const struct address_space_operations *a_ops;   /* methods */
         unsigned long           flags;          /* error bits/gfp mask */
         struct backing_dev_info *backing_dev_info; /* device readahead, etc */
         spinlock_t              private_lock;   /* for use by the address_space */
@@ -1405,7 +1405,7 @@ extern void bd_forget(struct inode *inode);
 extern void bdput(struct block_device *);
 extern struct block_device *open_by_devnum(dev_t, unsigned);
 extern const struct file_operations def_blk_fops;
-extern struct address_space_operations def_blk_aops;
+extern const struct address_space_operations def_blk_aops;
 extern const struct file_operations def_chr_fops;
 extern const struct file_operations bad_sock_fops;
 extern const struct file_operations def_fifo_fops;
diff --git a/include/linux/ide.h b/include/linux/ide.h
index ef7bef207f48..0c100168c0cf 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -793,6 +793,7 @@ typedef struct hwif_s {
         unsigned        auto_poll  : 1; /* supports nop auto-poll */
         unsigned        sg_mapped  : 1; /* sg_table and sg_nents are ready */
         unsigned        no_io_32bit : 1; /* 1 = can not do 32-bit IO ops */
+        unsigned        err_stops_fifo : 1; /* 1=data FIFO is cleared by an error */
 
         struct device   gendev;
         struct completion gendev_rel_comp; /* To deal with device release() */
diff --git a/include/linux/kbd_kern.h b/include/linux/kbd_kern.h
index 4eb851ece080..efe0ee4cc80b 100644
--- a/include/linux/kbd_kern.h
+++ b/include/linux/kbd_kern.h
@@ -155,10 +155,8 @@ static inline void con_schedule_flip(struct tty_struct *t)
 {
         unsigned long flags;
         spin_lock_irqsave(&t->buf.lock, flags);
-        if (t->buf.tail != NULL) {
-                t->buf.tail->active = 0;
+        if (t->buf.tail != NULL)
                 t->buf.tail->commit = t->buf.tail->used;
-        }
         spin_unlock_irqrestore(&t->buf.lock, flags);
         schedule_work(&t->buf.work);
 }
diff --git a/include/linux/module.h b/include/linux/module.h
index 9ebbb74b7b72..9e9dc7c24d95 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -203,6 +203,15 @@ void *__symbol_get_gpl(const char *symbol);
 #define EXPORT_SYMBOL_GPL_FUTURE(sym)                           \
         __EXPORT_SYMBOL(sym, "_gpl_future")
 
+
+#ifdef CONFIG_UNUSED_SYMBOLS
+#define EXPORT_UNUSED_SYMBOL(sym) __EXPORT_SYMBOL(sym, "_unused")
+#define EXPORT_UNUSED_SYMBOL_GPL(sym) __EXPORT_SYMBOL(sym, "_unused_gpl")
+#else
+#define EXPORT_UNUSED_SYMBOL(sym)
+#define EXPORT_UNUSED_SYMBOL_GPL(sym)
+#endif
+
 #endif
 
 struct module_ref
@@ -261,6 +270,15 @@ struct module
         unsigned int num_gpl_syms;
         const unsigned long *gpl_crcs;
 
+        /* unused exported symbols. */
+        const struct kernel_symbol *unused_syms;
+        unsigned int num_unused_syms;
+        const unsigned long *unused_crcs;
+        /* GPL-only, unused exported symbols. */
+        const struct kernel_symbol *unused_gpl_syms;
+        unsigned int num_unused_gpl_syms;
+        const unsigned long *unused_gpl_crcs;
+
         /* symbols that will be GPL-only in the near future. */
         const struct kernel_symbol *gpl_future_syms;
         unsigned int num_gpl_future_syms;
@@ -456,6 +474,8 @@ void module_remove_driver(struct device_driver *);
 #define EXPORT_SYMBOL(sym)
 #define EXPORT_SYMBOL_GPL(sym)
 #define EXPORT_SYMBOL_GPL_FUTURE(sym)
+#define EXPORT_UNUSED_SYMBOL(sym)
+#define EXPORT_UNUSED_SYMBOL_GPL(sym)
 
 /* Given an address, look for it in the exception tables. */
 static inline const struct exception_table_entry *
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 0a1740b2532e..d90b1bb37563 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -335,7 +335,7 @@ extern struct inode_operations nfs_file_inode_operations;
 extern struct inode_operations nfs3_file_inode_operations;
 #endif /* CONFIG_NFS_V3 */
 extern const struct file_operations nfs_file_operations;
-extern struct address_space_operations nfs_file_aops;
+extern const struct address_space_operations nfs_file_aops;
 
 static inline struct rpc_cred *nfs_file_cred(struct file *file)
 {
diff --git a/include/linux/plist.h b/include/linux/plist.h
index 3404faef542c..b95818a037ad 100644
--- a/include/linux/plist.h
+++ b/include/linux/plist.h
@@ -73,6 +73,7 @@
 #ifndef _LINUX_PLIST_H_
 #define _LINUX_PLIST_H_
 
+#include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/spinlock_types.h>
 
diff --git a/include/linux/reiserfs_fs.h b/include/linux/reiserfs_fs.h
index 5676c4210e2c..daa2d83cefe8 100644
--- a/include/linux/reiserfs_fs.h
+++ b/include/linux/reiserfs_fs.h
@@ -1973,7 +1973,7 @@ void reiserfs_unmap_buffer(struct buffer_head *);
 /* file.c */
 extern struct inode_operations reiserfs_file_inode_operations;
 extern const struct file_operations reiserfs_file_operations;
-extern struct address_space_operations reiserfs_address_space_operations;
+extern const struct address_space_operations reiserfs_address_space_operations;
 
 /* fix_nodes.c */
 
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
index e928c0dcc297..c8bb68099eb9 100644
--- a/include/linux/spi/spi.h
+++ b/include/linux/spi/spi.h
@@ -642,10 +642,14 @@ struct spi_board_info {
         u16             bus_num;
         u16             chip_select;
 
+        /* mode becomes spi_device.mode, and is essential for chips
+         * where the default of SPI_CS_HIGH = 0 is wrong.
+         */
+        u8              mode;
+
         /* ... may need additional spi_device chip config data here.
          * avoid stuff protocol drivers can set; but include stuff
          * needed to behave without being bound to a driver:
-         *  - chipselect polarity
          *  - quirks like clock rate mattering when not selected
          */
 };
diff --git a/include/linux/tty.h b/include/linux/tty.h
index cb35ca50a0a6..b3b807e4b050 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -57,7 +57,6 @@ struct tty_buffer {
         unsigned char *flag_buf_ptr;
         int used;
         int size;
-        int active;
         int commit;
         int read;
         /* Data points here */
@@ -259,7 +258,6 @@ struct tty_struct {
 #define TTY_DO_WRITE_WAKEUP     5       /* Call write_wakeup after queuing new */
 #define TTY_PUSH                6       /* n_tty private */
 #define TTY_CLOSING             7       /* ->close() in progress */
-#define TTY_DONT_FLIP           8       /* Defer buffer flip */
 #define TTY_LDISC               9       /* Line discipline attached */
 #define TTY_HW_COOK_OUT         14      /* Hardware can do output cooking */
 #define TTY_HW_COOK_IN          15      /* Hardware can do input cooking */
diff --git a/include/linux/tty_flip.h b/include/linux/tty_flip.h
index 31548303ee37..eb677cf56106 100644
--- a/include/linux/tty_flip.h
+++ b/include/linux/tty_flip.h
@@ -12,7 +12,7 @@ static inline int tty_insert_flip_char(struct tty_struct *tty,
                                         unsigned char ch, char flag)
 {
         struct tty_buffer *tb = tty->buf.tail;
-        if (tb && tb->active && tb->used < tb->size) {
+        if (tb && tb->used < tb->size) {
                 tb->flag_buf_ptr[tb->used] = flag;
                 tb->char_buf_ptr[tb->used++] = ch;
                 return 1;
diff --git a/include/linux/ufs_fs.h b/include/linux/ufs_fs.h
index 914f911325be..e39b7cc43390 100644
--- a/include/linux/ufs_fs.h
+++ b/include/linux/ufs_fs.h
@@ -966,7 +966,7 @@ extern void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de,
 extern struct inode_operations ufs_file_inode_operations;
 extern const struct file_operations ufs_file_operations;
 
-extern struct address_space_operations ufs_aops;
+extern const struct address_space_operations ufs_aops;
 
 /* ialloc.c */
 extern void ufs_free_inode (struct inode *inode);
diff --git a/include/linux/watchdog.h b/include/linux/watchdog.h
index 1192ed8f4fe8..011bcfeb9f09 100644
--- a/include/linux/watchdog.h
+++ b/include/linux/watchdog.h
@@ -28,6 +28,9 @@ struct watchdog_info {
 #define WDIOC_KEEPALIVE         _IOR(WATCHDOG_IOCTL_BASE, 5, int)
 #define WDIOC_SETTIMEOUT        _IOWR(WATCHDOG_IOCTL_BASE, 6, int)
 #define WDIOC_GETTIMEOUT        _IOR(WATCHDOG_IOCTL_BASE, 7, int)
+#define WDIOC_SETPRETIMEOUT     _IOWR(WATCHDOG_IOCTL_BASE, 8, int)
+#define WDIOC_GETPRETIMEOUT     _IOR(WATCHDOG_IOCTL_BASE, 9, int)
+#define WDIOC_GETTIMELEFT       _IOR(WATCHDOG_IOCTL_BASE, 10, int)
 
 #define WDIOF_UNKNOWN           -1      /* Unknown flag error */
 #define WDIOS_UNKNOWN           -1      /* Unknown status error */
@@ -38,9 +41,10 @@ struct watchdog_info {
 #define WDIOF_EXTERN2           0x0008  /* External relay 2 */
 #define WDIOF_POWERUNDER        0x0010  /* Power bad/power fault */
 #define WDIOF_CARDRESET         0x0020  /* Card previously reset the CPU */
-#define WDIOF_POWEROVER         0x0040  /* Power over voltage */
-#define WDIOF_SETTIMEOUT        0x0080  /* Set timeout (in seconds) */
-#define WDIOF_MAGICCLOSE        0x0100  /* Supports magic close char */
+#define WDIOF_POWEROVER         0x0040  /* Power over voltage */
+#define WDIOF_SETTIMEOUT        0x0080  /* Set timeout (in seconds) */
+#define WDIOF_MAGICCLOSE        0x0100  /* Supports magic close char */
+#define WDIOF_PRETIMEOUT        0x0200  /* Pretimeout (in seconds), get/set */
 #define WDIOF_KEEPALIVEPING     0x8000  /* Keep alive ping reply */
 
 #define WDIOS_DISABLECARD       0x0001  /* Turn off the watchdog timer */
diff --git a/kernel/module.c b/kernel/module.c
index 10e5b872adf6..99c022ac3d21 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -1,4 +1,4 @@
-/* Rewritten by Rusty Russell, on the backs of many others...
+/*
    Copyright (C) 2002 Richard Henderson
    Copyright (C) 2001 Rusty Russell, 2002 Rusty Russell IBM.
 
@@ -122,9 +122,17 @@ extern const struct kernel_symbol __start___ksymtab_gpl[];
 extern const struct kernel_symbol __stop___ksymtab_gpl[];
 extern const struct kernel_symbol __start___ksymtab_gpl_future[];
 extern const struct kernel_symbol __stop___ksymtab_gpl_future[];
+extern const struct kernel_symbol __start___ksymtab_unused[];
+extern const struct kernel_symbol __stop___ksymtab_unused[];
+extern const struct kernel_symbol __start___ksymtab_unused_gpl[];
+extern const struct kernel_symbol __stop___ksymtab_unused_gpl[];
+extern const struct kernel_symbol __start___ksymtab_gpl_future[];
+extern const struct kernel_symbol __stop___ksymtab_gpl_future[];
 extern const unsigned long __start___kcrctab[];
 extern const unsigned long __start___kcrctab_gpl[];
 extern const unsigned long __start___kcrctab_gpl_future[];
+extern const unsigned long __start___kcrctab_unused[];
+extern const unsigned long __start___kcrctab_unused_gpl[];
 
 #ifndef CONFIG_MODVERSIONS
 #define symversion(base, idx) NULL
@@ -144,6 +152,17 @@ static const struct kernel_symbol *lookup_symbol(const char *name,
         return NULL;
 }
 
+static void printk_unused_warning(const char *name)
+{
+        printk(KERN_WARNING "Symbol %s is marked as UNUSED, "
+                "however this module is using it.\n", name);
+        printk(KERN_WARNING "This symbol will go away in the future.\n");
+        printk(KERN_WARNING "Please evalute if this is the right api to use, "
+                "and if it really is, submit a report the linux kernel "
+                "mailinglist together with submitting your code for "
+                "inclusion.\n");
+}
+
 /* Find a symbol, return value, crc and module which owns it */
 static unsigned long __find_symbol(const char *name,
                                    struct module **owner,
@@ -186,6 +205,25 @@ static unsigned long __find_symbol(const char *name,
                 return ks->value;
         }
 
+        ks = lookup_symbol(name, __start___ksymtab_unused,
+                                 __stop___ksymtab_unused);
+        if (ks) {
+                printk_unused_warning(name);
+                *crc = symversion(__start___kcrctab_unused,
+                                  (ks - __start___ksymtab_unused));
+                return ks->value;
+        }
+
+        if (gplok)
+                ks = lookup_symbol(name, __start___ksymtab_unused_gpl,
+                                 __stop___ksymtab_unused_gpl);
+        if (ks) {
+                printk_unused_warning(name);
+                *crc = symversion(__start___kcrctab_unused_gpl,
+                                  (ks - __start___ksymtab_unused_gpl));
+                return ks->value;
+        }
+
         /* Now try modules. */ 
         list_for_each_entry(mod, &modules, list) {
                 *owner = mod;
@@ -204,6 +242,23 @@ static unsigned long __find_symbol(const char *name,
                                 return ks->value;
                         }
                 }
+                ks = lookup_symbol(name, mod->unused_syms, mod->unused_syms + mod->num_unused_syms);
+                if (ks) {
+                        printk_unused_warning(name);
+                        *crc = symversion(mod->unused_crcs, (ks - mod->unused_syms));
+                        return ks->value;
+                }
+
+                if (gplok) {
+                        ks = lookup_symbol(name, mod->unused_gpl_syms,
+                                           mod->unused_gpl_syms + mod->num_unused_gpl_syms);
+                        if (ks) {
+                                printk_unused_warning(name);
+                                *crc = symversion(mod->unused_gpl_crcs,
+                                                  (ks - mod->unused_gpl_syms));
+                                return ks->value;
+                        }
+                }
                 ks = lookup_symbol(name, mod->gpl_future_syms,
                                    (mod->gpl_future_syms +
                                     mod->num_gpl_future_syms));
@@ -1403,10 +1458,27 @@ static struct module *load_module(void __user *umod,
         Elf_Ehdr *hdr;
         Elf_Shdr *sechdrs;
         char *secstrings, *args, *modmagic, *strtab = NULL;
-        unsigned int i, symindex = 0, strindex = 0, setupindex, exindex,
-                exportindex, modindex, obsparmindex, infoindex, gplindex,
-                crcindex, gplcrcindex, versindex, pcpuindex, gplfutureindex,
-                gplfuturecrcindex, unwindex = 0;
+        unsigned int i;
+        unsigned int symindex = 0;
+        unsigned int strindex = 0;
+        unsigned int setupindex;
+        unsigned int exindex;
+        unsigned int exportindex;
+        unsigned int modindex;
+        unsigned int obsparmindex;
+        unsigned int infoindex;
+        unsigned int gplindex;
+        unsigned int crcindex;
+        unsigned int gplcrcindex;
+        unsigned int versindex;
+        unsigned int pcpuindex;
+        unsigned int gplfutureindex;
+        unsigned int gplfuturecrcindex;
+        unsigned int unwindex = 0;
+        unsigned int unusedindex;
+        unsigned int unusedcrcindex;
+        unsigned int unusedgplindex;
+        unsigned int unusedgplcrcindex;
         struct module *mod;
         long err = 0;
         void *percpu = NULL, *ptr = NULL; /* Stops spurious gcc warning */
@@ -1487,9 +1559,13 @@ static struct module *load_module(void __user *umod,
         exportindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab");
         gplindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_gpl");
         gplfutureindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_gpl_future");
+        unusedindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_unused");
+        unusedgplindex = find_sec(hdr, sechdrs, secstrings, "__ksymtab_unused_gpl");
         crcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab");
         gplcrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_gpl");
         gplfuturecrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_gpl_future");
+        unusedcrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_unused");
+        unusedgplcrcindex = find_sec(hdr, sechdrs, secstrings, "__kcrctab_unused_gpl");
         setupindex = find_sec(hdr, sechdrs, secstrings, "__param");
         exindex = find_sec(hdr, sechdrs, secstrings, "__ex_table");
         obsparmindex = find_sec(hdr, sechdrs, secstrings, "__obsparm");
@@ -1638,14 +1714,27 @@ static struct module *load_module(void __user *umod,
                 mod->gpl_crcs = (void *)sechdrs[gplcrcindex].sh_addr;
         mod->num_gpl_future_syms = sechdrs[gplfutureindex].sh_size /
                                         sizeof(*mod->gpl_future_syms);
+        mod->num_unused_syms = sechdrs[unusedindex].sh_size /
+                                        sizeof(*mod->unused_syms);
+        mod->num_unused_gpl_syms = sechdrs[unusedgplindex].sh_size /
+                                        sizeof(*mod->unused_gpl_syms);
         mod->gpl_future_syms = (void *)sechdrs[gplfutureindex].sh_addr;
         if (gplfuturecrcindex)
                 mod->gpl_future_crcs = (void *)sechdrs[gplfuturecrcindex].sh_addr;
 
+        mod->unused_syms = (void *)sechdrs[unusedindex].sh_addr;
+        if (unusedcrcindex)
+                mod->unused_crcs = (void *)sechdrs[unusedcrcindex].sh_addr;
+        mod->unused_gpl_syms = (void *)sechdrs[unusedgplindex].sh_addr;
+        if (unusedgplcrcindex)
+                mod->unused_crcs = (void *)sechdrs[unusedgplcrcindex].sh_addr;
+
 #ifdef CONFIG_MODVERSIONS
         if ((mod->num_syms && !crcindex) || 
             (mod->num_gpl_syms && !gplcrcindex) ||
-            (mod->num_gpl_future_syms && !gplfuturecrcindex)) {
+            (mod->num_gpl_future_syms && !gplfuturecrcindex) ||
+            (mod->num_unused_syms && !unusedcrcindex) ||
+            (mod->num_unused_gpl_syms && !unusedgplcrcindex)) {
                 printk(KERN_WARNING "%s: No versions for exported symbols."
                        " Tainting kernel.\n", mod->name);
                 add_taint(TAINT_FORCED_MODULE);
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 5330911ebd30..e4fcbd12cf6e 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -23,6 +23,22 @@ config MAGIC_SYSRQ
           keys are documented in <file:Documentation/sysrq.txt>. Don't say Y
           unless you really know what this hack does.
 
+config UNUSED_SYMBOLS
+        bool "Enable unused/obsolete exported symbols"
+        default y if X86
+        help
+          Unused but exported symbols make the kernel needlessly bigger.  For
+          that reason most of these unused exports will soon be removed.  This
+          option is provided temporarily to provide a transition period in case
+          some external kernel module needs one of these symbols anyway. If you
+          encounter such a case in your module, consider if you are actually
+          using the right API.  (rationale: since nobody in the kernel is using
+          this in a module, there is a pretty good chance it's actually the
+          wrong interface to use).  If you really need the symbol, please send a
+          mail to the linux kernel mailing list mentioning the symbol and why
+          you really need it, and what the merge plan to the mainline kernel for
+          your module is.
+
 config DEBUG_KERNEL
         bool "Kernel debugging"
         help
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index 797428afd111..bed7229378f2 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -489,7 +489,7 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
                 if (str < end)
                         *str = '\0';
                 else
-                        *end = '\0';
+                        end[-1] = '\0';
         }
         /* the trailing null byte doesn't count towards the total */
         return str-buf;
diff --git a/mm/filemap.c b/mm/filemap.c
index d504d6e98886..4082b3b3cea7 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -2069,7 +2069,7 @@ generic_file_buffered_write(struct kiocb *iocb, const struct iovec *iov,
 {
         struct file *file = iocb->ki_filp;
         struct address_space * mapping = file->f_mapping;
-        struct address_space_operations *a_ops = mapping->a_ops;
+        const struct address_space_operations *a_ops = mapping->a_ops;
         struct inode    *inode = mapping->host;
         long            status = 0;
         struct page     *page;
@@ -2219,7 +2219,7 @@ __generic_file_aio_write_nolock(struct kiocb *iocb, const struct iovec *iov,
                                 unsigned long nr_segs, loff_t *ppos)
 {
         struct file *file = iocb->ki_filp;
-        struct address_space * mapping = file->f_mapping;
+        const struct address_space * mapping = file->f_mapping;
         size_t ocount;          /* original count */
         size_t count;           /* after file limit checks */
         struct inode    *inode = mapping->host;
diff --git a/mm/filemap_xip.c b/mm/filemap_xip.c
index b960ac8e5918..b4fd0d7c9bfb 100644
--- a/mm/filemap_xip.c
+++ b/mm/filemap_xip.c
@@ -273,7 +273,7 @@ __xip_file_write(struct file *filp, const char __user *buf,
                   size_t count, loff_t pos, loff_t *ppos)
 {
         struct address_space * mapping = filp->f_mapping;
-        struct address_space_operations *a_ops = mapping->a_ops;
+        const struct address_space_operations *a_ops = mapping->a_ops;
         struct inode    *inode = mapping->host;
         long            status = 0;
         struct page     *page;
diff --git a/mm/shmem.c b/mm/shmem.c
index 38bc3334f263..ea64c07cbe72 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -174,7 +174,7 @@ static inline void shmem_unacct_blocks(unsigned long flags, long pages)
 }
 
 static struct super_operations shmem_ops;
-static struct address_space_operations shmem_aops;
+static const struct address_space_operations shmem_aops;
 static struct file_operations shmem_file_operations;
 static struct inode_operations shmem_inode_operations;
 static struct inode_operations shmem_dir_inode_operations;
@@ -2162,7 +2162,7 @@ static void destroy_inodecache(void)
                 printk(KERN_INFO "shmem_inode_cache: not all structures were freed\n");
 }
 
-static struct address_space_operations shmem_aops = {
+static const struct address_space_operations shmem_aops = {
         .writepage      = shmem_writepage,
         .set_page_dirty = __set_page_dirty_nobuffers,
 #ifdef CONFIG_TMPFS
diff --git a/mm/swap_state.c b/mm/swap_state.c
index e0e1583f32c2..7535211bb495 100644
--- a/mm/swap_state.c
+++ b/mm/swap_state.c
@@ -24,7 +24,7 @@
  * vmscan's shrink_list, to make sync_page look nicer, and to allow
  * future use of radix_tree tags in the swap cache.
  */
-static struct address_space_operations swap_aops = {
+static const struct address_space_operations swap_aops = {
         .writepage      = swap_writepage,
         .sync_page      = block_sync_page,
         .set_page_dirty = __set_page_dirty_nobuffers,
diff --git a/net/bluetooth/rfcomm/tty.c b/net/bluetooth/rfcomm/tty.c
index 74368f79ee5d..b81fad893328 100644
--- a/net/bluetooth/rfcomm/tty.c
+++ b/net/bluetooth/rfcomm/tty.c
@@ -480,12 +480,8 @@ static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb)
 
         BT_DBG("dlc %p tty %p len %d", dlc, tty, skb->len);
 
-        if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
-                tty_buffer_request_room(tty, skb->len);
-                tty_insert_flip_string(tty, skb->data, skb->len);
-                tty_flip_buffer_push(tty);
-        } else
-                tty->ldisc.receive_buf(tty, skb->data, NULL, skb->len);
+        tty_insert_flip_string(tty, skb->data, skb->len);
+        tty_flip_buffer_push(tty);
 
         kfree_skb(skb);
 }
diff --git a/sound/oss/cs4232.c b/sound/oss/cs4232.c
index c7f86f09c28d..80f6c08e26e7 100644
--- a/sound/oss/cs4232.c
+++ b/sound/oss/cs4232.c
@@ -405,7 +405,7 @@ static const struct pnp_device_id cs4232_pnp_table[] = {
 
 MODULE_DEVICE_TABLE(pnp, cs4232_pnp_table);
 
-static int cs4232_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *dev_id)
+static int __init cs4232_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *dev_id)
 {
         struct address_info *isapnpcfg;
 
diff --git a/sound/oss/via82cxxx_audio.c b/sound/oss/via82cxxx_audio.c
index 2343dedd44ae..29a6e0cff79f 100644
--- a/sound/oss/via82cxxx_audio.c
+++ b/sound/oss/via82cxxx_audio.c
@@ -309,7 +309,7 @@ struct via_info {
         unsigned sixchannel: 1; /* 8233/35 with 6 channel support */
         unsigned volume: 1;
 
-        int locked_rate : 1;
+        unsigned locked_rate : 1;
         
         int mixer_vol;          /* 8233/35 volume  - not yet implemented */