354 files changed, 13501 insertions, 9087 deletions

diff --git a/CREDITS b/CREDITS
index 9bf714a1c7d9..1d35f10ec3b2 100644
--- a/CREDITS
+++ b/CREDITS
@@ -1573,12 +1573,8 @@ S: 160 00 Praha 6
 S: Czech Republic
 
 N: Niels Kristian Bech Jensen
-E: nkbj@image.dk
-W: http://www.image.dk/~nkbj
+E: nkbj1970@hotmail.com
 D: Miscellaneous kernel updates and fixes.
-S: Dr. Holsts Vej 34, lejl. 164
-S: DK-8230 Åbyhøj
-S: Denmark
 
 N: Michael K. Johnson
 E: johnsonm@redhat.com
diff --git a/Documentation/DocBook/kernel-api.tmpl b/Documentation/DocBook/kernel-api.tmpl
index 31b727ceb127..3630a0d7695f 100644
--- a/Documentation/DocBook/kernel-api.tmpl
+++ b/Documentation/DocBook/kernel-api.tmpl
@@ -62,6 +62,8 @@
      <sect1><title>Internal Functions</title>
 !Ikernel/exit.c
 !Ikernel/signal.c
+!Iinclude/linux/kthread.h
+!Ekernel/kthread.c
      </sect1>
 
      <sect1><title>Kernel objects manipulation</title>
@@ -114,6 +116,29 @@ X!Ilib/string.c
      </sect1>
   </chapter>
 
+  <chapter id="kernel-lib">
+     <title>Basic Kernel Library Functions</title>
+
+     <para>
+       The Linux kernel provides more basic utility functions.
+     </para>
+
+     <sect1><title>Bitmap Operations</title>
+!Elib/bitmap.c
+!Ilib/bitmap.c
+     </sect1>
+
+     <sect1><title>Command-line Parsing</title>
+!Elib/cmdline.c
+     </sect1>
+
+     <sect1><title>CRC Functions</title>
+!Elib/crc16.c
+!Elib/crc32.c
+!Elib/crc-ccitt.c
+     </sect1>
+  </chapter>
+
   <chapter id="mm">
      <title>Memory Management in Linux</title>
      <sect1><title>The Slab Cache</title>
@@ -281,12 +306,13 @@ X!Ekernel/module.c
      <sect1><title>MTRR Handling</title>
 !Earch/i386/kernel/cpu/mtrr/main.c
      </sect1>
+
      <sect1><title>PCI Support Library</title>
 !Edrivers/pci/pci.c
 !Edrivers/pci/pci-driver.c
 !Edrivers/pci/remove.c
 !Edrivers/pci/pci-acpi.c
-<!-- kerneldoc does not understand to __devinit
+<!-- kerneldoc does not understand __devinit
 X!Edrivers/pci/search.c
  -->
 !Edrivers/pci/msi.c
@@ -315,6 +341,13 @@ X!Earch/i386/kernel/mca.c
      </sect1>
   </chapter>
 
+  <chapter id="firmware">
+     <title>Firmware Interfaces</title>
+     <sect1><title>DMI Interfaces</title>
+!Edrivers/firmware/dmi_scan.c
+     </sect1>
+  </chapter>
+
   <chapter id="devfs">
      <title>The Device File System</title>
 !Efs/devfs/base.c
@@ -403,7 +436,6 @@ X!Edrivers/pnp/system.c
      </sect1>
   </chapter>
 
-
   <chapter id="blkdev">
      <title>Block Devices</title>
 !Eblock/ll_rw_blk.c
@@ -414,6 +446,14 @@ X!Edrivers/pnp/system.c
 !Edrivers/char/misc.c
   </chapter>
 
+  <chapter id="parportdev">
+     <title>Parallel Port Devices</title>
+!Iinclude/linux/parport.h
+!Edrivers/parport/ieee1284.c
+!Edrivers/parport/share.c
+!Idrivers/parport/daisy.c
+  </chapter>
+
   <chapter id="viddev">
      <title>Video4Linux</title>
 !Edrivers/media/video/videodev.c
diff --git a/Documentation/RCU/checklist.txt b/Documentation/RCU/checklist.txt
index 49e27cc19385..1d50cf0c905e 100644
--- a/Documentation/RCU/checklist.txt
+++ b/Documentation/RCU/checklist.txt
@@ -144,9 +144,47 @@ over a rather long period of time, but improvements are always welcome!
         whether the increased speed is worth it.
 
 8.      Although synchronize_rcu() is a bit slower than is call_rcu(),
-        it usually results in simpler code.  So, unless update performance
-        is important or the updaters cannot block, synchronize_rcu()
-        should be used in preference to call_rcu().
+        it usually results in simpler code.  So, unless update
+        performance is critically important or the updaters cannot block,
+        synchronize_rcu() should be used in preference to call_rcu().
+
+        An especially important property of the synchronize_rcu()
+        primitive is that it automatically self-limits: if grace periods
+        are delayed for whatever reason, then the synchronize_rcu()
+        primitive will correspondingly delay updates.  In contrast,
+        code using call_rcu() should explicitly limit update rate in
+        cases where grace periods are delayed, as failing to do so can
+        result in excessive realtime latencies or even OOM conditions.
+
+        Ways of gaining this self-limiting property when using call_rcu()
+        include:
+
+        a.      Keeping a count of the number of data-structure elements
+                used by the RCU-protected data structure, including those
+                waiting for a grace period to elapse.  Enforce a limit
+                on this number, stalling updates as needed to allow
+                previously deferred frees to complete.
+
+                Alternatively, limit only the number awaiting deferred
+                free rather than the total number of elements.
+
+        b.      Limiting update rate.  For example, if updates occur only
+                once per hour, then no explicit rate limiting is required,
+                unless your system is already badly broken.  The dcache
+                subsystem takes this approach -- updates are guarded
+                by a global lock, limiting their rate.
+
+        c.      Trusted update -- if updates can only be done manually by
+                superuser or some other trusted user, then it might not
+                be necessary to automatically limit them.  The theory
+                here is that superuser already has lots of ways to crash
+                the machine.
+
+        d.      Use call_rcu_bh() rather than call_rcu(), in order to take
+                advantage of call_rcu_bh()'s faster grace periods.
+
+        e.      Periodically invoke synchronize_rcu(), permitting a limited
+                number of updates per grace period.
 
 9.      All RCU list-traversal primitives, which include
         list_for_each_rcu(), list_for_each_entry_rcu(),
diff --git a/Documentation/RCU/whatisRCU.txt b/Documentation/RCU/whatisRCU.txt
index 6e459420ee9f..4f41a60e5111 100644
--- a/Documentation/RCU/whatisRCU.txt
+++ b/Documentation/RCU/whatisRCU.txt
@@ -184,7 +184,17 @@ synchronize_rcu()
         blocking, it registers a function and argument which are invoked
         after all ongoing RCU read-side critical sections have completed.
         This callback variant is particularly useful in situations where
-        it is illegal to block.
+        it is illegal to block or where update-side performance is
+        critically important.
+
+        However, the call_rcu() API should not be used lightly, as use
+        of the synchronize_rcu() API generally results in simpler code.
+        In addition, the synchronize_rcu() API has the nice property
+        of automatically limiting update rate should grace periods
+        be delayed.  This property results in system resilience in face
+        of denial-of-service attacks.  Code using call_rcu() should limit
+        update rate in order to gain this same sort of resilience.  See
+        checklist.txt for some approaches to limiting the update rate.
 
 rcu_assign_pointer()
 
diff --git a/Documentation/devices.txt b/Documentation/devices.txt
index b2f593fc76ca..4aaf68fafebe 100644
--- a/Documentation/devices.txt
+++ b/Documentation/devices.txt
@@ -3,7 +3,7 @@
 
              Maintained by Torben Mathiasen <device@lanana.org>
 
-                      Last revised: 01 March 2006
+                      Last revised: 15 May 2006
 
 This list is the Linux Device List, the official registry of allocated
 device numbers and /dev directory nodes for the Linux operating
@@ -2791,6 +2791,7 @@ Your cooperation is appreciated.
                  170 = /dev/ttyNX0              Hilscher netX serial port 0
                     ...
                  185 = /dev/ttyNX15             Hilscher netX serial port 15
+                 186 = /dev/ttyJ0               JTAG1 DCC protocol based serial port emulation
 
 205 char        Low-density serial ports (alternate device)
                   0 = /dev/culu0                Callout device for ttyLU0
@@ -3108,6 +3109,10 @@ Your cooperation is appreciated.
                   ...
                 240 = /dev/rfdp         16th RFD FTL layer
 
+257 char        Phoenix Technologies Cryptographic Services Driver
+                  0 = /dev/ptlsec       Crypto Services Driver
+
+
 
  ****   ADDITIONAL /dev DIRECTORY ENTRIES
 
diff --git a/Documentation/filesystems/fuse.txt b/Documentation/filesystems/fuse.txt
index 33f74310d161..a584f05403a4 100644
--- a/Documentation/filesystems/fuse.txt
+++ b/Documentation/filesystems/fuse.txt
@@ -18,6 +18,14 @@ Non-privileged mount (or user mount):
   user.  NOTE: this is not the same as mounts allowed with the "user"
   option in /etc/fstab, which is not discussed here.
 
+Filesystem connection:
+
+  A connection between the filesystem daemon and the kernel.  The
+  connection exists until either the daemon dies, or the filesystem is
+  umounted.  Note that detaching (or lazy umounting) the filesystem
+  does _not_ break the connection, in this case it will exist until
+  the last reference to the filesystem is released.
+
 Mount owner:
 
   The user who does the mounting.
@@ -86,16 +94,20 @@ Mount options
   The default is infinite.  Note that the size of read requests is
   limited anyway to 32 pages (which is 128kbyte on i386).
 
-Sysfs
-~~~~~
+Control filesystem
+~~~~~~~~~~~~~~~~~~
+
+There's a control filesystem for FUSE, which can be mounted by:
 
-FUSE sets up the following hierarchy in sysfs:
+  mount -t fusectl none /sys/fs/fuse/connections
 
-  /sys/fs/fuse/connections/N/
+Mounting it under the '/sys/fs/fuse/connections' directory makes it
+backwards compatible with earlier versions.
 
-where N is an increasing number allocated to each new connection.
+Under the fuse control filesystem each connection has a directory
+named by a unique number.
 
-For each connection the following attributes are defined:
+For each connection the following files exist within this directory:
 
  'waiting'
 
@@ -110,7 +122,47 @@ For each connection the following attributes are defined:
   connection.  This means that all waiting requests will be aborted an
   error returned for all aborted and new requests.
 
-Only a privileged user may read or write these attributes.
+Only the owner of the mount may read or write these files.
+
+Interrupting filesystem operations
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If a process issuing a FUSE filesystem request is interrupted, the
+following will happen:
+
+  1) If the request is not yet sent to userspace AND the signal is
+     fatal (SIGKILL or unhandled fatal signal), then the request is
+     dequeued and returns immediately.
+
+  2) If the request is not yet sent to userspace AND the signal is not
+     fatal, then an 'interrupted' flag is set for the request.  When
+     the request has been successfully transfered to userspace and
+     this flag is set, an INTERRUPT request is queued.
+
+  3) If the request is already sent to userspace, then an INTERRUPT
+     request is queued.
+
+INTERRUPT requests take precedence over other requests, so the
+userspace filesystem will receive queued INTERRUPTs before any others.
+
+The userspace filesystem may ignore the INTERRUPT requests entirely,
+or may honor them by sending a reply to the _original_ request, with
+the error set to EINTR.
+
+It is also possible that there's a race between processing the
+original request and it's INTERRUPT request.  There are two possibilities:
+
+  1) The INTERRUPT request is processed before the original request is
+     processed
+
+  2) The INTERRUPT request is processed after the original request has
+     been answered
+
+If the filesystem cannot find the original request, it should wait for
+some timeout and/or a number of new requests to arrive, after which it
+should reply to the INTERRUPT request with an EAGAIN error.  In case
+1) the INTERRUPT request will be requeued.  In case 2) the INTERRUPT
+reply will be ignored.
 
 Aborting a filesystem connection
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -139,8 +191,8 @@ the filesystem.  There are several ways to do this:
   - Use forced umount (umount -f).  Works in all cases but only if
     filesystem is still attached (it hasn't been lazy unmounted)
 
-  - Abort filesystem through the sysfs interface.  Most powerful
-    method, always works.
+  - Abort filesystem through the FUSE control filesystem.  Most
+    powerful method, always works.
 
 How do non-privileged mounts work?
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -304,25 +356,7 @@ Scenario 1 -  Simple deadlock
  |                                    |     for "file"]
  |                                    |    *DEADLOCK*
 
-The solution for this is to allow requests to be interrupted while
-they are in userspace:
-
- |      [interrupted by signal]       |
- |    <fuse_unlink()                  |
- |    [release semaphore]             |    [semaphore acquired]
- |  <sys_unlink()                     |
- |                                    |    >fuse_unlink()
- |                                    |      [queue req on fc->pending]
- |                                    |      [wake up fc->waitq]
- |                                    |      [sleep on req->waitq]
-
-If the filesystem daemon was single threaded, this will stop here,
-since there's no other thread to dequeue and execute the request.
-In this case the solution is to kill the FUSE daemon as well.  If
-there are multiple serving threads, you just have to kill them as
-long as any remain.
-
-Moral: a filesystem which deadlocks, can soon find itself dead.
+The solution for this is to allow the filesystem to be aborted.
 
 Scenario 2 - Tricky deadlock
 ----------------------------
@@ -355,24 +389,14 @@ but is caused by a pagefault.
  |                                    |           [lock page]
  |                                    |           * DEADLOCK *
 
-Solution is again to let the the request be interrupted (not
-elaborated further).
-
-An additional problem is that while the write buffer is being
-copied to the request, the request must not be interrupted.  This
-is because the destination address of the copy may not be valid
-after the request is interrupted.
-
-This is solved with doing the copy atomically, and allowing
-interruption while the page(s) belonging to the write buffer are
-faulted with get_user_pages().  The 'req->locked' flag indicates
-when the copy is taking place, and interruption is delayed until
-this flag is unset.
+Solution is basically the same as above.
 
-Scenario 3 - Tricky deadlock with asynchronous read
----------------------------------------------------
+An additional problem is that while the write buffer is being copied
+to the request, the request must not be interrupted/aborted.  This is
+because the destination address of the copy may not be valid after the
+request has returned.
 
-The same situation as above, except thread-1 will wait on page lock
-and hence it will be uninterruptible as well.  The solution is to
-abort the connection with forced umount (if mount is attached) or
-through the abort attribute in sysfs.
+This is solved with doing the copy atomically, and allowing abort
+while the page(s) belonging to the write buffer are faulted with
+get_user_pages().  The 'req->locked' flag indicates when the copy is
+taking place, and abort is delayed until this flag is unset.
diff --git a/Documentation/filesystems/ramfs-rootfs-initramfs.txt b/Documentation/filesystems/ramfs-rootfs-initramfs.txt
index 60ab61e54e8a..25981e2e51be 100644
--- a/Documentation/filesystems/ramfs-rootfs-initramfs.txt
+++ b/Documentation/filesystems/ramfs-rootfs-initramfs.txt
@@ -70,11 +70,13 @@ tmpfs mounts.  See Documentation/filesystems/tmpfs.txt for more information.
 What is rootfs?
 ---------------
 
-Rootfs is a special instance of ramfs, which is always present in 2.6 systems.
-(It's used internally as the starting and stopping point for searches of the
-kernel's doubly-linked list of mount points.)
+Rootfs is a special instance of ramfs (or tmpfs, if that's enabled), which is
+always present in 2.6 systems.  You can't unmount rootfs for approximately the
+same reason you can't kill the init process; rather than having special code
+to check for and handle an empty list, it's smaller and simpler for the kernel
+to just make sure certain lists can't become empty.
 
-Most systems just mount another filesystem over it and ignore it.  The
+Most systems just mount another filesystem over rootfs and ignore it.  The
 amount of space an empty instance of ramfs takes up is tiny.
 
 What is initramfs?
@@ -92,14 +94,16 @@ out of that.
 
 All this differs from the old initrd in several ways:
 
-  - The old initrd was a separate file, while the initramfs archive is linked
-    into the linux kernel image.  (The directory linux-*/usr is devoted to
-    generating this archive during the build.)
+  - The old initrd was always a separate file, while the initramfs archive is
+    linked into the linux kernel image.  (The directory linux-*/usr is devoted
+    to generating this archive during the build.)
 
   - The old initrd file was a gzipped filesystem image (in some file format,
-    such as ext2, that had to be built into the kernel), while the new
+    such as ext2, that needed a driver built into the kernel), while the new
     initramfs archive is a gzipped cpio archive (like tar only simpler,
-    see cpio(1) and Documentation/early-userspace/buffer-format.txt).
+    see cpio(1) and Documentation/early-userspace/buffer-format.txt).  The
+    kernel's cpio extraction code is not only extremely small, it's also
+    __init data that can be discarded during the boot process.
 
   - The program run by the old initrd (which was called /initrd, not /init) did
     some setup and then returned to the kernel, while the init program from
@@ -124,13 +128,14 @@ Populating initramfs:
 
 The 2.6 kernel build process always creates a gzipped cpio format initramfs
 archive and links it into the resulting kernel binary.  By default, this
-archive is empty (consuming 134 bytes on x86).  The config option
-CONFIG_INITRAMFS_SOURCE (for some reason buried under devices->block devices
-in menuconfig, and living in usr/Kconfig) can be used to specify a source for
-the initramfs archive, which will automatically be incorporated into the
-resulting binary.  This option can point to an existing gzipped cpio archive, a
-directory containing files to be archived, or a text file specification such
-as the following example:
+archive is empty (consuming 134 bytes on x86).
+
+The config option CONFIG_INITRAMFS_SOURCE (for some reason buried under
+devices->block devices in menuconfig, and living in usr/Kconfig) can be used
+to specify a source for the initramfs archive, which will automatically be
+incorporated into the resulting binary.  This option can point to an existing
+gzipped cpio archive, a directory containing files to be archived, or a text
+file specification such as the following example:
 
   dir /dev 755 0 0
   nod /dev/console 644 0 0 c 5 1
@@ -146,23 +151,84 @@ as the following example:
 Run "usr/gen_init_cpio" (after the kernel build) to get a usage message
 documenting the above file format.
 
-One advantage of the text file is that root access is not required to
+One advantage of the configuration file is that root access is not required to
 set permissions or create device nodes in the new archive.  (Note that those
 two example "file" entries expect to find files named "init.sh" and "busybox" in
 a directory called "initramfs", under the linux-2.6.* directory.  See
 Documentation/early-userspace/README for more details.)
 
-The kernel does not depend on external cpio tools, gen_init_cpio is created
-from usr/gen_init_cpio.c which is entirely self-contained, and the kernel's
-boot-time extractor is also (obviously) self-contained.  However, if you _do_
-happen to have cpio installed, the following command line can extract the
-generated cpio image back into its component files:
+The kernel does not depend on external cpio tools.  If you specify a
+directory instead of a configuration file, the kernel's build infrastructure
+creates a configuration file from that directory (usr/Makefile calls
+scripts/gen_initramfs_list.sh), and proceeds to package up that directory
+using the config file (by feeding it to usr/gen_init_cpio, which is created
+from usr/gen_init_cpio.c).  The kernel's build-time cpio creation code is
+entirely self-contained, and the kernel's boot-time extractor is also
+(obviously) self-contained.
+
+The one thing you might need external cpio utilities installed for is creating
+or extracting your own preprepared cpio files to feed to the kernel build
+(instead of a config file or directory).
+
+The following command line can extract a cpio image (either by the above script
+or by the kernel build) back into its component files:
 
   cpio -i -d -H newc -F initramfs_data.cpio --no-absolute-filenames
 
+The following shell script can create a prebuilt cpio archive you can
+use in place of the above config file:
+
+  #!/bin/sh
+
+  # Copyright 2006 Rob Landley <rob@landley.net> and TimeSys Corporation.
+  # Licensed under GPL version 2
+
+  if [ $# -ne 2 ]
+  then
+    echo "usage: mkinitramfs directory imagename.cpio.gz"
+    exit 1
+  fi
+
+  if [ -d "$1" ]
+  then
+    echo "creating $2 from $1"
+    (cd "$1"; find . | cpio -o -H newc | gzip) > "$2"
+  else
+    echo "First argument must be a directory"
+    exit 1
+  fi
+
+Note: The cpio man page contains some bad advice that will break your initramfs
+archive if you follow it.  It says "A typical way to generate the list
+of filenames is with the find command; you should give find the -depth option
+to minimize problems with permissions on directories that are unwritable or not
+searchable."  Don't do this when creating initramfs.cpio.gz images, it won't
+work.  The Linux kernel cpio extractor won't create files in a directory that
+doesn't exist, so the directory entries must go before the files that go in
+those directories.  The above script gets them in the right order.
+
+External initramfs images:
+--------------------------
+
+If the kernel has initrd support enabled, an external cpio.gz archive can also
+be passed into a 2.6 kernel in place of an initrd.  In this case, the kernel
+will autodetect the type (initramfs, not initrd) and extract the external cpio
+archive into rootfs before trying to run /init.
+
+This has the memory efficiency advantages of initramfs (no ramdisk block
+device) but the separate packaging of initrd (which is nice if you have
+non-GPL code you'd like to run from initramfs, without conflating it with
+the GPL licensed Linux kernel binary).
+
+It can also be used to supplement the kernel's built-in initamfs image.  The
+files in the external archive will overwrite any conflicting files in
+the built-in initramfs archive.  Some distributors also prefer to customize
+a single kernel image with task-specific initramfs images, without recompiling.
+
 Contents of initramfs:
 ----------------------
 
+An initramfs archive is a complete self-contained root filesystem for Linux.
 If you don't already understand what shared libraries, devices, and paths
 you need to get a minimal root filesystem up and running, here are some
 references:
@@ -176,13 +242,36 @@ code against, along with some related utilities.  It is BSD licensed.
 
 I use uClibc (http://www.uclibc.org) and busybox (http://www.busybox.net)
 myself.  These are LGPL and GPL, respectively.  (A self-contained initramfs
-package is planned for the busybox 1.2 release.)
+package is planned for the busybox 1.3 release.)
 
 In theory you could use glibc, but that's not well suited for small embedded
 uses like this.  (A "hello world" program statically linked against glibc is
 over 400k.  With uClibc it's 7k.  Also note that glibc dlopens libnss to do
 name lookups, even when otherwise statically linked.)
 
+A good first step is to get initramfs to run a statically linked "hello world"
+program as init, and test it under an emulator like qemu (www.qemu.org) or
+User Mode Linux, like so:
+
+  cat > hello.c << EOF
+  #include <stdio.h>
+  #include <unistd.h>
+
+  int main(int argc, char *argv[])
+  {
+    printf("Hello world!\n");
+    sleep(999999999);
+  }
+  EOF
+  gcc -static hello2.c -o init
+  echo init | cpio -o -H newc | gzip > test.cpio.gz
+  # Testing external initramfs using the initrd loading mechanism.
+  qemu -kernel /boot/vmlinuz -initrd test.cpio.gz /dev/zero
+
+When debugging a normal root filesystem, it's nice to be able to boot with
+"init=/bin/sh".  The initramfs equivalent is "rdinit=/bin/sh", and it's
+just as useful.
+
 Why cpio rather than tar?
 -------------------------
 
@@ -241,7 +330,7 @@ the above threads) is:
 Future directions:
 ------------------
 
-Today (2.6.14), initramfs is always compiled in, but not always used.  The
+Today (2.6.16), initramfs is always compiled in, but not always used.  The
 kernel falls back to legacy boot code that is reached only if initramfs does
 not contain an /init program.  The fallback is legacy code, there to ensure a
 smooth transition and allowing early boot functionality to gradually move to
@@ -258,8 +347,9 @@ and so on.
 
 This kind of complexity (which inevitably includes policy) is rightly handled
 in userspace.  Both klibc and busybox/uClibc are working on simple initramfs
-packages to drop into a kernel build, and when standard solutions are ready
-and widely deployed, the kernel's legacy early boot code will become obsolete
-and a candidate for the feature removal schedule.
+packages to drop into a kernel build.
 
-But that's a while off yet.
+The klibc package has now been accepted into Andrew Morton's 2.6.17-mm tree.
+The kernel's current early boot code (partition detection, etc) will probably
+be migrated into a default initramfs, automatically created and used by the
+kernel build.
diff --git a/Documentation/kdump/kdump.txt b/Documentation/kdump/kdump.txt
index 212cf3c21abf..08bafa8c1caa 100644
--- a/Documentation/kdump/kdump.txt
+++ b/Documentation/kdump/kdump.txt
@@ -1,155 +1,325 @@
-Documentation for kdump - the kexec-based crash dumping solution
+================================================================
+Documentation for Kdump - The kexec-based Crash Dumping Solution
 ================================================================
 
-DESIGN
-======
+This document includes overview, setup and installation, and analysis
+information.
 
-Kdump uses kexec to reboot to a second kernel whenever a dump needs to be
-taken. This second kernel is booted with very little memory. The first kernel
-reserves the section of memory that the second kernel uses. This ensures that
-on-going DMA from the first kernel does not corrupt the second kernel.
+Overview
+========
 
-All the necessary information about Core image is encoded in ELF format and
-stored in reserved area of memory before crash. Physical address of start of
-ELF header is passed to new kernel through command line parameter elfcorehdr=.
+Kdump uses kexec to quickly boot to a dump-capture kernel whenever a
+dump of the system kernel's memory needs to be taken (for example, when
+the system panics). The system kernel's memory image is preserved across
+the reboot and is accessible to the dump-capture kernel.
 
-On i386, the first 640 KB of physical memory is needed to boot, irrespective
-of where the kernel loads. Hence, this region is backed up by kexec just before
-rebooting into the new kernel.
+You can use common Linux commands, such as cp and scp, to copy the
+memory image to a dump file on the local disk, or across the network to
+a remote system.
 
-In the second kernel, "old memory" can be accessed in two ways.
+Kdump and kexec are currently supported on the x86, x86_64, and ppc64
+architectures.
 
-- The first one is through a /dev/oldmem device interface. A capture utility
-  can read the device file and write out the memory in raw format. This is raw
-  dump of memory and analysis/capture tool should be intelligent enough to
-  determine where to look for the right information. ELF headers (elfcorehdr=)
-  can become handy here.
+When the system kernel boots, it reserves a small section of memory for
+the dump-capture kernel. This ensures that ongoing Direct Memory Access
+(DMA) from the system kernel does not corrupt the dump-capture kernel.
+The kexec -p command loads the dump-capture kernel into this reserved
+memory.
 
-- The second interface is through /proc/vmcore. This exports the dump as an ELF
-  format file which can be written out using any file copy command
-  (cp, scp, etc). Further, gdb can be used to perform limited debugging on
-  the dump file. This method ensures methods ensure that there is correct
-  ordering of the dump pages (corresponding to the first 640 KB that has been
-  relocated).
+On x86 machines, the first 640 KB of physical memory is needed to boot,
+regardless of where the kernel loads. Therefore, kexec backs up this
+region just before rebooting into the dump-capture kernel.
 
-SETUP
-=====
+All of the necessary information about the system kernel's core image is
+encoded in the ELF format, and stored in a reserved area of memory
+before a crash. The physical address of the start of the ELF header is
+passed to the dump-capture kernel through the elfcorehdr= boot
+parameter.
+
+With the dump-capture kernel, you can access the memory image, or "old
+memory," in two ways:
+
+- Through a /dev/oldmem device interface. A capture utility can read the
+  device file and write out the memory in raw format. This is a raw dump
+  of memory. Analysis and capture tools must be intelligent enough to
+  determine where to look for the right information.
+
+- Through /proc/vmcore. This exports the dump as an ELF-format file that
+  you can write out using file copy commands such as cp or scp. Further,
+  you can use analysis tools such as the GNU Debugger (GDB) and the Crash
+  tool to debug the dump file. This method ensures that the dump pages are
+  correctly ordered.
+
+
+Setup and Installation
+======================
+
+Install kexec-tools and the Kdump patch
+---------------------------------------
+
+1) Login as the root user.
+
+2) Download the kexec-tools user-space package from the following URL:
+
+   http://www.xmission.com/~ebiederm/files/kexec/kexec-tools-1.101.tar.gz
+
+3) Unpack the tarball with the tar command, as follows:
+
+   tar xvpzf kexec-tools-1.101.tar.gz
+
+4) Download the latest consolidated Kdump patch from the following URL:
+
+   http://lse.sourceforge.net/kdump/
+
+   (This location is being used until all the user-space Kdump patches
+   are integrated with the kexec-tools package.)
+
+5) Change to the kexec-tools-1.101 directory, as follows:
+
+   cd kexec-tools-1.101
+
+6) Apply the consolidated patch to the kexec-tools-1.101 source tree
+   with the patch command, as follows. (Modify the path to the downloaded
+   patch as necessary.)
+
+   patch -p1 < /path-to-kdump-patch/kexec-tools-1.101-kdump.patch
+
+7) Configure the package, as follows:
+
+   ./configure
+
+8) Compile the package, as follows:
+
+   make
+
+9) Install the package, as follows:
+
+   make install
+
+
+Download and build the system and dump-capture kernels
+------------------------------------------------------
+
+Download the mainline (vanilla) kernel source code (2.6.13-rc1 or newer)
+from http://www.kernel.org. Two kernels must be built: a system kernel
+and a dump-capture kernel. Use the following steps to configure these
+kernels with the necessary kexec and Kdump features:
+
+System kernel
+-------------
+
+1) Enable "kexec system call" in "Processor type and features."
+
+   CONFIG_KEXEC=y
+
+2) Enable "sysfs file system support" in "Filesystem" -> "Pseudo
+   filesystems." This is usually enabled by default.
+
+   CONFIG_SYSFS=y
+
+   Note that "sysfs file system support" might not appear in the "Pseudo
+   filesystems" menu if "Configure standard kernel features (for small
+   systems)" is not enabled in "General Setup." In this case, check the
+   .config file itself to ensure that sysfs is turned on, as follows:
+
+   grep 'CONFIG_SYSFS' .config
+
+3) Enable "Compile the kernel with debug info" in "Kernel hacking."
+
+   CONFIG_DEBUG_INFO=Y
+
+   This causes the kernel to be built with debug symbols. The dump
+   analysis tools require a vmlinux with debug symbols in order to read
+   and analyze a dump file.
+
+4) Make and install the kernel and its modules. Update the boot loader
+   (such as grub, yaboot, or lilo) configuration files as necessary.
+
+5) Boot the system kernel with the boot parameter "crashkernel=Y@X",
+   where Y specifies how much memory to reserve for the dump-capture kernel
+   and X specifies the beginning of this reserved memory. For example,
+   "crashkernel=64M@16M" tells the system kernel to reserve 64 MB of memory
+   starting at physical address 0x01000000 for the dump-capture kernel.
+
+   On x86 and x86_64, use "crashkernel=64M@16M".
+
+   On ppc64, use "crashkernel=128M@32M".
+
+
+The dump-capture kernel
+-----------------------
 
-1) Download the upstream kexec-tools userspace package from
-   http://www.xmission.com/~ebiederm/files/kexec/kexec-tools-1.101.tar.gz.
-
-   Apply the latest consolidated kdump patch on top of kexec-tools-1.101
-   from http://lse.sourceforge.net/kdump/. This arrangment has been made
-   till all the userspace patches supporting kdump are integrated with
-   upstream kexec-tools userspace.
-
-2) Download and build the appropriate (2.6.13-rc1 onwards) vanilla kernels.
-   Two kernels need to be built in order to get this feature working.
-   Following are the steps to properly configure the two kernels specific
-   to kexec and kdump features:
-
-  A) First kernel or regular kernel:
-  ----------------------------------
-   a) Enable "kexec system call" feature (in Processor type and features).
-      CONFIG_KEXEC=y
-   b) Enable "sysfs file system support" (in Pseudo filesystems).
-      CONFIG_SYSFS=y
-   c) make
-   d) Boot into first kernel with the command line parameter "crashkernel=Y@X".
-      Use appropriate values for X and Y. Y denotes how much memory to reserve
-      for the second kernel, and X denotes at what physical address the
-      reserved memory section starts. For example: "crashkernel=64M@16M".
-
-
-  B) Second kernel or dump capture kernel:
-  ---------------------------------------
-   a) For i386 architecture enable Highmem support
-      CONFIG_HIGHMEM=y
-   b) Enable "kernel crash dumps" feature (under "Processor type and features")
-      CONFIG_CRASH_DUMP=y
-   c) Make sure a suitable value for "Physical address where the kernel is
-      loaded" (under "Processor type and features"). By default this value
-      is 0x1000000 (16MB) and it should be same as X (See option d above),
-      e.g., 16 MB or 0x1000000.
-      CONFIG_PHYSICAL_START=0x1000000
-   d) Enable "/proc/vmcore support" (Optional, under "Pseudo filesystems").
-      CONFIG_PROC_VMCORE=y
-
-3) After booting to regular kernel or first kernel, load the second kernel
-   using the following command:
-
-   kexec -p <second-kernel> --args-linux --elf32-core-headers
-   --append="root=<root-dev> init 1 irqpoll maxcpus=1"
-
-   Notes:
-   ======
-     i) <second-kernel> has to be a vmlinux image ie uncompressed elf image.
-        bzImage will not work, as of now.
-    ii) --args-linux has to be speicfied as if kexec it loading an elf image,
-        it needs to know that the arguments supplied are of linux type.
-   iii) By default ELF headers are stored in ELF64 format to support systems
-        with more than 4GB memory. Option --elf32-core-headers forces generation
-        of ELF32 headers. The reason for this option being, as of now gdb can
-        not open vmcore file with ELF64 headers on a 32 bit systems. So ELF32
-        headers can be used if one has non-PAE systems and hence memory less
-        than 4GB.
-    iv) Specify "irqpoll" as command line parameter. This reduces driver
-         initialization failures in second kernel due to shared interrupts.
-     v) <root-dev> needs to be specified in a format corresponding to the root
-        device name in the output of mount command.
-    vi) If you have built the drivers required to mount root file system as
-        modules in <second-kernel>, then, specify
-        --initrd=<initrd-for-second-kernel>.
-   vii) Specify maxcpus=1 as, if during first kernel run, if panic happens on
-        non-boot cpus, second kernel doesn't seem to be boot up all the cpus.
-        The other option is to always built the second kernel without SMP
-        support ie CONFIG_SMP=n
-
-4) After successfully loading the second kernel as above, if a panic occurs
-   system reboots into the second kernel. A module can be written to force
-   the panic or "ALT-SysRq-c" can be used initiate a crash dump for testing
-   purposes.
-
-5) Once the second kernel has booted, write out the dump file using
+1) Under "General setup," append "-kdump" to the current string in
+   "Local version."
+
+2) On x86, enable high memory support under "Processor type and
+   features":
+
+   CONFIG_HIGHMEM64G=y
+   or
+   CONFIG_HIGHMEM4G
+
+3) On x86 and x86_64, disable symmetric multi-processing support
+   under "Processor type and features":
+
+   CONFIG_SMP=n
+   (If CONFIG_SMP=y, then specify maxcpus=1 on the kernel command line
+   when loading the dump-capture kernel, see section "Load the Dump-capture
+   Kernel".)
+
+4) On ppc64, disable NUMA support and enable EMBEDDED support:
+
+   CONFIG_NUMA=n
+   CONFIG_EMBEDDED=y
+   CONFIG_EEH=N for the dump-capture kernel
+
+5) Enable "kernel crash dumps" support under "Processor type and
+   features":
+
+   CONFIG_CRASH_DUMP=y
+
+6) Use a suitable value for "Physical address where the kernel is
+   loaded" (under "Processor type and features"). This only appears when
+   "kernel crash dumps" is enabled. By default this value is 0x1000000
+   (16MB). It should be the same as X in the "crashkernel=Y@X" boot
+   parameter discussed above.
+
+   On x86 and x86_64, use "CONFIG_PHYSICAL_START=0x1000000".
+
+   On ppc64 the value is automatically set at 32MB when
+   CONFIG_CRASH_DUMP is set.
+
+6) Optionally enable "/proc/vmcore support" under "Filesystems" ->
+   "Pseudo filesystems".
+
+   CONFIG_PROC_VMCORE=y
+   (CONFIG_PROC_VMCORE is set by default when CONFIG_CRASH_DUMP is selected.)
+
+7) Make and install the kernel and its modules. DO NOT add this kernel
+   to the boot loader configuration files.
+
+
+Load the Dump-capture Kernel
+============================
+
+After booting to the system kernel, load the dump-capture kernel using
+the following command:
+
+   kexec -p <dump-capture-kernel> \
+   --initrd=<initrd-for-dump-capture-kernel> --args-linux \
+   --append="root=<root-dev> init 1 irqpoll"
+
+
+Notes on loading the dump-capture kernel:
+
+* <dump-capture-kernel> must be a vmlinux image (that is, an
+  uncompressed ELF image). bzImage does not work at this time.
+
+* By default, the ELF headers are stored in ELF64 format to support
+  systems with more than 4GB memory. The --elf32-core-headers option can
+  be used to force the generation of ELF32 headers. This is necessary
+  because GDB currently cannot open vmcore files with ELF64 headers on
+  32-bit systems. ELF32 headers can be used on non-PAE systems (that is,
+  less than 4GB of memory).
+
+* The "irqpoll" boot parameter reduces driver initialization failures
+  due to shared interrupts in the dump-capture kernel.
+
+* You must specify <root-dev> in the format corresponding to the root
+  device name in the output of mount command.
+
+* "init 1" boots the dump-capture kernel into single-user mode without
+  networking. If you want networking, use "init 3."
+
+
+Kernel Panic
+============
+
+After successfully loading the dump-capture kernel as previously
+described, the system will reboot into the dump-capture kernel if a
+system crash is triggered.  Trigger points are located in panic(),
+die(), die_nmi() and in the sysrq handler (ALT-SysRq-c).
+
+The following conditions will execute a crash trigger point:
+
+If a hard lockup is detected and "NMI watchdog" is configured, the system
+will boot into the dump-capture kernel ( die_nmi() ).
+
+If die() is called, and it happens to be a thread with pid 0 or 1, or die()
+is called inside interrupt context or die() is called and panic_on_oops is set,
+the system will boot into the dump-capture kernel.
+
+On powererpc systems when a soft-reset is generated, die() is called by all cpus and the system system will boot into the dump-capture kernel.
+
+For testing purposes, you can trigger a crash by using "ALT-SysRq-c",
+"echo c > /proc/sysrq-trigger or write a module to force the panic.
+
+Write Out the Dump File
+=======================
+
+After the dump-capture kernel is booted, write out the dump file with
+the following command:
 
    cp /proc/vmcore <dump-file>
 
-   Dump memory can also be accessed as a /dev/oldmem device for a linear/raw
-   view.  To create the device, type:
+You can also access dumped memory as a /dev/oldmem device for a linear
+and raw view. To create the device, use the following command:
 
-   mknod /dev/oldmem c 1 12
+    mknod /dev/oldmem c 1 12
 
-   Use "dd" with suitable options for count, bs and skip to access specific
-   portions of the dump.
+Use the dd command with suitable options for count, bs, and skip to
+access specific portions of the dump.
 
-   Entire memory:  dd if=/dev/oldmem of=oldmem.001
+To see the entire memory, use the following command:
 
+   dd if=/dev/oldmem of=oldmem.001
 
-ANALYSIS
+
+Analysis
 ========
-Limited analysis can be done using gdb on the dump file copied out of
-/proc/vmcore. Use vmlinux built with -g and run
 
-  gdb vmlinux <dump-file>
+Before analyzing the dump image, you should reboot into a stable kernel.
+
+You can do limited analysis using GDB on the dump file copied out of
+/proc/vmcore. Use the debug vmlinux built with -g and run the following
+command:
+
+   gdb vmlinux <dump-file>
 
-Stack trace for the task on processor 0, register display, memory display
-work fine.
+Stack trace for the task on processor 0, register display, and memory
+display work fine.
 
-Note: gdb cannot analyse core files generated in ELF64 format for i386.
+Note: GDB cannot analyze core files generated in ELF64 format for x86.
+On systems with a maximum of 4GB of memory, you can generate
+ELF32-format headers using the --elf32-core-headers kernel option on the
+dump kernel.
 
-Latest "crash" (crash-4.0-2.18) as available on Dave Anderson's site
-http://people.redhat.com/~anderson/ works well with kdump format.
+You can also use the Crash utility to analyze dump files in Kdump
+format. Crash is available on Dave Anderson's site at the following URL:
 
+   http://people.redhat.com/~anderson/
+
+
+To Do
+=====
 
-TODO
-====
-1) Provide a kernel pages filtering mechanism so that core file size is not
-   insane on systems having huge memory banks.
-2) Relocatable kernel can help in maintaining multiple kernels for crashdump
-   and same kernel as the first kernel can be used to capture the dump.
+1) Provide a kernel pages filtering mechanism, so core file size is not
+   extreme on systems with huge memory banks.
 
+2) Relocatable kernel can help in maintaining multiple kernels for
+   crash_dump, and the same kernel as the system kernel can be used to
+   capture the dump.
 
-CONTACT
+
+Contact
 =======
+
 Vivek Goyal (vgoyal@in.ibm.com)
 Maneesh Soni (maneesh@in.ibm.com)
+
+
+Trademark
+=========
+
+Linux is a trademark of Linus Torvalds in the United States, other
+countries, or both.
diff --git a/Documentation/memory-barriers.txt b/Documentation/memory-barriers.txt
index 4710845dbac4..cf0d5416a4c3 100644
--- a/Documentation/memory-barriers.txt
+++ b/Documentation/memory-barriers.txt
@@ -262,9 +262,14 @@ What is required is some way of intervening to instruct the compiler and the
 CPU to restrict the order.
 
 Memory barriers are such interventions.  They impose a perceived partial
-ordering between the memory operations specified on either side of the barrier.
-They request that the sequence of memory events generated appears to other
-parts of the system as if the barrier is effective on that CPU.
+ordering over the memory operations on either side of the barrier.
+
+Such enforcement is important because the CPUs and other devices in a system
+can use a variety of tricks to improve performance - including reordering,
+deferral and combination of memory operations; speculative loads; speculative
+branch prediction and various types of caching.  Memory barriers are used to
+override or suppress these tricks, allowing the code to sanely control the
+interaction of multiple CPUs and/or devices.
 
 
 VARIETIES OF MEMORY BARRIER
@@ -282,7 +287,7 @@ Memory barriers come in four basic varieties:
      A write barrier is a partial ordering on stores only; it is not required
      to have any effect on loads.
 
-     A CPU can be viewed as as commiting a sequence of store operations to the
+     A CPU can be viewed as committing a sequence of store operations to the
      memory system as time progresses.  All stores before a write barrier will
      occur in the sequence _before_ all the stores after the write barrier.
 
@@ -413,7 +418,7 @@ There are certain things that the Linux kernel memory barriers do not guarantee:
      indirect effect will be the order in which the second CPU sees the effects
      of the first CPU's accesses occur, but see the next point:
 
- (*) There is no guarantee that the a CPU will see the correct order of effects
+ (*) There is no guarantee that a CPU will see the correct order of effects
      from a second CPU's accesses, even _if_ the second CPU uses a memory
      barrier, unless the first CPU _also_ uses a matching memory barrier (see
      the subsection on "SMP Barrier Pairing").
@@ -461,8 +466,8 @@ Whilst this may seem like a failure of coherency or causality maintenance, it
 isn't, and this behaviour can be observed on certain real CPUs (such as the DEC
 Alpha).
 
-To deal with this, a data dependency barrier must be inserted between the
-address load and the data load:
+To deal with this, a data dependency barrier or better must be inserted
+between the address load and the data load:
 
         CPU 1           CPU 2
         =============== ===============
@@ -484,7 +489,7 @@ lines.  The pointer P might be stored in an odd-numbered cache line, and the
 variable B might be stored in an even-numbered cache line.  Then, if the
 even-numbered bank of the reading CPU's cache is extremely busy while the
 odd-numbered bank is idle, one can see the new value of the pointer P (&B),
-but the old value of the variable B (1).
+but the old value of the variable B (2).
 
 
 Another example of where data dependency barriers might by required is where a
@@ -744,7 +749,7 @@ some effectively random order, despite the write barrier issued by CPU 1:
                                                 :       :
 
 
-If, however, a read barrier were to be placed between the load of E and the
+If, however, a read barrier were to be placed between the load of B and the
 load of A on CPU 2:
 
         CPU 1                   CPU 2
@@ -1461,9 +1466,8 @@ instruction itself is complete.
 
 On a UP system - where this wouldn't be a problem - the smp_mb() is just a
 compiler barrier, thus making sure the compiler emits the instructions in the
-right order without actually intervening in the CPU.  Since there there's only
-one CPU, that CPU's dependency ordering logic will take care of everything
-else.
+right order without actually intervening in the CPU.  Since there's only one
+CPU, that CPU's dependency ordering logic will take care of everything else.
 
 
 ATOMIC OPERATIONS
@@ -1640,9 +1644,9 @@ functions:
 
      The PCI bus, amongst others, defines an I/O space concept - which on such
      CPUs as i386 and x86_64 cpus readily maps to the CPU's concept of I/O
-     space.  However, it may also mapped as a virtual I/O space in the CPU's
-     memory map, particularly on those CPUs that don't support alternate
-     I/O spaces.
+     space.  However, it may also be mapped as a virtual I/O space in the CPU's
+     memory map, particularly on those CPUs that don't support alternate I/O
+     spaces.
 
      Accesses to this space may be fully synchronous (as on i386), but
      intermediary bridges (such as the PCI host bridge) may not fully honour
diff --git a/Documentation/rtc.txt b/Documentation/rtc.txt
index 95d17b3e2eee..2a58f985795a 100644
--- a/Documentation/rtc.txt
+++ b/Documentation/rtc.txt
@@ -44,8 +44,10 @@ normal timer interrupt, which is 100Hz.
 Programming and/or enabling interrupt frequencies greater than 64Hz is
 only allowed by root. This is perhaps a bit conservative, but we don't want
 an evil user generating lots of IRQs on a slow 386sx-16, where it might have
-a negative impact on performance.  Note that the interrupt handler is only
-a few lines of code to minimize any possibility of this effect.
+a negative impact on performance. This 64Hz limit can be changed by writing
+a different value to /proc/sys/dev/rtc/max-user-freq. Note that the
+interrupt handler is only a few lines of code to minimize any possibility
+of this effect.
 
 Also, if the kernel time is synchronized with an external source, the 
 kernel will write the time back to the CMOS clock every 11 minutes. In 
@@ -81,6 +83,7 @@ that will be using this driver.
  */
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <linux/rtc.h>
 #include <sys/ioctl.h>
 #include <sys/time.h>
diff --git a/Documentation/sysrq.txt b/Documentation/sysrq.txt
index ad0bedf678b3..e0188a23fd5e 100644
--- a/Documentation/sysrq.txt
+++ b/Documentation/sysrq.txt
@@ -115,8 +115,9 @@ trojan program is running at console and which could grab your password
 when you would try to login. It will kill all programs on given console
 and thus letting you make sure that the login prompt you see is actually
 the one from init, not some trojan program.
-IMPORTANT:In its true form it is not a true SAK like the one in   :IMPORTANT
-IMPORTANT:c2 compliant systems, and it should be mistook as such. :IMPORTANT
+IMPORTANT: In its true form it is not a true SAK like the one in a :IMPORTANT
+IMPORTANT: c2 compliant system, and it should not be mistaken as   :IMPORTANT
+IMPORTANT: such.                                                   :IMPORTANT
        It seems other find it useful as (System Attention Key) which is
 useful when you want to exit a program that will not let you switch consoles.
 (For example, X or a svgalib program.)
diff --git a/arch/arm/kernel/bios32.c b/arch/arm/kernel/bios32.c
index de606dfa8db9..302fc1401547 100644
--- a/arch/arm/kernel/bios32.c
+++ b/arch/arm/kernel/bios32.c
@@ -702,7 +702,6 @@ int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
         /*
          * Mark this as IO
          */
-        vma->vm_flags |= VM_SHM | VM_LOCKED | VM_IO;
         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 
         if (remap_pfn_range(vma, vma->vm_start, phys,
diff --git a/arch/arm/mach-ixp4xx/nas100d-power.c b/arch/arm/mach-ixp4xx/nas100d-power.c
index 99d333d7ebdd..a3745ed37f9f 100644
--- a/arch/arm/mach-ixp4xx/nas100d-power.c
+++ b/arch/arm/mach-ixp4xx/nas100d-power.c
@@ -20,11 +20,10 @@
 #include <linux/module.h>
 #include <linux/reboot.h>
 #include <linux/interrupt.h>
+#include <linux/reboot.h>
 
 #include <asm/mach-types.h>
 
-extern void ctrl_alt_del(void);
-
 static irqreturn_t nas100d_reset_handler(int irq, void *dev_id, struct pt_regs *regs)
 {
         /* Signal init to do the ctrlaltdel action, this will bypass init if
diff --git a/arch/arm/mach-ixp4xx/nslu2-power.c b/arch/arm/mach-ixp4xx/nslu2-power.c
index d80c362bc539..6d38e97142cc 100644
--- a/arch/arm/mach-ixp4xx/nslu2-power.c
+++ b/arch/arm/mach-ixp4xx/nslu2-power.c
@@ -20,11 +20,10 @@
 #include <linux/module.h>
 #include <linux/reboot.h>
 #include <linux/interrupt.h>
+#include <linux/reboot.h>
 
 #include <asm/mach-types.h>
 
-extern void ctrl_alt_del(void);
-
 static irqreturn_t nslu2_power_handler(int irq, void *dev_id, struct pt_regs *regs)
 {
         /* Signal init to do the ctrlaltdel action, this will bypass init if
diff --git a/arch/cris/arch-v32/drivers/pci/bios.c b/arch/cris/arch-v32/drivers/pci/bios.c
index 24bc149889b6..1e9d062103ae 100644
--- a/arch/cris/arch-v32/drivers/pci/bios.c
+++ b/arch/cris/arch-v32/drivers/pci/bios.c
@@ -27,8 +27,6 @@ int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
         /* Leave vm_pgoff as-is, the PCI space address is the physical
          * address on this platform.
          */
-        vma->vm_flags |= (VM_SHM | VM_LOCKED | VM_IO);
-
         prot = pgprot_val(vma->vm_page_prot);
         vma->vm_page_prot = __pgprot(prot);
 
diff --git a/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c b/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
index 05668e3598c0..5fd65325b81a 100644
--- a/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
+++ b/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c
@@ -371,11 +371,11 @@ static int acpi_cpufreq_early_init_acpi(void)
 
         dprintk("acpi_cpufreq_early_init\n");
 
-        for_each_cpu(i) {
+        for_each_possible_cpu(i) {
                 data = kzalloc(sizeof(struct acpi_processor_performance), 
                         GFP_KERNEL);
                 if (!data) {
-                        for_each_cpu(j) {
+                        for_each_possible_cpu(j) {
                                 kfree(acpi_perf_data[j]);
                                 acpi_perf_data[j] = NULL;
                         }
@@ -584,7 +584,7 @@ acpi_cpufreq_exit (void)
 
         cpufreq_unregister_driver(&acpi_cpufreq_driver);
 
-        for_each_cpu(i) {
+        for_each_possible_cpu(i) {
                 kfree(acpi_perf_data[i]);
                 acpi_perf_data[i] = NULL;
         }
diff --git a/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c b/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
index 31c3a5baaa7f..f7e4356f6820 100644
--- a/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
+++ b/arch/i386/kernel/cpu/cpufreq/speedstep-centrino.c
@@ -361,11 +361,11 @@ static int centrino_cpu_early_init_acpi(void)
         unsigned int    i, j;
         struct acpi_processor_performance       *data;
 
-        for_each_cpu(i) {
+        for_each_possible_cpu(i) {
                 data = kzalloc(sizeof(struct acpi_processor_performance), 
                                 GFP_KERNEL);
                 if (!data) {
-                        for_each_cpu(j) {
+                        for_each_possible_cpu(j) {
                                 kfree(acpi_perf_data[j]);
                                 acpi_perf_data[j] = NULL;
                         }
@@ -805,7 +805,7 @@ static void __exit centrino_exit(void)
         cpufreq_unregister_driver(&centrino_driver);
 
 #ifdef CONFIG_X86_SPEEDSTEP_CENTRINO_ACPI
-        for_each_cpu(j) {
+        for_each_possible_cpu(j) {
                 kfree(acpi_perf_data[j]);
                 acpi_perf_data[j] = NULL;
         }
diff --git a/arch/i386/kernel/crash.c b/arch/i386/kernel/crash.c
index 2b0cfce24a61..21dc1bbb8067 100644
--- a/arch/i386/kernel/crash.c
+++ b/arch/i386/kernel/crash.c
@@ -114,7 +114,8 @@ static int crash_nmi_callback(struct pt_regs *regs, int cpu)
         atomic_dec(&waiting_for_crash_ipi);
         /* Assume hlt works */
         halt();
-        for(;;);
+        for (;;)
+                cpu_relax();
 
         return 1;
 }
diff --git a/arch/i386/kernel/doublefault.c b/arch/i386/kernel/doublefault.c
index 5edb1d379add..b4d14c2eb345 100644
--- a/arch/i386/kernel/doublefault.c
+++ b/arch/i386/kernel/doublefault.c
@@ -44,7 +44,8 @@ static void doublefault_fn(void)
                 }
         }
 
-        for (;;) /* nothing */;
+        for (;;)
+                cpu_relax();
 }
 
 struct tss_struct doublefault_tss __cacheline_aligned = {
diff --git a/arch/i386/kernel/setup.c b/arch/i386/kernel/setup.c
index e6023970aa40..6c1639836e06 100644
--- a/arch/i386/kernel/setup.c
+++ b/arch/i386/kernel/setup.c
@@ -61,7 +61,7 @@
 #include <asm/io_apic.h>
 #include <asm/ist.h>
 #include <asm/io.h>
-#include "setup_arch_pre.h"
+#include <setup_arch.h>
 #include <bios_ebda.h>
 
 /* Forward Declaration. */
@@ -411,8 +411,8 @@ static void __init limit_regions(unsigned long long size)
         }
 }
 
-static void __init add_memory_region(unsigned long long start,
-                                  unsigned long long size, int type)
+void __init add_memory_region(unsigned long long start,
+                              unsigned long long size, int type)
 {
         int x;
 
@@ -475,7 +475,7 @@ static struct change_member *change_point[2*E820MAX] __initdata;
 static struct e820entry *overlap_list[E820MAX] __initdata;
 static struct e820entry new_bios[E820MAX] __initdata;
 
-static int __init sanitize_e820_map(struct e820entry * biosmap, char * pnr_map)
+int __init sanitize_e820_map(struct e820entry * biosmap, char * pnr_map)
 {
         struct change_member *change_tmp;
         unsigned long current_type, last_type;
@@ -644,7 +644,7 @@ static int __init sanitize_e820_map(struct e820entry * biosmap, char * pnr_map)
  * thinkpad 560x, for example, does not cooperate with the memory
  * detection code.)
  */
-static int __init copy_e820_map(struct e820entry * biosmap, int nr_map)
+int __init copy_e820_map(struct e820entry * biosmap, int nr_map)
 {
         /* Only one memory region (or negative)? Ignore it */
         if (nr_map < 2)
@@ -702,12 +702,6 @@ static inline void copy_edd(void)
 }
 #endif
 
-/*
- * Do NOT EVER look at the BIOS memory size location.
- * It does not work on many machines.
- */
-#define LOWMEMSIZE()    (0x9f000)
-
 static void __init parse_cmdline_early (char ** cmdline_p)
 {
         char c = ' ', *to = command_line, *from = saved_command_line;
@@ -1424,8 +1418,6 @@ static void __init register_memory(void)
                 pci_mem_start, gapstart, gapsize);
 }
 
-static char * __init machine_specific_memory_setup(void);
-
 #ifdef CONFIG_MCA
 static void set_mca_bus(int x)
 {
@@ -1708,7 +1700,6 @@ static __init int add_pcspkr(void)
 }
 device_initcall(add_pcspkr);
 
-#include "setup_arch_post.h"
 /*
  * Local Variables:
  * mode:c
diff --git a/arch/i386/kernel/smpboot.c b/arch/i386/kernel/smpboot.c
index 825b2b4ca721..bd0ca5c9f053 100644
--- a/arch/i386/kernel/smpboot.c
+++ b/arch/i386/kernel/smpboot.c
@@ -257,7 +257,7 @@ static void __init synchronize_tsc_bp (void)
                  * all APs synchronize but they loop on '== num_cpus'
                  */
                 while (atomic_read(&tsc_count_start) != num_booting_cpus()-1)
-                        mb();
+                        cpu_relax();
                 atomic_set(&tsc_count_stop, 0);
                 wmb();
                 /*
@@ -276,7 +276,7 @@ static void __init synchronize_tsc_bp (void)
                  * Wait for all APs to leave the synchronization point:
                  */
                 while (atomic_read(&tsc_count_stop) != num_booting_cpus()-1)
-                        mb();
+                        cpu_relax();
                 atomic_set(&tsc_count_start, 0);
                 wmb();
                 atomic_inc(&tsc_count_stop);
@@ -333,19 +333,21 @@ static void __init synchronize_tsc_ap (void)
          * this gets called, so we first wait for the BP to
          * finish SMP initialization:
          */
-        while (!atomic_read(&tsc_start_flag)) mb();
+        while (!atomic_read(&tsc_start_flag))
+                cpu_relax();
 
         for (i = 0; i < NR_LOOPS; i++) {
                 atomic_inc(&tsc_count_start);
                 while (atomic_read(&tsc_count_start) != num_booting_cpus())
-                        mb();
+                        cpu_relax();
 
                 rdtscll(tsc_values[smp_processor_id()]);
                 if (i == NR_LOOPS-1)
                         write_tsc(0, 0);
 
                 atomic_inc(&tsc_count_stop);
-                while (atomic_read(&tsc_count_stop) != num_booting_cpus()) mb();
+                while (atomic_read(&tsc_count_stop) != num_booting_cpus())
+                        cpu_relax();
         }
 }
 #undef NR_LOOPS
@@ -1433,7 +1435,7 @@ int __devinit __cpu_up(unsigned int cpu)
         /* Unleash the CPU! */
         cpu_set(cpu, smp_commenced_mask);
         while (!cpu_isset(cpu, cpu_online_map))
-                mb();
+                cpu_relax();
         return 0;
 }
 
diff --git a/arch/i386/lib/usercopy.c b/arch/i386/lib/usercopy.c
index 6979297ce278..c5aa65f7c02a 100644
--- a/arch/i386/lib/usercopy.c
+++ b/arch/i386/lib/usercopy.c
@@ -528,6 +528,97 @@ static unsigned long __copy_user_zeroing_intel_nocache(void *to,
         return size;
 }
 
+static unsigned long __copy_user_intel_nocache(void *to,
+                                const void __user *from, unsigned long size)
+{
+        int d0, d1;
+
+        __asm__ __volatile__(
+               "        .align 2,0x90\n"
+               "0:      movl 32(%4), %%eax\n"
+               "        cmpl $67, %0\n"
+               "        jbe 2f\n"
+               "1:      movl 64(%4), %%eax\n"
+               "        .align 2,0x90\n"
+               "2:      movl 0(%4), %%eax\n"
+               "21:     movl 4(%4), %%edx\n"
+               "        movnti %%eax, 0(%3)\n"
+               "        movnti %%edx, 4(%3)\n"
+               "3:      movl 8(%4), %%eax\n"
+               "31:     movl 12(%4),%%edx\n"
+               "        movnti %%eax, 8(%3)\n"
+               "        movnti %%edx, 12(%3)\n"
+               "4:      movl 16(%4), %%eax\n"
+               "41:     movl 20(%4), %%edx\n"
+               "        movnti %%eax, 16(%3)\n"
+               "        movnti %%edx, 20(%3)\n"
+               "10:     movl 24(%4), %%eax\n"
+               "51:     movl 28(%4), %%edx\n"
+               "        movnti %%eax, 24(%3)\n"
+               "        movnti %%edx, 28(%3)\n"
+               "11:     movl 32(%4), %%eax\n"
+               "61:     movl 36(%4), %%edx\n"
+               "        movnti %%eax, 32(%3)\n"
+               "        movnti %%edx, 36(%3)\n"
+               "12:     movl 40(%4), %%eax\n"
+               "71:     movl 44(%4), %%edx\n"
+               "        movnti %%eax, 40(%3)\n"
+               "        movnti %%edx, 44(%3)\n"
+               "13:     movl 48(%4), %%eax\n"
+               "81:     movl 52(%4), %%edx\n"
+               "        movnti %%eax, 48(%3)\n"
+               "        movnti %%edx, 52(%3)\n"
+               "14:     movl 56(%4), %%eax\n"
+               "91:     movl 60(%4), %%edx\n"
+               "        movnti %%eax, 56(%3)\n"
+               "        movnti %%edx, 60(%3)\n"
+               "        addl $-64, %0\n"
+               "        addl $64, %4\n"
+               "        addl $64, %3\n"
+               "        cmpl $63, %0\n"
+               "        ja  0b\n"
+               "        sfence \n"
+               "5:      movl  %0, %%eax\n"
+               "        shrl  $2, %0\n"
+               "        andl $3, %%eax\n"
+               "        cld\n"
+               "6:      rep; movsl\n"
+               "        movl %%eax,%0\n"
+               "7:      rep; movsb\n"
+               "8:\n"
+               ".section .fixup,\"ax\"\n"
+               "9:      lea 0(%%eax,%0,4),%0\n"
+               "16:     jmp 8b\n"
+               ".previous\n"
+               ".section __ex_table,\"a\"\n"
+               "        .align 4\n"
+               "        .long 0b,16b\n"
+               "        .long 1b,16b\n"
+               "        .long 2b,16b\n"
+               "        .long 21b,16b\n"
+               "        .long 3b,16b\n"
+               "        .long 31b,16b\n"
+               "        .long 4b,16b\n"
+               "        .long 41b,16b\n"
+               "        .long 10b,16b\n"
+               "        .long 51b,16b\n"
+               "        .long 11b,16b\n"
+               "        .long 61b,16b\n"
+               "        .long 12b,16b\n"
+               "        .long 71b,16b\n"
+               "        .long 13b,16b\n"
+               "        .long 81b,16b\n"
+               "        .long 14b,16b\n"
+               "        .long 91b,16b\n"
+               "        .long 6b,9b\n"
+               "        .long 7b,16b\n"
+               ".previous"
+               : "=&c"(size), "=&D" (d0), "=&S" (d1)
+               :  "1"(to), "2"(from), "0"(size)
+               : "eax", "edx", "memory");
+        return size;
+}
+
 #else
 
 /*
@@ -694,6 +785,19 @@ unsigned long __copy_from_user_ll(void *to, const void __user *from,
 }
 EXPORT_SYMBOL(__copy_from_user_ll);
 
+unsigned long __copy_from_user_ll_nozero(void *to, const void __user *from,
+                                         unsigned long n)
+{
+        BUG_ON((long)n < 0);
+        if (movsl_is_ok(to, from, n))
+                __copy_user(to, from, n);
+        else
+                n = __copy_user_intel((void __user *)to,
+                                      (const void *)from, n);
+        return n;
+}
+EXPORT_SYMBOL(__copy_from_user_ll_nozero);
+
 unsigned long __copy_from_user_ll_nocache(void *to, const void __user *from,
                                         unsigned long n)
 {
@@ -709,6 +813,21 @@ unsigned long __copy_from_user_ll_nocache(void *to, const void __user *from,
         return n;
 }
 
+unsigned long __copy_from_user_ll_nocache_nozero(void *to, const void __user *from,
+                                        unsigned long n)
+{
+        BUG_ON((long)n < 0);
+#ifdef CONFIG_X86_INTEL_USERCOPY
+        if ( n > 64 && cpu_has_xmm2)
+                n = __copy_user_intel_nocache(to, from, n);
+        else
+                __copy_user(to, from, n);
+#else
+        __copy_user(to, from, n);
+#endif
+        return n;
+}
+
 /**
  * copy_to_user: - Copy a block of data into user space.
  * @to:   Destination address, in user space.
diff --git a/arch/i386/mach-default/setup.c b/arch/i386/mach-default/setup.c
index b4a7455c6993..004837c58793 100644
--- a/arch/i386/mach-default/setup.c
+++ b/arch/i386/mach-default/setup.c
@@ -8,6 +8,8 @@
 #include <linux/interrupt.h>
 #include <asm/acpi.h>
 #include <asm/arch_hooks.h>
+#include <asm/e820.h>
+#include <asm/setup.h>
 
 #ifdef CONFIG_HOTPLUG_CPU
 #define DEFAULT_SEND_IPI        (1)
@@ -130,3 +132,44 @@ static int __init print_ipi_mode(void)
 }
 
 late_initcall(print_ipi_mode);
+
+/**
+ * machine_specific_memory_setup - Hook for machine specific memory setup.
+ *
+ * Description:
+ *      This is included late in kernel/setup.c so that it can make
+ *      use of all of the static functions.
+ **/
+
+char * __init machine_specific_memory_setup(void)
+{
+        char *who;
+
+
+        who = "BIOS-e820";
+
+        /*
+         * Try to copy the BIOS-supplied E820-map.
+         *
+         * Otherwise fake a memory map; one section from 0k->640k,
+         * the next section from 1mb->appropriate_mem_k
+         */
+        sanitize_e820_map(E820_MAP, &E820_MAP_NR);
+        if (copy_e820_map(E820_MAP, E820_MAP_NR) < 0) {
+                unsigned long mem_size;
+
+                /* compare results from other methods and take the greater */
+                if (ALT_MEM_K < EXT_MEM_K) {
+                        mem_size = EXT_MEM_K;
+                        who = "BIOS-88";
+                } else {
+                        mem_size = ALT_MEM_K;
+                        who = "BIOS-e801";
+                }
+
+                e820.nr_map = 0;
+                add_memory_region(0, LOWMEMSIZE(), E820_RAM);
+                add_memory_region(HIGH_MEMORY, mem_size << 10, E820_RAM);
+        }
+        return who;
+}
diff --git a/arch/i386/mach-visws/setup.c b/arch/i386/mach-visws/setup.c
index 07fac7e749c7..8a9e1a6f745d 100644
--- a/arch/i386/mach-visws/setup.c
+++ b/arch/i386/mach-visws/setup.c
@@ -10,6 +10,8 @@
 #include <asm/fixmap.h>
 #include <asm/arch_hooks.h>
 #include <asm/io.h>
+#include <asm/e820.h>
+#include <asm/setup.h>
 #include "cobalt.h"
 #include "piix4.h"
 
@@ -133,3 +135,50 @@ void __init time_init_hook(void)
         /* Wire cpu IDT entry to s/w handler (and Cobalt APIC to IDT) */
         setup_irq(0, &irq0);
 }
+
+/* Hook for machine specific memory setup. */
+
+#define MB (1024 * 1024)
+
+static unsigned long sgivwfb_mem_phys;
+static unsigned long sgivwfb_mem_size;
+
+long long mem_size __initdata = 0;
+
+char * __init machine_specific_memory_setup(void)
+{
+        long long gfx_mem_size = 8 * MB;
+
+        mem_size = ALT_MEM_K;
+
+        if (!mem_size) {
+                printk(KERN_WARNING "Bootloader didn't set memory size, upgrade it !\n");
+                mem_size = 128 * MB;
+        }
+
+        /*
+         * this hardcodes the graphics memory to 8 MB
+         * it really should be sized dynamically (or at least
+         * set as a boot param)
+         */
+        if (!sgivwfb_mem_size) {
+                printk(KERN_WARNING "Defaulting to 8 MB framebuffer size\n");
+                sgivwfb_mem_size = 8 * MB;
+        }
+
+        /*
+         * Trim to nearest MB
+         */
+        sgivwfb_mem_size &= ~((1 << 20) - 1);
+        sgivwfb_mem_phys = mem_size - gfx_mem_size;
+
+        add_memory_region(0, LOWMEMSIZE(), E820_RAM);
+        add_memory_region(HIGH_MEMORY, mem_size - sgivwfb_mem_size - HIGH_MEMORY, E820_RAM);
+        add_memory_region(sgivwfb_mem_phys, sgivwfb_mem_size, E820_RESERVED);
+
+        return "PROM";
+
+        /* Remove gcc warnings */
+        (void) sanitize_e820_map(NULL, NULL);
+        (void) copy_e820_map(NULL, 0);
+}
diff --git a/arch/i386/mach-voyager/setup.c b/arch/i386/mach-voyager/setup.c
index 7d8a3acb9441..0e225054e222 100644
--- a/arch/i386/mach-voyager/setup.c
+++ b/arch/i386/mach-voyager/setup.c
@@ -7,6 +7,9 @@
 #include <linux/interrupt.h>
 #include <asm/acpi.h>
 #include <asm/arch_hooks.h>
+#include <asm/voyager.h>
+#include <asm/e820.h>
+#include <asm/setup.h>
 
 void __init pre_intr_init_hook(void)
 {
@@ -45,3 +48,74 @@ void __init time_init_hook(void)
 {
         setup_irq(0, &irq0);
 }
+
+/* Hook for machine specific memory setup. */
+
+char * __init machine_specific_memory_setup(void)
+{
+        char *who;
+
+        who = "NOT VOYAGER";
+
+        if(voyager_level == 5) {
+                __u32 addr, length;
+                int i;
+
+                who = "Voyager-SUS";
+
+                e820.nr_map = 0;
+                for(i=0; voyager_memory_detect(i, &addr, &length); i++) {
+                        add_memory_region(addr, length, E820_RAM);
+                }
+                return who;
+        } else if(voyager_level == 4) {
+                __u32 tom;
+                __u16 catbase = inb(VOYAGER_SSPB_RELOCATION_PORT)<<8;
+                /* select the DINO config space */
+                outb(VOYAGER_DINO, VOYAGER_CAT_CONFIG_PORT);
+                /* Read DINO top of memory register */
+                tom = ((inb(catbase + 0x4) & 0xf0) << 16)
+                        + ((inb(catbase + 0x5) & 0x7f) << 24);
+
+                if(inb(catbase) != VOYAGER_DINO) {
+                        printk(KERN_ERR "Voyager: Failed to get DINO for L4, setting tom to EXT_MEM_K\n");
+                        tom = (EXT_MEM_K)<<10;
+                }
+                who = "Voyager-TOM";
+                add_memory_region(0, 0x9f000, E820_RAM);
+                /* map from 1M to top of memory */
+                add_memory_region(1*1024*1024, tom - 1*1024*1024, E820_RAM);
+                /* FIXME: Should check the ASICs to see if I need to
+                 * take out the 8M window.  Just do it at the moment
+                 * */
+                add_memory_region(8*1024*1024, 8*1024*1024, E820_RESERVED);
+                return who;
+        }
+
+        who = "BIOS-e820";
+
+        /*
+         * Try to copy the BIOS-supplied E820-map.
+         *
+         * Otherwise fake a memory map; one section from 0k->640k,
+         * the next section from 1mb->appropriate_mem_k
+         */
+        sanitize_e820_map(E820_MAP, &E820_MAP_NR);
+        if (copy_e820_map(E820_MAP, E820_MAP_NR) < 0) {
+                unsigned long mem_size;
+
+                /* compare results from other methods and take the greater */
+                if (ALT_MEM_K < EXT_MEM_K) {
+                        mem_size = EXT_MEM_K;
+                        who = "BIOS-88";
+                } else {
+                        mem_size = ALT_MEM_K;
+                        who = "BIOS-e801";
+                }
+
+                e820.nr_map = 0;
+                add_memory_region(0, LOWMEMSIZE(), E820_RAM);
+                add_memory_region(HIGH_MEMORY, mem_size << 10, E820_RAM);
+        }
+        return who;
+}
diff --git a/arch/i386/pci/i386.c b/arch/i386/pci/i386.c
index 7852827a599b..a151f7a99f5e 100644
--- a/arch/i386/pci/i386.c
+++ b/arch/i386/pci/i386.c
@@ -285,8 +285,6 @@ int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
         /* Leave vm_pgoff as-is, the PCI space address is the physical
          * address on this platform.
          */
-        vma->vm_flags |= (VM_SHM | VM_LOCKED | VM_IO);
-
         prot = pgprot_val(vma->vm_page_prot);
         if (boot_cpu_data.x86 > 3)
                 prot |= _PAGE_PCD | _PAGE_PWT;
diff --git a/arch/ia64/kernel/topology.c b/arch/ia64/kernel/topology.c
index 4f3a16b37f8f..879edb51d1e0 100644
--- a/arch/ia64/kernel/topology.c
+++ b/arch/ia64/kernel/topology.c
@@ -166,7 +166,7 @@ static void cache_shared_cpu_map_setup( unsigned int cpu,
 
         num_shared = (int) csi.num_shared;
         do {
-                for_each_cpu(j)
+                for_each_possible_cpu(j)
                         if (cpu_data(cpu)->socket_id == cpu_data(j)->socket_id
                                 && cpu_data(j)->core_id == csi.log1_cid
                                 && cpu_data(j)->thread_id == csi.log1_tid)
diff --git a/arch/ia64/pci/pci.c b/arch/ia64/pci/pci.c
index 61dd8608da4f..77375a55da31 100644
--- a/arch/ia64/pci/pci.c
+++ b/arch/ia64/pci/pci.c
@@ -602,8 +602,6 @@ pci_mmap_page_range (struct pci_dev *dev, struct vm_area_struct *vma,
          * Leave vm_pgoff as-is, the PCI space address is the physical
          * address on this platform.
          */
-        vma->vm_flags |= (VM_SHM | VM_RESERVED | VM_IO);
-
         if (write_combine && efi_range_is_wc(vma->vm_start,
                                              vma->vm_end - vma->vm_start))
                 vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
@@ -666,7 +664,6 @@ pci_mmap_legacy_page_range(struct pci_bus *bus, struct vm_area_struct *vma)
 
         vma->vm_pgoff += (unsigned long)addr >> PAGE_SHIFT;
         vma->vm_page_prot = prot;
-        vma->vm_flags |= (VM_SHM | VM_RESERVED | VM_IO);
 
         if (remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
                             size, vma->vm_page_prot))
diff --git a/arch/m68k/amiga/amiga_ksyms.c b/arch/m68k/amiga/amiga_ksyms.c
index b7bd84c73ea7..8f2e0587ae2f 100644
--- a/arch/m68k/amiga/amiga_ksyms.c
+++ b/arch/m68k/amiga/amiga_ksyms.c
@@ -23,8 +23,6 @@ EXPORT_SYMBOL(amiga_chip_avail);
 EXPORT_SYMBOL(amiga_chip_size);
 EXPORT_SYMBOL(amiga_audio_period);
 EXPORT_SYMBOL(amiga_audio_min_period);
-EXPORT_SYMBOL(amiga_do_irq);
-EXPORT_SYMBOL(amiga_do_irq_list);
 
 #ifdef CONFIG_AMIGA_PCMCIA
   EXPORT_SYMBOL(pcmcia_reset);
diff --git a/arch/m68k/amiga/amiints.c b/arch/m68k/amiga/amiints.c
index b0aa61bf8700..f9403f4640a1 100644
--- a/arch/m68k/amiga/amiints.c
+++ b/arch/m68k/amiga/amiints.c
@@ -35,61 +35,30 @@
  *           /Jes
  */
 
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/sched.h>
-#include <linux/kernel_stat.h>
 #include <linux/init.h>
+#include <linux/interrupt.h>
 #include <linux/errno.h>
-#include <linux/seq_file.h>
 
-#include <asm/system.h>
 #include <asm/irq.h>
 #include <asm/traps.h>
 #include <asm/amigahw.h>
 #include <asm/amigaints.h>
 #include <asm/amipcmcia.h>
 
-extern int cia_request_irq(struct ciabase *base,int irq,
-                           irqreturn_t (*handler)(int, void *, struct pt_regs *),
-                           unsigned long flags, const char *devname, void *dev_id);
-extern void cia_free_irq(struct ciabase *base, unsigned int irq, void *dev_id);
-extern void cia_init_IRQ(struct ciabase *base);
-extern int cia_get_irq_list(struct ciabase *base, struct seq_file *p);
-
-/* irq node variables for amiga interrupt sources */
-static irq_node_t *ami_irq_list[AMI_STD_IRQS];
-
-static unsigned short amiga_intena_vals[AMI_STD_IRQS] = {
-        [IRQ_AMIGA_VERTB]       = IF_VERTB,
-        [IRQ_AMIGA_COPPER]      = IF_COPER,
-        [IRQ_AMIGA_AUD0]        = IF_AUD0,
-        [IRQ_AMIGA_AUD1]        = IF_AUD1,
-        [IRQ_AMIGA_AUD2]        = IF_AUD2,
-        [IRQ_AMIGA_AUD3]        = IF_AUD3,
-        [IRQ_AMIGA_BLIT]        = IF_BLIT,
-        [IRQ_AMIGA_DSKSYN]      = IF_DSKSYN,
-        [IRQ_AMIGA_DSKBLK]      = IF_DSKBLK,
-        [IRQ_AMIGA_RBF]         = IF_RBF,
-        [IRQ_AMIGA_TBE]         = IF_TBE,
-        [IRQ_AMIGA_SOFT]        = IF_SOFT,
-        [IRQ_AMIGA_PORTS]       = IF_PORTS,
-        [IRQ_AMIGA_EXTER]       = IF_EXTER
-};
-static const unsigned char ami_servers[AMI_STD_IRQS] = {
-        [IRQ_AMIGA_VERTB]       = 1,
-        [IRQ_AMIGA_PORTS]       = 1,
-        [IRQ_AMIGA_EXTER]       = 1
+static void amiga_enable_irq(unsigned int irq);
+static void amiga_disable_irq(unsigned int irq);
+static irqreturn_t ami_int1(int irq, void *dev_id, struct pt_regs *fp);
+static irqreturn_t ami_int3(int irq, void *dev_id, struct pt_regs *fp);
+static irqreturn_t ami_int4(int irq, void *dev_id, struct pt_regs *fp);
+static irqreturn_t ami_int5(int irq, void *dev_id, struct pt_regs *fp);
+
+static struct irq_controller amiga_irq_controller = {
+        .name           = "amiga",
+        .lock           = SPIN_LOCK_UNLOCKED,
+        .enable         = amiga_enable_irq,
+        .disable        = amiga_disable_irq,
 };
 
-static short ami_ablecount[AMI_IRQS];
-
-static irqreturn_t ami_badint(int irq, void *dev_id, struct pt_regs *fp)
-{
-        num_spurious += 1;
-        return IRQ_NONE;
-}
-
 /*
  * void amiga_init_IRQ(void)
  *
@@ -103,23 +72,12 @@ static irqreturn_t ami_badint(int irq, void *dev_id, struct pt_regs *fp)
 
 void __init amiga_init_IRQ(void)
 {
-        int i;
+        request_irq(IRQ_AUTO_1, ami_int1, 0, "int1", NULL);
+        request_irq(IRQ_AUTO_3, ami_int3, 0, "int3", NULL);
+        request_irq(IRQ_AUTO_4, ami_int4, 0, "int4", NULL);
+        request_irq(IRQ_AUTO_5, ami_int5, 0, "int5", NULL);
 
-        /* initialize handlers */
-        for (i = 0; i < AMI_STD_IRQS; i++) {
-                if (ami_servers[i]) {
-                        ami_irq_list[i] = NULL;
-                } else {
-                        ami_irq_list[i] = new_irq_node();
-                        ami_irq_list[i]->handler = ami_badint;
-                        ami_irq_list[i]->flags   = 0;
-                        ami_irq_list[i]->dev_id  = NULL;
-                        ami_irq_list[i]->devname = NULL;
-                        ami_irq_list[i]->next    = NULL;
-                }
-        }
-        for (i = 0; i < AMI_IRQS; i++)
-                ami_ablecount[i] = 0;
+        m68k_setup_irq_controller(&amiga_irq_controller, IRQ_USER, AMI_STD_IRQS);
 
         /* turn off PCMCIA interrupts */
         if (AMIGAHW_PRESENT(PCMCIA))
@@ -134,249 +92,21 @@ void __init amiga_init_IRQ(void)
         cia_init_IRQ(&ciab_base);
 }
 
-static inline int amiga_insert_irq(irq_node_t **list, irq_node_t *node)
-{
-        unsigned long flags;
-        irq_node_t *cur;
-
-        if (!node->dev_id)
-                printk("%s: Warning: dev_id of %s is zero\n",
-                       __FUNCTION__, node->devname);
-
-        local_irq_save(flags);
-
-        cur = *list;
-
-        if (node->flags & SA_INTERRUPT) {
-                if (node->flags & SA_SHIRQ)
-                        return -EBUSY;
-                /*
-                 * There should never be more than one
-                 */
-                while (cur && cur->flags & SA_INTERRUPT) {
-                        list = &cur->next;
-                        cur = cur->next;
-                }
-        } else {
-                while (cur) {
-                        list = &cur->next;
-                        cur = cur->next;
-                }
-        }
-
-        node->next = cur;
-        *list = node;
-
-        local_irq_restore(flags);
-        return 0;
-}
-
-static inline void amiga_delete_irq(irq_node_t **list, void *dev_id)
-{
-        unsigned long flags;
-        irq_node_t *node;
-
-        local_irq_save(flags);
-
-        for (node = *list; node; list = &node->next, node = *list) {
-                if (node->dev_id == dev_id) {
-                        *list = node->next;
-                        /* Mark it as free. */
-                        node->handler = NULL;
-                        local_irq_restore(flags);
-                        return;
-                }
-        }
-        local_irq_restore(flags);
-        printk ("%s: tried to remove invalid irq\n", __FUNCTION__);
-}
-
-/*
- * amiga_request_irq : add an interrupt service routine for a particular
- *                     machine specific interrupt source.
- *                     If the addition was successful, it returns 0.
- */
-
-int amiga_request_irq(unsigned int irq,
-                      irqreturn_t (*handler)(int, void *, struct pt_regs *),
-                      unsigned long flags, const char *devname, void *dev_id)
-{
-        irq_node_t *node;
-        int error = 0;
-
-        if (irq >= AMI_IRQS) {
-                printk ("%s: Unknown IRQ %d from %s\n", __FUNCTION__,
-                        irq, devname);
-                return -ENXIO;
-        }
-
-        if (irq >= IRQ_AMIGA_AUTO)
-                return cpu_request_irq(irq - IRQ_AMIGA_AUTO, handler,
-                                       flags, devname, dev_id);
-
-        if (irq >= IRQ_AMIGA_CIAB)
-                return cia_request_irq(&ciab_base, irq - IRQ_AMIGA_CIAB,
-                                       handler, flags, devname, dev_id);
-
-        if (irq >= IRQ_AMIGA_CIAA)
-                return cia_request_irq(&ciaa_base, irq - IRQ_AMIGA_CIAA,
-                                       handler, flags, devname, dev_id);
-
-        /*
-         * IRQ_AMIGA_PORTS & IRQ_AMIGA_EXTER defaults to shared,
-         * we could add a check here for the SA_SHIRQ flag but all drivers
-         * should be aware of sharing anyway.
-         */
-        if (ami_servers[irq]) {
-                if (!(node = new_irq_node()))
-                        return -ENOMEM;
-                node->handler = handler;
-                node->flags   = flags;
-                node->dev_id  = dev_id;
-                node->devname = devname;
-                node->next    = NULL;
-                error = amiga_insert_irq(&ami_irq_list[irq], node);
-        } else {
-                ami_irq_list[irq]->handler = handler;
-                ami_irq_list[irq]->flags   = flags;
-                ami_irq_list[irq]->dev_id  = dev_id;
-                ami_irq_list[irq]->devname = devname;
-        }
-
-        /* enable the interrupt */
-        if (irq < IRQ_AMIGA_PORTS && !ami_ablecount[irq])
-                amiga_custom.intena = IF_SETCLR | amiga_intena_vals[irq];
-
-        return error;
-}
-
-void amiga_free_irq(unsigned int irq, void *dev_id)
-{
-        if (irq >= AMI_IRQS) {
-                printk ("%s: Unknown IRQ %d\n", __FUNCTION__, irq);
-                return;
-        }
-
-        if (irq >= IRQ_AMIGA_AUTO)
-                cpu_free_irq(irq - IRQ_AMIGA_AUTO, dev_id);
-
-        if (irq >= IRQ_AMIGA_CIAB) {
-                cia_free_irq(&ciab_base, irq - IRQ_AMIGA_CIAB, dev_id);
-                return;
-        }
-
-        if (irq >= IRQ_AMIGA_CIAA) {
-                cia_free_irq(&ciaa_base, irq - IRQ_AMIGA_CIAA, dev_id);
-                return;
-        }
-
-        if (ami_servers[irq]) {
-                amiga_delete_irq(&ami_irq_list[irq], dev_id);
-                /* if server list empty, disable the interrupt */
-                if (!ami_irq_list[irq] && irq < IRQ_AMIGA_PORTS)
-                        amiga_custom.intena = amiga_intena_vals[irq];
-        } else {
-                if (ami_irq_list[irq]->dev_id != dev_id)
-                        printk("%s: removing probably wrong IRQ %d from %s\n",
-                               __FUNCTION__, irq, ami_irq_list[irq]->devname);
-                ami_irq_list[irq]->handler = ami_badint;
-                ami_irq_list[irq]->flags   = 0;
-                ami_irq_list[irq]->dev_id  = NULL;
-                ami_irq_list[irq]->devname = NULL;
-                amiga_custom.intena = amiga_intena_vals[irq];
-        }
-}
-
 /*
  * Enable/disable a particular machine specific interrupt source.
  * Note that this may affect other interrupts in case of a shared interrupt.
  * This function should only be called for a _very_ short time to change some
  * internal data, that may not be changed by the interrupt at the same time.
- * ami_(enable|disable)_irq calls may also be nested.
  */
 
-void amiga_enable_irq(unsigned int irq)
-{
-        if (irq >= AMI_IRQS) {
-                printk("%s: Unknown IRQ %d\n", __FUNCTION__, irq);
-                return;
-        }
-
-        if (--ami_ablecount[irq])
-                return;
-
-        /* No action for auto-vector interrupts */
-        if (irq >= IRQ_AMIGA_AUTO){
-                printk("%s: Trying to enable auto-vector IRQ %i\n",
-                       __FUNCTION__, irq - IRQ_AMIGA_AUTO);
-                return;
-        }
-
-        if (irq >= IRQ_AMIGA_CIAB) {
-                cia_set_irq(&ciab_base, (1 << (irq - IRQ_AMIGA_CIAB)));
-                cia_able_irq(&ciab_base, CIA_ICR_SETCLR |
-                             (1 << (irq - IRQ_AMIGA_CIAB)));
-                return;
-        }
-
-        if (irq >= IRQ_AMIGA_CIAA) {
-                cia_set_irq(&ciaa_base, (1 << (irq - IRQ_AMIGA_CIAA)));
-                cia_able_irq(&ciaa_base, CIA_ICR_SETCLR |
-                             (1 << (irq - IRQ_AMIGA_CIAA)));
-                return;
-        }
-
-        /* enable the interrupt */
-        amiga_custom.intena = IF_SETCLR | amiga_intena_vals[irq];
-}
-
-void amiga_disable_irq(unsigned int irq)
-{
-        if (irq >= AMI_IRQS) {
-                printk("%s: Unknown IRQ %d\n", __FUNCTION__, irq);
-                return;
-        }
-
-        if (ami_ablecount[irq]++)
-                return;
-
-        /* No action for auto-vector interrupts */
-        if (irq >= IRQ_AMIGA_AUTO) {
-                printk("%s: Trying to disable auto-vector IRQ %i\n",
-                       __FUNCTION__, irq - IRQ_AMIGA_AUTO);
-                return;
-        }
-
-        if (irq >= IRQ_AMIGA_CIAB) {
-                cia_able_irq(&ciab_base, 1 << (irq - IRQ_AMIGA_CIAB));
-                return;
-        }
-
-        if (irq >= IRQ_AMIGA_CIAA) {
-                cia_able_irq(&ciaa_base, 1 << (irq - IRQ_AMIGA_CIAA));
-                return;
-        }
-
-        /* disable the interrupt */
-        amiga_custom.intena = amiga_intena_vals[irq];
-}
-
-inline void amiga_do_irq(int irq, struct pt_regs *fp)
+static void amiga_enable_irq(unsigned int irq)
 {
-        kstat_cpu(0).irqs[SYS_IRQS + irq]++;
-        ami_irq_list[irq]->handler(irq, ami_irq_list[irq]->dev_id, fp);
+        amiga_custom.intena = IF_SETCLR | (1 << (irq - IRQ_USER));
 }
 
-void amiga_do_irq_list(int irq, struct pt_regs *fp)
+static void amiga_disable_irq(unsigned int irq)
 {
-        irq_node_t *node;
-
-        kstat_cpu(0).irqs[SYS_IRQS + irq]++;
-
-        amiga_custom.intreq = amiga_intena_vals[irq];
-
-        for (node = ami_irq_list[irq]; node; node = node->next)
-                node->handler(irq, node->dev_id, fp);
+        amiga_custom.intena = 1 << (irq - IRQ_USER);
 }
 
 /*
@@ -390,19 +120,19 @@ static irqreturn_t ami_int1(int irq, void *dev_id, struct pt_regs *fp)
         /* if serial transmit buffer empty, interrupt */
         if (ints & IF_TBE) {
                 amiga_custom.intreq = IF_TBE;
-                amiga_do_irq(IRQ_AMIGA_TBE, fp);
+                m68k_handle_int(IRQ_AMIGA_TBE, fp);
         }
 
         /* if floppy disk transfer complete, interrupt */
         if (ints & IF_DSKBLK) {
                 amiga_custom.intreq = IF_DSKBLK;
-                amiga_do_irq(IRQ_AMIGA_DSKBLK, fp);
+                m68k_handle_int(IRQ_AMIGA_DSKBLK, fp);
         }
 
         /* if software interrupt set, interrupt */
         if (ints & IF_SOFT) {
                 amiga_custom.intreq = IF_SOFT;
-                amiga_do_irq(IRQ_AMIGA_SOFT, fp);
+                m68k_handle_int(IRQ_AMIGA_SOFT, fp);
         }
         return IRQ_HANDLED;
 }
@@ -414,18 +144,20 @@ static irqreturn_t ami_int3(int irq, void *dev_id, struct pt_regs *fp)
         /* if a blitter interrupt */
         if (ints & IF_BLIT) {
                 amiga_custom.intreq = IF_BLIT;
-                amiga_do_irq(IRQ_AMIGA_BLIT, fp);
+                m68k_handle_int(IRQ_AMIGA_BLIT, fp);
         }
 
         /* if a copper interrupt */
         if (ints & IF_COPER) {
                 amiga_custom.intreq = IF_COPER;
-                amiga_do_irq(IRQ_AMIGA_COPPER, fp);
+                m68k_handle_int(IRQ_AMIGA_COPPER, fp);
         }
 
         /* if a vertical blank interrupt */
-        if (ints & IF_VERTB)
-                amiga_do_irq_list(IRQ_AMIGA_VERTB, fp);
+        if (ints & IF_VERTB) {
+                amiga_custom.intreq = IF_VERTB;
+                m68k_handle_int(IRQ_AMIGA_VERTB, fp);
+        }
         return IRQ_HANDLED;
 }
 
@@ -436,25 +168,25 @@ static irqreturn_t ami_int4(int irq, void *dev_id, struct pt_regs *fp)
         /* if audio 0 interrupt */
         if (ints & IF_AUD0) {
                 amiga_custom.intreq = IF_AUD0;
-                amiga_do_irq(IRQ_AMIGA_AUD0, fp);
+                m68k_handle_int(IRQ_AMIGA_AUD0, fp);
         }
 
         /* if audio 1 interrupt */
         if (ints & IF_AUD1) {
                 amiga_custom.intreq = IF_AUD1;
-                amiga_do_irq(IRQ_AMIGA_AUD1, fp);
+                m68k_handle_int(IRQ_AMIGA_AUD1, fp);
         }
 
         /* if audio 2 interrupt */
         if (ints & IF_AUD2) {
                 amiga_custom.intreq = IF_AUD2;
-                amiga_do_irq(IRQ_AMIGA_AUD2, fp);
+                m68k_handle_int(IRQ_AMIGA_AUD2, fp);
         }
 
         /* if audio 3 interrupt */
         if (ints & IF_AUD3) {
                 amiga_custom.intreq = IF_AUD3;
-                amiga_do_irq(IRQ_AMIGA_AUD3, fp);
+                m68k_handle_int(IRQ_AMIGA_AUD3, fp);
         }
         return IRQ_HANDLED;
 }
@@ -466,55 +198,13 @@ static irqreturn_t ami_int5(int irq, void *dev_id, struct pt_regs *fp)
         /* if serial receive buffer full interrupt */
         if (ints & IF_RBF) {
                 /* acknowledge of IF_RBF must be done by the serial interrupt */
-                amiga_do_irq(IRQ_AMIGA_RBF, fp);
+                m68k_handle_int(IRQ_AMIGA_RBF, fp);
         }
 
         /* if a disk sync interrupt */
         if (ints & IF_DSKSYN) {
                 amiga_custom.intreq = IF_DSKSYN;
-                amiga_do_irq(IRQ_AMIGA_DSKSYN, fp);
+                m68k_handle_int(IRQ_AMIGA_DSKSYN, fp);
         }
         return IRQ_HANDLED;
 }
-
-static irqreturn_t ami_int7(int irq, void *dev_id, struct pt_regs *fp)
-{
-        panic ("level 7 interrupt received\n");
-}
-
-irqreturn_t (*amiga_default_handler[SYS_IRQS])(int, void *, struct pt_regs *) = {
-        [0] = ami_badint,
-        [1] = ami_int1,
-        [2] = ami_badint,
-        [3] = ami_int3,
-        [4] = ami_int4,
-        [5] = ami_int5,
-        [6] = ami_badint,
-        [7] = ami_int7
-};
-
-int show_amiga_interrupts(struct seq_file *p, void *v)
-{
-        int i;
-        irq_node_t *node;
-
-        for (i = 0; i < AMI_STD_IRQS; i++) {
-                if (!(node = ami_irq_list[i]))
-                        continue;
-                seq_printf(p, "ami  %2d: %10u ", i,
-                               kstat_cpu(0).irqs[SYS_IRQS + i]);
-                do {
-                        if (node->flags & SA_INTERRUPT)
-                                seq_puts(p, "F ");
-                        else
-                                seq_puts(p, "  ");
-                        seq_printf(p, "%s\n", node->devname);
-                        if ((node = node->next))
-                                seq_puts(p, "                    ");
-                } while (node);
-        }
-
-        cia_get_irq_list(&ciaa_base, p);
-        cia_get_irq_list(&ciab_base, p);
-        return 0;
-}
diff --git a/arch/m68k/amiga/cia.c b/arch/m68k/amiga/cia.c
index 9476eb9440f5..0956e45399e5 100644
--- a/arch/m68k/amiga/cia.c
+++ b/arch/m68k/amiga/cia.c
@@ -29,21 +29,18 @@ struct ciabase {
         unsigned short int_mask;
         int handler_irq, cia_irq, server_irq;
         char *name;
-        irq_handler_t irq_list[CIA_IRQS];
 } ciaa_base = {
         .cia            = &ciaa,
         .int_mask       = IF_PORTS,
-        .handler_irq    = IRQ_AMIGA_AUTO_2,
+        .handler_irq    = IRQ_AMIGA_PORTS,
         .cia_irq        = IRQ_AMIGA_CIAA,
-        .server_irq     = IRQ_AMIGA_PORTS,
-        .name           = "CIAA handler"
+        .name           = "CIAA"
 }, ciab_base = {
         .cia            = &ciab,
         .int_mask       = IF_EXTER,
-        .handler_irq    = IRQ_AMIGA_AUTO_6,
+        .handler_irq    = IRQ_AMIGA_EXTER,
         .cia_irq        = IRQ_AMIGA_CIAB,
-        .server_irq     = IRQ_AMIGA_EXTER,
-        .name           = "CIAB handler"
+        .name           = "CIAB"
 };
 
 /*
@@ -66,13 +63,11 @@ unsigned char cia_set_irq(struct ciabase *base, unsigned char mask)
 
 /*
  *  Enable or disable CIA interrupts, return old interrupt mask,
- *  interrupts will only be enabled if a handler exists
  */
 
 unsigned char cia_able_irq(struct ciabase *base, unsigned char mask)
 {
-        unsigned char old, tmp;
-        int i;
+        unsigned char old;
 
         old = base->icr_mask;
         base->icr_data |= base->cia->icr;
@@ -82,99 +77,104 @@ unsigned char cia_able_irq(struct ciabase *base, unsigned char mask)
         else
                 base->icr_mask &= ~mask;
         base->icr_mask &= CIA_ICR_ALL;
-        for (i = 0, tmp = 1; i < CIA_IRQS; i++, tmp <<= 1) {
-                if ((tmp & base->icr_mask) && !base->irq_list[i].handler) {
-                        base->icr_mask &= ~tmp;
-                        base->cia->icr = tmp;
-                }
-        }
         if (base->icr_data & base->icr_mask)
                 amiga_custom.intreq = IF_SETCLR | base->int_mask;
         return old;
 }
 
-int cia_request_irq(struct ciabase *base, unsigned int irq,
-                    irqreturn_t (*handler)(int, void *, struct pt_regs *),
-                    unsigned long flags, const char *devname, void *dev_id)
-{
-        unsigned char mask;
-
-        base->irq_list[irq].handler = handler;
-        base->irq_list[irq].flags   = flags;
-        base->irq_list[irq].dev_id  = dev_id;
-        base->irq_list[irq].devname = devname;
-
-        /* enable the interrupt */
-        mask = 1 << irq;
-        cia_set_irq(base, mask);
-        cia_able_irq(base, CIA_ICR_SETCLR | mask);
-        return 0;
-}
-
-void cia_free_irq(struct ciabase *base, unsigned int irq, void *dev_id)
-{
-        if (base->irq_list[irq].dev_id != dev_id)
-                printk("%s: removing probably wrong IRQ %i from %s\n",
-                       __FUNCTION__, base->cia_irq + irq,
-                       base->irq_list[irq].devname);
-
-        base->irq_list[irq].handler = NULL;
-        base->irq_list[irq].flags   = 0;
-
-        cia_able_irq(base, 1 << irq);
-}
-
 static irqreturn_t cia_handler(int irq, void *dev_id, struct pt_regs *fp)
 {
         struct ciabase *base = (struct ciabase *)dev_id;
-        int mach_irq, i;
+        int mach_irq;
         unsigned char ints;
 
         mach_irq = base->cia_irq;
-        irq = SYS_IRQS + mach_irq;
         ints = cia_set_irq(base, CIA_ICR_ALL);
         amiga_custom.intreq = base->int_mask;
-        for (i = 0; i < CIA_IRQS; i++, irq++, mach_irq++) {
-                if (ints & 1) {
-                        kstat_cpu(0).irqs[irq]++;
-                        base->irq_list[i].handler(mach_irq, base->irq_list[i].dev_id, fp);
-                }
-                ints >>= 1;
+        for (; ints; mach_irq++, ints >>= 1) {
+                if (ints & 1)
+                        m68k_handle_int(mach_irq, fp);
         }
-        amiga_do_irq_list(base->server_irq, fp);
         return IRQ_HANDLED;
 }
 
-void __init cia_init_IRQ(struct ciabase *base)
+static void cia_enable_irq(unsigned int irq)
 {
-        int i;
+        unsigned char mask;
 
-        /* init isr handlers */
-        for (i = 0; i < CIA_IRQS; i++) {
-                base->irq_list[i].handler = NULL;
-                base->irq_list[i].flags   = 0;
+        if (irq >= IRQ_AMIGA_CIAB) {
+                mask = 1 << (irq - IRQ_AMIGA_CIAB);
+                cia_set_irq(&ciab_base, mask);
+                cia_able_irq(&ciab_base, CIA_ICR_SETCLR | mask);
+        } else {
+                mask = 1 << (irq - IRQ_AMIGA_CIAA);
+                cia_set_irq(&ciaa_base, mask);
+                cia_able_irq(&ciaa_base, CIA_ICR_SETCLR | mask);
         }
+}
 
-        /* clear any pending interrupt and turn off all interrupts */
-        cia_set_irq(base, CIA_ICR_ALL);
-        cia_able_irq(base, CIA_ICR_ALL);
+static void cia_disable_irq(unsigned int irq)
+{
+        if (irq >= IRQ_AMIGA_CIAB)
+                cia_able_irq(&ciab_base, 1 << (irq - IRQ_AMIGA_CIAB));
+        else
+                cia_able_irq(&ciaa_base, 1 << (irq - IRQ_AMIGA_CIAA));
+}
 
-        /* install CIA handler */
-        request_irq(base->handler_irq, cia_handler, 0, base->name, base);
+static struct irq_controller cia_irq_controller = {
+        .name           = "cia",
+        .lock           = SPIN_LOCK_UNLOCKED,
+        .enable         = cia_enable_irq,
+        .disable        = cia_disable_irq,
+};
+
+/*
+ * Override auto irq 2 & 6 and use them as general chain
+ * for external interrupts, we link the CIA interrupt sources
+ * into this chain.
+ */
 
-        amiga_custom.intena = IF_SETCLR | base->int_mask;
+static void auto_enable_irq(unsigned int irq)
+{
+        switch (irq) {
+        case IRQ_AUTO_2:
+                amiga_custom.intena = IF_SETCLR | IF_PORTS;
+                break;
+        case IRQ_AUTO_6:
+                amiga_custom.intena = IF_SETCLR | IF_EXTER;
+                break;
+        }
 }
 
-int cia_get_irq_list(struct ciabase *base, struct seq_file *p)
+static void auto_disable_irq(unsigned int irq)
 {
-        int i, j;
-
-        j = base->cia_irq;
-        for (i = 0; i < CIA_IRQS; i++) {
-                seq_printf(p, "cia  %2d: %10d ", j + i,
-                               kstat_cpu(0).irqs[SYS_IRQS + j + i]);
-                seq_puts(p, "  ");
-                seq_printf(p, "%s\n", base->irq_list[i].devname);
+        switch (irq) {
+        case IRQ_AUTO_2:
+                amiga_custom.intena = IF_PORTS;
+                break;
+        case IRQ_AUTO_6:
+                amiga_custom.intena = IF_EXTER;
+                break;
         }
-        return 0;
+}
+
+static struct irq_controller auto_irq_controller = {
+        .name           = "auto",
+        .lock           = SPIN_LOCK_UNLOCKED,
+        .enable         = auto_enable_irq,
+        .disable        = auto_disable_irq,
+};
+
+void __init cia_init_IRQ(struct ciabase *base)
+{
+        m68k_setup_irq_controller(&cia_irq_controller, base->cia_irq, CIA_IRQS);
+
+        /* clear any pending interrupt and turn off all interrupts */
+        cia_set_irq(base, CIA_ICR_ALL);
+        cia_able_irq(base, CIA_ICR_ALL);
+
+        /* override auto int and install CIA handler */
+        m68k_setup_irq_controller(&auto_irq_controller, base->handler_irq, 1);
+        m68k_irq_startup(base->handler_irq);
+        request_irq(base->handler_irq, cia_handler, SA_SHIRQ, base->name, base);
 }
diff --git a/arch/m68k/amiga/config.c b/arch/m68k/amiga/config.c
index 12e3706fe02c..b5b8a416a07a 100644
--- a/arch/m68k/amiga/config.c
+++ b/arch/m68k/amiga/config.c
@@ -87,17 +87,8 @@ extern char m68k_debug_device[];
 static void amiga_sched_init(irqreturn_t (*handler)(int, void *, struct pt_regs *));
 /* amiga specific irq functions */
 extern void amiga_init_IRQ (void);
-extern irqreturn_t (*amiga_default_handler[]) (int, void *, struct pt_regs *);
-extern int amiga_request_irq (unsigned int irq,
-                              irqreturn_t (*handler)(int, void *, struct pt_regs *),
-                              unsigned long flags, const char *devname,
-                              void *dev_id);
-extern void amiga_free_irq (unsigned int irq, void *dev_id);
-extern void amiga_enable_irq (unsigned int);
-extern void amiga_disable_irq (unsigned int);
 static void amiga_get_model(char *model);
 static int amiga_get_hardware_list(char *buffer);
-extern int show_amiga_interrupts (struct seq_file *, void *);
 /* amiga specific timer functions */
 static unsigned long amiga_gettimeoffset (void);
 static int a3000_hwclk (int, struct rtc_time *);
@@ -392,14 +383,8 @@ void __init config_amiga(void)
 
   mach_sched_init      = amiga_sched_init;
   mach_init_IRQ        = amiga_init_IRQ;
-  mach_default_handler = &amiga_default_handler;
-  mach_request_irq     = amiga_request_irq;
-  mach_free_irq        = amiga_free_irq;
-  enable_irq           = amiga_enable_irq;
-  disable_irq          = amiga_disable_irq;
   mach_get_model       = amiga_get_model;
   mach_get_hardware_list = amiga_get_hardware_list;
-  mach_get_irq_list    = show_amiga_interrupts;
   mach_gettimeoffset   = amiga_gettimeoffset;
   if (AMIGAHW_PRESENT(A3000_CLK)){
     mach_hwclk         = a3000_hwclk;
diff --git a/arch/m68k/apollo/Makefile b/arch/m68k/apollo/Makefile
index 39264f3b6ad6..76a057962c38 100644
--- a/arch/m68k/apollo/Makefile
+++ b/arch/m68k/apollo/Makefile
@@ -2,4 +2,4 @@
 # Makefile for Linux arch/m68k/amiga source directory
 #
 
-obj-y           := config.o dn_ints.o dma.o
+obj-y           := config.o dn_ints.o
diff --git a/arch/m68k/apollo/config.c b/arch/m68k/apollo/config.c
index d401962d9b25..99c70978aafa 100644
--- a/arch/m68k/apollo/config.c
+++ b/arch/m68k/apollo/config.c
@@ -28,11 +28,6 @@ u_long apollo_model;
 
 extern void dn_sched_init(irqreturn_t (*handler)(int,void *,struct pt_regs *));
 extern void dn_init_IRQ(void);
-extern int dn_request_irq(unsigned int irq, irqreturn_t (*handler)(int, void *, struct pt_regs *), unsigned long flags, const char *devname, void *dev_id);
-extern void dn_free_irq(unsigned int irq, void *dev_id);
-extern void dn_enable_irq(unsigned int);
-extern void dn_disable_irq(unsigned int);
-extern int show_dn_interrupts(struct seq_file *, void *);
 extern unsigned long dn_gettimeoffset(void);
 extern int dn_dummy_hwclk(int, struct rtc_time *);
 extern int dn_dummy_set_clock_mmss(unsigned long);
@@ -40,13 +35,11 @@ extern void dn_dummy_reset(void);
 extern void dn_dummy_waitbut(void);
 extern struct fb_info *dn_fb_init(long *);
 extern void dn_dummy_debug_init(void);
-extern void dn_dummy_video_setup(char *,int *);
 extern irqreturn_t dn_process_int(int irq, struct pt_regs *fp);
 #ifdef CONFIG_HEARTBEAT
 static void dn_heartbeat(int on);
 #endif
 static irqreturn_t dn_timer_int(int irq,void *, struct pt_regs *);
-static irqreturn_t (*sched_timer_handler)(int, void *, struct pt_regs *)=NULL;
 static void dn_get_model(char *model);
 static const char *apollo_models[] = {
         [APOLLO_DN3000-APOLLO_DN3000] = "DN3000 (Otter)",
@@ -164,17 +157,10 @@ void config_apollo(void) {
 
         mach_sched_init=dn_sched_init; /* */
         mach_init_IRQ=dn_init_IRQ;
-        mach_default_handler=NULL;
-        mach_request_irq     = dn_request_irq;
-        mach_free_irq        = dn_free_irq;
-        enable_irq      = dn_enable_irq;
-        disable_irq     = dn_disable_irq;
-        mach_get_irq_list    = show_dn_interrupts;
         mach_gettimeoffset   = dn_gettimeoffset;
         mach_max_dma_address = 0xffffffff;
         mach_hwclk           = dn_dummy_hwclk; /* */
         mach_set_clock_mmss  = dn_dummy_set_clock_mmss; /* */
-        mach_process_int     = dn_process_int;
         mach_reset           = dn_dummy_reset;  /* */
 #ifdef CONFIG_HEARTBEAT
         mach_heartbeat = dn_heartbeat;
@@ -189,11 +175,13 @@ void config_apollo(void) {
 
 }
 
-irqreturn_t dn_timer_int(int irq, void *dev_id, struct pt_regs *fp) {
+irqreturn_t dn_timer_int(int irq, void *dev_id, struct pt_regs *fp)
+{
+        irqreturn_t (*timer_handler)(int, void *, struct pt_regs *) = dev_id;
 
         volatile unsigned char x;
 
-        sched_timer_handler(irq,dev_id,fp);
+        timer_handler(irq, dev_id, fp);
 
         x=*(volatile unsigned char *)(timer+3);
         x=*(volatile unsigned char *)(timer+5);
@@ -217,9 +205,7 @@ void dn_sched_init(irqreturn_t (*timer_routine)(int, void *, struct pt_regs *))
         printk("*(0x10803) %02x\n",*(volatile unsigned char *)(timer+0x3));
 #endif
 
-        sched_timer_handler=timer_routine;
-        request_irq(0,dn_timer_int,0,NULL,NULL);
-
+        request_irq(IRQ_APOLLO, dn_timer_int, 0, "time", timer_routine);
 }
 
 unsigned long dn_gettimeoffset(void) {
diff --git a/arch/m68k/apollo/dn_ints.c b/arch/m68k/apollo/dn_ints.c
index a31259359a12..9fe07803797b 100644
--- a/arch/m68k/apollo/dn_ints.c
+++ b/arch/m68k/apollo/dn_ints.c
@@ -1,125 +1,44 @@
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/jiffies.h>
-#include <linux/kernel_stat.h>
-#include <linux/timer.h>
+#include <linux/interrupt.h>
 
-#include <asm/system.h>
 #include <asm/irq.h>
 #include <asm/traps.h>
-#include <asm/page.h>
-#include <asm/machdep.h>
 #include <asm/apollohw.h>
-#include <asm/errno.h>
 
-static irq_handler_t dn_irqs[16];
-
-irqreturn_t dn_process_int(int irq, struct pt_regs *fp)
+void dn_process_int(unsigned int irq, struct pt_regs *fp)
 {
-  irqreturn_t res = IRQ_NONE;
-
-  if(dn_irqs[irq-160].handler) {
-    res = dn_irqs[irq-160].handler(irq,dn_irqs[irq-160].dev_id,fp);
-  } else {
-    printk("spurious irq %d occurred\n",irq);
-  }
-
-  *(volatile unsigned char *)(pica)=0x20;
-  *(volatile unsigned char *)(picb)=0x20;
-
-  return res;
-}
-
-void dn_init_IRQ(void) {
-
-  int i;
-
-  for(i=0;i<16;i++) {
-    dn_irqs[i].handler=NULL;
-    dn_irqs[i].flags=IRQ_FLG_STD;
-    dn_irqs[i].dev_id=NULL;
-    dn_irqs[i].devname=NULL;
-  }
-
-}
-
-int dn_request_irq(unsigned int irq, irqreturn_t (*handler)(int, void *, struct pt_regs *), unsigned long flags, const char *devname, void *dev_id) {
-
-  if((irq<0) || (irq>15)) {
-    printk("Trying to request invalid IRQ\n");
-    return -ENXIO;
-  }
-
-  if(!dn_irqs[irq].handler) {
-    dn_irqs[irq].handler=handler;
-    dn_irqs[irq].flags=IRQ_FLG_STD;
-    dn_irqs[irq].dev_id=dev_id;
-    dn_irqs[irq].devname=devname;
-    if(irq<8)
-      *(volatile unsigned char *)(pica+1)&=~(1<<irq);
-    else
-      *(volatile unsigned char *)(picb+1)&=~(1<<(irq-8));
-
-    return 0;
-  }
-  else {
-    printk("Trying to request already assigned irq %d\n",irq);
-    return -ENXIO;
-  }
-
-}
-
-void dn_free_irq(unsigned int irq, void *dev_id) {
-
-  if((irq<0) || (irq>15)) {
-    printk("Trying to free invalid IRQ\n");
-    return ;
-  }
-
-  if(irq<8)
-    *(volatile unsigned char *)(pica+1)|=(1<<irq);
-  else
-    *(volatile unsigned char *)(picb+1)|=(1<<(irq-8));
-
-  dn_irqs[irq].handler=NULL;
-  dn_irqs[irq].flags=IRQ_FLG_STD;
-  dn_irqs[irq].dev_id=NULL;
-  dn_irqs[irq].devname=NULL;
-
-  return ;
-
-}
-
-void dn_enable_irq(unsigned int irq) {
-
-  printk("dn enable irq\n");
-
-}
-
-void dn_disable_irq(unsigned int irq) {
-
-  printk("dn disable irq\n");
+        m68k_handle_int(irq, fp);
 
+        *(volatile unsigned char *)(pica)=0x20;
+        *(volatile unsigned char *)(picb)=0x20;
 }
 
-int show_dn_interrupts(struct seq_file *p, void *v) {
-
-  printk("dn get irq list\n");
-
-  return 0;
-
+int apollo_irq_startup(unsigned int irq)
+{
+        if (irq < 8)
+                *(volatile unsigned char *)(pica+1) &= ~(1 << irq);
+        else
+                *(volatile unsigned char *)(picb+1) &= ~(1 << (irq - 8));
+        return 0;
 }
 
-struct fb_info *dn_dummy_fb_init(long *mem_start) {
-
-  printk("fb init\n");
-
-  return NULL;
-
+void apollo_irq_shutdown(unsigned int irq)
+{
+        if (irq < 8)
+                *(volatile unsigned char *)(pica+1) |= (1 << irq);
+        else
+                *(volatile unsigned char *)(picb+1) |= (1 << (irq - 8));
 }
 
-void dn_dummy_video_setup(char *options,int *ints) {
+static struct irq_controller apollo_irq_controller = {
+        .name           = "apollo",
+        .lock           = SPIN_LOCK_UNLOCKED,
+        .startup        = apollo_irq_startup,
+        .shutdown       = apollo_irq_shutdown,
+};
 
-  printk("no video yet\n");
 
+void dn_init_IRQ(void)
+{
+        m68k_setup_user_interrupt(VEC_USER + 96, 16, dn_process_int);
+        m68k_setup_irq_controller(&apollo_irq_controller, IRQ_APOLLO, 16);
 }
diff --git a/arch/m68k/atari/ataints.c b/arch/m68k/atari/ataints.c
index 076f47917842..ece13cbf9950 100644
--- a/arch/m68k/atari/ataints.c
+++ b/arch/m68k/atari/ataints.c
@@ -104,6 +104,7 @@
  * the sr copy in the frame.
  */
 
+#if 0
 
 #define NUM_INT_SOURCES (8 + NUM_ATARI_SOURCES)
 
@@ -133,13 +134,6 @@ static struct irqhandler irq_handler[NUM_INT_SOURCES];
  */
 static struct irqparam irq_param[NUM_INT_SOURCES];
 
-/*
- * Bitmap for free interrupt vector numbers
- * (new vectors starting from 0x70 can be allocated by
- * atari_register_vme_int())
- */
-static int free_vme_vec_bitmap;
-
 /* check for valid int number (complex, sigh...) */
 #define IS_VALID_INTNO(n)                                                                                       \
         ((n) > 0 &&                                                                                                             \
@@ -301,6 +295,14 @@ __asm__ (__ALIGN_STR "\n"
 );
         for (;;);
 }
+#endif
+
+/*
+ * Bitmap for free interrupt vector numbers
+ * (new vectors starting from 0x70 can be allocated by
+ * atari_register_vme_int())
+ */
+static int free_vme_vec_bitmap;
 
 /* GK:
  * HBL IRQ handler for Falcon. Nobody needs it :-)
@@ -313,13 +315,34 @@ __ALIGN_STR "\n\t"
         "orw    #0x200,%sp@\n\t"        /* set saved ipl to 2 */
         "rte");
 
-/* Defined in entry.S; only increments 'num_spurious' */
-asmlinkage void bad_interrupt(void);
-
-extern void atari_microwire_cmd( int cmd );
+extern void atari_microwire_cmd(int cmd);
 
 extern int atari_SCC_reset_done;
 
+static int atari_startup_irq(unsigned int irq)
+{
+        m68k_irq_startup(irq);
+        atari_turnon_irq(irq);
+        atari_enable_irq(irq);
+        return 0;
+}
+
+static void atari_shutdown_irq(unsigned int irq)
+{
+        atari_disable_irq(irq);
+        atari_turnoff_irq(irq);
+        m68k_irq_shutdown(irq);
+}
+
+static struct irq_controller atari_irq_controller = {
+        .name           = "atari",
+        .lock           = SPIN_LOCK_UNLOCKED,
+        .startup        = atari_startup_irq,
+        .shutdown       = atari_shutdown_irq,
+        .enable         = atari_enable_irq,
+        .disable        = atari_disable_irq,
+};
+
 /*
  * void atari_init_IRQ (void)
  *
@@ -333,12 +356,8 @@ extern int atari_SCC_reset_done;
 
 void __init atari_init_IRQ(void)
 {
-        int i;
-
-        /* initialize the vector table */
-        for (i = 0; i < NUM_INT_SOURCES; ++i) {
-                vectors[IRQ_SOURCE_TO_VECTOR(i)] = bad_interrupt;
-        }
+        m68k_setup_user_interrupt(VEC_USER, 192, NULL);
+        m68k_setup_irq_controller(&atari_irq_controller, 1, NUM_ATARI_SOURCES - 1);
 
         /* Initialize the MFP(s) */
 
@@ -378,8 +397,7 @@ void __init atari_init_IRQ(void)
                                                                          * enabled in VME mask
                                                                          */
                 tt_scu.vme_mask = 0x60;         /* enable MFP and SCC ints */
-        }
-        else {
+        } else {
                 /* If no SCU and no Hades, the HSYNC interrupt needs to be
                  * disabled this way. (Else _inthandler in kernel/sys_call.S
                  * gets overruns)
@@ -404,184 +422,6 @@ void __init atari_init_IRQ(void)
 }
 
 
-static irqreturn_t atari_call_irq_list( int irq, void *dev_id, struct pt_regs *fp )
-{
-        irq_node_t *node;
-
-        for (node = (irq_node_t *)dev_id; node; node = node->next)
-                node->handler(irq, node->dev_id, fp);
-        return IRQ_HANDLED;
-}
-
-
-/*
- * atari_request_irq : add an interrupt service routine for a particular
- *                     machine specific interrupt source.
- *                     If the addition was successful, it returns 0.
- */
-
-int atari_request_irq(unsigned int irq, irqreturn_t (*handler)(int, void *, struct pt_regs *),
-                      unsigned long flags, const char *devname, void *dev_id)
-{
-        int vector;
-        unsigned long oflags = flags;
-
-        /*
-         * The following is a hack to make some PCI card drivers work,
-         * which set the SA_SHIRQ flag.
-         */
-
-        flags &= ~SA_SHIRQ;
-
-        if (flags == SA_INTERRUPT) {
-                printk ("%s: SA_INTERRUPT changed to IRQ_TYPE_SLOW for %s\n",
-                        __FUNCTION__, devname);
-                flags = IRQ_TYPE_SLOW;
-        }
-        if (flags < IRQ_TYPE_SLOW || flags > IRQ_TYPE_PRIO) {
-                printk ("%s: Bad irq type 0x%lx <0x%lx> requested from %s\n",
-                        __FUNCTION__, flags, oflags, devname);
-                return -EINVAL;
-        }
-        if (!IS_VALID_INTNO(irq)) {
-                printk ("%s: Unknown irq %d requested from %s\n",
-                        __FUNCTION__, irq, devname);
-                return -ENXIO;
-        }
-        vector = IRQ_SOURCE_TO_VECTOR(irq);
-
-        /*
-         * Check type/source combination: slow ints are (currently)
-         * only possible for MFP-interrupts.
-         */
-        if (flags == IRQ_TYPE_SLOW &&
-                (irq < STMFP_SOURCE_BASE || irq >= SCC_SOURCE_BASE)) {
-                printk ("%s: Slow irq requested for non-MFP source %d from %s\n",
-                        __FUNCTION__, irq, devname);
-                return -EINVAL;
-        }
-
-        if (vectors[vector] == bad_interrupt) {
-                /* int has no handler yet */
-                irq_handler[irq].handler = handler;
-                irq_handler[irq].dev_id  = dev_id;
-                irq_param[irq].flags   = flags;
-                irq_param[irq].devname = devname;
-                vectors[vector] =
-                        (flags == IRQ_TYPE_SLOW) ? slow_handlers[irq-STMFP_SOURCE_BASE] :
-                        (flags == IRQ_TYPE_FAST) ? atari_fast_irq_handler :
-                                                  atari_prio_irq_handler;
-                /* If MFP int, also enable and umask it */
-                atari_turnon_irq(irq);
-                atari_enable_irq(irq);
-
-                return 0;
-        }
-        else if (irq_param[irq].flags == flags) {
-                /* old handler is of same type -> handlers can be chained */
-                irq_node_t *node;
-                unsigned long flags;
-
-                local_irq_save(flags);
-
-                if (irq_handler[irq].handler != atari_call_irq_list) {
-                        /* Only one handler yet, make a node for this first one */
-                        if (!(node = new_irq_node()))
-                                return -ENOMEM;
-                        node->handler = irq_handler[irq].handler;
-                        node->dev_id  = irq_handler[irq].dev_id;
-                        node->devname = irq_param[irq].devname;
-                        node->next = NULL;
-
-                        irq_handler[irq].handler = atari_call_irq_list;
-                        irq_handler[irq].dev_id  = node;
-                        irq_param[irq].devname   = "chained";
-                }
-
-                if (!(node = new_irq_node()))
-                        return -ENOMEM;
-                node->handler = handler;
-                node->dev_id  = dev_id;
-                node->devname = devname;
-                /* new handlers are put in front of the queue */
-                node->next = irq_handler[irq].dev_id;
-                irq_handler[irq].dev_id = node;
-
-                local_irq_restore(flags);
-                return 0;
-        } else {
-                printk ("%s: Irq %d allocated by other type int (call from %s)\n",
-                        __FUNCTION__, irq, devname);
-                return -EBUSY;
-        }
-}
-
-void atari_free_irq(unsigned int irq, void *dev_id)
-{
-        unsigned long flags;
-        int vector;
-        irq_node_t **list, *node;
-
-        if (!IS_VALID_INTNO(irq)) {
-                printk("%s: Unknown irq %d\n", __FUNCTION__, irq);
-                return;
-        }
-
-        vector = IRQ_SOURCE_TO_VECTOR(irq);
-        if (vectors[vector] == bad_interrupt)
-                goto not_found;
-
-        local_irq_save(flags);
-
-        if (irq_handler[irq].handler != atari_call_irq_list) {
-                /* It's the only handler for the interrupt */
-                if (irq_handler[irq].dev_id != dev_id) {
-                        local_irq_restore(flags);
-                        goto not_found;
-                }
-                irq_handler[irq].handler = NULL;
-                irq_handler[irq].dev_id  = NULL;
-                irq_param[irq].devname   = NULL;
-                vectors[vector] = bad_interrupt;
-                /* If MFP int, also disable it */
-                atari_disable_irq(irq);
-                atari_turnoff_irq(irq);
-
-                local_irq_restore(flags);
-                return;
-        }
-
-        /* The interrupt is chained, find the irq on the list */
-        for(list = (irq_node_t **)&irq_handler[irq].dev_id; *list; list = &(*list)->next) {
-                if ((*list)->dev_id == dev_id) break;
-        }
-        if (!*list) {
-                local_irq_restore(flags);
-                goto not_found;
-        }
-
-        (*list)->handler = NULL; /* Mark it as free for reallocation */
-        *list = (*list)->next;
-
-        /* If there's now only one handler, unchain the interrupt, i.e. plug in
-         * the handler directly again and omit atari_call_irq_list */
-        node = (irq_node_t *)irq_handler[irq].dev_id;
-        if (node && !node->next) {
-                irq_handler[irq].handler = node->handler;
-                irq_handler[irq].dev_id  = node->dev_id;
-                irq_param[irq].devname   = node->devname;
-                node->handler = NULL; /* Mark it as free for reallocation */
-        }
-
-        local_irq_restore(flags);
-        return;
-
-not_found:
-        printk("%s: tried to remove invalid irq\n", __FUNCTION__);
-        return;
-}
-
-
 /*
  * atari_register_vme_int() returns the number of a free interrupt vector for
  * hardware with a programmable int vector (probably a VME board).
@@ -591,58 +431,24 @@ unsigned long atari_register_vme_int(void)
 {
         int i;
 
-        for(i = 0; i < 32; i++)
-                if((free_vme_vec_bitmap & (1 << i)) == 0)
+        for (i = 0; i < 32; i++)
+                if ((free_vme_vec_bitmap & (1 << i)) == 0)
                         break;
 
-        if(i == 16)
+        if (i == 16)
                 return 0;
 
         free_vme_vec_bitmap |= 1 << i;
-        return (VME_SOURCE_BASE + i);
+        return VME_SOURCE_BASE + i;
 }
 
 
 void atari_unregister_vme_int(unsigned long irq)
 {
-        if(irq >= VME_SOURCE_BASE && irq < VME_SOURCE_BASE + VME_MAX_SOURCES) {
+        if (irq >= VME_SOURCE_BASE && irq < VME_SOURCE_BASE + VME_MAX_SOURCES) {
                 irq -= VME_SOURCE_BASE;
                 free_vme_vec_bitmap &= ~(1 << irq);
         }
 }
 
 
-int show_atari_interrupts(struct seq_file *p, void *v)
-{
-        int i;
-
-        for (i = 0; i < NUM_INT_SOURCES; ++i) {
-                if (vectors[IRQ_SOURCE_TO_VECTOR(i)] == bad_interrupt)
-                        continue;
-                if (i < STMFP_SOURCE_BASE)
-                        seq_printf(p, "auto %2d: %10u ",
-                                       i, kstat_cpu(0).irqs[i]);
-                else
-                        seq_printf(p, "vec $%02x: %10u ",
-                                       IRQ_SOURCE_TO_VECTOR(i),
-                                       kstat_cpu(0).irqs[i]);
-
-                if (irq_handler[i].handler != atari_call_irq_list) {
-                        seq_printf(p, "%s\n", irq_param[i].devname);
-                }
-                else {
-                        irq_node_t *n;
-                        for( n = (irq_node_t *)irq_handler[i].dev_id; n; n = n->next ) {
-                                seq_printf(p, "%s\n", n->devname);
-                                if (n->next)
-                                        seq_puts(p, "                    " );
-                        }
-                }
-        }
-        if (num_spurious)
-                seq_printf(p, "spurio.: %10u\n", num_spurious);
-
-        return 0;
-}
-
-
diff --git a/arch/m68k/atari/config.c b/arch/m68k/atari/config.c
index 1012b08e5522..727289acad7e 100644
--- a/arch/m68k/atari/config.c
+++ b/arch/m68k/atari/config.c
@@ -57,12 +57,6 @@ static int atari_get_hardware_list(char *buffer);
 
 /* atari specific irq functions */
 extern void atari_init_IRQ (void);
-extern int atari_request_irq (unsigned int irq, irqreturn_t (*handler)(int, void *, struct pt_regs *),
-                              unsigned long flags, const char *devname, void *dev_id);
-extern void atari_free_irq (unsigned int irq, void *dev_id);
-extern void atari_enable_irq (unsigned int);
-extern void atari_disable_irq (unsigned int);
-extern int show_atari_interrupts (struct seq_file *, void *);
 extern void atari_mksound( unsigned int count, unsigned int ticks );
 #ifdef CONFIG_HEARTBEAT
 static void atari_heartbeat( int on );
@@ -232,13 +226,8 @@ void __init config_atari(void)
 
     mach_sched_init      = atari_sched_init;
     mach_init_IRQ        = atari_init_IRQ;
-    mach_request_irq     = atari_request_irq;
-    mach_free_irq        = atari_free_irq;
-    enable_irq           = atari_enable_irq;
-    disable_irq          = atari_disable_irq;
     mach_get_model       = atari_get_model;
     mach_get_hardware_list = atari_get_hardware_list;
-    mach_get_irq_list    = show_atari_interrupts;
     mach_gettimeoffset   = atari_gettimeoffset;
     mach_reset           = atari_reset;
     mach_max_dma_address = 0xffffff;
diff --git a/arch/m68k/bvme6000/Makefile b/arch/m68k/bvme6000/Makefile
index 2348e6ceed1e..d8174004fe2f 100644
--- a/arch/m68k/bvme6000/Makefile
+++ b/arch/m68k/bvme6000/Makefile
@@ -2,4 +2,4 @@
 # Makefile for Linux arch/m68k/bvme6000 source directory
 #
 
-obj-y           := config.o bvmeints.o rtc.o
+obj-y           := config.o rtc.o
diff --git a/arch/m68k/bvme6000/bvmeints.c b/arch/m68k/bvme6000/bvmeints.c
deleted file mode 100644
index 298a8df02664..000000000000
--- a/arch/m68k/bvme6000/bvmeints.c
+++ /dev/null
@@ -1,160 +0,0 @@
-/*
- * arch/m68k/bvme6000/bvmeints.c
- *
- * Copyright (C) 1997 Richard Hirst [richard@sleepie.demon.co.uk]
- *
- * based on amiints.c -- Amiga Linux interrupt handling code
- *
- * This file is subject to the terms and conditions of the GNU General Public
- * License.  See the file README.legal in the main directory of this archive
- * for more details.
- *
- */
-
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/seq_file.h>
-
-#include <asm/ptrace.h>
-#include <asm/system.h>
-#include <asm/irq.h>
-#include <asm/traps.h>
-
-static irqreturn_t bvme6000_defhand (int irq, void *dev_id, struct pt_regs *fp);
-
-/*
- * This should ideally be 4 elements only, for speed.
- */
-
-static struct {
-        irqreturn_t     (*handler)(int, void *, struct pt_regs *);
-        unsigned long   flags;
-        void            *dev_id;
-        const char      *devname;
-        unsigned        count;
-} irq_tab[256];
-
-/*
- * void bvme6000_init_IRQ (void)
- *
- * Parameters:  None
- *
- * Returns:     Nothing
- *
- * This function is called during kernel startup to initialize
- * the bvme6000 IRQ handling routines.
- */
-
-void bvme6000_init_IRQ (void)
-{
-        int i;
-
-        for (i = 0; i < 256; i++) {
-                irq_tab[i].handler = bvme6000_defhand;
-                irq_tab[i].flags = IRQ_FLG_STD;
-                irq_tab[i].dev_id = NULL;
-                irq_tab[i].devname = NULL;
-                irq_tab[i].count = 0;
-        }
-}
-
-int bvme6000_request_irq(unsigned int irq,
-                irqreturn_t (*handler)(int, void *, struct pt_regs *),
-                unsigned long flags, const char *devname, void *dev_id)
-{
-        if (irq > 255) {
-                printk("%s: Incorrect IRQ %d from %s\n", __FUNCTION__, irq, devname);
-                return -ENXIO;
-        }
-#if 0
-        /* Nothing special about auto-vectored devices for the BVME6000,
-         * but treat it specially to avoid changes elsewhere.
-         */
-
-        if (irq >= VEC_INT1 && irq <= VEC_INT7)
-                return cpu_request_irq(irq - VEC_SPUR, handler, flags,
-                                                devname, dev_id);
-#endif
-        if (!(irq_tab[irq].flags & IRQ_FLG_STD)) {
-                if (irq_tab[irq].flags & IRQ_FLG_LOCK) {
-                        printk("%s: IRQ %d from %s is not replaceable\n",
-                               __FUNCTION__, irq, irq_tab[irq].devname);
-                        return -EBUSY;
-                }
-                if (flags & IRQ_FLG_REPLACE) {
-                        printk("%s: %s can't replace IRQ %d from %s\n",
-                               __FUNCTION__, devname, irq, irq_tab[irq].devname);
-                        return -EBUSY;
-                }
-        }
-        irq_tab[irq].handler = handler;
-        irq_tab[irq].flags   = flags;
-        irq_tab[irq].dev_id  = dev_id;
-        irq_tab[irq].devname = devname;
-        return 0;
-}
-
-void bvme6000_free_irq(unsigned int irq, void *dev_id)
-{
-        if (irq > 255) {
-                printk("%s: Incorrect IRQ %d\n", __FUNCTION__, irq);
-                return;
-        }
-#if 0
-        if (irq >= VEC_INT1 && irq <= VEC_INT7) {
-                cpu_free_irq(irq - VEC_SPUR, dev_id);
-                return;
-        }
-#endif
-        if (irq_tab[irq].dev_id != dev_id)
-                printk("%s: Removing probably wrong IRQ %d from %s\n",
-                       __FUNCTION__, irq, irq_tab[irq].devname);
-
-        irq_tab[irq].handler = bvme6000_defhand;
-        irq_tab[irq].flags   = IRQ_FLG_STD;
-        irq_tab[irq].dev_id  = NULL;
-        irq_tab[irq].devname = NULL;
-}
-
-irqreturn_t bvme6000_process_int (unsigned long vec, struct pt_regs *fp)
-{
-        if (vec > 255) {
-                printk ("bvme6000_process_int: Illegal vector %ld", vec);
-                return IRQ_NONE;
-        } else {
-                irq_tab[vec].count++;
-                irq_tab[vec].handler(vec, irq_tab[vec].dev_id, fp);
-                return IRQ_HANDLED;
-        }
-}
-
-int show_bvme6000_interrupts(struct seq_file *p, void *v)
-{
-        int i;
-
-        for (i = 0; i < 256; i++) {
-                if (irq_tab[i].count)
-                        seq_printf(p, "Vec 0x%02x: %8d  %s\n",
-                            i, irq_tab[i].count,
-                            irq_tab[i].devname ? irq_tab[i].devname : "free");
-        }
-        return 0;
-}
-
-
-static irqreturn_t bvme6000_defhand (int irq, void *dev_id, struct pt_regs *fp)
-{
-        printk ("Unknown interrupt 0x%02x\n", irq);
-        return IRQ_NONE;
-}
-
-void bvme6000_enable_irq (unsigned int irq)
-{
-}
-
-
-void bvme6000_disable_irq (unsigned int irq)
-{
-}
-
diff --git a/arch/m68k/bvme6000/config.c b/arch/m68k/bvme6000/config.c
index c90cb5fcc8ef..d1e916ae55a8 100644
--- a/arch/m68k/bvme6000/config.c
+++ b/arch/m68k/bvme6000/config.c
@@ -36,15 +36,8 @@
 #include <asm/machdep.h>
 #include <asm/bvme6000hw.h>
 
-extern irqreturn_t bvme6000_process_int (int level, struct pt_regs *regs);
-extern void bvme6000_init_IRQ (void);
-extern void bvme6000_free_irq (unsigned int, void *);
-extern int  show_bvme6000_interrupts(struct seq_file *, void *);
-extern void bvme6000_enable_irq (unsigned int);
-extern void bvme6000_disable_irq (unsigned int);
 static void bvme6000_get_model(char *model);
 static int  bvme6000_get_hardware_list(char *buffer);
-extern int  bvme6000_request_irq(unsigned int irq, irqreturn_t (*handler)(int, void *, struct pt_regs *), unsigned long flags, const char *devname, void *dev_id);
 extern void bvme6000_sched_init(irqreturn_t (*handler)(int, void *, struct pt_regs *));
 extern unsigned long bvme6000_gettimeoffset (void);
 extern int bvme6000_hwclk (int, struct rtc_time *);
@@ -100,6 +93,14 @@ static int bvme6000_get_hardware_list(char *buffer)
     return 0;
 }
 
+/*
+ * This function is called during kernel startup to initialize
+ * the bvme6000 IRQ handling routines.
+ */
+static void bvme6000_init_IRQ(void)
+{
+        m68k_setup_user_interrupt(VEC_USER, 192, NULL);
+}
 
 void __init config_bvme6000(void)
 {
@@ -127,12 +128,6 @@ void __init config_bvme6000(void)
     mach_hwclk           = bvme6000_hwclk;
     mach_set_clock_mmss  = bvme6000_set_clock_mmss;
     mach_reset           = bvme6000_reset;
-    mach_free_irq        = bvme6000_free_irq;
-    mach_process_int     = bvme6000_process_int;
-    mach_get_irq_list    = show_bvme6000_interrupts;
-    mach_request_irq     = bvme6000_request_irq;
-    enable_irq           = bvme6000_enable_irq;
-    disable_irq          = bvme6000_disable_irq;
     mach_get_model       = bvme6000_get_model;
     mach_get_hardware_list = bvme6000_get_hardware_list;
 
diff --git a/arch/m68k/hp300/Makefile b/arch/m68k/hp300/Makefile
index 89b6317899e3..288b9c67c9bf 100644
--- a/arch/m68k/hp300/Makefile
+++ b/arch/m68k/hp300/Makefile
@@ -2,4 +2,4 @@
 # Makefile for Linux arch/m68k/hp300 source directory
 #
 
-obj-y           := ksyms.o config.o ints.o time.o reboot.o
+obj-y           := ksyms.o config.o time.o reboot.o
diff --git a/arch/m68k/hp300/config.c b/arch/m68k/hp300/config.c
index 6d129eef370f..2ef271cd818b 100644
--- a/arch/m68k/hp300/config.c
+++ b/arch/m68k/hp300/config.c
@@ -21,7 +21,6 @@
 #include <asm/hp300hw.h>
 #include <asm/rtc.h>
 
-#include "ints.h"
 #include "time.h"
 
 unsigned long hp300_model;
@@ -64,8 +63,6 @@ static char *hp300_models[] __initdata = {
 static char hp300_model_name[13] = "HP9000/";
 
 extern void hp300_reset(void);
-extern irqreturn_t (*hp300_default_handler[])(int, void *, struct pt_regs *);
-extern int show_hp300_interrupts(struct seq_file *, void *);
 #ifdef CONFIG_SERIAL_8250_CONSOLE
 extern int hp300_setup_serial_console(void) __init;
 #endif
@@ -245,16 +242,16 @@ static unsigned int hp300_get_ss(void)
                 hp300_rtc_read(RTC_REG_SEC2);
 }
 
+static void __init hp300_init_IRQ(void)
+{
+}
+
 void __init config_hp300(void)
 {
         mach_sched_init      = hp300_sched_init;
         mach_init_IRQ        = hp300_init_IRQ;
-        mach_request_irq     = hp300_request_irq;
-        mach_free_irq        = hp300_free_irq;
         mach_get_model       = hp300_get_model;
-        mach_get_irq_list    = show_hp300_interrupts;
         mach_gettimeoffset   = hp300_gettimeoffset;
-        mach_default_handler = &hp300_default_handler;
         mach_hwclk           = hp300_hwclk;
         mach_get_ss          = hp300_get_ss;
         mach_reset           = hp300_reset;
diff --git a/arch/m68k/hp300/ints.c b/arch/m68k/hp300/ints.c
deleted file mode 100644
index 0c5bb403e893..000000000000
--- a/arch/m68k/hp300/ints.c
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
- *  linux/arch/m68k/hp300/ints.c
- *
- *  Copyright (C) 1998 Philip Blundell <philb@gnu.org>
- *
- *  This file contains the HP300-specific interrupt handling.
- *  We only use the autovector interrupts, and therefore we need to
- *  maintain lists of devices sharing each ipl.
- *  [ipl list code added by Peter Maydell <pmaydell@chiark.greenend.org.uk> 06/1998]
- */
-
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/init.h>
-#include <linux/sched.h>
-#include <linux/kernel_stat.h>
-#include <linux/interrupt.h>
-#include <linux/spinlock.h>
-#include <asm/machdep.h>
-#include <asm/irq.h>
-#include <asm/io.h>
-#include <asm/system.h>
-#include <asm/traps.h>
-#include <asm/ptrace.h>
-#include <asm/errno.h>
-#include "ints.h"
-
-/* Each ipl has a linked list of interrupt service routines.
- * Service routines are added via hp300_request_irq() and removed
- * via hp300_free_irq(). The device driver should set IRQ_FLG_FAST
- * if it needs to be serviced early (eg FIFOless UARTs); this will
- * cause it to be added at the front of the queue rather than
- * the back.
- * Currently IRQ_FLG_SLOW and flags=0 are treated identically; if
- * we needed three levels of priority we could distinguish them
- * but this strikes me as mildly ugly...
- */
-
-/* we start with no entries in any list */
-static irq_node_t *hp300_irq_list[HP300_NUM_IRQS];
-
-static spinlock_t irqlist_lock;
-
-/* This handler receives all interrupts, dispatching them to the registered handlers */
-static irqreturn_t hp300_int_handler(int irq, void *dev_id, struct pt_regs *fp)
-{
-        irq_node_t *t;
-        /* We just give every handler on the chain an opportunity to handle
-         * the interrupt, in priority order.
-         */
-        for(t = hp300_irq_list[irq]; t; t=t->next)
-                t->handler(irq, t->dev_id, fp);
-        /* We could put in some accounting routines, checks for stray interrupts,
-         * etc, in here. Note that currently we can't tell whether or not
-         * a handler handles the interrupt, though.
-         */
-        return IRQ_HANDLED;
-}
-
-static irqreturn_t hp300_badint(int irq, void *dev_id, struct pt_regs *fp)
-{
-        num_spurious += 1;
-        return IRQ_NONE;
-}
-
-irqreturn_t (*hp300_default_handler[SYS_IRQS])(int, void *, struct pt_regs *) = {
-        [0] = hp300_badint,
-        [1] = hp300_int_handler,
-        [2] = hp300_int_handler,
-        [3] = hp300_int_handler,
-        [4] = hp300_int_handler,
-        [5] = hp300_int_handler,
-        [6] = hp300_int_handler,
-        [7] = hp300_int_handler
-};
-
-/* dev_id had better be unique to each handler because it's the only way we have
- * to distinguish handlers when removing them...
- *
- * It would be pretty easy to support IRQ_FLG_LOCK (handler is not replacable)
- * and IRQ_FLG_REPLACE (handler replaces existing one with this dev_id)
- * if we wanted to. IRQ_FLG_FAST is needed for devices where interrupt latency
- * matters (eg the dreaded FIFOless UART...)
- */
-int hp300_request_irq(unsigned int irq,
-                      irqreturn_t (*handler) (int, void *, struct pt_regs *),
-                      unsigned long flags, const char *devname, void *dev_id)
-{
-        irq_node_t *t, *n = new_irq_node();
-
-        if (!n)                                   /* oops, no free nodes */
-                return -ENOMEM;
-
-        spin_lock_irqsave(&irqlist_lock, flags);
-
-        if (!hp300_irq_list[irq]) {
-                /* no list yet */
-                hp300_irq_list[irq] = n;
-                n->next = NULL;
-        } else if (flags & IRQ_FLG_FAST) {
-                /* insert at head of list */
-                n->next = hp300_irq_list[irq];
-                hp300_irq_list[irq] = n;
-        } else {
-                /* insert at end of list */
-                for(t = hp300_irq_list[irq]; t->next; t = t->next)
-                        /* do nothing */;
-                n->next = NULL;
-                t->next = n;
-        }
-
-        /* Fill in n appropriately */
-        n->handler = handler;
-        n->flags = flags;
-        n->dev_id = dev_id;
-        n->devname = devname;
-        spin_unlock_irqrestore(&irqlist_lock, flags);
-        return 0;
-}
-
-void hp300_free_irq(unsigned int irq, void *dev_id)
-{
-        irq_node_t *t;
-        unsigned long flags;
-
-        spin_lock_irqsave(&irqlist_lock, flags);
-
-        t = hp300_irq_list[irq];
-        if (!t)                                   /* no handlers at all for that IRQ */
-        {
-                printk(KERN_ERR "hp300_free_irq: attempt to remove nonexistent handler for IRQ %d\n", irq);
-                spin_unlock_irqrestore(&irqlist_lock, flags);
-                return;
-        }
-
-        if (t->dev_id == dev_id)
-        {                                         /* removing first handler on chain */
-                t->flags = IRQ_FLG_STD;           /* we probably don't really need these */
-                t->dev_id = NULL;
-                t->devname = NULL;
-                t->handler = NULL;                /* frees this irq_node_t */
-                hp300_irq_list[irq] = t->next;
-                spin_unlock_irqrestore(&irqlist_lock, flags);
-                return;
-        }
-
-        /* OK, must be removing from middle of the chain */
-
-        for (t = hp300_irq_list[irq]; t->next && t->next->dev_id != dev_id; t = t->next)
-                /* do nothing */;
-        if (!t->next)
-        {
-                printk(KERN_ERR "hp300_free_irq: attempt to remove nonexistent handler for IRQ %d\n", irq);
-                spin_unlock_irqrestore(&irqlist_lock, flags);
-                return;
-        }
-        /* remove the entry after t: */
-        t->next->flags = IRQ_FLG_STD;
-        t->next->dev_id = NULL;
-        t->next->devname = NULL;
-        t->next->handler = NULL;
-        t->next = t->next->next;
-
-        spin_unlock_irqrestore(&irqlist_lock, flags);
-}
-
-int show_hp300_interrupts(struct seq_file *p, void *v)
-{
-        return 0;
-}
-
-void __init hp300_init_IRQ(void)
-{
-        spin_lock_init(&irqlist_lock);
-}
diff --git a/arch/m68k/hp300/ints.h b/arch/m68k/hp300/ints.h
deleted file mode 100644
index 8cfabe2f3840..000000000000
--- a/arch/m68k/hp300/ints.h
+++ /dev/null
@@ -1,9 +0,0 @@
-extern void hp300_init_IRQ(void);
-extern void (*hp300_handlers[8])(int, void *, struct pt_regs *);
-extern void hp300_free_irq(unsigned int irq, void *dev_id);
-extern int hp300_request_irq(unsigned int irq,
-                irqreturn_t (*handler) (int, void *, struct pt_regs *),
-                unsigned long flags, const char *devname, void *dev_id);
-
-/* number of interrupts, includes 0 (what's that?) */
-#define HP300_NUM_IRQS 8
diff --git a/arch/m68k/hp300/time.c b/arch/m68k/hp300/time.c
index 8da5b1b31e61..7df05662b277 100644
--- a/arch/m68k/hp300/time.c
+++ b/arch/m68k/hp300/time.c
@@ -18,7 +18,6 @@
 #include <asm/system.h>
 #include <asm/traps.h>
 #include <asm/blinken.h>
-#include "ints.h"
 
 /* Clock hardware definitions */
 
@@ -71,7 +70,7 @@ void __init hp300_sched_init(irqreturn_t (*vector)(int, void *, struct pt_regs *
 
   asm volatile(" movpw %0,%1@(5)" : : "d" (INTVAL), "a" (CLOCKBASE));
 
-  cpu_request_irq(6, hp300_tick, IRQ_FLG_STD, "timer tick", vector);
+  request_irq(IRQ_AUTO_6, hp300_tick, IRQ_FLG_STD, "timer tick", vector);
 
   out_8(CLOCKBASE + CLKCR2, 0x1);               /* select CR1 */
   out_8(CLOCKBASE + CLKCR1, 0x40);              /* enable irq */
diff --git a/arch/m68k/kernel/Makefile b/arch/m68k/kernel/Makefile
index 458925c471a1..dae609797dc0 100644
--- a/arch/m68k/kernel/Makefile
+++ b/arch/m68k/kernel/Makefile
@@ -9,8 +9,8 @@ else
 endif
 extra-y += vmlinux.lds
 
-obj-y           := entry.o process.o traps.o ints.o signal.o ptrace.o \
-                        sys_m68k.o time.o semaphore.o setup.o m68k_ksyms.o
+obj-y   := entry.o process.o traps.o ints.o dma.o signal.o ptrace.o \
+           sys_m68k.o time.o semaphore.o setup.o m68k_ksyms.o
 
 obj-$(CONFIG_PCI)       += bios32.o
 obj-$(CONFIG_MODULES)   += module.o
diff --git a/arch/m68k/kernel/dma.c b/arch/m68k/kernel/dma.c
new file mode 100644
index 000000000000..fc449f8b2045
--- /dev/null
+++ b/arch/m68k/kernel/dma.c
@@ -0,0 +1,129 @@
+/*
+ * 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.
+ */
+
+#undef DEBUG
+
+#include <linux/dma-mapping.h>
+#include <linux/device.h>
+#include <linux/kernel.h>
+#include <linux/vmalloc.h>
+
+#include <asm/pgalloc.h>
+#include <asm/scatterlist.h>
+
+void *dma_alloc_coherent(struct device *dev, size_t size,
+                         dma_addr_t *handle, int flag)
+{
+        struct page *page, **map;
+        pgprot_t pgprot;
+        void *addr;
+        int i, order;
+
+        pr_debug("dma_alloc_coherent: %d,%x\n", size, flag);
+
+        size = PAGE_ALIGN(size);
+        order = get_order(size);
+
+        page = alloc_pages(flag, order);
+        if (!page)
+                return NULL;
+
+        *handle = page_to_phys(page);
+        map = kmalloc(sizeof(struct page *) << order, flag & ~__GFP_DMA);
+        if (!map) {
+                __free_pages(page, order);
+                return NULL;
+        }
+        split_page(page, order);
+
+        order = 1 << order;
+        size >>= PAGE_SHIFT;
+        map[0] = page;
+        for (i = 1; i < size; i++)
+                map[i] = page + i;
+        for (; i < order; i++)
+                __free_page(page + i);
+        pgprot = __pgprot(_PAGE_PRESENT | _PAGE_ACCESSED | _PAGE_DIRTY);
+        if (CPU_IS_040_OR_060)
+                pgprot_val(pgprot) |= _PAGE_GLOBAL040 | _PAGE_NOCACHE_S;
+        else
+                pgprot_val(pgprot) |= _PAGE_NOCACHE030;
+        addr = vmap(map, size, flag, pgprot);
+        kfree(map);
+
+        return addr;
+}
+EXPORT_SYMBOL(dma_alloc_coherent);
+
+void dma_free_coherent(struct device *dev, size_t size,
+                       void *addr, dma_addr_t handle)
+{
+        pr_debug("dma_free_coherent: %p, %x\n", addr, handle);
+        vfree(addr);
+}
+EXPORT_SYMBOL(dma_free_coherent);
+
+inline void dma_sync_single_for_device(struct device *dev, dma_addr_t handle, size_t size,
+                                       enum dma_data_direction dir)
+{
+        switch (dir) {
+        case DMA_TO_DEVICE:
+                cache_push(handle, size);
+                break;
+        case DMA_FROM_DEVICE:
+                cache_clear(handle, size);
+                break;
+        default:
+                if (printk_ratelimit())
+                        printk("dma_sync_single_for_device: unsupported dir %u\n", dir);
+                break;
+        }
+}
+EXPORT_SYMBOL(dma_sync_single_for_device);
+
+void dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nents,
+                            enum dma_data_direction dir)
+{
+        int i;
+
+        for (i = 0; i < nents; sg++, i++)
+                dma_sync_single_for_device(dev, sg->dma_address, sg->length, dir);
+}
+EXPORT_SYMBOL(dma_sync_sg_for_device);
+
+dma_addr_t dma_map_single(struct device *dev, void *addr, size_t size,
+                          enum dma_data_direction dir)
+{
+        dma_addr_t handle = virt_to_bus(addr);
+
+        dma_sync_single_for_device(dev, handle, size, dir);
+        return handle;
+}
+EXPORT_SYMBOL(dma_map_single);
+
+dma_addr_t dma_map_page(struct device *dev, struct page *page,
+                        unsigned long offset, size_t size,
+                        enum dma_data_direction dir)
+{
+        dma_addr_t handle = page_to_phys(page) + offset;
+
+        dma_sync_single_for_device(dev, handle, size, dir);
+        return handle;
+}
+EXPORT_SYMBOL(dma_map_page);
+
+int dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
+               enum dma_data_direction dir)
+{
+        int i;
+
+        for (i = 0; i < nents; sg++, i++) {
+                sg->dma_address = page_to_phys(sg->page) + sg->offset;
+                dma_sync_single_for_device(dev, sg->dma_address, sg->length, dir);
+        }
+        return nents;
+}
+EXPORT_SYMBOL(dma_map_sg);
diff --git a/arch/m68k/kernel/entry.S b/arch/m68k/kernel/entry.S
index 522079f8c2ba..449b62b30f45 100644
--- a/arch/m68k/kernel/entry.S
+++ b/arch/m68k/kernel/entry.S
@@ -45,9 +45,11 @@
 #include <asm/asm-offsets.h>
 
 .globl system_call, buserr, trap, resume
-.globl inthandler, sys_call_table
+.globl sys_call_table
 .globl sys_fork, sys_clone, sys_vfork
 .globl ret_from_interrupt, bad_interrupt
+.globl auto_irqhandler_fixup
+.globl user_irqvec_fixup, user_irqhandler_fixup
 
 .text
 ENTRY(buserr)
@@ -191,65 +193,29 @@ do_delayed_trace:
         jbra    resume_userspace
 
 
-#if 0
-#ifdef CONFIG_AMIGA
-ami_inthandler:
-        addql   #1,irq_stat+CPUSTAT_LOCAL_IRQ_COUNT
-        SAVE_ALL_INT
-        GET_CURRENT(%d0)
-
-        bfextu  %sp@(PT_VECTOR){#4,#12},%d0
-        movel   %d0,%a0
-        addql   #1,%a0@(kstat+STAT_IRQ-VECOFF(VEC_SPUR))
-        movel   %a0@(autoirq_list-VECOFF(VEC_SPUR)),%a0
-
-| amiga vector int handler get the req mask instead of irq vector
-        lea     CUSTOMBASE,%a1
-        movew   %a1@(C_INTREQR),%d0
-        andw    %a1@(C_INTENAR),%d0
-
-| prepare stack (push frame pointer, dev_id & req mask)
-        pea     %sp@
-        movel   %a0@(IRQ_DEVID),%sp@-
-        movel   %d0,%sp@-
-        pea     %pc@(ret_from_interrupt:w)
-        jbra    @(IRQ_HANDLER,%a0)@(0)
-
-ENTRY(nmi_handler)
-        rte
-#endif
-#endif
+/* This is the main interrupt handler for autovector interrupts */
 
-/*
-** This is the main interrupt handler, responsible for calling process_int()
-*/
-inthandler:
+ENTRY(auto_inthandler)
         SAVE_ALL_INT
         GET_CURRENT(%d0)
         addqb   #1,%curptr@(TASK_INFO+TINFO_PREEMPT+1)
                                         |  put exception # in d0
-        bfextu %sp@(PT_VECTOR){#4,#10},%d0
+        bfextu  %sp@(PT_VECTOR){#4,#10},%d0
+        subw    #VEC_SPUR,%d0
 
         movel   %sp,%sp@-
         movel   %d0,%sp@-               |  put vector # on stack
-#if defined(MACH_Q40_ONLY) && defined(CONFIG_BLK_DEV_FD)
-        btstb   #4,0xff000000           | Q40 floppy needs very special treatment ...
-        jbeq    1f
-        btstb   #3,0xff000004
-        jbeq    1f
-        jbsr    floppy_hardint
-        jbra    3f
-1:
-#endif
-        jbsr    process_int             |  process the IRQ
-3:      addql   #8,%sp                  |  pop parameters off stack
+auto_irqhandler_fixup = . + 2
+        jsr     m68k_handle_int         |  process the IRQ
+        addql   #8,%sp                  |  pop parameters off stack
 
 ret_from_interrupt:
         subqb   #1,%curptr@(TASK_INFO+TINFO_PREEMPT+1)
-        jeq     1f
-2:
-        RESTORE_ALL
-1:
+        jeq     ret_from_last_interrupt
+2:      RESTORE_ALL
+
+        ALIGN
+ret_from_last_interrupt:
         moveq   #(~ALLOWINT>>8)&0xff,%d0
         andb    %sp@(PT_SR),%d0
         jne     2b
@@ -260,12 +226,42 @@ ret_from_interrupt:
         pea     ret_from_exception
         jra     do_softirq
 
+/* Handler for user defined interrupt vectors */
+
+ENTRY(user_inthandler)
+        SAVE_ALL_INT
+        GET_CURRENT(%d0)
+        addqb   #1,%curptr@(TASK_INFO+TINFO_PREEMPT+1)
+                                        |  put exception # in d0
+        bfextu  %sp@(PT_VECTOR){#4,#10},%d0
+user_irqvec_fixup = . + 2
+        subw    #VEC_USER,%d0
+
+        movel   %sp,%sp@-
+        movel   %d0,%sp@-               |  put vector # on stack
+user_irqhandler_fixup = . + 2
+        jsr     m68k_handle_int         |  process the IRQ
+        addql   #8,%sp                  |  pop parameters off stack
+
+        subqb   #1,%curptr@(TASK_INFO+TINFO_PREEMPT+1)
+        jeq     ret_from_last_interrupt
+        RESTORE_ALL
 
 /* Handler for uninitialized and spurious interrupts */
 
-bad_interrupt:
-        addql   #1,num_spurious
-        rte
+ENTRY(bad_inthandler)
+        SAVE_ALL_INT
+        GET_CURRENT(%d0)
+        addqb   #1,%curptr@(TASK_INFO+TINFO_PREEMPT+1)
+
+        movel   %sp,%sp@-
+        jsr     handle_badint
+        addql   #4,%sp
+
+        subqb   #1,%curptr@(TASK_INFO+TINFO_PREEMPT+1)
+        jeq     ret_from_last_interrupt
+        RESTORE_ALL
+
 
 ENTRY(sys_fork)
         SAVE_SWITCH_STACK
diff --git a/arch/m68k/kernel/ints.c b/arch/m68k/kernel/ints.c
index 4b85514792e7..5a8344b93547 100644
--- a/arch/m68k/kernel/ints.c
+++ b/arch/m68k/kernel/ints.c
@@ -39,47 +39,40 @@
 #include <asm/traps.h>
 #include <asm/page.h>
 #include <asm/machdep.h>
+#include <asm/cacheflush.h>
 
 #ifdef CONFIG_Q40
 #include <asm/q40ints.h>
 #endif
 
+extern u32 auto_irqhandler_fixup[];
+extern u32 user_irqhandler_fixup[];
+extern u16 user_irqvec_fixup[];
+
 /* table for system interrupt handlers */
-static irq_handler_t irq_list[SYS_IRQS];
-
-static const char *default_names[SYS_IRQS] = {
-        [0] = "spurious int",
-        [1] = "int1 handler",
-        [2] = "int2 handler",
-        [3] = "int3 handler",
-        [4] = "int4 handler",
-        [5] = "int5 handler",
-        [6] = "int6 handler",
-        [7] = "int7 handler"
+static struct irq_node *irq_list[NR_IRQS];
+static struct irq_controller *irq_controller[NR_IRQS];
+static int irq_depth[NR_IRQS];
+
+static int m68k_first_user_vec;
+
+static struct irq_controller auto_irq_controller = {
+        .name           = "auto",
+        .lock           = SPIN_LOCK_UNLOCKED,
+        .startup        = m68k_irq_startup,
+        .shutdown       = m68k_irq_shutdown,
 };
 
-/* The number of spurious interrupts */
-volatile unsigned int num_spurious;
+static struct irq_controller user_irq_controller = {
+        .name           = "user",
+        .lock           = SPIN_LOCK_UNLOCKED,
+        .startup        = m68k_irq_startup,
+        .shutdown       = m68k_irq_shutdown,
+};
 
 #define NUM_IRQ_NODES 100
 static irq_node_t nodes[NUM_IRQ_NODES];
 
-static void dummy_enable_irq(unsigned int irq);
-static void dummy_disable_irq(unsigned int irq);
-static int dummy_request_irq(unsigned int irq,
-                irqreturn_t (*handler) (int, void *, struct pt_regs *),
-                unsigned long flags, const char *devname, void *dev_id);
-static void dummy_free_irq(unsigned int irq, void *dev_id);
-
-void (*enable_irq) (unsigned int) = dummy_enable_irq;
-void (*disable_irq) (unsigned int) = dummy_disable_irq;
-
-int (*mach_request_irq) (unsigned int, irqreturn_t (*)(int, void *, struct pt_regs *),
-                      unsigned long, const char *, void *) = dummy_request_irq;
-void (*mach_free_irq) (unsigned int, void *) = dummy_free_irq;
-
-void init_irq_proc(void);
-
 /*
  * void init_IRQ(void)
  *
@@ -101,18 +94,70 @@ void __init init_IRQ(void)
                 hardirq_mask_is_broken();
         }
 
-        for (i = 0; i < SYS_IRQS; i++) {
-                if (mach_default_handler)
-                        irq_list[i].handler = (*mach_default_handler)[i];
-                irq_list[i].flags   = 0;
-                irq_list[i].dev_id  = NULL;
-                irq_list[i].devname = default_names[i];
-        }
+        for (i = IRQ_AUTO_1; i <= IRQ_AUTO_7; i++)
+                irq_controller[i] = &auto_irq_controller;
+
+        mach_init_IRQ();
+}
+
+/**
+ * m68k_setup_auto_interrupt
+ * @handler: called from auto vector interrupts
+ *
+ * setup the handler to be called from auto vector interrupts instead of the
+ * standard m68k_handle_int(), it will be called with irq numbers in the range
+ * from IRQ_AUTO_1 - IRQ_AUTO_7.
+ */
+void __init m68k_setup_auto_interrupt(void (*handler)(unsigned int, struct pt_regs *))
+{
+        if (handler)
+                *auto_irqhandler_fixup = (u32)handler;
+        flush_icache();
+}
 
-        for (i = 0; i < NUM_IRQ_NODES; i++)
-                nodes[i].handler = NULL;
+/**
+ * m68k_setup_user_interrupt
+ * @vec: first user vector interrupt to handle
+ * @cnt: number of active user vector interrupts
+ * @handler: called from user vector interrupts
+ *
+ * setup user vector interrupts, this includes activating the specified range
+ * of interrupts, only then these interrupts can be requested (note: this is
+ * different from auto vector interrupts). An optional handler can be installed
+ * to be called instead of the default m68k_handle_int(), it will be called
+ * with irq numbers starting from IRQ_USER.
+ */
+void __init m68k_setup_user_interrupt(unsigned int vec, unsigned int cnt,
+                                      void (*handler)(unsigned int, struct pt_regs *))
+{
+        int i;
+
+        m68k_first_user_vec = vec;
+        for (i = 0; i < cnt; i++)
+                irq_controller[IRQ_USER + i] = &user_irq_controller;
+        *user_irqvec_fixup = vec - IRQ_USER;
+        if (handler)
+                *user_irqhandler_fixup = (u32)handler;
+        flush_icache();
+}
+
+/**
+ * m68k_setup_irq_controller
+ * @contr: irq controller which controls specified irq
+ * @irq: first irq to be managed by the controller
+ *
+ * Change the controller for the specified range of irq, which will be used to
+ * manage these irq. auto/user irq already have a default controller, which can
+ * be changed as well, but the controller probably should use m68k_irq_startup/
+ * m68k_irq_shutdown.
+ */
+void m68k_setup_irq_controller(struct irq_controller *contr, unsigned int irq,
+                               unsigned int cnt)
+{
+        int i;
 
-        mach_init_IRQ ();
+        for (i = 0; i < cnt; i++)
+                irq_controller[irq + i] = contr;
 }
 
 irq_node_t *new_irq_node(void)
@@ -120,84 +165,183 @@ irq_node_t *new_irq_node(void)
         irq_node_t *node;
         short i;
 
-        for (node = nodes, i = NUM_IRQ_NODES-1; i >= 0; node++, i--)
-                if (!node->handler)
+        for (node = nodes, i = NUM_IRQ_NODES-1; i >= 0; node++, i--) {
+                if (!node->handler) {
+                        memset(node, 0, sizeof(*node));
                         return node;
+                }
+        }
 
         printk ("new_irq_node: out of nodes\n");
         return NULL;
 }
 
-/*
- * We will keep these functions until I have convinced Linus to move
- * the declaration of them from include/linux/sched.h to
- * include/asm/irq.h.
- */
+int setup_irq(unsigned int irq, struct irq_node *node)
+{
+        struct irq_controller *contr;
+        struct irq_node **prev;
+        unsigned long flags;
+
+        if (irq >= NR_IRQS || !(contr = irq_controller[irq])) {
+                printk("%s: Incorrect IRQ %d from %s\n",
+                       __FUNCTION__, irq, node->devname);
+                return -ENXIO;
+        }
+
+        spin_lock_irqsave(&contr->lock, flags);
+
+        prev = irq_list + irq;
+        if (*prev) {
+                /* Can't share interrupts unless both agree to */
+                if (!((*prev)->flags & node->flags & SA_SHIRQ)) {
+                        spin_unlock_irqrestore(&contr->lock, flags);
+                        return -EBUSY;
+                }
+                while (*prev)
+                        prev = &(*prev)->next;
+        }
+
+        if (!irq_list[irq]) {
+                if (contr->startup)
+                        contr->startup(irq);
+                else
+                        contr->enable(irq);
+        }
+        node->next = NULL;
+        *prev = node;
+
+        spin_unlock_irqrestore(&contr->lock, flags);
+
+        return 0;
+}
+
 int request_irq(unsigned int irq,
                 irqreturn_t (*handler) (int, void *, struct pt_regs *),
                 unsigned long flags, const char *devname, void *dev_id)
 {
-        return mach_request_irq(irq, handler, flags, devname, dev_id);
+        struct irq_node *node;
+        int res;
+
+        node = new_irq_node();
+        if (!node)
+                return -ENOMEM;
+
+        node->handler = handler;
+        node->flags   = flags;
+        node->dev_id  = dev_id;
+        node->devname = devname;
+
+        res = setup_irq(irq, node);
+        if (res)
+                node->handler = NULL;
+
+        return res;
 }
 
 EXPORT_SYMBOL(request_irq);
 
 void free_irq(unsigned int irq, void *dev_id)
 {
-        mach_free_irq(irq, dev_id);
+        struct irq_controller *contr;
+        struct irq_node **p, *node;
+        unsigned long flags;
+
+        if (irq >= NR_IRQS || !(contr = irq_controller[irq])) {
+                printk("%s: Incorrect IRQ %d\n", __FUNCTION__, irq);
+                return;
+        }
+
+        spin_lock_irqsave(&contr->lock, flags);
+
+        p = irq_list + irq;
+        while ((node = *p)) {
+                if (node->dev_id == dev_id)
+                        break;
+                p = &node->next;
+        }
+
+        if (node) {
+                *p = node->next;
+                node->handler = NULL;
+        } else
+                printk("%s: Removing probably wrong IRQ %d\n",
+                       __FUNCTION__, irq);
+
+        if (!irq_list[irq]) {
+                if (contr->shutdown)
+                        contr->shutdown(irq);
+                else
+                        contr->disable(irq);
+        }
+
+        spin_unlock_irqrestore(&contr->lock, flags);
 }
 
 EXPORT_SYMBOL(free_irq);
 
-int cpu_request_irq(unsigned int irq,
-                    irqreturn_t (*handler)(int, void *, struct pt_regs *),
-                    unsigned long flags, const char *devname, void *dev_id)
+void enable_irq(unsigned int irq)
 {
-        if (irq < IRQ1 || irq > IRQ7) {
-                printk("%s: Incorrect IRQ %d from %s\n",
-                       __FUNCTION__, irq, devname);
-                return -ENXIO;
-        }
+        struct irq_controller *contr;
+        unsigned long flags;
 
-#if 0
-        if (!(irq_list[irq].flags & IRQ_FLG_STD)) {
-                if (irq_list[irq].flags & IRQ_FLG_LOCK) {
-                        printk("%s: IRQ %d from %s is not replaceable\n",
-                               __FUNCTION__, irq, irq_list[irq].devname);
-                        return -EBUSY;
-                }
-                if (!(flags & IRQ_FLG_REPLACE)) {
-                        printk("%s: %s can't replace IRQ %d from %s\n",
-                               __FUNCTION__, devname, irq, irq_list[irq].devname);
-                        return -EBUSY;
-                }
+        if (irq >= NR_IRQS || !(contr = irq_controller[irq])) {
+                printk("%s: Incorrect IRQ %d\n",
+                       __FUNCTION__, irq);
+                return;
         }
-#endif
 
-        irq_list[irq].handler = handler;
-        irq_list[irq].flags   = flags;
-        irq_list[irq].dev_id  = dev_id;
-        irq_list[irq].devname = devname;
-        return 0;
+        spin_lock_irqsave(&contr->lock, flags);
+        if (irq_depth[irq]) {
+                if (!--irq_depth[irq]) {
+                        if (contr->enable)
+                                contr->enable(irq);
+                }
+        } else
+                WARN_ON(1);
+        spin_unlock_irqrestore(&contr->lock, flags);
 }
 
-void cpu_free_irq(unsigned int irq, void *dev_id)
+EXPORT_SYMBOL(enable_irq);
+
+void disable_irq(unsigned int irq)
 {
-        if (irq < IRQ1 || irq > IRQ7) {
-                printk("%s: Incorrect IRQ %d\n", __FUNCTION__, irq);
+        struct irq_controller *contr;
+        unsigned long flags;
+
+        if (irq >= NR_IRQS || !(contr = irq_controller[irq])) {
+                printk("%s: Incorrect IRQ %d\n",
+                       __FUNCTION__, irq);
                 return;
         }
 
-        if (irq_list[irq].dev_id != dev_id)
-                printk("%s: Removing probably wrong IRQ %d from %s\n",
-                       __FUNCTION__, irq, irq_list[irq].devname);
+        spin_lock_irqsave(&contr->lock, flags);
+        if (!irq_depth[irq]++) {
+                if (contr->disable)
+                        contr->disable(irq);
+        }
+        spin_unlock_irqrestore(&contr->lock, flags);
+}
 
-        irq_list[irq].handler = (*mach_default_handler)[irq];
-        irq_list[irq].flags   = 0;
-        irq_list[irq].dev_id  = NULL;
-        irq_list[irq].devname = default_names[irq];
+EXPORT_SYMBOL(disable_irq);
+
+int m68k_irq_startup(unsigned int irq)
+{
+        if (irq <= IRQ_AUTO_7)
+                vectors[VEC_SPUR + irq] = auto_inthandler;
+        else
+                vectors[m68k_first_user_vec + irq - IRQ_USER] = user_inthandler;
+        return 0;
 }
 
+void m68k_irq_shutdown(unsigned int irq)
+{
+        if (irq <= IRQ_AUTO_7)
+                vectors[VEC_SPUR + irq] = bad_inthandler;
+        else
+                vectors[m68k_first_user_vec + irq - IRQ_USER] = bad_inthandler;
+}
+
+
 /*
  * Do we need these probe functions on the m68k?
  *
@@ -225,58 +369,50 @@ int probe_irq_off (unsigned long irqs)
 
 EXPORT_SYMBOL(probe_irq_off);
 
-static void dummy_enable_irq(unsigned int irq)
-{
-        printk("calling uninitialized enable_irq()\n");
-}
-
-static void dummy_disable_irq(unsigned int irq)
+unsigned int irq_canonicalize(unsigned int irq)
 {
-        printk("calling uninitialized disable_irq()\n");
+#ifdef CONFIG_Q40
+        if (MACH_IS_Q40 && irq == 11)
+                irq = 10;
+#endif
+        return irq;
 }
 
-static int dummy_request_irq(unsigned int irq,
-                irqreturn_t (*handler) (int, void *, struct pt_regs *),
-                unsigned long flags, const char *devname, void *dev_id)
-{
-        printk("calling uninitialized request_irq()\n");
-        return 0;
-}
+EXPORT_SYMBOL(irq_canonicalize);
 
-static void dummy_free_irq(unsigned int irq, void *dev_id)
+asmlinkage void m68k_handle_int(unsigned int irq, struct pt_regs *regs)
 {
-        printk("calling uninitialized disable_irq()\n");
+        struct irq_node *node;
+
+        kstat_cpu(0).irqs[irq]++;
+        node = irq_list[irq];
+        do {
+                node->handler(irq, node->dev_id, regs);
+                node = node->next;
+        } while (node);
 }
 
-asmlinkage void process_int(unsigned long vec, struct pt_regs *fp)
+asmlinkage void handle_badint(struct pt_regs *regs)
 {
-        if (vec >= VEC_INT1 && vec <= VEC_INT7 && !MACH_IS_BVME6000) {
-                vec -= VEC_SPUR;
-                kstat_cpu(0).irqs[vec]++;
-                irq_list[vec].handler(vec, irq_list[vec].dev_id, fp);
-        } else {
-                if (mach_process_int)
-                        mach_process_int(vec, fp);
-                else
-                        panic("Can't process interrupt vector %ld\n", vec);
-                return;
-        }
+        kstat_cpu(0).irqs[0]++;
+        printk("unexpected interrupt from %u\n", regs->vector);
 }
 
 int show_interrupts(struct seq_file *p, void *v)
 {
+        struct irq_controller *contr;
+        struct irq_node *node;
         int i = *(loff_t *) v;
 
         /* autovector interrupts */
-        if (i < SYS_IRQS) {
-                if (mach_default_handler) {
-                        seq_printf(p, "auto %2d: %10u ", i,
-                                       i ? kstat_cpu(0).irqs[i] : num_spurious);
-                        seq_puts(p, "  ");
-                        seq_printf(p, "%s\n", irq_list[i].devname);
-                }
-        } else if (i == SYS_IRQS)
-                mach_get_irq_list(p, v);
+        if (irq_list[i]) {
+                contr = irq_controller[i];
+                node = irq_list[i];
+                seq_printf(p, "%-8s %3u: %10u %s", contr->name, i, kstat_cpu(0).irqs[i], node->devname);
+                while ((node = node->next))
+                        seq_printf(p, ", %s", node->devname);
+                seq_puts(p, "\n");
+        }
         return 0;
 }
 
diff --git a/arch/m68k/kernel/m68k_ksyms.c b/arch/m68k/kernel/m68k_ksyms.c
index 5b7952ea2bae..1f5e1b5aeda4 100644
--- a/arch/m68k/kernel/m68k_ksyms.c
+++ b/arch/m68k/kernel/m68k_ksyms.c
@@ -57,8 +57,6 @@ EXPORT_SYMBOL(dump_thread);
 EXPORT_SYMBOL(strnlen);
 EXPORT_SYMBOL(strrchr);
 EXPORT_SYMBOL(strstr);
-EXPORT_SYMBOL(enable_irq);
-EXPORT_SYMBOL(disable_irq);
 EXPORT_SYMBOL(kernel_thread);
 #ifdef CONFIG_VME
 EXPORT_SYMBOL(vme_brdtype);
diff --git a/arch/m68k/kernel/setup.c b/arch/m68k/kernel/setup.c
index 750d5b3c971f..214a95f9f3ac 100644
--- a/arch/m68k/kernel/setup.c
+++ b/arch/m68k/kernel/setup.c
@@ -68,11 +68,8 @@ char m68k_debug_device[6] = "";
 void (*mach_sched_init) (irqreturn_t (*handler)(int, void *, struct pt_regs *)) __initdata = NULL;
 /* machine dependent irq functions */
 void (*mach_init_IRQ) (void) __initdata = NULL;
-irqreturn_t (*(*mach_default_handler)[]) (int, void *, struct pt_regs *);
 void (*mach_get_model) (char *model);
 int (*mach_get_hardware_list) (char *buffer);
-int (*mach_get_irq_list) (struct seq_file *, void *);
-irqreturn_t (*mach_process_int) (int, struct pt_regs *);
 /* machine dependent timer functions */
 unsigned long (*mach_gettimeoffset) (void);
 int (*mach_hwclk) (int, struct rtc_time*);
diff --git a/arch/m68k/kernel/traps.c b/arch/m68k/kernel/traps.c
index 837a88709902..e86de7b061cd 100644
--- a/arch/m68k/kernel/traps.c
+++ b/arch/m68k/kernel/traps.c
@@ -45,7 +45,6 @@
 asmlinkage void system_call(void);
 asmlinkage void buserr(void);
 asmlinkage void trap(void);
-asmlinkage void inthandler(void);
 asmlinkage void nmihandler(void);
 #ifdef CONFIG_M68KFPU_EMU
 asmlinkage void fpu_emu(void);
@@ -53,51 +52,7 @@ asmlinkage void fpu_emu(void);
 
 e_vector vectors[256] = {
         [VEC_BUSERR]    = buserr,
-        [VEC_ADDRERR]   = trap,
-        [VEC_ILLEGAL]   = trap,
-        [VEC_ZERODIV]   = trap,
-        [VEC_CHK]       = trap,
-        [VEC_TRAP]      = trap,
-        [VEC_PRIV]      = trap,
-        [VEC_TRACE]     = trap,
-        [VEC_LINE10]    = trap,
-        [VEC_LINE11]    = trap,
-        [VEC_RESV12]    = trap,
-        [VEC_COPROC]    = trap,
-        [VEC_FORMAT]    = trap,
-        [VEC_UNINT]     = trap,
-        [VEC_RESV16]    = trap,
-        [VEC_RESV17]    = trap,
-        [VEC_RESV18]    = trap,
-        [VEC_RESV19]    = trap,
-        [VEC_RESV20]    = trap,
-        [VEC_RESV21]    = trap,
-        [VEC_RESV22]    = trap,
-        [VEC_RESV23]    = trap,
-        [VEC_SPUR]      = inthandler,
-        [VEC_INT1]      = inthandler,
-        [VEC_INT2]      = inthandler,
-        [VEC_INT3]      = inthandler,
-        [VEC_INT4]      = inthandler,
-        [VEC_INT5]      = inthandler,
-        [VEC_INT6]      = inthandler,
-        [VEC_INT7]      = inthandler,
         [VEC_SYS]       = system_call,
-        [VEC_TRAP1]     = trap,
-        [VEC_TRAP2]     = trap,
-        [VEC_TRAP3]     = trap,
-        [VEC_TRAP4]     = trap,
-        [VEC_TRAP5]     = trap,
-        [VEC_TRAP6]     = trap,
-        [VEC_TRAP7]     = trap,
-        [VEC_TRAP8]     = trap,
-        [VEC_TRAP9]     = trap,
-        [VEC_TRAP10]    = trap,
-        [VEC_TRAP11]    = trap,
-        [VEC_TRAP12]    = trap,
-        [VEC_TRAP13]    = trap,
-        [VEC_TRAP14]    = trap,
-        [VEC_TRAP15]    = trap,
 };
 
 /* nmi handler for the Amiga */
@@ -132,12 +87,15 @@ void __init trap_init (void)
 {
         int i;
 
-        for (i = 48; i < 64; i++)
+        for (i = VEC_SPUR; i <= VEC_INT7; i++)
+                vectors[i] = bad_inthandler;
+
+        for (i = 0; i < VEC_USER; i++)
                 if (!vectors[i])
                         vectors[i] = trap;
 
-        for (i = 64; i < 256; i++)
-                vectors[i] = inthandler;
+        for (i = VEC_USER; i < 256; i++)
+                vectors[i] = bad_inthandler;
 
 #ifdef CONFIG_M68KFPU_EMU
         if (FPU_IS_EMU)
@@ -927,66 +885,88 @@ void show_trace(unsigned long *stack)
 void show_registers(struct pt_regs *regs)
 {
         struct frame *fp = (struct frame *)regs;
+        mm_segment_t old_fs = get_fs();
+        u16 c, *cp;
         unsigned long addr;
         int i;
 
+        print_modules();
+        printk("PC: [<%08lx>]",regs->pc);
+        print_symbol(" %s", regs->pc);
+        printk("\nSR: %04x  SP: %p  a2: %08lx\n",
+               regs->sr, regs, regs->a2);
+        printk("d0: %08lx    d1: %08lx    d2: %08lx    d3: %08lx\n",
+               regs->d0, regs->d1, regs->d2, regs->d3);
+        printk("d4: %08lx    d5: %08lx    a0: %08lx    a1: %08lx\n",
+               regs->d4, regs->d5, regs->a0, regs->a1);
+
+        printk("Process %s (pid: %d, task=%p)\n",
+                current->comm, current->pid, current);
         addr = (unsigned long)&fp->un;
-        printk("Frame format=%X ", fp->ptregs.format);
-        switch (fp->ptregs.format) {
+        printk("Frame format=%X ", regs->format);
+        switch (regs->format) {
         case 0x2:
-            printk("instr addr=%08lx\n", fp->un.fmt2.iaddr);
-            addr += sizeof(fp->un.fmt2);
-            break;
+                printk("instr addr=%08lx\n", fp->un.fmt2.iaddr);
+                addr += sizeof(fp->un.fmt2);
+                break;
         case 0x3:
-            printk("eff addr=%08lx\n", fp->un.fmt3.effaddr);
-            addr += sizeof(fp->un.fmt3);
-            break;
+                printk("eff addr=%08lx\n", fp->un.fmt3.effaddr);
+                addr += sizeof(fp->un.fmt3);
+                break;
         case 0x4:
-            printk((CPU_IS_060 ? "fault addr=%08lx fslw=%08lx\n"
-                    : "eff addr=%08lx pc=%08lx\n"),
-                   fp->un.fmt4.effaddr, fp->un.fmt4.pc);
-            addr += sizeof(fp->un.fmt4);
-            break;
+                printk((CPU_IS_060 ? "fault addr=%08lx fslw=%08lx\n"
+                        : "eff addr=%08lx pc=%08lx\n"),
+                        fp->un.fmt4.effaddr, fp->un.fmt4.pc);
+                addr += sizeof(fp->un.fmt4);
+                break;
         case 0x7:
-            printk("eff addr=%08lx ssw=%04x faddr=%08lx\n",
-                   fp->un.fmt7.effaddr, fp->un.fmt7.ssw, fp->un.fmt7.faddr);
-            printk("wb 1 stat/addr/data: %04x %08lx %08lx\n",
-                   fp->un.fmt7.wb1s, fp->un.fmt7.wb1a, fp->un.fmt7.wb1dpd0);
-            printk("wb 2 stat/addr/data: %04x %08lx %08lx\n",
-                   fp->un.fmt7.wb2s, fp->un.fmt7.wb2a, fp->un.fmt7.wb2d);
-            printk("wb 3 stat/addr/data: %04x %08lx %08lx\n",
-                   fp->un.fmt7.wb3s, fp->un.fmt7.wb3a, fp->un.fmt7.wb3d);
-            printk("push data: %08lx %08lx %08lx %08lx\n",
-                   fp->un.fmt7.wb1dpd0, fp->un.fmt7.pd1, fp->un.fmt7.pd2,
-                   fp->un.fmt7.pd3);
-            addr += sizeof(fp->un.fmt7);
-            break;
+                printk("eff addr=%08lx ssw=%04x faddr=%08lx\n",
+                        fp->un.fmt7.effaddr, fp->un.fmt7.ssw, fp->un.fmt7.faddr);
+                printk("wb 1 stat/addr/data: %04x %08lx %08lx\n",
+                        fp->un.fmt7.wb1s, fp->un.fmt7.wb1a, fp->un.fmt7.wb1dpd0);
+                printk("wb 2 stat/addr/data: %04x %08lx %08lx\n",
+                        fp->un.fmt7.wb2s, fp->un.fmt7.wb2a, fp->un.fmt7.wb2d);
+                printk("wb 3 stat/addr/data: %04x %08lx %08lx\n",
+                        fp->un.fmt7.wb3s, fp->un.fmt7.wb3a, fp->un.fmt7.wb3d);
+                printk("push data: %08lx %08lx %08lx %08lx\n",
+                        fp->un.fmt7.wb1dpd0, fp->un.fmt7.pd1, fp->un.fmt7.pd2,
+                        fp->un.fmt7.pd3);
+                addr += sizeof(fp->un.fmt7);
+                break;
         case 0x9:
-            printk("instr addr=%08lx\n", fp->un.fmt9.iaddr);
-            addr += sizeof(fp->un.fmt9);
-            break;
+                printk("instr addr=%08lx\n", fp->un.fmt9.iaddr);
+                addr += sizeof(fp->un.fmt9);
+                break;
         case 0xa:
-            printk("ssw=%04x isc=%04x isb=%04x daddr=%08lx dobuf=%08lx\n",
-                   fp->un.fmta.ssw, fp->un.fmta.isc, fp->un.fmta.isb,
-                   fp->un.fmta.daddr, fp->un.fmta.dobuf);
-            addr += sizeof(fp->un.fmta);
-            break;
+                printk("ssw=%04x isc=%04x isb=%04x daddr=%08lx dobuf=%08lx\n",
+                        fp->un.fmta.ssw, fp->un.fmta.isc, fp->un.fmta.isb,
+                        fp->un.fmta.daddr, fp->un.fmta.dobuf);
+                addr += sizeof(fp->un.fmta);
+                break;
         case 0xb:
-            printk("ssw=%04x isc=%04x isb=%04x daddr=%08lx dobuf=%08lx\n",
-                   fp->un.fmtb.ssw, fp->un.fmtb.isc, fp->un.fmtb.isb,
-                   fp->un.fmtb.daddr, fp->un.fmtb.dobuf);
-            printk("baddr=%08lx dibuf=%08lx ver=%x\n",
-                   fp->un.fmtb.baddr, fp->un.fmtb.dibuf, fp->un.fmtb.ver);
-            addr += sizeof(fp->un.fmtb);
-            break;
+                printk("ssw=%04x isc=%04x isb=%04x daddr=%08lx dobuf=%08lx\n",
+                        fp->un.fmtb.ssw, fp->un.fmtb.isc, fp->un.fmtb.isb,
+                        fp->un.fmtb.daddr, fp->un.fmtb.dobuf);
+                printk("baddr=%08lx dibuf=%08lx ver=%x\n",
+                        fp->un.fmtb.baddr, fp->un.fmtb.dibuf, fp->un.fmtb.ver);
+                addr += sizeof(fp->un.fmtb);
+                break;
         default:
-            printk("\n");
+                printk("\n");
         }
         show_stack(NULL, (unsigned long *)addr);
 
-        printk("Code: ");
-        for (i = 0; i < 10; i++)
-                printk("%04x ", 0xffff & ((short *) fp->ptregs.pc)[i]);
+        printk("Code:");
+        set_fs(KERNEL_DS);
+        cp = (u16 *)regs->pc;
+        for (i = -8; i < 16; i++) {
+                if (get_user(c, cp + i) && i >= 0) {
+                        printk(" Bad PC value.");
+                        break;
+                }
+                printk(i ? " %04x" : " <%04x>", c);
+        }
+        set_fs(old_fs);
         printk ("\n");
 }
 
@@ -1190,19 +1170,7 @@ void die_if_kernel (char *str, struct pt_regs *fp, int nr)
 
         console_verbose();
         printk("%s: %08x\n",str,nr);
-        print_modules();
-        printk("PC: [<%08lx>]",fp->pc);
-        print_symbol(" %s\n", fp->pc);
-        printk("\nSR: %04x  SP: %p  a2: %08lx\n",
-               fp->sr, fp, fp->a2);
-        printk("d0: %08lx    d1: %08lx    d2: %08lx    d3: %08lx\n",
-               fp->d0, fp->d1, fp->d2, fp->d3);
-        printk("d4: %08lx    d5: %08lx    a0: %08lx    a1: %08lx\n",
-               fp->d4, fp->d5, fp->a0, fp->a1);
-
-        printk("Process %s (pid: %d, stackpage=%08lx)\n",
-                current->comm, current->pid, PAGE_SIZE+(unsigned long)current);
-        show_stack(NULL, (unsigned long *)fp);
+        show_registers(fp);
         do_exit(SIGSEGV);
 }
 
diff --git a/arch/m68k/mac/baboon.c b/arch/m68k/mac/baboon.c
index b19b7dd9bd21..6eaa881793d1 100644
--- a/arch/m68k/mac/baboon.c
+++ b/arch/m68k/mac/baboon.c
@@ -81,7 +81,7 @@ irqreturn_t baboon_irq(int irq, void *dev_id, struct pt_regs *regs)
         for (i = 0, irq_bit = 1 ; i < 3 ; i++, irq_bit <<= 1) {
                 if (events & irq_bit/* & baboon_active*/) {
                         baboon_active &= ~irq_bit;
-                        mac_do_irq_list(IRQ_BABOON_0 + i, regs);
+                        m68k_handle_int(IRQ_BABOON_0 + i, regs);
                         baboon_active |= irq_bit;
                         baboon->mb_ifr &= ~irq_bit;
                 }
diff --git a/arch/m68k/mac/config.c b/arch/m68k/mac/config.c
index 19dce75711b1..5a9990e436bb 100644
--- a/arch/m68k/mac/config.c
+++ b/arch/m68k/mac/config.c
@@ -94,20 +94,6 @@ static void mac_sched_init(irqreturn_t (*vector)(int, void *, struct pt_regs *))
         via_init_clock(vector);
 }
 
-extern irqreturn_t mac_default_handler(int, void *, struct pt_regs *);
-
-irqreturn_t (*mac_handlers[8])(int, void *, struct pt_regs *)=
-{
-        mac_default_handler,
-        mac_default_handler,
-        mac_default_handler,
-        mac_default_handler,
-        mac_default_handler,
-        mac_default_handler,
-        mac_default_handler,
-        mac_default_handler
-};
-
 /*
  * Parse a Macintosh-specific record in the bootinfo
  */
@@ -183,13 +169,7 @@ void __init config_mac(void)
 
         mach_sched_init      = mac_sched_init;
         mach_init_IRQ        = mac_init_IRQ;
-        mach_request_irq     = mac_request_irq;
-        mach_free_irq        = mac_free_irq;
-        enable_irq           = mac_enable_irq;
-        disable_irq          = mac_disable_irq;
         mach_get_model   = mac_get_model;
-        mach_default_handler = &mac_handlers;
-        mach_get_irq_list    = show_mac_interrupts;
         mach_gettimeoffset   = mac_gettimeoffset;
 #warning move to adb/via init
 #if 0
diff --git a/arch/m68k/mac/iop.c b/arch/m68k/mac/iop.c
index 9179a3798407..4c8ece7e64a3 100644
--- a/arch/m68k/mac/iop.c
+++ b/arch/m68k/mac/iop.c
@@ -317,7 +317,7 @@ void __init iop_register_interrupts(void)
 {
         if (iop_ism_present) {
                 if (oss_present) {
-                        cpu_request_irq(OSS_IRQLEV_IOPISM, iop_ism_irq,
+                        request_irq(OSS_IRQLEV_IOPISM, iop_ism_irq,
                                         IRQ_FLG_LOCK, "ISM IOP",
                                         (void *) IOP_NUM_ISM);
                         oss_irq_enable(IRQ_MAC_ADB);
diff --git a/arch/m68k/mac/macints.c b/arch/m68k/mac/macints.c
index 7a1600bd195d..694b14bb0de1 100644
--- a/arch/m68k/mac/macints.c
+++ b/arch/m68k/mac/macints.c
@@ -137,14 +137,6 @@
 #define DEBUG_SPURIOUS
 #define SHUTUP_SONIC
 
-/*
- * The mac_irq_list array is an array of linked lists of irq_node_t nodes.
- * Each node contains one handler to be called whenever the interrupt
- * occurs, with fast handlers listed before slow handlers.
- */
-
-irq_node_t *mac_irq_list[NUM_MAC_SOURCES];
-
 /* SCC interrupt mask */
 
 static int scc_mask;
@@ -209,8 +201,8 @@ extern int  baboon_irq_pending(int);
  * SCC interrupt routines
  */
 
-static void scc_irq_enable(int);
-static void scc_irq_disable(int);
+static void scc_irq_enable(unsigned int);
+static void scc_irq_disable(unsigned int);
 
 /*
  * console_loglevel determines NMI handler function
@@ -221,21 +213,25 @@ irqreturn_t mac_debug_handler(int, void *, struct pt_regs *);
 
 /* #define DEBUG_MACINTS */
 
+static void mac_enable_irq(unsigned int irq);
+static void mac_disable_irq(unsigned int irq);
+
+static struct irq_controller mac_irq_controller = {
+        .name           = "mac",
+        .lock           = SPIN_LOCK_UNLOCKED,
+        .enable         = mac_enable_irq,
+        .disable        = mac_disable_irq,
+};
+
 void mac_init_IRQ(void)
 {
-        int i;
-
 #ifdef DEBUG_MACINTS
         printk("mac_init_IRQ(): Setting things up...\n");
 #endif
-        /* Initialize the IRQ handler lists. Initially each list is empty, */
-
-        for (i = 0; i < NUM_MAC_SOURCES; i++) {
-                mac_irq_list[i] = NULL;
-        }
-
         scc_mask = 0;
 
+        m68k_setup_irq_controller(&mac_irq_controller, IRQ_USER,
+                                  NUM_MAC_SOURCES - IRQ_USER);
         /* Make sure the SONIC interrupt is cleared or things get ugly */
 #ifdef SHUTUP_SONIC
         printk("Killing onboard sonic... ");
@@ -252,15 +248,16 @@ void mac_init_IRQ(void)
          * at levels 1-7. Most of the work is done elsewhere.
          */
 
-        if (oss_present) {
+        if (oss_present)
                 oss_register_interrupts();
-        } else {
+        else
                 via_register_interrupts();
-        }
-        if (psc_present) psc_register_interrupts();
-        if (baboon_present) baboon_register_interrupts();
+        if (psc_present)
+                psc_register_interrupts();
+        if (baboon_present)
+                baboon_register_interrupts();
         iop_register_interrupts();
-        cpu_request_irq(7, mac_nmi_handler, IRQ_FLG_LOCK, "NMI",
+        request_irq(IRQ_AUTO_7, mac_nmi_handler, 0, "NMI",
                         mac_nmi_handler);
 #ifdef DEBUG_MACINTS
         printk("mac_init_IRQ(): Done!\n");
@@ -268,104 +265,6 @@ void mac_init_IRQ(void)
 }
 
 /*
- * Routines to work with irq_node_t's on linked lists lifted from
- * the Amiga code written by Roman Zippel.
- */
-
-static inline void mac_insert_irq(irq_node_t **list, irq_node_t *node)
-{
-        unsigned long flags;
-        irq_node_t *cur;
-
-        if (!node->dev_id)
-                printk("%s: Warning: dev_id of %s is zero\n",
-                       __FUNCTION__, node->devname);
-
-        local_irq_save(flags);
-
-        cur = *list;
-
-        if (node->flags & IRQ_FLG_FAST) {
-                node->flags &= ~IRQ_FLG_SLOW;
-                while (cur && cur->flags & IRQ_FLG_FAST) {
-                        list = &cur->next;
-                        cur = cur->next;
-                }
-        } else if (node->flags & IRQ_FLG_SLOW) {
-                while (cur) {
-                        list = &cur->next;
-                        cur = cur->next;
-                }
-        } else {
-                while (cur && !(cur->flags & IRQ_FLG_SLOW)) {
-                        list = &cur->next;
-                        cur = cur->next;
-                }
-        }
-
-        node->next = cur;
-        *list = node;
-
-        local_irq_restore(flags);
-}
-
-static inline void mac_delete_irq(irq_node_t **list, void *dev_id)
-{
-        unsigned long flags;
-        irq_node_t *node;
-
-        local_irq_save(flags);
-
-        for (node = *list; node; list = &node->next, node = *list) {
-                if (node->dev_id == dev_id) {
-                        *list = node->next;
-                        /* Mark it as free. */
-                        node->handler = NULL;
-                        local_irq_restore(flags);
-                        return;
-                }
-        }
-        local_irq_restore(flags);
-        printk ("%s: tried to remove invalid irq\n", __FUNCTION__);
-}
-
-/*
- * Call all the handlers for a given interrupt. Fast handlers are called
- * first followed by slow handlers.
- *
- * This code taken from the original Amiga code written by Roman Zippel.
- */
-
-void mac_do_irq_list(int irq, struct pt_regs *fp)
-{
-        irq_node_t *node, *slow_nodes;
-        unsigned long flags;
-
-        kstat_cpu(0).irqs[irq]++;
-
-#ifdef DEBUG_SPURIOUS
-        if (!mac_irq_list[irq] && (console_loglevel > 7)) {
-                printk("mac_do_irq_list: spurious interrupt %d!\n", irq);
-                return;
-        }
-#endif
-
-        /* serve first fast and normal handlers */
-        for (node = mac_irq_list[irq];
-             node && (!(node->flags & IRQ_FLG_SLOW));
-             node = node->next)
-                node->handler(irq, node->dev_id, fp);
-        if (!node) return;
-        local_save_flags(flags);
-        local_irq_restore((flags & ~0x0700) | (fp->sr & 0x0700));
-        /* if slow handlers exists, serve them now */
-        slow_nodes = node;
-        for (; node; node = node->next) {
-                node->handler(irq, node->dev_id, fp);
-        }
-}
-
-/*
  *  mac_enable_irq - enable an interrupt source
  * mac_disable_irq - disable an interrupt source
  *   mac_clear_irq - clears a pending interrupt
@@ -374,276 +273,124 @@ void mac_do_irq_list(int irq, struct pt_regs *fp)
  * These routines are just dispatchers to the VIA/OSS/PSC routines.
  */
 
-void mac_enable_irq (unsigned int irq)
+static void mac_enable_irq(unsigned int irq)
 {
-        int irq_src     = IRQ_SRC(irq);
+        int irq_src = IRQ_SRC(irq);
 
         switch(irq_src) {
-                case 1: via_irq_enable(irq);
-                        break;
-                case 2:
-                case 7: if (oss_present) {
-                                oss_irq_enable(irq);
-                        } else {
-                                via_irq_enable(irq);
-                        }
-                        break;
-                case 3:
-                case 4:
-                case 5:
-                case 6: if (psc_present) {
-                                psc_irq_enable(irq);
-                        } else if (oss_present) {
-                                oss_irq_enable(irq);
-                        } else if (irq_src == 4) {
-                                scc_irq_enable(irq);
-                        }
-                        break;
-                case 8: if (baboon_present) {
-                                baboon_irq_enable(irq);
-                        }
-                        break;
+        case 1:
+                via_irq_enable(irq);
+                break;
+        case 2:
+        case 7:
+                if (oss_present)
+                        oss_irq_enable(irq);
+                else
+                        via_irq_enable(irq);
+                break;
+        case 3:
+        case 4:
+        case 5:
+        case 6:
+                if (psc_present)
+                        psc_irq_enable(irq);
+                else if (oss_present)
+                        oss_irq_enable(irq);
+                else if (irq_src == 4)
+                        scc_irq_enable(irq);
+                break;
+        case 8:
+                if (baboon_present)
+                        baboon_irq_enable(irq);
+                break;
         }
 }
 
-void mac_disable_irq (unsigned int irq)
+static void mac_disable_irq(unsigned int irq)
 {
-        int irq_src     = IRQ_SRC(irq);
+        int irq_src = IRQ_SRC(irq);
 
         switch(irq_src) {
-                case 1: via_irq_disable(irq);
-                        break;
-                case 2:
-                case 7: if (oss_present) {
-                                oss_irq_disable(irq);
-                        } else {
-                                via_irq_disable(irq);
-                        }
-                        break;
-                case 3:
-                case 4:
-                case 5:
-                case 6: if (psc_present) {
-                                psc_irq_disable(irq);
-                        } else if (oss_present) {
-                                oss_irq_disable(irq);
-                        } else if (irq_src == 4) {
-                                scc_irq_disable(irq);
-                        }
-                        break;
-                case 8: if (baboon_present) {
-                                baboon_irq_disable(irq);
-                        }
-                        break;
+        case 1:
+                via_irq_disable(irq);
+                break;
+        case 2:
+        case 7:
+                if (oss_present)
+                        oss_irq_disable(irq);
+                else
+                        via_irq_disable(irq);
+                break;
+        case 3:
+        case 4:
+        case 5:
+        case 6:
+                if (psc_present)
+                        psc_irq_disable(irq);
+                else if (oss_present)
+                        oss_irq_disable(irq);
+                else if (irq_src == 4)
+                        scc_irq_disable(irq);
+                break;
+        case 8:
+                if (baboon_present)
+                        baboon_irq_disable(irq);
+                break;
         }
 }
 
-void mac_clear_irq( unsigned int irq )
+void mac_clear_irq(unsigned int irq)
 {
         switch(IRQ_SRC(irq)) {
-                case 1: via_irq_clear(irq);
-                        break;
-                case 2:
-                case 7: if (oss_present) {
-                                oss_irq_clear(irq);
-                        } else {
-                                via_irq_clear(irq);
-                        }
-                        break;
-                case 3:
-                case 4:
-                case 5:
-                case 6: if (psc_present) {
-                                psc_irq_clear(irq);
-                        } else if (oss_present) {
-                                oss_irq_clear(irq);
-                        }
-                        break;
-                case 8: if (baboon_present) {
-                                baboon_irq_clear(irq);
-                        }
-                        break;
+        case 1:
+                via_irq_clear(irq);
+                break;
+        case 2:
+        case 7:
+                if (oss_present)
+                        oss_irq_clear(irq);
+                else
+                        via_irq_clear(irq);
+                break;
+        case 3:
+        case 4:
+        case 5:
+        case 6:
+                if (psc_present)
+                        psc_irq_clear(irq);
+                else if (oss_present)
+                        oss_irq_clear(irq);
+                break;
+        case 8:
+                if (baboon_present)
+                        baboon_irq_clear(irq);
+                break;
         }
 }
 
-int mac_irq_pending( unsigned int irq )
+int mac_irq_pending(unsigned int irq)
 {
         switch(IRQ_SRC(irq)) {
-                case 1: return via_irq_pending(irq);
-                case 2:
-                case 7: if (oss_present) {
-                                return oss_irq_pending(irq);
-                        } else {
-                                return via_irq_pending(irq);
-                        }
-                case 3:
-                case 4:
-                case 5:
-                case 6: if (psc_present) {
-                                return psc_irq_pending(irq);
-                        } else if (oss_present) {
-                                return oss_irq_pending(irq);
-                        }
-        }
-        return 0;
-}
-
-/*
- * Add an interrupt service routine to an interrupt source.
- * Returns 0 on success.
- *
- * FIXME: You can register interrupts on nonexistent source (ie PSC4 on a
- *        non-PSC machine). We should return -EINVAL in those cases.
- */
-
-int mac_request_irq(unsigned int irq,
-                    irqreturn_t (*handler)(int, void *, struct pt_regs *),
-                    unsigned long flags, const char *devname, void *dev_id)
-{
-        irq_node_t *node;
-
-#ifdef DEBUG_MACINTS
-        printk ("%s: irq %d requested for %s\n", __FUNCTION__, irq, devname);
-#endif
-
-        if (irq < VIA1_SOURCE_BASE) {
-                return cpu_request_irq(irq, handler, flags, devname, dev_id);
+        case 1:
+                return via_irq_pending(irq);
+        case 2:
+        case 7:
+                if (oss_present)
+                        return oss_irq_pending(irq);
+                else
+                        return via_irq_pending(irq);
+        case 3:
+        case 4:
+        case 5:
+        case 6:
+                if (psc_present)
+                        return psc_irq_pending(irq);
+                else if (oss_present)
+                        return oss_irq_pending(irq);
         }
-
-        if (irq >= NUM_MAC_SOURCES) {
-                printk ("%s: unknown irq %d requested by %s\n",
-                        __FUNCTION__, irq, devname);
-        }
-
-        /* Get a node and stick it onto the right list */
-
-        if (!(node = new_irq_node())) return -ENOMEM;
-
-        node->handler   = handler;
-        node->flags     = flags;
-        node->dev_id    = dev_id;
-        node->devname   = devname;
-        node->next      = NULL;
-        mac_insert_irq(&mac_irq_list[irq], node);
-
-        /* Now enable the IRQ source */
-
-        mac_enable_irq(irq);
-
         return 0;
 }
 
-/*
- * Removes an interrupt service routine from an interrupt source.
- */
-
-void mac_free_irq(unsigned int irq, void *dev_id)
-{
-#ifdef DEBUG_MACINTS
-        printk ("%s: irq %d freed by %p\n", __FUNCTION__, irq, dev_id);
-#endif
-
-        if (irq < VIA1_SOURCE_BASE) {
-                cpu_free_irq(irq, dev_id);
-                return;
-        }
-
-        if (irq >= NUM_MAC_SOURCES) {
-                printk ("%s: unknown irq %d freed\n",
-                        __FUNCTION__, irq);
-                return;
-        }
-
-        mac_delete_irq(&mac_irq_list[irq], dev_id);
-
-        /* If the list for this interrupt is */
-        /* empty then disable the source.    */
-
-        if (!mac_irq_list[irq]) {
-                mac_disable_irq(irq);
-        }
-}
-
-/*
- * Generate a pretty listing for /proc/interrupts
- *
- * By the time we're called the autovector interrupt list has already been
- * generated, so we just need to do the machspec interrupts.
- *
- * 990506 (jmt) - rewritten to handle chained machspec interrupt handlers.
- *                Also removed display of num_spurious it is already
- *                displayed for us as autovector irq 0.
- */
-
-int show_mac_interrupts(struct seq_file *p, void *v)
-{
-        int i;
-        irq_node_t *node;
-        char *base;
-
-        /* Don't do Nubus interrupts in this loop; we do them separately  */
-        /* below so that we can print slot numbers instead of IRQ numbers */
-
-        for (i = VIA1_SOURCE_BASE ; i < NUM_MAC_SOURCES ; ++i) {
-
-                /* Nonexistant interrupt or nothing registered; skip it. */
-
-                if ((node = mac_irq_list[i]) == NULL) continue;
-                if (node->flags & IRQ_FLG_STD) continue;
-
-                base = "";
-                switch(IRQ_SRC(i)) {
-                        case 1: base = "via1";
-                                break;
-                        case 2: if (oss_present) {
-                                        base = "oss";
-                                } else {
-                                        base = "via2";
-                                }
-                                break;
-                        case 3:
-                        case 4:
-                        case 5:
-                        case 6: if (psc_present) {
-                                        base = "psc";
-                                } else if (oss_present) {
-                                        base = "oss";
-                                } else {
-                                        if (IRQ_SRC(i) == 4) base = "scc";
-                                }
-                                break;
-                        case 7: base = "nbus";
-                                break;
-                        case 8: base = "bbn";
-                                break;
-                }
-                seq_printf(p, "%4s %2d: %10u ", base, i, kstat_cpu(0).irqs[i]);
-
-                do {
-                        if (node->flags & IRQ_FLG_FAST) {
-                                seq_puts(p, "F ");
-                        } else if (node->flags & IRQ_FLG_SLOW) {
-                                seq_puts(p, "S ");
-                        } else {
-                                seq_puts(p, "  ");
-                        }
-                        seq_printf(p, "%s\n", node->devname);
-                        if ((node = node->next)) {
-                                seq_puts(p, "                    ");
-                        }
-                } while(node);
-
-        }
-        return 0;
-}
-
-void mac_default_handler(int irq, void *dev_id, struct pt_regs *regs)
-{
-#ifdef DEBUG_SPURIOUS
-        printk("Unexpected IRQ %d on device %p\n", irq, dev_id);
-#endif
-}
-
 static int num_debug[8];
 
 irqreturn_t mac_debug_handler(int irq, void *dev_id, struct pt_regs *regs)
@@ -683,7 +430,7 @@ irqreturn_t mac_nmi_handler(int irq, void *dev_id, struct pt_regs *fp)
         while (nmi_hold == 1)
                 udelay(1000);
 
-        if ( console_loglevel >= 8 ) {
+        if (console_loglevel >= 8) {
 #if 0
                 show_state();
                 printk("PC: %08lx\nSR: %04x  SP: %p\n", fp->pc, fp->sr, fp);
@@ -712,14 +459,16 @@ irqreturn_t mac_nmi_handler(int irq, void *dev_id, struct pt_regs *fp)
  * done in hardware (only the PSC can do that.)
  */
 
-static void scc_irq_enable(int irq) {
-        int irq_idx     = IRQ_IDX(irq);
+static void scc_irq_enable(unsigned int irq)
+{
+        int irq_idx = IRQ_IDX(irq);
 
         scc_mask |= (1 << irq_idx);
 }
 
-static void scc_irq_disable(int irq) {
-        int irq_idx     = IRQ_IDX(irq);
+static void scc_irq_disable(unsigned int irq)
+{
+        int irq_idx = IRQ_IDX(irq);
 
         scc_mask &= ~(1 << irq_idx);
 }
@@ -754,6 +503,8 @@ void mac_scc_dispatch(int irq, void *dev_id, struct pt_regs *regs)
         /* and since they're autovector interrupts they */
         /* pretty much kill the system.                 */
 
-        if (reg & 0x38) mac_do_irq_list(IRQ_SCCA, regs);
-        if (reg & 0x07) mac_do_irq_list(IRQ_SCCB, regs);
+        if (reg & 0x38)
+                m68k_handle_int(IRQ_SCCA, regs);
+        if (reg & 0x07)
+                m68k_handle_int(IRQ_SCCB, regs);
 }
diff --git a/arch/m68k/mac/oss.c b/arch/m68k/mac/oss.c
index 333547692724..63e04365191f 100644
--- a/arch/m68k/mac/oss.c
+++ b/arch/m68k/mac/oss.c
@@ -67,15 +67,15 @@ void __init oss_init(void)
 
 void __init oss_register_interrupts(void)
 {
-        cpu_request_irq(OSS_IRQLEV_SCSI, oss_irq, IRQ_FLG_LOCK,
+        request_irq(OSS_IRQLEV_SCSI, oss_irq, IRQ_FLG_LOCK,
                         "scsi", (void *) oss);
-        cpu_request_irq(OSS_IRQLEV_IOPSCC, mac_scc_dispatch, IRQ_FLG_LOCK,
+        request_irq(OSS_IRQLEV_IOPSCC, mac_scc_dispatch, IRQ_FLG_LOCK,
                         "scc", mac_scc_dispatch);
-        cpu_request_irq(OSS_IRQLEV_NUBUS, oss_nubus_irq, IRQ_FLG_LOCK,
+        request_irq(OSS_IRQLEV_NUBUS, oss_nubus_irq, IRQ_FLG_LOCK,
                         "nubus", (void *) oss);
-        cpu_request_irq(OSS_IRQLEV_SOUND, oss_irq, IRQ_FLG_LOCK,
+        request_irq(OSS_IRQLEV_SOUND, oss_irq, IRQ_FLG_LOCK,
                         "sound", (void *) oss);
-        cpu_request_irq(OSS_IRQLEV_VIA1, via1_irq, IRQ_FLG_LOCK,
+        request_irq(OSS_IRQLEV_VIA1, via1_irq, IRQ_FLG_LOCK,
                         "via1", (void *) via1);
 }
 
@@ -113,7 +113,7 @@ irqreturn_t oss_irq(int irq, void *dev_id, struct pt_regs *regs)
                 oss->irq_pending &= ~OSS_IP_SOUND;
         } else if (events & OSS_IP_SCSI) {
                 oss->irq_level[OSS_SCSI] = OSS_IRQLEV_DISABLED;
-                mac_do_irq_list(IRQ_MAC_SCSI, regs);
+                m68k_handle_int(IRQ_MAC_SCSI, regs);
                 oss->irq_pending &= ~OSS_IP_SCSI;
                 oss->irq_level[OSS_SCSI] = OSS_IRQLEV_SCSI;
         } else {
@@ -146,7 +146,7 @@ irqreturn_t oss_nubus_irq(int irq, void *dev_id, struct pt_regs *regs)
         for (i = 0, irq_bit = 1 ; i < 6 ; i++, irq_bit <<= 1) {
                 if (events & irq_bit) {
                         oss->irq_level[i] = OSS_IRQLEV_DISABLED;
-                        mac_do_irq_list(NUBUS_SOURCE_BASE + i, regs);
+                        m68k_handle_int(NUBUS_SOURCE_BASE + i, regs);
                         oss->irq_pending &= ~irq_bit;
                         oss->irq_level[i] = OSS_IRQLEV_NUBUS;
                 }
diff --git a/arch/m68k/mac/psc.c b/arch/m68k/mac/psc.c
index e72384e43a1e..e26218091755 100644
--- a/arch/m68k/mac/psc.c
+++ b/arch/m68k/mac/psc.c
@@ -117,10 +117,10 @@ void __init psc_init(void)
 
 void __init psc_register_interrupts(void)
 {
-        cpu_request_irq(3, psc_irq, IRQ_FLG_LOCK, "psc3", (void *) 0x30);
-        cpu_request_irq(4, psc_irq, IRQ_FLG_LOCK, "psc4", (void *) 0x40);
-        cpu_request_irq(5, psc_irq, IRQ_FLG_LOCK, "psc5", (void *) 0x50);
-        cpu_request_irq(6, psc_irq, IRQ_FLG_LOCK, "psc6", (void *) 0x60);
+        request_irq(IRQ_AUTO_3, psc_irq, 0, "psc3", (void *) 0x30);
+        request_irq(IRQ_AUTO_4, psc_irq, 0, "psc4", (void *) 0x40);
+        request_irq(IRQ_AUTO_5, psc_irq, 0, "psc5", (void *) 0x50);
+        request_irq(IRQ_AUTO_6, psc_irq, 0, "psc6", (void *) 0x60);
 }
 
 /*
@@ -149,7 +149,7 @@ irqreturn_t psc_irq(int irq, void *dev_id, struct pt_regs *regs)
         for (i = 0, irq_bit = 1 ; i < 4 ; i++, irq_bit <<= 1) {
                 if (events & irq_bit) {
                         psc_write_byte(pIER, irq_bit);
-                        mac_do_irq_list(base_irq + i, regs);
+                        m68k_handle_int(base_irq + i, regs);
                         psc_write_byte(pIFR, irq_bit);
                         psc_write_byte(pIER, irq_bit | 0x80);
                 }
diff --git a/arch/m68k/mac/via.c b/arch/m68k/mac/via.c
index a6e3814c8666..c4aa345d544e 100644
--- a/arch/m68k/mac/via.c
+++ b/arch/m68k/mac/via.c
@@ -253,21 +253,21 @@ void __init via_init_clock(irqreturn_t (*func)(int, void *, struct pt_regs *))
 void __init via_register_interrupts(void)
 {
         if (via_alt_mapping) {
-                cpu_request_irq(IRQ_AUTO_1, via1_irq,
+                request_irq(IRQ_AUTO_1, via1_irq,
                                 IRQ_FLG_LOCK|IRQ_FLG_FAST, "software",
                                 (void *) via1);
-                cpu_request_irq(IRQ_AUTO_6, via1_irq,
+                request_irq(IRQ_AUTO_6, via1_irq,
                                 IRQ_FLG_LOCK|IRQ_FLG_FAST, "via1",
                                 (void *) via1);
         } else {
-                cpu_request_irq(IRQ_AUTO_1, via1_irq,
+                request_irq(IRQ_AUTO_1, via1_irq,
                                 IRQ_FLG_LOCK|IRQ_FLG_FAST, "via1",
                                 (void *) via1);
         }
-        cpu_request_irq(IRQ_AUTO_2, via2_irq, IRQ_FLG_LOCK|IRQ_FLG_FAST,
+        request_irq(IRQ_AUTO_2, via2_irq, IRQ_FLG_LOCK|IRQ_FLG_FAST,
                         "via2", (void *) via2);
         if (!psc_present) {
-                cpu_request_irq(IRQ_AUTO_4, mac_scc_dispatch, IRQ_FLG_LOCK,
+                request_irq(IRQ_AUTO_4, mac_scc_dispatch, IRQ_FLG_LOCK,
                                 "scc", mac_scc_dispatch);
         }
         request_irq(IRQ_MAC_NUBUS, via_nubus_irq, IRQ_FLG_LOCK|IRQ_FLG_FAST,
@@ -424,7 +424,7 @@ irqreturn_t via1_irq(int irq, void *dev_id, struct pt_regs *regs)
         for (i = 0, irq_bit = 1 ; i < 7 ; i++, irq_bit <<= 1)
                 if (events & irq_bit) {
                         via1[vIER] = irq_bit;
-                        mac_do_irq_list(VIA1_SOURCE_BASE + i, regs);
+                        m68k_handle_int(VIA1_SOURCE_BASE + i, regs);
                         via1[vIFR] = irq_bit;
                         via1[vIER] = irq_bit | 0x80;
                 }
@@ -439,7 +439,7 @@ irqreturn_t via1_irq(int irq, void *dev_id, struct pt_regs *regs)
                 /* No, it won't be set. that's why we're doing this. */
                 via_irq_disable(IRQ_MAC_NUBUS);
                 via_irq_clear(IRQ_MAC_NUBUS);
-                mac_do_irq_list(IRQ_MAC_NUBUS, regs);
+                m68k_handle_int(IRQ_MAC_NUBUS, regs);
                 via_irq_enable(IRQ_MAC_NUBUS);
         }
 #endif
@@ -459,7 +459,7 @@ irqreturn_t via2_irq(int irq, void *dev_id, struct pt_regs *regs)
                 if (events & irq_bit) {
                         via2[gIER] = irq_bit;
                         via2[gIFR] = irq_bit | rbv_clear;
-                        mac_do_irq_list(VIA2_SOURCE_BASE + i, regs);
+                        m68k_handle_int(VIA2_SOURCE_BASE + i, regs);
                         via2[gIER] = irq_bit | 0x80;
                 }
         return IRQ_HANDLED;
@@ -481,7 +481,7 @@ irqreturn_t via_nubus_irq(int irq, void *dev_id, struct pt_regs *regs)
         for (i = 0, irq_bit = 1 ; i < 7 ; i++, irq_bit <<= 1) {
                 if (events & irq_bit) {
                         via_irq_disable(NUBUS_SOURCE_BASE + i);
-                        mac_do_irq_list(NUBUS_SOURCE_BASE + i, regs);
+                        m68k_handle_int(NUBUS_SOURCE_BASE + i, regs);
                         via_irq_enable(NUBUS_SOURCE_BASE + i);
                 }
         }
diff --git a/arch/m68k/mm/kmap.c b/arch/m68k/mm/kmap.c
index 85ad19a0ac79..43ffab048724 100644
--- a/arch/m68k/mm/kmap.c
+++ b/arch/m68k/mm/kmap.c
@@ -259,13 +259,15 @@ void __iounmap(void *addr, unsigned long size)
 
                 if (CPU_IS_020_OR_030) {
                         int pmd_off = (virtaddr/PTRTREESIZE) & 15;
+                        int pmd_type = pmd_dir->pmd[pmd_off] & _DESCTYPE_MASK;
 
-                        if ((pmd_dir->pmd[pmd_off] & _DESCTYPE_MASK) == _PAGE_PRESENT) {
+                        if (pmd_type == _PAGE_PRESENT) {
                                 pmd_dir->pmd[pmd_off] = 0;
                                 virtaddr += PTRTREESIZE;
                                 size -= PTRTREESIZE;
                                 continue;
-                        }
+                        } else if (pmd_type == 0)
+                                continue;
                 }
 
                 if (pmd_bad(*pmd_dir)) {
diff --git a/arch/m68k/mvme147/147ints.c b/arch/m68k/mvme147/147ints.c
deleted file mode 100644
index 69a744ee35a3..000000000000
--- a/arch/m68k/mvme147/147ints.c
+++ /dev/null
@@ -1,145 +0,0 @@
-/*
- * arch/m68k/mvme147/147ints.c
- *
- * Copyright (C) 1997 Richard Hirst [richard@sleepie.demon.co.uk]
- *
- * based on amiints.c -- Amiga Linux interrupt handling code
- *
- * This file is subject to the terms and conditions of the GNU General Public
- * License.  See the file README.legal in the main directory of this archive
- * for more details.
- *
- */
-
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/seq_file.h>
-
-#include <asm/ptrace.h>
-#include <asm/system.h>
-#include <asm/irq.h>
-#include <asm/traps.h>
-
-static irqreturn_t mvme147_defhand (int irq, void *dev_id, struct pt_regs *fp);
-
-/*
- * This should ideally be 4 elements only, for speed.
- */
-
-static struct {
-        irqreturn_t     (*handler)(int, void *, struct pt_regs *);
-        unsigned long   flags;
-        void            *dev_id;
-        const char      *devname;
-        unsigned        count;
-} irq_tab[256];
-
-/*
- * void mvme147_init_IRQ (void)
- *
- * Parameters:  None
- *
- * Returns:     Nothing
- *
- * This function is called during kernel startup to initialize
- * the mvme147 IRQ handling routines.
- */
-
-void mvme147_init_IRQ (void)
-{
-        int i;
-
-        for (i = 0; i < 256; i++) {
-                irq_tab[i].handler = mvme147_defhand;
-                irq_tab[i].flags = IRQ_FLG_STD;
-                irq_tab[i].dev_id = NULL;
-                irq_tab[i].devname = NULL;
-                irq_tab[i].count = 0;
-        }
-}
-
-int mvme147_request_irq(unsigned int irq,
-                irqreturn_t (*handler)(int, void *, struct pt_regs *),
-                unsigned long flags, const char *devname, void *dev_id)
-{
-        if (irq > 255) {
-                printk("%s: Incorrect IRQ %d from %s\n", __FUNCTION__, irq, devname);
-                return -ENXIO;
-        }
-        if (!(irq_tab[irq].flags & IRQ_FLG_STD)) {
-                if (irq_tab[irq].flags & IRQ_FLG_LOCK) {
-                        printk("%s: IRQ %d from %s is not replaceable\n",
-                               __FUNCTION__, irq, irq_tab[irq].devname);
-                        return -EBUSY;
-                }
-                if (flags & IRQ_FLG_REPLACE) {
-                        printk("%s: %s can't replace IRQ %d from %s\n",
-                               __FUNCTION__, devname, irq, irq_tab[irq].devname);
-                        return -EBUSY;
-                }
-        }
-        irq_tab[irq].handler = handler;
-        irq_tab[irq].flags   = flags;
-        irq_tab[irq].dev_id  = dev_id;
-        irq_tab[irq].devname = devname;
-        return 0;
-}
-
-void mvme147_free_irq(unsigned int irq, void *dev_id)
-{
-        if (irq > 255) {
-                printk("%s: Incorrect IRQ %d\n", __FUNCTION__, irq);
-                return;
-        }
-        if (irq_tab[irq].dev_id != dev_id)
-                printk("%s: Removing probably wrong IRQ %d from %s\n",
-                       __FUNCTION__, irq, irq_tab[irq].devname);
-
-        irq_tab[irq].handler = mvme147_defhand;
-        irq_tab[irq].flags   = IRQ_FLG_STD;
-        irq_tab[irq].dev_id  = NULL;
-        irq_tab[irq].devname = NULL;
-}
-
-irqreturn_t mvme147_process_int (unsigned long vec, struct pt_regs *fp)
-{
-        if (vec > 255) {
-                printk ("mvme147_process_int: Illegal vector %ld\n", vec);
-                return IRQ_NONE;
-        } else {
-                irq_tab[vec].count++;
-                irq_tab[vec].handler(vec, irq_tab[vec].dev_id, fp);
-                return IRQ_HANDLED;
-        }
-}
-
-int show_mvme147_interrupts (struct seq_file *p, void *v)
-{
-        int i;
-
-        for (i = 0; i < 256; i++) {
-                if (irq_tab[i].count)
-                        seq_printf(p, "Vec 0x%02x: %8d  %s\n",
-                            i, irq_tab[i].count,
-                            irq_tab[i].devname ? irq_tab[i].devname : "free");
-        }
-        return 0;
-}
-
-
-static irqreturn_t mvme147_defhand (int irq, void *dev_id, struct pt_regs *fp)
-{
-        printk ("Unknown interrupt 0x%02x\n", irq);
-        return IRQ_NONE;
-}
-
-void mvme147_enable_irq (unsigned int irq)
-{
-}
-
-
-void mvme147_disable_irq (unsigned int irq)
-{
-}
-
diff --git a/arch/m68k/mvme147/Makefile b/arch/m68k/mvme147/Makefile
index f0153ed3efa5..a36d38dbfbbc 100644
--- a/arch/m68k/mvme147/Makefile
+++ b/arch/m68k/mvme147/Makefile
@@ -2,4 +2,4 @@
 # Makefile for Linux arch/m68k/mvme147 source directory
 #
 
-obj-y           := config.o 147ints.o
+obj-y           := config.o
diff --git a/arch/m68k/mvme147/config.c b/arch/m68k/mvme147/config.c
index 0fcf9720c2fe..0cd0e5bddcee 100644
--- a/arch/m68k/mvme147/config.c
+++ b/arch/m68k/mvme147/config.c
@@ -36,15 +36,8 @@
 #include <asm/mvme147hw.h>
 
 
-extern irqreturn_t mvme147_process_int (int level, struct pt_regs *regs);
-extern void mvme147_init_IRQ (void);
-extern void mvme147_free_irq (unsigned int, void *);
-extern int  show_mvme147_interrupts (struct seq_file *, void *);
-extern void mvme147_enable_irq (unsigned int);
-extern void mvme147_disable_irq (unsigned int);
 static void mvme147_get_model(char *model);
 static int  mvme147_get_hardware_list(char *buffer);
-extern int mvme147_request_irq (unsigned int irq, irqreturn_t (*handler)(int, void *, struct pt_regs *), unsigned long flags, const char *devname, void *dev_id);
 extern void mvme147_sched_init(irqreturn_t (*handler)(int, void *, struct pt_regs *));
 extern unsigned long mvme147_gettimeoffset (void);
 extern int mvme147_hwclk (int, struct rtc_time *);
@@ -91,6 +84,15 @@ static int mvme147_get_hardware_list(char *buffer)
         return 0;
 }
 
+/*
+ * This function is called during kernel startup to initialize
+ * the mvme147 IRQ handling routines.
+ */
+
+void mvme147_init_IRQ(void)
+{
+        m68k_setup_user_interrupt(VEC_USER, 192, NULL);
+}
 
 void __init config_mvme147(void)
 {
@@ -101,12 +103,6 @@ void __init config_mvme147(void)
         mach_hwclk              = mvme147_hwclk;
         mach_set_clock_mmss     = mvme147_set_clock_mmss;
         mach_reset              = mvme147_reset;
-        mach_free_irq           = mvme147_free_irq;
-        mach_process_int        = mvme147_process_int;
-        mach_get_irq_list       = show_mvme147_interrupts;
-        mach_request_irq        = mvme147_request_irq;
-        enable_irq              = mvme147_enable_irq;
-        disable_irq             = mvme147_disable_irq;
         mach_get_model          = mvme147_get_model;
         mach_get_hardware_list  = mvme147_get_hardware_list;
 
diff --git a/arch/m68k/mvme16x/16xints.c b/arch/m68k/mvme16x/16xints.c
deleted file mode 100644
index 793ef735b59c..000000000000
--- a/arch/m68k/mvme16x/16xints.c
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
- * arch/m68k/mvme16x/16xints.c
- *
- * Copyright (C) 1995 Richard Hirst [richard@sleepie.demon.co.uk]
- *
- * based on amiints.c -- Amiga Linux interrupt handling code
- *
- * This file is subject to the terms and conditions of the GNU General Public
- * License.  See the file README.legal in the main directory of this archive
- * for more details.
- *
- */
-
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/seq_file.h>
-
-#include <asm/system.h>
-#include <asm/ptrace.h>
-#include <asm/irq.h>
-
-static irqreturn_t mvme16x_defhand (int irq, void *dev_id, struct pt_regs *fp);
-
-/*
- * This should ideally be 4 elements only, for speed.
- */
-
-static struct {
-        irqreturn_t     (*handler)(int, void *, struct pt_regs *);
-        unsigned long   flags;
-        void            *dev_id;
-        const char      *devname;
-        unsigned        count;
-} irq_tab[192];
-
-/*
- * void mvme16x_init_IRQ (void)
- *
- * Parameters:  None
- *
- * Returns:     Nothing
- *
- * This function is called during kernel startup to initialize
- * the mvme16x IRQ handling routines.  Should probably ensure
- * that the base vectors for the VMEChip2 and PCCChip2 are valid.
- */
-
-void mvme16x_init_IRQ (void)
-{
-        int i;
-
-        for (i = 0; i < 192; i++) {
-                irq_tab[i].handler = mvme16x_defhand;
-                irq_tab[i].flags = IRQ_FLG_STD;
-                irq_tab[i].dev_id = NULL;
-                irq_tab[i].devname = NULL;
-                irq_tab[i].count = 0;
-        }
-}
-
-int mvme16x_request_irq(unsigned int irq,
-                irqreturn_t (*handler)(int, void *, struct pt_regs *),
-                unsigned long flags, const char *devname, void *dev_id)
-{
-        if (irq < 64 || irq > 255) {
-                printk("%s: Incorrect IRQ %d from %s\n", __FUNCTION__, irq, devname);
-                return -ENXIO;
-        }
-
-        if (!(irq_tab[irq-64].flags & IRQ_FLG_STD)) {
-                if (irq_tab[irq-64].flags & IRQ_FLG_LOCK) {
-                        printk("%s: IRQ %d from %s is not replaceable\n",
-                               __FUNCTION__, irq, irq_tab[irq-64].devname);
-                        return -EBUSY;
-                }
-                if (flags & IRQ_FLG_REPLACE) {
-                        printk("%s: %s can't replace IRQ %d from %s\n",
-                               __FUNCTION__, devname, irq, irq_tab[irq-64].devname);
-                        return -EBUSY;
-                }
-        }
-        irq_tab[irq-64].handler = handler;
-        irq_tab[irq-64].flags   = flags;
-        irq_tab[irq-64].dev_id  = dev_id;
-        irq_tab[irq-64].devname = devname;
-        return 0;
-}
-
-void mvme16x_free_irq(unsigned int irq, void *dev_id)
-{
-        if (irq < 64 || irq > 255) {
-                printk("%s: Incorrect IRQ %d\n", __FUNCTION__, irq);
-                return;
-        }
-
-        if (irq_tab[irq-64].dev_id != dev_id)
-                printk("%s: Removing probably wrong IRQ %d from %s\n",
-                       __FUNCTION__, irq, irq_tab[irq-64].devname);
-
-        irq_tab[irq-64].handler = mvme16x_defhand;
-        irq_tab[irq-64].flags   = IRQ_FLG_STD;
-        irq_tab[irq-64].dev_id  = NULL;
-        irq_tab[irq-64].devname = NULL;
-}
-
-irqreturn_t mvme16x_process_int (unsigned long vec, struct pt_regs *fp)
-{
-        if (vec < 64 || vec > 255) {
-                printk ("mvme16x_process_int: Illegal vector %ld", vec);
-                return IRQ_NONE;
-        } else {
-                irq_tab[vec-64].count++;
-                irq_tab[vec-64].handler(vec, irq_tab[vec-64].dev_id, fp);
-                return IRQ_HANDLED;
-        }
-}
-
-int show_mvme16x_interrupts (struct seq_file *p, void *v)
-{
-        int i;
-
-        for (i = 0; i < 192; i++) {
-                if (irq_tab[i].count)
-                        seq_printf(p, "Vec 0x%02x: %8d  %s\n",
-                            i+64, irq_tab[i].count,
-                            irq_tab[i].devname ? irq_tab[i].devname : "free");
-        }
-        return 0;
-}
-
-
-static irqreturn_t mvme16x_defhand (int irq, void *dev_id, struct pt_regs *fp)
-{
-        printk ("Unknown interrupt 0x%02x\n", irq);
-        return IRQ_NONE;
-}
-
-
-void mvme16x_enable_irq (unsigned int irq)
-{
-}
-
-
-void mvme16x_disable_irq (unsigned int irq)
-{
-}
-
-
diff --git a/arch/m68k/mvme16x/Makefile b/arch/m68k/mvme16x/Makefile
index 5129f56b64a3..950e82f21640 100644
--- a/arch/m68k/mvme16x/Makefile
+++ b/arch/m68k/mvme16x/Makefile
@@ -2,4 +2,4 @@
 # Makefile for Linux arch/m68k/mvme16x source directory
 #
 
-obj-y           := config.o 16xints.o rtc.o mvme16x_ksyms.o
+obj-y           := config.o rtc.o mvme16x_ksyms.o
diff --git a/arch/m68k/mvme16x/config.c b/arch/m68k/mvme16x/config.c
index 26ce81c1337d..ce2727ed1bc0 100644
--- a/arch/m68k/mvme16x/config.c
+++ b/arch/m68k/mvme16x/config.c
@@ -40,15 +40,8 @@ extern t_bdid mvme_bdid;
 
 static MK48T08ptr_t volatile rtc = (MK48T08ptr_t)MVME_RTC_BASE;
 
-extern irqreturn_t mvme16x_process_int (int level, struct pt_regs *regs);
-extern void mvme16x_init_IRQ (void);
-extern void mvme16x_free_irq (unsigned int, void *);
-extern int show_mvme16x_interrupts (struct seq_file *, void *);
-extern void mvme16x_enable_irq (unsigned int);
-extern void mvme16x_disable_irq (unsigned int);
 static void mvme16x_get_model(char *model);
 static int  mvme16x_get_hardware_list(char *buffer);
-extern int  mvme16x_request_irq(unsigned int irq, irqreturn_t (*handler)(int, void *, struct pt_regs *), unsigned long flags, const char *devname, void *dev_id);
 extern void mvme16x_sched_init(irqreturn_t (*handler)(int, void *, struct pt_regs *));
 extern unsigned long mvme16x_gettimeoffset (void);
 extern int mvme16x_hwclk (int, struct rtc_time *);
@@ -120,6 +113,16 @@ static int mvme16x_get_hardware_list(char *buffer)
     return (len);
 }
 
+/*
+ * This function is called during kernel startup to initialize
+ * the mvme16x IRQ handling routines.  Should probably ensure
+ * that the base vectors for the VMEChip2 and PCCChip2 are valid.
+ */
+
+static void mvme16x_init_IRQ (void)
+{
+        m68k_setup_user_interrupt(VEC_USER, 192, NULL);
+}
 
 #define pcc2chip        ((volatile u_char *)0xfff42000)
 #define PccSCCMICR      0x1d
@@ -138,12 +141,6 @@ void __init config_mvme16x(void)
     mach_hwclk           = mvme16x_hwclk;
     mach_set_clock_mmss  = mvme16x_set_clock_mmss;
     mach_reset           = mvme16x_reset;
-    mach_free_irq        = mvme16x_free_irq;
-    mach_process_int     = mvme16x_process_int;
-    mach_get_irq_list    = show_mvme16x_interrupts;
-    mach_request_irq     = mvme16x_request_irq;
-    enable_irq           = mvme16x_enable_irq;
-    disable_irq          = mvme16x_disable_irq;
     mach_get_model       = mvme16x_get_model;
     mach_get_hardware_list = mvme16x_get_hardware_list;
 
diff --git a/arch/m68k/q40/config.c b/arch/m68k/q40/config.c
index 5e0f9b04d45e..efa52d302d67 100644
--- a/arch/m68k/q40/config.c
+++ b/arch/m68k/q40/config.c
@@ -37,15 +37,9 @@
 #include <asm/q40_master.h>
 
 extern irqreturn_t q40_process_int (int level, struct pt_regs *regs);
-extern irqreturn_t (*q40_default_handler[]) (int, void *, struct pt_regs *);  /* added just for debugging */
 extern void q40_init_IRQ (void);
-extern void q40_free_irq (unsigned int, void *);
-extern int  show_q40_interrupts (struct seq_file *, void *);
-extern void q40_enable_irq (unsigned int);
-extern void q40_disable_irq (unsigned int);
 static void q40_get_model(char *model);
 static int  q40_get_hardware_list(char *buffer);
-extern int  q40_request_irq(unsigned int irq, irqreturn_t (*handler)(int, void *, struct pt_regs *), unsigned long flags, const char *devname, void *dev_id);
 extern void q40_sched_init(irqreturn_t (*handler)(int, void *, struct pt_regs *));
 
 extern unsigned long q40_gettimeoffset (void);
@@ -175,13 +169,6 @@ void __init config_q40(void)
     mach_set_clock_mmss  = q40_set_clock_mmss;
 
     mach_reset           = q40_reset;
-    mach_free_irq        = q40_free_irq;
-    mach_process_int     = q40_process_int;
-    mach_get_irq_list    = show_q40_interrupts;
-    mach_request_irq     = q40_request_irq;
-    enable_irq           = q40_enable_irq;
-    disable_irq          = q40_disable_irq;
-    mach_default_handler = &q40_default_handler;
     mach_get_model       = q40_get_model;
     mach_get_hardware_list = q40_get_hardware_list;
 
diff --git a/arch/m68k/q40/q40ints.c b/arch/m68k/q40/q40ints.c
index f8ecc2664fe6..472f41c4158b 100644
--- a/arch/m68k/q40/q40ints.c
+++ b/arch/m68k/q40/q40ints.c
@@ -14,13 +14,8 @@
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
-#include <linux/string.h>
-#include <linux/sched.h>
-#include <linux/seq_file.h>
 #include <linux/interrupt.h>
-#include <linux/hardirq.h>
 
-#include <asm/rtc.h>
 #include <asm/ptrace.h>
 #include <asm/system.h>
 #include <asm/irq.h>
@@ -39,29 +34,37 @@
  *
 */
 
-extern int ints_inited;
+static void q40_irq_handler(unsigned int, struct pt_regs *fp);
+static void q40_enable_irq(unsigned int);
+static void q40_disable_irq(unsigned int);
 
+unsigned short q40_ablecount[35];
+unsigned short q40_state[35];
 
-irqreturn_t q40_irq2_handler (int, void *, struct pt_regs *fp);
-
-
-static irqreturn_t q40_defhand (int irq, void *dev_id, struct pt_regs *fp);
-static irqreturn_t default_handler(int lev, void *dev_id, struct pt_regs *regs);
-
-
-#define DEVNAME_SIZE 24
+static int q40_irq_startup(unsigned int irq)
+{
+        /* test for ISA ints not implemented by HW */
+        switch (irq) {
+        case 1: case 2: case 8: case 9:
+        case 11: case 12: case 13:
+                printk("%s: ISA IRQ %d not implemented by HW\n", __FUNCTION__, irq);
+                return -ENXIO;
+        }
+        return 0;
+}
 
-static struct q40_irq_node {
-        irqreturn_t     (*handler)(int, void *, struct pt_regs *);
-        unsigned long   flags;
-        void            *dev_id;
-  /*        struct q40_irq_node *next;*/
-        char            devname[DEVNAME_SIZE];
-        unsigned        count;
-        unsigned short  state;
-} irq_tab[Q40_IRQ_MAX+1];
+static void q40_irq_shutdown(unsigned int irq)
+{
+}
 
-short unsigned q40_ablecount[Q40_IRQ_MAX+1];
+static struct irq_controller q40_irq_controller = {
+        .name           = "q40",
+        .lock           = SPIN_LOCK_UNLOCKED,
+        .startup        = q40_irq_startup,
+        .shutdown       = q40_irq_shutdown,
+        .enable         = q40_enable_irq,
+        .disable        = q40_disable_irq,
+};
 
 /*
  * void q40_init_IRQ (void)
@@ -74,139 +77,29 @@ short unsigned q40_ablecount[Q40_IRQ_MAX+1];
  * the q40 IRQ handling routines.
  */
 
-static int disabled=0;
+static int disabled;
 
-void q40_init_IRQ (void)
+void q40_init_IRQ(void)
 {
-        int i;
-
-        disabled=0;
-        for (i = 0; i <= Q40_IRQ_MAX; i++) {
-                irq_tab[i].handler = q40_defhand;
-                irq_tab[i].flags = 0;
-                irq_tab[i].dev_id = NULL;
-                /*              irq_tab[i].next = NULL;*/
-                irq_tab[i].devname[0] = 0;
-                irq_tab[i].count = 0;
-                irq_tab[i].state =0;
-                q40_ablecount[i]=0;   /* all enabled */
-        }
+        m68k_setup_irq_controller(&q40_irq_controller, 1, Q40_IRQ_MAX);
 
         /* setup handler for ISA ints */
-        cpu_request_irq(IRQ2, q40_irq2_handler, 0, "q40 ISA and master chip",
-                        NULL);
+        m68k_setup_auto_interrupt(q40_irq_handler);
+
+        m68k_irq_startup(IRQ_AUTO_2);
+        m68k_irq_startup(IRQ_AUTO_4);
 
         /* now enable some ints.. */
-        master_outb(1,EXT_ENABLE_REG);  /* ISA IRQ 5-15 */
+        master_outb(1, EXT_ENABLE_REG);  /* ISA IRQ 5-15 */
 
         /* make sure keyboard IRQ is disabled */
-        master_outb(0,KEY_IRQ_ENABLE_REG);
+        master_outb(0, KEY_IRQ_ENABLE_REG);
 }
 
-int q40_request_irq(unsigned int irq,
-                irqreturn_t (*handler)(int, void *, struct pt_regs *),
-                unsigned long flags, const char *devname, void *dev_id)
-{
-  /*printk("q40_request_irq %d, %s\n",irq,devname);*/
-
-        if (irq > Q40_IRQ_MAX || (irq>15 && irq<32)) {
-                printk("%s: Incorrect IRQ %d from %s\n", __FUNCTION__, irq, devname);
-                return -ENXIO;
-        }
-
-        /* test for ISA ints not implemented by HW */
-        switch (irq)
-          {
-          case 1: case 2: case 8: case 9:
-          case 12: case 13:
-            printk("%s: ISA IRQ %d from %s not implemented by HW\n", __FUNCTION__, irq, devname);
-            return -ENXIO;
-          case 11:
-            printk("warning IRQ 10 and 11 not distinguishable\n");
-            irq=10;
-          default:
-            ;
-          }
-
-        if (irq<Q40_IRQ_SAMPLE)
-          {
-            if (irq_tab[irq].dev_id != NULL)
-                  {
-                    printk("%s: IRQ %d from %s is not replaceable\n",
-                           __FUNCTION__, irq, irq_tab[irq].devname);
-                    return -EBUSY;
-                  }
-            /*printk("IRQ %d set to handler %p\n",irq,handler);*/
-            if (dev_id==NULL)
-                  {
-                printk("WARNING: dev_id == NULL in request_irq\n");
-                dev_id=(void*)1;
-              }
-            irq_tab[irq].handler = handler;
-            irq_tab[irq].flags   = flags;
-            irq_tab[irq].dev_id  = dev_id;
-            strlcpy(irq_tab[irq].devname,devname,sizeof(irq_tab[irq].devname));
-            irq_tab[irq].state = 0;
-            return 0;
-          }
-        else {
-          /* Q40_IRQ_SAMPLE :somewhat special actions required here ..*/
-          cpu_request_irq(4, handler, flags, devname, dev_id);
-          cpu_request_irq(6, handler, flags, devname, dev_id);
-          return 0;
-        }
-}
-
-void q40_free_irq(unsigned int irq, void *dev_id)
-{
-        if (irq > Q40_IRQ_MAX || (irq>15 && irq<32)) {
-                printk("%s: Incorrect IRQ %d, dev_id %x \n", __FUNCTION__, irq, (unsigned)dev_id);
-                return;
-        }
-
-        /* test for ISA ints not implemented by HW */
-        switch (irq)
-          {
-          case 1: case 2: case 8: case 9:
-          case 12: case 13:
-            printk("%s: ISA IRQ %d from %x invalid\n", __FUNCTION__, irq, (unsigned)dev_id);
-            return;
-          case 11: irq=10;
-          default:
-            ;
-          }
-
-        if (irq<Q40_IRQ_SAMPLE)
-          {
-            if (irq_tab[irq].dev_id != dev_id)
-              printk("%s: Removing probably wrong IRQ %d from %s\n",
-                     __FUNCTION__, irq, irq_tab[irq].devname);
-
-            irq_tab[irq].handler = q40_defhand;
-            irq_tab[irq].flags   = 0;
-            irq_tab[irq].dev_id  = NULL;
-            /* irq_tab[irq].devname = NULL; */
-            /* do not reset state !! */
-          }
-        else
-          { /* == Q40_IRQ_SAMPLE */
-            cpu_free_irq(4, dev_id);
-            cpu_free_irq(6, dev_id);
-          }
-}
-
-
-irqreturn_t q40_process_int (int level, struct pt_regs *fp)
-{
-  printk("unexpected interrupt vec=%x, pc=%lx, d0=%lx, d0_orig=%lx, d1=%lx, d2=%lx\n",
-          level, fp->pc, fp->d0, fp->orig_d0, fp->d1, fp->d2);
-  printk("\tIIRQ_REG = %x, EIRQ_REG = %x\n",master_inb(IIRQ_REG),master_inb(EIRQ_REG));
-  return IRQ_HANDLED;
-}
 
 /*
  * this stuff doesn't really belong here..
-*/
+ */
 
 int ql_ticks;              /* 200Hz ticks since last jiffie */
 static int sound_ticks;
@@ -215,54 +108,53 @@ static int sound_ticks;
 
 void q40_mksound(unsigned int hz, unsigned int ticks)
 {
-  /* for now ignore hz, except that hz==0 switches off sound */
-  /* simply alternate the ampl (128-SVOL)-(128+SVOL)-..-.. at 200Hz */
-  if (hz==0)
-    {
-      if (sound_ticks)
-        sound_ticks=1;
-
-      *DAC_LEFT=128;
-      *DAC_RIGHT=128;
-
-      return;
-    }
-  /* sound itself is done in q40_timer_int */
-  if (sound_ticks == 0) sound_ticks=1000; /* pretty long beep */
-  sound_ticks=ticks<<1;
+        /* for now ignore hz, except that hz==0 switches off sound */
+        /* simply alternate the ampl (128-SVOL)-(128+SVOL)-..-.. at 200Hz */
+        if (hz == 0) {
+                if (sound_ticks)
+                        sound_ticks = 1;
+
+                *DAC_LEFT = 128;
+                *DAC_RIGHT = 128;
+
+                return;
+        }
+        /* sound itself is done in q40_timer_int */
+        if (sound_ticks == 0)
+                sound_ticks = 1000; /* pretty long beep */
+        sound_ticks = ticks << 1;
 }
 
 static irqreturn_t (*q40_timer_routine)(int, void *, struct pt_regs *);
 
 static irqreturn_t q40_timer_int (int irq, void * dev, struct pt_regs * regs)
 {
-    ql_ticks = ql_ticks ? 0 : 1;
-    if (sound_ticks)
-      {
-        unsigned char sval=(sound_ticks & 1) ? 128-SVOL : 128+SVOL;
-        sound_ticks--;
-        *DAC_LEFT=sval;
-        *DAC_RIGHT=sval;
-      }
-
-    if (!ql_ticks)
-        q40_timer_routine(irq, dev, regs);
-    return IRQ_HANDLED;
+        ql_ticks = ql_ticks ? 0 : 1;
+        if (sound_ticks) {
+                unsigned char sval=(sound_ticks & 1) ? 128-SVOL : 128+SVOL;
+                sound_ticks--;
+                *DAC_LEFT=sval;
+                *DAC_RIGHT=sval;
+        }
+
+        if (!ql_ticks)
+                q40_timer_routine(irq, dev, regs);
+        return IRQ_HANDLED;
 }
 
 void q40_sched_init (irqreturn_t (*timer_routine)(int, void *, struct pt_regs *))
 {
-    int timer_irq;
+        int timer_irq;
 
-    q40_timer_routine = timer_routine;
-    timer_irq=Q40_IRQ_FRAME;
+        q40_timer_routine = timer_routine;
+        timer_irq = Q40_IRQ_FRAME;
 
-    if (request_irq(timer_irq, q40_timer_int, 0,
+        if (request_irq(timer_irq, q40_timer_int, 0,
                                 "timer", q40_timer_int))
-        panic ("Couldn't register timer int");
+                panic("Couldn't register timer int");
 
-    master_outb(-1,FRAME_CLEAR_REG);
-    master_outb( 1,FRAME_RATE_REG);
+        master_outb(-1, FRAME_CLEAR_REG);
+        master_outb( 1, FRAME_RATE_REG);
 }
 
 
@@ -308,169 +200,132 @@ static int mext_disabled=0;  /* ext irq disabled by master chip? */
 static int aliased_irq=0;  /* how many times inside handler ?*/
 
 
-/* got level 2 interrupt, dispatch to ISA or keyboard/timer IRQs */
-irqreturn_t q40_irq2_handler (int vec, void *devname, struct pt_regs *fp)
+/* got interrupt, dispatch to ISA or keyboard/timer IRQs */
+static void q40_irq_handler(unsigned int irq, struct pt_regs *fp)
 {
-  unsigned mir, mer;
-  int irq,i;
+        unsigned mir, mer;
+        int i;
 
 //repeat:
-  mir=master_inb(IIRQ_REG);
-  if (mir&Q40_IRQ_FRAME_MASK) {
-          irq_tab[Q40_IRQ_FRAME].count++;
-          irq_tab[Q40_IRQ_FRAME].handler(Q40_IRQ_FRAME,irq_tab[Q40_IRQ_FRAME].dev_id,fp);
-          master_outb(-1,FRAME_CLEAR_REG);
-  }
-  if ((mir&Q40_IRQ_SER_MASK) || (mir&Q40_IRQ_EXT_MASK)) {
-          mer=master_inb(EIRQ_REG);
-          for (i=0; eirqs[i].mask; i++) {
-                  if (mer&(eirqs[i].mask)) {
-                          irq=eirqs[i].irq;
+        mir = master_inb(IIRQ_REG);
+#ifdef CONFIG_BLK_DEV_FD
+        if ((mir & Q40_IRQ_EXT_MASK) &&
+            (master_inb(EIRQ_REG) & Q40_IRQ6_MASK)) {
+                floppy_hardint();
+                return;
+        }
+#endif
+        switch (irq) {
+        case 4:
+        case 6:
+                m68k_handle_int(Q40_IRQ_SAMPLE, fp);
+                return;
+        }
+        if (mir & Q40_IRQ_FRAME_MASK) {
+                m68k_handle_int(Q40_IRQ_FRAME, fp);
+                master_outb(-1, FRAME_CLEAR_REG);
+        }
+        if ((mir & Q40_IRQ_SER_MASK) || (mir & Q40_IRQ_EXT_MASK)) {
+                mer = master_inb(EIRQ_REG);
+                for (i = 0; eirqs[i].mask; i++) {
+                        if (mer & eirqs[i].mask) {
+                                irq = eirqs[i].irq;
 /*
  * There is a little mess wrt which IRQ really caused this irq request. The
  * main problem is that IIRQ_REG and EIRQ_REG reflect the state when they
  * are read - which is long after the request came in. In theory IRQs should
  * not just go away but they occassionally do
  */
-                          if (irq>4 && irq<=15 && mext_disabled) {
-                                  /*aliased_irq++;*/
-                                  goto iirq;
-                          }
-                          if (irq_tab[irq].handler == q40_defhand ) {
-                                  printk("handler for IRQ %d not defined\n",irq);
-                                  continue; /* ignore uninited INTs :-( */
-                          }
-                          if ( irq_tab[irq].state & IRQ_INPROGRESS ) {
-                                  /* some handlers do local_irq_enable() for irq latency reasons, */
-                                  /* however reentering an active irq handler is not permitted */
+                                if (irq > 4 && irq <= 15 && mext_disabled) {
+                                        /*aliased_irq++;*/
+                                        goto iirq;
+                                }
+                                if (q40_state[irq] & IRQ_INPROGRESS) {
+                                        /* some handlers do local_irq_enable() for irq latency reasons, */
+                                        /* however reentering an active irq handler is not permitted */
 #ifdef IP_USE_DISABLE
-                                  /* in theory this is the better way to do it because it still */
-                                  /* lets through eg the serial irqs, unfortunately it crashes */
-                                  disable_irq(irq);
-                                  disabled=1;
+                                        /* in theory this is the better way to do it because it still */
+                                        /* lets through eg the serial irqs, unfortunately it crashes */
+                                        disable_irq(irq);
+                                        disabled = 1;
 #else
-                                  /*printk("IRQ_INPROGRESS detected for irq %d, disabling - %s disabled\n",irq,disabled ? "already" : "not yet"); */
-                                  fp->sr = (((fp->sr) & (~0x700))+0x200);
-                                  disabled=1;
+                                        /*printk("IRQ_INPROGRESS detected for irq %d, disabling - %s disabled\n",
+                                                irq, disabled ? "already" : "not yet"); */
+                                        fp->sr = (((fp->sr) & (~0x700))+0x200);
+                                        disabled = 1;
 #endif
-                                  goto iirq;
-                          }
-                          irq_tab[irq].count++;
-                          irq_tab[irq].state |= IRQ_INPROGRESS;
-                          irq_tab[irq].handler(irq,irq_tab[irq].dev_id,fp);
-                          irq_tab[irq].state &= ~IRQ_INPROGRESS;
-
-                          /* naively enable everything, if that fails than    */
-                          /* this function will be reentered immediately thus */
-                          /* getting another chance to disable the IRQ        */
-
-                          if ( disabled ) {
+                                        goto iirq;
+                                }
+                                q40_state[irq] |= IRQ_INPROGRESS;
+                                m68k_handle_int(irq, fp);
+                                q40_state[irq] &= ~IRQ_INPROGRESS;
+
+                                /* naively enable everything, if that fails than    */
+                                /* this function will be reentered immediately thus */
+                                /* getting another chance to disable the IRQ        */
+
+                                if (disabled) {
 #ifdef IP_USE_DISABLE
-                                  if (irq>4){
-                                          disabled=0;
-                                          enable_irq(irq);}
+                                        if (irq > 4) {
+                                                disabled = 0;
+                                                enable_irq(irq);
+                                        }
 #else
-                                  disabled=0;
-                                  /*printk("reenabling irq %d\n",irq); */
+                                        disabled = 0;
+                                        /*printk("reenabling irq %d\n", irq); */
 #endif
-                          }
+                                }
 // used to do 'goto repeat;' here, this delayed bh processing too long
-                          return IRQ_HANDLED;
-                  }
-          }
-          if (mer && ccleirq>0 && !aliased_irq)
-                  printk("ISA interrupt from unknown source? EIRQ_REG = %x\n",mer),ccleirq--;
-  }
- iirq:
-  mir=master_inb(IIRQ_REG);
-  /* should test whether keyboard irq is really enabled, doing it in defhand */
-  if (mir&Q40_IRQ_KEYB_MASK) {
-          irq_tab[Q40_IRQ_KEYBOARD].count++;
-          irq_tab[Q40_IRQ_KEYBOARD].handler(Q40_IRQ_KEYBOARD,irq_tab[Q40_IRQ_KEYBOARD].dev_id,fp);
-  }
-  return IRQ_HANDLED;
-}
-
-int show_q40_interrupts (struct seq_file *p, void *v)
-{
-        int i;
-
-        for (i = 0; i <= Q40_IRQ_MAX; i++) {
-                if (irq_tab[i].count)
-                      seq_printf(p, "%sIRQ %02d: %8d  %s%s\n",
-                              (i<=15) ? "ISA-" : "    " ,
-                            i, irq_tab[i].count,
-                            irq_tab[i].devname[0] ? irq_tab[i].devname : "?",
-                            irq_tab[i].handler == q40_defhand ?
-                                        " (now unassigned)" : "");
+                                return;
+                        }
+                }
+                if (mer && ccleirq > 0 && !aliased_irq) {
+                        printk("ISA interrupt from unknown source? EIRQ_REG = %x\n",mer);
+                        ccleirq--;
+                }
         }
-        return 0;
-}
-
+ iirq:
+        mir = master_inb(IIRQ_REG);
+        /* should test whether keyboard irq is really enabled, doing it in defhand */
+        if (mir & Q40_IRQ_KEYB_MASK)
+                m68k_handle_int(Q40_IRQ_KEYBOARD, fp);
 
-static irqreturn_t q40_defhand (int irq, void *dev_id, struct pt_regs *fp)
-{
-        if (irq!=Q40_IRQ_KEYBOARD)
-             printk ("Unknown q40 interrupt %d\n", irq);
-        else master_outb(-1,KEYBOARD_UNLOCK_REG);
-        return IRQ_NONE;
+        return;
 }
-static irqreturn_t default_handler(int lev, void *dev_id, struct pt_regs *regs)
-{
-        printk ("Uninitialised interrupt level %d\n", lev);
-        return IRQ_NONE;
-}
-
-irqreturn_t (*q40_default_handler[SYS_IRQS])(int, void *, struct pt_regs *) = {
-         [0] = default_handler,
-         [1] = default_handler,
-         [2] = default_handler,
-         [3] = default_handler,
-         [4] = default_handler,
-         [5] = default_handler,
-         [6] = default_handler,
-         [7] = default_handler
-};
-
 
-void q40_enable_irq (unsigned int irq)
+void q40_enable_irq(unsigned int irq)
 {
-  if ( irq>=5 && irq<=15 )
-  {
-    mext_disabled--;
-    if (mext_disabled>0)
-          printk("q40_enable_irq : nested disable/enable\n");
-    if (mext_disabled==0)
-    master_outb(1,EXT_ENABLE_REG);
-    }
+        if (irq >= 5 && irq <= 15) {
+                mext_disabled--;
+                if (mext_disabled > 0)
+                        printk("q40_enable_irq : nested disable/enable\n");
+                if (mext_disabled == 0)
+                        master_outb(1, EXT_ENABLE_REG);
+        }
 }
 
 
-void q40_disable_irq (unsigned int irq)
+void q40_disable_irq(unsigned int irq)
 {
-  /* disable ISA iqs : only do something if the driver has been
-   * verified to be Q40 "compatible" - right now IDE, NE2K
-   * Any driver should not attempt to sleep across disable_irq !!
-   */
-
-  if ( irq>=5 && irq<=15 ) {
-    master_outb(0,EXT_ENABLE_REG);
-    mext_disabled++;
-    if (mext_disabled>1) printk("disable_irq nesting count %d\n",mext_disabled);
-  }
+        /* disable ISA iqs : only do something if the driver has been
+         * verified to be Q40 "compatible" - right now IDE, NE2K
+         * Any driver should not attempt to sleep across disable_irq !!
+         */
+
+        if (irq >= 5 && irq <= 15) {
+                master_outb(0, EXT_ENABLE_REG);
+                mext_disabled++;
+                if (mext_disabled > 1)
+                        printk("disable_irq nesting count %d\n",mext_disabled);
+        }
 }
 
-unsigned long q40_probe_irq_on (void)
+unsigned long q40_probe_irq_on(void)
 {
-  printk("irq probing not working - reconfigure the driver to avoid this\n");
-  return -1;
+        printk("irq probing not working - reconfigure the driver to avoid this\n");
+        return -1;
 }
-int q40_probe_irq_off (unsigned long irqs)
+int q40_probe_irq_off(unsigned long irqs)
 {
-  return -1;
+        return -1;
 }
-/*
- * Local variables:
- * compile-command: "m68k-linux-gcc -D__KERNEL__ -I/home/rz/lx/linux-2.2.6/include -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer -pipe -fno-strength-reduce -ffixed-a2 -m68040   -c -o q40ints.o q40ints.c"
- * End:
- */
diff --git a/arch/m68k/sun3/config.c b/arch/m68k/sun3/config.c
index f1ca0dfbaa67..553c304aa2c5 100644
--- a/arch/m68k/sun3/config.c
+++ b/arch/m68k/sun3/config.c
@@ -36,7 +36,6 @@ extern char _text, _end;
 char sun3_reserved_pmeg[SUN3_PMEGS_NUM];
 
 extern unsigned long sun3_gettimeoffset(void);
-extern int show_sun3_interrupts (struct seq_file *, void *);
 extern void sun3_sched_init(irqreturn_t (*handler)(int, void *, struct pt_regs *));
 extern void sun3_get_model (char* model);
 extern void idprom_init (void);
@@ -147,13 +146,6 @@ void __init config_sun3(void)
 
         mach_sched_init      =  sun3_sched_init;
         mach_init_IRQ        =  sun3_init_IRQ;
-        mach_default_handler = &sun3_default_handler;
-        mach_request_irq     =  sun3_request_irq;
-        mach_free_irq        =  sun3_free_irq;
-        enable_irq           =  sun3_enable_irq;
-        disable_irq          =  sun3_disable_irq;
-        mach_process_int     =  sun3_process_int;
-        mach_get_irq_list    =  show_sun3_interrupts;
         mach_reset           =  sun3_reboot;
         mach_gettimeoffset   =  sun3_gettimeoffset;
         mach_get_model       =  sun3_get_model;
diff --git a/arch/m68k/sun3/sun3ints.c b/arch/m68k/sun3/sun3ints.c
index e62a033cd493..0912435e9e90 100644
--- a/arch/m68k/sun3/sun3ints.c
+++ b/arch/m68k/sun3/sun3ints.c
@@ -19,7 +19,6 @@
 #include <linux/seq_file.h>
 
 extern void sun3_leds (unsigned char);
-static irqreturn_t sun3_inthandle(int irq, void *dev_id, struct pt_regs *fp);
 
 void sun3_disable_interrupts(void)
 {
@@ -40,48 +39,30 @@ int led_pattern[8] = {
 
 volatile unsigned char* sun3_intreg;
 
-void sun3_insert_irq(irq_node_t **list, irq_node_t *node)
-{
-}
-
-void sun3_delete_irq(irq_node_t **list, void *dev_id)
-{
-}
-
 void sun3_enable_irq(unsigned int irq)
 {
-        *sun3_intreg |=  (1<<irq);
+        *sun3_intreg |=  (1 << irq);
 }
 
 void sun3_disable_irq(unsigned int irq)
 {
-        *sun3_intreg &= ~(1<<irq);
-}
-
-inline void sun3_do_irq(int irq, struct pt_regs *fp)
-{
-        kstat_cpu(0).irqs[SYS_IRQS + irq]++;
-        *sun3_intreg &= ~(1<<irq);
-        *sun3_intreg |=  (1<<irq);
+        *sun3_intreg &= ~(1 << irq);
 }
 
 static irqreturn_t sun3_int7(int irq, void *dev_id, struct pt_regs *fp)
 {
-        sun3_do_irq(irq,fp);
-        if(!(kstat_cpu(0).irqs[SYS_IRQS + irq] % 2000))
-                sun3_leds(led_pattern[(kstat_cpu(0).irqs[SYS_IRQS+irq]%16000)
-                          /2000]);
+        *sun3_intreg |=  (1 << irq);
+        if (!(kstat_cpu(0).irqs[irq] % 2000))
+                sun3_leds(led_pattern[(kstat_cpu(0).irqs[irq] % 16000) / 2000]);
         return IRQ_HANDLED;
 }
 
 static irqreturn_t sun3_int5(int irq, void *dev_id, struct pt_regs *fp)
 {
-        kstat_cpu(0).irqs[SYS_IRQS + irq]++;
 #ifdef CONFIG_SUN3
         intersil_clear();
 #endif
-        *sun3_intreg &= ~(1<<irq);
-        *sun3_intreg |=  (1<<irq);
+        *sun3_intreg |=  (1 << irq);
 #ifdef CONFIG_SUN3
         intersil_clear();
 #endif
@@ -89,65 +70,8 @@ static irqreturn_t sun3_int5(int irq, void *dev_id, struct pt_regs *fp)
 #ifndef CONFIG_SMP
         update_process_times(user_mode(fp));
 #endif
-        if(!(kstat_cpu(0).irqs[SYS_IRQS + irq] % 20))
-                sun3_leds(led_pattern[(kstat_cpu(0).irqs[SYS_IRQS+irq]%160)
-                /20]);
-        return IRQ_HANDLED;
-}
-
-/* handle requested ints, excepting 5 and 7, which always do the same
-   thing */
-irqreturn_t (*sun3_default_handler[SYS_IRQS])(int, void *, struct pt_regs *) = {
-        [0] = sun3_inthandle,
-        [1] = sun3_inthandle,
-        [2] = sun3_inthandle,
-        [3] = sun3_inthandle,
-        [4] = sun3_inthandle,
-        [5] = sun3_int5,
-        [6] = sun3_inthandle,
-        [7] = sun3_int7
-};
-
-static const char *dev_names[SYS_IRQS] = {
-        [5] = "timer",
-        [7] = "int7 handler"
-};
-static void *dev_ids[SYS_IRQS];
-static irqreturn_t (*sun3_inthandler[SYS_IRQS])(int, void *, struct pt_regs *) = {
-        [5] = sun3_int5,
-        [7] = sun3_int7
-};
-static irqreturn_t (*sun3_vechandler[SUN3_INT_VECS])(int, void *, struct pt_regs *);
-static void *vec_ids[SUN3_INT_VECS];
-static const char *vec_names[SUN3_INT_VECS];
-static int vec_ints[SUN3_INT_VECS];
-
-
-int show_sun3_interrupts(struct seq_file *p, void *v)
-{
-        int i;
-
-        for(i = 0; i < (SUN3_INT_VECS-1); i++) {
-                if(sun3_vechandler[i] != NULL) {
-                        seq_printf(p, "vec %3d: %10u %s\n", i+64,
-                                   vec_ints[i],
-                                   (vec_names[i]) ? vec_names[i] :
-                                   "sun3_vechandler");
-                }
-        }
-
-        return 0;
-}
-
-static irqreturn_t sun3_inthandle(int irq, void *dev_id, struct pt_regs *fp)
-{
-        if(sun3_inthandler[irq] == NULL)
-                panic ("bad interrupt %d received (id %p)\n",irq, dev_id);
-
-        kstat_cpu(0).irqs[SYS_IRQS + irq]++;
-        *sun3_intreg &= ~(1<<irq);
-
-        sun3_inthandler[irq](irq, dev_ids[irq], fp);
+        if (!(kstat_cpu(0).irqs[irq] % 20))
+                sun3_leds(led_pattern[(kstat_cpu(0).irqs[irq] % 160) / 20]);
         return IRQ_HANDLED;
 }
 
@@ -157,109 +81,31 @@ static irqreturn_t sun3_vec255(int irq, void *dev_id, struct pt_regs *fp)
         return IRQ_HANDLED;
 }
 
-void sun3_init_IRQ(void)
+static void sun3_inthandle(unsigned int irq, struct pt_regs *fp)
 {
-        int i;
-
-        *sun3_intreg = 1;
-
-        for(i = 0; i < SYS_IRQS; i++)
-        {
-                if(dev_names[i])
-                        cpu_request_irq(i, sun3_default_handler[i], 0,
-                                        dev_names[i], NULL);
-        }
-
-        for(i = 0; i < 192; i++)
-                sun3_vechandler[i] = NULL;
-
-        sun3_vechandler[191] = sun3_vec255;
-}
-
-int sun3_request_irq(unsigned int irq, irqreturn_t (*handler)(int, void *, struct pt_regs *),
-                      unsigned long flags, const char *devname, void *dev_id)
-{
-
-        if(irq < SYS_IRQS) {
-                if(sun3_inthandler[irq] != NULL) {
-                        printk("sun3_request_irq: request for irq %d -- already taken!\n", irq);
-                        return 1;
-                }
-
-                sun3_inthandler[irq] = handler;
-                dev_ids[irq] = dev_id;
-                dev_names[irq] = devname;
-
-                /* setting devname would be nice */
-                cpu_request_irq(irq, sun3_default_handler[irq], 0, devname,
-                                NULL);
-
-                return 0;
-        } else {
-                if((irq >= 64) && (irq <= 255)) {
-                        int vec;
-
-                        vec = irq - 64;
-                        if(sun3_vechandler[vec] != NULL) {
-                                printk("sun3_request_irq: request for vec %d -- already taken!\n", irq);
-                                return 1;
-                        }
-
-                        sun3_vechandler[vec] = handler;
-                        vec_ids[vec] = dev_id;
-                        vec_names[vec] = devname;
-                        vec_ints[vec] = 0;
-
-                        return 0;
-                }
-        }
-
-        printk("sun3_request_irq: invalid irq %d\n", irq);
-        return 1;
+        *sun3_intreg &= ~(1 << irq);
 
+        m68k_handle_int(irq, fp);
 }
 
-void sun3_free_irq(unsigned int irq, void *dev_id)
-{
-
-        if(irq < SYS_IRQS) {
-                if(sun3_inthandler[irq] == NULL)
-                        panic("sun3_free_int: attempt to free unused irq %d\n", irq);
-                if(dev_ids[irq] != dev_id)
-                        panic("sun3_free_int: incorrect dev_id for irq %d\n", irq);
-
-                sun3_inthandler[irq] = NULL;
-                return;
-        } else if((irq >= 64) && (irq <= 255)) {
-                int vec;
-
-                vec = irq - 64;
-                if(sun3_vechandler[vec] == NULL)
-                        panic("sun3_free_int: attempt to free unused vector %d\n", irq);
-                if(vec_ids[irq] != dev_id)
-                        panic("sun3_free_int: incorrect dev_id for vec %d\n", irq);
-
-                sun3_vechandler[vec] = NULL;
-                return;
-        } else {
-                panic("sun3_free_irq: invalid irq %d\n", irq);
-        }
-}
+static struct irq_controller sun3_irq_controller = {
+        .name           = "sun3",
+        .lock           = SPIN_LOCK_UNLOCKED,
+        .startup        = m68k_irq_startup,
+        .shutdown       = m68k_irq_shutdown,
+        .enable         = sun3_enable_irq,
+        .disable        = sun3_disable_irq,
+};
 
-irqreturn_t sun3_process_int(int irq, struct pt_regs *regs)
+void sun3_init_IRQ(void)
 {
+        *sun3_intreg = 1;
 
-        if((irq >= 64) && (irq <= 255)) {
-                int vec;
-
-                vec = irq - 64;
-                if(sun3_vechandler[vec] == NULL)
-                        panic ("bad interrupt vector %d received\n",irq);
+        m68k_setup_auto_interrupt(sun3_inthandle);
+        m68k_setup_irq_controller(&sun3_irq_controller, IRQ_AUTO_1, 7);
+        m68k_setup_user_interrupt(VEC_USER, 192, NULL);
 
-                vec_ints[vec]++;
-                return sun3_vechandler[vec](irq, vec_ids[vec], regs);
-        } else {
-                panic("sun3_process_int: unable to handle interrupt vector %d\n",
-                      irq);
-        }
+        request_irq(IRQ_AUTO_5, sun3_int5, 0, "int5", NULL);
+        request_irq(IRQ_AUTO_7, sun3_int7, 0, "int7", NULL);
+        request_irq(IRQ_USER+127, sun3_vec255, 0, "vec255", NULL);
 }
diff --git a/arch/m68k/sun3x/config.c b/arch/m68k/sun3x/config.c
index 0920f5d33606..52fb17408869 100644
--- a/arch/m68k/sun3x/config.c
+++ b/arch/m68k/sun3x/config.c
@@ -52,17 +52,10 @@ void __init config_sun3x(void)
 
         sun3x_prom_init();
 
-        mach_get_irq_list        = show_sun3_interrupts;
         mach_max_dma_address = 0xffffffff; /* we can DMA anywhere, whee */
 
-        mach_default_handler = &sun3_default_handler;
         mach_sched_init      = sun3x_sched_init;
         mach_init_IRQ        = sun3_init_IRQ;
-        enable_irq           = sun3_enable_irq;
-        disable_irq          = sun3_disable_irq;
-        mach_request_irq     = sun3_request_irq;
-        mach_free_irq        = sun3_free_irq;
-        mach_process_int     = sun3_process_int;
 
         mach_gettimeoffset   = sun3x_gettimeoffset;
         mach_reset           = sun3x_reboot;
diff --git a/arch/mips/kernel/irixsig.c b/arch/mips/kernel/irixsig.c
index a9bf6cc3abd1..676e868d26fb 100644
--- a/arch/mips/kernel/irixsig.c
+++ b/arch/mips/kernel/irixsig.c
@@ -13,6 +13,7 @@
 #include <linux/smp_lock.h>
 #include <linux/time.h>
 #include <linux/ptrace.h>
+#include <linux/resource.h>
 
 #include <asm/ptrace.h>
 #include <asm/uaccess.h>
@@ -540,8 +541,6 @@ out:
 #define IRIX_P_PGID   2
 #define IRIX_P_ALL    7
 
-extern int getrusage(struct task_struct *, int, struct rusage __user *);
-
 #define W_EXITED     1
 #define W_TRAPPED    2
 #define W_STOPPED    4
diff --git a/arch/mips/kernel/sysirix.c b/arch/mips/kernel/sysirix.c
index 19e1ef43eb4b..1137dd6ea7aa 100644
--- a/arch/mips/kernel/sysirix.c
+++ b/arch/mips/kernel/sysirix.c
@@ -31,6 +31,7 @@
 #include <linux/socket.h>
 #include <linux/security.h>
 #include <linux/syscalls.h>
+#include <linux/resource.h>
 
 #include <asm/ptrace.h>
 #include <asm/page.h>
@@ -235,7 +236,6 @@ asmlinkage int irix_prctl(unsigned option, ...)
 #undef DEBUG_PROCGRPS
 
 extern unsigned long irix_mapelf(int fd, struct elf_phdr __user *user_phdrp, int cnt);
-extern int getrusage(struct task_struct *p, int who, struct rusage __user *ru);
 extern char *prom_getenv(char *name);
 extern long prom_setenv(char *name, char *value);
 
diff --git a/arch/powerpc/kernel/pci_32.c b/arch/powerpc/kernel/pci_32.c
index c858eb4bef17..b5431ccf1147 100644
--- a/arch/powerpc/kernel/pci_32.c
+++ b/arch/powerpc/kernel/pci_32.c
@@ -1654,7 +1654,6 @@ int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
                 return -EINVAL;
 
         vma->vm_pgoff = offset >> PAGE_SHIFT;
-        vma->vm_flags |= VM_SHM | VM_LOCKED | VM_IO;
         vma->vm_page_prot = __pci_mmap_set_pgprot(dev, rp,
                                                   vma->vm_page_prot,
                                                   mmap_state, write_combine);
diff --git a/arch/powerpc/kernel/pci_64.c b/arch/powerpc/kernel/pci_64.c
index 5ad87c426bed..247937dd8b73 100644
--- a/arch/powerpc/kernel/pci_64.c
+++ b/arch/powerpc/kernel/pci_64.c
@@ -877,7 +877,6 @@ int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
                 return -EINVAL;
 
         vma->vm_pgoff = offset >> PAGE_SHIFT;
-        vma->vm_flags |= VM_SHM | VM_LOCKED | VM_IO;
         vma->vm_page_prot = __pci_mmap_set_pgprot(dev, rp,
                                                   vma->vm_page_prot,
                                                   mmap_state, write_combine);
diff --git a/arch/powerpc/kernel/proc_ppc64.c b/arch/powerpc/kernel/proc_ppc64.c
index 2b87f82df135..2ab8f2be911e 100644
--- a/arch/powerpc/kernel/proc_ppc64.c
+++ b/arch/powerpc/kernel/proc_ppc64.c
@@ -115,8 +115,6 @@ static int page_map_mmap( struct file *file, struct vm_area_struct *vma )
 {
         struct proc_dir_entry *dp = PDE(file->f_dentry->d_inode);
 
-        vma->vm_flags |= VM_SHM | VM_LOCKED;
-
         if ((vma->vm_end - vma->vm_start) > dp->size)
                 return -EINVAL;
 
diff --git a/arch/powerpc/kernel/traps.c b/arch/powerpc/kernel/traps.c
index 91a6e04d9741..52f5659534f4 100644
--- a/arch/powerpc/kernel/traps.c
+++ b/arch/powerpc/kernel/traps.c
@@ -32,6 +32,7 @@
 #include <linux/delay.h>
 #include <linux/kprobes.h>
 #include <linux/kexec.h>
+#include <linux/backlight.h>
 
 #include <asm/kdebug.h>
 #include <asm/pgtable.h>
@@ -105,10 +106,18 @@ int die(const char *str, struct pt_regs *regs, long err)
         spin_lock_irq(&die_lock);
         bust_spinlocks(1);
 #ifdef CONFIG_PMAC_BACKLIGHT
-        if (machine_is(powermac)) {
-                set_backlight_enable(1);
-                set_backlight_level(BACKLIGHT_MAX);
+        mutex_lock(&pmac_backlight_mutex);
+        if (machine_is(powermac) && pmac_backlight) {
+                struct backlight_properties *props;
+
+                down(&pmac_backlight->sem);
+                props = pmac_backlight->props;
+                props->brightness = props->max_brightness;
+                props->power = FB_BLANK_UNBLANK;
+                props->update_status(pmac_backlight);
+                up(&pmac_backlight->sem);
         }
+        mutex_unlock(&pmac_backlight_mutex);
 #endif
         printk("Oops: %s, sig: %ld [#%d]\n", str, err, ++die_counter);
 #ifdef CONFIG_PREEMPT
diff --git a/arch/powerpc/platforms/cell/cbe_regs.c b/arch/powerpc/platforms/cell/cbe_regs.c
index 2dfde61c8412..ce696c1cca75 100644
--- a/arch/powerpc/platforms/cell/cbe_regs.c
+++ b/arch/powerpc/platforms/cell/cbe_regs.c
@@ -89,7 +89,7 @@ void __init cbe_regs_init(void)
         struct device_node *cpu;
 
         /* Build local fast map of CPUs */
-        for_each_cpu(i)
+        for_each_possible_cpu(i)
                 cbe_thread_map[i].cpu_node = of_get_cpu_node(i, NULL);
 
         /* Find maps for each device tree CPU */
@@ -110,7 +110,7 @@ void __init cbe_regs_init(void)
                         return;
                 }
                 map->cpu_node = cpu;
-                for_each_cpu(i)
+                for_each_possible_cpu(i)
                         if (cbe_thread_map[i].cpu_node == cpu)
                                 cbe_thread_map[i].regs = map;
 
diff --git a/arch/powerpc/platforms/cell/interrupt.c b/arch/powerpc/platforms/cell/interrupt.c
index f4e2d8805c9e..1bbf822b4efc 100644
--- a/arch/powerpc/platforms/cell/interrupt.c
+++ b/arch/powerpc/platforms/cell/interrupt.c
@@ -180,7 +180,7 @@ static int setup_iic_hardcoded(void)
         unsigned long regs;
         struct iic *iic;
 
-        for_each_cpu(cpu) {
+        for_each_possible_cpu(cpu) {
                 iic = &per_cpu(iic, cpu);
                 nodeid = cpu/2;
 
diff --git a/arch/powerpc/platforms/powermac/backlight.c b/arch/powerpc/platforms/powermac/backlight.c
index 8be2f7d071f0..498b042e1837 100644
--- a/arch/powerpc/platforms/powermac/backlight.c
+++ b/arch/powerpc/platforms/powermac/backlight.c
@@ -3,200 +3,148 @@
  * Contains support for the backlight.
  *
  *   Copyright (C) 2000 Benjamin Herrenschmidt
+ *   Copyright (C) 2006 Michael Hanselmann <linux-kernel@hansmi.ch>
  *
  */
 
 #include <linux/config.h>
 #include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/stddef.h>
-#include <linux/reboot.h>
-#include <linux/nvram.h>
-#include <linux/console.h>
-#include <asm/sections.h>
-#include <asm/ptrace.h>
-#include <asm/io.h>
-#include <asm/pgtable.h>
-#include <asm/system.h>
+#include <linux/fb.h>
+#include <linux/backlight.h>
 #include <asm/prom.h>
-#include <asm/machdep.h>
-#include <asm/nvram.h>
 #include <asm/backlight.h>
 
-#include <linux/adb.h>
-#include <linux/pmu.h>
+#define OLD_BACKLIGHT_MAX 15
 
-static struct backlight_controller *backlighter;
-static void* backlighter_data;
-static int backlight_autosave;
-static int backlight_level = BACKLIGHT_MAX;
-static int backlight_enabled = 1;
-static int backlight_req_level = -1;
-static int backlight_req_enable = -1;
+/* Protect the pmac_backlight variable */
+DEFINE_MUTEX(pmac_backlight_mutex);
 
-static void backlight_callback(void *);
-static DECLARE_WORK(backlight_work, backlight_callback, NULL);
+/* Main backlight storage
+ *
+ * Backlight drivers in this variable are required to have the "props"
+ * attribute set and to have an update_status function.
+ *
+ * We can only store one backlight here, but since Apple laptops have only one
+ * internal display, it doesn't matter. Other backlight drivers can be used
+ * independently.
+ *
+ * Lock ordering:
+ * pmac_backlight_mutex (global, main backlight)
+ *   pmac_backlight->sem (backlight class)
+ */
+struct backlight_device *pmac_backlight;
 
-void register_backlight_controller(struct backlight_controller *ctrler,
-                                          void *data, char *type)
+int pmac_has_backlight_type(const char *type)
 {
-        struct device_node* bk_node;
-        char *prop;
-        int valid = 0;
-
-        /* There's already a matching controller, bail out */
-        if (backlighter != NULL)
-                return;
-
-        bk_node = find_devices("backlight");
-
-#ifdef CONFIG_ADB_PMU
-        /* Special case for the old PowerBook since I can't test on it */
-        backlight_autosave = machine_is_compatible("AAPL,3400/2400")
-                || machine_is_compatible("AAPL,3500");
-        if ((backlight_autosave
-             || machine_is_compatible("AAPL,PowerBook1998")
-             || machine_is_compatible("PowerBook1,1"))
-            && !strcmp(type, "pmu"))
-                valid = 1;
-#endif
+        struct device_node* bk_node = find_devices("backlight");
+
         if (bk_node) {
-                prop = get_property(bk_node, "backlight-control", NULL);
-                if (prop && !strncmp(prop, type, strlen(type)))
-                        valid = 1;
-        }
-        if (!valid)
-                return;
-        backlighter = ctrler;
-        backlighter_data = data;
-
-        if (bk_node && !backlight_autosave)
-                prop = get_property(bk_node, "bklt", NULL);
-        else
-                prop = NULL;
-        if (prop) {
-                backlight_level = ((*prop)+1) >> 1;
-                if (backlight_level > BACKLIGHT_MAX)
-                        backlight_level = BACKLIGHT_MAX;
+                char *prop = get_property(bk_node, "backlight-control", NULL);
+                if (prop && strncmp(prop, type, strlen(type)) == 0)
+                        return 1;
         }
 
-#ifdef CONFIG_ADB_PMU
-        if (backlight_autosave) {
-                struct adb_request req;
-                pmu_request(&req, NULL, 2, 0xd9, 0);
-                while (!req.complete)
-                        pmu_poll();
-                backlight_level = req.reply[0] >> 4;
-        }
-#endif
-        acquire_console_sem();
-        if (!backlighter->set_enable(1, backlight_level, data))
-                backlight_enabled = 1;
-        release_console_sem();
-
-        printk(KERN_INFO "Registered \"%s\" backlight controller,"
-               "level: %d/15\n", type, backlight_level);
+        return 0;
 }
-EXPORT_SYMBOL(register_backlight_controller);
 
-void unregister_backlight_controller(struct backlight_controller
-                                            *ctrler, void *data)
+int pmac_backlight_curve_lookup(struct fb_info *info, int value)
 {
-        /* We keep the current backlight level (for now) */
-        if (ctrler == backlighter && data == backlighter_data)
-                backlighter = NULL;
+        int level = (FB_BACKLIGHT_LEVELS - 1);
+
+        if (info && info->bl_dev) {
+                int i, max = 0;
+
+                /* Look for biggest value */
+                for (i = 0; i < FB_BACKLIGHT_LEVELS; i++)
+                        max = max((int)info->bl_curve[i], max);
+
+                /* Look for nearest value */
+                for (i = 0; i < FB_BACKLIGHT_LEVELS; i++) {
+                        int diff = abs(info->bl_curve[i] - value);
+                        if (diff < max) {
+                                max = diff;
+                                level = i;
+                        }
+                }
+
+        }
+
+        return level;
 }
-EXPORT_SYMBOL(unregister_backlight_controller);
 
-static int __set_backlight_enable(int enable)
+static void pmac_backlight_key(int direction)
 {
-        int rc;
-
-        if (!backlighter)
-                return -ENODEV;
-        acquire_console_sem();
-        rc = backlighter->set_enable(enable, backlight_level,
-                                     backlighter_data);
-        if (!rc)
-                backlight_enabled = enable;
-        release_console_sem();
-        return rc;
+        mutex_lock(&pmac_backlight_mutex);
+        if (pmac_backlight) {
+                struct backlight_properties *props;
+                int brightness;
+
+                down(&pmac_backlight->sem);
+                props = pmac_backlight->props;
+
+                brightness = props->brightness +
+                        ((direction?-1:1) * (props->max_brightness / 15));
+
+                if (brightness < 0)
+                        brightness = 0;
+                else if (brightness > props->max_brightness)
+                        brightness = props->max_brightness;
+
+                props->brightness = brightness;
+                props->update_status(pmac_backlight);
+
+                up(&pmac_backlight->sem);
+        }
+        mutex_unlock(&pmac_backlight_mutex);
 }
-int set_backlight_enable(int enable)
+
+void pmac_backlight_key_up()
 {
-        if (!backlighter)
-                return -ENODEV;
-        backlight_req_enable = enable;
-        schedule_work(&backlight_work);
-        return 0;
+        pmac_backlight_key(0);
 }
 
-EXPORT_SYMBOL(set_backlight_enable);
-
-int get_backlight_enable(void)
+void pmac_backlight_key_down()
 {
-        if (!backlighter)
-                return -ENODEV;
-        return backlight_enabled;
+        pmac_backlight_key(1);
 }
-EXPORT_SYMBOL(get_backlight_enable);
 
-static int __set_backlight_level(int level)
+int pmac_backlight_set_legacy_brightness(int brightness)
 {
-        int rc = 0;
-
-        if (!backlighter)
-                return -ENODEV;
-        if (level < BACKLIGHT_MIN)
-                level = BACKLIGHT_OFF;
-        if (level > BACKLIGHT_MAX)
-                level = BACKLIGHT_MAX;
-        acquire_console_sem();
-        if (backlight_enabled)
-                rc = backlighter->set_level(level, backlighter_data);
-        if (!rc)
-                backlight_level = level;
-        release_console_sem();
-        if (!rc && !backlight_autosave) {
-                level <<=1;
-                if (level & 0x10)
-                        level |= 0x01;
-                // -- todo: save to property "bklt"
+        int error = -ENXIO;
+
+        mutex_lock(&pmac_backlight_mutex);
+        if (pmac_backlight) {
+                struct backlight_properties *props;
+
+                down(&pmac_backlight->sem);
+                props = pmac_backlight->props;
+                props->brightness = brightness *
+                        props->max_brightness / OLD_BACKLIGHT_MAX;
+                props->update_status(pmac_backlight);
+                up(&pmac_backlight->sem);
+
+                error = 0;
         }
-        return rc;
+        mutex_unlock(&pmac_backlight_mutex);
+
+        return error;
 }
-int set_backlight_level(int level)
+
+int pmac_backlight_get_legacy_brightness()
 {
-        if (!backlighter)
-                return -ENODEV;
-        backlight_req_level = level;
-        schedule_work(&backlight_work);
-        return 0;
-}
+        int result = -ENXIO;
 
-EXPORT_SYMBOL(set_backlight_level);
+        mutex_lock(&pmac_backlight_mutex);
+        if (pmac_backlight) {
+                struct backlight_properties *props;
 
-int get_backlight_level(void)
-{
-        if (!backlighter)
-                return -ENODEV;
-        return backlight_level;
-}
-EXPORT_SYMBOL(get_backlight_level);
+                down(&pmac_backlight->sem);
+                props = pmac_backlight->props;
+                result = props->brightness *
+                        OLD_BACKLIGHT_MAX / props->max_brightness;
+                up(&pmac_backlight->sem);
+        }
+        mutex_unlock(&pmac_backlight_mutex);
 
-static void backlight_callback(void *dummy)
-{
-        int level, enable;
-
-        do {
-                level = backlight_req_level;
-                enable = backlight_req_enable;
-                mb();
-
-                if (level >= 0)
-                        __set_backlight_level(level);
-                if (enable >= 0)
-                        __set_backlight_enable(enable);
-        } while(cmpxchg(&backlight_req_level, level, -1) != level ||
-                cmpxchg(&backlight_req_enable, enable, -1) != enable);
+        return result;
 }
diff --git a/arch/powerpc/xmon/xmon.c b/arch/powerpc/xmon/xmon.c
index 4735b41c113c..0741df8c41b7 100644
--- a/arch/powerpc/xmon/xmon.c
+++ b/arch/powerpc/xmon/xmon.c
@@ -26,9 +26,6 @@
 #include <asm/prom.h>
 #include <asm/machdep.h>
 #include <asm/xmon.h>
-#ifdef CONFIG_PMAC_BACKLIGHT
-#include <asm/backlight.h>
-#endif
 #include <asm/processor.h>
 #include <asm/pgtable.h>
 #include <asm/mmu.h>
diff --git a/arch/ppc/kernel/pci.c b/arch/ppc/kernel/pci.c
index 809673a36f7a..d20accf9650d 100644
--- a/arch/ppc/kernel/pci.c
+++ b/arch/ppc/kernel/pci.c
@@ -1032,7 +1032,6 @@ int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
                 return -EINVAL;
 
         vma->vm_pgoff = offset >> PAGE_SHIFT;
-        vma->vm_flags |= VM_SHM | VM_LOCKED | VM_IO;
         vma->vm_page_prot = __pci_mmap_set_pgprot(dev, rp,
                                                   vma->vm_page_prot,
                                                   mmap_state, write_combine);
diff --git a/arch/s390/kernel/setup.c b/arch/s390/kernel/setup.c
index 0a04e4a564b2..b282034452a4 100644
--- a/arch/s390/kernel/setup.c
+++ b/arch/s390/kernel/setup.c
@@ -47,6 +47,7 @@
 #include <asm/irq.h>
 #include <asm/page.h>
 #include <asm/ptrace.h>
+#include <asm/sections.h>
 
 /*
  * Machine setup..
@@ -66,11 +67,6 @@ unsigned long __initdata zholes_size[MAX_NR_ZONES];
 static unsigned long __initdata memory_end;
 
 /*
- * Setup options
- */
-extern int _text,_etext, _edata, _end;
-
-/*
  * This is set up by the setup-routine at boot-time
  * for S390 need to find out, what we have to setup
  * using address 0x10400 ...
@@ -80,15 +76,11 @@ extern int _text,_etext, _edata, _end;
 
 static struct resource code_resource = {
         .name  = "Kernel code",
-        .start = (unsigned long) &_text,
-        .end = (unsigned long) &_etext - 1,
         .flags = IORESOURCE_BUSY | IORESOURCE_MEM,
 };
 
 static struct resource data_resource = {
         .name = "Kernel data",
-        .start = (unsigned long) &_etext,
-        .end = (unsigned long) &_edata - 1,
         .flags = IORESOURCE_BUSY | IORESOURCE_MEM,
 };
 
@@ -422,6 +414,11 @@ setup_resources(void)
         struct resource *res;
         int i;
 
+        code_resource.start = (unsigned long) &_text;
+        code_resource.end = (unsigned long) &_etext - 1;
+        data_resource.start = (unsigned long) &_etext;
+        data_resource.end = (unsigned long) &_edata - 1;
+
         for (i = 0; i < MEMORY_CHUNKS && memory_chunk[i].size > 0; i++) {
                 res = alloc_bootmem_low(sizeof(struct resource));
                 res->flags = IORESOURCE_BUSY | IORESOURCE_MEM;
diff --git a/arch/um/drivers/mconsole_kern.c b/arch/um/drivers/mconsole_kern.c
index 6d7173fc55a3..79149314ed04 100644
--- a/arch/um/drivers/mconsole_kern.c
+++ b/arch/um/drivers/mconsole_kern.c
@@ -300,8 +300,6 @@ void mconsole_reboot(struct mc_request *req)
         machine_restart(NULL);
 }
 
-extern void ctrl_alt_del(void);
-
 void mconsole_cad(struct mc_request *req)
 {
         mconsole_reply(req, "", 0, 0);
diff --git a/arch/um/include/sysdep-x86_64/syscalls.h b/arch/um/include/sysdep-x86_64/syscalls.h
index e06f83e80f4a..5e86aa047b2b 100644
--- a/arch/um/include/sysdep-x86_64/syscalls.h
+++ b/arch/um/include/sysdep-x86_64/syscalls.h
@@ -12,8 +12,6 @@
 
 typedef long syscall_handler_t(void);
 
-extern syscall_handler_t *ia32_sys_call_table[];
-
 extern syscall_handler_t *sys_call_table[];
 
 #define EXECUTE_SYSCALL(syscall, regs) \
diff --git a/arch/x86_64/kernel/setup.c b/arch/x86_64/kernel/setup.c
index b8d5116d7371..fdb82658b1a1 100644
--- a/arch/x86_64/kernel/setup.c
+++ b/arch/x86_64/kernel/setup.c
@@ -823,7 +823,7 @@ void __init setup_arch(char **cmdline_p)
 #endif
 #ifdef CONFIG_KEXEC
         if (crashk_res.start != crashk_res.end) {
-                reserve_bootmem(crashk_res.start,
+                reserve_bootmem_generic(crashk_res.start,
                         crashk_res.end - crashk_res.start + 1);
         }
 #endif
diff --git a/arch/xtensa/kernel/pci.c b/arch/xtensa/kernel/pci.c
index de19501aa809..c6f471b9eaa0 100644
--- a/arch/xtensa/kernel/pci.c
+++ b/arch/xtensa/kernel/pci.c
@@ -350,17 +350,6 @@ __pci_mmap_make_offset(struct pci_dev *dev, struct vm_area_struct *vma,
 }
 
 /*
- * Set vm_flags of VMA, as appropriate for this architecture, for a pci device
- * mapping.
- */
-static __inline__ void
-__pci_mmap_set_flags(struct pci_dev *dev, struct vm_area_struct *vma,
-                     enum pci_mmap_state mmap_state)
-{
-        vma->vm_flags |= VM_SHM | VM_LOCKED | VM_IO;
-}
-
-/*
  * Set vm_page_prot of VMA, as appropriate for this architecture, for a pci
  * device mapping.
  */
@@ -399,7 +388,6 @@ int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
         if (ret < 0)
                 return ret;
 
-        __pci_mmap_set_flags(dev, vma, mmap_state);
         __pci_mmap_set_pgprot(dev, vma, mmap_state, write_combine);
 
         ret = io_remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
diff --git a/drivers/block/amiflop.c b/drivers/block/amiflop.c
index 2a8af685926f..2641597c6549 100644
--- a/drivers/block/amiflop.c
+++ b/drivers/block/amiflop.c
@@ -64,6 +64,7 @@
 #include <linux/buffer_head.h>
 #include <linux/blkdev.h>
 #include <linux/elevator.h>
+#include <linux/interrupt.h>
 
 #include <asm/setup.h>
 #include <asm/uaccess.h>
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 25c3c4a5da81..39b0f53186e8 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -34,7 +34,7 @@
 #include <linux/blkpg.h>
 #include <linux/timer.h>
 #include <linux/proc_fs.h>
-#include <linux/init.h> 
+#include <linux/init.h>
 #include <linux/hdreg.h>
 #include <linux/spinlock.h>
 #include <linux/compat.h>
@@ -64,143 +64,129 @@ MODULE_LICENSE("GPL");
 
 /* define the PCI info for the cards we can control */
 static const struct pci_device_id cciss_pci_device_id[] = {
-        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS,
-                        0x0E11, 0x4070, 0, 0, 0},
-        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
-                        0x0E11, 0x4080, 0, 0, 0},
-        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
-                        0x0E11, 0x4082, 0, 0, 0},
-        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
-                        0x0E11, 0x4083, 0, 0, 0},
-        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
-                0x0E11, 0x409A, 0, 0, 0},
-        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
-                0x0E11, 0x409B, 0, 0, 0},
-        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
-                0x0E11, 0x409C, 0, 0, 0},
-        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
-                0x0E11, 0x409D, 0, 0, 0},
-        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
-                0x0E11, 0x4091, 0, 0, 0},
-        { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSA,
-                0x103C, 0x3225, 0, 0, 0},
-        { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
-                0x103c, 0x3223, 0, 0, 0},
-        { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
-                0x103c, 0x3234, 0, 0, 0},
-        { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
-                0x103c, 0x3235, 0, 0, 0},
-        { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
-                0x103c, 0x3211, 0, 0, 0},
-        { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
-                0x103c, 0x3212, 0, 0, 0},
-        { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
-                0x103c, 0x3213, 0, 0, 0},
-        { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
-                0x103c, 0x3214, 0, 0, 0},
-        { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
-                0x103c, 0x3215, 0, 0, 0},
+        {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS,  0x0E11, 0x4070},
+        {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4080},
+        {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4082},
+        {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB, 0x0E11, 0x4083},
+        {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x4091},
+        {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409A},
+        {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409B},
+        {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409C},
+        {PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC, 0x0E11, 0x409D},
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSA,     0x103C, 0x3225},
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3223},
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3234},
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3235},
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3211},
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3212},
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3213},
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3214},
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSD,     0x103C, 0x3215},
         {0,}
 };
-MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);
 
-#define NR_PRODUCTS ARRAY_SIZE(products)
+MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);
 
 /*  board_id = Subsystem Device ID & Vendor ID
  *  product = Marketing Name for the board
- *  access = Address of the struct of function pointers 
+ *  access = Address of the struct of function pointers
  */
 static struct board_type products[] = {
-        { 0x40700E11, "Smart Array 5300", &SA5_access },
-        { 0x40800E11, "Smart Array 5i", &SA5B_access},
-        { 0x40820E11, "Smart Array 532", &SA5B_access},
-        { 0x40830E11, "Smart Array 5312", &SA5B_access},
-        { 0x409A0E11, "Smart Array 641", &SA5_access},
-        { 0x409B0E11, "Smart Array 642", &SA5_access},
-        { 0x409C0E11, "Smart Array 6400", &SA5_access},
-        { 0x409D0E11, "Smart Array 6400 EM", &SA5_access},
-        { 0x40910E11, "Smart Array 6i", &SA5_access},
-        { 0x3225103C, "Smart Array P600", &SA5_access},
-        { 0x3223103C, "Smart Array P800", &SA5_access},
-        { 0x3234103C, "Smart Array P400", &SA5_access},
-        { 0x3235103C, "Smart Array P400i", &SA5_access},
-        { 0x3211103C, "Smart Array E200i", &SA5_access},
-        { 0x3212103C, "Smart Array E200", &SA5_access},
-        { 0x3213103C, "Smart Array E200i", &SA5_access},
-        { 0x3214103C, "Smart Array E200i", &SA5_access},
-        { 0x3215103C, "Smart Array E200i", &SA5_access},
+        {0x40700E11, "Smart Array 5300", &SA5_access},
+        {0x40800E11, "Smart Array 5i", &SA5B_access},
+        {0x40820E11, "Smart Array 532", &SA5B_access},
+        {0x40830E11, "Smart Array 5312", &SA5B_access},
+        {0x409A0E11, "Smart Array 641", &SA5_access},
+        {0x409B0E11, "Smart Array 642", &SA5_access},
+        {0x409C0E11, "Smart Array 6400", &SA5_access},
+        {0x409D0E11, "Smart Array 6400 EM", &SA5_access},
+        {0x40910E11, "Smart Array 6i", &SA5_access},
+        {0x3225103C, "Smart Array P600", &SA5_access},
+        {0x3223103C, "Smart Array P800", &SA5_access},
+        {0x3234103C, "Smart Array P400", &SA5_access},
+        {0x3235103C, "Smart Array P400i", &SA5_access},
+        {0x3211103C, "Smart Array E200i", &SA5_access},
+        {0x3212103C, "Smart Array E200", &SA5_access},
+        {0x3213103C, "Smart Array E200i", &SA5_access},
+        {0x3214103C, "Smart Array E200i", &SA5_access},
+        {0x3215103C, "Smart Array E200i", &SA5_access},
 };
 
-/* How long to wait (in millesconds) for board to go into simple mode */
-#define MAX_CONFIG_WAIT 30000 
+/* How long to wait (in milliseconds) for board to go into simple mode */
+#define MAX_CONFIG_WAIT 30000
 #define MAX_IOCTL_CONFIG_WAIT 1000
 
 /*define how many times we will try a command because of bus resets */
 #define MAX_CMD_RETRIES 3
 
 #define READ_AHEAD       1024
-#define NR_CMDS          384 /* #commands that can be outstanding */
+#define NR_CMDS          384    /* #commands that can be outstanding */
 #define MAX_CTLR        32
 
 /* Originally cciss driver only supports 8 major numbers */
 #define MAX_CTLR_ORIG   8
 
-
 static ctlr_info_t *hba[MAX_CTLR];
 
 static void do_cciss_request(request_queue_t *q);
 static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs);
 static int cciss_open(struct inode *inode, struct file *filep);
 static int cciss_release(struct inode *inode, struct file *filep);
-static int cciss_ioctl(struct inode *inode, struct file *filep, 
-                unsigned int cmd, unsigned long arg);
+static int cciss_ioctl(struct inode *inode, struct file *filep,
+                       unsigned int cmd, unsigned long arg);
 static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo);
 
 static int revalidate_allvol(ctlr_info_t *host);
 static int cciss_revalidate(struct gendisk *disk);
 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk);
-static int deregister_disk(struct gendisk *disk, drive_info_struct *drv, int clear_all);
+static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
+                           int clear_all);
 
 static void cciss_read_capacity(int ctlr, int logvol, ReadCapdata_struct *buf,
-        int withirq, unsigned int *total_size, unsigned int *block_size);
-static void cciss_geometry_inquiry(int ctlr, int logvol,
-                        int withirq, unsigned int total_size,
-                        unsigned int block_size, InquiryData_struct *inq_buff,
-                        drive_info_struct *drv);
+                                int withirq, unsigned int *total_size,
+                                unsigned int *block_size);
+static void cciss_geometry_inquiry(int ctlr, int logvol, int withirq,
+                                   unsigned int total_size,
+                                   unsigned int block_size,
+                                   InquiryData_struct *inq_buff,
+                                   drive_info_struct *drv);
 static void cciss_getgeometry(int cntl_num);
-static void __devinit cciss_interrupt_mode(ctlr_info_t *, struct pci_dev *, __u32);
-static void start_io( ctlr_info_t *h);
-static int sendcmd( __u8 cmd, int ctlr, void *buff, size_t size,
-        unsigned int use_unit_num, unsigned int log_unit, __u8 page_code,
-        unsigned char *scsi3addr, int cmd_type);
-static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
-        unsigned int use_unit_num, unsigned int log_unit, __u8  page_code,
-        int cmd_type);
+static void __devinit cciss_interrupt_mode(ctlr_info_t *, struct pci_dev *,
+                                           __u32);
+static void start_io(ctlr_info_t *h);
+static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size,
+                   unsigned int use_unit_num, unsigned int log_unit,
+                   __u8 page_code, unsigned char *scsi3addr, int cmd_type);
+static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
+                           unsigned int use_unit_num, unsigned int log_unit,
+                           __u8 page_code, int cmd_type);
 
 static void fail_all_cmds(unsigned long ctlr);
 
 #ifdef CONFIG_PROC_FS
-static int cciss_proc_get_info(char *buffer, char **start, off_t offset, 
-                int length, int *eof, void *data);
+static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
+                               int length, int *eof, void *data);
 static void cciss_procinit(int i);
 #else
-static void cciss_procinit(int i) {}
-#endif /* CONFIG_PROC_FS */
+static void cciss_procinit(int i)
+{
+}
+#endif                          /* CONFIG_PROC_FS */
 
 #ifdef CONFIG_COMPAT
 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg);
 #endif
 
-static struct block_device_operations cciss_fops  = {
-        .owner          = THIS_MODULE,
-        .open           = cciss_open, 
-        .release        = cciss_release,
-        .ioctl          = cciss_ioctl,
-        .getgeo         = cciss_getgeo,
+static struct block_device_operations cciss_fops = {
+        .owner = THIS_MODULE,
+        .open = cciss_open,
+        .release = cciss_release,
+        .ioctl = cciss_ioctl,
+        .getgeo = cciss_getgeo,
 #ifdef CONFIG_COMPAT
-        .compat_ioctl   = cciss_compat_ioctl,
+        .compat_ioctl = cciss_compat_ioctl,
 #endif
-        .revalidate_disk= cciss_revalidate,
+        .revalidate_disk = cciss_revalidate,
 };
 
 /*
@@ -208,28 +194,29 @@ static struct block_device_operations cciss_fops  = {
  */
 static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c)
 {
-        if (*Qptr == NULL) {
-                *Qptr = c;
-                c->next = c->prev = c;
-        } else {
-                c->prev = (*Qptr)->prev;
-                c->next = (*Qptr);
-                (*Qptr)->prev->next = c;
-                (*Qptr)->prev = c;
-        }
+        if (*Qptr == NULL) {
+                *Qptr = c;
+                c->next = c->prev = c;
+        } else {
+                c->prev = (*Qptr)->prev;
+                c->next = (*Qptr);
+                (*Qptr)->prev->next = c;
+                (*Qptr)->prev = c;
+        }
 }
 
-static inline CommandList_struct *removeQ(CommandList_struct **Qptr, 
-                                                CommandList_struct *c)
+static inline CommandList_struct *removeQ(CommandList_struct **Qptr,
+                                          CommandList_struct *c)
 {
-        if (c && c->next != c) {
-                if (*Qptr == c) *Qptr = c->next;
-                c->prev->next = c->next;
-                c->next->prev = c->prev;
-        } else {
-                *Qptr = NULL;
-        }
-        return c;
+        if (c && c->next != c) {
+                if (*Qptr == c)
+                        *Qptr = c->next;
+                c->prev->next = c->next;
+                c->next->prev = c->prev;
+        } else {
+                *Qptr = NULL;
+        }
+        return c;
 }
 
 #include "cciss_scsi.c"         /* For SCSI tape support */
@@ -242,23 +229,24 @@ static inline CommandList_struct *removeQ(CommandList_struct **Qptr,
 #define ENG_GIG 1000000000
 #define ENG_GIG_FACTOR (ENG_GIG/512)
 #define RAID_UNKNOWN 6
-static const char *raid_label[] = {"0","4","1(1+0)","5","5+1","ADG",
-                                           "UNKNOWN"};
+static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG",
+        "UNKNOWN"
+};
 
 static struct proc_dir_entry *proc_cciss;
 
-static int cciss_proc_get_info(char *buffer, char **start, off_t offset, 
-                int length, int *eof, void *data)
+static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
+                               int length, int *eof, void *data)
 {
-        off_t pos = 0;
-        off_t len = 0;
-        int size, i, ctlr;
-        ctlr_info_t *h = (ctlr_info_t*)data;
-        drive_info_struct *drv;
+        off_t pos = 0;
+        off_t len = 0;
+        int size, i, ctlr;
+        ctlr_info_t *h = (ctlr_info_t *) data;
+        drive_info_struct *drv;
         unsigned long flags;
-        sector_t vol_sz, vol_sz_frac;
+        sector_t vol_sz, vol_sz_frac;
 
-        ctlr = h->ctlr;
+        ctlr = h->ctlr;
 
         /* prevent displaying bogus info during configuration
          * or deconfiguration of a logical volume
@@ -266,35 +254,35 @@ static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
         if (h->busy_configuring) {
                 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
-        return -EBUSY;
+                return -EBUSY;
         }
         h->busy_configuring = 1;
         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
 
-        size = sprintf(buffer, "%s: HP %s Controller\n"
-                "Board ID: 0x%08lx\n"
-                "Firmware Version: %c%c%c%c\n"
-                "IRQ: %d\n"
-                "Logical drives: %d\n"
-                "Current Q depth: %d\n"
-                "Current # commands on controller: %d\n"
-                "Max Q depth since init: %d\n"
-                "Max # commands on controller since init: %d\n"
-                "Max SG entries since init: %d\n\n",
-                h->devname,
-                h->product_name,
-                (unsigned long)h->board_id,
-                h->firm_ver[0], h->firm_ver[1], h->firm_ver[2], h->firm_ver[3],
-                (unsigned int)h->intr[SIMPLE_MODE_INT],
-                h->num_luns, 
-                h->Qdepth, h->commands_outstanding,
-                h->maxQsinceinit, h->max_outstanding, h->maxSG);
-
-        pos += size; len += size;
+        size = sprintf(buffer, "%s: HP %s Controller\n"
+                       "Board ID: 0x%08lx\n"
+                       "Firmware Version: %c%c%c%c\n"
+                       "IRQ: %d\n"
+                       "Logical drives: %d\n"
+                       "Current Q depth: %d\n"
+                       "Current # commands on controller: %d\n"
+                       "Max Q depth since init: %d\n"
+                       "Max # commands on controller since init: %d\n"
+                       "Max SG entries since init: %d\n\n",
+                       h->devname,
+                       h->product_name,
+                       (unsigned long)h->board_id,
+                       h->firm_ver[0], h->firm_ver[1], h->firm_ver[2],
+                       h->firm_ver[3], (unsigned int)h->intr[SIMPLE_MODE_INT],
+                       h->num_luns, h->Qdepth, h->commands_outstanding,
+                       h->maxQsinceinit, h->max_outstanding, h->maxSG);
+
+        pos += size;
+        len += size;
         cciss_proc_tape_report(ctlr, buffer, &pos, &len);
-        for(i=0; i<=h->highest_lun; i++) {
+        for (i = 0; i <= h->highest_lun; i++) {
 
-                drv = &h->drv[i];
+                drv = &h->drv[i];
                 if (drv->heads == 0)
                         continue;
 
@@ -305,25 +293,26 @@ static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
 
                 if (drv->raid_level > 5)
                         drv->raid_level = RAID_UNKNOWN;
-                size = sprintf(buffer+len, "cciss/c%dd%d:"
-                                "\t%4u.%02uGB\tRAID %s\n",
-                                ctlr, i, (int)vol_sz, (int)vol_sz_frac,
-                                raid_label[drv->raid_level]);
-                pos += size; len += size;
-        }
-
-        *eof = 1;
-        *start = buffer+offset;
-        len -= offset;
-        if (len>length)
-                len = length;
+                size = sprintf(buffer + len, "cciss/c%dd%d:"
+                               "\t%4u.%02uGB\tRAID %s\n",
+                               ctlr, i, (int)vol_sz, (int)vol_sz_frac,
+                               raid_label[drv->raid_level]);
+                pos += size;
+                len += size;
+        }
+
+        *eof = 1;
+        *start = buffer + offset;
+        len -= offset;
+        if (len > length)
+                len = length;
         h->busy_configuring = 0;
-        return len;
+        return len;
 }
 
-static int 
-cciss_proc_write(struct file *file, const char __user *buffer, 
-                        unsigned long count, void *data)
+static int
+cciss_proc_write(struct file *file, const char __user *buffer,
+                 unsigned long count, void *data)
 {
         unsigned char cmd[80];
         int len;
@@ -332,20 +321,23 @@ cciss_proc_write(struct file *file, const char __user *buffer,
         int rc;
 #endif
 
-        if (count > sizeof(cmd)-1) return -EINVAL;
-        if (copy_from_user(cmd, buffer, count)) return -EFAULT;
+        if (count > sizeof(cmd) - 1)
+                return -EINVAL;
+        if (copy_from_user(cmd, buffer, count))
+                return -EFAULT;
         cmd[count] = '\0';
         len = strlen(cmd);      // above 3 lines ensure safety
-        if (len && cmd[len-1] == '\n')
+        if (len && cmd[len - 1] == '\n')
                 cmd[--len] = '\0';
 #       ifdef CONFIG_CISS_SCSI_TAPE
-                if (strcmp("engage scsi", cmd)==0) {
-                        rc = cciss_engage_scsi(h->ctlr);
-                        if (rc != 0) return -rc;
-                        return count;
-                }
-                /* might be nice to have "disengage" too, but it's not 
-                   safely possible. (only 1 module use count, lock issues.) */
+        if (strcmp("engage scsi", cmd) == 0) {
+                rc = cciss_engage_scsi(h->ctlr);
+                if (rc != 0)
+                        return -rc;
+                return count;
+        }
+        /* might be nice to have "disengage" too, but it's not
+           safely possible. (only 1 module use count, lock issues.) */
 #       endif
         return -EINVAL;
 }
@@ -358,116 +350,113 @@ static void __devinit cciss_procinit(int i)
 {
         struct proc_dir_entry *pde;
 
-        if (proc_cciss == NULL) {
-                proc_cciss = proc_mkdir("cciss", proc_root_driver);
-                if (!proc_cciss) 
+        if (proc_cciss == NULL) {
+                proc_cciss = proc_mkdir("cciss", proc_root_driver);
+                if (!proc_cciss)
                         return;
-        }
+        }
 
-        pde = create_proc_read_entry(hba[i]->devname, 
-                S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH, 
-                proc_cciss, cciss_proc_get_info, hba[i]);
+        pde = create_proc_read_entry(hba[i]->devname,
+                                     S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH,
+                                     proc_cciss, cciss_proc_get_info, hba[i]);
         pde->write_proc = cciss_proc_write;
 }
-#endif /* CONFIG_PROC_FS */
+#endif                          /* CONFIG_PROC_FS */
 
-/* 
- * For operations that cannot sleep, a command block is allocated at init, 
+/*
+ * For operations that cannot sleep, a command block is allocated at init,
  * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
- * which ones are free or in use.  For operations that can wait for kmalloc 
- * to possible sleep, this routine can be called with get_from_pool set to 0. 
- * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was. 
- */ 
-static CommandList_struct * cmd_alloc(ctlr_info_t *h, int get_from_pool)
+ * which ones are free or in use.  For operations that can wait for kmalloc
+ * to possible sleep, this routine can be called with get_from_pool set to 0.
+ * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was.
+ */
+static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool)
 {
         CommandList_struct *c;
-        int i; 
+        int i;
         u64bit temp64;
         dma_addr_t cmd_dma_handle, err_dma_handle;
 
-        if (!get_from_pool)
-        {
-                c = (CommandList_struct *) pci_alloc_consistent(
-                        h->pdev, sizeof(CommandList_struct), &cmd_dma_handle); 
-                if(c==NULL)
-                        return NULL;
+        if (!get_from_pool) {
+                c = (CommandList_struct *) pci_alloc_consistent(h->pdev,
+                        sizeof(CommandList_struct), &cmd_dma_handle);
+                if (c == NULL)
+                        return NULL;
                 memset(c, 0, sizeof(CommandList_struct));
 
                 c->cmdindex = -1;
 
-                c->err_info = (ErrorInfo_struct *)pci_alloc_consistent(
-                                        h->pdev, sizeof(ErrorInfo_struct), 
-                                        &err_dma_handle);
-        
-                if (c->err_info == NULL)
-                {
-                        pci_free_consistent(h->pdev, 
+                c->err_info = (ErrorInfo_struct *)
+                    pci_alloc_consistent(h->pdev, sizeof(ErrorInfo_struct),
+                            &err_dma_handle);
+
+                if (c->err_info == NULL) {
+                        pci_free_consistent(h->pdev,
                                 sizeof(CommandList_struct), c, cmd_dma_handle);
                         return NULL;
                 }
                 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
-        } else /* get it out of the controllers pool */ 
-        {
-                do {
-                        i = find_first_zero_bit(h->cmd_pool_bits, NR_CMDS);
-                        if (i == NR_CMDS)
-                                return NULL;
-                } while(test_and_set_bit(i & (BITS_PER_LONG - 1), h->cmd_pool_bits+(i/BITS_PER_LONG)) != 0);
+        } else {                /* get it out of the controllers pool */
+
+                do {
+                        i = find_first_zero_bit(h->cmd_pool_bits, NR_CMDS);
+                        if (i == NR_CMDS)
+                                return NULL;
+                } while (test_and_set_bit
+                         (i & (BITS_PER_LONG - 1),
+                          h->cmd_pool_bits + (i / BITS_PER_LONG)) != 0);
 #ifdef CCISS_DEBUG
                 printk(KERN_DEBUG "cciss: using command buffer %d\n", i);
 #endif
-                c = h->cmd_pool + i;
+                c = h->cmd_pool + i;
                 memset(c, 0, sizeof(CommandList_struct));
-                cmd_dma_handle = h->cmd_pool_dhandle 
-                                        + i*sizeof(CommandList_struct);
+                cmd_dma_handle = h->cmd_pool_dhandle
+                    + i * sizeof(CommandList_struct);
                 c->err_info = h->errinfo_pool + i;
                 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
-                err_dma_handle = h->errinfo_pool_dhandle 
-                                        + i*sizeof(ErrorInfo_struct);
-                h->nr_allocs++;
+                err_dma_handle = h->errinfo_pool_dhandle
+                    + i * sizeof(ErrorInfo_struct);
+                h->nr_allocs++;
 
                 c->cmdindex = i;
-        }
+        }
 
         c->busaddr = (__u32) cmd_dma_handle;
-        temp64.val = (__u64) err_dma_handle;    
+        temp64.val = (__u64) err_dma_handle;
         c->ErrDesc.Addr.lower = temp64.val32.lower;
         c->ErrDesc.Addr.upper = temp64.val32.upper;
         c->ErrDesc.Len = sizeof(ErrorInfo_struct);
-        
-        c->ctlr = h->ctlr;
-        return c;
-
 
+        c->ctlr = h->ctlr;
+        return c;
 }
 
-/* 
- * Frees a command block that was previously allocated with cmd_alloc(). 
+/*
+ * Frees a command block that was previously allocated with cmd_alloc().
  */
 static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool)
 {
         int i;
         u64bit temp64;
 
-        if( !got_from_pool)
-        { 
+        if (!got_from_pool) {
                 temp64.val32.lower = c->ErrDesc.Addr.lower;
                 temp64.val32.upper = c->ErrDesc.Addr.upper;
-                pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct), 
-                        c->err_info, (dma_addr_t) temp64.val);
-                pci_free_consistent(h->pdev, sizeof(CommandList_struct), 
-                        c, (dma_addr_t) c->busaddr);
-        } else 
-        {
+                pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct),
+                                    c->err_info, (dma_addr_t) temp64.val);
+                pci_free_consistent(h->pdev, sizeof(CommandList_struct),
+                                    c, (dma_addr_t) c->busaddr);
+        } else {
                 i = c - h->cmd_pool;
-                clear_bit(i&(BITS_PER_LONG-1), h->cmd_pool_bits+(i/BITS_PER_LONG));
-                h->nr_frees++;
-        }
+                clear_bit(i & (BITS_PER_LONG - 1),
+                          h->cmd_pool_bits + (i / BITS_PER_LONG));
+                h->nr_frees++;
+        }
 }
 
 static inline ctlr_info_t *get_host(struct gendisk *disk)
 {
-        return disk->queue->queuedata; 
+        return disk->queue->queuedata;
 }
 
 static inline drive_info_struct *get_drv(struct gendisk *disk)
@@ -485,7 +474,7 @@ static int cciss_open(struct inode *inode, struct file *filep)
 
 #ifdef CCISS_DEBUG
         printk(KERN_DEBUG "cciss_open %s\n", inode->i_bdev->bd_disk->disk_name);
-#endif /* CCISS_DEBUG */ 
+#endif                          /* CCISS_DEBUG */
 
         if (host->busy_initializing || drv->busy_configuring)
                 return -EBUSY;
@@ -498,10 +487,10 @@ static int cciss_open(struct inode *inode, struct file *filep)
          * for "raw controller".
          */
         if (drv->nr_blocks == 0) {
-                if (iminor(inode) != 0) {       /* not node 0? */
+                if (iminor(inode) != 0) {       /* not node 0? */
                         /* if not node 0 make sure it is a partition = 0 */
                         if (iminor(inode) & 0x0f) {
-                        return -ENXIO;
+                                return -ENXIO;
                                 /* if it is, make sure we have a LUN ID */
                         } else if (drv->LunID == 0) {
                                 return -ENXIO;
@@ -514,6 +503,7 @@ static int cciss_open(struct inode *inode, struct file *filep)
         host->usage_count++;
         return 0;
 }
+
 /*
  * Close.  Sync first.
  */
@@ -523,8 +513,9 @@ static int cciss_release(struct inode *inode, struct file *filep)
         drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
 
 #ifdef CCISS_DEBUG
-        printk(KERN_DEBUG "cciss_release %s\n", inode->i_bdev->bd_disk->disk_name);
-#endif /* CCISS_DEBUG */
+        printk(KERN_DEBUG "cciss_release %s\n",
+               inode->i_bdev->bd_disk->disk_name);
+#endif                          /* CCISS_DEBUG */
 
         drv->usage_count--;
         host->usage_count--;
@@ -542,8 +533,10 @@ static int do_ioctl(struct file *f, unsigned cmd, unsigned long arg)
         return ret;
 }
 
-static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long arg);
-static int cciss_ioctl32_big_passthru(struct file *f, unsigned cmd, unsigned long arg);
+static int cciss_ioctl32_passthru(struct file *f, unsigned cmd,
+                                  unsigned long arg);
+static int cciss_ioctl32_big_passthru(struct file *f, unsigned cmd,
+                                      unsigned long arg);
 
 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg)
 {
@@ -575,19 +568,26 @@ static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg)
         }
 }
 
-static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long arg)
+static int cciss_ioctl32_passthru(struct file *f, unsigned cmd,
+                                  unsigned long arg)
 {
         IOCTL32_Command_struct __user *arg32 =
-                (IOCTL32_Command_struct __user *) arg;
+            (IOCTL32_Command_struct __user *) arg;
         IOCTL_Command_struct arg64;
         IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
         int err;
         u32 cp;
 
         err = 0;
-        err |= copy_from_user(&arg64.LUN_info, &arg32->LUN_info, sizeof(arg64.LUN_info));
-        err |= copy_from_user(&arg64.Request, &arg32->Request, sizeof(arg64.Request));
-        err |= copy_from_user(&arg64.error_info, &arg32->error_info, sizeof(arg64.error_info));
+        err |=
+            copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
+                           sizeof(arg64.LUN_info));
+        err |=
+            copy_from_user(&arg64.Request, &arg32->Request,
+                           sizeof(arg64.Request));
+        err |=
+            copy_from_user(&arg64.error_info, &arg32->error_info,
+                           sizeof(arg64.error_info));
         err |= get_user(arg64.buf_size, &arg32->buf_size);
         err |= get_user(cp, &arg32->buf);
         arg64.buf = compat_ptr(cp);
@@ -596,28 +596,38 @@ static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long ar
         if (err)
                 return -EFAULT;
 
-        err = do_ioctl(f, CCISS_PASSTHRU, (unsigned long) p);
+        err = do_ioctl(f, CCISS_PASSTHRU, (unsigned long)p);
         if (err)
                 return err;
-        err |= copy_in_user(&arg32->error_info, &p->error_info, sizeof(arg32->error_info));
+        err |=
+            copy_in_user(&arg32->error_info, &p->error_info,
+                         sizeof(arg32->error_info));
         if (err)
                 return -EFAULT;
         return err;
 }
 
-static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd, unsigned long arg)
+static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd,
+                                      unsigned long arg)
 {
         BIG_IOCTL32_Command_struct __user *arg32 =
-                (BIG_IOCTL32_Command_struct __user *) arg;
+            (BIG_IOCTL32_Command_struct __user *) arg;
         BIG_IOCTL_Command_struct arg64;
-        BIG_IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
+        BIG_IOCTL_Command_struct __user *p =
+            compat_alloc_user_space(sizeof(arg64));
         int err;
         u32 cp;
 
         err = 0;
-        err |= copy_from_user(&arg64.LUN_info, &arg32->LUN_info, sizeof(arg64.LUN_info));
-        err |= copy_from_user(&arg64.Request, &arg32->Request, sizeof(arg64.Request));
-        err |= copy_from_user(&arg64.error_info, &arg32->error_info, sizeof(arg64.error_info));
+        err |=
+            copy_from_user(&arg64.LUN_info, &arg32->LUN_info,
+                           sizeof(arg64.LUN_info));
+        err |=
+            copy_from_user(&arg64.Request, &arg32->Request,
+                           sizeof(arg64.Request));
+        err |=
+            copy_from_user(&arg64.error_info, &arg32->error_info,
+                           sizeof(arg64.error_info));
         err |= get_user(arg64.buf_size, &arg32->buf_size);
         err |= get_user(arg64.malloc_size, &arg32->malloc_size);
         err |= get_user(cp, &arg32->buf);
@@ -625,12 +635,14 @@ static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd, unsigned
         err |= copy_to_user(p, &arg64, sizeof(arg64));
 
         if (err)
-                 return -EFAULT;
+                return -EFAULT;
 
-        err = do_ioctl(file, CCISS_BIG_PASSTHRU, (unsigned long) p);
+        err = do_ioctl(file, CCISS_BIG_PASSTHRU, (unsigned long)p);
         if (err)
                 return err;
-        err |= copy_in_user(&arg32->error_info, &p->error_info, sizeof(arg32->error_info));
+        err |=
+            copy_in_user(&arg32->error_info, &p->error_info,
+                         sizeof(arg32->error_info));
         if (err)
                 return -EFAULT;
         return err;
@@ -651,10 +663,10 @@ static int cciss_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 }
 
 /*
- * ioctl 
+ * ioctl
  */
-static int cciss_ioctl(struct inode *inode, struct file *filep, 
-                unsigned int cmd, unsigned long arg)
+static int cciss_ioctl(struct inode *inode, struct file *filep,
+                       unsigned int cmd, unsigned long arg)
 {
         struct block_device *bdev = inode->i_bdev;
         struct gendisk *disk = bdev->bd_disk;
@@ -665,171 +677,193 @@ static int cciss_ioctl(struct inode *inode, struct file *filep,
 
 #ifdef CCISS_DEBUG
         printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lx\n", cmd, arg);
-#endif /* CCISS_DEBUG */ 
-        
-        switch(cmd) {
+#endif                          /* CCISS_DEBUG */
+
+        switch (cmd) {
         case CCISS_GETPCIINFO:
-        {
-                cciss_pci_info_struct pciinfo;
-
-                if (!arg) return -EINVAL;
-                pciinfo.domain = pci_domain_nr(host->pdev->bus);
-                pciinfo.bus = host->pdev->bus->number;
-                pciinfo.dev_fn = host->pdev->devfn;
-                pciinfo.board_id = host->board_id;
-                if (copy_to_user(argp, &pciinfo,  sizeof( cciss_pci_info_struct )))
-                        return  -EFAULT;
-                return(0);
-        }       
+                {
+                        cciss_pci_info_struct pciinfo;
+
+                        if (!arg)
+                                return -EINVAL;
+                        pciinfo.domain = pci_domain_nr(host->pdev->bus);
+                        pciinfo.bus = host->pdev->bus->number;
+                        pciinfo.dev_fn = host->pdev->devfn;
+                        pciinfo.board_id = host->board_id;
+                        if (copy_to_user
+                            (argp, &pciinfo, sizeof(cciss_pci_info_struct)))
+                                return -EFAULT;
+                        return 0;
+                }
         case CCISS_GETINTINFO:
-        {
-                cciss_coalint_struct intinfo;
-                if (!arg) return -EINVAL;
-                intinfo.delay = readl(&host->cfgtable->HostWrite.CoalIntDelay);
-                intinfo.count = readl(&host->cfgtable->HostWrite.CoalIntCount);
-                if (copy_to_user(argp, &intinfo, sizeof( cciss_coalint_struct )))
-                        return -EFAULT;
-                return(0);
-        }
+                {
+                        cciss_coalint_struct intinfo;
+                        if (!arg)
+                                return -EINVAL;
+                        intinfo.delay =
+                            readl(&host->cfgtable->HostWrite.CoalIntDelay);
+                        intinfo.count =
+                            readl(&host->cfgtable->HostWrite.CoalIntCount);
+                        if (copy_to_user
+                            (argp, &intinfo, sizeof(cciss_coalint_struct)))
+                                return -EFAULT;
+                        return 0;
+                }
         case CCISS_SETINTINFO:
-        {
-                cciss_coalint_struct intinfo;
-                unsigned long flags;
-                int i;
-
-                if (!arg) return -EINVAL;       
-                if (!capable(CAP_SYS_ADMIN)) return -EPERM;
-                if (copy_from_user(&intinfo, argp, sizeof( cciss_coalint_struct)))
-                        return -EFAULT;
-                if ( (intinfo.delay == 0 ) && (intinfo.count == 0))
-
                 {
-//                      printk("cciss_ioctl: delay and count cannot be 0\n");
-                        return( -EINVAL);
+                        cciss_coalint_struct intinfo;
+                        unsigned long flags;
+                        int i;
+
+                        if (!arg)
+                                return -EINVAL;
+                        if (!capable(CAP_SYS_ADMIN))
+                                return -EPERM;
+                        if (copy_from_user
+                            (&intinfo, argp, sizeof(cciss_coalint_struct)))
+                                return -EFAULT;
+                        if ((intinfo.delay == 0) && (intinfo.count == 0))
+                        {
+//                      printk("cciss_ioctl: delay and count cannot be 0\n");
+                                return -EINVAL;
+                        }
+                        spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
+                        /* Update the field, and then ring the doorbell */
+                        writel(intinfo.delay,
+                               &(host->cfgtable->HostWrite.CoalIntDelay));
+                        writel(intinfo.count,
+                               &(host->cfgtable->HostWrite.CoalIntCount));
+                        writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
+
+                        for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
+                                if (!(readl(host->vaddr + SA5_DOORBELL)
+                                      & CFGTBL_ChangeReq))
+                                        break;
+                                /* delay and try again */
+                                udelay(1000);
+                        }
+                        spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
+                        if (i >= MAX_IOCTL_CONFIG_WAIT)
+                                return -EAGAIN;
+                        return 0;
                 }
-                spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
-                /* Update the field, and then ring the doorbell */ 
-                writel( intinfo.delay, 
-                        &(host->cfgtable->HostWrite.CoalIntDelay));
-                writel( intinfo.count, 
-                        &(host->cfgtable->HostWrite.CoalIntCount));
-                writel( CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
-
-                for(i=0;i<MAX_IOCTL_CONFIG_WAIT;i++) {
-                        if (!(readl(host->vaddr + SA5_DOORBELL) 
-                                        & CFGTBL_ChangeReq))
-                                break;
-                        /* delay and try again */
-                        udelay(1000);
-                }       
-                spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
-                if (i >= MAX_IOCTL_CONFIG_WAIT)
-                        return -EAGAIN;
-                return(0);
-        }
         case CCISS_GETNODENAME:
-        {
-                NodeName_type NodeName;
-                int i; 
-
-                if (!arg) return -EINVAL;
-                for(i=0;i<16;i++)
-                        NodeName[i] = readb(&host->cfgtable->ServerName[i]);
-                if (copy_to_user(argp, NodeName, sizeof( NodeName_type)))
-                        return  -EFAULT;
-                return(0);
-        }
+                {
+                        NodeName_type NodeName;
+                        int i;
+
+                        if (!arg)
+                                return -EINVAL;
+                        for (i = 0; i < 16; i++)
+                                NodeName[i] =
+                                    readb(&host->cfgtable->ServerName[i]);
+                        if (copy_to_user(argp, NodeName, sizeof(NodeName_type)))
+                                return -EFAULT;
+                        return 0;
+                }
         case CCISS_SETNODENAME:
-        {
-                NodeName_type NodeName;
-                unsigned long flags;
-                int i;
-
-                if (!arg) return -EINVAL;
-                if (!capable(CAP_SYS_ADMIN)) return -EPERM;
-                
-                if (copy_from_user(NodeName, argp, sizeof( NodeName_type)))
-                        return -EFAULT;
-
-                spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
-
-                        /* Update the field, and then ring the doorbell */ 
-                for(i=0;i<16;i++)
-                        writeb( NodeName[i], &host->cfgtable->ServerName[i]);
-                        
-                writel( CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
-
-                for(i=0;i<MAX_IOCTL_CONFIG_WAIT;i++) {
-                        if (!(readl(host->vaddr + SA5_DOORBELL) 
-                                        & CFGTBL_ChangeReq))
-                                break;
-                        /* delay and try again */
-                        udelay(1000);
-                }       
-                spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
-                if (i >= MAX_IOCTL_CONFIG_WAIT)
-                        return -EAGAIN;
-                return(0);
-        }
+                {
+                        NodeName_type NodeName;
+                        unsigned long flags;
+                        int i;
+
+                        if (!arg)
+                                return -EINVAL;
+                        if (!capable(CAP_SYS_ADMIN))
+                                return -EPERM;
+
+                        if (copy_from_user
+                            (NodeName, argp, sizeof(NodeName_type)))
+                                return -EFAULT;
+
+                        spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
+
+                        /* Update the field, and then ring the doorbell */
+                        for (i = 0; i < 16; i++)
+                                writeb(NodeName[i],
+                                       &host->cfgtable->ServerName[i]);
+
+                        writel(CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
+
+                        for (i = 0; i < MAX_IOCTL_CONFIG_WAIT; i++) {
+                                if (!(readl(host->vaddr + SA5_DOORBELL)
+                                      & CFGTBL_ChangeReq))
+                                        break;
+                                /* delay and try again */
+                                udelay(1000);
+                        }
+                        spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
+                        if (i >= MAX_IOCTL_CONFIG_WAIT)
+                                return -EAGAIN;
+                        return 0;
+                }
 
         case CCISS_GETHEARTBEAT:
-        {
-                Heartbeat_type heartbeat;
-
-                if (!arg) return -EINVAL;
-                heartbeat = readl(&host->cfgtable->HeartBeat);
-                if (copy_to_user(argp, &heartbeat, sizeof( Heartbeat_type)))
-                        return -EFAULT;
-                return(0);
-        }
+                {
+                        Heartbeat_type heartbeat;
+
+                        if (!arg)
+                                return -EINVAL;
+                        heartbeat = readl(&host->cfgtable->HeartBeat);
+                        if (copy_to_user
+                            (argp, &heartbeat, sizeof(Heartbeat_type)))
+                                return -EFAULT;
+                        return 0;
+                }
         case CCISS_GETBUSTYPES:
-        {
-                BusTypes_type BusTypes;
-
-                if (!arg) return -EINVAL;
-                BusTypes = readl(&host->cfgtable->BusTypes);
-                if (copy_to_user(argp, &BusTypes, sizeof( BusTypes_type) ))
-                        return  -EFAULT;
-                return(0);
-        }
+                {
+                        BusTypes_type BusTypes;
+
+                        if (!arg)
+                                return -EINVAL;
+                        BusTypes = readl(&host->cfgtable->BusTypes);
+                        if (copy_to_user
+                            (argp, &BusTypes, sizeof(BusTypes_type)))
+                                return -EFAULT;
+                        return 0;
+                }
         case CCISS_GETFIRMVER:
-        {
-                FirmwareVer_type firmware;
+                {
+                        FirmwareVer_type firmware;
 
-                if (!arg) return -EINVAL;
-                memcpy(firmware, host->firm_ver, 4);
+                        if (!arg)
+                                return -EINVAL;
+                        memcpy(firmware, host->firm_ver, 4);
 
-                if (copy_to_user(argp, firmware, sizeof( FirmwareVer_type)))
-                        return -EFAULT;
-                return(0);
-        }
-        case CCISS_GETDRIVVER:
-        {
-                DriverVer_type DriverVer = DRIVER_VERSION;
+                        if (copy_to_user
+                            (argp, firmware, sizeof(FirmwareVer_type)))
+                                return -EFAULT;
+                        return 0;
+                }
+        case CCISS_GETDRIVVER:
+                {
+                        DriverVer_type DriverVer = DRIVER_VERSION;
 
-                if (!arg) return -EINVAL;
+                        if (!arg)
+                                return -EINVAL;
 
-                if (copy_to_user(argp, &DriverVer, sizeof( DriverVer_type) ))
-                        return -EFAULT;
-                return(0);
-        }
+                        if (copy_to_user
+                            (argp, &DriverVer, sizeof(DriverVer_type)))
+                                return -EFAULT;
+                        return 0;
+                }
 
         case CCISS_REVALIDVOLS:
                 if (bdev != bdev->bd_contains || drv != host->drv)
                         return -ENXIO;
-                return revalidate_allvol(host);
-
-        case CCISS_GETLUNINFO: {
-                LogvolInfo_struct luninfo;
-                
-                luninfo.LunID = drv->LunID;
-                luninfo.num_opens = drv->usage_count;
-                luninfo.num_parts = 0;
-                if (copy_to_user(argp, &luninfo,
-                                sizeof(LogvolInfo_struct)))
-                        return -EFAULT;
-                return(0);
-        }
+                return revalidate_allvol(host);
+
+        case CCISS_GETLUNINFO:{
+                        LogvolInfo_struct luninfo;
+
+                        luninfo.LunID = drv->LunID;
+                        luninfo.num_opens = drv->usage_count;
+                        luninfo.num_parts = 0;
+                        if (copy_to_user(argp, &luninfo,
+                                         sizeof(LogvolInfo_struct)))
+                                return -EFAULT;
+                        return 0;
+                }
         case CCISS_DEREGDISK:
                 return rebuild_lun_table(host, disk);
 
@@ -837,278 +871,284 @@ static int cciss_ioctl(struct inode *inode, struct file *filep,
                 return rebuild_lun_table(host, NULL);
 
         case CCISS_PASSTHRU:
-        {
-                IOCTL_Command_struct iocommand;
-                CommandList_struct *c;
-                char    *buff = NULL;
-                u64bit  temp64;
-                unsigned long flags;
-                DECLARE_COMPLETION(wait);
-
-                if (!arg) return -EINVAL;
-        
-                if (!capable(CAP_SYS_RAWIO)) return -EPERM;
-
-                if (copy_from_user(&iocommand, argp, sizeof( IOCTL_Command_struct) ))
-                        return -EFAULT;
-                if((iocommand.buf_size < 1) && 
-                                (iocommand.Request.Type.Direction != XFER_NONE))
-                {       
-                        return -EINVAL;
-                } 
-#if 0 /* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */
-                /* Check kmalloc limits */
-                if(iocommand.buf_size > 128000)
-                        return -EINVAL;
-#endif
-                if(iocommand.buf_size > 0)
-                {
-                        buff =  kmalloc(iocommand.buf_size, GFP_KERNEL);
-                        if( buff == NULL) 
-                                return -EFAULT;
-                }
-                if (iocommand.Request.Type.Direction == XFER_WRITE)
-                {
-                        /* Copy the data into the buffer we created */ 
-                        if (copy_from_user(buff, iocommand.buf, iocommand.buf_size))
-                        {
-                                kfree(buff);
-                                return -EFAULT;
-                        }
-                } else {
-                        memset(buff, 0, iocommand.buf_size);
-                }
-                if ((c = cmd_alloc(host , 0)) == NULL)
-                {
-                        kfree(buff);
-                        return -ENOMEM;
-                }
-                        // Fill in the command type 
-                c->cmd_type = CMD_IOCTL_PEND;
-                        // Fill in Command Header 
-                c->Header.ReplyQueue = 0;  // unused in simple mode
-                if( iocommand.buf_size > 0)     // buffer to fill 
                 {
-                        c->Header.SGList = 1;
-                        c->Header.SGTotal= 1;
-                } else  // no buffers to fill  
-                {
-                        c->Header.SGList = 0;
-                        c->Header.SGTotal= 0;
-                }
-                c->Header.LUN = iocommand.LUN_info;
-                c->Header.Tag.lower = c->busaddr;  // use the kernel address the cmd block for tag
-                
-                // Fill in Request block 
-                c->Request = iocommand.Request; 
-        
-                // Fill in the scatter gather information
-                if (iocommand.buf_size > 0 ) 
-                {
-                        temp64.val = pci_map_single( host->pdev, buff,
-                                        iocommand.buf_size, 
-                                PCI_DMA_BIDIRECTIONAL); 
-                        c->SG[0].Addr.lower = temp64.val32.lower;
-                        c->SG[0].Addr.upper = temp64.val32.upper;
-                        c->SG[0].Len = iocommand.buf_size;
-                        c->SG[0].Ext = 0;  // we are not chaining
-                }
-                c->waiting = &wait;
+                        IOCTL_Command_struct iocommand;
+                        CommandList_struct *c;
+                        char *buff = NULL;
+                        u64bit temp64;
+                        unsigned long flags;
+                        DECLARE_COMPLETION(wait);
 
-                /* Put the request on the tail of the request queue */
-                spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
-                addQ(&host->reqQ, c);
-                host->Qdepth++;
-                start_io(host);
-                spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
+                        if (!arg)
+                                return -EINVAL;
 
-                wait_for_completion(&wait);
+                        if (!capable(CAP_SYS_RAWIO))
+                                return -EPERM;
 
-                /* unlock the buffers from DMA */
-                temp64.val32.lower = c->SG[0].Addr.lower;
-                temp64.val32.upper = c->SG[0].Addr.upper;
-                pci_unmap_single( host->pdev, (dma_addr_t) temp64.val,
-                        iocommand.buf_size, PCI_DMA_BIDIRECTIONAL);
+                        if (copy_from_user
+                            (&iocommand, argp, sizeof(IOCTL_Command_struct)))
+                                return -EFAULT;
+                        if ((iocommand.buf_size < 1) &&
+                            (iocommand.Request.Type.Direction != XFER_NONE)) {
+                                return -EINVAL;
+                        }
+#if 0                           /* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */
+                        /* Check kmalloc limits */
+                        if (iocommand.buf_size > 128000)
+                                return -EINVAL;
+#endif
+                        if (iocommand.buf_size > 0) {
+                                buff = kmalloc(iocommand.buf_size, GFP_KERNEL);
+                                if (buff == NULL)
+                                        return -EFAULT;
+                        }
+                        if (iocommand.Request.Type.Direction == XFER_WRITE) {
+                                /* Copy the data into the buffer we created */
+                                if (copy_from_user
+                                    (buff, iocommand.buf, iocommand.buf_size)) {
+                                        kfree(buff);
+                                        return -EFAULT;
+                                }
+                        } else {
+                                memset(buff, 0, iocommand.buf_size);
+                        }
+                        if ((c = cmd_alloc(host, 0)) == NULL) {
+                                kfree(buff);
+                                return -ENOMEM;
+                        }
+                        // Fill in the command type
+                        c->cmd_type = CMD_IOCTL_PEND;
+                        // Fill in Command Header
+                        c->Header.ReplyQueue = 0;       // unused in simple mode
+                        if (iocommand.buf_size > 0)     // buffer to fill
+                        {
+                                c->Header.SGList = 1;
+                                c->Header.SGTotal = 1;
+                        } else  // no buffers to fill
+                        {
+                                c->Header.SGList = 0;
+                                c->Header.SGTotal = 0;
+                        }
+                        c->Header.LUN = iocommand.LUN_info;
+                        c->Header.Tag.lower = c->busaddr;       // use the kernel address the cmd block for tag
 
-                /* Copy the error information out */ 
-                iocommand.error_info = *(c->err_info);
-                if ( copy_to_user(argp, &iocommand, sizeof( IOCTL_Command_struct) ) )
-                {
-                        kfree(buff);
-                        cmd_free(host, c, 0);
-                        return( -EFAULT);       
-                }       
+                        // Fill in Request block
+                        c->Request = iocommand.Request;
 
-                if (iocommand.Request.Type.Direction == XFER_READ)
-                {
-                        /* Copy the data out of the buffer we created */
-                        if (copy_to_user(iocommand.buf, buff, iocommand.buf_size))
-                        {
-                                kfree(buff);
+                        // Fill in the scatter gather information
+                        if (iocommand.buf_size > 0) {
+                                temp64.val = pci_map_single(host->pdev, buff,
+                                        iocommand.buf_size,
+                                        PCI_DMA_BIDIRECTIONAL);
+                                c->SG[0].Addr.lower = temp64.val32.lower;
+                                c->SG[0].Addr.upper = temp64.val32.upper;
+                                c->SG[0].Len = iocommand.buf_size;
+                                c->SG[0].Ext = 0;       // we are not chaining
+                        }
+                        c->waiting = &wait;
+
+                        /* Put the request on the tail of the request queue */
+                        spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
+                        addQ(&host->reqQ, c);
+                        host->Qdepth++;
+                        start_io(host);
+                        spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
+
+                        wait_for_completion(&wait);
+
+                        /* unlock the buffers from DMA */
+                        temp64.val32.lower = c->SG[0].Addr.lower;
+                        temp64.val32.upper = c->SG[0].Addr.upper;
+                        pci_unmap_single(host->pdev, (dma_addr_t) temp64.val,
+                                         iocommand.buf_size,
+                                         PCI_DMA_BIDIRECTIONAL);
+
+                        /* Copy the error information out */
+                        iocommand.error_info = *(c->err_info);
+                        if (copy_to_user
+                            (argp, &iocommand, sizeof(IOCTL_Command_struct))) {
+                                kfree(buff);
                                 cmd_free(host, c, 0);
                                 return -EFAULT;
                         }
-                }
-                kfree(buff);
-                cmd_free(host, c, 0);
-                return(0);
-        } 
-        case CCISS_BIG_PASSTHRU: {
-                BIG_IOCTL_Command_struct *ioc;
-                CommandList_struct *c;
-                unsigned char **buff = NULL;
-                int     *buff_size = NULL;
-                u64bit  temp64;
-                unsigned long flags;
-                BYTE sg_used = 0;
-                int status = 0;
-                int i;
-                DECLARE_COMPLETION(wait);
-                __u32   left;
-                __u32   sz;
-                BYTE    __user *data_ptr;
-
-                if (!arg)
-                        return -EINVAL;
-                if (!capable(CAP_SYS_RAWIO))
-                        return -EPERM;
-                ioc = (BIG_IOCTL_Command_struct *) 
-                        kmalloc(sizeof(*ioc), GFP_KERNEL);
-                if (!ioc) {
-                        status = -ENOMEM;
-                        goto cleanup1;
-                }
-                if (copy_from_user(ioc, argp, sizeof(*ioc))) {
-                        status = -EFAULT;
-                        goto cleanup1;
+
+                        if (iocommand.Request.Type.Direction == XFER_READ) {
+                                /* Copy the data out of the buffer we created */
+                                if (copy_to_user
+                                    (iocommand.buf, buff, iocommand.buf_size)) {
+                                        kfree(buff);
+                                        cmd_free(host, c, 0);
+                                        return -EFAULT;
+                                }
+                        }
+                        kfree(buff);
+                        cmd_free(host, c, 0);
+                        return 0;
                 }
-                if ((ioc->buf_size < 1) &&
-                        (ioc->Request.Type.Direction != XFER_NONE)) {
+        case CCISS_BIG_PASSTHRU:{
+                        BIG_IOCTL_Command_struct *ioc;
+                        CommandList_struct *c;
+                        unsigned char **buff = NULL;
+                        int *buff_size = NULL;
+                        u64bit temp64;
+                        unsigned long flags;
+                        BYTE sg_used = 0;
+                        int status = 0;
+                        int i;
+                        DECLARE_COMPLETION(wait);
+                        __u32 left;
+                        __u32 sz;
+                        BYTE __user *data_ptr;
+
+                        if (!arg)
+                                return -EINVAL;
+                        if (!capable(CAP_SYS_RAWIO))
+                                return -EPERM;
+                        ioc = (BIG_IOCTL_Command_struct *)
+                            kmalloc(sizeof(*ioc), GFP_KERNEL);
+                        if (!ioc) {
+                                status = -ENOMEM;
+                                goto cleanup1;
+                        }
+                        if (copy_from_user(ioc, argp, sizeof(*ioc))) {
+                                status = -EFAULT;
+                                goto cleanup1;
+                        }
+                        if ((ioc->buf_size < 1) &&
+                            (ioc->Request.Type.Direction != XFER_NONE)) {
                                 status = -EINVAL;
                                 goto cleanup1;
-                }
-                /* Check kmalloc limits  using all SGs */
-                if (ioc->malloc_size > MAX_KMALLOC_SIZE) {
-                        status = -EINVAL;
-                        goto cleanup1;
-                }
-                if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
-                        status = -EINVAL;
-                        goto cleanup1;
-                }
-                buff = kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL);
-                if (!buff) {
-                        status = -ENOMEM;
-                        goto cleanup1;
-                }
-                buff_size = (int *) kmalloc(MAXSGENTRIES * sizeof(int), 
-                                        GFP_KERNEL);
-                if (!buff_size) {
-                        status = -ENOMEM;
-                        goto cleanup1;
-                }
-                left = ioc->buf_size;
-                data_ptr = ioc->buf;
-                while (left) {
-                        sz = (left > ioc->malloc_size) ? ioc->malloc_size : left;
-                        buff_size[sg_used] = sz;
-                        buff[sg_used] = kmalloc(sz, GFP_KERNEL);
-                        if (buff[sg_used] == NULL) {
+                        }
+                        /* Check kmalloc limits  using all SGs */
+                        if (ioc->malloc_size > MAX_KMALLOC_SIZE) {
+                                status = -EINVAL;
+                                goto cleanup1;
+                        }
+                        if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
+                                status = -EINVAL;
+                                goto cleanup1;
+                        }
+                        buff =
+                            kzalloc(MAXSGENTRIES * sizeof(char *), GFP_KERNEL);
+                        if (!buff) {
                                 status = -ENOMEM;
                                 goto cleanup1;
                         }
-                        if (ioc->Request.Type.Direction == XFER_WRITE) {
-                                if (copy_from_user(buff[sg_used], data_ptr, sz)) {
+                        buff_size = (int *)kmalloc(MAXSGENTRIES * sizeof(int),
+                                                   GFP_KERNEL);
+                        if (!buff_size) {
+                                status = -ENOMEM;
+                                goto cleanup1;
+                        }
+                        left = ioc->buf_size;
+                        data_ptr = ioc->buf;
+                        while (left) {
+                                sz = (left >
+                                      ioc->malloc_size) ? ioc->
+                                    malloc_size : left;
+                                buff_size[sg_used] = sz;
+                                buff[sg_used] = kmalloc(sz, GFP_KERNEL);
+                                if (buff[sg_used] == NULL) {
                                         status = -ENOMEM;
                                         goto cleanup1;
                                 }
+                                if (ioc->Request.Type.Direction == XFER_WRITE) {
+                                        if (copy_from_user
+                                            (buff[sg_used], data_ptr, sz)) {
+                                                status = -ENOMEM;
+                                                goto cleanup1;
+                                        }
+                                } else {
+                                        memset(buff[sg_used], 0, sz);
+                                }
+                                left -= sz;
+                                data_ptr += sz;
+                                sg_used++;
+                        }
+                        if ((c = cmd_alloc(host, 0)) == NULL) {
+                                status = -ENOMEM;
+                                goto cleanup1;
+                        }
+                        c->cmd_type = CMD_IOCTL_PEND;
+                        c->Header.ReplyQueue = 0;
+
+                        if (ioc->buf_size > 0) {
+                                c->Header.SGList = sg_used;
+                                c->Header.SGTotal = sg_used;
                         } else {
-                                memset(buff[sg_used], 0, sz);
+                                c->Header.SGList = 0;
+                                c->Header.SGTotal = 0;
                         }
-                        left -= sz;
-                        data_ptr += sz;
-                        sg_used++;
-                }
-                if ((c = cmd_alloc(host , 0)) == NULL) {
-                        status = -ENOMEM;
-                        goto cleanup1;  
-                }
-                c->cmd_type = CMD_IOCTL_PEND;
-                c->Header.ReplyQueue = 0;
-                
-                if( ioc->buf_size > 0) {
-                        c->Header.SGList = sg_used;
-                        c->Header.SGTotal= sg_used;
-                } else { 
-                        c->Header.SGList = 0;
-                        c->Header.SGTotal= 0;
-                }
-                c->Header.LUN = ioc->LUN_info;
-                c->Header.Tag.lower = c->busaddr;
-                
-                c->Request = ioc->Request;
-                if (ioc->buf_size > 0 ) {
-                        int i;
-                        for(i=0; i<sg_used; i++) {
-                                temp64.val = pci_map_single( host->pdev, buff[i],
-                                        buff_size[i],
+                        c->Header.LUN = ioc->LUN_info;
+                        c->Header.Tag.lower = c->busaddr;
+
+                        c->Request = ioc->Request;
+                        if (ioc->buf_size > 0) {
+                                int i;
+                                for (i = 0; i < sg_used; i++) {
+                                        temp64.val =
+                                            pci_map_single(host->pdev, buff[i],
+                                                    buff_size[i],
+                                                    PCI_DMA_BIDIRECTIONAL);
+                                        c->SG[i].Addr.lower =
+                                            temp64.val32.lower;
+                                        c->SG[i].Addr.upper =
+                                            temp64.val32.upper;
+                                        c->SG[i].Len = buff_size[i];
+                                        c->SG[i].Ext = 0;       /* we are not chaining */
+                                }
+                        }
+                        c->waiting = &wait;
+                        /* Put the request on the tail of the request queue */
+                        spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
+                        addQ(&host->reqQ, c);
+                        host->Qdepth++;
+                        start_io(host);
+                        spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
+                        wait_for_completion(&wait);
+                        /* unlock the buffers from DMA */
+                        for (i = 0; i < sg_used; i++) {
+                                temp64.val32.lower = c->SG[i].Addr.lower;
+                                temp64.val32.upper = c->SG[i].Addr.upper;
+                                pci_unmap_single(host->pdev,
+                                        (dma_addr_t) temp64.val, buff_size[i],
                                         PCI_DMA_BIDIRECTIONAL);
-                                c->SG[i].Addr.lower = temp64.val32.lower;
-                                c->SG[i].Addr.upper = temp64.val32.upper;
-                                c->SG[i].Len = buff_size[i];
-                                c->SG[i].Ext = 0;  /* we are not chaining */
                         }
-                }
-                c->waiting = &wait;
-                /* Put the request on the tail of the request queue */
-                spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
-                addQ(&host->reqQ, c);
-                host->Qdepth++;
-                start_io(host);
-                spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
-                wait_for_completion(&wait);
-                /* unlock the buffers from DMA */
-                for(i=0; i<sg_used; i++) {
-                        temp64.val32.lower = c->SG[i].Addr.lower;
-                        temp64.val32.upper = c->SG[i].Addr.upper;
-                        pci_unmap_single( host->pdev, (dma_addr_t) temp64.val,
-                                buff_size[i], PCI_DMA_BIDIRECTIONAL);
-                }
-                /* Copy the error information out */
-                ioc->error_info = *(c->err_info);
-                if (copy_to_user(argp, ioc, sizeof(*ioc))) {
-                        cmd_free(host, c, 0);
-                        status = -EFAULT;
-                        goto cleanup1;
-                }
-                if (ioc->Request.Type.Direction == XFER_READ) {
-                        /* Copy the data out of the buffer we created */
-                        BYTE __user *ptr = ioc->buf;
-                        for(i=0; i< sg_used; i++) {
-                                if (copy_to_user(ptr, buff[i], buff_size[i])) {
-                                        cmd_free(host, c, 0);
-                                        status = -EFAULT;
-                                        goto cleanup1;
+                        /* Copy the error information out */
+                        ioc->error_info = *(c->err_info);
+                        if (copy_to_user(argp, ioc, sizeof(*ioc))) {
+                                cmd_free(host, c, 0);
+                                status = -EFAULT;
+                                goto cleanup1;
+                        }
+                        if (ioc->Request.Type.Direction == XFER_READ) {
+                                /* Copy the data out of the buffer we created */
+                                BYTE __user *ptr = ioc->buf;
+                                for (i = 0; i < sg_used; i++) {
+                                        if (copy_to_user
+                                            (ptr, buff[i], buff_size[i])) {
+                                                cmd_free(host, c, 0);
+                                                status = -EFAULT;
+                                                goto cleanup1;
+                                        }
+                                        ptr += buff_size[i];
                                 }
-                                ptr += buff_size[i];
                         }
+                        cmd_free(host, c, 0);
+                        status = 0;
+                      cleanup1:
+                        if (buff) {
+                                for (i = 0; i < sg_used; i++)
+                                        kfree(buff[i]);
+                                kfree(buff);
+                        }
+                        kfree(buff_size);
+                        kfree(ioc);
+                        return status;
                 }
-                cmd_free(host, c, 0);
-                status = 0;
-cleanup1:
-                if (buff) {
-                        for(i=0; i<sg_used; i++)
-                                kfree(buff[i]);
-                        kfree(buff);
-                }
-                kfree(buff_size);
-                kfree(ioc);
-                return(status);
-        }
         default:
                 return -ENOTTY;
         }
-        
 }
 
 /*
@@ -1119,7 +1159,7 @@ cleanup1:
  *
  * Right now I'm using the getgeometry() function to do this, but this
  * function should probably be finer grained and allow you to revalidate one
- * particualar logical volume (instead of all of them on a particular
+ * particular logical volume (instead of all of them on a particular
  * controller).
  */
 static int revalidate_allvol(ctlr_info_t *host)
@@ -1127,17 +1167,17 @@ static int revalidate_allvol(ctlr_info_t *host)
         int ctlr = host->ctlr, i;
         unsigned long flags;
 
-        spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
-        if (host->usage_count > 1) {
-                spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
-                printk(KERN_WARNING "cciss: Device busy for volume"
-                        " revalidation (usage=%d)\n", host->usage_count);
-                return -EBUSY;
-        }
-        host->usage_count++;
+        spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
+        if (host->usage_count > 1) {
+                spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
+                printk(KERN_WARNING "cciss: Device busy for volume"
+                       " revalidation (usage=%d)\n", host->usage_count);
+                return -EBUSY;
+        }
+        host->usage_count++;
         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
 
-        for(i=0; i< NWD; i++) {
+        for (i = 0; i < NWD; i++) {
                 struct gendisk *disk = host->gendisk[i];
                 if (disk) {
                         request_queue_t *q = disk->queue;
@@ -1149,22 +1189,22 @@ static int revalidate_allvol(ctlr_info_t *host)
                 }
         }
 
-        /*
-         * Set the partition and block size structures for all volumes
-         * on this controller to zero.  We will reread all of this data
-         */
-        memset(host->drv,        0, sizeof(drive_info_struct)
-                                                * CISS_MAX_LUN);
-        /*
-         * Tell the array controller not to give us any interrupts while
-         * we check the new geometry.  Then turn interrupts back on when
-         * we're done.
-         */
-        host->access.set_intr_mask(host, CCISS_INTR_OFF);
-        cciss_getgeometry(ctlr);
-        host->access.set_intr_mask(host, CCISS_INTR_ON);
-
-        /* Loop through each real device */ 
+        /*
+         * Set the partition and block size structures for all volumes
+         * on this controller to zero.  We will reread all of this data
+         */
+        memset(host->drv, 0, sizeof(drive_info_struct)
+               * CISS_MAX_LUN);
+        /*
+         * Tell the array controller not to give us any interrupts while
+         * we check the new geometry.  Then turn interrupts back on when
+         * we're done.
+         */
+        host->access.set_intr_mask(host, CCISS_INTR_OFF);
+        cciss_getgeometry(ctlr);
+        host->access.set_intr_mask(host, CCISS_INTR_ON);
+
+        /* Loop through each real device */
         for (i = 0; i < NWD; i++) {
                 struct gendisk *disk = host->gendisk[i];
                 drive_info_struct *drv = &(host->drv[i]);
@@ -1176,8 +1216,8 @@ static int revalidate_allvol(ctlr_info_t *host)
                 set_capacity(disk, drv->nr_blocks);
                 add_disk(disk);
         }
-        host->usage_count--;
-        return 0;
+        host->usage_count--;
+        return 0;
 }
 
 static inline void complete_buffers(struct bio *bio, int status)
@@ -1191,7 +1231,6 @@ static inline void complete_buffers(struct bio *bio, int status)
                 bio_endio(bio, nr_sectors << 9, status ? 0 : -EIO);
                 bio = xbh;
         }
-
 }
 
 static void cciss_softirq_done(struct request *rq)
@@ -1209,7 +1248,7 @@ static void cciss_softirq_done(struct request *rq)
 
         /* command did not need to be retried */
         /* unmap the DMA mapping for all the scatter gather elements */
-        for(i=0; i<cmd->Header.SGList; i++) {
+        for (i = 0; i < cmd->Header.SGList; i++) {
                 temp64.val32.lower = cmd->SG[i].Addr.lower;
                 temp64.val32.upper = cmd->SG[i].Addr.upper;
                 pci_unmap_page(h->pdev, temp64.val, cmd->SG[i].Len, ddir);
@@ -1219,11 +1258,12 @@ static void cciss_softirq_done(struct request *rq)
 
 #ifdef CCISS_DEBUG
         printk("Done with %p\n", rq);
-#endif /* CCISS_DEBUG */
+#endif                          /* CCISS_DEBUG */
 
+        add_disk_randomness(rq->rq_disk);
         spin_lock_irqsave(&h->lock, flags);
         end_that_request_last(rq, rq->errors);
-        cmd_free(h, cmd,1);
+        cmd_free(h, cmd, 1);
         spin_unlock_irqrestore(&h->lock, flags);
 }
 
@@ -1234,9 +1274,9 @@ static void cciss_softirq_done(struct request *rq)
  * will always be left registered with the kernel since it is also the
  * controller node.  Any changes to disk 0 will show up on the next
  * reboot.
-*/
+ */
 static void cciss_update_drive_info(int ctlr, int drv_index)
-  {
+{
         ctlr_info_t *h = hba[ctlr];
         struct gendisk *disk;
         ReadCapdata_struct *size_buff = NULL;
@@ -1246,13 +1286,13 @@ static void cciss_update_drive_info(int ctlr, int drv_index)
         unsigned long flags = 0;
         int ret = 0;
 
-        /* if the disk already exists then deregister it before proceeding*/
-        if (h->drv[drv_index].raid_level != -1){
+        /* if the disk already exists then deregister it before proceeding */
+        if (h->drv[drv_index].raid_level != -1) {
                 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
                 h->drv[drv_index].busy_configuring = 1;
                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
                 ret = deregister_disk(h->gendisk[drv_index],
-                        &h->drv[drv_index], 0);
+                                      &h->drv[drv_index], 0);
                 h->drv[drv_index].busy_configuring = 0;
         }
 
@@ -1260,27 +1300,25 @@ static void cciss_update_drive_info(int ctlr, int drv_index)
         if (ret)
                 return;
 
-
-        /* Get information about the disk and modify the driver sturcture */
-        size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
-        if (size_buff == NULL)
+        /* Get information about the disk and modify the driver structure */
+        size_buff = kmalloc(sizeof(ReadCapdata_struct), GFP_KERNEL);
+        if (size_buff == NULL)
                 goto mem_msg;
-        inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
+        inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
         if (inq_buff == NULL)
                 goto mem_msg;
 
         cciss_read_capacity(ctlr, drv_index, size_buff, 1,
-                &total_size, &block_size);
+                            &total_size, &block_size);
         cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
-                inq_buff, &h->drv[drv_index]);
+                               inq_buff, &h->drv[drv_index]);
 
         ++h->num_luns;
         disk = h->gendisk[drv_index];
         set_capacity(disk, h->drv[drv_index].nr_blocks);
 
-
         /* if it's the controller it's already added */
-        if (drv_index){
+        if (drv_index) {
                 disk->queue = blk_init_queue(do_cciss_request, &h->lock);
 
                 /* Set up queue information */
@@ -1300,17 +1338,17 @@ static void cciss_update_drive_info(int ctlr, int drv_index)
                 disk->queue->queuedata = hba[ctlr];
 
                 blk_queue_hardsect_size(disk->queue,
-                        hba[ctlr]->drv[drv_index].block_size);
+                                        hba[ctlr]->drv[drv_index].block_size);
 
                 h->drv[drv_index].queue = disk->queue;
                 add_disk(disk);
         }
 
-freeret:
+      freeret:
         kfree(size_buff);
         kfree(inq_buff);
         return;
-mem_msg:
+      mem_msg:
         printk(KERN_ERR "cciss: out of memory\n");
         goto freeret;
 }
@@ -1320,13 +1358,13 @@ mem_msg:
  * where new drives will be added.  If the index to be returned is greater
  * than the highest_lun index for the controller then highest_lun is set
  * to this new index.  If there are no available indexes then -1 is returned.
-*/
+ */
 static int cciss_find_free_drive_index(int ctlr)
 {
         int i;
 
-        for (i=0; i < CISS_MAX_LUN; i++){
-                if (hba[ctlr]->drv[i].raid_level == -1){
+        for (i = 0; i < CISS_MAX_LUN; i++) {
+                if (hba[ctlr]->drv[i].raid_level == -1) {
                         if (i > hba[ctlr]->highest_lun)
                                 hba[ctlr]->highest_lun = i;
                         return i;
@@ -1336,7 +1374,7 @@ static int cciss_find_free_drive_index(int ctlr)
 }
 
 /* This function will add and remove logical drives from the Logical
- * drive array of the controller and maintain persistancy of ordering
+ * drive array of the controller and maintain persistency of ordering
  * so that mount points are preserved until the next reboot.  This allows
  * for the removal of logical drives in the middle of the drive array
  * without a re-ordering of those drives.
@@ -1344,7 +1382,7 @@ static int cciss_find_free_drive_index(int ctlr)
  * h            = The controller to perform the operations on
  * del_disk     = The disk to remove if specified.  If the value given
  *                is NULL then no disk is removed.
-*/
+ */
 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
 {
         int ctlr = h->ctlr;
@@ -1361,12 +1399,12 @@ static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
 
         /* Set busy_configuring flag for this operation */
         spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
-        if (h->num_luns >= CISS_MAX_LUN){
+        if (h->num_luns >= CISS_MAX_LUN) {
                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
                 return -EINVAL;
         }
 
-        if (h->busy_configuring){
+        if (h->busy_configuring) {
                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
                 return -EBUSY;
         }
@@ -1376,7 +1414,7 @@ static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
          * and update the logical drive table.  If it is not NULL then
          * we will check if the disk is in use or not.
          */
-        if (del_disk != NULL){
+        if (del_disk != NULL) {
                 drv = get_drv(del_disk);
                 drv->busy_configuring = 1;
                 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
@@ -1394,61 +1432,67 @@ static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
                         goto mem_msg;
 
                 return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
-                                sizeof(ReportLunData_struct), 0, 0, 0,
-                                TYPE_CMD);
-
-                if (return_code == IO_OK){
-                        listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
-                        listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
-                        listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
-                        listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
-                } else{ /* reading number of logical volumes failed */
+                                              sizeof(ReportLunData_struct), 0,
+                                              0, 0, TYPE_CMD);
+
+                if (return_code == IO_OK) {
+                        listlength |=
+                            (0xff & (unsigned int)(ld_buff->LUNListLength[0]))
+                            << 24;
+                        listlength |=
+                            (0xff & (unsigned int)(ld_buff->LUNListLength[1]))
+                            << 16;
+                        listlength |=
+                            (0xff & (unsigned int)(ld_buff->LUNListLength[2]))
+                            << 8;
+                        listlength |=
+                            0xff & (unsigned int)(ld_buff->LUNListLength[3]);
+                } else {        /* reading number of logical volumes failed */
                         printk(KERN_WARNING "cciss: report logical volume"
-                                " command failed\n");
+                               " command failed\n");
                         listlength = 0;
                         goto freeret;
                 }
 
                 num_luns = listlength / 8;      /* 8 bytes per entry */
-                if (num_luns > CISS_MAX_LUN){
+                if (num_luns > CISS_MAX_LUN) {
                         num_luns = CISS_MAX_LUN;
                         printk(KERN_WARNING "cciss: more luns configured"
-                                " on controller than can be handled by"
-                                " this driver.\n");
+                               " on controller than can be handled by"
+                               " this driver.\n");
                 }
 
                 /* Compare controller drive array to drivers drive array.
-                * Check for updates in the drive information and any new drives
-                * on the controller.
-                */
-                for (i=0; i < num_luns; i++){
+                 * Check for updates in the drive information and any new drives
+                 * on the controller.
+                 */
+                for (i = 0; i < num_luns; i++) {
                         int j;
 
                         drv_found = 0;
 
-                        lunid = (0xff &
-                                (unsigned int)(ld_buff->LUN[i][3])) << 24;
-                        lunid |= (0xff &
-                                (unsigned int)(ld_buff->LUN[i][2])) << 16;
-                        lunid |= (0xff &
-                                (unsigned int)(ld_buff->LUN[i][1])) << 8;
-                        lunid |= 0xff &
-                                (unsigned int)(ld_buff->LUN[i][0]);
+                        lunid = (0xff &
+                                 (unsigned int)(ld_buff->LUN[i][3])) << 24;
+                        lunid |= (0xff &
+                                  (unsigned int)(ld_buff->LUN[i][2])) << 16;
+                        lunid |= (0xff &
+                                  (unsigned int)(ld_buff->LUN[i][1])) << 8;
+                        lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
 
                         /* Find if the LUN is already in the drive array
                          * of the controller.  If so then update its info
                          * if not is use.  If it does not exist then find
                          * the first free index and add it.
-                        */
-                        for (j=0; j <= h->highest_lun; j++){
-                                if (h->drv[j].LunID == lunid){
+                         */
+                        for (j = 0; j <= h->highest_lun; j++) {
+                                if (h->drv[j].LunID == lunid) {
                                         drv_index = j;
                                         drv_found = 1;
                                 }
                         }
 
                         /* check if the drive was found already in the array */
-                        if (!drv_found){
+                        if (!drv_found) {
                                 drv_index = cciss_find_free_drive_index(ctlr);
                                 if (drv_index == -1)
                                         goto freeret;
@@ -1456,18 +1500,18 @@ static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
                         }
                         h->drv[drv_index].LunID = lunid;
                         cciss_update_drive_info(ctlr, drv_index);
-                } /* end for */
-        } /* end else */
+                }               /* end for */
+        }                       /* end else */
 
-freeret:
+      freeret:
         kfree(ld_buff);
         h->busy_configuring = 0;
         /* We return -1 here to tell the ACU that we have registered/updated
          * all of the drives that we can and to keep it from calling us
          * additional times.
-        */
+         */
         return -1;
-mem_msg:
+      mem_msg:
         printk(KERN_ERR "cciss: out of memory\n");
         goto freeret;
 }
@@ -1483,7 +1527,7 @@ mem_msg:
  * clear_all = This flag determines whether or not the disk information
  *             is going to be completely cleared out and the highest_lun
  *             reset.  Sometimes we want to clear out information about
- *             the disk in preperation for re-adding it.  In this case
+ *             the disk in preparation for re-adding it.  In this case
  *             the highest_lun should be left unchanged and the LunID
  *             should not be cleared.
 */
@@ -1496,19 +1540,17 @@ static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
                 return -EPERM;
 
         /* make sure logical volume is NOT is use */
-        if(clear_all || (h->gendisk[0] == disk)) {
-        if (drv->usage_count > 1)
-                return -EBUSY;
-        }
-        else
-                if( drv->usage_count > 0 )
-                        return -EBUSY;
+        if (clear_all || (h->gendisk[0] == disk)) {
+                if (drv->usage_count > 1)
+                        return -EBUSY;
+        } else if (drv->usage_count > 0)
+                return -EBUSY;
 
         /* invalidate the devices and deregister the disk.  If it is disk
          * zero do not deregister it but just zero out it's values.  This
          * allows us to delete disk zero but keep the controller registered.
-        */
-        if (h->gendisk[0] != disk){
+         */
+        if (h->gendisk[0] != disk) {
                 if (disk) {
                         request_queue_t *q = disk->queue;
                         if (disk->flags & GENHD_FL_UP)
@@ -1530,91 +1572,90 @@ static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
         drv->raid_level = -1;   /* This can be used as a flag variable to
                                  * indicate that this element of the drive
                                  * array is free.
-                                */
-
-        if (clear_all){
-        /* check to see if it was the last disk */
-        if (drv == h->drv + h->highest_lun) {
-                /* if so, find the new hightest lun */
-                int i, newhighest =-1;
-                for(i=0; i<h->highest_lun; i++) {
-                        /* if the disk has size > 0, it is available */
+                                 */
+
+        if (clear_all) {
+                /* check to see if it was the last disk */
+                if (drv == h->drv + h->highest_lun) {
+                        /* if so, find the new hightest lun */
+                        int i, newhighest = -1;
+                        for (i = 0; i < h->highest_lun; i++) {
+                                /* if the disk has size > 0, it is available */
                                 if (h->drv[i].heads)
-                                newhighest = i;
+                                        newhighest = i;
+                        }
+                        h->highest_lun = newhighest;
                 }
-                h->highest_lun = newhighest;
-        }
 
-        drv->LunID = 0;
+                drv->LunID = 0;
         }
-        return(0);
+        return 0;
 }
 
-static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
-        size_t size,
-        unsigned int use_unit_num, /* 0: address the controller,
-                                      1: address logical volume log_unit,
-                                      2: periph device address is scsi3addr */
-        unsigned int log_unit, __u8 page_code, unsigned char *scsi3addr,
-        int cmd_type)
+static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num,      /* 0: address the controller,
+                                                                                                                           1: address logical volume log_unit,
+                                                                                                                           2: periph device address is scsi3addr */
+                    unsigned int log_unit, __u8 page_code,
+                    unsigned char *scsi3addr, int cmd_type)
 {
-        ctlr_info_t *h= hba[ctlr];
+        ctlr_info_t *h = hba[ctlr];
         u64bit buff_dma_handle;
         int status = IO_OK;
 
         c->cmd_type = CMD_IOCTL_PEND;
         c->Header.ReplyQueue = 0;
-        if( buff != NULL) {
+        if (buff != NULL) {
                 c->Header.SGList = 1;
-                c->Header.SGTotal= 1;
+                c->Header.SGTotal = 1;
         } else {
                 c->Header.SGList = 0;
-                c->Header.SGTotal= 0;
+                c->Header.SGTotal = 0;
         }
         c->Header.Tag.lower = c->busaddr;
 
         c->Request.Type.Type = cmd_type;
         if (cmd_type == TYPE_CMD) {
-                switch(cmd) {
-                case  CISS_INQUIRY:
+                switch (cmd) {
+                case CISS_INQUIRY:
                         /* If the logical unit number is 0 then, this is going
-                        to controller so It's a physical command
-                        mode = 0 target = 0.  So we have nothing to write.
-                        otherwise, if use_unit_num == 1,
-                        mode = 1(volume set addressing) target = LUNID
-                        otherwise, if use_unit_num == 2,
-                        mode = 0(periph dev addr) target = scsi3addr */
+                           to controller so It's a physical command
+                           mode = 0 target = 0.  So we have nothing to write.
+                           otherwise, if use_unit_num == 1,
+                           mode = 1(volume set addressing) target = LUNID
+                           otherwise, if use_unit_num == 2,
+                           mode = 0(periph dev addr) target = scsi3addr */
                         if (use_unit_num == 1) {
-                                c->Header.LUN.LogDev.VolId=
-                                        h->drv[log_unit].LunID;
-                                c->Header.LUN.LogDev.Mode = 1;
+                                c->Header.LUN.LogDev.VolId =
+                                    h->drv[log_unit].LunID;
+                                c->Header.LUN.LogDev.Mode = 1;
                         } else if (use_unit_num == 2) {
-                                memcpy(c->Header.LUN.LunAddrBytes,scsi3addr,8);
+                                memcpy(c->Header.LUN.LunAddrBytes, scsi3addr,
+                                       8);
                                 c->Header.LUN.LogDev.Mode = 0;
                         }
                         /* are we trying to read a vital product page */
-                        if(page_code != 0) {
+                        if (page_code != 0) {
                                 c->Request.CDB[1] = 0x01;
                                 c->Request.CDB[2] = page_code;
                         }
                         c->Request.CDBLen = 6;
-                        c->Request.Type.Attribute = ATTR_SIMPLE;  
+                        c->Request.Type.Attribute = ATTR_SIMPLE;
                         c->Request.Type.Direction = XFER_READ;
                         c->Request.Timeout = 0;
-                        c->Request.CDB[0] =  CISS_INQUIRY;
-                        c->Request.CDB[4] = size  & 0xFF;  
-                break;
+                        c->Request.CDB[0] = CISS_INQUIRY;
+                        c->Request.CDB[4] = size & 0xFF;
+                        break;
                 case CISS_REPORT_LOG:
                 case CISS_REPORT_PHYS:
-                        /* Talking to controller so It's a physical command
+                        /* Talking to controller so It's a physical command
                            mode = 00 target = 0.  Nothing to write.
-                        */
+                         */
                         c->Request.CDBLen = 12;
                         c->Request.Type.Attribute = ATTR_SIMPLE;
                         c->Request.Type.Direction = XFER_READ;
                         c->Request.Timeout = 0;
                         c->Request.CDB[0] = cmd;
-                        c->Request.CDB[6] = (size >> 24) & 0xFF;  //MSB
+                        c->Request.CDB[6] = (size >> 24) & 0xFF;        //MSB
                         c->Request.CDB[7] = (size >> 16) & 0xFF;
                         c->Request.CDB[8] = (size >> 8) & 0xFF;
                         c->Request.CDB[9] = size & 0xFF;
@@ -1628,7 +1669,7 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
                         c->Request.Type.Direction = XFER_READ;
                         c->Request.Timeout = 0;
                         c->Request.CDB[0] = cmd;
-                break;
+                        break;
                 case CCISS_CACHE_FLUSH:
                         c->Request.CDBLen = 12;
                         c->Request.Type.Attribute = ATTR_SIMPLE;
@@ -1636,32 +1677,32 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
                         c->Request.Timeout = 0;
                         c->Request.CDB[0] = BMIC_WRITE;
                         c->Request.CDB[6] = BMIC_CACHE_FLUSH;
-                break;
+                        break;
                 default:
                         printk(KERN_WARNING
-                                "cciss%d:  Unknown Command 0x%c\n", ctlr, cmd);
-                        return(IO_ERROR);
+                               "cciss%d:  Unknown Command 0x%c\n", ctlr, cmd);
+                        return IO_ERROR;
                 }
         } else if (cmd_type == TYPE_MSG) {
                 switch (cmd) {
-                case 0: /* ABORT message */
+                case 0: /* ABORT message */
                         c->Request.CDBLen = 12;
                         c->Request.Type.Attribute = ATTR_SIMPLE;
                         c->Request.Type.Direction = XFER_WRITE;
                         c->Request.Timeout = 0;
-                        c->Request.CDB[0] = cmd; /* abort */
-                        c->Request.CDB[1] = 0;   /* abort a command */
+                        c->Request.CDB[0] = cmd;        /* abort */
+                        c->Request.CDB[1] = 0;  /* abort a command */
                         /* buff contains the tag of the command to abort */
                         memcpy(&c->Request.CDB[4], buff, 8);
                         break;
-                case 1: /* RESET message */
+                case 1: /* RESET message */
                         c->Request.CDBLen = 12;
                         c->Request.Type.Attribute = ATTR_SIMPLE;
                         c->Request.Type.Direction = XFER_WRITE;
                         c->Request.Timeout = 0;
                         memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
-                        c->Request.CDB[0] = cmd;  /* reset */
-                        c->Request.CDB[1] = 0x04; /* reset a LUN */
+                        c->Request.CDB[0] = cmd;        /* reset */
+                        c->Request.CDB[1] = 0x04;       /* reset a LUN */
                 case 3: /* No-Op message */
                         c->Request.CDBLen = 1;
                         c->Request.Type.Attribute = ATTR_SIMPLE;
@@ -1671,168 +1712,164 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
                         break;
                 default:
                         printk(KERN_WARNING
-                                "cciss%d: unknown message type %d\n",
-                                ctlr, cmd);
+                               "cciss%d: unknown message type %d\n", ctlr, cmd);
                         return IO_ERROR;
                 }
         } else {
                 printk(KERN_WARNING
-                        "cciss%d: unknown command type %d\n", ctlr, cmd_type);
+                       "cciss%d: unknown command type %d\n", ctlr, cmd_type);
                 return IO_ERROR;
         }
         /* Fill in the scatter gather information */
         if (size > 0) {
                 buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
-                        buff, size, PCI_DMA_BIDIRECTIONAL);
+                                                             buff, size,
+                                                             PCI_DMA_BIDIRECTIONAL);
                 c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
                 c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
                 c->SG[0].Len = size;
-                c->SG[0].Ext = 0;  /* we are not chaining */
+                c->SG[0].Ext = 0;       /* we are not chaining */
         }
         return status;
 }
-static int sendcmd_withirq(__u8 cmd,
-        int     ctlr,
-        void    *buff,
-        size_t  size,
-        unsigned int use_unit_num,
-        unsigned int log_unit,
-        __u8    page_code,
-        int cmd_type)
+
+static int sendcmd_withirq(__u8 cmd,
+                           int ctlr,
+                           void *buff,
+                           size_t size,
+                           unsigned int use_unit_num,
+                           unsigned int log_unit, __u8 page_code, int cmd_type)
 {
         ctlr_info_t *h = hba[ctlr];
         CommandList_struct *c;
-        u64bit  buff_dma_handle;
+        u64bit buff_dma_handle;
         unsigned long flags;
         int return_status;
         DECLARE_COMPLETION(wait);
-        
-        if ((c = cmd_alloc(h , 0)) == NULL)
+
+        if ((c = cmd_alloc(h, 0)) == NULL)
                 return -ENOMEM;
         return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
-                log_unit, page_code, NULL, cmd_type);
+                                 log_unit, page_code, NULL, cmd_type);
         if (return_status != IO_OK) {
                 cmd_free(h, c, 0);
                 return return_status;
         }
-resend_cmd2:
+      resend_cmd2:
         c->waiting = &wait;
-        
+
         /* Put the request on the tail of the queue and send it */
         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
         addQ(&h->reqQ, c);
         h->Qdepth++;
         start_io(h);
         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
-        
+
         wait_for_completion(&wait);
 
-        if(c->err_info->CommandStatus != 0) 
-        { /* an error has occurred */ 
-                switch(c->err_info->CommandStatus)
-                {
-                        case CMD_TARGET_STATUS:
-                                printk(KERN_WARNING "cciss: cmd %p has "
-                                        " completed with errors\n", c);
-                                if( c->err_info->ScsiStatus)
-                                {
-                                        printk(KERN_WARNING "cciss: cmd %p "
-                                        "has SCSI Status = %x\n",
-                                                c,  
-                                                c->err_info->ScsiStatus);
-                                }
+        if (c->err_info->CommandStatus != 0) {  /* an error has occurred */
+                switch (c->err_info->CommandStatus) {
+                case CMD_TARGET_STATUS:
+                        printk(KERN_WARNING "cciss: cmd %p has "
+                               " completed with errors\n", c);
+                        if (c->err_info->ScsiStatus) {
+                                printk(KERN_WARNING "cciss: cmd %p "
+                                       "has SCSI Status = %x\n",
+                                       c, c->err_info->ScsiStatus);
+                        }
 
                         break;
-                        case CMD_DATA_UNDERRUN:
-                        case CMD_DATA_OVERRUN:
+                case CMD_DATA_UNDERRUN:
+                case CMD_DATA_OVERRUN:
                         /* expected for inquire and report lun commands */
                         break;
-                        case CMD_INVALID:
-                                printk(KERN_WARNING "cciss: Cmd %p is "
-                                        "reported invalid\n", c);
-                                return_status = IO_ERROR;
+                case CMD_INVALID:
+                        printk(KERN_WARNING "cciss: Cmd %p is "
+                               "reported invalid\n", c);
+                        return_status = IO_ERROR;
                         break;
-                        case CMD_PROTOCOL_ERR:
-                                printk(KERN_WARNING "cciss: cmd %p has "
-                                        "protocol error \n", c);
-                                return_status = IO_ERROR;
-                        break;
-case CMD_HARDWARE_ERR:
-                                printk(KERN_WARNING "cciss: cmd %p had " 
-                                        " hardware error\n", c);
-                                return_status = IO_ERROR;
-                        break;
-                        case CMD_CONNECTION_LOST:
-                                printk(KERN_WARNING "cciss: cmd %p had "
-                                        "connection lost\n", c);
-                                return_status = IO_ERROR;
+                case CMD_PROTOCOL_ERR:
+                        printk(KERN_WARNING "cciss: cmd %p has "
+                               "protocol error \n", c);
+                        return_status = IO_ERROR;
                         break;
-                        case CMD_ABORTED:
-                                printk(KERN_WARNING "cciss: cmd %p was "
-                                        "aborted\n", c);
-                                return_status = IO_ERROR;
+                case CMD_HARDWARE_ERR:
+                        printk(KERN_WARNING "cciss: cmd %p had "
+                               " hardware error\n", c);
+                        return_status = IO_ERROR;
                         break;
-                        case CMD_ABORT_FAILED:
-                                printk(KERN_WARNING "cciss: cmd %p reports "
-                                        "abort failed\n", c);
-                                return_status = IO_ERROR;
+                case CMD_CONNECTION_LOST:
+                        printk(KERN_WARNING "cciss: cmd %p had "
+                               "connection lost\n", c);
+                        return_status = IO_ERROR;
                         break;
-                        case CMD_UNSOLICITED_ABORT:
-                                printk(KERN_WARNING 
-                                        "cciss%d: unsolicited abort %p\n",
-                                        ctlr, c);
-                                if (c->retry_count < MAX_CMD_RETRIES) {
-                                        printk(KERN_WARNING 
-                                                "cciss%d: retrying %p\n", 
-                                                ctlr, c);
-                                        c->retry_count++;
-                                        /* erase the old error information */
-                                        memset(c->err_info, 0,
-                                                sizeof(ErrorInfo_struct));
-                                        return_status = IO_OK;
-                                        INIT_COMPLETION(wait);
-                                        goto resend_cmd2;
-                                }
-                                return_status = IO_ERROR;
+                case CMD_ABORTED:
+                        printk(KERN_WARNING "cciss: cmd %p was "
+                               "aborted\n", c);
+                        return_status = IO_ERROR;
+                        break;
+                case CMD_ABORT_FAILED:
+                        printk(KERN_WARNING "cciss: cmd %p reports "
+                               "abort failed\n", c);
+                        return_status = IO_ERROR;
                         break;
-                        default:
-                                printk(KERN_WARNING "cciss: cmd %p returned "
-                                        "unknown status %x\n", c, 
-                                                c->err_info->CommandStatus); 
-                                return_status = IO_ERROR;
+                case CMD_UNSOLICITED_ABORT:
+                        printk(KERN_WARNING
+                               "cciss%d: unsolicited abort %p\n", ctlr, c);
+                        if (c->retry_count < MAX_CMD_RETRIES) {
+                                printk(KERN_WARNING
+                                       "cciss%d: retrying %p\n", ctlr, c);
+                                c->retry_count++;
+                                /* erase the old error information */
+                                memset(c->err_info, 0,
+                                       sizeof(ErrorInfo_struct));
+                                return_status = IO_OK;
+                                INIT_COMPLETION(wait);
+                                goto resend_cmd2;
+                        }
+                        return_status = IO_ERROR;
+                        break;
+                default:
+                        printk(KERN_WARNING "cciss: cmd %p returned "
+                               "unknown status %x\n", c,
+                               c->err_info->CommandStatus);
+                        return_status = IO_ERROR;
                 }
-        }       
+        }
         /* unlock the buffers from DMA */
         buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
         buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
-        pci_unmap_single( h->pdev, (dma_addr_t) buff_dma_handle.val,
-                        c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
+        pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val,
+                         c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
         cmd_free(h, c, 0);
-        return(return_status);
-
+        return return_status;
 }
+
 static void cciss_geometry_inquiry(int ctlr, int logvol,
-                        int withirq, unsigned int total_size,
-                        unsigned int block_size, InquiryData_struct *inq_buff,
-                        drive_info_struct *drv)
+                                   int withirq, unsigned int total_size,
+                                   unsigned int block_size,
+                                   InquiryData_struct *inq_buff,
+                                   drive_info_struct *drv)
 {
         int return_code;
         memset(inq_buff, 0, sizeof(InquiryData_struct));
         if (withirq)
                 return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
-                        inq_buff, sizeof(*inq_buff), 1, logvol ,0xC1, TYPE_CMD);
+                                              inq_buff, sizeof(*inq_buff), 1,
+                                              logvol, 0xC1, TYPE_CMD);
         else
                 return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
-                        sizeof(*inq_buff), 1, logvol ,0xC1, NULL, TYPE_CMD);
+                                      sizeof(*inq_buff), 1, logvol, 0xC1, NULL,
+                                      TYPE_CMD);
         if (return_code == IO_OK) {
-                if(inq_buff->data_byte[8] == 0xFF) {
+                if (inq_buff->data_byte[8] == 0xFF) {
                         printk(KERN_WARNING
-                                "cciss: reading geometry failed, volume "
-                                "does not support reading geometry\n");
+                               "cciss: reading geometry failed, volume "
+                               "does not support reading geometry\n");
                         drv->block_size = block_size;
                         drv->nr_blocks = total_size;
                         drv->heads = 255;
-                        drv->sectors = 32; // Sectors per track
+                        drv->sectors = 32;      // Sectors per track
                         drv->cylinders = total_size / 255 / 32;
                 } else {
                         unsigned int t;
@@ -1846,37 +1883,42 @@ static void cciss_geometry_inquiry(int ctlr, int logvol,
                         drv->raid_level = inq_buff->data_byte[8];
                         t = drv->heads * drv->sectors;
                         if (t > 1) {
-                                drv->cylinders = total_size/t;
+                                drv->cylinders = total_size / t;
                         }
                 }
-        } else { /* Get geometry failed */
+        } else {                /* Get geometry failed */
                 printk(KERN_WARNING "cciss: reading geometry failed\n");
         }
         printk(KERN_INFO "      heads= %d, sectors= %d, cylinders= %d\n\n",
-                drv->heads, drv->sectors, drv->cylinders);
+               drv->heads, drv->sectors, drv->cylinders);
 }
+
 static void
 cciss_read_capacity(int ctlr, int logvol, ReadCapdata_struct *buf,
-                int withirq, unsigned int *total_size, unsigned int *block_size)
+                    int withirq, unsigned int *total_size,
+                    unsigned int *block_size)
 {
         int return_code;
         memset(buf, 0, sizeof(*buf));
         if (withirq)
                 return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
-                        ctlr, buf, sizeof(*buf), 1, logvol, 0, TYPE_CMD);
+                                              ctlr, buf, sizeof(*buf), 1,
+                                              logvol, 0, TYPE_CMD);
         else
                 return_code = sendcmd(CCISS_READ_CAPACITY,
-                        ctlr, buf, sizeof(*buf), 1, logvol, 0, NULL, TYPE_CMD);
+                                      ctlr, buf, sizeof(*buf), 1, logvol, 0,
+                                      NULL, TYPE_CMD);
         if (return_code == IO_OK) {
-                *total_size = be32_to_cpu(*((__be32 *) &buf->total_size[0]))+1;
-                *block_size = be32_to_cpu(*((__be32 *) &buf->block_size[0]));
-        } else { /* read capacity command failed */
+                *total_size =
+                    be32_to_cpu(*((__be32 *) & buf->total_size[0])) + 1;
+                *block_size = be32_to_cpu(*((__be32 *) & buf->block_size[0]));
+        } else {                /* read capacity command failed */
                 printk(KERN_WARNING "cciss: read capacity failed\n");
                 *total_size = 0;
                 *block_size = BLOCK_SIZE;
         }
         printk(KERN_INFO "      blocks= %u block_size= %d\n",
-                *total_size, *block_size);
+               *total_size, *block_size);
         return;
 }
 
@@ -1885,38 +1927,38 @@ static int cciss_revalidate(struct gendisk *disk)
         ctlr_info_t *h = get_host(disk);
         drive_info_struct *drv = get_drv(disk);
         int logvol;
-        int FOUND=0;
+        int FOUND = 0;
         unsigned int block_size;
         unsigned int total_size;
         ReadCapdata_struct *size_buff = NULL;
         InquiryData_struct *inq_buff = NULL;
 
-        for(logvol=0; logvol < CISS_MAX_LUN; logvol++)
-        {
-                if(h->drv[logvol].LunID == drv->LunID) {
-                        FOUND=1;
+        for (logvol = 0; logvol < CISS_MAX_LUN; logvol++) {
+                if (h->drv[logvol].LunID == drv->LunID) {
+                        FOUND = 1;
                         break;
                 }
         }
 
-        if (!FOUND) return 1;
+        if (!FOUND)
+                return 1;
 
-        size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
-        if (size_buff == NULL)
-        {
-                printk(KERN_WARNING "cciss: out of memory\n");
-                return 1;
-        }
-        inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
-        if (inq_buff == NULL)
-        {
-                printk(KERN_WARNING "cciss: out of memory\n");
+        size_buff = kmalloc(sizeof(ReadCapdata_struct), GFP_KERNEL);
+        if (size_buff == NULL) {
+                printk(KERN_WARNING "cciss: out of memory\n");
+                return 1;
+        }
+        inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
+        if (inq_buff == NULL) {
+                printk(KERN_WARNING "cciss: out of memory\n");
                 kfree(size_buff);
-                return 1;
-        }
+                return 1;
+        }
 
-        cciss_read_capacity(h->ctlr, logvol, size_buff, 1, &total_size, &block_size);
-        cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size, inq_buff, drv);
+        cciss_read_capacity(h->ctlr, logvol, size_buff, 1, &total_size,
+                            &block_size);
+        cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size,
+                               inq_buff, drv);
 
         blk_queue_hardsect_size(drv->queue, drv->block_size);
         set_capacity(disk, drv->nr_blocks);
@@ -1943,7 +1985,7 @@ static unsigned long pollcomplete(int ctlr)
                 if (done == FIFO_EMPTY)
                         schedule_timeout_uninterruptible(1);
                 else
-                        return (done);
+                        return done;
         }
         /* Invalid address to tell caller we ran out of time */
         return 1;
@@ -1952,28 +1994,28 @@ static unsigned long pollcomplete(int ctlr)
 static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
 {
         /* We get in here if sendcmd() is polling for completions
-           and gets some command back that it wasn't expecting -- 
-           something other than that which it just sent down.  
-           Ordinarily, that shouldn't happen, but it can happen when 
+           and gets some command back that it wasn't expecting --
+           something other than that which it just sent down.
+           Ordinarily, that shouldn't happen, but it can happen when
            the scsi tape stuff gets into error handling mode, and
-           starts using sendcmd() to try to abort commands and 
+           starts using sendcmd() to try to abort commands and
            reset tape drives.  In that case, sendcmd may pick up
            completions of commands that were sent to logical drives
-           through the block i/o system, or cciss ioctls completing, etc. 
+           through the block i/o system, or cciss ioctls completing, etc.
            In that case, we need to save those completions for later
            processing by the interrupt handler.
-        */
+         */
 
 #ifdef CONFIG_CISS_SCSI_TAPE
-        struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;     
+        struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;
 
         /* If it's not the scsi tape stuff doing error handling, (abort */
         /* or reset) then we don't expect anything weird. */
         if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
 #endif
-                printk( KERN_WARNING "cciss cciss%d: SendCmd "
-                      "Invalid command list address returned! (%lx)\n",
-                        ctlr, complete);
+                printk(KERN_WARNING "cciss cciss%d: SendCmd "
+                       "Invalid command list address returned! (%lx)\n",
+                       ctlr, complete);
                 /* not much we can do. */
 #ifdef CONFIG_CISS_SCSI_TAPE
                 return 1;
@@ -1984,7 +2026,7 @@ static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
         if (srl->ncompletions >= (NR_CMDS + 2)) {
                 /* Uh oh.  No room to save it for later... */
                 printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "
-                        "reject list overflow, command lost!\n", ctlr);
+                       "reject list overflow, command lost!\n", ctlr);
                 return 1;
         }
         /* Save it for later */
@@ -1995,340 +2037,327 @@ static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
 }
 
 /*
- * Send a command to the controller, and wait for it to complete.  
- * Only used at init time. 
+ * Send a command to the controller, and wait for it to complete.
+ * Only used at init time.
  */
-static int sendcmd(
-        __u8    cmd,
-        int     ctlr,
-        void    *buff,
-        size_t  size,
-        unsigned int use_unit_num, /* 0: address the controller,
-                                      1: address logical volume log_unit, 
-                                      2: periph device address is scsi3addr */
-        unsigned int log_unit,
-        __u8    page_code,
-        unsigned char *scsi3addr,
-        int cmd_type)
+static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use_unit_num,      /* 0: address the controller,
+                                                                                                   1: address logical volume log_unit,
+                                                                                                   2: periph device address is scsi3addr */
+                   unsigned int log_unit,
+                   __u8 page_code, unsigned char *scsi3addr, int cmd_type)
 {
         CommandList_struct *c;
         int i;
         unsigned long complete;
-        ctlr_info_t *info_p= hba[ctlr];
+        ctlr_info_t *info_p = hba[ctlr];
         u64bit buff_dma_handle;
         int status, done = 0;
 
         if ((c = cmd_alloc(info_p, 1)) == NULL) {
                 printk(KERN_WARNING "cciss: unable to get memory");
-                return(IO_ERROR);
+                return IO_ERROR;
         }
         status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
-                log_unit, page_code, scsi3addr, cmd_type);
+                          log_unit, page_code, scsi3addr, cmd_type);
         if (status != IO_OK) {
                 cmd_free(info_p, c, 1);
                 return status;
         }
-resend_cmd1:
+      resend_cmd1:
         /*
-         * Disable interrupt
-         */
+         * Disable interrupt
+         */
 #ifdef CCISS_DEBUG
         printk(KERN_DEBUG "cciss: turning intr off\n");
-#endif /* CCISS_DEBUG */ 
-        info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
-        
+#endif                          /* CCISS_DEBUG */
+        info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
+
         /* Make sure there is room in the command FIFO */
-        /* Actually it should be completely empty at this time */
+        /* Actually it should be completely empty at this time */
         /* unless we are in here doing error handling for the scsi */
         /* tape side of the driver. */
-        for (i = 200000; i > 0; i--) 
-        {
+        for (i = 200000; i > 0; i--) {
                 /* if fifo isn't full go */
-                if (!(info_p->access.fifo_full(info_p))) 
-                {
-                        
-                        break;
-                }
-                udelay(10);
-                printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
-                        " waiting!\n", ctlr);
-        }
-        /*
-         * Send the cmd
-         */
-        info_p->access.submit_command(info_p, c);
+                if (!(info_p->access.fifo_full(info_p))) {
+
+                        break;
+                }
+                udelay(10);
+                printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
+                       " waiting!\n", ctlr);
+        }
+        /*
+         * Send the cmd
+         */
+        info_p->access.submit_command(info_p, c);
         done = 0;
         do {
                 complete = pollcomplete(ctlr);
 
 #ifdef CCISS_DEBUG
                 printk(KERN_DEBUG "cciss: command completed\n");
-#endif /* CCISS_DEBUG */
+#endif                          /* CCISS_DEBUG */
 
                 if (complete == 1) {
-                        printk( KERN_WARNING
-                                "cciss cciss%d: SendCmd Timeout out, "
-                                "No command list address returned!\n",
-                                ctlr);
+                        printk(KERN_WARNING
+                               "cciss cciss%d: SendCmd Timeout out, "
+                               "No command list address returned!\n", ctlr);
                         status = IO_ERROR;
                         done = 1;
                         break;
                 }
 
                 /* This will need to change for direct lookup completions */
-                if ( (complete & CISS_ERROR_BIT)
-                     && (complete & ~CISS_ERROR_BIT) == c->busaddr)
-                     {
-                        /* if data overrun or underun on Report command 
-                                ignore it 
-                        */
+                if ((complete & CISS_ERROR_BIT)
+                    && (complete & ~CISS_ERROR_BIT) == c->busaddr) {
+                        /* if data overrun or underun on Report command
+                           ignore it
+                         */
                         if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
                              (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
                              (c->Request.CDB[0] == CISS_INQUIRY)) &&
-                                ((c->err_info->CommandStatus == 
-                                        CMD_DATA_OVERRUN) || 
-                                 (c->err_info->CommandStatus == 
-                                        CMD_DATA_UNDERRUN)
-                                ))
-                        {
+                            ((c->err_info->CommandStatus ==
+                              CMD_DATA_OVERRUN) ||
+                             (c->err_info->CommandStatus == CMD_DATA_UNDERRUN)
+                            )) {
                                 complete = c->busaddr;
                         } else {
                                 if (c->err_info->CommandStatus ==
-                                                CMD_UNSOLICITED_ABORT) {
+                                    CMD_UNSOLICITED_ABORT) {
                                         printk(KERN_WARNING "cciss%d: "
-                                                "unsolicited abort %p\n",
-                                                ctlr, c);
+                                               "unsolicited abort %p\n",
+                                               ctlr, c);
                                         if (c->retry_count < MAX_CMD_RETRIES) {
                                                 printk(KERN_WARNING
-                                                   "cciss%d: retrying %p\n",
-                                                   ctlr, c);
+                                                       "cciss%d: retrying %p\n",
+                                                       ctlr, c);
                                                 c->retry_count++;
                                                 /* erase the old error */
                                                 /* information */
                                                 memset(c->err_info, 0,
-                                                   sizeof(ErrorInfo_struct));
+                                                       sizeof
+                                                       (ErrorInfo_struct));
                                                 goto resend_cmd1;
                                         } else {
                                                 printk(KERN_WARNING
-                                                   "cciss%d: retried %p too "
-                                                   "many times\n", ctlr, c);
+                                                       "cciss%d: retried %p too "
+                                                       "many times\n", ctlr, c);
                                                 status = IO_ERROR;
                                                 goto cleanup1;
                                         }
-                                } else if (c->err_info->CommandStatus == CMD_UNABORTABLE) {
-                                        printk(KERN_WARNING "cciss%d: command could not be aborted.\n", ctlr);
+                                } else if (c->err_info->CommandStatus ==
+                                           CMD_UNABORTABLE) {
+                                        printk(KERN_WARNING
+                                               "cciss%d: command could not be aborted.\n",
+                                               ctlr);
                                         status = IO_ERROR;
                                         goto cleanup1;
                                 }
                                 printk(KERN_WARNING "ciss ciss%d: sendcmd"
-                                " Error %x \n", ctlr, 
-                                        c->err_info->CommandStatus); 
+                                       " Error %x \n", ctlr,
+                                       c->err_info->CommandStatus);
                                 printk(KERN_WARNING "ciss ciss%d: sendcmd"
-                                " offensive info\n"
-                                "  size %x\n   num %x   value %x\n", ctlr,
-                                  c->err_info->MoreErrInfo.Invalid_Cmd.offense_size,
-                                  c->err_info->MoreErrInfo.Invalid_Cmd.offense_num,
-                                  c->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
+                                       " offensive info\n"
+                                       "  size %x\n   num %x   value %x\n",
+                                       ctlr,
+                                       c->err_info->MoreErrInfo.Invalid_Cmd.
+                                       offense_size,
+                                       c->err_info->MoreErrInfo.Invalid_Cmd.
+                                       offense_num,
+                                       c->err_info->MoreErrInfo.Invalid_Cmd.
+                                       offense_value);
                                 status = IO_ERROR;
                                 goto cleanup1;
                         }
                 }
                 /* This will need changing for direct lookup completions */
-                if (complete != c->busaddr) {
+                if (complete != c->busaddr) {
                         if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
-                                BUG(); /* we are pretty much hosed if we get here. */
+                                BUG();  /* we are pretty much hosed if we get here. */
                         }
                         continue;
-                } else
+                } else
                         done = 1;
-        } while (!done);
-                
-cleanup1:       
+        } while (!done);
+
+      cleanup1:
         /* unlock the data buffer from DMA */
         buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
         buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
         pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
-                                c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
+                         c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
 #ifdef CONFIG_CISS_SCSI_TAPE
         /* if we saved some commands for later, process them now. */
         if (info_p->scsi_rejects.ncompletions > 0)
                 do_cciss_intr(0, info_p, NULL);
 #endif
         cmd_free(info_p, c, 1);
-        return (status);
-} 
+        return status;
+}
+
 /*
  * Map (physical) PCI mem into (virtual) kernel space
  */
 static void __iomem *remap_pci_mem(ulong base, ulong size)
 {
-        ulong page_base        = ((ulong) base) & PAGE_MASK;
-        ulong page_offs        = ((ulong) base) - page_base;
-        void __iomem *page_remapped = ioremap(page_base, page_offs+size);
+        ulong page_base = ((ulong) base) & PAGE_MASK;
+        ulong page_offs = ((ulong) base) - page_base;
+        void __iomem *page_remapped = ioremap(page_base, page_offs + size);
 
-        return page_remapped ? (page_remapped + page_offs) : NULL;
+        return page_remapped ? (page_remapped + page_offs) : NULL;
 }
 
-/* 
- * Takes jobs of the Q and sends them to the hardware, then puts it on 
- * the Q to wait for completion. 
- */ 
-static void start_io( ctlr_info_t *h)
+/*
+ * Takes jobs of the Q and sends them to the hardware, then puts it on
+ * the Q to wait for completion.
+ */
+static void start_io(ctlr_info_t *h)
 {
         CommandList_struct *c;
-        
-        while(( c = h->reqQ) != NULL )
-        {
+
+        while ((c = h->reqQ) != NULL) {
                 /* can't do anything if fifo is full */
                 if ((h->access.fifo_full(h))) {
                         printk(KERN_WARNING "cciss: fifo full\n");
                         break;
                 }
 
-                /* Get the first entry from the Request Q */ 
+                /* Get the first entry from the Request Q */
                 removeQ(&(h->reqQ), c);
                 h->Qdepth--;
-        
-                /* Tell the controller execute command */ 
+
+                /* Tell the controller execute command */
                 h->access.submit_command(h, c);
-                
-                /* Put job onto the completed Q */ 
-                addQ (&(h->cmpQ), c); 
+
+                /* Put job onto the completed Q */
+                addQ(&(h->cmpQ), c);
         }
 }
+
 /* Assumes that CCISS_LOCK(h->ctlr) is held. */
 /* Zeros out the error record and then resends the command back */
 /* to the controller */
-static inline void resend_cciss_cmd( ctlr_info_t *h, CommandList_struct *c)
+static inline void resend_cciss_cmd(ctlr_info_t *h, CommandList_struct *c)
 {
         /* erase the old error information */
         memset(c->err_info, 0, sizeof(ErrorInfo_struct));
 
         /* add it to software queue and then send it to the controller */
-        addQ(&(h->reqQ),c);
+        addQ(&(h->reqQ), c);
         h->Qdepth++;
-        if(h->Qdepth > h->maxQsinceinit)
+        if (h->Qdepth > h->maxQsinceinit)
                 h->maxQsinceinit = h->Qdepth;
 
         start_io(h);
 }
 
-/* checks the status of the job and calls complete buffers to mark all 
+/* checks the status of the job and calls complete buffers to mark all
  * buffers for the completed job. Note that this function does not need
  * to hold the hba/queue lock.
- */ 
-static inline void complete_command( ctlr_info_t *h, CommandList_struct *cmd,
-                int timeout)
+ */
+static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
+                                    int timeout)
 {
         int status = 1;
         int retry_cmd = 0;
-                
+
         if (timeout)
-                status = 0; 
+                status = 0;
 
-        if(cmd->err_info->CommandStatus != 0) 
-        { /* an error has occurred */ 
-                switch(cmd->err_info->CommandStatus)
-                {
+        if (cmd->err_info->CommandStatus != 0) {        /* an error has occurred */
+                switch (cmd->err_info->CommandStatus) {
                         unsigned char sense_key;
-                        case CMD_TARGET_STATUS:
-                                status = 0;
-                        
-                                if( cmd->err_info->ScsiStatus == 0x02)
-                                {
-                                        printk(KERN_WARNING "cciss: cmd %p "
-                                                "has CHECK CONDITION "
-                                                " byte 2 = 0x%x\n", cmd,
-                                                cmd->err_info->SenseInfo[2]
-                                        );
-                                        /* check the sense key */
-                                        sense_key = 0xf & 
-                                                cmd->err_info->SenseInfo[2];
-                                        /* no status or recovered error */
-                                        if((sense_key == 0x0) ||
-                                            (sense_key == 0x1))
-                                        {
-                                                        status = 1;
-                                        }
-                                } else
-                                {
-                                        printk(KERN_WARNING "cciss: cmd %p "
-                                                "has SCSI Status 0x%x\n",
-                                                cmd, cmd->err_info->ScsiStatus);
+                case CMD_TARGET_STATUS:
+                        status = 0;
+
+                        if (cmd->err_info->ScsiStatus == 0x02) {
+                                printk(KERN_WARNING "cciss: cmd %p "
+                                       "has CHECK CONDITION "
+                                       " byte 2 = 0x%x\n", cmd,
+                                       cmd->err_info->SenseInfo[2]
+                                    );
+                                /* check the sense key */
+                                sense_key = 0xf & cmd->err_info->SenseInfo[2];
+                                /* no status or recovered error */
+                                if ((sense_key == 0x0) || (sense_key == 0x1)) {
+                                        status = 1;
                                 }
+                        } else {
+                                printk(KERN_WARNING "cciss: cmd %p "
+                                       "has SCSI Status 0x%x\n",
+                                       cmd, cmd->err_info->ScsiStatus);
+                        }
                         break;
-                        case CMD_DATA_UNDERRUN:
-                                printk(KERN_WARNING "cciss: cmd %p has"
-                                        " completed with data underrun "
-                                        "reported\n", cmd);
+                case CMD_DATA_UNDERRUN:
+                        printk(KERN_WARNING "cciss: cmd %p has"
+                               " completed with data underrun "
+                               "reported\n", cmd);
                         break;
-                        case CMD_DATA_OVERRUN:
-                                printk(KERN_WARNING "cciss: cmd %p has"
-                                        " completed with data overrun "
-                                        "reported\n", cmd);
+                case CMD_DATA_OVERRUN:
+                        printk(KERN_WARNING "cciss: cmd %p has"
+                               " completed with data overrun "
+                               "reported\n", cmd);
                         break;
-                        case CMD_INVALID:
-                                printk(KERN_WARNING "cciss: cmd %p is "
-                                        "reported invalid\n", cmd);
-                                status = 0;
+                case CMD_INVALID:
+                        printk(KERN_WARNING "cciss: cmd %p is "
+                               "reported invalid\n", cmd);
+                        status = 0;
                         break;
-                        case CMD_PROTOCOL_ERR:
-                                printk(KERN_WARNING "cciss: cmd %p has "
-                                        "protocol error \n", cmd);
-                                status = 0;
-                        break;
-                        case CMD_HARDWARE_ERR:
-                                printk(KERN_WARNING "cciss: cmd %p had " 
-                                        " hardware error\n", cmd);
-                                status = 0;
-                        break;
-                        case CMD_CONNECTION_LOST:
-                                printk(KERN_WARNING "cciss: cmd %p had "
-                                        "connection lost\n", cmd);
-                                status=0;
+                case CMD_PROTOCOL_ERR:
+                        printk(KERN_WARNING "cciss: cmd %p has "
+                               "protocol error \n", cmd);
+                        status = 0;
                         break;
-                        case CMD_ABORTED:
-                                printk(KERN_WARNING "cciss: cmd %p was "
-                                        "aborted\n", cmd);
-                                status=0;
+                case CMD_HARDWARE_ERR:
+                        printk(KERN_WARNING "cciss: cmd %p had "
+                               " hardware error\n", cmd);
+                        status = 0;
                         break;
-                        case CMD_ABORT_FAILED:
-                                printk(KERN_WARNING "cciss: cmd %p reports "
-                                        "abort failed\n", cmd);
-                                status=0;
+                case CMD_CONNECTION_LOST:
+                        printk(KERN_WARNING "cciss: cmd %p had "
+                               "connection lost\n", cmd);
+                        status = 0;
                         break;
-                        case CMD_UNSOLICITED_ABORT:
-                                printk(KERN_WARNING "cciss%d: unsolicited "
-                                        "abort %p\n", h->ctlr, cmd);
-                                if (cmd->retry_count < MAX_CMD_RETRIES) {
-                                        retry_cmd=1;
-                                        printk(KERN_WARNING
-                                                "cciss%d: retrying %p\n",
-                                                h->ctlr, cmd);
-                                        cmd->retry_count++;
-                                } else
-                                        printk(KERN_WARNING
-                                                "cciss%d: %p retried too "
-                                                "many times\n", h->ctlr, cmd);
-                                status=0;
+                case CMD_ABORTED:
+                        printk(KERN_WARNING "cciss: cmd %p was "
+                               "aborted\n", cmd);
+                        status = 0;
+                        break;
+                case CMD_ABORT_FAILED:
+                        printk(KERN_WARNING "cciss: cmd %p reports "
+                               "abort failed\n", cmd);
+                        status = 0;
+                        break;
+                case CMD_UNSOLICITED_ABORT:
+                        printk(KERN_WARNING "cciss%d: unsolicited "
+                               "abort %p\n", h->ctlr, cmd);
+                        if (cmd->retry_count < MAX_CMD_RETRIES) {
+                                retry_cmd = 1;
+                                printk(KERN_WARNING
+                                       "cciss%d: retrying %p\n", h->ctlr, cmd);
+                                cmd->retry_count++;
+                        } else
+                                printk(KERN_WARNING
+                                       "cciss%d: %p retried too "
+                                       "many times\n", h->ctlr, cmd);
+                        status = 0;
                         break;
-                        case CMD_TIMEOUT:
-                                printk(KERN_WARNING "cciss: cmd %p timedout\n",
-                                        cmd);
-                                status=0;
+                case CMD_TIMEOUT:
+                        printk(KERN_WARNING "cciss: cmd %p timedout\n", cmd);
+                        status = 0;
                         break;
-                        default:
-                                printk(KERN_WARNING "cciss: cmd %p returned "
-                                        "unknown status %x\n", cmd, 
-                                                cmd->err_info->CommandStatus); 
-                                status=0;
+                default:
+                        printk(KERN_WARNING "cciss: cmd %p returned "
+                               "unknown status %x\n", cmd,
+                               cmd->err_info->CommandStatus);
+                        status = 0;
                 }
         }
         /* We need to return this command */
-        if(retry_cmd) {
-                resend_cciss_cmd(h,cmd);
+        if (retry_cmd) {
+                resend_cciss_cmd(h, cmd);
                 return;
-        }       
+        }
 
         cmd->rq->completion_data = cmd;
         cmd->rq->errors = status;
@@ -2336,12 +2365,12 @@ static inline void complete_command( ctlr_info_t *h, CommandList_struct *cmd,
         blk_complete_request(cmd->rq);
 }
 
-/* 
- * Get a request and submit it to the controller. 
+/*
+ * Get a request and submit it to the controller.
  */
 static void do_cciss_request(request_queue_t *q)
 {
-        ctlr_info_t *h= q->queuedata; 
+        ctlr_info_t *h = q->queuedata;
         CommandList_struct *c;
         int start_blk, seg;
         struct request *creq;
@@ -2352,18 +2381,18 @@ static void do_cciss_request(request_queue_t *q)
 
         /* We call start_io here in case there is a command waiting on the
          * queue that has not been sent.
-        */
+         */
         if (blk_queue_plugged(q))
                 goto startio;
 
-queue:
+      queue:
         creq = elv_next_request(q);
         if (!creq)
                 goto startio;
 
         BUG_ON(creq->nr_phys_segments > MAXSGENTRIES);
 
-        if (( c = cmd_alloc(h, 1)) == NULL)
+        if ((c = cmd_alloc(h, 1)) == NULL)
                 goto full;
 
         blkdev_dequeue_request(creq);
@@ -2372,81 +2401,82 @@ queue:
 
         c->cmd_type = CMD_RWREQ;
         c->rq = creq;
-        
-        /* fill in the request */ 
+
+        /* fill in the request */
         drv = creq->rq_disk->private_data;
-        c->Header.ReplyQueue = 0;  // unused in simple mode
+        c->Header.ReplyQueue = 0;       // unused in simple mode
         /* got command from pool, so use the command block index instead */
         /* for direct lookups. */
         /* The first 2 bits are reserved for controller error reporting. */
         c->Header.Tag.lower = (c->cmdindex << 3);
-        c->Header.Tag.lower |= 0x04; /* flag for direct lookup. */
-        c->Header.LUN.LogDev.VolId= drv->LunID;
+        c->Header.Tag.lower |= 0x04;    /* flag for direct lookup. */
+        c->Header.LUN.LogDev.VolId = drv->LunID;
         c->Header.LUN.LogDev.Mode = 1;
-        c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
-        c->Request.Type.Type =  TYPE_CMD; // It is a command. 
-        c->Request.Type.Attribute = ATTR_SIMPLE; 
-        c->Request.Type.Direction = 
-                (rq_data_dir(creq) == READ) ? XFER_READ: XFER_WRITE; 
-        c->Request.Timeout = 0; // Don't time out       
-        c->Request.CDB[0] = (rq_data_dir(creq) == READ) ? CCISS_READ : CCISS_WRITE;
+        c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
+        c->Request.Type.Type = TYPE_CMD;        // It is a command.
+        c->Request.Type.Attribute = ATTR_SIMPLE;
+        c->Request.Type.Direction =
+            (rq_data_dir(creq) == READ) ? XFER_READ : XFER_WRITE;
+        c->Request.Timeout = 0; // Don't time out
+        c->Request.CDB[0] =
+            (rq_data_dir(creq) == READ) ? CCISS_READ : CCISS_WRITE;
         start_blk = creq->sector;
 #ifdef CCISS_DEBUG
-        printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n",(int) creq->sector,
-                (int) creq->nr_sectors);        
-#endif /* CCISS_DEBUG */
+        printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n", (int)creq->sector,
+               (int)creq->nr_sectors);
+#endif                          /* CCISS_DEBUG */
 
         seg = blk_rq_map_sg(q, creq, tmp_sg);
 
-        /* get the DMA records for the setup */ 
+        /* get the DMA records for the setup */
         if (c->Request.Type.Direction == XFER_READ)
                 dir = PCI_DMA_FROMDEVICE;
         else
                 dir = PCI_DMA_TODEVICE;
 
-        for (i=0; i<seg; i++)
-        {
+        for (i = 0; i < seg; i++) {
                 c->SG[i].Len = tmp_sg[i].length;
                 temp64.val = (__u64) pci_map_page(h->pdev, tmp_sg[i].page,
-                                          tmp_sg[i].offset, tmp_sg[i].length,
-                                          dir);
+                                                  tmp_sg[i].offset,
+                                                  tmp_sg[i].length, dir);
                 c->SG[i].Addr.lower = temp64.val32.lower;
-                c->SG[i].Addr.upper = temp64.val32.upper;
-                c->SG[i].Ext = 0;  // we are not chaining
+                c->SG[i].Addr.upper = temp64.val32.upper;
+                c->SG[i].Ext = 0;       // we are not chaining
         }
-        /* track how many SG entries we are using */ 
-        if( seg > h->maxSG)
-                h->maxSG = seg; 
+        /* track how many SG entries we are using */
+        if (seg > h->maxSG)
+                h->maxSG = seg;
 
 #ifdef CCISS_DEBUG
-        printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n", creq->nr_sectors, seg);
-#endif /* CCISS_DEBUG */
+        printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n",
+               creq->nr_sectors, seg);
+#endif                          /* CCISS_DEBUG */
 
         c->Header.SGList = c->Header.SGTotal = seg;
-        c->Request.CDB[1]= 0;
-        c->Request.CDB[2]= (start_blk >> 24) & 0xff;    //MSB
-        c->Request.CDB[3]= (start_blk >> 16) & 0xff;
-        c->Request.CDB[4]= (start_blk >>  8) & 0xff;
-        c->Request.CDB[5]= start_blk & 0xff;
-        c->Request.CDB[6]= 0; // (sect >> 24) & 0xff; MSB
-        c->Request.CDB[7]= (creq->nr_sectors >>  8) & 0xff; 
-        c->Request.CDB[8]= creq->nr_sectors & 0xff; 
+        c->Request.CDB[1] = 0;
+        c->Request.CDB[2] = (start_blk >> 24) & 0xff;   //MSB
+        c->Request.CDB[3] = (start_blk >> 16) & 0xff;
+        c->Request.CDB[4] = (start_blk >> 8) & 0xff;
+        c->Request.CDB[5] = start_blk & 0xff;
+        c->Request.CDB[6] = 0;  // (sect >> 24) & 0xff; MSB
+        c->Request.CDB[7] = (creq->nr_sectors >> 8) & 0xff;
+        c->Request.CDB[8] = creq->nr_sectors & 0xff;
         c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
 
         spin_lock_irq(q->queue_lock);
 
-        addQ(&(h->reqQ),c);
+        addQ(&(h->reqQ), c);
         h->Qdepth++;
-        if(h->Qdepth > h->maxQsinceinit)
-                h->maxQsinceinit = h->Qdepth; 
+        if (h->Qdepth > h->maxQsinceinit)
+                h->maxQsinceinit = h->Qdepth;
 
         goto queue;
-full:
+      full:
         blk_stop_queue(q);
-startio:
+      startio:
         /* We will already have the driver lock here so not need
          * to lock it.
-        */
+         */
         start_io(h);
 }
 
@@ -2473,7 +2503,7 @@ static inline unsigned long get_next_completion(ctlr_info_t *h)
 static inline int interrupt_pending(ctlr_info_t *h)
 {
 #ifdef CONFIG_CISS_SCSI_TAPE
-        return ( h->access.intr_pending(h) 
+        return (h->access.intr_pending(h)
                 || (h->scsi_rejects.ncompletions > 0));
 #else
         return h->access.intr_pending(h);
@@ -2483,11 +2513,11 @@ static inline int interrupt_pending(ctlr_info_t *h)
 static inline long interrupt_not_for_us(ctlr_info_t *h)
 {
 #ifdef CONFIG_CISS_SCSI_TAPE
-        return (((h->access.intr_pending(h) == 0) || 
-                 (h->interrupts_enabled == 0)) 
-              && (h->scsi_rejects.ncompletions == 0));
+        return (((h->access.intr_pending(h) == 0) ||
+                 (h->interrupts_enabled == 0))
+                && (h->scsi_rejects.ncompletions == 0));
 #else
-        return (((h->access.intr_pending(h) == 0) || 
+        return (((h->access.intr_pending(h) == 0) ||
                  (h->interrupts_enabled == 0)));
 #endif
 }
@@ -2509,12 +2539,14 @@ static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs)
          */
         spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
         while (interrupt_pending(h)) {
-                while((a = get_next_completion(h)) != FIFO_EMPTY) {
+                while ((a = get_next_completion(h)) != FIFO_EMPTY) {
                         a1 = a;
                         if ((a & 0x04)) {
                                 a2 = (a >> 3);
                                 if (a2 >= NR_CMDS) {
-                                        printk(KERN_WARNING "cciss: controller cciss%d failed, stopping.\n", h->ctlr);
+                                        printk(KERN_WARNING
+                                               "cciss: controller cciss%d failed, stopping.\n",
+                                               h->ctlr);
                                         fail_all_cmds(h->ctlr);
                                         return IRQ_HANDLED;
                                 }
@@ -2523,22 +2555,24 @@ static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs)
                                 a = c->busaddr;
 
                         } else {
-                        a &= ~3;
+                                a &= ~3;
                                 if ((c = h->cmpQ) == NULL) {
-                                        printk(KERN_WARNING "cciss: Completion of %08x ignored\n", a1);
-                                continue;       
-                        } 
-                        while(c->busaddr != a) {
-                                c = c->next;
-                                if (c == h->cmpQ) 
-                                        break;
-                        }
+                                        printk(KERN_WARNING
+                                               "cciss: Completion of %08x ignored\n",
+                                               a1);
+                                        continue;
+                                }
+                                while (c->busaddr != a) {
+                                        c = c->next;
+                                        if (c == h->cmpQ)
+                                                break;
+                                }
                         }
                         /*
                          * If we've found the command, take it off the
                          * completion Q and free it
                          */
-                         if (c->busaddr == a) {
+                        if (c->busaddr == a) {
                                 removeQ(&h->cmpQ, c);
                                 if (c->cmd_type == CMD_RWREQ) {
                                         complete_command(h, c, 0);
@@ -2554,130 +2588,118 @@ static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs)
                 }
         }
 
-        /* check to see if we have maxed out the number of commands that can
-         * be placed on the queue.  If so then exit.  We do this check here
-         * in case the interrupt we serviced was from an ioctl and did not
-         * free any new commands.
+        /* check to see if we have maxed out the number of commands that can
+         * be placed on the queue.  If so then exit.  We do this check here
+         * in case the interrupt we serviced was from an ioctl and did not
+         * free any new commands.
+         */
+        if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS)
+                goto cleanup;
+
+        /* We have room on the queue for more commands.  Now we need to queue
+         * them up.  We will also keep track of the next queue to run so
+         * that every queue gets a chance to be started first.
          */
-        if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS)
-                goto cleanup;
-
-        /* We have room on the queue for more commands.  Now we need to queue
-         * them up.  We will also keep track of the next queue to run so
-         * that every queue gets a chance to be started first.
-        */
-        for (j=0; j < h->highest_lun + 1; j++){
+        for (j = 0; j < h->highest_lun + 1; j++) {
                 int curr_queue = (start_queue + j) % (h->highest_lun + 1);
-                /* make sure the disk has been added and the drive is real
-                 * because this can be called from the middle of init_one.
-                */
-                if(!(h->drv[curr_queue].queue) ||
-                                   !(h->drv[curr_queue].heads))
-                        continue;
-                blk_start_queue(h->gendisk[curr_queue]->queue);
-
-                /* check to see if we have maxed out the number of commands
-                 * that can be placed on the queue.
-                */
-                if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS)
-                {
-                        if (curr_queue == start_queue){
-                                h->next_to_run = (start_queue + 1) % (h->highest_lun + 1);
-                                goto cleanup;
-                        } else {
-                                h->next_to_run = curr_queue;
-                                goto cleanup;
-        }
-                } else {
+                /* make sure the disk has been added and the drive is real
+                 * because this can be called from the middle of init_one.
+                 */
+                if (!(h->drv[curr_queue].queue) || !(h->drv[curr_queue].heads))
+                        continue;
+                blk_start_queue(h->gendisk[curr_queue]->queue);
+
+                /* check to see if we have maxed out the number of commands
+                 * that can be placed on the queue.
+                 */
+                if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS) {
+                        if (curr_queue == start_queue) {
+                                h->next_to_run =
+                                    (start_queue + 1) % (h->highest_lun + 1);
+                                goto cleanup;
+                        } else {
+                                h->next_to_run = curr_queue;
+                                goto cleanup;
+                        }
+                } else {
                         curr_queue = (curr_queue + 1) % (h->highest_lun + 1);
-                }
-        }
+                }
+        }
 
-cleanup:
+      cleanup:
         spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
         return IRQ_HANDLED;
 }
-/* 
- *  We cannot read the structure directly, for portablity we must use 
+
+/*
+ *  We cannot read the structure directly, for portability we must use
  *   the io functions.
- *   This is for debug only. 
+ *   This is for debug only.
  */
 #ifdef CCISS_DEBUG
-static void print_cfg_table( CfgTable_struct *tb)
+static void print_cfg_table(CfgTable_struct *tb)
 {
         int i;
         char temp_name[17];
 
         printk("Controller Configuration information\n");
         printk("------------------------------------\n");
-        for(i=0;i<4;i++)
+        for (i = 0; i < 4; i++)
                 temp_name[i] = readb(&(tb->Signature[i]));
-        temp_name[4]='\0';
-        printk("   Signature = %s\n", temp_name); 
+        temp_name[4] = '\0';
+        printk("   Signature = %s\n", temp_name);
         printk("   Spec Number = %d\n", readl(&(tb->SpecValence)));
-        printk("   Transport methods supported = 0x%x\n", 
-                                readl(&(tb-> TransportSupport)));
-        printk("   Transport methods active = 0x%x\n", 
-                                readl(&(tb->TransportActive)));
-        printk("   Requested transport Method = 0x%x\n", 
-                        readl(&(tb->HostWrite.TransportRequest)));
-        printk("   Coalese Interrupt Delay = 0x%x\n", 
-                        readl(&(tb->HostWrite.CoalIntDelay)));
-        printk("   Coalese Interrupt Count = 0x%x\n", 
-                        readl(&(tb->HostWrite.CoalIntCount)));
-        printk("   Max outstanding commands = 0x%d\n", 
-                        readl(&(tb->CmdsOutMax)));
-        printk("   Bus Types = 0x%x\n", readl(&(tb-> BusTypes)));
-        for(i=0;i<16;i++)
+        printk("   Transport methods supported = 0x%x\n",
+               readl(&(tb->TransportSupport)));
+        printk("   Transport methods active = 0x%x\n",
+               readl(&(tb->TransportActive)));
+        printk("   Requested transport Method = 0x%x\n",
+               readl(&(tb->HostWrite.TransportRequest)));
+        printk("   Coalesce Interrupt Delay = 0x%x\n",
+               readl(&(tb->HostWrite.CoalIntDelay)));
+        printk("   Coalesce Interrupt Count = 0x%x\n",
+               readl(&(tb->HostWrite.CoalIntCount)));
+        printk("   Max outstanding commands = 0x%d\n",
+               readl(&(tb->CmdsOutMax)));
+        printk("   Bus Types = 0x%x\n", readl(&(tb->BusTypes)));
+        for (i = 0; i < 16; i++)
                 temp_name[i] = readb(&(tb->ServerName[i]));
         temp_name[16] = '\0';
         printk("   Server Name = %s\n", temp_name);
-        printk("   Heartbeat Counter = 0x%x\n\n\n", 
-                        readl(&(tb->HeartBeat)));
-}
-#endif /* CCISS_DEBUG */ 
-
-static void release_io_mem(ctlr_info_t *c)
-{
-        /* if IO mem was not protected do nothing */
-        if( c->io_mem_addr == 0)
-                return;
-        release_region(c->io_mem_addr, c->io_mem_length);
-        c->io_mem_addr = 0;
-        c->io_mem_length = 0;
+        printk("   Heartbeat Counter = 0x%x\n\n\n", readl(&(tb->HeartBeat)));
 }
+#endif                          /* CCISS_DEBUG */
 
-static int find_PCI_BAR_index(struct pci_dev *pdev,
-                                unsigned long pci_bar_addr)
+static int find_PCI_BAR_index(struct pci_dev *pdev, unsigned long pci_bar_addr)
 {
         int i, offset, mem_type, bar_type;
-        if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
+        if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
                 return 0;
         offset = 0;
-        for (i=0; i<DEVICE_COUNT_RESOURCE; i++) {
-                bar_type = pci_resource_flags(pdev, i) &
-                        PCI_BASE_ADDRESS_SPACE;
+        for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
+                bar_type = pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE;
                 if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
                         offset += 4;
                 else {
                         mem_type = pci_resource_flags(pdev, i) &
-                                PCI_BASE_ADDRESS_MEM_TYPE_MASK;
+                            PCI_BASE_ADDRESS_MEM_TYPE_MASK;
                         switch (mem_type) {
-                                case PCI_BASE_ADDRESS_MEM_TYPE_32:
-                                case PCI_BASE_ADDRESS_MEM_TYPE_1M:
-                                        offset += 4; /* 32 bit */
-                                        break;
-                                case PCI_BASE_ADDRESS_MEM_TYPE_64:
-                                        offset += 8;
-                                        break;
-                                default: /* reserved in PCI 2.2 */
-                                        printk(KERN_WARNING "Base address is invalid\n");
-                                        return -1;
+                        case PCI_BASE_ADDRESS_MEM_TYPE_32:
+                        case PCI_BASE_ADDRESS_MEM_TYPE_1M:
+                                offset += 4;    /* 32 bit */
+                                break;
+                        case PCI_BASE_ADDRESS_MEM_TYPE_64:
+                                offset += 8;
+                                break;
+                        default:        /* reserved in PCI 2.2 */
+                                printk(KERN_WARNING
+                                       "Base address is invalid\n");
+                                return -1;
                                 break;
                         }
                 }
-                if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
-                        return i+1;
+                if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
+                        return i + 1;
         }
         return -1;
 }
@@ -2686,53 +2708,54 @@ static int find_PCI_BAR_index(struct pci_dev *pdev,
  * controllers that are capable. If not, we use IO-APIC mode.
  */
 
-static void __devinit cciss_interrupt_mode(ctlr_info_t *c, struct pci_dev *pdev, __u32 board_id)
+static void __devinit cciss_interrupt_mode(ctlr_info_t *c,
+                                           struct pci_dev *pdev, __u32 board_id)
 {
 #ifdef CONFIG_PCI_MSI
-        int err;
-        struct msix_entry cciss_msix_entries[4] = {{0,0}, {0,1},
-                                                   {0,2}, {0,3}};
+        int err;
+        struct msix_entry cciss_msix_entries[4] = { {0, 0}, {0, 1},
+        {0, 2}, {0, 3}
+        };
 
         /* Some boards advertise MSI but don't really support it */
         if ((board_id == 0x40700E11) ||
-                (board_id == 0x40800E11) ||
-                (board_id == 0x40820E11) ||
-                (board_id == 0x40830E11))
+            (board_id == 0x40800E11) ||
+            (board_id == 0x40820E11) || (board_id == 0x40830E11))
                 goto default_int_mode;
 
-        if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) {
-                err = pci_enable_msix(pdev, cciss_msix_entries, 4);
-                if (!err) {
-                        c->intr[0] = cciss_msix_entries[0].vector;
-                        c->intr[1] = cciss_msix_entries[1].vector;
-                        c->intr[2] = cciss_msix_entries[2].vector;
-                        c->intr[3] = cciss_msix_entries[3].vector;
-                        c->msix_vector = 1;
-                        return;
-                }
-                if (err > 0) {
-                        printk(KERN_WARNING "cciss: only %d MSI-X vectors "
-                                        "available\n", err);
-                } else {
-                        printk(KERN_WARNING "cciss: MSI-X init failed %d\n",
-                                                err);
-                }
-        }
-        if (pci_find_capability(pdev, PCI_CAP_ID_MSI)) {
-                if (!pci_enable_msi(pdev)) {
-                        c->intr[SIMPLE_MODE_INT] = pdev->irq;
-                        c->msi_vector = 1;
-                        return;
-                } else {
-                        printk(KERN_WARNING "cciss: MSI init failed\n");
-                        c->intr[SIMPLE_MODE_INT] = pdev->irq;
-                        return;
-                }
-        }
-default_int_mode:
-#endif /* CONFIG_PCI_MSI */
+        if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) {
+                err = pci_enable_msix(pdev, cciss_msix_entries, 4);
+                if (!err) {
+                        c->intr[0] = cciss_msix_entries[0].vector;
+                        c->intr[1] = cciss_msix_entries[1].vector;
+                        c->intr[2] = cciss_msix_entries[2].vector;
+                        c->intr[3] = cciss_msix_entries[3].vector;
+                        c->msix_vector = 1;
+                        return;
+                }
+                if (err > 0) {
+                        printk(KERN_WARNING "cciss: only %d MSI-X vectors "
+                               "available\n", err);
+                } else {
+                        printk(KERN_WARNING "cciss: MSI-X init failed %d\n",
+                               err);
+                }
+        }
+        if (pci_find_capability(pdev, PCI_CAP_ID_MSI)) {
+                if (!pci_enable_msi(pdev)) {
+                        c->intr[SIMPLE_MODE_INT] = pdev->irq;
+                        c->msi_vector = 1;
+                        return;
+                } else {
+                        printk(KERN_WARNING "cciss: MSI init failed\n");
+                        c->intr[SIMPLE_MODE_INT] = pdev->irq;
+                        return;
+                }
+        }
+      default_int_mode:
+#endif                          /* CONFIG_PCI_MSI */
         /* if we get here we're going to use the default interrupt mode */
-        c->intr[SIMPLE_MODE_INT] = pdev->irq;
+        c->intr[SIMPLE_MODE_INT] = pdev->irq;
         return;
 }
 
@@ -2743,58 +2766,40 @@ static int cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
         __u64 cfg_offset;
         __u32 cfg_base_addr;
         __u64 cfg_base_addr_index;
-        int i;
+        int i, err;
 
         /* check to see if controller has been disabled */
         /* BEFORE trying to enable it */
-        (void) pci_read_config_word(pdev, PCI_COMMAND,&command);
-        if(!(command & 0x02))
-        {
-                printk(KERN_WARNING "cciss: controller appears to be disabled\n");
-                return(-1);
+        (void)pci_read_config_word(pdev, PCI_COMMAND, &command);
+        if (!(command & 0x02)) {
+                printk(KERN_WARNING
+                       "cciss: controller appears to be disabled\n");
+                return -ENODEV;
         }
 
-        if (pci_enable_device(pdev))
-        {
+        err = pci_enable_device(pdev);
+        if (err) {
                 printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
-                return( -1);
+                return err;
+        }
+
+        err = pci_request_regions(pdev, "cciss");
+        if (err) {
+                printk(KERN_ERR "cciss: Cannot obtain PCI resources, "
+                       "aborting\n");
+                goto err_out_disable_pdev;
         }
 
         subsystem_vendor_id = pdev->subsystem_vendor;
         subsystem_device_id = pdev->subsystem_device;
         board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
-                                        subsystem_vendor_id);
-
-        /* search for our IO range so we can protect it */
-        for(i=0; i<DEVICE_COUNT_RESOURCE; i++)
-        {
-                /* is this an IO range */ 
-                if( pci_resource_flags(pdev, i) & 0x01 ) {
-                        c->io_mem_addr = pci_resource_start(pdev, i);
-                        c->io_mem_length = pci_resource_end(pdev, i) -
-                                pci_resource_start(pdev, i) +1;
-#ifdef CCISS_DEBUG
-                        printk("IO value found base_addr[%d] %lx %lx\n", i,
-                                c->io_mem_addr, c->io_mem_length);
-#endif /* CCISS_DEBUG */
-                        /* register the IO range */ 
-                        if(!request_region( c->io_mem_addr,
-                                        c->io_mem_length, "cciss"))
-                        {
-                                printk(KERN_WARNING "cciss I/O memory range already in use addr=%lx length=%ld\n",
-                                c->io_mem_addr, c->io_mem_length);
-                                c->io_mem_addr= 0;
-                                c->io_mem_length = 0;
-                        } 
-                        break;
-                }
-        }
+                    subsystem_vendor_id);
 
 #ifdef CCISS_DEBUG
         printk("command = %x\n", command);
         printk("irq = %x\n", pdev->irq);
         printk("board_id = %x\n", board_id);
-#endif /* CCISS_DEBUG */ 
+#endif                          /* CCISS_DEBUG */
 
 /* If the kernel supports MSI/MSI-X we will try to enable that functionality,
  * else we use the IO-APIC interrupt assigned to us by system ROM.
@@ -2803,27 +2808,28 @@ static int cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
 
         /*
          * Memory base addr is first addr , the second points to the config
-         *   table
+         *   table
          */
 
-        c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
+        c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
 #ifdef CCISS_DEBUG
         printk("address 0 = %x\n", c->paddr);
-#endif /* CCISS_DEBUG */ 
+#endif                          /* CCISS_DEBUG */
         c->vaddr = remap_pci_mem(c->paddr, 200);
 
         /* Wait for the board to become ready.  (PCI hotplug needs this.)
          * We poll for up to 120 secs, once per 100ms. */
-        for (i=0; i < 1200; i++) {
+        for (i = 0; i < 1200; i++) {
                 scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
                 if (scratchpad == CCISS_FIRMWARE_READY)
                         break;
                 set_current_state(TASK_INTERRUPTIBLE);
-                schedule_timeout(HZ / 10); /* wait 100ms */
+                schedule_timeout(HZ / 10);      /* wait 100ms */
         }
         if (scratchpad != CCISS_FIRMWARE_READY) {
                 printk(KERN_WARNING "cciss: Board not ready.  Timed out.\n");
-                return -1;
+                err = -ENODEV;
+                goto err_out_free_res;
         }
 
         /* get the address index number */
@@ -2831,103 +2837,108 @@ static int cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
         cfg_base_addr &= (__u32) 0x0000ffff;
 #ifdef CCISS_DEBUG
         printk("cfg base address = %x\n", cfg_base_addr);
-#endif /* CCISS_DEBUG */
-        cfg_base_addr_index =
-                find_PCI_BAR_index(pdev, cfg_base_addr);
+#endif                          /* CCISS_DEBUG */
+        cfg_base_addr_index = find_PCI_BAR_index(pdev, cfg_base_addr);
 #ifdef CCISS_DEBUG
         printk("cfg base address index = %x\n", cfg_base_addr_index);
-#endif /* CCISS_DEBUG */
+#endif                          /* CCISS_DEBUG */
         if (cfg_base_addr_index == -1) {
                 printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
-                release_io_mem(c);
-                return -1;
+                err = -ENODEV;
+                goto err_out_free_res;
         }
 
         cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
 #ifdef CCISS_DEBUG
         printk("cfg offset = %x\n", cfg_offset);
-#endif /* CCISS_DEBUG */
-        c->cfgtable =  remap_pci_mem(pci_resource_start(pdev,
-                                cfg_base_addr_index) + cfg_offset,
-                                sizeof(CfgTable_struct));
+#endif                          /* CCISS_DEBUG */
+        c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
+                                                       cfg_base_addr_index) +
+                                    cfg_offset, sizeof(CfgTable_struct));
         c->board_id = board_id;
 
 #ifdef CCISS_DEBUG
         print_cfg_table(c->cfgtable);
-#endif /* CCISS_DEBUG */
+#endif                          /* CCISS_DEBUG */
 
-        for(i=0; i<NR_PRODUCTS; i++) {
+        for (i = 0; i < ARRAY_SIZE(products); i++) {
                 if (board_id == products[i].board_id) {
                         c->product_name = products[i].product_name;
                         c->access = *(products[i].access);
                         break;
                 }
         }
-        if (i == NR_PRODUCTS) {
+        if (i == ARRAY_SIZE(products)) {
                 printk(KERN_WARNING "cciss: Sorry, I don't know how"
-                        " to access the Smart Array controller %08lx\n", 
-                                (unsigned long)board_id);
-                return -1;
-        }
-        if (  (readb(&c->cfgtable->Signature[0]) != 'C') ||
-              (readb(&c->cfgtable->Signature[1]) != 'I') ||
-              (readb(&c->cfgtable->Signature[2]) != 'S') ||
-              (readb(&c->cfgtable->Signature[3]) != 'S') )
-        {
+                       " to access the Smart Array controller %08lx\n",
+                       (unsigned long)board_id);
+                err = -ENODEV;
+                goto err_out_free_res;
+        }
+        if ((readb(&c->cfgtable->Signature[0]) != 'C') ||
+            (readb(&c->cfgtable->Signature[1]) != 'I') ||
+            (readb(&c->cfgtable->Signature[2]) != 'S') ||
+            (readb(&c->cfgtable->Signature[3]) != 'S')) {
                 printk("Does not appear to be a valid CISS config table\n");
-                return -1;
+                err = -ENODEV;
+                goto err_out_free_res;
         }
-
 #ifdef CONFIG_X86
-{
-        /* Need to enable prefetch in the SCSI core for 6400 in x86 */
-        __u32 prefetch;
-        prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
-        prefetch |= 0x100;
-        writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
-}
+        {
+                /* Need to enable prefetch in the SCSI core for 6400 in x86 */
+                __u32 prefetch;
+                prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
+                prefetch |= 0x100;
+                writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
+        }
 #endif
 
 #ifdef CCISS_DEBUG
         printk("Trying to put board into Simple mode\n");
-#endif /* CCISS_DEBUG */ 
+#endif                          /* CCISS_DEBUG */
         c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
-        /* Update the field, and then ring the doorbell */ 
-        writel( CFGTBL_Trans_Simple, 
-                &(c->cfgtable->HostWrite.TransportRequest));
-        writel( CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
+        /* Update the field, and then ring the doorbell */
+        writel(CFGTBL_Trans_Simple, &(c->cfgtable->HostWrite.TransportRequest));
+        writel(CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
 
         /* under certain very rare conditions, this can take awhile.
          * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
          * as we enter this code.) */
-        for(i=0;i<MAX_CONFIG_WAIT;i++) {
+        for (i = 0; i < MAX_CONFIG_WAIT; i++) {
                 if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
                         break;
                 /* delay and try again */
                 set_current_state(TASK_INTERRUPTIBLE);
                 schedule_timeout(10);
-        }       
+        }
 
 #ifdef CCISS_DEBUG
-        printk(KERN_DEBUG "I counter got to %d %x\n", i, readl(c->vaddr + SA5_DOORBELL));
-#endif /* CCISS_DEBUG */
+        printk(KERN_DEBUG "I counter got to %d %x\n", i,
+               readl(c->vaddr + SA5_DOORBELL));
+#endif                          /* CCISS_DEBUG */
 #ifdef CCISS_DEBUG
-        print_cfg_table(c->cfgtable);   
-#endif /* CCISS_DEBUG */ 
+        print_cfg_table(c->cfgtable);
+#endif                          /* CCISS_DEBUG */
 
-        if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple))
-        {
+        if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple)) {
                 printk(KERN_WARNING "cciss: unable to get board into"
-                                        " simple mode\n");
-                return -1;
+                       " simple mode\n");
+                err = -ENODEV;
+                goto err_out_free_res;
         }
         return 0;
 
+      err_out_free_res:
+        pci_release_regions(pdev);
+
+      err_out_disable_pdev:
+        pci_disable_device(pdev);
+        return err;
 }
 
-/* 
- * Gets information about the local volumes attached to the controller. 
- */ 
+/*
+ * Gets information about the local volumes attached to the controller.
+ */
 static void cciss_getgeometry(int cntl_num)
 {
         ReportLunData_struct *ld_buff;
@@ -2938,102 +2949,102 @@ static void cciss_getgeometry(int cntl_num)
         int listlength = 0;
         __u32 lunid = 0;
         int block_size;
-        int total_size; 
+        int total_size;
 
         ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
-        if (ld_buff == NULL)
-        {
+        if (ld_buff == NULL) {
+                printk(KERN_ERR "cciss: out of memory\n");
+                return;
+        }
+        size_buff = kmalloc(sizeof(ReadCapdata_struct), GFP_KERNEL);
+        if (size_buff == NULL) {
                 printk(KERN_ERR "cciss: out of memory\n");
+                kfree(ld_buff);
                 return;
         }
-        size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
-        if (size_buff == NULL)
-        {
-                printk(KERN_ERR "cciss: out of memory\n");
+        inq_buff = kmalloc(sizeof(InquiryData_struct), GFP_KERNEL);
+        if (inq_buff == NULL) {
+                printk(KERN_ERR "cciss: out of memory\n");
                 kfree(ld_buff);
-                return;
-        }
-        inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
-        if (inq_buff == NULL)
-        {
-                printk(KERN_ERR "cciss: out of memory\n");
-                kfree(ld_buff);
                 kfree(size_buff);
-                return;
-        }
-        /* Get the firmware version */ 
-        return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff, 
-                sizeof(InquiryData_struct), 0, 0 ,0, NULL, TYPE_CMD);
-        if (return_code == IO_OK)
-        {
+                return;
+        }
+        /* Get the firmware version */
+        return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,
+                              sizeof(InquiryData_struct), 0, 0, 0, NULL,
+                              TYPE_CMD);
+        if (return_code == IO_OK) {
                 hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
                 hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
                 hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
                 hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
-        } else /* send command failed */
-        {
+        } else {                /* send command failed */
+
                 printk(KERN_WARNING "cciss: unable to determine firmware"
-                        " version of controller\n");
+                       " version of controller\n");
         }
-        /* Get the number of logical volumes */ 
-        return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff, 
-                        sizeof(ReportLunData_struct), 0, 0, 0, NULL, TYPE_CMD);
+        /* Get the number of logical volumes */
+        return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff,
+                              sizeof(ReportLunData_struct), 0, 0, 0, NULL,
+                              TYPE_CMD);
 
-        if( return_code == IO_OK)
-        {
+        if (return_code == IO_OK) {
 #ifdef CCISS_DEBUG
                 printk("LUN Data\n--------------------------\n");
-#endif /* CCISS_DEBUG */ 
-
-                listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
-                listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
-                listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;  
+#endif                          /* CCISS_DEBUG */
+
+                listlength |=
+                    (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
+                listlength |=
+                    (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
+                listlength |=
+                    (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
                 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
-        } else /* reading number of logical volumes failed */
-        {
+        } else {                /* reading number of logical volumes failed */
+
                 printk(KERN_WARNING "cciss: report logical volume"
-                        " command failed\n");
+                       " command failed\n");
                 listlength = 0;
         }
-        hba[cntl_num]->num_luns = listlength / 8; // 8 bytes pre entry
-        if (hba[cntl_num]->num_luns > CISS_MAX_LUN)
-        {
-                printk(KERN_ERR "ciss:  only %d number of logical volumes supported\n",
-                        CISS_MAX_LUN);
+        hba[cntl_num]->num_luns = listlength / 8;       // 8 bytes pre entry
+        if (hba[cntl_num]->num_luns > CISS_MAX_LUN) {
+                printk(KERN_ERR
+                       "ciss:  only %d number of logical volumes supported\n",
+                       CISS_MAX_LUN);
                 hba[cntl_num]->num_luns = CISS_MAX_LUN;
         }
 #ifdef CCISS_DEBUG
-        printk(KERN_DEBUG "Length = %x %x %x %x = %d\n", ld_buff->LUNListLength[0],
-                ld_buff->LUNListLength[1], ld_buff->LUNListLength[2],
-                ld_buff->LUNListLength[3],  hba[cntl_num]->num_luns);
-#endif /* CCISS_DEBUG */
-
-        hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns-1;
-//      for(i=0; i<  hba[cntl_num]->num_luns; i++)
-        for(i=0; i < CISS_MAX_LUN; i++)
-        {
-                if (i < hba[cntl_num]->num_luns){
-                        lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
-                                 << 24;
-                        lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
-                                 << 16;
-                        lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
-                                 << 8;
-                lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
-                
-                hba[cntl_num]->drv[i].LunID = lunid;
-
+        printk(KERN_DEBUG "Length = %x %x %x %x = %d\n",
+               ld_buff->LUNListLength[0], ld_buff->LUNListLength[1],
+               ld_buff->LUNListLength[2], ld_buff->LUNListLength[3],
+               hba[cntl_num]->num_luns);
+#endif                          /* CCISS_DEBUG */
+
+        hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns - 1;
+//      for(i=0; i<  hba[cntl_num]->num_luns; i++)
+        for (i = 0; i < CISS_MAX_LUN; i++) {
+                if (i < hba[cntl_num]->num_luns) {
+                        lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
+                            << 24;
+                        lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
+                            << 16;
+                        lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
+                            << 8;
+                        lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
+
+                        hba[cntl_num]->drv[i].LunID = lunid;
 
 #ifdef CCISS_DEBUG
-                printk(KERN_DEBUG "LUN[%d]:  %x %x %x %x = %x\n", i, 
-                        ld_buff->LUN[i][0], ld_buff->LUN[i][1],
-                        ld_buff->LUN[i][2], ld_buff->LUN[i][3],
-                        hba[cntl_num]->drv[i].LunID);
-#endif /* CCISS_DEBUG */
-                cciss_read_capacity(cntl_num, i, size_buff, 0,
-                        &total_size, &block_size);
+                        printk(KERN_DEBUG "LUN[%d]:  %x %x %x %x = %x\n", i,
+                               ld_buff->LUN[i][0], ld_buff->LUN[i][1],
+                               ld_buff->LUN[i][2], ld_buff->LUN[i][3],
+                               hba[cntl_num]->drv[i].LunID);
+#endif                          /* CCISS_DEBUG */
+                        cciss_read_capacity(cntl_num, i, size_buff, 0,
+                                            &total_size, &block_size);
                         cciss_geometry_inquiry(cntl_num, i, 0, total_size,
-                                block_size, inq_buff, &hba[cntl_num]->drv[i]);
+                                               block_size, inq_buff,
+                                               &hba[cntl_num]->drv[i]);
                 } else {
                         /* initialize raid_level to indicate a free space */
                         hba[cntl_num]->drv[i].raid_level = -1;
@@ -3042,7 +3053,7 @@ static void cciss_getgeometry(int cntl_num)
         kfree(ld_buff);
         kfree(size_buff);
         kfree(inq_buff);
-}       
+}
 
 /* Function to find the first free pointer into our hba[] array */
 /* Returns -1 if no free entries are left.  */
@@ -3056,7 +3067,7 @@ static int alloc_cciss_hba(void)
                         goto out;
         }
 
-        for(i=0; i< MAX_CTLR; i++) {
+        for (i = 0; i < MAX_CTLR; i++) {
                 if (!hba[i]) {
                         ctlr_info_t *p;
                         p = kzalloc(sizeof(ctlr_info_t), GFP_KERNEL);
@@ -3069,11 +3080,11 @@ static int alloc_cciss_hba(void)
                 }
         }
         printk(KERN_WARNING "cciss: This driver supports a maximum"
-                " of %d controllers.\n", MAX_CTLR);
+               " of %d controllers.\n", MAX_CTLR);
         goto out;
-Enomem:
+      Enomem:
         printk(KERN_ERR "cciss: out of memory.\n");
-out:
+      out:
         while (n--)
                 put_disk(disk[n]);
         return -1;
@@ -3096,20 +3107,17 @@ static void free_hba(int i)
  *  returns the number of block devices registered.
  */
 static int __devinit cciss_init_one(struct pci_dev *pdev,
-        const struct pci_device_id *ent)
+                                    const struct pci_device_id *ent)
 {
         request_queue_t *q;
         int i;
         int j;
         int rc;
+        int dac;
 
-        printk(KERN_DEBUG "cciss: Device 0x%x has been found at"
-                        " bus %d dev %d func %d\n",
-                pdev->device, pdev->bus->number, PCI_SLOT(pdev->devfn),
-                        PCI_FUNC(pdev->devfn));
         i = alloc_cciss_hba();
-        if(i < 0)
-                return (-1);
+        if (i < 0)
+                return -1;
 
         hba[i]->busy_initializing = 1;
 
@@ -3122,11 +3130,11 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
 
         /* configure PCI DMA stuff */
         if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
-                printk("cciss: using DAC cycles\n");
+                dac = 1;
         else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
-                printk("cciss: not using DAC cycles\n");
+                dac = 0;
         else {
-                printk("cciss: no suitable DMA available\n");
+                printk(KERN_ERR "cciss: no suitable DMA available\n");
                 goto clean1;
         }
 
@@ -3138,60 +3146,69 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
         if (i < MAX_CTLR_ORIG)
                 hba[i]->major = COMPAQ_CISS_MAJOR + i;
         rc = register_blkdev(hba[i]->major, hba[i]->devname);
-        if(rc == -EBUSY || rc == -EINVAL) {
+        if (rc == -EBUSY || rc == -EINVAL) {
                 printk(KERN_ERR
-                        "cciss:  Unable to get major number %d for %s "
-                        "on hba %d\n", hba[i]->major, hba[i]->devname, i);
+                       "cciss:  Unable to get major number %d for %s "
+                       "on hba %d\n", hba[i]->major, hba[i]->devname, i);
                 goto clean1;
-        }
-        else {
+        } else {
                 if (i >= MAX_CTLR_ORIG)
                         hba[i]->major = rc;
         }
 
         /* make sure the board interrupts are off */
         hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
-        if( request_irq(hba[i]->intr[SIMPLE_MODE_INT], do_cciss_intr,
-                SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM, 
-                        hba[i]->devname, hba[i])) {
+        if (request_irq(hba[i]->intr[SIMPLE_MODE_INT], do_cciss_intr,
+                        SA_INTERRUPT | SA_SHIRQ, hba[i]->devname, hba[i])) {
                 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
-                        hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname);
+                       hba[i]->intr[SIMPLE_MODE_INT], hba[i]->devname);
                 goto clean2;
         }
-        hba[i]->cmd_pool_bits = kmalloc(((NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG)*sizeof(unsigned long), GFP_KERNEL);
-        hba[i]->cmd_pool = (CommandList_struct *)pci_alloc_consistent(
-                hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct), 
-                &(hba[i]->cmd_pool_dhandle));
-        hba[i]->errinfo_pool = (ErrorInfo_struct *)pci_alloc_consistent(
-                hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct), 
-                &(hba[i]->errinfo_pool_dhandle));
-        if((hba[i]->cmd_pool_bits == NULL) 
-                || (hba[i]->cmd_pool == NULL)
-                || (hba[i]->errinfo_pool == NULL)) {
-                printk( KERN_ERR "cciss: out of memory");
+
+        printk(KERN_INFO "%s: <0x%x> at PCI %s IRQ %d%s using DAC\n",
+               hba[i]->devname, pdev->device, pci_name(pdev),
+               hba[i]->intr[SIMPLE_MODE_INT], dac ? "" : " not");
+
+        hba[i]->cmd_pool_bits =
+            kmalloc(((NR_CMDS + BITS_PER_LONG -
+                      1) / BITS_PER_LONG) * sizeof(unsigned long), GFP_KERNEL);
+        hba[i]->cmd_pool = (CommandList_struct *)
+            pci_alloc_consistent(hba[i]->pdev,
+                    NR_CMDS * sizeof(CommandList_struct),
+                    &(hba[i]->cmd_pool_dhandle));
+        hba[i]->errinfo_pool = (ErrorInfo_struct *)
+            pci_alloc_consistent(hba[i]->pdev,
+                    NR_CMDS * sizeof(ErrorInfo_struct),
+                    &(hba[i]->errinfo_pool_dhandle));
+        if ((hba[i]->cmd_pool_bits == NULL)
+            || (hba[i]->cmd_pool == NULL)
+            || (hba[i]->errinfo_pool == NULL)) {
+                printk(KERN_ERR "cciss: out of memory");
                 goto clean4;
         }
 #ifdef CONFIG_CISS_SCSI_TAPE
-        hba[i]->scsi_rejects.complete = 
-                kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) * 
-                        (NR_CMDS + 5), GFP_KERNEL);
+        hba[i]->scsi_rejects.complete =
+            kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
+                    (NR_CMDS + 5), GFP_KERNEL);
         if (hba[i]->scsi_rejects.complete == NULL) {
-                printk( KERN_ERR "cciss: out of memory");
+                printk(KERN_ERR "cciss: out of memory");
                 goto clean4;
         }
 #endif
         spin_lock_init(&hba[i]->lock);
 
-        /* Initialize the pdev driver private data. 
-                have it point to hba[i].  */
+        /* Initialize the pdev driver private data.
+           have it point to hba[i].  */
         pci_set_drvdata(pdev, hba[i]);
-        /* command and error info recs zeroed out before 
-                        they are used */
-        memset(hba[i]->cmd_pool_bits, 0, ((NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG)*sizeof(unsigned long));
+        /* command and error info recs zeroed out before
+           they are used */
+        memset(hba[i]->cmd_pool_bits, 0,
+               ((NR_CMDS + BITS_PER_LONG -
+                 1) / BITS_PER_LONG) * sizeof(unsigned long));
 
-#ifdef CCISS_DEBUG      
-        printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n",i);
-#endif /* CCISS_DEBUG */
+#ifdef CCISS_DEBUG
+        printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n", i);
+#endif                          /* CCISS_DEBUG */
 
         cciss_getgeometry(i);
 
@@ -3203,15 +3220,15 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
         cciss_procinit(i);
         hba[i]->busy_initializing = 0;
 
-        for(j=0; j < NWD; j++) { /* mfm */
+        for (j = 0; j < NWD; j++) {     /* mfm */
                 drive_info_struct *drv = &(hba[i]->drv[j]);
                 struct gendisk *disk = hba[i]->gendisk[j];
 
                 q = blk_init_queue(do_cciss_request, &hba[i]->lock);
                 if (!q) {
                         printk(KERN_ERR
-                           "cciss:  unable to allocate queue for disk %d\n",
-                           j);
+                               "cciss:  unable to allocate queue for disk %d\n",
+                               j);
                         break;
                 }
                 drv->queue = q;
@@ -3240,92 +3257,87 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
                 disk->driverfs_dev = &pdev->dev;
                 /* we must register the controller even if no disks exist */
                 /* this is for the online array utilities */
-                if(!drv->heads && j)
+                if (!drv->heads && j)
                         continue;
                 blk_queue_hardsect_size(q, drv->block_size);
                 set_capacity(disk, drv->nr_blocks);
                 add_disk(disk);
         }
 
-        return(1);
+        return 1;
 
-clean4:
+      clean4:
 #ifdef CONFIG_CISS_SCSI_TAPE
         kfree(hba[i]->scsi_rejects.complete);
 #endif
         kfree(hba[i]->cmd_pool_bits);
-        if(hba[i]->cmd_pool)
+        if (hba[i]->cmd_pool)
                 pci_free_consistent(hba[i]->pdev,
-                        NR_CMDS * sizeof(CommandList_struct),
-                        hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
-        if(hba[i]->errinfo_pool)
+                                    NR_CMDS * sizeof(CommandList_struct),
+                                    hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
+        if (hba[i]->errinfo_pool)
                 pci_free_consistent(hba[i]->pdev,
-                        NR_CMDS * sizeof( ErrorInfo_struct),
-                        hba[i]->errinfo_pool,
-                        hba[i]->errinfo_pool_dhandle);
+                                    NR_CMDS * sizeof(ErrorInfo_struct),
+                                    hba[i]->errinfo_pool,
+                                    hba[i]->errinfo_pool_dhandle);
         free_irq(hba[i]->intr[SIMPLE_MODE_INT], hba[i]);
-clean2:
+      clean2:
         unregister_blkdev(hba[i]->major, hba[i]->devname);
-clean1:
-        release_io_mem(hba[i]);
+      clean1:
         hba[i]->busy_initializing = 0;
         free_hba(i);
-        return(-1);
+        return -1;
 }
 
-static void __devexit cciss_remove_one (struct pci_dev *pdev)
+static void __devexit cciss_remove_one(struct pci_dev *pdev)
 {
         ctlr_info_t *tmp_ptr;
         int i, j;
         char flush_buf[4];
-        int return_code; 
+        int return_code;
 
-        if (pci_get_drvdata(pdev) == NULL)
-        {
-                printk( KERN_ERR "cciss: Unable to remove device \n");
+        if (pci_get_drvdata(pdev) == NULL) {
+                printk(KERN_ERR "cciss: Unable to remove device \n");
                 return;
         }
         tmp_ptr = pci_get_drvdata(pdev);
         i = tmp_ptr->ctlr;
-        if (hba[i] == NULL) 
-        {
+        if (hba[i] == NULL) {
                 printk(KERN_ERR "cciss: device appears to "
-                        "already be removed \n");
+                       "already be removed \n");
                 return;
         }
         /* Turn board interrupts off  and send the flush cache command */
         /* sendcmd will turn off interrupt, and send the flush...
-        * To write all data in the battery backed cache to disks */
+         * To write all data in the battery backed cache to disks */
         memset(flush_buf, 0, 4);
         return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
-                                TYPE_CMD);
-        if(return_code != IO_OK)
-        {
-                printk(KERN_WARNING "Error Flushing cache on controller %d\n", 
-                        i);
+                              TYPE_CMD);
+        if (return_code != IO_OK) {
+                printk(KERN_WARNING "Error Flushing cache on controller %d\n",
+                       i);
         }
         free_irq(hba[i]->intr[2], hba[i]);
 
 #ifdef CONFIG_PCI_MSI
-        if (hba[i]->msix_vector)
-                pci_disable_msix(hba[i]->pdev);
-        else if (hba[i]->msi_vector)
-                pci_disable_msi(hba[i]->pdev);
-#endif /* CONFIG_PCI_MSI */
+        if (hba[i]->msix_vector)
+                pci_disable_msix(hba[i]->pdev);
+        else if (hba[i]->msi_vector)
+                pci_disable_msi(hba[i]->pdev);
+#endif                          /* CONFIG_PCI_MSI */
 
-        pci_set_drvdata(pdev, NULL);
         iounmap(hba[i]->vaddr);
-        cciss_unregister_scsi(i);  /* unhook from SCSI subsystem */
+        cciss_unregister_scsi(i);       /* unhook from SCSI subsystem */
         unregister_blkdev(hba[i]->major, hba[i]->devname);
-        remove_proc_entry(hba[i]->devname, proc_cciss); 
-        
+        remove_proc_entry(hba[i]->devname, proc_cciss);
+
         /* remove it from the disk list */
         for (j = 0; j < NWD; j++) {
                 struct gendisk *disk = hba[i]->gendisk[j];
                 if (disk) {
                         request_queue_t *q = disk->queue;
 
-                        if (disk->flags & GENHD_FL_UP) 
+                        if (disk->flags & GENHD_FL_UP)
                                 del_gendisk(disk);
                         if (q)
                                 blk_cleanup_queue(q);
@@ -3334,26 +3346,28 @@ static void __devexit cciss_remove_one (struct pci_dev *pdev)
 
         pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct),
                             hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
-        pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct),
-                hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
+        pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof(ErrorInfo_struct),
+                            hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
         kfree(hba[i]->cmd_pool_bits);
 #ifdef CONFIG_CISS_SCSI_TAPE
         kfree(hba[i]->scsi_rejects.complete);
 #endif
-        release_io_mem(hba[i]);
+        pci_release_regions(pdev);
+        pci_disable_device(pdev);
+        pci_set_drvdata(pdev, NULL);
         free_hba(i);
-}       
+}
 
 static struct pci_driver cciss_pci_driver = {
-        .name =         "cciss",
-        .probe =        cciss_init_one,
-        .remove =       __devexit_p(cciss_remove_one),
-        .id_table =     cciss_pci_device_id, /* id_table */
+        .name = "cciss",
+        .probe = cciss_init_one,
+        .remove = __devexit_p(cciss_remove_one),
+        .id_table = cciss_pci_device_id,        /* id_table */
 };
 
 /*
  *  This is it.  Register the PCI driver information for the cards we control
- *  the OS will call our registered routines when it finds one of our cards. 
+ *  the OS will call our registered routines when it finds one of our cards.
  */
 static int __init cciss_init(void)
 {
@@ -3369,12 +3383,10 @@ static void __exit cciss_cleanup(void)
 
         pci_unregister_driver(&cciss_pci_driver);
         /* double check that all controller entrys have been removed */
-        for (i=0; i< MAX_CTLR; i++) 
-        {
-                if (hba[i] != NULL)
-                {
+        for (i = 0; i < MAX_CTLR; i++) {
+                if (hba[i] != NULL) {
                         printk(KERN_WARNING "cciss: had to remove"
-                                        " controller %d\n", i);
+                               " controller %d\n", i);
                         cciss_remove_one(hba[i]->pdev);
                 }
         }
@@ -3389,21 +3401,21 @@ static void fail_all_cmds(unsigned long ctlr)
         unsigned long flags;
 
         printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr);
-        h->alive = 0;   /* the controller apparently died... */
+        h->alive = 0;           /* the controller apparently died... */
 
         spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
 
-        pci_disable_device(h->pdev); /* Make sure it is really dead. */
+        pci_disable_device(h->pdev);    /* Make sure it is really dead. */
 
         /* move everything off the request queue onto the completed queue */
-        while( (c = h->reqQ) != NULL ) {
+        while ((c = h->reqQ) != NULL) {
                 removeQ(&(h->reqQ), c);
                 h->Qdepth--;
-                addQ (&(h->cmpQ), c);
+                addQ(&(h->cmpQ), c);
         }
 
         /* Now, fail everything on the completed queue with a HW error */
-        while( (c = h->cmpQ) != NULL ) {
+        while ((c = h->cmpQ) != NULL) {
                 removeQ(&h->cmpQ, c);
                 c->err_info->CommandStatus = CMD_HARDWARE_ERR;
                 if (c->cmd_type == CMD_RWREQ) {
@@ -3411,8 +3423,8 @@ static void fail_all_cmds(unsigned long ctlr)
                 } else if (c->cmd_type == CMD_IOCTL_PEND)
                         complete(c->waiting);
 #ifdef CONFIG_CISS_SCSI_TAPE
-                        else if (c->cmd_type == CMD_SCSI)
-                                complete_scsi_command(c, 0, 0);
+                else if (c->cmd_type == CMD_SCSI)
+                        complete_scsi_command(c, 0, 0);
 #endif
         }
         spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
diff --git a/drivers/block/cciss.h b/drivers/block/cciss.h
index b24fc0553ccf..868e0d862b0d 100644
--- a/drivers/block/cciss.h
+++ b/drivers/block/cciss.h
@@ -60,8 +60,6 @@ struct ctlr_info
         __u32   board_id;
         void __iomem *vaddr;
         unsigned long paddr;
-        unsigned long io_mem_addr;
-        unsigned long io_mem_length;
         CfgTable_struct __iomem *cfgtable;
         int     interrupts_enabled;
         int     major;
diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index b6ea2f0c7276..5eb6fb7b5cfa 100644
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -392,7 +392,7 @@ static void __devexit cpqarray_remove_one_eisa (int i)
 }
 
 /* pdev is NULL for eisa */
-static int cpqarray_register_ctlr( int i, struct pci_dev *pdev)
+static int __init cpqarray_register_ctlr( int i, struct pci_dev *pdev)
 {
         request_queue_t *q;
         int j;
@@ -410,8 +410,7 @@ static int cpqarray_register_ctlr( int i, struct pci_dev *pdev)
         }
         hba[i]->access.set_intr_mask(hba[i], 0);
         if (request_irq(hba[i]->intr, do_ida_intr,
-                SA_INTERRUPT|SA_SHIRQ|SA_SAMPLE_RANDOM,
-                hba[i]->devname, hba[i]))
+                SA_INTERRUPT|SA_SHIRQ, hba[i]->devname, hba[i]))
         {
                 printk(KERN_ERR "cpqarray: Unable to get irq %d for %s\n",
                                 hba[i]->intr, hba[i]->devname);
@@ -745,7 +744,7 @@ __setup("smart2=", cpqarray_setup);
 /*
  * Find an EISA controller's signature.  Set up an hba if we find it.
  */
-static int cpqarray_eisa_detect(void)
+static int __init cpqarray_eisa_detect(void)
 {
         int i=0, j;
         __u32 board_id;
@@ -1036,6 +1035,8 @@ static inline void complete_command(cmdlist_t *cmd, int timeout)
 
         complete_buffers(cmd->rq->bio, ok);
 
+        add_disk_randomness(cmd->rq->rq_disk);
+
         DBGPX(printk("Done with %p\n", cmd->rq););
         end_that_request_last(cmd->rq, ok ? 1 : -EIO);
 }
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 3c74ea729fc7..9dc294a74953 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -74,6 +74,7 @@
 #include <linux/completion.h>
 #include <linux/highmem.h>
 #include <linux/gfp.h>
+#include <linux/kthread.h>
 
 #include <asm/uaccess.h>
 
@@ -578,8 +579,6 @@ static int loop_thread(void *data)
         struct loop_device *lo = data;
         struct bio *bio;
 
-        daemonize("loop%d", lo->lo_number);
-
         /*
          * loop can be used in an encrypted device,
          * hence, it mustn't be stopped at all
@@ -592,11 +591,6 @@ static int loop_thread(void *data)
         lo->lo_state = Lo_bound;
         lo->lo_pending = 1;
 
-        /*
-         * complete it, we are running
-         */
-        complete(&lo->lo_done);
-
         for (;;) {
                 int pending;
 
@@ -629,7 +623,6 @@ static int loop_thread(void *data)
                         break;
         }
 
-        complete(&lo->lo_done);
         return 0;
 }
 
@@ -746,6 +739,7 @@ static int loop_set_fd(struct loop_device *lo, struct file *lo_file,
         unsigned lo_blocksize;
         int             lo_flags = 0;
         int             error;
+        struct task_struct *tsk;
         loff_t          size;
 
         /* This is safe, since we have a reference from open(). */
@@ -839,10 +833,11 @@ static int loop_set_fd(struct loop_device *lo, struct file *lo_file,
 
         set_blocksize(bdev, lo_blocksize);
 
-        error = kernel_thread(loop_thread, lo, CLONE_KERNEL);
-        if (error < 0)
+        tsk = kthread_run(loop_thread, lo, "loop%d", lo->lo_number);
+        if (IS_ERR(tsk)) {
+                error = PTR_ERR(tsk);
                 goto out_putf;
-        wait_for_completion(&lo->lo_done);
+        }
         return 0;
 
  out_putf:
@@ -898,6 +893,9 @@ static int loop_clr_fd(struct loop_device *lo, struct block_device *bdev)
         if (lo->lo_state != Lo_bound)
                 return -ENXIO;
 
+        if (!lo->lo_thread)
+                return -EINVAL;
+
         if (lo->lo_refcnt > 1)  /* we needed one fd for the ioctl */
                 return -EBUSY;
 
@@ -911,7 +909,7 @@ static int loop_clr_fd(struct loop_device *lo, struct block_device *bdev)
                 complete(&lo->lo_bh_done);
         spin_unlock_irq(&lo->lo_lock);
 
-        wait_for_completion(&lo->lo_done);
+        kthread_stop(lo->lo_thread);
 
         lo->lo_backing_file = NULL;
 
@@ -924,6 +922,7 @@ static int loop_clr_fd(struct loop_device *lo, struct block_device *bdev)
         lo->lo_sizelimit = 0;
         lo->lo_encrypt_key_size = 0;
         lo->lo_flags = 0;
+        lo->lo_thread = NULL;
         memset(lo->lo_encrypt_key, 0, LO_KEY_SIZE);
         memset(lo->lo_crypt_name, 0, LO_NAME_SIZE);
         memset(lo->lo_file_name, 0, LO_NAME_SIZE);
@@ -1288,7 +1287,6 @@ static int __init loop_init(void)
                 if (!lo->lo_queue)
                         goto out_mem4;
                 mutex_init(&lo->lo_ctl_mutex);
-                init_completion(&lo->lo_done);
                 init_completion(&lo->lo_bh_done);
                 lo->lo_number = i;
                 spin_lock_init(&lo->lo_lock);
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 8bca4905d7f7..7f554f2ed079 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -7,39 +7,9 @@
  * Copyright 1997-2000 Pavel Machek <pavel@ucw.cz>
  * Parts copyright 2001 Steven Whitehouse <steve@chygwyn.com>
  *
- * (part of code stolen from loop.c)
+ * This file is released under GPLv2 or later.
  *
- * 97-3-25 compiled 0-th version, not yet tested it 
- *   (it did not work, BTW) (later that day) HEY! it works!
- *   (bit later) hmm, not that much... 2:00am next day:
- *   yes, it works, but it gives something like 50kB/sec
- * 97-4-01 complete rewrite to make it possible for many requests at 
- *   once to be processed
- * 97-4-11 Making protocol independent of endianity etc.
- * 97-9-13 Cosmetic changes
- * 98-5-13 Attempt to make 64-bit-clean on 64-bit machines
- * 99-1-11 Attempt to make 64-bit-clean on 32-bit machines <ankry@mif.pg.gda.pl>
- * 01-2-27 Fix to store proper blockcount for kernel (calculated using
- *   BLOCK_SIZE_BITS, not device blocksize) <aga@permonline.ru>
- * 01-3-11 Make nbd work with new Linux block layer code. It now supports
- *   plugging like all the other block devices. Also added in MSG_MORE to
- *   reduce number of partial TCP segments sent. <steve@chygwyn.com>
- * 01-12-6 Fix deadlock condition by making queue locks independent of
- *   the transmit lock. <steve@chygwyn.com>
- * 02-10-11 Allow hung xmit to be aborted via SIGKILL & various fixes.
- *   <Paul.Clements@SteelEye.com> <James.Bottomley@SteelEye.com>
- * 03-06-22 Make nbd work with new linux 2.5 block layer design. This fixes
- *   memory corruption from module removal and possible memory corruption
- *   from sending/receiving disk data. <ldl@aros.net>
- * 03-06-23 Cosmetic changes. <ldl@aros.net>
- * 03-06-23 Enhance diagnostics support. <ldl@aros.net>
- * 03-06-24 Remove unneeded blksize_bits field from nbd_device struct.
- *   <ldl@aros.net>
- * 03-06-24 Cleanup PARANOIA usage & code. <ldl@aros.net>
- * 04-02-19 Remove PARANOIA, plus various cleanups (Paul Clements)
- * possible FIXME: make set_sock / set_blksize / set_size / do_it one syscall
- * why not: would need access_ok and friends, would share yet another
- *          structure with userland
+ * (part of code stolen from loop.c)
  */
 
 #include <linux/major.h>
diff --git a/drivers/cdrom/mcdx.c b/drivers/cdrom/mcdx.c
index a0b580c22d80..0f6e7aab8d2c 100644
--- a/drivers/cdrom/mcdx.c
+++ b/drivers/cdrom/mcdx.c
@@ -1006,7 +1006,7 @@ static int mcdx_talk(struct s_drive_stuff *stuffp,
 
 /* MODULE STUFF ***********************************************************/
 
-int __mcdx_init(void)
+static int __init __mcdx_init(void)
 {
         int i;
         int drives = 0;
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 78d928f9d9f1..63f28d169b36 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -865,6 +865,7 @@ config SONYPI
 config TANBAC_TB0219
         tristate "TANBAC TB0219 base board support"
         depends TANBAC_TB022X
+        select GPIO_VR41XX
 
 menu "Ftape, the floppy tape device driver"
 
diff --git a/drivers/char/applicom.c b/drivers/char/applicom.c
index a370e7a0bad5..9275d5e52e6d 100644
--- a/drivers/char/applicom.c
+++ b/drivers/char/applicom.c
@@ -166,11 +166,7 @@ static int ac_register_board(unsigned long physloc, void __iomem *loc,
         return boardno + 1;
 }
 
-#ifdef MODULE
-
-#define applicom_init init_module
-
-void cleanup_module(void)
+static void __exit applicom_exit(void)
 {
         unsigned int i;
 
@@ -188,9 +184,7 @@ void cleanup_module(void)
         }
 }
 
-#endif                          /* MODULE */
-
-int __init applicom_init(void)
+static int __init applicom_init(void)
 {
         int i, numisa = 0;
         struct pci_dev *dev = NULL;
@@ -355,10 +349,9 @@ out:
         return ret;
 }
 
+module_init(applicom_init);
+module_exit(applicom_exit);
 
-#ifndef MODULE
-__initcall(applicom_init);
-#endif
 
 static ssize_t ac_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos)
 {
@@ -851,28 +844,3 @@ static int ac_ioctl(struct inode *inode, struct file *file, unsigned int cmd, un
         return 0;
 }
 
-#ifndef MODULE
-static int __init applicom_setup(char *str)
-{
-        int ints[4];
-
-        (void) get_options(str, 4, ints);
-
-        if (ints[0] > 2) {
-                printk(KERN_WARNING "Too many arguments to 'applicom=', expected mem,irq only.\n");
-        }
-
-        if (ints[0] < 2) {
-                printk(KERN_INFO"applicom numargs: %d\n", ints[0]);
-                return 0;
-        }
-
-        mem = ints[1];
-        irq = ints[2];
-        return 1;
-}
-
-__setup("applicom=", applicom_setup);
-
-#endif                          /* MODULE */
-
diff --git a/drivers/char/cyclades.c b/drivers/char/cyclades.c
index cc7acf877dc0..122e7a72a4e1 100644
--- a/drivers/char/cyclades.c
+++ b/drivers/char/cyclades.c
@@ -2833,9 +2833,8 @@ cy_write(struct tty_struct * tty, const unsigned char *buf, int count)
         return 0;
     }
         
-    if (!tty || !info->xmit_buf || !tmp_buf){
-        return 0;
-    }
+    if (!info->xmit_buf || !tmp_buf)
+        return 0;
 
     CY_LOCK(info, flags);
     while (1) {
@@ -2884,7 +2883,7 @@ cy_put_char(struct tty_struct *tty, unsigned char ch)
     if (serial_paranoia_check(info, tty->name, "cy_put_char"))
         return;
 
-    if (!tty || !info->xmit_buf)
+    if (!info->xmit_buf)
         return;
 
     CY_LOCK(info, flags);
diff --git a/drivers/char/esp.c b/drivers/char/esp.c
index 09dc4b01232c..922174d527ae 100644
--- a/drivers/char/esp.c
+++ b/drivers/char/esp.c
@@ -1212,7 +1212,7 @@ static void rs_put_char(struct tty_struct *tty, unsigned char ch)
         if (serial_paranoia_check(info, tty->name, "rs_put_char"))
                 return;
 
-        if (!tty || !info->xmit_buf)
+        if (!info->xmit_buf)
                 return;
 
         spin_lock_irqsave(&info->lock, flags);
@@ -1256,7 +1256,7 @@ static int rs_write(struct tty_struct * tty,
         if (serial_paranoia_check(info, tty->name, "rs_write"))
                 return 0;
 
-        if (!tty || !info->xmit_buf)
+        if (!info->xmit_buf)
                 return 0;
             
         while (1) {
diff --git a/drivers/char/ip2/ip2main.c b/drivers/char/ip2/ip2main.c
index 03db1cb3fa95..9ab33c3d359f 100644
--- a/drivers/char/ip2/ip2main.c
+++ b/drivers/char/ip2/ip2main.c
@@ -305,7 +305,7 @@ static struct class *ip2_class;
 
 // Some functions to keep track of what irq's we have
 
-static int __init
+static int
 is_valid_irq(int irq)
 {
         int *i = Valid_Irqs;
@@ -316,14 +316,14 @@ is_valid_irq(int irq)
         return (*i);
 }
 
-static void __init
+static void
 mark_requested_irq( char irq )
 {
         rirqs[iindx++] = irq;
 }
 
 #ifdef MODULE
-static int __init
+static int
 clear_requested_irq( char irq )
 {
         int i;
@@ -337,7 +337,7 @@ clear_requested_irq( char irq )
 }
 #endif
 
-static int __init
+static int
 have_requested_irq( char irq )
 {
         // array init to zeros so 0 irq will not be requested as a side effect
@@ -818,7 +818,7 @@ EXPORT_SYMBOL(ip2_loadmain);
 /* the board, the channel structures are initialized, and the board details   */
 /* are reported on the console.                                               */
 /******************************************************************************/
-static void __init
+static void
 ip2_init_board( int boardnum )
 {
         int i;
@@ -961,7 +961,7 @@ err_initialize:
 /* EISA motherboard, or no valid board ID is selected it returns 0. Otherwise */
 /* it returns the base address of the controller.                             */
 /******************************************************************************/
-static unsigned short __init
+static unsigned short
 find_eisa_board( int start_slot )
 {
         int i, j;
diff --git a/drivers/char/isicom.c b/drivers/char/isicom.c
index e9ebabaf8cb0..efaaa1937ab6 100644
--- a/drivers/char/isicom.c
+++ b/drivers/char/isicom.c
@@ -1145,7 +1145,7 @@ static int isicom_write(struct tty_struct *tty,	const unsigned char *buf,
         if (isicom_paranoia_check(port, tty->name, "isicom_write"))
                 return 0;
 
-        if (!tty || !port->xmit_buf)
+        if (!port->xmit_buf)
                 return 0;
 
         spin_lock_irqsave(&card->card_lock, flags);
@@ -1180,7 +1180,7 @@ static void isicom_put_char(struct tty_struct *tty, unsigned char ch)
         if (isicom_paranoia_check(port, tty->name, "isicom_put_char"))
                 return;
 
-        if (!tty || !port->xmit_buf)
+        if (!port->xmit_buf)
                 return;
 
         spin_lock_irqsave(&card->card_lock, flags);
diff --git a/drivers/char/keyboard.c b/drivers/char/keyboard.c
index 5755b7e5f187..edd996f6fb87 100644
--- a/drivers/char/keyboard.c
+++ b/drivers/char/keyboard.c
@@ -39,6 +39,7 @@
 #include <linux/vt_kern.h>
 #include <linux/sysrq.h>
 #include <linux/input.h>
+#include <linux/reboot.h>
 
 static void kbd_disconnect(struct input_handle *handle);
 extern void ctrl_alt_del(void);
diff --git a/drivers/char/mmtimer.c b/drivers/char/mmtimer.c
index 1b05fa688996..d65b3109318a 100644
--- a/drivers/char/mmtimer.c
+++ b/drivers/char/mmtimer.c
@@ -329,7 +329,6 @@ static int mmtimer_mmap(struct file *file, struct vm_area_struct *vma)
         if (PAGE_SIZE > (1 << 16))
                 return -ENOSYS;
 
-        vma->vm_flags |= (VM_IO | VM_SHM | VM_LOCKED );
         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 
         mmtimer_addr = __pa(RTC_COUNTER_ADDR);
diff --git a/drivers/char/mxser.c b/drivers/char/mxser.c
index 0fb2fb9fb024..645d9d713aec 100644
--- a/drivers/char/mxser.c
+++ b/drivers/char/mxser.c
@@ -9,7 +9,7 @@
  *      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.
+ *      (at your option) any later version.
  *
  *      This program is distributed in the hope that it will be useful,
  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -71,8 +71,8 @@
 #define MXSERMAJOR       174
 #define MXSERCUMAJOR     175
 
-#define MXSER_EVENT_TXLOW        1
-#define MXSER_EVENT_HANGUP       2
+#define MXSER_EVENT_TXLOW       1
+#define MXSER_EVENT_HANGUP      2
 
 #define MXSER_BOARDS            4       /* Max. boards */
 #define MXSER_PORTS             32      /* Max. ports */
@@ -92,7 +92,8 @@
 #define UART_MCR_AFE            0x20
 #define UART_LSR_SPECIAL        0x1E
 
-#define RELEVANT_IFLAG(iflag)   (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK|IXON|IXOFF))
+#define RELEVANT_IFLAG(iflag)   (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK|\
+                                          IXON|IXOFF))
 
 #define IRQ_T(info) ((info->flags & ASYNC_SHARE_IRQ) ? SA_SHIRQ : SA_INTERRUPT)
 
@@ -152,27 +153,27 @@ static char *mxser_brdname[] = {
 };
 
 static int mxser_numports[] = {
-        8,                      // C168-ISA
-        4,                      // C104-ISA
-        4,                      // CI104J
-        8,                      // C168-PCI
-        4,                      // C104-PCI
-        2,                      // C102-ISA
-        2,                      // CI132
-        4,                      // CI134
-        2,                      // CP132
-        4,                      // CP114
-        4,                      // CT114
-        2,                      // CP102
-        4,                      // CP104U
-        8,                      // CP168U
-        2,                      // CP132U
-        4,                      // CP134U
-        4,                      // CP104JU
-        8,                      // RC7000
-        8,                      // CP118U 
-        2,                      // CP102UL 
-        2,                      // CP102U
+        8,                      /* C168-ISA */
+        4,                      /* C104-ISA */
+        4,                      /* CI104J */
+        8,                      /* C168-PCI */
+        4,                      /* C104-PCI */
+        2,                      /* C102-ISA */
+        2,                      /* CI132 */
+        4,                      /* CI134 */
+        2,                      /* CP132 */
+        4,                      /* CP114 */
+        4,                      /* CT114 */
+        2,                      /* CP102 */
+        4,                      /* CP104U */
+        8,                      /* CP168U */
+        2,                      /* CP132U */
+        4,                      /* CP134U */
+        4,                      /* CP104JU */
+        8,                      /* RC7000 */
+        8,                      /* CP118U */
+        2,                      /* CP102UL */
+        2,                      /* CP102U */
 };
 
 #define UART_TYPE_NUM   2
@@ -182,7 +183,7 @@ static const unsigned int Gmoxa_uart_id[UART_TYPE_NUM] = {
         MOXA_MUST_MU860_HWID
 };
 
-// This is only for PCI
+/* This is only for PCI */
 #define UART_INFO_NUM   3
 struct mxpciuart_info {
         int type;
@@ -231,7 +232,7 @@ MODULE_DEVICE_TABLE(pci, mxser_pcibrds);
 typedef struct _moxa_pci_info {
         unsigned short busNum;
         unsigned short devNum;
-        struct pci_dev *pdev;   // add by Victor Yu. 06-23-2003
+        struct pci_dev *pdev;   /* add by Victor Yu. 06-23-2003 */
 } moxa_pci_info;
 
 static int ioaddr[MXSER_BOARDS] = { 0, 0, 0, 0 };
@@ -280,6 +281,7 @@ struct mxser_mon_ext {
         int fifo[32];
         int iftype[32];
 };
+
 struct mxser_hwconf {
         int board_type;
         int ports;
@@ -290,9 +292,9 @@ struct mxser_hwconf {
         int ioaddr[MXSER_PORTS_PER_BOARD];
         int baud_base[MXSER_PORTS_PER_BOARD];
         moxa_pci_info pciInfo;
-        int IsMoxaMustChipFlag; // add by Victor Yu. 08-30-2002
-        int MaxCanSetBaudRate[MXSER_PORTS_PER_BOARD];   // add by Victor Yu. 09-04-2002
-        int opmode_ioaddr[MXSER_PORTS_PER_BOARD];       // add by Victor Yu. 01-05-2004
+        int IsMoxaMustChipFlag; /* add by Victor Yu. 08-30-2002 */
+        int MaxCanSetBaudRate[MXSER_PORTS_PER_BOARD];   /* add by Victor Yu. 09-04-2002 */
+        int opmode_ioaddr[MXSER_PORTS_PER_BOARD];       /* add by Victor Yu. 01-05-2004 */
 };
 
 struct mxser_struct {
@@ -334,9 +336,9 @@ struct mxser_struct {
         wait_queue_head_t delta_msr_wait;
         struct async_icount icount;     /* kernel counters for the 4 input interrupts */
         int timeout;
-        int IsMoxaMustChipFlag; // add by Victor Yu. 08-30-2002
-        int MaxCanSetBaudRate;  // add by Victor Yu. 09-04-2002
-        int opmode_ioaddr;      // add by Victor Yu. 01-05-2004
+        int IsMoxaMustChipFlag; /* add by Victor Yu. 08-30-2002 */
+        int MaxCanSetBaudRate;  /* add by Victor Yu. 09-04-2002 */
+        int opmode_ioaddr;      /* add by Victor Yu. 01-05-2004 */
         unsigned char stop_rx;
         unsigned char ldisc_stop_rx;
         long realbaud;
@@ -345,7 +347,6 @@ struct mxser_struct {
         spinlock_t slock;
 };
 
-
 struct mxser_mstatus {
         tcflag_t cflag;
         int cts;
@@ -358,7 +359,7 @@ static struct mxser_mstatus GMStatus[MXSER_PORTS];
 
 static int mxserBoardCAP[MXSER_BOARDS] = {
         0, 0, 0, 0
-            /*  0x180, 0x280, 0x200, 0x320   */
+        /*  0x180, 0x280, 0x200, 0x320 */
 };
 
 static struct tty_driver *mxvar_sdriver;
@@ -386,7 +387,7 @@ static struct mxser_hwconf mxsercfg[MXSER_BOARDS];
 static void mxser_getcfg(int board, struct mxser_hwconf *hwconf);
 static int mxser_init(void);
 
-//static void   mxser_poll(unsigned long);
+/* static void   mxser_poll(unsigned long); */
 static int mxser_get_ISA_conf(int, struct mxser_hwconf *);
 static int mxser_get_PCI_conf(int, int, int, struct mxser_hwconf *);
 static void mxser_do_softint(void *);
@@ -440,18 +441,18 @@ static int CheckIsMoxaMust(int io)
         SET_MOXA_MUST_XON1_VALUE(io, 0x11);
         if ((hwid = inb(io + UART_MCR)) != 0) {
                 outb(oldmcr, io + UART_MCR);
-                return (MOXA_OTHER_UART);
+                return MOXA_OTHER_UART;
         }
 
         GET_MOXA_MUST_HARDWARE_ID(io, &hwid);
         for (i = 0; i < UART_TYPE_NUM; i++) {
                 if (hwid == Gmoxa_uart_id[i])
-                        return (int) hwid;
+                        return (int)hwid;
         }
         return MOXA_OTHER_UART;
 }
 
-// above is modified by Victor Yu. 08-15-2002
+/* above is modified by Victor Yu. 08-15-2002 */
 
 static struct tty_operations mxser_ops = {
         .open = mxser_open,
@@ -504,7 +505,6 @@ static void __exit mxser_module_exit(void)
         else
                 printk(KERN_ERR "Couldn't unregister MOXA Smartio/Industio family serial driver\n");
 
-
         for (i = 0; i < MXSER_BOARDS; i++) {
                 struct pci_dev *pdev;
 
@@ -513,7 +513,7 @@ static void __exit mxser_module_exit(void)
                 else {
                         pdev = mxsercfg[i].pciInfo.pdev;
                         free_irq(mxsercfg[i].irq, &mxvar_table[i * MXSER_PORTS_PER_BOARD]);
-                        if (pdev != NULL) {     //PCI
+                        if (pdev != NULL) {     /* PCI */
                                 release_region(pci_resource_start(pdev, 2), pci_resource_len(pdev, 2));
                                 release_region(pci_resource_start(pdev, 3), pci_resource_len(pdev, 3));
                         } else {
@@ -524,7 +524,6 @@ static void __exit mxser_module_exit(void)
         }
         if (verbose)
                 printk(KERN_DEBUG "Done.\n");
-
 }
 
 static void process_txrx_fifo(struct mxser_struct *info)
@@ -558,8 +557,10 @@ static int mxser_initbrd(int board, struct mxser_hwconf *hwconf)
         n = board * MXSER_PORTS_PER_BOARD;
         info = &mxvar_table[n];
         /*if (verbose) */  {
-                printk(KERN_DEBUG "        ttyM%d - ttyM%d ", n, n + hwconf->ports - 1);
-                printk(" max. baud rate = %d bps.\n", hwconf->MaxCanSetBaudRate[0]);
+                printk(KERN_DEBUG "        ttyM%d - ttyM%d ",
+                        n, n + hwconf->ports - 1);
+                printk(" max. baud rate = %d bps.\n",
+                        hwconf->MaxCanSetBaudRate[0]);
         }
 
         for (i = 0; i < hwconf->ports; i++, n++, info++) {
@@ -568,12 +569,12 @@ static int mxser_initbrd(int board, struct mxser_hwconf *hwconf)
                 info->irq = hwconf->irq;
                 info->vector = hwconf->vector;
                 info->vectormask = hwconf->vector_mask;
-                info->opmode_ioaddr = hwconf->opmode_ioaddr[i]; // add by Victor Yu. 01-05-2004
+                info->opmode_ioaddr = hwconf->opmode_ioaddr[i]; /* add by Victor Yu. 01-05-2004 */
                 info->stop_rx = 0;
                 info->ldisc_stop_rx = 0;
 
                 info->IsMoxaMustChipFlag = hwconf->IsMoxaMustChipFlag;
-                //Enhance mode enabled here
+                /* Enhance mode enabled here */
                 if (info->IsMoxaMustChipFlag != MOXA_OTHER_UART) {
                         ENABLE_MOXA_MUST_ENCHANCE_MODE(info->base);
                 }
@@ -606,22 +607,25 @@ static int mxser_initbrd(int board, struct mxser_hwconf *hwconf)
 
         /* before set INT ISR, disable all int */
         for (i = 0; i < hwconf->ports; i++) {
-                outb(inb(hwconf->ioaddr[i] + UART_IER) & 0xf0, hwconf->ioaddr[i] + UART_IER);
+                outb(inb(hwconf->ioaddr[i] + UART_IER) & 0xf0,
+                        hwconf->ioaddr[i] + UART_IER);
         }
 
         n = board * MXSER_PORTS_PER_BOARD;
         info = &mxvar_table[n];
 
-        retval = request_irq(hwconf->irq, mxser_interrupt, IRQ_T(info), "mxser", info);
+        retval = request_irq(hwconf->irq, mxser_interrupt, IRQ_T(info),
+                                "mxser", info);
         if (retval) {
-                printk(KERN_ERR "Board %d: %s", board, mxser_brdname[hwconf->board_type - 1]);
-                printk("  Request irq fail,IRQ (%d) may be conflit with another device.\n", info->irq);
+                printk(KERN_ERR "Board %d: %s",
+                        board, mxser_brdname[hwconf->board_type - 1]);
+                printk("  Request irq failed, IRQ (%d) may conflict with"
+                        " another device.\n", info->irq);
                 return retval;
         }
         return 0;
 }
 
-
 static void mxser_getcfg(int board, struct mxser_hwconf *hwconf)
 {
         mxsercfg[board] = *hwconf;
@@ -631,26 +635,27 @@ static void mxser_getcfg(int board, struct mxser_hwconf *hwconf)
 static int mxser_get_PCI_conf(int busnum, int devnum, int board_type, struct mxser_hwconf *hwconf)
 {
         int i, j;
-//      unsigned int    val;
+        /* unsigned int val; */
         unsigned int ioaddress;
         struct pci_dev *pdev = hwconf->pciInfo.pdev;
 
-        //io address
+        /* io address */
         hwconf->board_type = board_type;
         hwconf->ports = mxser_numports[board_type - 1];
         ioaddress = pci_resource_start(pdev, 2);
-        request_region(pci_resource_start(pdev, 2), pci_resource_len(pdev, 2), "mxser(IO)");
+        request_region(pci_resource_start(pdev, 2), pci_resource_len(pdev, 2),
+                        "mxser(IO)");
 
-        for (i = 0; i < hwconf->ports; i++) {
+        for (i = 0; i < hwconf->ports; i++)
                 hwconf->ioaddr[i] = ioaddress + 8 * i;
-        }
 
-        //vector
+        /* vector */
         ioaddress = pci_resource_start(pdev, 3);
-        request_region(pci_resource_start(pdev, 3), pci_resource_len(pdev, 3), "mxser(vector)");
+        request_region(pci_resource_start(pdev, 3), pci_resource_len(pdev, 3),
+                        "mxser(vector)");
         hwconf->vector = ioaddress;
 
-        //irq
+        /* irq */
         hwconf->irq = hwconf->pciInfo.pdev->irq;
 
         hwconf->IsMoxaMustChipFlag = CheckIsMoxaMust(hwconf->ioaddr[0]);
@@ -663,7 +668,7 @@ static int mxser_get_PCI_conf(int busnum, int devnum, int board_type, struct mxs
                         if (Gpci_uart_info[j].type == hwconf->IsMoxaMustChipFlag) {
                                 hwconf->MaxCanSetBaudRate[i] = Gpci_uart_info[j].max_baud;
 
-                                //exception....CP-102
+                                /* exception....CP-102 */
                                 if (board_type == MXSER_BOARD_CP102)
                                         hwconf->MaxCanSetBaudRate[i] = 921600;
                                 break;
@@ -678,15 +683,15 @@ static int mxser_get_PCI_conf(int busnum, int devnum, int board_type, struct mxs
                         else
                                 hwconf->opmode_ioaddr[i] = ioaddress + 0x0c;
                 }
-                outb(0, ioaddress + 4); // default set to RS232 mode
-                outb(0, ioaddress + 0x0c);      //default set to RS232 mode
+                outb(0, ioaddress + 4); /* default set to RS232 mode */
+                outb(0, ioaddress + 0x0c);      /* default set to RS232 mode */
         }
 
         for (i = 0; i < hwconf->ports; i++) {
                 hwconf->vector_mask |= (1 << i);
                 hwconf->baud_base[i] = 921600;
         }
-        return (0);
+        return 0;
 }
 #endif
 
@@ -707,7 +712,8 @@ static int mxser_init(void)
                 mxsercfg[i].board_type = -1;
         }
 
-        printk(KERN_INFO "MOXA Smartio/Industio family driver version %s\n", MXSER_VERSION);
+        printk(KERN_INFO "MOXA Smartio/Industio family driver version %s\n",
+                MXSER_VERSION);
 
         /* Initialize the tty_driver structure */
         memset(mxvar_sdriver, 0, sizeof(struct tty_driver));
@@ -719,7 +725,7 @@ static int mxser_init(void)
         mxvar_sdriver->type = TTY_DRIVER_TYPE_SERIAL;
         mxvar_sdriver->subtype = SERIAL_TYPE_NORMAL;
         mxvar_sdriver->init_termios = tty_std_termios;
-        mxvar_sdriver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+        mxvar_sdriver->init_termios.c_cflag = B9600|CS8|CREAD|HUPCL|CLOCAL;
         mxvar_sdriver->flags = TTY_DRIVER_REAL_RAW;
         tty_set_operations(mxvar_sdriver, &mxser_ops);
         mxvar_sdriver->ttys = mxvar_tty;
@@ -739,23 +745,29 @@ static int mxser_init(void)
         /* Start finding ISA boards here */
         for (b = 0; b < MXSER_BOARDS && m < MXSER_BOARDS; b++) {
                 int cap;
+
                 if (!(cap = mxserBoardCAP[b]))
                         continue;
 
                 retval = mxser_get_ISA_conf(cap, &hwconf);
 
                 if (retval != 0)
-                        printk(KERN_INFO "Found MOXA %s board (CAP=0x%x)\n", mxser_brdname[hwconf.board_type - 1], ioaddr[b]);
+                        printk(KERN_INFO "Found MOXA %s board (CAP=0x%x)\n",
+                                mxser_brdname[hwconf.board_type - 1], ioaddr[b]);
 
                 if (retval <= 0) {
                         if (retval == MXSER_ERR_IRQ)
-                                printk(KERN_ERR "Invalid interrupt number,board not configured\n");
+                                printk(KERN_ERR "Invalid interrupt number, "
+                                        "board not configured\n");
                         else if (retval == MXSER_ERR_IRQ_CONFLIT)
-                                printk(KERN_ERR "Invalid interrupt number,board not configured\n");
+                                printk(KERN_ERR "Invalid interrupt number, "
+                                        "board not configured\n");
                         else if (retval == MXSER_ERR_VECTOR)
-                                printk(KERN_ERR "Invalid interrupt vector,board not configured\n");
+                                printk(KERN_ERR "Invalid interrupt vector, "
+                                        "board not configured\n");
                         else if (retval == MXSER_ERR_IOADDR)
-                                printk(KERN_ERR "Invalid I/O address,board not configured\n");
+                                printk(KERN_ERR "Invalid I/O address, "
+                                        "board not configured\n");
 
                         continue;
                 }
@@ -765,35 +777,43 @@ static int mxser_init(void)
                 hwconf.pciInfo.pdev = NULL;
 
                 mxser_getcfg(m, &hwconf);
-                //init mxsercfg first, or mxsercfg data is not correct on ISR.
-                //mxser_initbrd will hook ISR.
+                /*
+                 * init mxsercfg first,
+                 * or mxsercfg data is not correct on ISR.
+                 */
+                /* mxser_initbrd will hook ISR. */
                 if (mxser_initbrd(m, &hwconf) < 0)
                         continue;
 
-
                 m++;
         }
 
         /* Start finding ISA boards from module arg */
         for (b = 0; b < MXSER_BOARDS && m < MXSER_BOARDS; b++) {
                 int cap;
+
                 if (!(cap = ioaddr[b]))
                         continue;
 
                 retval = mxser_get_ISA_conf(cap, &hwconf);
 
                 if (retval != 0)
-                        printk(KERN_INFO "Found MOXA %s board (CAP=0x%x)\n", mxser_brdname[hwconf.board_type - 1], ioaddr[b]);
+                        printk(KERN_INFO "Found MOXA %s board (CAP=0x%x)\n",
+                                mxser_brdname[hwconf.board_type - 1], ioaddr[b]);
 
                 if (retval <= 0) {
                         if (retval == MXSER_ERR_IRQ)
-                                printk(KERN_ERR "Invalid interrupt number,board not configured\n");
+                                printk(KERN_ERR "Invalid interrupt number, "
+                                        "board not configured\n");
                         else if (retval == MXSER_ERR_IRQ_CONFLIT)
-                                printk(KERN_ERR "Invalid interrupt number,board not configured\n");
+                                printk(KERN_ERR "Invalid interrupt number, "
+                                        "board not configured\n");
                         else if (retval == MXSER_ERR_VECTOR)
-                                printk(KERN_ERR "Invalid interrupt vector,board not configured\n");
+                                printk(KERN_ERR "Invalid interrupt vector, "
+                                        "board not configured\n");
                         else if (retval == MXSER_ERR_IOADDR)
-                                printk(KERN_ERR "Invalid I/O address,board not configured\n");
+                                printk(KERN_ERR "Invalid I/O address, "
+                                        "board not configured\n");
 
                         continue;
                 }
@@ -803,8 +823,11 @@ static int mxser_init(void)
                 hwconf.pciInfo.pdev = NULL;
 
                 mxser_getcfg(m, &hwconf);
-                //init mxsercfg first, or mxsercfg data is not correct on ISR.
-                //mxser_initbrd will hook ISR.
+                /*
+                 * init mxsercfg first,
+                 * or mxsercfg data is not correct on ISR.
+                 */
+                /* mxser_initbrd will hook ISR. */
                 if (mxser_initbrd(m, &hwconf) < 0)
                         continue;
 
@@ -817,7 +840,8 @@ static int mxser_init(void)
         index = 0;
         b = 0;
         while (b < n) {
-                pdev = pci_find_device(mxser_pcibrds[b].vendor, mxser_pcibrds[b].device, pdev);
+                pdev = pci_find_device(mxser_pcibrds[b].vendor,
+                                mxser_pcibrds[b].device, pdev);
                         if (pdev == NULL) {
                         b++;
                         continue;
@@ -825,30 +849,48 @@ static int mxser_init(void)
                 hwconf.pciInfo.busNum = busnum = pdev->bus->number;
                 hwconf.pciInfo.devNum = devnum = PCI_SLOT(pdev->devfn) << 3;
                 hwconf.pciInfo.pdev = pdev;
-                printk(KERN_INFO "Found MOXA %s board(BusNo=%d,DevNo=%d)\n", mxser_brdname[(int) (mxser_pcibrds[b].driver_data) - 1], busnum, devnum >> 3);
+                printk(KERN_INFO "Found MOXA %s board(BusNo=%d,DevNo=%d)\n",
+                        mxser_brdname[(int) (mxser_pcibrds[b].driver_data) - 1],
+                        busnum, devnum >> 3);
                 index++;
-                if (m >= MXSER_BOARDS) {
-                        printk(KERN_ERR "Too many Smartio/Industio family boards find (maximum %d),board not configured\n", MXSER_BOARDS);
-                } else {
+                if (m >= MXSER_BOARDS)
+                        printk(KERN_ERR
+                                "Too many Smartio/Industio family boards find "
+                                "(maximum %d), board not configured\n",
+                                MXSER_BOARDS);
+                else {
                         if (pci_enable_device(pdev)) {
-                                printk(KERN_ERR "Moxa SmartI/O PCI enable fail !\n");
+                                printk(KERN_ERR "Moxa SmartI/O PCI enable "
+                                        "fail !\n");
                                 continue;
                         }
-                        retval = mxser_get_PCI_conf(busnum, devnum, (int) mxser_pcibrds[b].driver_data, &hwconf);
+                        retval = mxser_get_PCI_conf(busnum, devnum,
+                                        (int)mxser_pcibrds[b].driver_data,
+                                        &hwconf);
                         if (retval < 0) {
                                 if (retval == MXSER_ERR_IRQ)
-                                        printk(KERN_ERR "Invalid interrupt number,board not configured\n");
+                                        printk(KERN_ERR
+                                                "Invalid interrupt number, "
+                                                "board not configured\n");
                                 else if (retval == MXSER_ERR_IRQ_CONFLIT)
-                                        printk(KERN_ERR "Invalid interrupt number,board not configured\n");
+                                        printk(KERN_ERR
+                                                "Invalid interrupt number, "
+                                                "board not configured\n");
                                 else if (retval == MXSER_ERR_VECTOR)
-                                        printk(KERN_ERR "Invalid interrupt vector,board not configured\n");
+                                        printk(KERN_ERR
+                                                "Invalid interrupt vector, "
+                                                "board not configured\n");
                                 else if (retval == MXSER_ERR_IOADDR)
-                                        printk(KERN_ERR "Invalid I/O address,board not configured\n");
+                                        printk(KERN_ERR
+                                                "Invalid I/O address, "
+                                                "board not configured\n");
                                 continue;
                         }
                         mxser_getcfg(m, &hwconf);
-                        //init mxsercfg first, or mxsercfg data is not correct on ISR.
-                        //mxser_initbrd will hook ISR.
+                        /* init mxsercfg first,
+                         * or mxsercfg data is not correct on ISR.
+                         */
+                        /* mxser_initbrd will hook ISR. */
                         if (mxser_initbrd(m, &hwconf) < 0)
                                 continue;
                         m++;
@@ -858,7 +900,8 @@ static int mxser_init(void)
 
         retval = tty_register_driver(mxvar_sdriver);
         if (retval) {
-                printk(KERN_ERR "Couldn't install MOXA Smartio/Industio family driver !\n");
+                printk(KERN_ERR "Couldn't install MOXA Smartio/Industio family"
+                                " driver !\n");
                 put_tty_driver(mxvar_sdriver);
 
                 for (i = 0; i < MXSER_BOARDS; i++) {
@@ -866,7 +909,7 @@ static int mxser_init(void)
                                 continue;
                         else {
                                 free_irq(mxsercfg[i].irq, &mxvar_table[i * MXSER_PORTS_PER_BOARD]);
-                                //todo: release io, vector
+                                /* todo: release io, vector */
                         }
                 }
                 return retval;
@@ -877,7 +920,7 @@ static int mxser_init(void)
 
 static void mxser_do_softint(void *private_)
 {
-        struct mxser_struct *info = (struct mxser_struct *) private_;
+        struct mxser_struct *info = private_;
         struct tty_struct *tty;
 
         tty = info->tty;
@@ -926,7 +969,7 @@ static int mxser_open(struct tty_struct *tty, struct file *filp)
                 return -ENODEV;
         info = mxvar_table + line;
         if (!info->base)
-                return (-ENODEV);
+                return -ENODEV;
 
         tty->driver_data = info;
         info->tty = tty;
@@ -935,11 +978,11 @@ static int mxser_open(struct tty_struct *tty, struct file *filp)
          */
         retval = mxser_startup(info);
         if (retval)
-                return (retval);
+                return retval;
 
         retval = mxser_block_til_ready(tty, filp, info);
         if (retval)
-                return (retval);
+                return retval;
 
         info->count++;
 
@@ -955,11 +998,12 @@ static int mxser_open(struct tty_struct *tty, struct file *filp)
         info->pgrp = process_group(current);
         clear_bit(TTY_DONT_FLIP, &tty->flags);
 
-        //status = mxser_get_msr(info->base, 0, info->port);
-        //mxser_check_modem_status(info, status);
+        /*
+        status = mxser_get_msr(info->base, 0, info->port);
+        mxser_check_modem_status(info, status);
+        */
 
-/* unmark here for very high baud rate (ex. 921600 bps) used
-*/
+/* unmark here for very high baud rate (ex. 921600 bps) used */
         tty->low_latency = 1;
         return 0;
 }
@@ -972,7 +1016,7 @@ static int mxser_open(struct tty_struct *tty, struct file *filp)
  */
 static void mxser_close(struct tty_struct *tty, struct file *filp)
 {
-        struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
+        struct mxser_struct *info = tty->driver_data;
 
         unsigned long timeout;
         unsigned long flags;
@@ -997,11 +1041,13 @@ static void mxser_close(struct tty_struct *tty, struct file *filp)
                  * one, we've got real problems, since it means the
                  * serial port won't be shutdown.
                  */
-                printk(KERN_ERR "mxser_close: bad serial port count; tty->count is 1, " "info->count is %d\n", info->count);
+                printk(KERN_ERR "mxser_close: bad serial port count; "
+                        "tty->count is 1, info->count is %d\n", info->count);
                 info->count = 1;
         }
         if (--info->count < 0) {
-                printk(KERN_ERR "mxser_close: bad serial port count for ttys%d: %d\n", info->port, info->count);
+                printk(KERN_ERR "mxser_close: bad serial port count for "
+                        "ttys%d: %d\n", info->port, info->count);
                 info->count = 0;
         }
         if (info->count) {
@@ -1056,7 +1102,7 @@ static void mxser_close(struct tty_struct *tty, struct file *filp)
                 
         ld = tty_ldisc_ref(tty);
         if (ld) {
-                if(ld->flush_buffer)
+                if (ld->flush_buffer)
                         ld->flush_buffer(tty);
                 tty_ldisc_deref(ld);
         }
@@ -1078,31 +1124,34 @@ static void mxser_close(struct tty_struct *tty, struct file *filp)
 static int mxser_write(struct tty_struct *tty, const unsigned char *buf, int count)
 {
         int c, total = 0;
-        struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
+        struct mxser_struct *info = tty->driver_data;
         unsigned long flags;
 
-        if (!tty || !info->xmit_buf)
-                return (0);
+        if (!info->xmit_buf)
+                return 0;
 
         while (1) {
-                c = min_t(int, count, min(SERIAL_XMIT_SIZE - info->xmit_cnt - 1, SERIAL_XMIT_SIZE - info->xmit_head));
+                c = min_t(int, count, min(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
+                                          SERIAL_XMIT_SIZE - info->xmit_head));
                 if (c <= 0)
                         break;
 
                 memcpy(info->xmit_buf + info->xmit_head, buf, c);
                 spin_lock_irqsave(&info->slock, flags);
-                info->xmit_head = (info->xmit_head + c) & (SERIAL_XMIT_SIZE - 1);
+                info->xmit_head = (info->xmit_head + c) &
+                                  (SERIAL_XMIT_SIZE - 1);
                 info->xmit_cnt += c;
                 spin_unlock_irqrestore(&info->slock, flags);
 
                 buf += c;
                 count -= c;
                 total += c;
-
         }
 
         if (info->xmit_cnt && !tty->stopped && !(info->IER & UART_IER_THRI)) {
-                if (!tty->hw_stopped || (info->type == PORT_16550A) || (info->IsMoxaMustChipFlag)) {
+                if (!tty->hw_stopped ||
+                                (info->type == PORT_16550A) ||
+                                (info->IsMoxaMustChipFlag)) {
                         spin_lock_irqsave(&info->slock, flags);
                         info->IER |= UART_IER_THRI;
                         outb(info->IER, info->base + UART_IER);
@@ -1114,10 +1163,10 @@ static int mxser_write(struct tty_struct *tty, const unsigned char *buf, int cou
 
 static void mxser_put_char(struct tty_struct *tty, unsigned char ch)
 {
-        struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
+        struct mxser_struct *info = tty->driver_data;
         unsigned long flags;
 
-        if (!tty || !info->xmit_buf)
+        if (!info->xmit_buf)
                 return;
 
         if (info->xmit_cnt >= SERIAL_XMIT_SIZE - 1)
@@ -1129,7 +1178,9 @@ static void mxser_put_char(struct tty_struct *tty, unsigned char ch)
         info->xmit_cnt++;
         spin_unlock_irqrestore(&info->slock, flags);
         if (!tty->stopped && !(info->IER & UART_IER_THRI)) {
-                if (!tty->hw_stopped || (info->type == PORT_16550A) || info->IsMoxaMustChipFlag) {
+                if (!tty->hw_stopped ||
+                                (info->type == PORT_16550A) ||
+                                info->IsMoxaMustChipFlag) {
                         spin_lock_irqsave(&info->slock, flags);
                         info->IER |= UART_IER_THRI;
                         outb(info->IER, info->base + UART_IER);
@@ -1141,10 +1192,16 @@ static void mxser_put_char(struct tty_struct *tty, unsigned char ch)
 
 static void mxser_flush_chars(struct tty_struct *tty)
 {
-        struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
+        struct mxser_struct *info = tty->driver_data;
         unsigned long flags;
 
-        if (info->xmit_cnt <= 0 || tty->stopped || !info->xmit_buf || (tty->hw_stopped && (info->type != PORT_16550A) && (!info->IsMoxaMustChipFlag)))
+        if (info->xmit_cnt <= 0 ||
+                        tty->stopped ||
+                        !info->xmit_buf ||
+                        (tty->hw_stopped &&
+                         (info->type != PORT_16550A) &&
+                         (!info->IsMoxaMustChipFlag)
+                        ))
                 return;
 
         spin_lock_irqsave(&info->slock, flags);
@@ -1157,24 +1214,24 @@ static void mxser_flush_chars(struct tty_struct *tty)
 
 static int mxser_write_room(struct tty_struct *tty)
 {
-        struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
+        struct mxser_struct *info = tty->driver_data;
         int ret;
 
         ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
         if (ret < 0)
                 ret = 0;
-        return (ret);
+        return ret;
 }
 
 static int mxser_chars_in_buffer(struct tty_struct *tty)
 {
-        struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
+        struct mxser_struct *info = tty->driver_data;
         return info->xmit_cnt;
 }
 
 static void mxser_flush_buffer(struct tty_struct *tty)
 {
-        struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
+        struct mxser_struct *info = tty->driver_data;
         char fcr;
         unsigned long flags;
 
@@ -1184,7 +1241,8 @@ static void mxser_flush_buffer(struct tty_struct *tty)
 
         /* below added by shinhay */
         fcr = inb(info->base + UART_FCR);
-        outb((fcr | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT), info->base + UART_FCR);
+        outb((fcr | UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT),
+                info->base + UART_FCR);
         outb(fcr, info->base + UART_FCR);
 
         spin_unlock_irqrestore(&info->slock, flags);
@@ -1197,7 +1255,7 @@ static void mxser_flush_buffer(struct tty_struct *tty)
 
 static int mxser_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
 {
-        struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
+        struct mxser_struct *info = tty->driver_data;
         int retval;
         struct async_icount cprev, cnow;        /* kernel counter temps */
         struct serial_icounter_struct __user *p_cuser;
@@ -1206,9 +1264,9 @@ static int mxser_ioctl(struct tty_struct *tty, struct file *file, unsigned int c
         void __user *argp = (void __user *)arg;
 
         if (tty->index == MXSER_PORTS)
-                return (mxser_ioctl_special(cmd, argp));
+                return mxser_ioctl_special(cmd, argp);
 
-        // following add by Victor Yu. 01-05-2004
+        /* following add by Victor Yu. 01-05-2004 */
         if (cmd == MOXA_SET_OP_MODE || cmd == MOXA_GET_OP_MODE) {
                 int opmode, p;
                 static unsigned char ModeMask[] = { 0xfc, 0xf3, 0xcf, 0x3f };
@@ -1219,7 +1277,10 @@ static int mxser_ioctl(struct tty_struct *tty, struct file *file, unsigned int c
                 if (cmd == MOXA_SET_OP_MODE) {
                         if (get_user(opmode, (int __user *) argp))
                                 return -EFAULT;
-                        if (opmode != RS232_MODE && opmode != RS485_2WIRE_MODE && opmode != RS422_MODE && opmode != RS485_4WIRE_MODE)
+                        if (opmode != RS232_MODE &&
+                                        opmode != RS485_2WIRE_MODE &&
+                                        opmode != RS422_MODE &&
+                                        opmode != RS485_4WIRE_MODE)
                                 return -EFAULT;
                         mask = ModeMask[p];
                         shiftbit = p * 2;
@@ -1236,36 +1297,36 @@ static int mxser_ioctl(struct tty_struct *tty, struct file *file, unsigned int c
                 }
                 return 0;
         }
-        // above add by Victor Yu. 01-05-2004
+        /* above add by Victor Yu. 01-05-2004 */
 
         if ((cmd != TIOCGSERIAL) && (cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
                 if (tty->flags & (1 << TTY_IO_ERROR))
-                        return (-EIO);
+                        return -EIO;
         }
         switch (cmd) {
         case TCSBRK:            /* SVID version: non-zero arg --> no break */
                 retval = tty_check_change(tty);
                 if (retval)
-                        return (retval);
+                        return retval;
                 tty_wait_until_sent(tty, 0);
                 if (!arg)
                         mxser_send_break(info, HZ / 4); /* 1/4 second */
-                return (0);
+                return 0;
         case TCSBRKP:           /* support for POSIX tcsendbreak() */
                 retval = tty_check_change(tty);
                 if (retval)
-                        return (retval);
+                        return retval;
                 tty_wait_until_sent(tty, 0);
                 mxser_send_break(info, arg ? arg * (HZ / 10) : HZ / 4);
-                return (0);
+                return 0;
         case TIOCGSOFTCAR:
-                return put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long __user *) argp);
+                return put_user(C_CLOCAL(tty) ? 1 : 0, (unsigned long __user *)argp);
         case TIOCSSOFTCAR:
                 if (get_user(templ, (unsigned long __user *) argp))
                         return -EFAULT;
                 arg = templ;
                 tty->termios->c_cflag = ((tty->termios->c_cflag & ~CLOCAL) | (arg ? CLOCAL : 0));
-                return (0);
+                return 0;
         case TIOCGSERIAL:
                 return mxser_get_serial_info(info, argp);
         case TIOCSSERIAL:
@@ -1278,7 +1339,7 @@ static int mxser_ioctl(struct tty_struct *tty, struct file *file, unsigned int c
                  *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
                  * Caller should use TIOCGICOUNT to see which one it was
                  */
-        case TIOCMIWAIT:{
+        case TIOCMIWAIT: {
                         DECLARE_WAITQUEUE(wait, current);
                         int ret;
                         spin_lock_irqsave(&info->slock, flags);
@@ -1292,7 +1353,14 @@ static int mxser_ioctl(struct tty_struct *tty, struct file *file, unsigned int c
                                 spin_unlock_irqrestore(&info->slock, flags);
 
                                 set_current_state(TASK_INTERRUPTIBLE);
-                                if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) || ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) || ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) || ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
+                                if (((arg & TIOCM_RNG) &&
+                                                (cnow.rng != cprev.rng)) ||
+                                                ((arg & TIOCM_DSR) &&
+                                                (cnow.dsr != cprev.dsr)) ||
+                                                ((arg & TIOCM_CD) &&
+                                                (cnow.dcd != cprev.dcd)) ||
+                                                ((arg & TIOCM_CTS) &&
+                                                (cnow.cts != cprev.cts))) {
                                         ret = 0;
                                         break;
                                 }
@@ -1338,21 +1406,18 @@ static int mxser_ioctl(struct tty_struct *tty, struct file *file, unsigned int c
                 put_user(cnow.dsr, &p_cuser->dsr);
                 put_user(cnow.rng, &p_cuser->rng);
                 put_user(cnow.dcd, &p_cuser->dcd);
-
-/* */
                 return 0;
         case MOXA_HighSpeedOn:
-                return put_user(info->baud_base != 115200 ? 1 : 0, (int __user *) argp);
-
-        case MOXA_SDS_RSTICOUNTER:{
+                return put_user(info->baud_base != 115200 ? 1 : 0, (int __user *)argp);
+        case MOXA_SDS_RSTICOUNTER: {
                         info->mon_data.rxcnt = 0;
                         info->mon_data.txcnt = 0;
                         return 0;
                 }
-// (above) added by James.
+/* (above) added by James. */
         case MOXA_ASPP_SETBAUD:{
                         long baud;
-                        if (get_user(baud, (long __user *) argp))
+                        if (get_user(baud, (long __user *)argp))
                                 return -EFAULT;
                         mxser_set_baud(info, baud);
                         return 0;
@@ -1377,9 +1442,10 @@ static int mxser_ioctl(struct tty_struct *tty, struct file *file, unsigned int c
 
                         return 0;
                 }
-        case MOXA_ASPP_MON:{
+        case MOXA_ASPP_MON: {
                         int mcr, status;
-//      info->mon_data.ser_param = tty->termios->c_cflag;
+
+                        /* info->mon_data.ser_param = tty->termios->c_cflag; */
 
                         status = mxser_get_msr(info->base, 1, info->port, info);
                         mxser_check_modem_status(info, status);
@@ -1400,25 +1466,25 @@ static int mxser_ioctl(struct tty_struct *tty, struct file *file, unsigned int c
                         else
                                 info->mon_data.hold_reason &= ~NPPI_NOTIFY_CTSHOLD;
 
-
-                        if (copy_to_user(argp, &info->mon_data, sizeof(struct mxser_mon)))
+                        if (copy_to_user(argp, &info->mon_data,
+                                        sizeof(struct mxser_mon)))
                                 return -EFAULT;
 
                         return 0;
-
                 }
 
-        case MOXA_ASPP_LSTATUS:{
-                        if (copy_to_user(argp, &info->err_shadow, sizeof(unsigned char)))
+        case MOXA_ASPP_LSTATUS: {
+                        if (copy_to_user(argp, &info->err_shadow,
+                                        sizeof(unsigned char)))
                                 return -EFAULT;
 
                         info->err_shadow = 0;
                         return 0;
-
                 }
-        case MOXA_SET_BAUD_METHOD:{
+        case MOXA_SET_BAUD_METHOD: {
                         int method;
-                        if (get_user(method, (int __user *) argp))
+
+                        if (get_user(method, (int __user *)argp))
                                 return -EFAULT;
                         mxser_set_baud_method[info->port] = method;
                         if (copy_to_user(argp, &method, sizeof(int)))
@@ -1442,7 +1508,8 @@ static int mxser_ioctl_special(unsigned int cmd, void __user *argp)
 
         switch (cmd) {
         case MOXA_GET_CONF:
-                if (copy_to_user(argp, mxsercfg, sizeof(struct mxser_hwconf) * 4))
+                if (copy_to_user(argp, mxsercfg,
+                                sizeof(struct mxser_hwconf) * 4))
                         return -EFAULT;
                 return 0;
         case MOXA_GET_MAJOR:
@@ -1461,11 +1528,11 @@ static int mxser_ioctl_special(unsigned int cmd, void __user *argp)
                         if (mxvar_table[i].base)
                                 result |= (1 << i);
                 }
-                return put_user(result, (unsigned long __user *) argp);
+                return put_user(result, (unsigned long __user *)argp);
         case MOXA_GETDATACOUNT:
                 if (copy_to_user(argp, &mxvar_log, sizeof(mxvar_log)))
                         return -EFAULT;
-                return (0);
+                return 0;
         case MOXA_GETMSTATUS:
                 for (i = 0; i < MXSER_PORTS; i++) {
                         GMStatus[i].ri = 0;
@@ -1498,22 +1565,26 @@ static int mxser_ioctl_special(unsigned int cmd, void __user *argp)
                         else
                                 GMStatus[i].cts = 0;
                 }
-                if (copy_to_user(argp, GMStatus, sizeof(struct mxser_mstatus) * MXSER_PORTS))
+                if (copy_to_user(argp, GMStatus,
+                                sizeof(struct mxser_mstatus) * MXSER_PORTS))
                         return -EFAULT;
                 return 0;
-        case MOXA_ASPP_MON_EXT:{
+        case MOXA_ASPP_MON_EXT: {
                         int status;
                         int opmode, p;
                         int shiftbit;
                         unsigned cflag, iflag;
 
                         for (i = 0; i < MXSER_PORTS; i++) {
-
                                 if (!mxvar_table[i].base)
                                         continue;
 
-                                status = mxser_get_msr(mxvar_table[i].base, 0, i, &(mxvar_table[i]));
-//                      mxser_check_modem_status(&mxvar_table[i], status);
+                                status = mxser_get_msr(mxvar_table[i].base, 0,
+                                                        i, &(mxvar_table[i]));
+                                /*
+                                mxser_check_modem_status(&mxvar_table[i],
+                                                                status);
+                                */
                                 if (status & UART_MSR_TERI)
                                         mxvar_table[i].icount.rng++;
                                 if (status & UART_MSR_DDSR)
@@ -1578,75 +1649,76 @@ static int mxser_ioctl_special(unsigned int cmd, void __user *argp)
         return 0;
 }
 
-
 static void mxser_stoprx(struct tty_struct *tty)
 {
-        struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
-        //unsigned long flags;
-
+        struct mxser_struct *info = tty->driver_data;
+        /* unsigned long flags; */
 
         info->ldisc_stop_rx = 1;
         if (I_IXOFF(tty)) {
-
-                //MX_LOCK(&info->slock);
-                // following add by Victor Yu. 09-02-2002
+                /* MX_LOCK(&info->slock); */
+                /* following add by Victor Yu. 09-02-2002 */
                 if (info->IsMoxaMustChipFlag) {
                         info->IER &= ~MOXA_MUST_RECV_ISR;
                         outb(info->IER, info->base + UART_IER);
                 } else {
-                        // above add by Victor Yu. 09-02-2002
-
+                        /* above add by Victor Yu. 09-02-2002 */
                         info->x_char = STOP_CHAR(tty);
-                        //      outb(info->IER, 0); // mask by Victor Yu. 09-02-2002
+                        /* mask by Victor Yu. 09-02-2002 */
+                        /* outb(info->IER, 0); */
                         outb(0, info->base + UART_IER);
                         info->IER |= UART_IER_THRI;
-                        outb(info->IER, info->base + UART_IER); /* force Tx interrupt */
-                }               // add by Victor Yu. 09-02-2002
-                //MX_UNLOCK(&info->slock);
+                        /* force Tx interrupt */
+                        outb(info->IER, info->base + UART_IER);
+                }               /* add by Victor Yu. 09-02-2002 */
+                /* MX_UNLOCK(&info->slock); */
         }
 
         if (info->tty->termios->c_cflag & CRTSCTS) {
-                //MX_LOCK(&info->slock);
+                /* MX_LOCK(&info->slock); */
                 info->MCR &= ~UART_MCR_RTS;
                 outb(info->MCR, info->base + UART_MCR);
-                //MX_UNLOCK(&info->slock);
+                /* MX_UNLOCK(&info->slock); */
         }
 }
 
 static void mxser_startrx(struct tty_struct *tty)
 {
-        struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
-        //unsigned long flags;
+        struct mxser_struct *info = tty->driver_data;
+        /* unsigned long flags; */
 
         info->ldisc_stop_rx = 0;
         if (I_IXOFF(tty)) {
                 if (info->x_char)
                         info->x_char = 0;
                 else {
-                        //MX_LOCK(&info->slock);
+                        /* MX_LOCK(&info->slock); */
 
-                        // following add by Victor Yu. 09-02-2002
+                        /* following add by Victor Yu. 09-02-2002 */
                         if (info->IsMoxaMustChipFlag) {
                                 info->IER |= MOXA_MUST_RECV_ISR;
                                 outb(info->IER, info->base + UART_IER);
                         } else {
-                                // above add by Victor Yu. 09-02-2002
+                                /* above add by Victor Yu. 09-02-2002 */
 
                                 info->x_char = START_CHAR(tty);
-                                //          outb(info->IER, 0); // mask by Victor Yu. 09-02-2002
-                                outb(0, info->base + UART_IER); // add by Victor Yu. 09-02-2002
-                                info->IER |= UART_IER_THRI;     /* force Tx interrupt */
+                                /* mask by Victor Yu. 09-02-2002 */
+                                /* outb(info->IER, 0); */
+                                /* add by Victor Yu. 09-02-2002 */
+                                outb(0, info->base + UART_IER);
+                                /* force Tx interrupt */
+                                info->IER |= UART_IER_THRI;
                                 outb(info->IER, info->base + UART_IER);
-                        }       // add by Victor Yu. 09-02-2002
-                        //MX_UNLOCK(&info->slock);
+                        }       /* add by Victor Yu. 09-02-2002 */
+                        /* MX_UNLOCK(&info->slock); */
                 }
         }
 
         if (info->tty->termios->c_cflag & CRTSCTS) {
-                //MX_LOCK(&info->slock);
+                /* MX_LOCK(&info->slock); */
                 info->MCR |= UART_MCR_RTS;
                 outb(info->MCR, info->base + UART_MCR);
-                //MX_UNLOCK(&info->slock);
+                /* MX_UNLOCK(&info->slock); */
         }
 }
 
@@ -1656,48 +1728,53 @@ static void mxser_startrx(struct tty_struct *tty)
  */
 static void mxser_throttle(struct tty_struct *tty)
 {
-        //struct mxser_struct *info = (struct mxser_struct *)tty->driver_data;
-        //unsigned long flags;
-        //MX_LOCK(&info->slock);
+        /* struct mxser_struct *info = tty->driver_data; */
+        /* unsigned long flags; */
+
+        /* MX_LOCK(&info->slock); */
         mxser_stoprx(tty);
-        //MX_UNLOCK(&info->slock);
+        /* MX_UNLOCK(&info->slock); */
 }
 
 static void mxser_unthrottle(struct tty_struct *tty)
 {
-        //struct mxser_struct *info = (struct mxser_struct *)tty->driver_data;
-        //unsigned long flags;
-        //MX_LOCK(&info->slock);
+        /* struct mxser_struct *info = tty->driver_data; */
+        /* unsigned long flags; */
+
+        /* MX_LOCK(&info->slock); */
         mxser_startrx(tty);
-        //MX_UNLOCK(&info->slock);
+        /* MX_UNLOCK(&info->slock); */
 }
 
 static void mxser_set_termios(struct tty_struct *tty, struct termios *old_termios)
 {
-        struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
+        struct mxser_struct *info = tty->driver_data;
         unsigned long flags;
 
-        if ((tty->termios->c_cflag != old_termios->c_cflag) || (RELEVANT_IFLAG(tty->termios->c_iflag) != RELEVANT_IFLAG(old_termios->c_iflag))) {
+        if ((tty->termios->c_cflag != old_termios->c_cflag) ||
+                        (RELEVANT_IFLAG(tty->termios->c_iflag) != RELEVANT_IFLAG(old_termios->c_iflag))) {
 
                 mxser_change_speed(info, old_termios);
 
-                if ((old_termios->c_cflag & CRTSCTS) && !(tty->termios->c_cflag & CRTSCTS)) {
+                if ((old_termios->c_cflag & CRTSCTS) &&
+                                !(tty->termios->c_cflag & CRTSCTS)) {
                         tty->hw_stopped = 0;
                         mxser_start(tty);
                 }
         }
 
 /* Handle sw stopped */
-        if ((old_termios->c_iflag & IXON) && !(tty->termios->c_iflag & IXON)) {
+        if ((old_termios->c_iflag & IXON) &&
+                        !(tty->termios->c_iflag & IXON)) {
                 tty->stopped = 0;
 
-                // following add by Victor Yu. 09-02-2002
+                /* following add by Victor Yu. 09-02-2002 */
                 if (info->IsMoxaMustChipFlag) {
                         spin_lock_irqsave(&info->slock, flags);
                         DISABLE_MOXA_MUST_RX_SOFTWARE_FLOW_CONTROL(info->base);
                         spin_unlock_irqrestore(&info->slock, flags);
                 }
-                // above add by Victor Yu. 09-02-2002
+                /* above add by Victor Yu. 09-02-2002 */
 
                 mxser_start(tty);
         }
@@ -1711,7 +1788,7 @@ static void mxser_set_termios(struct tty_struct *tty, struct termios *old_termio
  */
 static void mxser_stop(struct tty_struct *tty)
 {
-        struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
+        struct mxser_struct *info = tty->driver_data;
         unsigned long flags;
 
         spin_lock_irqsave(&info->slock, flags);
@@ -1724,7 +1801,7 @@ static void mxser_stop(struct tty_struct *tty)
 
 static void mxser_start(struct tty_struct *tty)
 {
-        struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
+        struct mxser_struct *info = tty->driver_data;
         unsigned long flags;
 
         spin_lock_irqsave(&info->slock, flags);
@@ -1740,7 +1817,7 @@ static void mxser_start(struct tty_struct *tty)
  */
 static void mxser_wait_until_sent(struct tty_struct *tty, int timeout)
 {
-        struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
+        struct mxser_struct *info = tty->driver_data;
         unsigned long orig_jiffies, char_time;
         int lsr;
 
@@ -1777,7 +1854,8 @@ static void mxser_wait_until_sent(struct tty_struct *tty, int timeout)
         if (!timeout || timeout > 2 * info->timeout)
                 timeout = 2 * info->timeout;
 #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
-        printk(KERN_DEBUG "In rs_wait_until_sent(%d) check=%lu...", timeout, char_time);
+        printk(KERN_DEBUG "In rs_wait_until_sent(%d) check=%lu...",
+                timeout, char_time);
         printk("jiff=%lu...", jiffies);
 #endif
         while (!((lsr = inb(info->base + UART_LSR)) & UART_LSR_TEMT)) {
@@ -1803,7 +1881,7 @@ static void mxser_wait_until_sent(struct tty_struct *tty, int timeout)
  */
 void mxser_hangup(struct tty_struct *tty)
 {
-        struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
+        struct mxser_struct *info = tty->driver_data;
 
         mxser_flush_buffer(tty);
         mxser_shutdown(info);
@@ -1815,24 +1893,26 @@ void mxser_hangup(struct tty_struct *tty)
 }
 
 
-// added by James 03-12-2004.
+/* added by James 03-12-2004. */
 /*
  * mxser_rs_break() --- routine which turns the break handling on or off
  */
 static void mxser_rs_break(struct tty_struct *tty, int break_state)
 {
-        struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
+        struct mxser_struct *info = tty->driver_data;
         unsigned long flags;
 
         spin_lock_irqsave(&info->slock, flags);
         if (break_state == -1)
-                outb(inb(info->base + UART_LCR) | UART_LCR_SBC, info->base + UART_LCR);
+                outb(inb(info->base + UART_LCR) | UART_LCR_SBC,
+                        info->base + UART_LCR);
         else
-                outb(inb(info->base + UART_LCR) & ~UART_LCR_SBC, info->base + UART_LCR);
+                outb(inb(info->base + UART_LCR) & ~UART_LCR_SBC,
+                        info->base + UART_LCR);
         spin_unlock_irqrestore(&info->slock, flags);
 }
 
-// (above) added by James.
+/* (above) added by James. */
 
 
 /*
@@ -1848,7 +1928,7 @@ static irqreturn_t mxser_interrupt(int irq, void *dev_id, struct pt_regs *regs)
         int handled = IRQ_NONE;
 
         port = NULL;
-        //spin_lock(&gm_lock);
+        /* spin_lock(&gm_lock); */
 
         for (i = 0; i < MXSER_BOARDS; i++) {
                 if (dev_id == &(mxvar_table[i * MXSER_PORTS_PER_BOARD])) {
@@ -1857,29 +1937,25 @@ static irqreturn_t mxser_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                 }
         }
 
-        if (i == MXSER_BOARDS) {
+        if (i == MXSER_BOARDS)
                 goto irq_stop;
-        }
-        if (port == 0) {
+        if (port == 0)
                 goto irq_stop;
-        }
         max = mxser_numports[mxsercfg[i].board_type - 1];
         while (1) {
                 irqbits = inb(port->vector) & port->vectormask;
-                if (irqbits == port->vectormask) {
+                if (irqbits == port->vectormask)
                         break;
-                }
 
                 handled = IRQ_HANDLED;
                 for (i = 0, bits = 1; i < max; i++, irqbits |= bits, bits <<= 1) {
-                        if (irqbits == port->vectormask) {
+                        if (irqbits == port->vectormask)
                                 break;
-                        }
                         if (bits & irqbits)
                                 continue;
                         info = port + i;
 
-                        // following add by Victor Yu. 09-13-2002
+                        /* following add by Victor Yu. 09-13-2002 */
                         iir = inb(info->base + UART_IIR);
                         if (iir & UART_IIR_NO_INT)
                                 continue;
@@ -1890,9 +1966,9 @@ static irqreturn_t mxser_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                                 inb(info->base + UART_MSR);
                                 continue;
                         }
-                        // above add by Victor Yu. 09-13-2002
+                        /* above add by Victor Yu. 09-13-2002 */
                         /*
-                           if ( info->tty->flip.count < TTY_FLIPBUF_SIZE/4 ){
+                           if (info->tty->flip.count < TTY_FLIPBUF_SIZE / 4) {
                            info->IER |= MOXA_MUST_RECV_ISR;
                            outb(info->IER, info->base + UART_IER);
                            }
@@ -1908,18 +1984,15 @@ static irqreturn_t mxser_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                            status = inb(info->base + UART_LSR) & info->read_status_mask;
                          */
 
-                        // following add by Victor Yu. 09-02-2002
+                        /* following add by Victor Yu. 09-02-2002 */
                         status = inb(info->base + UART_LSR);
 
-                        if (status & UART_LSR_PE) {
+                        if (status & UART_LSR_PE)
                                 info->err_shadow |= NPPI_NOTIFY_PARITY;
-                        }
-                        if (status & UART_LSR_FE) {
+                        if (status & UART_LSR_FE)
                                 info->err_shadow |= NPPI_NOTIFY_FRAMING;
-                        }
-                        if (status & UART_LSR_OE) {
+                        if (status & UART_LSR_OE)
                                 info->err_shadow |= NPPI_NOTIFY_HW_OVERRUN;
-                        }
                         if (status & UART_LSR_BI)
                                 info->err_shadow |= NPPI_NOTIFY_BREAK;
 
@@ -1930,11 +2003,14 @@ static irqreturn_t mxser_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                                    continue;
                                    }
                                  */
-                                if (iir == MOXA_MUST_IIR_GDA || iir == MOXA_MUST_IIR_RDA || iir == MOXA_MUST_IIR_RTO || iir == MOXA_MUST_IIR_LSR)
+                                if (iir == MOXA_MUST_IIR_GDA ||
+                                                iir == MOXA_MUST_IIR_RDA ||
+                                                iir == MOXA_MUST_IIR_RTO ||
+                                                iir == MOXA_MUST_IIR_LSR)
                                         mxser_receive_chars(info, &status);
 
                         } else {
-                                // above add by Victor Yu. 09-02-2002
+                                /* above add by Victor Yu. 09-02-2002 */
 
                                 status &= info->read_status_mask;
                                 if (status & UART_LSR_DR)
@@ -1944,13 +2020,13 @@ static irqreturn_t mxser_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                         if (msr & UART_MSR_ANY_DELTA) {
                                 mxser_check_modem_status(info, msr);
                         }
-                        // following add by Victor Yu. 09-13-2002
+                        /* following add by Victor Yu. 09-13-2002 */
                         if (info->IsMoxaMustChipFlag) {
                                 if ((iir == 0x02) && (status & UART_LSR_THRE)) {
                                         mxser_transmit_chars(info);
                                 }
                         } else {
-                                // above add by Victor Yu. 09-13-2002
+                                /* above add by Victor Yu. 09-13-2002 */
 
                                 if (status & UART_LSR_THRE) {
 /* 8-2-99 by William
@@ -1966,7 +2042,7 @@ static irqreturn_t mxser_interrupt(int irq, void *dev_id, struct pt_regs *regs)
         }
 
       irq_stop:
-        //spin_unlock(&gm_lock);
+        /* spin_unlock(&gm_lock); */
         return handled;
 }
 
@@ -1984,56 +2060,58 @@ static void mxser_receive_chars(struct mxser_struct *info, int *status)
 
         recv_room = tty->receive_room;
         if ((recv_room == 0) && (!info->ldisc_stop_rx)) {
-                //mxser_throttle(tty);
+                /* mxser_throttle(tty); */
                 mxser_stoprx(tty);
-                //return;
+                /* return; */
         }
 
-        // following add by Victor Yu. 09-02-2002
+        /* following add by Victor Yu. 09-02-2002 */
         if (info->IsMoxaMustChipFlag != MOXA_OTHER_UART) {
 
                 if (*status & UART_LSR_SPECIAL) {
                         goto intr_old;
                 }
-                // following add by Victor Yu. 02-11-2004
-                if (info->IsMoxaMustChipFlag == MOXA_MUST_MU860_HWID && (*status & MOXA_MUST_LSR_RERR))
+                /* following add by Victor Yu. 02-11-2004 */
+                if (info->IsMoxaMustChipFlag == MOXA_MUST_MU860_HWID &&
+                                (*status & MOXA_MUST_LSR_RERR))
                         goto intr_old;
-                // above add by Victor Yu. 02-14-2004
+                /* above add by Victor Yu. 02-14-2004 */
                 if (*status & MOXA_MUST_LSR_RERR)
                         goto intr_old;
 
                 gdl = inb(info->base + MOXA_MUST_GDL_REGISTER);
 
-                if (info->IsMoxaMustChipFlag == MOXA_MUST_MU150_HWID)   // add by Victor Yu. 02-11-2004
+                /* add by Victor Yu. 02-11-2004 */
+                if (info->IsMoxaMustChipFlag == MOXA_MUST_MU150_HWID)
                         gdl &= MOXA_MUST_GDL_MASK;
                 if (gdl >= recv_room) {
                         if (!info->ldisc_stop_rx) {
-                                //mxser_throttle(tty);
+                                /* mxser_throttle(tty); */
                                 mxser_stoprx(tty);
                         }
-                        //return;
+                        /* return; */
                 }
                 while (gdl--) {
                         ch = inb(info->base + UART_RX);
                         tty_insert_flip_char(tty, ch, 0);
                         cnt++;
                         /*
-                           if((cnt>=HI_WATER) && (info->stop_rx==0)){
+                           if ((cnt >= HI_WATER) && (info->stop_rx == 0)) {
                            mxser_stoprx(tty);
-                           info->stop_rx=1;
+                           info->stop_rx = 1;
                            break;
                            } */
                 }
                 goto end_intr;
         }
-intr_old:
-        // above add by Victor Yu. 09-02-2002
+ intr_old:
+        /* above add by Victor Yu. 09-02-2002 */
 
         do {
                 if (max-- < 0)
                         break;
                 /*
-                   if((cnt>=HI_WATER) && (info->stop_rx==0)){
+                   if ((cnt >= HI_WATER) && (info->stop_rx == 0)) {
                    mxser_stoprx(tty);
                    info->stop_rx=1;
                    break;
@@ -2041,11 +2119,11 @@ intr_old:
                  */
 
                 ch = inb(info->base + UART_RX);
-                // following add by Victor Yu. 09-02-2002
+                /* following add by Victor Yu. 09-02-2002 */
                 if (info->IsMoxaMustChipFlag && (*status & UART_LSR_OE) /*&& !(*status&UART_LSR_DR) */ )
                         outb(0x23, info->base + UART_FCR);
                 *status &= info->read_status_mask;
-                // above add by Victor Yu. 09-02-2002
+                /* above add by Victor Yu. 09-02-2002 */
                 if (*status & info->ignore_status_mask) {
                         if (++ignored > 100)
                                 break;
@@ -2080,7 +2158,7 @@ intr_old:
                         cnt++;
                         if (cnt >= recv_room) {
                                 if (!info->ldisc_stop_rx) {
-                                        //mxser_throttle(tty);
+                                        /* mxser_throttle(tty); */
                                         mxser_stoprx(tty);
                                 }
                                 break;
@@ -2088,21 +2166,20 @@ intr_old:
 
                 }
 
-                // following add by Victor Yu. 09-02-2002
+                /* following add by Victor Yu. 09-02-2002 */
                 if (info->IsMoxaMustChipFlag)
                         break;
-                // above add by Victor Yu. 09-02-2002
+                /* above add by Victor Yu. 09-02-2002 */
 
                 /* mask by Victor Yu. 09-02-2002
                  *status = inb(info->base + UART_LSR) & info->read_status_mask;
                  */
-                // following add by Victor Yu. 09-02-2002
+                /* following add by Victor Yu. 09-02-2002 */
                 *status = inb(info->base + UART_LSR);
-                // above add by Victor Yu. 09-02-2002
+                /* above add by Victor Yu. 09-02-2002 */
         } while (*status & UART_LSR_DR);
 
-end_intr:               // add by Victor Yu. 09-02-2002
-
+end_intr:               /* add by Victor Yu. 09-02-2002 */
         mxvar_log.rxcnt[info->port] += cnt;
         info->mon_data.rxcnt += cnt;
         info->mon_data.up_rxcnt += cnt;
@@ -2137,7 +2214,10 @@ static void mxser_transmit_chars(struct mxser_struct *info)
                 return;
         }
 
-        if ((info->xmit_cnt <= 0) || info->tty->stopped || (info->tty->hw_stopped && (info->type != PORT_16550A) && (!info->IsMoxaMustChipFlag))) {
+        if ((info->xmit_cnt <= 0) || info->tty->stopped ||
+                        (info->tty->hw_stopped &&
+                        (info->type != PORT_16550A) &&
+                        (!info->IsMoxaMustChipFlag))) {
                 info->IER &= ~UART_IER_THRI;
                 outb(info->IER, info->base + UART_IER);
                 spin_unlock_irqrestore(&info->slock, flags);
@@ -2147,17 +2227,18 @@ static void mxser_transmit_chars(struct mxser_struct *info)
         cnt = info->xmit_cnt;
         count = info->xmit_fifo_size;
         do {
-                outb(info->xmit_buf[info->xmit_tail++], info->base + UART_TX);
+                outb(info->xmit_buf[info->xmit_tail++],
+                        info->base + UART_TX);
                 info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE - 1);
                 if (--info->xmit_cnt <= 0)
                         break;
         } while (--count > 0);
         mxvar_log.txcnt[info->port] += (cnt - info->xmit_cnt);
 
-// added by James 03-12-2004.
+/* added by James 03-12-2004. */
         info->mon_data.txcnt += (cnt - info->xmit_cnt);
         info->mon_data.up_txcnt += (cnt - info->xmit_cnt);
-// (above) added by James.
+/* (above) added by James. */
 
 /* added by casper 1/11/2000 */
         info->icount.tx += (cnt - info->xmit_cnt);
@@ -2188,7 +2269,6 @@ static void mxser_check_modem_status(struct mxser_struct *info, int status)
         info->mon_data.modem_status = status;
         wake_up_interruptible(&info->delta_msr_wait);
 
-
         if ((info->flags & ASYNC_CHECK_CD) && (status & UART_MSR_DDCD)) {
                 if (status & UART_MSR_DCD)
                         wake_up_interruptible(&info->open_wait);
@@ -2200,7 +2280,8 @@ static void mxser_check_modem_status(struct mxser_struct *info, int status)
                         if (status & UART_MSR_CTS) {
                                 info->tty->hw_stopped = 0;
 
-                                if ((info->type != PORT_16550A) && (!info->IsMoxaMustChipFlag)) {
+                                if ((info->type != PORT_16550A) &&
+                                                (!info->IsMoxaMustChipFlag)) {
                                         info->IER |= UART_IER_THRI;
                                         outb(info->IER, info->base + UART_IER);
                                 }
@@ -2209,7 +2290,8 @@ static void mxser_check_modem_status(struct mxser_struct *info, int status)
                 } else {
                         if (!(status & UART_MSR_CTS)) {
                                 info->tty->hw_stopped = 1;
-                                if ((info->type != PORT_16550A) && (!info->IsMoxaMustChipFlag)) {
+                                if ((info->type != PORT_16550A) &&
+                                                (!info->IsMoxaMustChipFlag)) {
                                         info->IER &= ~UART_IER_THRI;
                                         outb(info->IER, info->base + UART_IER);
                                 }
@@ -2231,7 +2313,7 @@ static int mxser_block_til_ready(struct tty_struct *tty, struct file *filp, stru
          */
         if ((filp->f_flags & O_NONBLOCK) || (tty->flags & (1 << TTY_IO_ERROR))) {
                 info->flags |= ASYNC_NORMAL_ACTIVE;
-                return (0);
+                return 0;
         }
 
         if (tty->termios->c_cflag & CLOCAL)
@@ -2254,7 +2336,8 @@ static int mxser_block_til_ready(struct tty_struct *tty, struct file *filp, stru
         info->blocked_open++;
         while (1) {
                 spin_lock_irqsave(&info->slock, flags);
-                outb(inb(info->base + UART_MCR) | UART_MCR_DTR | UART_MCR_RTS, info->base + UART_MCR);
+                outb(inb(info->base + UART_MCR) |
+                        UART_MCR_DTR | UART_MCR_RTS, info->base + UART_MCR);
                 spin_unlock_irqrestore(&info->slock, flags);
                 set_current_state(TASK_INTERRUPTIBLE);
                 if (tty_hung_up_p(filp) || !(info->flags & ASYNC_INITIALIZED)) {
@@ -2264,7 +2347,9 @@ static int mxser_block_til_ready(struct tty_struct *tty, struct file *filp, stru
                                 retval = -ERESTARTSYS;
                         break;
                 }
-                if (!(info->flags & ASYNC_CLOSING) && (do_clocal || (inb(info->base + UART_MSR) & UART_MSR_DCD)))
+                if (!(info->flags & ASYNC_CLOSING) &&
+                                (do_clocal ||
+                                (inb(info->base + UART_MSR) & UART_MSR_DCD)))
                         break;
                 if (signal_pending(current)) {
                         retval = -ERESTARTSYS;
@@ -2278,27 +2363,26 @@ static int mxser_block_til_ready(struct tty_struct *tty, struct file *filp, stru
                 info->count++;
         info->blocked_open--;
         if (retval)
-                return (retval);
+                return retval;
         info->flags |= ASYNC_NORMAL_ACTIVE;
-        return (0);
+        return 0;
 }
 
 static int mxser_startup(struct mxser_struct *info)
 {
-
         unsigned long page;
         unsigned long flags;
 
         page = __get_free_page(GFP_KERNEL);
         if (!page)
-                return (-ENOMEM);
+                return -ENOMEM;
 
         spin_lock_irqsave(&info->slock, flags);
 
         if (info->flags & ASYNC_INITIALIZED) {
                 free_page(page);
                 spin_unlock_irqrestore(&info->slock, flags);
-                return (0);
+                return 0;
         }
 
         if (!info->base || !info->type) {
@@ -2306,7 +2390,7 @@ static int mxser_startup(struct mxser_struct *info)
                         set_bit(TTY_IO_ERROR, &info->tty->flags);
                 free_page(page);
                 spin_unlock_irqrestore(&info->slock, flags);
-                return (0);
+                return 0;
         }
         if (info->xmit_buf)
                 free_page(page);
@@ -2318,9 +2402,12 @@ static int mxser_startup(struct mxser_struct *info)
          * (they will be reenabled in mxser_change_speed())
          */
         if (info->IsMoxaMustChipFlag)
-                outb((UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT | MOXA_MUST_FCR_GDA_MODE_ENABLE), info->base + UART_FCR);
+                outb((UART_FCR_CLEAR_RCVR |
+                        UART_FCR_CLEAR_XMIT |
+                        MOXA_MUST_FCR_GDA_MODE_ENABLE), info->base + UART_FCR);
         else
-                outb((UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT), info->base + UART_FCR);
+                outb((UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT),
+                        info->base + UART_FCR);
 
         /*
          * At this point there's no way the LSR could still be 0xFF;
@@ -2332,9 +2419,9 @@ static int mxser_startup(struct mxser_struct *info)
                 if (capable(CAP_SYS_ADMIN)) {
                         if (info->tty)
                                 set_bit(TTY_IO_ERROR, &info->tty->flags);
-                        return (0);
+                        return 0;
                 } else
-                        return (-ENODEV);
+                        return -ENODEV;
         }
 
         /*
@@ -2356,12 +2443,12 @@ static int mxser_startup(struct mxser_struct *info)
          * Finally, enable interrupts
          */
         info->IER = UART_IER_MSI | UART_IER_RLSI | UART_IER_RDI;
-//      info->IER = UART_IER_RLSI | UART_IER_RDI;
+        /* info->IER = UART_IER_RLSI | UART_IER_RDI; */
 
-        // following add by Victor Yu. 08-30-2002
+        /* following add by Victor Yu. 08-30-2002 */
         if (info->IsMoxaMustChipFlag)
                 info->IER |= MOXA_MUST_IER_EGDAI;
-        // above add by Victor Yu. 08-30-2002
+        /* above add by Victor Yu. 08-30-2002 */
         outb(info->IER, info->base + UART_IER); /* enable interrupts */
 
         /*
@@ -2383,7 +2470,7 @@ static int mxser_startup(struct mxser_struct *info)
         mxser_change_speed(info, NULL);
 
         info->flags |= ASYNC_INITIALIZED;
-        return (0);
+        return 0;
 }
 
 /*
@@ -2421,12 +2508,15 @@ static void mxser_shutdown(struct mxser_struct *info)
         outb(info->MCR, info->base + UART_MCR);
 
         /* clear Rx/Tx FIFO's */
-        // following add by Victor Yu. 08-30-2002
+        /* following add by Victor Yu. 08-30-2002 */
         if (info->IsMoxaMustChipFlag)
-                outb((UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT | MOXA_MUST_FCR_GDA_MODE_ENABLE), info->base + UART_FCR);
+                outb((UART_FCR_CLEAR_RCVR |
+                        UART_FCR_CLEAR_XMIT |
+                        MOXA_MUST_FCR_GDA_MODE_ENABLE), info->base + UART_FCR);
         else
-                // above add by Victor Yu. 08-30-2002
-                outb((UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT), info->base + UART_FCR);
+                /* above add by Victor Yu. 08-30-2002 */
+                outb((UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT),
+                        info->base + UART_FCR);
 
         /* read data port to reset things */
         (void) inb(info->base + UART_RX);
@@ -2436,11 +2526,10 @@ static void mxser_shutdown(struct mxser_struct *info)
 
         info->flags &= ~ASYNC_INITIALIZED;
 
-        // following add by Victor Yu. 09-23-2002
-        if (info->IsMoxaMustChipFlag) {
+        /* following add by Victor Yu. 09-23-2002 */
+        if (info->IsMoxaMustChipFlag)
                 SET_MOXA_MUST_NO_SOFTWARE_FLOW_CONTROL(info->base);
-        }
-        // above add by Victor Yu. 09-23-2002
+        /* above add by Victor Yu. 09-23-2002 */
 
         spin_unlock_irqrestore(&info->slock, flags);
 }
@@ -2457,14 +2546,12 @@ static int mxser_change_speed(struct mxser_struct *info, struct termios *old_ter
         long baud;
         unsigned long flags;
 
-
         if (!info->tty || !info->tty->termios)
                 return ret;
         cflag = info->tty->termios->c_cflag;
         if (!(info->base))
                 return ret;
 
-
 #ifndef B921600
 #define B921600 (B460800 +1)
 #endif
@@ -2559,9 +2646,8 @@ static int mxser_change_speed(struct mxser_struct *info, struct termios *old_ter
                 cval |= 0x04;
         if (cflag & PARENB)
                 cval |= UART_LCR_PARITY;
-        if (!(cflag & PARODD)) {
+        if (!(cflag & PARODD))
                 cval |= UART_LCR_EPAR;
-        }
         if (cflag & CMSPAR)
                 cval |= UART_LCR_SPAR;
 
@@ -2574,13 +2660,12 @@ static int mxser_change_speed(struct mxser_struct *info, struct termios *old_ter
                         fcr = 0;
         } else {
                 fcr = UART_FCR_ENABLE_FIFO;
-                // following add by Victor Yu. 08-30-2002
+                /* following add by Victor Yu. 08-30-2002 */
                 if (info->IsMoxaMustChipFlag) {
                         fcr |= MOXA_MUST_FCR_GDA_MODE_ENABLE;
                         SET_MOXA_MUST_FIFO_VALUE(info);
                 } else {
-                        // above add by Victor Yu. 08-30-2002
-
+                        /* above add by Victor Yu. 08-30-2002 */
                         switch (info->rx_trigger) {
                         case 1:
                                 fcr |= UART_FCR_TRIGGER_1;
@@ -2606,22 +2691,24 @@ static int mxser_change_speed(struct mxser_struct *info, struct termios *old_ter
                 info->IER |= UART_IER_MSI;
                 if ((info->type == PORT_16550A) || (info->IsMoxaMustChipFlag)) {
                         info->MCR |= UART_MCR_AFE;
-                        //status = mxser_get_msr(info->base, 0, info->port);
-/*      save_flags(flags);
+                        /* status = mxser_get_msr(info->base, 0, info->port); */
+/*
+        save_flags(flags);
         cli();
         status = inb(baseaddr + UART_MSR);
-        restore_flags(flags);*/
-                        //mxser_check_modem_status(info, status);
+        restore_flags(flags);
+*/
+                        /* mxser_check_modem_status(info, status); */
                 } else {
-                        //status = mxser_get_msr(info->base, 0, info->port);
-
-                        //MX_LOCK(&info->slock);
+                        /* status = mxser_get_msr(info->base, 0, info->port); */
+                        /* MX_LOCK(&info->slock); */
                         status = inb(info->base + UART_MSR);
-                        //MX_UNLOCK(&info->slock);
+                        /* MX_UNLOCK(&info->slock); */
                         if (info->tty->hw_stopped) {
                                 if (status & UART_MSR_CTS) {
                                         info->tty->hw_stopped = 0;
-                                        if ((info->type != PORT_16550A) && (!info->IsMoxaMustChipFlag)) {
+                                        if ((info->type != PORT_16550A) &&
+                                                        (!info->IsMoxaMustChipFlag)) {
                                                 info->IER |= UART_IER_THRI;
                                                 outb(info->IER, info->base + UART_IER);
                                         }
@@ -2630,7 +2717,8 @@ static int mxser_change_speed(struct mxser_struct *info, struct termios *old_ter
                         } else {
                                 if (!(status & UART_MSR_CTS)) {
                                         info->tty->hw_stopped = 1;
-                                        if ((info->type != PORT_16550A) && (!info->IsMoxaMustChipFlag)) {
+                                        if ((info->type != PORT_16550A) &&
+                                                        (!info->IsMoxaMustChipFlag)) {
                                                 info->IER &= ~UART_IER_THRI;
                                                 outb(info->IER, info->base + UART_IER);
                                         }
@@ -2668,11 +2756,17 @@ static int mxser_change_speed(struct mxser_struct *info, struct termios *old_ter
                  * overruns too.  (For real raw support).
                  */
                 if (I_IGNPAR(info->tty)) {
-                        info->ignore_status_mask |= UART_LSR_OE | UART_LSR_PE | UART_LSR_FE;
-                        info->read_status_mask |= UART_LSR_OE | UART_LSR_PE | UART_LSR_FE;
+                        info->ignore_status_mask |=
+                                                UART_LSR_OE |
+                                                UART_LSR_PE |
+                                                UART_LSR_FE;
+                        info->read_status_mask |=
+                                                UART_LSR_OE |
+                                                UART_LSR_PE |
+                                                UART_LSR_FE;
                 }
         }
-        // following add by Victor Yu. 09-02-2002
+        /* following add by Victor Yu. 09-02-2002 */
         if (info->IsMoxaMustChipFlag) {
                 spin_lock_irqsave(&info->slock, flags);
                 SET_MOXA_MUST_XON1_VALUE(info->base, START_CHAR(info->tty));
@@ -2698,7 +2792,7 @@ static int mxser_change_speed(struct mxser_struct *info, struct termios *old_ter
                  */
                 spin_unlock_irqrestore(&info->slock, flags);
         }
-        // above add by Victor Yu. 09-02-2002
+        /* above add by Victor Yu. 09-02-2002 */
 
 
         outb(fcr, info->base + UART_FCR);       /* set fcr */
@@ -2729,10 +2823,8 @@ static int mxser_set_baud(struct mxser_struct *info, long newspd)
                 quot = (2 * info->baud_base / 269);
         } else if (newspd) {
                 quot = info->baud_base / newspd;
-
                 if (quot == 0)
                         quot = 1;
-
         } else {
                 quot = 0;
         }
@@ -2765,8 +2857,6 @@ static int mxser_set_baud(struct mxser_struct *info, long newspd)
         return ret;
 }
 
-
-
 /*
  * ------------------------------------------------------------
  * friends of mxser_ioctl()
@@ -2777,7 +2867,7 @@ static int mxser_get_serial_info(struct mxser_struct *info, struct serial_struct
         struct serial_struct tmp;
 
         if (!retinfo)
-                return (-EFAULT);
+                return -EFAULT;
         memset(&tmp, 0, sizeof(tmp));
         tmp.type = info->type;
         tmp.line = info->port;
@@ -2791,7 +2881,7 @@ static int mxser_get_serial_info(struct mxser_struct *info, struct serial_struct
         tmp.hub6 = 0;
         if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
                 return -EFAULT;
-        return (0);
+        return 0;
 }
 
 static int mxser_set_serial_info(struct mxser_struct *info, struct serial_struct __user *new_info)
@@ -2801,29 +2891,37 @@ static int mxser_set_serial_info(struct mxser_struct *info, struct serial_struct
         int retval = 0;
 
         if (!new_info || !info->base)
-                return (-EFAULT);
+                return -EFAULT;
         if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
                 return -EFAULT;
 
-        if ((new_serial.irq != info->irq) || (new_serial.port != info->base) || (new_serial.custom_divisor != info->custom_divisor) || (new_serial.baud_base != info->baud_base))
-                return (-EPERM);
+        if ((new_serial.irq != info->irq) ||
+                        (new_serial.port != info->base) ||
+                        (new_serial.custom_divisor != info->custom_divisor) ||
+                        (new_serial.baud_base != info->baud_base))
+                return -EPERM;
 
         flags = info->flags & ASYNC_SPD_MASK;
 
         if (!capable(CAP_SYS_ADMIN)) {
-                if ((new_serial.baud_base != info->baud_base) || (new_serial.close_delay != info->close_delay) || ((new_serial.flags & ~ASYNC_USR_MASK) != (info->flags & ~ASYNC_USR_MASK)))
-                        return (-EPERM);
-                info->flags = ((info->flags & ~ASYNC_USR_MASK) | (new_serial.flags & ASYNC_USR_MASK));
+                if ((new_serial.baud_base != info->baud_base) ||
+                                (new_serial.close_delay != info->close_delay) ||
+                                ((new_serial.flags & ~ASYNC_USR_MASK) != (info->flags & ~ASYNC_USR_MASK)))
+                        return -EPERM;
+                info->flags = ((info->flags & ~ASYNC_USR_MASK) |
+                                (new_serial.flags & ASYNC_USR_MASK));
         } else {
                 /*
                  * OK, past this point, all the error checking has been done.
                  * At this point, we start making changes.....
                  */
-                info->flags = ((info->flags & ~ASYNC_FLAGS) | (new_serial.flags & ASYNC_FLAGS));
+                info->flags = ((info->flags & ~ASYNC_FLAGS) |
+                                (new_serial.flags & ASYNC_FLAGS));
                 info->close_delay = new_serial.close_delay * HZ / 100;
                 info->closing_wait = new_serial.closing_wait * HZ / 100;
-                info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
-                info->tty->low_latency = 0;     //(info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+                info->tty->low_latency =
+                                (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+                info->tty->low_latency = 0;     /* (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0; */
         }
 
         /* added by casper, 3/17/2000, for mouse */
@@ -2831,7 +2929,6 @@ static int mxser_set_serial_info(struct mxser_struct *info, struct serial_struct
 
         process_txrx_fifo(info);
 
-        /* */
         if (info->flags & ASYNC_INITIALIZED) {
                 if (flags != (info->flags & ASYNC_SPD_MASK)) {
                         mxser_change_speed(info, NULL);
@@ -2839,7 +2936,7 @@ static int mxser_set_serial_info(struct mxser_struct *info, struct serial_struct
         } else {
                 retval = mxser_startup(info);
         }
-        return (retval);
+        return retval;
 }
 
 /*
@@ -2876,25 +2973,27 @@ static void mxser_send_break(struct mxser_struct *info, int duration)
                 return;
         set_current_state(TASK_INTERRUPTIBLE);
         spin_lock_irqsave(&info->slock, flags);
-        outb(inb(info->base + UART_LCR) | UART_LCR_SBC, info->base + UART_LCR);
+        outb(inb(info->base + UART_LCR) | UART_LCR_SBC,
+                info->base + UART_LCR);
         spin_unlock_irqrestore(&info->slock, flags);
         schedule_timeout(duration);
         spin_lock_irqsave(&info->slock, flags);
-        outb(inb(info->base + UART_LCR) & ~UART_LCR_SBC, info->base + UART_LCR);
+        outb(inb(info->base + UART_LCR) & ~UART_LCR_SBC,
+                info->base + UART_LCR);
         spin_unlock_irqrestore(&info->slock, flags);
 }
 
 static int mxser_tiocmget(struct tty_struct *tty, struct file *file)
 {
-        struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
+        struct mxser_struct *info = tty->driver_data;
         unsigned char control, status;
         unsigned long flags;
 
 
         if (tty->index == MXSER_PORTS)
-                return (-ENOIOCTLCMD);
+                return -ENOIOCTLCMD;
         if (tty->flags & (1 << TTY_IO_ERROR))
-                return (-EIO);
+                return -EIO;
 
         control = info->MCR;
 
@@ -2904,12 +3003,16 @@ static int mxser_tiocmget(struct tty_struct *tty, struct file *file)
                 mxser_check_modem_status(info, status);
         spin_unlock_irqrestore(&info->slock, flags);
         return ((control & UART_MCR_RTS) ? TIOCM_RTS : 0) |
-            ((control & UART_MCR_DTR) ? TIOCM_DTR : 0) | ((status & UART_MSR_DCD) ? TIOCM_CAR : 0) | ((status & UART_MSR_RI) ? TIOCM_RNG : 0) | ((status & UART_MSR_DSR) ? TIOCM_DSR : 0) | ((status & UART_MSR_CTS) ? TIOCM_CTS : 0);
+                    ((control & UART_MCR_DTR) ? TIOCM_DTR : 0) |
+                    ((status & UART_MSR_DCD) ? TIOCM_CAR : 0) |
+                    ((status & UART_MSR_RI) ? TIOCM_RNG : 0) |
+                    ((status & UART_MSR_DSR) ? TIOCM_DSR : 0) |
+                    ((status & UART_MSR_CTS) ? TIOCM_CTS : 0);
 }
 
 static int mxser_tiocmset(struct tty_struct *tty, struct file *file, unsigned int set, unsigned int clear)
 {
-        struct mxser_struct *info = (struct mxser_struct *) tty->driver_data;
+        struct mxser_struct *info = tty->driver_data;
         unsigned long flags;
 
 
@@ -2968,38 +3071,36 @@ static int mxser_get_ISA_conf(int cap, struct mxser_hwconf *hwconf)
                 hwconf->board_type = MXSER_BOARD_CI104J;
                 hwconf->ports = 4;
         } else
-                return (0);
+                return 0;
 
         irq = 0;
         if (hwconf->ports == 2) {
                 irq = regs[9] & 0xF000;
                 irq = irq | (irq >> 4);
                 if (irq != (regs[9] & 0xFF00))
-                        return (MXSER_ERR_IRQ_CONFLIT);
+                        return MXSER_ERR_IRQ_CONFLIT;
         } else if (hwconf->ports == 4) {
                 irq = regs[9] & 0xF000;
                 irq = irq | (irq >> 4);
                 irq = irq | (irq >> 8);
                 if (irq != regs[9])
-                        return (MXSER_ERR_IRQ_CONFLIT);
+                        return MXSER_ERR_IRQ_CONFLIT;
         } else if (hwconf->ports == 8) {
                 irq = regs[9] & 0xF000;
                 irq = irq | (irq >> 4);
                 irq = irq | (irq >> 8);
                 if ((irq != regs[9]) || (irq != regs[10]))
-                        return (MXSER_ERR_IRQ_CONFLIT);
+                        return MXSER_ERR_IRQ_CONFLIT;
         }
 
-        if (!irq) {
-                return (MXSER_ERR_IRQ);
-        }
-        hwconf->irq = ((int) (irq & 0xF000) >> 12);
+        if (!irq)
+                return MXSER_ERR_IRQ;
+        hwconf->irq = ((int)(irq & 0xF000) >> 12);
         for (i = 0; i < 8; i++)
                 hwconf->ioaddr[i] = (int) regs[i + 1] & 0xFFF8;
-        if ((regs[12] & 0x80) == 0) {
-                return (MXSER_ERR_VECTOR);
-        }
-        hwconf->vector = (int) regs[11];        /* interrupt vector */
+        if ((regs[12] & 0x80) == 0)
+                return MXSER_ERR_VECTOR;
+        hwconf->vector = (int)regs[11]; /* interrupt vector */
         if (id == 1)
                 hwconf->vector_mask = 0x00FF;
         else
@@ -3007,10 +3108,10 @@ static int mxser_get_ISA_conf(int cap, struct mxser_hwconf *hwconf)
         for (i = 7, bits = 0x0100; i >= 0; i--, bits <<= 1) {
                 if (regs[12] & bits) {
                         hwconf->baud_base[i] = 921600;
-                        hwconf->MaxCanSetBaudRate[i] = 921600;  // add by Victor Yu. 09-04-2002
+                        hwconf->MaxCanSetBaudRate[i] = 921600;  /* add by Victor Yu. 09-04-2002 */
                 } else {
                         hwconf->baud_base[i] = 115200;
-                        hwconf->MaxCanSetBaudRate[i] = 115200;  // add by Victor Yu. 09-04-2002
+                        hwconf->MaxCanSetBaudRate[i] = 115200;  /* add by Victor Yu. 09-04-2002 */
                 }
         }
         scratch2 = inb(cap + UART_LCR) & (~UART_LCR_DLAB);
@@ -3030,7 +3131,7 @@ static int mxser_get_ISA_conf(int cap, struct mxser_hwconf *hwconf)
                 hwconf->ports = 4;
         request_region(hwconf->ioaddr[0], 8 * hwconf->ports, "mxser(IO)");
         request_region(hwconf->vector, 1, "mxser(vector)");
-        return (hwconf->ports);
+        return hwconf->ports;
 }
 
 #define CHIP_SK         0x01    /* Serial Data Clock  in Eprom */
@@ -3053,7 +3154,7 @@ static int mxser_read_register(int port, unsigned short *regs)
 
         id = mxser_program_mode(port);
         if (id < 0)
-                return (id);
+                return id;
         for (i = 0; i < 14; i++) {
                 k = (i & 0x3F) | 0x180;
                 for (j = 0x100; j > 0; j >>= 1) {
@@ -3066,7 +3167,7 @@ static int mxser_read_register(int port, unsigned short *regs)
                                 outb(CHIP_CS | CHIP_SK, port);  /* A? bit of read */
                         }
                 }
-                (void) inb(port);
+                (void)inb(port);
                 value = 0;
                 for (k = 0, j = 0x8000; k < 16; k++, j >>= 1) {
                         outb(CHIP_CS, port);
@@ -3078,28 +3179,33 @@ static int mxser_read_register(int port, unsigned short *regs)
                 outb(0, port);
         }
         mxser_normal_mode(port);
-        return (id);
+        return id;
 }
 
 static int mxser_program_mode(int port)
 {
         int id, i, j, n;
-        //unsigned long flags;
+        /* unsigned long flags; */
 
         spin_lock(&gm_lock);
         outb(0, port);
         outb(0, port);
         outb(0, port);
-        (void) inb(port);
-        (void) inb(port);
+        (void)inb(port);
+        (void)inb(port);
         outb(0, port);
-        (void) inb(port);
-        //restore_flags(flags);
+        (void)inb(port);
+        /* restore_flags(flags); */
         spin_unlock(&gm_lock);
 
         id = inb(port + 1) & 0x1F;
-        if ((id != C168_ASIC_ID) && (id != C104_ASIC_ID) && (id != C102_ASIC_ID) && (id != CI132_ASIC_ID) && (id != CI134_ASIC_ID) && (id != CI104J_ASIC_ID))
-                return (-1);
+        if ((id != C168_ASIC_ID) &&
+                        (id != C104_ASIC_ID) &&
+                        (id != C102_ASIC_ID) &&
+                        (id != CI132_ASIC_ID) &&
+                        (id != CI134_ASIC_ID) &&
+                        (id != CI104J_ASIC_ID))
+                return -1;
         for (i = 0, j = 0; i < 4; i++) {
                 n = inb(port + 2);
                 if (n == 'M') {
@@ -3112,7 +3218,7 @@ static int mxser_program_mode(int port)
         }
         if (j != 2)
                 id = -2;
-        return (id);
+        return id;
 }
 
 static void mxser_normal_mode(int port)
@@ -3130,7 +3236,7 @@ static void mxser_normal_mode(int port)
                 if ((n & 0x61) == 0x60)
                         break;
                 if ((n & 1) == 1)
-                        (void) inb(port);
+                        (void)inb(port);
         }
         outb(0x00, port + 4);
 }
diff --git a/drivers/char/n_r3964.c b/drivers/char/n_r3964.c
index c48de09d68f0..203dc2b661d5 100644
--- a/drivers/char/n_r3964.c
+++ b/drivers/char/n_r3964.c
@@ -951,7 +951,8 @@ static void add_msg(struct r3964_client_info *pClient, int msg_id, int arg,
    {
 queue_the_message:
 
-      pMsg = kmalloc(sizeof(struct r3964_message), GFP_KERNEL);
+      pMsg = kmalloc(sizeof(struct r3964_message),
+                     error_code?GFP_ATOMIC:GFP_KERNEL);
       TRACE_M("add_msg - kmalloc %p",pMsg);
       if(pMsg==NULL) {
          return;
diff --git a/drivers/char/pcmcia/synclink_cs.c b/drivers/char/pcmcia/synclink_cs.c
index 0c141c295fb6..17bc8abd5df5 100644
--- a/drivers/char/pcmcia/synclink_cs.c
+++ b/drivers/char/pcmcia/synclink_cs.c
@@ -1582,7 +1582,7 @@ static void mgslpc_put_char(struct tty_struct *tty, unsigned char ch)
         if (mgslpc_paranoia_check(info, tty->name, "mgslpc_put_char"))
                 return;
 
-        if (!tty || !info->tx_buf)
+        if (!info->tx_buf)
                 return;
 
         spin_lock_irqsave(&info->lock,flags);
@@ -1649,7 +1649,7 @@ static int mgslpc_write(struct tty_struct * tty,
                         __FILE__,__LINE__,info->device_name,count);
         
         if (mgslpc_paranoia_check(info, tty->name, "mgslpc_write") ||
-            !tty || !info->tx_buf)
+                !info->tx_buf)
                 goto cleanup;
 
         if (info->params.mode == MGSL_MODE_HDLC) {
diff --git a/drivers/char/rocket.c b/drivers/char/rocket.c
index 7edc6a4dbdc4..0708c5164c83 100644
--- a/drivers/char/rocket.c
+++ b/drivers/char/rocket.c
@@ -324,35 +324,15 @@ static void rp_do_receive(struct r_port *info,
                           CHANNEL_t * cp, unsigned int ChanStatus)
 {
         unsigned int CharNStat;
-        int ToRecv, wRecv, space = 0, count;
-        unsigned char *cbuf, *chead;
-        char *fbuf, *fhead;
-        struct tty_ldisc *ld;
-
-        ld = tty_ldisc_ref(tty);
+        int ToRecv, wRecv, space;
+        unsigned char *cbuf;
 
         ToRecv = sGetRxCnt(cp);
-        space = tty->receive_room;
-        if (space > 2 * TTY_FLIPBUF_SIZE)
-                space = 2 * TTY_FLIPBUF_SIZE;
-        count = 0;
 #ifdef ROCKET_DEBUG_INTR
-        printk(KERN_INFO "rp_do_receive(%d, %d)...", ToRecv, space);
+        printk(KERN_INFO "rp_do_receive(%d)...", ToRecv);
 #endif
-
-        /*
-         * determine how many we can actually read in.  If we can't
-         * read any in then we have a software overrun condition.
-         */
-        if (ToRecv > space)
-                ToRecv = space;
-
-        ToRecv = tty_prepare_flip_string_flags(tty, &chead, &fhead, ToRecv);
-        if (ToRecv <= 0)
-                goto done;
-
-        cbuf = chead;
-        fbuf = fhead;
+        if (ToRecv == 0)
+                return;
 
         /*
          * if status indicates there are errored characters in the
@@ -380,6 +360,8 @@ static void rp_do_receive(struct r_port *info,
                        info->read_status_mask);
 #endif
                 while (ToRecv) {
+                        char flag;
+
                         CharNStat = sInW(sGetTxRxDataIO(cp));
 #ifdef ROCKET_DEBUG_RECEIVE
                         printk(KERN_INFO "%x...", CharNStat);
@@ -392,17 +374,16 @@ static void rp_do_receive(struct r_port *info,
                         }
                         CharNStat &= info->read_status_mask;
                         if (CharNStat & STMBREAKH)
-                                *fbuf++ = TTY_BREAK;
+                                flag = TTY_BREAK;
                         else if (CharNStat & STMPARITYH)
-                                *fbuf++ = TTY_PARITY;
+                                flag = TTY_PARITY;
                         else if (CharNStat & STMFRAMEH)
-                                *fbuf++ = TTY_FRAME;
+                                flag = TTY_FRAME;
                         else if (CharNStat & STMRCVROVRH)
-                                *fbuf++ = TTY_OVERRUN;
+                                flag = TTY_OVERRUN;
                         else
-                                *fbuf++ = TTY_NORMAL;
-                        *cbuf++ = CharNStat & 0xff;
-                        count++;
+                                flag = TTY_NORMAL;
+                        tty_insert_flip_char(tty, CharNStat & 0xff, flag);
                         ToRecv--;
                 }
 
@@ -422,20 +403,23 @@ static void rp_do_receive(struct r_port *info,
                  * characters at time by doing repeated word IO
                  * transfer.
                  */
+                space = tty_prepare_flip_string(tty, &cbuf, ToRecv);
+                if (space < ToRecv) {
+#ifdef ROCKET_DEBUG_RECEIVE
+                        printk(KERN_INFO "rp_do_receive:insufficient space ToRecv=%d space=%d\n", ToRecv, space);
+#endif
+                        if (space <= 0)
+                                return;
+                        ToRecv = space;
+                }
                 wRecv = ToRecv >> 1;
                 if (wRecv)
                         sInStrW(sGetTxRxDataIO(cp), (unsigned short *) cbuf, wRecv);
                 if (ToRecv & 1)
                         cbuf[ToRecv - 1] = sInB(sGetTxRxDataIO(cp));
-                memset(fbuf, TTY_NORMAL, ToRecv);
-                cbuf += ToRecv;
-                fbuf += ToRecv;
-                count += ToRecv;
         }
         /*  Push the data up to the tty layer */
-        ld->receive_buf(tty, chead, fhead, count);
-done:
-        tty_ldisc_deref(ld);
+        tty_flip_buffer_push(tty);
 }
 
 /*
diff --git a/drivers/char/specialix.c b/drivers/char/specialix.c
index 5343e9fc6ab7..1b5330299e30 100644
--- a/drivers/char/specialix.c
+++ b/drivers/char/specialix.c
@@ -1683,7 +1683,7 @@ static int sx_write(struct tty_struct * tty,
 
         bp = port_Board(port);
 
-        if (!tty || !port->xmit_buf || !tmp_buf) {
+        if (!port->xmit_buf || !tmp_buf) {
                 func_exit();
                 return 0;
         }
@@ -1733,7 +1733,7 @@ static void sx_put_char(struct tty_struct * tty, unsigned char ch)
                 return;
         }
         dprintk (SX_DEBUG_TX, "check tty: %p %p\n", tty, port->xmit_buf);
-        if (!tty || !port->xmit_buf) {
+        if (!port->xmit_buf) {
                 func_exit();
                 return;
         }
diff --git a/drivers/char/synclink_gt.c b/drivers/char/synclink_gt.c
index b4d1f4eea435..4e35d4181224 100644
--- a/drivers/char/synclink_gt.c
+++ b/drivers/char/synclink_gt.c
@@ -101,6 +101,7 @@ MODULE_LICENSE("GPL");
 
 static struct pci_device_id pci_table[] = {
         {PCI_VENDOR_ID_MICROGATE, SYNCLINK_GT_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
+        {PCI_VENDOR_ID_MICROGATE, SYNCLINK_GT2_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
         {PCI_VENDOR_ID_MICROGATE, SYNCLINK_GT4_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
         {PCI_VENDOR_ID_MICROGATE, SYNCLINK_AC_DEVICE_ID, PCI_ANY_ID, PCI_ANY_ID,},
         {0,}, /* terminate list */
@@ -870,7 +871,7 @@ static int write(struct tty_struct *tty,
                 goto cleanup;
         DBGINFO(("%s write count=%d\n", info->device_name, count));
 
-        if (!tty || !info->tx_buf)
+        if (!info->tx_buf)
                 goto cleanup;
 
         if (count > info->max_frame_size) {
@@ -924,7 +925,7 @@ static void put_char(struct tty_struct *tty, unsigned char ch)
         if (sanity_check(info, tty->name, "put_char"))
                 return;
         DBGINFO(("%s put_char(%d)\n", info->device_name, ch));
-        if (!tty || !info->tx_buf)
+        if (!info->tx_buf)
                 return;
         spin_lock_irqsave(&info->lock,flags);
         if (!info->tx_active && (info->tx_count < info->max_frame_size))
@@ -2515,7 +2516,8 @@ static int set_txidle(struct slgt_info *info, int idle_mode)
         DBGINFO(("%s set_txidle(%d)\n", info->device_name, idle_mode));
         spin_lock_irqsave(&info->lock,flags);
         info->idle_mode = idle_mode;
-        tx_set_idle(info);
+        if (info->params.mode != MGSL_MODE_ASYNC)
+                tx_set_idle(info);
         spin_unlock_irqrestore(&info->lock,flags);
         return 0;
 }
@@ -3076,7 +3078,7 @@ static int block_til_ready(struct tty_struct *tty, struct file *filp,
 
 static int alloc_tmp_rbuf(struct slgt_info *info)
 {
-        info->tmp_rbuf = kmalloc(info->max_frame_size, GFP_KERNEL);
+        info->tmp_rbuf = kmalloc(info->max_frame_size + 5, GFP_KERNEL);
         if (info->tmp_rbuf == NULL)
                 return -ENOMEM;
         return 0;
@@ -3276,6 +3278,9 @@ static void add_device(struct slgt_info *info)
         case SYNCLINK_GT_DEVICE_ID:
                 devstr = "GT";
                 break;
+        case SYNCLINK_GT2_DEVICE_ID:
+                devstr = "GT2";
+                break;
         case SYNCLINK_GT4_DEVICE_ID:
                 devstr = "GT4";
                 break;
@@ -3353,7 +3358,9 @@ static void device_init(int adapter_num, struct pci_dev *pdev)
         int i;
         int port_count = 1;
 
-        if (pdev->device == SYNCLINK_GT4_DEVICE_ID)
+        if (pdev->device == SYNCLINK_GT2_DEVICE_ID)
+                port_count = 2;
+        else if (pdev->device == SYNCLINK_GT4_DEVICE_ID)
                 port_count = 4;
 
         /* allocate device instances for all ports */
@@ -3940,8 +3947,6 @@ static void async_mode(struct slgt_info *info)
 
         msc_set_vcr(info);
 
-        tx_set_idle(info);
-
         /* SCR (serial control)
          *
          * 15  1=tx req on FIFO half empty
@@ -4012,7 +4017,7 @@ static void hdlc_mode(struct slgt_info *info)
         case HDLC_ENCODING_DIFF_BIPHASE_LEVEL: val |= BIT12 + BIT11 + BIT10; break;
         }
 
-        switch (info->params.crc_type)
+        switch (info->params.crc_type & HDLC_CRC_MASK)
         {
         case HDLC_CRC_16_CCITT: val |= BIT9; break;
         case HDLC_CRC_32_CCITT: val |= BIT9 + BIT8; break;
@@ -4073,7 +4078,7 @@ static void hdlc_mode(struct slgt_info *info)
         case HDLC_ENCODING_DIFF_BIPHASE_LEVEL: val |= BIT12 + BIT11 + BIT10; break;
         }
 
-        switch (info->params.crc_type)
+        switch (info->params.crc_type & HDLC_CRC_MASK)
         {
         case HDLC_CRC_16_CCITT: val |= BIT9; break;
         case HDLC_CRC_32_CCITT: val |= BIT9 + BIT8; break;
@@ -4175,17 +4180,38 @@ static void hdlc_mode(struct slgt_info *info)
  */
 static void tx_set_idle(struct slgt_info *info)
 {
-        unsigned char val = 0xff;
+        unsigned char val;
+        unsigned short tcr;
 
-        switch(info->idle_mode)
-        {
-        case HDLC_TXIDLE_FLAGS:          val = 0x7e; break;
-        case HDLC_TXIDLE_ALT_ZEROS_ONES: val = 0xaa; break;
-        case HDLC_TXIDLE_ZEROS:          val = 0x00; break;
-        case HDLC_TXIDLE_ONES:           val = 0xff; break;
-        case HDLC_TXIDLE_ALT_MARK_SPACE: val = 0xaa; break;
-        case HDLC_TXIDLE_SPACE:          val = 0x00; break;
-        case HDLC_TXIDLE_MARK:           val = 0xff; break;
+        /* if preamble enabled (tcr[6] == 1) then tx idle size = 8 bits
+         * else tcr[5:4] = tx idle size: 00 = 8 bits, 01 = 16 bits
+         */
+        tcr = rd_reg16(info, TCR);
+        if (info->idle_mode & HDLC_TXIDLE_CUSTOM_16) {
+                /* disable preamble, set idle size to 16 bits */
+                tcr = (tcr & ~(BIT6 + BIT5)) | BIT4;
+                /* MSB of 16 bit idle specified in tx preamble register (TPR) */
+                wr_reg8(info, TPR, (unsigned char)((info->idle_mode >> 8) & 0xff));
+        } else if (!(tcr & BIT6)) {
+                /* preamble is disabled, set idle size to 8 bits */
+                tcr &= ~(BIT5 + BIT4);
+        }
+        wr_reg16(info, TCR, tcr);
+
+        if (info->idle_mode & (HDLC_TXIDLE_CUSTOM_8 | HDLC_TXIDLE_CUSTOM_16)) {
+                /* LSB of custom tx idle specified in tx idle register */
+                val = (unsigned char)(info->idle_mode & 0xff);
+        } else {
+                /* standard 8 bit idle patterns */
+                switch(info->idle_mode)
+                {
+                case HDLC_TXIDLE_FLAGS:          val = 0x7e; break;
+                case HDLC_TXIDLE_ALT_ZEROS_ONES:
+                case HDLC_TXIDLE_ALT_MARK_SPACE: val = 0xaa; break;
+                case HDLC_TXIDLE_ZEROS:
+                case HDLC_TXIDLE_SPACE:          val = 0x00; break;
+                default:                         val = 0xff;
+                }
         }
 
         wr_reg8(info, TIR, val);
@@ -4313,6 +4339,12 @@ static int rx_get_frame(struct slgt_info *info)
         unsigned long flags;
         struct tty_struct *tty = info->tty;
         unsigned char addr_field = 0xff;
+        unsigned int crc_size = 0;
+
+        switch (info->params.crc_type & HDLC_CRC_MASK) {
+        case HDLC_CRC_16_CCITT: crc_size = 2; break;
+        case HDLC_CRC_32_CCITT: crc_size = 4; break;
+        }
 
 check_again:
 
@@ -4357,7 +4389,7 @@ check_again:
         status = desc_status(info->rbufs[end]);
 
         /* ignore CRC bit if not using CRC (bit is undefined) */
-        if (info->params.crc_type == HDLC_CRC_NONE)
+        if ((info->params.crc_type & HDLC_CRC_MASK) == HDLC_CRC_NONE)
                 status &= ~BIT1;
 
         if (framesize == 0 ||
@@ -4366,34 +4398,34 @@ check_again:
                 goto check_again;
         }
 
-        if (framesize < 2 || status & (BIT1+BIT0)) {
-                if (framesize < 2 || (status & BIT0))
-                        info->icount.rxshort++;
-                else
-                        info->icount.rxcrc++;
+        if (framesize < (2 + crc_size) || status & BIT0) {
+                info->icount.rxshort++;
                 framesize = 0;
+        } else if (status & BIT1) {
+                info->icount.rxcrc++;
+                if (!(info->params.crc_type & HDLC_CRC_RETURN_EX))
+                        framesize = 0;
+        }
 
 #ifdef CONFIG_HDLC
-                {
-                        struct net_device_stats *stats = hdlc_stats(info->netdev);
-                        stats->rx_errors++;
-                        stats->rx_frame_errors++;
-                }
-#endif
-        } else {
-                /* adjust frame size for CRC, if any */
-                if (info->params.crc_type == HDLC_CRC_16_CCITT)
-                        framesize -= 2;
-                else if (info->params.crc_type == HDLC_CRC_32_CCITT)
-                        framesize -= 4;
+        if (framesize == 0) {
+                struct net_device_stats *stats = hdlc_stats(info->netdev);
+                stats->rx_errors++;
+                stats->rx_frame_errors++;
         }
+#endif
 
         DBGBH(("%s rx frame status=%04X size=%d\n",
                 info->device_name, status, framesize));
         DBGDATA(info, info->rbufs[start].buf, min_t(int, framesize, DMABUFSIZE), "rx");
 
         if (framesize) {
-                if (framesize > info->max_frame_size)
+                if (!(info->params.crc_type & HDLC_CRC_RETURN_EX)) {
+                        framesize -= crc_size;
+                        crc_size = 0;
+                }
+
+                if (framesize > info->max_frame_size + crc_size)
                         info->icount.rxlong++;
                 else {
                         /* copy dma buffer(s) to contiguous temp buffer */
@@ -4413,6 +4445,11 @@ check_again:
                                         i = 0;
                         }
 
+                        if (info->params.crc_type & HDLC_CRC_RETURN_EX) {
+                                *p = (status & BIT1) ? RX_CRC_ERROR : RX_OK;
+                                framesize++;
+                        }
+
 #ifdef CONFIG_HDLC
                         if (info->netcount)
                                 hdlcdev_rx(info,info->tmp_rbuf, framesize);
@@ -4671,13 +4708,13 @@ static int loopback_test(struct slgt_info *info)
 static int adapter_test(struct slgt_info *info)
 {
         DBGINFO(("testing %s\n", info->device_name));
-        if ((info->init_error = register_test(info)) < 0) {
+        if (register_test(info) < 0) {
                 printk("register test failure %s addr=%08X\n",
                         info->device_name, info->phys_reg_addr);
-        } else if ((info->init_error = irq_test(info)) < 0) {
+        } else if (irq_test(info) < 0) {
                 printk("IRQ test failure %s IRQ=%d\n",
                         info->device_name, info->irq_level);
-        } else if ((info->init_error = loopback_test(info)) < 0) {
+        } else if (loopback_test(info) < 0) {
                 printk("loopback test failure %s\n", info->device_name);
         }
         return info->init_error;
diff --git a/drivers/char/synclinkmp.c b/drivers/char/synclinkmp.c
index 858740131115..21bf15ad9980 100644
--- a/drivers/char/synclinkmp.c
+++ b/drivers/char/synclinkmp.c
@@ -988,7 +988,7 @@ static int write(struct tty_struct *tty,
         if (sanity_check(info, tty->name, "write"))
                 goto cleanup;
 
-        if (!tty || !info->tx_buf)
+        if (!info->tx_buf)
                 goto cleanup;
 
         if (info->params.mode == MGSL_MODE_HDLC) {
@@ -1067,7 +1067,7 @@ static void put_char(struct tty_struct *tty, unsigned char ch)
         if (sanity_check(info, tty->name, "put_char"))
                 return;
 
-        if (!tty || !info->tx_buf)
+        if (!info->tx_buf)
                 return;
 
         spin_lock_irqsave(&info->lock,flags);
diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig
index 1e371a510dd2..731c3d5da0dc 100644
--- a/drivers/firmware/Kconfig
+++ b/drivers/firmware/Kconfig
@@ -6,8 +6,7 @@
 menu "Firmware Drivers"
 
 config EDD
-        tristate "BIOS Enhanced Disk Drive calls determine boot disk (EXPERIMENTAL)"
-        depends on EXPERIMENTAL
+        tristate "BIOS Enhanced Disk Drive calls determine boot disk"
         depends on !IA64
         help
           Say Y or M here if you want to enable BIOS Enhanced Disk Drive
diff --git a/drivers/firmware/dmi_scan.c b/drivers/firmware/dmi_scan.c
index 948bd7e1445a..b9e3886d9e16 100644
--- a/drivers/firmware/dmi_scan.c
+++ b/drivers/firmware/dmi_scan.c
@@ -255,10 +255,15 @@ void __init dmi_scan_machine(void)
 /**
  *      dmi_check_system - check system DMI data
  *      @list: array of dmi_system_id structures to match against
+ *              All non-null elements of the list must match
+ *              their slot's (field index's) data (i.e., each
+ *              list string must be a substring of the specified
+ *              DMI slot's string data) to be considered a
+ *              successful match.
  *
  *      Walk the blacklist table running matching functions until someone
  *      returns non zero or we hit the end. Callback function is called for
- *      each successfull match. Returns the number of matches.
+ *      each successful match. Returns the number of matches.
  */
 int dmi_check_system(struct dmi_system_id *list)
 {
@@ -287,7 +292,7 @@ EXPORT_SYMBOL(dmi_check_system);
 
 /**
  *      dmi_get_system_info - return DMI data value
- *      @field: data index (see enum dmi_filed)
+ *      @field: data index (see enum dmi_field)
  *
  *      Returns one DMI data value, can be used to perform
  *      complex DMI data checks.
@@ -301,13 +306,13 @@ EXPORT_SYMBOL(dmi_get_system_info);
 /**
  *      dmi_find_device - find onboard device by type/name
  *      @type: device type or %DMI_DEV_TYPE_ANY to match all device types
- *      @desc: device name string or %NULL to match all
+ *      @name: device name string or %NULL to match all
  *      @from: previous device found in search, or %NULL for new search.
  *
  *      Iterates through the list of known onboard devices. If a device is
  *      found with a matching @vendor and @device, a pointer to its device
  *      structure is returned.  Otherwise, %NULL is returned.
- *      A new search is initiated by passing %NULL to the @from argument.
+ *      A new search is initiated by passing %NULL as the @from argument.
  *      If @from is not %NULL, searches continue from next device.
  */
 struct dmi_device * dmi_find_device(int type, const char *name,
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 6de3cd3d6e8e..99fa42402e71 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -395,7 +395,8 @@ static int cdrom_log_sense(ide_drive_t *drive, struct request *rq,
                          * we cannot reliably check if drive can auto-close
                          */
                         if (rq->cmd[0] == GPCMD_START_STOP_UNIT && sense->asc == 0x24)
-                                log = 0;
+                                break;
+                        log = 1;
                         break;
                 case UNIT_ATTENTION:
                         /*
@@ -417,6 +418,11 @@ void cdrom_analyze_sense_data(ide_drive_t *drive,
                               struct request *failed_command,
                               struct request_sense *sense)
 {
+        unsigned long sector;
+        unsigned long bio_sectors;
+        unsigned long valid;
+        struct cdrom_info *info = drive->driver_data;
+
         if (!cdrom_log_sense(drive, failed_command, sense))
                 return;
 
@@ -429,6 +435,37 @@ void cdrom_analyze_sense_data(ide_drive_t *drive,
                 if (sense->sense_key == 0x05 && sense->asc == 0x24)
                         return;
 
+        if (sense->error_code == 0x70) {        /* Current Error */
+                switch(sense->sense_key) {
+                case MEDIUM_ERROR:
+                case VOLUME_OVERFLOW:
+                case ILLEGAL_REQUEST:
+                        if (!sense->valid)
+                                break;
+                        if (failed_command == NULL ||
+                                        !blk_fs_request(failed_command))
+                                break;
+                        sector = (sense->information[0] << 24) |
+                                 (sense->information[1] << 16) |
+                                 (sense->information[2] <<  8) |
+                                 (sense->information[3]);
+
+                        bio_sectors = bio_sectors(failed_command->bio);
+                        if (bio_sectors < 4)
+                                bio_sectors = 4;
+                        if (drive->queue->hardsect_size == 2048)
+                                sector <<= 2;   /* Device sector size is 2K */
+                        sector &= ~(bio_sectors -1);
+                        valid = (sector - failed_command->sector) << 9;
+
+                        if (valid < 0)
+                                valid = 0;
+                        if (sector < get_capacity(info->disk) &&
+                                drive->probed_capacity - sector < 4 * 75) {
+                                set_capacity(info->disk, sector);
+                        }
+                }
+        }
 #if VERBOSE_IDE_CD_ERRORS
         {
                 int i;
@@ -609,17 +646,23 @@ static void cdrom_end_request (ide_drive_t *drive, int uptodate)
                                 sense = failed->sense;
                                 failed->sense_len = rq->sense_len;
                         }
-
+                        cdrom_analyze_sense_data(drive, failed, sense);
                         /*
                          * now end failed request
                          */
-                        spin_lock_irqsave(&ide_lock, flags);
-                        end_that_request_chunk(failed, 0, failed->data_len);
-                        end_that_request_last(failed, 0);
-                        spin_unlock_irqrestore(&ide_lock, flags);
-                }
-
-                cdrom_analyze_sense_data(drive, failed, sense);
+                        if (blk_fs_request(failed)) {
+                                if (ide_end_dequeued_request(drive, failed, 0,
+                                                failed->hard_nr_sectors))
+                                        BUG();
+                        } else {
+                                spin_lock_irqsave(&ide_lock, flags);
+                                end_that_request_chunk(failed, 0,
+                                                        failed->data_len);
+                                end_that_request_last(failed, 0);
+                                spin_unlock_irqrestore(&ide_lock, flags);
+                        }
+                } else
+                        cdrom_analyze_sense_data(drive, NULL, sense);
         }
 
         if (!rq->current_nr_sectors && blk_fs_request(rq))
@@ -633,6 +676,13 @@ static void cdrom_end_request (ide_drive_t *drive, int uptodate)
         ide_end_request(drive, uptodate, nsectors);
 }
 
+static void ide_dump_status_no_sense(ide_drive_t *drive, const char *msg, u8 stat)
+{
+        if (stat & 0x80)
+                return;
+        ide_dump_status(drive, msg, stat);
+}
+
 /* Returns 0 if the request should be continued.
    Returns 1 if the request was ended. */
 static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
@@ -761,16 +811,16 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
                            sense_key == DATA_PROTECT) {
                         /* No point in retrying after an illegal
                            request or data protect error.*/
-                        ide_dump_status (drive, "command error", stat);
+                        ide_dump_status_no_sense (drive, "command error", stat);
                         do_end_request = 1;
                 } else if (sense_key == MEDIUM_ERROR) {
                         /* No point in re-trying a zillion times on a bad 
                          * sector...  If we got here the error is not correctable */
-                        ide_dump_status (drive, "media error (bad sector)", stat);
+                        ide_dump_status_no_sense (drive, "media error (bad sector)", stat);
                         do_end_request = 1;
                 } else if (sense_key == BLANK_CHECK) {
                         /* Disk appears blank ?? */
-                        ide_dump_status (drive, "media error (blank)", stat);
+                        ide_dump_status_no_sense (drive, "media error (blank)", stat);
                         do_end_request = 1;
                 } else if ((err & ~ABRT_ERR) != 0) {
                         /* Go to the default handler
@@ -782,13 +832,27 @@ static int cdrom_decode_status(ide_drive_t *drive, int good_stat, int *stat_ret)
                         do_end_request = 1;
                 }
 
-                if (do_end_request)
-                        cdrom_end_request(drive, 0);
-
-                /* If we got a CHECK_CONDITION status,
-                   queue a request sense command. */
-                if ((stat & ERR_STAT) != 0)
-                        cdrom_queue_request_sense(drive, NULL, NULL);
+                /* End a request through request sense analysis when we have
+                   sense data. We need this in order to perform end of media
+                   processing */
+
+                if (do_end_request) {
+                        if (stat & ERR_STAT) {
+                                unsigned long flags;
+                                spin_lock_irqsave(&ide_lock, flags);
+                                blkdev_dequeue_request(rq);
+                                HWGROUP(drive)->rq = NULL;
+                                spin_unlock_irqrestore(&ide_lock, flags);
+
+                                cdrom_queue_request_sense(drive, rq->sense, rq);
+                        } else
+                                cdrom_end_request(drive, 0);
+                } else {
+                        /* If we got a CHECK_CONDITION status,
+                           queue a request sense command. */
+                        if (stat & ERR_STAT)
+                                cdrom_queue_request_sense(drive, NULL, NULL);
+                }
         } else {
                 blk_dump_rq_flags(rq, "ide-cd: bad rq");
                 cdrom_end_request(drive, 0);
@@ -1491,8 +1555,7 @@ static ide_startstop_t cdrom_do_packet_command (ide_drive_t *drive)
 }
 
 
-static
-int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
+static int cdrom_queue_packet_command(ide_drive_t *drive, struct request *rq)
 {
         struct request_sense sense;
         int retries = 10;
@@ -2220,6 +2283,9 @@ static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
                 toc->capacity = 0x1fffff;
 
         set_capacity(info->disk, toc->capacity * sectors_per_frame);
+        /* Save a private copy of te TOC capacity for error handling */
+        drive->probed_capacity = toc->capacity * sectors_per_frame;
+
         blk_queue_hardsect_size(drive->queue,
                                 sectors_per_frame << SECTOR_BITS);
 
@@ -2342,6 +2408,7 @@ static int cdrom_read_toc(ide_drive_t *drive, struct request_sense *sense)
         if (!stat && (last_written > toc->capacity)) {
                 toc->capacity = last_written;
                 set_capacity(info->disk, toc->capacity * sectors_per_frame);
+                drive->probed_capacity = toc->capacity * sectors_per_frame;
         }
 
         /* Remember that we've read this stuff. */
@@ -2698,14 +2765,11 @@ int ide_cdrom_drive_status (struct cdrom_device_info *cdi, int slot_nr)
          * any other way to detect this...
          */
         if (sense.sense_key == NOT_READY) {
-                if (sense.asc == 0x3a) {
-                        if (sense.ascq == 1)
-                                return CDS_NO_DISC;
-                        else if (sense.ascq == 0 || sense.ascq == 2)
-                                return CDS_TRAY_OPEN;
-                }
+                if (sense.asc == 0x3a && sense.ascq == 1)
+                        return CDS_NO_DISC;
+                else
+                        return CDS_TRAY_OPEN;
         }
-
         return CDS_DRIVE_NOT_READY;
 }
 
diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index a1179e924962..4656587aa2f7 100644
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -1284,7 +1284,7 @@ static ide_startstop_t idefloppy_do_request (ide_drive_t *drive, struct request
 
         debug_log(KERN_INFO "rq_status: %d, dev: %s, flags: %lx, errors: %d\n",
                         rq->rq_status,
-                        rq->rq_disk ? rq->rq_disk->disk_name ? "?",
+                        rq->rq_disk ? rq->rq_disk->disk_name : "?",
                         rq->flags, rq->errors);
         debug_log(KERN_INFO "sector: %ld, nr_sectors: %ld, "
                         "current_nr_sectors: %d\n", (long)rq->sector,
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index 4f2f138de2ca..622a55c72f03 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -223,6 +223,63 @@ static ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *
 }
 
 /**
+ *      ide_end_dequeued_request        -       complete an IDE I/O
+ *      @drive: IDE device for the I/O
+ *      @uptodate:
+ *      @nr_sectors: number of sectors completed
+ *
+ *      Complete an I/O that is no longer on the request queue. This
+ *      typically occurs when we pull the request and issue a REQUEST_SENSE.
+ *      We must still finish the old request but we must not tamper with the
+ *      queue in the meantime.
+ *
+ *      NOTE: This path does not handle barrier, but barrier is not supported
+ *      on ide-cd anyway.
+ */
+
+int ide_end_dequeued_request(ide_drive_t *drive, struct request *rq,
+                             int uptodate, int nr_sectors)
+{
+        unsigned long flags;
+        int ret = 1;
+
+        spin_lock_irqsave(&ide_lock, flags);
+
+        BUG_ON(!(rq->flags & REQ_STARTED));
+
+        /*
+         * if failfast is set on a request, override number of sectors and
+         * complete the whole request right now
+         */
+        if (blk_noretry_request(rq) && end_io_error(uptodate))
+                nr_sectors = rq->hard_nr_sectors;
+
+        if (!blk_fs_request(rq) && end_io_error(uptodate) && !rq->errors)
+                rq->errors = -EIO;
+
+        /*
+         * decide whether to reenable DMA -- 3 is a random magic for now,
+         * if we DMA timeout more than 3 times, just stay in PIO
+         */
+        if (drive->state == DMA_PIO_RETRY && drive->retry_pio <= 3) {
+                drive->state = 0;
+                HWGROUP(drive)->hwif->ide_dma_on(drive);
+        }
+
+        if (!end_that_request_first(rq, uptodate, nr_sectors)) {
+                add_disk_randomness(rq->rq_disk);
+                if (blk_rq_tagged(rq))
+                        blk_queue_end_tag(drive->queue, rq);
+                end_that_request_last(rq, uptodate);
+                ret = 0;
+        }
+        spin_unlock_irqrestore(&ide_lock, flags);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(ide_end_dequeued_request);
+
+
+/**
  *      ide_complete_pm_request - end the current Power Management request
  *      @drive: target drive
  *      @rq: request
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index f04791a58df0..09f3a7dab28a 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -2646,21 +2646,23 @@ static idetape_stage_t *idetape_kmalloc_stage (idetape_tape_t *tape)
         return __idetape_kmalloc_stage(tape, 0, 0);
 }
 
-static void idetape_copy_stage_from_user (idetape_tape_t *tape, idetape_stage_t *stage, const char __user *buf, int n)
+static int idetape_copy_stage_from_user (idetape_tape_t *tape, idetape_stage_t *stage, const char __user *buf, int n)
 {
         struct idetape_bh *bh = tape->bh;
         int count;
+        int ret = 0;
 
         while (n) {
 #if IDETAPE_DEBUG_BUGS
                 if (bh == NULL) {
                         printk(KERN_ERR "ide-tape: bh == NULL in "
                                 "idetape_copy_stage_from_user\n");
-                        return;
+                        return 1;
                 }
 #endif /* IDETAPE_DEBUG_BUGS */
                 count = min((unsigned int)(bh->b_size - atomic_read(&bh->b_count)), (unsigned int)n);
-                copy_from_user(bh->b_data + atomic_read(&bh->b_count), buf, count);
+                if (copy_from_user(bh->b_data + atomic_read(&bh->b_count), buf, count))
+                        ret = 1;
                 n -= count;
                 atomic_add(count, &bh->b_count);
                 buf += count;
@@ -2671,23 +2673,26 @@ static void idetape_copy_stage_from_user (idetape_tape_t *tape, idetape_stage_t
                 }
         }
         tape->bh = bh;
+        return ret;
 }
 
-static void idetape_copy_stage_to_user (idetape_tape_t *tape, char __user *buf, idetape_stage_t *stage, int n)
+static int idetape_copy_stage_to_user (idetape_tape_t *tape, char __user *buf, idetape_stage_t *stage, int n)
 {
         struct idetape_bh *bh = tape->bh;
         int count;
+        int ret = 0;
 
         while (n) {
 #if IDETAPE_DEBUG_BUGS
                 if (bh == NULL) {
                         printk(KERN_ERR "ide-tape: bh == NULL in "
                                 "idetape_copy_stage_to_user\n");
-                        return;
+                        return 1;
                 }
 #endif /* IDETAPE_DEBUG_BUGS */
                 count = min(tape->b_count, n);
-                copy_to_user(buf, tape->b_data, count);
+                if  (copy_to_user(buf, tape->b_data, count))
+                        ret = 1;
                 n -= count;
                 tape->b_data += count;
                 tape->b_count -= count;
@@ -2700,6 +2705,7 @@ static void idetape_copy_stage_to_user (idetape_tape_t *tape, char __user *buf,
                         }
                 }
         }
+        return ret;
 }
 
 static void idetape_init_merge_stage (idetape_tape_t *tape)
@@ -3719,6 +3725,7 @@ static ssize_t idetape_chrdev_read (struct file *file, char __user *buf,
         struct ide_tape_obj *tape = ide_tape_f(file);
         ide_drive_t *drive = tape->drive;
         ssize_t bytes_read,temp, actually_read = 0, rc;
+        ssize_t ret = 0;
 
 #if IDETAPE_DEBUG_LOG
         if (tape->debug_level >= 3)
@@ -3737,7 +3744,8 @@ static ssize_t idetape_chrdev_read (struct file *file, char __user *buf,
                 return (0);
         if (tape->merge_stage_size) {
                 actually_read = min((unsigned int)(tape->merge_stage_size), (unsigned int)count);
-                idetape_copy_stage_to_user(tape, buf, tape->merge_stage, actually_read);
+                if (idetape_copy_stage_to_user(tape, buf, tape->merge_stage, actually_read))
+                        ret = -EFAULT;
                 buf += actually_read;
                 tape->merge_stage_size -= actually_read;
                 count -= actually_read;
@@ -3746,7 +3754,8 @@ static ssize_t idetape_chrdev_read (struct file *file, char __user *buf,
                 bytes_read = idetape_add_chrdev_read_request(drive, tape->capabilities.ctl);
                 if (bytes_read <= 0)
                         goto finish;
-                idetape_copy_stage_to_user(tape, buf, tape->merge_stage, bytes_read);
+                if (idetape_copy_stage_to_user(tape, buf, tape->merge_stage, bytes_read))
+                        ret = -EFAULT;
                 buf += bytes_read;
                 count -= bytes_read;
                 actually_read += bytes_read;
@@ -3756,7 +3765,8 @@ static ssize_t idetape_chrdev_read (struct file *file, char __user *buf,
                 if (bytes_read <= 0)
                         goto finish;
                 temp = min((unsigned long)count, (unsigned long)bytes_read);
-                idetape_copy_stage_to_user(tape, buf, tape->merge_stage, temp);
+                if (idetape_copy_stage_to_user(tape, buf, tape->merge_stage, temp))
+                        ret = -EFAULT;
                 actually_read += temp;
                 tape->merge_stage_size = bytes_read-temp;
         }
@@ -3769,7 +3779,8 @@ finish:
                 idetape_space_over_filemarks(drive, MTFSF, 1);
                 return 0;
         }
-        return actually_read;
+
+        return (ret) ? ret : actually_read;
 }
 
 static ssize_t idetape_chrdev_write (struct file *file, const char __user *buf,
@@ -3777,7 +3788,8 @@ static ssize_t idetape_chrdev_write (struct file *file, const char __user *buf,
 {
         struct ide_tape_obj *tape = ide_tape_f(file);
         ide_drive_t *drive = tape->drive;
-        ssize_t retval, actually_written = 0;
+        ssize_t actually_written = 0;
+        ssize_t ret = 0;
 
         /* The drive is write protected. */
         if (tape->write_prot)
@@ -3813,7 +3825,7 @@ static ssize_t idetape_chrdev_write (struct file *file, const char __user *buf,
                  *      some drives (Seagate STT3401A) will return an error.
                  */
                 if (drive->dsc_overlap) {
-                        retval = idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, 0, tape->merge_stage->bh);
+                        ssize_t retval = idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, 0, tape->merge_stage->bh);
                         if (retval < 0) {
                                 __idetape_kfree_stage(tape->merge_stage);
                                 tape->merge_stage = NULL;
@@ -3834,12 +3846,14 @@ static ssize_t idetape_chrdev_write (struct file *file, const char __user *buf,
                 }
 #endif /* IDETAPE_DEBUG_BUGS */
                 actually_written = min((unsigned int)(tape->stage_size - tape->merge_stage_size), (unsigned int)count);
-                idetape_copy_stage_from_user(tape, tape->merge_stage, buf, actually_written);
+                if (idetape_copy_stage_from_user(tape, tape->merge_stage, buf, actually_written))
+                                ret = -EFAULT;
                 buf += actually_written;
                 tape->merge_stage_size += actually_written;
                 count -= actually_written;
 
                 if (tape->merge_stage_size == tape->stage_size) {
+                        ssize_t retval;
                         tape->merge_stage_size = 0;
                         retval = idetape_add_chrdev_write_request(drive, tape->capabilities.ctl);
                         if (retval <= 0)
@@ -3847,7 +3861,9 @@ static ssize_t idetape_chrdev_write (struct file *file, const char __user *buf,
                 }
         }
         while (count >= tape->stage_size) {
-                idetape_copy_stage_from_user(tape, tape->merge_stage, buf, tape->stage_size);
+                ssize_t retval;
+                if (idetape_copy_stage_from_user(tape, tape->merge_stage, buf, tape->stage_size))
+                        ret = -EFAULT;
                 buf += tape->stage_size;
                 count -= tape->stage_size;
                 retval = idetape_add_chrdev_write_request(drive, tape->capabilities.ctl);
@@ -3857,10 +3873,11 @@ static ssize_t idetape_chrdev_write (struct file *file, const char __user *buf,
         }
         if (count) {
                 actually_written += count;
-                idetape_copy_stage_from_user(tape, tape->merge_stage, buf, count);
+                if (idetape_copy_stage_from_user(tape, tape->merge_stage, buf, count))
+                        ret = -EFAULT;
                 tape->merge_stage_size += count;
         }
-        return (actually_written);
+        return (ret) ? ret : actually_written;
 }
 
 static int idetape_write_filemark (ide_drive_t *drive)
diff --git a/drivers/ieee1394/Kconfig b/drivers/ieee1394/Kconfig
index 79b81be67975..186737539cf5 100644
--- a/drivers/ieee1394/Kconfig
+++ b/drivers/ieee1394/Kconfig
@@ -4,7 +4,7 @@ menu "IEEE 1394 (FireWire) support"
 
 config IEEE1394
         tristate "IEEE 1394 (FireWire) support"
-        depends on (PCI || BROKEN) && (BROKEN || !FRV)
+        depends on PCI || BROKEN
         select NET
         help
           IEEE 1394 describes a high performance serial bus, which is also
diff --git a/drivers/ieee1394/nodemgr.c b/drivers/ieee1394/nodemgr.c
index 948f1b8c4238..50c71e17de73 100644
--- a/drivers/ieee1394/nodemgr.c
+++ b/drivers/ieee1394/nodemgr.c
@@ -8,6 +8,7 @@
  * directory of the kernel sources for details.
  */
 
+#include <linux/bitmap.h>
 #include <linux/kernel.h>
 #include <linux/config.h>
 #include <linux/list.h>
@@ -334,10 +335,12 @@ static ssize_t fw_show_ne_bus_options(struct device *dev, struct device_attribut
 static DEVICE_ATTR(bus_options,S_IRUGO,fw_show_ne_bus_options,NULL);
 
 
+/* tlabels_free, tlabels_allocations, tlabels_mask are read non-atomically
+ * here, therefore displayed values may be occasionally wrong. */
 static ssize_t fw_show_ne_tlabels_free(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct node_entry *ne = container_of(dev, struct node_entry, device);
-        return sprintf(buf, "%d\n", atomic_read(&ne->tpool->count.count) + 1);
+        return sprintf(buf, "%d\n", 64 - bitmap_weight(ne->tpool->pool, 64));
 }
 static DEVICE_ATTR(tlabels_free,S_IRUGO,fw_show_ne_tlabels_free,NULL);
 
diff --git a/drivers/input/touchscreen/ads7846.c b/drivers/input/touchscreen/ads7846.c
index 161afddd0f44..386023c594d7 100644
--- a/drivers/input/touchscreen/ads7846.c
+++ b/drivers/input/touchscreen/ads7846.c
@@ -773,8 +773,7 @@ static int __devinit ads7846_probe(struct spi_device *spi)
 
         ts->last_msg = m;
 
-        if (request_irq(spi->irq, ads7846_irq,
-                        SA_SAMPLE_RANDOM | SA_TRIGGER_FALLING,
+        if (request_irq(spi->irq, ads7846_irq, SA_TRIGGER_FALLING,
                         spi->dev.driver->name, ts)) {
                 dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq);
                 err = -EBUSY;
diff --git a/drivers/input/touchscreen/h3600_ts_input.c b/drivers/input/touchscreen/h3600_ts_input.c
index a18d56bdafd9..a595d386312f 100644
--- a/drivers/input/touchscreen/h3600_ts_input.c
+++ b/drivers/input/touchscreen/h3600_ts_input.c
@@ -399,16 +399,14 @@ static int h3600ts_connect(struct serio *serio, struct serio_driver *drv)
         set_GPIO_IRQ_edge(GPIO_BITSY_NPOWER_BUTTON, GPIO_RISING_EDGE);
 
         if (request_irq(IRQ_GPIO_BITSY_ACTION_BUTTON, action_button_handler,
-                        SA_SHIRQ | SA_INTERRUPT | SA_SAMPLE_RANDOM,
-                        "h3600_action", &ts->dev)) {
+                        SA_SHIRQ | SA_INTERRUPT, "h3600_action", &ts->dev)) {
                 printk(KERN_ERR "h3600ts.c: Could not allocate Action Button IRQ!\n");
                 err = -EBUSY;
                 goto fail2;
         }
 
         if (request_irq(IRQ_GPIO_BITSY_NPOWER_BUTTON, npower_button_handler,
-                        SA_SHIRQ | SA_INTERRUPT | SA_SAMPLE_RANDOM,
-                        "h3600_suspend", &ts->dev)) {
+                        SA_SHIRQ | SA_INTERRUPT, "h3600_suspend", &ts->dev)) {
                 printk(KERN_ERR "h3600ts.c: Could not allocate Power Button IRQ!\n");
                 err = -EBUSY;
                 goto fail3;
diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig
index f573d5af0b1f..96509989e921 100644
--- a/drivers/leds/Kconfig
+++ b/drivers/leds/Kconfig
@@ -93,5 +93,14 @@ config LEDS_TRIGGER_IDE_DISK
           This allows LEDs to be controlled by IDE disk activity.
           If unsure, say Y.
 
+config LEDS_TRIGGER_HEARTBEAT
+        tristate "LED Heartbeat Trigger"
+        depends LEDS_TRIGGERS
+        help
+          This allows LEDs to be controlled by a CPU load average.
+          The flash frequency is a hyperbolic function of the 1-minute
+          load average.
+          If unsure, say Y.
+
 endmenu
 
diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile
index dcea1001faa4..88d3b6eaa6a2 100644
--- a/drivers/leds/Makefile
+++ b/drivers/leds/Makefile
@@ -16,3 +16,4 @@ obj-$(CONFIG_LEDS_AMS_DELTA)		+= leds-ams-delta.o
 # LED Triggers
 obj-$(CONFIG_LEDS_TRIGGER_TIMER)        += ledtrig-timer.o
 obj-$(CONFIG_LEDS_TRIGGER_IDE_DISK)     += ledtrig-ide-disk.o
+obj-$(CONFIG_LEDS_TRIGGER_HEARTBEAT)    += ledtrig-heartbeat.o
diff --git a/drivers/leds/ledtrig-heartbeat.c b/drivers/leds/ledtrig-heartbeat.c
new file mode 100644
index 000000000000..4bf8cec8b8c1
--- /dev/null
+++ b/drivers/leds/ledtrig-heartbeat.c
@@ -0,0 +1,118 @@
+/*
+ * LED Heartbeat Trigger
+ *
+ * Copyright (C) 2006 Atsushi Nemoto <anemo@mba.ocn.ne.jp>
+ *
+ * Based on Richard Purdie's ledtrig-timer.c and some arch's
+ * CONFIG_HEARTBEAT code.
+ *
+ * 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/kernel.h>
+#include <linux/init.h>
+#include <linux/timer.h>
+#include <linux/sched.h>
+#include <linux/leds.h>
+#include "leds.h"
+
+struct heartbeat_trig_data {
+        unsigned int phase;
+        unsigned int period;
+        struct timer_list timer;
+};
+
+static void led_heartbeat_function(unsigned long data)
+{
+        struct led_classdev *led_cdev = (struct led_classdev *) data;
+        struct heartbeat_trig_data *heartbeat_data = led_cdev->trigger_data;
+        unsigned long brightness = LED_OFF;
+        unsigned long delay = 0;
+
+        /* acts like an actual heart beat -- ie thump-thump-pause... */
+        switch (heartbeat_data->phase) {
+        case 0:
+                /*
+                 * The hyperbolic function below modifies the
+                 * heartbeat period length in dependency of the
+                 * current (1min) load. It goes through the points
+                 * f(0)=1260, f(1)=860, f(5)=510, f(inf)->300.
+                 */
+                heartbeat_data->period = 300 +
+                        (6720 << FSHIFT) / (5 * avenrun[0] + (7 << FSHIFT));
+                heartbeat_data->period =
+                        msecs_to_jiffies(heartbeat_data->period);
+                delay = msecs_to_jiffies(70);
+                heartbeat_data->phase++;
+                brightness = LED_FULL;
+                break;
+        case 1:
+                delay = heartbeat_data->period / 4 - msecs_to_jiffies(70);
+                heartbeat_data->phase++;
+                break;
+        case 2:
+                delay = msecs_to_jiffies(70);
+                heartbeat_data->phase++;
+                brightness = LED_FULL;
+                break;
+        default:
+                delay = heartbeat_data->period - heartbeat_data->period / 4 -
+                        msecs_to_jiffies(70);
+                heartbeat_data->phase = 0;
+                break;
+        }
+
+        led_set_brightness(led_cdev, brightness);
+        mod_timer(&heartbeat_data->timer, jiffies + delay);
+}
+
+static void heartbeat_trig_activate(struct led_classdev *led_cdev)
+{
+        struct heartbeat_trig_data *heartbeat_data;
+
+        heartbeat_data = kzalloc(sizeof(*heartbeat_data), GFP_KERNEL);
+        if (!heartbeat_data)
+                return;
+
+        led_cdev->trigger_data = heartbeat_data;
+        setup_timer(&heartbeat_data->timer,
+                    led_heartbeat_function, (unsigned long) led_cdev);
+        heartbeat_data->phase = 0;
+        led_heartbeat_function(heartbeat_data->timer.data);
+}
+
+static void heartbeat_trig_deactivate(struct led_classdev *led_cdev)
+{
+        struct heartbeat_trig_data *heartbeat_data = led_cdev->trigger_data;
+
+        if (heartbeat_data) {
+                del_timer_sync(&heartbeat_data->timer);
+                kfree(heartbeat_data);
+        }
+}
+
+static struct led_trigger heartbeat_led_trigger = {
+        .name     = "heartbeat",
+        .activate = heartbeat_trig_activate,
+        .deactivate = heartbeat_trig_deactivate,
+};
+
+static int __init heartbeat_trig_init(void)
+{
+        return led_trigger_register(&heartbeat_led_trigger);
+}
+
+static void __exit heartbeat_trig_exit(void)
+{
+        led_trigger_unregister(&heartbeat_led_trigger);
+}
+
+module_init(heartbeat_trig_init);
+module_exit(heartbeat_trig_exit);
+
+MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
+MODULE_DESCRIPTION("Heartbeat LED trigger");
+MODULE_LICENSE("GPL");
diff --git a/drivers/macintosh/Kconfig b/drivers/macintosh/Kconfig
index ccf5df44cde4..37cd6ee4586b 100644
--- a/drivers/macintosh/Kconfig
+++ b/drivers/macintosh/Kconfig
@@ -99,17 +99,22 @@ config PMAC_MEDIABAY
           devices are not fully supported in the bay as I never had one to
           try with
 
-# made a separate option since backlight may end up beeing used
-# on non-powerbook machines (but only on PMU based ones AFAIK)
 config PMAC_BACKLIGHT
         bool "Backlight control for LCD screens"
         depends on ADB_PMU && (BROKEN || !PPC64)
         help
-          Say Y here to build in code to manage the LCD backlight on a
-          Macintosh PowerBook.  With this code, the backlight will be turned
-          on and off appropriately on power-management and lid-open/lid-closed
-          events; also, the PowerBook button device will be enabled so you can
-          change the screen brightness.
+          Say Y here to enable Macintosh specific extensions of the generic
+          backlight code. With this enabled, the brightness keys on older
+          PowerBooks will be enabled so you can change the screen brightness.
+          Newer models should use an userspace daemon like pbbuttonsd.
+
+config PMAC_BACKLIGHT_LEGACY
+        bool "Provide legacy ioctl's on /dev/pmu for the backlight"
+        depends on PMAC_BACKLIGHT && (BROKEN || !PPC64)
+        help
+          Say Y if you want to enable legacy ioctl's on /dev/pmu. This is for
+          programs which use this old interface. New and updated programs
+          should use the backlight classes in sysfs.
 
 config ADB_MACIO
         bool "Include MacIO (CHRP) ADB driver"
diff --git a/drivers/macintosh/Makefile b/drivers/macintosh/Makefile
index 6081acdea404..8972e53d2dcb 100644
--- a/drivers/macintosh/Makefile
+++ b/drivers/macintosh/Makefile
@@ -12,6 +12,7 @@ obj-$(CONFIG_INPUT_ADBHID)	+= adbhid.o
 obj-$(CONFIG_ANSLCD)            += ans-lcd.o
 
 obj-$(CONFIG_ADB_PMU)           += via-pmu.o
+obj-$(CONFIG_PMAC_BACKLIGHT)    += via-pmu-backlight.o
 obj-$(CONFIG_ADB_CUDA)          += via-cuda.o
 obj-$(CONFIG_PMAC_APM_EMU)      += apm_emu.o
 obj-$(CONFIG_PMAC_SMU)          += smu.o
diff --git a/drivers/macintosh/adbhid.c b/drivers/macintosh/adbhid.c
index 394334ec5765..c26e1236b275 100644
--- a/drivers/macintosh/adbhid.c
+++ b/drivers/macintosh/adbhid.c
@@ -503,9 +503,7 @@ adbhid_buttons_input(unsigned char *data, int nb, struct pt_regs *regs, int auto
         case 0x1f: /* Powerbook button device */
           {
                 int down = (data[1] == (data[1] & 0xf));
-#ifdef CONFIG_PMAC_BACKLIGHT
-                int backlight = get_backlight_level();
-#endif
+
                 /*
                  * XXX: Where is the contrast control for the passive?
                  *  -- Cort
@@ -530,29 +528,17 @@ adbhid_buttons_input(unsigned char *data, int nb, struct pt_regs *regs, int auto
 
                 case 0xa:       /* brightness decrease */
 #ifdef CONFIG_PMAC_BACKLIGHT
-                        if (!disable_kernel_backlight) {
-                                if (down && backlight >= 0) {
-                                        if (backlight > BACKLIGHT_OFF)
-                                                set_backlight_level(backlight-1);
-                                        else
-                                                set_backlight_level(BACKLIGHT_OFF);
-                                }
-                        }
-#endif /* CONFIG_PMAC_BACKLIGHT */
+                        if (!disable_kernel_backlight && down)
+                                pmac_backlight_key_down();
+#endif
                         input_report_key(adbhid[id]->input, KEY_BRIGHTNESSDOWN, down);
                         break;
 
                 case 0x9:       /* brightness increase */
 #ifdef CONFIG_PMAC_BACKLIGHT
-                        if (!disable_kernel_backlight) {
-                                if (down && backlight >= 0) {
-                                        if (backlight < BACKLIGHT_MAX)
-                                                set_backlight_level(backlight+1);
-                                        else 
-                                                set_backlight_level(BACKLIGHT_MAX);
-                                }
-                        }
-#endif /* CONFIG_PMAC_BACKLIGHT */
+                        if (!disable_kernel_backlight && down)
+                                pmac_backlight_key_up();
+#endif
                         input_report_key(adbhid[id]->input, KEY_BRIGHTNESSUP, down);
                         break;
 
diff --git a/drivers/macintosh/via-pmu-backlight.c b/drivers/macintosh/via-pmu-backlight.c
new file mode 100644
index 000000000000..b42d05f2aaff
--- /dev/null
+++ b/drivers/macintosh/via-pmu-backlight.c
@@ -0,0 +1,150 @@
+/*
+ * Backlight code for via-pmu
+ *
+ * Copyright (C) 1998 Paul Mackerras and Fabio Riccardi.
+ * Copyright (C) 2001-2002 Benjamin Herrenschmidt
+ * Copyright (C) 2006      Michael Hanselmann <linux-kernel@hansmi.ch>
+ *
+ */
+
+#include <asm/ptrace.h>
+#include <linux/adb.h>
+#include <linux/pmu.h>
+#include <asm/backlight.h>
+#include <asm/prom.h>
+
+#define MAX_PMU_LEVEL 0xFF
+
+static struct device_node *vias;
+static struct backlight_properties pmu_backlight_data;
+
+static int pmu_backlight_get_level_brightness(struct fb_info *info,
+                int level)
+{
+        int pmulevel;
+
+        /* Get and convert the value */
+        mutex_lock(&info->bl_mutex);
+        pmulevel = info->bl_curve[level] * FB_BACKLIGHT_MAX / MAX_PMU_LEVEL;
+        mutex_unlock(&info->bl_mutex);
+
+        if (pmulevel < 0)
+                pmulevel = 0;
+        else if (pmulevel > MAX_PMU_LEVEL)
+                pmulevel = MAX_PMU_LEVEL;
+
+        return pmulevel;
+}
+
+static int pmu_backlight_update_status(struct backlight_device *bd)
+{
+        struct fb_info *info = class_get_devdata(&bd->class_dev);
+        struct adb_request req;
+        int pmulevel, level = bd->props->brightness;
+
+        if (vias == NULL)
+                return -ENODEV;
+
+        if (bd->props->power != FB_BLANK_UNBLANK ||
+            bd->props->fb_blank != FB_BLANK_UNBLANK)
+                level = 0;
+
+        pmulevel = pmu_backlight_get_level_brightness(info, level);
+
+        pmu_request(&req, NULL, 2, PMU_BACKLIGHT_BRIGHT, pmulevel);
+        pmu_wait_complete(&req);
+
+        pmu_request(&req, NULL, 2, PMU_POWER_CTRL,
+                PMU_POW_BACKLIGHT | (level > 0 ? PMU_POW_ON : PMU_POW_OFF));
+        pmu_wait_complete(&req);
+
+        return 0;
+}
+
+static int pmu_backlight_get_brightness(struct backlight_device *bd)
+{
+        return bd->props->brightness;
+}
+
+static struct backlight_properties pmu_backlight_data = {
+        .owner          = THIS_MODULE,
+        .get_brightness = pmu_backlight_get_brightness,
+        .update_status  = pmu_backlight_update_status,
+        .max_brightness = (FB_BACKLIGHT_LEVELS - 1),
+};
+
+void __init pmu_backlight_init(struct device_node *in_vias)
+{
+        struct backlight_device *bd;
+        struct fb_info *info;
+        char name[10];
+        int level, autosave;
+
+        vias = in_vias;
+
+        /* Special case for the old PowerBook since I can't test on it */
+        autosave =
+                machine_is_compatible("AAPL,3400/2400") ||
+                machine_is_compatible("AAPL,3500");
+
+        if (!autosave &&
+            !pmac_has_backlight_type("pmu") &&
+            !machine_is_compatible("AAPL,PowerBook1998") &&
+            !machine_is_compatible("PowerBook1,1"))
+                return;
+
+        /* Actually, this is a hack, but I don't know of a better way
+         * to get the first framebuffer device.
+         */
+        info = registered_fb[0];
+        if (!info) {
+                printk("pmubl: No framebuffer found\n");
+                goto error;
+        }
+
+        snprintf(name, sizeof(name), "pmubl%d", info->node);
+
+        bd = backlight_device_register(name, info, &pmu_backlight_data);
+        if (IS_ERR(bd)) {
+                printk("pmubl: Backlight registration failed\n");
+                goto error;
+        }
+
+        mutex_lock(&info->bl_mutex);
+        info->bl_dev = bd;
+        fb_bl_default_curve(info, 0x7F, 0x46, 0x0E);
+        mutex_unlock(&info->bl_mutex);
+
+        level = pmu_backlight_data.max_brightness;
+
+        if (autosave) {
+                /* read autosaved value if available */
+                struct adb_request req;
+                pmu_request(&req, NULL, 2, 0xd9, 0);
+                pmu_wait_complete(&req);
+
+                mutex_lock(&info->bl_mutex);
+                level = pmac_backlight_curve_lookup(info,
+                                (req.reply[0] >> 4) *
+                                pmu_backlight_data.max_brightness / 15);
+                mutex_unlock(&info->bl_mutex);
+        }
+
+        up(&bd->sem);
+        bd->props->brightness = level;
+        bd->props->power = FB_BLANK_UNBLANK;
+        bd->props->update_status(bd);
+        down(&bd->sem);
+
+        mutex_lock(&pmac_backlight_mutex);
+        if (!pmac_backlight)
+                pmac_backlight = bd;
+        mutex_unlock(&pmac_backlight_mutex);
+
+        printk("pmubl: Backlight initialized (%s)\n", name);
+
+        return;
+
+error:
+        return;
+}
diff --git a/drivers/macintosh/via-pmu.c b/drivers/macintosh/via-pmu.c
index c63d4e7984be..2a355ae59562 100644
--- a/drivers/macintosh/via-pmu.c
+++ b/drivers/macintosh/via-pmu.c
@@ -144,7 +144,6 @@ static int data_index;
 static int data_len;
 static volatile int adb_int_pending;
 static volatile int disable_poll;
-static struct adb_request bright_req_1, bright_req_2;
 static struct device_node *vias;
 static int pmu_kind = PMU_UNKNOWN;
 static int pmu_fully_inited = 0;
@@ -161,7 +160,7 @@ static int drop_interrupts;
 #if defined(CONFIG_PM) && defined(CONFIG_PPC32)
 static int option_lid_wakeup = 1;
 #endif /* CONFIG_PM && CONFIG_PPC32 */
-#if (defined(CONFIG_PM)&&defined(CONFIG_PPC32))||defined(CONFIG_PMAC_BACKLIGHT)
+#if (defined(CONFIG_PM)&&defined(CONFIG_PPC32))||defined(CONFIG_PMAC_BACKLIGHT_LEGACY)
 static int sleep_in_progress;
 #endif
 static unsigned long async_req_locks;
@@ -208,10 +207,6 @@ static int proc_get_info(char *page, char **start, off_t off,
                           int count, int *eof, void *data);
 static int proc_get_irqstats(char *page, char **start, off_t off,
                           int count, int *eof, void *data);
-#ifdef CONFIG_PMAC_BACKLIGHT
-static int pmu_set_backlight_level(int level, void* data);
-static int pmu_set_backlight_enable(int on, int level, void* data);
-#endif /* CONFIG_PMAC_BACKLIGHT */
 static void pmu_pass_intr(unsigned char *data, int len);
 static int proc_get_batt(char *page, char **start, off_t off,
                         int count, int *eof, void *data);
@@ -292,13 +287,6 @@ static char *pbook_type[] = {
         "Core99"
 };
 
-#ifdef CONFIG_PMAC_BACKLIGHT
-static struct backlight_controller pmu_backlight_controller = {
-        pmu_set_backlight_enable,
-        pmu_set_backlight_level
-};
-#endif /* CONFIG_PMAC_BACKLIGHT */
-
 int __init find_via_pmu(void)
 {
         u64 taddr;
@@ -417,8 +405,6 @@ static int __init via_pmu_start(void)
         if (vias == NULL)
                 return -ENODEV;
 
-        bright_req_1.complete = 1;
-        bright_req_2.complete = 1;
         batt_req.complete = 1;
 
 #ifndef CONFIG_PPC_MERGE
@@ -483,9 +469,9 @@ static int __init via_pmu_dev_init(void)
                 return -ENODEV;
 
 #ifdef CONFIG_PMAC_BACKLIGHT
-        /* Enable backlight */
-        register_backlight_controller(&pmu_backlight_controller, NULL, "pmu");
-#endif /* CONFIG_PMAC_BACKLIGHT */
+        /* Initialize backlight */
+        pmu_backlight_init(vias);
+#endif
 
 #ifdef CONFIG_PPC32
         if (machine_is_compatible("AAPL,3400/2400") ||
@@ -1424,7 +1410,7 @@ next:
 #ifdef CONFIG_INPUT_ADBHID
                         if (!disable_kernel_backlight)
 #endif /* CONFIG_INPUT_ADBHID */
-                                set_backlight_level(data[1] >> 4);
+                                pmac_backlight_set_legacy_brightness(data[1] >> 4);
 #endif /* CONFIG_PMAC_BACKLIGHT */
         }
         /* Tick interrupt */
@@ -1674,61 +1660,6 @@ gpio1_interrupt(int irq, void *arg, struct pt_regs *regs)
         return IRQ_NONE;
 }
 
-#ifdef CONFIG_PMAC_BACKLIGHT
-static int backlight_to_bright[] = {
-        0x7f, 0x46, 0x42, 0x3e, 0x3a, 0x36, 0x32, 0x2e,
-        0x2a, 0x26, 0x22, 0x1e, 0x1a, 0x16, 0x12, 0x0e
-};
- 
-static int
-pmu_set_backlight_enable(int on, int level, void* data)
-{
-        struct adb_request req;
-        
-        if (vias == NULL)
-                return -ENODEV;
-
-        if (on) {
-                pmu_request(&req, NULL, 2, PMU_BACKLIGHT_BRIGHT,
-                            backlight_to_bright[level]);
-                pmu_wait_complete(&req);
-        }
-        pmu_request(&req, NULL, 2, PMU_POWER_CTRL,
-                    PMU_POW_BACKLIGHT | (on ? PMU_POW_ON : PMU_POW_OFF));
-        pmu_wait_complete(&req);
-
-        return 0;
-}
-
-static void
-pmu_bright_complete(struct adb_request *req)
-{
-        if (req == &bright_req_1)
-                clear_bit(1, &async_req_locks);
-        if (req == &bright_req_2)
-                clear_bit(2, &async_req_locks);
-}
-
-static int
-pmu_set_backlight_level(int level, void* data)
-{
-        if (vias == NULL)
-                return -ENODEV;
-
-        if (test_and_set_bit(1, &async_req_locks))
-                return -EAGAIN;
-        pmu_request(&bright_req_1, pmu_bright_complete, 2, PMU_BACKLIGHT_BRIGHT,
-                backlight_to_bright[level]);
-        if (test_and_set_bit(2, &async_req_locks))
-                return -EAGAIN;
-        pmu_request(&bright_req_2, pmu_bright_complete, 2, PMU_POWER_CTRL,
-                    PMU_POW_BACKLIGHT | (level > BACKLIGHT_OFF ?
-                                         PMU_POW_ON : PMU_POW_OFF));
-
-        return 0;
-}
-#endif /* CONFIG_PMAC_BACKLIGHT */
-
 void
 pmu_enable_irled(int on)
 {
@@ -2145,9 +2076,8 @@ pmac_suspend_devices(void)
                 return -EBUSY;
         }
 
-        /* Wait for completion of async backlight requests */
-        while (!bright_req_1.complete || !bright_req_2.complete ||
-                        !batt_req.complete)
+        /* Wait for completion of async requests */
+        while (!batt_req.complete)
                 pmu_poll();
 
         /* Giveup the lazy FPU & vec so we don't have to back them
@@ -2678,26 +2608,34 @@ pmu_ioctl(struct inode * inode, struct file *filp,
                         return put_user(1, argp);
 #endif /* CONFIG_PM && CONFIG_PPC32 */
 
-#ifdef CONFIG_PMAC_BACKLIGHT
-        /* Backlight should have its own device or go via
-         * the fbdev
-         */
+#ifdef CONFIG_PMAC_BACKLIGHT_LEGACY
+        /* Compatibility ioctl's for backlight */
         case PMU_IOC_GET_BACKLIGHT:
+        {
+                int brightness;
+
                 if (sleep_in_progress)
                         return -EBUSY;
-                error = get_backlight_level();
-                if (error < 0)
-                        return error;
-                return put_user(error, argp);
+
+                brightness = pmac_backlight_get_legacy_brightness();
+                if (brightness < 0)
+                        return brightness;
+                else
+                        return put_user(brightness, argp);
+
+        }
         case PMU_IOC_SET_BACKLIGHT:
         {
-                __u32 value;
+                int brightness;
+
                 if (sleep_in_progress)
                         return -EBUSY;
-                error = get_user(value, argp);
-                if (!error)
-                        error = set_backlight_level(value);
-                break;
+
+                error = get_user(brightness, argp);
+                if (error)
+                        return error;
+
+                return pmac_backlight_set_legacy_brightness(brightness);
         }
 #ifdef CONFIG_INPUT_ADBHID
         case PMU_IOC_GRAB_BACKLIGHT: {
@@ -2713,7 +2651,7 @@ pmu_ioctl(struct inode * inode, struct file *filp,
                 return 0;
         }
 #endif /* CONFIG_INPUT_ADBHID */
-#endif /* CONFIG_PMAC_BACKLIGHT */
+#endif /* CONFIG_PMAC_BACKLIGHT_LEGACY */
         case PMU_IOC_GET_MODEL:
                 return put_user(pmu_kind, argp);
         case PMU_IOC_HAS_ADB:
diff --git a/drivers/net/irda/irda-usb.c b/drivers/net/irda/irda-usb.c
index 844fa74ac9ec..2a0d538b387f 100644
--- a/drivers/net/irda/irda-usb.c
+++ b/drivers/net/irda/irda-usb.c
@@ -1105,7 +1105,7 @@ static int stir421x_patch_device(struct irda_usb_cb *self)
                 return ret;
 
         /* We get a patch from userspace */
-        IRDA_MESSAGE("%s(): Received firmware %s (%u bytes)\n",
+        IRDA_MESSAGE("%s(): Received firmware %s (%zu bytes)\n",
                      __FUNCTION__, stir421x_fw_name, fw->size);
 
         ret = -EINVAL;
diff --git a/drivers/net/sun3lance.c b/drivers/net/sun3lance.c
index d4c0002b43db..a2fad50437e6 100644
--- a/drivers/net/sun3lance.c
+++ b/drivers/net/sun3lance.c
@@ -55,7 +55,7 @@ static char *version = "sun3lance.c: v1.2 1/12/2001  Sam Creasey (sammy@sammy.ne
 /* sun3/60 addr/irq for the lance chip.  If your sun is different,
    change this. */
 #define LANCE_OBIO 0x120000
-#define LANCE_IRQ IRQ3
+#define LANCE_IRQ IRQ_AUTO_3
 
 /* Debug level:
  *  0 = silent, print only serious errors
diff --git a/drivers/net/wan/sdla.c b/drivers/net/wan/sdla.c
index 22e794071cf4..7628c2d81f45 100644
--- a/drivers/net/wan/sdla.c
+++ b/drivers/net/wan/sdla.c
@@ -60,9 +60,9 @@
 
 static const char* version = "SDLA driver v0.30, 12 Sep 1996, mike.mclagan@linux.org";
 
-static unsigned int valid_port[] __initdata = { 0x250, 0x270, 0x280, 0x300, 0x350, 0x360, 0x380, 0x390};
+static unsigned int valid_port[] = { 0x250, 0x270, 0x280, 0x300, 0x350, 0x360, 0x380, 0x390};
 
-static unsigned int valid_mem[]  __initdata = {
+static unsigned int valid_mem[] = {
                                     0xA0000, 0xA2000, 0xA4000, 0xA6000, 0xA8000, 0xAA000, 0xAC000, 0xAE000, 
                                     0xB0000, 0xB2000, 0xB4000, 0xB6000, 0xB8000, 0xBA000, 0xBC000, 0xBE000,
                                     0xC0000, 0xC2000, 0xC4000, 0xC6000, 0xC8000, 0xCA000, 0xCC000, 0xCE000,
diff --git a/drivers/oprofile/buffer_sync.c b/drivers/oprofile/buffer_sync.c
index b2e8e49c8659..43e521e99126 100644
--- a/drivers/oprofile/buffer_sync.c
+++ b/drivers/oprofile/buffer_sync.c
@@ -108,10 +108,10 @@ static int module_load_notify(struct notifier_block * self, unsigned long val, v
                 return 0;
 
         /* FIXME: should we process all CPU buffers ? */
-        down(&buffer_sem);
+        mutex_lock(&buffer_mutex);
         add_event_entry(ESCAPE_CODE);
         add_event_entry(MODULE_LOADED_CODE);
-        up(&buffer_sem);
+        mutex_unlock(&buffer_mutex);
 #endif
         return 0;
 }
@@ -501,7 +501,7 @@ void sync_buffer(int cpu)
         sync_buffer_state state = sb_buffer_start;
         unsigned long available;
 
-        down(&buffer_sem);
+        mutex_lock(&buffer_mutex);
  
         add_cpu_switch(cpu);
 
@@ -550,5 +550,5 @@ void sync_buffer(int cpu)
 
         mark_done(cpu);
 
-        up(&buffer_sem);
+        mutex_unlock(&buffer_mutex);
 }
diff --git a/drivers/oprofile/event_buffer.c b/drivers/oprofile/event_buffer.c
index b80318f03420..04d641714d34 100644
--- a/drivers/oprofile/event_buffer.c
+++ b/drivers/oprofile/event_buffer.c
@@ -24,7 +24,7 @@
 #include "event_buffer.h"
 #include "oprofile_stats.h"
 
-DECLARE_MUTEX(buffer_sem);
+DEFINE_MUTEX(buffer_mutex);
  
 static unsigned long buffer_opened;
 static DECLARE_WAIT_QUEUE_HEAD(buffer_wait);
@@ -32,7 +32,7 @@ static unsigned long * event_buffer;
 static unsigned long buffer_size;
 static unsigned long buffer_watershed;
 static size_t buffer_pos;
-/* atomic_t because wait_event checks it outside of buffer_sem */
+/* atomic_t because wait_event checks it outside of buffer_mutex */
 static atomic_t buffer_ready = ATOMIC_INIT(0);
 
 /* Add an entry to the event buffer. When we
@@ -60,10 +60,10 @@ void add_event_entry(unsigned long value)
  */
 void wake_up_buffer_waiter(void)
 {
-        down(&buffer_sem);
+        mutex_lock(&buffer_mutex);
         atomic_set(&buffer_ready, 1);
         wake_up(&buffer_wait);
-        up(&buffer_sem);
+        mutex_unlock(&buffer_mutex);
 }
 
  
@@ -162,7 +162,7 @@ static ssize_t event_buffer_read(struct file * file, char __user * buf,
         if (!atomic_read(&buffer_ready))
                 return -EAGAIN;
 
-        down(&buffer_sem);
+        mutex_lock(&buffer_mutex);
 
         atomic_set(&buffer_ready, 0);
 
@@ -177,7 +177,7 @@ static ssize_t event_buffer_read(struct file * file, char __user * buf,
         buffer_pos = 0;
  
 out:
-        up(&buffer_sem);
+        mutex_unlock(&buffer_mutex);
         return retval;
 }
  
diff --git a/drivers/oprofile/event_buffer.h b/drivers/oprofile/event_buffer.h
index 018023630599..92416276e577 100644
--- a/drivers/oprofile/event_buffer.h
+++ b/drivers/oprofile/event_buffer.h
@@ -11,7 +11,7 @@
 #define EVENT_BUFFER_H
 
 #include <linux/types.h> 
-#include <asm/semaphore.h>
+#include <asm/mutex.h>
  
 int alloc_event_buffer(void);
 
@@ -46,6 +46,6 @@ extern struct file_operations event_buffer_fops;
 /* mutex between sync_cpu_buffers() and the
  * file reading code.
  */
-extern struct semaphore buffer_sem;
+extern struct mutex buffer_mutex;
  
 #endif /* EVENT_BUFFER_H */
diff --git a/drivers/oprofile/oprof.c b/drivers/oprofile/oprof.c
index b3f1cd6a24c1..e5162a64018b 100644
--- a/drivers/oprofile/oprof.c
+++ b/drivers/oprofile/oprof.c
@@ -12,7 +12,7 @@
 #include <linux/init.h>
 #include <linux/oprofile.h>
 #include <linux/moduleparam.h>
-#include <asm/semaphore.h>
+#include <asm/mutex.h>
 
 #include "oprof.h"
 #include "event_buffer.h"
@@ -25,7 +25,7 @@ struct oprofile_operations oprofile_ops;
 unsigned long oprofile_started;
 unsigned long backtrace_depth;
 static unsigned long is_setup;
-static DECLARE_MUTEX(start_sem);
+static DEFINE_MUTEX(start_mutex);
 
 /* timer
    0 - use performance monitoring hardware if available
@@ -37,7 +37,7 @@ int oprofile_setup(void)
 {
         int err;
  
-        down(&start_sem);
+        mutex_lock(&start_mutex);
 
         if ((err = alloc_cpu_buffers()))
                 goto out;
@@ -57,7 +57,7 @@ int oprofile_setup(void)
                 goto out3;
 
         is_setup = 1;
-        up(&start_sem);
+        mutex_unlock(&start_mutex);
         return 0;
  
 out3:
@@ -68,7 +68,7 @@ out2:
 out1:
         free_cpu_buffers();
 out:
-        up(&start_sem);
+        mutex_unlock(&start_mutex);
         return err;
 }
 
@@ -78,7 +78,7 @@ int oprofile_start(void)
 {
         int err = -EINVAL;
  
-        down(&start_sem);
+        mutex_lock(&start_mutex);
  
         if (!is_setup)
                 goto out;
@@ -95,7 +95,7 @@ int oprofile_start(void)
 
         oprofile_started = 1;
 out:
-        up(&start_sem); 
+        mutex_unlock(&start_mutex);
         return err;
 }
 
@@ -103,7 +103,7 @@ out:
 /* echo 0>/dev/oprofile/enable */
 void oprofile_stop(void)
 {
-        down(&start_sem);
+        mutex_lock(&start_mutex);
         if (!oprofile_started)
                 goto out;
         oprofile_ops.stop();
@@ -111,20 +111,20 @@ void oprofile_stop(void)
         /* wake up the daemon to read what remains */
         wake_up_buffer_waiter();
 out:
-        up(&start_sem);
+        mutex_unlock(&start_mutex);
 }
 
 
 void oprofile_shutdown(void)
 {
-        down(&start_sem);
+        mutex_lock(&start_mutex);
         sync_stop();
         if (oprofile_ops.shutdown)
                 oprofile_ops.shutdown();
         is_setup = 0;
         free_event_buffer();
         free_cpu_buffers();
-        up(&start_sem);
+        mutex_unlock(&start_mutex);
 }
 
 
@@ -132,7 +132,7 @@ int oprofile_set_backtrace(unsigned long val)
 {
         int err = 0;
 
-        down(&start_sem);
+        mutex_lock(&start_mutex);
 
         if (oprofile_started) {
                 err = -EBUSY;
@@ -147,7 +147,7 @@ int oprofile_set_backtrace(unsigned long val)
         backtrace_depth = val;
 
 out:
-        up(&start_sem);
+        mutex_unlock(&start_mutex);
         return err;
 }
 
diff --git a/drivers/parport/Kconfig b/drivers/parport/Kconfig
index 4d8dc27ea9d1..c7fa28a28b9f 100644
--- a/drivers/parport/Kconfig
+++ b/drivers/parport/Kconfig
@@ -136,6 +136,18 @@ config PARPORT_SUNBPP
           found on many Sun machines. Note that many of the newer Ultras
           actually have pc style hardware instead.
 
+config PARPORT_AX88796
+        tristate "AX88796 Parallel Port"
+        depends on PARPORT
+        select PARPORT_NOT_PC
+        help
+          Say Y here if you need support for the parallel port hardware on
+          the AX88796 network controller chip. This code is also available
+          as a module (say M), called parport_ax88796.
+
+          The driver is not dependant on the AX88796 network driver, and
+          should not interfere with the networking functions of the chip.
+
 config PARPORT_1284
         bool "IEEE 1284 transfer modes"
         depends on PARPORT
diff --git a/drivers/parport/Makefile b/drivers/parport/Makefile
index a19de35f8de2..696b8d4ca887 100644
--- a/drivers/parport/Makefile
+++ b/drivers/parport/Makefile
@@ -17,4 +17,5 @@ obj-$(CONFIG_PARPORT_MFC3)	+= parport_mfc3.o
 obj-$(CONFIG_PARPORT_ATARI)     += parport_atari.o
 obj-$(CONFIG_PARPORT_SUNBPP)    += parport_sunbpp.o
 obj-$(CONFIG_PARPORT_GSC)       += parport_gsc.o
-obj-$(CONFIG_PARPORT_IP32)      += parport_ip32.o
+obj-$(CONFIG_PARPORT_AX88796)   += parport_ax88796.o
+obj-$(CONFIG_PARPORT_IP32)      += parport_ip32.o
\ No newline at end of file
diff --git a/drivers/parport/daisy.c b/drivers/parport/daisy.c
index 9ee67321b630..fd41e28101ea 100644
--- a/drivers/parport/daisy.c
+++ b/drivers/parport/daisy.c
@@ -283,7 +283,7 @@ void parport_close (struct pardevice *dev)
  *
  *      This tries to locate a device on the given parallel port,
  *      multiplexor port and daisy chain address, and returns its
- *      device number or -NXIO if no device with those coordinates
+ *      device number or %-ENXIO if no device with those coordinates
  *      exists.
  **/
 
diff --git a/drivers/parport/parport_ax88796.c b/drivers/parport/parport_ax88796.c
new file mode 100644
index 000000000000..4baa719439a2
--- /dev/null
+++ b/drivers/parport/parport_ax88796.c
@@ -0,0 +1,443 @@
+/* linux/drivers/parport/parport_ax88796.c
+ *
+ * (c) 2005,2006 Simtec Electronics
+ *      Ben Dooks <ben@simtec.co.uk>
+ *
+ * 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/kernel.h>
+#include <linux/parport.h>
+#include <linux/interrupt.h>
+#include <linux/errno.h>
+#include <linux/platform_device.h>
+
+#include <asm/io.h>
+#include <asm/irq.h>
+
+#define AX_SPR_BUSY             (1<<7)
+#define AX_SPR_ACK              (1<<6)
+#define AX_SPR_PE               (1<<5)
+#define AX_SPR_SLCT             (1<<4)
+#define AX_SPR_ERR              (1<<3)
+
+#define AX_CPR_nDOE             (1<<5)
+#define AX_CPR_SLCTIN           (1<<3)
+#define AX_CPR_nINIT            (1<<2)
+#define AX_CPR_ATFD             (1<<1)
+#define AX_CPR_STRB             (1<<0)
+
+struct ax_drvdata {
+        struct parport          *parport;
+        struct parport_state     suspend;
+
+        struct device           *dev;
+        struct resource         *io;
+
+        unsigned char            irq_enabled;
+
+        void __iomem            *base;
+        void __iomem            *spp_data;
+        void __iomem            *spp_spr;
+        void __iomem            *spp_cpr;
+};
+
+static inline struct ax_drvdata *pp_to_drv(struct parport *p)
+{
+        return p->private_data;
+}
+
+static unsigned char
+parport_ax88796_read_data(struct parport *p)
+{
+        struct ax_drvdata *dd = pp_to_drv(p);
+
+        return readb(dd->spp_data);
+}
+
+static void
+parport_ax88796_write_data(struct parport *p, unsigned char data)
+{
+        struct ax_drvdata *dd = pp_to_drv(p);
+
+        writeb(data, dd->spp_data);
+}
+
+static unsigned char
+parport_ax88796_read_control(struct parport *p)
+{
+        struct ax_drvdata *dd = pp_to_drv(p);
+        unsigned int cpr = readb(dd->spp_cpr);
+        unsigned int ret = 0;
+
+        if (!(cpr & AX_CPR_STRB))
+                ret |= PARPORT_CONTROL_STROBE;
+
+        if (!(cpr & AX_CPR_ATFD))
+                ret |= PARPORT_CONTROL_AUTOFD;
+
+        if (cpr & AX_CPR_nINIT)
+                ret |= PARPORT_CONTROL_INIT;
+
+        if (!(cpr & AX_CPR_SLCTIN))
+                ret |= PARPORT_CONTROL_SELECT;
+
+        return ret;
+}
+
+static void
+parport_ax88796_write_control(struct parport *p, unsigned char control)
+{
+        struct ax_drvdata *dd = pp_to_drv(p);
+        unsigned int cpr = readb(dd->spp_cpr);
+
+        cpr &= AX_CPR_nDOE;
+
+        if (!(control & PARPORT_CONTROL_STROBE))
+                cpr |= AX_CPR_STRB;
+
+        if (!(control & PARPORT_CONTROL_AUTOFD))
+                cpr |= AX_CPR_ATFD;
+
+        if (control & PARPORT_CONTROL_INIT)
+                cpr |= AX_CPR_nINIT;
+
+        if (!(control & PARPORT_CONTROL_SELECT))
+                cpr |= AX_CPR_SLCTIN;
+
+        dev_dbg(dd->dev, "write_control: ctrl=%02x, cpr=%02x\n", control, cpr);
+        writeb(cpr, dd->spp_cpr);
+
+        if (parport_ax88796_read_control(p) != control) {
+                dev_err(dd->dev, "write_control: read != set (%02x, %02x)\n",
+                        parport_ax88796_read_control(p), control);
+        }
+}
+
+static unsigned char
+parport_ax88796_read_status(struct parport *p)
+{
+        struct ax_drvdata *dd = pp_to_drv(p);
+        unsigned int status = readb(dd->spp_spr);
+        unsigned int ret = 0;
+
+        if (status & AX_SPR_BUSY)
+                ret |= PARPORT_STATUS_BUSY;
+
+        if (status & AX_SPR_ACK)
+                ret |= PARPORT_STATUS_ACK;
+
+        if (status & AX_SPR_ERR)
+                ret |= PARPORT_STATUS_ERROR;
+
+        if (status & AX_SPR_SLCT)
+                ret |= PARPORT_STATUS_SELECT;
+
+        if (status & AX_SPR_PE)
+                ret |= PARPORT_STATUS_PAPEROUT;
+
+        return ret;
+}
+
+static unsigned char
+parport_ax88796_frob_control(struct parport *p, unsigned char mask,
+                             unsigned char val)
+{
+        struct ax_drvdata *dd = pp_to_drv(p);
+        unsigned char old = parport_ax88796_read_control(p);
+
+        dev_dbg(dd->dev, "frob: mask=%02x, val=%02x, old=%02x\n",
+                mask, val, old);
+
+        parport_ax88796_write_control(p, (old & ~mask) | val);
+        return old;
+}
+
+static void
+parport_ax88796_enable_irq(struct parport *p)
+{
+        struct ax_drvdata *dd = pp_to_drv(p);
+        unsigned long flags;
+
+        local_irq_save(flags);
+        if (!dd->irq_enabled) {
+                enable_irq(p->irq);
+                dd->irq_enabled = 1;
+        }
+        local_irq_restore(flags);
+}
+
+static void
+parport_ax88796_disable_irq(struct parport *p)
+{
+        struct ax_drvdata *dd = pp_to_drv(p);
+        unsigned long flags;
+
+        local_irq_save(flags);
+        if (dd->irq_enabled) {
+                disable_irq(p->irq);
+                dd->irq_enabled = 0;
+        }
+        local_irq_restore(flags);
+}
+
+static void
+parport_ax88796_data_forward(struct parport *p)
+{
+        struct ax_drvdata *dd = pp_to_drv(p);
+        void __iomem *cpr = dd->spp_cpr;
+
+        writeb((readb(cpr) & ~AX_CPR_nDOE), cpr);
+}
+
+static void
+parport_ax88796_data_reverse(struct parport *p)
+{
+        struct ax_drvdata *dd = pp_to_drv(p);
+        void __iomem *cpr = dd->spp_cpr;
+
+        writeb(readb(cpr) | AX_CPR_nDOE, cpr);
+}
+
+static void
+parport_ax88796_init_state(struct pardevice *d, struct parport_state *s)
+{
+        struct ax_drvdata *dd = pp_to_drv(d->port);
+
+        memset(s, 0, sizeof(struct parport_state));
+
+        dev_dbg(dd->dev, "init_state: %p: state=%p\n", d, s);
+        s->u.ax88796.cpr = readb(dd->spp_cpr);
+}
+
+static void
+parport_ax88796_save_state(struct parport *p, struct parport_state *s)
+{
+        struct ax_drvdata *dd = pp_to_drv(p);
+
+        dev_dbg(dd->dev, "save_state: %p: state=%p\n", p, s);
+        s->u.ax88796.cpr = readb(dd->spp_cpr);
+}
+
+static void
+parport_ax88796_restore_state(struct parport *p, struct parport_state *s)
+{
+        struct ax_drvdata *dd = pp_to_drv(p);
+
+        dev_dbg(dd->dev, "restore_state: %p: state=%p\n", p, s);
+        writeb(s->u.ax88796.cpr, dd->spp_cpr);
+}
+
+static irqreturn_t
+parport_ax88796_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        parport_generic_irq(irq, dev_id, regs);
+        return IRQ_HANDLED;
+}
+
+
+static struct parport_operations parport_ax88796_ops = {
+        .write_data     = parport_ax88796_write_data,
+        .read_data      = parport_ax88796_read_data,
+
+        .write_control  = parport_ax88796_write_control,
+        .read_control   = parport_ax88796_read_control,
+        .frob_control   = parport_ax88796_frob_control,
+
+        .read_status    = parport_ax88796_read_status,
+
+        .enable_irq     = parport_ax88796_enable_irq,
+        .disable_irq    = parport_ax88796_disable_irq,
+
+        .data_forward   = parport_ax88796_data_forward,
+        .data_reverse   = parport_ax88796_data_reverse,
+
+        .init_state     = parport_ax88796_init_state,
+        .save_state     = parport_ax88796_save_state,
+        .restore_state  = parport_ax88796_restore_state,
+
+        .epp_write_data = parport_ieee1284_epp_write_data,
+        .epp_read_data  = parport_ieee1284_epp_read_data,
+        .epp_write_addr = parport_ieee1284_epp_write_addr,
+        .epp_read_addr  = parport_ieee1284_epp_read_addr,
+
+        .ecp_write_data = parport_ieee1284_ecp_write_data,
+        .ecp_read_data  = parport_ieee1284_ecp_read_data,
+        .ecp_write_addr = parport_ieee1284_ecp_write_addr,
+
+        .compat_write_data      = parport_ieee1284_write_compat,
+        .nibble_read_data       = parport_ieee1284_read_nibble,
+        .byte_read_data         = parport_ieee1284_read_byte,
+
+        .owner          = THIS_MODULE,
+};
+
+static int parport_ax88796_probe(struct platform_device *pdev)
+{
+        struct device *_dev = &pdev->dev;
+        struct ax_drvdata *dd;
+        struct parport *pp = NULL;
+        struct resource *res;
+        unsigned long size;
+        int spacing;
+        int irq;
+        int ret;
+
+        dd = kzalloc(sizeof(struct ax_drvdata), GFP_KERNEL);
+        if (dd == NULL) {
+                dev_err(_dev, "no memory for private data\n");
+                return -ENOMEM;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res == NULL) {
+                dev_err(_dev, "no MEM specified\n");
+                ret = -ENXIO;
+                goto exit_mem;
+        }
+
+        size = (res->end - res->start) + 1;
+        spacing = size / 3;
+
+        dd->io = request_mem_region(res->start, size, pdev->name);
+        if (dd->io == NULL) {
+                dev_err(_dev, "cannot reserve memory\n");
+                ret = -ENXIO;
+                goto exit_mem;
+        }
+
+        dd->base = ioremap(res->start, size);
+        if (dd->base == NULL) {
+                dev_err(_dev, "cannot ioremap region\n");
+                ret = -ENXIO;
+                goto exit_res;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq <= 0)
+                irq = PARPORT_IRQ_NONE;
+
+        pp = parport_register_port((unsigned long)dd->base, irq,
+                                   PARPORT_DMA_NONE,
+                                   &parport_ax88796_ops);
+
+        if (pp == NULL) {
+                dev_err(_dev, "failed to register parallel port\n");
+                ret = -ENOMEM;
+                goto exit_unmap;
+        }
+
+        pp->private_data = dd;
+        dd->parport = pp;
+        dd->dev = _dev;
+
+        dd->spp_data = dd->base;
+        dd->spp_spr  = dd->base + (spacing * 1);
+        dd->spp_cpr  = dd->base + (spacing * 2);
+
+        /* initialise the port controls */
+        writeb(AX_CPR_STRB, dd->spp_cpr);
+
+        if (irq >= 0) {
+                /* request irq */
+                ret = request_irq(irq, parport_ax88796_interrupt,
+                                  SA_TRIGGER_FALLING, pdev->name, pp);
+
+                if (ret < 0)
+                        goto exit_port;
+
+                dd->irq_enabled = 1;
+        }
+
+        platform_set_drvdata(pdev, pp);
+
+        dev_info(_dev, "attached parallel port driver\n");
+        parport_announce_port(pp);
+
+        return 0;
+
+ exit_port:
+        parport_remove_port(pp);
+ exit_unmap:
+        iounmap(dd->base);
+ exit_res:
+        release_resource(dd->io);
+        kfree(dd->io);
+ exit_mem:
+        kfree(dd);
+        return ret;
+}
+
+static int parport_ax88796_remove(struct platform_device *pdev)
+{
+        struct parport *p = platform_get_drvdata(pdev);
+        struct ax_drvdata *dd = pp_to_drv(p);
+
+        free_irq(p->irq, p);
+        parport_remove_port(p);
+        iounmap(dd->base);
+        release_resource(dd->io);
+        kfree(dd->io);
+        kfree(dd);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+
+static int parport_ax88796_suspend(struct platform_device *dev,
+                                   pm_message_t state)
+{
+        struct parport *p = platform_get_drvdata(dev);
+        struct ax_drvdata *dd = pp_to_drv(p);
+
+        parport_ax88796_save_state(p, &dd->suspend);
+        writeb(AX_CPR_nDOE | AX_CPR_STRB, dd->spp_cpr);
+        return 0;
+}
+
+static int parport_ax88796_resume(struct platform_device *dev)
+{
+        struct parport *p = platform_get_drvdata(dev);
+        struct ax_drvdata *dd = pp_to_drv(p);
+
+        parport_ax88796_restore_state(p, &dd->suspend);
+        return 0;
+}
+
+#else
+#define parport_ax88796_suspend NULL
+#define parport_ax88796_resume  NULL
+#endif
+
+static struct platform_driver axdrv = {
+        .driver         = {
+                .name   = "ax88796-pp",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = parport_ax88796_probe,
+        .remove         = parport_ax88796_remove,
+        .suspend        = parport_ax88796_suspend,
+        .resume         = parport_ax88796_resume,
+};
+
+static int __init parport_ax88796_init(void)
+{
+        return platform_driver_register(&axdrv);
+}
+
+static void __exit parport_ax88796_exit(void)
+{
+        platform_driver_unregister(&axdrv);
+}
+
+module_init(parport_ax88796_init)
+module_exit(parport_ax88796_exit)
+
+MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
+MODULE_DESCRIPTION("AX88796 Parport parallel port driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/parport/share.c b/drivers/parport/share.c
index bbbfd79adbaf..2cb22c8d3357 100644
--- a/drivers/parport/share.c
+++ b/drivers/parport/share.c
@@ -218,7 +218,7 @@ static void free_port (struct parport *port)
  *      parport_get_port - increment a port's reference count
  *      @port: the port
  *
- *      This ensure's that a struct parport pointer remains valid
+ *      This ensures that a struct parport pointer remains valid
  *      until the matching parport_put_port() call.
  **/
 
diff --git a/drivers/pnp/card.c b/drivers/pnp/card.c
index bb19c64073c6..0b4adcb60df4 100644
--- a/drivers/pnp/card.c
+++ b/drivers/pnp/card.c
@@ -60,30 +60,34 @@ static void card_remove_first(struct pnp_dev * dev)
         card_remove(dev);
 }
 
-static int card_probe(struct pnp_card * card, struct pnp_card_driver * drv)
+static int card_probe(struct pnp_card *card, struct pnp_card_driver *drv)
 {
-        const struct pnp_card_device_id *id = match_card(drv,card);
-        if (id) {
-                struct pnp_card_link * clink = pnp_alloc(sizeof(struct pnp_card_link));
-                if (!clink)
-                        return 0;
-                clink->card = card;
-                clink->driver = drv;
-                clink->pm_state = PMSG_ON;
-                if (drv->probe) {
-                        if (drv->probe(clink, id)>=0)
-                                return 1;
-                        else {
-                                struct pnp_dev * dev;
-                                card_for_each_dev(card, dev) {
-                                        if (dev->card_link == clink)
-                                                pnp_release_card_device(dev);
-                                }
-                                kfree(clink);
-                        }
-                } else
-                        return 1;
+        const struct pnp_card_device_id *id;
+        struct pnp_card_link *clink;
+        struct pnp_dev *dev;
+
+        if (!drv->probe)
+                return 0;
+        id = match_card(drv,card);
+        if (!id)
+                return 0;
+
+        clink = pnp_alloc(sizeof(*clink));
+        if (!clink)
+                return 0;
+        clink->card = card;
+        clink->driver = drv;
+        clink->pm_state = PMSG_ON;
+
+        if (drv->probe(clink, id) >= 0)
+                return 1;
+
+        /* Recovery */
+        card_for_each_dev(card, dev) {
+                if (dev->card_link == clink)
+                        pnp_release_card_device(dev);
         }
+        kfree(clink);
         return 0;
 }
 
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 65d090dbef46..bccff400b198 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -73,6 +73,13 @@ config RTC_INTF_DEV
           This driver can also be built as a module. If so, the module
           will be called rtc-dev.
 
+config RTC_INTF_DEV_UIE_EMUL
+        bool "RTC UIE emulation on dev interface"
+        depends on RTC_INTF_DEV
+        help
+          Provides an emulation for RTC_UIE if the underlaying rtc chip
+          driver did not provide RTC_UIE ioctls.
+
 comment "RTC drivers"
         depends on RTC_CLASS
 
@@ -86,6 +93,34 @@ config RTC_DRV_X1205
           This driver can also be built as a module. If so, the module
           will be called rtc-x1205.
 
+config RTC_DRV_DS1307
+        tristate "Dallas/Maxim DS1307 and similar I2C RTC chips"
+        depends on RTC_CLASS && I2C
+        help
+          If you say yes here you get support for various compatible RTC
+          chips (often with battery backup) connected with I2C.  This driver
+          should handle DS1307, DS1337, DS1338, DS1339, DS1340, ST M41T00,
+          and probably other chips.  In some cases the RTC must already
+          have been initialized (by manufacturing or a bootloader).
+
+          The first seven registers on these chips hold an RTC, and other
+          registers may add features such as NVRAM, a trickle charger for
+          the RTC/NVRAM backup power, and alarms.  This driver may not
+          expose all those available chip features.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-ds1307.
+
+config RTC_DRV_DS1553
+        tristate "Dallas DS1553"
+        depends on RTC_CLASS
+        help
+          If you say yes here you get support for the
+          Dallas DS1553 timekeeping chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-ds1553.
+
 config RTC_DRV_DS1672
         tristate "Dallas/Maxim DS1672"
         depends on RTC_CLASS && I2C
@@ -96,6 +131,16 @@ config RTC_DRV_DS1672
           This driver can also be built as a module. If so, the module
           will be called rtc-ds1672.
 
+config RTC_DRV_DS1742
+        tristate "Dallas DS1742"
+        depends on RTC_CLASS
+        help
+          If you say yes here you get support for the
+          Dallas DS1742 timekeeping chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-ds1742.
+
 config RTC_DRV_PCF8563
         tristate "Philips PCF8563/Epson RTC8564"
         depends on RTC_CLASS && I2C
@@ -107,6 +152,16 @@ config RTC_DRV_PCF8563
           This driver can also be built as a module. If so, the module
           will be called rtc-pcf8563.
 
+config RTC_DRV_PCF8583
+        tristate "Philips PCF8583"
+        depends on RTC_CLASS && I2C
+        help
+          If you say yes here you get support for the
+          Philips PCF8583 RTC chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-pcf8583.
+
 config RTC_DRV_RS5C372
         tristate "Ricoh RS5C372A/B"
         depends on RTC_CLASS && I2C
@@ -157,6 +212,22 @@ config RTC_DRV_VR41XX
           To compile this driver as a module, choose M here: the
           module will be called rtc-vr41xx.
 
+config RTC_DRV_PL031
+        tristate "ARM AMBA PL031 RTC"
+        depends on RTC_CLASS && ARM_AMBA
+        help
+          If you say Y here you will get access to ARM AMBA
+          PrimeCell PL031 UART found on certain ARM SOCs.
+
+          To compile this driver as a module, choose M here: the
+          module will be called rtc-pl031.
+
+config RTC_DRV_AT91
+        tristate "AT91RM9200"
+        depends on RTC_CLASS && ARCH_AT91RM9200
+        help
+          Driver for the Atmel AT91RM9200's internal RTC (Realtime Clock).
+
 config RTC_DRV_TEST
         tristate "Test driver/device"
         depends on RTC_CLASS
@@ -172,4 +243,24 @@ config RTC_DRV_TEST
           This driver can also be built as a module. If so, the module
           will be called rtc-test.
 
+config RTC_DRV_MAX6902
+        tristate "Maxim 6902"
+        depends on RTC_CLASS && SPI
+        help
+          If you say yes here you will get support for the
+          Maxim MAX6902 spi RTC chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-max6902.
+
+config RTC_DRV_V3020
+        tristate "EM Microelectronic V3020"
+        depends on RTC_CLASS
+        help
+          If you say yes here you will get support for the
+          EM Microelectronic v3020 RTC chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-v3020.
+
 endmenu
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index a9ca0f171686..900d210dd1a2 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -13,10 +13,18 @@ obj-$(CONFIG_RTC_INTF_DEV)	+= rtc-dev.o
 
 obj-$(CONFIG_RTC_DRV_X1205)     += rtc-x1205.o
 obj-$(CONFIG_RTC_DRV_TEST)      += rtc-test.o
+obj-$(CONFIG_RTC_DRV_DS1307)    += rtc-ds1307.o
 obj-$(CONFIG_RTC_DRV_DS1672)    += rtc-ds1672.o
+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_M48T86)    += rtc-m48t86.o
+obj-$(CONFIG_RTC_DRV_DS1553)    += rtc-ds1553.o
 obj-$(CONFIG_RTC_DRV_EP93XX)    += rtc-ep93xx.o
 obj-$(CONFIG_RTC_DRV_SA1100)    += rtc-sa1100.o
 obj-$(CONFIG_RTC_DRV_VR41XX)    += rtc-vr41xx.o
+obj-$(CONFIG_RTC_DRV_PL031)     += rtc-pl031.o
+obj-$(CONFIG_RTC_DRV_MAX6902)   += rtc-max6902.o
+obj-$(CONFIG_RTC_DRV_V3020)     += rtc-v3020.o
+obj-$(CONFIG_RTC_DRV_AT91)      += rtc-at91.o
diff --git a/drivers/rtc/class.c b/drivers/rtc/class.c
index 413c7d54ea10..5396beec30d0 100644
--- a/drivers/rtc/class.c
+++ b/drivers/rtc/class.c
@@ -69,6 +69,7 @@ struct rtc_device *rtc_device_register(const char *name, struct device *dev,
         rtc->id = id;
         rtc->ops = ops;
         rtc->owner = owner;
+        rtc->max_user_freq = 64;
         rtc->class_dev.dev = dev;
         rtc->class_dev.class = rtc_class;
         rtc->class_dev.release = rtc_device_release;
diff --git a/drivers/rtc/interface.c b/drivers/rtc/interface.c
index 56e490709b87..579cd667b16f 100644
--- a/drivers/rtc/interface.c
+++ b/drivers/rtc/interface.c
@@ -229,6 +229,9 @@ int rtc_irq_set_state(struct class_device *class_dev, struct rtc_task *task, int
         unsigned long flags;
         struct rtc_device *rtc = to_rtc_device(class_dev);
 
+        if (rtc->ops->irq_set_state == NULL)
+                return -ENXIO;
+
         spin_lock_irqsave(&rtc->irq_task_lock, flags);
         if (rtc->irq_task != task)
                 err = -ENXIO;
@@ -243,25 +246,12 @@ EXPORT_SYMBOL_GPL(rtc_irq_set_state);
 
 int rtc_irq_set_freq(struct class_device *class_dev, struct rtc_task *task, int freq)
 {
-        int err = 0, tmp = 0;
+        int err = 0;
         unsigned long flags;
         struct rtc_device *rtc = to_rtc_device(class_dev);
 
-        /* allowed range is 2-8192 */
-        if (freq < 2 || freq > 8192)
-                return -EINVAL;
-/*
-        FIXME: this does not belong here, will move where appropriate
-        at a later stage. It cannot hurt right now, trust me :)
-        if ((freq > rtc_max_user_freq) && (!capable(CAP_SYS_RESOURCE)))
-                return -EACCES;
-*/
-        /* check if freq is a power of 2 */
-        while (freq > (1 << tmp))
-                tmp++;
-
-        if (freq != (1 << tmp))
-                return -EINVAL;
+        if (rtc->ops->irq_set_freq == NULL)
+                return -ENXIO;
 
         spin_lock_irqsave(&rtc->irq_task_lock, flags);
         if (rtc->irq_task != task)
diff --git a/drivers/rtc/rtc-at91.c b/drivers/rtc/rtc-at91.c
new file mode 100644
index 000000000000..b676f443c17e
--- /dev/null
+++ b/drivers/rtc/rtc-at91.c
@@ -0,0 +1,407 @@
+/*
+ *      Real Time Clock interface for Linux on Atmel AT91RM9200
+ *
+ *      Copyright (C) 2002 Rick Bronson
+ *
+ *      Converted to RTC class model by Andrew Victor
+ *
+ *      Ported to Linux 2.6 by Steven Scholz
+ *      Based on s3c2410-rtc.c Simtec Electronics
+ *
+ *      Based on sa1100-rtc.c by Nils Faerber
+ *      Based on rtc.c by Paul Gortmaker
+ *
+ *      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/module.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/time.h>
+#include <linux/rtc.h>
+#include <linux/bcd.h>
+#include <linux/interrupt.h>
+#include <linux/ioctl.h>
+#include <linux/completion.h>
+
+#include <asm/uaccess.h>
+#include <asm/rtc.h>
+
+#include <asm/mach/time.h>
+
+
+#define AT91_RTC_FREQ           1
+#define AT91_RTC_EPOCH          1900UL  /* just like arch/arm/common/rtctime.c */
+
+static DECLARE_COMPLETION(at91_rtc_updated);
+static unsigned int at91_alarm_year = AT91_RTC_EPOCH;
+
+/*
+ * Decode time/date into rtc_time structure
+ */
+static void at91_rtc_decodetime(unsigned int timereg, unsigned int calreg,
+                                struct rtc_time *tm)
+{
+        unsigned int time, date;
+
+        /* must read twice in case it changes */
+        do {
+                time = at91_sys_read(timereg);
+                date = at91_sys_read(calreg);
+        } while ((time != at91_sys_read(timereg)) ||
+                        (date != at91_sys_read(calreg)));
+
+        tm->tm_sec  = BCD2BIN((time & AT91_RTC_SEC) >> 0);
+        tm->tm_min  = BCD2BIN((time & AT91_RTC_MIN) >> 8);
+        tm->tm_hour = BCD2BIN((time & AT91_RTC_HOUR) >> 16);
+
+        /*
+         * The Calendar Alarm register does not have a field for
+         * the year - so these will return an invalid value.  When an
+         * alarm is set, at91_alarm_year wille store the current year.
+         */
+        tm->tm_year  = BCD2BIN(date & AT91_RTC_CENT) * 100;     /* century */
+        tm->tm_year += BCD2BIN((date & AT91_RTC_YEAR) >> 8);    /* year */
+
+        tm->tm_wday = BCD2BIN((date & AT91_RTC_DAY) >> 21) - 1; /* day of the week [0-6], Sunday=0 */
+        tm->tm_mon  = BCD2BIN((date & AT91_RTC_MONTH) >> 16) - 1;
+        tm->tm_mday = BCD2BIN((date & AT91_RTC_DATE) >> 24);
+}
+
+/*
+ * Read current time and date in RTC
+ */
+static int at91_rtc_readtime(struct device *dev, struct rtc_time *tm)
+{
+        at91_rtc_decodetime(AT91_RTC_TIMR, AT91_RTC_CALR, tm);
+        tm->tm_yday = rtc_year_days(tm->tm_mday, tm->tm_mon, tm->tm_year);
+        tm->tm_year = tm->tm_year - 1900;
+
+        pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __FUNCTION__,
+                1900 + tm->tm_year, tm->tm_mon, tm->tm_mday,
+                tm->tm_hour, tm->tm_min, tm->tm_sec);
+
+        return 0;
+}
+
+/*
+ * Set current time and date in RTC
+ */
+static int at91_rtc_settime(struct device *dev, struct rtc_time *tm)
+{
+        unsigned long cr;
+
+        pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __FUNCTION__,
+                1900 + tm->tm_year, tm->tm_mon, tm->tm_mday,
+                tm->tm_hour, tm->tm_min, tm->tm_sec);
+
+        /* Stop Time/Calendar from counting */
+        cr = at91_sys_read(AT91_RTC_CR);
+        at91_sys_write(AT91_RTC_CR, cr | AT91_RTC_UPDCAL | AT91_RTC_UPDTIM);
+
+        at91_sys_write(AT91_RTC_IER, AT91_RTC_ACKUPD);
+        wait_for_completion(&at91_rtc_updated); /* wait for ACKUPD interrupt */
+        at91_sys_write(AT91_RTC_IDR, AT91_RTC_ACKUPD);
+
+        at91_sys_write(AT91_RTC_TIMR,
+                          BIN2BCD(tm->tm_sec) << 0
+                        | BIN2BCD(tm->tm_min) << 8
+                        | BIN2BCD(tm->tm_hour) << 16);
+
+        at91_sys_write(AT91_RTC_CALR,
+                          BIN2BCD((tm->tm_year + 1900) / 100)   /* century */
+                        | BIN2BCD(tm->tm_year % 100) << 8       /* year */
+                        | BIN2BCD(tm->tm_mon + 1) << 16         /* tm_mon starts at zero */
+                        | BIN2BCD(tm->tm_wday + 1) << 21        /* day of the week [0-6], Sunday=0 */
+                        | BIN2BCD(tm->tm_mday) << 24);
+
+        /* Restart Time/Calendar */
+        cr = at91_sys_read(AT91_RTC_CR);
+        at91_sys_write(AT91_RTC_CR, cr & ~(AT91_RTC_UPDCAL | AT91_RTC_UPDTIM));
+
+        return 0;
+}
+
+/*
+ * Read alarm time and date in RTC
+ */
+static int at91_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct rtc_time *tm = &alrm->time;
+
+        at91_rtc_decodetime(AT91_RTC_TIMALR, AT91_RTC_CALALR, tm);
+        tm->tm_yday = rtc_year_days(tm->tm_mday, tm->tm_mon, tm->tm_year);
+        tm->tm_year = at91_alarm_year - 1900;
+
+        pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __FUNCTION__,
+                1900 + tm->tm_year, tm->tm_mon, tm->tm_mday,
+                tm->tm_hour, tm->tm_min, tm->tm_sec);
+
+        return 0;
+}
+
+/*
+ * Set alarm time and date in RTC
+ */
+static int at91_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct rtc_time tm;
+
+        at91_rtc_decodetime(AT91_RTC_TIMR, AT91_RTC_CALR, &tm);
+
+        at91_alarm_year = tm.tm_year;
+
+        tm.tm_hour = alrm->time.tm_hour;
+        tm.tm_min = alrm->time.tm_min;
+        tm.tm_sec = alrm->time.tm_sec;
+
+        at91_sys_write(AT91_RTC_TIMALR,
+                  BIN2BCD(tm.tm_sec) << 0
+                | BIN2BCD(tm.tm_min) << 8
+                | BIN2BCD(tm.tm_hour) << 16
+                | AT91_RTC_HOUREN | AT91_RTC_MINEN | AT91_RTC_SECEN);
+        at91_sys_write(AT91_RTC_CALALR,
+                  BIN2BCD(tm.tm_mon + 1) << 16          /* tm_mon starts at zero */
+                | BIN2BCD(tm.tm_mday) << 24
+                | AT91_RTC_DATEEN | AT91_RTC_MTHEN);
+
+        pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __FUNCTION__,
+                at91_alarm_year, tm.tm_mon, tm.tm_mday, tm.tm_hour,
+                tm.tm_min, tm.tm_sec);
+
+        return 0;
+}
+
+/*
+ * Handle commands from user-space
+ */
+static int at91_rtc_ioctl(struct device *dev, unsigned int cmd,
+                        unsigned long arg)
+{
+        int ret = 0;
+
+        pr_debug("%s(): cmd=%08x, arg=%08lx.\n", __FUNCTION__, cmd, arg);
+
+        switch (cmd) {
+        case RTC_AIE_OFF:       /* alarm off */
+                at91_sys_write(AT91_RTC_IDR, AT91_RTC_ALARM);
+                break;
+        case RTC_AIE_ON:        /* alarm on */
+                at91_sys_write(AT91_RTC_IER, AT91_RTC_ALARM);
+                break;
+        case RTC_UIE_OFF:       /* update off */
+        case RTC_PIE_OFF:       /* periodic off */
+                at91_sys_write(AT91_RTC_IDR, AT91_RTC_SECEV);
+                break;
+        case RTC_UIE_ON:        /* update on */
+        case RTC_PIE_ON:        /* periodic on */
+                at91_sys_write(AT91_RTC_IER, AT91_RTC_SECEV);
+                break;
+        case RTC_IRQP_READ:     /* read periodic alarm frequency */
+                ret = put_user(AT91_RTC_FREQ, (unsigned long *) arg);
+                break;
+        case RTC_IRQP_SET:      /* set periodic alarm frequency */
+                if (arg != AT91_RTC_FREQ)
+                        ret = -EINVAL;
+                break;
+        default:
+                ret = -ENOIOCTLCMD;
+                break;
+        }
+
+        return ret;
+}
+
+/*
+ * Provide additional RTC information in /proc/driver/rtc
+ */
+static int at91_rtc_proc(struct device *dev, struct seq_file *seq)
+{
+        unsigned long imr = at91_sys_read(AT91_RTC_IMR);
+
+        seq_printf(seq, "alarm_IRQ\t: %s\n",
+                        (imr & AT91_RTC_ALARM) ? "yes" : "no");
+        seq_printf(seq, "update_IRQ\t: %s\n",
+                        (imr & AT91_RTC_ACKUPD) ? "yes" : "no");
+        seq_printf(seq, "periodic_IRQ\t: %s\n",
+                        (imr & AT91_RTC_SECEV) ? "yes" : "no");
+        seq_printf(seq, "periodic_freq\t: %ld\n",
+                        (unsigned long) AT91_RTC_FREQ);
+
+        return 0;
+}
+
+/*
+ * IRQ handler for the RTC
+ */
+static irqreturn_t at91_rtc_interrupt(int irq, void *dev_id,
+                                        struct pt_regs *regs)
+{
+        struct platform_device *pdev = dev_id;
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+        unsigned int rtsr;
+        unsigned long events = 0;
+
+        rtsr = at91_sys_read(AT91_RTC_SR) & at91_sys_read(AT91_RTC_IMR);
+        if (rtsr) {             /* this interrupt is shared!  Is it ours? */
+                if (rtsr & AT91_RTC_ALARM)
+                        events |= (RTC_AF | RTC_IRQF);
+                if (rtsr & AT91_RTC_SECEV)
+                        events |= (RTC_UF | RTC_IRQF);
+                if (rtsr & AT91_RTC_ACKUPD)
+                        complete(&at91_rtc_updated);
+
+                at91_sys_write(AT91_RTC_SCCR, rtsr);    /* clear status reg */
+
+                rtc_update_irq(&rtc->class_dev, 1, events);
+
+                pr_debug("%s(): num=%ld, events=0x%02lx\n", __FUNCTION__,
+                        events >> 8, events & 0x000000FF);
+
+                return IRQ_HANDLED;
+        }
+        return IRQ_NONE;                /* not handled */
+}
+
+static struct rtc_class_ops at91_rtc_ops = {
+        .ioctl          = at91_rtc_ioctl,
+        .read_time      = at91_rtc_readtime,
+        .set_time       = at91_rtc_settime,
+        .read_alarm     = at91_rtc_readalarm,
+        .set_alarm      = at91_rtc_setalarm,
+        .proc           = at91_rtc_proc,
+};
+
+/*
+ * Initialize and install RTC driver
+ */
+static int __init at91_rtc_probe(struct platform_device *pdev)
+{
+        struct rtc_device *rtc;
+        int ret;
+
+        at91_sys_write(AT91_RTC_CR, 0);
+        at91_sys_write(AT91_RTC_MR, 0);         /* 24 hour mode */
+
+        /* Disable all interrupts */
+        at91_sys_write(AT91_RTC_IDR, AT91_RTC_ACKUPD | AT91_RTC_ALARM |
+                                        AT91_RTC_SECEV | AT91_RTC_TIMEV |
+                                        AT91_RTC_CALEV);
+
+        ret = request_irq(AT91_ID_SYS, at91_rtc_interrupt,
+                                SA_SHIRQ, "at91_rtc", pdev);
+        if (ret) {
+                printk(KERN_ERR "at91_rtc: IRQ %d already in use.\n",
+                                AT91_ID_SYS);
+                return ret;
+        }
+
+        rtc = rtc_device_register(pdev->name, &pdev->dev,
+                                &at91_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                free_irq(AT91_ID_SYS, pdev);
+                return PTR_ERR(rtc);
+        }
+        platform_set_drvdata(pdev, rtc);
+
+        printk(KERN_INFO "AT91 Real Time Clock driver.\n");
+        return 0;
+}
+
+/*
+ * Disable and remove the RTC driver
+ */
+static int __devexit at91_rtc_remove(struct platform_device *pdev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+
+        /* Disable all interrupts */
+        at91_sys_write(AT91_RTC_IDR, AT91_RTC_ACKUPD | AT91_RTC_ALARM |
+                                        AT91_RTC_SECEV | AT91_RTC_TIMEV |
+                                        AT91_RTC_CALEV);
+        free_irq(AT91_ID_SYS, pdev);
+
+        rtc_device_unregister(rtc);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+
+/* AT91RM9200 RTC Power management control */
+
+static struct timespec at91_rtc_delta;
+
+static int at91_rtc_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct rtc_time tm;
+        struct timespec time;
+
+        time.tv_nsec = 0;
+
+        /* calculate time delta for suspend */
+        at91_rtc_readtime(&pdev->dev, &tm);
+        rtc_tm_to_time(&tm, &time.tv_sec);
+        save_time_delta(&at91_rtc_delta, &time);
+
+        pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __FUNCTION__,
+                1900 + tm.tm_year, tm.tm_mon, tm.tm_mday,
+                tm.tm_hour, tm.tm_min, tm.tm_sec);
+
+        return 0;
+}
+
+static int at91_rtc_resume(struct platform_device *pdev)
+{
+        struct rtc_time tm;
+        struct timespec time;
+
+        time.tv_nsec = 0;
+
+        at91_rtc_readtime(&pdev->dev, &tm);
+        rtc_tm_to_time(&tm, &time.tv_sec);
+        restore_time_delta(&at91_rtc_delta, &time);
+
+        pr_debug("%s(): %4d-%02d-%02d %02d:%02d:%02d\n", __FUNCTION__,
+                1900 + tm.tm_year, tm.tm_mon, tm.tm_mday,
+                tm.tm_hour, tm.tm_min, tm.tm_sec);
+
+        return 0;
+}
+#else
+#define at91_rtc_suspend NULL
+#define at91_rtc_resume  NULL
+#endif
+
+static struct platform_driver at91_rtc_driver = {
+        .probe          = at91_rtc_probe,
+        .remove         = at91_rtc_remove,
+        .suspend        = at91_rtc_suspend,
+        .resume         = at91_rtc_resume,
+        .driver         = {
+                .name   = "at91_rtc",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init at91_rtc_init(void)
+{
+        return platform_driver_register(&at91_rtc_driver);
+}
+
+static void __exit at91_rtc_exit(void)
+{
+        platform_driver_unregister(&at91_rtc_driver);
+}
+
+module_init(at91_rtc_init);
+module_exit(at91_rtc_exit);
+
+MODULE_AUTHOR("Rick Bronson");
+MODULE_DESCRIPTION("RTC driver for Atmel AT91RM9200");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-dev.c b/drivers/rtc/rtc-dev.c
index 2011567005f9..61a58259c93f 100644
--- a/drivers/rtc/rtc-dev.c
+++ b/drivers/rtc/rtc-dev.c
@@ -48,6 +48,93 @@ static int rtc_dev_open(struct inode *inode, struct file *file)
         return err;
 }
 
+#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
+/*
+ * Routine to poll RTC seconds field for change as often as possible,
+ * after first RTC_UIE use timer to reduce polling
+ */
+static void rtc_uie_task(void *data)
+{
+        struct rtc_device *rtc = data;
+        struct rtc_time tm;
+        int num = 0;
+        int err;
+
+        err = rtc_read_time(&rtc->class_dev, &tm);
+        spin_lock_irq(&rtc->irq_lock);
+        if (rtc->stop_uie_polling || err) {
+                rtc->uie_task_active = 0;
+        } else if (rtc->oldsecs != tm.tm_sec) {
+                num = (tm.tm_sec + 60 - rtc->oldsecs) % 60;
+                rtc->oldsecs = tm.tm_sec;
+                rtc->uie_timer.expires = jiffies + HZ - (HZ/10);
+                rtc->uie_timer_active = 1;
+                rtc->uie_task_active = 0;
+                add_timer(&rtc->uie_timer);
+        } else if (schedule_work(&rtc->uie_task) == 0) {
+                rtc->uie_task_active = 0;
+        }
+        spin_unlock_irq(&rtc->irq_lock);
+        if (num)
+                rtc_update_irq(&rtc->class_dev, num, RTC_UF | RTC_IRQF);
+}
+
+static void rtc_uie_timer(unsigned long data)
+{
+        struct rtc_device *rtc = (struct rtc_device *)data;
+        unsigned long flags;
+
+        spin_lock_irqsave(&rtc->irq_lock, flags);
+        rtc->uie_timer_active = 0;
+        rtc->uie_task_active = 1;
+        if ((schedule_work(&rtc->uie_task) == 0))
+                rtc->uie_task_active = 0;
+        spin_unlock_irqrestore(&rtc->irq_lock, flags);
+}
+
+static void clear_uie(struct rtc_device *rtc)
+{
+        spin_lock_irq(&rtc->irq_lock);
+        if (rtc->irq_active) {
+                rtc->stop_uie_polling = 1;
+                if (rtc->uie_timer_active) {
+                        spin_unlock_irq(&rtc->irq_lock);
+                        del_timer_sync(&rtc->uie_timer);
+                        spin_lock_irq(&rtc->irq_lock);
+                        rtc->uie_timer_active = 0;
+                }
+                if (rtc->uie_task_active) {
+                        spin_unlock_irq(&rtc->irq_lock);
+                        flush_scheduled_work();
+                        spin_lock_irq(&rtc->irq_lock);
+                }
+                rtc->irq_active = 0;
+        }
+        spin_unlock_irq(&rtc->irq_lock);
+}
+
+static int set_uie(struct rtc_device *rtc)
+{
+        struct rtc_time tm;
+        int err;
+
+        err = rtc_read_time(&rtc->class_dev, &tm);
+        if (err)
+                return err;
+        spin_lock_irq(&rtc->irq_lock);
+        if (!rtc->irq_active) {
+                rtc->irq_active = 1;
+                rtc->stop_uie_polling = 0;
+                rtc->oldsecs = tm.tm_sec;
+                rtc->uie_task_active = 1;
+                if (schedule_work(&rtc->uie_task) == 0)
+                        rtc->uie_task_active = 0;
+        }
+        rtc->irq_data = 0;
+        spin_unlock_irq(&rtc->irq_lock);
+        return 0;
+}
+#endif /* CONFIG_RTC_INTF_DEV_UIE_EMUL */
 
 static ssize_t
 rtc_dev_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
@@ -127,6 +214,28 @@ static int rtc_dev_ioctl(struct inode *inode, struct file *file,
         struct rtc_wkalrm alarm;
         void __user *uarg = (void __user *) arg;
 
+        /* check that the calles has appropriate permissions
+         * for certain ioctls. doing this check here is useful
+         * to avoid duplicate code in each driver.
+         */
+        switch (cmd) {
+        case RTC_EPOCH_SET:
+        case RTC_SET_TIME:
+                if (!capable(CAP_SYS_TIME))
+                        return -EACCES;
+                break;
+
+        case RTC_IRQP_SET:
+                if (arg > rtc->max_user_freq && !capable(CAP_SYS_RESOURCE))
+                        return -EACCES;
+                break;
+
+        case RTC_PIE_ON:
+                if (!capable(CAP_SYS_RESOURCE))
+                        return -EACCES;
+                break;
+        }
+
         /* avoid conflicting IRQ users */
         if (cmd == RTC_PIE_ON || cmd == RTC_PIE_OFF || cmd == RTC_IRQP_SET) {
                 spin_lock(&rtc->irq_task_lock);
@@ -185,9 +294,6 @@ static int rtc_dev_ioctl(struct inode *inode, struct file *file,
                 break;
 
         case RTC_SET_TIME:
-                if (!capable(CAP_SYS_TIME))
-                        return -EACCES;
-
                 if (copy_from_user(&tm, uarg, sizeof(tm)))
                         return -EFAULT;
 
@@ -203,10 +309,6 @@ static int rtc_dev_ioctl(struct inode *inode, struct file *file,
                         err = -EINVAL;
                         break;
                 }
-                if (!capable(CAP_SYS_TIME)) {
-                        err = -EACCES;
-                        break;
-                }
                 rtc_epoch = arg;
                 err = 0;
 #endif
@@ -232,6 +334,14 @@ static int rtc_dev_ioctl(struct inode *inode, struct file *file,
                         return -EFAULT;
                 break;
 
+#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
+        case RTC_UIE_OFF:
+                clear_uie(rtc);
+                return 0;
+
+        case RTC_UIE_ON:
+                return set_uie(rtc);
+#endif
         default:
                 err = -ENOTTY;
                 break;
@@ -244,6 +354,9 @@ static int rtc_dev_release(struct inode *inode, struct file *file)
 {
         struct rtc_device *rtc = to_rtc_device(file->private_data);
 
+#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
+        clear_uie(rtc);
+#endif
         if (rtc->ops->release)
                 rtc->ops->release(rtc->class_dev.dev);
 
@@ -284,6 +397,10 @@ static int rtc_dev_add_device(struct class_device *class_dev,
         mutex_init(&rtc->char_lock);
         spin_lock_init(&rtc->irq_lock);
         init_waitqueue_head(&rtc->irq_queue);
+#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
+        INIT_WORK(&rtc->uie_task, rtc_uie_task, rtc);
+        setup_timer(&rtc->uie_timer, rtc_uie_timer, (unsigned long)rtc);
+#endif
 
         cdev_init(&rtc->char_dev, &rtc_dev_fops);
         rtc->char_dev.owner = rtc->owner;
diff --git a/drivers/rtc/rtc-ds1307.c b/drivers/rtc/rtc-ds1307.c
new file mode 100644
index 000000000000..e8afb9384786
--- /dev/null
+++ b/drivers/rtc/rtc-ds1307.c
@@ -0,0 +1,388 @@
+/*
+ * rtc-ds1307.c - RTC driver for some mostly-compatible I2C chips.
+ *
+ *  Copyright (C) 2005 James Chapman (ds1337 core)
+ *  Copyright (C) 2006 David Brownell
+ *
+ * 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/init.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/string.h>
+#include <linux/rtc.h>
+#include <linux/bcd.h>
+
+
+
+/* We can't determine type by probing, but if we expect pre-Linux code
+ * to have set the chip up as a clock (turning on the oscillator and
+ * setting the date and time), Linux can ignore the non-clock features.
+ * That's a natural job for a factory or repair bench.
+ *
+ * If the I2C "force" mechanism is used, we assume the chip is a ds1337.
+ * (Much better would be board-specific tables of I2C devices, along with
+ * the platform_data drivers would use to sort such issues out.)
+ */
+enum ds_type {
+        unknown = 0,
+        ds_1307,                /* or ds1338, ... */
+        ds_1337,                /* or ds1339, ... */
+        ds_1340,                /* or st m41t00, ... */
+        // rs5c372 too?  different address...
+};
+
+static unsigned short normal_i2c[] = { 0x68, I2C_CLIENT_END };
+
+I2C_CLIENT_INSMOD;
+
+
+
+/* RTC registers don't differ much, except for the century flag */
+#define DS1307_REG_SECS         0x00    /* 00-59 */
+#       define DS1307_BIT_CH            0x80
+#define DS1307_REG_MIN          0x01    /* 00-59 */
+#define DS1307_REG_HOUR         0x02    /* 00-23, or 1-12{am,pm} */
+#       define DS1340_BIT_CENTURY_EN    0x80    /* in REG_HOUR */
+#       define DS1340_BIT_CENTURY       0x40    /* in REG_HOUR */
+#define DS1307_REG_WDAY         0x03    /* 01-07 */
+#define DS1307_REG_MDAY         0x04    /* 01-31 */
+#define DS1307_REG_MONTH        0x05    /* 01-12 */
+#       define DS1337_BIT_CENTURY       0x80    /* in REG_MONTH */
+#define DS1307_REG_YEAR         0x06    /* 00-99 */
+
+/* Other registers (control, status, alarms, trickle charge, NVRAM, etc)
+ * start at 7, and they differ a lot. Only control and status matter for RTC;
+ * be careful using them.
+ */
+#define DS1307_REG_CONTROL      0x07
+#       define DS1307_BIT_OUT           0x80
+#       define DS1307_BIT_SQWE          0x10
+#       define DS1307_BIT_RS1           0x02
+#       define DS1307_BIT_RS0           0x01
+#define DS1337_REG_CONTROL      0x0e
+#       define DS1337_BIT_nEOSC         0x80
+#       define DS1337_BIT_RS2           0x10
+#       define DS1337_BIT_RS1           0x08
+#       define DS1337_BIT_INTCN         0x04
+#       define DS1337_BIT_A2IE          0x02
+#       define DS1337_BIT_A1IE          0x01
+#define DS1337_REG_STATUS       0x0f
+#       define DS1337_BIT_OSF           0x80
+#       define DS1337_BIT_A2I           0x02
+#       define DS1337_BIT_A1I           0x01
+#define DS1339_REG_TRICKLE      0x10
+
+
+
+struct ds1307 {
+        u8                      reg_addr;
+        u8                      regs[8];
+        enum ds_type            type;
+        struct i2c_msg          msg[2];
+        struct i2c_client       client;
+        struct rtc_device       *rtc;
+};
+
+
+static int ds1307_get_time(struct device *dev, struct rtc_time *t)
+{
+        struct ds1307   *ds1307 = dev_get_drvdata(dev);
+        int             tmp;
+
+        /* read the RTC registers all at once */
+        ds1307->msg[1].flags = I2C_M_RD;
+        ds1307->msg[1].len = 7;
+
+        tmp = i2c_transfer(ds1307->client.adapter, ds1307->msg, 2);
+        if (tmp != 2) {
+                dev_err(dev, "%s error %d\n", "read", tmp);
+                return -EIO;
+        }
+
+        dev_dbg(dev, "%s: %02x %02x %02x %02x %02x %02x %02x\n",
+                        "read",
+                        ds1307->regs[0], ds1307->regs[1],
+                        ds1307->regs[2], ds1307->regs[3],
+                        ds1307->regs[4], ds1307->regs[5],
+                        ds1307->regs[6]);
+
+        t->tm_sec = BCD2BIN(ds1307->regs[DS1307_REG_SECS] & 0x7f);
+        t->tm_min = BCD2BIN(ds1307->regs[DS1307_REG_MIN] & 0x7f);
+        tmp = ds1307->regs[DS1307_REG_HOUR] & 0x3f;
+        t->tm_hour = BCD2BIN(tmp);
+        t->tm_wday = BCD2BIN(ds1307->regs[DS1307_REG_WDAY] & 0x07) - 1;
+        t->tm_mday = BCD2BIN(ds1307->regs[DS1307_REG_MDAY] & 0x3f);
+        tmp = ds1307->regs[DS1307_REG_MONTH] & 0x1f;
+        t->tm_mon = BCD2BIN(tmp) - 1;
+
+        /* assume 20YY not 19YY, and ignore DS1337_BIT_CENTURY */
+        t->tm_year = BCD2BIN(ds1307->regs[DS1307_REG_YEAR]) + 100;
+
+        dev_dbg(dev, "%s secs=%d, mins=%d, "
+                "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
+                "read", t->tm_sec, t->tm_min,
+                t->tm_hour, t->tm_mday,
+                t->tm_mon, t->tm_year, t->tm_wday);
+
+        return 0;
+}
+
+static int ds1307_set_time(struct device *dev, struct rtc_time *t)
+{
+        struct ds1307   *ds1307 = dev_get_drvdata(dev);
+        int             result;
+        int             tmp;
+        u8              *buf = ds1307->regs;
+
+        dev_dbg(dev, "%s secs=%d, mins=%d, "
+                "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
+                "write", dt->tm_sec, dt->tm_min,
+                dt->tm_hour, dt->tm_mday,
+                dt->tm_mon, dt->tm_year, dt->tm_wday);
+
+        *buf++ = 0;             /* first register addr */
+        buf[DS1307_REG_SECS] = BIN2BCD(t->tm_sec);
+        buf[DS1307_REG_MIN] = BIN2BCD(t->tm_min);
+        buf[DS1307_REG_HOUR] = BIN2BCD(t->tm_hour);
+        buf[DS1307_REG_WDAY] = BIN2BCD(t->tm_wday + 1);
+        buf[DS1307_REG_MDAY] = BIN2BCD(t->tm_mday);
+        buf[DS1307_REG_MONTH] = BIN2BCD(t->tm_mon + 1);
+
+        /* assume 20YY not 19YY */
+        tmp = t->tm_year - 100;
+        buf[DS1307_REG_YEAR] = BIN2BCD(tmp);
+
+        if (ds1307->type == ds_1337)
+                buf[DS1307_REG_MONTH] |= DS1337_BIT_CENTURY;
+        else if (ds1307->type == ds_1340)
+                buf[DS1307_REG_HOUR] |= DS1340_BIT_CENTURY_EN
+                                | DS1340_BIT_CENTURY;
+
+        ds1307->msg[1].flags = 0;
+        ds1307->msg[1].len = 8;
+
+        dev_dbg(dev, "%s: %02x %02x %02x %02x %02x %02x %02x\n",
+                "write", buf[0], buf[1], buf[2], buf[3],
+                buf[4], buf[5], buf[6]);
+
+        result = i2c_transfer(ds1307->client.adapter, &ds1307->msg[1], 1);
+        if (result != 1) {
+                dev_err(dev, "%s error %d\n", "write", tmp);
+                return -EIO;
+        }
+        return 0;
+}
+
+static struct rtc_class_ops ds13xx_rtc_ops = {
+        .read_time      = ds1307_get_time,
+        .set_time       = ds1307_set_time,
+};
+
+static struct i2c_driver ds1307_driver;
+
+static int __devinit
+ds1307_detect(struct i2c_adapter *adapter, int address, int kind)
+{
+        struct ds1307           *ds1307;
+        int                     err = -ENODEV;
+        struct i2c_client       *client;
+        int                     tmp;
+
+        if (!(ds1307 = kzalloc(sizeof(struct ds1307), GFP_KERNEL))) {
+                err = -ENOMEM;
+                goto exit;
+        }
+
+        client = &ds1307->client;
+        client->addr = address;
+        client->adapter = adapter;
+        client->driver = &ds1307_driver;
+        client->flags = 0;
+
+        i2c_set_clientdata(client, ds1307);
+
+        ds1307->msg[0].addr = client->addr;
+        ds1307->msg[0].flags = 0;
+        ds1307->msg[0].len = 1;
+        ds1307->msg[0].buf = &ds1307->reg_addr;
+
+        ds1307->msg[1].addr = client->addr;
+        ds1307->msg[1].flags = I2C_M_RD;
+        ds1307->msg[1].len = sizeof(ds1307->regs);
+        ds1307->msg[1].buf = ds1307->regs;
+
+        /* HACK: "force" implies "needs ds1337-style-oscillator setup" */
+        if (kind >= 0) {
+                ds1307->type = ds_1337;
+
+                ds1307->reg_addr = DS1337_REG_CONTROL;
+                ds1307->msg[1].len = 2;
+
+                tmp = i2c_transfer(client->adapter, ds1307->msg, 2);
+                if (tmp != 2) {
+                        pr_debug("read error %d\n", tmp);
+                        err = -EIO;
+                        goto exit_free;
+                }
+
+                ds1307->reg_addr = 0;
+                ds1307->msg[1].len = sizeof(ds1307->regs);
+
+                /* oscillator is off; need to turn it on */
+                if ((ds1307->regs[0] & DS1337_BIT_nEOSC)
+                                || (ds1307->regs[1] & DS1337_BIT_OSF)) {
+                        printk(KERN_ERR "no ds1337 oscillator code\n");
+                        goto exit_free;
+                }
+        } else
+                ds1307->type = ds_1307;
+
+read_rtc:
+        /* read RTC registers */
+
+        tmp = i2c_transfer(client->adapter, ds1307->msg, 2);
+        if (tmp != 2) {
+                pr_debug("read error %d\n", tmp);
+                err = -EIO;
+                goto exit_free;
+        }
+
+        /* minimal sanity checking; some chips (like DS1340) don't
+         * specify the extra bits as must-be-zero, but there are
+         * still a few values that are clearly out-of-range.
+         */
+        tmp = ds1307->regs[DS1307_REG_SECS];
+        if (tmp & DS1307_BIT_CH) {
+                if (ds1307->type && ds1307->type != ds_1307) {
+                        pr_debug("not a ds1307?\n");
+                        goto exit_free;
+                }
+                ds1307->type = ds_1307;
+
+                /* this partial initialization should work for ds1307,
+                 * ds1338, ds1340, st m41t00, and more.
+                 */
+                dev_warn(&client->dev, "oscillator started; SET TIME!\n");
+                i2c_smbus_write_byte_data(client, 0, 0);
+                goto read_rtc;
+        }
+        tmp = BCD2BIN(tmp & 0x7f);
+        if (tmp > 60)
+                goto exit_free;
+        tmp = BCD2BIN(ds1307->regs[DS1307_REG_MIN] & 0x7f);
+        if (tmp > 60)
+                goto exit_free;
+
+        tmp = BCD2BIN(ds1307->regs[DS1307_REG_MDAY] & 0x3f);
+        if (tmp == 0 || tmp > 31)
+                goto exit_free;
+
+        tmp = BCD2BIN(ds1307->regs[DS1307_REG_MONTH] & 0x1f);
+        if (tmp == 0 || tmp > 12)
+                goto exit_free;
+
+        /* force into in 24 hour mode (most chips) or
+         * disable century bit (ds1340)
+         */
+        tmp = ds1307->regs[DS1307_REG_HOUR];
+        if (tmp & (1 << 6)) {
+                if (tmp & (1 << 5))
+                        tmp = BCD2BIN(tmp & 0x1f) + 12;
+                else
+                        tmp = BCD2BIN(tmp);
+                i2c_smbus_write_byte_data(client,
+                                DS1307_REG_HOUR,
+                                BIN2BCD(tmp));
+        }
+
+        /* FIXME chips like 1337 can generate alarm irqs too; those are
+         * worth exposing through the API (especially when the irq is
+         * wakeup-capable).
+         */
+
+        switch (ds1307->type) {
+        case unknown:
+                strlcpy(client->name, "unknown", I2C_NAME_SIZE);
+                break;
+        case ds_1307:
+                strlcpy(client->name, "ds1307", I2C_NAME_SIZE);
+                break;
+        case ds_1337:
+                strlcpy(client->name, "ds1337", I2C_NAME_SIZE);
+                break;
+        case ds_1340:
+                strlcpy(client->name, "ds1340", I2C_NAME_SIZE);
+                break;
+        }
+
+        /* Tell the I2C layer a new client has arrived */
+        if ((err = i2c_attach_client(client)))
+                goto exit_free;
+
+        ds1307->rtc = rtc_device_register(client->name, &client->dev,
+                                &ds13xx_rtc_ops, THIS_MODULE);
+        if (IS_ERR(ds1307->rtc)) {
+                err = PTR_ERR(ds1307->rtc);
+                dev_err(&client->dev,
+                        "unable to register the class device\n");
+                goto exit_detach;
+        }
+
+        return 0;
+
+exit_detach:
+        i2c_detach_client(client);
+exit_free:
+        kfree(ds1307);
+exit:
+        return err;
+}
+
+static int __devinit
+ds1307_attach_adapter(struct i2c_adapter *adapter)
+{
+        if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
+                return 0;
+        return i2c_probe(adapter, &addr_data, ds1307_detect);
+}
+
+static int __devexit ds1307_detach_client(struct i2c_client *client)
+{
+        int             err;
+        struct ds1307   *ds1307 = i2c_get_clientdata(client);
+
+        rtc_device_unregister(ds1307->rtc);
+        if ((err = i2c_detach_client(client)))
+                return err;
+        kfree(ds1307);
+        return 0;
+}
+
+static struct i2c_driver ds1307_driver = {
+        .driver = {
+                .name   = "ds1307",
+                .owner  = THIS_MODULE,
+        },
+        .attach_adapter = ds1307_attach_adapter,
+        .detach_client  = __devexit_p(ds1307_detach_client),
+};
+
+static int __init ds1307_init(void)
+{
+        return i2c_add_driver(&ds1307_driver);
+}
+module_init(ds1307_init);
+
+static void __exit ds1307_exit(void)
+{
+        i2c_del_driver(&ds1307_driver);
+}
+module_exit(ds1307_exit);
+
+MODULE_DESCRIPTION("RTC driver for DS1307 and similar chips");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-ds1553.c b/drivers/rtc/rtc-ds1553.c
new file mode 100644
index 000000000000..ecafbad41a24
--- /dev/null
+++ b/drivers/rtc/rtc-ds1553.c
@@ -0,0 +1,414 @@
+/*
+ * An rtc driver for the Dallas DS1553
+ *
+ * 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.
+ */
+
+#include <linux/bcd.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/jiffies.h>
+#include <linux/interrupt.h>
+#include <linux/rtc.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+
+#define DRV_VERSION "0.1"
+
+#define RTC_REG_SIZE            0x2000
+#define RTC_OFFSET              0x1ff0
+
+#define RTC_FLAGS               (RTC_OFFSET + 0)
+#define RTC_SECONDS_ALARM       (RTC_OFFSET + 2)
+#define RTC_MINUTES_ALARM       (RTC_OFFSET + 3)
+#define RTC_HOURS_ALARM         (RTC_OFFSET + 4)
+#define RTC_DATE_ALARM          (RTC_OFFSET + 5)
+#define RTC_INTERRUPTS          (RTC_OFFSET + 6)
+#define RTC_WATCHDOG            (RTC_OFFSET + 7)
+#define RTC_CONTROL             (RTC_OFFSET + 8)
+#define RTC_CENTURY             (RTC_OFFSET + 8)
+#define RTC_SECONDS             (RTC_OFFSET + 9)
+#define RTC_MINUTES             (RTC_OFFSET + 10)
+#define RTC_HOURS               (RTC_OFFSET + 11)
+#define RTC_DAY                 (RTC_OFFSET + 12)
+#define RTC_DATE                (RTC_OFFSET + 13)
+#define RTC_MONTH               (RTC_OFFSET + 14)
+#define RTC_YEAR                (RTC_OFFSET + 15)
+
+#define RTC_CENTURY_MASK        0x3f
+#define RTC_SECONDS_MASK        0x7f
+#define RTC_DAY_MASK            0x07
+
+/* Bits in the Control/Century register */
+#define RTC_WRITE               0x80
+#define RTC_READ                0x40
+
+/* Bits in the Seconds register */
+#define RTC_STOP                0x80
+
+/* Bits in the Flags register */
+#define RTC_FLAGS_AF            0x40
+#define RTC_FLAGS_BLF           0x10
+
+/* Bits in the Interrupts register */
+#define RTC_INTS_AE             0x80
+
+struct rtc_plat_data {
+        struct rtc_device *rtc;
+        void __iomem *ioaddr;
+        unsigned long baseaddr;
+        unsigned long last_jiffies;
+        int irq;
+        unsigned int irqen;
+        int alrm_sec;
+        int alrm_min;
+        int alrm_hour;
+        int alrm_mday;
+};
+
+static int ds1553_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        u8 century;
+
+        century = BIN2BCD((tm->tm_year + 1900) / 100);
+
+        writeb(RTC_WRITE, pdata->ioaddr + RTC_CONTROL);
+
+        writeb(BIN2BCD(tm->tm_year % 100), ioaddr + RTC_YEAR);
+        writeb(BIN2BCD(tm->tm_mon + 1), ioaddr + RTC_MONTH);
+        writeb(BIN2BCD(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
+        writeb(BIN2BCD(tm->tm_mday), ioaddr + RTC_DATE);
+        writeb(BIN2BCD(tm->tm_hour), ioaddr + RTC_HOURS);
+        writeb(BIN2BCD(tm->tm_min), ioaddr + RTC_MINUTES);
+        writeb(BIN2BCD(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
+
+        /* RTC_CENTURY and RTC_CONTROL share same register */
+        writeb(RTC_WRITE | (century & RTC_CENTURY_MASK), ioaddr + RTC_CENTURY);
+        writeb(century & RTC_CENTURY_MASK, ioaddr + RTC_CONTROL);
+        return 0;
+}
+
+static int ds1553_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        unsigned int year, month, day, hour, minute, second, week;
+        unsigned int century;
+
+        /* give enough time to update RTC in case of continuous read */
+        if (pdata->last_jiffies == jiffies)
+                msleep(1);
+        pdata->last_jiffies = jiffies;
+        writeb(RTC_READ, ioaddr + RTC_CONTROL);
+        second = readb(ioaddr + RTC_SECONDS) & RTC_SECONDS_MASK;
+        minute = readb(ioaddr + RTC_MINUTES);
+        hour = readb(ioaddr + RTC_HOURS);
+        day = readb(ioaddr + RTC_DATE);
+        week = readb(ioaddr + RTC_DAY) & RTC_DAY_MASK;
+        month = readb(ioaddr + RTC_MONTH);
+        year = readb(ioaddr + RTC_YEAR);
+        century = readb(ioaddr + RTC_CENTURY) & RTC_CENTURY_MASK;
+        writeb(0, ioaddr + RTC_CONTROL);
+        tm->tm_sec = BCD2BIN(second);
+        tm->tm_min = BCD2BIN(minute);
+        tm->tm_hour = BCD2BIN(hour);
+        tm->tm_mday = BCD2BIN(day);
+        tm->tm_wday = BCD2BIN(week);
+        tm->tm_mon = BCD2BIN(month) - 1;
+        /* year is 1900 + tm->tm_year */
+        tm->tm_year = BCD2BIN(year) + BCD2BIN(century) * 100 - 1900;
+
+        if (rtc_valid_tm(tm) < 0) {
+                dev_err(dev, "retrieved date/time is not valid.\n");
+                rtc_time_to_tm(0, tm);
+        }
+        return 0;
+}
+
+static void ds1553_rtc_update_alarm(struct rtc_plat_data *pdata)
+{
+        void __iomem *ioaddr = pdata->ioaddr;
+        unsigned long flags;
+
+        spin_lock_irqsave(&pdata->rtc->irq_lock, flags);
+        writeb(pdata->alrm_mday < 0 || (pdata->irqen & RTC_UF) ?
+               0x80 : BIN2BCD(pdata->alrm_mday),
+               ioaddr + RTC_DATE_ALARM);
+        writeb(pdata->alrm_hour < 0 || (pdata->irqen & RTC_UF) ?
+               0x80 : BIN2BCD(pdata->alrm_hour),
+               ioaddr + RTC_HOURS_ALARM);
+        writeb(pdata->alrm_min < 0 || (pdata->irqen & RTC_UF) ?
+               0x80 : BIN2BCD(pdata->alrm_min),
+               ioaddr + RTC_MINUTES_ALARM);
+        writeb(pdata->alrm_sec < 0 || (pdata->irqen & RTC_UF) ?
+               0x80 : BIN2BCD(pdata->alrm_sec),
+               ioaddr + RTC_SECONDS_ALARM);
+        writeb(pdata->irqen ? RTC_INTS_AE : 0, ioaddr + RTC_INTERRUPTS);
+        readb(ioaddr + RTC_FLAGS);      /* clear interrupts */
+        spin_unlock_irqrestore(&pdata->rtc->irq_lock, flags);
+}
+
+static int ds1553_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        if (pdata->irq < 0)
+                return -EINVAL;
+        pdata->alrm_mday = alrm->time.tm_mday;
+        pdata->alrm_hour = alrm->time.tm_hour;
+        pdata->alrm_min = alrm->time.tm_min;
+        pdata->alrm_sec = alrm->time.tm_sec;
+        if (alrm->enabled)
+                pdata->irqen |= RTC_AF;
+        ds1553_rtc_update_alarm(pdata);
+        return 0;
+}
+
+static int ds1553_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        if (pdata->irq < 0)
+                return -EINVAL;
+        alrm->time.tm_mday = pdata->alrm_mday < 0 ? 0 : pdata->alrm_mday;
+        alrm->time.tm_hour = pdata->alrm_hour < 0 ? 0 : pdata->alrm_hour;
+        alrm->time.tm_min = pdata->alrm_min < 0 ? 0 : pdata->alrm_min;
+        alrm->time.tm_sec = pdata->alrm_sec < 0 ? 0 : pdata->alrm_sec;
+        alrm->enabled = (pdata->irqen & RTC_AF) ? 1 : 0;
+        return 0;
+}
+
+static irqreturn_t ds1553_rtc_interrupt(int irq, void *dev_id,
+                                        struct pt_regs *regs)
+{
+        struct platform_device *pdev = dev_id;
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        unsigned long events = RTC_IRQF;
+
+        /* read and clear interrupt */
+        if (!(readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_AF))
+                return IRQ_NONE;
+        if (readb(ioaddr + RTC_SECONDS_ALARM) & 0x80)
+                events |= RTC_UF;
+        else
+                events |= RTC_AF;
+        rtc_update_irq(&pdata->rtc->class_dev, 1, events);
+        return IRQ_HANDLED;
+}
+
+static void ds1553_rtc_release(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        if (pdata->irq >= 0) {
+                pdata->irqen = 0;
+                ds1553_rtc_update_alarm(pdata);
+        }
+}
+
+static int ds1553_rtc_ioctl(struct device *dev, unsigned int cmd,
+                            unsigned long arg)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        if (pdata->irq < 0)
+                return -ENOIOCTLCMD;
+        switch (cmd) {
+        case RTC_AIE_OFF:
+                pdata->irqen &= ~RTC_AF;
+                ds1553_rtc_update_alarm(pdata);
+                break;
+        case RTC_AIE_ON:
+                pdata->irqen |= RTC_AF;
+                ds1553_rtc_update_alarm(pdata);
+                break;
+        case RTC_UIE_OFF:
+                pdata->irqen &= ~RTC_UF;
+                ds1553_rtc_update_alarm(pdata);
+                break;
+        case RTC_UIE_ON:
+                pdata->irqen |= RTC_UF;
+                ds1553_rtc_update_alarm(pdata);
+                break;
+        default:
+                return -ENOIOCTLCMD;
+        }
+        return 0;
+}
+
+static struct rtc_class_ops ds1553_rtc_ops = {
+        .read_time      = ds1553_rtc_read_time,
+        .set_time       = ds1553_rtc_set_time,
+        .read_alarm     = ds1553_rtc_read_alarm,
+        .set_alarm      = ds1553_rtc_set_alarm,
+        .release        = ds1553_rtc_release,
+        .ioctl          = ds1553_rtc_ioctl,
+};
+
+static ssize_t ds1553_nvram_read(struct kobject *kobj, char *buf,
+                                 loff_t pos, size_t size)
+{
+        struct platform_device *pdev =
+                to_platform_device(container_of(kobj, struct device, kobj));
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        ssize_t count;
+
+        for (count = 0; size > 0 && pos < RTC_OFFSET; count++, size--)
+                *buf++ = readb(ioaddr + pos++);
+        return count;
+}
+
+static ssize_t ds1553_nvram_write(struct kobject *kobj, char *buf,
+                                  loff_t pos, size_t size)
+{
+        struct platform_device *pdev =
+                to_platform_device(container_of(kobj, struct device, kobj));
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        ssize_t count;
+
+        for (count = 0; size > 0 && pos < RTC_OFFSET; count++, size--)
+                writeb(*buf++, ioaddr + pos++);
+        return count;
+}
+
+static struct bin_attribute ds1553_nvram_attr = {
+        .attr = {
+                .name = "nvram",
+                .mode = S_IRUGO | S_IWUGO,
+                .owner = THIS_MODULE,
+        },
+        .size = RTC_OFFSET,
+        .read = ds1553_nvram_read,
+        .write = ds1553_nvram_write,
+};
+
+static int __init ds1553_rtc_probe(struct platform_device *pdev)
+{
+        struct rtc_device *rtc;
+        struct resource *res;
+        unsigned int cen, sec;
+        struct rtc_plat_data *pdata = NULL;
+        void __iomem *ioaddr = NULL;
+        int ret = 0;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENODEV;
+        pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return -ENOMEM;
+        pdata->irq = -1;
+        if (!request_mem_region(res->start, RTC_REG_SIZE, pdev->name)) {
+                ret = -EBUSY;
+                goto out;
+        }
+        pdata->baseaddr = res->start;
+        ioaddr = ioremap(pdata->baseaddr, RTC_REG_SIZE);
+        if (!ioaddr) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        pdata->ioaddr = ioaddr;
+        pdata->irq = platform_get_irq(pdev, 0);
+
+        /* turn RTC on if it was not on */
+        sec = readb(ioaddr + RTC_SECONDS);
+        if (sec & RTC_STOP) {
+                sec &= RTC_SECONDS_MASK;
+                cen = readb(ioaddr + RTC_CENTURY) & RTC_CENTURY_MASK;
+                writeb(RTC_WRITE, ioaddr + RTC_CONTROL);
+                writeb(sec, ioaddr + RTC_SECONDS);
+                writeb(cen & RTC_CENTURY_MASK, ioaddr + RTC_CONTROL);
+        }
+        if (readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_BLF)
+                dev_warn(&pdev->dev, "voltage-low detected.\n");
+
+        if (pdata->irq >= 0) {
+                writeb(0, ioaddr + RTC_INTERRUPTS);
+                if (request_irq(pdata->irq, ds1553_rtc_interrupt, SA_SHIRQ,
+                                pdev->name, pdev) < 0) {
+                        dev_warn(&pdev->dev, "interrupt not available.\n");
+                        pdata->irq = -1;
+                }
+        }
+
+        rtc = rtc_device_register(pdev->name, &pdev->dev,
+                                  &ds1553_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                ret = PTR_ERR(rtc);
+                goto out;
+        }
+        pdata->rtc = rtc;
+        pdata->last_jiffies = jiffies;
+        platform_set_drvdata(pdev, pdata);
+        sysfs_create_bin_file(&pdev->dev.kobj, &ds1553_nvram_attr);
+        return 0;
+ out:
+        if (pdata->irq >= 0)
+                free_irq(pdata->irq, pdev);
+        if (ioaddr)
+                iounmap(ioaddr);
+        if (pdata->baseaddr)
+                release_mem_region(pdata->baseaddr, RTC_REG_SIZE);
+        kfree(pdata);
+        return ret;
+}
+
+static int __devexit ds1553_rtc_remove(struct platform_device *pdev)
+{
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        sysfs_remove_bin_file(&pdev->dev.kobj, &ds1553_nvram_attr);
+        rtc_device_unregister(pdata->rtc);
+        if (pdata->irq >= 0) {
+                writeb(0, pdata->ioaddr + RTC_INTERRUPTS);
+                free_irq(pdata->irq, pdev);
+        }
+        iounmap(pdata->ioaddr);
+        release_mem_region(pdata->baseaddr, RTC_REG_SIZE);
+        kfree(pdata);
+        return 0;
+}
+
+static struct platform_driver ds1553_rtc_driver = {
+        .probe          = ds1553_rtc_probe,
+        .remove         = __devexit_p(ds1553_rtc_remove),
+        .driver         = {
+                .name   = "ds1553",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static __init int ds1553_init(void)
+{
+        return platform_driver_register(&ds1553_rtc_driver);
+}
+
+static __exit void ds1553_exit(void)
+{
+        return platform_driver_unregister(&ds1553_rtc_driver);
+}
+
+module_init(ds1553_init);
+module_exit(ds1553_exit);
+
+MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
+MODULE_DESCRIPTION("Dallas DS1553 RTC driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/rtc/rtc-ds1742.c b/drivers/rtc/rtc-ds1742.c
new file mode 100644
index 000000000000..8e47e5a06d2a
--- /dev/null
+++ b/drivers/rtc/rtc-ds1742.c
@@ -0,0 +1,259 @@
+/*
+ * An rtc driver for the Dallas DS1742
+ *
+ * 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.
+ */
+
+#include <linux/bcd.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/jiffies.h>
+#include <linux/rtc.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+
+#define DRV_VERSION "0.1"
+
+#define RTC_REG_SIZE            0x800
+#define RTC_OFFSET              0x7f8
+
+#define RTC_CONTROL             (RTC_OFFSET + 0)
+#define RTC_CENTURY             (RTC_OFFSET + 0)
+#define RTC_SECONDS             (RTC_OFFSET + 1)
+#define RTC_MINUTES             (RTC_OFFSET + 2)
+#define RTC_HOURS               (RTC_OFFSET + 3)
+#define RTC_DAY                 (RTC_OFFSET + 4)
+#define RTC_DATE                (RTC_OFFSET + 5)
+#define RTC_MONTH               (RTC_OFFSET + 6)
+#define RTC_YEAR                (RTC_OFFSET + 7)
+
+#define RTC_CENTURY_MASK        0x3f
+#define RTC_SECONDS_MASK        0x7f
+#define RTC_DAY_MASK            0x07
+
+/* Bits in the Control/Century register */
+#define RTC_WRITE               0x80
+#define RTC_READ                0x40
+
+/* Bits in the Seconds register */
+#define RTC_STOP                0x80
+
+/* Bits in the Day register */
+#define RTC_BATT_FLAG           0x80
+
+struct rtc_plat_data {
+        struct rtc_device *rtc;
+        void __iomem *ioaddr;
+        unsigned long baseaddr;
+        unsigned long last_jiffies;
+};
+
+static int ds1742_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        u8 century;
+
+        century = BIN2BCD((tm->tm_year + 1900) / 100);
+
+        writeb(RTC_WRITE, ioaddr + RTC_CONTROL);
+
+        writeb(BIN2BCD(tm->tm_year % 100), ioaddr + RTC_YEAR);
+        writeb(BIN2BCD(tm->tm_mon + 1), ioaddr + RTC_MONTH);
+        writeb(BIN2BCD(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
+        writeb(BIN2BCD(tm->tm_mday), ioaddr + RTC_DATE);
+        writeb(BIN2BCD(tm->tm_hour), ioaddr + RTC_HOURS);
+        writeb(BIN2BCD(tm->tm_min), ioaddr + RTC_MINUTES);
+        writeb(BIN2BCD(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
+
+        /* RTC_CENTURY and RTC_CONTROL share same register */
+        writeb(RTC_WRITE | (century & RTC_CENTURY_MASK), ioaddr + RTC_CENTURY);
+        writeb(century & RTC_CENTURY_MASK, ioaddr + RTC_CONTROL);
+        return 0;
+}
+
+static int ds1742_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        unsigned int year, month, day, hour, minute, second, week;
+        unsigned int century;
+
+        /* give enough time to update RTC in case of continuous read */
+        if (pdata->last_jiffies == jiffies)
+                msleep(1);
+        pdata->last_jiffies = jiffies;
+        writeb(RTC_READ, ioaddr + RTC_CONTROL);
+        second = readb(ioaddr + RTC_SECONDS) & RTC_SECONDS_MASK;
+        minute = readb(ioaddr + RTC_MINUTES);
+        hour = readb(ioaddr + RTC_HOURS);
+        day = readb(ioaddr + RTC_DATE);
+        week = readb(ioaddr + RTC_DAY) & RTC_DAY_MASK;
+        month = readb(ioaddr + RTC_MONTH);
+        year = readb(ioaddr + RTC_YEAR);
+        century = readb(ioaddr + RTC_CENTURY) & RTC_CENTURY_MASK;
+        writeb(0, ioaddr + RTC_CONTROL);
+        tm->tm_sec = BCD2BIN(second);
+        tm->tm_min = BCD2BIN(minute);
+        tm->tm_hour = BCD2BIN(hour);
+        tm->tm_mday = BCD2BIN(day);
+        tm->tm_wday = BCD2BIN(week);
+        tm->tm_mon = BCD2BIN(month) - 1;
+        /* year is 1900 + tm->tm_year */
+        tm->tm_year = BCD2BIN(year) + BCD2BIN(century) * 100 - 1900;
+
+        if (rtc_valid_tm(tm) < 0) {
+                dev_err(dev, "retrieved date/time is not valid.\n");
+                rtc_time_to_tm(0, tm);
+        }
+        return 0;
+}
+
+static struct rtc_class_ops ds1742_rtc_ops = {
+        .read_time      = ds1742_rtc_read_time,
+        .set_time       = ds1742_rtc_set_time,
+};
+
+static ssize_t ds1742_nvram_read(struct kobject *kobj, char *buf,
+                                 loff_t pos, size_t size)
+{
+        struct platform_device *pdev =
+                to_platform_device(container_of(kobj, struct device, kobj));
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        ssize_t count;
+
+        for (count = 0; size > 0 && pos < RTC_OFFSET; count++, size--)
+                *buf++ = readb(ioaddr + pos++);
+        return count;
+}
+
+static ssize_t ds1742_nvram_write(struct kobject *kobj, char *buf,
+                                  loff_t pos, size_t size)
+{
+        struct platform_device *pdev =
+                to_platform_device(container_of(kobj, struct device, kobj));
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        ssize_t count;
+
+        for (count = 0; size > 0 && pos < RTC_OFFSET; count++, size--)
+                writeb(*buf++, ioaddr + pos++);
+        return count;
+}
+
+static struct bin_attribute ds1742_nvram_attr = {
+        .attr = {
+                .name = "nvram",
+                .mode = S_IRUGO | S_IWUGO,
+                .owner = THIS_MODULE,
+        },
+        .size = RTC_OFFSET,
+        .read = ds1742_nvram_read,
+        .write = ds1742_nvram_write,
+};
+
+static int __init ds1742_rtc_probe(struct platform_device *pdev)
+{
+        struct rtc_device *rtc;
+        struct resource *res;
+        unsigned int cen, sec;
+        struct rtc_plat_data *pdata = NULL;
+        void __iomem *ioaddr = NULL;
+        int ret = 0;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENODEV;
+        pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return -ENOMEM;
+        if (!request_mem_region(res->start, RTC_REG_SIZE, pdev->name)) {
+                ret = -EBUSY;
+                goto out;
+        }
+        pdata->baseaddr = res->start;
+        ioaddr = ioremap(pdata->baseaddr, RTC_REG_SIZE);
+        if (!ioaddr) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        pdata->ioaddr = ioaddr;
+
+        /* turn RTC on if it was not on */
+        sec = readb(ioaddr + RTC_SECONDS);
+        if (sec & RTC_STOP) {
+                sec &= RTC_SECONDS_MASK;
+                cen = readb(ioaddr + RTC_CENTURY) & RTC_CENTURY_MASK;
+                writeb(RTC_WRITE, ioaddr + RTC_CONTROL);
+                writeb(sec, ioaddr + RTC_SECONDS);
+                writeb(cen & RTC_CENTURY_MASK, ioaddr + RTC_CONTROL);
+        }
+        if (readb(ioaddr + RTC_DAY) & RTC_BATT_FLAG)
+                dev_warn(&pdev->dev, "voltage-low detected.\n");
+
+        rtc = rtc_device_register(pdev->name, &pdev->dev,
+                                  &ds1742_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                ret = PTR_ERR(rtc);
+                goto out;
+        }
+        pdata->rtc = rtc;
+        pdata->last_jiffies = jiffies;
+        platform_set_drvdata(pdev, pdata);
+        sysfs_create_bin_file(&pdev->dev.kobj, &ds1742_nvram_attr);
+        return 0;
+ out:
+        if (ioaddr)
+                iounmap(ioaddr);
+        if (pdata->baseaddr)
+                release_mem_region(pdata->baseaddr, RTC_REG_SIZE);
+        kfree(pdata);
+        return ret;
+}
+
+static int __devexit ds1742_rtc_remove(struct platform_device *pdev)
+{
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        sysfs_remove_bin_file(&pdev->dev.kobj, &ds1742_nvram_attr);
+        rtc_device_unregister(pdata->rtc);
+        iounmap(pdata->ioaddr);
+        release_mem_region(pdata->baseaddr, RTC_REG_SIZE);
+        kfree(pdata);
+        return 0;
+}
+
+static struct platform_driver ds1742_rtc_driver = {
+        .probe          = ds1742_rtc_probe,
+        .remove         = __devexit_p(ds1742_rtc_remove),
+        .driver         = {
+                .name   = "ds1742",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static __init int ds1742_init(void)
+{
+        return platform_driver_register(&ds1742_rtc_driver);
+}
+
+static __exit void ds1742_exit(void)
+{
+        return platform_driver_unregister(&ds1742_rtc_driver);
+}
+
+module_init(ds1742_init);
+module_exit(ds1742_exit);
+
+MODULE_AUTHOR("Atsushi Nemoto <anemo@mba.ocn.ne.jp>");
+MODULE_DESCRIPTION("Dallas DS1742 RTC driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/rtc/rtc-lib.c b/drivers/rtc/rtc-lib.c
index cfedc1d28ee1..9812120f3a7c 100644
--- a/drivers/rtc/rtc-lib.c
+++ b/drivers/rtc/rtc-lib.c
@@ -18,9 +18,19 @@ static const unsigned char rtc_days_in_month[] = {
         31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
 };
 
+static const unsigned short rtc_ydays[2][13] = {
+        /* Normal years */
+        { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
+        /* Leap years */
+        { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
+};
+
 #define LEAPS_THRU_END_OF(y) ((y)/4 - (y)/100 + (y)/400)
 #define LEAP_YEAR(year) ((!(year % 4) && (year % 100)) || !(year % 400))
 
+/*
+ * The number of days in the month.
+ */
 int rtc_month_days(unsigned int month, unsigned int year)
 {
         return rtc_days_in_month[month] + (LEAP_YEAR(year) && month == 1);
@@ -28,6 +38,15 @@ int rtc_month_days(unsigned int month, unsigned int year)
 EXPORT_SYMBOL(rtc_month_days);
 
 /*
+ * The number of days since January 1. (0 to 365)
+ */
+int rtc_year_days(unsigned int day, unsigned int month, unsigned int year)
+{
+        return rtc_ydays[LEAP_YEAR(year)][month] + day-1;
+}
+EXPORT_SYMBOL(rtc_year_days);
+
+/*
  * Convert seconds since 01-01-1970 00:00:00 to Gregorian date.
  */
 void rtc_time_to_tm(unsigned long time, struct rtc_time *tm)
diff --git a/drivers/rtc/rtc-max6902.c b/drivers/rtc/rtc-max6902.c
new file mode 100644
index 000000000000..2c9739562b5c
--- /dev/null
+++ b/drivers/rtc/rtc-max6902.c
@@ -0,0 +1,286 @@
+/* drivers/char/max6902.c
+ *
+ * Copyright (C) 2006 8D Technologies inc.
+ * Copyright (C) 2004 Compulab Ltd.
+ *
+ * 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.
+ *
+ * Driver for MAX6902 spi RTC
+ *
+ * Changelog:
+ *
+ * 24-May-2006: Raphael Assenat <raph@8d.com>
+ *                - Major rework
+ *                              Converted to rtc_device and uses the SPI layer.
+ *
+ * ??-???-2005: Someone at Compulab
+ *                - Initial driver creation.
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/version.h>
+
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/init.h>
+#include <linux/rtc.h>
+#include <linux/spi/spi.h>
+#include <linux/bcd.h>
+#include <linux/delay.h>
+
+#define MAX6902_REG_SECONDS             0x01
+#define MAX6902_REG_MINUTES             0x03
+#define MAX6902_REG_HOURS               0x05
+#define MAX6902_REG_DATE                0x07
+#define MAX6902_REG_MONTH               0x09
+#define MAX6902_REG_DAY                 0x0B
+#define MAX6902_REG_YEAR                0x0D
+#define MAX6902_REG_CONTROL             0x0F
+#define MAX6902_REG_CENTURY             0x13
+
+#undef MAX6902_DEBUG
+
+struct max6902 {
+        struct rtc_device *rtc;
+        u8 buf[9]; /* Burst read cmd + 8 registers */
+        u8 tx_buf[2];
+        u8 rx_buf[2];
+};
+
+static void max6902_set_reg(struct device *dev, unsigned char address,
+                                unsigned char data)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        unsigned char buf[2];
+
+        /* MSB must be '0' to write */
+        buf[0] = address & 0x7f;
+        buf[1] = data;
+
+        spi_write(spi, buf, 2);
+}
+
+static int max6902_get_reg(struct device *dev, unsigned char address,
+                                unsigned char *data)
+{
+        struct spi_device *spi = to_spi_device(dev);
+        struct max6902 *chip = dev_get_drvdata(dev);
+        struct spi_message message;
+        struct spi_transfer xfer;
+        int status;
+
+        if (!data)
+                return -EINVAL;
+
+        /* Build our spi message */
+        spi_message_init(&message);
+        memset(&xfer, 0, sizeof(xfer));
+        xfer.len = 2;
+        /* Can tx_buf and rx_buf be equal? The doc in spi.h is not sure... */
+        xfer.tx_buf = chip->tx_buf;
+        xfer.rx_buf = chip->rx_buf;
+
+        /* Set MSB to indicate read */
+        chip->tx_buf[0] = address | 0x80;
+
+        spi_message_add_tail(&xfer, &message);
+
+        /* do the i/o */
+        status = spi_sync(spi, &message);
+        if (status == 0)
+                status = message.status;
+        else
+                return status;
+
+        *data = chip->rx_buf[1];
+
+        return status;
+}
+
+static int max6902_get_datetime(struct device *dev, struct rtc_time *dt)
+{
+        unsigned char tmp;
+        int century;
+        int err;
+        struct spi_device *spi = to_spi_device(dev);
+        struct max6902 *chip = dev_get_drvdata(dev);
+        struct spi_message message;
+        struct spi_transfer xfer;
+        int status;
+
+        err = max6902_get_reg(dev, MAX6902_REG_CENTURY, &tmp);
+        if (err)
+                return err;
+
+        /* build the message */
+        spi_message_init(&message);
+        memset(&xfer, 0, sizeof(xfer));
+        xfer.len = 1 + 7;       /* Burst read command + 7 registers */
+        xfer.tx_buf = chip->buf;
+        xfer.rx_buf = chip->buf;
+        chip->buf[0] = 0xbf;    /* Burst read */
+        spi_message_add_tail(&xfer, &message);
+
+        /* do the i/o */
+        status = spi_sync(spi, &message);
+        if (status == 0)
+                status = message.status;
+        else
+                return status;
+
+        /* The chip sends data in this order:
+         * Seconds, Minutes, Hours, Date, Month, Day, Year */
+        dt->tm_sec      = BCD2BIN(chip->buf[1]);
+        dt->tm_min      = BCD2BIN(chip->buf[2]);
+        dt->tm_hour     = BCD2BIN(chip->buf[3]);
+        dt->tm_mday     = BCD2BIN(chip->buf[4]);
+        dt->tm_mon      = BCD2BIN(chip->buf[5] - 1);
+        dt->tm_wday     = BCD2BIN(chip->buf[6]);
+        dt->tm_year = BCD2BIN(chip->buf[7]);
+
+        century = BCD2BIN(tmp) * 100;
+
+        dt->tm_year += century;
+        dt->tm_year -= 1900;
+
+#ifdef MAX6902_DEBUG
+        printk("\n%s : Read RTC values\n",__FUNCTION__);
+        printk("tm_hour: %i\n",dt->tm_hour);
+        printk("tm_min : %i\n",dt->tm_min);
+        printk("tm_sec : %i\n",dt->tm_sec);
+        printk("tm_year: %i\n",dt->tm_year);
+        printk("tm_mon : %i\n",dt->tm_mon);
+        printk("tm_mday: %i\n",dt->tm_mday);
+        printk("tm_wday: %i\n",dt->tm_wday);
+#endif
+
+        return 0;
+}
+
+static int max6902_set_datetime(struct device *dev, struct rtc_time *dt)
+{
+        dt->tm_year = dt->tm_year+1900;
+
+#ifdef MAX6902_DEBUG
+        printk("\n%s : Setting RTC values\n",__FUNCTION__);
+        printk("tm_sec : %i\n",dt->tm_sec);
+        printk("tm_min : %i\n",dt->tm_min);
+        printk("tm_hour: %i\n",dt->tm_hour);
+        printk("tm_mday: %i\n",dt->tm_mday);
+        printk("tm_wday: %i\n",dt->tm_wday);
+        printk("tm_year: %i\n",dt->tm_year);
+#endif
+
+        /* Remove write protection */
+        max6902_set_reg(dev, 0xF, 0);
+
+        max6902_set_reg(dev, 0x01, BIN2BCD(dt->tm_sec));
+        max6902_set_reg(dev, 0x03, BIN2BCD(dt->tm_min));
+        max6902_set_reg(dev, 0x05, BIN2BCD(dt->tm_hour));
+
+        max6902_set_reg(dev, 0x07, BIN2BCD(dt->tm_mday));
+        max6902_set_reg(dev, 0x09, BIN2BCD(dt->tm_mon+1));
+        max6902_set_reg(dev, 0x0B, BIN2BCD(dt->tm_wday));
+        max6902_set_reg(dev, 0x0D, BIN2BCD(dt->tm_year%100));
+        max6902_set_reg(dev, 0x13, BIN2BCD(dt->tm_year/100));
+
+        /* Compulab used a delay here. However, the datasheet
+         * does not mention a delay being required anywhere... */
+        /* delay(2000); */
+
+        /* Write protect */
+        max6902_set_reg(dev, 0xF, 0x80);
+
+        return 0;
+}
+
+static int max6902_read_time(struct device *dev, struct rtc_time *tm)
+{
+        return max6902_get_datetime(dev, tm);
+}
+
+static int max6902_set_time(struct device *dev, struct rtc_time *tm)
+{
+        return max6902_set_datetime(dev, tm);
+}
+
+static struct rtc_class_ops max6902_rtc_ops = {
+        .read_time      = max6902_read_time,
+        .set_time       = max6902_set_time,
+};
+
+static int __devinit max6902_probe(struct spi_device *spi)
+{
+        struct rtc_device *rtc;
+        unsigned char tmp;
+        struct max6902 *chip;
+        int res;
+
+        rtc = rtc_device_register("max6902",
+                                &spi->dev, &max6902_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
+
+        spi->mode = SPI_MODE_3;
+        spi->bits_per_word = 8;
+        spi_setup(spi);
+
+        chip = kzalloc(sizeof *chip, GFP_KERNEL);
+        if (!chip) {
+                rtc_device_unregister(rtc);
+                return -ENOMEM;
+        }
+        chip->rtc = rtc;
+        dev_set_drvdata(&spi->dev, chip);
+
+        res = max6902_get_reg(&spi->dev, MAX6902_REG_SECONDS, &tmp);
+        if (res) {
+                rtc_device_unregister(rtc);
+                return res;
+        }
+
+        return 0;
+}
+
+static int __devexit max6902_remove(struct spi_device *spi)
+{
+        struct max6902 *chip = platform_get_drvdata(spi);
+        struct rtc_device *rtc = chip->rtc;
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        kfree(chip);
+
+        return 0;
+}
+
+static struct spi_driver max6902_driver = {
+        .driver = {
+                .name   = "max6902",
+                .bus    = &spi_bus_type,
+                .owner  = THIS_MODULE,
+        },
+        .probe  = max6902_probe,
+        .remove = __devexit_p(max6902_remove),
+};
+
+static __init int max6902_init(void)
+{
+        printk("max6902 spi driver\n");
+        return spi_register_driver(&max6902_driver);
+}
+module_init(max6902_init);
+
+static __exit void max6902_exit(void)
+{
+        spi_unregister_driver(&max6902_driver);
+}
+module_exit(max6902_exit);
+
+MODULE_DESCRIPTION ("max6902 spi RTC driver");
+MODULE_AUTHOR ("Raphael Assenat");
+MODULE_LICENSE ("GPL");
diff --git a/drivers/rtc/rtc-pcf8583.c b/drivers/rtc/rtc-pcf8583.c
new file mode 100644
index 000000000000..b235a30cb661
--- /dev/null
+++ b/drivers/rtc/rtc-pcf8583.c
@@ -0,0 +1,394 @@
+/*
+ *  drivers/rtc/rtc-pcf8583.c
+ *
+ *  Copyright (C) 2000 Russell King
+ *
+ * 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.
+ *
+ *  Driver for PCF8583 RTC & RAM chip
+ *
+ *  Converted to the generic RTC susbsystem by G. Liakhovetski (2006)
+ */
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/mc146818rtc.h>
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/bcd.h>
+
+struct rtc_mem {
+        unsigned int    loc;
+        unsigned int    nr;
+        unsigned char   *data;
+};
+
+struct pcf8583 {
+        struct i2c_client client;
+        struct rtc_device *rtc;
+        unsigned char ctrl;
+};
+
+#define CTRL_STOP       0x80
+#define CTRL_HOLD       0x40
+#define CTRL_32KHZ      0x00
+#define CTRL_MASK       0x08
+#define CTRL_ALARMEN    0x04
+#define CTRL_ALARM      0x02
+#define CTRL_TIMER      0x01
+
+static unsigned short normal_i2c[] = { I2C_CLIENT_END };
+
+/* Module parameters */
+I2C_CLIENT_INSMOD;
+
+static struct i2c_driver pcf8583_driver;
+
+#define get_ctrl(x)    ((struct pcf8583 *)i2c_get_clientdata(x))->ctrl
+#define set_ctrl(x, v) get_ctrl(x) = v
+
+#define CMOS_YEAR       (64 + 128)
+#define CMOS_CHECKSUM   (63)
+
+static int pcf8583_get_datetime(struct i2c_client *client, struct rtc_time *dt)
+{
+        unsigned char buf[8], addr[1] = { 1 };
+        struct i2c_msg msgs[2] = {
+                {
+                        .addr = client->addr,
+                        .flags = 0,
+                        .len = 1,
+                        .buf = addr,
+                }, {
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = 6,
+                        .buf = buf,
+                }
+        };
+        int ret;
+
+        memset(buf, 0, sizeof(buf));
+
+        ret = i2c_transfer(client->adapter, msgs, 2);
+        if (ret == 2) {
+                dt->tm_year = buf[4] >> 6;
+                dt->tm_wday = buf[5] >> 5;
+
+                buf[4] &= 0x3f;
+                buf[5] &= 0x1f;
+
+                dt->tm_sec = BCD_TO_BIN(buf[1]);
+                dt->tm_min = BCD_TO_BIN(buf[2]);
+                dt->tm_hour = BCD_TO_BIN(buf[3]);
+                dt->tm_mday = BCD_TO_BIN(buf[4]);
+                dt->tm_mon = BCD_TO_BIN(buf[5]);
+        }
+
+        return ret == 2 ? 0 : -EIO;
+}
+
+static int pcf8583_set_datetime(struct i2c_client *client, struct rtc_time *dt, int datetoo)
+{
+        unsigned char buf[8];
+        int ret, len = 6;
+
+        buf[0] = 0;
+        buf[1] = get_ctrl(client) | 0x80;
+        buf[2] = 0;
+        buf[3] = BIN_TO_BCD(dt->tm_sec);
+        buf[4] = BIN_TO_BCD(dt->tm_min);
+        buf[5] = BIN_TO_BCD(dt->tm_hour);
+
+        if (datetoo) {
+                len = 8;
+                buf[6] = BIN_TO_BCD(dt->tm_mday) | (dt->tm_year << 6);
+                buf[7] = BIN_TO_BCD(dt->tm_mon)  | (dt->tm_wday << 5);
+        }
+
+        ret = i2c_master_send(client, (char *)buf, len);
+        if (ret != len)
+                return -EIO;
+
+        buf[1] = get_ctrl(client);
+        ret = i2c_master_send(client, (char *)buf, 2);
+
+        return ret == 2 ? 0 : -EIO;
+}
+
+static int pcf8583_get_ctrl(struct i2c_client *client, unsigned char *ctrl)
+{
+        *ctrl = get_ctrl(client);
+        return 0;
+}
+
+static int pcf8583_set_ctrl(struct i2c_client *client, unsigned char *ctrl)
+{
+        unsigned char buf[2];
+
+        buf[0] = 0;
+        buf[1] = *ctrl;
+        set_ctrl(client, *ctrl);
+
+        return i2c_master_send(client, (char *)buf, 2);
+}
+
+static int pcf8583_read_mem(struct i2c_client *client, struct rtc_mem *mem)
+{
+        unsigned char addr[1];
+        struct i2c_msg msgs[2] = {
+                {
+                        .addr = client->addr,
+                        .flags = 0,
+                        .len = 1,
+                        .buf = addr,
+                }, {
+                        .addr = client->addr,
+                        .flags = I2C_M_RD,
+                        .len = mem->nr,
+                        .buf = mem->data,
+                }
+        };
+
+        if (mem->loc < 8)
+                return -EINVAL;
+
+        addr[0] = mem->loc;
+
+        return i2c_transfer(client->adapter, msgs, 2) == 2 ? 0 : -EIO;
+}
+
+static int pcf8583_write_mem(struct i2c_client *client, struct rtc_mem *mem)
+{
+        unsigned char addr[1];
+        struct i2c_msg msgs[2] = {
+                {
+                        .addr = client->addr,
+                        .flags = 0,
+                        .len = 1,
+                        .buf = addr,
+                }, {
+                        .addr = client->addr,
+                        .flags = I2C_M_NOSTART,
+                        .len = mem->nr,
+                        .buf = mem->data,
+                }
+        };
+
+        if (mem->loc < 8)
+                return -EINVAL;
+
+        addr[0] = mem->loc;
+
+        return i2c_transfer(client->adapter, msgs, 2) == 2 ? 0 : -EIO;
+}
+
+static int pcf8583_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        unsigned char ctrl, year[2];
+        struct rtc_mem mem = { CMOS_YEAR, sizeof(year), year };
+        int real_year, year_offset, err;
+
+        /*
+         * Ensure that the RTC is running.
+         */
+        pcf8583_get_ctrl(client, &ctrl);
+        if (ctrl & (CTRL_STOP | CTRL_HOLD)) {
+                unsigned char new_ctrl = ctrl & ~(CTRL_STOP | CTRL_HOLD);
+
+                printk(KERN_WARNING "RTC: resetting control %02x -> %02x\n",
+                       ctrl, new_ctrl);
+
+                if ((err = pcf8583_set_ctrl(client, &new_ctrl)) < 0)
+                        return err;
+        }
+
+        if (pcf8583_get_datetime(client, tm) ||
+            pcf8583_read_mem(client, &mem))
+                return -EIO;
+
+        real_year = year[0];
+
+        /*
+         * The RTC year holds the LSB two bits of the current
+         * year, which should reflect the LSB two bits of the
+         * CMOS copy of the year.  Any difference indicates
+         * that we have to correct the CMOS version.
+         */
+        year_offset = tm->tm_year - (real_year & 3);
+        if (year_offset < 0)
+                /*
+                 * RTC year wrapped.  Adjust it appropriately.
+                 */
+                year_offset += 4;
+
+        tm->tm_year = real_year + year_offset + year[1] * 100;
+
+        return 0;
+}
+
+static int pcf8583_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        unsigned char year[2], chk;
+        struct rtc_mem cmos_year  = { CMOS_YEAR, sizeof(year), year };
+        struct rtc_mem cmos_check = { CMOS_CHECKSUM, 1, &chk };
+        int ret;
+
+        /*
+         * The RTC's own 2-bit year must reflect the least
+         * significant two bits of the CMOS year.
+         */
+
+        ret = pcf8583_set_datetime(client, tm, 1);
+        if (ret)
+                return ret;
+
+        ret = pcf8583_read_mem(client, &cmos_check);
+        if (ret)
+                return ret;
+
+        ret = pcf8583_read_mem(client, &cmos_year);
+        if (ret)
+                return ret;
+
+        chk -= year[1] + year[0];
+
+        year[1] = tm->tm_year / 100;
+        year[0] = tm->tm_year % 100;
+
+        chk += year[1] + year[0];
+
+        ret = pcf8583_write_mem(client, &cmos_year);
+
+        if (ret)
+                return ret;
+
+        ret = pcf8583_write_mem(client, &cmos_check);
+
+        return ret;
+}
+
+static struct rtc_class_ops pcf8583_rtc_ops = {
+        .read_time      = pcf8583_rtc_read_time,
+        .set_time       = pcf8583_rtc_set_time,
+};
+
+static int pcf8583_probe(struct i2c_adapter *adap, int addr, int kind);
+
+static int pcf8583_attach(struct i2c_adapter *adap)
+{
+        return i2c_probe(adap, &addr_data, pcf8583_probe);
+}
+
+static int pcf8583_detach(struct i2c_client *client)
+{
+        int err;
+        struct pcf8583 *pcf = i2c_get_clientdata(client);
+        struct rtc_device *rtc = pcf->rtc;
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        if ((err = i2c_detach_client(client)))
+                return err;
+
+        kfree(pcf);
+        return 0;
+}
+
+static struct i2c_driver pcf8583_driver = {
+        .driver = {
+                .name   = "pcf8583",
+        },
+        .id             = I2C_DRIVERID_PCF8583,
+        .attach_adapter = pcf8583_attach,
+        .detach_client  = pcf8583_detach,
+};
+
+static int pcf8583_probe(struct i2c_adapter *adap, int addr, int kind)
+{
+        struct pcf8583 *pcf;
+        struct i2c_client *client;
+        struct rtc_device *rtc;
+        unsigned char buf[1], ad[1] = { 0 };
+        int err;
+        struct i2c_msg msgs[2] = {
+                {
+                        .addr = addr,
+                        .flags = 0,
+                        .len = 1,
+                        .buf = ad,
+                }, {
+                        .addr = addr,
+                        .flags = I2C_M_RD,
+                        .len = 1,
+                        .buf = buf,
+                }
+        };
+
+        pcf = kzalloc(sizeof(*pcf), GFP_KERNEL);
+        if (!pcf)
+                return -ENOMEM;
+
+        client = &pcf->client;
+
+        client->addr            = addr;
+        client->adapter = adap;
+        client->driver  = &pcf8583_driver;
+
+        strlcpy(client->name, pcf8583_driver.driver.name, I2C_NAME_SIZE);
+
+        if (i2c_transfer(client->adapter, msgs, 2) != 2) {
+                err = -EIO;
+                goto exit_kfree;
+        }
+
+        err = i2c_attach_client(client);
+
+        if (err)
+                goto exit_kfree;
+
+        rtc = rtc_device_register(pcf8583_driver.driver.name, &client->dev,
+                                  &pcf8583_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rtc)) {
+                err = PTR_ERR(rtc);
+                goto exit_detach;
+        }
+
+        pcf->rtc = rtc;
+        i2c_set_clientdata(client, pcf);
+        set_ctrl(client, buf[0]);
+
+        return 0;
+
+exit_detach:
+        i2c_detach_client(client);
+
+exit_kfree:
+        kfree(pcf);
+
+        return err;
+}
+
+static __init int pcf8583_init(void)
+{
+        return i2c_add_driver(&pcf8583_driver);
+}
+
+static __exit void pcf8583_exit(void)
+{
+        i2c_del_driver(&pcf8583_driver);
+}
+
+module_init(pcf8583_init);
+module_exit(pcf8583_exit);
+
+MODULE_AUTHOR("Russell King");
+MODULE_DESCRIPTION("PCF8583 I2C RTC driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-pl031.c b/drivers/rtc/rtc-pl031.c
new file mode 100644
index 000000000000..ee538632660b
--- /dev/null
+++ b/drivers/rtc/rtc-pl031.c
@@ -0,0 +1,233 @@
+/*
+ * drivers/rtc/rtc-pl031.c
+ *
+ * Real Time Clock interface for ARM AMBA PrimeCell 031 RTC
+ *
+ * Author: Deepak Saxena <dsaxena@plexity.net>
+ *
+ * Copyright 2006 (c) 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
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/rtc.h>
+#include <linux/init.h>
+#include <linux/fs.h>
+#include <linux/interrupt.h>
+#include <linux/string.h>
+#include <linux/pm.h>
+
+#include <linux/amba/bus.h>
+
+#include <asm/io.h>
+#include <asm/bitops.h>
+#include <asm/hardware.h>
+#include <asm/irq.h>
+#include <asm/rtc.h>
+
+/*
+ * Register definitions
+ */
+#define RTC_DR          0x00    /* Data read register */
+#define RTC_MR          0x04    /* Match register */
+#define RTC_LR          0x08    /* Data load register */
+#define RTC_CR          0x0c    /* Control register */
+#define RTC_IMSC        0x10    /* Interrupt mask and set register */
+#define RTC_RIS         0x14    /* Raw interrupt status register */
+#define RTC_MIS         0x18    /* Masked interrupt status register */
+#define RTC_ICR         0x1c    /* Interrupt clear register */
+
+struct pl031_local {
+        struct rtc_device *rtc;
+        void __iomem *base;
+};
+
+static irqreturn_t pl031_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+{
+        struct rtc_device *rtc = dev_id;
+
+        rtc_update_irq(&rtc->class_dev, 1, RTC_AF);
+
+        return IRQ_HANDLED;
+}
+
+static int pl031_open(struct device *dev)
+{
+        /*
+         * We request IRQ in pl031_probe, so nothing to do here...
+         */
+        return 0;
+}
+
+static void pl031_release(struct device *dev)
+{
+}
+
+static int pl031_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
+{
+        struct pl031_local *ldata = dev_get_drvdata(dev);
+
+        switch (cmd) {
+        case RTC_AIE_OFF:
+                __raw_writel(1, ldata->base + RTC_MIS);
+                return 0;
+        case RTC_AIE_ON:
+                __raw_writel(0, ldata->base + RTC_MIS);
+                return 0;
+        }
+
+        return -ENOIOCTLCMD;
+}
+
+static int pl031_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct pl031_local *ldata = dev_get_drvdata(dev);
+
+        rtc_time_to_tm(__raw_readl(ldata->base + RTC_DR), tm);
+
+        return 0;
+}
+
+static int pl031_set_time(struct device *dev, struct rtc_time *tm)
+{
+        unsigned long time;
+        struct pl031_local *ldata = dev_get_drvdata(dev);
+
+        rtc_tm_to_time(tm, &time);
+        __raw_writel(time, ldata->base + RTC_LR);
+
+        return 0;
+}
+
+static int pl031_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct pl031_local *ldata = dev_get_drvdata(dev);
+
+        rtc_time_to_tm(__raw_readl(ldata->base + RTC_MR), &alarm->time);
+        alarm->pending = __raw_readl(ldata->base + RTC_RIS);
+        alarm->enabled = __raw_readl(ldata->base + RTC_IMSC);
+
+        return 0;
+}
+
+static int pl031_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct pl031_local *ldata = dev_get_drvdata(dev);
+        unsigned long time;
+
+        rtc_tm_to_time(&alarm->time, &time);
+
+        __raw_writel(time, ldata->base + RTC_MR);
+        __raw_writel(!alarm->enabled, ldata->base + RTC_MIS);
+
+        return 0;
+}
+
+static struct rtc_class_ops pl031_ops = {
+        .open = pl031_open,
+        .release = pl031_release,
+        .ioctl = pl031_ioctl,
+        .read_time = pl031_read_time,
+        .set_time = pl031_set_time,
+        .read_alarm = pl031_read_alarm,
+        .set_alarm = pl031_set_alarm,
+};
+
+static int pl031_remove(struct amba_device *adev)
+{
+        struct pl031_local *ldata = dev_get_drvdata(&adev->dev);
+
+        if (ldata) {
+                dev_set_drvdata(&adev->dev, NULL);
+                free_irq(adev->irq[0], ldata->rtc);
+                rtc_device_unregister(ldata->rtc);
+                iounmap(ldata->base);
+                kfree(ldata);
+        }
+
+        return 0;
+}
+
+static int pl031_probe(struct amba_device *adev, void *id)
+{
+        int ret;
+        struct pl031_local *ldata;
+
+
+        ldata = kmalloc(sizeof(struct pl031_local), GFP_KERNEL);
+        if (!ldata) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        dev_set_drvdata(&adev->dev, ldata);
+
+        ldata->base = ioremap(adev->res.start,
+                              adev->res.end - adev->res.start + 1);
+        if (!ldata->base) {
+                ret = -ENOMEM;
+                goto out_no_remap;
+        }
+
+        if (request_irq(adev->irq[0], pl031_interrupt, SA_INTERRUPT,
+                        "rtc-pl031", ldata->rtc)) {
+                ret = -EIO;
+                goto out_no_irq;
+        }
+
+        ldata->rtc = rtc_device_register("pl031", &adev->dev, &pl031_ops,
+                                         THIS_MODULE);
+        if (IS_ERR(ldata->rtc)) {
+                ret = PTR_ERR(ldata->rtc);
+                goto out_no_rtc;
+        }
+
+        return 0;
+
+out_no_rtc:
+        free_irq(adev->irq[0], ldata->rtc);
+out_no_irq:
+        iounmap(ldata->base);
+out_no_remap:
+        dev_set_drvdata(&adev->dev, NULL);
+        kfree(ldata);
+out:
+        return ret;
+}
+
+static struct amba_id pl031_ids[] __initdata = {
+        {
+                 .id = 0x00041031,
+                .mask = 0x000fffff, },
+        {0, 0},
+};
+
+static struct amba_driver pl031_driver = {
+        .drv = {
+                .name = "rtc-pl031",
+        },
+        .id_table = pl031_ids,
+        .probe = pl031_probe,
+        .remove = pl031_remove,
+};
+
+static int __init pl031_init(void)
+{
+        return amba_driver_register(&pl031_driver);
+}
+
+static void __exit pl031_exit(void)
+{
+        amba_driver_unregister(&pl031_driver);
+}
+
+module_init(pl031_init);
+module_exit(pl031_exit);
+
+MODULE_AUTHOR("Deepak Saxena <dsaxena@plexity.net");
+MODULE_DESCRIPTION("ARM AMBA PL031 RTC Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-sa1100.c b/drivers/rtc/rtc-sa1100.c
index a997529f8926..ab486fbc828d 100644
--- a/drivers/rtc/rtc-sa1100.c
+++ b/drivers/rtc/rtc-sa1100.c
@@ -229,8 +229,6 @@ static int sa1100_rtc_ioctl(struct device *dev, unsigned int cmd,
                 spin_unlock_irq(&sa1100_rtc_lock);
                 return 0;
         case RTC_PIE_ON:
-                if ((rtc_freq > 64) && !capable(CAP_SYS_RESOURCE))
-                        return -EACCES;
                 spin_lock_irq(&sa1100_rtc_lock);
                 OSMR1 = TIMER_FREQ/rtc_freq + OSCR;
                 OIER |= OIER_E1;
@@ -242,8 +240,6 @@ static int sa1100_rtc_ioctl(struct device *dev, unsigned int cmd,
         case RTC_IRQP_SET:
                 if (arg < 1 || arg > TIMER_FREQ)
                         return -EINVAL;
-                if ((arg > 64) && (!capable(CAP_SYS_RESOURCE)))
-                        return -EACCES;
                 rtc_freq = arg;
                 return 0;
         }
diff --git a/drivers/rtc/rtc-v3020.c b/drivers/rtc/rtc-v3020.c
new file mode 100644
index 000000000000..a40f400acff6
--- /dev/null
+++ b/drivers/rtc/rtc-v3020.c
@@ -0,0 +1,264 @@
+/* drivers/rtc/rtc-v3020.c
+ *
+ * Copyright (C) 2006 8D Technologies inc.
+ * Copyright (C) 2004 Compulab Ltd.
+ *
+ * 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.
+ *
+ * Driver for the V3020 RTC
+ *
+ * Changelog:
+ *
+ *  10-May-2006: Raphael Assenat <raph@8d.com>
+ *                              - Converted to platform driver
+ *                              - Use the generic rtc class
+ *
+ *  ??-???-2004: Someone at Compulab
+ *                      - Initial driver creation.
+ *
+ */
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/rtc.h>
+#include <linux/types.h>
+#include <linux/bcd.h>
+#include <linux/rtc-v3020.h>
+
+#include <asm/io.h>
+
+#undef DEBUG
+
+struct v3020 {
+        void __iomem *ioaddress;
+        int leftshift;
+        struct rtc_device *rtc;
+};
+
+static void v3020_set_reg(struct v3020 *chip, unsigned char address,
+                        unsigned char data)
+{
+        int i;
+        unsigned char tmp;
+
+        tmp = address;
+        for (i = 0; i < 4; i++) {
+                writel((tmp & 1) << chip->leftshift, chip->ioaddress);
+                tmp >>= 1;
+        }
+
+        /* Commands dont have data */
+        if (!V3020_IS_COMMAND(address)) {
+                for (i = 0; i < 8; i++) {
+                        writel((data & 1) << chip->leftshift, chip->ioaddress);
+                        data >>= 1;
+                }
+        }
+}
+
+static unsigned char v3020_get_reg(struct v3020 *chip, unsigned char address)
+{
+        unsigned int data=0;
+        int i;
+
+        for (i = 0; i < 4; i++) {
+                writel((address & 1) << chip->leftshift, chip->ioaddress);
+                address >>= 1;
+        }
+
+        for (i = 0; i < 8; i++) {
+                data >>= 1;
+                if (readl(chip->ioaddress) & (1 << chip->leftshift))
+                        data |= 0x80;
+        }
+
+        return data;
+}
+
+static int v3020_read_time(struct device *dev, struct rtc_time *dt)
+{
+        struct v3020 *chip = dev_get_drvdata(dev);
+        int tmp;
+
+        /* Copy the current time to ram... */
+        v3020_set_reg(chip, V3020_CMD_CLOCK2RAM, 0);
+
+        /* ...and then read constant values. */
+        tmp = v3020_get_reg(chip, V3020_SECONDS);
+        dt->tm_sec      = BCD2BIN(tmp);
+        tmp = v3020_get_reg(chip, V3020_MINUTES);
+        dt->tm_min      = BCD2BIN(tmp);
+        tmp = v3020_get_reg(chip, V3020_HOURS);
+        dt->tm_hour     = BCD2BIN(tmp);
+        tmp = v3020_get_reg(chip, V3020_MONTH_DAY);
+        dt->tm_mday     = BCD2BIN(tmp);
+        tmp = v3020_get_reg(chip, V3020_MONTH);
+        dt->tm_mon      = BCD2BIN(tmp);
+        tmp = v3020_get_reg(chip, V3020_WEEK_DAY);
+        dt->tm_wday     = BCD2BIN(tmp);
+        tmp = v3020_get_reg(chip, V3020_YEAR);
+        dt->tm_year = BCD2BIN(tmp)+100;
+
+#ifdef DEBUG
+        printk("\n%s : Read RTC values\n",__FUNCTION__);
+        printk("tm_hour: %i\n",dt->tm_hour);
+        printk("tm_min : %i\n",dt->tm_min);
+        printk("tm_sec : %i\n",dt->tm_sec);
+        printk("tm_year: %i\n",dt->tm_year);
+        printk("tm_mon : %i\n",dt->tm_mon);
+        printk("tm_mday: %i\n",dt->tm_mday);
+        printk("tm_wday: %i\n",dt->tm_wday);
+#endif
+
+        return 0;
+}
+
+
+static int v3020_set_time(struct device *dev, struct rtc_time *dt)
+{
+        struct v3020 *chip = dev_get_drvdata(dev);
+
+#ifdef DEBUG
+        printk("\n%s : Setting RTC values\n",__FUNCTION__);
+        printk("tm_sec : %i\n",dt->tm_sec);
+        printk("tm_min : %i\n",dt->tm_min);
+        printk("tm_hour: %i\n",dt->tm_hour);
+        printk("tm_mday: %i\n",dt->tm_mday);
+        printk("tm_wday: %i\n",dt->tm_wday);
+        printk("tm_year: %i\n",dt->tm_year);
+#endif
+
+        /* Write all the values to ram... */
+        v3020_set_reg(chip, V3020_SECONDS,      BIN2BCD(dt->tm_sec));
+        v3020_set_reg(chip, V3020_MINUTES,      BIN2BCD(dt->tm_min));
+        v3020_set_reg(chip, V3020_HOURS,        BIN2BCD(dt->tm_hour));
+        v3020_set_reg(chip, V3020_MONTH_DAY,    BIN2BCD(dt->tm_mday));
+        v3020_set_reg(chip, V3020_MONTH,        BIN2BCD(dt->tm_mon));
+        v3020_set_reg(chip, V3020_WEEK_DAY,     BIN2BCD(dt->tm_wday));
+        v3020_set_reg(chip, V3020_YEAR,         BIN2BCD(dt->tm_year % 100));
+
+        /* ...and set the clock. */
+        v3020_set_reg(chip, V3020_CMD_RAM2CLOCK, 0);
+
+        /* Compulab used this delay here. I dont know why,
+         * the datasheet does not specify a delay. */
+        /*mdelay(5);*/
+
+        return 0;
+}
+
+static struct rtc_class_ops v3020_rtc_ops = {
+        .read_time      = v3020_read_time,
+        .set_time       = v3020_set_time,
+};
+
+static int rtc_probe(struct platform_device *pdev)
+{
+        struct v3020_platform_data *pdata = pdev->dev.platform_data;
+        struct v3020 *chip;
+        struct rtc_device *rtc;
+        int retval = -EBUSY;
+        int i;
+        int temp;
+
+        if (pdev->num_resources != 1)
+                return -EBUSY;
+
+        if (pdev->resource[0].flags != IORESOURCE_MEM)
+                return -EBUSY;
+
+        if (pdev == NULL)
+                return -EBUSY;
+
+        chip = kzalloc(sizeof *chip, GFP_KERNEL);
+        if (!chip)
+                return -ENOMEM;
+
+        chip->leftshift = pdata->leftshift;
+        chip->ioaddress = ioremap(pdev->resource[0].start, 1);
+        if (chip->ioaddress == NULL)
+                goto err_chip;
+
+        /* Make sure the v3020 expects a communication cycle
+         * by reading 8 times */
+        for (i = 0; i < 8; i++)
+                temp = readl(chip->ioaddress);
+
+        /* Test chip by doing a write/read sequence
+         * to the chip ram */
+        v3020_set_reg(chip, V3020_SECONDS, 0x33);
+        if(v3020_get_reg(chip, V3020_SECONDS) != 0x33) {
+                retval = -ENODEV;
+                goto err_io;
+        }
+
+        /* Make sure frequency measurment mode, test modes, and lock
+         * are all disabled */
+        v3020_set_reg(chip, V3020_STATUS_0, 0x0);
+
+        dev_info(&pdev->dev, "Chip available at physical address 0x%p,"
+                "data connected to D%d\n",
+                (void*)pdev->resource[0].start,
+                chip->leftshift);
+
+        platform_set_drvdata(pdev, chip);
+
+        rtc = rtc_device_register("v3020",
+                                &pdev->dev, &v3020_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                retval = PTR_ERR(rtc);
+                goto err_io;
+        }
+        chip->rtc = rtc;
+
+        return 0;
+
+err_io:
+        iounmap(chip->ioaddress);
+err_chip:
+        kfree(chip);
+
+        return retval;
+}
+
+static int rtc_remove(struct platform_device *dev)
+{
+        struct v3020 *chip = platform_get_drvdata(dev);
+        struct rtc_device *rtc = chip->rtc;
+
+        if (rtc)
+                rtc_device_unregister(rtc);
+
+        iounmap(chip->ioaddress);
+        kfree(chip);
+
+        return 0;
+}
+
+static struct platform_driver rtc_device_driver = {
+        .probe  = rtc_probe,
+        .remove = rtc_remove,
+        .driver = {
+                .name   = "v3020",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static __init int v3020_init(void)
+{
+        return platform_driver_register(&rtc_device_driver);
+}
+
+static __exit void v3020_exit(void)
+{
+        platform_driver_unregister(&rtc_device_driver);
+}
+
+module_init(v3020_init);
+module_exit(v3020_exit);
+
+MODULE_DESCRIPTION("V3020 RTC");
+MODULE_AUTHOR("Raphael Assenat");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-vr41xx.c b/drivers/rtc/rtc-vr41xx.c
index 277596c302e3..33e029207e26 100644
--- a/drivers/rtc/rtc-vr41xx.c
+++ b/drivers/rtc/rtc-vr41xx.c
@@ -81,7 +81,6 @@ MODULE_LICENSE("GPL");
 
 #define RTC_FREQUENCY           32768
 #define MAX_PERIODIC_RATE       6553
-#define MAX_USER_PERIODIC_RATE  64
 
 static void __iomem *rtc1_base;
 static void __iomem *rtc2_base;
@@ -240,9 +239,6 @@ static int vr41xx_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long
                 if (arg > MAX_PERIODIC_RATE)
                         return -EINVAL;
 
-                if (arg > MAX_USER_PERIODIC_RATE && capable(CAP_SYS_RESOURCE) == 0)
-                        return -EACCES;
-
                 periodic_frequency = arg;
 
                 count = RTC_FREQUENCY;
@@ -263,10 +259,6 @@ static int vr41xx_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long
                 /* Doesn't support before 1900 */
                 if (arg < 1900)
                         return -EINVAL;
-
-                if (capable(CAP_SYS_TIME) == 0)
-                        return -EACCES;
-
                 epoch = arg;
                 break;
         default:
diff --git a/drivers/s390/char/sclp_quiesce.c b/drivers/s390/char/sclp_quiesce.c
index 56fa69168898..a4c53c172db6 100644
--- a/drivers/s390/char/sclp_quiesce.c
+++ b/drivers/s390/char/sclp_quiesce.c
@@ -13,6 +13,7 @@
 #include <linux/cpumask.h>
 #include <linux/smp.h>
 #include <linux/init.h>
+#include <linux/reboot.h>
 #include <asm/atomic.h>
 #include <asm/ptrace.h>
 #include <asm/sigp.h>
@@ -66,8 +67,6 @@ do_machine_quiesce(void)
 }
 #endif
 
-extern void ctrl_alt_del(void);
-
 /* Handler for quiesce event. Start shutdown procedure. */
 static void
 sclp_quiesce_handler(struct evbuf_header *evbuf)
diff --git a/drivers/sbus/char/flash.c b/drivers/sbus/char/flash.c
index 5ae684c011f8..31b8a5f6116f 100644
--- a/drivers/sbus/char/flash.c
+++ b/drivers/sbus/char/flash.c
@@ -71,7 +71,6 @@ flash_mmap(struct file *file, struct vm_area_struct *vma)
         if (vma->vm_end - (vma->vm_start + (vma->vm_pgoff << PAGE_SHIFT)) > size)
                 size = vma->vm_end - (vma->vm_start + (vma->vm_pgoff << PAGE_SHIFT));
 
-        vma->vm_flags |= (VM_SHM | VM_LOCKED);
         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 
         if (io_remap_pfn_range(vma, vma->vm_start, addr, size, vma->vm_page_prot))
diff --git a/drivers/sbus/char/vfc_dev.c b/drivers/sbus/char/vfc_dev.c
index dfdd6be551f3..ddcd330b9e89 100644
--- a/drivers/sbus/char/vfc_dev.c
+++ b/drivers/sbus/char/vfc_dev.c
@@ -623,7 +623,7 @@ static int vfc_mmap(struct file *file, struct vm_area_struct *vma)
                 map_size = sizeof(struct vfc_regs);
 
         vma->vm_flags |=
-                (VM_SHM | VM_LOCKED | VM_IO | VM_MAYREAD | VM_MAYWRITE | VM_MAYSHARE);
+                (VM_MAYREAD | VM_MAYWRITE | VM_MAYSHARE);
         map_offset = (unsigned int) (long)dev->phys_regs;
         ret = io_remap_pfn_range(vma, vma->vm_start,
                                   MK_IOSPACE_PFN(dev->which_io,
diff --git a/drivers/scsi/advansys.c b/drivers/scsi/advansys.c
index 2a419634b256..5ee47555a8af 100644
--- a/drivers/scsi/advansys.c
+++ b/drivers/scsi/advansys.c
@@ -17316,7 +17316,7 @@ AdvWaitEEPCmd(AdvPortAddr iop_base)
 /*
  * Write the EEPROM from 'cfg_buf'.
  */
-void
+void __init
 AdvSet3550EEPConfig(AdvPortAddr iop_base, ADVEEP_3550_CONFIG *cfg_buf)
 {
     ushort *wbuf;
@@ -17383,7 +17383,7 @@ AdvSet3550EEPConfig(AdvPortAddr iop_base, ADVEEP_3550_CONFIG *cfg_buf)
 /*
  * Write the EEPROM from 'cfg_buf'.
  */
-void
+void __init
 AdvSet38C0800EEPConfig(AdvPortAddr iop_base,
                        ADVEEP_38C0800_CONFIG *cfg_buf)
 {
@@ -17451,7 +17451,7 @@ AdvSet38C0800EEPConfig(AdvPortAddr iop_base,
 /*
  * Write the EEPROM from 'cfg_buf'.
  */
-void
+void __init
 AdvSet38C1600EEPConfig(AdvPortAddr iop_base,
                        ADVEEP_38C1600_CONFIG *cfg_buf)
 {
diff --git a/drivers/scsi/mac_esp.c b/drivers/scsi/mac_esp.c
index e31fadd61904..118206d68c6c 100644
--- a/drivers/scsi/mac_esp.c
+++ b/drivers/scsi/mac_esp.c
@@ -43,9 +43,6 @@
 
 /* #define DEBUG_MAC_ESP */
 
-#define mac_turnon_irq(x)       mac_enable_irq(x)
-#define mac_turnoff_irq(x)      mac_disable_irq(x)
-
 extern void esp_handle(struct NCR_ESP *esp);
 extern void mac_esp_intr(int irq, void *dev_id, struct pt_regs *pregs);
 
@@ -639,13 +636,13 @@ static void dma_init_write(struct NCR_ESP * esp, char * vaddress, int length)
 
 static void dma_ints_off(struct NCR_ESP * esp)
 {
-        mac_turnoff_irq(esp->irq);
+        disable_irq(esp->irq);
 }
 
 
 static void dma_ints_on(struct NCR_ESP * esp)
 {
-        mac_turnon_irq(esp->irq);
+        enable_irq(esp->irq);
 }
 
 /*
diff --git a/drivers/scsi/mac_scsi.c b/drivers/scsi/mac_scsi.c
index 777f9bcd1179..a942a21dd87e 100644
--- a/drivers/scsi/mac_scsi.c
+++ b/drivers/scsi/mac_scsi.c
@@ -65,9 +65,6 @@
 #define RESET_BOOT
 #define DRIVER_SETUP
 
-#define ENABLE_IRQ()    mac_enable_irq( IRQ_MAC_SCSI ); 
-#define DISABLE_IRQ()   mac_disable_irq( IRQ_MAC_SCSI );
-
 extern void via_scsi_clear(void);
 
 #ifdef RESET_BOOT
@@ -351,7 +348,7 @@ static void mac_scsi_reset_boot(struct Scsi_Host *instance)
         printk(KERN_INFO "Macintosh SCSI: resetting the SCSI bus..." );
 
         /* switch off SCSI IRQ - catch an interrupt without IRQ bit set else */
-        mac_disable_irq(IRQ_MAC_SCSI);
+        disable_irq(IRQ_MAC_SCSI);
 
         /* get in phase */
         NCR5380_write( TARGET_COMMAND_REG,
@@ -369,7 +366,7 @@ static void mac_scsi_reset_boot(struct Scsi_Host *instance)
                 barrier();
 
         /* switch on SCSI IRQ again */
-        mac_enable_irq(IRQ_MAC_SCSI);
+        enable_irq(IRQ_MAC_SCSI);
 
         printk(KERN_INFO " done\n" );
 }
diff --git a/drivers/scsi/megaraid/megaraid_mbox.c b/drivers/scsi/megaraid/megaraid_mbox.c
index bec1424eda85..b7caf60638e8 100644
--- a/drivers/scsi/megaraid/megaraid_mbox.c
+++ b/drivers/scsi/megaraid/megaraid_mbox.c
@@ -714,7 +714,7 @@ megaraid_io_detach(adapter_t *adapter)
  * . Allocate memory required for all the commands
  * . Use internal library of FW routines, build up complete soft state
  */
-static int __init
+static int __devinit
 megaraid_init_mbox(adapter_t *adapter)
 {
         struct pci_dev          *pdev;
diff --git a/drivers/scsi/sun3x_esp.c b/drivers/scsi/sun3x_esp.c
index cc990bed9683..2e2c1eb15636 100644
--- a/drivers/scsi/sun3x_esp.c
+++ b/drivers/scsi/sun3x_esp.c
@@ -332,11 +332,11 @@ static void dma_mmu_get_scsi_sgl (struct NCR_ESP *esp, Scsi_Cmnd *sp)
     struct scatterlist *sg = sp->SCp.buffer;
 
     while (sz >= 0) {
-            sg[sz].dvma_address = dvma_map((unsigned long)page_address(sg[sz].page) +
+            sg[sz].dma_address = dvma_map((unsigned long)page_address(sg[sz].page) +
                                            sg[sz].offset, sg[sz].length);
             sz--;
     }
-    sp->SCp.ptr=(char *)((unsigned long)sp->SCp.buffer->dvma_address);
+    sp->SCp.ptr=(char *)((unsigned long)sp->SCp.buffer->dma_address);
 }
 
 static void dma_mmu_release_scsi_one (struct NCR_ESP *esp, Scsi_Cmnd *sp)
@@ -350,14 +350,14 @@ static void dma_mmu_release_scsi_sgl (struct NCR_ESP *esp, Scsi_Cmnd *sp)
     struct scatterlist *sg = (struct scatterlist *)sp->buffer;
                         
     while(sz >= 0) {
-        dvma_unmap((char *)sg[sz].dvma_address);
+        dvma_unmap((char *)sg[sz].dma_address);
         sz--;
     }
 }
 
 static void dma_advance_sg (Scsi_Cmnd *sp)
 {
-    sp->SCp.ptr = (char *)((unsigned long)sp->SCp.buffer->dvma_address);
+    sp->SCp.ptr = (char *)((unsigned long)sp->SCp.buffer->dma_address);
 }
 
 static int sun3x_esp_release(struct Scsi_Host *instance)
diff --git a/drivers/scsi/wd7000.c b/drivers/scsi/wd7000.c
index e55f0ee7e7e4..574955b78a24 100644
--- a/drivers/scsi/wd7000.c
+++ b/drivers/scsi/wd7000.c
@@ -1391,7 +1391,7 @@ static int wd7000_proc_info(struct Scsi_Host *host, char *buffer, char **start,
  *
  */
 
-static int wd7000_detect(struct scsi_host_template *tpnt)
+static __init int wd7000_detect(struct scsi_host_template *tpnt)
 {
         short present = 0, biosaddr_ptr, sig_ptr, i, pass;
         short biosptr[NUM_CONFIGS];
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index 5a2840aeb547..168ede7902bd 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -86,6 +86,11 @@ config FB_FIRMWARE_EDID
          combination with certain motherboards and monitors are known to
          suffer from this problem.
 
+config FB_BACKLIGHT
+       bool
+       depends on FB
+       default n
+
 config FB_MODE_HELPERS
         bool "Enable Video Mode Handling Helpers"
         depends on FB
@@ -717,6 +722,16 @@ config FB_NVIDIA_I2C
           independently validate video mode parameters, you should say Y
           here.
 
+config FB_NVIDIA_BACKLIGHT
+        bool "Support for backlight control"
+        depends on FB_NVIDIA && PPC_PMAC
+        select FB_BACKLIGHT
+        select BACKLIGHT_LCD_SUPPORT
+        select BACKLIGHT_CLASS_DEVICE
+        default y
+        help
+          Say Y here if you want to control the backlight of your display.
+
 config FB_RIVA
         tristate "nVidia Riva support"
         depends on FB && PCI
@@ -755,6 +770,16 @@ config FB_RIVA_DEBUG
           of debugging informations to provide to the maintainer when
           something goes wrong.
 
+config FB_RIVA_BACKLIGHT
+        bool "Support for backlight control"
+        depends on FB_RIVA && PPC_PMAC
+        select FB_BACKLIGHT
+        select BACKLIGHT_LCD_SUPPORT
+        select BACKLIGHT_CLASS_DEVICE
+        default y
+        help
+          Say Y here if you want to control the backlight of your display.
+
 config FB_I810
         tristate "Intel 810/815 support (EXPERIMENTAL)"
         depends on FB && EXPERIMENTAL && PCI && X86_32
@@ -993,6 +1018,7 @@ config FB_RADEON
 
           There is a product page at
           http://apps.ati.com/ATIcompare/
+
 config FB_RADEON_I2C
         bool "DDC/I2C for ATI Radeon support"
         depends on FB_RADEON
@@ -1000,6 +1026,16 @@ config FB_RADEON_I2C
         help
           Say Y here if you want DDC/I2C support for your Radeon board. 
 
+config FB_RADEON_BACKLIGHT
+        bool "Support for backlight control"
+        depends on FB_RADEON && PPC_PMAC
+        select FB_BACKLIGHT
+        select BACKLIGHT_LCD_SUPPORT
+        select BACKLIGHT_CLASS_DEVICE
+        default y
+        help
+          Say Y here if you want to control the backlight of your display.
+
 config FB_RADEON_DEBUG
         bool "Lots of debug output from Radeon driver"
         depends on FB_RADEON
@@ -1024,6 +1060,16 @@ config FB_ATY128
           To compile this driver as a module, choose M here: the
           module will be called aty128fb.
 
+config FB_ATY128_BACKLIGHT
+        bool "Support for backlight control"
+        depends on FB_ATY128 && PPC_PMAC
+        select FB_BACKLIGHT
+        select BACKLIGHT_LCD_SUPPORT
+        select BACKLIGHT_CLASS_DEVICE
+        default y
+        help
+          Say Y here if you want to control the backlight of your display.
+
 config FB_ATY
         tristate "ATI Mach64 display support" if PCI || ATARI
         depends on FB && !SPARC32
@@ -1066,6 +1112,16 @@ config FB_ATY_GX
           is at
           <http://support.ati.com/products/pc/mach64/graphics_xpression.html>.
 
+config FB_ATY_BACKLIGHT
+        bool "Support for backlight control"
+        depends on FB_ATY && PPC_PMAC
+        select FB_BACKLIGHT
+        select BACKLIGHT_LCD_SUPPORT
+        select BACKLIGHT_CLASS_DEVICE
+        default y
+        help
+          Say Y here if you want to control the backlight of your display.
+
 config FB_S3TRIO
         bool "S3 Trio display support"
         depends on (FB = y) && PPC && BROKEN
diff --git a/drivers/video/aty/Makefile b/drivers/video/aty/Makefile
index 18521397a6e3..a6cc0e9ec790 100644
--- a/drivers/video/aty/Makefile
+++ b/drivers/video/aty/Makefile
@@ -10,5 +10,6 @@ atyfb-objs			:= $(atyfb-y)
 
 radeonfb-y                      := radeon_base.o radeon_pm.o radeon_monitor.o radeon_accel.o
 radeonfb-$(CONFIG_FB_RADEON_I2C)        += radeon_i2c.o
+radeonfb-$(CONFIG_FB_RADEON_BACKLIGHT)  += radeon_backlight.o
 radeonfb-objs                   := $(radeonfb-y)
 
diff --git a/drivers/video/aty/aty128fb.c b/drivers/video/aty/aty128fb.c
index f7bbff4ddc6a..db878fd55fb2 100644
--- a/drivers/video/aty/aty128fb.c
+++ b/drivers/video/aty/aty128fb.c
@@ -64,6 +64,7 @@
 #include <linux/pci.h>
 #include <linux/ioport.h>
 #include <linux/console.h>
+#include <linux/backlight.h>
 #include <asm/io.h>
 
 #ifdef CONFIG_PPC_PMAC
@@ -480,16 +481,6 @@ static struct fb_ops aty128fb_ops = {
         .fb_imageblit   = cfb_imageblit,
 };
 
-#ifdef CONFIG_PMAC_BACKLIGHT
-static int aty128_set_backlight_enable(int on, int level, void* data);
-static int aty128_set_backlight_level(int level, void* data);
-
-static struct backlight_controller aty128_backlight_controller = {
-        aty128_set_backlight_enable,
-        aty128_set_backlight_level
-};
-#endif /* CONFIG_PMAC_BACKLIGHT */
-
     /*
      * Functions to read from/write to the mmio registers
      *  - endian conversions may possibly be avoided by
@@ -1258,19 +1249,35 @@ static void aty128_set_crt_enable(struct aty128fb_par *par, int on)
 static void aty128_set_lcd_enable(struct aty128fb_par *par, int on)
 {
         u32 reg;
+#ifdef CONFIG_FB_ATY128_BACKLIGHT
+        struct fb_info *info = pci_get_drvdata(par->pdev);
+#endif
 
         if (on) {
                 reg = aty_ld_le32(LVDS_GEN_CNTL);
                 reg |= LVDS_ON | LVDS_EN | LVDS_BLON | LVDS_DIGION;
                 reg &= ~LVDS_DISPLAY_DIS;
                 aty_st_le32(LVDS_GEN_CNTL, reg);
-#ifdef CONFIG_PMAC_BACKLIGHT
-                aty128_set_backlight_enable(get_backlight_enable(),
-                                            get_backlight_level(), par);
+#ifdef CONFIG_FB_ATY128_BACKLIGHT
+                mutex_lock(&info->bl_mutex);
+                if (info->bl_dev) {
+                        down(&info->bl_dev->sem);
+                        info->bl_dev->props->update_status(info->bl_dev);
+                        up(&info->bl_dev->sem);
+                }
+                mutex_unlock(&info->bl_mutex);
 #endif  
         } else {
-#ifdef CONFIG_PMAC_BACKLIGHT
-                aty128_set_backlight_enable(0, 0, par);
+#ifdef CONFIG_FB_ATY128_BACKLIGHT
+                mutex_lock(&info->bl_mutex);
+                if (info->bl_dev) {
+                        down(&info->bl_dev->sem);
+                        info->bl_dev->props->brightness = 0;
+                        info->bl_dev->props->power = FB_BLANK_POWERDOWN;
+                        info->bl_dev->props->update_status(info->bl_dev);
+                        up(&info->bl_dev->sem);
+                }
+                mutex_unlock(&info->bl_mutex);
 #endif  
                 reg = aty_ld_le32(LVDS_GEN_CNTL);
                 reg |= LVDS_DISPLAY_DIS;
@@ -1691,6 +1698,184 @@ static int __init aty128fb_setup(char *options)
 }
 #endif  /*  MODULE  */
 
+/* Backlight */
+#ifdef CONFIG_FB_ATY128_BACKLIGHT
+#define MAX_LEVEL 0xFF
+
+static struct backlight_properties aty128_bl_data;
+
+static int aty128_bl_get_level_brightness(struct aty128fb_par *par,
+                int level)
+{
+        struct fb_info *info = pci_get_drvdata(par->pdev);
+        int atylevel;
+
+        /* Get and convert the value */
+        mutex_lock(&info->bl_mutex);
+        atylevel = MAX_LEVEL -
+                (info->bl_curve[level] * FB_BACKLIGHT_MAX / MAX_LEVEL);
+        mutex_unlock(&info->bl_mutex);
+
+        if (atylevel < 0)
+                atylevel = 0;
+        else if (atylevel > MAX_LEVEL)
+                atylevel = MAX_LEVEL;
+
+        return atylevel;
+}
+
+/* We turn off the LCD completely instead of just dimming the backlight.
+ * This provides greater power saving and the display is useless without
+ * backlight anyway
+ */
+#define BACKLIGHT_LVDS_OFF
+/* That one prevents proper CRT output with LCD off */
+#undef BACKLIGHT_DAC_OFF
+
+static int aty128_bl_update_status(struct backlight_device *bd)
+{
+        struct aty128fb_par *par = class_get_devdata(&bd->class_dev);
+        unsigned int reg = aty_ld_le32(LVDS_GEN_CNTL);
+        int level;
+
+        if (bd->props->power != FB_BLANK_UNBLANK ||
+            bd->props->fb_blank != FB_BLANK_UNBLANK ||
+            !par->lcd_on)
+                level = 0;
+        else
+                level = bd->props->brightness;
+
+        reg |= LVDS_BL_MOD_EN | LVDS_BLON;
+        if (level > 0) {
+                reg |= LVDS_DIGION;
+                if (!(reg & LVDS_ON)) {
+                        reg &= ~LVDS_BLON;
+                        aty_st_le32(LVDS_GEN_CNTL, reg);
+                        aty_ld_le32(LVDS_GEN_CNTL);
+                        mdelay(10);
+                        reg |= LVDS_BLON;
+                        aty_st_le32(LVDS_GEN_CNTL, reg);
+                }
+                reg &= ~LVDS_BL_MOD_LEVEL_MASK;
+                reg |= (aty128_bl_get_level_brightness(par, level) << LVDS_BL_MOD_LEVEL_SHIFT);
+#ifdef BACKLIGHT_LVDS_OFF
+                reg |= LVDS_ON | LVDS_EN;
+                reg &= ~LVDS_DISPLAY_DIS;
+#endif
+                aty_st_le32(LVDS_GEN_CNTL, reg);
+#ifdef BACKLIGHT_DAC_OFF
+                aty_st_le32(DAC_CNTL, aty_ld_le32(DAC_CNTL) & (~DAC_PDWN));
+#endif
+        } else {
+                reg &= ~LVDS_BL_MOD_LEVEL_MASK;
+                reg |= (aty128_bl_get_level_brightness(par, 0) << LVDS_BL_MOD_LEVEL_SHIFT);
+#ifdef BACKLIGHT_LVDS_OFF
+                reg |= LVDS_DISPLAY_DIS;
+                aty_st_le32(LVDS_GEN_CNTL, reg);
+                aty_ld_le32(LVDS_GEN_CNTL);
+                udelay(10);
+                reg &= ~(LVDS_ON | LVDS_EN | LVDS_BLON | LVDS_DIGION);
+#endif
+                aty_st_le32(LVDS_GEN_CNTL, reg);
+#ifdef BACKLIGHT_DAC_OFF
+                aty_st_le32(DAC_CNTL, aty_ld_le32(DAC_CNTL) | DAC_PDWN);
+#endif
+        }
+
+        return 0;
+}
+
+static int aty128_bl_get_brightness(struct backlight_device *bd)
+{
+        return bd->props->brightness;
+}
+
+static struct backlight_properties aty128_bl_data = {
+        .owner          = THIS_MODULE,
+        .get_brightness = aty128_bl_get_brightness,
+        .update_status  = aty128_bl_update_status,
+        .max_brightness = (FB_BACKLIGHT_LEVELS - 1),
+};
+
+static void aty128_bl_init(struct aty128fb_par *par)
+{
+        struct fb_info *info = pci_get_drvdata(par->pdev);
+        struct backlight_device *bd;
+        char name[12];
+
+        /* Could be extended to Rage128Pro LVDS output too */
+        if (par->chip_gen != rage_M3)
+                return;
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        if (!pmac_has_backlight_type("ati"))
+                return;
+#endif
+
+        snprintf(name, sizeof(name), "aty128bl%d", info->node);
+
+        bd = backlight_device_register(name, par, &aty128_bl_data);
+        if (IS_ERR(bd)) {
+                info->bl_dev = NULL;
+                printk("aty128: Backlight registration failed\n");
+                goto error;
+        }
+
+        mutex_lock(&info->bl_mutex);
+        info->bl_dev = bd;
+        fb_bl_default_curve(info, 0,
+                 63 * FB_BACKLIGHT_MAX / MAX_LEVEL,
+                219 * FB_BACKLIGHT_MAX / MAX_LEVEL);
+        mutex_unlock(&info->bl_mutex);
+
+        up(&bd->sem);
+        bd->props->brightness = aty128_bl_data.max_brightness;
+        bd->props->power = FB_BLANK_UNBLANK;
+        bd->props->update_status(bd);
+        down(&bd->sem);
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        mutex_lock(&pmac_backlight_mutex);
+        if (!pmac_backlight)
+                pmac_backlight = bd;
+        mutex_unlock(&pmac_backlight_mutex);
+#endif
+
+        printk("aty128: Backlight initialized (%s)\n", name);
+
+        return;
+
+error:
+        return;
+}
+
+static void aty128_bl_exit(struct aty128fb_par *par)
+{
+        struct fb_info *info = pci_get_drvdata(par->pdev);
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        mutex_lock(&pmac_backlight_mutex);
+#endif
+
+        mutex_lock(&info->bl_mutex);
+        if (info->bl_dev) {
+#ifdef CONFIG_PMAC_BACKLIGHT
+                if (pmac_backlight == info->bl_dev)
+                        pmac_backlight = NULL;
+#endif
+
+                backlight_device_unregister(info->bl_dev);
+                info->bl_dev = NULL;
+
+                printk("aty128: Backlight unloaded\n");
+        }
+        mutex_unlock(&info->bl_mutex);
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        mutex_unlock(&pmac_backlight_mutex);
+#endif
+}
+#endif /* CONFIG_FB_ATY128_BACKLIGHT */
 
 /*
  *  Initialisation
@@ -1835,17 +2020,15 @@ static int __init aty128_init(struct pci_dev *pdev, const struct pci_device_id *
         if (register_framebuffer(info) < 0)
                 return 0;
 
-#ifdef CONFIG_PMAC_BACKLIGHT
-        /* Could be extended to Rage128Pro LVDS output too */
-        if (par->chip_gen == rage_M3)
-                register_backlight_controller(&aty128_backlight_controller, par, "ati");
-#endif /* CONFIG_PMAC_BACKLIGHT */
-
         par->pm_reg = pci_find_capability(pdev, PCI_CAP_ID_PM);
         par->pdev = pdev;
         par->asleep = 0;
         par->lock_blank = 0;
-        
+
+#ifdef CONFIG_FB_ATY128_BACKLIGHT
+        aty128_bl_init(par);
+#endif
+
         printk(KERN_INFO "fb%d: %s frame buffer device on %s\n",
                info->node, info->fix.id, video_card);
 
@@ -1981,6 +2164,10 @@ static void __devexit aty128_remove(struct pci_dev *pdev)
 
         par = info->par;
 
+#ifdef CONFIG_FB_ATY128_BACKLIGHT
+        aty128_bl_exit(par);
+#endif
+
         unregister_framebuffer(info);
 #ifdef CONFIG_MTRR
         if (par->mtrr.vram_valid)
@@ -2011,10 +2198,14 @@ static int aty128fb_blank(int blank, struct fb_info *fb)
         if (par->lock_blank || par->asleep)
                 return 0;
 
-#ifdef CONFIG_PMAC_BACKLIGHT
-        if (machine_is(powermac) && blank)
-                set_backlight_enable(0);
-#endif /* CONFIG_PMAC_BACKLIGHT */
+#ifdef CONFIG_FB_ATY128_BACKLIGHT
+        if (machine_is(powermac) && blank) {
+                down(&fb->bl_dev->sem);
+                fb->bl_dev->props->power = FB_BLANK_POWERDOWN;
+                fb->bl_dev->props->update_status(fb->bl_dev);
+                up(&fb->bl_dev->sem);
+        }
+#endif
 
         if (blank & FB_BLANK_VSYNC_SUSPEND)
                 state |= 2;
@@ -2029,10 +2220,14 @@ static int aty128fb_blank(int blank, struct fb_info *fb)
                 aty128_set_crt_enable(par, par->crt_on && !blank);
                 aty128_set_lcd_enable(par, par->lcd_on && !blank);
         }
-#ifdef CONFIG_PMAC_BACKLIGHT
-        if (machine_is(powermac) && !blank)
-                set_backlight_enable(1);
-#endif /* CONFIG_PMAC_BACKLIGHT */
+#ifdef CONFIG_FB_ATY128_BACKLIGHT
+        if (machine_is(powermac) && !blank) {
+                down(&fb->bl_dev->sem);
+                fb->bl_dev->props->power = FB_BLANK_UNBLANK;
+                fb->bl_dev->props->update_status(fb->bl_dev);
+                up(&fb->bl_dev->sem);
+        }
+#endif
         return 0;
 }
 
@@ -2138,73 +2333,6 @@ static int aty128fb_ioctl(struct fb_info *info, u_int cmd, u_long arg)
         return -EINVAL;
 }
 
-#ifdef CONFIG_PMAC_BACKLIGHT
-static int backlight_conv[] = {
-        0xff, 0xc0, 0xb5, 0xaa, 0x9f, 0x94, 0x89, 0x7e,
-        0x73, 0x68, 0x5d, 0x52, 0x47, 0x3c, 0x31, 0x24
-};
-
-/* We turn off the LCD completely instead of just dimming the backlight.
- * This provides greater power saving and the display is useless without
- * backlight anyway
- */
-#define BACKLIGHT_LVDS_OFF
-/* That one prevents proper CRT output with LCD off */
-#undef BACKLIGHT_DAC_OFF
-
-static int aty128_set_backlight_enable(int on, int level, void *data)
-{
-        struct aty128fb_par *par = data;
-        unsigned int reg = aty_ld_le32(LVDS_GEN_CNTL);
-
-        if (!par->lcd_on)
-                on = 0;
-        reg |= LVDS_BL_MOD_EN | LVDS_BLON;
-        if (on && level > BACKLIGHT_OFF) {
-                reg |= LVDS_DIGION;
-                if (!(reg & LVDS_ON)) {
-                        reg &= ~LVDS_BLON;
-                        aty_st_le32(LVDS_GEN_CNTL, reg);
-                        (void)aty_ld_le32(LVDS_GEN_CNTL);
-                        mdelay(10);
-                        reg |= LVDS_BLON;
-                        aty_st_le32(LVDS_GEN_CNTL, reg);
-                }
-                reg &= ~LVDS_BL_MOD_LEVEL_MASK;
-                reg |= (backlight_conv[level] << LVDS_BL_MOD_LEVEL_SHIFT);
-#ifdef BACKLIGHT_LVDS_OFF
-                reg |= LVDS_ON | LVDS_EN;
-                reg &= ~LVDS_DISPLAY_DIS;
-#endif
-                aty_st_le32(LVDS_GEN_CNTL, reg);
-#ifdef BACKLIGHT_DAC_OFF
-                aty_st_le32(DAC_CNTL, aty_ld_le32(DAC_CNTL) & (~DAC_PDWN));
-#endif          
-        } else {
-                reg &= ~LVDS_BL_MOD_LEVEL_MASK;
-                reg |= (backlight_conv[0] << LVDS_BL_MOD_LEVEL_SHIFT);
-#ifdef BACKLIGHT_LVDS_OFF
-                reg |= LVDS_DISPLAY_DIS;
-                aty_st_le32(LVDS_GEN_CNTL, reg);
-                (void)aty_ld_le32(LVDS_GEN_CNTL);
-                udelay(10);
-                reg &= ~(LVDS_ON | LVDS_EN | LVDS_BLON | LVDS_DIGION);
-#endif          
-                aty_st_le32(LVDS_GEN_CNTL, reg);
-#ifdef BACKLIGHT_DAC_OFF
-                aty_st_le32(DAC_CNTL, aty_ld_le32(DAC_CNTL) | DAC_PDWN);
-#endif          
-        }
-
-        return 0;
-}
-
-static int aty128_set_backlight_level(int level, void* data)
-{
-        return aty128_set_backlight_enable(1, level, data);
-}
-#endif /* CONFIG_PMAC_BACKLIGHT */
-
 #if 0
     /*
      *  Accelerated functions
diff --git a/drivers/video/aty/atyfb.h b/drivers/video/aty/atyfb.h
index e9b7a64c1ac4..43d2cb58af87 100644
--- a/drivers/video/aty/atyfb.h
+++ b/drivers/video/aty/atyfb.h
@@ -151,6 +151,7 @@ struct atyfb_par {
         int lock_blank;
         unsigned long res_start;
         unsigned long res_size;
+        struct pci_dev *pdev;
 #ifdef __sparc__
         struct pci_mmap_map *mmap_map;
         u8 mmaped;
diff --git a/drivers/video/aty/atyfb_base.c b/drivers/video/aty/atyfb_base.c
index c054bb28b1c4..c5185f7cf4ba 100644
--- a/drivers/video/aty/atyfb_base.c
+++ b/drivers/video/aty/atyfb_base.c
@@ -66,6 +66,7 @@
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
 #include <linux/wait.h>
+#include <linux/backlight.h>
 
 #include <asm/io.h>
 #include <asm/uaccess.h>
@@ -2115,45 +2116,142 @@ static int atyfb_pci_resume(struct pci_dev *pdev)
 
 #endif /*  defined(CONFIG_PM) && defined(CONFIG_PCI) */
 
-#ifdef CONFIG_PMAC_BACKLIGHT
+/* Backlight */
+#ifdef CONFIG_FB_ATY_BACKLIGHT
+#define MAX_LEVEL 0xFF
 
-    /*
-     *   LCD backlight control
-     */
+static struct backlight_properties aty_bl_data;
 
-static int backlight_conv[] = {
-        0x00, 0x3f, 0x4c, 0x59, 0x66, 0x73, 0x80, 0x8d,
-        0x9a, 0xa7, 0xb4, 0xc1, 0xcf, 0xdc, 0xe9, 0xff
-};
+static int aty_bl_get_level_brightness(struct atyfb_par *par, int level)
+{
+        struct fb_info *info = pci_get_drvdata(par->pdev);
+        int atylevel;
+
+        /* Get and convert the value */
+        mutex_lock(&info->bl_mutex);
+        atylevel = info->bl_curve[level] * FB_BACKLIGHT_MAX / MAX_LEVEL;
+        mutex_unlock(&info->bl_mutex);
+
+        if (atylevel < 0)
+                atylevel = 0;
+        else if (atylevel > MAX_LEVEL)
+                atylevel = MAX_LEVEL;
 
-static int aty_set_backlight_enable(int on, int level, void *data)
+        return atylevel;
+}
+
+static int aty_bl_update_status(struct backlight_device *bd)
 {
-        struct fb_info *info = (struct fb_info *) data;
-        struct atyfb_par *par = (struct atyfb_par *) info->par;
+        struct atyfb_par *par = class_get_devdata(&bd->class_dev);
         unsigned int reg = aty_ld_lcd(LCD_MISC_CNTL, par);
+        int level;
+
+        if (bd->props->power != FB_BLANK_UNBLANK ||
+            bd->props->fb_blank != FB_BLANK_UNBLANK)
+                level = 0;
+        else
+                level = bd->props->brightness;
 
         reg |= (BLMOD_EN | BIASMOD_EN);
-        if (on && level > BACKLIGHT_OFF) {
+        if (level > 0) {
                 reg &= ~BIAS_MOD_LEVEL_MASK;
-                reg |= (backlight_conv[level] << BIAS_MOD_LEVEL_SHIFT);
+                reg |= (aty_bl_get_level_brightness(par, level) << BIAS_MOD_LEVEL_SHIFT);
         } else {
                 reg &= ~BIAS_MOD_LEVEL_MASK;
-                reg |= (backlight_conv[0] << BIAS_MOD_LEVEL_SHIFT);
+                reg |= (aty_bl_get_level_brightness(par, 0) << BIAS_MOD_LEVEL_SHIFT);
         }
         aty_st_lcd(LCD_MISC_CNTL, reg, par);
+
         return 0;
 }
 
-static int aty_set_backlight_level(int level, void *data)
+static int aty_bl_get_brightness(struct backlight_device *bd)
 {
-        return aty_set_backlight_enable(1, level, data);
+        return bd->props->brightness;
 }
 
-static struct backlight_controller aty_backlight_controller = {
-        aty_set_backlight_enable,
-        aty_set_backlight_level
+static struct backlight_properties aty_bl_data = {
+        .owner    = THIS_MODULE,
+        .get_brightness = aty_bl_get_brightness,
+        .update_status  = aty_bl_update_status,
+        .max_brightness = (FB_BACKLIGHT_LEVELS - 1),
 };
-#endif /* CONFIG_PMAC_BACKLIGHT */
+
+static void aty_bl_init(struct atyfb_par *par)
+{
+        struct fb_info *info = pci_get_drvdata(par->pdev);
+        struct backlight_device *bd;
+        char name[12];
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        if (!pmac_has_backlight_type("ati"))
+                return;
+#endif
+
+        snprintf(name, sizeof(name), "atybl%d", info->node);
+
+        bd = backlight_device_register(name, par, &aty_bl_data);
+        if (IS_ERR(bd)) {
+                info->bl_dev = NULL;
+                printk("aty: Backlight registration failed\n");
+                goto error;
+        }
+
+        mutex_lock(&info->bl_mutex);
+        info->bl_dev = bd;
+        fb_bl_default_curve(info, 0,
+                0x3F * FB_BACKLIGHT_MAX / MAX_LEVEL,
+                0xFF * FB_BACKLIGHT_MAX / MAX_LEVEL);
+        mutex_unlock(&info->bl_mutex);
+
+        up(&bd->sem);
+        bd->props->brightness = aty_bl_data.max_brightness;
+        bd->props->power = FB_BLANK_UNBLANK;
+        bd->props->update_status(bd);
+        down(&bd->sem);
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        mutex_lock(&pmac_backlight_mutex);
+        if (!pmac_backlight)
+                pmac_backlight = bd;
+        mutex_unlock(&pmac_backlight_mutex);
+#endif
+
+        printk("aty: Backlight initialized (%s)\n", name);
+
+        return;
+
+error:
+        return;
+}
+
+static void aty_bl_exit(struct atyfb_par *par)
+{
+        struct fb_info *info = pci_get_drvdata(par->pdev);
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        mutex_lock(&pmac_backlight_mutex);
+#endif
+
+        mutex_lock(&info->bl_mutex);
+        if (info->bl_dev) {
+#ifdef CONFIG_PMAC_BACKLIGHT
+                if (pmac_backlight == info->bl_dev)
+                        pmac_backlight = NULL;
+#endif
+
+                backlight_device_unregister(info->bl_dev);
+
+                printk("aty: Backlight unloaded\n");
+        }
+        mutex_unlock(&info->bl_mutex);
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        mutex_unlock(&pmac_backlight_mutex);
+#endif
+}
+
+#endif /* CONFIG_FB_ATY_BACKLIGHT */
 
 static void __init aty_calc_mem_refresh(struct atyfb_par *par, int xclk)
 {
@@ -2513,9 +2611,13 @@ static int __init aty_init(struct fb_info *info, const char *name)
                 /* these bits let the 101 powerbook wake up from sleep -- paulus */
                 aty_st_lcd(POWER_MANAGEMENT, aty_ld_lcd(POWER_MANAGEMENT, par)
                            | (USE_F32KHZ | TRISTATE_MEM_EN), par);
-        } else if (M64_HAS(MOBIL_BUS))
-                register_backlight_controller(&aty_backlight_controller, info, "ati");
-#endif /* CONFIG_PMAC_BACKLIGHT */
+        } else
+#endif
+        if (M64_HAS(MOBIL_BUS)) {
+#ifdef CONFIG_FB_ATY_BACKLIGHT
+                aty_bl_init (par);
+#endif
+        }
 
         memset(&var, 0, sizeof(var));
 #ifdef CONFIG_PPC
@@ -2674,8 +2776,16 @@ static int atyfb_blank(int blank, struct fb_info *info)
                 return 0;
 
 #ifdef CONFIG_PMAC_BACKLIGHT
-        if (machine_is(powermac) && blank > FB_BLANK_NORMAL)
-                set_backlight_enable(0);
+        if (machine_is(powermac) && blank > FB_BLANK_NORMAL) {
+                mutex_lock(&info->bl_mutex);
+                if (info->bl_dev) {
+                        down(&info->bl_dev->sem);
+                        info->bl_dev->props->power = FB_BLANK_POWERDOWN;
+                        info->bl_dev->props->update_status(info->bl_dev);
+                        up(&info->bl_dev->sem);
+                }
+                mutex_unlock(&info->bl_mutex);
+        }
 #elif defined(CONFIG_FB_ATY_GENERIC_LCD)
         if (par->lcd_table && blank > FB_BLANK_NORMAL &&
             (aty_ld_lcd(LCD_GEN_CNTL, par) & LCD_ON)) {
@@ -2706,8 +2816,16 @@ static int atyfb_blank(int blank, struct fb_info *info)
         aty_st_le32(CRTC_GEN_CNTL, gen_cntl, par);
 
 #ifdef CONFIG_PMAC_BACKLIGHT
-        if (machine_is(powermac) && blank <= FB_BLANK_NORMAL)
-                set_backlight_enable(1);
+        if (machine_is(powermac) && blank <= FB_BLANK_NORMAL) {
+                mutex_lock(&info->bl_mutex);
+                if (info->bl_dev) {
+                        down(&info->bl_dev->sem);
+                        info->bl_dev->props->power = FB_BLANK_UNBLANK;
+                        info->bl_dev->props->update_status(info->bl_dev);
+                        up(&info->bl_dev->sem);
+                }
+                mutex_unlock(&info->bl_mutex);
+        }
 #elif defined(CONFIG_FB_ATY_GENERIC_LCD)
         if (par->lcd_table && blank <= FB_BLANK_NORMAL &&
             (aty_ld_lcd(LCD_GEN_CNTL, par) & LCD_ON)) {
@@ -3440,6 +3558,7 @@ static int __devinit atyfb_pci_probe(struct pci_dev *pdev, const struct pci_devi
         par->res_start = res_start;
         par->res_size = res_size;
         par->irq = pdev->irq;
+        par->pdev = pdev;
 
         /* Setup "info" structure */
 #ifdef __sparc__
@@ -3571,6 +3690,11 @@ static void __devexit atyfb_remove(struct fb_info *info)
         aty_set_crtc(par, &saved_crtc);
         par->pll_ops->set_pll(info, &saved_pll);
 
+#ifdef CONFIG_FB_ATY_BACKLIGHT
+        if (M64_HAS(MOBIL_BUS))
+                aty_bl_exit(par);
+#endif
+
         unregister_framebuffer(info);
 
 #ifdef CONFIG_MTRR
diff --git a/drivers/video/aty/radeon_backlight.c b/drivers/video/aty/radeon_backlight.c
new file mode 100644
index 000000000000..7de66b855d4e
--- /dev/null
+++ b/drivers/video/aty/radeon_backlight.c
@@ -0,0 +1,247 @@
+/*
+ * Backlight code for ATI Radeon based graphic cards
+ *
+ * Copyright (c) 2000 Ani Joshi <ajoshi@kernel.crashing.org>
+ * Copyright (c) 2003 Benjamin Herrenschmidt <benh@kernel.crashing.org>
+ * Copyright (c) 2006 Michael Hanselmann <linux-kernel@hansmi.ch>
+ *
+ * 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 "radeonfb.h"
+#include <linux/backlight.h>
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+#include <asm/backlight.h>
+#endif
+
+#define MAX_RADEON_LEVEL 0xFF
+
+static struct backlight_properties radeon_bl_data;
+
+struct radeon_bl_privdata {
+        struct radeonfb_info *rinfo;
+        uint8_t negative;
+};
+
+static int radeon_bl_get_level_brightness(struct radeon_bl_privdata *pdata,
+                int level)
+{
+        struct fb_info *info = pdata->rinfo->info;
+        int rlevel;
+
+        mutex_lock(&info->bl_mutex);
+
+        /* Get and convert the value */
+        rlevel = pdata->rinfo->info->bl_curve[level] *
+                 FB_BACKLIGHT_MAX / MAX_RADEON_LEVEL;
+
+        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;
+
+        return rlevel;
+}
+
+static int radeon_bl_update_status(struct backlight_device *bd)
+{
+        struct radeon_bl_privdata *pdata = class_get_devdata(&bd->class_dev);
+        struct radeonfb_info *rinfo = pdata->rinfo;
+        u32 lvds_gen_cntl, tmpPixclksCntl;
+        int level;
+
+        if (rinfo->mon1_type != MT_LCD)
+                return 0;
+
+        /* We turn off the LCD completely instead of just dimming the
+         * backlight. This provides some greater power saving and the display
+         * is useless without backlight anyway.
+         */
+        if (bd->props->power != FB_BLANK_UNBLANK ||
+            bd->props->fb_blank != FB_BLANK_UNBLANK)
+                level = 0;
+        else
+                level = bd->props->brightness;
+
+        del_timer_sync(&rinfo->lvds_timer);
+        radeon_engine_idle();
+
+        lvds_gen_cntl = INREG(LVDS_GEN_CNTL);
+        if (level > 0) {
+                lvds_gen_cntl &= ~LVDS_DISPLAY_DIS;
+                if (!(lvds_gen_cntl & LVDS_BLON) || !(lvds_gen_cntl & LVDS_ON)) {
+                        lvds_gen_cntl |= (rinfo->init_state.lvds_gen_cntl & LVDS_DIGON);
+                        lvds_gen_cntl |= LVDS_BLON | LVDS_EN;
+                        OUTREG(LVDS_GEN_CNTL, lvds_gen_cntl);
+                        lvds_gen_cntl &= ~LVDS_BL_MOD_LEVEL_MASK;
+                        lvds_gen_cntl |=
+                                (radeon_bl_get_level_brightness(pdata, level) <<
+                                 LVDS_BL_MOD_LEVEL_SHIFT);
+                        lvds_gen_cntl |= LVDS_ON;
+                        lvds_gen_cntl |= (rinfo->init_state.lvds_gen_cntl & LVDS_BL_MOD_EN);
+                        rinfo->pending_lvds_gen_cntl = lvds_gen_cntl;
+                        mod_timer(&rinfo->lvds_timer,
+                                  jiffies + msecs_to_jiffies(rinfo->panel_info.pwr_delay));
+                } else {
+                        lvds_gen_cntl &= ~LVDS_BL_MOD_LEVEL_MASK;
+                        lvds_gen_cntl |=
+                                (radeon_bl_get_level_brightness(pdata, level) <<
+                                 LVDS_BL_MOD_LEVEL_SHIFT);
+                        OUTREG(LVDS_GEN_CNTL, lvds_gen_cntl);
+                }
+                rinfo->init_state.lvds_gen_cntl &= ~LVDS_STATE_MASK;
+                rinfo->init_state.lvds_gen_cntl |= rinfo->pending_lvds_gen_cntl
+                        & LVDS_STATE_MASK;
+        } else {
+                /* Asic bug, when turning off LVDS_ON, we have to make sure
+                   RADEON_PIXCLK_LVDS_ALWAYS_ON bit is off
+                */
+                tmpPixclksCntl = INPLL(PIXCLKS_CNTL);
+                if (rinfo->is_mobility || rinfo->is_IGP)
+                        OUTPLLP(PIXCLKS_CNTL, 0, ~PIXCLK_LVDS_ALWAYS_ONb);
+                lvds_gen_cntl &= ~(LVDS_BL_MOD_LEVEL_MASK | LVDS_BL_MOD_EN);
+                lvds_gen_cntl |= (radeon_bl_get_level_brightness(pdata, 0) <<
+                                  LVDS_BL_MOD_LEVEL_SHIFT);
+                lvds_gen_cntl |= LVDS_DISPLAY_DIS;
+                OUTREG(LVDS_GEN_CNTL, lvds_gen_cntl);
+                udelay(100);
+                lvds_gen_cntl &= ~(LVDS_ON | LVDS_EN);
+                OUTREG(LVDS_GEN_CNTL, lvds_gen_cntl);
+                lvds_gen_cntl &= ~(LVDS_DIGON);
+                rinfo->pending_lvds_gen_cntl = lvds_gen_cntl;
+                mod_timer(&rinfo->lvds_timer,
+                          jiffies + msecs_to_jiffies(rinfo->panel_info.pwr_delay));
+                if (rinfo->is_mobility || rinfo->is_IGP)
+                        OUTPLL(PIXCLKS_CNTL, tmpPixclksCntl);
+        }
+        rinfo->init_state.lvds_gen_cntl &= ~LVDS_STATE_MASK;
+        rinfo->init_state.lvds_gen_cntl |= (lvds_gen_cntl & LVDS_STATE_MASK);
+
+        return 0;
+}
+
+static int radeon_bl_get_brightness(struct backlight_device *bd)
+{
+        return bd->props->brightness;
+}
+
+static struct backlight_properties radeon_bl_data = {
+        .owner          = THIS_MODULE,
+        .get_brightness = radeon_bl_get_brightness,
+        .update_status  = radeon_bl_update_status,
+        .max_brightness = (FB_BACKLIGHT_LEVELS - 1),
+};
+
+void radeonfb_bl_init(struct radeonfb_info *rinfo)
+{
+        struct backlight_device *bd;
+        struct radeon_bl_privdata *pdata;
+        char name[12];
+
+        if (rinfo->mon1_type != MT_LCD)
+                return;
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        if (!pmac_has_backlight_type("ati") &&
+            !pmac_has_backlight_type("mnca"))
+                return;
+#endif
+
+        pdata = kmalloc(sizeof(struct radeon_bl_privdata), GFP_KERNEL);
+        if (!pdata) {
+                printk("radeonfb: Memory allocation failed\n");
+                goto error;
+        }
+
+        snprintf(name, sizeof(name), "radeonbl%d", rinfo->info->node);
+
+        bd = backlight_device_register(name, pdata, &radeon_bl_data);
+        if (IS_ERR(bd)) {
+                rinfo->info->bl_dev = NULL;
+                printk("radeonfb: Backlight registration failed\n");
+                goto error;
+        }
+
+        pdata->rinfo = rinfo;
+
+        /* Pardon me for that hack... maybe some day we can figure out in what
+         * direction backlight should work on a given panel?
+         */
+        pdata->negative =
+                (rinfo->family != CHIP_FAMILY_RV200 &&
+                 rinfo->family != CHIP_FAMILY_RV250 &&
+                 rinfo->family != CHIP_FAMILY_RV280 &&
+                 rinfo->family != CHIP_FAMILY_RV350);
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        pdata->negative = pdata->negative ||
+                machine_is_compatible("PowerBook4,3") ||
+                machine_is_compatible("PowerBook6,3") ||
+                machine_is_compatible("PowerBook6,5");
+#endif
+
+        mutex_lock(&rinfo->info->bl_mutex);
+        rinfo->info->bl_dev = bd;
+        fb_bl_default_curve(rinfo->info, 0,
+                 63 * FB_BACKLIGHT_MAX / MAX_RADEON_LEVEL,
+                217 * FB_BACKLIGHT_MAX / MAX_RADEON_LEVEL);
+        mutex_unlock(&rinfo->info->bl_mutex);
+
+        up(&bd->sem);
+        bd->props->brightness = radeon_bl_data.max_brightness;
+        bd->props->power = FB_BLANK_UNBLANK;
+        bd->props->update_status(bd);
+        down(&bd->sem);
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        mutex_lock(&pmac_backlight_mutex);
+        if (!pmac_backlight)
+                pmac_backlight = bd;
+        mutex_unlock(&pmac_backlight_mutex);
+#endif
+
+        printk("radeonfb: Backlight initialized (%s)\n", name);
+
+        return;
+
+error:
+        kfree(pdata);
+        return;
+}
+
+void radeonfb_bl_exit(struct radeonfb_info *rinfo)
+{
+#ifdef CONFIG_PMAC_BACKLIGHT
+        mutex_lock(&pmac_backlight_mutex);
+#endif
+
+        mutex_lock(&rinfo->info->bl_mutex);
+        if (rinfo->info->bl_dev) {
+                struct radeon_bl_privdata *pdata;
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+                if (pmac_backlight == rinfo->info->bl_dev)
+                        pmac_backlight = NULL;
+#endif
+
+                pdata = class_get_devdata(&rinfo->info->bl_dev->class_dev);
+                backlight_device_unregister(rinfo->info->bl_dev);
+                kfree(pdata);
+                rinfo->info->bl_dev = NULL;
+
+                printk("radeonfb: Backlight unloaded\n");
+        }
+        mutex_unlock(&rinfo->info->bl_mutex);
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        mutex_unlock(&pmac_backlight_mutex);
+#endif
+}
diff --git a/drivers/video/aty/radeon_base.c b/drivers/video/aty/radeon_base.c
index 387a18a47ac2..c5ecbb02e01d 100644
--- a/drivers/video/aty/radeon_base.c
+++ b/drivers/video/aty/radeon_base.c
@@ -78,10 +78,6 @@
 #include <asm/pci-bridge.h>
 #include "../macmodes.h"
 
-#ifdef CONFIG_PMAC_BACKLIGHT
-#include <asm/backlight.h>
-#endif
-
 #ifdef CONFIG_BOOTX_TEXT
 #include <asm/btext.h>
 #endif
@@ -277,20 +273,6 @@ static int nomtrr = 0;
  * prototypes
  */
 
-
-#ifdef CONFIG_PPC_OF
-
-#ifdef CONFIG_PMAC_BACKLIGHT
-static int radeon_set_backlight_enable(int on, int level, void *data);
-static int radeon_set_backlight_level(int level, void *data);
-static struct backlight_controller radeon_backlight_controller = {
-        radeon_set_backlight_enable,
-        radeon_set_backlight_level
-};
-#endif /* CONFIG_PMAC_BACKLIGHT */
-
-#endif /* CONFIG_PPC_OF */
-
 static void radeon_unmap_ROM(struct radeonfb_info *rinfo, struct pci_dev *dev)
 {
         if (!rinfo->bios_seg)
@@ -1913,116 +1895,6 @@ static int __devinit radeon_set_fbinfo (struct radeonfb_info *rinfo)
         return 0;
 }
 
-
-#ifdef CONFIG_PMAC_BACKLIGHT
-
-/* TODO: Dbl check these tables, we don't go up to full ON backlight
- * in these, possibly because we noticed MacOS doesn't, but I'd prefer
- * having some more official numbers from ATI
- */
-static int backlight_conv_m6[] = {
-        0xff, 0xc0, 0xb5, 0xaa, 0x9f, 0x94, 0x89, 0x7e,
-        0x73, 0x68, 0x5d, 0x52, 0x47, 0x3c, 0x31, 0x24
-};
-static int backlight_conv_m7[] = {
-        0x00, 0x3f, 0x4a, 0x55, 0x60, 0x6b, 0x76, 0x81,
-        0x8c, 0x97, 0xa2, 0xad, 0xb8, 0xc3, 0xce, 0xd9
-};
-
-#define BACKLIGHT_LVDS_OFF
-#undef BACKLIGHT_DAC_OFF
-
-/* We turn off the LCD completely instead of just dimming the backlight.
- * This provides some greater power saving and the display is useless
- * without backlight anyway.
- */
-static int radeon_set_backlight_enable(int on, int level, void *data)
-{
-        struct radeonfb_info *rinfo = (struct radeonfb_info *)data;
-        u32 lvds_gen_cntl, tmpPixclksCntl;
-        int* conv_table;
-
-        if (rinfo->mon1_type != MT_LCD)
-                return 0;
-
-        /* Pardon me for that hack... maybe some day we can figure
-         * out in what direction backlight should work on a given
-         * panel ?
-         */
-        if ((rinfo->family == CHIP_FAMILY_RV200 ||
-             rinfo->family == CHIP_FAMILY_RV250 ||
-             rinfo->family == CHIP_FAMILY_RV280 ||
-             rinfo->family == CHIP_FAMILY_RV350) &&
-            !machine_is_compatible("PowerBook4,3") &&
-            !machine_is_compatible("PowerBook6,3") &&
-            !machine_is_compatible("PowerBook6,5"))
-                conv_table = backlight_conv_m7;
-        else
-                conv_table = backlight_conv_m6;
-
-        del_timer_sync(&rinfo->lvds_timer);
-        radeon_engine_idle();
-
-        lvds_gen_cntl = INREG(LVDS_GEN_CNTL);
-        if (on && (level > BACKLIGHT_OFF)) {
-                lvds_gen_cntl &= ~LVDS_DISPLAY_DIS;
-                if (!(lvds_gen_cntl & LVDS_BLON) || !(lvds_gen_cntl & LVDS_ON)) {
-                        lvds_gen_cntl |= (rinfo->init_state.lvds_gen_cntl & LVDS_DIGON);
-                        lvds_gen_cntl |= LVDS_BLON | LVDS_EN;
-                        OUTREG(LVDS_GEN_CNTL, lvds_gen_cntl);
-                        lvds_gen_cntl &= ~LVDS_BL_MOD_LEVEL_MASK;
-                        lvds_gen_cntl |= (conv_table[level] <<
-                                          LVDS_BL_MOD_LEVEL_SHIFT);
-                        lvds_gen_cntl |= LVDS_ON;
-                        lvds_gen_cntl |= (rinfo->init_state.lvds_gen_cntl & LVDS_BL_MOD_EN);
-                        rinfo->pending_lvds_gen_cntl = lvds_gen_cntl;
-                        mod_timer(&rinfo->lvds_timer,
-                                  jiffies + msecs_to_jiffies(rinfo->panel_info.pwr_delay));
-                } else {
-                        lvds_gen_cntl &= ~LVDS_BL_MOD_LEVEL_MASK;
-                        lvds_gen_cntl |= (conv_table[level] <<
-                                          LVDS_BL_MOD_LEVEL_SHIFT);
-                        OUTREG(LVDS_GEN_CNTL, lvds_gen_cntl);
-                }
-                rinfo->init_state.lvds_gen_cntl &= ~LVDS_STATE_MASK;
-                rinfo->init_state.lvds_gen_cntl |= rinfo->pending_lvds_gen_cntl
-                        & LVDS_STATE_MASK;
-        } else {
-                /* Asic bug, when turning off LVDS_ON, we have to make sure
-                   RADEON_PIXCLK_LVDS_ALWAYS_ON bit is off
-                */
-                tmpPixclksCntl = INPLL(PIXCLKS_CNTL);
-                if (rinfo->is_mobility || rinfo->is_IGP)
-                        OUTPLLP(PIXCLKS_CNTL, 0, ~PIXCLK_LVDS_ALWAYS_ONb);
-                lvds_gen_cntl &= ~(LVDS_BL_MOD_LEVEL_MASK | LVDS_BL_MOD_EN);
-                lvds_gen_cntl |= (conv_table[0] <<
-                                  LVDS_BL_MOD_LEVEL_SHIFT);
-                lvds_gen_cntl |= LVDS_DISPLAY_DIS;
-                OUTREG(LVDS_GEN_CNTL, lvds_gen_cntl);
-                udelay(100);
-                lvds_gen_cntl &= ~(LVDS_ON | LVDS_EN);
-                OUTREG(LVDS_GEN_CNTL, lvds_gen_cntl);
-                lvds_gen_cntl &= ~(LVDS_DIGON);
-                rinfo->pending_lvds_gen_cntl = lvds_gen_cntl;
-                mod_timer(&rinfo->lvds_timer,
-                          jiffies + msecs_to_jiffies(rinfo->panel_info.pwr_delay));
-                if (rinfo->is_mobility || rinfo->is_IGP)
-                        OUTPLL(PIXCLKS_CNTL, tmpPixclksCntl);
-        }
-        rinfo->init_state.lvds_gen_cntl &= ~LVDS_STATE_MASK;
-        rinfo->init_state.lvds_gen_cntl |= (lvds_gen_cntl & LVDS_STATE_MASK);
-
-        return 0;
-}
-
-
-static int radeon_set_backlight_level(int level, void *data)
-{
-        return radeon_set_backlight_enable(1, level, data);
-}
-#endif /* CONFIG_PMAC_BACKLIGHT */
-
-
 /*
  * This reconfigure the card's internal memory map. In theory, we'd like
  * to setup the card's memory at the same address as it's PCI bus address,
@@ -2477,14 +2349,7 @@ static int __devinit radeonfb_pci_register (struct pci_dev *pdev,
                                                  MTRR_TYPE_WRCOMB, 1);
 #endif
 
-#ifdef CONFIG_PMAC_BACKLIGHT
-        if (rinfo->mon1_type == MT_LCD) {
-                register_backlight_controller(&radeon_backlight_controller,
-                                              rinfo, "ati");
-                register_backlight_controller(&radeon_backlight_controller,
-                                              rinfo, "mnca");
-        }
-#endif
+        radeonfb_bl_init(rinfo);
 
         printk ("radeonfb (%s): %s\n", pci_name(rinfo->pdev), rinfo->name);
 
@@ -2528,7 +2393,8 @@ static void __devexit radeonfb_pci_unregister (struct pci_dev *pdev)
  
         if (!rinfo)
                 return;
- 
+
+        radeonfb_bl_exit(rinfo);
         radeonfb_pm_exit(rinfo);
 
         if (rinfo->mon1_EDID)
diff --git a/drivers/video/aty/radeonfb.h b/drivers/video/aty/radeonfb.h
index 217e00ab4a2d..1645943b1123 100644
--- a/drivers/video/aty/radeonfb.h
+++ b/drivers/video/aty/radeonfb.h
@@ -625,4 +625,13 @@ extern int radeon_screen_blank(struct radeonfb_info *rinfo, int blank, int mode_
 extern void radeon_write_mode (struct radeonfb_info *rinfo, struct radeon_regs *mode,
                                int reg_only);
 
+/* Backlight functions */
+#ifdef CONFIG_FB_RADEON_BACKLIGHT
+extern void radeonfb_bl_init(struct radeonfb_info *rinfo);
+extern void radeonfb_bl_exit(struct radeonfb_info *rinfo);
+#else
+static inline void radeonfb_bl_init(struct radeonfb_info *rinfo) {}
+static inline void radeonfb_bl_exit(struct radeonfb_info *rinfo) {}
+#endif
+
 #endif /* __RADEONFB_H__ */
diff --git a/drivers/video/chipsfb.c b/drivers/video/chipsfb.c
index 72ff6bf75e5e..d76bbfac92cc 100644
--- a/drivers/video/chipsfb.c
+++ b/drivers/video/chipsfb.c
@@ -148,9 +148,24 @@ static int chipsfb_set_par(struct fb_info *info)
 static int chipsfb_blank(int blank, struct fb_info *info)
 {
 #ifdef CONFIG_PMAC_BACKLIGHT
-        // used to disable backlight only for blank > 1, but it seems
-        // useful at blank = 1 too (saves battery, extends backlight life)
-        set_backlight_enable(!blank);
+        mutex_lock(&pmac_backlight_mutex);
+
+        if (pmac_backlight) {
+                down(&pmac_backlight->sem);
+
+                /* used to disable backlight only for blank > 1, but it seems
+                 * useful at blank = 1 too (saves battery, extends backlight
+                 * life)
+                 */
+                if (blank)
+                        pmac_backlight->props->power = FB_BLANK_POWERDOWN;
+                else
+                        pmac_backlight->props->power = FB_BLANK_UNBLANK;
+                pmac_backlight->props->update_status(pmac_backlight);
+                up(&pmac_backlight->sem);
+        }
+
+        mutex_unlock(&pmac_backlight_mutex);
 #endif /* CONFIG_PMAC_BACKLIGHT */
 
         return 1;       /* get fb_blank to set the colormap to all black */
@@ -401,7 +416,14 @@ chipsfb_pci_init(struct pci_dev *dp, const struct pci_device_id *ent)
 
 #ifdef CONFIG_PMAC_BACKLIGHT
         /* turn on the backlight */
-        set_backlight_enable(1);
+        mutex_lock(&pmac_backlight_mutex);
+        if (pmac_backlight) {
+                down(&pmac_backlight->sem);
+                pmac_backlight->props->power = FB_BLANK_UNBLANK;
+                pmac_backlight->props->update_status(pmac_backlight);
+                up(&pmac_backlight->sem);
+        }
+        mutex_unlock(&pmac_backlight_mutex);
 #endif /* CONFIG_PMAC_BACKLIGHT */
 
 #ifdef CONFIG_PPC
diff --git a/drivers/video/fbsysfs.c b/drivers/video/fbsysfs.c
index 34e07399756b..3ceb8c1b392e 100644
--- a/drivers/video/fbsysfs.c
+++ b/drivers/video/fbsysfs.c
@@ -18,6 +18,7 @@
 #include <linux/kernel.h>
 #include <linux/fb.h>
 #include <linux/console.h>
+#include <linux/module.h>
 
 /**
  * framebuffer_alloc - creates a new frame buffer info structure
@@ -55,6 +56,10 @@ struct fb_info *framebuffer_alloc(size_t size, struct device *dev)
 
         info->device = dev;
 
+#ifdef CONFIG_FB_BACKLIGHT
+        mutex_init(&info->bl_mutex);
+#endif
+
         return info;
 #undef PADDING
 #undef BYTES_PER_LONG
@@ -414,6 +419,65 @@ static ssize_t show_fbstate(struct class_device *class_device, char *buf)
         return snprintf(buf, PAGE_SIZE, "%d\n", fb_info->state);
 }
 
+#ifdef CONFIG_FB_BACKLIGHT
+static ssize_t store_bl_curve(struct class_device *class_device,
+                const char *buf, size_t count)
+{
+        struct fb_info *fb_info = class_get_devdata(class_device);
+        u8 tmp_curve[FB_BACKLIGHT_LEVELS];
+        unsigned int i;
+
+        if (count != (FB_BACKLIGHT_LEVELS / 8 * 24))
+                return -EINVAL;
+
+        for (i = 0; i < (FB_BACKLIGHT_LEVELS / 8); ++i)
+                if (sscanf(&buf[i * 24],
+                        "%2hhx %2hhx %2hhx %2hhx %2hhx %2hhx %2hhx %2hhx\n",
+                        &tmp_curve[i * 8 + 0],
+                        &tmp_curve[i * 8 + 1],
+                        &tmp_curve[i * 8 + 2],
+                        &tmp_curve[i * 8 + 3],
+                        &tmp_curve[i * 8 + 4],
+                        &tmp_curve[i * 8 + 5],
+                        &tmp_curve[i * 8 + 6],
+                        &tmp_curve[i * 8 + 7]) != 8)
+                        return -EINVAL;
+
+        /* If there has been an error in the input data, we won't
+         * reach this loop.
+         */
+        mutex_lock(&fb_info->bl_mutex);
+        for (i = 0; i < FB_BACKLIGHT_LEVELS; ++i)
+                fb_info->bl_curve[i] = tmp_curve[i];
+        mutex_unlock(&fb_info->bl_mutex);
+
+        return count;
+}
+
+static ssize_t show_bl_curve(struct class_device *class_device, char *buf)
+{
+        struct fb_info *fb_info = class_get_devdata(class_device);
+        ssize_t len = 0;
+        unsigned int i;
+
+        mutex_lock(&fb_info->bl_mutex);
+        for (i = 0; i < FB_BACKLIGHT_LEVELS; i += 8)
+                len += snprintf(&buf[len], PAGE_SIZE,
+                                "%02x %02x %02x %02x %02x %02x %02x %02x\n",
+                                fb_info->bl_curve[i + 0],
+                                fb_info->bl_curve[i + 1],
+                                fb_info->bl_curve[i + 2],
+                                fb_info->bl_curve[i + 3],
+                                fb_info->bl_curve[i + 4],
+                                fb_info->bl_curve[i + 5],
+                                fb_info->bl_curve[i + 6],
+                                fb_info->bl_curve[i + 7]);
+        mutex_unlock(&fb_info->bl_mutex);
+
+        return len;
+}
+#endif
+
 /* When cmap is added back in it should be a binary attribute
  * not a text one. Consideration should also be given to converting
  * fbdev to use configfs instead of sysfs */
@@ -432,6 +496,9 @@ static struct class_device_attribute class_device_attrs[] = {
         __ATTR(con_rotate, S_IRUGO|S_IWUSR, show_con_rotate, store_con_rotate),
         __ATTR(con_rotate_all, S_IWUSR, NULL, store_con_rotate_all),
         __ATTR(state, S_IRUGO|S_IWUSR, show_fbstate, store_fbstate),
+#ifdef CONFIG_FB_BACKLIGHT
+        __ATTR(bl_curve, S_IRUGO|S_IWUSR, show_bl_curve, store_bl_curve),
+#endif
 };
 
 int fb_init_class_device(struct fb_info *fb_info)
@@ -454,4 +521,25 @@ void fb_cleanup_class_device(struct fb_info *fb_info)
                                          &class_device_attrs[i]);
 }
 
+#ifdef CONFIG_FB_BACKLIGHT
+/* This function generates a linear backlight curve
+ *
+ *     0: off
+ *   1-7: min
+ * 8-127: linear from min to max
+ */
+void fb_bl_default_curve(struct fb_info *fb_info, u8 off, u8 min, u8 max)
+{
+        unsigned int i, flat, count, range = (max - min);
+
+        fb_info->bl_curve[0] = off;
 
+        for (flat = 1; flat < (FB_BACKLIGHT_LEVELS / 16); ++flat)
+                fb_info->bl_curve[flat] = min;
+
+        count = FB_BACKLIGHT_LEVELS * 15 / 16;
+        for (i = 0; i < count; ++i)
+                fb_info->bl_curve[flat + i] = min + (range * (i + 1) / count);
+}
+EXPORT_SYMBOL_GPL(fb_bl_default_curve);
+#endif
diff --git a/drivers/video/igafb.c b/drivers/video/igafb.c
index 6b88050d21bf..8a0c2d3d3805 100644
--- a/drivers/video/igafb.c
+++ b/drivers/video/igafb.c
@@ -232,9 +232,6 @@ static int igafb_mmap(struct fb_info *info,
 
         size = vma->vm_end - vma->vm_start;
 
-        /* To stop the swapper from even considering these pages. */
-        vma->vm_flags |= (VM_SHM | VM_LOCKED);
-
         /* Each page, see which map applies */
         for (page = 0; page < size; ) {
                 map_size = 0;
diff --git a/drivers/video/nvidia/Makefile b/drivers/video/nvidia/Makefile
index 690d37e8de5b..ca47432113e0 100644
--- a/drivers/video/nvidia/Makefile
+++ b/drivers/video/nvidia/Makefile
@@ -7,6 +7,7 @@ obj-$(CONFIG_FB_NVIDIA)          += nvidiafb.o
 nvidiafb-y                       := nvidia.o nv_hw.o nv_setup.o \
                                     nv_accel.o
 nvidiafb-$(CONFIG_FB_NVIDIA_I2C) += nv_i2c.o
+nvidiafb-$(CONFIG_FB_NVIDIA_BACKLIGHT)  += nv_backlight.o
 nvidiafb-$(CONFIG_PPC_OF)        += nv_of.o
 
-nvidiafb-objs                    := $(nvidiafb-y)
\ No newline at end of file
+nvidiafb-objs                    := $(nvidiafb-y)
diff --git a/drivers/video/nvidia/nv_backlight.c b/drivers/video/nvidia/nv_backlight.c
new file mode 100644
index 000000000000..1c1c10c699c5
--- /dev/null
+++ b/drivers/video/nvidia/nv_backlight.c
@@ -0,0 +1,175 @@
+/*
+ * Backlight code for nVidia based graphic cards
+ *
+ * Copyright 2004 Antonino Daplas <adaplas@pol.net>
+ * Copyright (c) 2006 Michael Hanselmann <linux-kernel@hansmi.ch>
+ *
+ * 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/backlight.h>
+#include <linux/fb.h>
+#include <linux/pci.h>
+#include "nv_local.h"
+#include "nv_type.h"
+#include "nv_proto.h"
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+#include <asm/backlight.h>
+#include <asm/machdep.h>
+#endif
+
+/* We do not have any information about which values are allowed, thus
+ * we used safe values.
+ */
+#define MIN_LEVEL 0x158
+#define MAX_LEVEL 0x534
+
+static struct backlight_properties nvidia_bl_data;
+
+static int nvidia_bl_get_level_brightness(struct nvidia_par *par,
+                int level)
+{
+        struct fb_info *info = pci_get_drvdata(par->pci_dev);
+        int nlevel;
+
+        /* Get and convert the value */
+        mutex_lock(&info->bl_mutex);
+        nlevel = info->bl_curve[level] * FB_BACKLIGHT_MAX / MAX_LEVEL;
+        mutex_unlock(&info->bl_mutex);
+
+        if (nlevel < 0)
+                nlevel = 0;
+        else if (nlevel < MIN_LEVEL)
+                nlevel = MIN_LEVEL;
+        else if (nlevel > MAX_LEVEL)
+                nlevel = MAX_LEVEL;
+
+        return nlevel;
+}
+
+static int nvidia_bl_update_status(struct backlight_device *bd)
+{
+        struct nvidia_par *par = class_get_devdata(&bd->class_dev);
+        u32 tmp_pcrt, tmp_pmc, fpcontrol;
+        int level;
+
+        if (!par->FlatPanel)
+                return 0;
+
+        if (bd->props->power != FB_BLANK_UNBLANK ||
+            bd->props->fb_blank != FB_BLANK_UNBLANK)
+                level = 0;
+        else
+                level = bd->props->brightness;
+
+        tmp_pmc = NV_RD32(par->PMC, 0x10F0) & 0x0000FFFF;
+        tmp_pcrt = NV_RD32(par->PCRTC0, 0x081C) & 0xFFFFFFFC;
+        fpcontrol = NV_RD32(par->PRAMDAC, 0x0848) & 0xCFFFFFCC;
+
+        if (level > 0) {
+                tmp_pcrt |= 0x1;
+                tmp_pmc |= (1 << 31); /* backlight bit */
+                tmp_pmc |= nvidia_bl_get_level_brightness(par, level) << 16;
+                fpcontrol |= par->fpSyncs;
+        } else
+                fpcontrol |= 0x20000022;
+
+        NV_WR32(par->PCRTC0, 0x081C, tmp_pcrt);
+        NV_WR32(par->PMC, 0x10F0, tmp_pmc);
+        NV_WR32(par->PRAMDAC, 0x848, fpcontrol);
+
+        return 0;
+}
+
+static int nvidia_bl_get_brightness(struct backlight_device *bd)
+{
+        return bd->props->brightness;
+}
+
+static struct backlight_properties nvidia_bl_data = {
+        .owner          = THIS_MODULE,
+        .get_brightness = nvidia_bl_get_brightness,
+        .update_status  = nvidia_bl_update_status,
+        .max_brightness = (FB_BACKLIGHT_LEVELS - 1),
+};
+
+void nvidia_bl_init(struct nvidia_par *par)
+{
+        struct fb_info *info = pci_get_drvdata(par->pci_dev);
+        struct backlight_device *bd;
+        char name[12];
+
+        if (!par->FlatPanel)
+                return;
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        if (!machine_is(powermac) ||
+            !pmac_has_backlight_type("mnca"))
+                return;
+#endif
+
+        snprintf(name, sizeof(name), "nvidiabl%d", info->node);
+
+        bd = backlight_device_register(name, par, &nvidia_bl_data);
+        if (IS_ERR(bd)) {
+                info->bl_dev = NULL;
+                printk("nvidia: Backlight registration failed\n");
+                goto error;
+        }
+
+        mutex_lock(&info->bl_mutex);
+        info->bl_dev = bd;
+        fb_bl_default_curve(info, 0,
+                0x158 * FB_BACKLIGHT_MAX / MAX_LEVEL,
+                0x534 * FB_BACKLIGHT_MAX / MAX_LEVEL);
+        mutex_unlock(&info->bl_mutex);
+
+        up(&bd->sem);
+        bd->props->brightness = nvidia_bl_data.max_brightness;
+        bd->props->power = FB_BLANK_UNBLANK;
+        bd->props->update_status(bd);
+        down(&bd->sem);
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        mutex_lock(&pmac_backlight_mutex);
+        if (!pmac_backlight)
+                pmac_backlight = bd;
+        mutex_unlock(&pmac_backlight_mutex);
+#endif
+
+        printk("nvidia: Backlight initialized (%s)\n", name);
+
+        return;
+
+error:
+        return;
+}
+
+void nvidia_bl_exit(struct nvidia_par *par)
+{
+        struct fb_info *info = pci_get_drvdata(par->pci_dev);
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        mutex_lock(&pmac_backlight_mutex);
+#endif
+
+        mutex_lock(&info->bl_mutex);
+        if (info->bl_dev) {
+#ifdef CONFIG_PMAC_BACKLIGHT
+                if (pmac_backlight == info->bl_dev)
+                        pmac_backlight = NULL;
+#endif
+
+                backlight_device_unregister(info->bl_dev);
+
+                printk("nvidia: Backlight unloaded\n");
+        }
+        mutex_unlock(&info->bl_mutex);
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        mutex_unlock(&pmac_backlight_mutex);
+#endif
+}
diff --git a/drivers/video/nvidia/nv_proto.h b/drivers/video/nvidia/nv_proto.h
index b149a690ee0f..6fba656cd56b 100644
--- a/drivers/video/nvidia/nv_proto.h
+++ b/drivers/video/nvidia/nv_proto.h
@@ -63,4 +63,14 @@ extern void nvidiafb_imageblit(struct fb_info *info,
                                const struct fb_image *image);
 extern int nvidiafb_sync(struct fb_info *info);
 extern u8 byte_rev[256];
+
+/* in nv_backlight.h */
+#ifdef CONFIG_FB_NVIDIA_BACKLIGHT
+extern void nvidia_bl_init(struct nvidia_par *par);
+extern void nvidia_bl_exit(struct nvidia_par *par);
+#else
+static inline void nvidia_bl_init(struct nvidia_par *par) {}
+static inline void nvidia_bl_exit(struct nvidia_par *par) {}
+#endif
+
 #endif                          /* __NV_PROTO_H__ */
diff --git a/drivers/video/nvidia/nvidia.c b/drivers/video/nvidia/nvidia.c
index 093ab9977c7c..03a7c1e9ce38 100644
--- a/drivers/video/nvidia/nvidia.c
+++ b/drivers/video/nvidia/nvidia.c
@@ -22,6 +22,7 @@
 #include <linux/init.h>
 #include <linux/pci.h>
 #include <linux/console.h>
+#include <linux/backlight.h>
 #ifdef CONFIG_MTRR
 #include <asm/mtrr.h>
 #endif
@@ -29,10 +30,6 @@
 #include <asm/prom.h>
 #include <asm/pci-bridge.h>
 #endif
-#ifdef CONFIG_PMAC_BACKLIGHT
-#include <asm/machdep.h>
-#include <asm/backlight.h>
-#endif
 
 #include "nv_local.h"
 #include "nv_type.h"
@@ -470,75 +467,6 @@ static struct fb_var_screeninfo __devinitdata nvidiafb_default_var = {
         .vmode = FB_VMODE_NONINTERLACED
 };
 
-/*
- * Backlight control
- */
-#ifdef CONFIG_PMAC_BACKLIGHT
-
-static int nvidia_backlight_levels[] = {
-        0x158,
-        0x192,
-        0x1c6,
-        0x200,
-        0x234,
-        0x268,
-        0x2a2,
-        0x2d6,
-        0x310,
-        0x344,
-        0x378,
-        0x3b2,
-        0x3e6,
-        0x41a,
-        0x454,
-        0x534,
-};
-
-/* ------------------------------------------------------------------------- *
- *
- * Backlight operations
- *
- * ------------------------------------------------------------------------- */
-
-static int nvidia_set_backlight_enable(int on, int level, void *data)
-{
-        struct nvidia_par *par = data;
-        u32 tmp_pcrt, tmp_pmc, fpcontrol;
-
-        tmp_pmc = NV_RD32(par->PMC, 0x10F0) & 0x0000FFFF;
-        tmp_pcrt = NV_RD32(par->PCRTC0, 0x081C) & 0xFFFFFFFC;
-        fpcontrol = NV_RD32(par->PRAMDAC, 0x0848) & 0xCFFFFFCC;
-
-        if (on && (level > BACKLIGHT_OFF)) {
-                tmp_pcrt |= 0x1;
-                tmp_pmc |= (1 << 31);   // backlight bit
-                tmp_pmc |= nvidia_backlight_levels[level - 1] << 16;
-        }
-
-        if (on)
-                fpcontrol |= par->fpSyncs;
-        else
-                fpcontrol |= 0x20000022;
-
-        NV_WR32(par->PCRTC0, 0x081C, tmp_pcrt);
-        NV_WR32(par->PMC, 0x10F0, tmp_pmc);
-        NV_WR32(par->PRAMDAC, 0x848, fpcontrol);
-
-        return 0;
-}
-
-static int nvidia_set_backlight_level(int level, void *data)
-{
-        return nvidia_set_backlight_enable(1, level, data);
-}
-
-static struct backlight_controller nvidia_backlight_controller = {
-        nvidia_set_backlight_enable,
-        nvidia_set_backlight_level
-};
-
-#endif                          /* CONFIG_PMAC_BACKLIGHT */
-
 static void nvidiafb_load_cursor_image(struct nvidia_par *par, u8 * data8,
                                        u16 bg, u16 fg, u32 w, u32 h)
 {
@@ -1355,10 +1283,15 @@ static int nvidiafb_blank(int blank, struct fb_info *info)
         NVWriteSeq(par, 0x01, tmp);
         NVWriteCrtc(par, 0x1a, vesa);
 
-#ifdef CONFIG_PMAC_BACKLIGHT
-        if (par->FlatPanel && machine_is(powermac)) {
-                set_backlight_enable(!blank);
+#ifdef CONFIG_FB_NVIDIA_BACKLIGHT
+        mutex_lock(&info->bl_mutex);
+        if (info->bl_dev) {
+                down(&info->bl_dev->sem);
+                info->bl_dev->props->power = blank;
+                info->bl_dev->props->update_status(info->bl_dev);
+                up(&info->bl_dev->sem);
         }
+        mutex_unlock(&info->bl_mutex);
 #endif
 
         NVTRACE_LEAVE();
@@ -1741,11 +1674,9 @@ static int __devinit nvidiafb_probe(struct pci_dev *pd,
                "PCI nVidia %s framebuffer (%dMB @ 0x%lX)\n",
                info->fix.id,
                par->FbMapSize / (1024 * 1024), info->fix.smem_start);
-#ifdef CONFIG_PMAC_BACKLIGHT
-        if (par->FlatPanel && machine_is(powermac))
-                register_backlight_controller(&nvidia_backlight_controller,
-                                              par, "mnca");
-#endif
+
+        nvidia_bl_init(par);
+
         NVTRACE_LEAVE();
         return 0;
 
@@ -1775,6 +1706,8 @@ static void __exit nvidiafb_remove(struct pci_dev *pd)
 
         NVTRACE_ENTER();
 
+        nvidia_bl_exit(par);
+
         unregister_framebuffer(info);
 #ifdef CONFIG_MTRR
         if (par->mtrr.vram_valid)
diff --git a/drivers/video/riva/fbdev.c b/drivers/video/riva/fbdev.c
index 3e9308f0f165..d4384ab1df65 100644
--- a/drivers/video/riva/fbdev.c
+++ b/drivers/video/riva/fbdev.c
@@ -41,6 +41,7 @@
 #include <linux/fb.h>
 #include <linux/init.h>
 #include <linux/pci.h>
+#include <linux/backlight.h>
 #ifdef CONFIG_MTRR
 #include <asm/mtrr.h>
 #endif
@@ -272,34 +273,154 @@ static const struct riva_regs reg_template = {
 /*
  * Backlight control
  */
-#ifdef CONFIG_PMAC_BACKLIGHT
+#ifdef CONFIG_FB_RIVA_BACKLIGHT
+/* We do not have any information about which values are allowed, thus
+ * we used safe values.
+ */
+#define MIN_LEVEL 0x158
+#define MAX_LEVEL 0x534
 
-static int riva_backlight_levels[] = {
-    0x158,
-    0x192,
-    0x1c6,
-    0x200,
-    0x234,
-    0x268,
-    0x2a2,
-    0x2d6,
-    0x310,
-    0x344,
-    0x378,
-    0x3b2,
-    0x3e6,
-    0x41a,
-    0x454,
-    0x534,
-};
+static struct backlight_properties riva_bl_data;
+
+static int riva_bl_get_level_brightness(struct riva_par *par,
+                int level)
+{
+        struct fb_info *info = pci_get_drvdata(par->pdev);
+        int nlevel;
+
+        /* Get and convert the value */
+        mutex_lock(&info->bl_mutex);
+        nlevel = info->bl_curve[level] * FB_BACKLIGHT_MAX / MAX_LEVEL;
+        mutex_unlock(&info->bl_mutex);
+
+        if (nlevel < 0)
+                nlevel = 0;
+        else if (nlevel < MIN_LEVEL)
+                nlevel = MIN_LEVEL;
+        else if (nlevel > MAX_LEVEL)
+                nlevel = MAX_LEVEL;
+
+        return nlevel;
+}
+
+static int riva_bl_update_status(struct backlight_device *bd)
+{
+        struct riva_par *par = class_get_devdata(&bd->class_dev);
+        U032 tmp_pcrt, tmp_pmc;
+        int level;
+
+        if (bd->props->power != FB_BLANK_UNBLANK ||
+            bd->props->fb_blank != FB_BLANK_UNBLANK)
+                level = 0;
+        else
+                level = bd->props->brightness;
+
+        tmp_pmc = par->riva.PMC[0x10F0/4] & 0x0000FFFF;
+        tmp_pcrt = par->riva.PCRTC0[0x081C/4] & 0xFFFFFFFC;
+        if(level > 0) {
+                tmp_pcrt |= 0x1;
+                tmp_pmc |= (1 << 31); /* backlight bit */
+                tmp_pmc |= riva_bl_get_level_brightness(par, level) << 16; /* level */
+        }
+        par->riva.PCRTC0[0x081C/4] = tmp_pcrt;
+        par->riva.PMC[0x10F0/4] = tmp_pmc;
+
+        return 0;
+}
+
+static int riva_bl_get_brightness(struct backlight_device *bd)
+{
+        return bd->props->brightness;
+}
 
-static int riva_set_backlight_enable(int on, int level, void *data);
-static int riva_set_backlight_level(int level, void *data);
-static struct backlight_controller riva_backlight_controller = {
-        riva_set_backlight_enable,
-        riva_set_backlight_level
+static struct backlight_properties riva_bl_data = {
+        .owner    = THIS_MODULE,
+        .get_brightness = riva_bl_get_brightness,
+        .update_status  = riva_bl_update_status,
+        .max_brightness = (FB_BACKLIGHT_LEVELS - 1),
 };
-#endif /* CONFIG_PMAC_BACKLIGHT */
+
+static void riva_bl_init(struct riva_par *par)
+{
+        struct fb_info *info = pci_get_drvdata(par->pdev);
+        struct backlight_device *bd;
+        char name[12];
+
+        if (!par->FlatPanel)
+                return;
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        if (!machine_is(powermac) ||
+            !pmac_has_backlight_type("mnca"))
+                return;
+#endif
+
+        snprintf(name, sizeof(name), "rivabl%d", info->node);
+
+        bd = backlight_device_register(name, par, &riva_bl_data);
+        if (IS_ERR(bd)) {
+                info->bl_dev = NULL;
+                printk("riva: Backlight registration failed\n");
+                goto error;
+        }
+
+        mutex_lock(&info->bl_mutex);
+        info->bl_dev = bd;
+        fb_bl_default_curve(info, 0,
+                0x158 * FB_BACKLIGHT_MAX / MAX_LEVEL,
+                0x534 * FB_BACKLIGHT_MAX / MAX_LEVEL);
+        mutex_unlock(&info->bl_mutex);
+
+        up(&bd->sem);
+        bd->props->brightness = riva_bl_data.max_brightness;
+        bd->props->power = FB_BLANK_UNBLANK;
+        bd->props->update_status(bd);
+        down(&bd->sem);
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        mutex_lock(&pmac_backlight_mutex);
+        if (!pmac_backlight)
+                pmac_backlight = bd;
+        mutex_unlock(&pmac_backlight_mutex);
+#endif
+
+        printk("riva: Backlight initialized (%s)\n", name);
+
+        return;
+
+error:
+        return;
+}
+
+static void riva_bl_exit(struct riva_par *par)
+{
+        struct fb_info *info = pci_get_drvdata(par->pdev);
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        mutex_lock(&pmac_backlight_mutex);
+#endif
+
+        mutex_lock(&info->bl_mutex);
+        if (info->bl_dev) {
+#ifdef CONFIG_PMAC_BACKLIGHT
+                if (pmac_backlight == info->bl_dev)
+                        pmac_backlight = NULL;
+#endif
+
+                backlight_device_unregister(info->bl_dev);
+
+                printk("riva: Backlight unloaded\n");
+        }
+        mutex_unlock(&info->bl_mutex);
+
+#ifdef CONFIG_PMAC_BACKLIGHT
+        mutex_unlock(&pmac_backlight_mutex);
+#endif
+}
+#else
+static inline void riva_bl_init(struct riva_par *par) {}
+static inline void riva_bl_exit(struct riva_par *par) {}
+#endif /* CONFIG_FB_RIVA_BACKLIGHT */
 
 /* ------------------------------------------------------------------------- *
  *
@@ -973,36 +1094,6 @@ static int riva_get_cmap_len(const struct fb_var_screeninfo *var)
 
 /* ------------------------------------------------------------------------- *
  *
- * Backlight operations
- *
- * ------------------------------------------------------------------------- */
-
-#ifdef CONFIG_PMAC_BACKLIGHT
-static int riva_set_backlight_enable(int on, int level, void *data)
-{
-        struct riva_par *par = data;
-        U032 tmp_pcrt, tmp_pmc;
-
-        tmp_pmc = par->riva.PMC[0x10F0/4] & 0x0000FFFF;
-        tmp_pcrt = par->riva.PCRTC0[0x081C/4] & 0xFFFFFFFC;
-        if(on && (level > BACKLIGHT_OFF)) {
-                tmp_pcrt |= 0x1;
-                tmp_pmc |= (1 << 31); // backlight bit
-                tmp_pmc |= riva_backlight_levels[level-1] << 16; // level
-        }
-        par->riva.PCRTC0[0x081C/4] = tmp_pcrt;
-        par->riva.PMC[0x10F0/4] = tmp_pmc;
-        return 0;
-}
-
-static int riva_set_backlight_level(int level, void *data)
-{
-        return riva_set_backlight_enable(1, level, data);
-}
-#endif /* CONFIG_PMAC_BACKLIGHT */
-
-/* ------------------------------------------------------------------------- *
- *
  * framebuffer operations
  *
  * ------------------------------------------------------------------------- */
@@ -1247,10 +1338,15 @@ static int rivafb_blank(int blank, struct fb_info *info)
         SEQout(par, 0x01, tmp);
         CRTCout(par, 0x1a, vesa);
 
-#ifdef CONFIG_PMAC_BACKLIGHT
-        if ( par->FlatPanel && machine_is(powermac)) {
-                set_backlight_enable(!blank);
+#ifdef CONFIG_FB_RIVA_BACKLIGHT
+        mutex_lock(&info->bl_mutex);
+        if (info->bl_dev) {
+                down(&info->bl_dev->sem);
+                info->bl_dev->props->power = blank;
+                info->bl_dev->props->update_status(info->bl_dev);
+                up(&info->bl_dev->sem);
         }
+        mutex_unlock(&info->bl_mutex);
 #endif
 
         NVTRACE_LEAVE();
@@ -2037,11 +2133,9 @@ static int __devinit rivafb_probe(struct pci_dev *pd,
                 RIVAFB_VERSION,
                 info->fix.smem_len / (1024 * 1024),
                 info->fix.smem_start);
-#ifdef CONFIG_PMAC_BACKLIGHT
-        if (default_par->FlatPanel && machine_is(powermac))
-                register_backlight_controller(&riva_backlight_controller,
-                                              default_par, "mnca");
-#endif
+
+        riva_bl_init(info->par);
+
         NVTRACE_LEAVE();
         return 0;
 
@@ -2074,6 +2168,8 @@ static void __exit rivafb_remove(struct pci_dev *pd)
         
         NVTRACE_ENTER();
 
+        riva_bl_exit(par);
+
 #ifdef CONFIG_FB_RIVA_I2C
         riva_delete_i2c_busses(par);
         kfree(par->EDID);
diff --git a/drivers/video/tridentfb.c b/drivers/video/tridentfb.c
index 9ac2d3171187..41f8c2d93892 100644
--- a/drivers/video/tridentfb.c
+++ b/drivers/video/tridentfb.c
@@ -551,7 +551,7 @@ static inline void enable_mmio(void)
 #define crtc_unlock()   write3X4(CRTVSyncEnd, read3X4(CRTVSyncEnd) & 0x7F)
 
 /*  Return flat panel's maximum x resolution */
-static int __init get_nativex(void)
+static int __devinit get_nativex(void)
 {
         int x,y,tmp;
 
@@ -658,7 +658,7 @@ static void set_number_of_lines(int lines)
  * If we see that FP is active we assume we have one.
  * Otherwise we have a CRT display.User can override.
  */
-static unsigned int __init get_displaytype(void)
+static unsigned int __devinit get_displaytype(void)
 {
         if (fp)
                 return DISPLAY_FP;
@@ -668,7 +668,7 @@ static unsigned int __init get_displaytype(void)
 }
 
 /* Try detecting the video memory size */
-static unsigned int __init get_memsize(void)
+static unsigned int __devinit get_memsize(void)
 {
         unsigned char tmp, tmp2;
         unsigned int k;
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index 2cb87ba4b1c1..5c6bdf82146c 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -530,9 +530,6 @@ error:
         if (vfid)
                 v9fs_fid_destroy(vfid);
 
-        if (inode)
-                iput(inode);
-
         return err;
 }
 
@@ -1054,6 +1051,9 @@ static int v9fs_vfs_readlink(struct dentry *dentry, char __user * buffer,
         int ret;
         char *link = __getname();
 
+        if (unlikely(!link))
+                return -ENOMEM;
+
         if (buflen > PATH_MAX)
                 buflen = PATH_MAX;
 
@@ -1171,9 +1171,6 @@ error:
         if (vfid)
                 v9fs_fid_destroy(vfid);
 
-        if (inode)
-                iput(inode);
-
         return err;
 
 }
@@ -1227,6 +1224,9 @@ v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
         }
 
         name = __getname();
+        if (unlikely(!name))
+                return -ENOMEM;
+
         sprintf(name, "%d\n", oldfid->fid);
         retval = v9fs_vfs_mkspecial(dir, dentry, V9FS_DMLINK, name);
         __putname(name);
diff --git a/fs/Kconfig b/fs/Kconfig
index 2aa4624cc018..1cdc043922d5 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -776,7 +776,8 @@ endmenu
 menu "Pseudo filesystems"
 
 config PROC_FS
-        bool "/proc file system support"
+        bool "/proc file system support" if EMBEDDED
+        default y
         help
           This is a virtual file system providing information about the status
           of the system. "Virtual" means that it doesn't take up any space on
@@ -1370,11 +1371,19 @@ config UFS_FS
 
 config UFS_FS_WRITE
         bool "UFS file system write support (DANGEROUS)"
-        depends on UFS_FS && EXPERIMENTAL && BROKEN
+        depends on UFS_FS && EXPERIMENTAL
         help
           Say Y here if you want to try writing to UFS partitions. This is
           experimental, so you should back up your UFS partitions beforehand.
 
+config UFS_DEBUG
+        bool "UFS debugging"
+        depends on UFS_FS
+        help
+          If you are experiencing any problems with the UFS filesystem, say
+          Y here.  This will result in _many_ additional debugging messages to be
+          written to the system log.
+
 endmenu
 
 menu "Network File Systems"
diff --git a/fs/affs/super.c b/fs/affs/super.c
index 8765cba35bb9..5200f4938df0 100644
--- a/fs/affs/super.c
+++ b/fs/affs/super.c
@@ -271,6 +271,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
         int                      reserved;
         unsigned long            mount_flags;
         int                      tmp_flags;     /* fix remount prototype... */
+        u8                       sig[4];
 
         pr_debug("AFFS: read_super(%s)\n",data ? (const char *)data : "no options");
 
@@ -370,8 +371,9 @@ got_root:
                 printk(KERN_ERR "AFFS: Cannot read boot block\n");
                 goto out_error;
         }
-        chksum = be32_to_cpu(*(__be32 *)boot_bh->b_data);
+        memcpy(sig, boot_bh->b_data, 4);
         brelse(boot_bh);
+        chksum = be32_to_cpu(*(__be32 *)sig);
 
         /* Dircache filesystems are compatible with non-dircache ones
          * when reading. As long as they aren't supported, writing is
@@ -420,11 +422,11 @@ got_root:
         }
 
         if (mount_flags & SF_VERBOSE) {
-                chksum = cpu_to_be32(chksum);
-                printk(KERN_NOTICE "AFFS: Mounting volume \"%*s\": Type=%.3s\\%c, Blocksize=%d\n",
-                        AFFS_ROOT_TAIL(sb, root_bh)->disk_name[0],
+                u8 len = AFFS_ROOT_TAIL(sb, root_bh)->disk_name[0];
+                printk(KERN_NOTICE "AFFS: Mounting volume \"%.*s\": Type=%.3s\\%c, Blocksize=%d\n",
+                        len > 31 ? 31 : len,
                         AFFS_ROOT_TAIL(sb, root_bh)->disk_name + 1,
-                        (char *)&chksum,((char *)&chksum)[3] + '0',blocksize);
+                        sig, sig[3] + '0', blocksize);
         }
 
         sb->s_flags |= MS_NODEV | MS_NOSUID;
diff --git a/fs/autofs4/expire.c b/fs/autofs4/expire.c
index b8ce02607d66..4456d1daa40f 100644
--- a/fs/autofs4/expire.c
+++ b/fs/autofs4/expire.c
@@ -174,6 +174,12 @@ static int autofs4_tree_busy(struct vfsmount *mnt,
                         struct autofs_info *ino = autofs4_dentry_ino(p);
                         unsigned int ino_count = atomic_read(&ino->count);
 
+                        /*
+                         * Clean stale dentries below that have not been
+                         * invalidated after a mount fail during lookup
+                         */
+                        d_invalidate(p);
+
                         /* allow for dget above and top is already dgot */
                         if (p == top)
                                 ino_count += 2;
diff --git a/fs/dcache.c b/fs/dcache.c
index 313b54b2b8f2..b85fda360533 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -406,7 +406,7 @@ static void prune_dcache(int count, struct super_block *sb)
                 cond_resched_lock(&dcache_lock);
 
                 tmp = dentry_unused.prev;
-                if (unlikely(sb)) {
+                if (sb) {
                         /* Try to find a dentry for this sb, but don't try
                          * too hard, if they aren't near the tail they will
                          * be moved down again soon
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index 08e7e6a555ca..9c677bbd0b08 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -1,6 +1,6 @@
 /*
  *  fs/eventpoll.c ( Efficent event polling implementation )
- *  Copyright (C) 2001,...,2003  Davide Libenzi
+ *  Copyright (C) 2001,...,2006  Davide Libenzi
  *
  *  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
@@ -1004,7 +1004,7 @@ static int ep_insert(struct eventpoll *ep, struct epoll_event *event,
 
                 /* Notify waiting tasks that events are available */
                 if (waitqueue_active(&ep->wq))
-                        wake_up(&ep->wq);
+                        __wake_up_locked(&ep->wq, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE);
                 if (waitqueue_active(&ep->poll_wait))
                         pwake++;
         }
@@ -1083,7 +1083,8 @@ static int ep_modify(struct eventpoll *ep, struct epitem *epi, struct epoll_even
 
                                 /* Notify waiting tasks that events are available */
                                 if (waitqueue_active(&ep->wq))
-                                        wake_up(&ep->wq);
+                                        __wake_up_locked(&ep->wq, TASK_UNINTERRUPTIBLE |
+                                                         TASK_INTERRUPTIBLE);
                                 if (waitqueue_active(&ep->poll_wait))
                                         pwake++;
                         }
@@ -1260,7 +1261,8 @@ is_linked:
          * wait list.
          */
         if (waitqueue_active(&ep->wq))
-                wake_up(&ep->wq);
+                __wake_up_locked(&ep->wq, TASK_UNINTERRUPTIBLE |
+                                 TASK_INTERRUPTIBLE);
         if (waitqueue_active(&ep->poll_wait))
                 pwake++;
 
@@ -1444,7 +1446,8 @@ static void ep_reinject_items(struct eventpoll *ep, struct list_head *txlist)
                  * wait list.
                  */
                 if (waitqueue_active(&ep->wq))
-                        wake_up(&ep->wq);
+                        __wake_up_locked(&ep->wq, TASK_UNINTERRUPTIBLE |
+                                         TASK_INTERRUPTIBLE);
                 if (waitqueue_active(&ep->poll_wait))
                         pwake++;
         }
@@ -1516,7 +1519,7 @@ retry:
                  * ep_poll_callback() when events will become available.
                  */
                 init_waitqueue_entry(&wait, current);
-                add_wait_queue(&ep->wq, &wait);
+                __add_wait_queue(&ep->wq, &wait);
 
                 for (;;) {
                         /*
@@ -1536,7 +1539,7 @@ retry:
                         jtimeout = schedule_timeout(jtimeout);
                         write_lock_irqsave(&ep->lock, flags);
                 }
-                remove_wait_queue(&ep->wq, &wait);
+                __remove_wait_queue(&ep->wq, &wait);
 
                 set_current_state(TASK_RUNNING);
         }
diff --git a/fs/ext2/Makefile b/fs/ext2/Makefile
index c5d02da73bc3..e0b2b43c1fdb 100644
--- a/fs/ext2/Makefile
+++ b/fs/ext2/Makefile
@@ -4,7 +4,7 @@
 
 obj-$(CONFIG_EXT2_FS) += ext2.o
 
-ext2-y := balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o \
+ext2-y := balloc.o dir.o file.o fsync.o ialloc.o inode.o \
           ioctl.o namei.o super.o symlink.o
 
 ext2-$(CONFIG_EXT2_FS_XATTR)     += xattr.o xattr_user.o xattr_trusted.o
diff --git a/fs/ext2/balloc.c b/fs/ext2/balloc.c
index 2c00953d4b0b..433a213a8bd9 100644
--- a/fs/ext2/balloc.c
+++ b/fs/ext2/balloc.c
@@ -521,6 +521,26 @@ io_error:
         goto out_release;
 }
 
+#ifdef EXT2FS_DEBUG
+
+static int nibblemap[] = {4, 3, 3, 2, 3, 2, 2, 1, 3, 2, 2, 1, 2, 1, 1, 0};
+
+unsigned long ext2_count_free (struct buffer_head * map, unsigned int numchars)
+{
+        unsigned int i;
+        unsigned long sum = 0;
+
+        if (!map)
+                return (0);
+        for (i = 0; i < numchars; i++)
+                sum += nibblemap[map->b_data[i] & 0xf] +
+                        nibblemap[(map->b_data[i] >> 4) & 0xf];
+        return (sum);
+}
+
+#endif  /*  EXT2FS_DEBUG  */
+
+/* Superblock must be locked */
 unsigned long ext2_count_free_blocks (struct super_block * sb)
 {
         struct ext2_group_desc * desc;
@@ -530,7 +550,6 @@ unsigned long ext2_count_free_blocks (struct super_block * sb)
         unsigned long bitmap_count, x;
         struct ext2_super_block *es;
 
-        lock_super (sb);
         es = EXT2_SB(sb)->s_es;
         desc_count = 0;
         bitmap_count = 0;
@@ -554,7 +573,6 @@ unsigned long ext2_count_free_blocks (struct super_block * sb)
         printk("ext2_count_free_blocks: stored = %lu, computed = %lu, %lu\n",
                 (long)le32_to_cpu(es->s_free_blocks_count),
                 desc_count, bitmap_count);
-        unlock_super (sb);
         return bitmap_count;
 #else
         for (i = 0; i < EXT2_SB(sb)->s_groups_count; i++) {
diff --git a/fs/ext2/bitmap.c b/fs/ext2/bitmap.c
deleted file mode 100644
index e9983a0dd396..000000000000
--- a/fs/ext2/bitmap.c
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- *  linux/fs/ext2/bitmap.c
- *
- * Copyright (C) 1992, 1993, 1994, 1995
- * Remy Card (card@masi.ibp.fr)
- * Laboratoire MASI - Institut Blaise Pascal
- * Universite Pierre et Marie Curie (Paris VI)
- */
-
-#ifdef EXT2FS_DEBUG
-
-#include <linux/buffer_head.h>
-
-#include "ext2.h"
-
-static int nibblemap[] = {4, 3, 3, 2, 3, 2, 2, 1, 3, 2, 2, 1, 2, 1, 1, 0};
-
-unsigned long ext2_count_free (struct buffer_head * map, unsigned int numchars)
-{
-        unsigned int i;
-        unsigned long sum = 0;
-        
-        if (!map) 
-                return (0);
-        for (i = 0; i < numchars; i++)
-                sum += nibblemap[map->b_data[i] & 0xf] +
-                        nibblemap[(map->b_data[i] >> 4) & 0xf];
-        return (sum);
-}
-
-#endif  /*  EXT2FS_DEBUG  */
-
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 3c1c9aaaca6b..92ea8265d7d5 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -399,8 +399,7 @@ ino_t ext2_inode_by_name(struct inode * dir, struct dentry *dentry)
         de = ext2_find_entry (dir, dentry, &page);
         if (de) {
                 res = le32_to_cpu(de->inode);
-                kunmap(page);
-                page_cache_release(page);
+                ext2_put_page(page);
         }
         return res;
 }
diff --git a/fs/ext2/fsync.c b/fs/ext2/fsync.c
index c9c2e5ffa48e..7806b9e8155b 100644
--- a/fs/ext2/fsync.c
+++ b/fs/ext2/fsync.c
@@ -24,7 +24,7 @@
 
 #include "ext2.h"
 #include <linux/smp_lock.h>
-#include <linux/buffer_head.h>          /* for fsync_inode_buffers() */
+#include <linux/buffer_head.h>          /* for sync_mapping_buffers() */
 
 
 /*
diff --git a/fs/ext2/ialloc.c b/fs/ext2/ialloc.c
index e52765219e16..308c252568c6 100644
--- a/fs/ext2/ialloc.c
+++ b/fs/ext2/ialloc.c
@@ -638,6 +638,7 @@ fail:
         return ERR_PTR(err);
 }
 
+/* Superblock must be locked */
 unsigned long ext2_count_free_inodes (struct super_block * sb)
 {
         struct ext2_group_desc *desc;
@@ -649,7 +650,6 @@ unsigned long ext2_count_free_inodes (struct super_block * sb)
         unsigned long bitmap_count = 0;
         struct buffer_head *bitmap_bh = NULL;
 
-        lock_super (sb);
         es = EXT2_SB(sb)->s_es;
         for (i = 0; i < EXT2_SB(sb)->s_groups_count; i++) {
                 unsigned x;
@@ -672,7 +672,6 @@ unsigned long ext2_count_free_inodes (struct super_block * sb)
         printk("ext2_count_free_inodes: stored = %lu, computed = %lu, %lu\n",
                 percpu_counter_read(&EXT2_SB(sb)->s_freeinodes_counter),
                 desc_count, bitmap_count);
-        unlock_super(sb);
         return desc_count;
 #else
         for (i = 0; i < EXT2_SB(sb)->s_groups_count; i++) {
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index ee4ba759581e..d4233b2e6436 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -854,7 +854,6 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent)
         }
         if (!ext2_check_descriptors (sb)) {
                 printk ("EXT2-fs: group descriptors corrupted!\n");
-                db_count = i;
                 goto failed_mount2;
         }
         sbi->s_gdb_count = db_count;
@@ -1046,6 +1045,7 @@ static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf)
         unsigned long overhead;
         int i;
 
+        lock_super(sb);
         if (test_opt (sb, MINIX_DF))
                 overhead = 0;
         else {
@@ -1086,6 +1086,7 @@ static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf)
         buf->f_files = le32_to_cpu(sbi->s_es->s_inodes_count);
         buf->f_ffree = ext2_count_free_inodes (sb);
         buf->f_namelen = EXT2_NAME_LEN;
+        unlock_super(sb);
         return 0;
 }
 
diff --git a/fs/ext3/balloc.c b/fs/ext3/balloc.c
index 77927d6938f6..96172e89ddc3 100644
--- a/fs/ext3/balloc.c
+++ b/fs/ext3/balloc.c
@@ -163,20 +163,19 @@ restart:
 #endif
 
 static int
-goal_in_my_reservation(struct ext3_reserve_window *rsv, int goal,
+goal_in_my_reservation(struct ext3_reserve_window *rsv, ext3_grpblk_t grp_goal,
                         unsigned int group, struct super_block * sb)
 {
-        unsigned long group_first_block, group_last_block;
+        ext3_fsblk_t group_first_block, group_last_block;
 
-        group_first_block = le32_to_cpu(EXT3_SB(sb)->s_es->s_first_data_block) +
-                                group * EXT3_BLOCKS_PER_GROUP(sb);
+        group_first_block = ext3_group_first_block_no(sb, group);
         group_last_block = group_first_block + EXT3_BLOCKS_PER_GROUP(sb) - 1;
 
         if ((rsv->_rsv_start > group_last_block) ||
             (rsv->_rsv_end < group_first_block))
                 return 0;
-        if ((goal >= 0) && ((goal + group_first_block < rsv->_rsv_start)
-                || (goal + group_first_block > rsv->_rsv_end)))
+        if ((grp_goal >= 0) && ((grp_goal + group_first_block < rsv->_rsv_start)
+                || (grp_goal + group_first_block > rsv->_rsv_end)))
                 return 0;
         return 1;
 }
@@ -187,7 +186,7 @@ goal_in_my_reservation(struct ext3_reserve_window *rsv, int goal,
  * Returns NULL if there are no windows or if all windows start after the goal.
  */
 static struct ext3_reserve_window_node *
-search_reserve_window(struct rb_root *root, unsigned long goal)
+search_reserve_window(struct rb_root *root, ext3_fsblk_t goal)
 {
         struct rb_node *n = root->rb_node;
         struct ext3_reserve_window_node *rsv;
@@ -223,7 +222,7 @@ void ext3_rsv_window_add(struct super_block *sb,
 {
         struct rb_root *root = &EXT3_SB(sb)->s_rsv_window_root;
         struct rb_node *node = &rsv->rsv_node;
-        unsigned int start = rsv->rsv_start;
+        ext3_fsblk_t start = rsv->rsv_start;
 
         struct rb_node ** p = &root->rb_node;
         struct rb_node * parent = NULL;
@@ -310,20 +309,20 @@ void ext3_discard_reservation(struct inode *inode)
 
 /* Free given blocks, update quota and i_blocks field */
 void ext3_free_blocks_sb(handle_t *handle, struct super_block *sb,
-                         unsigned long block, unsigned long count,
-                         int *pdquot_freed_blocks)
+                         ext3_fsblk_t block, unsigned long count,
+                         unsigned long *pdquot_freed_blocks)
 {
         struct buffer_head *bitmap_bh = NULL;
         struct buffer_head *gd_bh;
         unsigned long block_group;
-        unsigned long bit;
+        ext3_grpblk_t bit;
         unsigned long i;
         unsigned long overflow;
         struct ext3_group_desc * desc;
         struct ext3_super_block * es;
         struct ext3_sb_info *sbi;
         int err = 0, ret;
-        unsigned group_freed;
+        ext3_grpblk_t group_freed;
 
         *pdquot_freed_blocks = 0;
         sbi = EXT3_SB(sb);
@@ -333,7 +332,7 @@ void ext3_free_blocks_sb(handle_t *handle, struct super_block *sb,
             block + count > le32_to_cpu(es->s_blocks_count)) {
                 ext3_error (sb, "ext3_free_blocks",
                             "Freeing blocks not in datazone - "
-                            "block = %lu, count = %lu", block, count);
+                            "block = "E3FSBLK", count = %lu", block, count);
                 goto error_return;
         }
 
@@ -369,7 +368,7 @@ do_more:
                       sbi->s_itb_per_group))
                 ext3_error (sb, "ext3_free_blocks",
                             "Freeing blocks in system zones - "
-                            "Block = %lu, count = %lu",
+                            "Block = "E3FSBLK", count = %lu",
                             block, count);
 
         /*
@@ -453,7 +452,8 @@ do_more:
                                                 bit + i, bitmap_bh->b_data)) {
                         jbd_unlock_bh_state(bitmap_bh);
                         ext3_error(sb, __FUNCTION__,
-                                "bit already cleared for block %lu", block + i);
+                                "bit already cleared for block "E3FSBLK,
+                                 block + i);
                         jbd_lock_bh_state(bitmap_bh);
                         BUFFER_TRACE(bitmap_bh, "bit already cleared");
                 } else {
@@ -493,10 +493,10 @@ error_return:
 
 /* Free given blocks, update quota and i_blocks field */
 void ext3_free_blocks(handle_t *handle, struct inode *inode,
-                        unsigned long block, unsigned long count)
+                        ext3_fsblk_t block, unsigned long count)
 {
         struct super_block * sb;
-        int dquot_freed_blocks;
+        unsigned long dquot_freed_blocks;
 
         sb = inode->i_sb;
         if (!sb) {
@@ -525,7 +525,7 @@ void ext3_free_blocks(handle_t *handle, struct inode *inode,
  * data-writes at some point, and disable it for metadata allocations or
  * sync-data inodes.
  */
-static int ext3_test_allocatable(int nr, struct buffer_head *bh)
+static int ext3_test_allocatable(ext3_grpblk_t nr, struct buffer_head *bh)
 {
         int ret;
         struct journal_head *jh = bh2jh(bh);
@@ -542,11 +542,11 @@ static int ext3_test_allocatable(int nr, struct buffer_head *bh)
         return ret;
 }
 
-static int
-bitmap_search_next_usable_block(int start, struct buffer_head *bh,
-                                        int maxblocks)
+static ext3_grpblk_t
+bitmap_search_next_usable_block(ext3_grpblk_t start, struct buffer_head *bh,
+                                        ext3_grpblk_t maxblocks)
 {
-        int next;
+        ext3_grpblk_t next;
         struct journal_head *jh = bh2jh(bh);
 
         /*
@@ -576,10 +576,11 @@ bitmap_search_next_usable_block(int start, struct buffer_head *bh,
  * the initial goal; then for a free byte somewhere in the bitmap; then
  * for any free bit in the bitmap.
  */
-static int
-find_next_usable_block(int start, struct buffer_head *bh, int maxblocks)
+static ext3_grpblk_t
+find_next_usable_block(ext3_grpblk_t start, struct buffer_head *bh,
+                        ext3_grpblk_t maxblocks)
 {
-        int here, next;
+        ext3_grpblk_t here, next;
         char *p, *r;
 
         if (start > 0) {
@@ -591,7 +592,7 @@ find_next_usable_block(int start, struct buffer_head *bh, int maxblocks)
                  * less than EXT3_BLOCKS_PER_GROUP. Aligning up to the
                  * next 64-bit boundary is simple..
                  */
-                int end_goal = (start + 63) & ~63;
+                ext3_grpblk_t end_goal = (start + 63) & ~63;
                 if (end_goal > maxblocks)
                         end_goal = maxblocks;
                 here = ext3_find_next_zero_bit(bh->b_data, end_goal, start);
@@ -628,7 +629,7 @@ find_next_usable_block(int start, struct buffer_head *bh, int maxblocks)
  * zero (failure).
  */
 static inline int
-claim_block(spinlock_t *lock, int block, struct buffer_head *bh)
+claim_block(spinlock_t *lock, ext3_grpblk_t block, struct buffer_head *bh)
 {
         struct journal_head *jh = bh2jh(bh);
         int ret;
@@ -651,19 +652,18 @@ claim_block(spinlock_t *lock, int block, struct buffer_head *bh)
  * new bitmap.  In that case we must release write access to the old one via
  * ext3_journal_release_buffer(), else we'll run out of credits.
  */
-static int
+static ext3_grpblk_t
 ext3_try_to_allocate(struct super_block *sb, handle_t *handle, int group,
-                        struct buffer_head *bitmap_bh, int goal,
+                        struct buffer_head *bitmap_bh, ext3_grpblk_t grp_goal,
                         unsigned long *count, struct ext3_reserve_window *my_rsv)
 {
-        int group_first_block, start, end;
+        ext3_fsblk_t group_first_block;
+        ext3_grpblk_t start, end;
         unsigned long num = 0;
 
         /* we do allocation within the reservation window if we have a window */
         if (my_rsv) {
-                group_first_block =
-                        le32_to_cpu(EXT3_SB(sb)->s_es->s_first_data_block) +
-                        group * EXT3_BLOCKS_PER_GROUP(sb);
+                group_first_block = ext3_group_first_block_no(sb, group);
                 if (my_rsv->_rsv_start >= group_first_block)
                         start = my_rsv->_rsv_start - group_first_block;
                 else
@@ -673,13 +673,13 @@ ext3_try_to_allocate(struct super_block *sb, handle_t *handle, int group,
                 if (end > EXT3_BLOCKS_PER_GROUP(sb))
                         /* reservation window crosses group boundary */
                         end = EXT3_BLOCKS_PER_GROUP(sb);
-                if ((start <= goal) && (goal < end))
-                        start = goal;
+                if ((start <= grp_goal) && (grp_goal < end))
+                        start = grp_goal;
                 else
-                        goal = -1;
+                        grp_goal = -1;
         } else {
-                if (goal > 0)
-                        start = goal;
+                if (grp_goal > 0)
+                        start = grp_goal;
                 else
                         start = 0;
                 end = EXT3_BLOCKS_PER_GROUP(sb);
@@ -688,43 +688,43 @@ ext3_try_to_allocate(struct super_block *sb, handle_t *handle, int group,
         BUG_ON(start > EXT3_BLOCKS_PER_GROUP(sb));
 
 repeat:
-        if (goal < 0 || !ext3_test_allocatable(goal, bitmap_bh)) {
-                goal = find_next_usable_block(start, bitmap_bh, end);
-                if (goal < 0)
+        if (grp_goal < 0 || !ext3_test_allocatable(grp_goal, bitmap_bh)) {
+                grp_goal = find_next_usable_block(start, bitmap_bh, end);
+                if (grp_goal < 0)
                         goto fail_access;
                 if (!my_rsv) {
                         int i;
 
-                        for (i = 0; i < 7 && goal > start &&
-                                        ext3_test_allocatable(goal - 1,
+                        for (i = 0; i < 7 && grp_goal > start &&
+                                        ext3_test_allocatable(grp_goal - 1,
                                                                 bitmap_bh);
-                                        i++, goal--)
+                                        i++, grp_goal--)
                                 ;
                 }
         }
-        start = goal;
+        start = grp_goal;
 
-        if (!claim_block(sb_bgl_lock(EXT3_SB(sb), group), goal, bitmap_bh)) {
+        if (!claim_block(sb_bgl_lock(EXT3_SB(sb), group), grp_goal, bitmap_bh)) {
                 /*
                  * The block was allocated by another thread, or it was
                  * allocated and then freed by another thread
                  */
                 start++;
-                goal++;
+                grp_goal++;
                 if (start >= end)
                         goto fail_access;
                 goto repeat;
         }
         num++;
-        goal++;
-        while (num < *count && goal < end
-                && ext3_test_allocatable(goal, bitmap_bh)
-                && claim_block(sb_bgl_lock(EXT3_SB(sb), group), goal, bitmap_bh)) {
+        grp_goal++;
+        while (num < *count && grp_goal < end
+                && ext3_test_allocatable(grp_goal, bitmap_bh)
+                && claim_block(sb_bgl_lock(EXT3_SB(sb), group), grp_goal, bitmap_bh)) {
                 num++;
-                goal++;
+                grp_goal++;
         }
         *count = num;
-        return goal - num;
+        return grp_goal - num;
 fail_access:
         *count = num;
         return -1;
@@ -766,12 +766,13 @@ fail_access:
 static int find_next_reservable_window(
                                 struct ext3_reserve_window_node *search_head,
                                 struct ext3_reserve_window_node *my_rsv,
-                                struct super_block * sb, int start_block,
-                                int last_block)
+                                struct super_block * sb,
+                                ext3_fsblk_t start_block,
+                                ext3_fsblk_t last_block)
 {
         struct rb_node *next;
         struct ext3_reserve_window_node *rsv, *prev;
-        int cur;
+        ext3_fsblk_t cur;
         int size = my_rsv->rsv_goal_size;
 
         /* TODO: make the start of the reservation window byte-aligned */
@@ -873,10 +874,10 @@ static int find_next_reservable_window(
  *
  *      @rsv: the reservation
  *
- *      @goal: The goal (group-relative).  It is where the search for a
+ *      @grp_goal: The goal (group-relative).  It is where the search for a
  *              free reservable space should start from.
- *              if we have a goal(goal >0 ), then start from there,
- *              no goal(goal = -1), we start from the first block
+ *              if we have a grp_goal(grp_goal >0 ), then start from there,
+ *              no grp_goal(grp_goal = -1), we start from the first block
  *              of the group.
  *
  *      @sb: the super block
@@ -885,25 +886,24 @@ static int find_next_reservable_window(
  *
  */
 static int alloc_new_reservation(struct ext3_reserve_window_node *my_rsv,
-                int goal, struct super_block *sb,
+                ext3_grpblk_t grp_goal, struct super_block *sb,
                 unsigned int group, struct buffer_head *bitmap_bh)
 {
         struct ext3_reserve_window_node *search_head;
-        int group_first_block, group_end_block, start_block;
-        int first_free_block;
+        ext3_fsblk_t group_first_block, group_end_block, start_block;
+        ext3_grpblk_t first_free_block;
         struct rb_root *fs_rsv_root = &EXT3_SB(sb)->s_rsv_window_root;
         unsigned long size;
         int ret;
         spinlock_t *rsv_lock = &EXT3_SB(sb)->s_rsv_window_lock;
 
-        group_first_block = le32_to_cpu(EXT3_SB(sb)->s_es->s_first_data_block) +
-                                group * EXT3_BLOCKS_PER_GROUP(sb);
+        group_first_block = ext3_group_first_block_no(sb, group);
         group_end_block = group_first_block + EXT3_BLOCKS_PER_GROUP(sb) - 1;
 
-        if (goal < 0)
+        if (grp_goal < 0)
                 start_block = group_first_block;
         else
-                start_block = goal + group_first_block;
+                start_block = grp_goal + group_first_block;
 
         size = my_rsv->rsv_goal_size;
 
@@ -1057,14 +1057,15 @@ static void try_to_extend_reservation(struct ext3_reserve_window_node *my_rsv,
  * sorted double linked list should be fast.
  *
  */
-static int
+static ext3_grpblk_t
 ext3_try_to_allocate_with_rsv(struct super_block *sb, handle_t *handle,
                         unsigned int group, struct buffer_head *bitmap_bh,
-                        int goal, struct ext3_reserve_window_node * my_rsv,
+                        ext3_grpblk_t grp_goal,
+                        struct ext3_reserve_window_node * my_rsv,
                         unsigned long *count, int *errp)
 {
-        unsigned long group_first_block;
-        int ret = 0;
+        ext3_fsblk_t group_first_block;
+        ext3_grpblk_t ret = 0;
         int fatal;
         unsigned long num = *count;
 
@@ -1090,17 +1091,16 @@ ext3_try_to_allocate_with_rsv(struct super_block *sb, handle_t *handle,
          */
         if (my_rsv == NULL ) {
                 ret = ext3_try_to_allocate(sb, handle, group, bitmap_bh,
-                                                goal, count, NULL);
+                                                grp_goal, count, NULL);
                 goto out;
         }
         /*
-         * goal is a group relative block number (if there is a goal)
-         * 0 < goal < EXT3_BLOCKS_PER_GROUP(sb)
+         * grp_goal is a group relative block number (if there is a goal)
+         * 0 < grp_goal < EXT3_BLOCKS_PER_GROUP(sb)
          * first block is a filesystem wide block number
          * first block is the block number of the first block in this group
          */
-        group_first_block = le32_to_cpu(EXT3_SB(sb)->s_es->s_first_data_block) +
-                        group * EXT3_BLOCKS_PER_GROUP(sb);
+        group_first_block = ext3_group_first_block_no(sb, group);
 
         /*
          * Basically we will allocate a new block from inode's reservation
@@ -1119,24 +1119,24 @@ ext3_try_to_allocate_with_rsv(struct super_block *sb, handle_t *handle,
          */
         while (1) {
                 if (rsv_is_empty(&my_rsv->rsv_window) || (ret < 0) ||
-                        !goal_in_my_reservation(&my_rsv->rsv_window, goal, group, sb)) {
+                        !goal_in_my_reservation(&my_rsv->rsv_window, grp_goal, group, sb)) {
                         if (my_rsv->rsv_goal_size < *count)
                                 my_rsv->rsv_goal_size = *count;
-                        ret = alloc_new_reservation(my_rsv, goal, sb,
+                        ret = alloc_new_reservation(my_rsv, grp_goal, sb,
                                                         group, bitmap_bh);
                         if (ret < 0)
                                 break;                  /* failed */
 
-                        if (!goal_in_my_reservation(&my_rsv->rsv_window, goal, group, sb))
-                                goal = -1;
-                } else if (goal > 0 && (my_rsv->rsv_end-goal+1) < *count)
+                        if (!goal_in_my_reservation(&my_rsv->rsv_window, grp_goal, group, sb))
+                                grp_goal = -1;
+                } else if (grp_goal > 0 && (my_rsv->rsv_end-grp_goal+1) < *count)
                         try_to_extend_reservation(my_rsv, sb,
-                                        *count-my_rsv->rsv_end + goal - 1);
+                                        *count-my_rsv->rsv_end + grp_goal - 1);
 
                 if ((my_rsv->rsv_start >= group_first_block + EXT3_BLOCKS_PER_GROUP(sb))
                     || (my_rsv->rsv_end < group_first_block))
                         BUG();
-                ret = ext3_try_to_allocate(sb, handle, group, bitmap_bh, goal,
+                ret = ext3_try_to_allocate(sb, handle, group, bitmap_bh, grp_goal,
                                            &num, &my_rsv->rsv_window);
                 if (ret >= 0) {
                         my_rsv->rsv_alloc_hit += num;
@@ -1164,7 +1164,7 @@ out:
 
 static int ext3_has_free_blocks(struct ext3_sb_info *sbi)
 {
-        int free_blocks, root_blocks;
+        ext3_fsblk_t free_blocks, root_blocks;
 
         free_blocks = percpu_counter_read_positive(&sbi->s_freeblocks_counter);
         root_blocks = le32_to_cpu(sbi->s_es->s_r_blocks_count);
@@ -1200,19 +1200,20 @@ int ext3_should_retry_alloc(struct super_block *sb, int *retries)
  * bitmap, and then for any free bit if that fails.
  * This function also updates quota and i_blocks field.
  */
-int ext3_new_blocks(handle_t *handle, struct inode *inode,
-                        unsigned long goal, unsigned long *count, int *errp)
+ext3_fsblk_t ext3_new_blocks(handle_t *handle, struct inode *inode,
+                        ext3_fsblk_t goal, unsigned long *count, int *errp)
 {
         struct buffer_head *bitmap_bh = NULL;
         struct buffer_head *gdp_bh;
         int group_no;
         int goal_group;
-        int ret_block;
+        ext3_grpblk_t grp_target_blk;   /* blockgroup relative goal block */
+        ext3_grpblk_t grp_alloc_blk;    /* blockgroup-relative allocated block*/
+        ext3_fsblk_t ret_block;         /* filesyetem-wide allocated block */
         int bgi;                        /* blockgroup iteration index */
-        int target_block;
         int fatal = 0, err;
         int performed_allocation = 0;
-        int free_blocks;
+        ext3_grpblk_t free_blocks;      /* number of free blocks in a group */
         struct super_block *sb;
         struct ext3_group_desc *gdp;
         struct ext3_super_block *es;
@@ -1285,16 +1286,17 @@ retry:
                 my_rsv = NULL;
 
         if (free_blocks > 0) {
-                ret_block = ((goal - le32_to_cpu(es->s_first_data_block)) %
+                grp_target_blk = ((goal - le32_to_cpu(es->s_first_data_block)) %
                                 EXT3_BLOCKS_PER_GROUP(sb));
                 bitmap_bh = read_block_bitmap(sb, group_no);
                 if (!bitmap_bh)
                         goto io_error;
-                ret_block = ext3_try_to_allocate_with_rsv(sb, handle, group_no,
-                                        bitmap_bh, ret_block, my_rsv, &num, &fatal);
+                grp_alloc_blk = ext3_try_to_allocate_with_rsv(sb, handle,
+                                        group_no, bitmap_bh, grp_target_blk,
+                                        my_rsv, &num, &fatal);
                 if (fatal)
                         goto out;
-                if (ret_block >= 0)
+                if (grp_alloc_blk >= 0)
                         goto allocated;
         }
 
@@ -1327,11 +1329,15 @@ retry:
                 bitmap_bh = read_block_bitmap(sb, group_no);
                 if (!bitmap_bh)
                         goto io_error;
-                ret_block = ext3_try_to_allocate_with_rsv(sb, handle, group_no,
-                                        bitmap_bh, -1, my_rsv, &num, &fatal);
+                /*
+                 * try to allocate block(s) from this group, without a goal(-1).
+                 */
+                grp_alloc_blk = ext3_try_to_allocate_with_rsv(sb, handle,
+                                        group_no, bitmap_bh, -1, my_rsv,
+                                        &num, &fatal);
                 if (fatal)
                         goto out;
-                if (ret_block >= 0) 
+                if (grp_alloc_blk >= 0)
                         goto allocated;
         }
         /*
@@ -1360,18 +1366,18 @@ allocated:
         if (fatal)
                 goto out;
 
-        target_block = ret_block + group_no * EXT3_BLOCKS_PER_GROUP(sb)
-                                + le32_to_cpu(es->s_first_data_block);
+        ret_block = grp_alloc_blk + ext3_group_first_block_no(sb, group_no);
 
-        if (in_range(le32_to_cpu(gdp->bg_block_bitmap), target_block, num) ||
-            in_range(le32_to_cpu(gdp->bg_inode_bitmap), target_block, num) ||
-            in_range(target_block, le32_to_cpu(gdp->bg_inode_table),
+        if (in_range(le32_to_cpu(gdp->bg_block_bitmap), ret_block, num) ||
+            in_range(le32_to_cpu(gdp->bg_inode_bitmap), ret_block, num) ||
+            in_range(ret_block, le32_to_cpu(gdp->bg_inode_table),
                       EXT3_SB(sb)->s_itb_per_group) ||
-            in_range(target_block + num - 1, le32_to_cpu(gdp->bg_inode_table),
+            in_range(ret_block + num - 1, le32_to_cpu(gdp->bg_inode_table),
                       EXT3_SB(sb)->s_itb_per_group))
                 ext3_error(sb, "ext3_new_block",
                             "Allocating block in system zone - "
-                            "blocks from %u, length %lu", target_block, num);
+                            "blocks from "E3FSBLK", length %lu",
+                             ret_block, num);
 
         performed_allocation = 1;
 
@@ -1380,7 +1386,7 @@ allocated:
                 struct buffer_head *debug_bh;
 
                 /* Record bitmap buffer state in the newly allocated block */
-                debug_bh = sb_find_get_block(sb, target_block);
+                debug_bh = sb_find_get_block(sb, ret_block);
                 if (debug_bh) {
                         BUFFER_TRACE(debug_bh, "state when allocated");
                         BUFFER_TRACE2(debug_bh, bitmap_bh, "bitmap state");
@@ -1393,24 +1399,21 @@ allocated:
                 int i;
 
                 for (i = 0; i < num; i++) {
-                        if (ext3_test_bit(ret_block,
+                        if (ext3_test_bit(grp_alloc_blk+i,
                                         bh2jh(bitmap_bh)->b_committed_data)) {
                                 printk("%s: block was unexpectedly set in "
                                         "b_committed_data\n", __FUNCTION__);
                         }
                 }
         }
-        ext3_debug("found bit %d\n", ret_block);
+        ext3_debug("found bit %d\n", grp_alloc_blk);
         spin_unlock(sb_bgl_lock(sbi, group_no));
         jbd_unlock_bh_state(bitmap_bh);
 #endif
 
-        /* ret_block was blockgroup-relative.  Now it becomes fs-relative */
-        ret_block = target_block;
-
         if (ret_block + num - 1 >= le32_to_cpu(es->s_blocks_count)) {
                 ext3_error(sb, "ext3_new_block",
-                            "block(%d) >= blocks count(%d) - "
+                            "block("E3FSBLK") >= blocks count(%d) - "
                             "block_group = %d, es == %p ", ret_block,
                         le32_to_cpu(es->s_blocks_count), group_no, es);
                 goto out;
@@ -1421,7 +1424,7 @@ allocated:
          * list of some description.  We don't know in advance whether
          * the caller wants to use it as metadata or data.
          */
-        ext3_debug("allocating block %d. Goal hits %d of %d.\n",
+        ext3_debug("allocating block %lu. Goal hits %d of %d.\n",
                         ret_block, goal_hits, goal_attempts);
 
         spin_lock(sb_bgl_lock(sbi, group_no));
@@ -1461,23 +1464,24 @@ out:
         return 0;
 }
 
-int ext3_new_block(handle_t *handle, struct inode *inode,
-                        unsigned long goal, int *errp)
+ext3_fsblk_t ext3_new_block(handle_t *handle, struct inode *inode,
+                        ext3_fsblk_t goal, int *errp)
 {
         unsigned long count = 1;
 
         return ext3_new_blocks(handle, inode, goal, &count, errp);
 }
 
-unsigned long ext3_count_free_blocks(struct super_block *sb)
+ext3_fsblk_t ext3_count_free_blocks(struct super_block *sb)
 {
-        unsigned long desc_count;
+        ext3_fsblk_t desc_count;
         struct ext3_group_desc *gdp;
         int i;
         unsigned long ngroups = EXT3_SB(sb)->s_groups_count;
 #ifdef EXT3FS_DEBUG
         struct ext3_super_block *es;
-        unsigned long bitmap_count, x;
+        ext3_fsblk_t bitmap_count;
+        unsigned long x;
         struct buffer_head *bitmap_bh = NULL;
 
         es = EXT3_SB(sb)->s_es;
@@ -1502,8 +1506,10 @@ unsigned long ext3_count_free_blocks(struct super_block *sb)
                 bitmap_count += x;
         }
         brelse(bitmap_bh);
-        printk("ext3_count_free_blocks: stored = %u, computed = %lu, %lu\n",
-               le32_to_cpu(es->s_free_blocks_count), desc_count, bitmap_count);
+        printk("ext3_count_free_blocks: stored = "E3FSBLK
+                ", computed = "E3FSBLK", "E3FSBLK"\n",
+               le32_to_cpu(es->s_free_blocks_count),
+                desc_count, bitmap_count);
         return bitmap_count;
 #else
         desc_count = 0;
@@ -1520,7 +1526,7 @@ unsigned long ext3_count_free_blocks(struct super_block *sb)
 }
 
 static inline int
-block_in_use(unsigned long block, struct super_block *sb, unsigned char *map)
+block_in_use(ext3_fsblk_t block, struct super_block *sb, unsigned char *map)
 {
         return ext3_test_bit ((block -
                 le32_to_cpu(EXT3_SB(sb)->s_es->s_first_data_block)) %
diff --git a/fs/ext3/ialloc.c b/fs/ext3/ialloc.c
index dc826464f313..36546ed36a14 100644
--- a/fs/ext3/ialloc.c
+++ b/fs/ext3/ialloc.c
@@ -262,9 +262,11 @@ static int find_group_orlov(struct super_block *sb, struct inode *parent)
         int ngroups = sbi->s_groups_count;
         int inodes_per_group = EXT3_INODES_PER_GROUP(sb);
         int freei, avefreei;
-        int freeb, avefreeb;
-        int blocks_per_dir, ndirs;
-        int max_debt, max_dirs, min_blocks, min_inodes;
+        ext3_fsblk_t freeb, avefreeb;
+        ext3_fsblk_t blocks_per_dir;
+        int ndirs;
+        int max_debt, max_dirs, min_inodes;
+        ext3_grpblk_t min_blocks;
         int group = -1, i;
         struct ext3_group_desc *desc;
         struct buffer_head *bh;
@@ -307,7 +309,7 @@ static int find_group_orlov(struct super_block *sb, struct inode *parent)
         min_inodes = avefreei - inodes_per_group / 4;
         min_blocks = avefreeb - EXT3_BLOCKS_PER_GROUP(sb) / 4;
 
-        max_debt = EXT3_BLOCKS_PER_GROUP(sb) / max(blocks_per_dir, BLOCK_COST);
+        max_debt = EXT3_BLOCKS_PER_GROUP(sb) / max(blocks_per_dir, (ext3_fsblk_t)BLOCK_COST);
         if (max_debt * INODE_COST > inodes_per_group)
                 max_debt = inodes_per_group / INODE_COST;
         if (max_debt > 255)
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index 2edd7eec88fd..0321e1b9034a 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -62,7 +62,7 @@ static int ext3_inode_is_fast_symlink(struct inode *inode)
  * still needs to be revoked.
  */
 int ext3_forget(handle_t *handle, int is_metadata, struct inode *inode,
-                        struct buffer_head *bh, int blocknr)
+                        struct buffer_head *bh, ext3_fsblk_t blocknr)
 {
         int err;
 
@@ -407,13 +407,13 @@ no_block:
  *
  *      Caller must make sure that @ind is valid and will stay that way.
  */
-static unsigned long ext3_find_near(struct inode *inode, Indirect *ind)
+static ext3_fsblk_t ext3_find_near(struct inode *inode, Indirect *ind)
 {
         struct ext3_inode_info *ei = EXT3_I(inode);
         __le32 *start = ind->bh ? (__le32*) ind->bh->b_data : ei->i_data;
         __le32 *p;
-        unsigned long bg_start;
-        unsigned long colour;
+        ext3_fsblk_t bg_start;
+        ext3_grpblk_t colour;
 
         /* Try to find previous block */
         for (p = ind->p - 1; p >= start; p--) {
@@ -429,8 +429,7 @@ static unsigned long ext3_find_near(struct inode *inode, Indirect *ind)
          * It is going to be referred to from the inode itself? OK, just put it
          * into the same cylinder group then.
          */
-        bg_start = (ei->i_block_group * EXT3_BLOCKS_PER_GROUP(inode->i_sb)) +
-                le32_to_cpu(EXT3_SB(inode->i_sb)->s_es->s_first_data_block);
+        bg_start = ext3_group_first_block_no(inode->i_sb, ei->i_block_group);
         colour = (current->pid % 16) *
                         (EXT3_BLOCKS_PER_GROUP(inode->i_sb) / 16);
         return bg_start + colour;
@@ -448,7 +447,7 @@ static unsigned long ext3_find_near(struct inode *inode, Indirect *ind)
  *      stores it in *@goal and returns zero.
  */
 
-static unsigned long ext3_find_goal(struct inode *inode, long block,
+static ext3_fsblk_t ext3_find_goal(struct inode *inode, long block,
                 Indirect chain[4], Indirect *partial)
 {
         struct ext3_block_alloc_info *block_i;
@@ -516,13 +515,13 @@ static int ext3_blks_to_allocate(Indirect *branch, int k, unsigned long blks,
  *              direct blocks
  */
 static int ext3_alloc_blocks(handle_t *handle, struct inode *inode,
-                        unsigned long goal, int indirect_blks, int blks,
-                        unsigned long long new_blocks[4], int *err)
+                        ext3_fsblk_t goal, int indirect_blks, int blks,
+                        ext3_fsblk_t new_blocks[4], int *err)
 {
         int target, i;
         unsigned long count = 0;
         int index = 0;
-        unsigned long current_block = 0;
+        ext3_fsblk_t current_block = 0;
         int ret = 0;
 
         /*
@@ -592,7 +591,7 @@ failed_out:
  *      as described above and return 0.
  */
 static int ext3_alloc_branch(handle_t *handle, struct inode *inode,
-                        int indirect_blks, int *blks, unsigned long goal,
+                        int indirect_blks, int *blks, ext3_fsblk_t goal,
                         int *offsets, Indirect *branch)
 {
         int blocksize = inode->i_sb->s_blocksize;
@@ -600,8 +599,8 @@ static int ext3_alloc_branch(handle_t *handle, struct inode *inode,
         int err = 0;
         struct buffer_head *bh;
         int num;
-        unsigned long long new_blocks[4];
-        unsigned long long current_block;
+        ext3_fsblk_t new_blocks[4];
+        ext3_fsblk_t current_block;
 
         num = ext3_alloc_blocks(handle, inode, goal, indirect_blks,
                                 *blks, new_blocks, &err);
@@ -688,7 +687,7 @@ static int ext3_splice_branch(handle_t *handle, struct inode *inode,
         int i;
         int err = 0;
         struct ext3_block_alloc_info *block_i;
-        unsigned long current_block;
+        ext3_fsblk_t current_block;
 
         block_i = EXT3_I(inode)->i_block_alloc_info;
         /*
@@ -795,13 +794,13 @@ int ext3_get_blocks_handle(handle_t *handle, struct inode *inode,
         int offsets[4];
         Indirect chain[4];
         Indirect *partial;
-        unsigned long goal;
+        ext3_fsblk_t goal;
         int indirect_blks;
         int blocks_to_boundary = 0;
         int depth;
         struct ext3_inode_info *ei = EXT3_I(inode);
         int count = 0;
-        unsigned long first_block = 0;
+        ext3_fsblk_t first_block = 0;
 
 
         J_ASSERT(handle != NULL || create == 0);
@@ -819,7 +818,7 @@ int ext3_get_blocks_handle(handle_t *handle, struct inode *inode,
                 count++;
                 /*map more blocks*/
                 while (count < maxblocks && count <= blocks_to_boundary) {
-                        unsigned long blk;
+                        ext3_fsblk_t blk;
 
                         if (!verify_chain(chain, partial)) {
                                 /*
@@ -1759,7 +1758,7 @@ void ext3_set_aops(struct inode *inode)
 static int ext3_block_truncate_page(handle_t *handle, struct page *page,
                 struct address_space *mapping, loff_t from)
 {
-        unsigned long index = from >> PAGE_CACHE_SHIFT;
+        ext3_fsblk_t index = from >> PAGE_CACHE_SHIFT;
         unsigned offset = from & (PAGE_CACHE_SIZE-1);
         unsigned blocksize, iblock, length, pos;
         struct inode *inode = mapping->host;
@@ -1960,7 +1959,7 @@ no_top:
  * than `count' because there can be holes in there.
  */
 static void ext3_clear_blocks(handle_t *handle, struct inode *inode,
-                struct buffer_head *bh, unsigned long block_to_free,
+                struct buffer_head *bh, ext3_fsblk_t block_to_free,
                 unsigned long count, __le32 *first, __le32 *last)
 {
         __le32 *p;
@@ -2022,12 +2021,12 @@ static void ext3_free_data(handle_t *handle, struct inode *inode,
                            struct buffer_head *this_bh,
                            __le32 *first, __le32 *last)
 {
-        unsigned long block_to_free = 0;    /* Starting block # of a run */
+        ext3_fsblk_t block_to_free = 0;    /* Starting block # of a run */
         unsigned long count = 0;            /* Number of blocks in the run */ 
         __le32 *block_to_free_p = NULL;     /* Pointer into inode/ind
                                                corresponding to
                                                block_to_free */
-        unsigned long nr;                   /* Current block # */
+        ext3_fsblk_t nr;                    /* Current block # */
         __le32 *p;                          /* Pointer into inode/ind
                                                for current block */
         int err;
@@ -2089,7 +2088,7 @@ static void ext3_free_branches(handle_t *handle, struct inode *inode,
                                struct buffer_head *parent_bh,
                                __le32 *first, __le32 *last, int depth)
 {
-        unsigned long nr;
+        ext3_fsblk_t nr;
         __le32 *p;
 
         if (is_handle_aborted(handle))
@@ -2113,7 +2112,7 @@ static void ext3_free_branches(handle_t *handle, struct inode *inode,
                          */
                         if (!bh) {
                                 ext3_error(inode->i_sb, "ext3_free_branches",
-                                           "Read failure, inode=%ld, block=%ld",
+                                           "Read failure, inode=%ld, block="E3FSBLK,
                                            inode->i_ino, nr);
                                 continue;
                         }
@@ -2394,11 +2393,12 @@ out_stop:
         ext3_journal_stop(handle);
 }
 
-static unsigned long ext3_get_inode_block(struct super_block *sb,
+static ext3_fsblk_t ext3_get_inode_block(struct super_block *sb,
                 unsigned long ino, struct ext3_iloc *iloc)
 {
         unsigned long desc, group_desc, block_group;
-        unsigned long offset, block;
+        unsigned long offset;
+        ext3_fsblk_t block;
         struct buffer_head *bh;
         struct ext3_group_desc * gdp;
 
@@ -2448,7 +2448,7 @@ static unsigned long ext3_get_inode_block(struct super_block *sb,
 static int __ext3_get_inode_loc(struct inode *inode,
                                 struct ext3_iloc *iloc, int in_mem)
 {
-        unsigned long block;
+        ext3_fsblk_t block;
         struct buffer_head *bh;
 
         block = ext3_get_inode_block(inode->i_sb, inode->i_ino, iloc);
@@ -2459,7 +2459,8 @@ static int __ext3_get_inode_loc(struct inode *inode,
         if (!bh) {
                 ext3_error (inode->i_sb, "ext3_get_inode_loc",
                                 "unable to read inode block - "
-                                "inode=%lu, block=%lu", inode->i_ino, block);
+                                "inode=%lu, block="E3FSBLK,
+                                 inode->i_ino, block);
                 return -EIO;
         }
         if (!buffer_uptodate(bh)) {
@@ -2540,7 +2541,7 @@ make_io:
                 if (!buffer_uptodate(bh)) {
                         ext3_error(inode->i_sb, "ext3_get_inode_loc",
                                         "unable to read inode block - "
-                                        "inode=%lu, block=%lu",
+                                        "inode=%lu, block="E3FSBLK,
                                         inode->i_ino, block);
                         brelse(bh);
                         return -EIO;
diff --git a/fs/ext3/ioctl.c b/fs/ext3/ioctl.c
index 8c22aa9a7fbb..3a6b012d120c 100644
--- a/fs/ext3/ioctl.c
+++ b/fs/ext3/ioctl.c
@@ -204,7 +204,7 @@ flags_err:
                 return 0;
         }
         case EXT3_IOC_GROUP_EXTEND: {
-                unsigned long n_blocks_count;
+                ext3_fsblk_t n_blocks_count;
                 struct super_block *sb = inode->i_sb;
                 int err;
 
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index b8f5cd1e540d..d9176dba3698 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -1379,7 +1379,6 @@ static int ext3_add_entry (handle_t *handle, struct dentry *dentry,
         int     dx_fallback=0;
 #endif
         unsigned blocksize;
-        unsigned nlen, rlen;
         u32 block, blocks;
 
         sb = dir->i_sb;
@@ -1417,8 +1416,7 @@ static int ext3_add_entry (handle_t *handle, struct dentry *dentry,
                 return retval;
         de = (struct ext3_dir_entry_2 *) bh->b_data;
         de->inode = 0;
-        de->rec_len = cpu_to_le16(rlen = blocksize);
-        nlen = 0;
+        de->rec_len = cpu_to_le16(blocksize);
         return add_dirent_to_buf(handle, dentry, inode, de, bh);
 }
 
diff --git a/fs/ext3/resize.c b/fs/ext3/resize.c
index 34b39e9a1e5a..dfd811895d8f 100644
--- a/fs/ext3/resize.c
+++ b/fs/ext3/resize.c
@@ -28,16 +28,16 @@ static int verify_group_input(struct super_block *sb,
 {
         struct ext3_sb_info *sbi = EXT3_SB(sb);
         struct ext3_super_block *es = sbi->s_es;
-        unsigned start = le32_to_cpu(es->s_blocks_count);
-        unsigned end = start + input->blocks_count;
+        ext3_fsblk_t start = le32_to_cpu(es->s_blocks_count);
+        ext3_fsblk_t end = start + input->blocks_count;
         unsigned group = input->group;
-        unsigned itend = input->inode_table + sbi->s_itb_per_group;
+        ext3_fsblk_t itend = input->inode_table + sbi->s_itb_per_group;
         unsigned overhead = ext3_bg_has_super(sb, group) ?
                 (1 + ext3_bg_num_gdb(sb, group) +
                  le16_to_cpu(es->s_reserved_gdt_blocks)) : 0;
-        unsigned metaend = start + overhead;
+        ext3_fsblk_t metaend = start + overhead;
         struct buffer_head *bh = NULL;
-        int free_blocks_count;
+        ext3_grpblk_t free_blocks_count;
         int err = -EINVAL;
 
         input->free_blocks_count = free_blocks_count =
@@ -64,7 +64,8 @@ static int verify_group_input(struct super_block *sb,
                 ext3_warning(sb, __FUNCTION__, "Bad blocks count %u",
                              input->blocks_count);
         else if (!(bh = sb_bread(sb, end - 1)))
-                ext3_warning(sb, __FUNCTION__, "Cannot read last block (%u)",
+                ext3_warning(sb, __FUNCTION__,
+                             "Cannot read last block ("E3FSBLK")",
                              end - 1);
         else if (outside(input->block_bitmap, start, end))
                 ext3_warning(sb, __FUNCTION__,
@@ -77,7 +78,7 @@ static int verify_group_input(struct super_block *sb,
         else if (outside(input->inode_table, start, end) ||
                  outside(itend - 1, start, end))
                 ext3_warning(sb, __FUNCTION__,
-                             "Inode table not in group (blocks %u-%u)",
+                             "Inode table not in group (blocks %u-"E3FSBLK")",
                              input->inode_table, itend - 1);
         else if (input->inode_bitmap == input->block_bitmap)
                 ext3_warning(sb, __FUNCTION__,
@@ -85,24 +86,27 @@ static int verify_group_input(struct super_block *sb,
                              input->block_bitmap);
         else if (inside(input->block_bitmap, input->inode_table, itend))
                 ext3_warning(sb, __FUNCTION__,
-                             "Block bitmap (%u) in inode table (%u-%u)",
+                             "Block bitmap (%u) in inode table (%u-"E3FSBLK")",
                              input->block_bitmap, input->inode_table, itend-1);
         else if (inside(input->inode_bitmap, input->inode_table, itend))
                 ext3_warning(sb, __FUNCTION__,
-                             "Inode bitmap (%u) in inode table (%u-%u)",
+                             "Inode bitmap (%u) in inode table (%u-"E3FSBLK")",
                              input->inode_bitmap, input->inode_table, itend-1);
         else if (inside(input->block_bitmap, start, metaend))
                 ext3_warning(sb, __FUNCTION__,
-                             "Block bitmap (%u) in GDT table (%u-%u)",
+                             "Block bitmap (%u) in GDT table"
+                             " ("E3FSBLK"-"E3FSBLK")",
                              input->block_bitmap, start, metaend - 1);
         else if (inside(input->inode_bitmap, start, metaend))
                 ext3_warning(sb, __FUNCTION__,
-                             "Inode bitmap (%u) in GDT table (%u-%u)",
+                             "Inode bitmap (%u) in GDT table"
+                             " ("E3FSBLK"-"E3FSBLK")",
                              input->inode_bitmap, start, metaend - 1);
         else if (inside(input->inode_table, start, metaend) ||
                  inside(itend - 1, start, metaend))
                 ext3_warning(sb, __FUNCTION__,
-                             "Inode table (%u-%u) overlaps GDT table (%u-%u)",
+                             "Inode table (%u-"E3FSBLK") overlaps"
+                             "GDT table ("E3FSBLK"-"E3FSBLK")",
                              input->inode_table, itend - 1, start, metaend - 1);
         else
                 err = 0;
@@ -112,7 +116,7 @@ static int verify_group_input(struct super_block *sb,
 }
 
 static struct buffer_head *bclean(handle_t *handle, struct super_block *sb,
-                                  unsigned long blk)
+                                  ext3_fsblk_t blk)
 {
         struct buffer_head *bh;
         int err;
@@ -163,15 +167,14 @@ static int setup_new_group_blocks(struct super_block *sb,
                                   struct ext3_new_group_data *input)
 {
         struct ext3_sb_info *sbi = EXT3_SB(sb);
-        unsigned long start = input->group * sbi->s_blocks_per_group +
-                le32_to_cpu(sbi->s_es->s_first_data_block);
+        ext3_fsblk_t start = ext3_group_first_block_no(sb, input->group);
         int reserved_gdb = ext3_bg_has_super(sb, input->group) ?
                 le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) : 0;
         unsigned long gdblocks = ext3_bg_num_gdb(sb, input->group);
         struct buffer_head *bh;
         handle_t *handle;
-        unsigned long block;
-        int bit;
+        ext3_fsblk_t block;
+        ext3_grpblk_t bit;
         int i;
         int err = 0, err2;
 
@@ -328,7 +331,7 @@ static unsigned ext3_list_backups(struct super_block *sb, unsigned *three,
 static int verify_reserved_gdb(struct super_block *sb,
                                struct buffer_head *primary)
 {
-        const unsigned long blk = primary->b_blocknr;
+        const ext3_fsblk_t blk = primary->b_blocknr;
         const unsigned long end = EXT3_SB(sb)->s_groups_count;
         unsigned three = 1;
         unsigned five = 5;
@@ -340,7 +343,8 @@ static int verify_reserved_gdb(struct super_block *sb,
         while ((grp = ext3_list_backups(sb, &three, &five, &seven)) < end) {
                 if (le32_to_cpu(*p++) != grp * EXT3_BLOCKS_PER_GROUP(sb) + blk){
                         ext3_warning(sb, __FUNCTION__,
-                                     "reserved GDT %ld missing grp %d (%ld)",
+                                     "reserved GDT "E3FSBLK
+                                     " missing grp %d ("E3FSBLK")",
                                      blk, grp,
                                      grp * EXT3_BLOCKS_PER_GROUP(sb) + blk);
                         return -EINVAL;
@@ -372,7 +376,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
         struct super_block *sb = inode->i_sb;
         struct ext3_super_block *es = EXT3_SB(sb)->s_es;
         unsigned long gdb_num = input->group / EXT3_DESC_PER_BLOCK(sb);
-        unsigned long gdblock = EXT3_SB(sb)->s_sbh->b_blocknr + 1 + gdb_num;
+        ext3_fsblk_t gdblock = EXT3_SB(sb)->s_sbh->b_blocknr + 1 + gdb_num;
         struct buffer_head **o_group_desc, **n_group_desc;
         struct buffer_head *dind;
         int gdbackups;
@@ -417,7 +421,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
         data = (__u32 *)dind->b_data;
         if (le32_to_cpu(data[gdb_num % EXT3_ADDR_PER_BLOCK(sb)]) != gdblock) {
                 ext3_warning(sb, __FUNCTION__,
-                             "new group %u GDT block %lu not reserved",
+                             "new group %u GDT block "E3FSBLK" not reserved",
                              input->group, gdblock);
                 err = -EINVAL;
                 goto exit_dind;
@@ -515,7 +519,7 @@ static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
         struct buffer_head **primary;
         struct buffer_head *dind;
         struct ext3_iloc iloc;
-        unsigned long blk;
+        ext3_fsblk_t blk;
         __u32 *data, *end;
         int gdbackups = 0;
         int res, i;
@@ -540,7 +544,8 @@ static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
         for (res = 0; res < reserved_gdb; res++, blk++) {
                 if (le32_to_cpu(*data) != blk) {
                         ext3_warning(sb, __FUNCTION__,
-                                     "reserved block %lu not at offset %ld",
+                                     "reserved block "E3FSBLK
+                                     " not at offset %ld",
                                      blk, (long)(data - (__u32 *)dind->b_data));
                         err = -EINVAL;
                         goto exit_bh;
@@ -902,15 +907,16 @@ exit_put:
  * GDT blocks are reserved to grow to the desired size.
  */
 int ext3_group_extend(struct super_block *sb, struct ext3_super_block *es,
-                      unsigned long n_blocks_count)
+                      ext3_fsblk_t n_blocks_count)
 {
-        unsigned long o_blocks_count;
+        ext3_fsblk_t o_blocks_count;
         unsigned long o_groups_count;
-        unsigned long last;
-        int add;
+        ext3_grpblk_t last;
+        ext3_grpblk_t add;
         struct buffer_head * bh;
         handle_t *handle;
-        int err, freed_blocks;
+        int err;
+        unsigned long freed_blocks;
 
         /* We don't need to worry about locking wrt other resizers just
          * yet: we're going to revalidate es->s_blocks_count after
@@ -919,12 +925,22 @@ int ext3_group_extend(struct super_block *sb, struct ext3_super_block *es,
         o_groups_count = EXT3_SB(sb)->s_groups_count;
 
         if (test_opt(sb, DEBUG))
-                printk(KERN_DEBUG "EXT3-fs: extending last group from %lu to %lu blocks\n",
+                printk(KERN_DEBUG "EXT3-fs: extending last group from "E3FSBLK" uto "E3FSBLK" blocks\n",
                        o_blocks_count, n_blocks_count);
 
         if (n_blocks_count == 0 || n_blocks_count == o_blocks_count)
                 return 0;
 
+        if (n_blocks_count > (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) {
+                printk(KERN_ERR "EXT3-fs: filesystem on %s:"
+                        " too large to resize to %lu blocks safely\n",
+                        sb->s_id, n_blocks_count);
+                if (sizeof(sector_t) < 8)
+                        ext3_warning(sb, __FUNCTION__,
+                        "CONFIG_LBD not enabled\n");
+                return -EINVAL;
+        }
+
         if (n_blocks_count < o_blocks_count) {
                 ext3_warning(sb, __FUNCTION__,
                              "can't shrink FS - resize aborted");
@@ -948,7 +964,8 @@ int ext3_group_extend(struct super_block *sb, struct ext3_super_block *es,
 
         if (o_blocks_count + add < n_blocks_count)
                 ext3_warning(sb, __FUNCTION__,
-                             "will only finish group (%lu blocks, %u new)",
+                             "will only finish group ("E3FSBLK
+                             " blocks, %u new)",
                              o_blocks_count + add, add);
 
         /* See if the device is actually as big as what was requested */
@@ -991,10 +1008,10 @@ int ext3_group_extend(struct super_block *sb, struct ext3_super_block *es,
         ext3_journal_dirty_metadata(handle, EXT3_SB(sb)->s_sbh);
         sb->s_dirt = 1;
         unlock_super(sb);
-        ext3_debug("freeing blocks %ld through %ld\n", o_blocks_count,
+        ext3_debug("freeing blocks %lu through "E3FSBLK"\n", o_blocks_count,
                    o_blocks_count + add);
         ext3_free_blocks_sb(handle, sb, o_blocks_count, add, &freed_blocks);
-        ext3_debug("freed blocks %ld through %ld\n", o_blocks_count,
+        ext3_debug("freed blocks "E3FSBLK" through "E3FSBLK"\n", o_blocks_count,
                    o_blocks_count + add);
         if ((err = ext3_journal_stop(handle)))
                 goto exit_put;
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index a60cc6ec130f..b2891cc29db1 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -689,14 +689,15 @@ static match_table_t tokens = {
         {Opt_resize, "resize"},
 };
 
-static unsigned long get_sb_block(void **data)
+static ext3_fsblk_t get_sb_block(void **data)
 {
-        unsigned long   sb_block;
+        ext3_fsblk_t    sb_block;
         char            *options = (char *) *data;
 
         if (!options || strncmp(options, "sb=", 3) != 0)
                 return 1;       /* Default location */
         options += 3;
+        /*todo: use simple_strtoll with >32bit ext3 */
         sb_block = simple_strtoul(options, &options, 0);
         if (*options && *options != ',') {
                 printk("EXT3-fs: Invalid sb specification: %s\n",
@@ -711,7 +712,7 @@ static unsigned long get_sb_block(void **data)
 
 static int parse_options (char *options, struct super_block *sb,
                           unsigned long *inum, unsigned long *journal_devnum,
-                          unsigned long *n_blocks_count, int is_remount)
+                          ext3_fsblk_t *n_blocks_count, int is_remount)
 {
         struct ext3_sb_info *sbi = EXT3_SB(sb);
         char * p;
@@ -1128,7 +1129,7 @@ static int ext3_setup_super(struct super_block *sb, struct ext3_super_block *es,
 static int ext3_check_descriptors (struct super_block * sb)
 {
         struct ext3_sb_info *sbi = EXT3_SB(sb);
-        unsigned long block = le32_to_cpu(sbi->s_es->s_first_data_block);
+        ext3_fsblk_t block = le32_to_cpu(sbi->s_es->s_first_data_block);
         struct ext3_group_desc * gdp = NULL;
         int desc_block = 0;
         int i;
@@ -1315,15 +1316,14 @@ static loff_t ext3_max_size(int bits)
         return res;
 }
 
-static unsigned long descriptor_loc(struct super_block *sb,
-                                    unsigned long logic_sb_block,
+static ext3_fsblk_t descriptor_loc(struct super_block *sb,
+                                    ext3_fsblk_t logic_sb_block,
                                     int nr)
 {
         struct ext3_sb_info *sbi = EXT3_SB(sb);
-        unsigned long bg, first_data_block, first_meta_bg;
+        unsigned long bg, first_meta_bg;
         int has_super = 0;
 
-        first_data_block = le32_to_cpu(sbi->s_es->s_first_data_block);
         first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
 
         if (!EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_META_BG) ||
@@ -1332,7 +1332,7 @@ static unsigned long descriptor_loc(struct super_block *sb,
         bg = sbi->s_desc_per_block * nr;
         if (ext3_bg_has_super(sb, bg))
                 has_super = 1;
-        return (first_data_block + has_super + (bg * sbi->s_blocks_per_group));
+        return (has_super + ext3_group_first_block_no(sb, bg));
 }
 
 
@@ -1341,9 +1341,9 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
         struct buffer_head * bh;
         struct ext3_super_block *es = NULL;
         struct ext3_sb_info *sbi;
-        unsigned long block;
-        unsigned long sb_block = get_sb_block(&data);
-        unsigned long logic_sb_block;
+        ext3_fsblk_t block;
+        ext3_fsblk_t sb_block = get_sb_block(&data);
+        ext3_fsblk_t logic_sb_block;
         unsigned long offset = 0;
         unsigned long journal_inum = 0;
         unsigned long journal_devnum = 0;
@@ -1565,6 +1565,16 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
                 goto failed_mount;
         }
 
+        if (le32_to_cpu(es->s_blocks_count) >
+                    (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) {
+                printk(KERN_ERR "EXT3-fs: filesystem on %s:"
+                        " too large to mount safely\n", sb->s_id);
+                if (sizeof(sector_t) < 8)
+                        printk(KERN_WARNING "EXT3-fs: CONFIG_LBD not "
+                                        "enabled\n");
+                goto failed_mount;
+        }
+
         if (EXT3_BLOCKS_PER_GROUP(sb) == 0)
                 goto cantfind_ext3;
         sbi->s_groups_count = (le32_to_cpu(es->s_blocks_count) -
@@ -1593,7 +1603,7 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
                 }
         }
         if (!ext3_check_descriptors (sb)) {
-                printk (KERN_ERR "EXT3-fs: group descriptors corrupted !\n");
+                printk(KERN_ERR "EXT3-fs: group descriptors corrupted!\n");
                 goto failed_mount2;
         }
         sbi->s_gdb_count = db_count;
@@ -1830,10 +1840,10 @@ static journal_t *ext3_get_dev_journal(struct super_block *sb,
 {
         struct buffer_head * bh;
         journal_t *journal;
-        int start;
-        int len;
+        ext3_fsblk_t start;
+        ext3_fsblk_t len;
         int hblock, blocksize;
-        unsigned long sb_block;
+        ext3_fsblk_t sb_block;
         unsigned long offset;
         struct ext3_super_block * es;
         struct block_device *bdev;
@@ -2206,7 +2216,7 @@ static int ext3_remount (struct super_block * sb, int * flags, char * data)
 {
         struct ext3_super_block * es;
         struct ext3_sb_info *sbi = EXT3_SB(sb);
-        unsigned long n_blocks_count = 0;
+        ext3_fsblk_t n_blocks_count = 0;
         unsigned long old_sb_flags;
         struct ext3_mount_options old_opts;
         int err;
@@ -2326,7 +2336,7 @@ static int ext3_statfs (struct dentry * dentry, struct kstatfs * buf)
         struct super_block *sb = dentry->d_sb;
         struct ext3_sb_info *sbi = EXT3_SB(sb);
         struct ext3_super_block *es = sbi->s_es;
-        unsigned long overhead;
+        ext3_fsblk_t overhead;
         int i;
 
         if (test_opt (sb, MINIX_DF))
diff --git a/fs/ext3/xattr.c b/fs/ext3/xattr.c
index e8d60bf6b7df..a44a0562203a 100644
--- a/fs/ext3/xattr.c
+++ b/fs/ext3/xattr.c
@@ -225,7 +225,7 @@ ext3_xattr_block_get(struct inode *inode, int name_index, const char *name,
         error = -ENODATA;
         if (!EXT3_I(inode)->i_file_acl)
                 goto cleanup;
-        ea_idebug(inode, "reading block %d", EXT3_I(inode)->i_file_acl);
+        ea_idebug(inode, "reading block %u", EXT3_I(inode)->i_file_acl);
         bh = sb_bread(inode->i_sb, EXT3_I(inode)->i_file_acl);
         if (!bh)
                 goto cleanup;
@@ -233,7 +233,7 @@ ext3_xattr_block_get(struct inode *inode, int name_index, const char *name,
                 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
         if (ext3_xattr_check_block(bh)) {
 bad_block:      ext3_error(inode->i_sb, __FUNCTION__,
-                           "inode %ld: bad block %d", inode->i_ino,
+                           "inode %ld: bad block "E3FSBLK, inode->i_ino,
                            EXT3_I(inode)->i_file_acl);
                 error = -EIO;
                 goto cleanup;
@@ -366,7 +366,7 @@ ext3_xattr_block_list(struct inode *inode, char *buffer, size_t buffer_size)
         error = 0;
         if (!EXT3_I(inode)->i_file_acl)
                 goto cleanup;
-        ea_idebug(inode, "reading block %d", EXT3_I(inode)->i_file_acl);
+        ea_idebug(inode, "reading block %u", EXT3_I(inode)->i_file_acl);
         bh = sb_bread(inode->i_sb, EXT3_I(inode)->i_file_acl);
         error = -EIO;
         if (!bh)
@@ -375,7 +375,7 @@ ext3_xattr_block_list(struct inode *inode, char *buffer, size_t buffer_size)
                 atomic_read(&(bh->b_count)), le32_to_cpu(BHDR(bh)->h_refcount));
         if (ext3_xattr_check_block(bh)) {
                 ext3_error(inode->i_sb, __FUNCTION__,
-                           "inode %ld: bad block %d", inode->i_ino,
+                           "inode %ld: bad block "E3FSBLK, inode->i_ino,
                            EXT3_I(inode)->i_file_acl);
                 error = -EIO;
                 goto cleanup;
@@ -647,7 +647,7 @@ ext3_xattr_block_find(struct inode *inode, struct ext3_xattr_info *i,
                         le32_to_cpu(BHDR(bs->bh)->h_refcount));
                 if (ext3_xattr_check_block(bs->bh)) {
                         ext3_error(sb, __FUNCTION__,
-                                "inode %ld: bad block %d", inode->i_ino,
+                                "inode %ld: bad block "E3FSBLK, inode->i_ino,
                                 EXT3_I(inode)->i_file_acl);
                         error = -EIO;
                         goto cleanup;
@@ -792,11 +792,12 @@ inserted:
                         get_bh(new_bh);
                 } else {
                         /* We need to allocate a new block */
-                        int goal = le32_to_cpu(
+                        ext3_fsblk_t goal = le32_to_cpu(
                                         EXT3_SB(sb)->s_es->s_first_data_block) +
-                                EXT3_I(inode)->i_block_group *
+                                (ext3_fsblk_t)EXT3_I(inode)->i_block_group *
                                 EXT3_BLOCKS_PER_GROUP(sb);
-                        int block = ext3_new_block(handle, inode, goal, &error);
+                        ext3_fsblk_t block = ext3_new_block(handle, inode,
+                                                        goal, &error);
                         if (error)
                                 goto cleanup;
                         ea_idebug(inode, "creating block %d", block);
@@ -847,7 +848,7 @@ cleanup_dquot:
 
 bad_block:
         ext3_error(inode->i_sb, __FUNCTION__,
-                   "inode %ld: bad block %d", inode->i_ino,
+                   "inode %ld: bad block "E3FSBLK, inode->i_ino,
                    EXT3_I(inode)->i_file_acl);
         goto cleanup;
 
@@ -1076,14 +1077,14 @@ ext3_xattr_delete_inode(handle_t *handle, struct inode *inode)
         bh = sb_bread(inode->i_sb, EXT3_I(inode)->i_file_acl);
         if (!bh) {
                 ext3_error(inode->i_sb, __FUNCTION__,
-                        "inode %ld: block %d read error", inode->i_ino,
+                        "inode %ld: block "E3FSBLK" read error", inode->i_ino,
                         EXT3_I(inode)->i_file_acl);
                 goto cleanup;
         }
         if (BHDR(bh)->h_magic != cpu_to_le32(EXT3_XATTR_MAGIC) ||
             BHDR(bh)->h_blocks != cpu_to_le32(1)) {
                 ext3_error(inode->i_sb, __FUNCTION__,
-                        "inode %ld: bad block %d", inode->i_ino,
+                        "inode %ld: bad block "E3FSBLK, inode->i_ino,
                         EXT3_I(inode)->i_file_acl);
                 goto cleanup;
         }
@@ -1210,11 +1211,11 @@ again:
                 bh = sb_bread(inode->i_sb, ce->e_block);
                 if (!bh) {
                         ext3_error(inode->i_sb, __FUNCTION__,
-                                "inode %ld: block %ld read error",
+                                "inode %ld: block %lu read error",
                                 inode->i_ino, (unsigned long) ce->e_block);
                 } else if (le32_to_cpu(BHDR(bh)->h_refcount) >=
                                 EXT3_XATTR_REFCOUNT_MAX) {
-                        ea_idebug(inode, "block %ld refcount %d>=%d",
+                        ea_idebug(inode, "block %lu refcount %d>=%d",
                                   (unsigned long) ce->e_block,
                                   le32_to_cpu(BHDR(bh)->h_refcount),
                                           EXT3_XATTR_REFCOUNT_MAX);
diff --git a/fs/freevxfs/vxfs.h b/fs/freevxfs/vxfs.h
index 583bd78086d8..d35979a58743 100644
--- a/fs/freevxfs/vxfs.h
+++ b/fs/freevxfs/vxfs.h
@@ -159,11 +159,11 @@ struct vxfs_sb {
  * In core superblock filesystem private data for VxFS.
  */
 struct vxfs_sb_info {
-        struct vxfs_sb          *vsi_raw;       /* raw (on disk) supeblock */
+        struct vxfs_sb          *vsi_raw;       /* raw (on disk) superblock */
         struct buffer_head      *vsi_bp;        /* buffer for raw superblock*/
         struct inode            *vsi_fship;     /* fileset header inode */
         struct inode            *vsi_ilist;     /* inode list inode */
-        struct inode            *vsi_stilist;   /* structual inode list inode */
+        struct inode            *vsi_stilist;   /* structural inode list inode */
         u_long                  vsi_iext;       /* initial inode list */
         ino_t                   vsi_fshino;     /* fileset header inode */
         daddr_t                 vsi_oltext;     /* OLT extent */
diff --git a/fs/freevxfs/vxfs_fshead.c b/fs/freevxfs/vxfs_fshead.c
index 6dee109aeea4..78948b4b1894 100644
--- a/fs/freevxfs/vxfs_fshead.c
+++ b/fs/freevxfs/vxfs_fshead.c
@@ -112,7 +112,7 @@ vxfs_read_fshead(struct super_block *sbp)
 
         vip = vxfs_blkiget(sbp, infp->vsi_iext, infp->vsi_fshino);
         if (!vip) {
-                printk(KERN_ERR "vxfs: unabled to read fsh inode\n");
+                printk(KERN_ERR "vxfs: unable to read fsh inode\n");
                 return -EINVAL;
         }
         if (!VXFS_ISFSH(vip)) {
@@ -129,13 +129,13 @@ vxfs_read_fshead(struct super_block *sbp)
 
         infp->vsi_fship = vxfs_get_fake_inode(sbp, vip);
         if (!infp->vsi_fship) {
-                printk(KERN_ERR "vxfs: unabled to get fsh inode\n");
+                printk(KERN_ERR "vxfs: unable to get fsh inode\n");
                 goto out_free_fship;
         }
 
         sfp = vxfs_getfsh(infp->vsi_fship, 0);
         if (!sfp) {
-                printk(KERN_ERR "vxfs: unabled to get structural fsh\n");
+                printk(KERN_ERR "vxfs: unable to get structural fsh\n");
                 goto out_iput_fship;
         } 
 
@@ -145,7 +145,7 @@ vxfs_read_fshead(struct super_block *sbp)
 
         pfp = vxfs_getfsh(infp->vsi_fship, 1);
         if (!pfp) {
-                printk(KERN_ERR "vxfs: unabled to get primary fsh\n");
+                printk(KERN_ERR "vxfs: unable to get primary fsh\n");
                 goto out_free_sfp;
         }
 
@@ -159,7 +159,7 @@ vxfs_read_fshead(struct super_block *sbp)
 
         infp->vsi_stilist = vxfs_get_fake_inode(sbp, tip);
         if (!infp->vsi_stilist) {
-                printk(KERN_ERR "vxfs: unabled to get structual list inode\n");
+                printk(KERN_ERR "vxfs: unable to get structural list inode\n");
                 kfree(tip);
                 goto out_free_pfp;
         }
@@ -174,7 +174,7 @@ vxfs_read_fshead(struct super_block *sbp)
                 goto out_iput_stilist;
         infp->vsi_ilist = vxfs_get_fake_inode(sbp, tip);
         if (!infp->vsi_ilist) {
-                printk(KERN_ERR "vxfs: unabled to get inode list inode\n");
+                printk(KERN_ERR "vxfs: unable to get inode list inode\n");
                 kfree(tip);
                 goto out_iput_stilist;
         }
diff --git a/fs/fuse/Makefile b/fs/fuse/Makefile
index c3e1f760cac9..72437065f6ad 100644
--- a/fs/fuse/Makefile
+++ b/fs/fuse/Makefile
@@ -4,4 +4,4 @@
 
 obj-$(CONFIG_FUSE_FS) += fuse.o
 
-fuse-objs := dev.o dir.o file.o inode.o
+fuse-objs := dev.o dir.o file.o inode.o control.o
diff --git a/fs/fuse/control.c b/fs/fuse/control.c
new file mode 100644
index 000000000000..a3bce3a77253
--- /dev/null
+++ b/fs/fuse/control.c
@@ -0,0 +1,218 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2006  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU GPL.
+  See the file COPYING.
+*/
+
+#include "fuse_i.h"
+
+#include <linux/init.h>
+#include <linux/module.h>
+
+#define FUSE_CTL_SUPER_MAGIC 0x65735543
+
+/*
+ * This is non-NULL when the single instance of the control filesystem
+ * exists.  Protected by fuse_mutex
+ */
+static struct super_block *fuse_control_sb;
+
+static struct fuse_conn *fuse_ctl_file_conn_get(struct file *file)
+{
+        struct fuse_conn *fc;
+        mutex_lock(&fuse_mutex);
+        fc = file->f_dentry->d_inode->u.generic_ip;
+        if (fc)
+                fc = fuse_conn_get(fc);
+        mutex_unlock(&fuse_mutex);
+        return fc;
+}
+
+static ssize_t fuse_conn_abort_write(struct file *file, const char __user *buf,
+                                     size_t count, loff_t *ppos)
+{
+        struct fuse_conn *fc = fuse_ctl_file_conn_get(file);
+        if (fc) {
+                fuse_abort_conn(fc);
+                fuse_conn_put(fc);
+        }
+        return count;
+}
+
+static ssize_t fuse_conn_waiting_read(struct file *file, char __user *buf,
+                                      size_t len, loff_t *ppos)
+{
+        char tmp[32];
+        size_t size;
+
+        if (!*ppos) {
+                struct fuse_conn *fc = fuse_ctl_file_conn_get(file);
+                if (!fc)
+                        return 0;
+
+                file->private_data=(void *)(long)atomic_read(&fc->num_waiting);
+                fuse_conn_put(fc);
+        }
+        size = sprintf(tmp, "%ld\n", (long)file->private_data);
+        return simple_read_from_buffer(buf, len, ppos, tmp, size);
+}
+
+static const struct file_operations fuse_ctl_abort_ops = {
+        .open = nonseekable_open,
+        .write = fuse_conn_abort_write,
+};
+
+static const struct file_operations fuse_ctl_waiting_ops = {
+        .open = nonseekable_open,
+        .read = fuse_conn_waiting_read,
+};
+
+static struct dentry *fuse_ctl_add_dentry(struct dentry *parent,
+                                          struct fuse_conn *fc,
+                                          const char *name,
+                                          int mode, int nlink,
+                                          struct inode_operations *iop,
+                                          const struct file_operations *fop)
+{
+        struct dentry *dentry;
+        struct inode *inode;
+
+        BUG_ON(fc->ctl_ndents >= FUSE_CTL_NUM_DENTRIES);
+        dentry = d_alloc_name(parent, name);
+        if (!dentry)
+                return NULL;
+
+        fc->ctl_dentry[fc->ctl_ndents++] = dentry;
+        inode = new_inode(fuse_control_sb);
+        if (!inode)
+                return NULL;
+
+        inode->i_mode = mode;
+        inode->i_uid = fc->user_id;
+        inode->i_gid = fc->group_id;
+        inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+        /* setting ->i_op to NULL is not allowed */
+        if (iop)
+                inode->i_op = iop;
+        inode->i_fop = fop;
+        inode->i_nlink = nlink;
+        inode->u.generic_ip = fc;
+        d_add(dentry, inode);
+        return dentry;
+}
+
+/*
+ * Add a connection to the control filesystem (if it exists).  Caller
+ * must host fuse_mutex
+ */
+int fuse_ctl_add_conn(struct fuse_conn *fc)
+{
+        struct dentry *parent;
+        char name[32];
+
+        if (!fuse_control_sb)
+                return 0;
+
+        parent = fuse_control_sb->s_root;
+        parent->d_inode->i_nlink++;
+        sprintf(name, "%llu", (unsigned long long) fc->id);
+        parent = fuse_ctl_add_dentry(parent, fc, name, S_IFDIR | 0500, 2,
+                                     &simple_dir_inode_operations,
+                                     &simple_dir_operations);
+        if (!parent)
+                goto err;
+
+        if (!fuse_ctl_add_dentry(parent, fc, "waiting", S_IFREG | 0400, 1,
+                                NULL, &fuse_ctl_waiting_ops) ||
+            !fuse_ctl_add_dentry(parent, fc, "abort", S_IFREG | 0200, 1,
+                                 NULL, &fuse_ctl_abort_ops))
+                goto err;
+
+        return 0;
+
+ err:
+        fuse_ctl_remove_conn(fc);
+        return -ENOMEM;
+}
+
+/*
+ * Remove a connection from the control filesystem (if it exists).
+ * Caller must host fuse_mutex
+ */
+void fuse_ctl_remove_conn(struct fuse_conn *fc)
+{
+        int i;
+
+        if (!fuse_control_sb)
+                return;
+
+        for (i = fc->ctl_ndents - 1; i >= 0; i--) {
+                struct dentry *dentry = fc->ctl_dentry[i];
+                dentry->d_inode->u.generic_ip = NULL;
+                d_drop(dentry);
+                dput(dentry);
+        }
+        fuse_control_sb->s_root->d_inode->i_nlink--;
+}
+
+static int fuse_ctl_fill_super(struct super_block *sb, void *data, int silent)
+{
+        struct tree_descr empty_descr = {""};
+        struct fuse_conn *fc;
+        int err;
+
+        err = simple_fill_super(sb, FUSE_CTL_SUPER_MAGIC, &empty_descr);
+        if (err)
+                return err;
+
+        mutex_lock(&fuse_mutex);
+        BUG_ON(fuse_control_sb);
+        fuse_control_sb = sb;
+        list_for_each_entry(fc, &fuse_conn_list, entry) {
+                err = fuse_ctl_add_conn(fc);
+                if (err) {
+                        fuse_control_sb = NULL;
+                        mutex_unlock(&fuse_mutex);
+                        return err;
+                }
+        }
+        mutex_unlock(&fuse_mutex);
+
+        return 0;
+}
+
+static int fuse_ctl_get_sb(struct file_system_type *fs_type, int flags,
+                        const char *dev_name, void *raw_data,
+                        struct vfsmount *mnt)
+{
+        return get_sb_single(fs_type, flags, raw_data,
+                                fuse_ctl_fill_super, mnt);
+}
+
+static void fuse_ctl_kill_sb(struct super_block *sb)
+{
+        mutex_lock(&fuse_mutex);
+        fuse_control_sb = NULL;
+        mutex_unlock(&fuse_mutex);
+
+        kill_litter_super(sb);
+}
+
+static struct file_system_type fuse_ctl_fs_type = {
+        .owner          = THIS_MODULE,
+        .name           = "fusectl",
+        .get_sb         = fuse_ctl_get_sb,
+        .kill_sb        = fuse_ctl_kill_sb,
+};
+
+int __init fuse_ctl_init(void)
+{
+        return register_filesystem(&fuse_ctl_fs_type);
+}
+
+void fuse_ctl_cleanup(void)
+{
+        unregister_filesystem(&fuse_ctl_fs_type);
+}
diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c
index 104a62dadb94..1e2006caf158 100644
--- a/fs/fuse/dev.c
+++ b/fs/fuse/dev.c
@@ -34,6 +34,7 @@ static void fuse_request_init(struct fuse_req *req)
 {
         memset(req, 0, sizeof(*req));
         INIT_LIST_HEAD(&req->list);
+        INIT_LIST_HEAD(&req->intr_entry);
         init_waitqueue_head(&req->waitq);
         atomic_set(&req->count, 1);
 }
@@ -64,18 +65,6 @@ static void restore_sigs(sigset_t *oldset)
         sigprocmask(SIG_SETMASK, oldset, NULL);
 }
 
-/*
- * Reset request, so that it can be reused
- *
- * The caller must be _very_ careful to make sure, that it is holding
- * the only reference to req
- */
-void fuse_reset_request(struct fuse_req *req)
-{
-        BUG_ON(atomic_read(&req->count) != 1);
-        fuse_request_init(req);
-}
-
 static void __fuse_get_request(struct fuse_req *req)
 {
         atomic_inc(&req->count);
@@ -88,6 +77,13 @@ static void __fuse_put_request(struct fuse_req *req)
         atomic_dec(&req->count);
 }
 
+static void fuse_req_init_context(struct fuse_req *req)
+{
+        req->in.h.uid = current->fsuid;
+        req->in.h.gid = current->fsgid;
+        req->in.h.pid = current->pid;
+}
+
 struct fuse_req *fuse_get_req(struct fuse_conn *fc)
 {
         struct fuse_req *req;
@@ -103,14 +99,16 @@ struct fuse_req *fuse_get_req(struct fuse_conn *fc)
         if (intr)
                 goto out;
 
+        err = -ENOTCONN;
+        if (!fc->connected)
+                goto out;
+
         req = fuse_request_alloc();
         err = -ENOMEM;
         if (!req)
                 goto out;
 
-        req->in.h.uid = current->fsuid;
-        req->in.h.gid = current->fsgid;
-        req->in.h.pid = current->pid;
+        fuse_req_init_context(req);
         req->waiting = 1;
         return req;
 
@@ -119,142 +117,183 @@ struct fuse_req *fuse_get_req(struct fuse_conn *fc)
         return ERR_PTR(err);
 }
 
-void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req)
+/*
+ * Return request in fuse_file->reserved_req.  However that may
+ * currently be in use.  If that is the case, wait for it to become
+ * available.
+ */
+static struct fuse_req *get_reserved_req(struct fuse_conn *fc,
+                                         struct file *file)
 {
-        if (atomic_dec_and_test(&req->count)) {
-                if (req->waiting)
-                        atomic_dec(&fc->num_waiting);
-                fuse_request_free(req);
-        }
+        struct fuse_req *req = NULL;
+        struct fuse_file *ff = file->private_data;
+
+        do {
+                wait_event(fc->blocked_waitq, ff->reserved_req);
+                spin_lock(&fc->lock);
+                if (ff->reserved_req) {
+                        req = ff->reserved_req;
+                        ff->reserved_req = NULL;
+                        get_file(file);
+                        req->stolen_file = file;
+                }
+                spin_unlock(&fc->lock);
+        } while (!req);
+
+        return req;
 }
 
 /*
- * Called with sbput_sem held for read (request_end) or write
- * (fuse_put_super).  By the time fuse_put_super() is finished, all
- * inodes belonging to background requests must be released, so the
- * iputs have to be done within the locked region.
+ * Put stolen request back into fuse_file->reserved_req
  */
-void fuse_release_background(struct fuse_conn *fc, struct fuse_req *req)
+static void put_reserved_req(struct fuse_conn *fc, struct fuse_req *req)
 {
-        iput(req->inode);
-        iput(req->inode2);
+        struct file *file = req->stolen_file;
+        struct fuse_file *ff = file->private_data;
+
         spin_lock(&fc->lock);
-        list_del(&req->bg_entry);
-        if (fc->num_background == FUSE_MAX_BACKGROUND) {
-                fc->blocked = 0;
-                wake_up_all(&fc->blocked_waitq);
-        }
-        fc->num_background--;
+        fuse_request_init(req);
+        BUG_ON(ff->reserved_req);
+        ff->reserved_req = req;
+        wake_up(&fc->blocked_waitq);
         spin_unlock(&fc->lock);
+        fput(file);
 }
 
 /*
- * This function is called when a request is finished.  Either a reply
- * has arrived or it was interrupted (and not yet sent) or some error
- * occurred during communication with userspace, or the device file
- * was closed.  In case of a background request the reference to the
- * stored objects are released.  The requester thread is woken up (if
- * still waiting), the 'end' callback is called if given, else the
- * reference to the request is released
+ * Gets a requests for a file operation, always succeeds
  *
- * Releasing extra reference for foreground requests must be done
- * within the same locked region as setting state to finished.  This
- * is because fuse_reset_request() may be called after request is
- * finished and it must be the sole possessor.  If request is
- * interrupted and put in the background, it will return with an error
- * and hence never be reset and reused.
+ * This is used for sending the FLUSH request, which must get to
+ * userspace, due to POSIX locks which may need to be unlocked.
  *
- * Called with fc->lock, unlocks it
+ * If allocation fails due to OOM, use the reserved request in
+ * fuse_file.
+ *
+ * This is very unlikely to deadlock accidentally, since the
+ * filesystem should not have it's own file open.  If deadlock is
+ * intentional, it can still be broken by "aborting" the filesystem.
  */
-static void request_end(struct fuse_conn *fc, struct fuse_req *req)
+struct fuse_req *fuse_get_req_nofail(struct fuse_conn *fc, struct file *file)
 {
-        list_del(&req->list);
-        req->state = FUSE_REQ_FINISHED;
-        if (!req->background) {
-                spin_unlock(&fc->lock);
-                wake_up(&req->waitq);
-                fuse_put_request(fc, req);
-        } else {
-                void (*end) (struct fuse_conn *, struct fuse_req *) = req->end;
-                req->end = NULL;
-                spin_unlock(&fc->lock);
-                down_read(&fc->sbput_sem);
-                if (fc->mounted)
-                        fuse_release_background(fc, req);
-                up_read(&fc->sbput_sem);
+        struct fuse_req *req;
 
-                /* fput must go outside sbput_sem, otherwise it can deadlock */
-                if (req->file)
-                        fput(req->file);
+        atomic_inc(&fc->num_waiting);
+        wait_event(fc->blocked_waitq, !fc->blocked);
+        req = fuse_request_alloc();
+        if (!req)
+                req = get_reserved_req(fc, file);
 
-                if (end)
-                        end(fc, req);
+        fuse_req_init_context(req);
+        req->waiting = 1;
+        return req;
+}
+
+void fuse_put_request(struct fuse_conn *fc, struct fuse_req *req)
+{
+        if (atomic_dec_and_test(&req->count)) {
+                if (req->waiting)
+                        atomic_dec(&fc->num_waiting);
+
+                if (req->stolen_file)
+                        put_reserved_req(fc, req);
                 else
-                        fuse_put_request(fc, req);
+                        fuse_request_free(req);
         }
 }
 
 /*
- * Unfortunately request interruption not just solves the deadlock
- * problem, it causes problems too.  These stem from the fact, that an
- * interrupted request is continued to be processed in userspace,
- * while all the locks and object references (inode and file) held
- * during the operation are released.
- *
- * To release the locks is exactly why there's a need to interrupt the
- * request, so there's not a lot that can be done about this, except
- * introduce additional locking in userspace.
- *
- * More important is to keep inode and file references until userspace
- * has replied, otherwise FORGET and RELEASE could be sent while the
- * inode/file is still used by the filesystem.
- *
- * For this reason the concept of "background" request is introduced.
- * An interrupted request is backgrounded if it has been already sent
- * to userspace.  Backgrounding involves getting an extra reference to
- * inode(s) or file used in the request, and adding the request to
- * fc->background list.  When a reply is received for a background
- * request, the object references are released, and the request is
- * removed from the list.  If the filesystem is unmounted while there
- * are still background requests, the list is walked and references
- * are released as if a reply was received.
+ * This function is called when a request is finished.  Either a reply
+ * has arrived or it was aborted (and not yet sent) or some error
+ * occurred during communication with userspace, or the device file
+ * was closed.  The requester thread is woken up (if still waiting),
+ * the 'end' callback is called if given, else the reference to the
+ * request is released
  *
- * There's one more use for a background request.  The RELEASE message is
- * always sent as background, since it doesn't return an error or
- * data.
+ * Called with fc->lock, unlocks it
  */
-static void background_request(struct fuse_conn *fc, struct fuse_req *req)
-{
-        req->background = 1;
-        list_add(&req->bg_entry, &fc->background);
-        fc->num_background++;
-        if (fc->num_background == FUSE_MAX_BACKGROUND)
-                fc->blocked = 1;
-        if (req->inode)
-                req->inode = igrab(req->inode);
-        if (req->inode2)
-                req->inode2 = igrab(req->inode2);
+static void request_end(struct fuse_conn *fc, struct fuse_req *req)
+{
+        void (*end) (struct fuse_conn *, struct fuse_req *) = req->end;
+        req->end = NULL;
+        list_del(&req->list);
+        list_del(&req->intr_entry);
+        req->state = FUSE_REQ_FINISHED;
+        if (req->background) {
+                if (fc->num_background == FUSE_MAX_BACKGROUND) {
+                        fc->blocked = 0;
+                        wake_up_all(&fc->blocked_waitq);
+                }
+                fc->num_background--;
+        }
+        spin_unlock(&fc->lock);
+        dput(req->dentry);
+        mntput(req->vfsmount);
         if (req->file)
-                get_file(req->file);
+                fput(req->file);
+        wake_up(&req->waitq);
+        if (end)
+                end(fc, req);
+        else
+                fuse_put_request(fc, req);
 }
 
-/* Called with fc->lock held.  Releases, and then reacquires it. */
-static void request_wait_answer(struct fuse_conn *fc, struct fuse_req *req)
+static void wait_answer_interruptible(struct fuse_conn *fc,
+                                      struct fuse_req *req)
 {
-        sigset_t oldset;
+        if (signal_pending(current))
+                return;
 
         spin_unlock(&fc->lock);
-        block_sigs(&oldset);
         wait_event_interruptible(req->waitq, req->state == FUSE_REQ_FINISHED);
-        restore_sigs(&oldset);
         spin_lock(&fc->lock);
-        if (req->state == FUSE_REQ_FINISHED && !req->interrupted)
-                return;
+}
+
+static void queue_interrupt(struct fuse_conn *fc, struct fuse_req *req)
+{
+        list_add_tail(&req->intr_entry, &fc->interrupts);
+        wake_up(&fc->waitq);
+        kill_fasync(&fc->fasync, SIGIO, POLL_IN);
+}
+
+/* Called with fc->lock held.  Releases, and then reacquires it. */
+static void request_wait_answer(struct fuse_conn *fc, struct fuse_req *req)
+{
+        if (!fc->no_interrupt) {
+                /* Any signal may interrupt this */
+                wait_answer_interruptible(fc, req);
+
+                if (req->aborted)
+                        goto aborted;
+                if (req->state == FUSE_REQ_FINISHED)
+                        return;
 
-        if (!req->interrupted) {
-                req->out.h.error = -EINTR;
                 req->interrupted = 1;
+                if (req->state == FUSE_REQ_SENT)
+                        queue_interrupt(fc, req);
+        }
+
+        if (req->force) {
+                spin_unlock(&fc->lock);
+                wait_event(req->waitq, req->state == FUSE_REQ_FINISHED);
+                spin_lock(&fc->lock);
+        } else {
+                sigset_t oldset;
+
+                /* Only fatal signals may interrupt this */
+                block_sigs(&oldset);
+                wait_answer_interruptible(fc, req);
+                restore_sigs(&oldset);
         }
+
+        if (req->aborted)
+                goto aborted;
+        if (req->state == FUSE_REQ_FINISHED)
+                return;
+
+        req->out.h.error = -EINTR;
+        req->aborted = 1;
+
+ aborted:
         if (req->locked) {
                 /* This is uninterruptible sleep, because data is
                    being copied to/from the buffers of req.  During
@@ -268,8 +307,11 @@ static void request_wait_answer(struct fuse_conn *fc, struct fuse_req *req)
         if (req->state == FUSE_REQ_PENDING) {
                 list_del(&req->list);
                 __fuse_put_request(req);
-        } else if (req->state == FUSE_REQ_SENT)
-                background_request(fc, req);
+        } else if (req->state == FUSE_REQ_SENT) {
+                spin_unlock(&fc->lock);
+                wait_event(req->waitq, req->state == FUSE_REQ_FINISHED);
+                spin_lock(&fc->lock);
+        }
 }
 
 static unsigned len_args(unsigned numargs, struct fuse_arg *args)
@@ -283,13 +325,19 @@ static unsigned len_args(unsigned numargs, struct fuse_arg *args)
         return nbytes;
 }
 
+static u64 fuse_get_unique(struct fuse_conn *fc)
+ {
+        fc->reqctr++;
+        /* zero is special */
+        if (fc->reqctr == 0)
+                fc->reqctr = 1;
+
+        return fc->reqctr;
+}
+
 static void queue_request(struct fuse_conn *fc, struct fuse_req *req)
 {
-        fc->reqctr++;
-        /* zero is special */
-        if (fc->reqctr == 0)
-                fc->reqctr = 1;
-        req->in.h.unique = fc->reqctr;
+        req->in.h.unique = fuse_get_unique(fc);
         req->in.h.len = sizeof(struct fuse_in_header) +
                 len_args(req->in.numargs, (struct fuse_arg *) req->in.args);
         list_add_tail(&req->list, &fc->pending);
@@ -302,9 +350,6 @@ static void queue_request(struct fuse_conn *fc, struct fuse_req *req)
         kill_fasync(&fc->fasync, SIGIO, POLL_IN);
 }
 
-/*
- * This can only be interrupted by a SIGKILL
- */
 void request_send(struct fuse_conn *fc, struct fuse_req *req)
 {
         req->isreply = 1;
@@ -327,8 +372,12 @@ void request_send(struct fuse_conn *fc, struct fuse_req *req)
 static void request_send_nowait(struct fuse_conn *fc, struct fuse_req *req)
 {
         spin_lock(&fc->lock);
-        background_request(fc, req);
         if (fc->connected) {
+                req->background = 1;
+                fc->num_background++;
+                if (fc->num_background == FUSE_MAX_BACKGROUND)
+                        fc->blocked = 1;
+
                 queue_request(fc, req);
                 spin_unlock(&fc->lock);
         } else {
@@ -352,14 +401,14 @@ void request_send_background(struct fuse_conn *fc, struct fuse_req *req)
 /*
  * Lock the request.  Up to the next unlock_request() there mustn't be
  * anything that could cause a page-fault.  If the request was already
- * interrupted bail out.
+ * aborted bail out.
  */
 static int lock_request(struct fuse_conn *fc, struct fuse_req *req)
 {
         int err = 0;
         if (req) {
                 spin_lock(&fc->lock);
-                if (req->interrupted)
+                if (req->aborted)
                         err = -ENOENT;
                 else
                         req->locked = 1;
@@ -369,7 +418,7 @@ static int lock_request(struct fuse_conn *fc, struct fuse_req *req)
 }
 
 /*
- * Unlock request.  If it was interrupted during being locked, the
+ * Unlock request.  If it was aborted during being locked, the
  * requester thread is currently waiting for it to be unlocked, so
  * wake it up.
  */
@@ -378,7 +427,7 @@ static void unlock_request(struct fuse_conn *fc, struct fuse_req *req)
         if (req) {
                 spin_lock(&fc->lock);
                 req->locked = 0;
-                if (req->interrupted)
+                if (req->aborted)
                         wake_up(&req->waitq);
                 spin_unlock(&fc->lock);
         }
@@ -557,13 +606,18 @@ static int fuse_copy_args(struct fuse_copy_state *cs, unsigned numargs,
         return err;
 }
 
+static int request_pending(struct fuse_conn *fc)
+{
+        return !list_empty(&fc->pending) || !list_empty(&fc->interrupts);
+}
+
 /* Wait until a request is available on the pending list */
 static void request_wait(struct fuse_conn *fc)
 {
         DECLARE_WAITQUEUE(wait, current);
 
         add_wait_queue_exclusive(&fc->waitq, &wait);
-        while (fc->connected && list_empty(&fc->pending)) {
+        while (fc->connected && !request_pending(fc)) {
                 set_current_state(TASK_INTERRUPTIBLE);
                 if (signal_pending(current))
                         break;
@@ -577,11 +631,50 @@ static void request_wait(struct fuse_conn *fc)
 }
 
 /*
+ * Transfer an interrupt request to userspace
+ *
+ * Unlike other requests this is assembled on demand, without a need
+ * to allocate a separate fuse_req structure.
+ *
+ * Called with fc->lock held, releases it
+ */
+static int fuse_read_interrupt(struct fuse_conn *fc, struct fuse_req *req,
+                               const struct iovec *iov, unsigned long nr_segs)
+{
+        struct fuse_copy_state cs;
+        struct fuse_in_header ih;
+        struct fuse_interrupt_in arg;
+        unsigned reqsize = sizeof(ih) + sizeof(arg);
+        int err;
+
+        list_del_init(&req->intr_entry);
+        req->intr_unique = fuse_get_unique(fc);
+        memset(&ih, 0, sizeof(ih));
+        memset(&arg, 0, sizeof(arg));
+        ih.len = reqsize;
+        ih.opcode = FUSE_INTERRUPT;
+        ih.unique = req->intr_unique;
+        arg.unique = req->in.h.unique;
+
+        spin_unlock(&fc->lock);
+        if (iov_length(iov, nr_segs) < reqsize)
+                return -EINVAL;
+
+        fuse_copy_init(&cs, fc, 1, NULL, iov, nr_segs);
+        err = fuse_copy_one(&cs, &ih, sizeof(ih));
+        if (!err)
+                err = fuse_copy_one(&cs, &arg, sizeof(arg));
+        fuse_copy_finish(&cs);
+
+        return err ? err : reqsize;
+}
+
+/*
  * Read a single request into the userspace filesystem's buffer.  This
  * function waits until a request is available, then removes it from
  * the pending list and copies request data to userspace buffer.  If
- * no reply is needed (FORGET) or request has been interrupted or
- * there was an error during the copying then it's finished by calling
+ * no reply is needed (FORGET) or request has been aborted or there
+ * was an error during the copying then it's finished by calling
  * request_end().  Otherwise add it to the processing list, and set
  * the 'sent' flag.
  */
@@ -601,7 +694,7 @@ static ssize_t fuse_dev_readv(struct file *file, const struct iovec *iov,
         spin_lock(&fc->lock);
         err = -EAGAIN;
         if ((file->f_flags & O_NONBLOCK) && fc->connected &&
-            list_empty(&fc->pending))
+            !request_pending(fc))
                 goto err_unlock;
 
         request_wait(fc);
@@ -609,9 +702,15 @@ static ssize_t fuse_dev_readv(struct file *file, const struct iovec *iov,
         if (!fc->connected)
                 goto err_unlock;
         err = -ERESTARTSYS;
-        if (list_empty(&fc->pending))
+        if (!request_pending(fc))
                 goto err_unlock;
 
+        if (!list_empty(&fc->interrupts)) {
+                req = list_entry(fc->interrupts.next, struct fuse_req,
+                                 intr_entry);
+                return fuse_read_interrupt(fc, req, iov, nr_segs);
+        }
+
         req = list_entry(fc->pending.next, struct fuse_req, list);
         req->state = FUSE_REQ_READING;
         list_move(&req->list, &fc->io);
@@ -636,10 +735,10 @@ static ssize_t fuse_dev_readv(struct file *file, const struct iovec *iov,
         fuse_copy_finish(&cs);
         spin_lock(&fc->lock);
         req->locked = 0;
-        if (!err && req->interrupted)
+        if (!err && req->aborted)
                 err = -ENOENT;
         if (err) {
-                if (!req->interrupted)
+                if (!req->aborted)
                         req->out.h.error = -EIO;
                 request_end(fc, req);
                 return err;
@@ -649,6 +748,8 @@ static ssize_t fuse_dev_readv(struct file *file, const struct iovec *iov,
         else {
                 req->state = FUSE_REQ_SENT;
                 list_move_tail(&req->list, &fc->processing);
+                if (req->interrupted)
+                        queue_interrupt(fc, req);
                 spin_unlock(&fc->lock);
         }
         return reqsize;
@@ -675,7 +776,7 @@ static struct fuse_req *request_find(struct fuse_conn *fc, u64 unique)
         list_for_each(entry, &fc->processing) {
                 struct fuse_req *req;
                 req = list_entry(entry, struct fuse_req, list);
-                if (req->in.h.unique == unique)
+                if (req->in.h.unique == unique || req->intr_unique == unique)
                         return req;
         }
         return NULL;
@@ -741,17 +842,33 @@ static ssize_t fuse_dev_writev(struct file *file, const struct iovec *iov,
                 goto err_unlock;
 
         req = request_find(fc, oh.unique);
-        err = -EINVAL;
         if (!req)
                 goto err_unlock;
 
-        if (req->interrupted) {
+        if (req->aborted) {
                 spin_unlock(&fc->lock);
                 fuse_copy_finish(&cs);
                 spin_lock(&fc->lock);
                 request_end(fc, req);
                 return -ENOENT;
         }
+        /* Is it an interrupt reply? */
+        if (req->intr_unique == oh.unique) {
+                err = -EINVAL;
+                if (nbytes != sizeof(struct fuse_out_header))
+                        goto err_unlock;
+
+                if (oh.error == -ENOSYS)
+                        fc->no_interrupt = 1;
+                else if (oh.error == -EAGAIN)
+                        queue_interrupt(fc, req);
+
+                spin_unlock(&fc->lock);
+                fuse_copy_finish(&cs);
+                return nbytes;
+        }
+
+        req->state = FUSE_REQ_WRITING;
         list_move(&req->list, &fc->io);
         req->out.h = oh;
         req->locked = 1;
@@ -764,9 +881,9 @@ static ssize_t fuse_dev_writev(struct file *file, const struct iovec *iov,
         spin_lock(&fc->lock);
         req->locked = 0;
         if (!err) {
-                if (req->interrupted)
+                if (req->aborted)
                         err = -ENOENT;
-        } else if (!req->interrupted)
+        } else if (!req->aborted)
                 req->out.h.error = -EIO;
         request_end(fc, req);
 
@@ -800,7 +917,7 @@ static unsigned fuse_dev_poll(struct file *file, poll_table *wait)
         spin_lock(&fc->lock);
         if (!fc->connected)
                 mask = POLLERR;
-        else if (!list_empty(&fc->pending))
+        else if (request_pending(fc))
                 mask |= POLLIN | POLLRDNORM;
         spin_unlock(&fc->lock);
 
@@ -826,7 +943,7 @@ static void end_requests(struct fuse_conn *fc, struct list_head *head)
 /*
  * Abort requests under I/O
  *
- * The requests are set to interrupted and finished, and the request
+ * The requests are set to aborted and finished, and the request
  * waiter is woken up.  This will make request_wait_answer() wait
  * until the request is unlocked and then return.
  *
@@ -841,7 +958,7 @@ static void end_io_requests(struct fuse_conn *fc)
                         list_entry(fc->io.next, struct fuse_req, list);
                 void (*end) (struct fuse_conn *, struct fuse_req *) = req->end;
 
-                req->interrupted = 1;
+                req->aborted = 1;
                 req->out.h.error = -ECONNABORTED;
                 req->state = FUSE_REQ_FINISHED;
                 list_del_init(&req->list);
@@ -874,19 +991,20 @@ static void end_io_requests(struct fuse_conn *fc)
  * onto the pending list is prevented by req->connected being false.
  *
  * Progression of requests under I/O to the processing list is
- * prevented by the req->interrupted flag being true for these
- * requests.  For this reason requests on the io list must be aborted
- * first.
+ * prevented by the req->aborted flag being true for these requests.
+ * For this reason requests on the io list must be aborted first.
  */
 void fuse_abort_conn(struct fuse_conn *fc)
 {
         spin_lock(&fc->lock);
         if (fc->connected) {
                 fc->connected = 0;
+                fc->blocked = 0;
                 end_io_requests(fc);
                 end_requests(fc, &fc->pending);
                 end_requests(fc, &fc->processing);
                 wake_up_all(&fc->waitq);
+                wake_up_all(&fc->blocked_waitq);
                 kill_fasync(&fc->fasync, SIGIO, POLL_IN);
         }
         spin_unlock(&fc->lock);
@@ -902,7 +1020,7 @@ static int fuse_dev_release(struct inode *inode, struct file *file)
                 end_requests(fc, &fc->processing);
                 spin_unlock(&fc->lock);
                 fasync_helper(-1, file, 0, &fc->fasync);
-                kobject_put(&fc->kobj);
+                fuse_conn_put(fc);
         }
 
         return 0;
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index 8d7546e832e8..72a74cde6de8 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -1,6 +1,6 @@
 /*
   FUSE: Filesystem in Userspace
-  Copyright (C) 2001-2005  Miklos Szeredi <miklos@szeredi.hu>
+  Copyright (C) 2001-2006  Miklos Szeredi <miklos@szeredi.hu>
 
   This program can be distributed under the terms of the GNU GPL.
   See the file COPYING.
@@ -79,7 +79,6 @@ static void fuse_lookup_init(struct fuse_req *req, struct inode *dir,
 {
         req->in.h.opcode = FUSE_LOOKUP;
         req->in.h.nodeid = get_node_id(dir);
-        req->inode = dir;
         req->in.numargs = 1;
         req->in.args[0].size = entry->d_name.len + 1;
         req->in.args[0].value = entry->d_name.name;
@@ -225,6 +224,20 @@ static struct dentry *fuse_lookup(struct inode *dir, struct dentry *entry,
 }
 
 /*
+ * Synchronous release for the case when something goes wrong in CREATE_OPEN
+ */
+static void fuse_sync_release(struct fuse_conn *fc, struct fuse_file *ff,
+                              u64 nodeid, int flags)
+{
+        struct fuse_req *req;
+
+        req = fuse_release_fill(ff, nodeid, flags, FUSE_RELEASE);
+        req->force = 1;
+        request_send(fc, req);
+        fuse_put_request(fc, req);
+}
+
+/*
  * Atomic create+open operation
  *
  * If the filesystem doesn't support this, then fall back to separate
@@ -237,6 +250,7 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
         struct inode *inode;
         struct fuse_conn *fc = get_fuse_conn(dir);
         struct fuse_req *req;
+        struct fuse_req *forget_req;
         struct fuse_open_in inarg;
         struct fuse_open_out outopen;
         struct fuse_entry_out outentry;
@@ -247,9 +261,14 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
         if (fc->no_create)
                 return -ENOSYS;
 
+        forget_req = fuse_get_req(fc);
+        if (IS_ERR(forget_req))
+                return PTR_ERR(forget_req);
+
         req = fuse_get_req(fc);
+        err = PTR_ERR(req);
         if (IS_ERR(req))
-                return PTR_ERR(req);
+                goto out_put_forget_req;
 
         err = -ENOMEM;
         ff = fuse_file_alloc();
@@ -262,7 +281,6 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
         inarg.mode = mode;
         req->in.h.opcode = FUSE_CREATE;
         req->in.h.nodeid = get_node_id(dir);
-        req->inode = dir;
         req->in.numargs = 2;
         req->in.args[0].size = sizeof(inarg);
         req->in.args[0].value = &inarg;
@@ -285,25 +303,23 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
         if (!S_ISREG(outentry.attr.mode) || invalid_nodeid(outentry.nodeid))
                 goto out_free_ff;
 
+        fuse_put_request(fc, req);
         inode = fuse_iget(dir->i_sb, outentry.nodeid, outentry.generation,
                           &outentry.attr);
-        err = -ENOMEM;
         if (!inode) {
                 flags &= ~(O_CREAT | O_EXCL | O_TRUNC);
                 ff->fh = outopen.fh;
-                /* Special release, with inode = NULL, this will
-                   trigger a 'forget' request when the release is
-                   complete */
-                fuse_send_release(fc, ff, outentry.nodeid, NULL, flags, 0);
-                goto out_put_request;
+                fuse_sync_release(fc, ff, outentry.nodeid, flags);
+                fuse_send_forget(fc, forget_req, outentry.nodeid, 1);
+                return -ENOMEM;
         }
-        fuse_put_request(fc, req);
+        fuse_put_request(fc, forget_req);
         d_instantiate(entry, inode);
         fuse_change_timeout(entry, &outentry);
         file = lookup_instantiate_filp(nd, entry, generic_file_open);
         if (IS_ERR(file)) {
                 ff->fh = outopen.fh;
-                fuse_send_release(fc, ff, outentry.nodeid, inode, flags, 0);
+                fuse_sync_release(fc, ff, outentry.nodeid, flags);
                 return PTR_ERR(file);
         }
         fuse_finish_open(inode, file, ff, &outopen);
@@ -313,6 +329,8 @@ static int fuse_create_open(struct inode *dir, struct dentry *entry, int mode,
         fuse_file_free(ff);
  out_put_request:
         fuse_put_request(fc, req);
+ out_put_forget_req:
+        fuse_put_request(fc, forget_req);
         return err;
 }
 
@@ -328,7 +346,6 @@ static int create_new_entry(struct fuse_conn *fc, struct fuse_req *req,
         int err;
 
         req->in.h.nodeid = get_node_id(dir);
-        req->inode = dir;
         req->out.numargs = 1;
         req->out.args[0].size = sizeof(outarg);
         req->out.args[0].value = &outarg;
@@ -448,7 +465,6 @@ static int fuse_unlink(struct inode *dir, struct dentry *entry)
 
         req->in.h.opcode = FUSE_UNLINK;
         req->in.h.nodeid = get_node_id(dir);
-        req->inode = dir;
         req->in.numargs = 1;
         req->in.args[0].size = entry->d_name.len + 1;
         req->in.args[0].value = entry->d_name.name;
@@ -480,7 +496,6 @@ static int fuse_rmdir(struct inode *dir, struct dentry *entry)
 
         req->in.h.opcode = FUSE_RMDIR;
         req->in.h.nodeid = get_node_id(dir);
-        req->inode = dir;
         req->in.numargs = 1;
         req->in.args[0].size = entry->d_name.len + 1;
         req->in.args[0].value = entry->d_name.name;
@@ -510,8 +525,6 @@ static int fuse_rename(struct inode *olddir, struct dentry *oldent,
         inarg.newdir = get_node_id(newdir);
         req->in.h.opcode = FUSE_RENAME;
         req->in.h.nodeid = get_node_id(olddir);
-        req->inode = olddir;
-        req->inode2 = newdir;
         req->in.numargs = 3;
         req->in.args[0].size = sizeof(inarg);
         req->in.args[0].value = &inarg;
@@ -558,7 +571,6 @@ static int fuse_link(struct dentry *entry, struct inode *newdir,
         memset(&inarg, 0, sizeof(inarg));
         inarg.oldnodeid = get_node_id(inode);
         req->in.h.opcode = FUSE_LINK;
-        req->inode2 = inode;
         req->in.numargs = 2;
         req->in.args[0].size = sizeof(inarg);
         req->in.args[0].value = &inarg;
@@ -587,7 +599,6 @@ int fuse_do_getattr(struct inode *inode)
 
         req->in.h.opcode = FUSE_GETATTR;
         req->in.h.nodeid = get_node_id(inode);
-        req->inode = inode;
         req->out.numargs = 1;
         req->out.args[0].size = sizeof(arg);
         req->out.args[0].value = &arg;
@@ -679,7 +690,6 @@ static int fuse_access(struct inode *inode, int mask)
         inarg.mask = mask;
         req->in.h.opcode = FUSE_ACCESS;
         req->in.h.nodeid = get_node_id(inode);
-        req->inode = inode;
         req->in.numargs = 1;
         req->in.args[0].size = sizeof(inarg);
         req->in.args[0].value = &inarg;
@@ -820,7 +830,6 @@ static char *read_link(struct dentry *dentry)
         }
         req->in.h.opcode = FUSE_READLINK;
         req->in.h.nodeid = get_node_id(inode);
-        req->inode = inode;
         req->out.argvar = 1;
         req->out.numargs = 1;
         req->out.args[0].size = PAGE_SIZE - 1;
@@ -939,7 +948,6 @@ static int fuse_setattr(struct dentry *entry, struct iattr *attr)
         iattr_to_fattr(attr, &inarg);
         req->in.h.opcode = FUSE_SETATTR;
         req->in.h.nodeid = get_node_id(inode);
-        req->inode = inode;
         req->in.numargs = 1;
         req->in.args[0].size = sizeof(inarg);
         req->in.args[0].value = &inarg;
@@ -1002,7 +1010,6 @@ static int fuse_setxattr(struct dentry *entry, const char *name,
         inarg.flags = flags;
         req->in.h.opcode = FUSE_SETXATTR;
         req->in.h.nodeid = get_node_id(inode);
-        req->inode = inode;
         req->in.numargs = 3;
         req->in.args[0].size = sizeof(inarg);
         req->in.args[0].value = &inarg;
@@ -1041,7 +1048,6 @@ static ssize_t fuse_getxattr(struct dentry *entry, const char *name,
         inarg.size = size;
         req->in.h.opcode = FUSE_GETXATTR;
         req->in.h.nodeid = get_node_id(inode);
-        req->inode = inode;
         req->in.numargs = 2;
         req->in.args[0].size = sizeof(inarg);
         req->in.args[0].value = &inarg;
@@ -1091,7 +1097,6 @@ static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size)
         inarg.size = size;
         req->in.h.opcode = FUSE_LISTXATTR;
         req->in.h.nodeid = get_node_id(inode);
-        req->inode = inode;
         req->in.numargs = 1;
         req->in.args[0].size = sizeof(inarg);
         req->in.args[0].value = &inarg;
@@ -1135,7 +1140,6 @@ static int fuse_removexattr(struct dentry *entry, const char *name)
 
         req->in.h.opcode = FUSE_REMOVEXATTR;
         req->in.h.nodeid = get_node_id(inode);
-        req->inode = inode;
         req->in.numargs = 1;
         req->in.args[0].size = strlen(name) + 1;
         req->in.args[0].value = name;
diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 087f3b734f40..28aa81eae2cc 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -30,7 +30,6 @@ static int fuse_send_open(struct inode *inode, struct file *file, int isdir,
         inarg.flags = file->f_flags & ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
         req->in.h.opcode = isdir ? FUSE_OPENDIR : FUSE_OPEN;
         req->in.h.nodeid = get_node_id(inode);
-        req->inode = inode;
         req->in.numargs = 1;
         req->in.args[0].size = sizeof(inarg);
         req->in.args[0].value = &inarg;
@@ -49,8 +48,8 @@ struct fuse_file *fuse_file_alloc(void)
         struct fuse_file *ff;
         ff = kmalloc(sizeof(struct fuse_file), GFP_KERNEL);
         if (ff) {
-                ff->release_req = fuse_request_alloc();
-                if (!ff->release_req) {
+                ff->reserved_req = fuse_request_alloc();
+                if (!ff->reserved_req) {
                         kfree(ff);
                         ff = NULL;
                 }
@@ -60,7 +59,7 @@ struct fuse_file *fuse_file_alloc(void)
 
 void fuse_file_free(struct fuse_file *ff)
 {
-        fuse_request_free(ff->release_req);
+        fuse_request_free(ff->reserved_req);
         kfree(ff);
 }
 
@@ -113,37 +112,22 @@ int fuse_open_common(struct inode *inode, struct file *file, int isdir)
         return err;
 }
 
-/* Special case for failed iget in CREATE */
-static void fuse_release_end(struct fuse_conn *fc, struct fuse_req *req)
+struct fuse_req *fuse_release_fill(struct fuse_file *ff, u64 nodeid, int flags,
+                                   int opcode)
 {
-        /* If called from end_io_requests(), req has more than one
-           reference and fuse_reset_request() cannot work */
-        if (fc->connected) {
-                u64 nodeid = req->in.h.nodeid;
-                fuse_reset_request(req);
-                fuse_send_forget(fc, req, nodeid, 1);
-        } else
-                fuse_put_request(fc, req);
-}
-
-void fuse_send_release(struct fuse_conn *fc, struct fuse_file *ff,
-                       u64 nodeid, struct inode *inode, int flags, int isdir)
-{
-        struct fuse_req * req = ff->release_req;
+        struct fuse_req *req = ff->reserved_req;
         struct fuse_release_in *inarg = &req->misc.release_in;
 
         inarg->fh = ff->fh;
         inarg->flags = flags;
-        req->in.h.opcode = isdir ? FUSE_RELEASEDIR : FUSE_RELEASE;
+        req->in.h.opcode = opcode;
         req->in.h.nodeid = nodeid;
-        req->inode = inode;
         req->in.numargs = 1;
         req->in.args[0].size = sizeof(struct fuse_release_in);
         req->in.args[0].value = inarg;
-        request_send_background(fc, req);
-        if (!inode)
-                req->end = fuse_release_end;
         kfree(ff);
+
+        return req;
 }
 
 int fuse_release_common(struct inode *inode, struct file *file, int isdir)
@@ -151,8 +135,15 @@ int fuse_release_common(struct inode *inode, struct file *file, int isdir)
         struct fuse_file *ff = file->private_data;
         if (ff) {
                 struct fuse_conn *fc = get_fuse_conn(inode);
-                u64 nodeid = get_node_id(inode);
-                fuse_send_release(fc, ff, nodeid, inode, file->f_flags, isdir);
+                struct fuse_req *req;
+
+                req = fuse_release_fill(ff, get_node_id(inode), file->f_flags,
+                                        isdir ? FUSE_RELEASEDIR : FUSE_RELEASE);
+
+                /* Hold vfsmount and dentry until release is finished */
+                req->vfsmount = mntget(file->f_vfsmnt);
+                req->dentry = dget(file->f_dentry);
+                request_send_background(fc, req);
         }
 
         /* Return value is ignored by VFS */
@@ -169,6 +160,28 @@ static int fuse_release(struct inode *inode, struct file *file)
         return fuse_release_common(inode, file, 0);
 }
 
+/*
+ * Scramble the ID space with XTEA, so that the value of the files_struct
+ * pointer is not exposed to userspace.
+ */
+static u64 fuse_lock_owner_id(struct fuse_conn *fc, fl_owner_t id)
+{
+        u32 *k = fc->scramble_key;
+        u64 v = (unsigned long) id;
+        u32 v0 = v;
+        u32 v1 = v >> 32;
+        u32 sum = 0;
+        int i;
+
+        for (i = 0; i < 32; i++) {
+                v0 += ((v1 << 4 ^ v1 >> 5) + v1) ^ (sum + k[sum & 3]);
+                sum += 0x9E3779B9;
+                v1 += ((v0 << 4 ^ v0 >> 5) + v0) ^ (sum + k[sum>>11 & 3]);
+        }
+
+        return (u64) v0 + ((u64) v1 << 32);
+}
+
 static int fuse_flush(struct file *file, fl_owner_t id)
 {
         struct inode *inode = file->f_dentry->d_inode;
@@ -184,19 +197,16 @@ static int fuse_flush(struct file *file, fl_owner_t id)
         if (fc->no_flush)
                 return 0;
 
-        req = fuse_get_req(fc);
-        if (IS_ERR(req))
-                return PTR_ERR(req);
-
+        req = fuse_get_req_nofail(fc, file);
         memset(&inarg, 0, sizeof(inarg));
         inarg.fh = ff->fh;
+        inarg.lock_owner = fuse_lock_owner_id(fc, id);
         req->in.h.opcode = FUSE_FLUSH;
         req->in.h.nodeid = get_node_id(inode);
-        req->inode = inode;
-        req->file = file;
         req->in.numargs = 1;
         req->in.args[0].size = sizeof(inarg);
         req->in.args[0].value = &inarg;
+        req->force = 1;
         request_send(fc, req);
         err = req->out.h.error;
         fuse_put_request(fc, req);
@@ -232,8 +242,6 @@ int fuse_fsync_common(struct file *file, struct dentry *de, int datasync,
         inarg.fsync_flags = datasync ? 1 : 0;
         req->in.h.opcode = isdir ? FUSE_FSYNCDIR : FUSE_FSYNC;
         req->in.h.nodeid = get_node_id(inode);
-        req->inode = inode;
-        req->file = file;
         req->in.numargs = 1;
         req->in.args[0].size = sizeof(inarg);
         req->in.args[0].value = &inarg;
@@ -266,8 +274,6 @@ void fuse_read_fill(struct fuse_req *req, struct file *file,
         inarg->size = count;
         req->in.h.opcode = opcode;
         req->in.h.nodeid = get_node_id(inode);
-        req->inode = inode;
-        req->file = file;
         req->in.numargs = 1;
         req->in.args[0].size = sizeof(struct fuse_read_in);
         req->in.args[0].value = inarg;
@@ -342,6 +348,8 @@ static void fuse_send_readpages(struct fuse_req *req, struct file *file,
         req->out.page_zeroing = 1;
         fuse_read_fill(req, file, inode, pos, count, FUSE_READ);
         if (fc->async_read) {
+                get_file(file);
+                req->file = file;
                 req->end = fuse_readpages_end;
                 request_send_background(fc, req);
         } else {
@@ -420,8 +428,6 @@ static size_t fuse_send_write(struct fuse_req *req, struct file *file,
         inarg.size = count;
         req->in.h.opcode = FUSE_WRITE;
         req->in.h.nodeid = get_node_id(inode);
-        req->inode = inode;
-        req->file = file;
         req->in.argpages = 1;
         req->in.numargs = 2;
         req->in.args[0].size = sizeof(struct fuse_write_in);
@@ -619,6 +625,126 @@ static int fuse_set_page_dirty(struct page *page)
         return 0;
 }
 
+static int convert_fuse_file_lock(const struct fuse_file_lock *ffl,
+                                  struct file_lock *fl)
+{
+        switch (ffl->type) {
+        case F_UNLCK:
+                break;
+
+        case F_RDLCK:
+        case F_WRLCK:
+                if (ffl->start > OFFSET_MAX || ffl->end > OFFSET_MAX ||
+                    ffl->end < ffl->start)
+                        return -EIO;
+
+                fl->fl_start = ffl->start;
+                fl->fl_end = ffl->end;
+                fl->fl_pid = ffl->pid;
+                break;
+
+        default:
+                return -EIO;
+        }
+        fl->fl_type = ffl->type;
+        return 0;
+}
+
+static void fuse_lk_fill(struct fuse_req *req, struct file *file,
+                         const struct file_lock *fl, int opcode, pid_t pid)
+{
+        struct inode *inode = file->f_dentry->d_inode;
+        struct fuse_conn *fc = get_fuse_conn(inode);
+        struct fuse_file *ff = file->private_data;
+        struct fuse_lk_in *arg = &req->misc.lk_in;
+
+        arg->fh = ff->fh;
+        arg->owner = fuse_lock_owner_id(fc, fl->fl_owner);
+        arg->lk.start = fl->fl_start;
+        arg->lk.end = fl->fl_end;
+        arg->lk.type = fl->fl_type;
+        arg->lk.pid = pid;
+        req->in.h.opcode = opcode;
+        req->in.h.nodeid = get_node_id(inode);
+        req->in.numargs = 1;
+        req->in.args[0].size = sizeof(*arg);
+        req->in.args[0].value = arg;
+}
+
+static int fuse_getlk(struct file *file, struct file_lock *fl)
+{
+        struct inode *inode = file->f_dentry->d_inode;
+        struct fuse_conn *fc = get_fuse_conn(inode);
+        struct fuse_req *req;
+        struct fuse_lk_out outarg;
+        int err;
+
+        req = fuse_get_req(fc);
+        if (IS_ERR(req))
+                return PTR_ERR(req);
+
+        fuse_lk_fill(req, file, fl, FUSE_GETLK, 0);
+        req->out.numargs = 1;
+        req->out.args[0].size = sizeof(outarg);
+        req->out.args[0].value = &outarg;
+        request_send(fc, req);
+        err = req->out.h.error;
+        fuse_put_request(fc, req);
+        if (!err)
+                err = convert_fuse_file_lock(&outarg.lk, fl);
+
+        return err;
+}
+
+static int fuse_setlk(struct file *file, struct file_lock *fl)
+{
+        struct inode *inode = file->f_dentry->d_inode;
+        struct fuse_conn *fc = get_fuse_conn(inode);
+        struct fuse_req *req;
+        int opcode = (fl->fl_flags & FL_SLEEP) ? FUSE_SETLKW : FUSE_SETLK;
+        pid_t pid = fl->fl_type != F_UNLCK ? current->tgid : 0;
+        int err;
+
+        /* Unlock on close is handled by the flush method */
+        if (fl->fl_flags & FL_CLOSE)
+                return 0;
+
+        req = fuse_get_req(fc);
+        if (IS_ERR(req))
+                return PTR_ERR(req);
+
+        fuse_lk_fill(req, file, fl, opcode, pid);
+        request_send(fc, req);
+        err = req->out.h.error;
+        /* locking is restartable */
+        if (err == -EINTR)
+                err = -ERESTARTSYS;
+        fuse_put_request(fc, req);
+        return err;
+}
+
+static int fuse_file_lock(struct file *file, int cmd, struct file_lock *fl)
+{
+        struct inode *inode = file->f_dentry->d_inode;
+        struct fuse_conn *fc = get_fuse_conn(inode);
+        int err;
+
+        if (cmd == F_GETLK) {
+                if (fc->no_lock) {
+                        if (!posix_test_lock(file, fl, fl))
+                                fl->fl_type = F_UNLCK;
+                        err = 0;
+                } else
+                        err = fuse_getlk(file, fl);
+        } else {
+                if (fc->no_lock)
+                        err = posix_lock_file_wait(file, fl);
+                else
+                        err = fuse_setlk(file, fl);
+        }
+        return err;
+}
+
 static const struct file_operations fuse_file_operations = {
         .llseek         = generic_file_llseek,
         .read           = generic_file_read,
@@ -628,6 +754,7 @@ static const struct file_operations fuse_file_operations = {
         .flush          = fuse_flush,
         .release        = fuse_release,
         .fsync          = fuse_fsync,
+        .lock           = fuse_file_lock,
         .sendfile       = generic_file_sendfile,
 };
 
@@ -639,6 +766,7 @@ static const struct file_operations fuse_direct_io_file_operations = {
         .flush          = fuse_flush,
         .release        = fuse_release,
         .fsync          = fuse_fsync,
+        .lock           = fuse_file_lock,
         /* no mmap and sendfile */
 };
 
diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h
index 0474202cb5dc..0dbf96621841 100644
--- a/fs/fuse/fuse_i.h
+++ b/fs/fuse/fuse_i.h
@@ -8,12 +8,13 @@
 
 #include <linux/fuse.h>
 #include <linux/fs.h>
+#include <linux/mount.h>
 #include <linux/wait.h>
 #include <linux/list.h>
 #include <linux/spinlock.h>
 #include <linux/mm.h>
 #include <linux/backing-dev.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 /** Max number of pages that can be used in a single read request */
 #define FUSE_MAX_PAGES_PER_REQ 32
@@ -24,6 +25,9 @@
 /** It could be as large as PATH_MAX, but would that have any uses? */
 #define FUSE_NAME_MAX 1024
 
+/** Number of dentries for each connection in the control filesystem */
+#define FUSE_CTL_NUM_DENTRIES 3
+
 /** If the FUSE_DEFAULT_PERMISSIONS flag is given, the filesystem
     module will check permissions based on the file mode.  Otherwise no
     permission checking is done in the kernel */
@@ -33,6 +37,11 @@
     doing the mount will be allowed to access the filesystem */
 #define FUSE_ALLOW_OTHER         (1 << 1)
 
+/** List of active connections */
+extern struct list_head fuse_conn_list;
+
+/** Global mutex protecting fuse_conn_list and the control filesystem */
+extern struct mutex fuse_mutex;
 
 /** FUSE inode */
 struct fuse_inode {
@@ -56,7 +65,7 @@ struct fuse_inode {
 /** FUSE specific file data */
 struct fuse_file {
         /** Request reserved for flush and release */
-        struct fuse_req *release_req;
+        struct fuse_req *reserved_req;
 
         /** File handle used by userspace */
         u64 fh;
@@ -122,6 +131,7 @@ enum fuse_req_state {
         FUSE_REQ_PENDING,
         FUSE_REQ_READING,
         FUSE_REQ_SENT,
+        FUSE_REQ_WRITING,
         FUSE_REQ_FINISHED
 };
 
@@ -135,12 +145,15 @@ struct fuse_req {
             fuse_conn */
         struct list_head list;
 
-        /** Entry on the background list */
-        struct list_head bg_entry;
+        /** Entry on the interrupts list  */
+        struct list_head intr_entry;
 
         /** refcount */
         atomic_t count;
 
+        /** Unique ID for the interrupt request */
+        u64 intr_unique;
+
         /*
          * The following bitfields are either set once before the
          * request is queued or setting/clearing them is protected by
@@ -150,12 +163,18 @@ struct fuse_req {
         /** True if the request has reply */
         unsigned isreply:1;
 
-        /** The request was interrupted */
-        unsigned interrupted:1;
+        /** Force sending of the request even if interrupted */
+        unsigned force:1;
+
+        /** The request was aborted */
+        unsigned aborted:1;
 
         /** Request is sent in the background */
         unsigned background:1;
 
+        /** The request has been interrupted */
+        unsigned interrupted:1;
+
         /** Data is being copied to/from the request */
         unsigned locked:1;
 
@@ -181,6 +200,7 @@ struct fuse_req {
                 struct fuse_init_in init_in;
                 struct fuse_init_out init_out;
                 struct fuse_read_in read_in;
+                struct fuse_lk_in lk_in;
         } misc;
 
         /** page vector */
@@ -192,17 +212,20 @@ struct fuse_req {
         /** offset of data on first page */
         unsigned page_offset;
 
-        /** Inode used in the request */
-        struct inode *inode;
-
-        /** Second inode used in the request (or NULL) */
-        struct inode *inode2;
-
         /** File used in the request (or NULL) */
         struct file *file;
 
+        /** vfsmount used in release */
+        struct vfsmount *vfsmount;
+
+        /** dentry used in release */
+        struct dentry *dentry;
+
         /** Request completion callback */
         void (*end)(struct fuse_conn *, struct fuse_req *);
+
+        /** Request is stolen from fuse_file->reserved_req */
+        struct file *stolen_file;
 };
 
 /**
@@ -216,6 +239,9 @@ struct fuse_conn {
         /** Lock protecting accessess to  members of this structure */
         spinlock_t lock;
 
+        /** Refcount */
+        atomic_t count;
+
         /** The user id for this mount */
         uid_t user_id;
 
@@ -243,13 +269,12 @@ struct fuse_conn {
         /** The list of requests under I/O */
         struct list_head io;
 
-        /** Requests put in the background (RELEASE or any other
-            interrupted request) */
-        struct list_head background;
-
         /** Number of requests currently in the background */
         unsigned num_background;
 
+        /** Pending interrupts */
+        struct list_head interrupts;
+
         /** Flag indicating if connection is blocked.  This will be
             the case before the INIT reply is received, and if there
             are too many outstading backgrounds requests */
@@ -258,15 +283,9 @@ struct fuse_conn {
         /** waitq for blocked connection */
         wait_queue_head_t blocked_waitq;
 
-        /** RW semaphore for exclusion with fuse_put_super() */
-        struct rw_semaphore sbput_sem;
-
         /** The next unique request id */
         u64 reqctr;
 
-        /** Mount is active */
-        unsigned mounted;
-
         /** Connection established, cleared on umount, connection
             abort and device release */
         unsigned connected;
@@ -305,12 +324,18 @@ struct fuse_conn {
         /** Is removexattr not implemented by fs? */
         unsigned no_removexattr : 1;
 
+        /** Are file locking primitives not implemented by fs? */
+        unsigned no_lock : 1;
+
         /** Is access not implemented by fs? */
         unsigned no_access : 1;
 
         /** Is create not implemented by fs? */
         unsigned no_create : 1;
 
+        /** Is interrupt not implemented by fs? */
+        unsigned no_interrupt : 1;
+
         /** The number of requests waiting for completion */
         atomic_t num_waiting;
 
@@ -320,11 +345,23 @@ struct fuse_conn {
         /** Backing dev info */
         struct backing_dev_info bdi;
 
-        /** kobject */
-        struct kobject kobj;
+        /** Entry on the fuse_conn_list */
+        struct list_head entry;
+
+        /** Unique ID */
+        u64 id;
+
+        /** Dentries in the control filesystem */
+        struct dentry *ctl_dentry[FUSE_CTL_NUM_DENTRIES];
+
+        /** number of dentries used in the above array */
+        int ctl_ndents;
 
         /** O_ASYNC requests */
         struct fasync_struct *fasync;
+
+        /** Key for lock owner ID scrambling */
+        u32 scramble_key[4];
 };
 
 static inline struct fuse_conn *get_fuse_conn_super(struct super_block *sb)
@@ -337,11 +374,6 @@ static inline struct fuse_conn *get_fuse_conn(struct inode *inode)
         return get_fuse_conn_super(inode->i_sb);
 }
 
-static inline struct fuse_conn *get_fuse_conn_kobj(struct kobject *obj)
-{
-        return container_of(obj, struct fuse_conn, kobj);
-}
-
 static inline struct fuse_inode *get_fuse_inode(struct inode *inode)
 {
         return container_of(inode, struct fuse_inode, inode);
@@ -383,12 +415,9 @@ void fuse_file_free(struct fuse_file *ff);
 void fuse_finish_open(struct inode *inode, struct file *file,
                       struct fuse_file *ff, struct fuse_open_out *outarg);
 
-/**
- * Send a RELEASE request
- */
-void fuse_send_release(struct fuse_conn *fc, struct fuse_file *ff,
-                       u64 nodeid, struct inode *inode, int flags, int isdir);
-
+/** */
+struct fuse_req *fuse_release_fill(struct fuse_file *ff, u64 nodeid, int flags,
+                                   int opcode);
 /**
  * Send RELEASE or RELEASEDIR request
  */
@@ -435,6 +464,9 @@ int fuse_dev_init(void);
  */
 void fuse_dev_cleanup(void);
 
+int fuse_ctl_init(void);
+void fuse_ctl_cleanup(void);
+
 /**
  * Allocate a request
  */
@@ -446,14 +478,14 @@ struct fuse_req *fuse_request_alloc(void);
 void fuse_request_free(struct fuse_req *req);
 
 /**
- * Reinitialize a request, the preallocated flag is left unmodified
+ * Get a request, may fail with -ENOMEM
  */
-void fuse_reset_request(struct fuse_req *req);
+struct fuse_req *fuse_get_req(struct fuse_conn *fc);
 
 /**
- * Reserve a preallocated request
+ * Gets a requests for a file operation, always succeeds
  */
-struct fuse_req *fuse_get_req(struct fuse_conn *fc);
+struct fuse_req *fuse_get_req_nofail(struct fuse_conn *fc, struct file *file);
 
 /**
  * Decrement reference count of a request.  If count goes to zero free
@@ -476,11 +508,6 @@ void request_send_noreply(struct fuse_conn *fc, struct fuse_req *req);
  */
 void request_send_background(struct fuse_conn *fc, struct fuse_req *req);
 
-/**
- * Release inodes and file associated with background request
- */
-void fuse_release_background(struct fuse_conn *fc, struct fuse_req *req);
-
 /* Abort all requests */
 void fuse_abort_conn(struct fuse_conn *fc);
 
@@ -493,3 +520,23 @@ int fuse_do_getattr(struct inode *inode);
  * Invalidate inode attributes
  */
 void fuse_invalidate_attr(struct inode *inode);
+
+/**
+ * Acquire reference to fuse_conn
+ */
+struct fuse_conn *fuse_conn_get(struct fuse_conn *fc);
+
+/**
+ * Release reference to fuse_conn
+ */
+void fuse_conn_put(struct fuse_conn *fc);
+
+/**
+ * Add connection to control filesystem
+ */
+int fuse_ctl_add_conn(struct fuse_conn *fc);
+
+/**
+ * Remove connection from control filesystem
+ */
+void fuse_ctl_remove_conn(struct fuse_conn *fc);
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index a13c0f529058..5ceb8bd7a189 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -11,25 +11,20 @@
 #include <linux/pagemap.h>
 #include <linux/slab.h>
 #include <linux/file.h>
-#include <linux/mount.h>
 #include <linux/seq_file.h>
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/parser.h>
 #include <linux/statfs.h>
+#include <linux/random.h>
 
 MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
 MODULE_DESCRIPTION("Filesystem in Userspace");
 MODULE_LICENSE("GPL");
 
 static kmem_cache_t *fuse_inode_cachep;
-static struct subsystem connections_subsys;
-
-struct fuse_conn_attr {
-        struct attribute attr;
-        ssize_t (*show)(struct fuse_conn *, char *);
-        ssize_t (*store)(struct fuse_conn *, const char *, size_t);
-};
+struct list_head fuse_conn_list;
+DEFINE_MUTEX(fuse_mutex);
 
 #define FUSE_SUPER_MAGIC 0x65735546
 
@@ -104,6 +99,14 @@ static void fuse_clear_inode(struct inode *inode)
         }
 }
 
+static int fuse_remount_fs(struct super_block *sb, int *flags, char *data)
+{
+        if (*flags & MS_MANDLOCK)
+                return -EINVAL;
+
+        return 0;
+}
+
 void fuse_change_attributes(struct inode *inode, struct fuse_attr *attr)
 {
         if (S_ISREG(inode->i_mode) && i_size_read(inode) != attr->size)
@@ -204,22 +207,19 @@ static void fuse_put_super(struct super_block *sb)
 {
         struct fuse_conn *fc = get_fuse_conn_super(sb);
 
-        down_write(&fc->sbput_sem);
-        while (!list_empty(&fc->background))
-                fuse_release_background(fc,
-                                        list_entry(fc->background.next,
-                                                   struct fuse_req, bg_entry));
-
         spin_lock(&fc->lock);
-        fc->mounted = 0;
         fc->connected = 0;
+        fc->blocked = 0;
         spin_unlock(&fc->lock);
-        up_write(&fc->sbput_sem);
         /* Flush all readers on this fs */
         kill_fasync(&fc->fasync, SIGIO, POLL_IN);
         wake_up_all(&fc->waitq);
-        kobject_del(&fc->kobj);
-        kobject_put(&fc->kobj);
+        wake_up_all(&fc->blocked_waitq);
+        mutex_lock(&fuse_mutex);
+        list_del(&fc->entry);
+        fuse_ctl_remove_conn(fc);
+        mutex_unlock(&fuse_mutex);
+        fuse_conn_put(fc);
 }
 
 static void convert_fuse_statfs(struct kstatfs *stbuf, struct fuse_kstatfs *attr)
@@ -369,11 +369,6 @@ static int fuse_show_options(struct seq_file *m, struct vfsmount *mnt)
         return 0;
 }
 
-static void fuse_conn_release(struct kobject *kobj)
-{
-        kfree(get_fuse_conn_kobj(kobj));
-}
-
 static struct fuse_conn *new_conn(void)
 {
         struct fuse_conn *fc;
@@ -381,24 +376,35 @@ static struct fuse_conn *new_conn(void)
         fc = kzalloc(sizeof(*fc), GFP_KERNEL);
         if (fc) {
                 spin_lock_init(&fc->lock);
+                atomic_set(&fc->count, 1);
                 init_waitqueue_head(&fc->waitq);
                 init_waitqueue_head(&fc->blocked_waitq);
                 INIT_LIST_HEAD(&fc->pending);
                 INIT_LIST_HEAD(&fc->processing);
                 INIT_LIST_HEAD(&fc->io);
-                INIT_LIST_HEAD(&fc->background);
-                init_rwsem(&fc->sbput_sem);
-                kobj_set_kset_s(fc, connections_subsys);
-                kobject_init(&fc->kobj);
+                INIT_LIST_HEAD(&fc->interrupts);
                 atomic_set(&fc->num_waiting, 0);
                 fc->bdi.ra_pages = (VM_MAX_READAHEAD * 1024) / PAGE_CACHE_SIZE;
                 fc->bdi.unplug_io_fn = default_unplug_io_fn;
                 fc->reqctr = 0;
                 fc->blocked = 1;
+                get_random_bytes(&fc->scramble_key, sizeof(fc->scramble_key));
         }
         return fc;
 }
 
+void fuse_conn_put(struct fuse_conn *fc)
+{
+        if (atomic_dec_and_test(&fc->count))
+                kfree(fc);
+}
+
+struct fuse_conn *fuse_conn_get(struct fuse_conn *fc)
+{
+        atomic_inc(&fc->count);
+        return fc;
+}
+
 static struct inode *get_root_inode(struct super_block *sb, unsigned mode)
 {
         struct fuse_attr attr;
@@ -414,6 +420,7 @@ static struct super_operations fuse_super_operations = {
         .destroy_inode  = fuse_destroy_inode,
         .read_inode     = fuse_read_inode,
         .clear_inode    = fuse_clear_inode,
+        .remount_fs     = fuse_remount_fs,
         .put_super      = fuse_put_super,
         .umount_begin   = fuse_umount_begin,
         .statfs         = fuse_statfs,
@@ -433,8 +440,12 @@ static void process_init_reply(struct fuse_conn *fc, struct fuse_req *req)
                         ra_pages = arg->max_readahead / PAGE_CACHE_SIZE;
                         if (arg->flags & FUSE_ASYNC_READ)
                                 fc->async_read = 1;
-                } else
+                        if (!(arg->flags & FUSE_POSIX_LOCKS))
+                                fc->no_lock = 1;
+                } else {
                         ra_pages = fc->max_read / PAGE_CACHE_SIZE;
+                        fc->no_lock = 1;
+                }
 
                 fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
                 fc->minor = arg->minor;
@@ -452,7 +463,7 @@ static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
         arg->major = FUSE_KERNEL_VERSION;
         arg->minor = FUSE_KERNEL_MINOR_VERSION;
         arg->max_readahead = fc->bdi.ra_pages * PAGE_CACHE_SIZE;
-        arg->flags |= FUSE_ASYNC_READ;
+        arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS;
         req->in.h.opcode = FUSE_INIT;
         req->in.numargs = 1;
         req->in.args[0].size = sizeof(*arg);
@@ -468,10 +479,9 @@ static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
         request_send_background(fc, req);
 }
 
-static unsigned long long conn_id(void)
+static u64 conn_id(void)
 {
-        /* BKL is held for ->get_sb() */
-        static unsigned long long ctr = 1;
+        static u64 ctr = 1;
         return ctr++;
 }
 
@@ -485,6 +495,9 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent)
         struct fuse_req *init_req;
         int err;
 
+        if (sb->s_flags & MS_MANDLOCK)
+                return -EINVAL;
+
         if (!parse_fuse_opt((char *) data, &d))
                 return -EINVAL;
 
@@ -528,25 +541,21 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent)
         if (!init_req)
                 goto err_put_root;
 
-        err = kobject_set_name(&fc->kobj, "%llu", conn_id());
-        if (err)
-                goto err_free_req;
-
-        err = kobject_add(&fc->kobj);
-        if (err)
-                goto err_free_req;
-
-        /* Setting file->private_data can't race with other mount()
-           instances, since BKL is held for ->get_sb() */
+        mutex_lock(&fuse_mutex);
         err = -EINVAL;
         if (file->private_data)
-                goto err_kobject_del;
+                goto err_unlock;
 
+        fc->id = conn_id();
+        err = fuse_ctl_add_conn(fc);
+        if (err)
+                goto err_unlock;
+
+        list_add_tail(&fc->entry, &fuse_conn_list);
         sb->s_root = root_dentry;
-        fc->mounted = 1;
         fc->connected = 1;
-        kobject_get(&fc->kobj);
-        file->private_data = fc;
+        file->private_data = fuse_conn_get(fc);
+        mutex_unlock(&fuse_mutex);
         /*
          * atomic_dec_and_test() in fput() provides the necessary
          * memory barrier for file->private_data to be visible on all
@@ -558,15 +567,14 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent)
 
         return 0;
 
- err_kobject_del:
-        kobject_del(&fc->kobj);
- err_free_req:
+ err_unlock:
+        mutex_unlock(&fuse_mutex);
         fuse_request_free(init_req);
  err_put_root:
         dput(root_dentry);
  err:
         fput(file);
-        kobject_put(&fc->kobj);
+        fuse_conn_put(fc);
         return err;
 }
 
@@ -584,68 +592,8 @@ static struct file_system_type fuse_fs_type = {
         .kill_sb        = kill_anon_super,
 };
 
-static ssize_t fuse_conn_waiting_show(struct fuse_conn *fc, char *page)
-{
-        return sprintf(page, "%i\n", atomic_read(&fc->num_waiting));
-}
-
-static ssize_t fuse_conn_abort_store(struct fuse_conn *fc, const char *page,
-                                     size_t count)
-{
-        fuse_abort_conn(fc);
-        return count;
-}
-
-static struct fuse_conn_attr fuse_conn_waiting =
-        __ATTR(waiting, 0400, fuse_conn_waiting_show, NULL);
-static struct fuse_conn_attr fuse_conn_abort =
-        __ATTR(abort, 0600, NULL, fuse_conn_abort_store);
-
-static struct attribute *fuse_conn_attrs[] = {
-        &fuse_conn_waiting.attr,
-        &fuse_conn_abort.attr,
-        NULL,
-};
-
-static ssize_t fuse_conn_attr_show(struct kobject *kobj,
-                                   struct attribute *attr,
-                                   char *page)
-{
-        struct fuse_conn_attr *fca =
-                container_of(attr, struct fuse_conn_attr, attr);
-
-        if (fca->show)
-                return fca->show(get_fuse_conn_kobj(kobj), page);
-        else
-                return -EACCES;
-}
-
-static ssize_t fuse_conn_attr_store(struct kobject *kobj,
-                                    struct attribute *attr,
-                                    const char *page, size_t count)
-{
-        struct fuse_conn_attr *fca =
-                container_of(attr, struct fuse_conn_attr, attr);
-
-        if (fca->store)
-                return fca->store(get_fuse_conn_kobj(kobj), page, count);
-        else
-                return -EACCES;
-}
-
-static struct sysfs_ops fuse_conn_sysfs_ops = {
-        .show   = &fuse_conn_attr_show,
-        .store  = &fuse_conn_attr_store,
-};
-
-static struct kobj_type ktype_fuse_conn = {
-        .release        = fuse_conn_release,
-        .sysfs_ops      = &fuse_conn_sysfs_ops,
-        .default_attrs  = fuse_conn_attrs,
-};
-
 static decl_subsys(fuse, NULL, NULL);
-static decl_subsys(connections, &ktype_fuse_conn, NULL);
+static decl_subsys(connections, NULL, NULL);
 
 static void fuse_inode_init_once(void *foo, kmem_cache_t *cachep,
                                  unsigned long flags)
@@ -719,6 +667,7 @@ static int __init fuse_init(void)
         printk("fuse init (API version %i.%i)\n",
                FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);
 
+        INIT_LIST_HEAD(&fuse_conn_list);
         res = fuse_fs_init();
         if (res)
                 goto err;
@@ -731,8 +680,14 @@ static int __init fuse_init(void)
         if (res)
                 goto err_dev_cleanup;
 
+        res = fuse_ctl_init();
+        if (res)
+                goto err_sysfs_cleanup;
+
         return 0;
 
+ err_sysfs_cleanup:
+        fuse_sysfs_cleanup();
  err_dev_cleanup:
         fuse_dev_cleanup();
  err_fs_cleanup:
@@ -745,6 +700,7 @@ static void __exit fuse_exit(void)
 {
         printk(KERN_DEBUG "fuse exit\n");
 
+        fuse_ctl_cleanup();
         fuse_sysfs_cleanup();
         fuse_fs_cleanup();
         fuse_dev_cleanup();
diff --git a/fs/jbd/recovery.c b/fs/jbd/recovery.c
index 80d7f53fd0a7..de5bafb4e853 100644
--- a/fs/jbd/recovery.c
+++ b/fs/jbd/recovery.c
@@ -531,6 +531,7 @@ static int do_one_pass(journal_t *journal,
                 default:
                         jbd_debug(3, "Unrecognised magic %d, end of scan.\n",
                                   blocktype);
+                        brelse(bh);
                         goto done;
                 }
         }
diff --git a/fs/namei.c b/fs/namei.c
index bb4a3e40e432..c784e8bb57a3 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -2243,14 +2243,16 @@ asmlinkage long sys_linkat(int olddfd, const char __user *oldname,
         int error;
         char * to;
 
-        if (flags != 0)
+        if ((flags & ~AT_SYMLINK_FOLLOW) != 0)
                 return -EINVAL;
 
         to = getname(newname);
         if (IS_ERR(to))
                 return PTR_ERR(to);
 
-        error = __user_walk_fd(olddfd, oldname, 0, &old_nd);
+        error = __user_walk_fd(olddfd, oldname,
+                               flags & AT_SYMLINK_FOLLOW ? LOOKUP_FOLLOW : 0,
+                               &old_nd);
         if (error)
                 goto exit;
         error = do_path_lookup(newdfd, to, LOOKUP_PARENT, &nd);
diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index 88292f9e4b9b..2e42c2dcae12 100644
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -1358,7 +1358,7 @@ err_out:
         goto out;
 }
 
-static size_t __ntfs_copy_from_user_iovec(char *vaddr,
+static size_t __ntfs_copy_from_user_iovec_inatomic(char *vaddr,
                 const struct iovec *iov, size_t iov_ofs, size_t bytes)
 {
         size_t total = 0;
@@ -1376,10 +1376,6 @@ static size_t __ntfs_copy_from_user_iovec(char *vaddr,
                 bytes -= len;
                 vaddr += len;
                 if (unlikely(left)) {
-                        /*
-                         * Zero the rest of the target like __copy_from_user().
-                         */
-                        memset(vaddr, 0, bytes);
                         total -= left;
                         break;
                 }
@@ -1420,11 +1416,13 @@ static inline void ntfs_set_next_iovec(const struct iovec **iovp,
  * pages (out to offset + bytes), to emulate ntfs_copy_from_user()'s
  * single-segment behaviour.
  *
- * We call the same helper (__ntfs_copy_from_user_iovec()) both when atomic and
- * when not atomic.  This is ok because __ntfs_copy_from_user_iovec() calls
- * __copy_from_user_inatomic() and it is ok to call this when non-atomic.  In
- * fact, the only difference between __copy_from_user_inatomic() and
- * __copy_from_user() is that the latter calls might_sleep().  And on many
+ * We call the same helper (__ntfs_copy_from_user_iovec_inatomic()) both
+ * when atomic and when not atomic.  This is ok because
+ * __ntfs_copy_from_user_iovec_inatomic() calls __copy_from_user_inatomic()
+ * and it is ok to call this when non-atomic.
+ * Infact, the only difference between __copy_from_user_inatomic() and
+ * __copy_from_user() is that the latter calls might_sleep() and the former
+ * should not zero the tail of the buffer on error.  And on many
  * architectures __copy_from_user_inatomic() is just defined to
  * __copy_from_user() so it makes no difference at all on those architectures.
  */
@@ -1441,14 +1439,18 @@ static inline size_t ntfs_copy_from_user_iovec(struct page **pages,
                 if (len > bytes)
                         len = bytes;
                 kaddr = kmap_atomic(*pages, KM_USER0);
-                copied = __ntfs_copy_from_user_iovec(kaddr + ofs,
+                copied = __ntfs_copy_from_user_iovec_inatomic(kaddr + ofs,
                                 *iov, *iov_ofs, len);
                 kunmap_atomic(kaddr, KM_USER0);
                 if (unlikely(copied != len)) {
                         /* Do it the slow way. */
                         kaddr = kmap(*pages);
-                        copied = __ntfs_copy_from_user_iovec(kaddr + ofs,
+                        copied = __ntfs_copy_from_user_iovec_inatomic(kaddr + ofs,
                                         *iov, *iov_ofs, len);
+                        /*
+                         * Zero the rest of the target like __copy_from_user().
+                         */
+                        memset(kaddr + ofs + copied, 0, len - copied);
                         kunmap(*pages);
                         if (unlikely(copied != len))
                                 goto err_out;
diff --git a/fs/open.c b/fs/open.c
index 5fb16e5267dc..303f06d2a7b9 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -322,7 +322,7 @@ static long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
 
         error = locks_verify_truncate(inode, file, length);
         if (!error)
-                error = do_truncate(dentry, length, 0, file);
+                error = do_truncate(dentry, length, ATTR_MTIME|ATTR_CTIME, file);
 out_putf:
         fput(file);
 out:
diff --git a/fs/openpromfs/inode.c b/fs/openpromfs/inode.c
index 464e2bce0203..efc7c91128af 100644
--- a/fs/openpromfs/inode.c
+++ b/fs/openpromfs/inode.c
@@ -64,6 +64,11 @@ static int openpromfs_readdir(struct file *, void *, filldir_t);
 static struct dentry *openpromfs_lookup(struct inode *, struct dentry *dentry, struct nameidata *nd);
 static int openpromfs_unlink (struct inode *, struct dentry *dentry);
 
+static inline u16 ptr_nod(void *p)
+{
+    return (long)p & 0xFFFF;
+}
+
 static ssize_t nodenum_read(struct file *file, char __user *buf,
                             size_t count, loff_t *ppos)
 {
@@ -72,7 +77,7 @@ static ssize_t nodenum_read(struct file *file, char __user *buf,
         
         if (count < 0 || !inode->u.generic_ip)
                 return -EINVAL;
-        sprintf (buffer, "%8.8x\n", (u32)(long)(inode->u.generic_ip));
+        sprintf (buffer, "%8.8lx\n", (long)inode->u.generic_ip);
         if (file->f_pos >= 9)
                 return 0;
         if (count > 9 - file->f_pos)
@@ -95,9 +100,9 @@ static ssize_t property_read(struct file *filp, char __user *buf,
         char buffer[64];
         
         if (!filp->private_data) {
-                node = nodes[(u16)((long)inode->u.generic_ip)].node;
+                node = nodes[ptr_nod(inode->u.generic_ip)].node;
                 i = ((u32)(long)inode->u.generic_ip) >> 16;
-                if ((u16)((long)inode->u.generic_ip) == aliases) {
+                if (ptr_nod(inode->u.generic_ip) == aliases) {
                         if (i >= aliases_nodes)
                                 p = NULL;
                         else
@@ -111,7 +116,7 @@ static ssize_t property_read(struct file *filp, char __user *buf,
                         return -EIO;
                 i = prom_getproplen (node, p);
                 if (i < 0) {
-                        if ((u16)((long)inode->u.generic_ip) == aliases)
+                        if (ptr_nod(inode->u.generic_ip) == aliases)
                                 i = 0;
                         else
                                 return -EIO;
@@ -123,7 +128,7 @@ static ssize_t property_read(struct file *filp, char __user *buf,
                                               GFP_KERNEL);
                 if (!filp->private_data)
                         return -ENOMEM;
-                op = (openprom_property *)filp->private_data;
+                op = filp->private_data;
                 op->flag = 0;
                 op->alloclen = 2 * i;
                 strcpy (op->name, p);
@@ -163,7 +168,7 @@ static ssize_t property_read(struct file *filp, char __user *buf,
                                 op->len--;
                 }
         } else
-                op = (openprom_property *)filp->private_data;
+                op = filp->private_data;
         if (!count || !(op->len || (op->flag & OPP_ASCIIZ)))
                 return 0;
         if (*ppos >= 0xffffff || count >= 0xffffff)
@@ -335,7 +340,7 @@ static ssize_t property_write(struct file *filp, const char __user *buf,
                         return i;
         }
         k = *ppos;
-        op = (openprom_property *)filp->private_data;
+        op = filp->private_data;
         if (!(op->flag & OPP_STRING)) {
                 u32 *first, *last;
                 int first_off, last_cnt;
@@ -388,13 +393,13 @@ static ssize_t property_write(struct file *filp, const char __user *buf,
                         memcpy (b, filp->private_data,
                                 sizeof (openprom_property)
                                 + strlen (op->name) + op->alloclen);
-                        memset (((char *)b) + sizeof (openprom_property)
+                        memset (b + sizeof (openprom_property)
                                 + strlen (op->name) + op->alloclen, 
                                 0, 2 * i - op->alloclen);
-                        op = (openprom_property *)b;
+                        op = b;
                         op->alloclen = 2*i;
                         b = filp->private_data;
-                        filp->private_data = (void *)op;
+                        filp->private_data = op;
                         kfree (b);
                 }
                 first = ((u32 *)op->value) + (k / 9);
@@ -448,10 +453,11 @@ static ssize_t property_write(struct file *filp, const char __user *buf,
                                         *q |= simple_strtoul (tmp, NULL, 16);
                                         buf += last_cnt;
                                 } else {
-                                        char tchars[17]; /* XXX yuck... */
+                                        char tchars[2 * sizeof(long) + 1];
 
-                                        if (copy_from_user(tchars, buf, 16))
+                                        if (copy_from_user(tchars, buf, sizeof(tchars) - 1))
                                                 return -EFAULT;
+                                        tchars[sizeof(tchars) - 1] = '\0';
                                         *q = simple_strtoul (tchars, NULL, 16);
                                         buf += 9;
                                 }
@@ -497,13 +503,13 @@ write_try_string:
                         memcpy (b, filp->private_data,
                                 sizeof (openprom_property)
                                 + strlen (op->name) + op->alloclen);
-                        memset (((char *)b) + sizeof (openprom_property)
+                        memset (b + sizeof (openprom_property)
                                 + strlen (op->name) + op->alloclen, 
                                 0, 2*(count - *ppos) - op->alloclen);
-                        op = (openprom_property *)b;
+                        op = b;
                         op->alloclen = 2*(count + *ppos);
                         b = filp->private_data;
-                        filp->private_data = (void *)op;
+                        filp->private_data = op;
                         kfree (b);
                 }
                 p = op->value + *ppos - ((op->flag & OPP_QUOTED) ? 1 : 0);
@@ -532,15 +538,15 @@ write_try_string:
 
 int property_release (struct inode *inode, struct file *filp)
 {
-        openprom_property *op = (openprom_property *)filp->private_data;
+        openprom_property *op = filp->private_data;
         int error;
         u32 node;
         
         if (!op)
                 return 0;
         lock_kernel();
-        node = nodes[(u16)((long)inode->u.generic_ip)].node;
-        if ((u16)((long)inode->u.generic_ip) == aliases) {
+        node = nodes[ptr_nod(inode->u.generic_ip)].node;
+        if (ptr_nod(inode->u.generic_ip) == aliases) {
                 if ((op->flag & OPP_DIRTY) && (op->flag & OPP_STRING)) {
                         char *p = op->name;
                         int i = (op->value - op->name) - strlen (op->name) - 1;
@@ -931,7 +937,7 @@ static int __init check_space (u16 n)
                         return -1;
 
                 if (nodes) {
-                        memcpy ((char *)pages, (char *)nodes,
+                        memcpy ((char *)pages, nodes,
                                 (1 << alloced) * PAGE_SIZE);
                         free_pages ((unsigned long)nodes, alloced);
                 }
diff --git a/fs/select.c b/fs/select.c
index 9c4f0f2604f1..33b72ba0f86f 100644
--- a/fs/select.c
+++ b/fs/select.c
@@ -746,9 +746,9 @@ out_fds:
 asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds,
                         long timeout_msecs)
 {
-        s64 timeout_jiffies = 0;
+        s64 timeout_jiffies;
 
-        if (timeout_msecs) {
+        if (timeout_msecs > 0) {
 #if HZ > 1000
                 /* We can only overflow if HZ > 1000 */
                 if (timeout_msecs / 1000 > (s64)0x7fffffffffffffffULL / (s64)HZ)
@@ -756,6 +756,9 @@ asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds,
                 else
 #endif
                         timeout_jiffies = msecs_to_jiffies(timeout_msecs);
+        } else {
+                /* Infinite (< 0) or no (0) timeout */
+                timeout_jiffies = timeout_msecs;
         }
 
         return do_sys_poll(ufds, nfds, &timeout_jiffies);
diff --git a/fs/smbfs/smbiod.c b/fs/smbfs/smbiod.c
index 481a97a423fa..3f71384020cb 100644
--- a/fs/smbfs/smbiod.c
+++ b/fs/smbfs/smbiod.c
@@ -20,6 +20,7 @@
 #include <linux/smp_lock.h>
 #include <linux/module.h>
 #include <linux/net.h>
+#include <linux/kthread.h>
 #include <net/ip.h>
 
 #include <linux/smb_fs.h>
@@ -40,7 +41,7 @@ enum smbiod_state {
 };
 
 static enum smbiod_state smbiod_state = SMBIOD_DEAD;
-static pid_t smbiod_pid;
+static struct task_struct *smbiod_thread;
 static DECLARE_WAIT_QUEUE_HEAD(smbiod_wait);
 static LIST_HEAD(smb_servers);
 static DEFINE_SPINLOCK(servers_lock);
@@ -67,20 +68,29 @@ void smbiod_wake_up(void)
  */
 static int smbiod_start(void)
 {
-        pid_t pid;
+        struct task_struct *tsk;
+        int err = 0;
+
         if (smbiod_state != SMBIOD_DEAD)
                 return 0;
         smbiod_state = SMBIOD_STARTING;
         __module_get(THIS_MODULE);
         spin_unlock(&servers_lock);
-        pid = kernel_thread(smbiod, NULL, 0);
-        if (pid < 0)
+        tsk = kthread_run(smbiod, NULL, "smbiod");
+        if (IS_ERR(tsk)) {
+                err = PTR_ERR(tsk);
                 module_put(THIS_MODULE);
+        }
 
         spin_lock(&servers_lock);
-        smbiod_state = pid < 0 ? SMBIOD_DEAD : SMBIOD_RUNNING;
-        smbiod_pid = pid;
-        return pid;
+        if (err < 0) {
+                smbiod_state = SMBIOD_DEAD;
+                smbiod_thread = NULL;
+        } else {
+                smbiod_state = SMBIOD_RUNNING;
+                smbiod_thread = tsk;
+        }
+        return err;
 }
 
 /*
@@ -290,8 +300,6 @@ out:
  */
 static int smbiod(void *unused)
 {
-        daemonize("smbiod");
-
         allow_signal(SIGKILL);
 
         VERBOSE("SMB Kernel thread starting (%d) ...\n", current->pid);
diff --git a/fs/ufs/balloc.c b/fs/ufs/balloc.c
index 3ada9dcf55b8..95b878e5c7a0 100644
--- a/fs/ufs/balloc.c
+++ b/fs/ufs/balloc.c
@@ -21,14 +21,6 @@
 #include "swab.h"
 #include "util.h"
 
-#undef UFS_BALLOC_DEBUG
-
-#ifdef UFS_BALLOC_DEBUG
-#define UFSD(x) printk("(%s, %d), %s:", __FILE__, __LINE__, __FUNCTION__); printk x;
-#else
-#define UFSD(x)
-#endif
-
 static unsigned ufs_add_fragments (struct inode *, unsigned, unsigned, unsigned, int *);
 static unsigned ufs_alloc_fragments (struct inode *, unsigned, unsigned, unsigned, int *);
 static unsigned ufs_alloccg_block (struct inode *, struct ufs_cg_private_info *, unsigned, int *);
@@ -39,7 +31,8 @@ static void ufs_clusteracct(struct super_block *, struct ufs_cg_private_info *,
 /*
  * Free 'count' fragments from fragment number 'fragment'
  */
-void ufs_free_fragments (struct inode * inode, unsigned fragment, unsigned count) {
+void ufs_free_fragments(struct inode *inode, unsigned fragment, unsigned count)
+{
         struct super_block * sb;
         struct ufs_sb_private_info * uspi;
         struct ufs_super_block_first * usb1;
@@ -51,7 +44,7 @@ void ufs_free_fragments (struct inode * inode, unsigned fragment, unsigned count
         uspi = UFS_SB(sb)->s_uspi;
         usb1 = ubh_get_usb_first(uspi);
         
-        UFSD(("ENTER, fragment %u, count %u\n", fragment, count))
+        UFSD("ENTER, fragment %u, count %u\n", fragment, count);
         
         if (ufs_fragnum(fragment) + count > uspi->s_fpg)
                 ufs_error (sb, "ufs_free_fragments", "internal error");
@@ -68,7 +61,7 @@ void ufs_free_fragments (struct inode * inode, unsigned fragment, unsigned count
         ucpi = ufs_load_cylinder (sb, cgno);
         if (!ucpi) 
                 goto failed;
-        ucg = ubh_get_ucg (UCPI_UBH);
+        ucg = ubh_get_ucg (UCPI_UBH(ucpi));
         if (!ufs_cg_chkmagic(sb, ucg)) {
                 ufs_panic (sb, "ufs_free_fragments", "internal error, bad magic number on cg %u", cgno);
                 goto failed;
@@ -76,11 +69,11 @@ void ufs_free_fragments (struct inode * inode, unsigned fragment, unsigned count
 
         end_bit = bit + count;
         bbase = ufs_blknum (bit);
-        blkmap = ubh_blkmap (UCPI_UBH, ucpi->c_freeoff, bbase);
+        blkmap = ubh_blkmap (UCPI_UBH(ucpi), ucpi->c_freeoff, bbase);
         ufs_fragacct (sb, blkmap, ucg->cg_frsum, -1);
         for (i = bit; i < end_bit; i++) {
-                if (ubh_isclr (UCPI_UBH, ucpi->c_freeoff, i))
-                        ubh_setbit (UCPI_UBH, ucpi->c_freeoff, i);
+                if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_freeoff, i))
+                        ubh_setbit (UCPI_UBH(ucpi), ucpi->c_freeoff, i);
                 else 
                         ufs_error (sb, "ufs_free_fragments",
                                    "bit already cleared for fragment %u", i);
@@ -90,51 +83,52 @@ void ufs_free_fragments (struct inode * inode, unsigned fragment, unsigned count
 
         
         fs32_add(sb, &ucg->cg_cs.cs_nffree, count);
-        fs32_add(sb, &usb1->fs_cstotal.cs_nffree, count);
+        uspi->cs_total.cs_nffree += count;
         fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, count);
-        blkmap = ubh_blkmap (UCPI_UBH, ucpi->c_freeoff, bbase);
+        blkmap = ubh_blkmap (UCPI_UBH(ucpi), ucpi->c_freeoff, bbase);
         ufs_fragacct(sb, blkmap, ucg->cg_frsum, 1);
 
         /*
          * Trying to reassemble free fragments into block
          */
         blkno = ufs_fragstoblks (bbase);
-        if (ubh_isblockset(UCPI_UBH, ucpi->c_freeoff, blkno)) {
+        if (ubh_isblockset(UCPI_UBH(ucpi), ucpi->c_freeoff, blkno)) {
                 fs32_sub(sb, &ucg->cg_cs.cs_nffree, uspi->s_fpb);
-                fs32_sub(sb, &usb1->fs_cstotal.cs_nffree, uspi->s_fpb);
+                uspi->cs_total.cs_nffree -= uspi->s_fpb;
                 fs32_sub(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, uspi->s_fpb);
                 if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD)
                         ufs_clusteracct (sb, ucpi, blkno, 1);
                 fs32_add(sb, &ucg->cg_cs.cs_nbfree, 1);
-                fs32_add(sb, &usb1->fs_cstotal.cs_nbfree, 1);
+                uspi->cs_total.cs_nbfree++;
                 fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nbfree, 1);
                 cylno = ufs_cbtocylno (bbase);
                 fs16_add(sb, &ubh_cg_blks(ucpi, cylno, ufs_cbtorpos(bbase)), 1);
                 fs32_add(sb, &ubh_cg_blktot(ucpi, cylno), 1);
         }
         
-        ubh_mark_buffer_dirty (USPI_UBH);
-        ubh_mark_buffer_dirty (UCPI_UBH);
+        ubh_mark_buffer_dirty (USPI_UBH(uspi));
+        ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
         if (sb->s_flags & MS_SYNCHRONOUS) {
-                ubh_ll_rw_block (SWRITE, 1, (struct ufs_buffer_head **)&ucpi);
-                ubh_wait_on_buffer (UCPI_UBH);
+                ubh_ll_rw_block(SWRITE, UCPI_UBH(ucpi));
+                ubh_wait_on_buffer (UCPI_UBH(ucpi));
         }
         sb->s_dirt = 1;
         
         unlock_super (sb);
-        UFSD(("EXIT\n"))
+        UFSD("EXIT\n");
         return;
 
 failed:
         unlock_super (sb);
-        UFSD(("EXIT (FAILED)\n"))
+        UFSD("EXIT (FAILED)\n");
         return;
 }
 
 /*
  * Free 'count' fragments from fragment number 'fragment' (free whole blocks)
  */
-void ufs_free_blocks (struct inode * inode, unsigned fragment, unsigned count) {
+void ufs_free_blocks(struct inode *inode, unsigned fragment, unsigned count)
+{
         struct super_block * sb;
         struct ufs_sb_private_info * uspi;
         struct ufs_super_block_first * usb1;
@@ -146,7 +140,7 @@ void ufs_free_blocks (struct inode * inode, unsigned fragment, unsigned count) {
         uspi = UFS_SB(sb)->s_uspi;
         usb1 = ubh_get_usb_first(uspi);
 
-        UFSD(("ENTER, fragment %u, count %u\n", fragment, count))
+        UFSD("ENTER, fragment %u, count %u\n", fragment, count);
         
         if ((fragment & uspi->s_fpbmask) || (count & uspi->s_fpbmask)) {
                 ufs_error (sb, "ufs_free_blocks", "internal error, "
@@ -162,7 +156,7 @@ do_more:
         bit = ufs_dtogd (fragment);
         if (cgno >= uspi->s_ncg) {
                 ufs_panic (sb, "ufs_free_blocks", "freeing blocks are outside device");
-                goto failed;
+                goto failed_unlock;
         }
         end_bit = bit + count;
         if (end_bit > uspi->s_fpg) {
@@ -173,36 +167,36 @@ do_more:
 
         ucpi = ufs_load_cylinder (sb, cgno);
         if (!ucpi) 
-                goto failed;
-        ucg = ubh_get_ucg (UCPI_UBH);
+                goto failed_unlock;
+        ucg = ubh_get_ucg (UCPI_UBH(ucpi));
         if (!ufs_cg_chkmagic(sb, ucg)) {
                 ufs_panic (sb, "ufs_free_blocks", "internal error, bad magic number on cg %u", cgno);
-                goto failed;
+                goto failed_unlock;
         }
 
         for (i = bit; i < end_bit; i += uspi->s_fpb) {
                 blkno = ufs_fragstoblks(i);
-                if (ubh_isblockset(UCPI_UBH, ucpi->c_freeoff, blkno)) {
+                if (ubh_isblockset(UCPI_UBH(ucpi), ucpi->c_freeoff, blkno)) {
                         ufs_error(sb, "ufs_free_blocks", "freeing free fragment");
                 }
-                ubh_setblock(UCPI_UBH, ucpi->c_freeoff, blkno);
+                ubh_setblock(UCPI_UBH(ucpi), ucpi->c_freeoff, blkno);
                 if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD)
                         ufs_clusteracct (sb, ucpi, blkno, 1);
                 DQUOT_FREE_BLOCK(inode, uspi->s_fpb);
 
                 fs32_add(sb, &ucg->cg_cs.cs_nbfree, 1);
-                fs32_add(sb, &usb1->fs_cstotal.cs_nbfree, 1);
+                uspi->cs_total.cs_nbfree++;
                 fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nbfree, 1);
                 cylno = ufs_cbtocylno(i);
                 fs16_add(sb, &ubh_cg_blks(ucpi, cylno, ufs_cbtorpos(i)), 1);
                 fs32_add(sb, &ubh_cg_blktot(ucpi, cylno), 1);
         }
 
-        ubh_mark_buffer_dirty (USPI_UBH);
-        ubh_mark_buffer_dirty (UCPI_UBH);
+        ubh_mark_buffer_dirty (USPI_UBH(uspi));
+        ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
         if (sb->s_flags & MS_SYNCHRONOUS) {
-                ubh_ll_rw_block (SWRITE, 1, (struct ufs_buffer_head **)&ucpi);
-                ubh_wait_on_buffer (UCPI_UBH);
+                ubh_ll_rw_block(SWRITE, UCPI_UBH(ucpi));
+                ubh_wait_on_buffer (UCPI_UBH(ucpi));
         }
 
         if (overflow) {
@@ -213,38 +207,127 @@ do_more:
 
         sb->s_dirt = 1;
         unlock_super (sb);
-        UFSD(("EXIT\n"))
+        UFSD("EXIT\n");
         return;
 
-failed:
+failed_unlock:
         unlock_super (sb);
-        UFSD(("EXIT (FAILED)\n"))
+failed:
+        UFSD("EXIT (FAILED)\n");
         return;
 }
 
+static struct page *ufs_get_locked_page(struct address_space *mapping,
+                                  unsigned long index)
+{
+        struct page *page;
+
+try_again:
+        page = find_lock_page(mapping, index);
+        if (!page) {
+                page = read_cache_page(mapping, index,
+                                       (filler_t*)mapping->a_ops->readpage,
+                                       NULL);
+                if (IS_ERR(page)) {
+                        printk(KERN_ERR "ufs_change_blocknr: "
+                               "read_cache_page error: ino %lu, index: %lu\n",
+                               mapping->host->i_ino, index);
+                        goto out;
+                }
 
+                lock_page(page);
 
-#define NULLIFY_FRAGMENTS \
-        for (i = oldcount; i < newcount; i++) { \
-                bh = sb_getblk(sb, result + i); \
-                memset (bh->b_data, 0, sb->s_blocksize); \
-                set_buffer_uptodate(bh); \
-                mark_buffer_dirty (bh); \
-                if (IS_SYNC(inode)) \
-                        sync_dirty_buffer(bh); \
-                brelse (bh); \
+                if (!PageUptodate(page) || PageError(page)) {
+                        unlock_page(page);
+                        page_cache_release(page);
+
+                        printk(KERN_ERR "ufs_change_blocknr: "
+                               "can not read page: ino %lu, index: %lu\n",
+                               mapping->host->i_ino, index);
+
+                        page = ERR_PTR(-EIO);
+                        goto out;
+                }
         }
 
-unsigned ufs_new_fragments (struct inode * inode, __fs32 * p, unsigned fragment,
-        unsigned goal, unsigned count, int * err )
+        if (unlikely(!page->mapping || !page_has_buffers(page))) {
+                unlock_page(page);
+                page_cache_release(page);
+                goto try_again;/*we really need these buffers*/
+        }
+out:
+        return page;
+}
+
+/*
+ * Modify inode page cache in such way:
+ * have - blocks with b_blocknr equal to oldb...oldb+count-1
+ * get - blocks with b_blocknr equal to newb...newb+count-1
+ * also we suppose that oldb...oldb+count-1 blocks
+ * situated at the end of file.
+ *
+ * We can come here from ufs_writepage or ufs_prepare_write,
+ * locked_page is argument of these functions, so we already lock it.
+ */
+static void ufs_change_blocknr(struct inode *inode, unsigned int baseblk,
+                               unsigned int count, unsigned int oldb,
+                               unsigned int newb, struct page *locked_page)
+{
+        unsigned int blk_per_page = 1 << (PAGE_CACHE_SHIFT - inode->i_blkbits);
+        struct address_space *mapping = inode->i_mapping;
+        pgoff_t index, cur_index = locked_page->index;
+        unsigned int i, j;
+        struct page *page;
+        struct buffer_head *head, *bh;
+
+        UFSD("ENTER, ino %lu, count %u, oldb %u, newb %u\n",
+              inode->i_ino, count, oldb, newb);
+
+        BUG_ON(!PageLocked(locked_page));
+
+        for (i = 0; i < count; i += blk_per_page) {
+                index = (baseblk+i) >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
+
+                if (likely(cur_index != index)) {
+                        page = ufs_get_locked_page(mapping, index);
+                        if (IS_ERR(page))
+                                continue;
+                } else
+                        page = locked_page;
+
+                j = i;
+                head = page_buffers(page);
+                bh = head;
+                do {
+                        if (likely(bh->b_blocknr == j + oldb && j < count)) {
+                                unmap_underlying_metadata(bh->b_bdev,
+                                                          bh->b_blocknr);
+                                bh->b_blocknr = newb + j++;
+                                mark_buffer_dirty(bh);
+                        }
+
+                        bh = bh->b_this_page;
+                } while (bh != head);
+
+                set_page_dirty(page);
+
+                if (likely(cur_index != index)) {
+                        unlock_page(page);
+                        page_cache_release(page);
+                }
+        }
+        UFSD("EXIT\n");
+}
+
+unsigned ufs_new_fragments(struct inode * inode, __fs32 * p, unsigned fragment,
+                           unsigned goal, unsigned count, int * err, struct page *locked_page)
 {
         struct super_block * sb;
         struct ufs_sb_private_info * uspi;
         struct ufs_super_block_first * usb1;
-        struct buffer_head * bh;
-        unsigned cgno, oldcount, newcount, tmp, request, i, result;
+        unsigned cgno, oldcount, newcount, tmp, request, result;
         
-        UFSD(("ENTER, ino %lu, fragment %u, goal %u, count %u\n", inode->i_ino, fragment, goal, count))
+        UFSD("ENTER, ino %lu, fragment %u, goal %u, count %u\n", inode->i_ino, fragment, goal, count);
         
         sb = inode->i_sb;
         uspi = UFS_SB(sb)->s_uspi;
@@ -273,14 +356,14 @@ unsigned ufs_new_fragments (struct inode * inode, __fs32 * p, unsigned fragment,
                         return (unsigned)-1;
                 }
                 if (fragment < UFS_I(inode)->i_lastfrag) {
-                        UFSD(("EXIT (ALREADY ALLOCATED)\n"))
+                        UFSD("EXIT (ALREADY ALLOCATED)\n");
                         unlock_super (sb);
                         return 0;
                 }
         }
         else {
                 if (tmp) {
-                        UFSD(("EXIT (ALREADY ALLOCATED)\n"))
+                        UFSD("EXIT (ALREADY ALLOCATED)\n");
                         unlock_super(sb);
                         return 0;
                 }
@@ -289,9 +372,9 @@ unsigned ufs_new_fragments (struct inode * inode, __fs32 * p, unsigned fragment,
         /*
          * There is not enough space for user on the device
          */
-        if (!capable(CAP_SYS_RESOURCE) && ufs_freespace(usb1, UFS_MINFREE) <= 0) {
+        if (!capable(CAP_SYS_RESOURCE) && ufs_freespace(uspi, UFS_MINFREE) <= 0) {
                 unlock_super (sb);
-                UFSD(("EXIT (FAILED)\n"))
+                UFSD("EXIT (FAILED)\n");
                 return 0;
         }
 
@@ -310,12 +393,10 @@ unsigned ufs_new_fragments (struct inode * inode, __fs32 * p, unsigned fragment,
                 if (result) {
                         *p = cpu_to_fs32(sb, result);
                         *err = 0;
-                        inode->i_blocks += count << uspi->s_nspfshift;
                         UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count);
-                        NULLIFY_FRAGMENTS
                 }
                 unlock_super(sb);
-                UFSD(("EXIT, result %u\n", result))
+                UFSD("EXIT, result %u\n", result);
                 return result;
         }
 
@@ -325,11 +406,9 @@ unsigned ufs_new_fragments (struct inode * inode, __fs32 * p, unsigned fragment,
         result = ufs_add_fragments (inode, tmp, oldcount, newcount, err);
         if (result) {
                 *err = 0;
-                inode->i_blocks += count << uspi->s_nspfshift;
                 UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count);
-                NULLIFY_FRAGMENTS
                 unlock_super(sb);
-                UFSD(("EXIT, result %u\n", result))
+                UFSD("EXIT, result %u\n", result);
                 return result;
         }
 
@@ -339,8 +418,8 @@ unsigned ufs_new_fragments (struct inode * inode, __fs32 * p, unsigned fragment,
         switch (fs32_to_cpu(sb, usb1->fs_optim)) {
             case UFS_OPTSPACE:
                 request = newcount;
-                if (uspi->s_minfree < 5 || fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree) 
-                    > uspi->s_dsize * uspi->s_minfree / (2 * 100) )
+                if (uspi->s_minfree < 5 || uspi->cs_total.cs_nffree
+                    > uspi->s_dsize * uspi->s_minfree / (2 * 100))
                         break;
                 usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTTIME);
                 break;
@@ -349,7 +428,7 @@ unsigned ufs_new_fragments (struct inode * inode, __fs32 * p, unsigned fragment,
         
             case UFS_OPTTIME:
                 request = uspi->s_fpb;
-                if (fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree) < uspi->s_dsize *
+                if (uspi->cs_total.cs_nffree < uspi->s_dsize *
                     (uspi->s_minfree - 2) / 100)
                         break;
                 usb1->fs_optim = cpu_to_fs32(sb, UFS_OPTTIME);
@@ -357,39 +436,22 @@ unsigned ufs_new_fragments (struct inode * inode, __fs32 * p, unsigned fragment,
         }
         result = ufs_alloc_fragments (inode, cgno, goal, request, err);
         if (result) {
-                for (i = 0; i < oldcount; i++) {
-                        bh = sb_bread(sb, tmp + i);
-                        if(bh)
-                        {
-                                clear_buffer_dirty(bh);
-                                bh->b_blocknr = result + i;
-                                mark_buffer_dirty (bh);
-                                if (IS_SYNC(inode))
-                                        sync_dirty_buffer(bh);
-                                brelse (bh);
-                        }
-                        else
-                        {
-                                printk(KERN_ERR "ufs_new_fragments: bread fail\n");
-                                unlock_super(sb);
-                                return 0;
-                        }
-                }
+                ufs_change_blocknr(inode, fragment - oldcount, oldcount, tmp,
+                                   result, locked_page);
+
                 *p = cpu_to_fs32(sb, result);
                 *err = 0;
-                inode->i_blocks += count << uspi->s_nspfshift;
                 UFS_I(inode)->i_lastfrag = max_t(u32, UFS_I(inode)->i_lastfrag, fragment + count);
-                NULLIFY_FRAGMENTS
                 unlock_super(sb);
                 if (newcount < request)
                         ufs_free_fragments (inode, result + newcount, request - newcount);
                 ufs_free_fragments (inode, tmp, oldcount);
-                UFSD(("EXIT, result %u\n", result))
+                UFSD("EXIT, result %u\n", result);
                 return result;
         }
 
         unlock_super(sb);
-        UFSD(("EXIT (FAILED)\n"))
+        UFSD("EXIT (FAILED)\n");
         return 0;
 }               
 
@@ -404,7 +466,7 @@ ufs_add_fragments (struct inode * inode, unsigned fragment,
         struct ufs_cylinder_group * ucg;
         unsigned cgno, fragno, fragoff, count, fragsize, i;
         
-        UFSD(("ENTER, fragment %u, oldcount %u, newcount %u\n", fragment, oldcount, newcount))
+        UFSD("ENTER, fragment %u, oldcount %u, newcount %u\n", fragment, oldcount, newcount);
         
         sb = inode->i_sb;
         uspi = UFS_SB(sb)->s_uspi;
@@ -419,7 +481,7 @@ ufs_add_fragments (struct inode * inode, unsigned fragment,
         ucpi = ufs_load_cylinder (sb, cgno);
         if (!ucpi)
                 return 0;
-        ucg = ubh_get_ucg (UCPI_UBH);
+        ucg = ubh_get_ucg (UCPI_UBH(ucpi));
         if (!ufs_cg_chkmagic(sb, ucg)) {
                 ufs_panic (sb, "ufs_add_fragments",
                         "internal error, bad magic number on cg %u", cgno);
@@ -429,14 +491,14 @@ ufs_add_fragments (struct inode * inode, unsigned fragment,
         fragno = ufs_dtogd (fragment);
         fragoff = ufs_fragnum (fragno);
         for (i = oldcount; i < newcount; i++)
-                if (ubh_isclr (UCPI_UBH, ucpi->c_freeoff, fragno + i))
+                if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_freeoff, fragno + i))
                         return 0;
         /*
          * Block can be extended
          */
         ucg->cg_time = cpu_to_fs32(sb, get_seconds());
         for (i = newcount; i < (uspi->s_fpb - fragoff); i++)
-                if (ubh_isclr (UCPI_UBH, ucpi->c_freeoff, fragno + i))
+                if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_freeoff, fragno + i))
                         break;
         fragsize = i - oldcount;
         if (!fs32_to_cpu(sb, ucg->cg_frsum[fragsize]))
@@ -446,7 +508,7 @@ ufs_add_fragments (struct inode * inode, unsigned fragment,
         if (fragsize != count)
                 fs32_add(sb, &ucg->cg_frsum[fragsize - count], 1);
         for (i = oldcount; i < newcount; i++)
-                ubh_clrbit (UCPI_UBH, ucpi->c_freeoff, fragno + i);
+                ubh_clrbit (UCPI_UBH(ucpi), ucpi->c_freeoff, fragno + i);
         if(DQUOT_ALLOC_BLOCK(inode, count)) {
                 *err = -EDQUOT;
                 return 0;
@@ -454,17 +516,17 @@ ufs_add_fragments (struct inode * inode, unsigned fragment,
 
         fs32_sub(sb, &ucg->cg_cs.cs_nffree, count);
         fs32_sub(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, count);
-        fs32_sub(sb, &usb1->fs_cstotal.cs_nffree, count);
+        uspi->cs_total.cs_nffree -= count;
         
-        ubh_mark_buffer_dirty (USPI_UBH);
-        ubh_mark_buffer_dirty (UCPI_UBH);
+        ubh_mark_buffer_dirty (USPI_UBH(uspi));
+        ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
         if (sb->s_flags & MS_SYNCHRONOUS) {
-                ubh_ll_rw_block (SWRITE, 1, (struct ufs_buffer_head **)&ucpi);
-                ubh_wait_on_buffer (UCPI_UBH);
+                ubh_ll_rw_block(SWRITE, UCPI_UBH(ucpi));
+                ubh_wait_on_buffer (UCPI_UBH(ucpi));
         }
         sb->s_dirt = 1;
 
-        UFSD(("EXIT, fragment %u\n", fragment))
+        UFSD("EXIT, fragment %u\n", fragment);
         
         return fragment;
 }
@@ -487,7 +549,7 @@ static unsigned ufs_alloc_fragments (struct inode * inode, unsigned cgno,
         struct ufs_cylinder_group * ucg;
         unsigned oldcg, i, j, k, result, allocsize;
         
-        UFSD(("ENTER, ino %lu, cgno %u, goal %u, count %u\n", inode->i_ino, cgno, goal, count))
+        UFSD("ENTER, ino %lu, cgno %u, goal %u, count %u\n", inode->i_ino, cgno, goal, count);
 
         sb = inode->i_sb;
         uspi = UFS_SB(sb)->s_uspi;
@@ -521,14 +583,14 @@ static unsigned ufs_alloc_fragments (struct inode * inode, unsigned cgno,
                 UFS_TEST_FREE_SPACE_CG
         }
         
-        UFSD(("EXIT (FAILED)\n"))
+        UFSD("EXIT (FAILED)\n");
         return 0;
 
 cg_found:
         ucpi = ufs_load_cylinder (sb, cgno);
         if (!ucpi)
                 return 0;
-        ucg = ubh_get_ucg (UCPI_UBH);
+        ucg = ubh_get_ucg (UCPI_UBH(ucpi));
         if (!ufs_cg_chkmagic(sb, ucg)) 
                 ufs_panic (sb, "ufs_alloc_fragments",
                         "internal error, bad magic number on cg %u", cgno);
@@ -551,12 +613,12 @@ cg_found:
                         return 0;
                 goal = ufs_dtogd (result);
                 for (i = count; i < uspi->s_fpb; i++)
-                        ubh_setbit (UCPI_UBH, ucpi->c_freeoff, goal + i);
+                        ubh_setbit (UCPI_UBH(ucpi), ucpi->c_freeoff, goal + i);
                 i = uspi->s_fpb - count;
                 DQUOT_FREE_BLOCK(inode, i);
 
                 fs32_add(sb, &ucg->cg_cs.cs_nffree, i);
-                fs32_add(sb, &usb1->fs_cstotal.cs_nffree, i);
+                uspi->cs_total.cs_nffree += i;
                 fs32_add(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, i);
                 fs32_add(sb, &ucg->cg_frsum[i], 1);
                 goto succed;
@@ -570,10 +632,10 @@ cg_found:
                 return 0;
         }
         for (i = 0; i < count; i++)
-                ubh_clrbit (UCPI_UBH, ucpi->c_freeoff, result + i);
+                ubh_clrbit (UCPI_UBH(ucpi), ucpi->c_freeoff, result + i);
         
         fs32_sub(sb, &ucg->cg_cs.cs_nffree, count);
-        fs32_sub(sb, &usb1->fs_cstotal.cs_nffree, count);
+        uspi->cs_total.cs_nffree -= count;
         fs32_sub(sb, &UFS_SB(sb)->fs_cs(cgno).cs_nffree, count);
         fs32_sub(sb, &ucg->cg_frsum[allocsize], 1);
 
@@ -581,16 +643,16 @@ cg_found:
                 fs32_add(sb, &ucg->cg_frsum[allocsize - count], 1);
 
 succed:
-        ubh_mark_buffer_dirty (USPI_UBH);
-        ubh_mark_buffer_dirty (UCPI_UBH);
+        ubh_mark_buffer_dirty (USPI_UBH(uspi));
+        ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
         if (sb->s_flags & MS_SYNCHRONOUS) {
-                ubh_ll_rw_block (SWRITE, 1, (struct ufs_buffer_head **)&ucpi);
-                ubh_wait_on_buffer (UCPI_UBH);
+                ubh_ll_rw_block(SWRITE, UCPI_UBH(ucpi));
+                ubh_wait_on_buffer (UCPI_UBH(ucpi));
         }
         sb->s_dirt = 1;
 
         result += cgno * uspi->s_fpg;
-        UFSD(("EXIT3, result %u\n", result))
+        UFSD("EXIT3, result %u\n", result);
         return result;
 }
 
@@ -603,12 +665,12 @@ static unsigned ufs_alloccg_block (struct inode * inode,
         struct ufs_cylinder_group * ucg;
         unsigned result, cylno, blkno;
 
-        UFSD(("ENTER, goal %u\n", goal))
+        UFSD("ENTER, goal %u\n", goal);
 
         sb = inode->i_sb;
         uspi = UFS_SB(sb)->s_uspi;
         usb1 = ubh_get_usb_first(uspi);
-        ucg = ubh_get_ucg(UCPI_UBH);
+        ucg = ubh_get_ucg(UCPI_UBH(ucpi));
 
         if (goal == 0) {
                 goal = ucpi->c_rotor;
@@ -620,7 +682,7 @@ static unsigned ufs_alloccg_block (struct inode * inode,
         /*
          * If the requested block is available, use it.
          */
-        if (ubh_isblockset(UCPI_UBH, ucpi->c_freeoff, ufs_fragstoblks(goal))) {
+        if (ubh_isblockset(UCPI_UBH(ucpi), ucpi->c_freeoff, ufs_fragstoblks(goal))) {
                 result = goal;
                 goto gotit;
         }
@@ -632,7 +694,7 @@ norot:
         ucpi->c_rotor = result;
 gotit:
         blkno = ufs_fragstoblks(result);
-        ubh_clrblock (UCPI_UBH, ucpi->c_freeoff, blkno);
+        ubh_clrblock (UCPI_UBH(ucpi), ucpi->c_freeoff, blkno);
         if ((UFS_SB(sb)->s_flags & UFS_CG_MASK) == UFS_CG_44BSD)
                 ufs_clusteracct (sb, ucpi, blkno, -1);
         if(DQUOT_ALLOC_BLOCK(inode, uspi->s_fpb)) {
@@ -641,31 +703,76 @@ gotit:
         }
 
         fs32_sub(sb, &ucg->cg_cs.cs_nbfree, 1);
-        fs32_sub(sb, &usb1->fs_cstotal.cs_nbfree, 1);
+        uspi->cs_total.cs_nbfree--;
         fs32_sub(sb, &UFS_SB(sb)->fs_cs(ucpi->c_cgx).cs_nbfree, 1);
         cylno = ufs_cbtocylno(result);
         fs16_sub(sb, &ubh_cg_blks(ucpi, cylno, ufs_cbtorpos(result)), 1);
         fs32_sub(sb, &ubh_cg_blktot(ucpi, cylno), 1);
         
-        UFSD(("EXIT, result %u\n", result))
+        UFSD("EXIT, result %u\n", result);
 
         return result;
 }
 
-static unsigned ufs_bitmap_search (struct super_block * sb,
-        struct ufs_cg_private_info * ucpi, unsigned goal, unsigned count)
+static unsigned ubh_scanc(struct ufs_sb_private_info *uspi,
+                          struct ufs_buffer_head *ubh,
+                          unsigned begin, unsigned size,
+                          unsigned char *table, unsigned char mask)
 {
-        struct ufs_sb_private_info * uspi;
-        struct ufs_super_block_first * usb1;
-        struct ufs_cylinder_group * ucg;
-        unsigned start, length, location, result;
-        unsigned possition, fragsize, blockmap, mask;
-        
-        UFSD(("ENTER, cg %u, goal %u, count %u\n", ucpi->c_cgx, goal, count))
+        unsigned rest, offset;
+        unsigned char *cp;
+        
+
+        offset = begin & ~uspi->s_fmask;
+        begin >>= uspi->s_fshift;
+        for (;;) {
+                if ((offset + size) < uspi->s_fsize)
+                        rest = size;
+                else
+                        rest = uspi->s_fsize - offset;
+                size -= rest;
+                cp = ubh->bh[begin]->b_data + offset;
+                while ((table[*cp++] & mask) == 0 && --rest)
+                        ;
+                if (rest || !size)
+                        break;
+                begin++;
+                offset = 0;
+        }
+        return (size + rest);
+}
+
+/*
+ * Find a block of the specified size in the specified cylinder group.
+ * @sp: pointer to super block
+ * @ucpi: pointer to cylinder group info
+ * @goal: near which block we want find new one
+ * @count: specified size
+ */
+static unsigned ufs_bitmap_search(struct super_block *sb,
+                                  struct ufs_cg_private_info *ucpi,
+                                  unsigned goal, unsigned count)
+{
+        /*
+         * Bit patterns for identifying fragments in the block map
+         * used as ((map & mask_arr) == want_arr)
+         */
+        static const int mask_arr[9] = {
+                0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff, 0x1ff, 0x3ff
+        };
+        static const int want_arr[9] = {
+                0x0, 0x2, 0x6, 0xe, 0x1e, 0x3e, 0x7e, 0xfe, 0x1fe
+        };
+        struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
+        struct ufs_super_block_first *usb1;
+        struct ufs_cylinder_group *ucg;
+        unsigned start, length, loc, result;
+        unsigned pos, want, blockmap, mask, end;
+
+        UFSD("ENTER, cg %u, goal %u, count %u\n", ucpi->c_cgx, goal, count);
 
-        uspi = UFS_SB(sb)->s_uspi;
         usb1 = ubh_get_usb_first (uspi);
-        ucg = ubh_get_ucg(UCPI_UBH);
+        ucg = ubh_get_ucg(UCPI_UBH(ucpi));
 
         if (goal)
                 start = ufs_dtogd(goal) >> 3;
@@ -673,53 +780,50 @@ static unsigned ufs_bitmap_search (struct super_block * sb,
                 start = ucpi->c_frotor >> 3;
                 
         length = ((uspi->s_fpg + 7) >> 3) - start;
-        location = ubh_scanc(UCPI_UBH, ucpi->c_freeoff + start, length,
+        loc = ubh_scanc(uspi, UCPI_UBH(ucpi), ucpi->c_freeoff + start, length,
                 (uspi->s_fpb == 8) ? ufs_fragtable_8fpb : ufs_fragtable_other,
                 1 << (count - 1 + (uspi->s_fpb & 7))); 
-        if (location == 0) {
+        if (loc == 0) {
                 length = start + 1;
-                location = ubh_scanc(UCPI_UBH, ucpi->c_freeoff, length, 
-                        (uspi->s_fpb == 8) ? ufs_fragtable_8fpb : ufs_fragtable_other,
-                        1 << (count - 1 + (uspi->s_fpb & 7)));
-                if (location == 0) {
-                        ufs_error (sb, "ufs_bitmap_search",
-                        "bitmap corrupted on cg %u, start %u, length %u, count %u, freeoff %u\n",
-                        ucpi->c_cgx, start, length, count, ucpi->c_freeoff);
+                loc = ubh_scanc(uspi, UCPI_UBH(ucpi), ucpi->c_freeoff, length,
+                                (uspi->s_fpb == 8) ? ufs_fragtable_8fpb :
+                                ufs_fragtable_other,
+                                1 << (count - 1 + (uspi->s_fpb & 7)));
+                if (loc == 0) {
+                        ufs_error(sb, "ufs_bitmap_search",
+                                  "bitmap corrupted on cg %u, start %u,"
+                                  " length %u, count %u, freeoff %u\n",
+                                  ucpi->c_cgx, start, length, count,
+                                  ucpi->c_freeoff);
                         return (unsigned)-1;
                 }
                 start = 0;
         }
-        result = (start + length - location) << 3;
+        result = (start + length - loc) << 3;
         ucpi->c_frotor = result;
 
         /*
          * found the byte in the map
          */
-        blockmap = ubh_blkmap(UCPI_UBH, ucpi->c_freeoff, result);
-        fragsize = 0;
-        for (possition = 0, mask = 1; possition < 8; possition++, mask <<= 1) {
-                if (blockmap & mask) {
-                        if (!(possition & uspi->s_fpbmask))
-                                fragsize = 1;
-                        else 
-                                fragsize++;
-                }
-                else {
-                        if (fragsize == count) {
-                                result += possition - count;
-                                UFSD(("EXIT, result %u\n", result))
-                                return result;
-                        }
-                        fragsize = 0;
-                }
-        }
-        if (fragsize == count) {
-                result += possition - count;
-                UFSD(("EXIT, result %u\n", result))
-                return result;
-        }
-        ufs_error (sb, "ufs_bitmap_search", "block not in map on cg %u\n", ucpi->c_cgx);
-        UFSD(("EXIT (FAILED)\n"))
+
+        for (end = result + 8; result < end; result += uspi->s_fpb) {
+                blockmap = ubh_blkmap(UCPI_UBH(ucpi), ucpi->c_freeoff, result);
+                blockmap <<= 1;
+                mask = mask_arr[count];
+                want = want_arr[count];
+                for (pos = 0; pos <= uspi->s_fpb - count; pos++) {
+                        if ((blockmap & mask) == want) {
+                                UFSD("EXIT, result %u\n", result);
+                                return result + pos;
+                        }
+                        mask <<= 1;
+                        want <<= 1;
+                }
+        }
+
+        ufs_error(sb, "ufs_bitmap_search", "block not in map on cg %u\n",
+                  ucpi->c_cgx);
+        UFSD("EXIT (FAILED)\n");
         return (unsigned)-1;
 }
 
@@ -734,9 +838,9 @@ static void ufs_clusteracct(struct super_block * sb,
                 return;
 
         if (cnt > 0)
-                ubh_setbit(UCPI_UBH, ucpi->c_clusteroff, blkno);
+                ubh_setbit(UCPI_UBH(ucpi), ucpi->c_clusteroff, blkno);
         else
-                ubh_clrbit(UCPI_UBH, ucpi->c_clusteroff, blkno);
+                ubh_clrbit(UCPI_UBH(ucpi), ucpi->c_clusteroff, blkno);
 
         /*
          * Find the size of the cluster going forward.
@@ -745,7 +849,7 @@ static void ufs_clusteracct(struct super_block * sb,
         end = start + uspi->s_contigsumsize;
         if ( end >= ucpi->c_nclusterblks)
                 end = ucpi->c_nclusterblks;
-        i = ubh_find_next_zero_bit (UCPI_UBH, ucpi->c_clusteroff, end, start);
+        i = ubh_find_next_zero_bit (UCPI_UBH(ucpi), ucpi->c_clusteroff, end, start);
         if (i > end)
                 i = end;
         forw = i - start;
@@ -757,7 +861,7 @@ static void ufs_clusteracct(struct super_block * sb,
         end = start - uspi->s_contigsumsize;
         if (end < 0 ) 
                 end = -1;
-        i = ubh_find_last_zero_bit (UCPI_UBH, ucpi->c_clusteroff, start, end);
+        i = ubh_find_last_zero_bit (UCPI_UBH(ucpi), ucpi->c_clusteroff, start, end);
         if ( i < end) 
                 i = end;
         back = start - i;
@@ -769,11 +873,11 @@ static void ufs_clusteracct(struct super_block * sb,
         i = back + forw + 1;
         if (i > uspi->s_contigsumsize)
                 i = uspi->s_contigsumsize;
-        fs32_add(sb, (__fs32*)ubh_get_addr(UCPI_UBH, ucpi->c_clustersumoff + (i << 2)), cnt);
+        fs32_add(sb, (__fs32*)ubh_get_addr(UCPI_UBH(ucpi), ucpi->c_clustersumoff + (i << 2)), cnt);
         if (back > 0)
-                fs32_sub(sb, (__fs32*)ubh_get_addr(UCPI_UBH, ucpi->c_clustersumoff + (back << 2)), cnt);
+                fs32_sub(sb, (__fs32*)ubh_get_addr(UCPI_UBH(ucpi), ucpi->c_clustersumoff + (back << 2)), cnt);
         if (forw > 0)
-                fs32_sub(sb, (__fs32*)ubh_get_addr(UCPI_UBH, ucpi->c_clustersumoff + (forw << 2)), cnt);
+                fs32_sub(sb, (__fs32*)ubh_get_addr(UCPI_UBH(ucpi), ucpi->c_clustersumoff + (forw << 2)), cnt);
 }
 
 
diff --git a/fs/ufs/cylinder.c b/fs/ufs/cylinder.c
index 14abb8b835f7..09c39e5e6386 100644
--- a/fs/ufs/cylinder.c
+++ b/fs/ufs/cylinder.c
@@ -20,15 +20,6 @@
 #include "swab.h"
 #include "util.h"
 
-#undef UFS_CYLINDER_DEBUG
-
-#ifdef UFS_CYLINDER_DEBUG
-#define UFSD(x) printk("(%s, %d), %s:", __FILE__, __LINE__, __FUNCTION__); printk x;
-#else
-#define UFSD(x)
-#endif
-
-
 /*
  * Read cylinder group into cache. The memory space for ufs_cg_private_info
  * structure is already allocated during ufs_read_super.
@@ -42,19 +33,19 @@ static void ufs_read_cylinder (struct super_block * sb,
         struct ufs_cylinder_group * ucg;
         unsigned i, j;
 
-        UFSD(("ENTER, cgno %u, bitmap_nr %u\n", cgno, bitmap_nr))
+        UFSD("ENTER, cgno %u, bitmap_nr %u\n", cgno, bitmap_nr);
         uspi = sbi->s_uspi;
         ucpi = sbi->s_ucpi[bitmap_nr];
         ucg = (struct ufs_cylinder_group *)sbi->s_ucg[cgno]->b_data;
 
-        UCPI_UBH->fragment = ufs_cgcmin(cgno);
-        UCPI_UBH->count = uspi->s_cgsize >> sb->s_blocksize_bits;
+        UCPI_UBH(ucpi)->fragment = ufs_cgcmin(cgno);
+        UCPI_UBH(ucpi)->count = uspi->s_cgsize >> sb->s_blocksize_bits;
         /*
          * We have already the first fragment of cylinder group block in buffer
          */
-        UCPI_UBH->bh[0] = sbi->s_ucg[cgno];
-        for (i = 1; i < UCPI_UBH->count; i++)
-                if (!(UCPI_UBH->bh[i] = sb_bread(sb, UCPI_UBH->fragment + i)))
+        UCPI_UBH(ucpi)->bh[0] = sbi->s_ucg[cgno];
+        for (i = 1; i < UCPI_UBH(ucpi)->count; i++)
+                if (!(UCPI_UBH(ucpi)->bh[i] = sb_bread(sb, UCPI_UBH(ucpi)->fragment + i)))
                         goto failed;
         sbi->s_cgno[bitmap_nr] = cgno;
                         
@@ -73,7 +64,7 @@ static void ufs_read_cylinder (struct super_block * sb,
         ucpi->c_clustersumoff = fs32_to_cpu(sb, ucg->cg_u.cg_44.cg_clustersumoff);
         ucpi->c_clusteroff = fs32_to_cpu(sb, ucg->cg_u.cg_44.cg_clusteroff);
         ucpi->c_nclusterblks = fs32_to_cpu(sb, ucg->cg_u.cg_44.cg_nclusterblks);
-        UFSD(("EXIT\n"))
+        UFSD("EXIT\n");
         return; 
         
 failed:
@@ -95,15 +86,15 @@ void ufs_put_cylinder (struct super_block * sb, unsigned bitmap_nr)
         struct ufs_cylinder_group * ucg;
         unsigned i;
 
-        UFSD(("ENTER, bitmap_nr %u\n", bitmap_nr))
+        UFSD("ENTER, bitmap_nr %u\n", bitmap_nr);
 
         uspi = sbi->s_uspi;
         if (sbi->s_cgno[bitmap_nr] == UFS_CGNO_EMPTY) {
-                UFSD(("EXIT\n"))
+                UFSD("EXIT\n");
                 return;
         }
         ucpi = sbi->s_ucpi[bitmap_nr];
-        ucg = ubh_get_ucg(UCPI_UBH);
+        ucg = ubh_get_ucg(UCPI_UBH(ucpi));
 
         if (uspi->s_ncg > UFS_MAX_GROUP_LOADED && bitmap_nr >= sbi->s_cg_loaded) {
                 ufs_panic (sb, "ufs_put_cylinder", "internal error");
@@ -116,13 +107,13 @@ void ufs_put_cylinder (struct super_block * sb, unsigned bitmap_nr)
         ucg->cg_rotor = cpu_to_fs32(sb, ucpi->c_rotor);
         ucg->cg_frotor = cpu_to_fs32(sb, ucpi->c_frotor);
         ucg->cg_irotor = cpu_to_fs32(sb, ucpi->c_irotor);
-        ubh_mark_buffer_dirty (UCPI_UBH);
-        for (i = 1; i < UCPI_UBH->count; i++) {
-                brelse (UCPI_UBH->bh[i]);
+        ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
+        for (i = 1; i < UCPI_UBH(ucpi)->count; i++) {
+                brelse (UCPI_UBH(ucpi)->bh[i]);
         }
 
         sbi->s_cgno[bitmap_nr] = UFS_CGNO_EMPTY;
-        UFSD(("EXIT\n"))
+        UFSD("EXIT\n");
 }
 
 /*
@@ -139,7 +130,7 @@ struct ufs_cg_private_info * ufs_load_cylinder (
         struct ufs_cg_private_info * ucpi;
         unsigned cg, i, j;
 
-        UFSD(("ENTER, cgno %u\n", cgno))
+        UFSD("ENTER, cgno %u\n", cgno);
 
         uspi = sbi->s_uspi;
         if (cgno >= uspi->s_ncg) {
@@ -150,7 +141,7 @@ struct ufs_cg_private_info * ufs_load_cylinder (
          * Cylinder group number cg it in cache and it was last used
          */
         if (sbi->s_cgno[0] == cgno) {
-                UFSD(("EXIT\n"))
+                UFSD("EXIT\n");
                 return sbi->s_ucpi[0];
         }
         /*
@@ -160,16 +151,16 @@ struct ufs_cg_private_info * ufs_load_cylinder (
                 if (sbi->s_cgno[cgno] != UFS_CGNO_EMPTY) {
                         if (sbi->s_cgno[cgno] != cgno) {
                                 ufs_panic (sb, "ufs_load_cylinder", "internal error, wrong number of cg in cache");
-                                UFSD(("EXIT (FAILED)\n"))
+                                UFSD("EXIT (FAILED)\n");
                                 return NULL;
                         }
                         else {
-                                UFSD(("EXIT\n"))
+                                UFSD("EXIT\n");
                                 return sbi->s_ucpi[cgno];
                         }
                 } else {
                         ufs_read_cylinder (sb, cgno, cgno);
-                        UFSD(("EXIT\n"))
+                        UFSD("EXIT\n");
                         return sbi->s_ucpi[cgno];
                 }
         }
@@ -204,6 +195,6 @@ struct ufs_cg_private_info * ufs_load_cylinder (
                 sbi->s_ucpi[0] = ucpi;
                 ufs_read_cylinder (sb, cgno, 0);
         }
-        UFSD(("EXIT\n"))
+        UFSD("EXIT\n");
         return sbi->s_ucpi[0];
 }
diff --git a/fs/ufs/dir.c b/fs/ufs/dir.c
index 1a561202d3f4..7f0a0aa63584 100644
--- a/fs/ufs/dir.c
+++ b/fs/ufs/dir.c
@@ -11,31 +11,20 @@
  * 4.4BSD (FreeBSD) support added on February 1st 1998 by
  * Niels Kristian Bech Jensen <nkbj@image.dk> partially based
  * on code by Martin von Loewis <martin@mira.isdn.cs.tu-berlin.de>.
+ *
+ * Migration to usage of "page cache" on May 2006 by
+ * Evgeniy Dushistov <dushistov@mail.ru> based on ext2 code base.
  */
 
 #include <linux/time.h>
 #include <linux/fs.h>
 #include <linux/ufs_fs.h>
 #include <linux/smp_lock.h>
-#include <linux/buffer_head.h>
 #include <linux/sched.h>
 
 #include "swab.h"
 #include "util.h"
 
-#undef UFS_DIR_DEBUG
-
-#ifdef UFS_DIR_DEBUG
-#define UFSD(x) printk("(%s, %d), %s: ", __FILE__, __LINE__, __FUNCTION__); printk x;
-#else
-#define UFSD(x)
-#endif
-
-static int
-ufs_check_dir_entry (const char *, struct inode *, struct ufs_dir_entry *,
-                     struct buffer_head *, unsigned long);
-
-
 /*
  * NOTE! unlike strncmp, ufs_match returns 1 for success, 0 for failure.
  *
@@ -51,495 +40,541 @@ static inline int ufs_match(struct super_block *sb, int len,
         return !memcmp(name, de->d_name, len);
 }
 
-/*
- * This is blatantly stolen from ext2fs
- */
-static int
-ufs_readdir (struct file * filp, void * dirent, filldir_t filldir)
+static int ufs_commit_chunk(struct page *page, unsigned from, unsigned to)
 {
-        struct inode *inode = filp->f_dentry->d_inode;
-        int error = 0;
-        unsigned long offset, lblk;
-        int i, stored;
-        struct buffer_head * bh;
-        struct ufs_dir_entry * de;
-        struct super_block * sb;
-        int de_reclen;
-        unsigned flags;
-        u64     blk= 0L;
-
-        lock_kernel();
-
-        sb = inode->i_sb;
-        flags = UFS_SB(sb)->s_flags;
-
-        UFSD(("ENTER, ino %lu  f_pos %lu\n", inode->i_ino, (unsigned long) filp->f_pos))
-
-        stored = 0;
-        bh = NULL;
-        offset = filp->f_pos & (sb->s_blocksize - 1);
-
-        while (!error && !stored && filp->f_pos < inode->i_size) {
-                lblk = (filp->f_pos) >> sb->s_blocksize_bits;
-                blk = ufs_frag_map(inode, lblk);
-                if (!blk || !(bh = sb_bread(sb, blk))) {
-                        /* XXX - error - skip to the next block */
-                        printk("ufs_readdir: "
-                               "dir inode %lu has a hole at offset %lu\n",
-                               inode->i_ino, (unsigned long int)filp->f_pos);
-                        filp->f_pos += sb->s_blocksize - offset;
-                        continue;
-                }
-
-revalidate:
-                /* If the dir block has changed since the last call to
-                 * readdir(2), then we might be pointing to an invalid
-                 * dirent right now.  Scan from the start of the block
-                 * to make sure. */
-                if (filp->f_version != inode->i_version) {
-                        for (i = 0; i < sb->s_blocksize && i < offset; ) {
-                                de = (struct ufs_dir_entry *)(bh->b_data + i);
-                                /* It's too expensive to do a full
-                                 * dirent test each time round this
-                                 * loop, but we do have to test at
-                                 * least that it is non-zero.  A
-                                 * failure will be detected in the
-                                 * dirent test below. */
-                                de_reclen = fs16_to_cpu(sb, de->d_reclen);
-                                if (de_reclen < 1)
-                                        break;
-                                i += de_reclen;
-                        }
-                        offset = i;
-                        filp->f_pos = (filp->f_pos & ~(sb->s_blocksize - 1))
-                                | offset;
-                        filp->f_version = inode->i_version;
-                }
+        struct inode *dir = page->mapping->host;
+        int err = 0;
+        dir->i_version++;
+        page->mapping->a_ops->commit_write(NULL, page, from, to);
+        if (IS_DIRSYNC(dir))
+                err = write_one_page(page, 1);
+        else
+                unlock_page(page);
+        return err;
+}
 
-                while (!error && filp->f_pos < inode->i_size
-                       && offset < sb->s_blocksize) {
-                        de = (struct ufs_dir_entry *) (bh->b_data + offset);
-                        /* XXX - put in a real ufs_check_dir_entry() */
-                        if ((de->d_reclen == 0) || (ufs_get_de_namlen(sb, de) == 0)) {
-                                filp->f_pos = (filp->f_pos &
-                                              (sb->s_blocksize - 1)) +
-                                               sb->s_blocksize;
-                                brelse(bh);
-                                unlock_kernel();
-                                return stored;
-                        }
-                        if (!ufs_check_dir_entry ("ufs_readdir", inode, de,
-                                                   bh, offset)) {
-                                /* On error, skip the f_pos to the
-                                   next block. */
-                                filp->f_pos = (filp->f_pos |
-                                              (sb->s_blocksize - 1)) +
-                                               1;
-                                brelse (bh);
-                                unlock_kernel();
-                                return stored;
-                        }
-                        offset += fs16_to_cpu(sb, de->d_reclen);
-                        if (de->d_ino) {
-                                /* We might block in the next section
-                                 * if the data destination is
-                                 * currently swapped out.  So, use a
-                                 * version stamp to detect whether or
-                                 * not the directory has been modified
-                                 * during the copy operation. */
-                                unsigned long version = filp->f_version;
-                                unsigned char d_type = DT_UNKNOWN;
+static inline void ufs_put_page(struct page *page)
+{
+        kunmap(page);
+        page_cache_release(page);
+}
 
-                                UFSD(("filldir(%s,%u)\n", de->d_name,
-                                                        fs32_to_cpu(sb, de->d_ino)))
-                                UFSD(("namlen %u\n", ufs_get_de_namlen(sb, de)))
+static inline unsigned long ufs_dir_pages(struct inode *inode)
+{
+        return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT;
+}
 
-                                if ((flags & UFS_DE_MASK) == UFS_DE_44BSD)
-                                        d_type = de->d_u.d_44.d_type;
-                                error = filldir(dirent, de->d_name,
-                                                ufs_get_de_namlen(sb, de), filp->f_pos,
-                                                fs32_to_cpu(sb, de->d_ino), d_type);
-                                if (error)
-                                        break;
-                                if (version != filp->f_version)
-                                        goto revalidate;
-                                stored ++;
-                        }
-                        filp->f_pos += fs16_to_cpu(sb, de->d_reclen);
-                }
-                offset = 0;
-                brelse (bh);
+ino_t ufs_inode_by_name(struct inode *dir, struct dentry *dentry)
+{
+        ino_t res = 0;
+        struct ufs_dir_entry *de;
+        struct page *page;
+        
+        de = ufs_find_entry(dir, dentry, &page);
+        if (de) {
+                res = fs32_to_cpu(dir->i_sb, de->d_ino);
+                ufs_put_page(page);
         }
-        unlock_kernel();
-        return 0;
+        return res;
 }
 
-/*
- * define how far ahead to read directories while searching them.
- */
-#define NAMEI_RA_CHUNKS  2
-#define NAMEI_RA_BLOCKS  4
-#define NAMEI_RA_SIZE        (NAMEI_RA_CHUNKS * NAMEI_RA_BLOCKS)
-#define NAMEI_RA_INDEX(c,b)  (((c) * NAMEI_RA_BLOCKS) + (b))
 
-/*
- *      ufs_find_entry()
- *
- * finds an entry in the specified directory with the wanted name. It
- * returns the cache buffer in which the entry was found, and the entry
- * itself (as a parameter - res_bh). It does NOT read the inode of the
- * entry - you'll have to do that yourself if you want to.
- */
-struct ufs_dir_entry * ufs_find_entry (struct dentry *dentry,
-        struct buffer_head ** res_bh)
+/* Releases the page */
+void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de,
+                  struct page *page, struct inode *inode)
 {
-        struct super_block * sb;
-        struct buffer_head * bh_use[NAMEI_RA_SIZE];
-        struct buffer_head * bh_read[NAMEI_RA_SIZE];
-        unsigned long offset;
-        int block, toread, i, err;
-        struct inode *dir = dentry->d_parent->d_inode;
-        const char *name = dentry->d_name.name;
-        int namelen = dentry->d_name.len;
+        unsigned from = (char *) de - (char *) page_address(page);
+        unsigned to = from + fs16_to_cpu(dir->i_sb, de->d_reclen);
+        int err;
 
-        UFSD(("ENTER, dir_ino %lu, name %s, namlen %u\n", dir->i_ino, name, namelen))
-        
-        *res_bh = NULL;
-        
-        sb = dir->i_sb;
-        
-        if (namelen > UFS_MAXNAMLEN)
-                return NULL;
+        lock_page(page);
+        err = page->mapping->a_ops->prepare_write(NULL, page, from, to);
+        BUG_ON(err);
+        de->d_ino = cpu_to_fs32(dir->i_sb, inode->i_ino);
+        ufs_set_de_type(dir->i_sb, de, inode->i_mode);
+        err = ufs_commit_chunk(page, from, to);
+        ufs_put_page(page);
+        dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
+        mark_inode_dirty(dir);
+}
 
-        memset (bh_use, 0, sizeof (bh_use));
-        toread = 0;
-        for (block = 0; block < NAMEI_RA_SIZE; ++block) {
-                struct buffer_head * bh;
 
-                if ((block << sb->s_blocksize_bits) >= dir->i_size)
-                        break;
-                bh = ufs_getfrag (dir, block, 0, &err);
-                bh_use[block] = bh;
-                if (bh && !buffer_uptodate(bh))
-                        bh_read[toread++] = bh;
+static void ufs_check_page(struct page *page)
+{
+        struct inode *dir = page->mapping->host;
+        struct super_block *sb = dir->i_sb;
+        char *kaddr = page_address(page);
+        unsigned offs, rec_len;
+        unsigned limit = PAGE_CACHE_SIZE;
+        struct ufs_dir_entry *p;
+        char *error;
+
+        if ((dir->i_size >> PAGE_CACHE_SHIFT) == page->index) {
+                limit = dir->i_size & ~PAGE_CACHE_MASK;
+                if (limit & (UFS_SECTOR_SIZE - 1))
+                        goto Ebadsize;
+                if (!limit)
+                        goto out;
         }
+        for (offs = 0; offs <= limit - UFS_DIR_REC_LEN(1); offs += rec_len) {
+                p = (struct ufs_dir_entry *)(kaddr + offs);
+                rec_len = fs16_to_cpu(sb, p->d_reclen);
+
+                if (rec_len < UFS_DIR_REC_LEN(1))
+                        goto Eshort;
+                if (rec_len & 3)
+                        goto Ealign;
+                if (rec_len < UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, p)))
+                        goto Enamelen;
+                if (((offs + rec_len - 1) ^ offs) & ~(UFS_SECTOR_SIZE-1))
+                        goto Espan;
+                if (fs32_to_cpu(sb, p->d_ino) > (UFS_SB(sb)->s_uspi->s_ipg *
+                                                  UFS_SB(sb)->s_uspi->s_ncg))
+                        goto Einumber;
+        }
+        if (offs != limit)
+                goto Eend;
+out:
+        SetPageChecked(page);
+        return;
+
+        /* Too bad, we had an error */
+
+Ebadsize:
+        ufs_error(sb, "ufs_check_page",
+                  "size of directory #%lu is not a multiple of chunk size",
+                  dir->i_ino
+        );
+        goto fail;
+Eshort:
+        error = "rec_len is smaller than minimal";
+        goto bad_entry;
+Ealign:
+        error = "unaligned directory entry";
+        goto bad_entry;
+Enamelen:
+        error = "rec_len is too small for name_len";
+        goto bad_entry;
+Espan:
+        error = "directory entry across blocks";
+        goto bad_entry;
+Einumber:
+        error = "inode out of bounds";
+bad_entry:
+        ufs_error (sb, "ufs_check_page", "bad entry in directory #%lu: %s - "
+                   "offset=%lu, rec_len=%d, name_len=%d",
+                   dir->i_ino, error, (page->index<<PAGE_CACHE_SHIFT)+offs,
+                   rec_len, ufs_get_de_namlen(sb, p));
+        goto fail;
+Eend:
+        p = (struct ufs_dir_entry *)(kaddr + offs);
+        ufs_error (sb, "ext2_check_page",
+                   "entry in directory #%lu spans the page boundary"
+                   "offset=%lu",
+                   dir->i_ino, (page->index<<PAGE_CACHE_SHIFT)+offs);
+fail:
+        SetPageChecked(page);
+        SetPageError(page);
+}
 
-        for (block = 0, offset = 0; offset < dir->i_size; block++) {
-                struct buffer_head * bh;
-                struct ufs_dir_entry * de;
-                char * dlimit;
-
-                if ((block % NAMEI_RA_BLOCKS) == 0 && toread) {
-                        ll_rw_block (READ, toread, bh_read);
-                        toread = 0;
-                }
-                bh = bh_use[block % NAMEI_RA_SIZE];
-                if (!bh) {
-                        ufs_error (sb, "ufs_find_entry", 
-                                "directory #%lu contains a hole at offset %lu",
-                                dir->i_ino, offset);
-                        offset += sb->s_blocksize;
-                        continue;
-                }
-                wait_on_buffer (bh);
-                if (!buffer_uptodate(bh)) {
-                        /*
-                         * read error: all bets are off
-                         */
-                        break;
-                }
-
-                de = (struct ufs_dir_entry *) bh->b_data;
-                dlimit = bh->b_data + sb->s_blocksize;
-                while ((char *) de < dlimit && offset < dir->i_size) {
-                        /* this code is executed quadratically often */
-                        /* do minimal checking by hand */
-                        int de_len;
-
-                        if ((char *) de + namelen <= dlimit &&
-                            ufs_match(sb, namelen, name, de)) {
-                                /* found a match -
-                                just to be sure, do a full check */
-                                if (!ufs_check_dir_entry("ufs_find_entry",
-                                    dir, de, bh, offset))
-                                        goto failed;
-                                for (i = 0; i < NAMEI_RA_SIZE; ++i) {
-                                        if (bh_use[i] != bh)
-                                                brelse (bh_use[i]);
-                                }
-                                *res_bh = bh;
-                                return de;
-                        }
-                        /* prevent looping on a bad block */
-                        de_len = fs16_to_cpu(sb, de->d_reclen);
-                        if (de_len <= 0)
-                                goto failed;
-                        offset += de_len;
-                        de = (struct ufs_dir_entry *) ((char *) de + de_len);
-                }
-
-                brelse (bh);
-                if (((block + NAMEI_RA_SIZE) << sb->s_blocksize_bits ) >=
-                    dir->i_size)
-                        bh = NULL;
-                else
-                        bh = ufs_getfrag (dir, block + NAMEI_RA_SIZE, 0, &err);
-                bh_use[block % NAMEI_RA_SIZE] = bh;
-                if (bh && !buffer_uptodate(bh))
-                        bh_read[toread++] = bh;
+static struct page *ufs_get_page(struct inode *dir, unsigned long n)
+{
+        struct address_space *mapping = dir->i_mapping;
+        struct page *page = read_cache_page(mapping, n,
+                                (filler_t*)mapping->a_ops->readpage, NULL);
+        if (!IS_ERR(page)) {
+                wait_on_page_locked(page);
+                kmap(page);
+                if (!PageUptodate(page))
+                        goto fail;
+                if (!PageChecked(page))
+                        ufs_check_page(page);
+                if (PageError(page))
+                        goto fail;
         }
+        return page;
 
-failed:
-        for (i = 0; i < NAMEI_RA_SIZE; ++i) brelse (bh_use[i]);
-        UFSD(("EXIT\n"))
-        return NULL;
+fail:
+        ufs_put_page(page);
+        return ERR_PTR(-EIO);
 }
 
-static int
-ufs_check_dir_entry (const char *function, struct inode *dir,
-                     struct ufs_dir_entry *de, struct buffer_head *bh,
-                     unsigned long offset)
+/*
+ * Return the offset into page `page_nr' of the last valid
+ * byte in that page, plus one.
+ */
+static unsigned
+ufs_last_byte(struct inode *inode, unsigned long page_nr)
 {
-        struct super_block *sb = dir->i_sb;
-        const char *error_msg = NULL;
-        int rlen = fs16_to_cpu(sb, de->d_reclen);
-
-        if (rlen < UFS_DIR_REC_LEN(1))
-                error_msg = "reclen is smaller than minimal";
-        else if (rlen % 4 != 0)
-                error_msg = "reclen % 4 != 0";
-        else if (rlen < UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de)))
-                error_msg = "reclen is too small for namlen";
-        else if (((char *) de - bh->b_data) + rlen > dir->i_sb->s_blocksize)
-                error_msg = "directory entry across blocks";
-        else if (fs32_to_cpu(sb, de->d_ino) > (UFS_SB(sb)->s_uspi->s_ipg *
-                                      UFS_SB(sb)->s_uspi->s_ncg))
-                error_msg = "inode out of bounds";
-
-        if (error_msg != NULL)
-                ufs_error (sb, function, "bad entry in directory #%lu, size %Lu: %s - "
-                            "offset=%lu, inode=%lu, reclen=%d, namlen=%d",
-                            dir->i_ino, dir->i_size, error_msg, offset,
-                            (unsigned long)fs32_to_cpu(sb, de->d_ino),
-                            rlen, ufs_get_de_namlen(sb, de));
-        
-        return (error_msg == NULL ? 1 : 0);
+        unsigned last_byte = inode->i_size;
+
+        last_byte -= page_nr << PAGE_CACHE_SHIFT;
+        if (last_byte > PAGE_CACHE_SIZE)
+                last_byte = PAGE_CACHE_SIZE;
+        return last_byte;
 }
 
-struct ufs_dir_entry *ufs_dotdot(struct inode *dir, struct buffer_head **p)
+static inline struct ufs_dir_entry *
+ufs_next_entry(struct super_block *sb, struct ufs_dir_entry *p)
 {
-        int err;
-        struct buffer_head *bh = ufs_bread (dir, 0, 0, &err);
-        struct ufs_dir_entry *res = NULL;
-
-        if (bh) {
-                res = (struct ufs_dir_entry *) bh->b_data;
-                res = (struct ufs_dir_entry *)((char *)res +
-                        fs16_to_cpu(dir->i_sb, res->d_reclen));
-        }
-        *p = bh;
-        return res;
+        return (struct ufs_dir_entry *)((char *)p +
+                                        fs16_to_cpu(sb, p->d_reclen));
 }
-ino_t ufs_inode_by_name(struct inode * dir, struct dentry *dentry)
+
+struct ufs_dir_entry *ufs_dotdot(struct inode *dir, struct page **p)
 {
-        ino_t res = 0;
-        struct ufs_dir_entry * de;
-        struct buffer_head *bh;
+        struct page *page = ufs_get_page(dir, 0);
+        struct ufs_dir_entry *de = NULL;
 
-        de = ufs_find_entry (dentry, &bh);
-        if (de) {
-                res = fs32_to_cpu(dir->i_sb, de->d_ino);
-                brelse(bh);
+        if (!IS_ERR(page)) {
+                de = ufs_next_entry(dir->i_sb,
+                                    (struct ufs_dir_entry *)page_address(page));
+                *p = page;
         }
-        return res;
+        return de;
 }
 
-void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de,
-                struct buffer_head *bh, struct inode *inode)
+/*
+ *      ufs_find_entry()
+ *
+ * finds an entry in the specified directory with the wanted name. It
+ * returns the page in which the entry was found, and the entry itself
+ * (as a parameter - res_dir). Page is returned mapped and unlocked.
+ * Entry is guaranteed to be valid.
+ */
+struct ufs_dir_entry *ufs_find_entry(struct inode *dir, struct dentry *dentry,
+                                     struct page **res_page)
 {
-        dir->i_version++;
-        de->d_ino = cpu_to_fs32(dir->i_sb, inode->i_ino);
-        mark_buffer_dirty(bh);
-        if (IS_DIRSYNC(dir))
-                sync_dirty_buffer(bh);
-        brelse (bh);
+        struct super_block *sb = dir->i_sb;
+        const char *name = dentry->d_name.name;
+        int namelen = dentry->d_name.len;
+        unsigned reclen = UFS_DIR_REC_LEN(namelen);
+        unsigned long start, n;
+        unsigned long npages = ufs_dir_pages(dir);
+        struct page *page = NULL;
+        struct ufs_inode_info *ui = UFS_I(dir);
+        struct ufs_dir_entry *de;
+
+        UFSD("ENTER, dir_ino %lu, name %s, namlen %u\n", dir->i_ino, name, namelen);
+
+        if (npages == 0 || namelen > UFS_MAXNAMLEN)
+                goto out;
+
+        /* OFFSET_CACHE */
+        *res_page = NULL;
+
+        start = ui->i_dir_start_lookup;
+
+        if (start >= npages)
+                start = 0;
+        n = start;
+        do {
+                char *kaddr;
+                page = ufs_get_page(dir, n);
+                if (!IS_ERR(page)) {
+                        kaddr = page_address(page);
+                        de = (struct ufs_dir_entry *) kaddr;
+                        kaddr += ufs_last_byte(dir, n) - reclen;
+                        while ((char *) de <= kaddr) {
+                                if (de->d_reclen == 0) {
+                                        ufs_error(dir->i_sb, __FUNCTION__,
+                                                  "zero-length directory entry");
+                                        ufs_put_page(page);
+                                        goto out;
+                                }
+                                if (ufs_match(sb, namelen, name, de))
+                                        goto found;
+                                de = ufs_next_entry(sb, de);
+                        }
+                        ufs_put_page(page);
+                }
+                if (++n >= npages)
+                        n = 0;
+        } while (n != start);
+out:
+        return NULL;
+
+found:
+        *res_page = page;
+        ui->i_dir_start_lookup = n;
+        return de;
 }
 
 /*
- *      ufs_add_entry()
- *
- * adds a file entry to the specified directory, using the same
- * semantics as ufs_find_entry(). It returns NULL if it failed.
+ *      Parent is locked.
  */
 int ufs_add_link(struct dentry *dentry, struct inode *inode)
 {
-        struct super_block * sb;
-        struct ufs_sb_private_info * uspi;
-        unsigned long offset;
-        unsigned fragoff;
-        unsigned short rec_len;
-        struct buffer_head * bh;
-        struct ufs_dir_entry * de, * de1;
         struct inode *dir = dentry->d_parent->d_inode;
         const char *name = dentry->d_name.name;
         int namelen = dentry->d_name.len;
+        struct super_block *sb = dir->i_sb;
+        unsigned reclen = UFS_DIR_REC_LEN(namelen);
+        unsigned short rec_len, name_len;
+        struct page *page = NULL;
+        struct ufs_dir_entry *de;
+        unsigned long npages = ufs_dir_pages(dir);
+        unsigned long n;
+        char *kaddr;
+        unsigned from, to;
         int err;
 
-        UFSD(("ENTER, name %s, namelen %u\n", name, namelen))
-        
-        sb = dir->i_sb;
-        uspi = UFS_SB(sb)->s_uspi;
-
-        if (!namelen)
-                return -EINVAL;
-        bh = ufs_bread (dir, 0, 0, &err);
-        if (!bh)
-                return err;
-        rec_len = UFS_DIR_REC_LEN(namelen);
-        offset = 0;
-        de = (struct ufs_dir_entry *) bh->b_data;
-        while (1) {
-                if ((char *)de >= UFS_SECTOR_SIZE + bh->b_data) {
-                        fragoff = offset & ~uspi->s_fmask;
-                        if (fragoff != 0 && fragoff != UFS_SECTOR_SIZE)
-                                ufs_error (sb, "ufs_add_entry", "internal error"
-                                        " fragoff %u", fragoff);
-                        if (!fragoff) {
-                                brelse (bh);
-                                bh = ufs_bread (dir, offset >> sb->s_blocksize_bits, 1, &err);
-                                if (!bh)
-                                        return err;
-                        }
-                        if (dir->i_size <= offset) {
-                                if (dir->i_size == 0) {
-                                        brelse(bh);
-                                        return -ENOENT;
-                                }
-                                de = (struct ufs_dir_entry *) (bh->b_data + fragoff);
-                                de->d_ino = 0;
+        UFSD("ENTER, name %s, namelen %u\n", name, namelen);
+
+        /*
+         * We take care of directory expansion in the same loop.
+         * This code plays outside i_size, so it locks the page
+         * to protect that region.
+         */
+        for (n = 0; n <= npages; n++) {
+                char *dir_end;
+
+                page = ufs_get_page(dir, n);
+                err = PTR_ERR(page);
+                if (IS_ERR(page))
+                        goto out;
+                lock_page(page);
+                kaddr = page_address(page);
+                dir_end = kaddr + ufs_last_byte(dir, n);
+                de = (struct ufs_dir_entry *)kaddr;
+                kaddr += PAGE_CACHE_SIZE - reclen;
+                while ((char *)de <= kaddr) {
+                        if ((char *)de == dir_end) {
+                                /* We hit i_size */
+                                name_len = 0;
+                                rec_len = UFS_SECTOR_SIZE;
                                 de->d_reclen = cpu_to_fs16(sb, UFS_SECTOR_SIZE);
-                                ufs_set_de_namlen(sb, de, 0);
-                                dir->i_size = offset + UFS_SECTOR_SIZE;
-                                mark_inode_dirty(dir);
-                        } else {
-                                de = (struct ufs_dir_entry *) bh->b_data;
+                                de->d_ino = 0;
+                                goto got_it;
                         }
+                        if (de->d_reclen == 0) {
+                                ufs_error(dir->i_sb, __FUNCTION__,
+                                          "zero-length directory entry");
+                                err = -EIO;
+                                goto out_unlock;
+                        }
+                        err = -EEXIST;
+                        if (ufs_match(sb, namelen, name, de))
+                                goto out_unlock;
+                        name_len = UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de));
+                        rec_len = fs16_to_cpu(sb, de->d_reclen);
+                        if (!de->d_ino && rec_len >= reclen)
+                                goto got_it;
+                        if (rec_len >= name_len + reclen)
+                                goto got_it;
+                        de = (struct ufs_dir_entry *) ((char *) de + rec_len);
                 }
-                if (!ufs_check_dir_entry ("ufs_add_entry", dir, de, bh, offset)) {
-                        brelse (bh);
-                        return -ENOENT;
-                }
-                if (ufs_match(sb, namelen, name, de)) {
-                        brelse (bh);
-                        return -EEXIST;
-                }
-                if (de->d_ino == 0 && fs16_to_cpu(sb, de->d_reclen) >= rec_len)
-                        break;
-                        
-                if (fs16_to_cpu(sb, de->d_reclen) >=
-                     UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de)) + rec_len)
-                        break;
-                offset += fs16_to_cpu(sb, de->d_reclen);
-                de = (struct ufs_dir_entry *) ((char *) de + fs16_to_cpu(sb, de->d_reclen));
+                unlock_page(page);
+                ufs_put_page(page);
         }
-
+        BUG();
+        return -EINVAL;
+
+got_it:
+        from = (char*)de - (char*)page_address(page);
+        to = from + rec_len;
+        err = page->mapping->a_ops->prepare_write(NULL, page, from, to);
+        if (err)
+                goto out_unlock;
         if (de->d_ino) {
-                de1 = (struct ufs_dir_entry *) ((char *) de +
-                        UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de)));
-                de1->d_reclen =
-                        cpu_to_fs16(sb, fs16_to_cpu(sb, de->d_reclen) -
-                                UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de)));
-                de->d_reclen =
-                        cpu_to_fs16(sb, UFS_DIR_REC_LEN(ufs_get_de_namlen(sb, de)));
+                struct ufs_dir_entry *de1 =
+                        (struct ufs_dir_entry *) ((char *) de + name_len);
+                de1->d_reclen = cpu_to_fs16(sb, rec_len - name_len);
+                de->d_reclen = cpu_to_fs16(sb, name_len);
+
                 de = de1;
         }
-        de->d_ino = 0;
+
         ufs_set_de_namlen(sb, de, namelen);
-        memcpy (de->d_name, name, namelen + 1);
+        memcpy(de->d_name, name, namelen + 1);
         de->d_ino = cpu_to_fs32(sb, inode->i_ino);
         ufs_set_de_type(sb, de, inode->i_mode);
-        mark_buffer_dirty(bh);
-        if (IS_DIRSYNC(dir))
-                sync_dirty_buffer(bh);
-        brelse (bh);
+
+        err = ufs_commit_chunk(page, from, to);
         dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
-        dir->i_version++;
+
         mark_inode_dirty(dir);
+        /* OFFSET_CACHE */
+out_put:
+        ufs_put_page(page);
+out:
+        return err;
+out_unlock:
+        unlock_page(page);
+        goto out_put;
+}
 
-        UFSD(("EXIT\n"))
+static inline unsigned
+ufs_validate_entry(struct super_block *sb, char *base,
+                   unsigned offset, unsigned mask)
+{
+        struct ufs_dir_entry *de = (struct ufs_dir_entry*)(base + offset);
+        struct ufs_dir_entry *p = (struct ufs_dir_entry*)(base + (offset&mask));
+        while ((char*)p < (char*)de) {
+                if (p->d_reclen == 0)
+                        break;
+                p = ufs_next_entry(sb, p);
+        }
+        return (char *)p - base;
+}
+
+
+/*
+ * This is blatantly stolen from ext2fs
+ */
+static int
+ufs_readdir(struct file *filp, void *dirent, filldir_t filldir)
+{
+        loff_t pos = filp->f_pos;
+        struct inode *inode = filp->f_dentry->d_inode;
+        struct super_block *sb = inode->i_sb;
+        unsigned int offset = pos & ~PAGE_CACHE_MASK;
+        unsigned long n = pos >> PAGE_CACHE_SHIFT;
+        unsigned long npages = ufs_dir_pages(inode);
+        unsigned chunk_mask = ~(UFS_SECTOR_SIZE - 1);
+        int need_revalidate = filp->f_version != inode->i_version;
+        unsigned flags = UFS_SB(sb)->s_flags;
+
+        UFSD("BEGIN\n");
+
+        if (pos > inode->i_size - UFS_DIR_REC_LEN(1))
+                return 0;
+
+        for ( ; n < npages; n++, offset = 0) {
+                char *kaddr, *limit;
+                struct ufs_dir_entry *de;
+
+                struct page *page = ufs_get_page(inode, n);
+
+                if (IS_ERR(page)) {
+                        ufs_error(sb, __FUNCTION__,
+                                  "bad page in #%lu",
+                                  inode->i_ino);
+                        filp->f_pos += PAGE_CACHE_SIZE - offset;
+                        return -EIO;
+                }
+                kaddr = page_address(page);
+                if (unlikely(need_revalidate)) {
+                        if (offset) {
+                                offset = ufs_validate_entry(sb, kaddr, offset, chunk_mask);
+                                filp->f_pos = (n<<PAGE_CACHE_SHIFT) + offset;
+                        }
+                        filp->f_version = inode->i_version;
+                        need_revalidate = 0;
+                }
+                de = (struct ufs_dir_entry *)(kaddr+offset);
+                limit = kaddr + ufs_last_byte(inode, n) - UFS_DIR_REC_LEN(1);
+                for ( ;(char*)de <= limit; de = ufs_next_entry(sb, de)) {
+                        if (de->d_reclen == 0) {
+                                ufs_error(sb, __FUNCTION__,
+                                        "zero-length directory entry");
+                                ufs_put_page(page);
+                                return -EIO;
+                        }
+                        if (de->d_ino) {
+                                int over;
+                                unsigned char d_type = DT_UNKNOWN;
+
+                                offset = (char *)de - kaddr;
+
+                                UFSD("filldir(%s,%u)\n", de->d_name,
+                                      fs32_to_cpu(sb, de->d_ino));
+                                UFSD("namlen %u\n", ufs_get_de_namlen(sb, de));
+
+                                if ((flags & UFS_DE_MASK) == UFS_DE_44BSD)
+                                        d_type = de->d_u.d_44.d_type;
+
+                                over = filldir(dirent, de->d_name,
+                                               ufs_get_de_namlen(sb, de),
+                                                (n<<PAGE_CACHE_SHIFT) | offset,
+                                               fs32_to_cpu(sb, de->d_ino), d_type);
+                                if (over) {
+                                        ufs_put_page(page);
+                                        return 0;
+                                }
+                        }
+                        filp->f_pos += fs16_to_cpu(sb, de->d_reclen);
+                }
+                ufs_put_page(page);
+        }
         return 0;
 }
 
+
 /*
  * ufs_delete_entry deletes a directory entry by merging it with the
  * previous entry.
  */
-int ufs_delete_entry (struct inode * inode, struct ufs_dir_entry * dir,
-        struct buffer_head * bh )
-        
+int ufs_delete_entry(struct inode *inode, struct ufs_dir_entry *dir,
+                     struct page * page)
 {
-        struct super_block * sb;
-        struct ufs_dir_entry * de, * pde;
-        unsigned i;
-        
-        UFSD(("ENTER\n"))
+        struct super_block *sb = inode->i_sb;
+        struct address_space *mapping = page->mapping;
+        char *kaddr = page_address(page);
+        unsigned from = ((char*)dir - kaddr) & ~(UFS_SECTOR_SIZE - 1);
+        unsigned to = ((char*)dir - kaddr) + fs16_to_cpu(sb, dir->d_reclen);
+        struct ufs_dir_entry *pde = NULL;
+        struct ufs_dir_entry *de = (struct ufs_dir_entry *) (kaddr + from);
+        int err;
 
-        sb = inode->i_sb;
-        i = 0;
-        pde = NULL;
-        de = (struct ufs_dir_entry *) bh->b_data;
-        
-        UFSD(("ino %u, reclen %u, namlen %u, name %s\n",
-                fs32_to_cpu(sb, de->d_ino),
-                fs16_to_cpu(sb, de->d_reclen),
-                ufs_get_de_namlen(sb, de), de->d_name))
-
-        while (i < bh->b_size) {
-                if (!ufs_check_dir_entry ("ufs_delete_entry", inode, de, bh, i)) {
-                        brelse(bh);
-                        return -EIO;
-                }
-                if (de == dir)  {
-                        if (pde)
-                                fs16_add(sb, &pde->d_reclen,
-                                        fs16_to_cpu(sb, dir->d_reclen));
-                        dir->d_ino = 0;
-                        inode->i_version++;
-                        inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
-                        mark_inode_dirty(inode);
-                        mark_buffer_dirty(bh);
-                        if (IS_DIRSYNC(inode))
-                                sync_dirty_buffer(bh);
-                        brelse(bh);
-                        UFSD(("EXIT\n"))
-                        return 0;
+        UFSD("ENTER\n");
+
+        UFSD("ino %u, reclen %u, namlen %u, name %s\n",
+              fs32_to_cpu(sb, de->d_ino),
+              fs16_to_cpu(sb, de->d_reclen),
+              ufs_get_de_namlen(sb, de), de->d_name);
+
+        while ((char*)de < (char*)dir) {
+                if (de->d_reclen == 0) {
+                        ufs_error(inode->i_sb, __FUNCTION__,
+                                  "zero-length directory entry");
+                        err = -EIO;
+                        goto out;
                 }
-                i += fs16_to_cpu(sb, de->d_reclen);
-                if (i == UFS_SECTOR_SIZE) pde = NULL;
-                else pde = de;
-                de = (struct ufs_dir_entry *)
-                    ((char *) de + fs16_to_cpu(sb, de->d_reclen));
-                if (i == UFS_SECTOR_SIZE && de->d_reclen == 0)
-                        break;
+                pde = de;
+                de = ufs_next_entry(sb, de);
         }
-        UFSD(("EXIT\n"))
-        brelse(bh);
-        return -ENOENT;
+        if (pde)
+                from = (char*)pde - (char*)page_address(page);
+        lock_page(page);
+        err = mapping->a_ops->prepare_write(NULL, page, from, to);
+        BUG_ON(err);
+        if (pde)
+                pde->d_reclen = cpu_to_fs16(sb, to-from);
+        dir->d_ino = 0;
+        err = ufs_commit_chunk(page, from, to);
+        inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC;
+        mark_inode_dirty(inode);
+out:
+        ufs_put_page(page);
+        UFSD("EXIT\n");
+        return err;
 }
 
 int ufs_make_empty(struct inode * inode, struct inode *dir)
 {
         struct super_block * sb = dir->i_sb;
-        struct buffer_head * dir_block;
+        struct address_space *mapping = inode->i_mapping;
+        struct page *page = grab_cache_page(mapping, 0);
         struct ufs_dir_entry * de;
+        char *base;
         int err;
 
-        dir_block = ufs_bread (inode, 0, 1, &err);
-        if (!dir_block)
-                return err;
+        if (!page)
+                return -ENOMEM;
+        kmap(page);
+        err = mapping->a_ops->prepare_write(NULL, page, 0, UFS_SECTOR_SIZE);
+        if (err) {
+                unlock_page(page);
+                goto fail;
+        }
+
+
+        base = (char*)page_address(page);
+        memset(base, 0, PAGE_CACHE_SIZE);
+
+        de = (struct ufs_dir_entry *) base;
 
-        inode->i_blocks = sb->s_blocksize / UFS_SECTOR_SIZE;
-        de = (struct ufs_dir_entry *) dir_block->b_data;
         de->d_ino = cpu_to_fs32(sb, inode->i_ino);
         ufs_set_de_type(sb, de, inode->i_mode);
         ufs_set_de_namlen(sb, de, 1);
@@ -552,72 +587,65 @@ int ufs_make_empty(struct inode * inode, struct inode *dir)
         de->d_reclen = cpu_to_fs16(sb, UFS_SECTOR_SIZE - UFS_DIR_REC_LEN(1));
         ufs_set_de_namlen(sb, de, 2);
         strcpy (de->d_name, "..");
-        mark_buffer_dirty(dir_block);
-        brelse (dir_block);
-        mark_inode_dirty(inode);
-        return 0;
+
+        err = ufs_commit_chunk(page, 0, UFS_SECTOR_SIZE);
+fail:
+        kunmap(page);
+        page_cache_release(page);
+        return err;
 }
 
 /*
  * routine to check that the specified directory is empty (for rmdir)
  */
-int ufs_empty_dir (struct inode * inode)
+int ufs_empty_dir(struct inode * inode)
 {
-        struct super_block * sb;
-        unsigned long offset;
-        struct buffer_head * bh;
-        struct ufs_dir_entry * de, * de1;
-        int err;
-        
-        sb = inode->i_sb;
-
-        if (inode->i_size < UFS_DIR_REC_LEN(1) + UFS_DIR_REC_LEN(2) ||
-            !(bh = ufs_bread (inode, 0, 0, &err))) {
-                ufs_warning (inode->i_sb, "empty_dir",
-                              "bad directory (dir #%lu) - no data block",
-                              inode->i_ino);
-                return 1;
-        }
-        de = (struct ufs_dir_entry *) bh->b_data;
-        de1 = (struct ufs_dir_entry *)
-                ((char *)de + fs16_to_cpu(sb, de->d_reclen));
-        if (fs32_to_cpu(sb, de->d_ino) != inode->i_ino || de1->d_ino == 0 ||
-             strcmp (".", de->d_name) || strcmp ("..", de1->d_name)) {
-                ufs_warning (inode->i_sb, "empty_dir",
-                              "bad directory (dir #%lu) - no `.' or `..'",
-                              inode->i_ino);
-                return 1;
-        }
-        offset = fs16_to_cpu(sb, de->d_reclen) + fs16_to_cpu(sb, de1->d_reclen);
-        de = (struct ufs_dir_entry *)
-                ((char *)de1 + fs16_to_cpu(sb, de1->d_reclen));
-        while (offset < inode->i_size ) {
-                if (!bh || (void *) de >= (void *) (bh->b_data + sb->s_blocksize)) {
-                        brelse (bh);
-                        bh = ufs_bread (inode, offset >> sb->s_blocksize_bits, 1, &err);
-                        if (!bh) {
-                                ufs_error (sb, "empty_dir",
-                                            "directory #%lu contains a hole at offset %lu",
-                                            inode->i_ino, offset);
-                                offset += sb->s_blocksize;
-                                continue;
+        struct super_block *sb = inode->i_sb;
+        struct page *page = NULL;
+        unsigned long i, npages = ufs_dir_pages(inode);
+
+        for (i = 0; i < npages; i++) {
+                char *kaddr;
+                struct ufs_dir_entry *de;
+                page = ufs_get_page(inode, i);
+
+                if (IS_ERR(page))
+                        continue;
+
+                kaddr = page_address(page);
+                de = (struct ufs_dir_entry *)kaddr;
+                kaddr += ufs_last_byte(inode, i) - UFS_DIR_REC_LEN(1);
+
+                while ((char *)de <= kaddr) {
+                        if (de->d_reclen == 0) {
+                                ufs_error(inode->i_sb, __FUNCTION__,
+                                        "zero-length directory entry: "
+                                        "kaddr=%p, de=%p\n", kaddr, de);
+                                goto not_empty;
                         }
-                        de = (struct ufs_dir_entry *) bh->b_data;
-                }
-                if (!ufs_check_dir_entry ("empty_dir", inode, de, bh, offset)) {
-                        brelse (bh);
-                        return 1;
-                }
-                if (de->d_ino) {
-                        brelse (bh);
-                        return 0;
+                        if (de->d_ino) {
+                                u16 namelen=ufs_get_de_namlen(sb, de);
+                                /* check for . and .. */
+                                if (de->d_name[0] != '.')
+                                        goto not_empty;
+                                if (namelen > 2)
+                                        goto not_empty;
+                                if (namelen < 2) {
+                                        if (inode->i_ino !=
+                                            fs32_to_cpu(sb, de->d_ino))
+                                                goto not_empty;
+                                } else if (de->d_name[1] != '.')
+                                        goto not_empty;
+                        }
+                        de = ufs_next_entry(sb, de);
                 }
-                offset += fs16_to_cpu(sb, de->d_reclen);
-                de = (struct ufs_dir_entry *)
-                        ((char *)de + fs16_to_cpu(sb, de->d_reclen));
+                ufs_put_page(page);
         }
-        brelse (bh);
         return 1;
+
+not_empty:
+        ufs_put_page(page);
+        return 0;
 }
 
 const struct file_operations ufs_dir_operations = {
diff --git a/fs/ufs/file.c b/fs/ufs/file.c
index 312fd3f86313..0e5001512a9d 100644
--- a/fs/ufs/file.c
+++ b/fs/ufs/file.c
@@ -25,6 +25,26 @@
 
 #include <linux/fs.h>
 #include <linux/ufs_fs.h>
+#include <linux/buffer_head.h>  /* for sync_mapping_buffers() */
+
+static int ufs_sync_file(struct file *file, struct dentry *dentry, int datasync)
+{
+        struct inode *inode = dentry->d_inode;
+        int err;
+        int ret;
+
+        ret = sync_mapping_buffers(inode->i_mapping);
+        if (!(inode->i_state & I_DIRTY))
+                return ret;
+        if (datasync && !(inode->i_state & I_DIRTY_DATASYNC))
+                return ret;
+
+        err = ufs_sync_inode(inode);
+        if (ret == 0)
+                ret = err;
+        return ret;
+}
+
 
 /*
  * We have mostly NULL's here: the current defaults are ok for
@@ -37,6 +57,7 @@ const struct file_operations ufs_file_operations = {
         .write          = generic_file_write,
         .mmap           = generic_file_mmap,
         .open           = generic_file_open,
+        .fsync          = ufs_sync_file,
         .sendfile       = generic_file_sendfile,
 };
 
diff --git a/fs/ufs/ialloc.c b/fs/ufs/ialloc.c
index c7a47ed4f430..9501dcd3b213 100644
--- a/fs/ufs/ialloc.c
+++ b/fs/ufs/ialloc.c
@@ -34,14 +34,6 @@
 #include "swab.h"
 #include "util.h"
 
-#undef UFS_IALLOC_DEBUG
-
-#ifdef UFS_IALLOC_DEBUG
-#define UFSD(x) printk("(%s, %d), %s: ", __FILE__, __LINE__, __FUNCTION__); printk x;
-#else
-#define UFSD(x)
-#endif
-
 /*
  * NOTE! When we get the inode, we're the only people
  * that have access to it, and as such there are no
@@ -68,7 +60,7 @@ void ufs_free_inode (struct inode * inode)
         int is_directory;
         unsigned ino, cg, bit;
         
-        UFSD(("ENTER, ino %lu\n", inode->i_ino))
+        UFSD("ENTER, ino %lu\n", inode->i_ino);
 
         sb = inode->i_sb;
         uspi = UFS_SB(sb)->s_uspi;
@@ -91,7 +83,7 @@ void ufs_free_inode (struct inode * inode)
                 unlock_super (sb);
                 return;
         }
-        ucg = ubh_get_ucg(UCPI_UBH);
+        ucg = ubh_get_ucg(UCPI_UBH(ucpi));
         if (!ufs_cg_chkmagic(sb, ucg))
                 ufs_panic (sb, "ufs_free_fragments", "internal error, bad cg magic number");
 
@@ -104,33 +96,33 @@ void ufs_free_inode (struct inode * inode)
 
         clear_inode (inode);
 
-        if (ubh_isclr (UCPI_UBH, ucpi->c_iusedoff, bit))
+        if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_iusedoff, bit))
                 ufs_error(sb, "ufs_free_inode", "bit already cleared for inode %u", ino);
         else {
-                ubh_clrbit (UCPI_UBH, ucpi->c_iusedoff, bit);
+                ubh_clrbit (UCPI_UBH(ucpi), ucpi->c_iusedoff, bit);
                 if (ino < ucpi->c_irotor)
                         ucpi->c_irotor = ino;
                 fs32_add(sb, &ucg->cg_cs.cs_nifree, 1);
-                fs32_add(sb, &usb1->fs_cstotal.cs_nifree, 1);
+                uspi->cs_total.cs_nifree++;
                 fs32_add(sb, &UFS_SB(sb)->fs_cs(cg).cs_nifree, 1);
 
                 if (is_directory) {
                         fs32_sub(sb, &ucg->cg_cs.cs_ndir, 1);
-                        fs32_sub(sb, &usb1->fs_cstotal.cs_ndir, 1);
+                        uspi->cs_total.cs_ndir--;
                         fs32_sub(sb, &UFS_SB(sb)->fs_cs(cg).cs_ndir, 1);
                 }
         }
 
-        ubh_mark_buffer_dirty (USPI_UBH);
-        ubh_mark_buffer_dirty (UCPI_UBH);
+        ubh_mark_buffer_dirty (USPI_UBH(uspi));
+        ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
         if (sb->s_flags & MS_SYNCHRONOUS) {
-                ubh_ll_rw_block (SWRITE, 1, (struct ufs_buffer_head **) &ucpi);
-                ubh_wait_on_buffer (UCPI_UBH);
+                ubh_ll_rw_block(SWRITE, UCPI_UBH(ucpi));
+                ubh_wait_on_buffer (UCPI_UBH(ucpi));
         }
         
         sb->s_dirt = 1;
         unlock_super (sb);
-        UFSD(("EXIT\n"))
+        UFSD("EXIT\n");
 }
 
 /*
@@ -155,7 +147,7 @@ struct inode * ufs_new_inode(struct inode * dir, int mode)
         unsigned cg, bit, i, j, start;
         struct ufs_inode_info *ufsi;
 
-        UFSD(("ENTER\n"))
+        UFSD("ENTER\n");
         
         /* Cannot create files in a deleted directory */
         if (!dir || !dir->i_nlink)
@@ -213,43 +205,43 @@ cg_found:
         ucpi = ufs_load_cylinder (sb, cg);
         if (!ucpi)
                 goto failed;
-        ucg = ubh_get_ucg(UCPI_UBH);
+        ucg = ubh_get_ucg(UCPI_UBH(ucpi));
         if (!ufs_cg_chkmagic(sb, ucg)) 
                 ufs_panic (sb, "ufs_new_inode", "internal error, bad cg magic number");
 
         start = ucpi->c_irotor;
-        bit = ubh_find_next_zero_bit (UCPI_UBH, ucpi->c_iusedoff, uspi->s_ipg, start);
+        bit = ubh_find_next_zero_bit (UCPI_UBH(ucpi), ucpi->c_iusedoff, uspi->s_ipg, start);
         if (!(bit < uspi->s_ipg)) {
-                bit = ubh_find_first_zero_bit (UCPI_UBH, ucpi->c_iusedoff, start);
+                bit = ubh_find_first_zero_bit (UCPI_UBH(ucpi), ucpi->c_iusedoff, start);
                 if (!(bit < start)) {
                         ufs_error (sb, "ufs_new_inode",
                             "cylinder group %u corrupted - error in inode bitmap\n", cg);
                         goto failed;
                 }
         }
-        UFSD(("start = %u, bit = %u, ipg = %u\n", start, bit, uspi->s_ipg))
-        if (ubh_isclr (UCPI_UBH, ucpi->c_iusedoff, bit))
-                ubh_setbit (UCPI_UBH, ucpi->c_iusedoff, bit);
+        UFSD("start = %u, bit = %u, ipg = %u\n", start, bit, uspi->s_ipg);
+        if (ubh_isclr (UCPI_UBH(ucpi), ucpi->c_iusedoff, bit))
+                ubh_setbit (UCPI_UBH(ucpi), ucpi->c_iusedoff, bit);
         else {
                 ufs_panic (sb, "ufs_new_inode", "internal error");
                 goto failed;
         }
         
         fs32_sub(sb, &ucg->cg_cs.cs_nifree, 1);
-        fs32_sub(sb, &usb1->fs_cstotal.cs_nifree, 1);
+        uspi->cs_total.cs_nifree--;
         fs32_sub(sb, &sbi->fs_cs(cg).cs_nifree, 1);
         
         if (S_ISDIR(mode)) {
                 fs32_add(sb, &ucg->cg_cs.cs_ndir, 1);
-                fs32_add(sb, &usb1->fs_cstotal.cs_ndir, 1);
+                uspi->cs_total.cs_ndir++;
                 fs32_add(sb, &sbi->fs_cs(cg).cs_ndir, 1);
         }
 
-        ubh_mark_buffer_dirty (USPI_UBH);
-        ubh_mark_buffer_dirty (UCPI_UBH);
+        ubh_mark_buffer_dirty (USPI_UBH(uspi));
+        ubh_mark_buffer_dirty (UCPI_UBH(ucpi));
         if (sb->s_flags & MS_SYNCHRONOUS) {
-                ubh_ll_rw_block (SWRITE, 1, (struct ufs_buffer_head **) &ucpi);
-                ubh_wait_on_buffer (UCPI_UBH);
+                ubh_ll_rw_block(SWRITE, UCPI_UBH(ucpi));
+                ubh_wait_on_buffer (UCPI_UBH(ucpi));
         }
         sb->s_dirt = 1;
 
@@ -272,6 +264,7 @@ cg_found:
         ufsi->i_shadow = 0;
         ufsi->i_osync = 0;
         ufsi->i_oeftflag = 0;
+        ufsi->i_dir_start_lookup = 0;
         memset(&ufsi->i_u1, 0, sizeof(ufsi->i_u1));
 
         insert_inode_hash(inode);
@@ -287,14 +280,14 @@ cg_found:
                 return ERR_PTR(-EDQUOT);
         }
 
-        UFSD(("allocating inode %lu\n", inode->i_ino))
-        UFSD(("EXIT\n"))
+        UFSD("allocating inode %lu\n", inode->i_ino);
+        UFSD("EXIT\n");
         return inode;
 
 failed:
         unlock_super (sb);
         make_bad_inode(inode);
         iput (inode);
-        UFSD(("EXIT (FAILED)\n"))
+        UFSD("EXIT (FAILED)\n");
         return ERR_PTR(-ENOSPC);
 }
diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
index 3c3f62ce2ad9..f2dbdf5a8769 100644
--- a/fs/ufs/inode.c
+++ b/fs/ufs/inode.c
@@ -41,14 +41,7 @@
 #include "swab.h"
 #include "util.h"
 
-#undef UFS_INODE_DEBUG
-#undef UFS_INODE_DEBUG_MORE
-
-#ifdef UFS_INODE_DEBUG
-#define UFSD(x) printk("(%s, %d), %s: ", __FILE__, __LINE__, __FUNCTION__); printk x;
-#else
-#define UFSD(x)
-#endif
+static u64 ufs_frag_map(struct inode *inode, sector_t frag);
 
 static int ufs_block_to_path(struct inode *inode, sector_t i_block, sector_t offsets[4])
 {
@@ -61,7 +54,7 @@ static int ufs_block_to_path(struct inode *inode, sector_t i_block, sector_t off
         int n = 0;
 
 
-        UFSD(("ptrs=uspi->s_apb = %d,double_blocks=%ld \n",ptrs,double_blocks));
+        UFSD("ptrs=uspi->s_apb = %d,double_blocks=%ld \n",ptrs,double_blocks);
         if (i_block < 0) {
                 ufs_warning(inode->i_sb, "ufs_block_to_path", "block < 0");
         } else if (i_block < direct_blocks) {
@@ -89,7 +82,7 @@ static int ufs_block_to_path(struct inode *inode, sector_t i_block, sector_t off
  * the begining of the filesystem.
  */
 
-u64  ufs_frag_map(struct inode *inode, sector_t frag)
+static u64 ufs_frag_map(struct inode *inode, sector_t frag)
 {
         struct ufs_inode_info *ufsi = UFS_I(inode);
         struct super_block *sb = inode->i_sb;
@@ -104,8 +97,8 @@ u64  ufs_frag_map(struct inode *inode, sector_t frag)
         unsigned flags = UFS_SB(sb)->s_flags;
         u64 temp = 0L;
 
-        UFSD((": frag = %llu  depth = %d\n", (unsigned long long)frag, depth));
-        UFSD((": uspi->s_fpbshift = %d ,uspi->s_apbmask = %x, mask=%llx\n",uspi->s_fpbshift,uspi->s_apbmask,mask));
+        UFSD(": frag = %llu  depth = %d\n", (unsigned long long)frag, depth);
+        UFSD(": uspi->s_fpbshift = %d ,uspi->s_apbmask = %x, mask=%llx\n",uspi->s_fpbshift,uspi->s_apbmask,mask);
 
         if (depth == 0)
                 return 0;
@@ -161,26 +154,64 @@ out:
         return ret;
 }
 
-static struct buffer_head * ufs_inode_getfrag (struct inode *inode,
-        unsigned int fragment, unsigned int new_fragment,
-        unsigned int required, int *err, int metadata, long *phys, int *new)
+static void ufs_clear_frag(struct inode *inode, struct buffer_head *bh)
+{
+        lock_buffer(bh);
+        memset(bh->b_data, 0, inode->i_sb->s_blocksize);
+        set_buffer_uptodate(bh);
+        mark_buffer_dirty(bh);
+        unlock_buffer(bh);
+        if (IS_SYNC(inode))
+                sync_dirty_buffer(bh);
+}
+
+static struct buffer_head *
+ufs_clear_frags(struct inode *inode, sector_t beg,
+                unsigned int n)
+{
+        struct buffer_head *res, *bh;
+        sector_t end = beg + n;
+
+        res = sb_getblk(inode->i_sb, beg);
+        ufs_clear_frag(inode, res);
+        for (++beg; beg < end; ++beg) {
+                bh = sb_getblk(inode->i_sb, beg);
+                ufs_clear_frag(inode, bh);
+                brelse(bh);
+        }
+        return res;
+}
+
+/**
+ * ufs_inode_getfrag() - allocate new fragment(s)
+ * @inode - pointer to inode
+ * @fragment - number of `fragment' which hold pointer
+ *   to new allocated fragment(s)
+ * @new_fragment - number of new allocated fragment(s)
+ * @required - how many fragment(s) we require
+ * @err - we set it if something wrong
+ * @phys - pointer to where we save physical number of new allocated fragments,
+ *   NULL if we allocate not data(indirect blocks for example).
+ * @new - we set it if we allocate new block
+ * @locked_page - for ufs_new_fragments()
+ */
+static struct buffer_head *
+ufs_inode_getfrag(struct inode *inode, unsigned int fragment,
+                  sector_t new_fragment, unsigned int required, int *err,
+                  long *phys, int *new, struct page *locked_page)
 {
         struct ufs_inode_info *ufsi = UFS_I(inode);
-        struct super_block * sb;
-        struct ufs_sb_private_info * uspi;
+        struct super_block *sb = inode->i_sb;
+        struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
         struct buffer_head * result;
         unsigned block, blockoff, lastfrag, lastblock, lastblockoff;
         unsigned tmp, goal;
         __fs32 * p, * p2;
-        unsigned flags = 0;
 
-        UFSD(("ENTER, ino %lu, fragment %u, new_fragment %u, required %u\n",
-                inode->i_ino, fragment, new_fragment, required))         
+        UFSD("ENTER, ino %lu, fragment %u, new_fragment %llu, required %u, "
+             "metadata %d\n", inode->i_ino, fragment,
+             (unsigned long long)new_fragment, required, !phys);
 
-        sb = inode->i_sb;
-        uspi = UFS_SB(sb)->s_uspi;
-
-        flags = UFS_SB(sb)->s_flags;
         /* TODO : to be done for write support
         if ( (flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
              goto ufs2;
@@ -195,16 +226,16 @@ repeat:
         tmp = fs32_to_cpu(sb, *p);
         lastfrag = ufsi->i_lastfrag;
         if (tmp && fragment < lastfrag) {
-                if (metadata) {
+                if (!phys) {
                         result = sb_getblk(sb, uspi->s_sbbase + tmp + blockoff);
                         if (tmp == fs32_to_cpu(sb, *p)) {
-                                UFSD(("EXIT, result %u\n", tmp + blockoff))
+                                UFSD("EXIT, result %u\n", tmp + blockoff);
                                 return result;
                         }
                         brelse (result);
                         goto repeat;
                 } else {
-                        *phys = tmp;
+                        *phys = tmp + blockoff;
                         return NULL;
                 }
         }
@@ -221,7 +252,8 @@ repeat:
                 if (lastblockoff) {
                         p2 = ufsi->i_u1.i_data + lastblock;
                         tmp = ufs_new_fragments (inode, p2, lastfrag, 
-                                fs32_to_cpu(sb, *p2), uspi->s_fpb - lastblockoff, err);
+                                                 fs32_to_cpu(sb, *p2), uspi->s_fpb - lastblockoff,
+                                                 err, locked_page);
                         if (!tmp) {
                                 if (lastfrag != ufsi->i_lastfrag)
                                         goto repeat;
@@ -233,14 +265,16 @@ repeat:
                 }
                 goal = fs32_to_cpu(sb, ufsi->i_u1.i_data[lastblock]) + uspi->s_fpb;
                 tmp = ufs_new_fragments (inode, p, fragment - blockoff, 
-                        goal, required + blockoff, err);
+                                         goal, required + blockoff,
+                                         err, locked_page);
         }
         /*
          * We will extend last allocated block
          */
         else if (lastblock == block) {
-                tmp = ufs_new_fragments (inode, p, fragment - (blockoff - lastblockoff),
-                        fs32_to_cpu(sb, *p), required +  (blockoff - lastblockoff), err);
+                tmp = ufs_new_fragments(inode, p, fragment - (blockoff - lastblockoff),
+                                        fs32_to_cpu(sb, *p), required +  (blockoff - lastblockoff),
+                                        err, locked_page);
         }
         /*
          * We will allocate new block before last allocated block
@@ -248,8 +282,8 @@ repeat:
         else /* (lastblock > block) */ {
                 if (lastblock && (tmp = fs32_to_cpu(sb, ufsi->i_u1.i_data[lastblock-1])))
                         goal = tmp + uspi->s_fpb;
-                tmp = ufs_new_fragments (inode, p, fragment - blockoff, 
-                        goal, uspi->s_fpb, err);
+                tmp = ufs_new_fragments(inode, p, fragment - blockoff,
+                                        goal, uspi->s_fpb, err, locked_page);
         }
         if (!tmp) {
                 if ((!blockoff && *p) || 
@@ -259,14 +293,10 @@ repeat:
                 return NULL;
         }
 
-        /* The nullification of framgents done in ufs/balloc.c is
-         * something I don't have the stomache to move into here right
-         * now. -DaveM
-         */
-        if (metadata) {
-                result = sb_getblk(inode->i_sb, tmp + blockoff);
+        if (!phys) {
+                result = ufs_clear_frags(inode, tmp + blockoff, required);
         } else {
-                *phys = tmp;
+                *phys = tmp + blockoff;
                 result = NULL;
                 *err = 0;
                 *new = 1;
@@ -276,7 +306,7 @@ repeat:
         if (IS_SYNC(inode))
                 ufs_sync_inode (inode);
         mark_inode_dirty(inode);
-        UFSD(("EXIT, result %u\n", tmp + blockoff))
+        UFSD("EXIT, result %u\n", tmp + blockoff);
         return result;
 
      /* This part : To be implemented ....
@@ -295,22 +325,35 @@ repeat2:
      */
 }
 
-static struct buffer_head * ufs_block_getfrag (struct inode *inode,
-        struct buffer_head *bh, unsigned int fragment, unsigned int new_fragment, 
-        unsigned int blocksize, int * err, int metadata, long *phys, int *new)
+/**
+ * ufs_inode_getblock() - allocate new block
+ * @inode - pointer to inode
+ * @bh - pointer to block which hold "pointer" to new allocated block
+ * @fragment - number of `fragment' which hold pointer
+ *   to new allocated block
+ * @new_fragment - number of new allocated fragment
+ *  (block will hold this fragment and also uspi->s_fpb-1)
+ * @err - see ufs_inode_getfrag()
+ * @phys - see ufs_inode_getfrag()
+ * @new - see ufs_inode_getfrag()
+ * @locked_page - see ufs_inode_getfrag()
+ */
+static struct buffer_head *
+ufs_inode_getblock(struct inode *inode, struct buffer_head *bh,
+                  unsigned int fragment, sector_t new_fragment, int *err,
+                  long *phys, int *new, struct page *locked_page)
 {
-        struct super_block * sb;
-        struct ufs_sb_private_info * uspi;
+        struct super_block *sb = inode->i_sb;
+        struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
         struct buffer_head * result;
         unsigned tmp, goal, block, blockoff;
         __fs32 * p;
 
-        sb = inode->i_sb;
-        uspi = UFS_SB(sb)->s_uspi;
         block = ufs_fragstoblks (fragment);
         blockoff = ufs_fragnum (fragment);
 
-        UFSD(("ENTER, ino %lu, fragment %u, new_fragment %u\n", inode->i_ino, fragment, new_fragment))  
+        UFSD("ENTER, ino %lu, fragment %u, new_fragment %llu, metadata %d\n",
+             inode->i_ino, fragment, (unsigned long long)new_fragment, !phys);
 
         result = NULL;
         if (!bh)
@@ -326,14 +369,14 @@ static struct buffer_head * ufs_block_getfrag (struct inode *inode,
 repeat:
         tmp = fs32_to_cpu(sb, *p);
         if (tmp) {
-                if (metadata) {
+                if (!phys) {
                         result = sb_getblk(sb, uspi->s_sbbase + tmp + blockoff);
                         if (tmp == fs32_to_cpu(sb, *p))
                                 goto out;
                         brelse (result);
                         goto repeat;
                 } else {
-                        *phys = tmp;
+                        *phys = tmp + blockoff;
                         goto out;
                 }
         }
@@ -342,21 +385,19 @@ repeat:
                 goal = tmp + uspi->s_fpb;
         else
                 goal = bh->b_blocknr + uspi->s_fpb;
-        tmp = ufs_new_fragments (inode, p, ufs_blknum(new_fragment), goal, uspi->s_fpb, err);
+        tmp = ufs_new_fragments(inode, p, ufs_blknum(new_fragment), goal,
+                                uspi->s_fpb, err, locked_page);
         if (!tmp) {
                 if (fs32_to_cpu(sb, *p))
                         goto repeat;
                 goto out;
         }               
 
-        /* The nullification of framgents done in ufs/balloc.c is
-         * something I don't have the stomache to move into here right
-         * now. -DaveM
-         */
-        if (metadata) {
-                result = sb_getblk(sb, tmp + blockoff);
+
+        if (!phys) {
+                result = ufs_clear_frags(inode, tmp + blockoff, uspi->s_fpb);
         } else {
-                *phys = tmp;
+                *phys = tmp + blockoff;
                 *new = 1;
         }
 
@@ -365,18 +406,19 @@ repeat:
                 sync_dirty_buffer(bh);
         inode->i_ctime = CURRENT_TIME_SEC;
         mark_inode_dirty(inode);
-        UFSD(("result %u\n", tmp + blockoff));
+        UFSD("result %u\n", tmp + blockoff);
 out:
         brelse (bh);
-        UFSD(("EXIT\n"));
+        UFSD("EXIT\n");
         return result;
 }
 
-/*
- * This function gets the block which contains the fragment.
+/**
+ * ufs_getfrag_bloc() - `get_block_t' function, interface between UFS and
+ * readpage, writepage and so on
  */
 
-int ufs_getfrag_block (struct inode *inode, sector_t fragment, struct buffer_head *bh_result, int create)
+int ufs_getfrag_block(struct inode *inode, sector_t fragment, struct buffer_head *bh_result, int create)
 {
         struct super_block * sb = inode->i_sb;
         struct ufs_sb_private_info * uspi = UFS_SB(sb)->s_uspi;
@@ -387,7 +429,7 @@ int ufs_getfrag_block (struct inode *inode, sector_t fragment, struct buffer_hea
         
         if (!create) {
                 phys64 = ufs_frag_map(inode, fragment);
-                UFSD(("phys64 = %llu \n",phys64));
+                UFSD("phys64 = %llu \n",phys64);
                 if (phys64)
                         map_bh(bh_result, sb, phys64);
                 return 0;
@@ -402,7 +444,7 @@ int ufs_getfrag_block (struct inode *inode, sector_t fragment, struct buffer_hea
 
         lock_kernel();
 
-        UFSD(("ENTER, ino %lu, fragment %llu\n", inode->i_ino, (unsigned long long)fragment))
+        UFSD("ENTER, ino %lu, fragment %llu\n", inode->i_ino, (unsigned long long)fragment);
         if (fragment < 0)
                 goto abort_negative;
         if (fragment >
@@ -418,15 +460,15 @@ int ufs_getfrag_block (struct inode *inode, sector_t fragment, struct buffer_hea
          * it much more readable:
          */
 #define GET_INODE_DATABLOCK(x) \
-                ufs_inode_getfrag(inode, x, fragment, 1, &err, 0, &phys, &new)
+        ufs_inode_getfrag(inode, x, fragment, 1, &err, &phys, &new, bh_result->b_page)
 #define GET_INODE_PTR(x) \
-                ufs_inode_getfrag(inode, x, fragment, uspi->s_fpb, &err, 1, NULL, NULL)
+        ufs_inode_getfrag(inode, x, fragment, uspi->s_fpb, &err, NULL, NULL, bh_result->b_page)
 #define GET_INDIRECT_DATABLOCK(x) \
-                ufs_block_getfrag(inode, bh, x, fragment, sb->s_blocksize, \
-                                  &err, 0, &phys, &new);
+        ufs_inode_getblock(inode, bh, x, fragment,      \
+                          &err, &phys, &new, bh_result->b_page);
 #define GET_INDIRECT_PTR(x) \
-                ufs_block_getfrag(inode, bh, x, fragment, sb->s_blocksize, \
-                                  &err, 1, NULL, NULL);
+        ufs_inode_getblock(inode, bh, x, fragment,      \
+                          &err, NULL, NULL, bh_result->b_page);
 
         if (ptr < UFS_NDIR_FRAGMENT) {
                 bh = GET_INODE_DATABLOCK(ptr);
@@ -474,8 +516,9 @@ abort_too_big:
         goto abort;
 }
 
-struct buffer_head *ufs_getfrag(struct inode *inode, unsigned int fragment,
-                                int create, int *err)
+static struct buffer_head *ufs_getfrag(struct inode *inode,
+                                       unsigned int fragment,
+                                       int create, int *err)
 {
         struct buffer_head dummy;
         int error;
@@ -502,7 +545,7 @@ struct buffer_head * ufs_bread (struct inode * inode, unsigned fragment,
 {
         struct buffer_head * bh;
 
-        UFSD(("ENTER, ino %lu, fragment %u\n", inode->i_ino, fragment))
+        UFSD("ENTER, ino %lu, fragment %u\n", inode->i_ino, fragment);
         bh = ufs_getfrag (inode, fragment, create, err);
         if (!bh || buffer_uptodate(bh))                 
                 return bh;
@@ -540,6 +583,28 @@ struct address_space_operations ufs_aops = {
         .bmap = ufs_bmap
 };
 
+static void ufs_set_inode_ops(struct inode *inode)
+{
+        if (S_ISREG(inode->i_mode)) {
+                inode->i_op = &ufs_file_inode_operations;
+                inode->i_fop = &ufs_file_operations;
+                inode->i_mapping->a_ops = &ufs_aops;
+        } else if (S_ISDIR(inode->i_mode)) {
+                inode->i_op = &ufs_dir_inode_operations;
+                inode->i_fop = &ufs_dir_operations;
+                inode->i_mapping->a_ops = &ufs_aops;
+        } else if (S_ISLNK(inode->i_mode)) {
+                if (!inode->i_blocks)
+                        inode->i_op = &ufs_fast_symlink_inode_operations;
+                else {
+                        inode->i_op = &page_symlink_inode_operations;
+                        inode->i_mapping->a_ops = &ufs_aops;
+                }
+        } else
+                init_special_inode(inode, inode->i_mode,
+                                   ufs_get_inode_dev(inode->i_sb, UFS_I(inode)));
+}
+
 void ufs_read_inode (struct inode * inode)
 {
         struct ufs_inode_info *ufsi = UFS_I(inode);
@@ -552,7 +617,7 @@ void ufs_read_inode (struct inode * inode)
         unsigned i;
         unsigned flags;
         
-        UFSD(("ENTER, ino %lu\n", inode->i_ino))
+        UFSD("ENTER, ino %lu\n", inode->i_ino);
         
         sb = inode->i_sb;
         uspi = UFS_SB(sb)->s_uspi;
@@ -603,38 +668,22 @@ void ufs_read_inode (struct inode * inode)
         ufsi->i_shadow = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_shadow);
         ufsi->i_oeftflag = fs32_to_cpu(sb, ufs_inode->ui_u3.ui_sun.ui_oeftflag);
         ufsi->i_lastfrag = (inode->i_size + uspi->s_fsize - 1) >> uspi->s_fshift;
+        ufsi->i_dir_start_lookup = 0;
         
         if (S_ISCHR(mode) || S_ISBLK(mode) || inode->i_blocks) {
                 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR); i++)
                         ufsi->i_u1.i_data[i] = ufs_inode->ui_u2.ui_addr.ui_db[i];
-        }
-        else {
+        } else {
                 for (i = 0; i < (UFS_NDADDR + UFS_NINDIR) * 4; i++)
                         ufsi->i_u1.i_symlink[i] = ufs_inode->ui_u2.ui_symlink[i];
         }
         ufsi->i_osync = 0;
 
-        if (S_ISREG(inode->i_mode)) {
-                inode->i_op = &ufs_file_inode_operations;
-                inode->i_fop = &ufs_file_operations;
-                inode->i_mapping->a_ops = &ufs_aops;
-        } else if (S_ISDIR(inode->i_mode)) {
-                inode->i_op = &ufs_dir_inode_operations;
-                inode->i_fop = &ufs_dir_operations;
-        } else if (S_ISLNK(inode->i_mode)) {
-                if (!inode->i_blocks)
-                        inode->i_op = &ufs_fast_symlink_inode_operations;
-                else {
-                        inode->i_op = &page_symlink_inode_operations;
-                        inode->i_mapping->a_ops = &ufs_aops;
-                }
-        } else
-                init_special_inode(inode, inode->i_mode,
-                        ufs_get_inode_dev(sb, ufsi));
+        ufs_set_inode_ops(inode);
 
         brelse (bh);
 
-        UFSD(("EXIT\n"))
+        UFSD("EXIT\n");
         return;
 
 bad_inode:
@@ -642,7 +691,7 @@ bad_inode:
         return;
 
 ufs2_inode :
-        UFSD(("Reading ufs2 inode, ino %lu\n", inode->i_ino))
+        UFSD("Reading ufs2 inode, ino %lu\n", inode->i_ino);
 
         ufs2_inode = (struct ufs2_inode *)(bh->b_data + sizeof(struct ufs2_inode) * ufs_inotofsbo(inode->i_ino));
 
@@ -690,27 +739,11 @@ ufs2_inode :
         }
         ufsi->i_osync = 0;
 
-        if (S_ISREG(inode->i_mode)) {
-                inode->i_op = &ufs_file_inode_operations;
-                inode->i_fop = &ufs_file_operations;
-                inode->i_mapping->a_ops = &ufs_aops;
-        } else if (S_ISDIR(inode->i_mode)) {
-                inode->i_op = &ufs_dir_inode_operations;
-                inode->i_fop = &ufs_dir_operations;
-        } else if (S_ISLNK(inode->i_mode)) {
-                if (!inode->i_blocks)
-                        inode->i_op = &ufs_fast_symlink_inode_operations;
-                else {
-                        inode->i_op = &page_symlink_inode_operations;
-                        inode->i_mapping->a_ops = &ufs_aops;
-                }
-        } else   /* TODO  : here ...*/
-                init_special_inode(inode, inode->i_mode,
-                        ufs_get_inode_dev(sb, ufsi));
+        ufs_set_inode_ops(inode);
 
         brelse(bh);
 
-        UFSD(("EXIT\n"))
+        UFSD("EXIT\n");
         return;
 }
 
@@ -724,7 +757,7 @@ static int ufs_update_inode(struct inode * inode, int do_sync)
         unsigned i;
         unsigned flags;
 
-        UFSD(("ENTER, ino %lu\n", inode->i_ino))
+        UFSD("ENTER, ino %lu\n", inode->i_ino);
 
         sb = inode->i_sb;
         uspi = UFS_SB(sb)->s_uspi;
@@ -785,7 +818,7 @@ static int ufs_update_inode(struct inode * inode, int do_sync)
                 sync_dirty_buffer(bh);
         brelse (bh);
         
-        UFSD(("EXIT\n"))
+        UFSD("EXIT\n");
         return 0;
 }
 
diff --git a/fs/ufs/namei.c b/fs/ufs/namei.c
index 8d5f98a01c74..abd5f23a426d 100644
--- a/fs/ufs/namei.c
+++ b/fs/ufs/namei.c
@@ -1,6 +1,9 @@
 /*
  * linux/fs/ufs/namei.c
  *
+ * Migration to usage of "page cache" on May 2006 by
+ * Evgeniy Dushistov <dushistov@mail.ru> based on ext2 code base.
+ *
  * Copyright (C) 1998
  * Daniel Pirkl <daniel.pirkl@email.cz>
  * Charles University, Faculty of Mathematics and Physics
@@ -28,21 +31,9 @@
 #include <linux/fs.h>
 #include <linux/ufs_fs.h>
 #include <linux/smp_lock.h>
-#include <linux/buffer_head.h>
 #include "swab.h"       /* will go away - see comment in mknod() */
 #include "util.h"
 
-/*
-#undef UFS_NAMEI_DEBUG
-*/
-#define UFS_NAMEI_DEBUG
-
-#ifdef UFS_NAMEI_DEBUG
-#define UFSD(x) printk("(%s, %d), %s: ", __FILE__, __LINE__, __FUNCTION__); printk x;
-#else
-#define UFSD(x)
-#endif
-
 static inline int ufs_add_nondir(struct dentry *dentry, struct inode *inode)
 {
         int err = ufs_add_link(dentry, inode);
@@ -88,8 +79,13 @@ static struct dentry *ufs_lookup(struct inode * dir, struct dentry *dentry, stru
 static int ufs_create (struct inode * dir, struct dentry * dentry, int mode,
                 struct nameidata *nd)
 {
-        struct inode * inode = ufs_new_inode(dir, mode);
-        int err = PTR_ERR(inode);
+        struct inode *inode;
+        int err;
+
+        UFSD("BEGIN\n");
+        inode = ufs_new_inode(dir, mode);
+        err = PTR_ERR(inode);
+
         if (!IS_ERR(inode)) {
                 inode->i_op = &ufs_file_inode_operations;
                 inode->i_fop = &ufs_file_operations;
@@ -99,6 +95,7 @@ static int ufs_create (struct inode * dir, struct dentry * dentry, int mode,
                 err = ufs_add_nondir(dentry, inode);
                 unlock_kernel();
         }
+        UFSD("END: err=%d\n", err);
         return err;
 }
 
@@ -205,6 +202,7 @@ static int ufs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
 
         inode->i_op = &ufs_dir_inode_operations;
         inode->i_fop = &ufs_dir_operations;
+        inode->i_mapping->a_ops = &ufs_aops;
 
         inode_inc_link_count(inode);
 
@@ -231,19 +229,18 @@ out_dir:
         goto out;
 }
 
-static int ufs_unlink(struct inode * dir, struct dentry *dentry)
+static int ufs_unlink(struct inode *dir, struct dentry *dentry)
 {
         struct inode * inode = dentry->d_inode;
-        struct buffer_head * bh;
-        struct ufs_dir_entry * de;
+        struct ufs_dir_entry *de;
+        struct page *page;
         int err = -ENOENT;
 
-        lock_kernel();
-        de = ufs_find_entry (dentry, &bh);
+        de = ufs_find_entry(dir, dentry, &page);
         if (!de)
                 goto out;
 
-        err = ufs_delete_entry (dir, de, bh);
+        err = ufs_delete_entry(dir, de, page);
         if (err)
                 goto out;
 
@@ -251,7 +248,6 @@ static int ufs_unlink(struct inode * dir, struct dentry *dentry)
         inode_dec_link_count(inode);
         err = 0;
 out:
-        unlock_kernel();
         return err;
 }
 
@@ -273,42 +269,42 @@ static int ufs_rmdir (struct inode * dir, struct dentry *dentry)
         return err;
 }
 
-static int ufs_rename (struct inode * old_dir, struct dentry * old_dentry,
-        struct inode * new_dir, struct dentry * new_dentry )
+static int ufs_rename(struct inode *old_dir, struct dentry *old_dentry,
+                      struct inode *new_dir, struct dentry *new_dentry)
 {
         struct inode *old_inode = old_dentry->d_inode;
         struct inode *new_inode = new_dentry->d_inode;
-        struct buffer_head *dir_bh = NULL;
-        struct ufs_dir_entry *dir_de = NULL;
-        struct buffer_head *old_bh;
+        struct page *dir_page = NULL;
+        struct ufs_dir_entry * dir_de = NULL;
+        struct page *old_page;
         struct ufs_dir_entry *old_de;
         int err = -ENOENT;
 
-        lock_kernel();
-        old_de = ufs_find_entry (old_dentry, &old_bh);
+        old_de = ufs_find_entry(old_dir, old_dentry, &old_page);
         if (!old_de)
                 goto out;
 
         if (S_ISDIR(old_inode->i_mode)) {
                 err = -EIO;
-                dir_de = ufs_dotdot(old_inode, &dir_bh);
+                dir_de = ufs_dotdot(old_inode, &dir_page);
                 if (!dir_de)
                         goto out_old;
         }
 
         if (new_inode) {
-                struct buffer_head *new_bh;
+                struct page *new_page;
                 struct ufs_dir_entry *new_de;
 
                 err = -ENOTEMPTY;
-                if (dir_de && !ufs_empty_dir (new_inode))
+                if (dir_de && !ufs_empty_dir(new_inode))
                         goto out_dir;
+
                 err = -ENOENT;
-                new_de = ufs_find_entry (new_dentry, &new_bh);
+                new_de = ufs_find_entry(new_dir, new_dentry, &new_page);
                 if (!new_de)
                         goto out_dir;
                 inode_inc_link_count(old_inode);
-                ufs_set_link(new_dir, new_de, new_bh, old_inode);
+                ufs_set_link(new_dir, new_de, new_page, old_inode);
                 new_inode->i_ctime = CURRENT_TIME_SEC;
                 if (dir_de)
                         new_inode->i_nlink--;
@@ -329,24 +325,32 @@ static int ufs_rename (struct inode * old_dir, struct dentry * old_dentry,
                         inode_inc_link_count(new_dir);
         }
 
-        ufs_delete_entry (old_dir, old_de, old_bh);
+        /*
+         * Like most other Unix systems, set the ctime for inodes on a
+         * rename.
+         * inode_dec_link_count() will mark the inode dirty.
+         */
+        old_inode->i_ctime = CURRENT_TIME_SEC;
 
+        ufs_delete_entry(old_dir, old_de, old_page);
         inode_dec_link_count(old_inode);
 
         if (dir_de) {
-                ufs_set_link(old_inode, dir_de, dir_bh, new_dir);
+                ufs_set_link(old_inode, dir_de, dir_page, new_dir);
                 inode_dec_link_count(old_dir);
         }
-        unlock_kernel();
         return 0;
 
+
 out_dir:
-        if (dir_de)
-                brelse(dir_bh);
+        if (dir_de) {
+                kunmap(dir_page);
+                page_cache_release(dir_page);
+        }
 out_old:
-        brelse (old_bh);
+        kunmap(old_page);
+        page_cache_release(old_page);
 out:
-        unlock_kernel();
         return err;
 }
 
diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index fe5ab2aa2899..74ef5e9bedff 100644
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -90,95 +90,84 @@
 #include "swab.h"
 #include "util.h"
 
-#undef UFS_SUPER_DEBUG
-#undef UFS_SUPER_DEBUG_MORE
-
-
-#undef UFS_SUPER_DEBUG_MORE
-#ifdef UFS_SUPER_DEBUG
-#define UFSD(x) printk("(%s, %d), %s: ", __FILE__, __LINE__, __FUNCTION__); printk x;
-#else
-#define UFSD(x)
-#endif
-
-#ifdef UFS_SUPER_DEBUG_MORE
+#ifdef CONFIG_UFS_DEBUG
 /*
  * Print contents of ufs_super_block, useful for debugging
  */
-void ufs_print_super_stuff(struct super_block *sb,
-        struct ufs_super_block_first * usb1,
-        struct ufs_super_block_second * usb2, 
-        struct ufs_super_block_third * usb3)
+static void ufs_print_super_stuff(struct super_block *sb, unsigned flags,
+                                  struct ufs_super_block_first *usb1,
+                                  struct ufs_super_block_second *usb2,
+                                  struct ufs_super_block_third *usb3)
 {
         printk("ufs_print_super_stuff\n");
-        printk("size of usb:     %u\n", sizeof(struct ufs_super_block));
-        printk("  magic:         0x%x\n", fs32_to_cpu(sb, usb3->fs_magic));
-        printk("  sblkno:        %u\n", fs32_to_cpu(sb, usb1->fs_sblkno));
-        printk("  cblkno:        %u\n", fs32_to_cpu(sb, usb1->fs_cblkno));
-        printk("  iblkno:        %u\n", fs32_to_cpu(sb, usb1->fs_iblkno));
-        printk("  dblkno:        %u\n", fs32_to_cpu(sb, usb1->fs_dblkno));
-        printk("  cgoffset:      %u\n", fs32_to_cpu(sb, usb1->fs_cgoffset));
-        printk("  ~cgmask:       0x%x\n", ~fs32_to_cpu(sb, usb1->fs_cgmask));
-        printk("  size:          %u\n", fs32_to_cpu(sb, usb1->fs_size));
-        printk("  dsize:         %u\n", fs32_to_cpu(sb, usb1->fs_dsize));
-        printk("  ncg:           %u\n", fs32_to_cpu(sb, usb1->fs_ncg));
-        printk("  bsize:         %u\n", fs32_to_cpu(sb, usb1->fs_bsize));
-        printk("  fsize:         %u\n", fs32_to_cpu(sb, usb1->fs_fsize));
-        printk("  frag:          %u\n", fs32_to_cpu(sb, usb1->fs_frag));
-        printk("  fragshift:     %u\n", fs32_to_cpu(sb, usb1->fs_fragshift));
-        printk("  ~fmask:        %u\n", ~fs32_to_cpu(sb, usb1->fs_fmask));
-        printk("  fshift:        %u\n", fs32_to_cpu(sb, usb1->fs_fshift));
-        printk("  sbsize:        %u\n", fs32_to_cpu(sb, usb1->fs_sbsize));
-        printk("  spc:           %u\n", fs32_to_cpu(sb, usb1->fs_spc));
-        printk("  cpg:           %u\n", fs32_to_cpu(sb, usb1->fs_cpg));
-        printk("  ipg:           %u\n", fs32_to_cpu(sb, usb1->fs_ipg));
-        printk("  fpg:           %u\n", fs32_to_cpu(sb, usb1->fs_fpg));
-        printk("  csaddr:        %u\n", fs32_to_cpu(sb, usb1->fs_csaddr));
-        printk("  cssize:        %u\n", fs32_to_cpu(sb, usb1->fs_cssize));
-        printk("  cgsize:        %u\n", fs32_to_cpu(sb, usb1->fs_cgsize));
-        printk("  fstodb:        %u\n", fs32_to_cpu(sb, usb1->fs_fsbtodb));
-        printk("  contigsumsize: %d\n", fs32_to_cpu(sb, usb3->fs_u2.fs_44.fs_contigsumsize));
-        printk("  postblformat:  %u\n", fs32_to_cpu(sb, usb3->fs_postblformat));
-        printk("  nrpos:         %u\n", fs32_to_cpu(sb, usb3->fs_nrpos));
-        printk("  ndir           %u\n", fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir));
-        printk("  nifree         %u\n", fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree));
-        printk("  nbfree         %u\n", fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree));
-        printk("  nffree         %u\n", fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree));
-        printk("\n");
-}
-
-/*
- * Print contents of ufs2 ufs_super_block, useful for debugging
- */
-void ufs2_print_super_stuff(
-     struct super_block *sb,
-      struct ufs_super_block *usb)
-{
-        printk("ufs_print_super_stuff\n");
-        printk("size of usb:     %u\n", sizeof(struct ufs_super_block));
-        printk("  magic:         0x%x\n", fs32_to_cpu(sb, usb->fs_magic));
-        printk("  fs_size:   %u\n",fs64_to_cpu(sb, usb->fs_u11.fs_u2.fs_size));
-        printk("  fs_dsize:  %u\n",fs64_to_cpu(sb, usb->fs_u11.fs_u2.fs_dsize));
-        printk("  bsize:         %u\n", fs32_to_cpu(usb, usb->fs_bsize));
-        printk("  fsize:         %u\n", fs32_to_cpu(usb, usb->fs_fsize));
-        printk("  fs_volname:  %s\n", usb->fs_u11.fs_u2.fs_volname);
-        printk("  fs_fsmnt:  %s\n", usb->fs_u11.fs_u2.fs_fsmnt);
-        printk("  fs_sblockloc: %u\n",fs64_to_cpu(sb,
-                        usb->fs_u11.fs_u2.fs_sblockloc));
-        printk("  cs_ndir(No of dirs):  %u\n",fs64_to_cpu(sb,
-                        usb->fs_u11.fs_u2.fs_cstotal.cs_ndir));
-        printk("  cs_nbfree(No of free blocks):  %u\n",fs64_to_cpu(sb,
-                        usb->fs_u11.fs_u2.fs_cstotal.cs_nbfree));
+        printk("  magic:     0x%x\n", fs32_to_cpu(sb, usb3->fs_magic));
+        if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {
+                printk("  fs_size:   %llu\n", (unsigned long long)
+                       fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_size));
+                printk("  fs_dsize:  %llu\n", (unsigned long long)
+                       fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize));
+                printk("  bsize:         %u\n",
+                       fs32_to_cpu(sb, usb1->fs_bsize));
+                printk("  fsize:         %u\n",
+                       fs32_to_cpu(sb, usb1->fs_fsize));
+                printk("  fs_volname:  %s\n", usb2->fs_un.fs_u2.fs_volname);
+                printk("  fs_sblockloc: %llu\n", (unsigned long long)
+                       fs64_to_cpu(sb, usb2->fs_un.fs_u2.fs_sblockloc));
+                printk("  cs_ndir(No of dirs):  %llu\n", (unsigned long long)
+                       fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_ndir));
+                printk("  cs_nbfree(No of free blocks):  %llu\n",
+                       (unsigned long long)
+                       fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_nbfree));
+        } else {
+                printk(" sblkno:      %u\n", fs32_to_cpu(sb, usb1->fs_sblkno));
+                printk(" cblkno:      %u\n", fs32_to_cpu(sb, usb1->fs_cblkno));
+                printk(" iblkno:      %u\n", fs32_to_cpu(sb, usb1->fs_iblkno));
+                printk(" dblkno:      %u\n", fs32_to_cpu(sb, usb1->fs_dblkno));
+                printk(" cgoffset:    %u\n",
+                       fs32_to_cpu(sb, usb1->fs_cgoffset));
+                printk(" ~cgmask:     0x%x\n",
+                       ~fs32_to_cpu(sb, usb1->fs_cgmask));
+                printk(" size:        %u\n", fs32_to_cpu(sb, usb1->fs_size));
+                printk(" dsize:       %u\n", fs32_to_cpu(sb, usb1->fs_dsize));
+                printk(" ncg:         %u\n", fs32_to_cpu(sb, usb1->fs_ncg));
+                printk(" bsize:       %u\n", fs32_to_cpu(sb, usb1->fs_bsize));
+                printk(" fsize:       %u\n", fs32_to_cpu(sb, usb1->fs_fsize));
+                printk(" frag:        %u\n", fs32_to_cpu(sb, usb1->fs_frag));
+                printk(" fragshift:   %u\n",
+                       fs32_to_cpu(sb, usb1->fs_fragshift));
+                printk(" ~fmask:      %u\n", ~fs32_to_cpu(sb, usb1->fs_fmask));
+                printk(" fshift:      %u\n", fs32_to_cpu(sb, usb1->fs_fshift));
+                printk(" sbsize:      %u\n", fs32_to_cpu(sb, usb1->fs_sbsize));
+                printk(" spc:         %u\n", fs32_to_cpu(sb, usb1->fs_spc));
+                printk(" cpg:         %u\n", fs32_to_cpu(sb, usb1->fs_cpg));
+                printk(" ipg:         %u\n", fs32_to_cpu(sb, usb1->fs_ipg));
+                printk(" fpg:         %u\n", fs32_to_cpu(sb, usb1->fs_fpg));
+                printk(" csaddr:      %u\n", fs32_to_cpu(sb, usb1->fs_csaddr));
+                printk(" cssize:      %u\n", fs32_to_cpu(sb, usb1->fs_cssize));
+                printk(" cgsize:      %u\n", fs32_to_cpu(sb, usb1->fs_cgsize));
+                printk(" fstodb:      %u\n",
+                       fs32_to_cpu(sb, usb1->fs_fsbtodb));
+                printk(" nrpos:       %u\n", fs32_to_cpu(sb, usb3->fs_nrpos));
+                printk(" ndir         %u\n",
+                       fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir));
+                printk(" nifree       %u\n",
+                       fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree));
+                printk(" nbfree       %u\n",
+                       fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree));
+                printk(" nffree       %u\n",
+                       fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree));
+        }
         printk("\n");
 }
 
 /*
  * Print contents of ufs_cylinder_group, useful for debugging
  */
-void ufs_print_cylinder_stuff(struct super_block *sb, struct ufs_cylinder_group *cg)
+static void ufs_print_cylinder_stuff(struct super_block *sb,
+                                     struct ufs_cylinder_group *cg)
 {
         printk("\nufs_print_cylinder_stuff\n");
-        printk("size of ucg: %u\n", sizeof(struct ufs_cylinder_group));
+        printk("size of ucg: %zu\n", sizeof(struct ufs_cylinder_group));
         printk("  magic:        %x\n", fs32_to_cpu(sb, cg->cg_magic));
         printk("  time:         %u\n", fs32_to_cpu(sb, cg->cg_time));
         printk("  cgx:          %u\n", fs32_to_cpu(sb, cg->cg_cgx));
@@ -202,12 +191,18 @@ void ufs_print_cylinder_stuff(struct super_block *sb, struct ufs_cylinder_group
         printk("  iuseoff:      %u\n", fs32_to_cpu(sb, cg->cg_iusedoff));
         printk("  freeoff:      %u\n", fs32_to_cpu(sb, cg->cg_freeoff));
         printk("  nextfreeoff:  %u\n", fs32_to_cpu(sb, cg->cg_nextfreeoff));
-        printk("  clustersumoff %u\n", fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clustersumoff));
-        printk("  clusteroff    %u\n", fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clusteroff));
-        printk("  nclusterblks  %u\n", fs32_to_cpu(sb, cg->cg_u.cg_44.cg_nclusterblks));
+        printk("  clustersumoff %u\n",
+               fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clustersumoff));
+        printk("  clusteroff    %u\n",
+               fs32_to_cpu(sb, cg->cg_u.cg_44.cg_clusteroff));
+        printk("  nclusterblks  %u\n",
+               fs32_to_cpu(sb, cg->cg_u.cg_44.cg_nclusterblks));
         printk("\n");
 }
-#endif /* UFS_SUPER_DEBUG_MORE */
+#else
+#  define ufs_print_super_stuff(sb, flags, usb1, usb2, usb3) /**/
+#  define ufs_print_cylinder_stuff(sb, cg) /**/
+#endif /* CONFIG_UFS_DEBUG */
 
 static struct super_operations ufs_super_ops;
 
@@ -225,7 +220,7 @@ void ufs_error (struct super_block * sb, const char * function,
         
         if (!(sb->s_flags & MS_RDONLY)) {
                 usb1->fs_clean = UFS_FSBAD;
-                ubh_mark_buffer_dirty(USPI_UBH);
+                ubh_mark_buffer_dirty(USPI_UBH(uspi));
                 sb->s_dirt = 1;
                 sb->s_flags |= MS_RDONLY;
         }
@@ -257,7 +252,7 @@ void ufs_panic (struct super_block * sb, const char * function,
         
         if (!(sb->s_flags & MS_RDONLY)) {
                 usb1->fs_clean = UFS_FSBAD;
-                ubh_mark_buffer_dirty(USPI_UBH);
+                ubh_mark_buffer_dirty(USPI_UBH(uspi));
                 sb->s_dirt = 1;
         }
         va_start (args, fmt);
@@ -309,7 +304,7 @@ static int ufs_parse_options (char * options, unsigned * mount_options)
 {
         char * p;
         
-        UFSD(("ENTER\n"))
+        UFSD("ENTER\n");
         
         if (!options)
                 return 1;
@@ -386,27 +381,57 @@ static int ufs_parse_options (char * options, unsigned * mount_options)
 }
 
 /*
+ * Diffrent types of UFS hold fs_cstotal in different
+ * places, and use diffrent data structure for it.
+ * To make things simplier we just copy fs_cstotal to ufs_sb_private_info
+ */
+static void ufs_setup_cstotal(struct super_block *sb)
+{
+        struct ufs_sb_info *sbi = UFS_SB(sb);
+        struct ufs_sb_private_info *uspi = sbi->s_uspi;
+        struct ufs_super_block_first *usb1;
+        struct ufs_super_block_second *usb2;
+        struct ufs_super_block_third *usb3;
+        unsigned mtype = sbi->s_mount_opt & UFS_MOUNT_UFSTYPE;
+
+        UFSD("ENTER, mtype=%u\n", mtype);
+        usb1 = ubh_get_usb_first(uspi);
+        usb2 = ubh_get_usb_second(uspi);
+        usb3 = ubh_get_usb_third(uspi);
+
+        if ((mtype == UFS_MOUNT_UFSTYPE_44BSD &&
+             (usb1->fs_flags & UFS_FLAGS_UPDATED)) ||
+            mtype == UFS_MOUNT_UFSTYPE_UFS2) {
+                /*we have statistic in different place, then usual*/
+                uspi->cs_total.cs_ndir = fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_ndir);
+                uspi->cs_total.cs_nbfree = fs64_to_cpu(sb, usb2->fs_un.fs_u2.cs_nbfree);
+                uspi->cs_total.cs_nifree = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nifree);
+                uspi->cs_total.cs_nffree = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nffree);
+        } else {
+                uspi->cs_total.cs_ndir = fs32_to_cpu(sb, usb1->fs_cstotal.cs_ndir);
+                uspi->cs_total.cs_nbfree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree);
+                uspi->cs_total.cs_nifree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree);
+                uspi->cs_total.cs_nffree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree);
+        }
+        UFSD("EXIT\n");
+}
+
+/*
  * Read on-disk structures associated with cylinder groups
  */
-static int ufs_read_cylinder_structures (struct super_block *sb)
+static int ufs_read_cylinder_structures(struct super_block *sb)
 {
-        struct ufs_sb_info * sbi = UFS_SB(sb);
-        struct ufs_sb_private_info * uspi;
-        struct ufs_super_block *usb;
+        struct ufs_sb_info *sbi = UFS_SB(sb);
+        struct ufs_sb_private_info *uspi = sbi->s_uspi;
+        unsigned flags = sbi->s_flags;
         struct ufs_buffer_head * ubh;
         unsigned char * base, * space;
         unsigned size, blks, i;
-        unsigned flags = 0;
-        
-        UFSD(("ENTER\n"))
-        
-        uspi = sbi->s_uspi;
+        struct ufs_super_block_third *usb3;
 
-        usb  = (struct ufs_super_block *)
-                ((struct ufs_buffer_head *)uspi)->bh[0]->b_data;
+        UFSD("ENTER\n");
 
-        flags = UFS_SB(sb)->s_flags;
-        
+        usb3 = ubh_get_usb_third(uspi);
         /*
          * Read cs structures from (usually) first data block
          * on the device. 
@@ -424,7 +449,7 @@ static int ufs_read_cylinder_structures (struct super_block *sb)
 
                 if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) 
                         ubh = ubh_bread(sb,
-                                fs64_to_cpu(sb, usb->fs_u11.fs_u2.fs_csaddr) + i, size);
+                                fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_csaddr) + i, size);
                 else 
                         ubh = ubh_bread(sb, uspi->s_csaddr + i, size);
                 
@@ -451,14 +476,13 @@ static int ufs_read_cylinder_structures (struct super_block *sb)
                 sbi->s_cgno[i] = UFS_CGNO_EMPTY;
         }
         for (i = 0; i < uspi->s_ncg; i++) {
-                UFSD(("read cg %u\n", i))
+                UFSD("read cg %u\n", i);
                 if (!(sbi->s_ucg[i] = sb_bread(sb, ufs_cgcmin(i))))
                         goto failed;
                 if (!ufs_cg_chkmagic (sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data))
                         goto failed;
-#ifdef UFS_SUPER_DEBUG_MORE
+
                 ufs_print_cylinder_stuff(sb, (struct ufs_cylinder_group *) sbi->s_ucg[i]->b_data);
-#endif
         }
         for (i = 0; i < UFS_MAX_GROUP_LOADED; i++) {
                 if (!(sbi->s_ucpi[i] = kmalloc (sizeof(struct ufs_cg_private_info), GFP_KERNEL)))
@@ -466,7 +490,7 @@ static int ufs_read_cylinder_structures (struct super_block *sb)
                 sbi->s_cgno[i] = UFS_CGNO_EMPTY;
         }
         sbi->s_cg_loaded = 0;
-        UFSD(("EXIT\n"))
+        UFSD("EXIT\n");
         return 1;
 
 failed:
@@ -479,26 +503,69 @@ failed:
                 for (i = 0; i < UFS_MAX_GROUP_LOADED; i++)
                         kfree (sbi->s_ucpi[i]);
         }
-        UFSD(("EXIT (FAILED)\n"))
+        UFSD("EXIT (FAILED)\n");
         return 0;
 }
 
 /*
- * Put on-disk structures associated with cylinder groups and 
- * write them back to disk
+ * Sync our internal copy of fs_cstotal with disk
  */
-static void ufs_put_cylinder_structures (struct super_block *sb)
+static void ufs_put_cstotal(struct super_block *sb)
 {
-        struct ufs_sb_info * sbi = UFS_SB(sb);
-        struct ufs_sb_private_info * uspi;
+        unsigned mtype = UFS_SB(sb)->s_mount_opt & UFS_MOUNT_UFSTYPE;
+        struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
+        struct ufs_super_block_first *usb1;
+        struct ufs_super_block_second *usb2;
+        struct ufs_super_block_third *usb3;
+
+        UFSD("ENTER\n");
+        usb1 = ubh_get_usb_first(uspi);
+        usb2 = ubh_get_usb_second(uspi);
+        usb3 = ubh_get_usb_third(uspi);
+
+        if ((mtype == UFS_MOUNT_UFSTYPE_44BSD &&
+             (usb1->fs_flags & UFS_FLAGS_UPDATED)) ||
+            mtype == UFS_MOUNT_UFSTYPE_UFS2) {
+                /*we have statistic in different place, then usual*/
+                usb2->fs_un.fs_u2.cs_ndir =
+                        cpu_to_fs64(sb, uspi->cs_total.cs_ndir);
+                usb2->fs_un.fs_u2.cs_nbfree =
+                        cpu_to_fs64(sb, uspi->cs_total.cs_nbfree);
+                usb3->fs_un1.fs_u2.cs_nifree =
+                        cpu_to_fs64(sb, uspi->cs_total.cs_nifree);
+                usb3->fs_un1.fs_u2.cs_nffree =
+                        cpu_to_fs64(sb, uspi->cs_total.cs_nffree);
+        } else {
+                usb1->fs_cstotal.cs_ndir =
+                        cpu_to_fs32(sb, uspi->cs_total.cs_ndir);
+                usb1->fs_cstotal.cs_nbfree =
+                        cpu_to_fs32(sb, uspi->cs_total.cs_nbfree);
+                usb1->fs_cstotal.cs_nifree =
+                        cpu_to_fs32(sb, uspi->cs_total.cs_nifree);
+                usb1->fs_cstotal.cs_nffree =
+                        cpu_to_fs32(sb, uspi->cs_total.cs_nffree);
+        }
+        ubh_mark_buffer_dirty(USPI_UBH(uspi));
+        UFSD("EXIT\n");
+}
+
+/**
+ * ufs_put_super_internal() - put on-disk intrenal structures
+ * @sb: pointer to super_block structure
+ * Put on-disk structures associated with cylinder groups
+ * and write them back to disk, also update cs_total on disk
+ */
+static void ufs_put_super_internal(struct super_block *sb)
+{
+        struct ufs_sb_info *sbi = UFS_SB(sb);
+        struct ufs_sb_private_info *uspi = sbi->s_uspi;
         struct ufs_buffer_head * ubh;
         unsigned char * base, * space;
         unsigned blks, size, i;
-        
-        UFSD(("ENTER\n"))
-        
-        uspi = sbi->s_uspi;
 
+        
+        UFSD("ENTER\n");
+        ufs_put_cstotal(sb);
         size = uspi->s_cssize;
         blks = (size + uspi->s_fsize - 1) >> uspi->s_fshift;
         base = space = (char*) sbi->s_csp;
@@ -523,7 +590,7 @@ static void ufs_put_cylinder_structures (struct super_block *sb)
                 brelse (sbi->s_ucg[i]);
         kfree (sbi->s_ucg);
         kfree (base);
-        UFSD(("EXIT\n"))
+        UFSD("EXIT\n");
 }
 
 static int ufs_fill_super(struct super_block *sb, void *data, int silent)
@@ -533,7 +600,6 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
         struct ufs_super_block_first * usb1;
         struct ufs_super_block_second * usb2;
         struct ufs_super_block_third * usb3;
-        struct ufs_super_block *usb;
         struct ufs_buffer_head * ubh;   
         struct inode *inode;
         unsigned block_size, super_block_size;
@@ -544,7 +610,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
         ubh = NULL;
         flags = 0;
         
-        UFSD(("ENTER\n"))
+        UFSD("ENTER\n");
                 
         sbi = kmalloc(sizeof(struct ufs_sb_info), GFP_KERNEL);
         if (!sbi)
@@ -552,7 +618,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
         sb->s_fs_info = sbi;
         memset(sbi, 0, sizeof(struct ufs_sb_info));
 
-        UFSD(("flag %u\n", (int)(sb->s_flags & MS_RDONLY)))
+        UFSD("flag %u\n", (int)(sb->s_flags & MS_RDONLY));
         
 #ifndef CONFIG_UFS_FS_WRITE
         if (!(sb->s_flags & MS_RDONLY)) {
@@ -593,7 +659,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
            the rules */
         switch (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) {
         case UFS_MOUNT_UFSTYPE_44BSD:
-                UFSD(("ufstype=44bsd\n"))
+                UFSD("ufstype=44bsd\n");
                 uspi->s_fsize = block_size = 512;
                 uspi->s_fmask = ~(512 - 1);
                 uspi->s_fshift = 9;
@@ -602,7 +668,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
                 flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
                 break;
         case UFS_MOUNT_UFSTYPE_UFS2:
-                UFSD(("ufstype=ufs2\n"));
+                UFSD("ufstype=ufs2\n");
                 super_block_offset=SBLOCK_UFS2;
                 uspi->s_fsize = block_size = 512;
                 uspi->s_fmask = ~(512 - 1);
@@ -617,7 +683,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
                 break;
                 
         case UFS_MOUNT_UFSTYPE_SUN:
-                UFSD(("ufstype=sun\n"))
+                UFSD("ufstype=sun\n");
                 uspi->s_fsize = block_size = 1024;
                 uspi->s_fmask = ~(1024 - 1);
                 uspi->s_fshift = 10;
@@ -628,7 +694,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
                 break;
 
         case UFS_MOUNT_UFSTYPE_SUNx86:
-                UFSD(("ufstype=sunx86\n"))
+                UFSD("ufstype=sunx86\n");
                 uspi->s_fsize = block_size = 1024;
                 uspi->s_fmask = ~(1024 - 1);
                 uspi->s_fshift = 10;
@@ -639,7 +705,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
                 break;
 
         case UFS_MOUNT_UFSTYPE_OLD:
-                UFSD(("ufstype=old\n"))
+                UFSD("ufstype=old\n");
                 uspi->s_fsize = block_size = 1024;
                 uspi->s_fmask = ~(1024 - 1);
                 uspi->s_fshift = 10;
@@ -654,7 +720,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
                 break;
         
         case UFS_MOUNT_UFSTYPE_NEXTSTEP:
-                UFSD(("ufstype=nextstep\n"))
+                UFSD("ufstype=nextstep\n");
                 uspi->s_fsize = block_size = 1024;
                 uspi->s_fmask = ~(1024 - 1);
                 uspi->s_fshift = 10;
@@ -669,7 +735,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
                 break;
         
         case UFS_MOUNT_UFSTYPE_NEXTSTEP_CD:
-                UFSD(("ufstype=nextstep-cd\n"))
+                UFSD("ufstype=nextstep-cd\n");
                 uspi->s_fsize = block_size = 2048;
                 uspi->s_fmask = ~(2048 - 1);
                 uspi->s_fshift = 11;
@@ -684,7 +750,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
                 break;
         
         case UFS_MOUNT_UFSTYPE_OPENSTEP:
-                UFSD(("ufstype=openstep\n"))
+                UFSD("ufstype=openstep\n");
                 uspi->s_fsize = block_size = 1024;
                 uspi->s_fmask = ~(1024 - 1);
                 uspi->s_fshift = 10;
@@ -699,7 +765,7 @@ static int ufs_fill_super(struct super_block *sb, void *data, int silent)
                 break;
         
         case UFS_MOUNT_UFSTYPE_HP:
-                UFSD(("ufstype=hp\n"))
+                UFSD("ufstype=hp\n");
                 uspi->s_fsize = block_size = 1024;
                 uspi->s_fmask = ~(1024 - 1);
                 uspi->s_fshift = 10;
@@ -737,8 +803,6 @@ again:
         usb1 = ubh_get_usb_first(uspi);
         usb2 = ubh_get_usb_second(uspi);
         usb3 = ubh_get_usb_third(uspi);
-        usb  = (struct ufs_super_block *)
-                ((struct ufs_buffer_head *)uspi)->bh[0]->b_data ;
 
         /*
          * Check ufs magic number
@@ -820,16 +884,12 @@ magic_found:
                 ubh = NULL;
                 block_size = uspi->s_fsize;
                 super_block_size = uspi->s_sbsize;
-                UFSD(("another value of block_size or super_block_size %u, %u\n", block_size, super_block_size))
+                UFSD("another value of block_size or super_block_size %u, %u\n", block_size, super_block_size);
                 goto again;
         }
 
-#ifdef UFS_SUPER_DEBUG_MORE
-        if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
-                ufs2_print_super_stuff(sb,usb);
-        else
-                ufs_print_super_stuff(sb, usb1, usb2, usb3);
-#endif
+
+        ufs_print_super_stuff(sb, flags, usb1, usb2, usb3);
 
         /*
          * Check, if file system was correctly unmounted.
@@ -842,13 +902,13 @@ magic_found:
           (ufs_get_fs_state(sb, usb1, usb3) == (UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time))))) {
                 switch(usb1->fs_clean) {
                 case UFS_FSCLEAN:
-                        UFSD(("fs is clean\n"))
+                        UFSD("fs is clean\n");
                         break;
                 case UFS_FSSTABLE:
-                        UFSD(("fs is stable\n"))
+                        UFSD("fs is stable\n");
                         break;
                 case UFS_FSOSF1:
-                        UFSD(("fs is DEC OSF/1\n"))
+                        UFSD("fs is DEC OSF/1\n");
                         break;
                 case UFS_FSACTIVE:
                         printk("ufs_read_super: fs is active\n");
@@ -863,8 +923,7 @@ magic_found:
                         sb->s_flags |= MS_RDONLY;
                         break;
                 }
-        }
-        else {
+        } else {
                 printk("ufs_read_super: fs needs fsck\n");
                 sb->s_flags |= MS_RDONLY;
         }
@@ -884,10 +943,9 @@ magic_found:
         uspi->s_cgmask = fs32_to_cpu(sb, usb1->fs_cgmask);
 
         if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {
-                uspi->s_u2_size  = fs64_to_cpu(sb, usb->fs_u11.fs_u2.fs_size);
-                uspi->s_u2_dsize = fs64_to_cpu(sb, usb->fs_u11.fs_u2.fs_dsize);
-        }
-        else {
+                uspi->s_u2_size  = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_size);
+                uspi->s_u2_dsize = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize);
+        } else {
                 uspi->s_size  =  fs32_to_cpu(sb, usb1->fs_size);
                 uspi->s_dsize =  fs32_to_cpu(sb, usb1->fs_dsize);
         }
@@ -901,8 +959,8 @@ magic_found:
         uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
         uspi->s_bshift = fs32_to_cpu(sb, usb1->fs_bshift);
         uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
-        UFSD(("uspi->s_bshift = %d,uspi->s_fshift = %d", uspi->s_bshift,
-                uspi->s_fshift));
+        UFSD("uspi->s_bshift = %d,uspi->s_fshift = %d", uspi->s_bshift,
+                uspi->s_fshift);
         uspi->s_fpbshift = fs32_to_cpu(sb, usb1->fs_fragshift);
         uspi->s_fsbtodb = fs32_to_cpu(sb, usb1->fs_fsbtodb);
         /* s_sbsize already set */
@@ -922,8 +980,8 @@ magic_found:
         uspi->s_spc = fs32_to_cpu(sb, usb1->fs_spc);
         uspi->s_ipg = fs32_to_cpu(sb, usb1->fs_ipg);
         uspi->s_fpg = fs32_to_cpu(sb, usb1->fs_fpg);
-        uspi->s_cpc = fs32_to_cpu(sb, usb2->fs_cpc);
-        uspi->s_contigsumsize = fs32_to_cpu(sb, usb3->fs_u2.fs_44.fs_contigsumsize);
+        uspi->s_cpc = fs32_to_cpu(sb, usb2->fs_un.fs_u1.fs_cpc);
+        uspi->s_contigsumsize = fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_contigsumsize);
         uspi->s_qbmask = ufs_get_fs_qbmask(sb, usb3);
         uspi->s_qfmask = ufs_get_fs_qfmask(sb, usb3);
         uspi->s_postblformat = fs32_to_cpu(sb, usb3->fs_postblformat);
@@ -935,12 +993,11 @@ magic_found:
          * Compute another frequently used values
          */
         uspi->s_fpbmask = uspi->s_fpb - 1;
-        if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {
+        if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
                 uspi->s_apbshift = uspi->s_bshift - 3;
-        }
-        else {
+        else
                 uspi->s_apbshift = uspi->s_bshift - 2;
-        }
+
         uspi->s_2apbshift = uspi->s_apbshift * 2;
         uspi->s_3apbshift = uspi->s_apbshift * 3;
         uspi->s_apb = 1 << uspi->s_apbshift;
@@ -956,7 +1013,7 @@ magic_found:
         if ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) ==
             UFS_MOUNT_UFSTYPE_44BSD)
                 uspi->s_maxsymlinklen =
-                    fs32_to_cpu(sb, usb3->fs_u2.fs_44.fs_maxsymlinklen);
+                    fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen);
         
         sbi->s_flags = flags;
 
@@ -967,7 +1024,7 @@ magic_found:
         if (!sb->s_root)
                 goto dalloc_failed;
 
-
+        ufs_setup_cstotal(sb);
         /*
          * Read cylinder group structures
          */
@@ -975,7 +1032,7 @@ magic_found:
                 if (!ufs_read_cylinder_structures(sb))
                         goto failed;
 
-        UFSD(("EXIT\n"))
+        UFSD("EXIT\n");
         return 0;
 
 dalloc_failed:
@@ -986,15 +1043,16 @@ failed:
         kfree (uspi);
         kfree(sbi);
         sb->s_fs_info = NULL;
-        UFSD(("EXIT (FAILED)\n"))
+        UFSD("EXIT (FAILED)\n");
         return -EINVAL;
 
 failed_nomem:
-        UFSD(("EXIT (NOMEM)\n"))
+        UFSD("EXIT (NOMEM)\n");
         return -ENOMEM;
 }
 
-static void ufs_write_super (struct super_block *sb) {
+static void ufs_write_super(struct super_block *sb)
+{
         struct ufs_sb_private_info * uspi;
         struct ufs_super_block_first * usb1;
         struct ufs_super_block_third * usb3;
@@ -1002,7 +1060,7 @@ static void ufs_write_super (struct super_block *sb) {
 
         lock_kernel();
 
-        UFSD(("ENTER\n"))
+        UFSD("ENTER\n");
         flags = UFS_SB(sb)->s_flags;
         uspi = UFS_SB(sb)->s_uspi;
         usb1 = ubh_get_usb_first(uspi);
@@ -1014,26 +1072,27 @@ static void ufs_write_super (struct super_block *sb) {
                   || (flags & UFS_ST_MASK) == UFS_ST_SUNx86)
                         ufs_set_fs_state(sb, usb1, usb3,
                                         UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
-                ubh_mark_buffer_dirty (USPI_UBH);
+                ufs_put_cstotal(sb);
         }
         sb->s_dirt = 0;
-        UFSD(("EXIT\n"))
+        UFSD("EXIT\n");
         unlock_kernel();
 }
 
-static void ufs_put_super (struct super_block *sb)
+static void ufs_put_super(struct super_block *sb)
 {
         struct ufs_sb_info * sbi = UFS_SB(sb);
                 
-        UFSD(("ENTER\n"))
+        UFSD("ENTER\n");
 
         if (!(sb->s_flags & MS_RDONLY))
-                ufs_put_cylinder_structures (sb);
+                ufs_put_super_internal(sb);
         
         ubh_brelse_uspi (sbi->s_uspi);
         kfree (sbi->s_uspi);
         kfree (sbi);
         sb->s_fs_info = NULL;
+        UFSD("EXIT\n");
         return;
 }
 
@@ -1062,8 +1121,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
                 return -EINVAL;
         if (!(new_mount_opt & UFS_MOUNT_UFSTYPE)) {
                 new_mount_opt |= ufstype;
-        }
-        else if ((new_mount_opt & UFS_MOUNT_UFSTYPE) != ufstype) {
+        } else if ((new_mount_opt & UFS_MOUNT_UFSTYPE) != ufstype) {
                 printk("ufstype can't be changed during remount\n");
                 return -EINVAL;
         }
@@ -1077,20 +1135,19 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
          * fs was mouted as rw, remounting ro
          */
         if (*mount_flags & MS_RDONLY) {
-                ufs_put_cylinder_structures(sb);
+                ufs_put_super_internal(sb);
                 usb1->fs_time = cpu_to_fs32(sb, get_seconds());
                 if ((flags & UFS_ST_MASK) == UFS_ST_SUN
                   || (flags & UFS_ST_MASK) == UFS_ST_SUNx86) 
                         ufs_set_fs_state(sb, usb1, usb3,
                                 UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time));
-                ubh_mark_buffer_dirty (USPI_UBH);
+                ubh_mark_buffer_dirty (USPI_UBH(uspi));
                 sb->s_dirt = 0;
                 sb->s_flags |= MS_RDONLY;
-        }
+        } else {
         /*
          * fs was mounted as ro, remounting rw
          */
-        else {
 #ifndef CONFIG_UFS_FS_WRITE
                 printk("ufs was compiled with read-only support, "
                 "can't be mounted as read-write\n");
@@ -1102,7 +1159,7 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
                         printk("this ufstype is read-only supported\n");
                         return -EINVAL;
                 }
-                if (!ufs_read_cylinder_structures (sb)) {
+                if (!ufs_read_cylinder_structures(sb)) {
                         printk("failed during remounting\n");
                         return -EPERM;
                 }
@@ -1113,37 +1170,31 @@ static int ufs_remount (struct super_block *sb, int *mount_flags, char *data)
         return 0;
 }
 
-static int ufs_statfs (struct dentry *dentry, struct kstatfs *buf)
+static int ufs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
         struct super_block *sb = dentry->d_sb;
-        struct ufs_sb_private_info * uspi;
-        struct ufs_super_block_first * usb1;
-        struct ufs_super_block * usb;
-        unsigned  flags = 0;
+        struct ufs_sb_private_info *uspi= UFS_SB(sb)->s_uspi;
+        unsigned  flags = UFS_SB(sb)->s_flags;
+        struct ufs_super_block_first *usb1;
+        struct ufs_super_block_second *usb2;
+        struct ufs_super_block_third *usb3;
 
         lock_kernel();
 
-        uspi = UFS_SB(sb)->s_uspi;
-        usb1 = ubh_get_usb_first (uspi);
-        usb  = (struct ufs_super_block *)
-                ((struct ufs_buffer_head *)uspi)->bh[0]->b_data ;
+        usb1 = ubh_get_usb_first(uspi);
+        usb2 = ubh_get_usb_second(uspi);
+        usb3 = ubh_get_usb_third(uspi);
         
-        flags = UFS_SB(sb)->s_flags;
         if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {
                 buf->f_type = UFS2_MAGIC;
-                buf->f_blocks = fs64_to_cpu(sb, usb->fs_u11.fs_u2.fs_dsize);
-                buf->f_bfree = ufs_blkstofrags(fs64_to_cpu(sb, usb->fs_u11.fs_u2.fs_cstotal.cs_nbfree)) +
-                        fs64_to_cpu(sb, usb->fs_u11.fs_u2.fs_cstotal.cs_nffree);
-                buf->f_ffree = fs64_to_cpu(sb,
-                        usb->fs_u11.fs_u2.fs_cstotal.cs_nifree);
-        }
-        else {
+                buf->f_blocks = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize);
+        } else {
                 buf->f_type = UFS_MAGIC;
                 buf->f_blocks = uspi->s_dsize;
-                buf->f_bfree = ufs_blkstofrags(fs32_to_cpu(sb, usb1->fs_cstotal.cs_nbfree)) +
-                        fs32_to_cpu(sb, usb1->fs_cstotal.cs_nffree);
-                buf->f_ffree = fs32_to_cpu(sb, usb1->fs_cstotal.cs_nifree);
         }
+        buf->f_bfree = ufs_blkstofrags(uspi->cs_total.cs_nbfree) +
+                uspi->cs_total.cs_nffree;
+        buf->f_ffree = uspi->cs_total.cs_nifree;
         buf->f_bsize = sb->s_blocksize;
         buf->f_bavail = (buf->f_bfree > (((long)buf->f_blocks / 100) * uspi->s_minfree))
                 ? (buf->f_bfree - (((long)buf->f_blocks / 100) * uspi->s_minfree)) : 0;
diff --git a/fs/ufs/truncate.c b/fs/ufs/truncate.c
index 02e86291ef8a..3c3b301f8701 100644
--- a/fs/ufs/truncate.c
+++ b/fs/ufs/truncate.c
@@ -49,14 +49,6 @@
 #include "swab.h"
 #include "util.h"
 
-#undef UFS_TRUNCATE_DEBUG
-
-#ifdef UFS_TRUNCATE_DEBUG
-#define UFSD(x) printk("(%s, %d), %s: ", __FILE__, __LINE__, __FUNCTION__); printk x;
-#else
-#define UFSD(x)
-#endif
- 
 /*
  * Secure deletion currently doesn't work. It interacts very badly
  * with buffers shared with memory mappings, and for that reason
@@ -82,7 +74,7 @@ static int ufs_trunc_direct (struct inode * inode)
         unsigned i, tmp;
         int retry;
         
-        UFSD(("ENTER\n"))
+        UFSD("ENTER\n");
 
         sb = inode->i_sb;
         uspi = UFS_SB(sb)->s_uspi;
@@ -105,7 +97,7 @@ static int ufs_trunc_direct (struct inode * inode)
                 block2 = ufs_fragstoblks (frag3);
         }
 
-        UFSD(("frag1 %u, frag2 %u, block1 %u, block2 %u, frag3 %u, frag4 %u\n", frag1, frag2, block1, block2, frag3, frag4))
+        UFSD("frag1 %u, frag2 %u, block1 %u, block2 %u, frag3 %u, frag4 %u\n", frag1, frag2, block1, block2, frag3, frag4);
 
         if (frag1 >= frag2)
                 goto next1;             
@@ -120,9 +112,8 @@ static int ufs_trunc_direct (struct inode * inode)
         frag1 = ufs_fragnum (frag1);
         frag2 = ufs_fragnum (frag2);
 
-        inode->i_blocks -= (frag2-frag1) << uspi->s_nspfshift;
-        mark_inode_dirty(inode);
         ufs_free_fragments (inode, tmp + frag1, frag2 - frag1);
+        mark_inode_dirty(inode);
         frag_to_free = tmp + frag1;
 
 next1:
@@ -136,8 +127,7 @@ next1:
                         continue;
 
                 *p = 0;
-                inode->i_blocks -= uspi->s_nspb;
-                mark_inode_dirty(inode);
+
                 if (free_count == 0) {
                         frag_to_free = tmp;
                         free_count = uspi->s_fpb;
@@ -148,6 +138,7 @@ next1:
                         frag_to_free = tmp;
                         free_count = uspi->s_fpb;
                 }
+                mark_inode_dirty(inode);
         }
         
         if (free_count > 0)
@@ -166,12 +157,12 @@ next1:
         frag4 = ufs_fragnum (frag4);
 
         *p = 0;
-        inode->i_blocks -= frag4 << uspi->s_nspfshift;
-        mark_inode_dirty(inode);
+
         ufs_free_fragments (inode, tmp, frag4);
+        mark_inode_dirty(inode);
  next3:
 
-        UFSD(("EXIT\n"))
+        UFSD("EXIT\n");
         return retry;
 }
 
@@ -186,7 +177,7 @@ static int ufs_trunc_indirect (struct inode * inode, unsigned offset, __fs32 *p)
         unsigned frag_to_free, free_count;
         int retry;
 
-        UFSD(("ENTER\n"))
+        UFSD("ENTER\n");
                 
         sb = inode->i_sb;
         uspi = UFS_SB(sb)->s_uspi;
@@ -227,7 +218,7 @@ static int ufs_trunc_indirect (struct inode * inode, unsigned offset, __fs32 *p)
                         frag_to_free = tmp;
                         free_count = uspi->s_fpb;
                 }
-                inode->i_blocks -= uspi->s_nspb;
+
                 mark_inode_dirty(inode);
         }
 
@@ -238,26 +229,21 @@ static int ufs_trunc_indirect (struct inode * inode, unsigned offset, __fs32 *p)
                 if (*ubh_get_addr32(ind_ubh,i))
                         break;
         if (i >= uspi->s_apb) {
-                if (ubh_max_bcount(ind_ubh) != 1) {
-                        retry = 1;
-                }
-                else {
-                        tmp = fs32_to_cpu(sb, *p);
-                        *p = 0;
-                        inode->i_blocks -= uspi->s_nspb;
-                        mark_inode_dirty(inode);
-                        ufs_free_blocks (inode, tmp, uspi->s_fpb);
-                        ubh_bforget(ind_ubh);
-                        ind_ubh = NULL;
-                }
+                tmp = fs32_to_cpu(sb, *p);
+                *p = 0;
+
+                ufs_free_blocks (inode, tmp, uspi->s_fpb);
+                mark_inode_dirty(inode);
+                ubh_bforget(ind_ubh);
+                ind_ubh = NULL;
         }
         if (IS_SYNC(inode) && ind_ubh && ubh_buffer_dirty(ind_ubh)) {
-                ubh_ll_rw_block (SWRITE, 1, &ind_ubh);
+                ubh_ll_rw_block(SWRITE, ind_ubh);
                 ubh_wait_on_buffer (ind_ubh);
         }
         ubh_brelse (ind_ubh);
         
-        UFSD(("EXIT\n"))
+        UFSD("EXIT\n");
         
         return retry;
 }
@@ -271,7 +257,7 @@ static int ufs_trunc_dindirect (struct inode *inode, unsigned offset, __fs32 *p)
         __fs32 * dind;
         int retry = 0;
         
-        UFSD(("ENTER\n"))
+        UFSD("ENTER\n");
         
         sb = inode->i_sb;
         uspi = UFS_SB(sb)->s_uspi;
@@ -306,25 +292,21 @@ static int ufs_trunc_dindirect (struct inode *inode, unsigned offset, __fs32 *p)
                 if (*ubh_get_addr32 (dind_bh, i))
                         break;
         if (i >= uspi->s_apb) {
-                if (ubh_max_bcount(dind_bh) != 1)
-                        retry = 1;
-                else {
-                        tmp = fs32_to_cpu(sb, *p);
-                        *p = 0;
-                        inode->i_blocks -= uspi->s_nspb;
-                        mark_inode_dirty(inode);
-                        ufs_free_blocks (inode, tmp, uspi->s_fpb);
-                        ubh_bforget(dind_bh);
-                        dind_bh = NULL;
-                }
+                tmp = fs32_to_cpu(sb, *p);
+                *p = 0;
+
+                ufs_free_blocks(inode, tmp, uspi->s_fpb);
+                mark_inode_dirty(inode);
+                ubh_bforget(dind_bh);
+                dind_bh = NULL;
         }
         if (IS_SYNC(inode) && dind_bh && ubh_buffer_dirty(dind_bh)) {
-                ubh_ll_rw_block (SWRITE, 1, &dind_bh);
+                ubh_ll_rw_block(SWRITE, dind_bh);
                 ubh_wait_on_buffer (dind_bh);
         }
         ubh_brelse (dind_bh);
         
-        UFSD(("EXIT\n"))
+        UFSD("EXIT\n");
         
         return retry;
 }
@@ -339,7 +321,7 @@ static int ufs_trunc_tindirect (struct inode * inode)
         __fs32 * tind, * p;
         int retry;
         
-        UFSD(("ENTER\n"))
+        UFSD("ENTER\n");
 
         sb = inode->i_sb;
         uspi = UFS_SB(sb)->s_uspi;
@@ -370,25 +352,21 @@ static int ufs_trunc_tindirect (struct inode * inode)
                 if (*ubh_get_addr32 (tind_bh, i))
                         break;
         if (i >= uspi->s_apb) {
-                if (ubh_max_bcount(tind_bh) != 1)
-                        retry = 1;
-                else {
-                        tmp = fs32_to_cpu(sb, *p);
-                        *p = 0;
-                        inode->i_blocks -= uspi->s_nspb;
-                        mark_inode_dirty(inode);
-                        ufs_free_blocks (inode, tmp, uspi->s_fpb);
-                        ubh_bforget(tind_bh);
-                        tind_bh = NULL;
-                }
+                tmp = fs32_to_cpu(sb, *p);
+                *p = 0;
+
+                ufs_free_blocks(inode, tmp, uspi->s_fpb);
+                mark_inode_dirty(inode);
+                ubh_bforget(tind_bh);
+                tind_bh = NULL;
         }
         if (IS_SYNC(inode) && tind_bh && ubh_buffer_dirty(tind_bh)) {
-                ubh_ll_rw_block (SWRITE, 1, &tind_bh);
+                ubh_ll_rw_block(SWRITE, tind_bh);
                 ubh_wait_on_buffer (tind_bh);
         }
         ubh_brelse (tind_bh);
         
-        UFSD(("EXIT\n"))
+        UFSD("EXIT\n");
         return retry;
 }
                 
@@ -399,7 +377,7 @@ void ufs_truncate (struct inode * inode)
         struct ufs_sb_private_info * uspi;
         int retry;
         
-        UFSD(("ENTER\n"))
+        UFSD("ENTER\n");
         sb = inode->i_sb;
         uspi = UFS_SB(sb)->s_uspi;
 
@@ -430,5 +408,5 @@ void ufs_truncate (struct inode * inode)
         ufsi->i_lastfrag = DIRECT_FRAGMENT;
         unlock_kernel();
         mark_inode_dirty(inode);
-        UFSD(("EXIT\n"))
+        UFSD("EXIT\n");
 }
diff --git a/fs/ufs/util.c b/fs/ufs/util.c
index 59acc8f073ac..a2f13f45708b 100644
--- a/fs/ufs/util.c
+++ b/fs/ufs/util.c
@@ -14,15 +14,6 @@
 #include "swab.h"
 #include "util.h"
 
-#undef UFS_UTILS_DEBUG
-
-#ifdef UFS_UTILS_DEBUG
-#define UFSD(x) printk("(%s, %d), %s: ", __FILE__, __LINE__, __FUNCTION__); printk x;
-#else
-#define UFSD(x)
-#endif
-
-
 struct ufs_buffer_head * _ubh_bread_ (struct ufs_sb_private_info * uspi,
         struct super_block *sb, u64 fragment, u64 size)
 {
@@ -63,17 +54,17 @@ struct ufs_buffer_head * ubh_bread_uspi (struct ufs_sb_private_info * uspi,
         count = size >> uspi->s_fshift;
         if (count <= 0 || count > UFS_MAXFRAG)
                 return NULL;
-        USPI_UBH->fragment = fragment;
-        USPI_UBH->count = count;
+        USPI_UBH(uspi)->fragment = fragment;
+        USPI_UBH(uspi)->count = count;
         for (i = 0; i < count; i++)
-                if (!(USPI_UBH->bh[i] = sb_bread(sb, fragment + i)))
+                if (!(USPI_UBH(uspi)->bh[i] = sb_bread(sb, fragment + i)))
                         goto failed;
         for (; i < UFS_MAXFRAG; i++)
-                USPI_UBH->bh[i] = NULL;
-        return USPI_UBH;
+                USPI_UBH(uspi)->bh[i] = NULL;
+        return USPI_UBH(uspi);
 failed:
         for (j = 0; j < i; j++)
-                brelse (USPI_UBH->bh[j]);
+                brelse (USPI_UBH(uspi)->bh[j]);
         return NULL;
 }
 
@@ -90,11 +81,11 @@ void ubh_brelse (struct ufs_buffer_head * ubh)
 void ubh_brelse_uspi (struct ufs_sb_private_info * uspi)
 {
         unsigned i;
-        if (!USPI_UBH)
+        if (!USPI_UBH(uspi))
                 return;
-        for ( i = 0; i < USPI_UBH->count; i++ ) {
-                brelse (USPI_UBH->bh[i]);
-                USPI_UBH->bh[i] = NULL;
+        for ( i = 0; i < USPI_UBH(uspi)->count; i++ ) {
+                brelse (USPI_UBH(uspi)->bh[i]);
+                USPI_UBH(uspi)->bh[i] = NULL;
         }
 }
 
@@ -121,13 +112,12 @@ void ubh_mark_buffer_uptodate (struct ufs_buffer_head * ubh, int flag)
         }
 }
 
-void ubh_ll_rw_block (int rw, unsigned nr, struct ufs_buffer_head * ubh[])
+void ubh_ll_rw_block(int rw, struct ufs_buffer_head *ubh)
 {
-        unsigned i;
         if (!ubh)
                 return;
-        for ( i = 0; i < nr; i++ )
-                ll_rw_block (rw, ubh[i]->count, ubh[i]->bh);
+
+        ll_rw_block(rw, ubh->count, ubh->bh);
 }
 
 void ubh_wait_on_buffer (struct ufs_buffer_head * ubh)
@@ -139,18 +129,6 @@ void ubh_wait_on_buffer (struct ufs_buffer_head * ubh)
                 wait_on_buffer (ubh->bh[i]);
 }
 
-unsigned ubh_max_bcount (struct ufs_buffer_head * ubh)
-{
-        unsigned i;
-        unsigned max = 0;
-        if (!ubh)
-                return 0;
-        for ( i = 0; i < ubh->count; i++ ) 
-                if ( atomic_read(&ubh->bh[i]->b_count) > max )
-                        max = atomic_read(&ubh->bh[i]->b_count);
-        return max;
-}
-
 void ubh_bforget (struct ufs_buffer_head * ubh)
 {
         unsigned i;
diff --git a/fs/ufs/util.h b/fs/ufs/util.h
index 48d6d9bcc157..406981fff5e7 100644
--- a/fs/ufs/util.h
+++ b/fs/ufs/util.h
@@ -17,10 +17,16 @@
 #define in_range(b,first,len)   ((b)>=(first)&&(b)<(first)+(len))
 
 /*
- * macros used for retyping
+ * functions used for retyping
  */
-#define UCPI_UBH ((struct ufs_buffer_head *)ucpi)
-#define USPI_UBH ((struct ufs_buffer_head *)uspi)
+static inline struct ufs_buffer_head *UCPI_UBH(struct ufs_cg_private_info *cpi)
+{
+        return &cpi->c_ubh;
+}
+static inline struct ufs_buffer_head *USPI_UBH(struct ufs_sb_private_info *spi)
+{
+        return &spi->s_ubh;
+}
 
 
 
@@ -33,12 +39,12 @@ ufs_get_fs_state(struct super_block *sb, struct ufs_super_block_first *usb1,
 {
         switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
         case UFS_ST_SUN:
-                return fs32_to_cpu(sb, usb3->fs_u2.fs_sun.fs_state);
+                return fs32_to_cpu(sb, usb3->fs_un2.fs_sun.fs_state);
         case UFS_ST_SUNx86:
                 return fs32_to_cpu(sb, usb1->fs_u1.fs_sunx86.fs_state);
         case UFS_ST_44BSD:
         default:
-                return fs32_to_cpu(sb, usb3->fs_u2.fs_44.fs_state);
+                return fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_state);
         }
 }
 
@@ -48,13 +54,13 @@ ufs_set_fs_state(struct super_block *sb, struct ufs_super_block_first *usb1,
 {
         switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
         case UFS_ST_SUN:
-                usb3->fs_u2.fs_sun.fs_state = cpu_to_fs32(sb, value);
+                usb3->fs_un2.fs_sun.fs_state = cpu_to_fs32(sb, value);
                 break;
         case UFS_ST_SUNx86:
                 usb1->fs_u1.fs_sunx86.fs_state = cpu_to_fs32(sb, value);
                 break;
         case UFS_ST_44BSD:
-                usb3->fs_u2.fs_44.fs_state = cpu_to_fs32(sb, value);
+                usb3->fs_un2.fs_44.fs_state = cpu_to_fs32(sb, value);
                 break;
         }
 }
@@ -64,7 +70,7 @@ ufs_get_fs_npsect(struct super_block *sb, struct ufs_super_block_first *usb1,
                   struct ufs_super_block_third *usb3)
 {
         if ((UFS_SB(sb)->s_flags & UFS_ST_MASK) == UFS_ST_SUNx86)
-                return fs32_to_cpu(sb, usb3->fs_u2.fs_sunx86.fs_npsect);
+                return fs32_to_cpu(sb, usb3->fs_un2.fs_sunx86.fs_npsect);
         else
                 return fs32_to_cpu(sb, usb1->fs_u1.fs_sun.fs_npsect);
 }
@@ -76,16 +82,16 @@ ufs_get_fs_qbmask(struct super_block *sb, struct ufs_super_block_third *usb3)
 
         switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
         case UFS_ST_SUN:
-                ((__fs32 *)&tmp)[0] = usb3->fs_u2.fs_sun.fs_qbmask[0];
-                ((__fs32 *)&tmp)[1] = usb3->fs_u2.fs_sun.fs_qbmask[1];
+                ((__fs32 *)&tmp)[0] = usb3->fs_un2.fs_sun.fs_qbmask[0];
+                ((__fs32 *)&tmp)[1] = usb3->fs_un2.fs_sun.fs_qbmask[1];
                 break;
         case UFS_ST_SUNx86:
-                ((__fs32 *)&tmp)[0] = usb3->fs_u2.fs_sunx86.fs_qbmask[0];
-                ((__fs32 *)&tmp)[1] = usb3->fs_u2.fs_sunx86.fs_qbmask[1];
+                ((__fs32 *)&tmp)[0] = usb3->fs_un2.fs_sunx86.fs_qbmask[0];
+                ((__fs32 *)&tmp)[1] = usb3->fs_un2.fs_sunx86.fs_qbmask[1];
                 break;
         case UFS_ST_44BSD:
-                ((__fs32 *)&tmp)[0] = usb3->fs_u2.fs_44.fs_qbmask[0];
-                ((__fs32 *)&tmp)[1] = usb3->fs_u2.fs_44.fs_qbmask[1];
+                ((__fs32 *)&tmp)[0] = usb3->fs_un2.fs_44.fs_qbmask[0];
+                ((__fs32 *)&tmp)[1] = usb3->fs_un2.fs_44.fs_qbmask[1];
                 break;
         }
 
@@ -99,16 +105,16 @@ ufs_get_fs_qfmask(struct super_block *sb, struct ufs_super_block_third *usb3)
 
         switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
         case UFS_ST_SUN:
-                ((__fs32 *)&tmp)[0] = usb3->fs_u2.fs_sun.fs_qfmask[0];
-                ((__fs32 *)&tmp)[1] = usb3->fs_u2.fs_sun.fs_qfmask[1];
+                ((__fs32 *)&tmp)[0] = usb3->fs_un2.fs_sun.fs_qfmask[0];
+                ((__fs32 *)&tmp)[1] = usb3->fs_un2.fs_sun.fs_qfmask[1];
                 break;
         case UFS_ST_SUNx86:
-                ((__fs32 *)&tmp)[0] = usb3->fs_u2.fs_sunx86.fs_qfmask[0];
-                ((__fs32 *)&tmp)[1] = usb3->fs_u2.fs_sunx86.fs_qfmask[1];
+                ((__fs32 *)&tmp)[0] = usb3->fs_un2.fs_sunx86.fs_qfmask[0];
+                ((__fs32 *)&tmp)[1] = usb3->fs_un2.fs_sunx86.fs_qfmask[1];
                 break;
         case UFS_ST_44BSD:
-                ((__fs32 *)&tmp)[0] = usb3->fs_u2.fs_44.fs_qfmask[0];
-                ((__fs32 *)&tmp)[1] = usb3->fs_u2.fs_44.fs_qfmask[1];
+                ((__fs32 *)&tmp)[0] = usb3->fs_un2.fs_44.fs_qfmask[0];
+                ((__fs32 *)&tmp)[1] = usb3->fs_un2.fs_44.fs_qfmask[1];
                 break;
         }
 
@@ -236,9 +242,8 @@ extern void ubh_brelse (struct ufs_buffer_head *);
 extern void ubh_brelse_uspi (struct ufs_sb_private_info *);
 extern void ubh_mark_buffer_dirty (struct ufs_buffer_head *);
 extern void ubh_mark_buffer_uptodate (struct ufs_buffer_head *, int);
-extern void ubh_ll_rw_block (int, unsigned, struct ufs_buffer_head **);
+extern void ubh_ll_rw_block(int, struct ufs_buffer_head *);
 extern void ubh_wait_on_buffer (struct ufs_buffer_head *);
-extern unsigned ubh_max_bcount (struct ufs_buffer_head *);
 extern void ubh_bforget (struct ufs_buffer_head *);
 extern int  ubh_buffer_dirty (struct ufs_buffer_head *);
 #define ubh_ubhcpymem(mem,ubh,size) _ubh_ubhcpymem_(uspi,mem,ubh,size)
@@ -297,40 +302,26 @@ static inline void *get_usb_offset(struct ufs_sb_private_info *uspi,
 #define ubh_blkmap(ubh,begin,bit) \
         ((*ubh_get_addr(ubh, (begin) + ((bit) >> 3)) >> ((bit) & 7)) & (0xff >> (UFS_MAXFRAG - uspi->s_fpb)))
 
-
-/*
- * Macros for access to superblock array structures
- */
-#define ubh_postbl(ubh,cylno,i) \
-        ((uspi->s_postblformat != UFS_DYNAMICPOSTBLFMT) \
-        ? (*(__s16*)(ubh_get_addr(ubh, \
-        (unsigned)(&((struct ufs_super_block *)0)->fs_opostbl) \
-        + (((cylno) * 16 + (i)) << 1) ) )) \
-        : (*(__s16*)(ubh_get_addr(ubh, \
-        uspi->s_postbloff + (((cylno) * uspi->s_nrpos + (i)) << 1) ))))
-
-#define ubh_rotbl(ubh,i) \
-        ((uspi->s_postblformat != UFS_DYNAMICPOSTBLFMT) \
-        ? (*(__u8*)(ubh_get_addr(ubh, \
-        (unsigned)(&((struct ufs_super_block *)0)->fs_space) + (i)))) \
-        : (*(__u8*)(ubh_get_addr(ubh, uspi->s_rotbloff + (i)))))
-
 /*
  * Determine the number of available frags given a
  * percentage to hold in reserve.
  */
-#define ufs_freespace(usb, percentreserved) \
-        (ufs_blkstofrags(fs32_to_cpu(sb, (usb)->fs_cstotal.cs_nbfree)) + \
-        fs32_to_cpu(sb, (usb)->fs_cstotal.cs_nffree) - (uspi->s_dsize * (percentreserved) / 100))
+static inline u64
+ufs_freespace(struct ufs_sb_private_info *uspi, int percentreserved)
+{
+        return ufs_blkstofrags(uspi->cs_total.cs_nbfree) +
+                uspi->cs_total.cs_nffree -
+                (uspi->s_dsize * (percentreserved) / 100);
+}
 
 /*
  * Macros to access cylinder group array structures
  */
 #define ubh_cg_blktot(ucpi,cylno) \
-        (*((__fs32*)ubh_get_addr(UCPI_UBH, (ucpi)->c_btotoff + ((cylno) << 2))))
+        (*((__fs32*)ubh_get_addr(UCPI_UBH(ucpi), (ucpi)->c_btotoff + ((cylno) << 2))))
 
 #define ubh_cg_blks(ucpi,cylno,rpos) \
-        (*((__fs16*)ubh_get_addr(UCPI_UBH, \
+        (*((__fs16*)ubh_get_addr(UCPI_UBH(ucpi), \
         (ucpi)->c_boff + (((cylno) * uspi->s_nrpos + (rpos)) << 1 ))))
 
 /*
@@ -508,29 +499,3 @@ static inline void ufs_fragacct (struct super_block * sb, unsigned blockmap,
         if (fragsize > 0 && fragsize < uspi->s_fpb)
                 fs32_add(sb, &fraglist[fragsize], cnt);
 }
-
-#define ubh_scanc(ubh,begin,size,table,mask) _ubh_scanc_(uspi,ubh,begin,size,table,mask)
-static inline unsigned _ubh_scanc_(struct ufs_sb_private_info * uspi, struct ufs_buffer_head * ubh, 
-        unsigned begin, unsigned size, unsigned char * table, unsigned char mask)
-{
-        unsigned rest, offset;
-        unsigned char * cp;
-        
-
-        offset = begin & ~uspi->s_fmask;
-        begin >>= uspi->s_fshift;
-        for (;;) {
-                if ((offset + size) < uspi->s_fsize)
-                        rest = size;
-                else
-                        rest = uspi->s_fsize - offset;
-                size -= rest;
-                cp = ubh->bh[begin]->b_data + offset;
-                while ((table[*cp++] & mask) == 0 && --rest);
-                if (rest || !size)
-                        break;
-                begin++;
-                offset = 0;
-        }
-        return (size + rest);
-}
diff --git a/include/asm-alpha/floppy.h b/include/asm-alpha/floppy.h
index e177d4180f83..21816d35ef89 100644
--- a/include/asm-alpha/floppy.h
+++ b/include/asm-alpha/floppy.h
@@ -25,9 +25,8 @@
 #define fd_enable_irq()         enable_irq(FLOPPY_IRQ)
 #define fd_disable_irq()        disable_irq(FLOPPY_IRQ)
 #define fd_cacheflush(addr,size) /* nothing */
-#define fd_request_irq()        request_irq(FLOPPY_IRQ, floppy_interrupt, \
-                                            SA_INTERRUPT|SA_SAMPLE_RANDOM, \
-                                            "floppy", NULL)
+#define fd_request_irq()        request_irq(FLOPPY_IRQ, floppy_interrupt,\
+                                            SA_INTERRUPT, "floppy", NULL)
 #define fd_free_irq()           free_irq(FLOPPY_IRQ, NULL);
 
 #ifdef CONFIG_PCI
diff --git a/include/asm-arm/floppy.h b/include/asm-arm/floppy.h
index 6ea657c886b9..aa0c8d28d8d9 100644
--- a/include/asm-arm/floppy.h
+++ b/include/asm-arm/floppy.h
@@ -25,7 +25,7 @@
 
 #define fd_inb(port)            inb((port))
 #define fd_request_irq()        request_irq(IRQ_FLOPPYDISK,floppy_interrupt,\
-                                        SA_INTERRUPT|SA_SAMPLE_RANDOM,"floppy",NULL)
+                                            SA_INTERRUPT,"floppy",NULL)
 #define fd_free_irq()           free_irq(IRQ_FLOPPYDISK,NULL)
 #define fd_disable_irq()        disable_irq(IRQ_FLOPPYDISK)
 #define fd_enable_irq()         enable_irq(IRQ_FLOPPYDISK)
diff --git a/include/asm-arm26/floppy.h b/include/asm-arm26/floppy.h
index 9e090ad7e477..a18af069ca28 100644
--- a/include/asm-arm26/floppy.h
+++ b/include/asm-arm26/floppy.h
@@ -22,7 +22,7 @@
 
 #define fd_inb(port)            inb((port))
 #define fd_request_irq()        request_irq(IRQ_FLOPPYDISK,floppy_interrupt,\
-                                        SA_INTERRUPT|SA_SAMPLE_RANDOM,"floppy",NULL)
+                                        SA_INTERRUPT,"floppy",NULL)
 #define fd_free_irq()           free_irq(IRQ_FLOPPYDISK,NULL)
 #define fd_disable_irq()        disable_irq(IRQ_FLOPPYDISK)
 #define fd_enable_irq()         enable_irq(IRQ_FLOPPYDISK)
diff --git a/include/asm-generic/bug.h b/include/asm-generic/bug.h
index 0cd9711895fa..845cb67ad8ea 100644
--- a/include/asm-generic/bug.h
+++ b/include/asm-generic/bug.h
@@ -38,4 +38,17 @@
 #endif
 #endif
 
+#define WARN_ON_ONCE(condition)                         \
+({                                                      \
+        static int __warn_once = 1;                     \
+        int __ret = 0;                                  \
+                                                        \
+        if (unlikely((condition) && __warn_once)) {     \
+                __warn_once = 0;                        \
+                WARN_ON(1);                             \
+                __ret = 1;                              \
+        }                                               \
+        __ret;                                          \
+})
+
 #endif
diff --git a/include/asm-generic/percpu.h b/include/asm-generic/percpu.h
index c0caf433a7d7..c74521157461 100644
--- a/include/asm-generic/percpu.h
+++ b/include/asm-generic/percpu.h
@@ -14,6 +14,7 @@ extern unsigned long __per_cpu_offset[NR_CPUS];
 /* var is in discarded region: offset to particular copy we want */
 #define per_cpu(var, cpu) (*RELOC_HIDE(&per_cpu__##var, __per_cpu_offset[cpu]))
 #define __get_cpu_var(var) per_cpu(var, smp_processor_id())
+#define __raw_get_cpu_var(var) per_cpu(var, raw_smp_processor_id())
 
 /* A macro to avoid #include hell... */
 #define percpu_modcopy(pcpudst, src, size)                      \
@@ -30,6 +31,7 @@ do {								\
 
 #define per_cpu(var, cpu)                       (*((void)(cpu), &per_cpu__##var))
 #define __get_cpu_var(var)                      per_cpu__##var
+#define __raw_get_cpu_var(var)                  per_cpu__##var
 
 #endif  /* SMP */
 
diff --git a/include/asm-i386/floppy.h b/include/asm-i386/floppy.h
index 03403045c182..9cb2793eb211 100644
--- a/include/asm-i386/floppy.h
+++ b/include/asm-i386/floppy.h
@@ -147,9 +147,8 @@ static int fd_request_irq(void)
                 return request_irq(FLOPPY_IRQ, floppy_hardint,SA_INTERRUPT,
                                                    "floppy", NULL);
         else
-                return request_irq(FLOPPY_IRQ, floppy_interrupt,
-                                                   SA_INTERRUPT|SA_SAMPLE_RANDOM,
-                                                   "floppy", NULL);     
+                return request_irq(FLOPPY_IRQ, floppy_interrupt, SA_INTERRUPT,
+                                   "floppy", NULL);
 
 }
 
diff --git a/include/asm-i386/mach-default/setup_arch_pre.h b/include/asm-i386/mach-default/setup_arch.h
index fb42099e7bd4..fb42099e7bd4 100644
--- a/include/asm-i386/mach-default/setup_arch_pre.h
+++ b/include/asm-i386/mach-default/setup_arch.h
diff --git a/include/asm-i386/mach-default/setup_arch_post.h b/include/asm-i386/mach-default/setup_arch_post.h
deleted file mode 100644
index 2fc4888721f6..000000000000
--- a/include/asm-i386/mach-default/setup_arch_post.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/**
- * machine_specific_memory_setup - Hook for machine specific memory setup.
- *
- * Description:
- *      This is included late in kernel/setup.c so that it can make
- *      use of all of the static functions.
- **/
-
-static char * __init machine_specific_memory_setup(void)
-{
-        char *who;
-
-
-        who = "BIOS-e820";
-
-        /*
-         * Try to copy the BIOS-supplied E820-map.
-         *
-         * Otherwise fake a memory map; one section from 0k->640k,
-         * the next section from 1mb->appropriate_mem_k
-         */
-        sanitize_e820_map(E820_MAP, &E820_MAP_NR);
-        if (copy_e820_map(E820_MAP, E820_MAP_NR) < 0) {
-                unsigned long mem_size;
-
-                /* compare results from other methods and take the greater */
-                if (ALT_MEM_K < EXT_MEM_K) {
-                        mem_size = EXT_MEM_K;
-                        who = "BIOS-88";
-                } else {
-                        mem_size = ALT_MEM_K;
-                        who = "BIOS-e801";
-                }
-
-                e820.nr_map = 0;
-                add_memory_region(0, LOWMEMSIZE(), E820_RAM);
-                add_memory_region(HIGH_MEMORY, mem_size << 10, E820_RAM);
-        }
-        return who;
-}
diff --git a/include/asm-i386/mach-visws/setup_arch_pre.h b/include/asm-i386/mach-visws/setup_arch.h
index b92d6d9a4d3c..b92d6d9a4d3c 100644
--- a/include/asm-i386/mach-visws/setup_arch_pre.h
+++ b/include/asm-i386/mach-visws/setup_arch.h
diff --git a/include/asm-i386/mach-visws/setup_arch_post.h b/include/asm-i386/mach-visws/setup_arch_post.h
deleted file mode 100644
index cdbd895a54b1..000000000000
--- a/include/asm-i386/mach-visws/setup_arch_post.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/* Hook for machine specific memory setup.
- *
- * This is included late in kernel/setup.c so that it can make use of all of
- * the static functions. */
-
-#define MB (1024 * 1024)
-
-unsigned long sgivwfb_mem_phys;
-unsigned long sgivwfb_mem_size;
-
-long long mem_size __initdata = 0;
-
-static char * __init machine_specific_memory_setup(void)
-{
-        long long gfx_mem_size = 8 * MB;
-
-        mem_size = ALT_MEM_K;
-
-        if (!mem_size) {
-                printk(KERN_WARNING "Bootloader didn't set memory size, upgrade it !\n");
-                mem_size = 128 * MB;
-        }
-
-        /*
-         * this hardcodes the graphics memory to 8 MB
-         * it really should be sized dynamically (or at least
-         * set as a boot param)
-         */
-        if (!sgivwfb_mem_size) {
-                printk(KERN_WARNING "Defaulting to 8 MB framebuffer size\n");
-                sgivwfb_mem_size = 8 * MB;
-        }
-
-        /*
-         * Trim to nearest MB
-         */
-        sgivwfb_mem_size &= ~((1 << 20) - 1);
-        sgivwfb_mem_phys = mem_size - gfx_mem_size;
-
-        add_memory_region(0, LOWMEMSIZE(), E820_RAM);
-        add_memory_region(HIGH_MEMORY, mem_size - sgivwfb_mem_size - HIGH_MEMORY, E820_RAM);
-        add_memory_region(sgivwfb_mem_phys, sgivwfb_mem_size, E820_RESERVED);
-
-        return "PROM";
-
-        /* Remove gcc warnings */
-        (void) sanitize_e820_map(NULL, NULL);
-        (void) copy_e820_map(NULL, 0);
-}
diff --git a/include/asm-i386/mach-voyager/setup_arch_pre.h b/include/asm-i386/mach-voyager/setup_arch.h
index 48f7e6ff49a5..84d01ad33459 100644
--- a/include/asm-i386/mach-voyager/setup_arch_pre.h
+++ b/include/asm-i386/mach-voyager/setup_arch.h
@@ -3,7 +3,7 @@
 
 /* Hook to call BIOS initialisation function */
 
-/* for voyager, pass the voyager BIOS/SUS info area to the detection 
+/* for voyager, pass the voyager BIOS/SUS info area to the detection
  * routines */
 
 #define ARCH_SETUP      voyager_detect(VOYAGER_BIOS_INFO);
diff --git a/include/asm-i386/mach-voyager/setup_arch_post.h b/include/asm-i386/mach-voyager/setup_arch_post.h
deleted file mode 100644
index f6f6c2cbc75c..000000000000
--- a/include/asm-i386/mach-voyager/setup_arch_post.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/* Hook for machine specific memory setup.
- *
- * This is included late in kernel/setup.c so that it can make use of all of
- * the static functions. */
-
-static char * __init machine_specific_memory_setup(void)
-{
-        char *who;
-
-        who = "NOT VOYAGER";
-
-        if(voyager_level == 5) {
-                __u32 addr, length;
-                int i;
-
-                who = "Voyager-SUS";
-
-                e820.nr_map = 0;
-                for(i=0; voyager_memory_detect(i, &addr, &length); i++) {
-                        add_memory_region(addr, length, E820_RAM);
-                }
-                return who;
-        } else if(voyager_level == 4) {
-                __u32 tom;
-                __u16 catbase = inb(VOYAGER_SSPB_RELOCATION_PORT)<<8;
-                /* select the DINO config space */
-                outb(VOYAGER_DINO, VOYAGER_CAT_CONFIG_PORT);
-                /* Read DINO top of memory register */
-                tom = ((inb(catbase + 0x4) & 0xf0) << 16)
-                        + ((inb(catbase + 0x5) & 0x7f) << 24);
-
-                if(inb(catbase) != VOYAGER_DINO) {
-                        printk(KERN_ERR "Voyager: Failed to get DINO for L4, setting tom to EXT_MEM_K\n");
-                        tom = (EXT_MEM_K)<<10;
-                }
-                who = "Voyager-TOM";
-                add_memory_region(0, 0x9f000, E820_RAM);
-                /* map from 1M to top of memory */
-                add_memory_region(1*1024*1024, tom - 1*1024*1024, E820_RAM);
-                /* FIXME: Should check the ASICs to see if I need to
-                 * take out the 8M window.  Just do it at the moment
-                 * */
-                add_memory_region(8*1024*1024, 8*1024*1024, E820_RESERVED);
-                return who;
-        }
-
-        who = "BIOS-e820";
-
-        /*
-         * Try to copy the BIOS-supplied E820-map.
-         *
-         * Otherwise fake a memory map; one section from 0k->640k,
-         * the next section from 1mb->appropriate_mem_k
-         */
-        sanitize_e820_map(E820_MAP, &E820_MAP_NR);
-        if (copy_e820_map(E820_MAP, E820_MAP_NR) < 0) {
-                unsigned long mem_size;
-
-                /* compare results from other methods and take the greater */
-                if (ALT_MEM_K < EXT_MEM_K) {
-                        mem_size = EXT_MEM_K;
-                        who = "BIOS-88";
-                } else {
-                        mem_size = ALT_MEM_K;
-                        who = "BIOS-e801";
-                }
-
-                e820.nr_map = 0;
-                add_memory_region(0, LOWMEMSIZE(), E820_RAM);
-                add_memory_region(HIGH_MEMORY, mem_size << 10, E820_RAM);
-        }
-        return who;
-}
diff --git a/include/asm-i386/setup.h b/include/asm-i386/setup.h
index ee941457b55d..f737e423029e 100644
--- a/include/asm-i386/setup.h
+++ b/include/asm-i386/setup.h
@@ -59,6 +59,21 @@ extern unsigned char boot_params[PARAM_SIZE];
 #define EDD_MBR_SIGNATURE ((unsigned int *) (PARAM+EDD_MBR_SIG_BUF))
 #define EDD_BUF     ((struct edd_info *) (PARAM+EDDBUF))
 
+/*
+ * Do NOT EVER look at the BIOS memory size location.
+ * It does not work on many machines.
+ */
+#define LOWMEMSIZE()    (0x9f000)
+
+struct e820entry;
+
+char * __init machine_specific_memory_setup(void);
+
+int __init copy_e820_map(struct e820entry * biosmap, int nr_map);
+int __init sanitize_e820_map(struct e820entry * biosmap, char * pnr_map);
+void __init add_memory_region(unsigned long long start,
+                              unsigned long long size, int type);
+
 #endif /* __ASSEMBLY__ */
 
 #endif /* _i386_SETUP_H */
diff --git a/include/asm-i386/uaccess.h b/include/asm-i386/uaccess.h
index 8462f8e0e658..54d905ebc63d 100644
--- a/include/asm-i386/uaccess.h
+++ b/include/asm-i386/uaccess.h
@@ -390,8 +390,12 @@ unsigned long __must_check __copy_to_user_ll(void __user *to,
                                 const void *from, unsigned long n);
 unsigned long __must_check __copy_from_user_ll(void *to,
                                 const void __user *from, unsigned long n);
+unsigned long __must_check __copy_from_user_ll_nozero(void *to,
+                                const void __user *from, unsigned long n);
 unsigned long __must_check __copy_from_user_ll_nocache(void *to,
                                 const void __user *from, unsigned long n);
+unsigned long __must_check __copy_from_user_ll_nocache_nozero(void *to,
+                                const void __user *from, unsigned long n);
 
 /*
  * Here we special-case 1, 2 and 4-byte copy_*_user invocations.  On a fault
@@ -458,10 +462,41 @@ __copy_to_user(void __user *to, const void *from, unsigned long n)
  *
  * If some data could not be copied, this function will pad the copied
  * data to the requested size using zero bytes.
+ *
+ * An alternate version - __copy_from_user_inatomic() - may be called from
+ * atomic context and will fail rather than sleep.  In this case the
+ * uncopied bytes will *NOT* be padded with zeros.  See fs/filemap.h
+ * for explanation of why this is needed.
  */
 static __always_inline unsigned long
 __copy_from_user_inatomic(void *to, const void __user *from, unsigned long n)
 {
+        /* Avoid zeroing the tail if the copy fails..
+         * If 'n' is constant and 1, 2, or 4, we do still zero on a failure,
+         * but as the zeroing behaviour is only significant when n is not
+         * constant, that shouldn't be a problem.
+         */
+        if (__builtin_constant_p(n)) {
+                unsigned long ret;
+
+                switch (n) {
+                case 1:
+                        __get_user_size(*(u8 *)to, from, 1, ret, 1);
+                        return ret;
+                case 2:
+                        __get_user_size(*(u16 *)to, from, 2, ret, 2);
+                        return ret;
+                case 4:
+                        __get_user_size(*(u32 *)to, from, 4, ret, 4);
+                        return ret;
+                }
+        }
+        return __copy_from_user_ll_nozero(to, from, n);
+}
+static __always_inline unsigned long
+__copy_from_user(void *to, const void __user *from, unsigned long n)
+{
+        might_sleep();
         if (__builtin_constant_p(n)) {
                 unsigned long ret;
 
@@ -482,9 +517,10 @@ __copy_from_user_inatomic(void *to, const void __user *from, unsigned long n)
 
 #define ARCH_HAS_NOCACHE_UACCESS
 
-static __always_inline unsigned long __copy_from_user_inatomic_nocache(void *to,
+static __always_inline unsigned long __copy_from_user_nocache(void *to,
                                 const void __user *from, unsigned long n)
 {
+        might_sleep();
         if (__builtin_constant_p(n)) {
                 unsigned long ret;
 
@@ -504,17 +540,9 @@ static __always_inline unsigned long __copy_from_user_inatomic_nocache(void *to,
 }
 
 static __always_inline unsigned long
-__copy_from_user(void *to, const void __user *from, unsigned long n)
+__copy_from_user_inatomic_nocache(void *to, const void __user *from, unsigned long n)
 {
-       might_sleep();
-       return __copy_from_user_inatomic(to, from, n);
-}
-
-static __always_inline unsigned long
-__copy_from_user_nocache(void *to, const void __user *from, unsigned long n)
-{
-       might_sleep();
-       return __copy_from_user_inatomic_nocache(to, from, n);
+       return __copy_from_user_ll_nocache_nozero(to, from, n);
 }
 
 unsigned long __must_check copy_to_user(void __user *to,
diff --git a/include/asm-ia64/percpu.h b/include/asm-ia64/percpu.h
index ae357d504fba..24d898b650c5 100644
--- a/include/asm-ia64/percpu.h
+++ b/include/asm-ia64/percpu.h
@@ -42,6 +42,7 @@ DECLARE_PER_CPU(unsigned long, local_per_cpu_offset);
 
 #define per_cpu(var, cpu)  (*RELOC_HIDE(&per_cpu__##var, __per_cpu_offset[cpu]))
 #define __get_cpu_var(var) (*RELOC_HIDE(&per_cpu__##var, __ia64_per_cpu_var(local_per_cpu_offset)))
+#define __raw_get_cpu_var(var) (*RELOC_HIDE(&per_cpu__##var, __ia64_per_cpu_var(local_per_cpu_offset)))
 
 extern void percpu_modcopy(void *pcpudst, const void *src, unsigned long size);
 extern void setup_per_cpu_areas (void);
@@ -51,6 +52,7 @@ extern void *per_cpu_init(void);
 
 #define per_cpu(var, cpu)                       (*((void)(cpu), &per_cpu__##var))
 #define __get_cpu_var(var)                      per_cpu__##var
+#define __raw_get_cpu_var(var)                  per_cpu__##var
 #define per_cpu_init()                          (__phys_per_cpu_start)
 
 #endif  /* SMP */
diff --git a/include/asm-m68k/amigaints.h b/include/asm-m68k/amigaints.h
index aa968d014bb6..7c8713468fd2 100644
--- a/include/asm-m68k/amigaints.h
+++ b/include/asm-m68k/amigaints.h
@@ -13,6 +13,8 @@
 #ifndef _ASMm68k_AMIGAINTS_H_
 #define _ASMm68k_AMIGAINTS_H_
 
+#include <asm/irq.h>
+
 /*
 ** Amiga Interrupt sources.
 **
@@ -23,72 +25,52 @@
 #define CIA_IRQS            (5)
 #define AMI_IRQS            (32) /* AUTO_IRQS+AMI_STD_IRQS+2*CIA_IRQS */
 
-/* vertical blanking interrupt */
-#define IRQ_AMIGA_VERTB     0
+/* builtin serial port interrupts */
+#define IRQ_AMIGA_TBE           (IRQ_USER+0)
+#define IRQ_AMIGA_RBF           (IRQ_USER+11)
 
-/* copper interrupt */
-#define IRQ_AMIGA_COPPER    1
+/* floppy disk interrupts */
+#define IRQ_AMIGA_DSKBLK        (IRQ_USER+1)
+#define IRQ_AMIGA_DSKSYN        (IRQ_USER+12)
 
-/* Audio interrupts */
-#define IRQ_AMIGA_AUD0      2
-#define IRQ_AMIGA_AUD1      3
-#define IRQ_AMIGA_AUD2      4
-#define IRQ_AMIGA_AUD3      5
+/* software interrupts */
+#define IRQ_AMIGA_SOFT          (IRQ_USER+2)
 
-/* Blitter done interrupt */
-#define IRQ_AMIGA_BLIT      6
+/* interrupts from external hardware */
+#define IRQ_AMIGA_PORTS         IRQ_AUTO_2
+#define IRQ_AMIGA_EXTER         IRQ_AUTO_6
 
-/* floppy disk interrupts */
-#define IRQ_AMIGA_DSKSYN    7
-#define IRQ_AMIGA_DSKBLK    8
+/* copper interrupt */
+#define IRQ_AMIGA_COPPER        (IRQ_USER+4)
 
-/* builtin serial port interrupts */
-#define IRQ_AMIGA_RBF       9
-#define IRQ_AMIGA_TBE       10
+/* vertical blanking interrupt */
+#define IRQ_AMIGA_VERTB         (IRQ_USER+5)
 
-/* software interrupts */
-#define IRQ_AMIGA_SOFT      11
+/* Blitter done interrupt */
+#define IRQ_AMIGA_BLIT          (IRQ_USER+6)
 
-/* interrupts from external hardware */
-#define IRQ_AMIGA_PORTS     12
-#define IRQ_AMIGA_EXTER     13
+/* Audio interrupts */
+#define IRQ_AMIGA_AUD0          (IRQ_USER+7)
+#define IRQ_AMIGA_AUD1          (IRQ_USER+8)
+#define IRQ_AMIGA_AUD2          (IRQ_USER+9)
+#define IRQ_AMIGA_AUD3          (IRQ_USER+10)
 
 /* CIA interrupt sources */
-#define IRQ_AMIGA_CIAA      14
-#define IRQ_AMIGA_CIAA_TA   14
-#define IRQ_AMIGA_CIAA_TB   15
-#define IRQ_AMIGA_CIAA_ALRM 16
-#define IRQ_AMIGA_CIAA_SP   17
-#define IRQ_AMIGA_CIAA_FLG  18
-#define IRQ_AMIGA_CIAB      19
-#define IRQ_AMIGA_CIAB_TA   19
-#define IRQ_AMIGA_CIAB_TB   20
-#define IRQ_AMIGA_CIAB_ALRM 21
-#define IRQ_AMIGA_CIAB_SP   22
-#define IRQ_AMIGA_CIAB_FLG  23
-
-/* auto-vector interrupts */
-#define IRQ_AMIGA_AUTO      24
-#define IRQ_AMIGA_AUTO_0    24 /* This is just a dummy */
-#define IRQ_AMIGA_AUTO_1    25
-#define IRQ_AMIGA_AUTO_2    26
-#define IRQ_AMIGA_AUTO_3    27
-#define IRQ_AMIGA_AUTO_4    28
-#define IRQ_AMIGA_AUTO_5    29
-#define IRQ_AMIGA_AUTO_6    30
-#define IRQ_AMIGA_AUTO_7    31
-
-#define IRQ_FLOPPY          IRQ_AMIGA_DSKBLK
+#define IRQ_AMIGA_CIAA          (IRQ_USER+14)
+#define IRQ_AMIGA_CIAA_TA       (IRQ_USER+14)
+#define IRQ_AMIGA_CIAA_TB       (IRQ_USER+15)
+#define IRQ_AMIGA_CIAA_ALRM     (IRQ_USER+16)
+#define IRQ_AMIGA_CIAA_SP       (IRQ_USER+17)
+#define IRQ_AMIGA_CIAA_FLG      (IRQ_USER+18)
+#define IRQ_AMIGA_CIAB          (IRQ_USER+19)
+#define IRQ_AMIGA_CIAB_TA       (IRQ_USER+19)
+#define IRQ_AMIGA_CIAB_TB       (IRQ_USER+20)
+#define IRQ_AMIGA_CIAB_ALRM     (IRQ_USER+21)
+#define IRQ_AMIGA_CIAB_SP       (IRQ_USER+22)
+#define IRQ_AMIGA_CIAB_FLG      (IRQ_USER+23)
 
-/* INTREQR masks */
-#define IRQ1_MASK   0x0007      /* INTREQR mask for IRQ 1 */
-#define IRQ2_MASK   0x0008      /* INTREQR mask for IRQ 2 */
-#define IRQ3_MASK   0x0070      /* INTREQR mask for IRQ 3 */
-#define IRQ4_MASK   0x0780      /* INTREQR mask for IRQ 4 */
-#define IRQ5_MASK   0x1800      /* INTREQR mask for IRQ 5 */
-#define IRQ6_MASK   0x2000      /* INTREQR mask for IRQ 6 */
-#define IRQ7_MASK   0x4000      /* INTREQR mask for IRQ 7 */
 
+/* INTREQR masks */
 #define IF_SETCLR   0x8000      /* set/clr bit */
 #define IF_INTEN    0x4000      /* master interrupt bit in INT* registers */
 #define IF_EXTER    0x2000      /* external level 6 and CIA B interrupt */
@@ -106,9 +88,6 @@
 #define IF_DSKBLK   0x0002      /* diskblock DMA finished */
 #define IF_TBE      0x0001      /* serial transmit buffer empty interrupt */
 
-extern void amiga_do_irq(int irq, struct pt_regs *fp);
-extern void amiga_do_irq_list(int irq, struct pt_regs *fp);
-
 /* CIA interrupt control register bits */
 
 #define CIA_ICR_TA      0x01
@@ -125,6 +104,7 @@ extern void amiga_do_irq_list(int irq, struct pt_regs *fp);
 
 extern struct ciabase ciaa_base, ciab_base;
 
+extern void cia_init_IRQ(struct ciabase *base);
 extern unsigned char cia_set_irq(struct ciabase *base, unsigned char mask);
 extern unsigned char cia_able_irq(struct ciabase *base, unsigned char mask);
 
diff --git a/include/asm-m68k/apollohw.h b/include/asm-m68k/apollohw.h
index 4304e1c33e17..a1373b9aa281 100644
--- a/include/asm-m68k/apollohw.h
+++ b/include/asm-m68k/apollohw.h
@@ -3,6 +3,8 @@
 #ifndef _ASMm68k_APOLLOHW_H_
 #define _ASMm68k_APOLLOHW_H_
 
+#include <linux/types.h>
+
 /*
    apollo models
 */
@@ -101,4 +103,6 @@ extern u_long timer_physaddr;
 
 #define isaIO2mem(x) (((((x) & 0x3f8)  << 7) | (((x) & 0xfc00) >> 6) | ((x) & 0x7)) + 0x40000 + IO_BASE)
 
+#define IRQ_APOLLO      IRQ_USER
+
 #endif
diff --git a/include/asm-m68k/atari_stdma.h b/include/asm-m68k/atari_stdma.h
index 64f92880ce43..b4eadf852738 100644
--- a/include/asm-m68k/atari_stdma.h
+++ b/include/asm-m68k/atari_stdma.h
@@ -3,7 +3,7 @@
 #define _atari_stdma_h
 
 
-#include <asm/irq.h>
+#include <linux/interrupt.h>
 
 
 /***************************** Prototypes *****************************/
diff --git a/include/asm-m68k/atariints.h b/include/asm-m68k/atariints.h
index 42952c890593..0ed454fc24bb 100644
--- a/include/asm-m68k/atariints.h
+++ b/include/asm-m68k/atariints.h
@@ -45,17 +45,6 @@
 #define IRQ_TYPE_FAST     1
 #define IRQ_TYPE_PRIO     2
 
-#define IRQ_SPURIOUS      (0)
-
-/* auto-vector interrupts */
-#define IRQ_AUTO_1        (1)
-#define IRQ_AUTO_2        (2)
-#define IRQ_AUTO_3        (3)
-#define IRQ_AUTO_4        (4)
-#define IRQ_AUTO_5        (5)
-#define IRQ_AUTO_6        (6)
-#define IRQ_AUTO_7        (7)
-
 /* ST-MFP interrupts */
 #define IRQ_MFP_BUSY      (8)
 #define IRQ_MFP_DCD       (9)
diff --git a/include/asm-m68k/bvme6000hw.h b/include/asm-m68k/bvme6000hw.h
index 28a859b03959..f40d2f8510ee 100644
--- a/include/asm-m68k/bvme6000hw.h
+++ b/include/asm-m68k/bvme6000hw.h
@@ -109,23 +109,23 @@ typedef struct {
 
 #define BVME_IRQ_TYPE_PRIO      0
 
-#define BVME_IRQ_PRN            0x54
-#define BVME_IRQ_I596           0x1a
-#define BVME_IRQ_SCSI           0x1b
-#define BVME_IRQ_TIMER          0x59
-#define BVME_IRQ_RTC            0x1e
-#define BVME_IRQ_ABORT          0x1f
+#define BVME_IRQ_PRN            (IRQ_USER+20)
+#define BVME_IRQ_TIMER          (IRQ_USER+25)
+#define BVME_IRQ_I596           IRQ_AUTO_2
+#define BVME_IRQ_SCSI           IRQ_AUTO_3
+#define BVME_IRQ_RTC            IRQ_AUTO_6
+#define BVME_IRQ_ABORT          IRQ_AUTO_7
 
 /* SCC interrupts */
-#define BVME_IRQ_SCC_BASE               0x40
-#define BVME_IRQ_SCCB_TX                0x40
-#define BVME_IRQ_SCCB_STAT              0x42
-#define BVME_IRQ_SCCB_RX                0x44
-#define BVME_IRQ_SCCB_SPCOND            0x46
-#define BVME_IRQ_SCCA_TX                0x48
-#define BVME_IRQ_SCCA_STAT              0x4a
-#define BVME_IRQ_SCCA_RX                0x4c
-#define BVME_IRQ_SCCA_SPCOND            0x4e
+#define BVME_IRQ_SCC_BASE               IRQ_USER
+#define BVME_IRQ_SCCB_TX                IRQ_USER
+#define BVME_IRQ_SCCB_STAT              (IRQ_USER+2)
+#define BVME_IRQ_SCCB_RX                (IRQ_USER+4)
+#define BVME_IRQ_SCCB_SPCOND            (IRQ_USER+6)
+#define BVME_IRQ_SCCA_TX                (IRQ_USER+8)
+#define BVME_IRQ_SCCA_STAT              (IRQ_USER+10)
+#define BVME_IRQ_SCCA_RX                (IRQ_USER+12)
+#define BVME_IRQ_SCCA_SPCOND            (IRQ_USER+14)
 
 /* Address control registers */
 
diff --git a/include/asm-m68k/cacheflush.h b/include/asm-m68k/cacheflush.h
index 8aba971b1368..24d3ff449135 100644
--- a/include/asm-m68k/cacheflush.h
+++ b/include/asm-m68k/cacheflush.h
@@ -3,26 +3,30 @@
 
 #include <linux/mm.h>
 
+/* cache code */
+#define FLUSH_I_AND_D   (0x00000808)
+#define FLUSH_I         (0x00000008)
+
 /*
  * Cache handling functions
  */
 
-#define flush_icache()                                          \
-({                                                              \
-        if (CPU_IS_040_OR_060)                                  \
-                __asm__ __volatile__("nop\n\t"                  \
-                                     ".chip 68040\n\t"          \
-                                     "cinva %%ic\n\t"           \
-                                     ".chip 68k" : );           \
-        else {                                                  \
-                unsigned long _tmp;                             \
-                __asm__ __volatile__("movec %%cacr,%0\n\t"      \
-                                     "orw %1,%0\n\t"            \
-                                     "movec %0,%%cacr"          \
-                                     : "=&d" (_tmp)             \
-                                     : "id" (FLUSH_I)); \
-        }                                                       \
-})
+static inline void flush_icache(void)
+{
+        if (CPU_IS_040_OR_060)
+                asm volatile (  "nop\n"
+                        "       .chip   68040\n"
+                        "       cpusha  %bc\n"
+                        "       .chip   68k");
+        else {
+                unsigned long tmp;
+                asm volatile (  "movec  %%cacr,%0\n"
+                        "       or.w    %1,%0\n"
+                        "       movec   %0,%%cacr"
+                        : "=&d" (tmp)
+                        : "id" (FLUSH_I));
+        }
+}
 
 /*
  * invalidate the cache for the specified memory range.
@@ -43,10 +47,6 @@ extern void cache_push(unsigned long paddr, int len);
  */
 extern void cache_push_v(unsigned long vaddr, int len);
 
-/* cache code */
-#define FLUSH_I_AND_D   (0x00000808)
-#define FLUSH_I         (0x00000008)
-
 /* This is needed whenever the virtual mapping of the current
    process changes.  */
 #define __flush_cache_all()                                     \
diff --git a/include/asm-m68k/dma-mapping.h b/include/asm-m68k/dma-mapping.h
index dffd59cf1364..cebbb03370ec 100644
--- a/include/asm-m68k/dma-mapping.h
+++ b/include/asm-m68k/dma-mapping.h
@@ -1,11 +1,91 @@
 #ifndef _M68K_DMA_MAPPING_H
 #define _M68K_DMA_MAPPING_H
 
+#include <asm/cache.h>
 
-#ifdef CONFIG_PCI
-#include <asm-generic/dma-mapping.h>
-#else
-#include <asm-generic/dma-mapping-broken.h>
-#endif
+struct scatterlist;
+
+static inline int dma_supported(struct device *dev, u64 mask)
+{
+        return 1;
+}
+
+static inline int dma_set_mask(struct device *dev, u64 mask)
+{
+        return 0;
+}
+
+static inline int dma_get_cache_alignment(void)
+{
+        return 1 << L1_CACHE_SHIFT;
+}
+
+static inline int dma_is_consistent(dma_addr_t dma_addr)
+{
+        return 0;
+}
+
+extern void *dma_alloc_coherent(struct device *, size_t,
+                                dma_addr_t *, int);
+extern void dma_free_coherent(struct device *, size_t,
+                              void *, dma_addr_t);
+
+static inline void *dma_alloc_noncoherent(struct device *dev, size_t size,
+                                          dma_addr_t *handle, int flag)
+{
+        return dma_alloc_coherent(dev, size, handle, flag);
+}
+static inline void dma_free_noncoherent(struct device *dev, size_t size,
+                                        void *addr, dma_addr_t handle)
+{
+        dma_free_coherent(dev, size, addr, handle);
+}
+static inline void dma_cache_sync(void *vaddr, size_t size,
+                                  enum dma_data_direction dir)
+{
+        /* we use coherent allocation, so not much to do here. */
+}
+
+extern dma_addr_t dma_map_single(struct device *, void *, size_t,
+                                 enum dma_data_direction);
+static inline void dma_unmap_single(struct device *dev, dma_addr_t addr,
+                                    size_t size, enum dma_data_direction dir)
+{
+}
+
+extern dma_addr_t dma_map_page(struct device *, struct page *,
+                               unsigned long, size_t size,
+                               enum dma_data_direction);
+static inline void dma_unmap_page(struct device *dev, dma_addr_t address,
+                                  size_t size, enum dma_data_direction dir)
+{
+}
+
+extern int dma_map_sg(struct device *, struct scatterlist *, int,
+                      enum dma_data_direction);
+static inline void dma_unmap_sg(struct device *dev, struct scatterlist *sg,
+                                int nhwentries, enum dma_data_direction dir)
+{
+}
+
+extern void dma_sync_single_for_device(struct device *, dma_addr_t, size_t,
+                                       enum dma_data_direction);
+extern void dma_sync_sg_for_device(struct device *, struct scatterlist *, int,
+                                   enum dma_data_direction);
+
+static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t handle,
+                                           size_t size, enum dma_data_direction dir)
+{
+}
+
+static inline void dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
+                                       int nents, enum dma_data_direction dir)
+{
+}
+
+static inline int dma_mapping_error(dma_addr_t handle)
+{
+        return 0;
+}
 
 #endif  /* _M68K_DMA_MAPPING_H */
diff --git a/include/asm-m68k/irq.h b/include/asm-m68k/irq.h
index 9727ca9d9f26..f4ae7d8feac6 100644
--- a/include/asm-m68k/irq.h
+++ b/include/asm-m68k/irq.h
@@ -1,13 +1,9 @@
 #ifndef _M68K_IRQ_H_
 #define _M68K_IRQ_H_
 
-#include <linux/interrupt.h>
-
-/*
- * # of m68k interrupts
- */
-
-#define SYS_IRQS 8
+#include <linux/linkage.h>
+#include <linux/hardirq.h>
+#include <linux/spinlock_types.h>
 
 /*
  * This should be the same as the max(NUM_X_SOURCES) for all the
@@ -15,10 +11,20 @@
  * Currently the Atari has 72 and the Amiga 24, but if both are
  * supported in the kernel it is better to make room for 72.
  */
-#if defined(CONFIG_ATARI) || defined(CONFIG_MAC)
-#define NR_IRQS (72+SYS_IRQS)
+#if defined(CONFIG_VME) || defined(CONFIG_SUN3) || defined(CONFIG_SUN3X)
+#define NR_IRQS 200
+#elif defined(CONFIG_ATARI) || defined(CONFIG_MAC)
+#define NR_IRQS 72
+#elif defined(CONFIG_Q40)
+#define NR_IRQS 43
+#elif defined(CONFIG_AMIGA)
+#define NR_IRQS 32
+#elif defined(CONFIG_APOLLO)
+#define NR_IRQS 24
+#elif defined(CONFIG_HP300)
+#define NR_IRQS 8
 #else
-#define NR_IRQS (24+SYS_IRQS)
+#error unknown nr of irqs
 #endif
 
 /*
@@ -40,53 +46,25 @@
  * that routine requires service.
  */
 
-#define IRQ1            (1)     /* level 1 interrupt */
-#define IRQ2            (2)     /* level 2 interrupt */
-#define IRQ3            (3)     /* level 3 interrupt */
-#define IRQ4            (4)     /* level 4 interrupt */
-#define IRQ5            (5)     /* level 5 interrupt */
-#define IRQ6            (6)     /* level 6 interrupt */
-#define IRQ7            (7)     /* level 7 interrupt (non-maskable) */
+#define IRQ_SPURIOUS    0
 
-/*
- * "Generic" interrupt sources
- */
-
-#define IRQ_SCHED_TIMER (8)    /* interrupt source for scheduling timer */
+#define IRQ_AUTO_1      1       /* level 1 interrupt */
+#define IRQ_AUTO_2      2       /* level 2 interrupt */
+#define IRQ_AUTO_3      3       /* level 3 interrupt */
+#define IRQ_AUTO_4      4       /* level 4 interrupt */
+#define IRQ_AUTO_5      5       /* level 5 interrupt */
+#define IRQ_AUTO_6      6       /* level 6 interrupt */
+#define IRQ_AUTO_7      7       /* level 7 interrupt (non-maskable) */
 
-static __inline__ int irq_canonicalize(int irq)
-{
-        return irq;
-}
-
-/*
- * Machine specific interrupt sources.
- *
- * Adding an interrupt service routine for a source with this bit
- * set indicates a special machine specific interrupt source.
- * The machine specific files define these sources.
- *
- * The IRQ_MACHSPEC bit is now gone - the only thing it did was to
- * introduce unnecessary overhead.
- *
- * All interrupt handling is actually machine specific so it is better
- * to use function pointers, as used by the Sparc port, and select the
- * interrupt handling functions when initializing the kernel. This way
- * we save some unnecessary overhead at run-time.
- *                                                      01/11/97 - Jes
- */
+#define IRQ_USER        8
 
-extern void (*enable_irq)(unsigned int);
-extern void (*disable_irq)(unsigned int);
+extern unsigned int irq_canonicalize(unsigned int irq);
+extern void enable_irq(unsigned int);
+extern void disable_irq(unsigned int);
 #define disable_irq_nosync      disable_irq
 
 struct pt_regs;
 
-extern int cpu_request_irq(unsigned int,
-                           irqreturn_t (*)(int, void *, struct pt_regs *),
-                           unsigned long, const char *, void *);
-extern void cpu_free_irq(unsigned int, void *);
-
 /*
  * various flags for request_irq() - the Amiga now uses the standard
  * mechanism like all other architectures - SA_INTERRUPT and SA_SHIRQ
@@ -105,29 +83,45 @@ extern void cpu_free_irq(unsigned int, void *);
  * interrupt source (if it supports chaining).
  */
 typedef struct irq_node {
-        irqreturn_t     (*handler)(int, void *, struct pt_regs *);
-        unsigned long   flags;
+        int             (*handler)(int, void *, struct pt_regs *);
         void            *dev_id;
-        const char      *devname;
         struct irq_node *next;
+        unsigned long   flags;
+        const char      *devname;
 } irq_node_t;
 
 /*
  * This structure has only 4 elements for speed reasons
  */
 typedef struct irq_handler {
-        irqreturn_t     (*handler)(int, void *, struct pt_regs *);
+        int             (*handler)(int, void *, struct pt_regs *);
         unsigned long   flags;
         void            *dev_id;
         const char      *devname;
 } irq_handler_t;
 
-/* count of spurious interrupts */
-extern volatile unsigned int num_spurious;
+struct irq_controller {
+        const char *name;
+        spinlock_t lock;
+        int (*startup)(unsigned int irq);
+        void (*shutdown)(unsigned int irq);
+        void (*enable)(unsigned int irq);
+        void (*disable)(unsigned int irq);
+};
+
+extern int m68k_irq_startup(unsigned int);
+extern void m68k_irq_shutdown(unsigned int);
 
 /*
  * This function returns a new irq_node_t
  */
 extern irq_node_t *new_irq_node(void);
 
+extern void m68k_setup_auto_interrupt(void (*handler)(unsigned int, struct pt_regs *));
+extern void m68k_setup_user_interrupt(unsigned int vec, unsigned int cnt,
+                                      void (*handler)(unsigned int, struct pt_regs *));
+extern void m68k_setup_irq_controller(struct irq_controller *, unsigned int, unsigned int);
+
+asmlinkage void m68k_handle_int(unsigned int, struct pt_regs *);
+
 #endif /* _M68K_IRQ_H_ */
diff --git a/include/asm-m68k/mac_oss.h b/include/asm-m68k/mac_oss.h
index 7644a639cd6c..7221f7251934 100644
--- a/include/asm-m68k/mac_oss.h
+++ b/include/asm-m68k/mac_oss.h
@@ -69,12 +69,12 @@
 
 #define OSS_IRQLEV_DISABLED     0
 #define OSS_IRQLEV_IOPISM       1       /* ADB? */
-#define OSS_IRQLEV_SCSI         2
-#define OSS_IRQLEV_NUBUS        3       /* keep this on its own level */
-#define OSS_IRQLEV_IOPSCC       4       /* matches VIA alternate mapping */
-#define OSS_IRQLEV_SOUND        5       /* matches VIA alternate mapping */
+#define OSS_IRQLEV_SCSI         IRQ_AUTO_2
+#define OSS_IRQLEV_NUBUS        IRQ_AUTO_3      /* keep this on its own level */
+#define OSS_IRQLEV_IOPSCC       IRQ_AUTO_4      /* matches VIA alternate mapping */
+#define OSS_IRQLEV_SOUND        IRQ_AUTO_5      /* matches VIA alternate mapping */
 #define OSS_IRQLEV_60HZ         6       /* matches VIA alternate mapping */
-#define OSS_IRQLEV_VIA1         6       /* matches VIA alternate mapping */
+#define OSS_IRQLEV_VIA1         IRQ_AUTO_6      /* matches VIA alternate mapping */
 #define OSS_IRQLEV_PARITY       7       /* matches VIA alternate mapping */
 
 #ifndef __ASSEMBLY__
diff --git a/include/asm-m68k/machdep.h b/include/asm-m68k/machdep.h
index 7d3fee342369..df898f27e434 100644
--- a/include/asm-m68k/machdep.h
+++ b/include/asm-m68k/machdep.h
@@ -13,14 +13,8 @@ struct buffer_head;
 extern void (*mach_sched_init) (irqreturn_t (*handler)(int, void *, struct pt_regs *));
 /* machine dependent irq functions */
 extern void (*mach_init_IRQ) (void);
-extern irqreturn_t (*(*mach_default_handler)[]) (int, void *, struct pt_regs *);
-extern int (*mach_request_irq) (unsigned int irq, irqreturn_t (*handler)(int, void *, struct pt_regs *),
-                                unsigned long flags, const char *devname, void *dev_id);
-extern void (*mach_free_irq) (unsigned int irq, void *dev_id);
 extern void (*mach_get_model) (char *model);
 extern int (*mach_get_hardware_list) (char *buffer);
-extern int (*mach_get_irq_list) (struct seq_file *p, void *v);
-extern irqreturn_t (*mach_process_int) (int irq, struct pt_regs *fp);
 /* machine dependent timer functions */
 extern unsigned long (*mach_gettimeoffset)(void);
 extern int (*mach_hwclk)(int, struct rtc_time*);
diff --git a/include/asm-m68k/macintosh.h b/include/asm-m68k/macintosh.h
index 6fc3d19512d1..27d11da2b479 100644
--- a/include/asm-m68k/macintosh.h
+++ b/include/asm-m68k/macintosh.h
@@ -11,17 +11,7 @@
 extern void mac_reset(void);
 extern void mac_poweroff(void);
 extern void mac_init_IRQ(void);
-extern int mac_request_irq (unsigned int, irqreturn_t (*)(int, void *,
-                                struct pt_regs *),
-                                unsigned long, const char *, void *);
-extern void mac_free_irq(unsigned int, void *);
-extern void mac_enable_irq(unsigned int);
-extern void mac_disable_irq(unsigned int);
 extern int mac_irq_pending(unsigned int);
-extern int show_mac_interrupts(struct seq_file *, void *);
-#if 0
-extern void mac_default_handler(int irq);
-#endif
 extern void mac_identify(void);
 extern void mac_report_hardware(void);
 extern void mac_debugging_penguin(int);
diff --git a/include/asm-m68k/macints.h b/include/asm-m68k/macints.h
index fd8c3a9fea4d..679c48ab4407 100644
--- a/include/asm-m68k/macints.h
+++ b/include/asm-m68k/macints.h
@@ -59,17 +59,6 @@
 #define IRQ_SRC(irq)    (irq >> 3)
 #define IRQ_IDX(irq)    (irq & 7)
 
-#define IRQ_SPURIOUS      (0)
-
-/* auto-vector interrupts */
-#define IRQ_AUTO_1        (1)
-#define IRQ_AUTO_2        (2)
-#define IRQ_AUTO_3        (3)
-#define IRQ_AUTO_4        (4)
-#define IRQ_AUTO_5        (5)
-#define IRQ_AUTO_6        (6)
-#define IRQ_AUTO_7        (7)
-
 /* VIA1 interrupts */
 #define IRQ_VIA1_0        (8)           /* one second int. */
 #define IRQ_VIA1_1        (9)           /* VBlank int. */
@@ -163,7 +152,4 @@
 #define INT_CLK   24576     /* CLK while int_clk =2.456MHz and divide = 100 */
 #define INT_TICKS 246       /* to make sched_time = 99.902... HZ */
 
-extern irq_node_t *mac_irq_list[NUM_MAC_SOURCES];
-extern void mac_do_irq_list(int irq, struct pt_regs *);
-
 #endif /* asm/macints.h */
diff --git a/include/asm-m68k/mvme147hw.h b/include/asm-m68k/mvme147hw.h
index f245139f3671..b81043108472 100644
--- a/include/asm-m68k/mvme147hw.h
+++ b/include/asm-m68k/mvme147hw.h
@@ -1,6 +1,8 @@
 #ifndef _MVME147HW_H_
 #define _MVME147HW_H_
 
+#include <asm/irq.h>
+
 typedef struct {
         unsigned char
                 ctrl,
@@ -72,39 +74,39 @@ struct pcc_regs {
 #define PCC_LEVEL_SCSI_PORT     0x04
 #define PCC_LEVEL_SCSI_DMA      0x04
 
-#define PCC_IRQ_AC_FAIL         0x40
-#define PCC_IRQ_BERR            0x41
-#define PCC_IRQ_ABORT           0x42
-/* #define PCC_IRQ_SERIAL       0x43 */
-#define PCC_IRQ_PRINTER         0x47
-#define PCC_IRQ_TIMER1          0x48
-#define PCC_IRQ_TIMER2          0x49
-#define PCC_IRQ_SOFTWARE1       0x4a
-#define PCC_IRQ_SOFTWARE2       0x4b
+#define PCC_IRQ_AC_FAIL         (IRQ_USER+0)
+#define PCC_IRQ_BERR            (IRQ_USER+1)
+#define PCC_IRQ_ABORT           (IRQ_USER+2)
+/* #define PCC_IRQ_SERIAL       (IRQ_USER+3) */
+#define PCC_IRQ_PRINTER         (IRQ_USER+7)
+#define PCC_IRQ_TIMER1          (IRQ_USER+8)
+#define PCC_IRQ_TIMER2          (IRQ_USER+9)
+#define PCC_IRQ_SOFTWARE1       (IRQ_USER+10)
+#define PCC_IRQ_SOFTWARE2       (IRQ_USER+11)
 
 
 #define M147_SCC_A_ADDR         0xfffe3002
 #define M147_SCC_B_ADDR         0xfffe3000
 #define M147_SCC_PCLK           5000000
 
-#define MVME147_IRQ_SCSI_PORT   0x45
-#define MVME147_IRQ_SCSI_DMA    0x46
+#define MVME147_IRQ_SCSI_PORT   (IRQ_USER+0x45)
+#define MVME147_IRQ_SCSI_DMA    (IRQ_USER+0x46)
 
 /* SCC interrupts, for MVME147 */
 
 #define MVME147_IRQ_TYPE_PRIO   0
-#define MVME147_IRQ_SCC_BASE            0x60
-#define MVME147_IRQ_SCCB_TX             0x60
-#define MVME147_IRQ_SCCB_STAT           0x62
-#define MVME147_IRQ_SCCB_RX             0x64
-#define MVME147_IRQ_SCCB_SPCOND         0x66
-#define MVME147_IRQ_SCCA_TX             0x68
-#define MVME147_IRQ_SCCA_STAT           0x6a
-#define MVME147_IRQ_SCCA_RX             0x6c
-#define MVME147_IRQ_SCCA_SPCOND         0x6e
+#define MVME147_IRQ_SCC_BASE            (IRQ_USER+32)
+#define MVME147_IRQ_SCCB_TX             (IRQ_USER+32)
+#define MVME147_IRQ_SCCB_STAT           (IRQ_USER+34)
+#define MVME147_IRQ_SCCB_RX             (IRQ_USER+36)
+#define MVME147_IRQ_SCCB_SPCOND         (IRQ_USER+38)
+#define MVME147_IRQ_SCCA_TX             (IRQ_USER+40)
+#define MVME147_IRQ_SCCA_STAT           (IRQ_USER+42)
+#define MVME147_IRQ_SCCA_RX             (IRQ_USER+44)
+#define MVME147_IRQ_SCCA_SPCOND         (IRQ_USER+46)
 
 #define MVME147_LANCE_BASE      0xfffe1800
-#define MVME147_LANCE_IRQ       0x44
+#define MVME147_LANCE_IRQ       (IRQ_USER+4)
 
 #define ETHERNET_ADDRESS 0xfffe0778
 
diff --git a/include/asm-m68k/mvme16xhw.h b/include/asm-m68k/mvme16xhw.h
index 5d07231d2426..6117f56653d2 100644
--- a/include/asm-m68k/mvme16xhw.h
+++ b/include/asm-m68k/mvme16xhw.h
@@ -66,28 +66,28 @@ typedef struct {
 
 #define MVME162_IRQ_TYPE_PRIO   0
 
-#define MVME167_IRQ_PRN         0x54
-#define MVME16x_IRQ_I596        0x57
-#define MVME16x_IRQ_SCSI        0x55
-#define MVME16x_IRQ_FLY         0x7f
-#define MVME167_IRQ_SER_ERR     0x5c
-#define MVME167_IRQ_SER_MODEM   0x5d
-#define MVME167_IRQ_SER_TX      0x5e
-#define MVME167_IRQ_SER_RX      0x5f
-#define MVME16x_IRQ_TIMER       0x59
-#define MVME167_IRQ_ABORT       0x6e
-#define MVME162_IRQ_ABORT       0x5e
+#define MVME167_IRQ_PRN         (IRQ_USER+20)
+#define MVME16x_IRQ_I596        (IRQ_USER+23)
+#define MVME16x_IRQ_SCSI        (IRQ_USER+21)
+#define MVME16x_IRQ_FLY         (IRQ_USER+63)
+#define MVME167_IRQ_SER_ERR     (IRQ_USER+28)
+#define MVME167_IRQ_SER_MODEM   (IRQ_USER+29)
+#define MVME167_IRQ_SER_TX      (IRQ_USER+30)
+#define MVME167_IRQ_SER_RX      (IRQ_USER+31)
+#define MVME16x_IRQ_TIMER       (IRQ_USER+25)
+#define MVME167_IRQ_ABORT       (IRQ_USER+46)
+#define MVME162_IRQ_ABORT       (IRQ_USER+30)
 
 /* SCC interrupts, for MVME162 */
-#define MVME162_IRQ_SCC_BASE            0x40
-#define MVME162_IRQ_SCCB_TX             0x40
-#define MVME162_IRQ_SCCB_STAT           0x42
-#define MVME162_IRQ_SCCB_RX             0x44
-#define MVME162_IRQ_SCCB_SPCOND         0x46
-#define MVME162_IRQ_SCCA_TX             0x48
-#define MVME162_IRQ_SCCA_STAT           0x4a
-#define MVME162_IRQ_SCCA_RX             0x4c
-#define MVME162_IRQ_SCCA_SPCOND         0x4e
+#define MVME162_IRQ_SCC_BASE            (IRQ_USER+0)
+#define MVME162_IRQ_SCCB_TX             (IRQ_USER+0)
+#define MVME162_IRQ_SCCB_STAT           (IRQ_USER+2)
+#define MVME162_IRQ_SCCB_RX             (IRQ_USER+4)
+#define MVME162_IRQ_SCCB_SPCOND         (IRQ_USER+6)
+#define MVME162_IRQ_SCCA_TX             (IRQ_USER+8)
+#define MVME162_IRQ_SCCA_STAT           (IRQ_USER+10)
+#define MVME162_IRQ_SCCA_RX             (IRQ_USER+12)
+#define MVME162_IRQ_SCCA_SPCOND         (IRQ_USER+14)
 
 /* MVME162 version register */
 
diff --git a/include/asm-m68k/scatterlist.h b/include/asm-m68k/scatterlist.h
index d7c9b5c5e6c7..8e612266da51 100644
--- a/include/asm-m68k/scatterlist.h
+++ b/include/asm-m68k/scatterlist.h
@@ -2,18 +2,17 @@
 #define _M68K_SCATTERLIST_H
 
 struct scatterlist {
-        /* These two are only valid if ADDRESS member of this
-         * struct is NULL.
-         */
         struct page *page;
         unsigned int offset;
-
         unsigned int length;
 
-        __u32 dvma_address; /* A place to hang host-specific addresses at. */
+        __u32 dma_address;      /* A place to hang host-specific addresses at. */
 };
 
 /* This is bogus and should go away. */
 #define ISA_DMA_THRESHOLD (0x00ffffff)
 
+#define sg_dma_address(sg)      ((sg)->dma_address)
+#define sg_dma_len(sg)          ((sg)->length)
+
 #endif /* !(_M68K_SCATTERLIST_H) */
diff --git a/include/asm-m68k/signal.h b/include/asm-m68k/signal.h
index b7b7ea20caab..85037a3d3e8e 100644
--- a/include/asm-m68k/signal.h
+++ b/include/asm-m68k/signal.h
@@ -156,13 +156,17 @@ typedef struct sigaltstack {
 
 static inline void sigaddset(sigset_t *set, int _sig)
 {
-        __asm__("bfset %0{%1,#1}" : "=m" (*set) : "id" ((_sig - 1) ^ 31)
+        asm ("bfset %0{%1,#1}"
+                : "+od" (*set)
+                : "id" ((_sig - 1) ^ 31)
                 : "cc");
 }
 
 static inline void sigdelset(sigset_t *set, int _sig)
 {
-        __asm__("bfclr %0{%1,#1}" : "=m"(*set) : "id"((_sig - 1) ^ 31)
+        asm ("bfclr %0{%1,#1}"
+                : "+od" (*set)
+                : "id" ((_sig - 1) ^ 31)
                 : "cc");
 }
 
@@ -175,8 +179,10 @@ static inline int __const_sigismember(sigset_t *set, int _sig)
 static inline int __gen_sigismember(sigset_t *set, int _sig)
 {
         int ret;
-        __asm__("bfextu %1{%2,#1},%0"
-                : "=d"(ret) : "m"(*set), "id"((_sig-1) ^ 31));
+        asm ("bfextu %1{%2,#1},%0"
+                : "=d" (ret)
+                : "od" (*set), "id" ((_sig-1) ^ 31)
+                : "cc");
         return ret;
 }
 
@@ -187,7 +193,10 @@ static inline int __gen_sigismember(sigset_t *set, int _sig)
 
 static inline int sigfindinword(unsigned long word)
 {
-        __asm__("bfffo %1{#0,#0},%0" : "=d"(word) : "d"(word & -word) : "cc");
+        asm ("bfffo %1{#0,#0},%0"
+                : "=d" (word)
+                : "d" (word & -word)
+                : "cc");
         return word ^ 31;
 }
 
diff --git a/include/asm-m68k/sun3ints.h b/include/asm-m68k/sun3ints.h
index bd038fccb64b..de91fa071b99 100644
--- a/include/asm-m68k/sun3ints.h
+++ b/include/asm-m68k/sun3ints.h
@@ -12,37 +12,25 @@
 #define SUN3INTS_H
 
 #include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/sched.h>
-#include <linux/kernel_stat.h>
 #include <linux/interrupt.h>
-#include <linux/seq_file.h>
-#include <asm/segment.h>
 #include <asm/intersil.h>
 #include <asm/oplib.h>
+#include <asm/traps.h>
 
 #define SUN3_INT_VECS 192
 
 void sun3_enable_irq(unsigned int irq);
 void sun3_disable_irq(unsigned int irq);
-int sun3_request_irq(unsigned int irq,
-                     irqreturn_t (*handler)(int, void *, struct pt_regs *),
-                     unsigned long flags, const char *devname, void *dev_id
-                    );
 extern void sun3_init_IRQ (void);
-extern irqreturn_t (*sun3_default_handler[]) (int, void *, struct pt_regs *);
-extern void sun3_free_irq (unsigned int irq, void *dev_id);
 extern void sun3_enable_interrupts (void);
 extern void sun3_disable_interrupts (void);
-extern int show_sun3_interrupts(struct seq_file *, void *);
-extern irqreturn_t sun3_process_int(int, struct pt_regs *);
 extern volatile unsigned char* sun3_intreg;
 
 /* master list of VME vectors -- don't fuck with this */
-#define SUN3_VEC_FLOPPY 0x40
-#define SUN3_VEC_VMESCSI0 0x40
-#define SUN3_VEC_VMESCSI1 0x41
-#define SUN3_VEC_CG 0xA8
+#define SUN3_VEC_FLOPPY         (IRQ_USER+0)
+#define SUN3_VEC_VMESCSI0       (IRQ_USER+0)
+#define SUN3_VEC_VMESCSI1       (IRQ_USER+1)
+#define SUN3_VEC_CG             (IRQ_USER+104)
 
 
 #endif /* SUN3INTS_H */
diff --git a/include/asm-m68k/traps.h b/include/asm-m68k/traps.h
index 475056191252..8caef25624c7 100644
--- a/include/asm-m68k/traps.h
+++ b/include/asm-m68k/traps.h
@@ -13,8 +13,15 @@
 
 #ifndef __ASSEMBLY__
 
+#include <linux/linkage.h>
+#include <asm/ptrace.h>
+
 typedef void (*e_vector)(void);
 
+asmlinkage void auto_inthandler(void);
+asmlinkage void user_inthandler(void);
+asmlinkage void bad_inthandler(void);
+
 extern e_vector vectors[];
 
 #endif
diff --git a/include/asm-m68k/uaccess.h b/include/asm-m68k/uaccess.h
index b761ef218cea..88b1f47400e1 100644
--- a/include/asm-m68k/uaccess.h
+++ b/include/asm-m68k/uaccess.h
@@ -181,144 +181,164 @@ asm volatile ("\n"					\
 unsigned long __generic_copy_from_user(void *to, const void __user *from, unsigned long n);
 unsigned long __generic_copy_to_user(void __user *to, const void *from, unsigned long n);
 
+#define __constant_copy_from_user_asm(res, to, from, tmp, n, s1, s2, s3)\
+        asm volatile ("\n"                                              \
+                "1:     moves."#s1"     (%2)+,%3\n"                     \
+                "       move."#s1"      %3,(%1)+\n"                     \
+                "2:     moves."#s2"     (%2)+,%3\n"                     \
+                "       move."#s2"      %3,(%1)+\n"                     \
+                "       .ifnc   \""#s3"\",\"\"\n"                       \
+                "3:     moves."#s3"     (%2)+,%3\n"                     \
+                "       move."#s3"      %3,(%1)+\n"                     \
+                "       .endif\n"                                       \
+                "4:\n"                                                  \
+                "       .section __ex_table,\"a\"\n"                    \
+                "       .align  4\n"                                    \
+                "       .long   1b,10f\n"                               \
+                "       .long   2b,20f\n"                               \
+                "       .ifnc   \""#s3"\",\"\"\n"                       \
+                "       .long   3b,30f\n"                               \
+                "       .endif\n"                                       \
+                "       .previous\n"                                    \
+                "\n"                                                    \
+                "       .section .fixup,\"ax\"\n"                       \
+                "       .even\n"                                        \
+                "10:    clr."#s1"       (%1)+\n"                        \
+                "20:    clr."#s2"       (%1)+\n"                        \
+                "       .ifnc   \""#s3"\",\"\"\n"                       \
+                "30:    clr."#s3"       (%1)+\n"                        \
+                "       .endif\n"                                       \
+                "       moveq.l #"#n",%0\n"                             \
+                "       jra     4b\n"                                   \
+                "       .previous\n"                                    \
+                : "+d" (res), "+&a" (to), "+a" (from), "=&d" (tmp)      \
+                : : "memory")
+
 static __always_inline unsigned long
 __constant_copy_from_user(void *to, const void __user *from, unsigned long n)
 {
         unsigned long res = 0, tmp;
 
-        /* limit the inlined version to 3 moves */
-        if (n == 11 || n > 12)
-                return __generic_copy_from_user(to, from, n);
-
         switch (n) {
         case 1:
                 __get_user_asm(res, *(u8 *)to, (u8 *)from, u8, b, d, 1);
-                return res;
+                break;
         case 2:
                 __get_user_asm(res, *(u16 *)to, (u16 *)from, u16, w, d, 2);
-                return res;
+                break;
+        case 3:
+                __constant_copy_from_user_asm(res, to, from, tmp, 3, w, b,);
+                break;
         case 4:
                 __get_user_asm(res, *(u32 *)to, (u32 *)from, u32, l, r, 4);
-                return res;
+                break;
+        case 5:
+                __constant_copy_from_user_asm(res, to, from, tmp, 5, l, b,);
+                break;
+        case 6:
+                __constant_copy_from_user_asm(res, to, from, tmp, 6, l, w,);
+                break;
+        case 7:
+                __constant_copy_from_user_asm(res, to, from, tmp, 7, l, w, b);
+                break;
+        case 8:
+                __constant_copy_from_user_asm(res, to, from, tmp, 8, l, l,);
+                break;
+        case 9:
+                __constant_copy_from_user_asm(res, to, from, tmp, 9, l, l, b);
+                break;
+        case 10:
+                __constant_copy_from_user_asm(res, to, from, tmp, 10, l, l, w);
+                break;
+        case 12:
+                __constant_copy_from_user_asm(res, to, from, tmp, 12, l, l, l);
+                break;
+        default:
+                /* we limit the inlined version to 3 moves */
+                return __generic_copy_from_user(to, from, n);
         }
 
-        asm volatile ("\n"
-                "       .ifndef .Lfrom_user\n"
-                "       .set    .Lfrom_user,1\n"
-                "       .macro  copy_from_user to,from,tmp\n"
-                "       .if     .Lcnt >= 4\n"
-                "1:     moves.l (\\from)+,\\tmp\n"
-                "       move.l  \\tmp,(\\to)+\n"
-                "       .set    .Lcnt,.Lcnt-4\n"
-                "       .elseif .Lcnt & 2\n"
-                "1:     moves.w (\\from)+,\\tmp\n"
-                "       move.w  \\tmp,(\\to)+\n"
-                "       .set    .Lcnt,.Lcnt-2\n"
-                "       .elseif .Lcnt & 1\n"
-                "1:     moves.b (\\from)+,\\tmp\n"
-                "       move.b  \\tmp,(\\to)+\n"
-                "       .set    .Lcnt,.Lcnt-1\n"
-                "       .else\n"
-                "       .exitm\n"
-                "       .endif\n"
-                "\n"
-                "       .section __ex_table,\"a\"\n"
-                "       .align  4\n"
-                "       .long   1b,3f\n"
-                "       .previous\n"
-                "       .endm\n"
-                "       .endif\n"
-                "\n"
-                "       .set    .Lcnt,%c4\n"
-                "       copy_from_user %1,%2,%3\n"
-                "       copy_from_user %1,%2,%3\n"
-                "       copy_from_user %1,%2,%3\n"
-                "2:\n"
-                "       .section .fixup,\"ax\"\n"
-                "       .even\n"
-                "3:     moveq.l %4,%0\n"
-                "       move.l  %5,%1\n"
-                "       .rept   %c4 / 4\n"
-                "       clr.l   (%1)+\n"
-                "       .endr\n"
-                "       .if     %c4 & 2\n"
-                "       clr.w   (%1)+\n"
-                "       .endif\n"
-                "       .if     %c4 & 1\n"
-                "       clr.b   (%1)+\n"
-                "       .endif\n"
-                "       jra     2b\n"
-                "       .previous\n"
-                : "+r" (res), "+a" (to), "+a" (from), "=&d" (tmp)
-                : "i" (n), "g" (to)
-                : "memory");
-
         return res;
 }
 
+#define __constant_copy_to_user_asm(res, to, from, tmp, n, s1, s2, s3)  \
+        asm volatile ("\n"                                              \
+                "       move."#s1"      (%2)+,%3\n"                     \
+                "11:    moves."#s1"     %3,(%1)+\n"                     \
+                "12:    move."#s2"      (%2)+,%3\n"                     \
+                "21:    moves."#s2"     %3,(%1)+\n"                     \
+                "22:\n"                                                 \
+                "       .ifnc   \""#s3"\",\"\"\n"                       \
+                "       move."#s3"      (%2)+,%3\n"                     \
+                "31:    moves."#s3"     %3,(%1)+\n"                     \
+                "32:\n"                                                 \
+                "       .endif\n"                                       \
+                "4:\n"                                                  \
+                "\n"                                                    \
+                "       .section __ex_table,\"a\"\n"                    \
+                "       .align  4\n"                                    \
+                "       .long   11b,5f\n"                               \
+                "       .long   12b,5f\n"                               \
+                "       .long   21b,5f\n"                               \
+                "       .long   22b,5f\n"                               \
+                "       .ifnc   \""#s3"\",\"\"\n"                       \
+                "       .long   31b,5f\n"                               \
+                "       .long   32b,5f\n"                               \
+                "       .endif\n"                                       \
+                "       .previous\n"                                    \
+                "\n"                                                    \
+                "       .section .fixup,\"ax\"\n"                       \
+                "       .even\n"                                        \
+                "5:     moveq.l #"#n",%0\n"                             \
+                "       jra     4b\n"                                   \
+                "       .previous\n"                                    \
+                : "+d" (res), "+a" (to), "+a" (from), "=&d" (tmp)       \
+                : : "memory")
+
 static __always_inline unsigned long
 __constant_copy_to_user(void __user *to, const void *from, unsigned long n)
 {
         unsigned long res = 0, tmp;
 
-        /* limit the inlined version to 3 moves */
-        if (n == 11 || n > 12)
-                return __generic_copy_to_user(to, from, n);
-
         switch (n) {
         case 1:
                 __put_user_asm(res, *(u8 *)from, (u8 *)to, b, d, 1);
-                return res;
+                break;
         case 2:
                 __put_user_asm(res, *(u16 *)from, (u16 *)to, w, d, 2);
-                return res;
+                break;
+        case 3:
+                __constant_copy_to_user_asm(res, to, from, tmp, 3, w, b,);
+                break;
         case 4:
                 __put_user_asm(res, *(u32 *)from, (u32 *)to, l, r, 4);
-                return res;
+                break;
+        case 5:
+                __constant_copy_to_user_asm(res, to, from, tmp, 5, l, b,);
+                break;
+        case 6:
+                __constant_copy_to_user_asm(res, to, from, tmp, 6, l, w,);
+                break;
+        case 7:
+                __constant_copy_to_user_asm(res, to, from, tmp, 7, l, w, b);
+                break;
+        case 8:
+                __constant_copy_to_user_asm(res, to, from, tmp, 8, l, l,);
+                break;
+        case 9:
+                __constant_copy_to_user_asm(res, to, from, tmp, 9, l, l, b);
+                break;
+        case 10:
+                __constant_copy_to_user_asm(res, to, from, tmp, 10, l, l, w);
+                break;
+        case 12:
+                __constant_copy_to_user_asm(res, to, from, tmp, 12, l, l, l);
+                break;
+        default:
+                /* limit the inlined version to 3 moves */
+                return __generic_copy_to_user(to, from, n);
         }
 
-        asm volatile ("\n"
-                "       .ifndef .Lto_user\n"
-                "       .set    .Lto_user,1\n"
-                "       .macro  copy_to_user to,from,tmp\n"
-                "       .if     .Lcnt >= 4\n"
-                "       move.l  (\\from)+,\\tmp\n"
-                "11:    moves.l \\tmp,(\\to)+\n"
-                "12:    .set    .Lcnt,.Lcnt-4\n"
-                "       .elseif .Lcnt & 2\n"
-                "       move.w  (\\from)+,\\tmp\n"
-                "11:    moves.w \\tmp,(\\to)+\n"
-                "12:    .set    .Lcnt,.Lcnt-2\n"
-                "       .elseif .Lcnt & 1\n"
-                "       move.b  (\\from)+,\\tmp\n"
-                "11:    moves.b \\tmp,(\\to)+\n"
-                "12:    .set    .Lcnt,.Lcnt-1\n"
-                "       .else\n"
-                "       .exitm\n"
-                "       .endif\n"
-                "\n"
-                "       .section __ex_table,\"a\"\n"
-                "       .align  4\n"
-                "       .long   11b,3f\n"
-                "       .long   12b,3f\n"
-                "       .previous\n"
-                "       .endm\n"
-                "       .endif\n"
-                "\n"
-                "       .set    .Lcnt,%c4\n"
-                "       copy_to_user %1,%2,%3\n"
-                "       copy_to_user %1,%2,%3\n"
-                "       copy_to_user %1,%2,%3\n"
-                "2:\n"
-                "       .section .fixup,\"ax\"\n"
-                "       .even\n"
-                "3:     moveq.l %4,%0\n"
-                "       jra     2b\n"
-                "       .previous\n"
-                : "+r" (res), "+a" (to), "+a" (from), "=&d" (tmp)
-                : "i" (n)
-                : "memory");
-
         return res;
 }
 
diff --git a/include/asm-mips/compat.h b/include/asm-mips/compat.h
index 986511db54a6..900f472fdd2b 100644
--- a/include/asm-mips/compat.h
+++ b/include/asm-mips/compat.h
@@ -145,8 +145,5 @@ static inline void __user *compat_alloc_user_space(long len)
 
         return (void __user *) (regs->regs[29] - len);
 }
-#if defined (__MIPSEL__)
-#define __COMPAT_ENDIAN_SWAP__  1
-#endif
 
 #endif /* _ASM_COMPAT_H */
diff --git a/include/asm-mips/mach-generic/floppy.h b/include/asm-mips/mach-generic/floppy.h
index 682a5858f8d7..83cd69e30ec3 100644
--- a/include/asm-mips/mach-generic/floppy.h
+++ b/include/asm-mips/mach-generic/floppy.h
@@ -98,7 +98,7 @@ static inline void fd_disable_irq(void)
 static inline int fd_request_irq(void)
 {
         return request_irq(FLOPPY_IRQ, floppy_interrupt,
-                           SA_INTERRUPT | SA_SAMPLE_RANDOM, "floppy", NULL);
+                           SA_INTERRUPT, "floppy", NULL);
 }
 
 static inline void fd_free_irq(void)
diff --git a/include/asm-mips/mach-jazz/floppy.h b/include/asm-mips/mach-jazz/floppy.h
index c9dad99b1232..9413117915f4 100644
--- a/include/asm-mips/mach-jazz/floppy.h
+++ b/include/asm-mips/mach-jazz/floppy.h
@@ -90,7 +90,7 @@ static inline void fd_disable_irq(void)
 static inline int fd_request_irq(void)
 {
         return request_irq(FLOPPY_IRQ, floppy_interrupt,
-                           SA_INTERRUPT | SA_SAMPLE_RANDOM, "floppy", NULL);
+                           SA_INTERRUPT, "floppy", NULL);
 }
 
 static inline void fd_free_irq(void)
diff --git a/include/asm-parisc/floppy.h b/include/asm-parisc/floppy.h
index ca3aed768cdc..458cdb2a7530 100644
--- a/include/asm-parisc/floppy.h
+++ b/include/asm-parisc/floppy.h
@@ -159,10 +159,8 @@ static int fd_request_irq(void)
                 return request_irq(FLOPPY_IRQ, floppy_hardint,SA_INTERRUPT,
                                                    "floppy", NULL);
         else
-                return request_irq(FLOPPY_IRQ, floppy_interrupt,
-                                                   SA_INTERRUPT|SA_SAMPLE_RANDOM,
-                                                   "floppy", NULL);     
-
+                return request_irq(FLOPPY_IRQ, floppy_interrupt, SA_INTERRUPT,
+                                   "floppy", NULL);
 }
 
 static unsigned long dma_mem_alloc(unsigned long size)
diff --git a/include/asm-powerpc/backlight.h b/include/asm-powerpc/backlight.h
index 1ba1f27a0b63..a5e9e656e332 100644
--- a/include/asm-powerpc/backlight.h
+++ b/include/asm-powerpc/backlight.h
@@ -2,30 +2,30 @@
  * Routines for handling backlight control on PowerBooks
  *
  * For now, implementation resides in
- * arch/powerpc/platforms/powermac/pmac_support.c
+ * arch/powerpc/platforms/powermac/backlight.c
  *
  */
 #ifndef __ASM_POWERPC_BACKLIGHT_H
 #define __ASM_POWERPC_BACKLIGHT_H
 #ifdef __KERNEL__
 
-/* Abstract values */
-#define BACKLIGHT_OFF   0
-#define BACKLIGHT_MIN   1
-#define BACKLIGHT_MAX   0xf
+#include <linux/fb.h>
+#include <linux/mutex.h>
 
-struct backlight_controller {
-        int (*set_enable)(int enable, int level, void *data);
-        int (*set_level)(int level, void *data);
-};
+/* For locking instructions, see the implementation file */
+extern struct backlight_device *pmac_backlight;
+extern struct mutex pmac_backlight_mutex;
 
-extern void register_backlight_controller(struct backlight_controller *ctrler, void *data, char *type);
-extern void unregister_backlight_controller(struct backlight_controller *ctrler, void *data);
+extern void pmac_backlight_calc_curve(struct fb_info*);
+extern int pmac_backlight_curve_lookup(struct fb_info *info, int value);
 
-extern int set_backlight_enable(int enable);
-extern int get_backlight_enable(void);
-extern int set_backlight_level(int level);
-extern int get_backlight_level(void);
+extern int pmac_has_backlight_type(const char *type);
+
+extern void pmac_backlight_key_up(void);
+extern void pmac_backlight_key_down(void);
+
+extern int pmac_backlight_set_legacy_brightness(int brightness);
+extern int pmac_backlight_get_legacy_brightness(void);
 
 #endif /* __KERNEL__ */
 #endif
diff --git a/include/asm-powerpc/floppy.h b/include/asm-powerpc/floppy.h
index 7e2d169ee856..9c8d91bf5a0d 100644
--- a/include/asm-powerpc/floppy.h
+++ b/include/asm-powerpc/floppy.h
@@ -27,8 +27,7 @@
 #define fd_disable_irq()        disable_irq(FLOPPY_IRQ)
 #define fd_cacheflush(addr,size) /* nothing */
 #define fd_request_irq()        request_irq(FLOPPY_IRQ, floppy_interrupt, \
-                                            SA_INTERRUPT|SA_SAMPLE_RANDOM, \
-                                            "floppy", NULL)
+                                            SA_INTERRUPT, "floppy", NULL)
 #define fd_free_irq()           free_irq(FLOPPY_IRQ, NULL);
 
 #ifdef CONFIG_PCI
diff --git a/include/asm-powerpc/percpu.h b/include/asm-powerpc/percpu.h
index 184a7a4d2fdf..faa1fc703053 100644
--- a/include/asm-powerpc/percpu.h
+++ b/include/asm-powerpc/percpu.h
@@ -22,6 +22,7 @@
 /* var is in discarded region: offset to particular copy we want */
 #define per_cpu(var, cpu) (*RELOC_HIDE(&per_cpu__##var, __per_cpu_offset(cpu)))
 #define __get_cpu_var(var) (*RELOC_HIDE(&per_cpu__##var, __my_cpu_offset()))
+#define __raw_get_cpu_var(var) (*RELOC_HIDE(&per_cpu__##var, __my_cpu_offset()))
 
 /* A macro to avoid #include hell... */
 #define percpu_modcopy(pcpudst, src, size)                      \
@@ -41,6 +42,7 @@ extern void setup_per_cpu_areas(void);
 
 #define per_cpu(var, cpu)                       (*((void)(cpu), &per_cpu__##var))
 #define __get_cpu_var(var)                      per_cpu__##var
+#define __raw_get_cpu_var(var)                  per_cpu__##var
 
 #endif  /* SMP */
 
diff --git a/include/asm-ppc/floppy.h b/include/asm-ppc/floppy.h
index 8ccd4a276fe9..2ba191eba448 100644
--- a/include/asm-ppc/floppy.h
+++ b/include/asm-ppc/floppy.h
@@ -99,10 +99,8 @@ static int fd_request_irq(void)
                 return request_irq(FLOPPY_IRQ, floppy_hardint,SA_INTERRUPT,
                                                    "floppy", NULL);
         else
-                return request_irq(FLOPPY_IRQ, floppy_interrupt,
-                                                   SA_INTERRUPT|SA_SAMPLE_RANDOM,
-                                                   "floppy", NULL);
-
+                return request_irq(FLOPPY_IRQ, floppy_interrupt, SA_INTERRUPT,
+                                   "floppy", NULL);
 }
 
 static int vdma_dma_setup(char *addr, unsigned long size, int mode, int io)
diff --git a/include/asm-s390/percpu.h b/include/asm-s390/percpu.h
index 436d216601e5..d9a8cca9b653 100644
--- a/include/asm-s390/percpu.h
+++ b/include/asm-s390/percpu.h
@@ -40,6 +40,7 @@ extern unsigned long __per_cpu_offset[NR_CPUS];
     __typeof__(type) per_cpu__##name
 
 #define __get_cpu_var(var) __reloc_hide(var,S390_lowcore.percpu_offset)
+#define __raw_get_cpu_var(var) __reloc_hide(var,S390_lowcore.percpu_offset)
 #define per_cpu(var,cpu) __reloc_hide(var,__per_cpu_offset[cpu])
 
 /* A macro to avoid #include hell... */
@@ -57,6 +58,7 @@ do {								\
     __typeof__(type) per_cpu__##name
 
 #define __get_cpu_var(var) __reloc_hide(var,0)
+#define __raw_get_cpu_var(var) __reloc_hide(var,0)
 #define per_cpu(var,cpu) __reloc_hide(var,0)
 
 #endif /* SMP */
diff --git a/include/asm-sh/floppy.h b/include/asm-sh/floppy.h
index 38d7a2942476..307d9ce9f9ed 100644
--- a/include/asm-sh/floppy.h
+++ b/include/asm-sh/floppy.h
@@ -147,11 +147,10 @@ static int fd_request_irq(void)
 {
         if(can_use_virtual_dma)
                 return request_irq(FLOPPY_IRQ, floppy_hardint,SA_INTERRUPT,
-                                                   "floppy", NULL);
+                                   "floppy", NULL);
         else
-                return request_irq(FLOPPY_IRQ, floppy_interrupt,
-                                                   SA_INTERRUPT|SA_SAMPLE_RANDOM,
-                                                   "floppy", NULL);     
+                return request_irq(FLOPPY_IRQ, floppy_interrupt, SA_INTERRUPT,
+                                   "floppy", NULL);
 
 }
 
diff --git a/include/asm-sparc64/percpu.h b/include/asm-sparc64/percpu.h
index baef13b58952..a6ece06b83db 100644
--- a/include/asm-sparc64/percpu.h
+++ b/include/asm-sparc64/percpu.h
@@ -21,6 +21,7 @@ register unsigned long __local_per_cpu_offset asm("g5");
 /* var is in discarded region: offset to particular copy we want */
 #define per_cpu(var, cpu) (*RELOC_HIDE(&per_cpu__##var, __per_cpu_offset(cpu)))
 #define __get_cpu_var(var) (*RELOC_HIDE(&per_cpu__##var, __local_per_cpu_offset))
+#define __raw_get_cpu_var(var) (*RELOC_HIDE(&per_cpu__##var, __local_per_cpu_offset))
 
 /* A macro to avoid #include hell... */
 #define percpu_modcopy(pcpudst, src, size)                      \
@@ -37,6 +38,7 @@ do {								\
 
 #define per_cpu(var, cpu)                       (*((void)cpu, &per_cpu__##var))
 #define __get_cpu_var(var)                      per_cpu__##var
+#define __raw_get_cpu_var(var)                  per_cpu__##var
 
 #endif  /* SMP */
 
diff --git a/include/asm-x86_64/floppy.h b/include/asm-x86_64/floppy.h
index 52825ce689f2..006291e89b4a 100644
--- a/include/asm-x86_64/floppy.h
+++ b/include/asm-x86_64/floppy.h
@@ -147,10 +147,8 @@ static int fd_request_irq(void)
                 return request_irq(FLOPPY_IRQ, floppy_hardint,SA_INTERRUPT,
                                                    "floppy", NULL);
         else
-                return request_irq(FLOPPY_IRQ, floppy_interrupt,
-                                                   SA_INTERRUPT|SA_SAMPLE_RANDOM,
-                                                   "floppy", NULL);     
-
+                return request_irq(FLOPPY_IRQ, floppy_interrupt, SA_INTERRUPT,
+                                   "floppy", NULL);
 }
 
 static unsigned long dma_mem_alloc(unsigned long size)
diff --git a/include/asm-x86_64/percpu.h b/include/asm-x86_64/percpu.h
index 7f33aaf9f7b1..549eb929b2c0 100644
--- a/include/asm-x86_64/percpu.h
+++ b/include/asm-x86_64/percpu.h
@@ -21,6 +21,7 @@
 /* var is in discarded region: offset to particular copy we want */
 #define per_cpu(var, cpu) (*RELOC_HIDE(&per_cpu__##var, __per_cpu_offset(cpu)))
 #define __get_cpu_var(var) (*RELOC_HIDE(&per_cpu__##var, __my_cpu_offset()))
+#define __raw_get_cpu_var(var) (*RELOC_HIDE(&per_cpu__##var, __my_cpu_offset()))
 
 /* A macro to avoid #include hell... */
 #define percpu_modcopy(pcpudst, src, size)                      \
@@ -40,6 +41,7 @@ extern void setup_per_cpu_areas(void);
 
 #define per_cpu(var, cpu)                       (*((void)(cpu), &per_cpu__##var))
 #define __get_cpu_var(var)                      per_cpu__##var
+#define __raw_get_cpu_var(var)                  per_cpu__##var
 
 #endif  /* SMP */
 
diff --git a/include/linux/acct.h b/include/linux/acct.h
index 3d54fbcf969e..e86bae7324d2 100644
--- a/include/linux/acct.h
+++ b/include/linux/acct.h
@@ -121,13 +121,17 @@ struct vfsmount;
 struct super_block;
 extern void acct_auto_close_mnt(struct vfsmount *m);
 extern void acct_auto_close(struct super_block *sb);
-extern void acct_process(long exitcode);
+extern void acct_init_pacct(struct pacct_struct *pacct);
+extern void acct_collect(long exitcode, int group_dead);
+extern void acct_process(void);
 extern void acct_update_integrals(struct task_struct *tsk);
 extern void acct_clear_integrals(struct task_struct *tsk);
 #else
 #define acct_auto_close_mnt(x)  do { } while (0)
 #define acct_auto_close(x)      do { } while (0)
-#define acct_process(x)         do { } while (0)
+#define acct_init_pacct(x)      do { } while (0)
+#define acct_collect(x,y)       do { } while (0)
+#define acct_process()          do { } while (0)
 #define acct_update_integrals(x)                do { } while (0)
 #define acct_clear_integrals(task)      do { } while (0)
 #endif
diff --git a/include/linux/bio.h b/include/linux/bio.h
index b60ffe32cd21..76bdaeab6f62 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -47,7 +47,7 @@
 #define BIO_BUG_ON
 #endif
 
-#define BIO_MAX_PAGES           (256)
+#define BIO_MAX_PAGES           256
 #define BIO_MAX_SIZE            (BIO_MAX_PAGES << PAGE_CACHE_SHIFT)
 #define BIO_MAX_SECTORS         (BIO_MAX_SIZE >> 9)
 
diff --git a/include/linux/console.h b/include/linux/console.h
index 08734e660d41..d0f8a8009490 100644
--- a/include/linux/console.h
+++ b/include/linux/console.h
@@ -87,6 +87,7 @@ void give_up_console(const struct consw *sw);
 #define CON_CONSDEV     (2) /* Last on the command line */
 #define CON_ENABLED     (4)
 #define CON_BOOT        (8)
+#define CON_ANYTIME     (16) /* Safe to call when cpu is offline */
 
 struct console
 {
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index 9cbb781d6f80..b268a3c0c376 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -317,7 +317,8 @@ static inline void __cpus_remap(cpumask_t *dstp, const cpumask_t *srcp,
                 (cpu) < NR_CPUS;                \
                 (cpu) = next_cpu((cpu), (mask)))
 #else /* NR_CPUS == 1 */
-#define for_each_cpu_mask(cpu, mask) for ((cpu) = 0; (cpu) < 1; (cpu)++)
+#define for_each_cpu_mask(cpu, mask)            \
+        for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask)
 #endif /* NR_CPUS */
 
 /*
@@ -405,7 +406,6 @@ int __any_online_cpu(const cpumask_t *mask);
 #define any_online_cpu(mask)            0
 #endif
 
-#define for_each_cpu(cpu)  for_each_cpu_mask((cpu), cpu_possible_map)
 #define for_each_possible_cpu(cpu)  for_each_cpu_mask((cpu), cpu_possible_map)
 #define for_each_online_cpu(cpu)  for_each_cpu_mask((cpu), cpu_online_map)
 #define for_each_present_cpu(cpu) for_each_cpu_mask((cpu), cpu_present_map)
diff --git a/include/linux/eventpoll.h b/include/linux/eventpoll.h
index 1e4bdfcf83a2..84cfa8bbdc36 100644
--- a/include/linux/eventpoll.h
+++ b/include/linux/eventpoll.h
@@ -1,6 +1,6 @@
 /*
  *  include/linux/eventpoll.h ( Efficent event polling implementation )
- *  Copyright (C) 2001,...,2003  Davide Libenzi
+ *  Copyright (C) 2001,...,2006  Davide Libenzi
  *
  *  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
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
index 757d54d8f1a5..5607e6457a65 100644
--- a/include/linux/ext3_fs.h
+++ b/include/linux/ext3_fs.h
@@ -710,6 +710,14 @@ struct dir_private_info {
         __u32           next_hash;
 };
 
+/* calculate the first block number of the group */
+static inline ext3_fsblk_t
+ext3_group_first_block_no(struct super_block *sb, unsigned long group_no)
+{
+        return group_no * (ext3_fsblk_t)EXT3_BLOCKS_PER_GROUP(sb) +
+                le32_to_cpu(EXT3_SB(sb)->s_es->s_first_data_block);
+}
+
 /*
  * Special error return code only used by dx_probe() and its callers.
  */
@@ -730,14 +738,16 @@ struct dir_private_info {
 /* balloc.c */
 extern int ext3_bg_has_super(struct super_block *sb, int group);
 extern unsigned long ext3_bg_num_gdb(struct super_block *sb, int group);
-extern int ext3_new_block (handle_t *, struct inode *, unsigned long, int *);
-extern int ext3_new_blocks (handle_t *, struct inode *, unsigned long,
-                        unsigned long *, int *);
-extern void ext3_free_blocks (handle_t *, struct inode *, unsigned long,
-                              unsigned long);
-extern void ext3_free_blocks_sb (handle_t *, struct super_block *,
-                                 unsigned long, unsigned long, int *);
-extern unsigned long ext3_count_free_blocks (struct super_block *);
+extern ext3_fsblk_t ext3_new_block (handle_t *handle, struct inode *inode,
+                        ext3_fsblk_t goal, int *errp);
+extern ext3_fsblk_t ext3_new_blocks (handle_t *handle, struct inode *inode,
+                        ext3_fsblk_t goal, unsigned long *count, int *errp);
+extern void ext3_free_blocks (handle_t *handle, struct inode *inode,
+                        ext3_fsblk_t block, unsigned long count);
+extern void ext3_free_blocks_sb (handle_t *handle, struct super_block *sb,
+                                 ext3_fsblk_t block, unsigned long count,
+                                unsigned long *pdquot_freed_blocks);
+extern ext3_fsblk_t ext3_count_free_blocks (struct super_block *);
 extern void ext3_check_blocks_bitmap (struct super_block *);
 extern struct ext3_group_desc * ext3_get_group_desc(struct super_block * sb,
                                                     unsigned int block_group,
@@ -773,7 +783,8 @@ extern unsigned long ext3_count_free (struct buffer_head *, unsigned);
 
 
 /* inode.c */
-int ext3_forget(handle_t *, int, struct inode *, struct buffer_head *, int);
+int ext3_forget(handle_t *handle, int is_metadata, struct inode *inode,
+                struct buffer_head *bh, ext3_fsblk_t blocknr);
 struct buffer_head * ext3_getblk (handle_t *, struct inode *, long, int, int *);
 struct buffer_head * ext3_bread (handle_t *, struct inode *, int, int, int *);
 int ext3_get_blocks_handle(handle_t *handle, struct inode *inode,
@@ -808,7 +819,7 @@ extern int ext3_group_add(struct super_block *sb,
                                 struct ext3_new_group_data *input);
 extern int ext3_group_extend(struct super_block *sb,
                                 struct ext3_super_block *es,
-                                unsigned long n_blocks_count);
+                                ext3_fsblk_t n_blocks_count);
 
 /* super.c */
 extern void ext3_error (struct super_block *, const char *, const char *, ...)
diff --git a/include/linux/ext3_fs_i.h b/include/linux/ext3_fs_i.h
index 7abf90147180..2f18b9511f21 100644
--- a/include/linux/ext3_fs_i.h
+++ b/include/linux/ext3_fs_i.h
@@ -21,9 +21,17 @@
 #include <linux/seqlock.h>
 #include <linux/mutex.h>
 
+/* data type for block offset of block group */
+typedef int ext3_grpblk_t;
+
+/* data type for filesystem-wide blocks number */
+typedef unsigned long ext3_fsblk_t;
+
+#define E3FSBLK "%lu"
+
 struct ext3_reserve_window {
-        __u32                   _rsv_start;     /* First byte reserved */
-        __u32                   _rsv_end;       /* Last byte reserved or 0 */
+        ext3_fsblk_t    _rsv_start;     /* First byte reserved */
+        ext3_fsblk_t    _rsv_end;       /* Last byte reserved or 0 */
 };
 
 struct ext3_reserve_window_node {
@@ -50,7 +58,7 @@ struct ext3_block_alloc_info {
          * allocated to this file.  This give us the goal (target) for the next
          * allocation when we detect linearly ascending requests.
          */
-        __u32                   last_alloc_physical_block;
+        ext3_fsblk_t            last_alloc_physical_block;
 };
 
 #define rsv_start rsv_window._rsv_start
@@ -67,7 +75,7 @@ struct ext3_inode_info {
         __u8    i_frag_no;
         __u8    i_frag_size;
 #endif
-        __u32   i_file_acl;
+        ext3_fsblk_t    i_file_acl;
         __u32   i_dir_acl;
         __u32   i_dtime;
 
diff --git a/include/linux/fb.h b/include/linux/fb.h
index 315d89740ddf..f1281687e549 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -1,6 +1,7 @@
 #ifndef _LINUX_FB_H
 #define _LINUX_FB_H
 
+#include <linux/backlight.h>
 #include <asm/types.h>
 
 /* Definitions of frame buffers                                         */
@@ -366,6 +367,12 @@ struct fb_cursor {
         struct fb_image image;  /* Cursor image */
 };
 
+#ifdef CONFIG_FB_BACKLIGHT
+/* Settings for the generic backlight code */
+#define FB_BACKLIGHT_LEVELS     128
+#define FB_BACKLIGHT_MAX        0xFF
+#endif
+
 #ifdef __KERNEL__
 
 #include <linux/fs.h>
@@ -756,6 +763,21 @@ struct fb_info {
         struct fb_cmap cmap;            /* Current cmap */
         struct list_head modelist;      /* mode list */
         struct fb_videomode *mode;      /* current mode */
+
+#ifdef CONFIG_FB_BACKLIGHT
+        /* Lock ordering:
+         * bl_mutex (protects bl_dev and bl_curve)
+         *   bl_dev->sem (backlight class)
+         */
+        struct mutex bl_mutex;
+
+        /* assigned backlight device */
+        struct backlight_device *bl_dev;
+
+        /* Backlight level curve */
+        u8 bl_curve[FB_BACKLIGHT_LEVELS];
+#endif
+
         struct fb_ops *fbops;
         struct device *device;
         struct class_device *class_device; /* sysfs per device attrs */
@@ -895,6 +917,7 @@ extern struct fb_info *framebuffer_alloc(size_t size, struct device *dev);
 extern void framebuffer_release(struct fb_info *info);
 extern int fb_init_class_device(struct fb_info *fb_info);
 extern void fb_cleanup_class_device(struct fb_info *head);
+extern void fb_bl_default_curve(struct fb_info *fb_info, u8 off, u8 min, u8 max);
 
 /* drivers/video/fbmon.c */
 #define FB_MAXTIMINGS           0
diff --git a/include/linux/fcntl.h b/include/linux/fcntl.h
index c52a63755fdd..996f5611cd59 100644
--- a/include/linux/fcntl.h
+++ b/include/linux/fcntl.h
@@ -29,6 +29,7 @@
 #define AT_SYMLINK_NOFOLLOW     0x100   /* Do not follow symbolic links.  */
 #define AT_REMOVEDIR            0x200   /* Remove directory instead of
                                            unlinking file.  */
+#define AT_SYMLINK_FOLLOW       0x400   /* Follow symbolic links.  */
 
 #ifdef __KERNEL__
 
diff --git a/include/linux/fuse.h b/include/linux/fuse.h
index 5425b60021e3..9fc48a674b82 100644
--- a/include/linux/fuse.h
+++ b/include/linux/fuse.h
@@ -1,6 +1,6 @@
 /*
     FUSE: Filesystem in Userspace
-    Copyright (C) 2001-2005  Miklos Szeredi <miklos@szeredi.hu>
+    Copyright (C) 2001-2006  Miklos Szeredi <miklos@szeredi.hu>
 
     This program can be distributed under the terms of the GNU GPL.
     See the file COPYING.
@@ -9,18 +9,19 @@
 /* This file defines the kernel interface of FUSE */
 
 #include <asm/types.h>
+#include <linux/major.h>
 
 /** Version number of this interface */
 #define FUSE_KERNEL_VERSION 7
 
 /** Minor version number of this interface */
-#define FUSE_KERNEL_MINOR_VERSION 6
+#define FUSE_KERNEL_MINOR_VERSION 7
 
 /** The node ID of the root inode */
 #define FUSE_ROOT_ID 1
 
 /** The major number of the fuse character device */
-#define FUSE_MAJOR 10
+#define FUSE_MAJOR MISC_MAJOR
 
 /** The minor number of the fuse character device */
 #define FUSE_MINOR 229
@@ -58,6 +59,13 @@ struct fuse_kstatfs {
         __u32   spare[6];
 };
 
+struct fuse_file_lock {
+        __u64   start;
+        __u64   end;
+        __u32   type;
+        __u32   pid; /* tgid */
+};
+
 /**
  * Bitmasks for fuse_setattr_in.valid
  */
@@ -82,6 +90,7 @@ struct fuse_kstatfs {
  * INIT request/reply flags
  */
 #define FUSE_ASYNC_READ         (1 << 0)
+#define FUSE_POSIX_LOCKS        (1 << 1)
 
 enum fuse_opcode {
         FUSE_LOOKUP        = 1,
@@ -112,8 +121,12 @@ enum fuse_opcode {
         FUSE_READDIR       = 28,
         FUSE_RELEASEDIR    = 29,
         FUSE_FSYNCDIR      = 30,
+        FUSE_GETLK         = 31,
+        FUSE_SETLK         = 32,
+        FUSE_SETLKW        = 33,
         FUSE_ACCESS        = 34,
-        FUSE_CREATE        = 35
+        FUSE_CREATE        = 35,
+        FUSE_INTERRUPT     = 36,
 };
 
 /* The read buffer is required to be at least 8k, but may be much larger */
@@ -199,6 +212,7 @@ struct fuse_flush_in {
         __u64   fh;
         __u32   flush_flags;
         __u32   padding;
+        __u64   lock_owner;
 };
 
 struct fuse_read_in {
@@ -247,6 +261,16 @@ struct fuse_getxattr_out {
         __u32   padding;
 };
 
+struct fuse_lk_in {
+        __u64   fh;
+        __u64   owner;
+        struct fuse_file_lock lk;
+};
+
+struct fuse_lk_out {
+        struct fuse_file_lock lk;
+};
+
 struct fuse_access_in {
         __u32   mask;
         __u32   padding;
@@ -268,6 +292,10 @@ struct fuse_init_out {
         __u32   max_write;
 };
 
+struct fuse_interrupt_in {
+        __u64   unique;
+};
+
 struct fuse_in_header {
         __u32   len;
         __u32   opcode;
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 7d2a1b974c5e..07d7305f131e 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -40,7 +40,6 @@ struct hrtimer_base;
 
 /**
  * struct hrtimer - the basic hrtimer structure
- *
  * @node:       red black tree node for time ordered insertion
  * @expires:    the absolute expiry time in the hrtimers internal
  *              representation. The time is related to the clock on
@@ -59,7 +58,6 @@ struct hrtimer {
 
 /**
  * struct hrtimer_sleeper - simple sleeper structure
- *
  * @timer:      embedded timer structure
  * @task:       task to wake up
  *
@@ -72,7 +70,6 @@ struct hrtimer_sleeper {
 
 /**
  * struct hrtimer_base - the timer base for a specific clock
- *
  * @index:              clock type index for per_cpu support when moving a timer
  *                      to a base on another cpu.
  * @lock:               lock protecting the base and associated timers
diff --git a/include/linux/ide.h b/include/linux/ide.h
index 77e66d055f5b..ef7bef207f48 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -630,6 +630,7 @@ typedef struct ide_drive_s {
         unsigned int    usage;          /* current "open()" count for drive */
         unsigned int    failures;       /* current failure count */
         unsigned int    max_failures;   /* maximum allowed failure count */
+        u64             probed_capacity;/* initial reported media capacity (ide-cd only currently) */
 
         u64             capacity64;     /* total number of sectors */
 
@@ -1005,6 +1006,8 @@ extern	ide_hwif_t	ide_hwifs[];		/* master data repository */
 extern int noautodma;
 
 extern int ide_end_request (ide_drive_t *drive, int uptodate, int nrsecs);
+int ide_end_dequeued_request(ide_drive_t *drive, struct request *rq,
+                             int uptodate, int nr_sectors);
 
 /*
  * This is used on exit from the driver to designate the next irq handler
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 8c21aaa248b4..3c5e4c2e517d 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -117,6 +117,8 @@ extern int scnprintf(char * buf, size_t size, const char * fmt, ...)
         __attribute__ ((format (printf, 3, 4)));
 extern int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
         __attribute__ ((format (printf, 3, 0)));
+extern char *kasprintf(gfp_t gfp, const char *fmt, ...)
+        __attribute__ ((format (printf, 2, 3)));
 
 extern int sscanf(const char *, const char *, ...)
         __attribute__ ((format (scanf, 2, 3)));
diff --git a/include/linux/kthread.h b/include/linux/kthread.h
index ebdd41fd1082..7cce5dfa092f 100644
--- a/include/linux/kthread.h
+++ b/include/linux/kthread.h
@@ -4,37 +4,19 @@
 #include <linux/err.h>
 #include <linux/sched.h>
 
-/**
- * kthread_create: create a kthread.
- * @threadfn: the function to run until signal_pending(current).
- * @data: data ptr for @threadfn.
- * @namefmt: printf-style name for the thread.
- *
- * Description: This helper function creates and names a kernel
- * thread.  The thread will be stopped: use wake_up_process() to start
- * it.  See also kthread_run(), kthread_create_on_cpu().
- *
- * When woken, the thread will run @threadfn() with @data as its
- * argument. @threadfn can either call do_exit() directly if it is a
- * standalone thread for which noone will call kthread_stop(), or
- * return when 'kthread_should_stop()' is true (which means
- * kthread_stop() has been called).  The return value should be zero
- * or a negative error number: it will be passed to kthread_stop().
- *
- * Returns a task_struct or ERR_PTR(-ENOMEM).
- */
 struct task_struct *kthread_create(int (*threadfn)(void *data),
                                    void *data,
                                    const char namefmt[], ...);
 
 /**
- * kthread_run: create and wake a thread.
+ * kthread_run - create and wake a thread.
  * @threadfn: the function to run until signal_pending(current).
  * @data: data ptr for @threadfn.
  * @namefmt: printf-style name for the thread.
  *
  * Description: Convenient wrapper for kthread_create() followed by
- * wake_up_process().  Returns the kthread, or ERR_PTR(-ENOMEM). */
+ * wake_up_process().  Returns the kthread or ERR_PTR(-ENOMEM).
+ */
 #define kthread_run(threadfn, data, namefmt, ...)                          \
 ({                                                                         \
         struct task_struct *__k                                            \
@@ -44,50 +26,9 @@ struct task_struct *kthread_create(int (*threadfn)(void *data),
         __k;                                                               \
 })
 
-/**
- * kthread_bind: bind a just-created kthread to a cpu.
- * @k: thread created by kthread_create().
- * @cpu: cpu (might not be online, must be possible) for @k to run on.
- *
- * Description: This function is equivalent to set_cpus_allowed(),
- * except that @cpu doesn't need to be online, and the thread must be
- * stopped (ie. just returned from kthread_create().
- */
 void kthread_bind(struct task_struct *k, unsigned int cpu);
-
-/**
- * kthread_stop: stop a thread created by kthread_create().
- * @k: thread created by kthread_create().
- *
- * Sets kthread_should_stop() for @k to return true, wakes it, and
- * waits for it to exit.  Your threadfn() must not call do_exit()
- * itself if you use this function!  This can also be called after
- * kthread_create() instead of calling wake_up_process(): the thread
- * will exit without calling threadfn().
- *
- * Returns the result of threadfn(), or -EINTR if wake_up_process()
- * was never called. */
 int kthread_stop(struct task_struct *k);
-
-/**
- * kthread_stop_sem: stop a thread created by kthread_create().
- * @k: thread created by kthread_create().
- * @s: semaphore that @k waits on while idle.
- *
- * Does essentially the same thing as kthread_stop() above, but wakes
- * @k by calling up(@s).
- *
- * Returns the result of threadfn(), or -EINTR if wake_up_process()
- * was never called. */
 int kthread_stop_sem(struct task_struct *k, struct semaphore *s);
-
-/**
- * kthread_should_stop: should this kthread return now?
- *
- * When someone calls kthread_stop on your kthread, it will be woken
- * and this will return true.  You should then return, and your return
- * value will be passed through to kthread_stop().
- */
 int kthread_should_stop(void);
 
 #endif /* _LINUX_KTHREAD_H */
diff --git a/include/linux/ktime.h b/include/linux/ktime.h
index 62bc57580707..ed3396dcc4f7 100644
--- a/include/linux/ktime.h
+++ b/include/linux/ktime.h
@@ -66,7 +66,6 @@ typedef union {
 
 /**
  * ktime_set - Set a ktime_t variable from a seconds/nanoseconds value
- *
  * @secs:       seconds to set
  * @nsecs:      nanoseconds to set
  *
@@ -138,7 +137,6 @@ static inline ktime_t ktime_set(const long secs, const unsigned long nsecs)
 
 /**
  * ktime_sub - subtract two ktime_t variables
- *
  * @lhs:        minuend
  * @rhs:        subtrahend
  *
@@ -157,7 +155,6 @@ static inline ktime_t ktime_sub(const ktime_t lhs, const ktime_t rhs)
 
 /**
  * ktime_add - add two ktime_t variables
- *
  * @add1:       addend1
  * @add2:       addend2
  *
@@ -184,7 +181,6 @@ static inline ktime_t ktime_add(const ktime_t add1, const ktime_t add2)
 
 /**
  * ktime_add_ns - Add a scalar nanoseconds value to a ktime_t variable
- *
  * @kt:         addend
  * @nsec:       the scalar nsec value to add
  *
@@ -194,7 +190,6 @@ extern ktime_t ktime_add_ns(const ktime_t kt, u64 nsec);
 
 /**
  * timespec_to_ktime - convert a timespec to ktime_t format
- *
  * @ts:         the timespec variable to convert
  *
  * Returns a ktime_t variable with the converted timespec value
@@ -207,7 +202,6 @@ static inline ktime_t timespec_to_ktime(const struct timespec ts)
 
 /**
  * timeval_to_ktime - convert a timeval to ktime_t format
- *
  * @tv:         the timeval variable to convert
  *
  * Returns a ktime_t variable with the converted timeval value
@@ -220,7 +214,6 @@ static inline ktime_t timeval_to_ktime(const struct timeval tv)
 
 /**
  * ktime_to_timespec - convert a ktime_t variable to timespec format
- *
  * @kt:         the ktime_t variable to convert
  *
  * Returns the timespec representation of the ktime value
@@ -233,7 +226,6 @@ static inline struct timespec ktime_to_timespec(const ktime_t kt)
 
 /**
  * ktime_to_timeval - convert a ktime_t variable to timeval format
- *
  * @kt:         the ktime_t variable to convert
  *
  * Returns the timeval representation of the ktime value
diff --git a/include/linux/list.h b/include/linux/list.h
index a02642e4710a..37ca31b21bb7 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -281,16 +281,17 @@ static inline int list_empty(const struct list_head *head)
 }
 
 /**
- * list_empty_careful - tests whether a list is
- * empty _and_ checks that no other CPU might be
- * in the process of still modifying either member
+ * list_empty_careful - tests whether a list is empty and not being modified
+ * @head: the list to test
+ *
+ * Description:
+ * tests whether a list is empty _and_ checks that no other CPU might be
+ * in the process of modifying either member (next or prev)
  *
  * NOTE: using list_empty_careful() without synchronization
  * can only be safe if the only activity that can happen
  * to the list entry is list_del_init(). Eg. it cannot be used
  * if another CPU could re-list_add() it.
- *
- * @head: the list to test.
  */
 static inline int list_empty_careful(const struct list_head *head)
 {
@@ -350,7 +351,7 @@ static inline void list_splice_init(struct list_head *list,
 
 /**
  * list_for_each        -       iterate over a list
- * @pos:        the &struct list_head to use as a loop counter.
+ * @pos:        the &struct list_head to use as a loop cursor.
  * @head:       the head for your list.
  */
 #define list_for_each(pos, head) \
@@ -359,7 +360,7 @@ static inline void list_splice_init(struct list_head *list,
 
 /**
  * __list_for_each      -       iterate over a list
- * @pos:        the &struct list_head to use as a loop counter.
+ * @pos:        the &struct list_head to use as a loop cursor.
  * @head:       the head for your list.
  *
  * This variant differs from list_for_each() in that it's the
@@ -372,7 +373,7 @@ static inline void list_splice_init(struct list_head *list,
 
 /**
  * list_for_each_prev   -       iterate over a list backwards
- * @pos:        the &struct list_head to use as a loop counter.
+ * @pos:        the &struct list_head to use as a loop cursor.
  * @head:       the head for your list.
  */
 #define list_for_each_prev(pos, head) \
@@ -380,8 +381,8 @@ static inline void list_splice_init(struct list_head *list,
                 pos = pos->prev)
 
 /**
- * list_for_each_safe   -       iterate over a list safe against removal of list entry
- * @pos:        the &struct list_head to use as a loop counter.
+ * list_for_each_safe - iterate over a list safe against removal of list entry
+ * @pos:        the &struct list_head to use as a loop cursor.
  * @n:          another &struct list_head to use as temporary storage
  * @head:       the head for your list.
  */
@@ -391,7 +392,7 @@ static inline void list_splice_init(struct list_head *list,
 
 /**
  * list_for_each_entry  -       iterate over list of given type
- * @pos:        the type * to use as a loop counter.
+ * @pos:        the type * to use as a loop cursor.
  * @head:       the head for your list.
  * @member:     the name of the list_struct within the struct.
  */
@@ -402,7 +403,7 @@ static inline void list_splice_init(struct list_head *list,
 
 /**
  * list_for_each_entry_reverse - iterate backwards over list of given type.
- * @pos:        the type * to use as a loop counter.
+ * @pos:        the type * to use as a loop cursor.
  * @head:       the head for your list.
  * @member:     the name of the list_struct within the struct.
  */
@@ -412,21 +413,24 @@ static inline void list_splice_init(struct list_head *list,
              pos = list_entry(pos->member.prev, typeof(*pos), member))
 
 /**
- * list_prepare_entry - prepare a pos entry for use as a start point in
- *                      list_for_each_entry_continue
+ * list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue
  * @pos:        the type * to use as a start point
  * @head:       the head of the list
  * @member:     the name of the list_struct within the struct.
+ *
+ * Prepares a pos entry for use as a start point in list_for_each_entry_continue.
  */
 #define list_prepare_entry(pos, head, member) \
         ((pos) ? : list_entry(head, typeof(*pos), member))
 
 /**
- * list_for_each_entry_continue -       iterate over list of given type
- *                      continuing after existing point
- * @pos:        the type * to use as a loop counter.
+ * list_for_each_entry_continue - continue iteration over list of given type
+ * @pos:        the type * to use as a loop cursor.
  * @head:       the head for your list.
  * @member:     the name of the list_struct within the struct.
+ *
+ * Continue to iterate over list of given type, continuing after
+ * the current position.
  */
 #define list_for_each_entry_continue(pos, head, member)                 \
         for (pos = list_entry(pos->member.next, typeof(*pos), member);  \
@@ -434,11 +438,12 @@ static inline void list_splice_init(struct list_head *list,
              pos = list_entry(pos->member.next, typeof(*pos), member))
 
 /**
- * list_for_each_entry_from -   iterate over list of given type
- *                      continuing from existing point
- * @pos:        the type * to use as a loop counter.
+ * list_for_each_entry_from - iterate over list of given type from the current point
+ * @pos:        the type * to use as a loop cursor.
  * @head:       the head for your list.
  * @member:     the name of the list_struct within the struct.
+ *
+ * Iterate over list of given type, continuing from current position.
  */
 #define list_for_each_entry_from(pos, head, member)                     \
         for (; prefetch(pos->member.next), &pos->member != (head);      \
@@ -446,7 +451,7 @@ static inline void list_splice_init(struct list_head *list,
 
 /**
  * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
- * @pos:        the type * to use as a loop counter.
+ * @pos:        the type * to use as a loop cursor.
  * @n:          another type * to use as temporary storage
  * @head:       the head for your list.
  * @member:     the name of the list_struct within the struct.
@@ -458,12 +463,14 @@ static inline void list_splice_init(struct list_head *list,
              pos = n, n = list_entry(n->member.next, typeof(*n), member))
 
 /**
- * list_for_each_entry_safe_continue -  iterate over list of given type
- *                      continuing after existing point safe against removal of list entry
- * @pos:        the type * to use as a loop counter.
+ * list_for_each_entry_safe_continue
+ * @pos:        the type * to use as a loop cursor.
  * @n:          another type * to use as temporary storage
  * @head:       the head for your list.
  * @member:     the name of the list_struct within the struct.
+ *
+ * Iterate over list of given type, continuing after current point,
+ * safe against removal of list entry.
  */
 #define list_for_each_entry_safe_continue(pos, n, head, member)                 \
         for (pos = list_entry(pos->member.next, typeof(*pos), member),          \
@@ -472,12 +479,14 @@ static inline void list_splice_init(struct list_head *list,
              pos = n, n = list_entry(n->member.next, typeof(*n), member))
 
 /**
- * list_for_each_entry_safe_from - iterate over list of given type
- *                      from existing point safe against removal of list entry
- * @pos:        the type * to use as a loop counter.
+ * list_for_each_entry_safe_from
+ * @pos:        the type * to use as a loop cursor.
  * @n:          another type * to use as temporary storage
  * @head:       the head for your list.
  * @member:     the name of the list_struct within the struct.
+ *
+ * Iterate over list of given type from current point, safe against
+ * removal of list entry.
  */
 #define list_for_each_entry_safe_from(pos, n, head, member)                     \
         for (n = list_entry(pos->member.next, typeof(*pos), member);            \
@@ -485,12 +494,14 @@ static inline void list_splice_init(struct list_head *list,
              pos = n, n = list_entry(n->member.next, typeof(*n), member))
 
 /**
- * list_for_each_entry_safe_reverse - iterate backwards over list of given type safe against
- *                                    removal of list entry
- * @pos:        the type * to use as a loop counter.
+ * list_for_each_entry_safe_reverse
+ * @pos:        the type * to use as a loop cursor.
  * @n:          another type * to use as temporary storage
  * @head:       the head for your list.
  * @member:     the name of the list_struct within the struct.
+ *
+ * Iterate backwards over list of given type, safe against removal
+ * of list entry.
  */
 #define list_for_each_entry_safe_reverse(pos, n, head, member)          \
         for (pos = list_entry((head)->prev, typeof(*pos), member),      \
@@ -500,7 +511,7 @@ static inline void list_splice_init(struct list_head *list,
 
 /**
  * list_for_each_rcu    -       iterate over an rcu-protected list
- * @pos:        the &struct list_head to use as a loop counter.
+ * @pos:        the &struct list_head to use as a loop cursor.
  * @head:       the head for your list.
  *
  * This list-traversal primitive may safely run concurrently with
@@ -518,12 +529,13 @@ static inline void list_splice_init(struct list_head *list,
                 pos = pos->next)
 
 /**
- * list_for_each_safe_rcu       -       iterate over an rcu-protected list safe
- *                                      against removal of list entry
- * @pos:        the &struct list_head to use as a loop counter.
+ * list_for_each_safe_rcu
+ * @pos:        the &struct list_head to use as a loop cursor.
  * @n:          another &struct list_head to use as temporary storage
  * @head:       the head for your list.
  *
+ * Iterate over an rcu-protected list, safe against removal of list entry.
+ *
  * This list-traversal primitive may safely run concurrently with
  * the _rcu list-mutation primitives such as list_add_rcu()
  * as long as the traversal is guarded by rcu_read_lock().
@@ -535,7 +547,7 @@ static inline void list_splice_init(struct list_head *list,
 
 /**
  * list_for_each_entry_rcu      -       iterate over rcu list of given type
- * @pos:        the type * to use as a loop counter.
+ * @pos:        the type * to use as a loop cursor.
  * @head:       the head for your list.
  * @member:     the name of the list_struct within the struct.
  *
@@ -551,11 +563,12 @@ static inline void list_splice_init(struct list_head *list,
 
 
 /**
- * list_for_each_continue_rcu   -       iterate over an rcu-protected list
- *                      continuing after existing point.
- * @pos:        the &struct list_head to use as a loop counter.
+ * list_for_each_continue_rcu
+ * @pos:        the &struct list_head to use as a loop cursor.
  * @head:       the head for your list.
  *
+ * Iterate over an rcu-protected list, continuing after current point.
+ *
  * This list-traversal primitive may safely run concurrently with
  * the _rcu list-mutation primitives such as list_add_rcu()
  * as long as the traversal is guarded by rcu_read_lock().
@@ -681,11 +694,14 @@ static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
 
 
 /**
- * hlist_add_head_rcu - adds the specified element to the specified hlist,
- * while permitting racing traversals.
+ * hlist_add_head_rcu
  * @n: the element to add to the hash list.
  * @h: the list to add to.
  *
+ * Description:
+ * Adds the specified element to the specified hlist,
+ * while permitting racing traversals.
+ *
  * The caller must take whatever precautions are necessary
  * (such as holding appropriate locks) to avoid racing
  * with another list-mutation primitive, such as hlist_add_head_rcu()
@@ -730,11 +746,14 @@ static inline void hlist_add_after(struct hlist_node *n,
 }
 
 /**
- * hlist_add_before_rcu - adds the specified element to the specified hlist
- * before the specified node while permitting racing traversals.
+ * hlist_add_before_rcu
  * @n: the new element to add to the hash list.
  * @next: the existing element to add the new element before.
  *
+ * Description:
+ * Adds the specified element to the specified hlist
+ * before the specified node while permitting racing traversals.
+ *
  * The caller must take whatever precautions are necessary
  * (such as holding appropriate locks) to avoid racing
  * with another list-mutation primitive, such as hlist_add_head_rcu()
@@ -755,11 +774,14 @@ static inline void hlist_add_before_rcu(struct hlist_node *n,
 }
 
 /**
- * hlist_add_after_rcu - adds the specified element to the specified hlist
- * after the specified node while permitting racing traversals.
+ * hlist_add_after_rcu
  * @prev: the existing element to add the new element after.
  * @n: the new element to add to the hash list.
  *
+ * Description:
+ * Adds the specified element to the specified hlist
+ * after the specified node while permitting racing traversals.
+ *
  * The caller must take whatever precautions are necessary
  * (such as holding appropriate locks) to avoid racing
  * with another list-mutation primitive, such as hlist_add_head_rcu()
@@ -792,8 +814,8 @@ static inline void hlist_add_after_rcu(struct hlist_node *prev,
 
 /**
  * hlist_for_each_entry - iterate over list of given type
- * @tpos:       the type * to use as a loop counter.
- * @pos:        the &struct hlist_node to use as a loop counter.
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct hlist_node to use as a loop cursor.
  * @head:       the head for your list.
  * @member:     the name of the hlist_node within the struct.
  */
@@ -804,9 +826,9 @@ static inline void hlist_add_after_rcu(struct hlist_node *prev,
              pos = pos->next)
 
 /**
- * hlist_for_each_entry_continue - iterate over a hlist continuing after existing point
- * @tpos:       the type * to use as a loop counter.
- * @pos:        the &struct hlist_node to use as a loop counter.
+ * hlist_for_each_entry_continue - iterate over a hlist continuing after current point
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct hlist_node to use as a loop cursor.
  * @member:     the name of the hlist_node within the struct.
  */
 #define hlist_for_each_entry_continue(tpos, pos, member)                 \
@@ -816,9 +838,9 @@ static inline void hlist_add_after_rcu(struct hlist_node *prev,
              pos = pos->next)
 
 /**
- * hlist_for_each_entry_from - iterate over a hlist continuing from existing point
- * @tpos:       the type * to use as a loop counter.
- * @pos:        the &struct hlist_node to use as a loop counter.
+ * hlist_for_each_entry_from - iterate over a hlist continuing from current point
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct hlist_node to use as a loop cursor.
  * @member:     the name of the hlist_node within the struct.
  */
 #define hlist_for_each_entry_from(tpos, pos, member)                     \
@@ -828,8 +850,8 @@ static inline void hlist_add_after_rcu(struct hlist_node *prev,
 
 /**
  * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
- * @tpos:       the type * to use as a loop counter.
- * @pos:        the &struct hlist_node to use as a loop counter.
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct hlist_node to use as a loop cursor.
  * @n:          another &struct hlist_node to use as temporary storage
  * @head:       the head for your list.
  * @member:     the name of the hlist_node within the struct.
@@ -842,8 +864,8 @@ static inline void hlist_add_after_rcu(struct hlist_node *prev,
 
 /**
  * hlist_for_each_entry_rcu - iterate over rcu list of given type
- * @tpos:       the type * to use as a loop counter.
- * @pos:        the &struct hlist_node to use as a loop counter.
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct hlist_node to use as a loop cursor.
  * @head:       the head for your list.
  * @member:     the name of the hlist_node within the struct.
  *
diff --git a/include/linux/loop.h b/include/linux/loop.h
index e76c7611d6cc..bf3d2345ce99 100644
--- a/include/linux/loop.h
+++ b/include/linux/loop.h
@@ -59,7 +59,7 @@ struct loop_device {
         struct bio              *lo_bio;
         struct bio              *lo_biotail;
         int                     lo_state;
-        struct completion       lo_done;
+        struct task_struct      *lo_thread;
         struct completion       lo_bh_done;
         struct mutex            lo_ctl_mutex;
         int                     lo_pending;
diff --git a/include/linux/migrate.h b/include/linux/migrate.h
index 5dba23a1c0d0..48148e0cdbd1 100644
--- a/include/linux/migrate.h
+++ b/include/linux/migrate.h
@@ -16,7 +16,9 @@ extern int fail_migrate_page(struct address_space *,
                         struct page *, struct page *);
 
 extern int migrate_prep(void);
-
+extern int migrate_vmas(struct mm_struct *mm,
+                const nodemask_t *from, const nodemask_t *to,
+                unsigned long flags);
 #else
 
 static inline int isolate_lru_page(struct page *p, struct list_head *list)
@@ -30,6 +32,13 @@ static inline int migrate_pages_to(struct list_head *pagelist,
 
 static inline int migrate_prep(void) { return -ENOSYS; }
 
+static inline int migrate_vmas(struct mm_struct *mm,
+                const nodemask_t *from, const nodemask_t *to,
+                unsigned long flags)
+{
+        return -ENOSYS;
+}
+
 /* Possible settings for the migrate_page() method in address_operations */
 #define migrate_page NULL
 #define fail_migrate_page NULL
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 3b09444121d9..a929ea197e48 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -145,7 +145,6 @@ extern unsigned int kobjsize(const void *objp);
 
 #define VM_GROWSDOWN    0x00000100      /* general info on the segment */
 #define VM_GROWSUP      0x00000200
-#define VM_SHM          0x00000000      /* Means nothing: delete it later */
 #define VM_PFNMAP       0x00000400      /* Page-ranges managed without "struct page", just pure PFN */
 #define VM_DENYWRITE    0x00000800      /* ETXTBSY on write attempts.. */
 
@@ -207,6 +206,8 @@ struct vm_operations_struct {
         int (*set_policy)(struct vm_area_struct *vma, struct mempolicy *new);
         struct mempolicy *(*get_policy)(struct vm_area_struct *vma,
                                         unsigned long addr);
+        int (*migrate)(struct vm_area_struct *vma, const nodemask_t *from,
+                const nodemask_t *to, unsigned long flags);
 #endif
 };
 
diff --git a/include/linux/nbd.h b/include/linux/nbd.h
index 1d7cdd20b553..e712e7d47cc2 100644
--- a/include/linux/nbd.h
+++ b/include/linux/nbd.h
@@ -77,11 +77,11 @@ struct nbd_device {
  * server. All data are in network byte order.
  */
 struct nbd_request {
-        __u32 magic;
-        __u32 type;     /* == READ || == WRITE  */
+        __be32 magic;
+        __be32 type;    /* == READ || == WRITE  */
         char handle[8];
-        __u64 from;
-        __u32 len;
+        __be64 from;
+        __be32 len;
 }
 #ifdef __GNUC__
         __attribute__ ((packed))
@@ -93,8 +93,8 @@ struct nbd_request {
  * it has completed an I/O request (or an error occurs).
  */
 struct nbd_reply {
-        __u32 magic;
-        __u32 error;            /* 0 = ok, else error   */
+        __be32 magic;
+        __be32 error;           /* 0 = ok, else error   */
         char handle[8];         /* handle you got from request  */
 };
 #endif
diff --git a/include/linux/parport.h b/include/linux/parport.h
index d42737eeee06..5bf321e82c99 100644
--- a/include/linux/parport.h
+++ b/include/linux/parport.h
@@ -127,6 +127,10 @@ struct amiga_parport_state {
        unsigned char statusdir;/* ciab.ddrb & 7 */
 };
 
+struct ax88796_parport_state {
+        unsigned char cpr;
+};
+
 struct ip32_parport_state {
         unsigned int dcr;
         unsigned int ecr;
@@ -138,6 +142,7 @@ struct parport_state {
                 /* ARC has no state. */
                 struct ax_parport_state ax;
                 struct amiga_parport_state amiga;
+                struct ax88796_parport_state ax88796;
                 /* Atari has not state. */
                 struct ip32_parport_state ip32;
                 void *misc; 
diff --git a/include/linux/pmu.h b/include/linux/pmu.h
index ecce5912f4d6..2ed807ddc08c 100644
--- a/include/linux/pmu.h
+++ b/include/linux/pmu.h
@@ -230,4 +230,8 @@ extern int pmu_battery_count;
 extern struct pmu_battery_info pmu_batteries[PMU_MAX_BATTERIES];
 extern unsigned int pmu_power_flags;
 
+/* Backlight */
+extern int disable_kernel_backlight;
+extern void pmu_backlight_init(struct device_node*);
+
 #endif  /* __KERNEL__ */
diff --git a/include/linux/reboot.h b/include/linux/reboot.h
index 015297ff73fa..1dd1c707311f 100644
--- a/include/linux/reboot.h
+++ b/include/linux/reboot.h
@@ -59,13 +59,13 @@ extern void machine_crash_shutdown(struct pt_regs *);
  * Architecture independent implemenations of sys_reboot commands.
  */
 
-extern void kernel_restart_prepare(char *cmd);
 extern void kernel_shutdown_prepare(enum system_states state);
 
 extern void kernel_restart(char *cmd);
 extern void kernel_halt(void);
 extern void kernel_power_off(void);
-extern void kernel_kexec(void);
+
+void ctrl_alt_del(void);
 
 /*
  * Emergency restart, callable from an interrupt handler.
diff --git a/include/linux/resource.h b/include/linux/resource.h
index 21a86cb6acdb..ae13db714742 100644
--- a/include/linux/resource.h
+++ b/include/linux/resource.h
@@ -3,6 +3,8 @@
 
 #include <linux/time.h>
 
+struct task_struct;
+
 /*
  * Resource control/accounting header file for linux
  */
@@ -67,4 +69,6 @@ struct rlimit {
  */
 #include <asm/resource.h>
 
+int getrusage(struct task_struct *p, int who, struct rusage __user *ru);
+
 #endif
diff --git a/include/linux/rtc-v3020.h b/include/linux/rtc-v3020.h
new file mode 100644
index 000000000000..bf74e63c98fe
--- /dev/null
+++ b/include/linux/rtc-v3020.h
@@ -0,0 +1,35 @@
+/*
+ * v3020.h - Registers definition and platform data structure for the v3020 RTC.
+ *
+ * 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 (C) 2006, 8D Technologies inc.
+ */
+#ifndef __LINUX_V3020_H
+#define __LINUX_V3020_H
+
+/* The v3020 has only one data pin but which one
+ * is used depends on the board. */
+struct v3020_platform_data {
+        int leftshift; /* (1<<(leftshift)) & readl() */
+};
+
+#define V3020_STATUS_0  0x00
+#define V3020_STATUS_1  0x01
+#define V3020_SECONDS   0x02
+#define V3020_MINUTES   0x03
+#define V3020_HOURS             0x04
+#define V3020_MONTH_DAY 0x05
+#define V3020_MONTH             0x06
+#define V3020_YEAR              0x07
+#define V3020_WEEK_DAY  0x08
+#define V3020_WEEK              0x09
+
+#define V3020_IS_COMMAND(val) ((val)>=0x0E)
+
+#define V3020_CMD_RAM2CLOCK     0x0E
+#define V3020_CMD_CLOCK2RAM     0x0F
+
+#endif /* __LINUX_V3020_H */
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index ab61cd1199f2..36e2bf4b4315 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -102,6 +102,7 @@ struct rtc_pll_info {
 #include <linux/interrupt.h>
 
 extern int rtc_month_days(unsigned int month, unsigned int year);
+extern int rtc_year_days(unsigned int day, unsigned int month, unsigned int year);
 extern int rtc_valid_tm(struct rtc_time *tm);
 extern int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time);
 extern void rtc_time_to_tm(unsigned long time, struct rtc_time *tm);
@@ -155,6 +156,17 @@ struct rtc_device
         struct rtc_task *irq_task;
         spinlock_t irq_task_lock;
         int irq_freq;
+        int max_user_freq;
+#ifdef CONFIG_RTC_INTF_DEV_UIE_EMUL
+        struct work_struct uie_task;
+        struct timer_list uie_timer;
+        /* Those fields are protected by rtc->irq_lock */
+        unsigned int oldsecs;
+        unsigned int irq_active:1;
+        unsigned int stop_uie_polling:1;
+        unsigned int uie_task_active:1;
+        unsigned int uie_timer_active:1;
+#endif
 };
 #define to_rtc_device(d) container_of(d, struct rtc_device, class_dev)
 
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 38b4791e6a5d..8d11d9310db0 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -358,6 +358,14 @@ struct sighand_struct {
         spinlock_t              siglock;
 };
 
+struct pacct_struct {
+        int                     ac_flag;
+        long                    ac_exitcode;
+        unsigned long           ac_mem;
+        cputime_t               ac_utime, ac_stime;
+        unsigned long           ac_minflt, ac_majflt;
+};
+
 /*
  * NOTE! "signal_struct" does not have it's own
  * locking, because a shared signal_struct always
@@ -449,6 +457,9 @@ struct signal_struct {
         struct key *session_keyring;    /* keyring inherited over fork */
         struct key *process_keyring;    /* keyring private to this process */
 #endif
+#ifdef CONFIG_BSD_PROCESS_ACCT
+        struct pacct_struct pacct;      /* per-process accounting information */
+#endif
 };
 
 /* Context switch must be unlocked if interrupts are to be enabled */
diff --git a/include/linux/synclink.h b/include/linux/synclink.h
index 2993302f7923..0577f5284cbc 100644
--- a/include/linux/synclink.h
+++ b/include/linux/synclink.h
@@ -1,7 +1,7 @@
 /*
  * SyncLink Multiprotocol Serial Adapter Driver
  *
- * $Id: synclink.h,v 3.11 2006/02/06 21:20:29 paulkf Exp $
+ * $Id: synclink.h,v 3.13 2006/05/23 18:25:06 paulkf Exp $
  *
  * Copyright (C) 1998-2000 by Microgate Corporation
  *
@@ -97,6 +97,8 @@
 #define HDLC_TXIDLE_ALT_MARK_SPACE      4
 #define HDLC_TXIDLE_SPACE               5
 #define HDLC_TXIDLE_MARK                6
+#define HDLC_TXIDLE_CUSTOM_8            0x10000000
+#define HDLC_TXIDLE_CUSTOM_16           0x20000000
 
 #define HDLC_ENCODING_NRZ                       0
 #define HDLC_ENCODING_NRZB                      1
@@ -170,6 +172,7 @@ typedef struct _MGSL_PARAMS
 #define SYNCLINK_GT_DEVICE_ID 0x0070
 #define SYNCLINK_GT4_DEVICE_ID 0x0080
 #define SYNCLINK_AC_DEVICE_ID  0x0090
+#define SYNCLINK_GT2_DEVICE_ID 0x00A0
 #define MGSL_MAX_SERIAL_NUMBER 30
 
 /*
diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h
index c7132029af0f..6a60770984e9 100644
--- a/include/linux/sysctl.h
+++ b/include/linux/sysctl.h
@@ -55,7 +55,7 @@ enum
         CTL_KERN=1,             /* General kernel info and control */
         CTL_VM=2,               /* VM management */
         CTL_NET=3,              /* Networking */
-        CTL_PROC=4,             /* Process info */
+        /* was CTL_PROC */
         CTL_FS=5,               /* Filesystems */
         CTL_DEBUG=6,            /* Debugging */
         CTL_DEV=7,              /* Devices */
@@ -767,8 +767,6 @@ enum {
         NET_BRIDGE_NF_FILTER_VLAN_TAGGED = 4,
 };
 
-/* CTL_PROC names: */
-
 /* CTL_FS names: */
 enum
 {
diff --git a/include/linux/ufs_fs.h b/include/linux/ufs_fs.h
index 86b5b4271b5a..914f911325be 100644
--- a/include/linux/ufs_fs.h
+++ b/include/linux/ufs_fs.h
@@ -220,6 +220,19 @@ typedef __u16 __bitwise __fs16;
  */
 #define UFS_MINFREE         5
 #define UFS_DEFAULTOPT      UFS_OPTTIME
+
+/*
+ * Debug code
+ */
+#ifdef CONFIG_UFS_DEBUG
+#       define UFSD(f, a...)    {                                       \
+                printk ("UFSD (%s, %d): %s:",                           \
+                        __FILE__, __LINE__, __FUNCTION__);              \
+                printk (f, ## a);                                       \
+        }
+#else
+#       define UFSD(f, a...)    /**/
+#endif
             
 /*
  * Turn file system block numbers into disk block addresses.
@@ -339,7 +352,22 @@ struct ufs2_csum_total {
 };
 
 /*
+ * File system flags
+ */
+#define UFS_UNCLEAN      0x01    /* file system not clean at mount (unused) */
+#define UFS_DOSOFTDEP    0x02    /* file system using soft dependencies */
+#define UFS_NEEDSFSCK    0x04    /* needs sync fsck (FreeBSD compat, unused) */
+#define UFS_INDEXDIRS    0x08    /* kernel supports indexed directories */
+#define UFS_ACLS         0x10    /* file system has ACLs enabled */
+#define UFS_MULTILABEL   0x20    /* file system is MAC multi-label */
+#define UFS_FLAGS_UPDATED 0x80   /* flags have been moved to new location */
+
+#if 0
+/*
  * This is the actual superblock, as it is laid out on the disk.
+ * Do NOT use this structure, because of sizeof(ufs_super_block) > 512 and
+ * it may occupy several blocks, use
+ * struct ufs_super_block_(first,second,third) instead.
  */
 struct ufs_super_block {
         __fs32  fs_link;        /* UNUSED */
@@ -416,7 +444,7 @@ struct ufs_super_block {
         __s8    fs_fmod;        /* super block modified flag */
         __s8    fs_clean;       /* file system is clean flag */
         __s8    fs_ronly;       /* mounted read-only flag */
-        __s8    fs_flags;       /* currently unused flag */
+        __s8    fs_flags;
         union {
                 struct {
                         __s8    fs_fsmnt[UFS_MAXMNTLEN];/* name mounted on */
@@ -485,6 +513,7 @@ struct ufs_super_block {
         __fs32  fs_magic;               /* magic number */
         __u8    fs_space[1];            /* list of blocks for each rotation */
 };
+#endif/*struct ufs_super_block*/
 
 /*
  * Preference for optimization.
@@ -666,7 +695,7 @@ struct ufs_buffer_head {
 };
 
 struct ufs_cg_private_info {
-        struct ufs_cylinder_group ucg;
+        struct ufs_buffer_head c_ubh;
         __u32   c_cgx;          /* number of cylidner group */
         __u16   c_ncyl;         /* number of cyl's this cg */
         __u16   c_niblk;        /* number of inode blocks this cg */
@@ -686,6 +715,7 @@ struct ufs_cg_private_info {
 
 struct ufs_sb_private_info {
         struct ufs_buffer_head s_ubh; /* buffer containing super block */
+        struct ufs2_csum_total cs_total;
         __u32   s_sblkno;       /* offset of super-blocks in filesys */
         __u32   s_cblkno;       /* offset of cg-block in filesys */
         __u32   s_iblkno;       /* offset of inode-blocks in filesys */
@@ -824,16 +854,54 @@ struct ufs_super_block_first {
 };
 
 struct ufs_super_block_second {
-        __s8    fs_fsmnt[212];
-        __fs32  fs_cgrotor;
-        __fs32  fs_csp[UFS_MAXCSBUFS];
-        __fs32  fs_maxcluster;
-        __fs32  fs_cpc;
-        __fs16  fs_opostbl[82];
-};      
+        union {
+                struct {
+                        __s8    fs_fsmnt[212];
+                        __fs32  fs_cgrotor;
+                        __fs32  fs_csp[UFS_MAXCSBUFS];
+                        __fs32  fs_maxcluster;
+                        __fs32  fs_cpc;
+                        __fs16  fs_opostbl[82];
+                } fs_u1;
+                struct {
+                        __s8  fs_fsmnt[UFS2_MAXMNTLEN - UFS_MAXMNTLEN + 212];
+                        __u8   fs_volname[UFS2_MAXVOLLEN];
+                        __fs64  fs_swuid;
+                        __fs32  fs_pad;
+                        __fs32   fs_cgrotor;
+                        __fs32   fs_ocsp[UFS2_NOCSPTRS];
+                        __fs32   fs_contigdirs;
+                        __fs32   fs_csp;
+                        __fs32   fs_maxcluster;
+                        __fs32   fs_active;
+                        __fs32   fs_old_cpc;
+                        __fs32   fs_maxbsize;
+                        __fs64   fs_sparecon64[17];
+                        __fs64   fs_sblockloc;
+                        __fs64  cs_ndir;
+                        __fs64  cs_nbfree;
+                } fs_u2;
+        } fs_un;
+};
 
 struct ufs_super_block_third {
-        __fs16  fs_opostbl[46];
+        union {
+                struct {
+                        __fs16  fs_opostbl[46];
+                } fs_u1;
+                struct {
+                        __fs64  cs_nifree;      /* number of free inodes */
+                        __fs64  cs_nffree;      /* number of free frags */
+                        __fs64   cs_numclusters;        /* number of free clusters */
+                        __fs64   cs_spare[3];   /* future expansion */
+                        struct  ufs_timeval    fs_time;         /* last time written */
+                        __fs64    fs_size;              /* number of blocks in fs */
+                        __fs64    fs_dsize;     /* number of data blocks in fs */
+                        __fs64   fs_csaddr;     /* blk addr of cyl grp summary area */
+                        __fs64    fs_pendingblocks;/* blocks in process of being freed */
+                        __fs32    fs_pendinginodes;/*inodes in process of being freed */
+                } fs_u2;
+        } fs_un1;
         union {
                 struct {
                         __fs32  fs_sparecon[53];/* reserved for future constants */
@@ -861,7 +929,7 @@ struct ufs_super_block_third {
                         __fs32  fs_qfmask[2];   /* ~usb_fmask */
                         __fs32  fs_state;       /* file system state time stamp */
                 } fs_44;
-        } fs_u2;
+        } fs_un2;
         __fs32  fs_postblformat;
         __fs32  fs_nrpos;
         __fs32  fs_postbloff;
@@ -875,7 +943,8 @@ struct ufs_super_block_third {
 /* balloc.c */
 extern void ufs_free_fragments (struct inode *, unsigned, unsigned);
 extern void ufs_free_blocks (struct inode *, unsigned, unsigned);
-extern unsigned ufs_new_fragments (struct inode *, __fs32 *, unsigned, unsigned, unsigned, int *);
+extern unsigned ufs_new_fragments(struct inode *, __fs32 *, unsigned, unsigned,
+                                  unsigned, int *, struct page *);
 
 /* cylinder.c */
 extern struct ufs_cg_private_info * ufs_load_cylinder (struct super_block *, unsigned);
@@ -886,11 +955,12 @@ extern struct inode_operations ufs_dir_inode_operations;
 extern int ufs_add_link (struct dentry *, struct inode *);
 extern ino_t ufs_inode_by_name(struct inode *, struct dentry *);
 extern int ufs_make_empty(struct inode *, struct inode *);
-extern struct ufs_dir_entry * ufs_find_entry (struct dentry *, struct buffer_head **);
-extern int ufs_delete_entry (struct inode *, struct ufs_dir_entry *, struct buffer_head *);
+extern struct ufs_dir_entry *ufs_find_entry(struct inode *, struct dentry *, struct page **);
+extern int ufs_delete_entry(struct inode *, struct ufs_dir_entry *, struct page *);
 extern int ufs_empty_dir (struct inode *);
-extern struct ufs_dir_entry * ufs_dotdot (struct inode *, struct buffer_head **);
-extern void ufs_set_link(struct inode *, struct ufs_dir_entry *, struct buffer_head *, struct inode *);
+extern struct ufs_dir_entry *ufs_dotdot(struct inode *, struct page **);
+extern void ufs_set_link(struct inode *dir, struct ufs_dir_entry *de,
+                         struct page *page, struct inode *inode);
 
 /* file.c */
 extern struct inode_operations ufs_file_inode_operations;
@@ -903,13 +973,11 @@ extern void ufs_free_inode (struct inode *inode);
 extern struct inode * ufs_new_inode (struct inode *, int);
 
 /* inode.c */
-extern u64  ufs_frag_map (struct inode *, sector_t);
 extern void ufs_read_inode (struct inode *);
 extern void ufs_put_inode (struct inode *);
 extern int ufs_write_inode (struct inode *, int);
 extern int ufs_sync_inode (struct inode *);
 extern void ufs_delete_inode (struct inode *);
-extern struct buffer_head * ufs_getfrag (struct inode *, unsigned, int, int *);
 extern struct buffer_head * ufs_bread (struct inode *, unsigned, int, int *);
 extern int ufs_getfrag_block (struct inode *inode, sector_t fragment, struct buffer_head *bh_result, int create);
 
diff --git a/include/linux/ufs_fs_i.h b/include/linux/ufs_fs_i.h
index 21665a953978..f50ce3b0cd52 100644
--- a/include/linux/ufs_fs_i.h
+++ b/include/linux/ufs_fs_i.h
@@ -27,6 +27,7 @@ struct ufs_inode_info {
         __u32   i_oeftflag;
         __u16   i_osync;
         __u32   i_lastfrag;
+        __u32   i_dir_start_lookup;
         struct inode vfs_inode;
 };
 
diff --git a/init/Kconfig b/init/Kconfig
index df864a358221..e0358f3946a1 100644
--- a/init/Kconfig
+++ b/init/Kconfig
@@ -151,7 +151,8 @@ config BSD_PROCESS_ACCT_V3
           at <http://www.physik3.uni-rostock.de/tim/kernel/utils/acct/>.
 
 config SYSCTL
-        bool "Sysctl support"
+        bool "Sysctl support" if EMBEDDED
+        default y
         ---help---
           The sysctl interface provides a means of dynamically changing
           certain kernel parameters and variables on the fly without requiring
diff --git a/kernel/acct.c b/kernel/acct.c
index 6802020e0ceb..368c4f03fe0e 100644
--- a/kernel/acct.c
+++ b/kernel/acct.c
@@ -75,7 +75,7 @@ int acct_parm[3] = {4, 2, 30};
 /*
  * External references and all of the globals.
  */
-static void do_acct_process(long, struct file *);
+static void do_acct_process(struct file *);
 
 /*
  * This structure is used so that all the data protected by lock
@@ -196,7 +196,7 @@ static void acct_file_reopen(struct file *file)
         if (old_acct) {
                 mnt_unpin(old_acct->f_vfsmnt);
                 spin_unlock(&acct_globals.lock);
-                do_acct_process(0, old_acct);
+                do_acct_process(old_acct);
                 filp_close(old_acct, NULL);
                 spin_lock(&acct_globals.lock);
         }
@@ -419,16 +419,15 @@ static u32 encode_float(u64 value)
 /*
  *  do_acct_process does all actual work. Caller holds the reference to file.
  */
-static void do_acct_process(long exitcode, struct file *file)
+static void do_acct_process(struct file *file)
 {
+        struct pacct_struct *pacct = &current->signal->pacct;
         acct_t ac;
         mm_segment_t fs;
-        unsigned long vsize;
         unsigned long flim;
         u64 elapsed;
         u64 run_time;
         struct timespec uptime;
-        unsigned long jiffies;
 
         /*
          * First check to see if there is enough free_space to continue
@@ -469,12 +468,6 @@ static void do_acct_process(long exitcode, struct file *file)
 #endif
         do_div(elapsed, AHZ);
         ac.ac_btime = xtime.tv_sec - elapsed;
-        jiffies = cputime_to_jiffies(cputime_add(current->utime,
-                                                 current->signal->utime));
-        ac.ac_utime = encode_comp_t(jiffies_to_AHZ(jiffies));
-        jiffies = cputime_to_jiffies(cputime_add(current->stime,
-                                                 current->signal->stime));
-        ac.ac_stime = encode_comp_t(jiffies_to_AHZ(jiffies));
         /* we really need to bite the bullet and change layout */
         ac.ac_uid = current->uid;
         ac.ac_gid = current->gid;
@@ -496,37 +489,18 @@ static void do_acct_process(long exitcode, struct file *file)
                 old_encode_dev(tty_devnum(current->signal->tty)) : 0;
         read_unlock(&tasklist_lock);
 
-        ac.ac_flag = 0;
-        if (current->flags & PF_FORKNOEXEC)
-                ac.ac_flag |= AFORK;
-        if (current->flags & PF_SUPERPRIV)
-                ac.ac_flag |= ASU;
-        if (current->flags & PF_DUMPCORE)
-                ac.ac_flag |= ACORE;
-        if (current->flags & PF_SIGNALED)
-                ac.ac_flag |= AXSIG;
-
-        vsize = 0;
-        if (current->mm) {
-                struct vm_area_struct *vma;
-                down_read(&current->mm->mmap_sem);
-                vma = current->mm->mmap;
-                while (vma) {
-                        vsize += vma->vm_end - vma->vm_start;
-                        vma = vma->vm_next;
-                }
-                up_read(&current->mm->mmap_sem);
-        }
-        vsize = vsize / 1024;
-        ac.ac_mem = encode_comp_t(vsize);
+        spin_lock(&current->sighand->siglock);
+        ac.ac_utime = encode_comp_t(jiffies_to_AHZ(cputime_to_jiffies(pacct->ac_utime)));
+        ac.ac_stime = encode_comp_t(jiffies_to_AHZ(cputime_to_jiffies(pacct->ac_stime)));
+        ac.ac_flag = pacct->ac_flag;
+        ac.ac_mem = encode_comp_t(pacct->ac_mem);
+        ac.ac_minflt = encode_comp_t(pacct->ac_minflt);
+        ac.ac_majflt = encode_comp_t(pacct->ac_majflt);
+        ac.ac_exitcode = pacct->ac_exitcode;
+        spin_unlock(&current->sighand->siglock);
         ac.ac_io = encode_comp_t(0 /* current->io_usage */);    /* %% */
         ac.ac_rw = encode_comp_t(ac.ac_io / 1024);
-        ac.ac_minflt = encode_comp_t(current->signal->min_flt +
-                                     current->min_flt);
-        ac.ac_majflt = encode_comp_t(current->signal->maj_flt +
-                                     current->maj_flt);
         ac.ac_swaps = encode_comp_t(0);
-        ac.ac_exitcode = exitcode;
 
         /*
          * Kernel segment override to datasegment and write it
@@ -546,12 +520,63 @@ static void do_acct_process(long exitcode, struct file *file)
 }
 
 /**
+ * acct_init_pacct - initialize a new pacct_struct
+ */
+void acct_init_pacct(struct pacct_struct *pacct)
+{
+        memset(pacct, 0, sizeof(struct pacct_struct));
+        pacct->ac_utime = pacct->ac_stime = cputime_zero;
+}
+
+/**
+ * acct_collect - collect accounting information into pacct_struct
+ * @exitcode: task exit code
+ * @group_dead: not 0, if this thread is the last one in the process.
+ */
+void acct_collect(long exitcode, int group_dead)
+{
+        struct pacct_struct *pacct = &current->signal->pacct;
+        unsigned long vsize = 0;
+
+        if (group_dead && current->mm) {
+                struct vm_area_struct *vma;
+                down_read(&current->mm->mmap_sem);
+                vma = current->mm->mmap;
+                while (vma) {
+                        vsize += vma->vm_end - vma->vm_start;
+                        vma = vma->vm_next;
+                }
+                up_read(&current->mm->mmap_sem);
+        }
+
+        spin_lock_irq(&current->sighand->siglock);
+        if (group_dead)
+                pacct->ac_mem = vsize / 1024;
+        if (thread_group_leader(current)) {
+                pacct->ac_exitcode = exitcode;
+                if (current->flags & PF_FORKNOEXEC)
+                        pacct->ac_flag |= AFORK;
+        }
+        if (current->flags & PF_SUPERPRIV)
+                pacct->ac_flag |= ASU;
+        if (current->flags & PF_DUMPCORE)
+                pacct->ac_flag |= ACORE;
+        if (current->flags & PF_SIGNALED)
+                pacct->ac_flag |= AXSIG;
+        pacct->ac_utime = cputime_add(pacct->ac_utime, current->utime);
+        pacct->ac_stime = cputime_add(pacct->ac_stime, current->stime);
+        pacct->ac_minflt += current->min_flt;
+        pacct->ac_majflt += current->maj_flt;
+        spin_unlock_irq(&current->sighand->siglock);
+}
+
+/**
  * acct_process - now just a wrapper around do_acct_process
  * @exitcode: task exit code
  *
  * handles process accounting for an exiting task
  */
-void acct_process(long exitcode)
+void acct_process()
 {
         struct file *file = NULL;
 
@@ -570,7 +595,7 @@ void acct_process(long exitcode)
         get_file(file);
         spin_unlock(&acct_globals.lock);
 
-        do_acct_process(exitcode, file);
+        do_acct_process(file);
         fput(file);
 }
 
@@ -599,9 +624,7 @@ void acct_update_integrals(struct task_struct *tsk)
  */
 void acct_clear_integrals(struct task_struct *tsk)
 {
-        if (tsk) {
-                tsk->acct_stimexpd = 0;
-                tsk->acct_rss_mem1 = 0;
-                tsk->acct_vm_mem1 = 0;
-        }
+        tsk->acct_stimexpd = 0;
+        tsk->acct_rss_mem1 = 0;
+        tsk->acct_vm_mem1 = 0;
 }
diff --git a/kernel/compat.c b/kernel/compat.c
index 2f672332430f..126dee9530aa 100644
--- a/kernel/compat.c
+++ b/kernel/compat.c
@@ -730,17 +730,10 @@ void
 sigset_from_compat (sigset_t *set, compat_sigset_t *compat)
 {
         switch (_NSIG_WORDS) {
-#if defined (__COMPAT_ENDIAN_SWAP__)
-        case 4: set->sig[3] = compat->sig[7] | (((long)compat->sig[6]) << 32 );
-        case 3: set->sig[2] = compat->sig[5] | (((long)compat->sig[4]) << 32 );
-        case 2: set->sig[1] = compat->sig[3] | (((long)compat->sig[2]) << 32 );
-        case 1: set->sig[0] = compat->sig[1] | (((long)compat->sig[0]) << 32 );
-#else
         case 4: set->sig[3] = compat->sig[6] | (((long)compat->sig[7]) << 32 );
         case 3: set->sig[2] = compat->sig[4] | (((long)compat->sig[5]) << 32 );
         case 2: set->sig[1] = compat->sig[2] | (((long)compat->sig[3]) << 32 );
         case 1: set->sig[0] = compat->sig[0] | (((long)compat->sig[1]) << 32 );
-#endif
         }
 }
 
diff --git a/kernel/exit.c b/kernel/exit.c
index a3baf92462bd..e76bd02e930e 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -36,6 +36,7 @@
 #include <linux/compat.h>
 #include <linux/pipe_fs_i.h>
 #include <linux/audit.h> /* for audit_free() */
+#include <linux/resource.h>
 
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
@@ -45,8 +46,6 @@
 extern void sem_exit (void);
 extern struct task_struct *child_reaper;
 
-int getrusage(struct task_struct *, int, struct rusage __user *);
-
 static void exit_mm(struct task_struct * tsk);
 
 static void __unhash_process(struct task_struct *p)
@@ -895,11 +894,11 @@ fastcall NORET_TYPE void do_exit(long code)
         if (group_dead) {
                 hrtimer_cancel(&tsk->signal->real_timer);
                 exit_itimers(tsk->signal);
-                acct_process(code);
         }
+        acct_collect(code, group_dead);
         if (unlikely(tsk->robust_list))
                 exit_robust_list(tsk);
-#ifdef CONFIG_COMPAT
+#if defined(CONFIG_FUTEX) && defined(CONFIG_COMPAT)
         if (unlikely(tsk->compat_robust_list))
                 compat_exit_robust_list(tsk);
 #endif
@@ -907,6 +906,8 @@ fastcall NORET_TYPE void do_exit(long code)
                 audit_free(tsk);
         exit_mm(tsk);
 
+        if (group_dead)
+                acct_process();
         exit_sem(tsk);
         __exit_files(tsk);
         __exit_fs(tsk);
diff --git a/kernel/fork.c b/kernel/fork.c
index 49adc0e8d47c..dfd10cb370c3 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -874,6 +874,7 @@ static inline int copy_signal(unsigned long clone_flags, struct task_struct * ts
                 tsk->it_prof_expires =
                         secs_to_cputime(sig->rlim[RLIMIT_CPU].rlim_cur);
         }
+        acct_init_pacct(&sig->pacct);
 
         return 0;
 }
diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index 18324305724a..55601b3ce60e 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -98,7 +98,6 @@ static DEFINE_PER_CPU(struct hrtimer_base, hrtimer_bases[MAX_HRTIMER_BASES]) =
 
 /**
  * ktime_get_ts - get the monotonic clock in timespec format
- *
  * @ts:         pointer to timespec variable
  *
  * The function calculates the monotonic clock from the realtime
@@ -238,7 +237,6 @@ lock_hrtimer_base(const struct hrtimer *timer, unsigned long *flags)
 # ifndef CONFIG_KTIME_SCALAR
 /**
  * ktime_add_ns - Add a scalar nanoseconds value to a ktime_t variable
- *
  * @kt:         addend
  * @nsec:       the scalar nsec value to add
  *
@@ -299,7 +297,6 @@ void unlock_hrtimer_base(const struct hrtimer *timer, unsigned long *flags)
 
 /**
  * hrtimer_forward - forward the timer expiry
- *
  * @timer:      hrtimer to forward
  * @now:        forward past this time
  * @interval:   the interval to forward
@@ -411,7 +408,6 @@ remove_hrtimer(struct hrtimer *timer, struct hrtimer_base *base)
 
 /**
  * hrtimer_start - (re)start an relative timer on the current CPU
- *
  * @timer:      the timer to be added
  * @tim:        expiry time
  * @mode:       expiry mode: absolute (HRTIMER_ABS) or relative (HRTIMER_REL)
@@ -460,14 +456,13 @@ EXPORT_SYMBOL_GPL(hrtimer_start);
 
 /**
  * hrtimer_try_to_cancel - try to deactivate a timer
- *
  * @timer:      hrtimer to stop
  *
  * Returns:
  *  0 when the timer was not active
  *  1 when the timer was active
  * -1 when the timer is currently excuting the callback function and
- *    can not be stopped
+ *    cannot be stopped
  */
 int hrtimer_try_to_cancel(struct hrtimer *timer)
 {
@@ -489,7 +484,6 @@ EXPORT_SYMBOL_GPL(hrtimer_try_to_cancel);
 
 /**
  * hrtimer_cancel - cancel a timer and wait for the handler to finish.
- *
  * @timer:      the timer to be cancelled
  *
  * Returns:
@@ -510,7 +504,6 @@ EXPORT_SYMBOL_GPL(hrtimer_cancel);
 
 /**
  * hrtimer_get_remaining - get remaining time for the timer
- *
  * @timer:      the timer to read
  */
 ktime_t hrtimer_get_remaining(const struct hrtimer *timer)
@@ -564,7 +557,6 @@ ktime_t hrtimer_get_next_event(void)
 
 /**
  * hrtimer_init - initialize a timer to the given clock
- *
  * @timer:      the timer to be initialized
  * @clock_id:   the clock to be used
  * @mode:       timer mode abs/rel
@@ -576,7 +568,7 @@ void hrtimer_init(struct hrtimer *timer, clockid_t clock_id,
 
         memset(timer, 0, sizeof(struct hrtimer));
 
-        bases = per_cpu(hrtimer_bases, raw_smp_processor_id());
+        bases = __raw_get_cpu_var(hrtimer_bases);
 
         if (clock_id == CLOCK_REALTIME && mode != HRTIMER_ABS)
                 clock_id = CLOCK_MONOTONIC;
@@ -588,7 +580,6 @@ EXPORT_SYMBOL_GPL(hrtimer_init);
 
 /**
  * hrtimer_get_res - get the timer resolution for a clock
- *
  * @which_clock: which clock to query
  * @tp:          pointer to timespec variable to store the resolution
  *
@@ -599,7 +590,7 @@ int hrtimer_get_res(const clockid_t which_clock, struct timespec *tp)
 {
         struct hrtimer_base *bases;
 
-        bases = per_cpu(hrtimer_bases, raw_smp_processor_id());
+        bases = __raw_get_cpu_var(hrtimer_bases);
         *tp = ktime_to_timespec(bases[which_clock].resolution);
 
         return 0;
diff --git a/kernel/kthread.c b/kernel/kthread.c
index c5f3c6613b6d..24be714b04c7 100644
--- a/kernel/kthread.c
+++ b/kernel/kthread.c
@@ -45,6 +45,13 @@ struct kthread_stop_info
 static DEFINE_MUTEX(kthread_stop_lock);
 static struct kthread_stop_info kthread_stop_info;
 
+/**
+ * kthread_should_stop - should this kthread return now?
+ *
+ * When someone calls kthread_stop on your kthread, it will be woken
+ * and this will return true.  You should then return, and your return
+ * value will be passed through to kthread_stop().
+ */
 int kthread_should_stop(void)
 {
         return (kthread_stop_info.k == current);
@@ -122,6 +129,25 @@ static void keventd_create_kthread(void *_create)
         complete(&create->done);
 }
 
+/**
+ * kthread_create - create a kthread.
+ * @threadfn: the function to run until signal_pending(current).
+ * @data: data ptr for @threadfn.
+ * @namefmt: printf-style name for the thread.
+ *
+ * Description: This helper function creates and names a kernel
+ * thread.  The thread will be stopped: use wake_up_process() to start
+ * it.  See also kthread_run(), kthread_create_on_cpu().
+ *
+ * When woken, the thread will run @threadfn() with @data as its
+ * argument. @threadfn can either call do_exit() directly if it is a
+ * standalone thread for which noone will call kthread_stop(), or
+ * return when 'kthread_should_stop()' is true (which means
+ * kthread_stop() has been called).  The return value should be zero
+ * or a negative error number; it will be passed to kthread_stop().
+ *
+ * Returns a task_struct or ERR_PTR(-ENOMEM).
+ */
 struct task_struct *kthread_create(int (*threadfn)(void *data),
                                    void *data,
                                    const char namefmt[],
@@ -156,6 +182,15 @@ struct task_struct *kthread_create(int (*threadfn)(void *data),
 }
 EXPORT_SYMBOL(kthread_create);
 
+/**
+ * kthread_bind - bind a just-created kthread to a cpu.
+ * @k: thread created by kthread_create().
+ * @cpu: cpu (might not be online, must be possible) for @k to run on.
+ *
+ * Description: This function is equivalent to set_cpus_allowed(),
+ * except that @cpu doesn't need to be online, and the thread must be
+ * stopped (i.e., just returned from kthread_create().
+ */
 void kthread_bind(struct task_struct *k, unsigned int cpu)
 {
         BUG_ON(k->state != TASK_INTERRUPTIBLE);
@@ -166,12 +201,36 @@ void kthread_bind(struct task_struct *k, unsigned int cpu)
 }
 EXPORT_SYMBOL(kthread_bind);
 
+/**
+ * kthread_stop - stop a thread created by kthread_create().
+ * @k: thread created by kthread_create().
+ *
+ * Sets kthread_should_stop() for @k to return true, wakes it, and
+ * waits for it to exit.  Your threadfn() must not call do_exit()
+ * itself if you use this function!  This can also be called after
+ * kthread_create() instead of calling wake_up_process(): the thread
+ * will exit without calling threadfn().
+ *
+ * Returns the result of threadfn(), or %-EINTR if wake_up_process()
+ * was never called.
+ */
 int kthread_stop(struct task_struct *k)
 {
         return kthread_stop_sem(k, NULL);
 }
 EXPORT_SYMBOL(kthread_stop);
 
+/**
+ * kthread_stop_sem - stop a thread created by kthread_create().
+ * @k: thread created by kthread_create().
+ * @s: semaphore that @k waits on while idle.
+ *
+ * Does essentially the same thing as kthread_stop() above, but wakes
+ * @k by calling up(@s).
+ *
+ * Returns the result of threadfn(), or %-EINTR if wake_up_process()
+ * was never called.
+ */
 int kthread_stop_sem(struct task_struct *k, struct semaphore *s)
 {
         int ret;
@@ -210,5 +269,5 @@ static __init int helper_init(void)
 
         return 0;
 }
-core_initcall(helper_init);
 
+core_initcall(helper_init);
diff --git a/kernel/module.c b/kernel/module.c
index bbe04862e1b0..d75275de1c28 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -1326,7 +1326,7 @@ int is_exported(const char *name, const struct module *mod)
         if (!mod && lookup_symbol(name, __start___ksymtab, __stop___ksymtab))
                 return 1;
         else
-                if (lookup_symbol(name, mod->syms, mod->syms + mod->num_syms))
+                if (mod && lookup_symbol(name, mod->syms, mod->syms + mod->num_syms))
                         return 1;
                 else
                         return 0;
diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig
index cdf315e794ff..fc311a4673a2 100644
--- a/kernel/power/Kconfig
+++ b/kernel/power/Kconfig
@@ -38,7 +38,7 @@ config PM_DEBUG
 
 config PM_TRACE
         bool "Suspend/resume event tracing"
-        depends on PM && PM_DEBUG && X86
+        depends on PM && PM_DEBUG && X86_32
         default y
         ---help---
         This enables some cheesy code to save the last PM event point in the
diff --git a/kernel/power/disk.c b/kernel/power/disk.c
index 81d4d982f3f0..e13e74067845 100644
--- a/kernel/power/disk.c
+++ b/kernel/power/disk.c
@@ -231,7 +231,7 @@ static int software_resume(void)
 late_initcall(software_resume);
 
 
-static char * pm_disk_modes[] = {
+static const char * const pm_disk_modes[] = {
         [PM_DISK_FIRMWARE]      = "firmware",
         [PM_DISK_PLATFORM]      = "platform",
         [PM_DISK_SHUTDOWN]      = "shutdown",
diff --git a/kernel/power/main.c b/kernel/power/main.c
index cdf0f07af92f..6d295c776794 100644
--- a/kernel/power/main.c
+++ b/kernel/power/main.c
@@ -145,7 +145,7 @@ static void suspend_finish(suspend_state_t state)
 
 
 
-static char *pm_states[PM_SUSPEND_MAX] = {
+static const char * const pm_states[PM_SUSPEND_MAX] = {
         [PM_SUSPEND_STANDBY]    = "standby",
         [PM_SUSPEND_MEM]        = "mem",
 #ifdef CONFIG_SOFTWARE_SUSPEND
@@ -262,7 +262,7 @@ static ssize_t state_show(struct subsystem * subsys, char * buf)
 static ssize_t state_store(struct subsystem * subsys, const char * buf, size_t n)
 {
         suspend_state_t state = PM_SUSPEND_STANDBY;
-        char ** s;
+        const char * const *s;
         char *p;
         int error;
         int len;
diff --git a/kernel/printk.c b/kernel/printk.c
index 19a955619294..95b7fe17f124 100644
--- a/kernel/printk.c
+++ b/kernel/printk.c
@@ -24,6 +24,7 @@
 #include <linux/console.h>
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/moduleparam.h>
 #include <linux/interrupt.h>                    /* For in_interrupt() */
 #include <linux/config.h>
 #include <linux/delay.h>
@@ -327,7 +328,9 @@ static void __call_console_drivers(unsigned long start, unsigned long end)
         struct console *con;
 
         for (con = console_drivers; con; con = con->next) {
-                if ((con->flags & CON_ENABLED) && con->write)
+                if ((con->flags & CON_ENABLED) && con->write &&
+                                (cpu_online(smp_processor_id()) ||
+                                (con->flags & CON_ANYTIME)))
                         con->write(con, &LOG_BUF(start), end - start);
         }
 }
@@ -437,6 +440,7 @@ static int printk_time = 1;
 #else
 static int printk_time = 0;
 #endif
+module_param(printk_time, int, S_IRUGO | S_IWUSR);
 
 static int __init printk_time_setup(char *str)
 {
@@ -453,6 +457,18 @@ __attribute__((weak)) unsigned long long printk_clock(void)
         return sched_clock();
 }
 
+/* Check if we have any console registered that can be called early in boot. */
+static int have_callable_console(void)
+{
+        struct console *con;
+
+        for (con = console_drivers; con; con = con->next)
+                if (con->flags & CON_ANYTIME)
+                        return 1;
+
+        return 0;
+}
+
 /**
  * printk - print a kernel message
  * @fmt: format string
@@ -566,27 +582,29 @@ asmlinkage int vprintk(const char *fmt, va_list args)
                         log_level_unknown = 1;
         }
 
-        if (!cpu_online(smp_processor_id())) {
+        if (!down_trylock(&console_sem)) {
                 /*
-                 * Some console drivers may assume that per-cpu resources have
-                 * been allocated.  So don't allow them to be called by this
-                 * CPU until it is officially up.  We shouldn't be calling into
-                 * random console drivers on a CPU which doesn't exist yet..
+                 * We own the drivers.  We can drop the spinlock and
+                 * let release_console_sem() print the text, maybe ...
                  */
+                console_locked = 1;
                 printk_cpu = UINT_MAX;
                 spin_unlock_irqrestore(&logbuf_lock, flags);
-                goto out;
-        }
-        if (!down_trylock(&console_sem)) {
-                console_locked = 1;
+
                 /*
-                 * We own the drivers.  We can drop the spinlock and let
-                 * release_console_sem() print the text
+                 * Console drivers may assume that per-cpu resources have
+                 * been allocated. So unless they're explicitly marked as
+                 * being able to cope (CON_ANYTIME) don't call them until
+                 * this CPU is officially up.
                  */
-                printk_cpu = UINT_MAX;
-                spin_unlock_irqrestore(&logbuf_lock, flags);
-                console_may_schedule = 0;
-                release_console_sem();
+                if (cpu_online(smp_processor_id()) || have_callable_console()) {
+                        console_may_schedule = 0;
+                        release_console_sem();
+                } else {
+                        /* Release by hand to avoid flushing the buffer. */
+                        console_locked = 0;
+                        up(&console_sem);
+                }
         } else {
                 /*
                  * Someone else owns the drivers.  We drop the spinlock, which
@@ -596,7 +614,7 @@ asmlinkage int vprintk(const char *fmt, va_list args)
                 printk_cpu = UINT_MAX;
                 spin_unlock_irqrestore(&logbuf_lock, flags);
         }
-out:
+
         preempt_enable();
         return printed_len;
 }
diff --git a/kernel/sched.c b/kernel/sched.c
index 5dbc42694477..f06d059edef5 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -4152,7 +4152,7 @@ EXPORT_SYMBOL(yield);
  */
 void __sched io_schedule(void)
 {
-        struct runqueue *rq = &per_cpu(runqueues, raw_smp_processor_id());
+        struct runqueue *rq = &__raw_get_cpu_var(runqueues);
 
         atomic_inc(&rq->nr_iowait);
         schedule();
@@ -4163,7 +4163,7 @@ EXPORT_SYMBOL(io_schedule);
 
 long __sched io_schedule_timeout(long timeout)
 {
-        struct runqueue *rq = &per_cpu(runqueues, raw_smp_processor_id());
+        struct runqueue *rq = &__raw_get_cpu_var(runqueues);
         long ret;
 
         atomic_inc(&rq->nr_iowait);
@@ -4756,6 +4756,8 @@ static int migration_call(struct notifier_block *nfb, unsigned long action,
                 break;
 #ifdef CONFIG_HOTPLUG_CPU
         case CPU_UP_CANCELED:
+                if (!cpu_rq(cpu)->migration_thread)
+                        break;
                 /* Unbind it from offline cpu so it can run.  Fall thru. */
                 kthread_bind(cpu_rq(cpu)->migration_thread,
                              any_online_cpu(cpu_online_map));
diff --git a/kernel/softirq.c b/kernel/softirq.c
index 336f92d64e2e..9e2f1c6e73d7 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -470,6 +470,8 @@ static int cpu_callback(struct notifier_block *nfb,
                 break;
 #ifdef CONFIG_HOTPLUG_CPU
         case CPU_UP_CANCELED:
+                if (!per_cpu(ksoftirqd, hotcpu))
+                        break;
                 /* Unbind so it can run.  Fall thru. */
                 kthread_bind(per_cpu(ksoftirqd, hotcpu),
                              any_online_cpu(cpu_online_map));
diff --git a/kernel/softlockup.c b/kernel/softlockup.c
index 14c7faf02909..b5c3b94e01ce 100644
--- a/kernel/softlockup.c
+++ b/kernel/softlockup.c
@@ -36,7 +36,7 @@ static struct notifier_block panic_block = {
 
 void touch_softlockup_watchdog(void)
 {
-        per_cpu(touch_timestamp, raw_smp_processor_id()) = jiffies;
+        __raw_get_cpu_var(touch_timestamp) = jiffies;
 }
 EXPORT_SYMBOL(touch_softlockup_watchdog);
 
@@ -127,6 +127,8 @@ cpu_callback(struct notifier_block *nfb, unsigned long action, void *hcpu)
                 break;
 #ifdef CONFIG_HOTPLUG_CPU
         case CPU_UP_CANCELED:
+                if (!per_cpu(watchdog_task, hotcpu))
+                        break;
                 /* Unbind so it can run.  Fall thru. */
                 kthread_bind(per_cpu(watchdog_task, hotcpu),
                              any_online_cpu(cpu_online_map));
diff --git a/kernel/stop_machine.c b/kernel/stop_machine.c
index dcfb5d731466..2c0aacc37c55 100644
--- a/kernel/stop_machine.c
+++ b/kernel/stop_machine.c
@@ -4,6 +4,7 @@
 #include <linux/cpu.h>
 #include <linux/err.h>
 #include <linux/syscalls.h>
+#include <linux/kthread.h>
 #include <asm/atomic.h>
 #include <asm/semaphore.h>
 #include <asm/uaccess.h>
@@ -25,13 +26,11 @@ static unsigned int stopmachine_num_threads;
 static atomic_t stopmachine_thread_ack;
 static DECLARE_MUTEX(stopmachine_mutex);
 
-static int stopmachine(void *cpu)
+static int stopmachine(void *unused)
 {
         int irqs_disabled = 0;
         int prepared = 0;
 
-        set_cpus_allowed(current, cpumask_of_cpu((int)(long)cpu));
-
         /* Ack: we are alive */
         smp_mb(); /* Theoretically the ack = 0 might not be on this CPU yet. */
         atomic_inc(&stopmachine_thread_ack);
@@ -85,7 +84,8 @@ static void stopmachine_set_state(enum stopmachine_state state)
 
 static int stop_machine(void)
 {
-        int i, ret = 0;
+        int ret = 0;
+        unsigned int i;
         struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
 
         /* One high-prio thread per cpu.  We'll do this one. */
@@ -96,11 +96,16 @@ static int stop_machine(void)
         stopmachine_state = STOPMACHINE_WAIT;
 
         for_each_online_cpu(i) {
+                struct task_struct *tsk;
                 if (i == raw_smp_processor_id())
                         continue;
-                ret = kernel_thread(stopmachine, (void *)(long)i,CLONE_KERNEL);
-                if (ret < 0)
+                tsk = kthread_create(stopmachine, NULL, "stopmachine");
+                if (IS_ERR(tsk)) {
+                        ret = PTR_ERR(tsk);
                         break;
+                }
+                kthread_bind(tsk, i);
+                wake_up_process(tsk);
                 stopmachine_num_threads++;
         }
 
diff --git a/kernel/sys.c b/kernel/sys.c
index 90930b28d2ca..2d5179c67cec 100644
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -137,14 +137,15 @@ static int __kprobes notifier_call_chain(struct notifier_block **nl,
                 unsigned long val, void *v)
 {
         int ret = NOTIFY_DONE;
-        struct notifier_block *nb;
+        struct notifier_block *nb, *next_nb;
 
         nb = rcu_dereference(*nl);
         while (nb) {
+                next_nb = rcu_dereference(nb->next);
                 ret = nb->notifier_call(nb, val, v);
                 if ((ret & NOTIFY_STOP_MASK) == NOTIFY_STOP_MASK)
                         break;
-                nb = rcu_dereference(nb->next);
+                nb = next_nb;
         }
         return ret;
 }
@@ -588,7 +589,7 @@ void emergency_restart(void)
 }
 EXPORT_SYMBOL_GPL(emergency_restart);
 
-void kernel_restart_prepare(char *cmd)
+static void kernel_restart_prepare(char *cmd)
 {
         blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
         system_state = SYSTEM_RESTART;
@@ -622,7 +623,7 @@ EXPORT_SYMBOL_GPL(kernel_restart);
  *      Move into place and start executing a preloaded standalone
  *      executable.  If nothing was preloaded return an error.
  */
-void kernel_kexec(void)
+static void kernel_kexec(void)
 {
 #ifdef CONFIG_KEXEC
         struct kimage *image;
@@ -636,7 +637,6 @@ void kernel_kexec(void)
         machine_kexec(image);
 #endif
 }
-EXPORT_SYMBOL_GPL(kernel_kexec);
 
 void kernel_shutdown_prepare(enum system_states state)
 {
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index eb8bd214e7d7..2c0e65819448 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -143,7 +143,6 @@ static struct ctl_table_header root_table_header =
 
 static ctl_table kern_table[];
 static ctl_table vm_table[];
-static ctl_table proc_table[];
 static ctl_table fs_table[];
 static ctl_table debug_table[];
 static ctl_table dev_table[];
@@ -203,12 +202,6 @@ static ctl_table root_table[] = {
         },
 #endif
         {
-                .ctl_name       = CTL_PROC,
-                .procname       = "proc",
-                .mode           = 0555,
-                .child          = proc_table,
-        },
-        {
                 .ctl_name       = CTL_FS,
                 .procname       = "fs",
                 .mode           = 0555,
@@ -927,10 +920,6 @@ static ctl_table vm_table[] = {
         { .ctl_name = 0 }
 };
 
-static ctl_table proc_table[] = {
-        { .ctl_name = 0 }
-};
-
 static ctl_table fs_table[] = {
         {
                 .ctl_name       = FS_NRINODE,
diff --git a/kernel/timer.c b/kernel/timer.c
index f35b3939e937..eb97371b87d8 100644
--- a/kernel/timer.c
+++ b/kernel/timer.c
@@ -146,7 +146,7 @@ static void internal_add_timer(tvec_base_t *base, struct timer_list *timer)
 void fastcall init_timer(struct timer_list *timer)
 {
         timer->entry.next = NULL;
-        timer->base = per_cpu(tvec_bases, raw_smp_processor_id());
+        timer->base = __raw_get_cpu_var(tvec_bases);
 }
 EXPORT_SYMBOL(init_timer);
 
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 740c5abceb07..565cf7a1febd 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -428,22 +428,34 @@ int schedule_delayed_work_on(int cpu,
         return ret;
 }
 
-int schedule_on_each_cpu(void (*func) (void *info), void *info)
+/**
+ * schedule_on_each_cpu - call a function on each online CPU from keventd
+ * @func: the function to call
+ * @info: a pointer to pass to func()
+ *
+ * Returns zero on success.
+ * Returns -ve errno on failure.
+ *
+ * Appears to be racy against CPU hotplug.
+ *
+ * schedule_on_each_cpu() is very slow.
+ */
+int schedule_on_each_cpu(void (*func)(void *info), void *info)
 {
         int cpu;
-        struct work_struct *work;
+        struct work_struct *works;
 
-        work = kmalloc(NR_CPUS * sizeof(struct work_struct), GFP_KERNEL);
-
-        if (!work)
+        works = alloc_percpu(struct work_struct);
+        if (!works)
                 return -ENOMEM;
+
         for_each_online_cpu(cpu) {
-                INIT_WORK(work + cpu, func, info);
+                INIT_WORK(per_cpu_ptr(works, cpu), func, info);
                 __queue_work(per_cpu_ptr(keventd_wq->cpu_wq, cpu),
-                                work + cpu);
+                                per_cpu_ptr(works, cpu));
         }
         flush_workqueue(keventd_wq);
-        kfree(work);
+        free_percpu(works);
         return 0;
 }
 
@@ -578,6 +590,8 @@ static int workqueue_cpu_callback(struct notifier_block *nfb,
 
         case CPU_UP_CANCELED:
                 list_for_each_entry(wq, &workqueues, list) {
+                        if (!per_cpu_ptr(wq->cpu_wq, hotcpu)->thread)
+                                continue;
                         /* Unbind so it can run. */
                         kthread_bind(per_cpu_ptr(wq->cpu_wq, hotcpu)->thread,
                                      any_online_cpu(cpu_online_map));
diff --git a/lib/bitmap.c b/lib/bitmap.c
index ed2ae3b0cd06..d71e38c54ea5 100644
--- a/lib/bitmap.c
+++ b/lib/bitmap.c
@@ -317,16 +317,16 @@ EXPORT_SYMBOL(bitmap_scnprintf);
 
 /**
  * bitmap_parse - convert an ASCII hex string into a bitmap.
- * @buf: pointer to buffer in user space containing string.
- * @buflen: buffer size in bytes.  If string is smaller than this
+ * @ubuf: pointer to buffer in user space containing string.
+ * @ubuflen: buffer size in bytes.  If string is smaller than this
  *    then it must be terminated with a \0.
  * @maskp: pointer to bitmap array that will contain result.
  * @nmaskbits: size of bitmap, in bits.
  *
  * Commas group hex digits into chunks.  Each chunk defines exactly 32
  * bits of the resultant bitmask.  No chunk may specify a value larger
- * than 32 bits (-EOVERFLOW), and if a chunk specifies a smaller value
- * then leading 0-bits are prepended.  -EINVAL is returned for illegal
+ * than 32 bits (%-EOVERFLOW), and if a chunk specifies a smaller value
+ * then leading 0-bits are prepended.  %-EINVAL is returned for illegal
  * characters and for grouping errors such as "1,,5", ",44", "," and "".
  * Leading and trailing whitespace accepted, but not embedded whitespace.
  */
@@ -452,8 +452,8 @@ EXPORT_SYMBOL(bitmap_scnlistprintf);
 
 /**
  * bitmap_parselist - convert list format ASCII string to bitmap
- * @buf: read nul-terminated user string from this buffer
- * @mask: write resulting mask here
+ * @bp: read nul-terminated user string from this buffer
+ * @maskp: write resulting mask here
  * @nmaskbits: number of bits in mask to be written
  *
  * Input format is a comma-separated list of decimal numbers and
@@ -461,10 +461,11 @@ EXPORT_SYMBOL(bitmap_scnlistprintf);
  * decimal numbers, the smallest and largest bit numbers set in
  * the range.
  *
- * Returns 0 on success, -errno on invalid input strings:
- *    -EINVAL:   second number in range smaller than first
- *    -EINVAL:   invalid character in string
- *    -ERANGE:   bit number specified too large for mask
+ * Returns 0 on success, -errno on invalid input strings.
+ * Error values:
+ *    %-EINVAL: second number in range smaller than first
+ *    %-EINVAL: invalid character in string
+ *    %-ERANGE: bit number specified too large for mask
  */
 int bitmap_parselist(const char *bp, unsigned long *maskp, int nmaskbits)
 {
@@ -625,10 +626,10 @@ EXPORT_SYMBOL(bitmap_remap);
 
 /**
  * bitmap_bitremap - Apply map defined by a pair of bitmaps to a single bit
- *      @oldbit - bit position to be mapped
- *      @old: defines domain of map
- *      @new: defines range of map
- *      @bits: number of bits in each of these bitmaps
+ *      @oldbit: bit position to be mapped
+ *      @old: defines domain of map
+ *      @new: defines range of map
+ *      @bits: number of bits in each of these bitmaps
  *
  * Let @old and @new define a mapping of bit positions, such that
  * whatever position is held by the n-th set bit in @old is mapped
@@ -790,7 +791,7 @@ EXPORT_SYMBOL(bitmap_release_region);
  *
  * Allocate (set bits in) a specified region of a bitmap.
  *
- * Return 0 on success, or -EBUSY if specified region wasn't
+ * Return 0 on success, or %-EBUSY if specified region wasn't
  * free (not all bits were zero).
  */
 int bitmap_allocate_region(unsigned long *bitmap, int pos, int order)
diff --git a/lib/crc-ccitt.c b/lib/crc-ccitt.c
index 115d149af407..7f6dd68d2d09 100644
--- a/lib/crc-ccitt.c
+++ b/lib/crc-ccitt.c
@@ -53,9 +53,9 @@ EXPORT_SYMBOL(crc_ccitt_table);
 
 /**
  *      crc_ccitt - recompute the CRC for the data buffer
- *      @crc - previous CRC value
- *      @buffer - data pointer
- *      @len - number of bytes in the buffer
+ *      @crc: previous CRC value
+ *      @buffer: data pointer
+ *      @len: number of bytes in the buffer
  */
 u16 crc_ccitt(u16 crc, u8 const *buffer, size_t len)
 {
diff --git a/lib/crc16.c b/lib/crc16.c
index 011fe573c666..8737b084d1f9 100644
--- a/lib/crc16.c
+++ b/lib/crc16.c
@@ -47,12 +47,12 @@ u16 const crc16_table[256] = {
 EXPORT_SYMBOL(crc16_table);
 
 /**
- * Compute the CRC-16 for the data buffer
+ * crc16 - compute the CRC-16 for the data buffer
+ * @crc:        previous CRC value
+ * @buffer:     data pointer
+ * @len:        number of bytes in the buffer
  *
- * @param crc     previous CRC value
- * @param buffer  data pointer
- * @param len     number of bytes in the buffer
- * @return        the updated CRC value
+ * Returns the updated CRC value.
  */
 u16 crc16(u16 crc, u8 const *buffer, size_t len)
 {
diff --git a/lib/crc32.c b/lib/crc32.c
index 065198f98b3f..285fd9bc61be 100644
--- a/lib/crc32.c
+++ b/lib/crc32.c
@@ -42,20 +42,21 @@ MODULE_AUTHOR("Matt Domsch <Matt_Domsch@dell.com>");
 MODULE_DESCRIPTION("Ethernet CRC32 calculations");
 MODULE_LICENSE("GPL");
 
+/**
+ * crc32_le() - Calculate bitwise little-endian Ethernet AUTODIN II CRC32
+ * @crc: seed value for computation.  ~0 for Ethernet, sometimes 0 for
+ *      other uses, or the previous crc32 value if computing incrementally.
+ * @p: pointer to buffer over which CRC is run
+ * @len: length of buffer @p
+ */
+u32 __attribute_pure__ crc32_le(u32 crc, unsigned char const *p, size_t len);
+
 #if CRC_LE_BITS == 1
 /*
  * In fact, the table-based code will work in this case, but it can be
  * simplified by inlining the table in ?: form.
  */
 
-/**
- * crc32_le() - Calculate bitwise little-endian Ethernet AUTODIN II CRC32
- * @crc - seed value for computation.  ~0 for Ethernet, sometimes 0 for
- *        other uses, or the previous crc32 value if computing incrementally.
- * @p   - pointer to buffer over which CRC is run
- * @len - length of buffer @p
- * 
- */
 u32 __attribute_pure__ crc32_le(u32 crc, unsigned char const *p, size_t len)
 {
         int i;
@@ -68,14 +69,6 @@ u32 __attribute_pure__ crc32_le(u32 crc, unsigned char const *p, size_t len)
 }
 #else                           /* Table-based approach */
 
-/**
- * crc32_le() - Calculate bitwise little-endian Ethernet AUTODIN II CRC32
- * @crc - seed value for computation.  ~0 for Ethernet, sometimes 0 for
- *        other uses, or the previous crc32 value if computing incrementally.
- * @p   - pointer to buffer over which CRC is run
- * @len - length of buffer @p
- * 
- */
 u32 __attribute_pure__ crc32_le(u32 crc, unsigned char const *p, size_t len)
 {
 # if CRC_LE_BITS == 8
@@ -145,20 +138,21 @@ u32 __attribute_pure__ crc32_le(u32 crc, unsigned char const *p, size_t len)
 }
 #endif
 
+/**
+ * crc32_be() - Calculate bitwise big-endian Ethernet AUTODIN II CRC32
+ * @crc: seed value for computation.  ~0 for Ethernet, sometimes 0 for
+ *      other uses, or the previous crc32 value if computing incrementally.
+ * @p: pointer to buffer over which CRC is run
+ * @len: length of buffer @p
+ */
+u32 __attribute_pure__ crc32_be(u32 crc, unsigned char const *p, size_t len);
+
 #if CRC_BE_BITS == 1
 /*
  * In fact, the table-based code will work in this case, but it can be
  * simplified by inlining the table in ?: form.
  */
 
-/**
- * crc32_be() - Calculate bitwise big-endian Ethernet AUTODIN II CRC32
- * @crc - seed value for computation.  ~0 for Ethernet, sometimes 0 for
- *        other uses, or the previous crc32 value if computing incrementally.
- * @p   - pointer to buffer over which CRC is run
- * @len - length of buffer @p
- * 
- */
 u32 __attribute_pure__ crc32_be(u32 crc, unsigned char const *p, size_t len)
 {
         int i;
@@ -173,14 +167,6 @@ u32 __attribute_pure__ crc32_be(u32 crc, unsigned char const *p, size_t len)
 }
 
 #else                           /* Table-based approach */
-/**
- * crc32_be() - Calculate bitwise big-endian Ethernet AUTODIN II CRC32
- * @crc - seed value for computation.  ~0 for Ethernet, sometimes 0 for
- *        other uses, or the previous crc32 value if computing incrementally.
- * @p   - pointer to buffer over which CRC is run
- * @len - length of buffer @p
- * 
- */
 u32 __attribute_pure__ crc32_be(u32 crc, unsigned char const *p, size_t len)
 {
 # if CRC_BE_BITS == 8
@@ -249,6 +235,10 @@ u32 __attribute_pure__ crc32_be(u32 crc, unsigned char const *p, size_t len)
 }
 #endif
 
+/**
+ * bitreverse - reverse the order of bits in a u32 value
+ * @x: value to be bit-reversed
+ */
 u32 bitreverse(u32 x)
 {
         x = (x >> 16) | (x << 16);
diff --git a/lib/idr.c b/lib/idr.c
index d226259c3c28..de19030a999b 100644
--- a/lib/idr.c
+++ b/lib/idr.c
@@ -48,15 +48,21 @@ static struct idr_layer *alloc_layer(struct idr *idp)
         return(p);
 }
 
+/* only called when idp->lock is held */
+static void __free_layer(struct idr *idp, struct idr_layer *p)
+{
+        p->ary[0] = idp->id_free;
+        idp->id_free = p;
+        idp->id_free_cnt++;
+}
+
 static void free_layer(struct idr *idp, struct idr_layer *p)
 {
         /*
          * Depends on the return element being zeroed.
          */
         spin_lock(&idp->lock);
-        p->ary[0] = idp->id_free;
-        idp->id_free = p;
-        idp->id_free_cnt++;
+        __free_layer(idp, p);
         spin_unlock(&idp->lock);
 }
 
@@ -184,12 +190,14 @@ build_up:
                          * The allocation failed.  If we built part of
                          * the structure tear it down.
                          */
+                        spin_lock(&idp->lock);
                         for (new = p; p && p != idp->top; new = p) {
                                 p = p->ary[0];
                                 new->ary[0] = NULL;
                                 new->bitmap = new->count = 0;
-                                free_layer(idp, new);
+                                __free_layer(idp, new);
                         }
+                        spin_unlock(&idp->lock);
                         return -1;
                 }
                 new->ary[0] = p;
diff --git a/lib/libcrc32c.c b/lib/libcrc32c.c
index 52b6dc144ce3..60f46803af3f 100644
--- a/lib/libcrc32c.c
+++ b/lib/libcrc32c.c
@@ -88,7 +88,7 @@ crc32c_le(u32 crc, unsigned char const *p, size_t len)
  * reflect output bytes = true
  */
 
-static u32 crc32c_table[256] = {
+static const u32 crc32c_table[256] = {
         0x00000000L, 0xF26B8303L, 0xE13B70F7L, 0x1350F3F4L,
         0xC79A971FL, 0x35F1141CL, 0x26A1E7E8L, 0xD4CA64EBL,
         0x8AD958CFL, 0x78B2DBCCL, 0x6BE22838L, 0x9989AB3BL,
diff --git a/lib/radix-tree.c b/lib/radix-tree.c
index b32efae7688e..637d55608de5 100644
--- a/lib/radix-tree.c
+++ b/lib/radix-tree.c
@@ -530,7 +530,7 @@ int radix_tree_tag_get(struct radix_tree_root *root,
                         int ret = tag_get(slot, tag, offset);
 
                         BUG_ON(ret && saw_unset_tag);
-                        return ret;
+                        return !!ret;
                 }
                 slot = slot->slots[offset];
                 shift -= RADIX_TREE_MAP_SHIFT;
diff --git a/lib/reed_solomon/reed_solomon.c b/lib/reed_solomon/reed_solomon.c
index f8ac9fa95de1..2cc11faa4ff1 100644
--- a/lib/reed_solomon/reed_solomon.c
+++ b/lib/reed_solomon/reed_solomon.c
@@ -54,7 +54,6 @@ static DEFINE_MUTEX(rslistlock);
 
 /**
  * rs_init - Initialize a Reed-Solomon codec
- *
  * @symsize:    symbol size, bits (1-8)
  * @gfpoly:     Field generator polynomial coefficients
  * @fcr:        first root of RS code generator polynomial, index form
@@ -62,7 +61,7 @@ static DEFINE_MUTEX(rslistlock);
  * @nroots:     RS code generator polynomial degree (number of roots)
  *
  * Allocate a control structure and the polynom arrays for faster
- * en/decoding. Fill the arrays according to the given parameters
+ * en/decoding. Fill the arrays according to the given parameters.
  */
 static struct rs_control *rs_init(int symsize, int gfpoly, int fcr,
                                    int prim, int nroots)
@@ -155,8 +154,7 @@ errrs:
 
 
 /**
- *  free_rs - Free the rs control structure, if its not longer used
- *
+ *  free_rs - Free the rs control structure, if it is no longer used
  *  @rs:        the control structure which is not longer used by the
  *              caller
  */
@@ -176,7 +174,6 @@ void free_rs(struct rs_control *rs)
 
 /**
  * init_rs - Find a matching or allocate a new rs control structure
- *
  *  @symsize:   the symbol size (number of bits)
  *  @gfpoly:    the extended Galois field generator polynomial coefficients,
  *              with the 0th coefficient in the low order bit. The polynomial
@@ -236,7 +233,6 @@ out:
 #ifdef CONFIG_REED_SOLOMON_ENC8
 /**
  *  encode_rs8 - Calculate the parity for data values (8bit data width)
- *
  *  @rs:        the rs control structure
  *  @data:      data field of a given type
  *  @len:       data length
@@ -258,7 +254,6 @@ EXPORT_SYMBOL_GPL(encode_rs8);
 #ifdef CONFIG_REED_SOLOMON_DEC8
 /**
  *  decode_rs8 - Decode codeword (8bit data width)
- *
  *  @rs:        the rs control structure
  *  @data:      data field of a given type
  *  @par:       received parity data field
@@ -285,7 +280,6 @@ EXPORT_SYMBOL_GPL(decode_rs8);
 #ifdef CONFIG_REED_SOLOMON_ENC16
 /**
  *  encode_rs16 - Calculate the parity for data values (16bit data width)
- *
  *  @rs:        the rs control structure
  *  @data:      data field of a given type
  *  @len:       data length
@@ -305,7 +299,6 @@ EXPORT_SYMBOL_GPL(encode_rs16);
 #ifdef CONFIG_REED_SOLOMON_DEC16
 /**
  *  decode_rs16 - Decode codeword (16bit data width)
- *
  *  @rs:        the rs control structure
  *  @data:      data field of a given type
  *  @par:       received parity data field
diff --git a/lib/vsprintf.c b/lib/vsprintf.c
index b07db5ca3f66..797428afd111 100644
--- a/lib/vsprintf.c
+++ b/lib/vsprintf.c
@@ -187,49 +187,49 @@ static char * number(char * buf, char * end, unsigned long long num, int base, i
         size -= precision;
         if (!(type&(ZEROPAD+LEFT))) {
                 while(size-->0) {
-                        if (buf <= end)
+                        if (buf < end)
                                 *buf = ' ';
                         ++buf;
                 }
         }
         if (sign) {
-                if (buf <= end)
+                if (buf < end)
                         *buf = sign;
                 ++buf;
         }
         if (type & SPECIAL) {
                 if (base==8) {
-                        if (buf <= end)
+                        if (buf < end)
                                 *buf = '0';
                         ++buf;
                 } else if (base==16) {
-                        if (buf <= end)
+                        if (buf < end)
                                 *buf = '0';
                         ++buf;
-                        if (buf <= end)
+                        if (buf < end)
                                 *buf = digits[33];
                         ++buf;
                 }
         }
         if (!(type & LEFT)) {
                 while (size-- > 0) {
-                        if (buf <= end)
+                        if (buf < end)
                                 *buf = c;
                         ++buf;
                 }
         }
         while (i < precision--) {
-                if (buf <= end)
+                if (buf < end)
                         *buf = '0';
                 ++buf;
         }
         while (i-- > 0) {
-                if (buf <= end)
+                if (buf < end)
                         *buf = tmp[i];
                 ++buf;
         }
         while (size-- > 0) {
-                if (buf <= end)
+                if (buf < end)
                         *buf = ' ';
                 ++buf;
         }
@@ -272,7 +272,8 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
                                 /* 'z' changed to 'Z' --davidm 1/25/99 */
                                 /* 't' added for ptrdiff_t */
 
-        /* Reject out-of-range values early */
+        /* Reject out-of-range values early.  Large positive sizes are
+           used for unknown buffer sizes. */
         if (unlikely((int) size < 0)) {
                 /* There can be only one.. */
                 static int warn = 1;
@@ -282,16 +283,17 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
         }
 
         str = buf;
-        end = buf + size - 1;
+        end = buf + size;
 
-        if (end < buf - 1) {
-                end = ((void *) -1);
-                size = end - buf + 1;
+        /* Make sure end is always >= buf */
+        if (end < buf) {
+                end = ((void *)-1);
+                size = end - buf;
         }
 
         for (; *fmt ; ++fmt) {
                 if (*fmt != '%') {
-                        if (str <= end)
+                        if (str < end)
                                 *str = *fmt;
                         ++str;
                         continue;
@@ -357,17 +359,17 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
                         case 'c':
                                 if (!(flags & LEFT)) {
                                         while (--field_width > 0) {
-                                                if (str <= end)
+                                                if (str < end)
                                                         *str = ' ';
                                                 ++str;
                                         }
                                 }
                                 c = (unsigned char) va_arg(args, int);
-                                if (str <= end)
+                                if (str < end)
                                         *str = c;
                                 ++str;
                                 while (--field_width > 0) {
-                                        if (str <= end)
+                                        if (str < end)
                                                 *str = ' ';
                                         ++str;
                                 }
@@ -382,18 +384,18 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
 
                                 if (!(flags & LEFT)) {
                                         while (len < field_width--) {
-                                                if (str <= end)
+                                                if (str < end)
                                                         *str = ' ';
                                                 ++str;
                                         }
                                 }
                                 for (i = 0; i < len; ++i) {
-                                        if (str <= end)
+                                        if (str < end)
                                                 *str = *s;
                                         ++str; ++s;
                                 }
                                 while (len < field_width--) {
-                                        if (str <= end)
+                                        if (str < end)
                                                 *str = ' ';
                                         ++str;
                                 }
@@ -426,7 +428,7 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
                                 continue;
 
                         case '%':
-                                if (str <= end)
+                                if (str < end)
                                         *str = '%';
                                 ++str;
                                 continue;
@@ -449,11 +451,11 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
                                 break;
 
                         default:
-                                if (str <= end)
+                                if (str < end)
                                         *str = '%';
                                 ++str;
                                 if (*fmt) {
-                                        if (str <= end)
+                                        if (str < end)
                                                 *str = *fmt;
                                         ++str;
                                 } else {
@@ -483,14 +485,13 @@ int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
                 str = number(str, end, num, base,
                                 field_width, precision, flags);
         }
-        if (str <= end)
-                *str = '\0';
-        else if (size > 0)
-                /* don't write out a null byte if the buf size is zero */
-                *end = '\0';
-        /* the trailing null byte doesn't count towards the total
-        * ++str;
-        */
+        if (size > 0) {
+                if (str < end)
+                        *str = '\0';
+                else
+                        *end = '\0';
+        }
+        /* the trailing null byte doesn't count towards the total */
         return str-buf;
 }
 
@@ -848,3 +849,26 @@ int sscanf(const char * buf, const char * fmt, ...)
 }
 
 EXPORT_SYMBOL(sscanf);
+
+
+/* Simplified asprintf. */
+char *kasprintf(gfp_t gfp, const char *fmt, ...)
+{
+        va_list ap;
+        unsigned int len;
+        char *p;
+
+        va_start(ap, fmt);
+        len = vsnprintf(NULL, 0, fmt, ap);
+        va_end(ap);
+
+        p = kmalloc(len+1, gfp);
+        if (!p)
+                return NULL;
+        va_start(ap, fmt);
+        vsnprintf(p, len+1, fmt, ap);
+        va_end(ap);
+        return p;
+}
+
+EXPORT_SYMBOL(kasprintf);
diff --git a/mm/filemap.c b/mm/filemap.c
index 807a463fd5ed..9c7334bafda8 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -828,6 +828,32 @@ grab_cache_page_nowait(struct address_space *mapping, unsigned long index)
 }
 EXPORT_SYMBOL(grab_cache_page_nowait);
 
+/*
+ * CD/DVDs are error prone. When a medium error occurs, the driver may fail
+ * a _large_ part of the i/o request. Imagine the worst scenario:
+ *
+ *      ---R__________________________________________B__________
+ *         ^ reading here                             ^ bad block(assume 4k)
+ *
+ * read(R) => miss => readahead(R...B) => media error => frustrating retries
+ * => failing the whole request => read(R) => read(R+1) =>
+ * readahead(R+1...B+1) => bang => read(R+2) => read(R+3) =>
+ * readahead(R+3...B+2) => bang => read(R+3) => read(R+4) =>
+ * readahead(R+4...B+3) => bang => read(R+4) => read(R+5) => ......
+ *
+ * It is going insane. Fix it by quickly scaling down the readahead size.
+ */
+static void shrink_readahead_size_eio(struct file *filp,
+                                        struct file_ra_state *ra)
+{
+        if (!ra->ra_pages)
+                return;
+
+        ra->ra_pages /= 4;
+        printk(KERN_WARNING "Reducing readahead size to %luK\n",
+                        ra->ra_pages << (PAGE_CACHE_SHIFT - 10));
+}
+
 /**
  * do_generic_mapping_read - generic file read routine
  * @mapping:    address_space to be read
@@ -985,6 +1011,7 @@ readpage:
                                 }
                                 unlock_page(page);
                                 error = -EIO;
+                                shrink_readahead_size_eio(filp, &ra);
                                 goto readpage_error;
                         }
                         unlock_page(page);
@@ -1522,6 +1549,7 @@ page_not_uptodate:
          * Things didn't work out. Return zero to tell the
          * mm layer so, possibly freeing the page cache page first.
          */
+        shrink_readahead_size_eio(file, ra);
         page_cache_release(page);
         return NULL;
 }
@@ -1892,7 +1920,7 @@ int remove_suid(struct dentry *dentry)
 EXPORT_SYMBOL(remove_suid);
 
 size_t
-__filemap_copy_from_user_iovec(char *vaddr, 
+__filemap_copy_from_user_iovec_inatomic(char *vaddr,
                         const struct iovec *iov, size_t base, size_t bytes)
 {
         size_t copied = 0, left = 0;
@@ -1908,12 +1936,8 @@ __filemap_copy_from_user_iovec(char *vaddr,
                 vaddr += copy;
                 iov++;
 
-                if (unlikely(left)) {
-                        /* zero the rest of the target like __copy_from_user */
-                        if (bytes)
-                                memset(vaddr, 0, bytes);
+                if (unlikely(left))
                         break;
-                }
         }
         return copied - left;
 }
diff --git a/mm/filemap.h b/mm/filemap.h
index 5683cde22055..536979fb4ba7 100644
--- a/mm/filemap.h
+++ b/mm/filemap.h
@@ -16,15 +16,23 @@
 #include <linux/uaccess.h>
 
 size_t
-__filemap_copy_from_user_iovec(char *vaddr,
-                               const struct iovec *iov,
-                               size_t base,
-                               size_t bytes);
+__filemap_copy_from_user_iovec_inatomic(char *vaddr,
+                                        const struct iovec *iov,
+                                        size_t base,
+                                        size_t bytes);
 
 /*
  * Copy as much as we can into the page and return the number of bytes which
  * were sucessfully copied.  If a fault is encountered then clear the page
  * out to (offset+bytes) and return the number of bytes which were copied.
+ *
+ * NOTE: For this to work reliably we really want copy_from_user_inatomic_nocache
+ * to *NOT* zero any tail of the buffer that it failed to copy.  If it does,
+ * and if the following non-atomic copy succeeds, then there is a small window
+ * where the target page contains neither the data before the write, nor the
+ * data after the write (it contains zero).  A read at this time will see
+ * data that is inconsistent with any ordering of the read and the write.
+ * (This has been detected in practice).
  */
 static inline size_t
 filemap_copy_from_user(struct page *page, unsigned long offset,
@@ -60,13 +68,15 @@ filemap_copy_from_user_iovec(struct page *page, unsigned long offset,
         size_t copied;
 
         kaddr = kmap_atomic(page, KM_USER0);
-        copied = __filemap_copy_from_user_iovec(kaddr + offset, iov,
-                                                base, bytes);
+        copied = __filemap_copy_from_user_iovec_inatomic(kaddr + offset, iov,
+                                                         base, bytes);
         kunmap_atomic(kaddr, KM_USER0);
         if (copied != bytes) {
                 kaddr = kmap(page);
-                copied = __filemap_copy_from_user_iovec(kaddr + offset, iov,
-                                                        base, bytes);
+                copied = __filemap_copy_from_user_iovec_inatomic(kaddr + offset, iov,
+                                                                 base, bytes);
+                if (bytes - copied)
+                        memset(kaddr + offset + copied, 0, bytes - copied);
                 kunmap(page);
         }
         return copied;
diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index ec4a1a950df9..73e0f23b7f51 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -632,6 +632,10 @@ int do_migrate_pages(struct mm_struct *mm,
 
         down_read(&mm->mmap_sem);
 
+        err = migrate_vmas(mm, from_nodes, to_nodes, flags);
+        if (err)
+                goto out;
+
 /*
  * Find a 'source' bit set in 'tmp' whose corresponding 'dest'
  * bit in 'to' is not also set in 'tmp'.  Clear the found 'source'
@@ -691,7 +695,7 @@ int do_migrate_pages(struct mm_struct *mm,
                 if (err < 0)
                         break;
         }
-
+out:
         up_read(&mm->mmap_sem);
         if (err < 0)
                 return err;
diff --git a/mm/migrate.c b/mm/migrate.c
index 1c2a71aa05cd..3f1e0c2c942c 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -616,15 +616,13 @@ static int unmap_and_move(new_page_t get_new_page, unsigned long private,
         /*
          * Establish migration ptes or remove ptes
          */
-        if (try_to_unmap(page, 1) != SWAP_FAIL) {
-                if (!page_mapped(page))
-                        rc = move_to_new_page(newpage, page);
-        } else
-                /* A vma has VM_LOCKED set -> permanent failure */
-                rc = -EPERM;
+        try_to_unmap(page, 1);
+        if (!page_mapped(page))
+                rc = move_to_new_page(newpage, page);
 
         if (rc)
                 remove_migration_ptes(page, page);
+
 unlock:
         unlock_page(page);
 
@@ -976,3 +974,23 @@ out2:
 }
 #endif
 
+/*
+ * Call migration functions in the vma_ops that may prepare
+ * memory in a vm for migration. migration functions may perform
+ * the migration for vmas that do not have an underlying page struct.
+ */
+int migrate_vmas(struct mm_struct *mm, const nodemask_t *to,
+        const nodemask_t *from, unsigned long flags)
+{
+        struct vm_area_struct *vma;
+        int err = 0;
+
+        for(vma = mm->mmap; vma->vm_next && !err; vma = vma->vm_next) {
+                if (vma->vm_ops && vma->vm_ops->migrate) {
+                        err = vma->vm_ops->migrate(vma, to, from, flags);
+                        if (err)
+                                break;
+                }
+        }
+        return err;
+}
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 423db0db7c02..6c1174fcf52c 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -957,8 +957,7 @@ restart:
                 goto got_pg;
 
         do {
-                if (cpuset_zone_allowed(*z, gfp_mask|__GFP_HARDWALL))
-                        wakeup_kswapd(*z, order);
+                wakeup_kswapd(*z, order);
         } while (*(++z));
 
         /*
diff --git a/mm/pdflush.c b/mm/pdflush.c
index df7e50b8f70c..b02102feeb4b 100644
--- a/mm/pdflush.c
+++ b/mm/pdflush.c
@@ -104,21 +104,20 @@ static int __pdflush(struct pdflush_work *my_work)
                 list_move(&my_work->list, &pdflush_list);
                 my_work->when_i_went_to_sleep = jiffies;
                 spin_unlock_irq(&pdflush_lock);
-
                 schedule();
-                if (try_to_freeze()) {
-                        spin_lock_irq(&pdflush_lock);
-                        continue;
-                }
-
+                try_to_freeze();
                 spin_lock_irq(&pdflush_lock);
                 if (!list_empty(&my_work->list)) {
-                        printk("pdflush: bogus wakeup!\n");
+                        /*
+                         * Someone woke us up, but without removing our control
+                         * structure from the global list.  swsusp will do this
+                         * in try_to_freeze()->refrigerator().  Handle it.
+                         */
                         my_work->fn = NULL;
                         continue;
                 }
                 if (my_work->fn == NULL) {
-                        printk("pdflush: NULL work function\n");
+                        printk("pdflush: bogus wakeup\n");
                         continue;
                 }
                 spin_unlock_irq(&pdflush_lock);
diff --git a/mm/readahead.c b/mm/readahead.c
index 0f142a40984b..e39e416860d7 100644
--- a/mm/readahead.c
+++ b/mm/readahead.c
@@ -118,8 +118,7 @@ static inline unsigned long get_next_ra_size(struct file_ra_state *ra)
 #define list_to_page(head) (list_entry((head)->prev, struct page, lru))
 
 /**
- * read_cache_pages - populate an address space with some pages, and
- *                      start reads against them.
+ * read_cache_pages - populate an address space with some pages & start reads against them
  * @mapping: the address_space
  * @pages: The address of a list_head which contains the target pages.  These
  *   pages have their ->index populated and are otherwise uninitialised.
@@ -182,14 +181,11 @@ static int read_pages(struct address_space *mapping, struct file *filp,
                 list_del(&page->lru);
                 if (!add_to_page_cache(page, mapping,
                                         page->index, GFP_KERNEL)) {
-                        ret = mapping->a_ops->readpage(filp, page);
-                        if (ret != AOP_TRUNCATED_PAGE) {
-                                if (!pagevec_add(&lru_pvec, page))
-                                        __pagevec_lru_add(&lru_pvec);
-                                continue;
-                        } /* else fall through to release */
-                }
-                page_cache_release(page);
+                        mapping->a_ops->readpage(filp, page);
+                        if (!pagevec_add(&lru_pvec, page))
+                                __pagevec_lru_add(&lru_pvec);
+                } else
+                        page_cache_release(page);
         }
         pagevec_lru_add(&lru_pvec);
         ret = 0;
diff --git a/mm/rmap.c b/mm/rmap.c
index 882a85826bb2..e76909e880ca 100644
--- a/mm/rmap.c
+++ b/mm/rmap.c
@@ -562,9 +562,8 @@ static int try_to_unmap_one(struct page *page, struct vm_area_struct *vma,
          * If it's recently referenced (perhaps page_referenced
          * skipped over this mm) then we should reactivate it.
          */
-        if ((vma->vm_flags & VM_LOCKED) ||
-                        (ptep_clear_flush_young(vma, address, pte)
-                                && !migration)) {
+        if (!migration && ((vma->vm_flags & VM_LOCKED) ||
+                        (ptep_clear_flush_young(vma, address, pte)))) {
                 ret = SWAP_FAIL;
                 goto out_unmap;
         }
@@ -771,7 +770,7 @@ static int try_to_unmap_file(struct page *page, int migration)
 
         list_for_each_entry(vma, &mapping->i_mmap_nonlinear,
                                                 shared.vm_set.list) {
-                if (vma->vm_flags & VM_LOCKED)
+                if ((vma->vm_flags & VM_LOCKED) && !migration)
                         continue;
                 cursor = (unsigned long) vma->vm_private_data;
                 if (cursor > max_nl_cursor)
@@ -805,7 +804,7 @@ static int try_to_unmap_file(struct page *page, int migration)
         do {
                 list_for_each_entry(vma, &mapping->i_mmap_nonlinear,
                                                 shared.vm_set.list) {
-                        if (vma->vm_flags & VM_LOCKED)
+                        if ((vma->vm_flags & VM_LOCKED) && !migration)
                                 continue;
                         cursor = (unsigned long) vma->vm_private_data;
                         while ( cursor < max_nl_cursor &&
diff --git a/net/ipv4/netfilter/ip_tables.c b/net/ipv4/netfilter/ip_tables.c
index cee3397ec277..706c0025ec5e 100644
--- a/net/ipv4/netfilter/ip_tables.c
+++ b/net/ipv4/netfilter/ip_tables.c
@@ -1761,7 +1761,7 @@ translate_compat_table(const char *name,
                 goto free_newinfo;
 
         /* And one copy for every other CPU */
-        for_each_cpu(i)
+        for_each_possible_cpu(i)
                 if (newinfo->entries[i] && newinfo->entries[i] != entry1)
                         memcpy(newinfo->entries[i], entry1, newinfo->size);
 
diff --git a/net/ipv4/route.c b/net/ipv4/route.c
index cc9423de7311..60b11aece5c3 100644
--- a/net/ipv4/route.c
+++ b/net/ipv4/route.c
@@ -244,7 +244,7 @@ static unsigned int		rt_hash_rnd;
 
 static DEFINE_PER_CPU(struct rt_cache_stat, rt_cache_stat);
 #define RT_CACHE_STAT_INC(field) \
-        (per_cpu(rt_cache_stat, raw_smp_processor_id()).field++)
+        (__raw_get_cpu_var(rt_cache_stat).field++)
 
 static int rt_intern_hash(unsigned hash, struct rtable *rth,
                                 struct rtable **res);
diff --git a/scripts/bloat-o-meter b/scripts/bloat-o-meter
index 75f21d843c1d..ce59fc2d8de4 100755
--- a/scripts/bloat-o-meter
+++ b/scripts/bloat-o-meter
@@ -18,7 +18,8 @@ def getsizes(file):
     for l in os.popen("nm --size-sort " + file).readlines():
         size, type, name = l[:-1].split()
         if type in "tTdDbB":
-            sym[name] = int(size, 16)
+            if "." in name: name = "static." + name.split(".")[0]
+            sym[name] = sym.get(name, 0) + int(size, 16)
     return sym
 
 old = getsizes(sys.argv[1])
diff --git a/scripts/checkstack.pl b/scripts/checkstack.pl
index dadfa20ffec0..b34924663ac1 100755
--- a/scripts/checkstack.pl
+++ b/scripts/checkstack.pl
@@ -89,11 +89,21 @@ sub bysize($) {
 #
 my $funcre = qr/^$x* <(.*)>:$/;
 my $func;
+my $file, $lastslash;
+
 while (my $line = <STDIN>) {
         if ($line =~ m/$funcre/) {
                 $func = $1;
         }
-        if ($line =~ m/$re/) {
+        elsif ($line =~ m/(.*):\s*file format/) {
+                $file = $1;
+                $file =~ s/\.ko//;
+                $lastslash = rindex($file, "/");
+                if ($lastslash != -1) {
+                        $file = substr($file, $lastslash + 1);
+                }
+        }
+        elsif ($line =~ m/$re/) {
                 my $size = $1;
                 $size = hex($size) if ($size =~ /^0x/);
 
@@ -109,7 +119,7 @@ while (my $line = <STDIN>) {
                 $addr =~ s/ /0/g;
                 $addr = "0x$addr";
 
-                my $intro = "$addr $func:";
+                my $intro = "$addr $func [$file]:";
                 my $padlen = 56 - length($intro);
                 while ($padlen > 0) {
                         $intro .= '     ';
diff --git a/scripts/kernel-doc b/scripts/kernel-doc
index 99fe4b7fb2f1..00e21297aefe 100755
--- a/scripts/kernel-doc
+++ b/scripts/kernel-doc
@@ -253,6 +253,7 @@ my $lineprefix="";
 # 3 - scanning prototype.
 # 4 - documentation block
 my $state;
+my $in_doc_sect;
 
 #declaration types: can be
 # 'function', 'struct', 'union', 'enum', 'typedef'
@@ -1064,7 +1065,7 @@ sub output_struct_man(%) {
     }
     print "};\n.br\n";
 
-    print ".SH Arguments\n";
+    print ".SH Members\n";
     foreach $parameter (@{$args{'parameterlist'}}) {
         ($parameter =~ /^#/) && next;
 
@@ -1673,6 +1674,9 @@ sub process_state3_type($$) {
 # replace <, >, and &
 sub xml_escape($) {
         my $text = shift;
+        if (($output_mode eq "text") || ($output_mode eq "man")) {
+                return $text;
+        }
         $text =~ s/\&/\\\\\\amp;/g;
         $text =~ s/\</\\\\\\lt;/g;
         $text =~ s/\>/\\\\\\gt;/g;
@@ -1706,6 +1710,7 @@ sub process_file($) {
         if ($state == 0) {
             if (/$doc_start/o) {
                 $state = 1;             # next line is always the function name
+                $in_doc_sect = 0;
             }
         } elsif ($state == 1) { # this line is the function name (always)
             if (/$doc_block/o) {
@@ -1756,12 +1761,20 @@ sub process_file($) {
                 $newcontents = $2;
 
                 if ($contents ne "") {
+                    if (!$in_doc_sect && $verbose) {
+                        print STDERR "Warning(${file}:$.): contents before sections\n";
+                        ++$warnings;
+                    }
                     dump_section($section, xml_escape($contents));
                     $section = $section_default;
                 }
 
+                $in_doc_sect = 1;
                 $contents = $newcontents;
                 if ($contents ne "") {
+                    if (substr($contents, 0, 1) eq " ") {
+                        $contents = substr($contents, 1);
+                    }
                     $contents .= "\n";
                 }
                 $section = $newsection;
@@ -1776,7 +1789,7 @@ sub process_file($) {
                 $prototype = "";
                 $state = 3;
                 $brcount = 0;
-#           print STDERR "end of doc comment, looking for prototype\n";
+#               print STDERR "end of doc comment, looking for prototype\n";
             } elsif (/$doc_content/) {
                 # miguel-style comment kludge, look for blank lines after
                 # @parameter line to signify start of description
@@ -1793,7 +1806,7 @@ sub process_file($) {
                 print STDERR "Warning(${file}:$.): bad line: $_";
                 ++$warnings;
             }
-        } elsif ($state == 3) { # scanning for function { (end of prototype)
+        } elsif ($state == 3) { # scanning for function '{' (end of prototype)
             if ($decl_type eq 'function') {
                 process_state3_function($_, $file);
             } else {
diff --git a/sound/oss/Kconfig b/sound/oss/Kconfig
index 080ab036b67a..95754e2f71b8 100644
--- a/sound/oss/Kconfig
+++ b/sound/oss/Kconfig
@@ -114,8 +114,9 @@ config SOUND_VRC5477
           with the AC97 codec.
 
 config SOUND_AU1550_AC97
-        tristate "Au1550 AC97 Sound"
-        depends on SOUND_PRIME && SOC_AU1550
+        tristate "Au1550/Au1200 AC97 Sound"
+        select SND_AC97_CODEC
+        depends on SOUND_PRIME && (SOC_AU1550 || SOC_AU1200)
 
 config SOUND_TRIDENT
         tristate "Trident 4DWave DX/NX, SiS 7018 or ALi 5451 PCI Audio Core"
diff --git a/sound/oss/au1550_ac97.c b/sound/oss/au1550_ac97.c
index 9011abe241ab..4cdb86252d67 100644
--- a/sound/oss/au1550_ac97.c
+++ b/sound/oss/au1550_ac97.c
@@ -213,7 +213,8 @@ rdcodec(struct ac97_codec *codec, u8 addr)
         }
         if (i == POLL_COUNT) {
                 err("rdcodec: read poll expired!");
-                return 0;
+                data = 0;
+                goto out;
         }
 
         /* wait for command done?
@@ -226,7 +227,8 @@ rdcodec(struct ac97_codec *codec, u8 addr)
         }
         if (i == POLL_COUNT) {
                 err("rdcodec: read cmdwait expired!");
-                return 0;
+                data = 0;
+                goto out;
         }
 
         data = au_readl(PSC_AC97CDC) & 0xffff;
@@ -237,6 +239,7 @@ rdcodec(struct ac97_codec *codec, u8 addr)
         au_writel(PSC_AC97EVNT_CD, PSC_AC97EVNT);
         au_sync();
 
+ out:
         spin_unlock_irqrestore(&s->lock, flags);
 
         return data;
@@ -1892,6 +1895,8 @@ static /*const */ struct file_operations au1550_audio_fops = {
 
 MODULE_AUTHOR("Advanced Micro Devices (AMD), dan@embeddededge.com");
 MODULE_DESCRIPTION("Au1550 AC97 Audio Driver");
+MODULE_LICENSE("GPL");
+
 
 static int __devinit
 au1550_probe(void)
diff --git a/sound/oss/emu10k1/midi.c b/sound/oss/emu10k1/midi.c
index 25ae8e4a488d..8ac77df86397 100644
--- a/sound/oss/emu10k1/midi.c
+++ b/sound/oss/emu10k1/midi.c
@@ -45,7 +45,7 @@
 #include "../sound_config.h"
 #endif
 
-static DEFINE_SPINLOCK(midi_spinlock __attribute((unused)));
+static DEFINE_SPINLOCK(midi_spinlock);
 
 static void init_midi_hdr(struct midi_hdr *midihdr)
 {
diff --git a/sound/oss/msnd.c b/sound/oss/msnd.c
index 5dbfc0f9c3c7..ba38d6200099 100644
--- a/sound/oss/msnd.c
+++ b/sound/oss/msnd.c
@@ -47,7 +47,7 @@
 static multisound_dev_t         *devs[MSND_MAX_DEVS];
 static int                      num_devs;
 
-int __init msnd_register(multisound_dev_t *dev)
+int msnd_register(multisound_dev_t *dev)
 {
         int i;