753 files changed, 40178 insertions, 19663 deletions

diff --git a/Documentation/ABI/testing/sysfs-block b/Documentation/ABI/testing/sysfs-block
index 44f52a4f5903..cbbd3e069945 100644
--- a/Documentation/ABI/testing/sysfs-block
+++ b/Documentation/ABI/testing/sysfs-block
@@ -60,3 +60,62 @@ Description:
                 Indicates whether the block layer should automatically
                 generate checksums for write requests bound for
                 devices that support receiving integrity metadata.
+
+What:           /sys/block/<disk>/alignment_offset
+Date:           April 2009
+Contact:        Martin K. Petersen <martin.petersen@oracle.com>
+Description:
+                Storage devices may report a physical block size that is
+                bigger than the logical block size (for instance a drive
+                with 4KB physical sectors exposing 512-byte logical
+                blocks to the operating system).  This parameter
+                indicates how many bytes the beginning of the device is
+                offset from the disk's natural alignment.
+
+What:           /sys/block/<disk>/<partition>/alignment_offset
+Date:           April 2009
+Contact:        Martin K. Petersen <martin.petersen@oracle.com>
+Description:
+                Storage devices may report a physical block size that is
+                bigger than the logical block size (for instance a drive
+                with 4KB physical sectors exposing 512-byte logical
+                blocks to the operating system).  This parameter
+                indicates how many bytes the beginning of the partition
+                is offset from the disk's natural alignment.
+
+What:           /sys/block/<disk>/queue/logical_block_size
+Date:           May 2009
+Contact:        Martin K. Petersen <martin.petersen@oracle.com>
+Description:
+                This is the smallest unit the storage device can
+                address.  It is typically 512 bytes.
+
+What:           /sys/block/<disk>/queue/physical_block_size
+Date:           May 2009
+Contact:        Martin K. Petersen <martin.petersen@oracle.com>
+Description:
+                This is the smallest unit the storage device can write
+                without resorting to read-modify-write operation.  It is
+                usually the same as the logical block size but may be
+                bigger.  One example is SATA drives with 4KB sectors
+                that expose a 512-byte logical block size to the
+                operating system.
+
+What:           /sys/block/<disk>/queue/minimum_io_size
+Date:           April 2009
+Contact:        Martin K. Petersen <martin.petersen@oracle.com>
+Description:
+                Storage devices may report a preferred minimum I/O size,
+                which is the smallest request the device can perform
+                without incurring a read-modify-write penalty.  For disk
+                drives this is often the physical block size.  For RAID
+                arrays it is often the stripe chunk size.
+
+What:           /sys/block/<disk>/queue/optimal_io_size
+Date:           April 2009
+Contact:        Martin K. Petersen <martin.petersen@oracle.com>
+Description:
+                Storage devices may report an optimal I/O size, which is
+                the device's preferred unit of receiving I/O.  This is
+                rarely reported for disk drives.  For RAID devices it is
+                usually the stripe width or the internal block size.
diff --git a/Documentation/ABI/testing/sysfs-bus-pci-devices-cciss b/Documentation/ABI/testing/sysfs-bus-pci-devices-cciss
new file mode 100644
index 000000000000..0a92a7c93a62
--- /dev/null
+++ b/Documentation/ABI/testing/sysfs-bus-pci-devices-cciss
@@ -0,0 +1,33 @@
+Where:          /sys/bus/pci/devices/<dev>/ccissX/cXdY/model
+Date:           March 2009
+Kernel Version: 2.6.30
+Contact:        iss_storagedev@hp.com
+Description:    Displays the SCSI INQUIRY page 0 model for logical drive
+                Y of controller X.
+
+Where:          /sys/bus/pci/devices/<dev>/ccissX/cXdY/rev
+Date:           March 2009
+Kernel Version: 2.6.30
+Contact:        iss_storagedev@hp.com
+Description:    Displays the SCSI INQUIRY page 0 revision for logical
+                drive Y of controller X.
+
+Where:          /sys/bus/pci/devices/<dev>/ccissX/cXdY/unique_id
+Date:           March 2009
+Kernel Version: 2.6.30
+Contact:        iss_storagedev@hp.com
+Description:    Displays the SCSI INQUIRY page 83 serial number for logical
+                drive Y of controller X.
+
+Where:          /sys/bus/pci/devices/<dev>/ccissX/cXdY/vendor
+Date:           March 2009
+Kernel Version: 2.6.30
+Contact:        iss_storagedev@hp.com
+Description:    Displays the SCSI INQUIRY page 0 vendor for logical drive
+                Y of controller X.
+
+Where:          /sys/bus/pci/devices/<dev>/ccissX/cXdY/block:cciss!cXdY
+Date:           March 2009
+Kernel Version: 2.6.30
+Contact:        iss_storagedev@hp.com
+Description:    A symbolic link to /sys/block/cciss!cXdY
diff --git a/Documentation/Smack.txt b/Documentation/Smack.txt
index 629c92e99783..34614b4c708e 100644
--- a/Documentation/Smack.txt
+++ b/Documentation/Smack.txt
@@ -184,8 +184,9 @@ length. Single character labels using special characters, that being anything
 other than a letter or digit, are reserved for use by the Smack development
 team. Smack labels are unstructured, case sensitive, and the only operation
 ever performed on them is comparison for equality. Smack labels cannot
-contain unprintable characters or the "/" (slash) character. Smack labels
-cannot begin with a '-', which is reserved for special options.
+contain unprintable characters, the "/" (slash), the "\" (backslash), the "'"
+(quote) and '"' (double-quote) characters.
+Smack labels cannot begin with a '-', which is reserved for special options.
 
 There are some predefined labels:
 
@@ -523,3 +524,18 @@ Smack supports some mount options:
 
 These mount options apply to all file system types.
 
+Smack auditing
+
+If you want Smack auditing of security events, you need to set CONFIG_AUDIT
+in your kernel configuration.
+By default, all denied events will be audited. You can change this behavior by
+writing a single character to the /smack/logging file :
+0 : no logging
+1 : log denied (default)
+2 : log accepted
+3 : log denied & accepted
+
+Events are logged as 'key=value' pairs, for each event you at least will get
+the subjet, the object, the rights requested, the action, the kernel function
+that triggered the event, plus other pairs depending on the type of event
+audited.
diff --git a/Documentation/block/biodoc.txt b/Documentation/block/biodoc.txt
index 6fab97ea7e6b..8d2158a1c6aa 100644
--- a/Documentation/block/biodoc.txt
+++ b/Documentation/block/biodoc.txt
@@ -186,7 +186,7 @@ a virtual address mapping (unlike the earlier scheme of virtual address
 do not have a corresponding kernel virtual address space mapping) and
 low-memory pages.
 
-Note: Please refer to Documentation/PCI/PCI-DMA-mapping.txt for a discussion
+Note: Please refer to Documentation/DMA-mapping.txt for a discussion
 on PCI high mem DMA aspects and mapping of scatter gather lists, and support
 for 64 bit PCI.
 
diff --git a/Documentation/filesystems/gfs2-glocks.txt b/Documentation/filesystems/gfs2-glocks.txt
index 4dae9a3840bf..0494f78d87e4 100644
--- a/Documentation/filesystems/gfs2-glocks.txt
+++ b/Documentation/filesystems/gfs2-glocks.txt
@@ -60,7 +60,7 @@ go_lock          | Called for the first local holder of a lock
 go_unlock        | Called on the final local unlock of a lock
 go_dump          | Called to print content of object for debugfs file, or on
                  | error to dump glock to the log.
-go_type;         | The type of the glock, LM_TYPE_.....
+go_type          | The type of the glock, LM_TYPE_.....
 go_min_hold_time | The minimum hold time
 
 The minimum hold time for each lock is the time after a remote lock
diff --git a/Documentation/filesystems/gfs2.txt b/Documentation/filesystems/gfs2.txt
index 593004b6bbab..5e3ab8f3beff 100644
--- a/Documentation/filesystems/gfs2.txt
+++ b/Documentation/filesystems/gfs2.txt
@@ -11,18 +11,15 @@ their I/O so file system consistency is maintained.  One of the nifty
 features of GFS is perfect consistency -- changes made to the file system
 on one machine show up immediately on all other machines in the cluster.
 
-GFS uses interchangable inter-node locking mechanisms.  Different lock
-modules can plug into GFS and each file system selects the appropriate
-lock module at mount time.  Lock modules include:
+GFS uses interchangable inter-node locking mechanisms, the currently
+supported mechanisms are:
 
   lock_nolock -- allows gfs to be used as a local file system
 
   lock_dlm -- uses a distributed lock manager (dlm) for inter-node locking
   The dlm is found at linux/fs/dlm/
 
-In addition to interfacing with an external locking manager, a gfs lock
-module is responsible for interacting with external cluster management
-systems.  Lock_dlm depends on user space cluster management systems found
+Lock_dlm depends on user space cluster management systems found
 at the URL above.
 
 To use gfs as a local file system, no external clustering systems are
@@ -31,13 +28,19 @@ needed, simply:
   $ mkfs -t gfs2 -p lock_nolock -j 1 /dev/block_device
   $ mount -t gfs2 /dev/block_device /dir
 
-GFS2 is not on-disk compatible with previous versions of GFS.
+If you are using Fedora, you need to install the gfs2-utils package
+and, for lock_dlm, you will also need to install the cman package
+and write a cluster.conf as per the documentation.
+
+GFS2 is not on-disk compatible with previous versions of GFS, but it
+is pretty close.
 
 The following man pages can be found at the URL above:
-  gfs2_fsck     to repair a filesystem
+  fsck.gfs2     to repair a filesystem
   gfs2_grow     to expand a filesystem online
   gfs2_jadd     to add journals to a filesystem online
   gfs2_tool     to manipulate, examine and tune a filesystem
   gfs2_quota    to examine and change quota values in a filesystem
+  gfs2_convert  to convert a gfs filesystem to gfs2 in-place
   mount.gfs2    to help mount(8) mount a filesystem
   mkfs.gfs2     to make a filesystem
diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index 4a3c2209a124..72d3bf08d79b 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -928,6 +928,12 @@ and is between 256 and 4096 characters. It is defined in the file
                         Formt: { "sha1" | "md5" }
                         default: "sha1"
 
+        ima_tcb         [IMA]
+                        Load a policy which meets the needs of the Trusted
+                        Computing Base.  This means IMA will measure all
+                        programs exec'd, files mmap'd for exec, and all files
+                        opened for read by uid=0.
+
         in2000=         [HW,SCSI]
                         See header of drivers/scsi/in2000.c.
 
diff --git a/Documentation/sysctl/kernel.txt b/Documentation/sysctl/kernel.txt
index f11ca7979fa6..322a00bb99d9 100644
--- a/Documentation/sysctl/kernel.txt
+++ b/Documentation/sysctl/kernel.txt
@@ -32,6 +32,7 @@ show up in /proc/sys/kernel:
 - kstack_depth_to_print       [ X86 only ]
 - l2cr                        [ PPC only ]
 - modprobe                    ==> Documentation/debugging-modules.txt
+- modules_disabled
 - msgmax
 - msgmnb
 - msgmni
@@ -184,6 +185,16 @@ kernel stack.
 
 ==============================================================
 
+modules_disabled:
+
+A toggle value indicating if modules are allowed to be loaded
+in an otherwise modular kernel.  This toggle defaults to off
+(0), but can be set true (1).  Once true, modules can be
+neither loaded nor unloaded, and the toggle cannot be set back
+to false.
+
+==============================================================
+
 osrelease, ostype & version:
 
 # cat osrelease
diff --git a/MAINTAINERS b/MAINTAINERS
index cf4abddfc8a4..ccdb57524e3c 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -71,7 +71,7 @@ P: Person
 M: Mail patches to
 L: Mailing list that is relevant to this area
 W: Web-page with status/info
-T: SCM tree type and location.  Type is one of: git, hg, quilt.
+T: SCM tree type and location.  Type is one of: git, hg, quilt, stgit.
 S: Status, one of the following:
 
         Supported:      Someone is actually paid to look after this.
@@ -159,7 +159,8 @@ F:	drivers/net/r8169.c
 8250/16?50 (AND CLONE UARTS) SERIAL DRIVER
 L:      linux-serial@vger.kernel.org
 W:      http://serial.sourceforge.net
-S:      Orphan
+M:      alan@lxorguk.ukuu.org.uk
+S:      Odd Fixes
 F:      drivers/serial/8250*
 F:      include/linux/serial_8250.h
 
@@ -1978,6 +1979,16 @@ F:	Documentation/edac.txt
 F:      drivers/edac/edac_*
 F:      include/linux/edac.h
 
+EDAC-AMD64
+P:      Doug Thompson
+M:      dougthompson@xmission.com
+P:      Borislav Petkov
+M:      borislav.petkov@amd.com
+L:      bluesmoke-devel@lists.sourceforge.net (moderated for non-subscribers)
+W:      bluesmoke.sourceforge.net
+S:      Supported
+F:      drivers/edac/amd64_edac*
+
 EDAC-E752X
 P:      Mark Gross
 M:      mark.gross@intel.com
@@ -5629,6 +5640,7 @@ P:	Alan Cox
 M:      alan@lxorguk.ukuu.org.uk
 L:      linux-kernel@vger.kernel.org
 S:      Maintained
+T:      stgit http://zeniv.linux.org.uk/~alan/ttydev/
 
 TULIP NETWORK DRIVERS
 P:      Grant Grundler
diff --git a/arch/arm/plat-mxc/include/mach/imx-uart.h b/arch/arm/plat-mxc/include/mach/imx-uart.h
index 599217b2e13f..f9bd17dd8dd7 100644
--- a/arch/arm/plat-mxc/include/mach/imx-uart.h
+++ b/arch/arm/plat-mxc/include/mach/imx-uart.h
@@ -20,11 +20,16 @@
 #define ASMARM_ARCH_UART_H
 
 #define IMXUART_HAVE_RTSCTS (1<<0)
+#define IMXUART_IRDA        (1<<1)
 
 struct imxuart_platform_data {
         int (*init)(struct platform_device *pdev);
         int (*exit)(struct platform_device *pdev);
         unsigned int flags;
+        void (*irda_enable)(int enable);
+        unsigned int irda_inv_rx:1;
+        unsigned int irda_inv_tx:1;
+        unsigned short transceiver_delay;
 };
 
 #endif
diff --git a/arch/arm/plat-omap/mailbox.c b/arch/arm/plat-omap/mailbox.c
index 0abfbaa59871..40424edae939 100644
--- a/arch/arm/plat-omap/mailbox.c
+++ b/arch/arm/plat-omap/mailbox.c
@@ -147,24 +147,40 @@ static int __mbox_msg_send(struct omap_mbox *mbox, mbox_msg_t msg, void *arg)
         return ret;
 }
 
+struct omap_msg_tx_data {
+        mbox_msg_t      msg;
+        void            *arg;
+};
+
+static void omap_msg_tx_end_io(struct request *rq, int error)
+{
+        kfree(rq->special);
+        __blk_put_request(rq->q, rq);
+}
+
 int omap_mbox_msg_send(struct omap_mbox *mbox, mbox_msg_t msg, void* arg)
 {
+        struct omap_msg_tx_data *tx_data;
         struct request *rq;
         struct request_queue *q = mbox->txq->queue;
-        int ret = 0;
+
+        tx_data = kmalloc(sizeof(*tx_data), GFP_ATOMIC);
+        if (unlikely(!tx_data))
+                return -ENOMEM;
 
         rq = blk_get_request(q, WRITE, GFP_ATOMIC);
         if (unlikely(!rq)) {
-                ret = -ENOMEM;
-                goto fail;
+                kfree(tx_data);
+                return -ENOMEM;
         }
 
-        rq->data = (void *)msg;
-        blk_insert_request(q, rq, 0, arg);
+        tx_data->msg = msg;
+        tx_data->arg = arg;
+        rq->end_io = omap_msg_tx_end_io;
+        blk_insert_request(q, rq, 0, tx_data);
 
         schedule_work(&mbox->txq->work);
- fail:
-        return ret;
+        return 0;
 }
 EXPORT_SYMBOL(omap_mbox_msg_send);
 
@@ -178,22 +194,28 @@ static void mbox_tx_work(struct work_struct *work)
         struct request_queue *q = mbox->txq->queue;
 
         while (1) {
+                struct omap_msg_tx_data *tx_data;
+
                 spin_lock(q->queue_lock);
-                rq = elv_next_request(q);
+                rq = blk_fetch_request(q);
                 spin_unlock(q->queue_lock);
 
                 if (!rq)
                         break;
 
-                ret = __mbox_msg_send(mbox, (mbox_msg_t) rq->data, rq->special);
+                tx_data = rq->special;
+
+                ret = __mbox_msg_send(mbox, tx_data->msg, tx_data->arg);
                 if (ret) {
                         enable_mbox_irq(mbox, IRQ_TX);
+                        spin_lock(q->queue_lock);
+                        blk_requeue_request(q, rq);
+                        spin_unlock(q->queue_lock);
                         return;
                 }
 
                 spin_lock(q->queue_lock);
-                if (__blk_end_request(rq, 0, 0))
-                        BUG();
+                __blk_end_request_all(rq, 0);
                 spin_unlock(q->queue_lock);
         }
 }
@@ -218,16 +240,13 @@ static void mbox_rx_work(struct work_struct *work)
 
         while (1) {
                 spin_lock_irqsave(q->queue_lock, flags);
-                rq = elv_next_request(q);
+                rq = blk_fetch_request(q);
                 spin_unlock_irqrestore(q->queue_lock, flags);
                 if (!rq)
                         break;
 
-                msg = (mbox_msg_t) rq->data;
-
-                if (blk_end_request(rq, 0, 0))
-                        BUG();
-
+                msg = (mbox_msg_t)rq->special;
+                blk_end_request_all(rq, 0);
                 mbox->rxq->callback((void *)msg);
         }
 }
@@ -264,7 +283,6 @@ static void __mbox_rx_interrupt(struct omap_mbox *mbox)
                         goto nomem;
 
                 msg = mbox_fifo_read(mbox);
-                rq->data = (void *)msg;
 
                 if (unlikely(mbox_seq_test(mbox, msg))) {
                         pr_info("mbox: Illegal seq bit!(%08x)\n", msg);
@@ -272,7 +290,7 @@ static void __mbox_rx_interrupt(struct omap_mbox *mbox)
                                 mbox->err_notify();
                 }
 
-                blk_insert_request(q, rq, 0, NULL);
+                blk_insert_request(q, rq, 0, (void *)msg);
                 if (mbox->ops->type == OMAP_MBOX_TYPE1)
                         break;
         }
@@ -329,16 +347,15 @@ omap_mbox_read(struct device *dev, struct device_attribute *attr, char *buf)
 
         while (1) {
                 spin_lock_irqsave(q->queue_lock, flags);
-                rq = elv_next_request(q);
+                rq = blk_fetch_request(q);
                 spin_unlock_irqrestore(q->queue_lock, flags);
 
                 if (!rq)
                         break;
 
-                *p = (mbox_msg_t) rq->data;
+                *p = (mbox_msg_t)rq->special;
 
-                if (blk_end_request(rq, 0, 0))
-                        BUG();
+                blk_end_request_all(rq, 0);
 
                 if (unlikely(mbox_seq_test(mbox, *p))) {
                         pr_info("mbox: Illegal seq bit!(%08x) ignored\n", *p);
diff --git a/arch/frv/Kconfig b/arch/frv/Kconfig
index 9d1552a9ee2c..8a5bd7a9c6f5 100644
--- a/arch/frv/Kconfig
+++ b/arch/frv/Kconfig
@@ -6,6 +6,7 @@ config FRV
         bool
         default y
         select HAVE_IDE
+        select HAVE_ARCH_TRACEHOOK
 
 config ZONE_DMA
         bool
diff --git a/arch/frv/include/asm/bitops.h b/arch/frv/include/asm/bitops.h
index 287f6f697ce2..50ae91b29674 100644
--- a/arch/frv/include/asm/bitops.h
+++ b/arch/frv/include/asm/bitops.h
@@ -112,7 +112,7 @@ extern unsigned long atomic_test_and_XOR_mask(unsigned long mask, volatile unsig
 #define atomic_clear_mask(mask, v)      atomic_test_and_ANDNOT_mask((mask), (v))
 #define atomic_set_mask(mask, v)        atomic_test_and_OR_mask((mask), (v))
 
-static inline int test_and_clear_bit(int nr, volatile void *addr)
+static inline int test_and_clear_bit(unsigned long nr, volatile void *addr)
 {
         volatile unsigned long *ptr = addr;
         unsigned long mask = 1UL << (nr & 31);
@@ -120,7 +120,7 @@ static inline int test_and_clear_bit(int nr, volatile void *addr)
         return (atomic_test_and_ANDNOT_mask(mask, ptr) & mask) != 0;
 }
 
-static inline int test_and_set_bit(int nr, volatile void *addr)
+static inline int test_and_set_bit(unsigned long nr, volatile void *addr)
 {
         volatile unsigned long *ptr = addr;
         unsigned long mask = 1UL << (nr & 31);
@@ -128,7 +128,7 @@ static inline int test_and_set_bit(int nr, volatile void *addr)
         return (atomic_test_and_OR_mask(mask, ptr) & mask) != 0;
 }
 
-static inline int test_and_change_bit(int nr, volatile void *addr)
+static inline int test_and_change_bit(unsigned long nr, volatile void *addr)
 {
         volatile unsigned long *ptr = addr;
         unsigned long mask = 1UL << (nr & 31);
@@ -136,22 +136,22 @@ static inline int test_and_change_bit(int nr, volatile void *addr)
         return (atomic_test_and_XOR_mask(mask, ptr) & mask) != 0;
 }
 
-static inline void clear_bit(int nr, volatile void *addr)
+static inline void clear_bit(unsigned long nr, volatile void *addr)
 {
         test_and_clear_bit(nr, addr);
 }
 
-static inline void set_bit(int nr, volatile void *addr)
+static inline void set_bit(unsigned long nr, volatile void *addr)
 {
         test_and_set_bit(nr, addr);
 }
 
-static inline void change_bit(int nr, volatile void * addr)
+static inline void change_bit(unsigned long nr, volatile void *addr)
 {
         test_and_change_bit(nr, addr);
 }
 
-static inline void __clear_bit(int nr, volatile void * addr)
+static inline void __clear_bit(unsigned long nr, volatile void *addr)
 {
         volatile unsigned long *a = addr;
         int mask;
@@ -161,7 +161,7 @@ static inline void __clear_bit(int nr, volatile void * addr)
         *a &= ~mask;
 }
 
-static inline void __set_bit(int nr, volatile void * addr)
+static inline void __set_bit(unsigned long nr, volatile void *addr)
 {
         volatile unsigned long *a = addr;
         int mask;
@@ -171,7 +171,7 @@ static inline void __set_bit(int nr, volatile void * addr)
         *a |= mask;
 }
 
-static inline void __change_bit(int nr, volatile void *addr)
+static inline void __change_bit(unsigned long nr, volatile void *addr)
 {
         volatile unsigned long *a = addr;
         int mask;
@@ -181,7 +181,7 @@ static inline void __change_bit(int nr, volatile void *addr)
         *a ^= mask;
 }
 
-static inline int __test_and_clear_bit(int nr, volatile void * addr)
+static inline int __test_and_clear_bit(unsigned long nr, volatile void *addr)
 {
         volatile unsigned long *a = addr;
         int mask, retval;
@@ -193,7 +193,7 @@ static inline int __test_and_clear_bit(int nr, volatile void * addr)
         return retval;
 }
 
-static inline int __test_and_set_bit(int nr, volatile void * addr)
+static inline int __test_and_set_bit(unsigned long nr, volatile void *addr)
 {
         volatile unsigned long *a = addr;
         int mask, retval;
@@ -205,7 +205,7 @@ static inline int __test_and_set_bit(int nr, volatile void * addr)
         return retval;
 }
 
-static inline int __test_and_change_bit(int nr, volatile void * addr)
+static inline int __test_and_change_bit(unsigned long nr, volatile void *addr)
 {
         volatile unsigned long *a = addr;
         int mask, retval;
@@ -220,12 +220,13 @@ static inline int __test_and_change_bit(int nr, volatile void * addr)
 /*
  * This routine doesn't need to be atomic.
  */
-static inline int __constant_test_bit(int nr, const volatile void * addr)
+static inline int
+__constant_test_bit(unsigned long nr, const volatile void *addr)
 {
         return ((1UL << (nr & 31)) & (((const volatile unsigned int *) addr)[nr >> 5])) != 0;
 }
 
-static inline int __test_bit(int nr, const volatile void * addr)
+static inline int __test_bit(unsigned long nr, const volatile void *addr)
 {
         int     * a = (int *) addr;
         int     mask;
diff --git a/arch/frv/include/asm/elf.h b/arch/frv/include/asm/elf.h
index 7279ec07d62e..7bbf6e47f8c8 100644
--- a/arch/frv/include/asm/elf.h
+++ b/arch/frv/include/asm/elf.h
@@ -116,6 +116,7 @@ do {											\
 } while(0)
 
 #define USE_ELF_CORE_DUMP
+#define CORE_DUMP_USE_REGSET
 #define ELF_FDPIC_CORE_EFLAGS   EF_FRV_FDPIC
 #define ELF_EXEC_PAGESIZE       16384
 
diff --git a/arch/frv/include/asm/pci.h b/arch/frv/include/asm/pci.h
index 585d9b49949a..cc685e60b0f9 100644
--- a/arch/frv/include/asm/pci.h
+++ b/arch/frv/include/asm/pci.h
@@ -87,8 +87,7 @@ static inline void pci_dma_sync_single(struct pci_dev *hwdev,
                                        dma_addr_t dma_handle,
                                        size_t size, int direction)
 {
-        if (direction == PCI_DMA_NONE)
-                BUG();
+        BUG_ON(direction == PCI_DMA_NONE);
 
         frv_cache_wback_inv((unsigned long)bus_to_virt(dma_handle),
                             (unsigned long)bus_to_virt(dma_handle) + size);
@@ -105,9 +104,7 @@ static inline void pci_dma_sync_sg(struct pci_dev *hwdev,
                                    int nelems, int direction)
 {
         int i;
-
-        if (direction == PCI_DMA_NONE)
-                BUG();
+        BUG_ON(direction == PCI_DMA_NONE);
 
         for (i = 0; i < nelems; i++)
                 frv_cache_wback_inv(sg_dma_address(&sg[i]),
diff --git a/arch/frv/include/asm/ptrace.h b/arch/frv/include/asm/ptrace.h
index cf6934012b64..a54b535c9e49 100644
--- a/arch/frv/include/asm/ptrace.h
+++ b/arch/frv/include/asm/ptrace.h
@@ -65,6 +65,8 @@
 #ifdef __KERNEL__
 #ifndef __ASSEMBLY__
 
+struct task_struct;
+
 /*
  * we dedicate GR28 to keeping a pointer to the current exception frame
  * - gr28 is destroyed on entry to the kernel from userspace
@@ -73,11 +75,18 @@ register struct pt_regs *__frame asm("gr28");
 
 #define user_mode(regs)                 (!((regs)->psr & PSR_S))
 #define instruction_pointer(regs)       ((regs)->pc)
+#define user_stack_pointer(regs)        ((regs)->sp)
 
 extern unsigned long user_stack(const struct pt_regs *);
 extern void show_regs(struct pt_regs *);
 #define profile_pc(regs) ((regs)->pc)
-#endif
+
+#define task_pt_regs(task) ((task)->thread.frame0)
+
+#define arch_has_single_step()  (1)
+extern void user_enable_single_step(struct task_struct *);
+extern void user_disable_single_step(struct task_struct *);
 
 #endif /* !__ASSEMBLY__ */
+#endif /* __KERNEL__ */
 #endif /* _ASM_PTRACE_H */
diff --git a/arch/frv/include/asm/syscall.h b/arch/frv/include/asm/syscall.h
new file mode 100644
index 000000000000..70689eb29b98
--- /dev/null
+++ b/arch/frv/include/asm/syscall.h
@@ -0,0 +1,123 @@
+/* syscall parameter access functions
+ *
+ * Copyright (C) 2009 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public Licence
+ * as published by the Free Software Foundation; either version
+ * 2 of the Licence, or (at your option) any later version.
+ */
+
+#ifndef _ASM_SYSCALL_H
+#define _ASM_SYSCALL_H
+
+#include <linux/err.h>
+#include <asm/ptrace.h>
+
+/*
+ * Get the system call number or -1
+ */
+static inline long syscall_get_nr(struct task_struct *task,
+                                  struct pt_regs *regs)
+{
+        return regs->syscallno;
+}
+
+/*
+ * Restore the clobbered GR8 register
+ * (1st syscall arg was overwritten with syscall return or error)
+ */
+static inline void syscall_rollback(struct task_struct *task,
+                                    struct pt_regs *regs)
+{
+        regs->gr8 = regs->orig_gr8;
+}
+
+/*
+ * See if the syscall return value is an error, returning it if it is and 0 if
+ * not
+ */
+static inline long syscall_get_error(struct task_struct *task,
+                                     struct pt_regs *regs)
+{
+        return IS_ERR_VALUE(regs->gr8) ? regs->gr8 : 0;
+}
+
+/*
+ * Get the syscall return value
+ */
+static inline long syscall_get_return_value(struct task_struct *task,
+                                            struct pt_regs *regs)
+{
+        return regs->gr8;
+}
+
+/*
+ * Set the syscall return value
+ */
+static inline void syscall_set_return_value(struct task_struct *task,
+                                            struct pt_regs *regs,
+                                            int error, long val)
+{
+        if (error)
+                regs->gr8 = -error;
+        else
+                regs->gr8 = val;
+}
+
+/*
+ * Retrieve the system call arguments
+ */
+static inline void syscall_get_arguments(struct task_struct *task,
+                                         struct pt_regs *regs,
+                                         unsigned int i, unsigned int n,
+                                         unsigned long *args)
+{
+        /*
+         * Do this simply for now. If we need to start supporting
+         * fetching arguments from arbitrary indices, this will need some
+         * extra logic. Presently there are no in-tree users that depend
+         * on this behaviour.
+         */
+        BUG_ON(i);
+
+        /* Argument pattern is: GR8, GR9, GR10, GR11, GR12, GR13 */
+        switch (n) {
+        case 6: args[5] = regs->gr13;
+        case 5: args[4] = regs->gr12;
+        case 4: args[3] = regs->gr11;
+        case 3: args[2] = regs->gr10;
+        case 2: args[1] = regs->gr9;
+        case 1: args[0] = regs->gr8;
+                break;
+        default:
+                BUG();
+        }
+}
+
+/*
+ * Alter the system call arguments
+ */
+static inline void syscall_set_arguments(struct task_struct *task,
+                                         struct pt_regs *regs,
+                                         unsigned int i, unsigned int n,
+                                         const unsigned long *args)
+{
+        /* Same note as above applies */
+        BUG_ON(i);
+
+        switch (n) {
+        case 6: regs->gr13 = args[5];
+        case 5: regs->gr12 = args[4];
+        case 4: regs->gr11 = args[3];
+        case 3: regs->gr10 = args[2];
+        case 2: regs->gr9  = args[1];
+        case 1: regs->gr8  = args[0];
+                break;
+        default:
+                BUG();
+        }
+}
+
+#endif /* _ASM_SYSCALL_H */
diff --git a/arch/frv/include/asm/thread_info.h b/arch/frv/include/asm/thread_info.h
index bb53ab753ffb..e8a5ed7be021 100644
--- a/arch/frv/include/asm/thread_info.h
+++ b/arch/frv/include/asm/thread_info.h
@@ -109,20 +109,20 @@ register struct thread_info *__current_thread_info asm("gr15");
  * - other flags in MSW
  */
 #define TIF_SYSCALL_TRACE       0       /* syscall trace active */
-#define TIF_SIGPENDING          1       /* signal pending */
-#define TIF_NEED_RESCHED        2       /* rescheduling necessary */
-#define TIF_SINGLESTEP          3       /* restore singlestep on return to user mode */
-#define TIF_IRET                4       /* return with iret */
+#define TIF_NOTIFY_RESUME       1       /* callback before returning to user */
+#define TIF_SIGPENDING          2       /* signal pending */
+#define TIF_NEED_RESCHED        3       /* rescheduling necessary */
+#define TIF_SINGLESTEP          4       /* restore singlestep on return to user mode */
 #define TIF_RESTORE_SIGMASK     5       /* restore signal mask in do_signal() */
 #define TIF_POLLING_NRFLAG      16      /* true if poll_idle() is polling TIF_NEED_RESCHED */
 #define TIF_MEMDIE              17      /* OOM killer killed process */
 #define TIF_FREEZE              18      /* freezing for suspend */
 
 #define _TIF_SYSCALL_TRACE      (1 << TIF_SYSCALL_TRACE)
+#define _TIF_NOTIFY_RESUME      (1 << TIF_NOTIFY_RESUME)
 #define _TIF_SIGPENDING         (1 << TIF_SIGPENDING)
 #define _TIF_NEED_RESCHED       (1 << TIF_NEED_RESCHED)
 #define _TIF_SINGLESTEP         (1 << TIF_SINGLESTEP)
-#define _TIF_IRET               (1 << TIF_IRET)
 #define _TIF_RESTORE_SIGMASK    (1 << TIF_RESTORE_SIGMASK)
 #define _TIF_POLLING_NRFLAG     (1 << TIF_POLLING_NRFLAG)
 #define _TIF_FREEZE             (1 << TIF_FREEZE)
diff --git a/arch/frv/kernel/entry.S b/arch/frv/kernel/entry.S
index 1da523b3298e..356e0e327a89 100644
--- a/arch/frv/kernel/entry.S
+++ b/arch/frv/kernel/entry.S
@@ -886,7 +886,6 @@ system_call:
         bnc             icc0,#0,__syscall_badsys
 
         ldi             @(gr15,#TI_FLAGS),gr4
-        ori             gr4,#_TIF_SYSCALL_TRACE,gr4
         andicc          gr4,#_TIF_SYSCALL_TRACE,gr0,icc0
         bne             icc0,#0,__syscall_trace_entry
 
@@ -1150,11 +1149,10 @@ __entry_work_notifysig:
         # perform syscall entry tracing
 __syscall_trace_entry:
         LEDS            0x6320
-        setlos.p        #0,gr8
-        call            do_syscall_trace
+        call            syscall_trace_entry
 
-        ldi             @(gr28,#REG_SYSCALLNO),gr7
-        lddi            @(gr28,#REG_GR(8)) ,gr8
+        lddi.p          @(gr28,#REG_GR(8)) ,gr8
+        ori             gr8,#0,gr7              ; syscall_trace_entry() returned new syscallno
         lddi            @(gr28,#REG_GR(10)),gr10
         lddi.p          @(gr28,#REG_GR(12)),gr12
 
@@ -1169,11 +1167,10 @@ __syscall_exit_work:
         beq             icc0,#1,__entry_work_pending
 
         movsg           psr,gr23
-        andi            gr23,#~PSR_PIL,gr23     ; could let do_syscall_trace() call schedule()
+        andi            gr23,#~PSR_PIL,gr23     ; could let syscall_trace_exit() call schedule()
         movgs           gr23,psr
 
-        setlos.p        #1,gr8
-        call            do_syscall_trace
+        call            syscall_trace_exit
         bra             __entry_resume_userspace
 
 __syscall_badsys:
diff --git a/arch/frv/kernel/ptrace.c b/arch/frv/kernel/ptrace.c
index 5e7d401d21e7..60eeed3694c0 100644
--- a/arch/frv/kernel/ptrace.c
+++ b/arch/frv/kernel/ptrace.c
@@ -19,6 +19,9 @@
 #include <linux/user.h>
 #include <linux/security.h>
 #include <linux/signal.h>
+#include <linux/regset.h>
+#include <linux/elf.h>
+#include <linux/tracehook.h>
 
 #include <asm/uaccess.h>
 #include <asm/page.h>
@@ -33,6 +36,169 @@
  */
 
 /*
+ * retrieve the contents of FRV userspace general registers
+ */
+static int genregs_get(struct task_struct *target,
+                       const struct user_regset *regset,
+                       unsigned int pos, unsigned int count,
+                       void *kbuf, void __user *ubuf)
+{
+        const struct user_int_regs *iregs = &target->thread.user->i;
+        int ret;
+
+        ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
+                                  iregs, 0, sizeof(*iregs));
+        if (ret < 0)
+                return ret;
+
+        return user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
+                                        sizeof(*iregs), -1);
+}
+
+/*
+ * update the contents of the FRV userspace general registers
+ */
+static int genregs_set(struct task_struct *target,
+                       const struct user_regset *regset,
+                       unsigned int pos, unsigned int count,
+                       const void *kbuf, const void __user *ubuf)
+{
+        struct user_int_regs *iregs = &target->thread.user->i;
+        unsigned int offs_gr0, offs_gr1;
+        int ret;
+
+        /* not allowed to set PSR or __status */
+        if (pos < offsetof(struct user_int_regs, psr) + sizeof(long) &&
+            pos + count > offsetof(struct user_int_regs, psr))
+                return -EIO;
+
+        if (pos < offsetof(struct user_int_regs, __status) + sizeof(long) &&
+            pos + count > offsetof(struct user_int_regs, __status))
+                return -EIO;
+
+        /* set the control regs */
+        offs_gr0 = offsetof(struct user_int_regs, gr[0]);
+        offs_gr1 = offsetof(struct user_int_regs, gr[1]);
+        ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
+                                 iregs, 0, offs_gr0);
+        if (ret < 0)
+                return ret;
+
+        /* skip GR0/TBR */
+        ret = user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
+                                        offs_gr0, offs_gr1);
+        if (ret < 0)
+                return ret;
+
+        /* set the general regs */
+        ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
+                                 &iregs->gr[1], offs_gr1, sizeof(*iregs));
+        if (ret < 0)
+                return ret;
+
+        return user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
+                                        sizeof(*iregs), -1);
+}
+
+/*
+ * retrieve the contents of FRV userspace FP/Media registers
+ */
+static int fpmregs_get(struct task_struct *target,
+                       const struct user_regset *regset,
+                       unsigned int pos, unsigned int count,
+                       void *kbuf, void __user *ubuf)
+{
+        const struct user_fpmedia_regs *fpregs = &target->thread.user->f;
+        int ret;
+
+        ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
+                                  fpregs, 0, sizeof(*fpregs));
+        if (ret < 0)
+                return ret;
+
+        return user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
+                                        sizeof(*fpregs), -1);
+}
+
+/*
+ * update the contents of the FRV userspace FP/Media registers
+ */
+static int fpmregs_set(struct task_struct *target,
+                       const struct user_regset *regset,
+                       unsigned int pos, unsigned int count,
+                       const void *kbuf, const void __user *ubuf)
+{
+        struct user_fpmedia_regs *fpregs = &target->thread.user->f;
+        int ret;
+
+        ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
+                                 fpregs, 0, sizeof(*fpregs));
+        if (ret < 0)
+                return ret;
+
+        return user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
+                                        sizeof(*fpregs), -1);
+}
+
+/*
+ * determine if the FP/Media registers have actually been used
+ */
+static int fpmregs_active(struct task_struct *target,
+                          const struct user_regset *regset)
+{
+        return tsk_used_math(target) ? regset->n : 0;
+}
+
+/*
+ * Define the register sets available on the FRV under Linux
+ */
+enum frv_regset {
+        REGSET_GENERAL,
+        REGSET_FPMEDIA,
+};
+
+static const struct user_regset frv_regsets[] = {
+        /*
+         * General register format is:
+         *      PSR, ISR, CCR, CCCR, LR, LCR, PC, (STATUS), SYSCALLNO, ORIG_G8
+         *      GNER0-1, IACC0, TBR, GR1-63
+         */
+        [REGSET_GENERAL] = {
+                .core_note_type = NT_PRSTATUS,
+                .n              = ELF_NGREG,
+                .size           = sizeof(long),
+                .align          = sizeof(long),
+                .get            = genregs_get,
+                .set            = genregs_set,
+        },
+        /*
+         * FPU/Media register format is:
+         *      FR0-63, FNER0-1, MSR0-1, ACC0-7, ACCG0-8, FSR
+         */
+        [REGSET_FPMEDIA] = {
+                .core_note_type = NT_PRFPREG,
+                .n              = sizeof(struct user_fpmedia_regs) / sizeof(long),
+                .size           = sizeof(long),
+                .align          = sizeof(long),
+                .get            = fpmregs_get,
+                .set            = fpmregs_set,
+                .active         = fpmregs_active,
+        },
+};
+
+static const struct user_regset_view user_frv_native_view = {
+        .name           = "frv",
+        .e_machine      = EM_FRV,
+        .regsets        = frv_regsets,
+        .n              = ARRAY_SIZE(frv_regsets),
+};
+
+const struct user_regset_view *task_user_regset_view(struct task_struct *task)
+{
+        return &user_frv_native_view;
+}
+
+/*
  * Get contents of register REGNO in task TASK.
  */
 static inline long get_reg(struct task_struct *task, int regno)
@@ -69,40 +235,23 @@ static inline int put_reg(struct task_struct *task, int regno,
 }
 
 /*
- * check that an address falls within the bounds of the target process's memory
- * mappings
- */
-static inline int is_user_addr_valid(struct task_struct *child,
-                                     unsigned long start, unsigned long len)
-{
-#ifdef CONFIG_MMU
-        if (start >= PAGE_OFFSET || len > PAGE_OFFSET - start)
-                return -EIO;
-        return 0;
-#else
-        struct vm_area_struct *vma;
-
-        vma = find_vma(child->mm, start);
-        if (vma && start >= vma->vm_start && start + len <= vma->vm_end)
-                return 0;
-
-        return -EIO;
-#endif
-}
-
-/*
  * Called by kernel/ptrace.c when detaching..
  *
  * Control h/w single stepping
  */
-void ptrace_disable(struct task_struct *child)
+void user_enable_single_step(struct task_struct *child)
+{
+        child->thread.frame0->__status |= REG__STATUS_STEP;
+}
+
+void user_disable_single_step(struct task_struct *child)
 {
         child->thread.frame0->__status &= ~REG__STATUS_STEP;
 }
 
-void ptrace_enable(struct task_struct *child)
+void ptrace_disable(struct task_struct *child)
 {
-        child->thread.frame0->__status |= REG__STATUS_STEP;
+        user_disable_single_step(child);
 }
 
 long arch_ptrace(struct task_struct *child, long request, long addr, long data)
@@ -111,15 +260,6 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
         int ret;
 
         switch (request) {
-                /* when I and D space are separate, these will need to be fixed. */
-        case PTRACE_PEEKTEXT: /* read word at location addr. */
-        case PTRACE_PEEKDATA:
-                ret = -EIO;
-                if (is_user_addr_valid(child, addr, sizeof(tmp)) < 0)
-                        break;
-                ret = generic_ptrace_peekdata(child, addr, data);
-                break;
-
                 /* read the word at location addr in the USER area. */
         case PTRACE_PEEKUSR: {
                 tmp = 0;
@@ -163,15 +303,6 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                 break;
         }
 
-                /* when I and D space are separate, this will have to be fixed. */
-        case PTRACE_POKETEXT: /* write the word at location addr. */
-        case PTRACE_POKEDATA:
-                ret = -EIO;
-                if (is_user_addr_valid(child, addr, sizeof(tmp)) < 0)
-                        break;
-                ret = generic_ptrace_pokedata(child, addr, data);
-                break;
-
         case PTRACE_POKEUSR: /* write the word at location addr in the USER area */
                 ret = -EIO;
                 if ((addr & 3) || addr < 0)
@@ -179,7 +310,7 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
 
                 ret = 0;
                 switch (addr >> 2) {
-                case 0 ... PT__END-1:
+                case 0 ... PT__END - 1:
                         ret = put_reg(child, addr >> 2, data);
                         break;
 
@@ -189,95 +320,29 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                 }
                 break;
 
-        case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
-        case PTRACE_CONT: /* restart after signal. */
-                ret = -EIO;
-                if (!valid_signal(data))
-                        break;
-                if (request == PTRACE_SYSCALL)
-                        set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-                else
-                        clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-                child->exit_code = data;
-                ptrace_disable(child);
-                wake_up_process(child);
-                ret = 0;
-                break;
-
-                /* make the child exit.  Best I can do is send it a sigkill.
-                 * perhaps it should be put in the status that it wants to
-                 * exit.
-                 */
-        case PTRACE_KILL:
-                ret = 0;
-                if (child->exit_state == EXIT_ZOMBIE)   /* already dead */
-                        break;
-                child->exit_code = SIGKILL;
-                clear_tsk_thread_flag(child, TIF_SINGLESTEP);
-                ptrace_disable(child);
-                wake_up_process(child);
-                break;
-
-        case PTRACE_SINGLESTEP:  /* set the trap flag. */
-                ret = -EIO;
-                if (!valid_signal(data))
-                        break;
-                clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-                ptrace_enable(child);
-                child->exit_code = data;
-                wake_up_process(child);
-                ret = 0;
-                break;
-
-        case PTRACE_DETACH:     /* detach a process that was attached. */
-                ret = ptrace_detach(child, data);
-                break;
-
-        case PTRACE_GETREGS: { /* Get all integer regs from the child. */
-                int i;
-                for (i = 0; i < PT__GPEND; i++) {
-                        tmp = get_reg(child, i);
-                        if (put_user(tmp, (unsigned long *) data)) {
-                                ret = -EFAULT;
-                                break;
-                        }
-                        data += sizeof(long);
-                }
-                ret = 0;
-                break;
-        }
-
-        case PTRACE_SETREGS: { /* Set all integer regs in the child. */
-                int i;
-                for (i = 0; i < PT__GPEND; i++) {
-                        if (get_user(tmp, (unsigned long *) data)) {
-                                ret = -EFAULT;
-                                break;
-                        }
-                        put_reg(child, i, tmp);
-                        data += sizeof(long);
-                }
-                ret = 0;
-                break;
-        }
-
-        case PTRACE_GETFPREGS: { /* Get the child FP/Media state. */
-                ret = 0;
-                if (copy_to_user((void *) data,
-                                 &child->thread.user->f,
-                                 sizeof(child->thread.user->f)))
-                        ret = -EFAULT;
-                break;
-        }
-
-        case PTRACE_SETFPREGS: { /* Set the child FP/Media state. */
-                ret = 0;
-                if (copy_from_user(&child->thread.user->f,
-                                   (void *) data,
-                                   sizeof(child->thread.user->f)))
-                        ret = -EFAULT;
-                break;
-        }
+        case PTRACE_GETREGS:    /* Get all integer regs from the child. */
+                return copy_regset_to_user(child, &user_frv_native_view,
+                                           REGSET_GENERAL,
+                                           0, sizeof(child->thread.user->i),
+                                           (void __user *)data);
+
+        case PTRACE_SETREGS:    /* Set all integer regs in the child. */
+                return copy_regset_from_user(child, &user_frv_native_view,
+                                             REGSET_GENERAL,
+                                             0, sizeof(child->thread.user->i),
+                                             (const void __user *)data);
+
+        case PTRACE_GETFPREGS:  /* Get the child FP/Media state. */
+                return copy_regset_to_user(child, &user_frv_native_view,
+                                           REGSET_FPMEDIA,
+                                           0, sizeof(child->thread.user->f),
+                                           (void __user *)data);
+
+        case PTRACE_SETFPREGS:  /* Set the child FP/Media state. */
+                return copy_regset_from_user(child, &user_frv_native_view,
+                                             REGSET_FPMEDIA,
+                                             0, sizeof(child->thread.user->f),
+                                             (const void __user *)data);
 
         case PTRACE_GETFDPIC:
                 tmp = 0;
@@ -300,414 +365,36 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                 break;
 
         default:
-                ret = -EIO;
+                ret = ptrace_request(child, request, addr, data);
                 break;
         }
         return ret;
 }
 
-int __nongprelbss kstrace;
-
-static const struct {
-        const char      *name;
-        unsigned        argmask;
-} __syscall_name_table[NR_syscalls] = {
-        [0]     = { "restart_syscall"                   },
-        [1]     = { "exit",             0x000001        },
-        [2]     = { "fork",             0xffffff        },
-        [3]     = { "read",             0x000141        },
-        [4]     = { "write",            0x000141        },
-        [5]     = { "open",             0x000235        },
-        [6]     = { "close",            0x000001        },
-        [7]     = { "waitpid",          0x000141        },
-        [8]     = { "creat",            0x000025        },
-        [9]     = { "link",             0x000055        },
-        [10]    = { "unlink",           0x000005        },
-        [11]    = { "execve",           0x000445        },
-        [12]    = { "chdir",            0x000005        },
-        [13]    = { "time",             0x000004        },
-        [14]    = { "mknod",            0x000325        },
-        [15]    = { "chmod",            0x000025        },
-        [16]    = { "lchown",           0x000025        },
-        [17]    = { "break" },
-        [18]    = { "oldstat",          0x000045        },
-        [19]    = { "lseek",            0x000131        },
-        [20]    = { "getpid",           0xffffff        },
-        [21]    = { "mount",            0x043555        },
-        [22]    = { "umount",           0x000005        },
-        [23]    = { "setuid",           0x000001        },
-        [24]    = { "getuid",           0xffffff        },
-        [25]    = { "stime",            0x000004        },
-        [26]    = { "ptrace",           0x004413        },
-        [27]    = { "alarm",            0x000001        },
-        [28]    = { "oldfstat",         0x000041        },
-        [29]    = { "pause",            0xffffff        },
-        [30]    = { "utime",            0x000045        },
-        [31]    = { "stty" },
-        [32]    = { "gtty" },
-        [33]    = { "access",           0x000025        },
-        [34]    = { "nice",             0x000001        },
-        [35]    = { "ftime" },
-        [36]    = { "sync",             0xffffff        },
-        [37]    = { "kill",             0x000011        },
-        [38]    = { "rename",           0x000055        },
-        [39]    = { "mkdir",            0x000025        },
-        [40]    = { "rmdir",            0x000005        },
-        [41]    = { "dup",              0x000001        },
-        [42]    = { "pipe",             0x000004        },
-        [43]    = { "times",            0x000004        },
-        [44]    = { "prof" },
-        [45]    = { "brk",              0x000004        },
-        [46]    = { "setgid",           0x000001        },
-        [47]    = { "getgid",           0xffffff        },
-        [48]    = { "signal",           0x000041        },
-        [49]    = { "geteuid",          0xffffff        },
-        [50]    = { "getegid",          0xffffff        },
-        [51]    = { "acct",             0x000005        },
-        [52]    = { "umount2",          0x000035        },
-        [53]    = { "lock" },
-        [54]    = { "ioctl",            0x000331        },
-        [55]    = { "fcntl",            0x000331        },
-        [56]    = { "mpx" },
-        [57]    = { "setpgid",          0x000011        },
-        [58]    = { "ulimit" },
-        [60]    = { "umask",            0x000002        },
-        [61]    = { "chroot",           0x000005        },
-        [62]    = { "ustat",            0x000043        },
-        [63]    = { "dup2",             0x000011        },
-        [64]    = { "getppid",          0xffffff        },
-        [65]    = { "getpgrp",          0xffffff        },
-        [66]    = { "setsid",           0xffffff        },
-        [67]    = { "sigaction" },
-        [68]    = { "sgetmask" },
-        [69]    = { "ssetmask" },
-        [70]    = { "setreuid" },
-        [71]    = { "setregid" },
-        [72]    = { "sigsuspend" },
-        [73]    = { "sigpending" },
-        [74]    = { "sethostname" },
-        [75]    = { "setrlimit" },
-        [76]    = { "getrlimit" },
-        [77]    = { "getrusage" },
-        [78]    = { "gettimeofday" },
-        [79]    = { "settimeofday" },
-        [80]    = { "getgroups" },
-        [81]    = { "setgroups" },
-        [82]    = { "select" },
-        [83]    = { "symlink" },
-        [84]    = { "oldlstat" },
-        [85]    = { "readlink" },
-        [86]    = { "uselib" },
-        [87]    = { "swapon" },
-        [88]    = { "reboot" },
-        [89]    = { "readdir" },
-        [91]    = { "munmap",           0x000034        },
-        [92]    = { "truncate" },
-        [93]    = { "ftruncate" },
-        [94]    = { "fchmod" },
-        [95]    = { "fchown" },
-        [96]    = { "getpriority" },
-        [97]    = { "setpriority" },
-        [99]    = { "statfs" },
-        [100]   = { "fstatfs" },
-        [102]   = { "socketcall" },
-        [103]   = { "syslog" },
-        [104]   = { "setitimer" },
-        [105]   = { "getitimer" },
-        [106]   = { "stat" },
-        [107]   = { "lstat" },
-        [108]   = { "fstat" },
-        [111]   = { "vhangup" },
-        [114]   = { "wait4" },
-        [115]   = { "swapoff" },
-        [116]   = { "sysinfo" },
-        [117]   = { "ipc" },
-        [118]   = { "fsync" },
-        [119]   = { "sigreturn" },
-        [120]   = { "clone" },
-        [121]   = { "setdomainname" },
-        [122]   = { "uname" },
-        [123]   = { "modify_ldt" },
-        [123]   = { "cacheflush" },
-        [124]   = { "adjtimex" },
-        [125]   = { "mprotect" },
-        [126]   = { "sigprocmask" },
-        [127]   = { "create_module" },
-        [128]   = { "init_module" },
-        [129]   = { "delete_module" },
-        [130]   = { "get_kernel_syms" },
-        [131]   = { "quotactl" },
-        [132]   = { "getpgid" },
-        [133]   = { "fchdir" },
-        [134]   = { "bdflush" },
-        [135]   = { "sysfs" },
-        [136]   = { "personality" },
-        [137]   = { "afs_syscall" },
-        [138]   = { "setfsuid" },
-        [139]   = { "setfsgid" },
-        [140]   = { "_llseek",                  0x014331        },
-        [141]   = { "getdents" },
-        [142]   = { "_newselect",               0x000141        },
-        [143]   = { "flock" },
-        [144]   = { "msync" },
-        [145]   = { "readv" },
-        [146]   = { "writev" },
-        [147]   = { "getsid",                   0x000001        },
-        [148]   = { "fdatasync",                0x000001        },
-        [149]   = { "_sysctl",                  0x000004        },
-        [150]   = { "mlock" },
-        [151]   = { "munlock" },
-        [152]   = { "mlockall" },
-        [153]   = { "munlockall" },
-        [154]   = { "sched_setparam" },
-        [155]   = { "sched_getparam" },
-        [156]   = { "sched_setscheduler" },
-        [157]   = { "sched_getscheduler" },
-        [158]   = { "sched_yield" },
-        [159]   = { "sched_get_priority_max" },
-        [160]   = { "sched_get_priority_min" },
-        [161]   = { "sched_rr_get_interval" },
-        [162]   = { "nanosleep",                0x000044        },
-        [163]   = { "mremap" },
-        [164]   = { "setresuid" },
-        [165]   = { "getresuid" },
-        [166]   = { "vm86" },
-        [167]   = { "query_module" },
-        [168]   = { "poll" },
-        [169]   = { "nfsservctl" },
-        [170]   = { "setresgid" },
-        [171]   = { "getresgid" },
-        [172]   = { "prctl",                    0x333331        },
-        [173]   = { "rt_sigreturn",             0xffffff        },
-        [174]   = { "rt_sigaction",             0x001441        },
-        [175]   = { "rt_sigprocmask",           0x001441        },
-        [176]   = { "rt_sigpending",            0x000014        },
-        [177]   = { "rt_sigtimedwait",          0x001444        },
-        [178]   = { "rt_sigqueueinfo",          0x000411        },
-        [179]   = { "rt_sigsuspend",            0x000014        },
-        [180]   = { "pread",                    0x003341        },
-        [181]   = { "pwrite",                   0x003341        },
-        [182]   = { "chown",                    0x000115        },
-        [183]   = { "getcwd" },
-        [184]   = { "capget" },
-        [185]   = { "capset" },
-        [186]   = { "sigaltstack" },
-        [187]   = { "sendfile" },
-        [188]   = { "getpmsg" },
-        [189]   = { "putpmsg" },
-        [190]   = { "vfork",                    0xffffff        },
-        [191]   = { "ugetrlimit" },
-        [192]   = { "mmap2",                    0x313314        },
-        [193]   = { "truncate64" },
-        [194]   = { "ftruncate64" },
-        [195]   = { "stat64",                   0x000045        },
-        [196]   = { "lstat64",                  0x000045        },
-        [197]   = { "fstat64",                  0x000041        },
-        [198]   = { "lchown32" },
-        [199]   = { "getuid32",                 0xffffff        },
-        [200]   = { "getgid32",                 0xffffff        },
-        [201]   = { "geteuid32",                0xffffff        },
-        [202]   = { "getegid32",                0xffffff        },
-        [203]   = { "setreuid32" },
-        [204]   = { "setregid32" },
-        [205]   = { "getgroups32" },
-        [206]   = { "setgroups32" },
-        [207]   = { "fchown32" },
-        [208]   = { "setresuid32" },
-        [209]   = { "getresuid32" },
-        [210]   = { "setresgid32" },
-        [211]   = { "getresgid32" },
-        [212]   = { "chown32" },
-        [213]   = { "setuid32" },
-        [214]   = { "setgid32" },
-        [215]   = { "setfsuid32" },
-        [216]   = { "setfsgid32" },
-        [217]   = { "pivot_root" },
-        [218]   = { "mincore" },
-        [219]   = { "madvise" },
-        [220]   = { "getdents64" },
-        [221]   = { "fcntl64" },
-        [223]   = { "security" },
-        [224]   = { "gettid" },
-        [225]   = { "readahead" },
-        [226]   = { "setxattr" },
-        [227]   = { "lsetxattr" },
-        [228]   = { "fsetxattr" },
-        [229]   = { "getxattr" },
-        [230]   = { "lgetxattr" },
-        [231]   = { "fgetxattr" },
-        [232]   = { "listxattr" },
-        [233]   = { "llistxattr" },
-        [234]   = { "flistxattr" },
-        [235]   = { "removexattr" },
-        [236]   = { "lremovexattr" },
-        [237]   = { "fremovexattr" },
-        [238]   = { "tkill" },
-        [239]   = { "sendfile64" },
-        [240]   = { "futex" },
-        [241]   = { "sched_setaffinity" },
-        [242]   = { "sched_getaffinity" },
-        [243]   = { "set_thread_area" },
-        [244]   = { "get_thread_area" },
-        [245]   = { "io_setup" },
-        [246]   = { "io_destroy" },
-        [247]   = { "io_getevents" },
-        [248]   = { "io_submit" },
-        [249]   = { "io_cancel" },
-        [250]   = { "fadvise64" },
-        [252]   = { "exit_group",               0x000001        },
-        [253]   = { "lookup_dcookie" },
-        [254]   = { "epoll_create" },
-        [255]   = { "epoll_ctl" },
-        [256]   = { "epoll_wait" },
-        [257]   = { "remap_file_pages" },
-        [258]   = { "set_tid_address" },
-        [259]   = { "timer_create" },
-        [260]   = { "timer_settime" },
-        [261]   = { "timer_gettime" },
-        [262]   = { "timer_getoverrun" },
-        [263]   = { "timer_delete" },
-        [264]   = { "clock_settime" },
-        [265]   = { "clock_gettime" },
-        [266]   = { "clock_getres" },
-        [267]   = { "clock_nanosleep" },
-        [268]   = { "statfs64" },
-        [269]   = { "fstatfs64" },
-        [270]   = { "tgkill" },
-        [271]   = { "utimes" },
-        [272]   = { "fadvise64_64" },
-        [273]   = { "vserver" },
-        [274]   = { "mbind" },
-        [275]   = { "get_mempolicy" },
-        [276]   = { "set_mempolicy" },
-        [277]   = { "mq_open" },
-        [278]   = { "mq_unlink" },
-        [279]   = { "mq_timedsend" },
-        [280]   = { "mq_timedreceive" },
-        [281]   = { "mq_notify" },
-        [282]   = { "mq_getsetattr" },
-        [283]   = { "sys_kexec_load" },
-};
-
-asmlinkage void do_syscall_trace(int leaving)
+/*
+ * handle tracing of system call entry
+ * - return the revised system call number or ULONG_MAX to cause ENOSYS
+ */
+asmlinkage unsigned long syscall_trace_entry(void)
 {
-#if 0
-        unsigned long *argp;
-        const char *name;
-        unsigned argmask;
-        char buffer[16];
-
-        if (!kstrace)
-                return;
-
-        if (!current->mm)
-                return;
-
-        if (__frame->gr7 == __NR_close)
-                return;
-
-#if 0
-        if (__frame->gr7 != __NR_mmap2 &&
-            __frame->gr7 != __NR_vfork &&
-            __frame->gr7 != __NR_execve &&
-            __frame->gr7 != __NR_exit)
-                return;
-#endif
-
-        argmask = 0;
-        name = NULL;
-        if (__frame->gr7 < NR_syscalls) {
-                name = __syscall_name_table[__frame->gr7].name;
-                argmask = __syscall_name_table[__frame->gr7].argmask;
-        }
-        if (!name) {
-                sprintf(buffer, "sys_%lx", __frame->gr7);
-                name = buffer;
-        }
-
-        if (!leaving) {
-                if (!argmask) {
-                        printk(KERN_CRIT "[%d] %s(%lx,%lx,%lx,%lx,%lx,%lx)\n",
-                               current->pid,
-                               name,
-                               __frame->gr8,
-                               __frame->gr9,
-                               __frame->gr10,
-                               __frame->gr11,
-                               __frame->gr12,
-                               __frame->gr13);
-                }
-                else if (argmask == 0xffffff) {
-                        printk(KERN_CRIT "[%d] %s()\n",
-                               current->pid,
-                               name);
-                }
-                else {
-                        printk(KERN_CRIT "[%d] %s(",
-                               current->pid,
-                               name);
-
-                        argp = &__frame->gr8;
-
-                        do {
-                                switch (argmask & 0xf) {
-                                case 1:
-                                        printk("%ld", (long) *argp);
-                                        break;
-                                case 2:
-                                        printk("%lo", *argp);
-                                        break;
-                                case 3:
-                                        printk("%lx", *argp);
-                                        break;
-                                case 4:
-                                        printk("%p", (void *) *argp);
-                                        break;
-                                case 5:
-                                        printk("\"%s\"", (char *) *argp);
-                                        break;
-                                }
-
-                                argp++;
-                                argmask >>= 4;
-                                if (argmask)
-                                        printk(",");
-
-                        } while (argmask);
-
-                        printk(")\n");
-                }
-        }
-        else {
-                if ((int)__frame->gr8 > -4096 && (int)__frame->gr8 < 4096)
-                        printk(KERN_CRIT "[%d] %s() = %ld\n", current->pid, name, __frame->gr8);
-                else
-                        printk(KERN_CRIT "[%d] %s() = %lx\n", current->pid, name, __frame->gr8);
+        __frame->__status |= REG__STATUS_SYSC_ENTRY;
+        if (tracehook_report_syscall_entry(__frame)) {
+                /* tracing decided this syscall should not happen, so
+                 * We'll return a bogus call number to get an ENOSYS
+                 * error, but leave the original number in
+                 * __frame->syscallno
+                 */
+                return ULONG_MAX;
         }
-        return;
-#endif
-
-        if (!test_thread_flag(TIF_SYSCALL_TRACE))
-                return;
-
-        if (!(current->ptrace & PT_PTRACED))
-                return;
 
-        /* we need to indicate entry or exit to strace */
-        if (leaving)
-                __frame->__status |= REG__STATUS_SYSC_EXIT;
-        else
-                __frame->__status |= REG__STATUS_SYSC_ENTRY;
-
-        ptrace_notify(SIGTRAP);
+        return __frame->syscallno;
+}
 
-        /*
-         * this isn't the same as continuing with a signal, but it will do
-         * for normal use.  strace only continues with a signal if the
-         * stopping signal is not SIGTRAP.  -brl
-         */
-        if (current->exit_code) {
-                send_sig(current->exit_code, current, 1);
-                current->exit_code = 0;
-        }
+/*
+ * handle tracing of system call exit
+ */
+asmlinkage void syscall_trace_exit(void)
+{
+        __frame->__status |= REG__STATUS_SYSC_EXIT;
+        tracehook_report_syscall_exit(__frame, 0);
 }
diff --git a/arch/frv/kernel/signal.c b/arch/frv/kernel/signal.c
index 3bdb368292a8..4a7a62c6e783 100644
--- a/arch/frv/kernel/signal.c
+++ b/arch/frv/kernel/signal.c
@@ -21,6 +21,7 @@
 #include <linux/unistd.h>
 #include <linux/personality.h>
 #include <linux/freezer.h>
+#include <linux/tracehook.h>
 #include <asm/ucontext.h>
 #include <asm/uaccess.h>
 #include <asm/cacheflush.h>
@@ -516,6 +517,9 @@ static void do_signal(void)
                          * clear the TIF_RESTORE_SIGMASK flag */
                         if (test_thread_flag(TIF_RESTORE_SIGMASK))
                                 clear_thread_flag(TIF_RESTORE_SIGMASK);
+
+                        tracehook_signal_handler(signr, &info, &ka, __frame,
+                                                 test_thread_flag(TIF_SINGLESTEP));
                 }
 
                 return;
@@ -564,4 +568,10 @@ asmlinkage void do_notify_resume(__u32 thread_info_flags)
         if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
                 do_signal();
 
+        /* deal with notification on about to resume userspace execution */
+        if (thread_info_flags & _TIF_NOTIFY_RESUME) {
+                clear_thread_flag(TIF_NOTIFY_RESUME);
+                tracehook_notify_resume(__frame);
+        }
+
 } /* end do_notify_resume() */
diff --git a/arch/frv/kernel/uaccess.c b/arch/frv/kernel/uaccess.c
index 9fb771a20df3..374f88d6cc00 100644
--- a/arch/frv/kernel/uaccess.c
+++ b/arch/frv/kernel/uaccess.c
@@ -23,8 +23,7 @@ long strncpy_from_user(char *dst, const char __user *src, long count)
         char *p, ch;
         long err = -EFAULT;
 
-        if (count < 0)
-                BUG();
+        BUG_ON(count < 0);
 
         p = dst;
 
@@ -76,8 +75,7 @@ long strnlen_user(const char __user *src, long count)
         long err = 0;
         char ch;
 
-        if (count < 0)
-                BUG();
+        BUG_ON(count < 0);
 
 #ifndef CONFIG_MMU
         if ((unsigned long) src < memory_start)
diff --git a/arch/frv/mb93090-mb00/pci-dma-nommu.c b/arch/frv/mb93090-mb00/pci-dma-nommu.c
index 52ff9aec799d..4e1ba0b15443 100644
--- a/arch/frv/mb93090-mb00/pci-dma-nommu.c
+++ b/arch/frv/mb93090-mb00/pci-dma-nommu.c
@@ -116,8 +116,7 @@ EXPORT_SYMBOL(dma_free_coherent);
 dma_addr_t dma_map_single(struct device *dev, void *ptr, size_t size,
                           enum dma_data_direction direction)
 {
-        if (direction == DMA_NONE)
-                BUG();
+        BUG_ON(direction == DMA_NONE);
 
         frv_cache_wback_inv((unsigned long) ptr, (unsigned long) ptr + size);
 
@@ -151,8 +150,7 @@ int dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
                 frv_cache_wback_inv(sg_dma_address(&sg[i]),
                                     sg_dma_address(&sg[i]) + sg_dma_len(&sg[i]));
 
-        if (direction == DMA_NONE)
-                BUG();
+        BUG_ON(direction == DMA_NONE);
 
         return nents;
 }
diff --git a/arch/frv/mb93090-mb00/pci-dma.c b/arch/frv/mb93090-mb00/pci-dma.c
index 3ddedebc4eb3..45954f0813dc 100644
--- a/arch/frv/mb93090-mb00/pci-dma.c
+++ b/arch/frv/mb93090-mb00/pci-dma.c
@@ -48,8 +48,7 @@ EXPORT_SYMBOL(dma_free_coherent);
 dma_addr_t dma_map_single(struct device *dev, void *ptr, size_t size,
                           enum dma_data_direction direction)
 {
-        if (direction == DMA_NONE)
-                BUG();
+        BUG_ON(direction == DMA_NONE);
 
         frv_cache_wback_inv((unsigned long) ptr, (unsigned long) ptr + size);
 
@@ -81,8 +80,7 @@ int dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
         void *vaddr;
         int i;
 
-        if (direction == DMA_NONE)
-                BUG();
+        BUG_ON(direction == DMA_NONE);
 
         dampr2 = __get_DAMPR(2);
 
diff --git a/arch/ia64/include/asm/kvm_host.h b/arch/ia64/include/asm/kvm_host.h
index 4542651e6acb..5f43697aed30 100644
--- a/arch/ia64/include/asm/kvm_host.h
+++ b/arch/ia64/include/asm/kvm_host.h
@@ -371,6 +371,7 @@ struct kvm_vcpu_arch {
         int last_run_cpu;
         int vmm_tr_slot;
         int vm_tr_slot;
+        int sn_rtc_tr_slot;
 
 #define KVM_MP_STATE_RUNNABLE          0
 #define KVM_MP_STATE_UNINITIALIZED     1
@@ -465,6 +466,7 @@ struct kvm_arch {
         unsigned long   vmm_init_rr;
 
         int             online_vcpus;
+        int             is_sn2;
 
         struct kvm_ioapic *vioapic;
         struct kvm_vm_stat stat;
@@ -472,6 +474,7 @@ struct kvm_arch {
 
         struct list_head assigned_dev_head;
         struct iommu_domain *iommu_domain;
+        int iommu_flags;
         struct hlist_head irq_ack_notifier_list;
 
         unsigned long irq_sources_bitmap;
@@ -578,6 +581,8 @@ struct kvm_vmm_info{
         kvm_vmm_entry   *vmm_entry;
         kvm_tramp_entry *tramp_entry;
         unsigned long   vmm_ivt;
+        unsigned long   patch_mov_ar;
+        unsigned long   patch_mov_ar_sn2;
 };
 
 int kvm_highest_pending_irq(struct kvm_vcpu *vcpu);
@@ -585,7 +590,6 @@ int kvm_emulate_halt(struct kvm_vcpu *vcpu);
 int kvm_pal_emul(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run);
 void kvm_sal_emul(struct kvm_vcpu *vcpu);
 
-static inline void kvm_inject_nmi(struct kvm_vcpu *vcpu) {}
 #endif /* __ASSEMBLY__*/
 
 #endif
diff --git a/arch/ia64/include/asm/pgtable.h b/arch/ia64/include/asm/pgtable.h
index 7a9bff47564f..0a9cc73d35c7 100644
--- a/arch/ia64/include/asm/pgtable.h
+++ b/arch/ia64/include/asm/pgtable.h
@@ -146,6 +146,8 @@
 #define PAGE_GATE       __pgprot(__ACCESS_BITS | _PAGE_PL_0 | _PAGE_AR_X_RX)
 #define PAGE_KERNEL     __pgprot(__DIRTY_BITS  | _PAGE_PL_0 | _PAGE_AR_RWX)
 #define PAGE_KERNELRX   __pgprot(__ACCESS_BITS | _PAGE_PL_0 | _PAGE_AR_RX)
+#define PAGE_KERNEL_UC  __pgprot(__DIRTY_BITS  | _PAGE_PL_0 | _PAGE_AR_RWX | \
+                                 _PAGE_MA_UC)
 
 # ifndef __ASSEMBLY__
 
diff --git a/arch/ia64/kernel/irq_ia64.c b/arch/ia64/kernel/irq_ia64.c
index acc4d19ae62a..b448197728be 100644
--- a/arch/ia64/kernel/irq_ia64.c
+++ b/arch/ia64/kernel/irq_ia64.c
@@ -610,6 +610,9 @@ static struct irqaction ipi_irqaction = {
         .name =         "IPI"
 };
 
+/*
+ * KVM uses this interrupt to force a cpu out of guest mode
+ */
 static struct irqaction resched_irqaction = {
         .handler =      dummy_handler,
         .flags =        IRQF_DISABLED,
diff --git a/arch/ia64/kvm/Kconfig b/arch/ia64/kvm/Kconfig
index 0a2d6b86075a..64d520937874 100644
--- a/arch/ia64/kvm/Kconfig
+++ b/arch/ia64/kvm/Kconfig
@@ -23,7 +23,7 @@ if VIRTUALIZATION
 
 config KVM
         tristate "Kernel-based Virtual Machine (KVM) support"
-        depends on HAVE_KVM && EXPERIMENTAL
+        depends on HAVE_KVM && MODULES && EXPERIMENTAL
         # for device assignment:
         depends on PCI
         select PREEMPT_NOTIFIERS
diff --git a/arch/ia64/kvm/kvm-ia64.c b/arch/ia64/kvm/kvm-ia64.c
index d20a5db4c4dd..80c57b0a21c4 100644
--- a/arch/ia64/kvm/kvm-ia64.c
+++ b/arch/ia64/kvm/kvm-ia64.c
@@ -41,6 +41,9 @@
 #include <asm/div64.h>
 #include <asm/tlb.h>
 #include <asm/elf.h>
+#include <asm/sn/addrs.h>
+#include <asm/sn/clksupport.h>
+#include <asm/sn/shub_mmr.h>
 
 #include "misc.h"
 #include "vti.h"
@@ -65,6 +68,16 @@ struct kvm_stats_debugfs_item debugfs_entries[] = {
         { NULL }
 };
 
+static unsigned long kvm_get_itc(struct kvm_vcpu *vcpu)
+{
+#if defined(CONFIG_IA64_SGI_SN2) || defined(CONFIG_IA64_GENERIC)
+        if (vcpu->kvm->arch.is_sn2)
+                return rtc_time();
+        else
+#endif
+                return ia64_getreg(_IA64_REG_AR_ITC);
+}
+
 static void kvm_flush_icache(unsigned long start, unsigned long len)
 {
         int l;
@@ -119,8 +132,7 @@ void kvm_arch_hardware_enable(void *garbage)
         unsigned long saved_psr;
         int slot;
 
-        pte = pte_val(mk_pte_phys(__pa(kvm_vmm_base),
-                                PAGE_KERNEL));
+        pte = pte_val(mk_pte_phys(__pa(kvm_vmm_base), PAGE_KERNEL));
         local_irq_save(saved_psr);
         slot = ia64_itr_entry(0x3, KVM_VMM_BASE, pte, KVM_VMM_SHIFT);
         local_irq_restore(saved_psr);
@@ -283,6 +295,18 @@ static int handle_sal_call(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 
 }
 
+static int __apic_accept_irq(struct kvm_vcpu *vcpu, uint64_t vector)
+{
+        struct vpd *vpd = to_host(vcpu->kvm, vcpu->arch.vpd);
+
+        if (!test_and_set_bit(vector, &vpd->irr[0])) {
+                vcpu->arch.irq_new_pending = 1;
+                kvm_vcpu_kick(vcpu);
+                return 1;
+        }
+        return 0;
+}
+
 /*
  *  offset: address offset to IPI space.
  *  value:  deliver value.
@@ -292,20 +316,20 @@ static void vcpu_deliver_ipi(struct kvm_vcpu *vcpu, uint64_t dm,
 {
         switch (dm) {
         case SAPIC_FIXED:
-                kvm_apic_set_irq(vcpu, vector, 0);
                 break;
         case SAPIC_NMI:
-                kvm_apic_set_irq(vcpu, 2, 0);
+                vector = 2;
                 break;
         case SAPIC_EXTINT:
-                kvm_apic_set_irq(vcpu, 0, 0);
+                vector = 0;
                 break;
         case SAPIC_INIT:
         case SAPIC_PMI:
         default:
                 printk(KERN_ERR"kvm: Unimplemented Deliver reserved IPI!\n");
-                break;
+                return;
         }
+        __apic_accept_irq(vcpu, vector);
 }
 
 static struct kvm_vcpu *lid_to_vcpu(struct kvm *kvm, unsigned long id,
@@ -413,6 +437,23 @@ static int handle_switch_rr6(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
         return 1;
 }
 
+static int kvm_sn2_setup_mappings(struct kvm_vcpu *vcpu)
+{
+        unsigned long pte, rtc_phys_addr, map_addr;
+        int slot;
+
+        map_addr = KVM_VMM_BASE + (1UL << KVM_VMM_SHIFT);
+        rtc_phys_addr = LOCAL_MMR_OFFSET | SH_RTC;
+        pte = pte_val(mk_pte_phys(rtc_phys_addr, PAGE_KERNEL_UC));
+        slot = ia64_itr_entry(0x3, map_addr, pte, PAGE_SHIFT);
+        vcpu->arch.sn_rtc_tr_slot = slot;
+        if (slot < 0) {
+                printk(KERN_ERR "Mayday mayday! RTC mapping failed!\n");
+                slot = 0;
+        }
+        return slot;
+}
+
 int kvm_emulate_halt(struct kvm_vcpu *vcpu)
 {
 
@@ -426,7 +467,7 @@ int kvm_emulate_halt(struct kvm_vcpu *vcpu)
 
         if (irqchip_in_kernel(vcpu->kvm)) {
 
-                vcpu_now_itc = ia64_getreg(_IA64_REG_AR_ITC) + vcpu->arch.itc_offset;
+                vcpu_now_itc = kvm_get_itc(vcpu) + vcpu->arch.itc_offset;
 
                 if (time_after(vcpu_now_itc, vpd->itm)) {
                         vcpu->arch.timer_check = 1;
@@ -447,10 +488,10 @@ int kvm_emulate_halt(struct kvm_vcpu *vcpu)
                 hrtimer_cancel(p_ht);
                 vcpu->arch.ht_active = 0;
 
-                if (test_and_clear_bit(KVM_REQ_UNHALT, &vcpu->requests))
+                if (test_and_clear_bit(KVM_REQ_UNHALT, &vcpu->requests) ||
+                                kvm_cpu_has_pending_timer(vcpu))
                         if (vcpu->arch.mp_state == KVM_MP_STATE_HALTED)
-                                vcpu->arch.mp_state =
-                                        KVM_MP_STATE_RUNNABLE;
+                                vcpu->arch.mp_state = KVM_MP_STATE_RUNNABLE;
 
                 if (vcpu->arch.mp_state != KVM_MP_STATE_RUNNABLE)
                         return -EINTR;
@@ -551,22 +592,35 @@ static int kvm_insert_vmm_mapping(struct kvm_vcpu *vcpu)
         if (r < 0)
                 goto out;
         vcpu->arch.vm_tr_slot = r;
+
+#if defined(CONFIG_IA64_SGI_SN2) || defined(CONFIG_IA64_GENERIC)
+        if (kvm->arch.is_sn2) {
+                r = kvm_sn2_setup_mappings(vcpu);
+                if (r < 0)
+                        goto out;
+        }
+#endif
+
         r = 0;
 out:
         return r;
-
 }
 
 static void kvm_purge_vmm_mapping(struct kvm_vcpu *vcpu)
 {
-
+        struct kvm *kvm = vcpu->kvm;
         ia64_ptr_entry(0x3, vcpu->arch.vmm_tr_slot);
         ia64_ptr_entry(0x3, vcpu->arch.vm_tr_slot);
-
+#if defined(CONFIG_IA64_SGI_SN2) || defined(CONFIG_IA64_GENERIC)
+        if (kvm->arch.is_sn2)
+                ia64_ptr_entry(0x3, vcpu->arch.sn_rtc_tr_slot);
+#endif
 }
 
 static int kvm_vcpu_pre_transition(struct kvm_vcpu *vcpu)
 {
+        unsigned long psr;
+        int r;
         int cpu = smp_processor_id();
 
         if (vcpu->arch.last_run_cpu != cpu ||
@@ -578,36 +632,27 @@ static int kvm_vcpu_pre_transition(struct kvm_vcpu *vcpu)
 
         vcpu->arch.host_rr6 = ia64_get_rr(RR6);
         vti_set_rr6(vcpu->arch.vmm_rr);
-        return kvm_insert_vmm_mapping(vcpu);
+        local_irq_save(psr);
+        r = kvm_insert_vmm_mapping(vcpu);
+        local_irq_restore(psr);
+        return r;
 }
+
 static void kvm_vcpu_post_transition(struct kvm_vcpu *vcpu)
 {
         kvm_purge_vmm_mapping(vcpu);
         vti_set_rr6(vcpu->arch.host_rr6);
 }
 
-static int  vti_vcpu_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+static int __vcpu_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 {
         union context *host_ctx, *guest_ctx;
         int r;
 
-        /*Get host and guest context with guest address space.*/
-        host_ctx = kvm_get_host_context(vcpu);
-        guest_ctx = kvm_get_guest_context(vcpu);
-
-        r = kvm_vcpu_pre_transition(vcpu);
-        if (r < 0)
-                goto out;
-        kvm_vmm_info->tramp_entry(host_ctx, guest_ctx);
-        kvm_vcpu_post_transition(vcpu);
-        r = 0;
-out:
-        return r;
-}
-
-static int __vcpu_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
-{
-        int r;
+        /*
+         * down_read() may sleep and return with interrupts enabled
+         */
+        down_read(&vcpu->kvm->slots_lock);
 
 again:
         if (signal_pending(current)) {
@@ -616,26 +661,31 @@ again:
                 goto out;
         }
 
-        /*
-         * down_read() may sleep and return with interrupts enabled
-         */
-        down_read(&vcpu->kvm->slots_lock);
-
         preempt_disable();
         local_irq_disable();
 
-        vcpu->guest_mode = 1;
+        /*Get host and guest context with guest address space.*/
+        host_ctx = kvm_get_host_context(vcpu);
+        guest_ctx = kvm_get_guest_context(vcpu);
+
+        clear_bit(KVM_REQ_KICK, &vcpu->requests);
+
+        r = kvm_vcpu_pre_transition(vcpu);
+        if (r < 0)
+                goto vcpu_run_fail;
+
+        up_read(&vcpu->kvm->slots_lock);
         kvm_guest_enter();
-        r = vti_vcpu_run(vcpu, kvm_run);
-        if (r < 0) {
-                local_irq_enable();
-                preempt_enable();
-                kvm_run->exit_reason = KVM_EXIT_FAIL_ENTRY;
-                goto out;
-        }
+
+        /*
+         * Transition to the guest
+         */
+        kvm_vmm_info->tramp_entry(host_ctx, guest_ctx);
+
+        kvm_vcpu_post_transition(vcpu);
 
         vcpu->arch.launched = 1;
-        vcpu->guest_mode = 0;
+        set_bit(KVM_REQ_KICK, &vcpu->requests);
         local_irq_enable();
 
         /*
@@ -646,9 +696,10 @@ again:
          */
         barrier();
         kvm_guest_exit();
-        up_read(&vcpu->kvm->slots_lock);
         preempt_enable();
 
+        down_read(&vcpu->kvm->slots_lock);
+
         r = kvm_handle_exit(kvm_run, vcpu);
 
         if (r > 0) {
@@ -657,12 +708,20 @@ again:
         }
 
 out:
+        up_read(&vcpu->kvm->slots_lock);
         if (r > 0) {
                 kvm_resched(vcpu);
+                down_read(&vcpu->kvm->slots_lock);
                 goto again;
         }
 
         return r;
+
+vcpu_run_fail:
+        local_irq_enable();
+        preempt_enable();
+        kvm_run->exit_reason = KVM_EXIT_FAIL_ENTRY;
+        goto out;
 }
 
 static void kvm_set_mmio_data(struct kvm_vcpu *vcpu)
@@ -788,6 +847,9 @@ struct  kvm *kvm_arch_create_vm(void)
 
         if (IS_ERR(kvm))
                 return ERR_PTR(-ENOMEM);
+
+        kvm->arch.is_sn2 = ia64_platform_is("sn2");
+
         kvm_init_vm(kvm);
 
         kvm->arch.online_vcpus = 0;
@@ -884,7 +946,7 @@ int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
         RESTORE_REGS(saved_gp);
 
         vcpu->arch.irq_new_pending = 1;
-        vcpu->arch.itc_offset = regs->saved_itc - ia64_getreg(_IA64_REG_AR_ITC);
+        vcpu->arch.itc_offset = regs->saved_itc - kvm_get_itc(vcpu);
         set_bit(KVM_REQ_RESUME, &vcpu->requests);
 
         vcpu_put(vcpu);
@@ -1043,10 +1105,6 @@ static void kvm_free_vmm_area(void)
         }
 }
 
-static void vti_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
-{
-}
-
 static int vti_init_vpd(struct kvm_vcpu *vcpu)
 {
         int i;
@@ -1165,7 +1223,7 @@ int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
                 regs->cr_iip = PALE_RESET_ENTRY;
 
                 /*Initialize itc offset for vcpus*/
-                itc_offset = 0UL - ia64_getreg(_IA64_REG_AR_ITC);
+                itc_offset = 0UL - kvm_get_itc(vcpu);
                 for (i = 0; i < kvm->arch.online_vcpus; i++) {
                         v = (struct kvm_vcpu *)((char *)vcpu +
                                         sizeof(struct kvm_vcpu_data) * i);
@@ -1237,6 +1295,7 @@ static int vti_vcpu_setup(struct kvm_vcpu *vcpu, int id)
 
         local_irq_save(psr);
         r = kvm_insert_vmm_mapping(vcpu);
+        local_irq_restore(psr);
         if (r)
                 goto fail;
         r = kvm_vcpu_init(vcpu, vcpu->kvm, id);
@@ -1254,13 +1313,11 @@ static int vti_vcpu_setup(struct kvm_vcpu *vcpu, int id)
                 goto uninit;
 
         kvm_purge_vmm_mapping(vcpu);
-        local_irq_restore(psr);
 
         return 0;
 uninit:
         kvm_vcpu_uninit(vcpu);
 fail:
-        local_irq_restore(psr);
         return r;
 }
 
@@ -1291,7 +1348,6 @@ struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
         vcpu->kvm = kvm;
 
         cpu = get_cpu();
-        vti_vcpu_load(vcpu, cpu);
         r = vti_vcpu_setup(vcpu, id);
         put_cpu();
 
@@ -1427,7 +1483,7 @@ int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu, struct kvm_regs *regs)
         }
         for (i = 0; i < 4; i++)
                 regs->insvc[i] = vcpu->arch.insvc[i];
-        regs->saved_itc = vcpu->arch.itc_offset + ia64_getreg(_IA64_REG_AR_ITC);
+        regs->saved_itc = vcpu->arch.itc_offset + kvm_get_itc(vcpu);
         SAVE_REGS(xtp);
         SAVE_REGS(metaphysical_rr0);
         SAVE_REGS(metaphysical_rr4);
@@ -1574,6 +1630,7 @@ int kvm_arch_set_memory_region(struct kvm *kvm,
 
 void kvm_arch_flush_shadow(struct kvm *kvm)
 {
+        kvm_flush_remote_tlbs(kvm);
 }
 
 long kvm_arch_dev_ioctl(struct file *filp,
@@ -1616,8 +1673,37 @@ out:
         return 0;
 }
 
+
+/*
+ * On SN2, the ITC isn't stable, so copy in fast path code to use the
+ * SN2 RTC, replacing the ITC based default verion.
+ */
+static void kvm_patch_vmm(struct kvm_vmm_info *vmm_info,
+                          struct module *module)
+{
+        unsigned long new_ar, new_ar_sn2;
+        unsigned long module_base;
+
+        if (!ia64_platform_is("sn2"))
+                return;
+
+        module_base = (unsigned long)module->module_core;
+
+        new_ar = kvm_vmm_base + vmm_info->patch_mov_ar - module_base;
+        new_ar_sn2 = kvm_vmm_base + vmm_info->patch_mov_ar_sn2 - module_base;
+
+        printk(KERN_INFO "kvm: Patching ITC emulation to use SGI SN2 RTC "
+               "as source\n");
+
+        /*
+         * Copy the SN2 version of mov_ar into place. They are both
+         * the same size, so 6 bundles is sufficient (6 * 0x10).
+         */
+        memcpy((void *)new_ar, (void *)new_ar_sn2, 0x60);
+}
+
 static int kvm_relocate_vmm(struct kvm_vmm_info *vmm_info,
-                                                struct module *module)
+                            struct module *module)
 {
         unsigned long module_base;
         unsigned long vmm_size;
@@ -1639,6 +1725,7 @@ static int kvm_relocate_vmm(struct kvm_vmm_info *vmm_info,
                 return -EFAULT;
 
         memcpy((void *)kvm_vmm_base, (void *)module_base, vmm_size);
+        kvm_patch_vmm(vmm_info, module);
         kvm_flush_icache(kvm_vmm_base, vmm_size);
 
         /*Recalculate kvm_vmm_info based on new VMM*/
@@ -1792,38 +1879,24 @@ void kvm_arch_hardware_unsetup(void)
 {
 }
 
-static void vcpu_kick_intr(void *info)
-{
-#ifdef DEBUG
-        struct kvm_vcpu *vcpu = (struct kvm_vcpu *)info;
-        printk(KERN_DEBUG"vcpu_kick_intr %p \n", vcpu);
-#endif
-}
-
 void kvm_vcpu_kick(struct kvm_vcpu *vcpu)
 {
-        int ipi_pcpu = vcpu->cpu;
-        int cpu = get_cpu();
+        int me;
+        int cpu = vcpu->cpu;
 
         if (waitqueue_active(&vcpu->wq))
                 wake_up_interruptible(&vcpu->wq);
 
-        if (vcpu->guest_mode && cpu != ipi_pcpu)
-                smp_call_function_single(ipi_pcpu, vcpu_kick_intr, vcpu, 0);
+        me = get_cpu();
+        if (cpu != me && (unsigned) cpu < nr_cpu_ids && cpu_online(cpu))
+                if (!test_and_set_bit(KVM_REQ_KICK, &vcpu->requests))
+                        smp_send_reschedule(cpu);
         put_cpu();
 }
 
-int kvm_apic_set_irq(struct kvm_vcpu *vcpu, u8 vec, u8 trig)
+int kvm_apic_set_irq(struct kvm_vcpu *vcpu, struct kvm_lapic_irq *irq)
 {
-
-        struct vpd *vpd = to_host(vcpu->kvm, vcpu->arch.vpd);
-
-        if (!test_and_set_bit(vec, &vpd->irr[0])) {
-                vcpu->arch.irq_new_pending = 1;
-                kvm_vcpu_kick(vcpu);
-                return 1;
-        }
-        return 0;
+        return __apic_accept_irq(vcpu, irq->vector);
 }
 
 int kvm_apic_match_physical_addr(struct kvm_lapic *apic, u16 dest)
@@ -1836,20 +1909,18 @@ int kvm_apic_match_logical_addr(struct kvm_lapic *apic, u8 mda)
         return 0;
 }
 
-struct kvm_vcpu *kvm_get_lowest_prio_vcpu(struct kvm *kvm, u8 vector,
-                                       unsigned long bitmap)
+int kvm_apic_compare_prio(struct kvm_vcpu *vcpu1, struct kvm_vcpu *vcpu2)
 {
-        struct kvm_vcpu *lvcpu = kvm->vcpus[0];
-        int i;
-
-        for (i = 1; i < kvm->arch.online_vcpus; i++) {
-                if (!kvm->vcpus[i])
-                        continue;
-                if (lvcpu->arch.xtp > kvm->vcpus[i]->arch.xtp)
-                        lvcpu = kvm->vcpus[i];
-        }
+        return vcpu1->arch.xtp - vcpu2->arch.xtp;
+}
 
-        return lvcpu;
+int kvm_apic_match_dest(struct kvm_vcpu *vcpu, struct kvm_lapic *source,
+                int short_hand, int dest, int dest_mode)
+{
+        struct kvm_lapic *target = vcpu->arch.apic;
+        return (dest_mode == 0) ?
+                kvm_apic_match_physical_addr(target, dest) :
+                kvm_apic_match_logical_addr(target, dest);
 }
 
 static int find_highest_bits(int *dat)
@@ -1888,6 +1959,12 @@ int kvm_cpu_has_interrupt(struct kvm_vcpu *vcpu)
         return 0;
 }
 
+int kvm_arch_interrupt_allowed(struct kvm_vcpu *vcpu)
+{
+        /* do real check here */
+        return 1;
+}
+
 int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu)
 {
         return vcpu->arch.timer_fired;
@@ -1918,6 +1995,7 @@ static int vcpu_reset(struct kvm_vcpu *vcpu)
         long psr;
         local_irq_save(psr);
         r = kvm_insert_vmm_mapping(vcpu);
+        local_irq_restore(psr);
         if (r)
                 goto fail;
 
@@ -1930,7 +2008,6 @@ static int vcpu_reset(struct kvm_vcpu *vcpu)
         kvm_purge_vmm_mapping(vcpu);
         r = 0;
 fail:
-        local_irq_restore(psr);
         return r;
 }
 
diff --git a/arch/ia64/kvm/kvm_fw.c b/arch/ia64/kvm/kvm_fw.c
index a8ae52ed5635..e4b82319881d 100644
--- a/arch/ia64/kvm/kvm_fw.c
+++ b/arch/ia64/kvm/kvm_fw.c
@@ -21,6 +21,9 @@
 
 #include <linux/kvm_host.h>
 #include <linux/smp.h>
+#include <asm/sn/addrs.h>
+#include <asm/sn/clksupport.h>
+#include <asm/sn/shub_mmr.h>
 
 #include "vti.h"
 #include "misc.h"
@@ -188,12 +191,35 @@ static struct ia64_pal_retval pal_freq_base(struct kvm_vcpu *vcpu)
         return result;
 }
 
-static struct ia64_pal_retval pal_freq_ratios(struct kvm_vcpu *vcpu)
+/*
+ * On the SGI SN2, the ITC isn't stable. Emulation backed by the SN2
+ * RTC is used instead. This function patches the ratios from SAL
+ * to match the RTC before providing them to the guest.
+ */
+static void sn2_patch_itc_freq_ratios(struct ia64_pal_retval *result)
 {
+        struct pal_freq_ratio *ratio;
+        unsigned long sal_freq, sal_drift, factor;
+
+        result->status = ia64_sal_freq_base(SAL_FREQ_BASE_PLATFORM,
+                                            &sal_freq, &sal_drift);
+        ratio = (struct pal_freq_ratio *)&result->v2;
+        factor = ((sal_freq * 3) + (sn_rtc_cycles_per_second / 2)) /
+                sn_rtc_cycles_per_second;
+
+        ratio->num = 3;
+        ratio->den = factor;
+}
 
+static struct ia64_pal_retval pal_freq_ratios(struct kvm_vcpu *vcpu)
+{
         struct ia64_pal_retval result;
 
         PAL_CALL(result, PAL_FREQ_RATIOS, 0, 0, 0);
+
+        if (vcpu->kvm->arch.is_sn2)
+                sn2_patch_itc_freq_ratios(&result);
+
         return result;
 }
 
diff --git a/arch/ia64/kvm/lapic.h b/arch/ia64/kvm/lapic.h
index 6d6cbcb14893..ee541cebcd78 100644
--- a/arch/ia64/kvm/lapic.h
+++ b/arch/ia64/kvm/lapic.h
@@ -20,6 +20,10 @@ void kvm_free_lapic(struct kvm_vcpu *vcpu);
 
 int kvm_apic_match_physical_addr(struct kvm_lapic *apic, u16 dest);
 int kvm_apic_match_logical_addr(struct kvm_lapic *apic, u8 mda);
-int kvm_apic_set_irq(struct kvm_vcpu *vcpu, u8 vec, u8 trig);
+int kvm_apic_match_dest(struct kvm_vcpu *vcpu, struct kvm_lapic *source,
+                int short_hand, int dest, int dest_mode);
+int kvm_apic_compare_prio(struct kvm_vcpu *vcpu1, struct kvm_vcpu *vcpu2);
+int kvm_apic_set_irq(struct kvm_vcpu *vcpu, struct kvm_lapic_irq *irq);
+#define kvm_apic_present(x) (true)
 
 #endif
diff --git a/arch/ia64/kvm/optvfault.S b/arch/ia64/kvm/optvfault.S
index 32254ce9a1bd..f793be3effff 100644
--- a/arch/ia64/kvm/optvfault.S
+++ b/arch/ia64/kvm/optvfault.S
@@ -11,6 +11,7 @@
 
 #include <asm/asmmacro.h>
 #include <asm/processor.h>
+#include <asm/kvm_host.h>
 
 #include "vti.h"
 #include "asm-offsets.h"
@@ -140,6 +141,35 @@ GLOBAL_ENTRY(kvm_asm_mov_from_ar)
         ;;
 END(kvm_asm_mov_from_ar)
 
+/*
+ * Special SGI SN2 optimized version of mov_from_ar using the SN2 RTC
+ * clock as it's source for emulating the ITC. This version will be
+ * copied on top of the original version if the host is determined to
+ * be an SN2.
+ */
+GLOBAL_ENTRY(kvm_asm_mov_from_ar_sn2)
+        add r18=VMM_VCPU_ITC_OFS_OFFSET, r21
+        movl r19 = (KVM_VMM_BASE+(1<<KVM_VMM_SHIFT))
+
+        add r16=VMM_VCPU_LAST_ITC_OFFSET,r21
+        extr.u r17=r25,6,7
+        mov r24=b0
+        ;;
+        ld8 r18=[r18]
+        ld8 r19=[r19]
+        addl r20=@gprel(asm_mov_to_reg),gp
+        ;;
+        add r19=r19,r18
+        shladd r17=r17,4,r20
+        ;;
+        adds r30=kvm_resume_to_guest-asm_mov_to_reg,r20
+        st8 [r16] = r19
+        mov b0=r17
+        br.sptk.few b0
+        ;;
+END(kvm_asm_mov_from_ar_sn2)
+
+
 
 // mov r1=rr[r3]
 GLOBAL_ENTRY(kvm_asm_mov_from_rr)
diff --git a/arch/ia64/kvm/process.c b/arch/ia64/kvm/process.c
index b1dc80952d91..a8f84da04b49 100644
--- a/arch/ia64/kvm/process.c
+++ b/arch/ia64/kvm/process.c
@@ -652,20 +652,25 @@ void  kvm_ia64_handle_break(unsigned long ifa, struct kvm_pt_regs *regs,
                 unsigned long isr, unsigned long iim)
 {
         struct kvm_vcpu *v = current_vcpu;
+        long psr;
 
         if (ia64_psr(regs)->cpl == 0) {
                 /* Allow hypercalls only when cpl = 0.  */
                 if (iim == DOMN_PAL_REQUEST) {
+                        local_irq_save(psr);
                         set_pal_call_data(v);
                         vmm_transition(v);
                         get_pal_call_result(v);
                         vcpu_increment_iip(v);
+                        local_irq_restore(psr);
                         return;
                 } else if (iim == DOMN_SAL_REQUEST) {
+                        local_irq_save(psr);
                         set_sal_call_data(v);
                         vmm_transition(v);
                         get_sal_call_result(v);
                         vcpu_increment_iip(v);
+                        local_irq_restore(psr);
                         return;
                 }
         }
diff --git a/arch/ia64/kvm/vcpu.c b/arch/ia64/kvm/vcpu.c
index a18ee17b9192..a2c6c15e4761 100644
--- a/arch/ia64/kvm/vcpu.c
+++ b/arch/ia64/kvm/vcpu.c
@@ -788,13 +788,29 @@ void vcpu_set_fpreg(struct kvm_vcpu *vcpu, unsigned long reg,
                 setfpreg(reg, val, regs);   /* FIXME: handle NATs later*/
 }
 
+/*
+ * The Altix RTC is mapped specially here for the vmm module
+ */
+#define SN_RTC_BASE     (u64 *)(KVM_VMM_BASE+(1UL<<KVM_VMM_SHIFT))
+static long kvm_get_itc(struct kvm_vcpu *vcpu)
+{
+#if defined(CONFIG_IA64_SGI_SN2) || defined(CONFIG_IA64_GENERIC)
+        struct kvm *kvm = (struct kvm *)KVM_VM_BASE;
+
+        if (kvm->arch.is_sn2)
+                return (*SN_RTC_BASE);
+        else
+#endif
+                return ia64_getreg(_IA64_REG_AR_ITC);
+}
+
 /************************************************************************
  * lsapic timer
  ***********************************************************************/
 u64 vcpu_get_itc(struct kvm_vcpu *vcpu)
 {
         unsigned long guest_itc;
-        guest_itc = VMX(vcpu, itc_offset) + ia64_getreg(_IA64_REG_AR_ITC);
+        guest_itc = VMX(vcpu, itc_offset) + kvm_get_itc(vcpu);
 
         if (guest_itc >= VMX(vcpu, last_itc)) {
                 VMX(vcpu, last_itc) = guest_itc;
@@ -809,7 +825,7 @@ static void vcpu_set_itc(struct kvm_vcpu *vcpu, u64 val)
         struct kvm_vcpu *v;
         struct kvm *kvm;
         int i;
-        long itc_offset = val - ia64_getreg(_IA64_REG_AR_ITC);
+        long itc_offset = val - kvm_get_itc(vcpu);
         unsigned long vitv = VCPU(vcpu, itv);
 
         kvm = (struct kvm *)KVM_VM_BASE;
diff --git a/arch/ia64/kvm/vmm.c b/arch/ia64/kvm/vmm.c
index 9eee5c04bacc..f4b4c899bb6c 100644
--- a/arch/ia64/kvm/vmm.c
+++ b/arch/ia64/kvm/vmm.c
@@ -30,15 +30,19 @@ MODULE_AUTHOR("Intel");
 MODULE_LICENSE("GPL");
 
 extern char kvm_ia64_ivt;
+extern char kvm_asm_mov_from_ar;
+extern char kvm_asm_mov_from_ar_sn2;
 extern fpswa_interface_t *vmm_fpswa_interface;
 
 long vmm_sanity = 1;
 
 struct kvm_vmm_info vmm_info = {
-        .module      = THIS_MODULE,
-        .vmm_entry   = vmm_entry,
-        .tramp_entry = vmm_trampoline,
-        .vmm_ivt     = (unsigned long)&kvm_ia64_ivt,
+        .module                 = THIS_MODULE,
+        .vmm_entry              = vmm_entry,
+        .tramp_entry            = vmm_trampoline,
+        .vmm_ivt                = (unsigned long)&kvm_ia64_ivt,
+        .patch_mov_ar           = (unsigned long)&kvm_asm_mov_from_ar,
+        .patch_mov_ar_sn2       = (unsigned long)&kvm_asm_mov_from_ar_sn2,
 };
 
 static int __init  kvm_vmm_init(void)
diff --git a/arch/ia64/kvm/vmm_ivt.S b/arch/ia64/kvm/vmm_ivt.S
index 3ef1a017a318..40920c630649 100644
--- a/arch/ia64/kvm/vmm_ivt.S
+++ b/arch/ia64/kvm/vmm_ivt.S
@@ -95,7 +95,7 @@ GLOBAL_ENTRY(kvm_vmm_panic)
         ;;
         srlz.i    // guarantee that interruption collection is on
         ;;
-        //(p15) ssm psr.i               // restore psr.i
+        (p15) ssm psr.i               // restore psr.
         addl r14=@gprel(ia64_leave_hypervisor),gp
         ;;
         KVM_SAVE_REST
@@ -249,7 +249,7 @@ ENTRY(kvm_break_fault)
         ;;
         srlz.i         // guarantee that interruption collection is on
         ;;
-        //(p15)ssm psr.i               // restore psr.i
+        (p15)ssm psr.i               // restore psr.i
         addl r14=@gprel(ia64_leave_hypervisor),gp
         ;;
         KVM_SAVE_REST
@@ -439,7 +439,7 @@ kvm_dispatch_vexirq:
         ;;
         srlz.i // guarantee that interruption collection is on
         ;;
-        //(p15) ssm psr.i               // restore psr.i
+        (p15) ssm psr.i               // restore psr.i
         adds r3=8,r2                // set up second base pointer
         ;;
         KVM_SAVE_REST
@@ -819,7 +819,7 @@ ENTRY(kvm_dtlb_miss_dispatch)
         ;;
         srlz.i     // guarantee that interruption collection is on
         ;;
-        //(p15) ssm psr.i               // restore psr.i
+        (p15) ssm psr.i               // restore psr.i
         addl r14=@gprel(ia64_leave_hypervisor_prepare),gp
         ;;
         KVM_SAVE_REST
@@ -842,7 +842,7 @@ ENTRY(kvm_itlb_miss_dispatch)
         ;;
         srlz.i   // guarantee that interruption collection is on
         ;;
-        //(p15) ssm psr.i               // restore psr.i
+        (p15) ssm psr.i               // restore psr.i
         addl r14=@gprel(ia64_leave_hypervisor),gp
         ;;
         KVM_SAVE_REST
@@ -871,7 +871,7 @@ ENTRY(kvm_dispatch_reflection)
         ;;
         srlz.i   // guarantee that interruption collection is on
         ;;
-        //(p15) ssm psr.i               // restore psr.i
+        (p15) ssm psr.i               // restore psr.i
         addl r14=@gprel(ia64_leave_hypervisor),gp
         ;;
         KVM_SAVE_REST
@@ -898,7 +898,7 @@ ENTRY(kvm_dispatch_virtualization_fault)
         ;;
         srlz.i    // guarantee that interruption collection is on
         ;;
-        //(p15) ssm psr.i               // restore psr.i
+        (p15) ssm psr.i               // restore psr.i
         addl r14=@gprel(ia64_leave_hypervisor_prepare),gp
         ;;
         KVM_SAVE_REST
@@ -920,7 +920,7 @@ ENTRY(kvm_dispatch_interrupt)
         ;;
         srlz.i
         ;;
-        //(p15) ssm psr.i
+        (p15) ssm psr.i
         addl r14=@gprel(ia64_leave_hypervisor),gp
         ;;
         KVM_SAVE_REST
@@ -1333,7 +1333,7 @@ hostret =   r24
         ;;
 (p7)    srlz.i
         ;;
-//(p6)    ssm psr.i
+(p6)    ssm psr.i
         ;;
         mov rp=rpsave
         mov ar.pfs=pfssave
diff --git a/arch/ia64/kvm/vtlb.c b/arch/ia64/kvm/vtlb.c
index 2c2501f13159..4290a429bf7c 100644
--- a/arch/ia64/kvm/vtlb.c
+++ b/arch/ia64/kvm/vtlb.c
@@ -254,7 +254,8 @@ u64 guest_vhpt_lookup(u64 iha, u64 *pte)
                         "(p7) st8 [%2]=r9;;"
                         "ssm psr.ic;;"
                         "srlz.d;;"
-                        /* "ssm psr.i;;" Once interrupts in vmm open, need fix*/
+                        "ssm psr.i;;"
+                        "srlz.d;;"
                         : "=r"(ret) : "r"(iha), "r"(pte):"memory");
 
         return ret;
diff --git a/arch/mn10300/Kconfig b/arch/mn10300/Kconfig
index 355926730e8d..89faacad5d17 100644
--- a/arch/mn10300/Kconfig
+++ b/arch/mn10300/Kconfig
@@ -8,6 +8,7 @@ mainmenu "Linux Kernel Configuration"
 config MN10300
         def_bool y
         select HAVE_OPROFILE
+        select HAVE_ARCH_TRACEHOOK
 
 config AM33
         def_bool y
diff --git a/arch/mn10300/include/asm/elf.h b/arch/mn10300/include/asm/elf.h
index bf09f8bb392e..49105462e6fc 100644
--- a/arch/mn10300/include/asm/elf.h
+++ b/arch/mn10300/include/asm/elf.h
@@ -34,7 +34,7 @@
  */
 typedef unsigned long elf_greg_t;
 
-#define ELF_NGREG (sizeof (struct pt_regs) / sizeof(elf_greg_t))
+#define ELF_NGREG ((sizeof(struct pt_regs) / sizeof(elf_greg_t)) - 1)
 typedef elf_greg_t elf_gregset_t[ELF_NGREG];
 
 #define ELF_NFPREG 32
@@ -76,6 +76,7 @@ do {									\
 } while (0)
 
 #define USE_ELF_CORE_DUMP
+#define CORE_DUMP_USE_REGSET
 #define ELF_EXEC_PAGESIZE       4096
 
 /*
diff --git a/arch/mn10300/include/asm/processor.h b/arch/mn10300/include/asm/processor.h
index 73239271873d..f7d4b0d285e8 100644
--- a/arch/mn10300/include/asm/processor.h
+++ b/arch/mn10300/include/asm/processor.h
@@ -143,13 +143,7 @@ extern unsigned long thread_saved_pc(struct task_struct *tsk);
 
 unsigned long get_wchan(struct task_struct *p);
 
-#define task_pt_regs(task)                                              \
-({                                                                      \
-       struct pt_regs *__regs__;                                        \
-       __regs__ = (struct pt_regs *) (KSTK_TOP(task_stack_page(task)) - 8); \
-       __regs__ - 1;                                                    \
-})
-
+#define task_pt_regs(task) ((task)->thread.uregs)
 #define KSTK_EIP(task) (task_pt_regs(task)->pc)
 #define KSTK_ESP(task) (task_pt_regs(task)->sp)
 
diff --git a/arch/mn10300/include/asm/ptrace.h b/arch/mn10300/include/asm/ptrace.h
index 7b06cc623d8b..921942ed1b03 100644
--- a/arch/mn10300/include/asm/ptrace.h
+++ b/arch/mn10300/include/asm/ptrace.h
@@ -91,9 +91,17 @@ extern struct pt_regs *__frame; /* current frame pointer */
 #if defined(__KERNEL__)
 
 #if !defined(__ASSEMBLY__)
+struct task_struct;
+
 #define user_mode(regs)                 (((regs)->epsw & EPSW_nSL) == EPSW_nSL)
 #define instruction_pointer(regs)       ((regs)->pc)
+#define user_stack_pointer(regs)        ((regs)->sp)
 extern void show_regs(struct pt_regs *);
+
+#define arch_has_single_step()  (1)
+extern void user_enable_single_step(struct task_struct *);
+extern void user_disable_single_step(struct task_struct *);
+
 #endif  /*  !__ASSEMBLY  */
 
 #define profile_pc(regs) ((regs)->pc)
diff --git a/arch/mn10300/kernel/entry.S b/arch/mn10300/kernel/entry.S
index 3dc3e462f92a..7408a27199f3 100644
--- a/arch/mn10300/kernel/entry.S
+++ b/arch/mn10300/kernel/entry.S
@@ -76,7 +76,7 @@ ENTRY(system_call)
         cmp     nr_syscalls,d0
         bcc     syscall_badsys
         btst    _TIF_SYSCALL_TRACE,(TI_flags,a2)
-        bne     syscall_trace_entry
+        bne     syscall_entry_trace
 syscall_call:
         add     d0,d0,a1
         add     a1,a1
@@ -104,11 +104,10 @@ restore_all:
 syscall_exit_work:
         btst    _TIF_SYSCALL_TRACE,d2
         beq     work_pending
-        __sti                           # could let do_syscall_trace() call
+        __sti                           # could let syscall_trace_exit() call
                                         # schedule() instead
         mov     fp,d0
-        mov     1,d1
-        call    do_syscall_trace[],0    # do_syscall_trace(regs,entryexit)
+        call    syscall_trace_exit[],0  # do_syscall_trace(regs)
         jmp     resume_userspace
 
         ALIGN
@@ -138,13 +137,11 @@ work_notifysig:
         jmp     resume_userspace
 
         # perform syscall entry tracing
-syscall_trace_entry:
+syscall_entry_trace:
         mov     -ENOSYS,d0
         mov     d0,(REG_D0,fp)
         mov     fp,d0
-        clr     d1
-        call    do_syscall_trace[],0
-        mov     (REG_ORIG_D0,fp),d0
+        call    syscall_trace_entry[],0 # returns the syscall number to actually use
         mov     (REG_D1,fp),d1
         cmp     nr_syscalls,d0
         bcs     syscall_call
diff --git a/arch/mn10300/kernel/ptrace.c b/arch/mn10300/kernel/ptrace.c
index d6d6cdc75c52..e143339ad28e 100644
--- a/arch/mn10300/kernel/ptrace.c
+++ b/arch/mn10300/kernel/ptrace.c
@@ -17,6 +17,9 @@
 #include <linux/errno.h>
 #include <linux/ptrace.h>
 #include <linux/user.h>
+#include <linux/regset.h>
+#include <linux/elf.h>
+#include <linux/tracehook.h>
 #include <asm/uaccess.h>
 #include <asm/pgtable.h>
 #include <asm/system.h>
@@ -64,12 +67,6 @@ static inline int get_stack_long(struct task_struct *task, int offset)
                 ((unsigned long) task->thread.uregs + offset);
 }
 
-/*
- * this routine will put a word on the processes privileged stack.
- * the offset is how far from the base addr as stored in the TSS.
- * this routine assumes that all the privileged stacks are in our
- * data space.
- */
 static inline
 int put_stack_long(struct task_struct *task, int offset, unsigned long data)
 {
@@ -80,94 +77,233 @@ int put_stack_long(struct task_struct *task, int offset, unsigned long data)
         return 0;
 }
 
-static inline unsigned long get_fpregs(struct fpu_state_struct *buf,
-                                       struct task_struct *tsk)
+/*
+ * retrieve the contents of MN10300 userspace general registers
+ */
+static int genregs_get(struct task_struct *target,
+                       const struct user_regset *regset,
+                       unsigned int pos, unsigned int count,
+                       void *kbuf, void __user *ubuf)
 {
-        return __copy_to_user(buf, &tsk->thread.fpu_state,
-                              sizeof(struct fpu_state_struct));
+        const struct pt_regs *regs = task_pt_regs(target);
+        int ret;
+
+        /* we need to skip regs->next */
+        ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
+                                  regs, 0, PT_ORIG_D0 * sizeof(long));
+        if (ret < 0)
+                return ret;
+
+        ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
+                                  &regs->orig_d0, PT_ORIG_D0 * sizeof(long),
+                                  NR_PTREGS * sizeof(long));
+        if (ret < 0)
+                return ret;
+
+        return user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
+                                        NR_PTREGS * sizeof(long), -1);
 }
 
-static inline unsigned long set_fpregs(struct task_struct *tsk,
-                                       struct fpu_state_struct *buf)
+/*
+ * update the contents of the MN10300 userspace general registers
+ */
+static int genregs_set(struct task_struct *target,
+                       const struct user_regset *regset,
+                       unsigned int pos, unsigned int count,
+                       const void *kbuf, const void __user *ubuf)
 {
-        return __copy_from_user(&tsk->thread.fpu_state, buf,
-                                sizeof(struct fpu_state_struct));
+        struct pt_regs *regs = task_pt_regs(target);
+        unsigned long tmp;
+        int ret;
+
+        /* we need to skip regs->next */
+        ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
+                                 regs, 0, PT_ORIG_D0 * sizeof(long));
+        if (ret < 0)
+                return ret;
+
+        ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
+                                 &regs->orig_d0, PT_ORIG_D0 * sizeof(long),
+                                 PT_EPSW * sizeof(long));
+        if (ret < 0)
+                return ret;
+
+        /* we need to mask off changes to EPSW */
+        tmp = regs->epsw;
+        ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
+                                 &tmp, PT_EPSW * sizeof(long),
+                                 PT_PC * sizeof(long));
+        tmp &= EPSW_FLAG_V | EPSW_FLAG_C | EPSW_FLAG_N | EPSW_FLAG_Z;
+        tmp |= regs->epsw & ~(EPSW_FLAG_V | EPSW_FLAG_C | EPSW_FLAG_N |
+                              EPSW_FLAG_Z);
+        regs->epsw = tmp;
+
+        if (ret < 0)
+                return ret;
+
+        /* and finally load the PC */
+        ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
+                                 &regs->pc, PT_PC * sizeof(long),
+                                 NR_PTREGS * sizeof(long));
+
+        if (ret < 0)
+                return ret;
+
+        return user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
+                                         NR_PTREGS * sizeof(long), -1);
 }
 
-static inline void fpsave_init(struct task_struct *task)
+/*
+ * retrieve the contents of MN10300 userspace FPU registers
+ */
+static int fpuregs_get(struct task_struct *target,
+                       const struct user_regset *regset,
+                       unsigned int pos, unsigned int count,
+                       void *kbuf, void __user *ubuf)
 {
-        memset(&task->thread.fpu_state, 0, sizeof(struct fpu_state_struct));
+        const struct fpu_state_struct *fpregs = &target->thread.fpu_state;
+        int ret;
+
+        unlazy_fpu(target);
+
+        ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
+                                  fpregs, 0, sizeof(*fpregs));
+        if (ret < 0)
+                return ret;
+
+        return user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
+                                        sizeof(*fpregs), -1);
 }
 
 /*
- * make sure the single step bit is not set
+ * update the contents of the MN10300 userspace FPU registers
  */
-void ptrace_disable(struct task_struct *child)
+static int fpuregs_set(struct task_struct *target,
+                       const struct user_regset *regset,
+                       unsigned int pos, unsigned int count,
+                       const void *kbuf, const void __user *ubuf)
+{
+        struct fpu_state_struct fpu_state = target->thread.fpu_state;
+        int ret;
+
+        ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
+                                 &fpu_state, 0, sizeof(fpu_state));
+        if (ret < 0)
+                return ret;
+
+        fpu_kill_state(target);
+        target->thread.fpu_state = fpu_state;
+        set_using_fpu(target);
+
+        return user_regset_copyin_ignore(&pos, &count, &kbuf, &ubuf,
+                                         sizeof(fpu_state), -1);
+}
+
+/*
+ * determine if the FPU registers have actually been used
+ */
+static int fpuregs_active(struct task_struct *target,
+                          const struct user_regset *regset)
+{
+        return is_using_fpu(target) ? regset->n : 0;
+}
+
+/*
+ * Define the register sets available on the MN10300 under Linux
+ */
+enum mn10300_regset {
+        REGSET_GENERAL,
+        REGSET_FPU,
+};
+
+static const struct user_regset mn10300_regsets[] = {
+        /*
+         * General register format is:
+         *      A3, A2, D3, D2, MCVF, MCRL, MCRH, MDRQ
+         *      E1, E0, E7...E2, SP, LAR, LIR, MDR
+         *      A1, A0, D1, D0, ORIG_D0, EPSW, PC
+         */
+        [REGSET_GENERAL] = {
+                .core_note_type = NT_PRSTATUS,
+                .n              = ELF_NGREG,
+                .size           = sizeof(long),
+                .align          = sizeof(long),
+                .get            = genregs_get,
+                .set            = genregs_set,
+        },
+        /*
+         * FPU register format is:
+         *      FS0-31, FPCR
+         */
+        [REGSET_FPU] = {
+                .core_note_type = NT_PRFPREG,
+                .n              = sizeof(struct fpu_state_struct) / sizeof(long),
+                .size           = sizeof(long),
+                .align          = sizeof(long),
+                .get            = fpuregs_get,
+                .set            = fpuregs_set,
+                .active         = fpuregs_active,
+        },
+};
+
+static const struct user_regset_view user_mn10300_native_view = {
+        .name           = "mn10300",
+        .e_machine      = EM_MN10300,
+        .regsets        = mn10300_regsets,
+        .n              = ARRAY_SIZE(mn10300_regsets),
+};
+
+const struct user_regset_view *task_user_regset_view(struct task_struct *task)
+{
+        return &user_mn10300_native_view;
+}
+
+/*
+ * set the single-step bit
+ */
+void user_enable_single_step(struct task_struct *child)
 {
 #ifndef CONFIG_MN10300_USING_JTAG
         struct user *dummy = NULL;
         long tmp;
 
         tmp = get_stack_long(child, (unsigned long) &dummy->regs.epsw);
-        tmp &= ~EPSW_T;
+        tmp |= EPSW_T;
         put_stack_long(child, (unsigned long) &dummy->regs.epsw, tmp);
 #endif
 }
 
 /*
- * set the single step bit
+ * make sure the single-step bit is not set
  */
-void ptrace_enable(struct task_struct *child)
+void user_disable_single_step(struct task_struct *child)
 {
 #ifndef CONFIG_MN10300_USING_JTAG
         struct user *dummy = NULL;
         long tmp;
 
         tmp = get_stack_long(child, (unsigned long) &dummy->regs.epsw);
-        tmp |= EPSW_T;
+        tmp &= ~EPSW_T;
         put_stack_long(child, (unsigned long) &dummy->regs.epsw, tmp);
 #endif
 }
 
+void ptrace_disable(struct task_struct *child)
+{
+        user_disable_single_step(child);
+}
+
 /*
  * handle the arch-specific side of process tracing
  */
 long arch_ptrace(struct task_struct *child, long request, long addr, long data)
 {
-        struct fpu_state_struct fpu_state;
-        int i, ret;
+        unsigned long tmp;
+        int ret;
 
         switch (request) {
-        /* read the word at location addr. */
-        case PTRACE_PEEKTEXT: {
-                unsigned long tmp;
-                int copied;
-
-                copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
-                ret = -EIO;
-                if (copied != sizeof(tmp))
-                        break;
-                ret = put_user(tmp, (unsigned long *) data);
-                break;
-        }
-
-        /* read the word at location addr. */
-        case PTRACE_PEEKDATA: {
-                unsigned long tmp;
-                int copied;
-
-                copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
-                ret = -EIO;
-                if (copied != sizeof(tmp))
-                        break;
-                ret = put_user(tmp, (unsigned long *) data);
-                break;
-        }
-
         /* read the word at location addr in the USER area. */
-        case PTRACE_PEEKUSR: {
-                unsigned long tmp;
-
+        case PTRACE_PEEKUSR:
                 ret = -EIO;
                 if ((addr & 3) || addr < 0 ||
                     addr > sizeof(struct user) - 3)
@@ -179,17 +315,6 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                                              ptrace_regid_to_frame[addr]);
                 ret = put_user(tmp, (unsigned long *) data);
                 break;
-        }
-
-        /* write the word at location addr. */
-        case PTRACE_POKETEXT:
-        case PTRACE_POKEDATA:
-                if (access_process_vm(child, addr, &data, sizeof(data), 1) ==
-                    sizeof(data))
-                        ret = 0;
-                else
-                        ret = -EIO;
-                break;
 
                 /* write the word at location addr in the USER area */
         case PTRACE_POKEUSR:
@@ -204,132 +329,32 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                                              data);
                 break;
 
-                /* continue and stop at next (return from) syscall */
-        case PTRACE_SYSCALL:
-                /* restart after signal. */
-        case PTRACE_CONT:
-                ret = -EIO;
-                if ((unsigned long) data > _NSIG)
-                        break;
-                if (request == PTRACE_SYSCALL)
-                        set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-                else
-                        clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-                child->exit_code = data;
-                ptrace_disable(child);
-                wake_up_process(child);
-                ret = 0;
-                break;
-
-                /*
-                 * make the child exit
-                 * - the best I can do is send it a sigkill
-                 * - perhaps it should be put in the status that it wants to
-                 *   exit
-                 */
-        case PTRACE_KILL:
-                ret = 0;
-                if (child->exit_state == EXIT_ZOMBIE)   /* already dead */
-                        break;
-                child->exit_code = SIGKILL;
-                clear_tsk_thread_flag(child, TIF_SINGLESTEP);
-                ptrace_disable(child);
-                wake_up_process(child);
-                break;
-
-        case PTRACE_SINGLESTEP: /* set the trap flag. */
-#ifndef CONFIG_MN10300_USING_JTAG
-                ret = -EIO;
-                if ((unsigned long) data > _NSIG)
-                        break;
-                clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-                ptrace_enable(child);
-                child->exit_code = data;
-                wake_up_process(child);
-                ret = 0;
-#else
-                ret = -EINVAL;
-#endif
-                break;
-
-        case PTRACE_DETACH:     /* detach a process that was attached. */
-                ret = ptrace_detach(child, data);
-                break;
-
-                /* Get all gp regs from the child. */
-        case PTRACE_GETREGS: {
-                unsigned long tmp;
-
-                if (!access_ok(VERIFY_WRITE, (unsigned *) data, NR_PTREGS << 2)) {
-                        ret = -EIO;
-                        break;
-                }
-
-                for (i = 0; i < NR_PTREGS << 2; i += 4) {
-                        tmp = get_stack_long(child, ptrace_regid_to_frame[i]);
-                        __put_user(tmp, (unsigned long *) data);
-                        data += sizeof(tmp);
-                }
-                ret = 0;
-                break;
-        }
-
-        case PTRACE_SETREGS: { /* Set all gp regs in the child. */
-                unsigned long tmp;
-
-                if (!access_ok(VERIFY_READ, (unsigned long *)data,
-                               sizeof(struct pt_regs))) {
-                        ret = -EIO;
-                        break;
-                }
-
-                for (i = 0; i < NR_PTREGS << 2; i += 4) {
-                        __get_user(tmp, (unsigned long *) data);
-                        put_stack_long(child, ptrace_regid_to_frame[i], tmp);
-                        data += sizeof(tmp);
-                }
-                ret = 0;
-                break;
-        }
-
-        case PTRACE_GETFPREGS: { /* Get the child FPU state. */
-                if (is_using_fpu(child)) {
-                        unlazy_fpu(child);
-                        fpu_state = child->thread.fpu_state;
-                } else {
-                        memset(&fpu_state, 0, sizeof(fpu_state));
-                }
-
-                ret = -EIO;
-                if (copy_to_user((void *) data, &fpu_state,
-                                 sizeof(fpu_state)) == 0)
-                        ret = 0;
-                break;
-        }
-
-        case PTRACE_SETFPREGS: { /* Set the child FPU state. */
-                ret = -EFAULT;
-                if (copy_from_user(&fpu_state, (const void *) data,
-                                   sizeof(fpu_state)) == 0) {
-                        fpu_kill_state(child);
-                        child->thread.fpu_state = fpu_state;
-                        set_using_fpu(child);
-                        ret = 0;
-                }
-                break;
-        }
-
-        case PTRACE_SETOPTIONS: {
-                if (data & PTRACE_O_TRACESYSGOOD)
-                        child->ptrace |= PT_TRACESYSGOOD;
-                else
-                        child->ptrace &= ~PT_TRACESYSGOOD;
-                ret = 0;
-                break;
-        }
+        case PTRACE_GETREGS:    /* Get all integer regs from the child. */
+                return copy_regset_to_user(child, &user_mn10300_native_view,
+                                           REGSET_GENERAL,
+                                           0, NR_PTREGS * sizeof(long),
+                                           (void __user *)data);
+
+        case PTRACE_SETREGS:    /* Set all integer regs in the child. */
+                return copy_regset_from_user(child, &user_mn10300_native_view,
+                                             REGSET_GENERAL,
+                                             0, NR_PTREGS * sizeof(long),
+                                             (const void __user *)data);
+
+        case PTRACE_GETFPREGS:  /* Get the child FPU state. */
+                return copy_regset_to_user(child, &user_mn10300_native_view,
+                                           REGSET_FPU,
+                                           0, sizeof(struct fpu_state_struct),
+                                           (void __user *)data);
+
+        case PTRACE_SETFPREGS:  /* Set the child FPU state. */
+                return copy_regset_from_user(child, &user_mn10300_native_view,
+                                             REGSET_FPU,
+                                             0, sizeof(struct fpu_state_struct),
+                                             (const void __user *)data);
 
         default:
-                ret = -EIO;
+                ret = ptrace_request(child, request, addr, data);
                 break;
         }
 
@@ -337,43 +362,26 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
 }
 
 /*
- * notification of system call entry/exit
- * - triggered by current->work.syscall_trace
+ * handle tracing of system call entry
+ * - return the revised system call number or ULONG_MAX to cause ENOSYS
  */
-asmlinkage void do_syscall_trace(struct pt_regs *regs, int entryexit)
+asmlinkage unsigned long syscall_trace_entry(struct pt_regs *regs)
 {
-#if 0
-        /* just in case... */
-        printk(KERN_DEBUG "[%d] syscall_%lu(%lx,%lx,%lx,%lx) = %lx\n",
-               current->pid,
-               regs->orig_d0,
-               regs->a0,
-               regs->d1,
-               regs->a3,
-               regs->a2,
-               regs->d0);
-        return;
-#endif
-
-        if (!test_thread_flag(TIF_SYSCALL_TRACE) &&
-            !test_thread_flag(TIF_SINGLESTEP))
-                return;
-        if (!(current->ptrace & PT_PTRACED))
-                return;
+        if (tracehook_report_syscall_entry(regs))
+                /* tracing decided this syscall should not happen, so
+                 * We'll return a bogus call number to get an ENOSYS
+                 * error, but leave the original number in
+                 * regs->orig_d0
+                 */
+                return ULONG_MAX;
 
-        /* the 0x80 provides a way for the tracing parent to distinguish
-           between a syscall stop and SIGTRAP delivery */
-        ptrace_notify(SIGTRAP |
-                      ((current->ptrace & PT_TRACESYSGOOD) &&
-                       !test_thread_flag(TIF_SINGLESTEP) ? 0x80 : 0));
+        return regs->orig_d0;
+}
 
-        /*
-         * this isn't the same as continuing with a signal, but it will do
-         * for normal use.  strace only continues with a signal if the
-         * stopping signal is not SIGTRAP.  -brl
-         */
-        if (current->exit_code) {
-                send_sig(current->exit_code, current, 1);
-                current->exit_code = 0;
-        }
+/*
+ * handle tracing of system call exit
+ */
+asmlinkage void syscall_trace_exit(struct pt_regs *regs)
+{
+        tracehook_report_syscall_exit(regs, 0);
 }
diff --git a/arch/mn10300/kernel/signal.c b/arch/mn10300/kernel/signal.c
index 841ca9955a18..9f7572a0f578 100644
--- a/arch/mn10300/kernel/signal.c
+++ b/arch/mn10300/kernel/signal.c
@@ -23,6 +23,7 @@
 #include <linux/tty.h>
 #include <linux/personality.h>
 #include <linux/suspend.h>
+#include <linux/tracehook.h>
 #include <asm/cacheflush.h>
 #include <asm/ucontext.h>
 #include <asm/uaccess.h>
@@ -511,6 +512,9 @@ static void do_signal(struct pt_regs *regs)
                          * clear the TIF_RESTORE_SIGMASK flag */
                         if (test_thread_flag(TIF_RESTORE_SIGMASK))
                                 clear_thread_flag(TIF_RESTORE_SIGMASK);
+
+                        tracehook_signal_handler(signr, &info, &ka, regs,
+                                                 test_thread_flag(TIF_SINGLESTEP));
                 }
 
                 return;
@@ -561,4 +565,9 @@ asmlinkage void do_notify_resume(struct pt_regs *regs, u32 thread_info_flags)
         /* deal with pending signal delivery */
         if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
                 do_signal(regs);
+
+        if (thread_info_flags & _TIF_NOTIFY_RESUME) {
+                clear_thread_flag(TIF_NOTIFY_RESUME);
+                tracehook_notify_resume(__frame);
+        }
 }
diff --git a/arch/mn10300/mm/tlb-mn10300.S b/arch/mn10300/mm/tlb-mn10300.S
index 789208094e98..7095147dcb8b 100644
--- a/arch/mn10300/mm/tlb-mn10300.S
+++ b/arch/mn10300/mm/tlb-mn10300.S
@@ -165,24 +165,6 @@ ENTRY(itlb_aerror)
 ENTRY(dtlb_aerror)
         and     ~EPSW_NMID,epsw
         add     -4,sp
-        mov     d1,(sp)
-
-        movhu   (MMUFCR_DFC),d1                 # is it the initial valid write
-                                                # to this page?
-        and     MMUFCR_xFC_INITWR,d1
-        beq     dtlb_pagefault                  # jump if not
-
-        mov     (DPTEL),d1                      # set the dirty bit
-                                                # (don't replace with BSET!)
-        or      _PAGE_DIRTY,d1
-        mov     d1,(DPTEL)
-        mov     (sp),d1
-        add     4,sp
-        rti
-
-        ALIGN
-dtlb_pagefault:
-        mov     (sp),d1
         SAVE_ALL
         add     -4,sp                           # need to pass three params
 
diff --git a/arch/powerpc/kvm/powerpc.c b/arch/powerpc/kvm/powerpc.c
index 9057335fdc61..2cf915e51e7e 100644
--- a/arch/powerpc/kvm/powerpc.c
+++ b/arch/powerpc/kvm/powerpc.c
@@ -41,6 +41,12 @@ int kvm_cpu_has_interrupt(struct kvm_vcpu *v)
         return !!(v->arch.pending_exceptions);
 }
 
+int kvm_arch_interrupt_allowed(struct kvm_vcpu *vcpu)
+{
+        /* do real check here */
+        return 1;
+}
+
 int kvm_arch_vcpu_runnable(struct kvm_vcpu *v)
 {
         return !(v->arch.msr & MSR_WE);
diff --git a/arch/powerpc/sysdev/axonram.c b/arch/powerpc/sysdev/axonram.c
index 9e105cbc5e5f..a4779912a5ca 100644
--- a/arch/powerpc/sysdev/axonram.c
+++ b/arch/powerpc/sysdev/axonram.c
@@ -250,7 +250,7 @@ axon_ram_probe(struct of_device *device, const struct of_device_id *device_id)
 
         set_capacity(bank->disk, bank->size >> AXON_RAM_SECTOR_SHIFT);
         blk_queue_make_request(bank->disk->queue, axon_ram_make_request);
-        blk_queue_hardsect_size(bank->disk->queue, AXON_RAM_SECTOR_SIZE);
+        blk_queue_logical_block_size(bank->disk->queue, AXON_RAM_SECTOR_SIZE);
         add_disk(bank->disk);
 
         bank->irq_id = irq_of_parse_and_map(device->node, 0);
diff --git a/arch/s390/include/asm/kvm_host.h b/arch/s390/include/asm/kvm_host.h
index 54ea39f96ecd..a27d0d5a6f86 100644
--- a/arch/s390/include/asm/kvm_host.h
+++ b/arch/s390/include/asm/kvm_host.h
@@ -13,6 +13,8 @@
 
 #ifndef ASM_KVM_HOST_H
 #define ASM_KVM_HOST_H
+#include <linux/hrtimer.h>
+#include <linux/interrupt.h>
 #include <linux/kvm_host.h>
 #include <asm/debug.h>
 #include <asm/cpuid.h>
@@ -210,7 +212,8 @@ struct kvm_vcpu_arch {
         s390_fp_regs      guest_fpregs;
         unsigned int      guest_acrs[NUM_ACRS];
         struct kvm_s390_local_interrupt local_int;
-        struct timer_list ckc_timer;
+        struct hrtimer    ckc_timer;
+        struct tasklet_struct tasklet;
         union  {
                 cpuid_t   cpu_id;
                 u64       stidp_data;
diff --git a/arch/s390/kvm/intercept.c b/arch/s390/kvm/intercept.c
index 9d19803111ba..98997ccba501 100644
--- a/arch/s390/kvm/intercept.c
+++ b/arch/s390/kvm/intercept.c
@@ -154,17 +154,25 @@ static int handle_stop(struct kvm_vcpu *vcpu)
 static int handle_validity(struct kvm_vcpu *vcpu)
 {
         int viwhy = vcpu->arch.sie_block->ipb >> 16;
+        int rc;
+
         vcpu->stat.exit_validity++;
-        if (viwhy == 0x37) {
-                fault_in_pages_writeable((char __user *)
-                                         vcpu->kvm->arch.guest_origin +
-                                         vcpu->arch.sie_block->prefix,
-                                         PAGE_SIZE);
-                return 0;
-        }
-        VCPU_EVENT(vcpu, 2, "unhandled validity intercept code %d",
-                   viwhy);
-        return -ENOTSUPP;
+        if ((viwhy == 0x37) && (vcpu->arch.sie_block->prefix
+                <= vcpu->kvm->arch.guest_memsize - 2*PAGE_SIZE)){
+                rc = fault_in_pages_writeable((char __user *)
+                         vcpu->kvm->arch.guest_origin +
+                         vcpu->arch.sie_block->prefix,
+                         2*PAGE_SIZE);
+                if (rc)
+                        /* user will receive sigsegv, exit to user */
+                        rc = -ENOTSUPP;
+        } else
+                rc = -ENOTSUPP;
+
+        if (rc)
+                VCPU_EVENT(vcpu, 2, "unhandled validity intercept code %d",
+                           viwhy);
+        return rc;
 }
 
 static int handle_instruction(struct kvm_vcpu *vcpu)
diff --git a/arch/s390/kvm/interrupt.c b/arch/s390/kvm/interrupt.c
index 0189356fe209..f04f5301b1b4 100644
--- a/arch/s390/kvm/interrupt.c
+++ b/arch/s390/kvm/interrupt.c
@@ -12,6 +12,8 @@
 
 #include <asm/lowcore.h>
 #include <asm/uaccess.h>
+#include <linux/hrtimer.h>
+#include <linux/interrupt.h>
 #include <linux/kvm_host.h>
 #include <linux/signal.h>
 #include "kvm-s390.h"
@@ -299,13 +301,13 @@ int kvm_cpu_has_interrupt(struct kvm_vcpu *vcpu)
         }
 
         if ((!rc) && atomic_read(&fi->active)) {
-                spin_lock_bh(&fi->lock);
+                spin_lock(&fi->lock);
                 list_for_each_entry(inti, &fi->list, list)
                         if (__interrupt_is_deliverable(vcpu, inti)) {
                                 rc = 1;
                                 break;
                         }
-                spin_unlock_bh(&fi->lock);
+                spin_unlock(&fi->lock);
         }
 
         if ((!rc) && (vcpu->arch.sie_block->ckc <
@@ -318,6 +320,12 @@ int kvm_cpu_has_interrupt(struct kvm_vcpu *vcpu)
         return rc;
 }
 
+int kvm_arch_interrupt_allowed(struct kvm_vcpu *vcpu)
+{
+        /* do real check here */
+        return 1;
+}
+
 int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu)
 {
         return 0;
@@ -355,14 +363,12 @@ int kvm_s390_handle_wait(struct kvm_vcpu *vcpu)
                 return 0;
         }
 
-        sltime = (vcpu->arch.sie_block->ckc - now) / (0xf4240000ul / HZ) + 1;
+        sltime = ((vcpu->arch.sie_block->ckc - now)*125)>>9;
 
-        vcpu->arch.ckc_timer.expires = jiffies + sltime;
-
-        add_timer(&vcpu->arch.ckc_timer);
-        VCPU_EVENT(vcpu, 5, "enabled wait timer:%llx jiffies", sltime);
+        hrtimer_start(&vcpu->arch.ckc_timer, ktime_set (0, sltime) , HRTIMER_MODE_REL);
+        VCPU_EVENT(vcpu, 5, "enabled wait via clock comparator: %llx ns", sltime);
 no_timer:
-        spin_lock_bh(&vcpu->arch.local_int.float_int->lock);
+        spin_lock(&vcpu->arch.local_int.float_int->lock);
         spin_lock_bh(&vcpu->arch.local_int.lock);
         add_wait_queue(&vcpu->arch.local_int.wq, &wait);
         while (list_empty(&vcpu->arch.local_int.list) &&
@@ -371,33 +377,46 @@ no_timer:
                 !signal_pending(current)) {
                 set_current_state(TASK_INTERRUPTIBLE);
                 spin_unlock_bh(&vcpu->arch.local_int.lock);
-                spin_unlock_bh(&vcpu->arch.local_int.float_int->lock);
+                spin_unlock(&vcpu->arch.local_int.float_int->lock);
                 vcpu_put(vcpu);
                 schedule();
                 vcpu_load(vcpu);
-                spin_lock_bh(&vcpu->arch.local_int.float_int->lock);
+                spin_lock(&vcpu->arch.local_int.float_int->lock);
                 spin_lock_bh(&vcpu->arch.local_int.lock);
         }
         __unset_cpu_idle(vcpu);
         __set_current_state(TASK_RUNNING);
         remove_wait_queue(&vcpu->wq, &wait);
         spin_unlock_bh(&vcpu->arch.local_int.lock);
-        spin_unlock_bh(&vcpu->arch.local_int.float_int->lock);
-        del_timer(&vcpu->arch.ckc_timer);
+        spin_unlock(&vcpu->arch.local_int.float_int->lock);
+        hrtimer_try_to_cancel(&vcpu->arch.ckc_timer);
         return 0;
 }
 
-void kvm_s390_idle_wakeup(unsigned long data)
+void kvm_s390_tasklet(unsigned long parm)
 {
-        struct kvm_vcpu *vcpu = (struct kvm_vcpu *)data;
+        struct kvm_vcpu *vcpu = (struct kvm_vcpu *) parm;
 
-        spin_lock_bh(&vcpu->arch.local_int.lock);
+        spin_lock(&vcpu->arch.local_int.lock);
         vcpu->arch.local_int.timer_due = 1;
         if (waitqueue_active(&vcpu->arch.local_int.wq))
                 wake_up_interruptible(&vcpu->arch.local_int.wq);
-        spin_unlock_bh(&vcpu->arch.local_int.lock);
+        spin_unlock(&vcpu->arch.local_int.lock);
 }
 
+/*
+ * low level hrtimer wake routine. Because this runs in hardirq context
+ * we schedule a tasklet to do the real work.
+ */
+enum hrtimer_restart kvm_s390_idle_wakeup(struct hrtimer *timer)
+{
+        struct kvm_vcpu *vcpu;
+
+        vcpu = container_of(timer, struct kvm_vcpu, arch.ckc_timer);
+        tasklet_schedule(&vcpu->arch.tasklet);
+
+        return HRTIMER_NORESTART;
+}
 
 void kvm_s390_deliver_pending_interrupts(struct kvm_vcpu *vcpu)
 {
@@ -436,7 +455,7 @@ void kvm_s390_deliver_pending_interrupts(struct kvm_vcpu *vcpu)
         if (atomic_read(&fi->active)) {
                 do {
                         deliver = 0;
-                        spin_lock_bh(&fi->lock);
+                        spin_lock(&fi->lock);
                         list_for_each_entry_safe(inti, n, &fi->list, list) {
                                 if (__interrupt_is_deliverable(vcpu, inti)) {
                                         list_del(&inti->list);
@@ -447,7 +466,7 @@ void kvm_s390_deliver_pending_interrupts(struct kvm_vcpu *vcpu)
                         }
                         if (list_empty(&fi->list))
                                 atomic_set(&fi->active, 0);
-                        spin_unlock_bh(&fi->lock);
+                        spin_unlock(&fi->lock);
                         if (deliver) {
                                 __do_deliver_interrupt(vcpu, inti);
                                 kfree(inti);
@@ -512,7 +531,7 @@ int kvm_s390_inject_vm(struct kvm *kvm,
 
         mutex_lock(&kvm->lock);
         fi = &kvm->arch.float_int;
-        spin_lock_bh(&fi->lock);
+        spin_lock(&fi->lock);
         list_add_tail(&inti->list, &fi->list);
         atomic_set(&fi->active, 1);
         sigcpu = find_first_bit(fi->idle_mask, KVM_MAX_VCPUS);
@@ -529,7 +548,7 @@ int kvm_s390_inject_vm(struct kvm *kvm,
         if (waitqueue_active(&li->wq))
                 wake_up_interruptible(&li->wq);
         spin_unlock_bh(&li->lock);
-        spin_unlock_bh(&fi->lock);
+        spin_unlock(&fi->lock);
         mutex_unlock(&kvm->lock);
         return 0;
 }
diff --git a/arch/s390/kvm/kvm-s390.c b/arch/s390/kvm/kvm-s390.c
index f4d56e9939c9..10bccd1f8aee 100644
--- a/arch/s390/kvm/kvm-s390.c
+++ b/arch/s390/kvm/kvm-s390.c
@@ -15,6 +15,7 @@
 #include <linux/compiler.h>
 #include <linux/err.h>
 #include <linux/fs.h>
+#include <linux/hrtimer.h>
 #include <linux/init.h>
 #include <linux/kvm.h>
 #include <linux/kvm_host.h>
@@ -195,6 +196,10 @@ out_nokvm:
 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
 {
         VCPU_EVENT(vcpu, 3, "%s", "free cpu");
+        if (vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda ==
+                (__u64) vcpu->arch.sie_block)
+                vcpu->kvm->arch.sca->cpu[vcpu->vcpu_id].sda = 0;
+        smp_mb();
         free_page((unsigned long)(vcpu->arch.sie_block));
         kvm_vcpu_uninit(vcpu);
         kfree(vcpu);
@@ -283,8 +288,10 @@ int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu)
         vcpu->arch.sie_block->gmsor = vcpu->kvm->arch.guest_origin;
         vcpu->arch.sie_block->ecb   = 2;
         vcpu->arch.sie_block->eca   = 0xC1002001U;
-        setup_timer(&vcpu->arch.ckc_timer, kvm_s390_idle_wakeup,
-                 (unsigned long) vcpu);
+        hrtimer_init(&vcpu->arch.ckc_timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
+        tasklet_init(&vcpu->arch.tasklet, kvm_s390_tasklet,
+                     (unsigned long) vcpu);
+        vcpu->arch.ckc_timer.function = kvm_s390_idle_wakeup;
         get_cpu_id(&vcpu->arch.cpu_id);
         vcpu->arch.cpu_id.version = 0xff;
         return 0;
@@ -307,19 +314,21 @@ struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm,
 
         vcpu->arch.sie_block->icpua = id;
         BUG_ON(!kvm->arch.sca);
-        BUG_ON(kvm->arch.sca->cpu[id].sda);
-        kvm->arch.sca->cpu[id].sda = (__u64) vcpu->arch.sie_block;
+        if (!kvm->arch.sca->cpu[id].sda)
+                kvm->arch.sca->cpu[id].sda = (__u64) vcpu->arch.sie_block;
+        else
+                BUG_ON(!kvm->vcpus[id]); /* vcpu does already exist */
         vcpu->arch.sie_block->scaoh = (__u32)(((__u64)kvm->arch.sca) >> 32);
         vcpu->arch.sie_block->scaol = (__u32)(__u64)kvm->arch.sca;
 
         spin_lock_init(&vcpu->arch.local_int.lock);
         INIT_LIST_HEAD(&vcpu->arch.local_int.list);
         vcpu->arch.local_int.float_int = &kvm->arch.float_int;
-        spin_lock_bh(&kvm->arch.float_int.lock);
+        spin_lock(&kvm->arch.float_int.lock);
         kvm->arch.float_int.local_int[id] = &vcpu->arch.local_int;
         init_waitqueue_head(&vcpu->arch.local_int.wq);
         vcpu->arch.local_int.cpuflags = &vcpu->arch.sie_block->cpuflags;
-        spin_unlock_bh(&kvm->arch.float_int.lock);
+        spin_unlock(&kvm->arch.float_int.lock);
 
         rc = kvm_vcpu_init(vcpu, kvm, id);
         if (rc)
@@ -478,6 +487,12 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 
         vcpu_load(vcpu);
 
+        /* verify, that memory has been registered */
+        if (!vcpu->kvm->arch.guest_memsize) {
+                vcpu_put(vcpu);
+                return -EINVAL;
+        }
+
         if (vcpu->sigset_active)
                 sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved);
 
@@ -657,6 +672,8 @@ int kvm_arch_set_memory_region(struct kvm *kvm,
                                 struct kvm_memory_slot old,
                                 int user_alloc)
 {
+        int i;
+
         /* A few sanity checks. We can have exactly one memory slot which has
            to start at guest virtual zero and which has to be located at a
            page boundary in userland and which has to end at a page boundary.
@@ -664,7 +681,7 @@ int kvm_arch_set_memory_region(struct kvm *kvm,
            vmas. It is okay to mmap() and munmap() stuff in this slot after
            doing this call at any time */
 
-        if (mem->slot)
+        if (mem->slot || kvm->arch.guest_memsize)
                 return -EINVAL;
 
         if (mem->guest_phys_addr)
@@ -676,15 +693,39 @@ int kvm_arch_set_memory_region(struct kvm *kvm,
         if (mem->memory_size & (PAGE_SIZE - 1))
                 return -EINVAL;
 
+        if (!user_alloc)
+                return -EINVAL;
+
+        /* lock all vcpus */
+        for (i = 0; i < KVM_MAX_VCPUS; ++i) {
+                if (!kvm->vcpus[i])
+                        continue;
+                if (!mutex_trylock(&kvm->vcpus[i]->mutex))
+                        goto fail_out;
+        }
+
         kvm->arch.guest_origin = mem->userspace_addr;
         kvm->arch.guest_memsize = mem->memory_size;
 
-        /* FIXME: we do want to interrupt running CPUs and update their memory
-           configuration now to avoid race conditions. But hey, changing the
-           memory layout while virtual CPUs are running is usually bad
-           programming practice. */
+        /* update sie control blocks, and unlock all vcpus */
+        for (i = 0; i < KVM_MAX_VCPUS; ++i) {
+                if (kvm->vcpus[i]) {
+                        kvm->vcpus[i]->arch.sie_block->gmsor =
+                                kvm->arch.guest_origin;
+                        kvm->vcpus[i]->arch.sie_block->gmslm =
+                                kvm->arch.guest_memsize +
+                                kvm->arch.guest_origin +
+                                VIRTIODESCSPACE - 1ul;
+                        mutex_unlock(&kvm->vcpus[i]->mutex);
+                }
+        }
 
         return 0;
+
+fail_out:
+        for (; i >= 0; i--)
+                mutex_unlock(&kvm->vcpus[i]->mutex);
+        return -EINVAL;
 }
 
 void kvm_arch_flush_shadow(struct kvm *kvm)
diff --git a/arch/s390/kvm/kvm-s390.h b/arch/s390/kvm/kvm-s390.h
index 00bbe69b78da..748fee872323 100644
--- a/arch/s390/kvm/kvm-s390.h
+++ b/arch/s390/kvm/kvm-s390.h
@@ -14,6 +14,7 @@
 #ifndef ARCH_S390_KVM_S390_H
 #define ARCH_S390_KVM_S390_H
 
+#include <linux/hrtimer.h>
 #include <linux/kvm.h>
 #include <linux/kvm_host.h>
 
@@ -41,7 +42,8 @@ static inline int __cpu_is_stopped(struct kvm_vcpu *vcpu)
 }
 
 int kvm_s390_handle_wait(struct kvm_vcpu *vcpu);
-void kvm_s390_idle_wakeup(unsigned long data);
+enum hrtimer_restart kvm_s390_idle_wakeup(struct hrtimer *timer);
+void kvm_s390_tasklet(unsigned long parm);
 void kvm_s390_deliver_pending_interrupts(struct kvm_vcpu *vcpu);
 int kvm_s390_inject_vm(struct kvm *kvm,
                 struct kvm_s390_interrupt *s390int);
diff --git a/arch/s390/kvm/priv.c b/arch/s390/kvm/priv.c
index 4b88834b8dd8..93ecd06e1a74 100644
--- a/arch/s390/kvm/priv.c
+++ b/arch/s390/kvm/priv.c
@@ -204,11 +204,11 @@ static void handle_stsi_3_2_2(struct kvm_vcpu *vcpu, struct sysinfo_3_2_2 *mem)
         int cpus = 0;
         int n;
 
-        spin_lock_bh(&fi->lock);
+        spin_lock(&fi->lock);
         for (n = 0; n < KVM_MAX_VCPUS; n++)
                 if (fi->local_int[n])
                         cpus++;
-        spin_unlock_bh(&fi->lock);
+        spin_unlock(&fi->lock);
 
         /* deal with other level 3 hypervisors */
         if (stsi(mem, 3, 2, 2) == -ENOSYS)
diff --git a/arch/s390/kvm/sigp.c b/arch/s390/kvm/sigp.c
index f27dbedf0866..36678835034d 100644
--- a/arch/s390/kvm/sigp.c
+++ b/arch/s390/kvm/sigp.c
@@ -52,7 +52,7 @@ static int __sigp_sense(struct kvm_vcpu *vcpu, u16 cpu_addr,
         if (cpu_addr >= KVM_MAX_VCPUS)
                 return 3; /* not operational */
 
-        spin_lock_bh(&fi->lock);
+        spin_lock(&fi->lock);
         if (fi->local_int[cpu_addr] == NULL)
                 rc = 3; /* not operational */
         else if (atomic_read(fi->local_int[cpu_addr]->cpuflags)
@@ -64,7 +64,7 @@ static int __sigp_sense(struct kvm_vcpu *vcpu, u16 cpu_addr,
                 *reg |= SIGP_STAT_STOPPED;
                 rc = 1; /* status stored */
         }
-        spin_unlock_bh(&fi->lock);
+        spin_unlock(&fi->lock);
 
         VCPU_EVENT(vcpu, 4, "sensed status of cpu %x rc %x", cpu_addr, rc);
         return rc;
@@ -86,7 +86,7 @@ static int __sigp_emergency(struct kvm_vcpu *vcpu, u16 cpu_addr)
 
         inti->type = KVM_S390_INT_EMERGENCY;
 
-        spin_lock_bh(&fi->lock);
+        spin_lock(&fi->lock);
         li = fi->local_int[cpu_addr];
         if (li == NULL) {
                 rc = 3; /* not operational */
@@ -102,7 +102,7 @@ static int __sigp_emergency(struct kvm_vcpu *vcpu, u16 cpu_addr)
         spin_unlock_bh(&li->lock);
         rc = 0; /* order accepted */
 unlock:
-        spin_unlock_bh(&fi->lock);
+        spin_unlock(&fi->lock);
         VCPU_EVENT(vcpu, 4, "sent sigp emerg to cpu %x", cpu_addr);
         return rc;
 }
@@ -123,7 +123,7 @@ static int __sigp_stop(struct kvm_vcpu *vcpu, u16 cpu_addr, int store)
 
         inti->type = KVM_S390_SIGP_STOP;
 
-        spin_lock_bh(&fi->lock);
+        spin_lock(&fi->lock);
         li = fi->local_int[cpu_addr];
         if (li == NULL) {
                 rc = 3; /* not operational */
@@ -142,7 +142,7 @@ static int __sigp_stop(struct kvm_vcpu *vcpu, u16 cpu_addr, int store)
         spin_unlock_bh(&li->lock);
         rc = 0; /* order accepted */
 unlock:
-        spin_unlock_bh(&fi->lock);
+        spin_unlock(&fi->lock);
         VCPU_EVENT(vcpu, 4, "sent sigp stop to cpu %x", cpu_addr);
         return rc;
 }
@@ -188,7 +188,7 @@ static int __sigp_set_prefix(struct kvm_vcpu *vcpu, u16 cpu_addr, u32 address,
         if (!inti)
                 return 2; /* busy */
 
-        spin_lock_bh(&fi->lock);
+        spin_lock(&fi->lock);
         li = fi->local_int[cpu_addr];
 
         if ((cpu_addr >= KVM_MAX_VCPUS) || (li == NULL)) {
@@ -220,7 +220,7 @@ static int __sigp_set_prefix(struct kvm_vcpu *vcpu, u16 cpu_addr, u32 address,
 out_li:
         spin_unlock_bh(&li->lock);
 out_fi:
-        spin_unlock_bh(&fi->lock);
+        spin_unlock(&fi->lock);
         return rc;
 }
 
diff --git a/arch/sh/Kconfig b/arch/sh/Kconfig
index e7390dd0283d..586cd045e2db 100644
--- a/arch/sh/Kconfig
+++ b/arch/sh/Kconfig
@@ -15,6 +15,7 @@ config SUPERH
         select HAVE_IOREMAP_PROT if MMU
         select HAVE_ARCH_TRACEHOOK
         select HAVE_DMA_API_DEBUG
+        select RTC_LIB
         help
           The SuperH is a RISC processor targeted for use in embedded systems
           and consumer electronics; it was also used in the Sega Dreamcast
@@ -74,14 +75,18 @@ config GENERIC_IOMAP
         bool
 
 config GENERIC_TIME
-        def_bool n
+        def_bool y
 
 config GENERIC_CLOCKEVENTS
-        def_bool n
+        def_bool y
 
 config GENERIC_CLOCKEVENTS_BROADCAST
         bool
 
+config GENERIC_CMOS_UPDATE
+        def_bool y
+        depends on SH_SH03 || SH_DREAMCAST
+
 config GENERIC_LOCKBREAK
         def_bool y
         depends on SMP && PREEMPT
@@ -112,6 +117,12 @@ config SYS_SUPPORTS_PCI
 config SYS_SUPPORTS_CMT
         bool
 
+config SYS_SUPPORTS_MTU2
+        bool
+
+config SYS_SUPPORTS_TMU
+        bool
+
 config STACKTRACE_SUPPORT
         def_bool y
 
@@ -157,13 +168,14 @@ config CPU_SH3
         bool
         select CPU_HAS_INTEVT
         select CPU_HAS_SR_RB
+        select SYS_SUPPORTS_TMU
 
 config CPU_SH4
         bool
         select CPU_HAS_INTEVT
         select CPU_HAS_SR_RB
-        select CPU_HAS_PTEA if !CPU_SH4A || CPU_SHX2
         select CPU_HAS_FPU if !CPU_SH4AL_DSP
+        select SYS_SUPPORTS_TMU
 
 config CPU_SH4A
         bool
@@ -177,6 +189,7 @@ config CPU_SH4AL_DSP
 config CPU_SH5
         bool
         select CPU_HAS_FPU
+        select SYS_SUPPORTS_TMU
 
 config CPU_SHX2
         bool
@@ -210,27 +223,32 @@ config CPU_SUBTYPE_SH7201
         bool "Support SH7201 processor"
         select CPU_SH2A
         select CPU_HAS_FPU
+        select SYS_SUPPORTS_MTU2
  
 config CPU_SUBTYPE_SH7203
         bool "Support SH7203 processor"
         select CPU_SH2A
         select CPU_HAS_FPU
         select SYS_SUPPORTS_CMT
+        select SYS_SUPPORTS_MTU2
 
 config CPU_SUBTYPE_SH7206
         bool "Support SH7206 processor"
         select CPU_SH2A
         select SYS_SUPPORTS_CMT
+        select SYS_SUPPORTS_MTU2
 
 config CPU_SUBTYPE_SH7263
         bool "Support SH7263 processor"
         select CPU_SH2A
         select CPU_HAS_FPU
         select SYS_SUPPORTS_CMT
+        select SYS_SUPPORTS_MTU2
 
 config CPU_SUBTYPE_MXG
         bool "Support MX-G processor"
         select CPU_SH2A
+        select SYS_SUPPORTS_MTU2
         help
           Select MX-G if running on an R8A03022BG part.
 
@@ -283,6 +301,7 @@ config CPU_SUBTYPE_SH7720
         bool "Support SH7720 processor"
         select CPU_SH3
         select CPU_HAS_DSP
+        select SYS_SUPPORTS_CMT
         help
           Select SH7720 if you have a SH3-DSP SH7720 CPU.
 
@@ -290,6 +309,7 @@ config CPU_SUBTYPE_SH7721
         bool "Support SH7721 processor"
         select CPU_SH3
         select CPU_HAS_DSP
+        select SYS_SUPPORTS_CMT
         help
           Select SH7721 if you have a SH3-DSP SH7721 CPU.
 
@@ -347,6 +367,16 @@ config CPU_SUBTYPE_SH7723
         help
           Select SH7723 if you have an SH-MobileR2 CPU.
 
+config CPU_SUBTYPE_SH7724
+        bool "Support SH7724 processor"
+        select CPU_SH4A
+        select CPU_SHX2
+        select ARCH_SHMOBILE
+        select ARCH_SPARSEMEM_ENABLE
+        select SYS_SUPPORTS_CMT
+        help
+          Select SH7724 if you have an SH-MobileR2R CPU.
+
 config CPU_SUBTYPE_SH7763
         bool "Support SH7763 processor"
         select CPU_SH4A
@@ -442,48 +472,26 @@ source "arch/sh/boards/Kconfig"
 
 menu "Timer and clock configuration"
 
-config SH_TMU
-        bool "TMU timer support"
-        depends on CPU_SH3 || CPU_SH4
+config SH_TIMER_TMU
+        bool "TMU timer driver"
+        depends on SYS_SUPPORTS_TMU
         default y
-        select GENERIC_TIME
-        select GENERIC_CLOCKEVENTS
         help
-          This enables the use of the TMU as the system timer.
+          This enables the build of the TMU timer driver.
 
-config SH_CMT
-        bool "CMT timer support"
-        depends on SYS_SUPPORTS_CMT && CPU_SH2
+config SH_TIMER_CMT
+        bool "CMT timer driver"
+        depends on SYS_SUPPORTS_CMT
         default y
         help
-          This enables the use of the CMT as the system timer.
+          This enables build of the CMT timer driver.
 
-#
-# Support for the new-style CMT driver. This will replace SH_CMT
-# once its other dependencies are merged.
-#
-config SH_TIMER_CMT
-        bool "CMT clockevents driver"
-        depends on SYS_SUPPORTS_CMT && !SH_CMT
-        select GENERIC_CLOCKEVENTS
-
-config SH_MTU2
-        bool "MTU2 timer support"
-        depends on CPU_SH2A
+config SH_TIMER_MTU2
+        bool "MTU2 timer driver"
+        depends on SYS_SUPPORTS_MTU2
         default y
         help
-          This enables the use of the MTU2 as the system timer.
-
-config SH_TIMER_IRQ
-        int
-        default "28" if CPU_SUBTYPE_SH7780 || CPU_SUBTYPE_SH7785 || \
-                        CPU_SUBTYPE_SH7763
-        default "86" if CPU_SUBTYPE_SH7619
-        default "140" if CPU_SUBTYPE_SH7206
-        default "142" if CPU_SUBTYPE_SH7203 && SH_CMT
-        default "153" if CPU_SUBTYPE_SH7203 && SH_MTU2
-        default "238" if CPU_SUBTYPE_MXG
-        default "16"
+          This enables build of the MTU2 timer driver.
 
 config SH_PCLK_FREQ
         int "Peripheral clock frequency (in Hz)"
@@ -494,7 +502,7 @@ config SH_PCLK_FREQ
                               CPU_SUBTYPE_SH7760 || CPU_SUBTYPE_SH7705 || \
                               CPU_SUBTYPE_SH7203 || CPU_SUBTYPE_SH7206 || \
                               CPU_SUBTYPE_SH7263 || CPU_SUBTYPE_MXG    || \
-                              CPU_SUBTYPE_SH7786
+                              CPU_SUBTYPE_SH7786 || CPU_SUBTYPE_SH7724
         default "60000000" if CPU_SUBTYPE_SH7751 || CPU_SUBTYPE_SH7751R
         default "66000000" if CPU_SUBTYPE_SH4_202
         default "50000000"
@@ -503,6 +511,13 @@ config SH_PCLK_FREQ
           This is necessary for determining the reference clock value on
           platforms lacking an RTC.
 
+config SH_CLK_CPG
+        def_bool y
+
+config SH_CLK_CPG_LEGACY
+        depends on SH_CLK_CPG
+        def_bool y if !CPU_SUBTYPE_SH7785 && !ARCH_SHMOBILE
+
 config SH_CLK_MD
         int "CPU Mode Pin Setting"
         depends on CPU_SH2
@@ -663,27 +678,54 @@ config GUSA_RB
           LLSC, this should be more efficient than the other alternative of
           disabling interrupts around the atomic sequence.
 
+config SPARSE_IRQ
+        bool "Support sparse irq numbering"
+        depends on EXPERIMENTAL
+        help
+          This enables support for sparse irqs. This is useful in general
+          as most CPUs have a fairly sparse array of IRQ vectors, which
+          the irq_desc then maps directly on to. Systems with a high
+          number of off-chip IRQs will want to treat this as
+          experimental until they have been independently verified.
+
+          If you don't know what to do here, say N.
+
 endmenu
 
 menu "Boot options"
 
 config ZERO_PAGE_OFFSET
-        hex "Zero page offset"
-        default "0x00004000" if SH_SH03
-        default "0x00010000" if PAGE_SIZE_64KB
+        hex
+        default "0x00010000" if PAGE_SIZE_64KB || SH_RTS7751R2D || \
+                                SH_7751_SOLUTION_ENGINE
+        default "0x00004000" if PAGE_SIZE_16KB || SH_SH03
         default "0x00002000" if PAGE_SIZE_8KB
         default "0x00001000"
         help
           This sets the default offset of zero page.
 
 config BOOT_LINK_OFFSET
-        hex "Link address offset for booting"
+        hex
+        default "0x00210000" if SH_SHMIN
+        default "0x00400000" if SH_CAYMAN
+        default "0x00810000" if SH_7780_SOLUTION_ENGINE
+        default "0x009e0000" if SH_TITAN
+        default "0x01800000" if SH_SDK7780
+        default "0x02000000" if SH_EDOSK7760
         default "0x00800000"
         help
           This option allows you to set the link address offset of the zImage.
           This can be useful if you are on a board which has a small amount of
           memory.
 
+config ENTRY_OFFSET
+        hex
+        default "0x00001000" if PAGE_SIZE_4KB
+        default "0x00002000" if PAGE_SIZE_8KB
+        default "0x00004000" if PAGE_SIZE_16KB
+        default "0x00010000" if PAGE_SIZE_64KB
+        default "0x00000000"
+
 config UBC_WAKEUP
         bool "Wakeup UBC on startup"
         depends on CPU_SH4 && !CPU_SH4A
diff --git a/arch/sh/Kconfig.cpu b/arch/sh/Kconfig.cpu
index c7d704381a6d..cd6e3ea598d5 100644
--- a/arch/sh/Kconfig.cpu
+++ b/arch/sh/Kconfig.cpu
@@ -76,11 +76,6 @@ config SPECULATIVE_EXECUTION
 
           If unsure, say N.
 
-config SH64_USER_MISALIGNED_FIXUP
-        def_bool y
-        prompt "Fixup misaligned loads/stores occurring in user mode"
-        depends on SUPERH64
-
 config SH64_ID2815_WORKAROUND
         bool "Include workaround for SH5-101 cut2 silicon defect ID2815"
         depends on CPU_SUBTYPE_SH5_101
@@ -101,9 +96,6 @@ config CPU_HAS_SR_RB
           See <file:Documentation/sh/register-banks.txt> for further
           information on SR.RB and register banking in the kernel in general.
 
-config CPU_HAS_PTEA
-        bool
-
 config CPU_HAS_PTEAEX
         bool
 
diff --git a/arch/sh/Kconfig.debug b/arch/sh/Kconfig.debug
index 0d62681f72a0..8179cc9be9a4 100644
--- a/arch/sh/Kconfig.debug
+++ b/arch/sh/Kconfig.debug
@@ -38,10 +38,10 @@ config EARLY_SCIF_CONSOLE_PORT
         default "0xffe00000" if CPU_SUBTYPE_SH7780 || CPU_SUBTYPE_SH7763 || \
                                 CPU_SUBTYPE_SH7722 || CPU_SUBTYPE_SH7366 || \
                                 CPU_SUBTYPE_SH7343
-        default "0xffe80000" if CPU_SH4
         default "0xffea0000" if CPU_SUBTYPE_SH7785
         default "0xfffe8000" if CPU_SUBTYPE_SH7203
         default "0xfffe9800" if CPU_SUBTYPE_SH7206 || CPU_SUBTYPE_SH7263
+        default "0xffe80000" if CPU_SH4
         default "0x00000000"
 
 config EARLY_PRINTK
@@ -92,7 +92,7 @@ config 4KSTACKS
 
 config IRQSTACKS
         bool "Use separate kernel stacks when processing interrupts"
-        depends on DEBUG_KERNEL && SUPERH32
+        depends on DEBUG_KERNEL && SUPERH32 && BROKEN
         help
           If you say Y here the kernel will use separate kernel stacks
           for handling hard and soft interrupts.  This can help avoid
@@ -122,27 +122,8 @@ config SH_NO_BSS_INIT
           For all other cases, say N. If this option seems perplexing, or
           you aren't sure, say N.
 
-config MORE_COMPILE_OPTIONS
-        bool "Add any additional compile options"
-        help
-          If you want to add additional CFLAGS to the kernel build, enable this
-          option and then enter what you would like to add in the next question.
-          Note however that -g is already appended with the selection of KGDB.
-
-config COMPILE_OPTIONS
-        string "Additional compile arguments"
-        depends on MORE_COMPILE_OPTIONS
-
 config SH64_SR_WATCH
         bool "Debug: set SR.WATCH to enable hardware watchpoints and trace"
         depends on SUPERH64
 
-config POOR_MANS_STRACE
-        bool "Debug: enable rudimentary strace facility"
-        depends on SUPERH64
-        help
-          This option allows system calls to be traced to the console.  It also
-          aids in detecting kernel stack underflow.  It is useful for debugging
-          early-userland problems (e.g. init incurring fatal exceptions.)
-
 endmenu
diff --git a/arch/sh/Makefile b/arch/sh/Makefile
index bece1f7535f2..75d049b03f7e 100644
--- a/arch/sh/Makefile
+++ b/arch/sh/Makefile
@@ -70,9 +70,6 @@ cflags-$(CONFIG_CPU_LITTLE_ENDIAN)	+= -ml
 cflags-y        += $(call cc-option,-mno-fdpic)
 cflags-y        += $(isaflags-y) -ffreestanding
 
-cflags-$(CONFIG_MORE_COMPILE_OPTIONS)   += \
-        $(shell echo $(CONFIG_COMPILE_OPTIONS) | sed -e 's/"//g')
-
 OBJCOPYFLAGS    := -O binary -R .note -R .note.gnu.build-id -R .comment \
                    -R .stab -R .stabstr -S
 
@@ -85,7 +82,6 @@ defaultimage-$(CONFIG_SH_7206_SOLUTION_ENGINE)	:= vmlinux
 defaultimage-$(CONFIG_SH_7619_SOLUTION_ENGINE)  := vmlinux
 
 # Set some sensible Kbuild defaults
-KBUILD_DEFCONFIG        := shx3_defconfig
 KBUILD_IMAGE            := $(defaultimage-y)
 
 #
@@ -93,26 +89,38 @@ KBUILD_IMAGE		:= $(defaultimage-y)
 # error messages during linking.
 #
 ifdef CONFIG_SUPERH32
-UTS_MACHINE     := sh
-LDFLAGS_vmlinux += -e _stext
+UTS_MACHINE             := sh
+BITS                    := 32
+LDFLAGS_vmlinux         += -e _stext
+KBUILD_DEFCONFIG        := shx3_defconfig
 else
-UTS_MACHINE     := sh64
-LDFLAGS_vmlinux += --defsym phys_stext=_stext-$(CONFIG_PAGE_OFFSET) \
-                   --defsym phys_stext_shmedia=phys_stext+1 \
-                   -e phys_stext_shmedia
+UTS_MACHINE             := sh64
+BITS                    := 64
+LDFLAGS_vmlinux         += --defsym phys_stext=_stext-$(CONFIG_PAGE_OFFSET) \
+                           --defsym phys_stext_shmedia=phys_stext+1 \
+                           -e phys_stext_shmedia
+KBUILD_DEFCONFIG        := cayman_defconfig
+endif
+
+ifneq ($(SUBARCH),$(ARCH))
+  ifeq ($(CROSS_COMPILE),)
+    CROSS_COMPILE := $(call cc-cross-prefix, $(UTS_MACHINE)-linux-  $(UTS_MACHINE)-linux-gnu-  $(UTS_MACHINE)-unknown-linux-gnu-)
+  endif
 endif
 
 ifdef CONFIG_CPU_LITTLE_ENDIAN
-LDFLAGS_vmlinux         += --defsym 'jiffies=jiffies_64'
+ld-bfd                  := elf32-$(UTS_MACHINE)-linux
+LDFLAGS_vmlinux         += --defsym 'jiffies=jiffies_64' --oformat $(ld-bfd)
 LDFLAGS                 += -EL
 else
-LDFLAGS_vmlinux         += --defsym 'jiffies=jiffies_64+4'
+ld-bfd                  := elf32-$(UTS_MACHINE)big-linux
+LDFLAGS_vmlinux         += --defsym 'jiffies=jiffies_64+4' --oformat $(ld-bfd)
 LDFLAGS                 += -EB
 endif
 
-head-y                  := arch/sh/kernel/init_task.o
-head-$(CONFIG_SUPERH32) += arch/sh/kernel/head_32.o
-head-$(CONFIG_SUPERH64) += arch/sh/kernel/head_64.o
+export ld-bfd BITS
+
+head-y  := arch/sh/kernel/init_task.o arch/sh/kernel/head_$(BITS).o
 
 core-y                          += arch/sh/kernel/ arch/sh/mm/ arch/sh/boards/
 core-$(CONFIG_SH_FPU_EMU)       += arch/sh/math-emu/
@@ -193,10 +201,11 @@ zImage uImage uImage.srec vmlinux.srec: vmlinux
 
 compressed: zImage
 
-archprepare: maketools arch/sh/lib64/syscalltab.h
+archprepare: maketools
 
 archclean:
         $(Q)$(MAKE) $(clean)=$(boot)
+        $(Q)$(MAKE) $(clean)=arch/sh/kernel/vsyscall
 
 define archhelp
         @echo '* zImage                    - Compressed kernel image'
@@ -205,34 +214,4 @@ define archhelp
         @echo '  uImage.srec               - Create an S-record for U-Boot'
 endef
 
-define filechk_gen-syscalltab
-       (set -e; \
-        echo "/*"; \
-        echo " * DO NOT MODIFY."; \
-        echo " *"; \
-        echo " * This file was generated by arch/sh/Makefile"; \
-        echo " * Any changes will be reverted at build time."; \
-        echo " */"; \
-        echo ""; \
-        echo "#ifndef __SYSCALLTAB_H"; \
-        echo "#define __SYSCALLTAB_H"; \
-        echo ""; \
-        echo "#include <linux/kernel.h>"; \
-        echo ""; \
-        echo "struct syscall_info {"; \
-        echo "  const char *name;"; \
-        echo "} syscall_info_table[] = {"; \
-        sed -e '/^.*\.long /!d;s//      { "/;s/\(\([^/]*\)\/\)\{1\}.*/\2/; \
-                s/[ \t]*$$//g;s/$$/" },/;s/\("\)sys_/\1/g'; \
-        echo "};"; \
-        echo ""; \
-        echo "#define NUM_SYSCALL_INFO_ENTRIES ARRAY_SIZE(syscall_info_table)";\
-        echo ""; \
-        echo "#endif /* __SYSCALLTAB_H */" )
-endef
-
-arch/sh/lib64/syscalltab.h: arch/sh/kernel/syscalls_64.S
-        $(call filechk,gen-syscalltab)
-
-CLEAN_FILES += arch/sh/lib64/syscalltab.h \
-               include/asm-sh/machtypes.h
+CLEAN_FILES += include/asm-sh/machtypes.h
diff --git a/arch/sh/boards/Kconfig b/arch/sh/boards/Kconfig
index dcc1af8a2cfe..1c91b1f565d5 100644
--- a/arch/sh/boards/Kconfig
+++ b/arch/sh/boards/Kconfig
@@ -46,6 +46,15 @@ config SH_7722_SOLUTION_ENGINE
           Select 7722 SolutionEngine if configuring for a Hitachi SH772
           evaluation board.
 
+config SH_7724_SOLUTION_ENGINE
+        bool "SolutionEngine7724"
+        select SOLUTION_ENGINE
+        depends on CPU_SUBTYPE_SH7724
+        select ARCH_REQUIRE_GPIOLIB
+        help
+          Select 7724 SolutionEngine if configuring for a Hitachi SH7724
+          evaluation board.
+
 config SH_7751_SOLUTION_ENGINE
         bool "SolutionEngine7751"
         select SOLUTION_ENGINE
@@ -121,7 +130,7 @@ config SH_RTS7751R2D
         bool "RTS7751R2D"
         depends on CPU_SUBTYPE_SH7751R
         select SYS_SUPPORTS_PCI
-        select IO_TRAPPED
+        select IO_TRAPPED if MMU
         help
           Select RTS7751R2D if configuring for a Renesas Technology
           Sales SH-Graphics board.
@@ -145,13 +154,13 @@ config SH_HIGHLANDER
         bool "Highlander"
         depends on CPU_SUBTYPE_SH7780 || CPU_SUBTYPE_SH7785
         select SYS_SUPPORTS_PCI
-        select IO_TRAPPED
+        select IO_TRAPPED if MMU
 
 config SH_SH7785LCR
         bool "SH7785LCR"
         depends on CPU_SUBTYPE_SH7785
         select SYS_SUPPORTS_PCI
-        select IO_TRAPPED
+        select IO_TRAPPED if MMU
 
 config SH_SH7785LCR_29BIT_PHYSMAPS
         bool "SH7785LCR 29bit physmaps"
diff --git a/arch/sh/boards/board-ap325rxa.c b/arch/sh/boards/board-ap325rxa.c
index f2a29641b6a3..1c4d83ef2a47 100644
--- a/arch/sh/boards/board-ap325rxa.c
+++ b/arch/sh/boards/board-ap325rxa.c
@@ -535,6 +535,18 @@ static int __init ap325rxa_devices_setup(void)
 }
 device_initcall(ap325rxa_devices_setup);
 
+/* Return the board specific boot mode pin configuration */
+static int ap325rxa_mode_pins(void)
+{
+        /* MD0=0, MD1=0, MD2=0: Clock Mode 0
+         * MD3=0: 16-bit Area0 Bus Width
+         * MD5=1: Little Endian
+         * TSTMD=1, MD8=1: Test Mode Disabled
+         */
+        return MODE_PIN5 | MODE_PIN8;
+}
+
 static struct sh_machine_vector mv_ap325rxa __initmv = {
         .mv_name = "AP-325RXA",
+        .mv_mode_pins = ap325rxa_mode_pins,
 };
diff --git a/arch/sh/boards/board-sh7785lcr.c b/arch/sh/boards/board-sh7785lcr.c
index 6f94f17adc46..7be56fb06c1f 100644
--- a/arch/sh/boards/board-sh7785lcr.c
+++ b/arch/sh/boards/board-sh7785lcr.c
@@ -2,12 +2,12 @@
  * Renesas Technology Corp. R0P7785LC0011RL Support.
  *
  * Copyright (C) 2008  Yoshihiro Shimoda
+ * Copyright (C) 2009  Paul Mundt
  *
  * 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.
  */
-
 #include <linux/init.h>
 #include <linux/platform_device.h>
 #include <linux/sm501.h>
@@ -19,8 +19,12 @@
 #include <linux/i2c-pca-platform.h>
 #include <linux/i2c-algo-pca.h>
 #include <linux/irq.h>
-#include <asm/heartbeat.h>
+#include <linux/clk.h>
+#include <linux/errno.h>
 #include <mach/sh7785lcr.h>
+#include <asm/heartbeat.h>
+#include <asm/clock.h>
+#include <cpu/sh7785.h>
 
 /*
  * NOTE: This board has 2 physical memory maps.
@@ -273,6 +277,20 @@ void __init init_sh7785lcr_IRQ(void)
         plat_irq_setup_pins(IRQ_MODE_IRQ3210);
 }
 
+static int sh7785lcr_clk_init(void)
+{
+        struct clk *clk;
+        int ret;
+
+        clk = clk_get(NULL, "extal");
+        if (!clk || IS_ERR(clk))
+                return PTR_ERR(clk);
+        ret = clk_set_rate(clk, 33333333);
+        clk_put(clk);
+
+        return ret;
+}
+
 static void sh7785lcr_power_off(void)
 {
         unsigned char *p;
@@ -303,12 +321,34 @@ static void __init sh7785lcr_setup(char **cmdline_p)
         writel(0x000307c2, sm501_reg);
 }
 
+/* Return the board specific boot mode pin configuration */
+static int sh7785lcr_mode_pins(void)
+{
+        int value = 0;
+
+        /* These are the factory default settings of S1 and S2.
+         * If you change these dip switches then you will need to
+         * adjust the values below as well.
+         */
+        value |= MODE_PIN4; /* Clock Mode 16 */
+        value |= MODE_PIN5; /* 32-bit Area0 bus width */
+        value |= MODE_PIN6; /* 32-bit Area0 bus width */
+        value |= MODE_PIN7; /* Area 0 SRAM interface [fixed] */
+        value |= MODE_PIN8; /* Little Endian */
+        value |= MODE_PIN9; /* Master Mode */
+        value |= MODE_PIN14; /* No PLL step-up */
+
+        return value;
+}
+
 /*
  * The Machine Vector
  */
 static struct sh_machine_vector mv_sh7785lcr __initmv = {
         .mv_name                = "SH7785LCR",
         .mv_setup               = sh7785lcr_setup,
+        .mv_clk_init            = sh7785lcr_clk_init,
         .mv_init_irq            = init_sh7785lcr_IRQ,
+        .mv_mode_pins           = sh7785lcr_mode_pins,
 };
 
diff --git a/arch/sh/boards/mach-cayman/Makefile b/arch/sh/boards/mach-cayman/Makefile
index cafe1ac3b29c..00fa3eaecb1b 100644
--- a/arch/sh/boards/mach-cayman/Makefile
+++ b/arch/sh/boards/mach-cayman/Makefile
@@ -1,4 +1,4 @@
 #
 # Makefile for the Hitachi Cayman specific parts of the kernel
 #
-obj-y := setup.o irq.o
+obj-y := setup.o irq.o panic.o
diff --git a/arch/sh/boards/mach-cayman/irq.c b/arch/sh/boards/mach-cayman/irq.c
index da62ad516994..33f770856319 100644
--- a/arch/sh/boards/mach-cayman/irq.c
+++ b/arch/sh/boards/mach-cayman/irq.c
@@ -142,26 +142,11 @@ int cayman_irq_demux(int evt)
         return irq;
 }
 
-#if defined(CONFIG_PROC_FS) && defined(CONFIG_SYSCTL)
-int cayman_irq_describe(char* p, int irq)
-{
-        if (irq < NR_INTC_IRQS) {
-                return intc_irq_describe(p, irq);
-        } else if (irq < NR_INTC_IRQS + 8) {
-                return sprintf(p, "(SMSC %d)", irq - NR_INTC_IRQS);
-        } else if ((irq >= NR_INTC_IRQS + 24) && (irq < NR_INTC_IRQS + 32)) {
-                return sprintf(p, "(PCI2 %d)", irq - (NR_INTC_IRQS + 24));
-        }
-
-        return 0;
-}
-#endif
-
 void init_cayman_irq(void)
 {
         int i;
 
-        epld_virt = onchip_remap(EPLD_BASE, 1024, "EPLD");
+        epld_virt = (unsigned long)ioremap_nocache(EPLD_BASE, 1024);
         if (!epld_virt) {
                 printk(KERN_ERR "Cayman IRQ: Unable to remap EPLD\n");
                 return;
diff --git a/arch/sh/boards/mach-cayman/panic.c b/arch/sh/boards/mach-cayman/panic.c
new file mode 100644
index 000000000000..d1e67306d07c
--- /dev/null
+++ b/arch/sh/boards/mach-cayman/panic.c
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2003  Richard Curnow, SuperH UK Limited
+ *
+ * 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.
+ */
+
+#include <linux/kernel.h>
+#include <linux/io.h>
+#include <cpu/registers.h>
+
+/* THIS IS A PHYSICAL ADDRESS */
+#define HDSP2534_ADDR (0x04002100)
+
+static void poor_mans_delay(void)
+{
+        int i;
+
+        for (i = 0; i < 2500000; i++)
+                cpu_relax();
+}
+
+static void show_value(unsigned long x)
+{
+        int i;
+        unsigned nibble;
+        for (i = 0; i < 8; i++) {
+                nibble = ((x >> (i * 4)) & 0xf);
+
+                __raw_writeb(nibble + ((nibble > 9) ? 55 : 48),
+                          HDSP2534_ADDR + 0xe0 + ((7 - i) << 2));
+        }
+}
+
+void
+panic_handler(unsigned long panicPC, unsigned long panicSSR,
+              unsigned long panicEXPEVT)
+{
+        while (1) {
+                /* This piece of code displays the PC on the LED display */
+                show_value(panicPC);
+                poor_mans_delay();
+                show_value(panicSSR);
+                poor_mans_delay();
+                show_value(panicEXPEVT);
+                poor_mans_delay();
+        }
+}
diff --git a/arch/sh/boards/mach-cayman/setup.c b/arch/sh/boards/mach-cayman/setup.c
index e7f9cc5f2ff1..7e8216ac31bd 100644
--- a/arch/sh/boards/mach-cayman/setup.c
+++ b/arch/sh/boards/mach-cayman/setup.c
@@ -102,7 +102,7 @@ static int __init smsc_superio_setup(void)
 {
         unsigned char devid, devrev;
 
-        smsc_superio_virt = onchip_remap(SMSC_SUPERIO_BASE, 1024, "SMSC SuperIO");
+        smsc_superio_virt = (unsigned long)ioremap_nocache(SMSC_SUPERIO_BASE, 1024);
         if (!smsc_superio_virt) {
                 panic("Unable to remap SMSC SuperIO\n");
         }
diff --git a/arch/sh/boards/mach-dreamcast/setup.c b/arch/sh/boards/mach-dreamcast/setup.c
index d1bee4884cd6..ebe99227d4e6 100644
--- a/arch/sh/boards/mach-dreamcast/setup.c
+++ b/arch/sh/boards/mach-dreamcast/setup.c
@@ -30,7 +30,6 @@
 
 extern struct irq_chip systemasic_int;
 extern void aica_time_init(void);
-extern int gapspci_init(void);
 extern int systemasic_irq_demux(int);
 
 static void __init dreamcast_setup(char **cmdline_p)
@@ -51,11 +50,6 @@ static void __init dreamcast_setup(char **cmdline_p)
                                          handle_level_irq);
 
         board_time_init = aica_time_init;
-
-#ifdef CONFIG_PCI
-        if (gapspci_init() < 0)
-                printk(KERN_WARNING "GAPSPCI was not detected.\n");
-#endif
 }
 
 static struct sh_machine_vector mv_dreamcast __initmv = {
diff --git a/arch/sh/boards/mach-migor/setup.c b/arch/sh/boards/mach-migor/setup.c
index 1ee1de0bc1c3..6ed401cd3156 100644
--- a/arch/sh/boards/mach-migor/setup.c
+++ b/arch/sh/boards/mach-migor/setup.c
@@ -584,3 +584,22 @@ static int __init migor_devices_setup(void)
         return platform_add_devices(migor_devices, ARRAY_SIZE(migor_devices));
 }
 __initcall(migor_devices_setup);
+
+/* Return the board specific boot mode pin configuration */
+static int migor_mode_pins(void)
+{
+        /* MD0=1, MD1=1, MD2=0: Clock Mode 3
+         * MD3=0: 16-bit Area0 Bus Width
+         * MD5=1: Little Endian
+         * TSTMD=1, MD8=0: Test Mode Disabled
+         */
+        return MODE_PIN0 | MODE_PIN1 | MODE_PIN5;
+}
+
+/*
+ * The Machine Vector
+ */
+static struct sh_machine_vector mv_migor __initmv = {
+        .mv_name                = "Migo-R",
+        .mv_mode_pins           = migor_mode_pins,
+};
diff --git a/arch/sh/boards/mach-r2d/setup.c b/arch/sh/boards/mach-r2d/setup.c
index c585be00956e..a625ecb93e47 100644
--- a/arch/sh/boards/mach-r2d/setup.c
+++ b/arch/sh/boards/mach-r2d/setup.c
@@ -10,6 +10,9 @@
  */
 #include <linux/init.h>
 #include <linux/platform_device.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/partitions.h>
+#include <linux/mtd/physmap.h>
 #include <linux/ata_platform.h>
 #include <linux/sm501.h>
 #include <linux/sm501-regs.h>
@@ -181,6 +184,50 @@ static struct platform_device sm501_device = {
         .resource       = sm501_resources,
 };
 
+static struct mtd_partition r2d_partitions[] = {
+        {
+                .name           = "U-Boot",
+                .offset         = 0x00000000,
+                .size           = 0x00040000,
+                .mask_flags     = MTD_WRITEABLE,
+        }, {
+                .name           = "Environment",
+                .offset         = MTDPART_OFS_NXTBLK,
+                .size           = 0x00040000,
+                .mask_flags     = MTD_WRITEABLE,
+        }, {
+                .name           = "Kernel",
+                .offset         = MTDPART_OFS_NXTBLK,
+                .size           = 0x001c0000,
+        }, {
+                .name           = "Flash_FS",
+                .offset         = MTDPART_OFS_NXTBLK,
+                .size           = MTDPART_SIZ_FULL,
+        }
+};
+
+static struct physmap_flash_data flash_data = {
+        .width          = 2,
+        .nr_parts       = ARRAY_SIZE(r2d_partitions),
+        .parts          = r2d_partitions,
+};
+
+static struct resource flash_resource = {
+        .start          = 0x00000000,
+        .end            = 0x02000000,
+        .flags          = IORESOURCE_MEM,
+};
+
+static struct platform_device flash_device = {
+        .name           = "physmap-flash",
+        .id             = -1,
+        .resource       = &flash_resource,
+        .num_resources  = 1,
+        .dev            = {
+                .platform_data = &flash_data,
+        },
+};
+
 static struct platform_device *rts7751r2d_devices[] __initdata = {
         &sm501_device,
         &heartbeat_device,
@@ -203,6 +250,9 @@ static int __init rts7751r2d_devices_setup(void)
         if (register_trapped_io(&cf_trapped_io) == 0)
                 platform_device_register(&cf_ide_device);
 
+        if (mach_is_r2d_plus())
+                platform_device_register(&flash_device);
+
         spi_register_board_info(spi_bus, ARRAY_SIZE(spi_bus));
 
         return platform_add_devices(rts7751r2d_devices,
diff --git a/arch/sh/boards/mach-se/7724/Makefile b/arch/sh/boards/mach-se/7724/Makefile
new file mode 100644
index 000000000000..349cbd6ce82d
--- /dev/null
+++ b/arch/sh/boards/mach-se/7724/Makefile
@@ -0,0 +1,10 @@
+#
+# Makefile for the HITACHI UL SolutionEngine 7724 specific parts of the kernel
+#
+# 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.
+#
+#
+
+obj-y    := setup.o irq.o
\ No newline at end of file
diff --git a/arch/sh/boards/mach-se/7724/irq.c b/arch/sh/boards/mach-se/7724/irq.c
new file mode 100644
index 000000000000..f76cf3b49f23
--- /dev/null
+++ b/arch/sh/boards/mach-se/7724/irq.c
@@ -0,0 +1,139 @@
+/*
+ * linux/arch/sh/boards/se/7724/irq.c
+ *
+ * Copyright (C) 2009 Renesas Solutions Corp.
+ *
+ * Kuninori Morimoto <morimoto.kuninori@renesas.com>
+ *
+ * Based on  linux/arch/sh/boards/se/7722/irq.c
+ * Copyright (C) 2007  Nobuhiro Iwamatsu
+ *
+ * Hitachi UL SolutionEngine 7724 Support.
+ *
+ * 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.
+ */
+#include <linux/init.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <asm/irq.h>
+#include <asm/io.h>
+#include <mach-se/mach/se7724.h>
+
+struct fpga_irq {
+        unsigned long  sraddr;
+        unsigned long  mraddr;
+        unsigned short mask;
+        unsigned int   base;
+};
+
+static unsigned int fpga2irq(unsigned int irq)
+{
+        if (irq >= IRQ0_BASE &&
+            irq <= IRQ0_END)
+                return IRQ0_IRQ;
+        else if (irq >= IRQ1_BASE &&
+                 irq <= IRQ1_END)
+                return IRQ1_IRQ;
+        else
+                return IRQ2_IRQ;
+}
+
+static struct fpga_irq get_fpga_irq(unsigned int irq)
+{
+        struct fpga_irq set;
+
+        switch (irq) {
+        case IRQ0_IRQ:
+                set.sraddr = IRQ0_SR;
+                set.mraddr = IRQ0_MR;
+                set.mask   = IRQ0_MASK;
+                set.base   = IRQ0_BASE;
+                break;
+        case IRQ1_IRQ:
+                set.sraddr = IRQ1_SR;
+                set.mraddr = IRQ1_MR;
+                set.mask   = IRQ1_MASK;
+                set.base   = IRQ1_BASE;
+                break;
+        default:
+                set.sraddr = IRQ2_SR;
+                set.mraddr = IRQ2_MR;
+                set.mask   = IRQ2_MASK;
+                set.base   = IRQ2_BASE;
+                break;
+        }
+
+        return set;
+}
+
+static void disable_se7724_irq(unsigned int irq)
+{
+        struct fpga_irq set = get_fpga_irq(fpga2irq(irq));
+        unsigned int bit = irq - set.base;
+        ctrl_outw(ctrl_inw(set.mraddr) | 0x0001 << bit, set.mraddr);
+}
+
+static void enable_se7724_irq(unsigned int irq)
+{
+        struct fpga_irq set = get_fpga_irq(fpga2irq(irq));
+        unsigned int bit = irq - set.base;
+        ctrl_outw(ctrl_inw(set.mraddr) & ~(0x0001 << bit), set.mraddr);
+}
+
+static struct irq_chip se7724_irq_chip __read_mostly = {
+        .name           = "SE7724-FPGA",
+        .mask           = disable_se7724_irq,
+        .unmask         = enable_se7724_irq,
+        .mask_ack       = disable_se7724_irq,
+};
+
+static void se7724_irq_demux(unsigned int irq, struct irq_desc *desc)
+{
+        struct fpga_irq set = get_fpga_irq(irq);
+        unsigned short intv = ctrl_inw(set.sraddr);
+        struct irq_desc *ext_desc;
+        unsigned int ext_irq = set.base;
+
+        intv &= set.mask;
+
+        while (intv) {
+                if (intv & 0x0001) {
+                        ext_desc = irq_desc + ext_irq;
+                        handle_level_irq(ext_irq, ext_desc);
+                }
+                intv >>= 1;
+                ext_irq++;
+        }
+}
+
+/*
+ * Initialize IRQ setting
+ */
+void __init init_se7724_IRQ(void)
+{
+        int i;
+
+        ctrl_outw(0xffff, IRQ0_MR);  /* mask all */
+        ctrl_outw(0xffff, IRQ1_MR);  /* mask all */
+        ctrl_outw(0xffff, IRQ2_MR);  /* mask all */
+        ctrl_outw(0x0000, IRQ0_SR);  /* clear irq */
+        ctrl_outw(0x0000, IRQ1_SR);  /* clear irq */
+        ctrl_outw(0x0000, IRQ2_SR);  /* clear irq */
+        ctrl_outw(0x002a, IRQ_MODE); /* set irq type */
+
+        for (i = 0; i < SE7724_FPGA_IRQ_NR; i++)
+                set_irq_chip_and_handler_name(SE7724_FPGA_IRQ_BASE + i,
+                                              &se7724_irq_chip,
+                                              handle_level_irq, "level");
+
+        set_irq_chained_handler(IRQ0_IRQ, se7724_irq_demux);
+        set_irq_type(IRQ0_IRQ, IRQ_TYPE_LEVEL_LOW);
+
+        set_irq_chained_handler(IRQ1_IRQ, se7724_irq_demux);
+        set_irq_type(IRQ1_IRQ, IRQ_TYPE_LEVEL_LOW);
+
+        set_irq_chained_handler(IRQ2_IRQ, se7724_irq_demux);
+        set_irq_type(IRQ2_IRQ, IRQ_TYPE_LEVEL_LOW);
+}
diff --git a/arch/sh/boards/mach-se/7724/setup.c b/arch/sh/boards/mach-se/7724/setup.c
new file mode 100644
index 000000000000..9cd04bd558b8
--- /dev/null
+++ b/arch/sh/boards/mach-se/7724/setup.c
@@ -0,0 +1,448 @@
+/*
+ * linux/arch/sh/boards/se/7724/setup.c
+ *
+ * Copyright (C) 2009 Renesas Solutions Corp.
+ *
+ * Kuninori Morimoto <morimoto.kuninori@renesas.com>
+ *
+ * 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.
+ */
+
+#include <linux/init.h>
+#include <linux/device.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/mtd/physmap.h>
+#include <linux/delay.h>
+#include <linux/smc91x.h>
+#include <linux/gpio.h>
+#include <linux/input.h>
+#include <video/sh_mobile_lcdc.h>
+#include <media/sh_mobile_ceu.h>
+#include <asm/io.h>
+#include <asm/heartbeat.h>
+#include <asm/sh_keysc.h>
+#include <cpu/sh7724.h>
+#include <mach-se/mach/se7724.h>
+
+/*
+ * SWx    1234 5678
+ * ------------------------------------
+ * SW31 : 1001 1100    : default
+ * SW32 : 0111 1111    : use on board flash
+ *
+ * SW41 : abxx xxxx  -> a = 0 : Analog  monitor
+ *                          1 : Digital monitor
+ *                      b = 0 : VGA
+ *                          1 : SVGA
+ */
+
+/* Heartbeat */
+static struct heartbeat_data heartbeat_data = {
+        .regsize = 16,
+};
+
+static struct resource heartbeat_resources[] = {
+        [0] = {
+                .start  = PA_LED,
+                .end    = PA_LED,
+                .flags  = IORESOURCE_MEM,
+        },
+};
+
+static struct platform_device heartbeat_device = {
+        .name           = "heartbeat",
+        .id             = -1,
+        .dev = {
+                .platform_data = &heartbeat_data,
+        },
+        .num_resources  = ARRAY_SIZE(heartbeat_resources),
+        .resource       = heartbeat_resources,
+};
+
+/* LAN91C111 */
+static struct smc91x_platdata smc91x_info = {
+        .flags = SMC91X_USE_16BIT | SMC91X_NOWAIT,
+};
+
+static struct resource smc91x_eth_resources[] = {
+        [0] = {
+                .name   = "SMC91C111" ,
+                .start  = 0x1a300300,
+                .end    = 0x1a30030f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = IRQ0_SMC,
+                .flags  = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL,
+        },
+};
+
+static struct platform_device smc91x_eth_device = {
+        .name   = "smc91x",
+        .num_resources  = ARRAY_SIZE(smc91x_eth_resources),
+        .resource       = smc91x_eth_resources,
+        .dev    = {
+                .platform_data  = &smc91x_info,
+        },
+};
+
+/* MTD */
+static struct mtd_partition nor_flash_partitions[] = {
+        {
+                .name = "uboot",
+                .offset = 0,
+                .size = (1 * 1024 * 1024),
+                .mask_flags = MTD_WRITEABLE,    /* Read-only */
+        }, {
+                .name = "kernel",
+                .offset = MTDPART_OFS_APPEND,
+                .size = (2 * 1024 * 1024),
+        }, {
+                .name = "free-area",
+                .offset = MTDPART_OFS_APPEND,
+                .size = MTDPART_SIZ_FULL,
+        },
+};
+
+static struct physmap_flash_data nor_flash_data = {
+        .width          = 2,
+        .parts          = nor_flash_partitions,
+        .nr_parts       = ARRAY_SIZE(nor_flash_partitions),
+};
+
+static struct resource nor_flash_resources[] = {
+        [0] = {
+                .name   = "NOR Flash",
+                .start  = 0x00000000,
+                .end    = 0x01ffffff,
+                .flags  = IORESOURCE_MEM,
+        }
+};
+
+static struct platform_device nor_flash_device = {
+        .name           = "physmap-flash",
+        .resource       = nor_flash_resources,
+        .num_resources  = ARRAY_SIZE(nor_flash_resources),
+        .dev            = {
+                .platform_data = &nor_flash_data,
+        },
+};
+
+/* LCDC */
+static struct sh_mobile_lcdc_info lcdc_info = {
+        .clock_source = LCDC_CLK_EXTERNAL,
+        .ch[0] = {
+                .chan = LCDC_CHAN_MAINLCD,
+                .bpp = 16,
+                .clock_divider = 1,
+                .lcd_cfg = {
+                        .name = "LB070WV1",
+                        .sync = 0, /* hsync and vsync are active low */
+                },
+                .lcd_size_cfg = { /* 7.0 inch */
+                        .width = 152,
+                        .height = 91,
+                },
+                .board_cfg = {
+                },
+        }
+};
+
+static struct resource lcdc_resources[] = {
+        [0] = {
+                .name   = "LCDC",
+                .start  = 0xfe940000,
+                .end    = 0xfe941fff,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 106,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device lcdc_device = {
+        .name           = "sh_mobile_lcdc_fb",
+        .num_resources  = ARRAY_SIZE(lcdc_resources),
+        .resource       = lcdc_resources,
+        .dev            = {
+                .platform_data  = &lcdc_info,
+        },
+};
+
+/* CEU0 */
+static struct sh_mobile_ceu_info sh_mobile_ceu0_info = {
+        .flags = SH_CEU_FLAG_USE_8BIT_BUS,
+};
+
+static struct resource ceu0_resources[] = {
+        [0] = {
+                .name   = "CEU0",
+                .start  = 0xfe910000,
+                .end    = 0xfe91009f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 52,
+                .flags  = IORESOURCE_IRQ,
+        },
+        [2] = {
+                /* place holder for contiguous memory */
+        },
+};
+
+static struct platform_device ceu0_device = {
+        .name           = "sh_mobile_ceu",
+        .id             = 0, /* "ceu0" clock */
+        .num_resources  = ARRAY_SIZE(ceu0_resources),
+        .resource       = ceu0_resources,
+        .dev    = {
+                .platform_data  = &sh_mobile_ceu0_info,
+        },
+};
+
+/* CEU1 */
+static struct sh_mobile_ceu_info sh_mobile_ceu1_info = {
+        .flags = SH_CEU_FLAG_USE_8BIT_BUS,
+};
+
+static struct resource ceu1_resources[] = {
+        [0] = {
+                .name   = "CEU1",
+                .start  = 0xfe914000,
+                .end    = 0xfe91409f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 63,
+                .flags  = IORESOURCE_IRQ,
+        },
+        [2] = {
+                /* place holder for contiguous memory */
+        },
+};
+
+static struct platform_device ceu1_device = {
+        .name           = "sh_mobile_ceu",
+        .id             = 1, /* "ceu1" clock */
+        .num_resources  = ARRAY_SIZE(ceu1_resources),
+        .resource       = ceu1_resources,
+        .dev    = {
+                .platform_data  = &sh_mobile_ceu1_info,
+        },
+};
+
+/* KEYSC */
+static struct sh_keysc_info keysc_info = {
+        .mode = SH_KEYSC_MODE_1,
+        .scan_timing = 10,
+        .delay = 50,
+        .keycodes = {
+                KEY_1, KEY_2, KEY_3, KEY_4, KEY_5,
+                KEY_6, KEY_7, KEY_8, KEY_9, KEY_A,
+                KEY_B, KEY_C, KEY_D, KEY_E, KEY_F,
+                KEY_G, KEY_H, KEY_I, KEY_K, KEY_L,
+                KEY_M, KEY_N, KEY_O, KEY_P, KEY_Q,
+                KEY_R, KEY_S, KEY_T, KEY_U, KEY_V,
+        },
+};
+
+static struct resource keysc_resources[] = {
+        [0] = {
+                .start  = 0x1a204000,
+                .end    = 0x1a20400f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = IRQ0_KEY,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device keysc_device = {
+        .name           = "sh_keysc",
+        .id             = 0, /* "keysc0" clock */
+        .num_resources  = ARRAY_SIZE(keysc_resources),
+        .resource       = keysc_resources,
+        .dev    = {
+                .platform_data  = &keysc_info,
+        },
+};
+
+static struct platform_device *ms7724se_devices[] __initdata = {
+        &heartbeat_device,
+        &smc91x_eth_device,
+        &lcdc_device,
+        &nor_flash_device,
+        &ceu0_device,
+        &ceu1_device,
+        &keysc_device,
+};
+
+#define SW4140    0xBA201000
+#define FPGA_OUT  0xBA200400
+#define PORT_HIZA 0xA4050158
+
+#define SW41_A    0x0100
+#define SW41_B    0x0200
+#define SW41_C    0x0400
+#define SW41_D    0x0800
+#define SW41_E    0x1000
+#define SW41_F    0x2000
+#define SW41_G    0x4000
+#define SW41_H    0x8000
+static int __init devices_setup(void)
+{
+        u16 sw = ctrl_inw(SW4140); /* select camera, monitor */
+
+        /* Reset Release */
+        ctrl_outw(ctrl_inw(FPGA_OUT) &
+                  ~((1 << 1)  | /* LAN */
+                    (1 << 6)  | /* VIDEO DAC */
+                    (1 << 12)), /* USB0 */
+                  FPGA_OUT);
+
+        /* enable IRQ 0,1,2 */
+        gpio_request(GPIO_FN_INTC_IRQ0, NULL);
+        gpio_request(GPIO_FN_INTC_IRQ1, NULL);
+        gpio_request(GPIO_FN_INTC_IRQ2, NULL);
+
+        /* enable SCIFA3 */
+        gpio_request(GPIO_FN_SCIF3_I_SCK, NULL);
+        gpio_request(GPIO_FN_SCIF3_I_RXD, NULL);
+        gpio_request(GPIO_FN_SCIF3_I_TXD, NULL);
+        gpio_request(GPIO_FN_SCIF3_I_CTS, NULL);
+        gpio_request(GPIO_FN_SCIF3_I_RTS, NULL);
+
+        /* enable LCDC */
+        gpio_request(GPIO_FN_LCDD23,   NULL);
+        gpio_request(GPIO_FN_LCDD22,   NULL);
+        gpio_request(GPIO_FN_LCDD21,   NULL);
+        gpio_request(GPIO_FN_LCDD20,   NULL);
+        gpio_request(GPIO_FN_LCDD19,   NULL);
+        gpio_request(GPIO_FN_LCDD18,   NULL);
+        gpio_request(GPIO_FN_LCDD17,   NULL);
+        gpio_request(GPIO_FN_LCDD16,   NULL);
+        gpio_request(GPIO_FN_LCDD15,   NULL);
+        gpio_request(GPIO_FN_LCDD14,   NULL);
+        gpio_request(GPIO_FN_LCDD13,   NULL);
+        gpio_request(GPIO_FN_LCDD12,   NULL);
+        gpio_request(GPIO_FN_LCDD11,   NULL);
+        gpio_request(GPIO_FN_LCDD10,   NULL);
+        gpio_request(GPIO_FN_LCDD9,    NULL);
+        gpio_request(GPIO_FN_LCDD8,    NULL);
+        gpio_request(GPIO_FN_LCDD7,    NULL);
+        gpio_request(GPIO_FN_LCDD6,    NULL);
+        gpio_request(GPIO_FN_LCDD5,    NULL);
+        gpio_request(GPIO_FN_LCDD4,    NULL);
+        gpio_request(GPIO_FN_LCDD3,    NULL);
+        gpio_request(GPIO_FN_LCDD2,    NULL);
+        gpio_request(GPIO_FN_LCDD1,    NULL);
+        gpio_request(GPIO_FN_LCDD0,    NULL);
+        gpio_request(GPIO_FN_LCDDISP,  NULL);
+        gpio_request(GPIO_FN_LCDHSYN,  NULL);
+        gpio_request(GPIO_FN_LCDDCK,   NULL);
+        gpio_request(GPIO_FN_LCDVSYN,  NULL);
+        gpio_request(GPIO_FN_LCDDON,   NULL);
+        gpio_request(GPIO_FN_LCDVEPWC, NULL);
+        gpio_request(GPIO_FN_LCDVCPWC, NULL);
+        gpio_request(GPIO_FN_LCDRD,    NULL);
+        gpio_request(GPIO_FN_LCDLCLK,  NULL);
+        ctrl_outw((ctrl_inw(PORT_HIZA) & ~0x0001), PORT_HIZA);
+
+        /* enable CEU0 */
+        gpio_request(GPIO_FN_VIO0_D15, NULL);
+        gpio_request(GPIO_FN_VIO0_D14, NULL);
+        gpio_request(GPIO_FN_VIO0_D13, NULL);
+        gpio_request(GPIO_FN_VIO0_D12, NULL);
+        gpio_request(GPIO_FN_VIO0_D11, NULL);
+        gpio_request(GPIO_FN_VIO0_D10, NULL);
+        gpio_request(GPIO_FN_VIO0_D9,  NULL);
+        gpio_request(GPIO_FN_VIO0_D8,  NULL);
+        gpio_request(GPIO_FN_VIO0_D7,  NULL);
+        gpio_request(GPIO_FN_VIO0_D6,  NULL);
+        gpio_request(GPIO_FN_VIO0_D5,  NULL);
+        gpio_request(GPIO_FN_VIO0_D4,  NULL);
+        gpio_request(GPIO_FN_VIO0_D3,  NULL);
+        gpio_request(GPIO_FN_VIO0_D2,  NULL);
+        gpio_request(GPIO_FN_VIO0_D1,  NULL);
+        gpio_request(GPIO_FN_VIO0_D0,  NULL);
+        gpio_request(GPIO_FN_VIO0_VD,  NULL);
+        gpio_request(GPIO_FN_VIO0_CLK, NULL);
+        gpio_request(GPIO_FN_VIO0_FLD, NULL);
+        gpio_request(GPIO_FN_VIO0_HD,  NULL);
+        platform_resource_setup_memory(&ceu0_device, "ceu", 4 << 20);
+
+        /* enable CEU1 */
+        gpio_request(GPIO_FN_VIO1_D7,  NULL);
+        gpio_request(GPIO_FN_VIO1_D6,  NULL);
+        gpio_request(GPIO_FN_VIO1_D5,  NULL);
+        gpio_request(GPIO_FN_VIO1_D4,  NULL);
+        gpio_request(GPIO_FN_VIO1_D3,  NULL);
+        gpio_request(GPIO_FN_VIO1_D2,  NULL);
+        gpio_request(GPIO_FN_VIO1_D1,  NULL);
+        gpio_request(GPIO_FN_VIO1_D0,  NULL);
+        gpio_request(GPIO_FN_VIO1_FLD, NULL);
+        gpio_request(GPIO_FN_VIO1_HD,  NULL);
+        gpio_request(GPIO_FN_VIO1_VD,  NULL);
+        gpio_request(GPIO_FN_VIO1_CLK, NULL);
+        platform_resource_setup_memory(&ceu1_device, "ceu", 4 << 20);
+
+        /* KEYSC */
+        gpio_request(GPIO_FN_KEYOUT5_IN5, NULL);
+        gpio_request(GPIO_FN_KEYOUT4_IN6, NULL);
+        gpio_request(GPIO_FN_KEYIN4,      NULL);
+        gpio_request(GPIO_FN_KEYIN3,      NULL);
+        gpio_request(GPIO_FN_KEYIN2,      NULL);
+        gpio_request(GPIO_FN_KEYIN1,      NULL);
+        gpio_request(GPIO_FN_KEYIN0,      NULL);
+        gpio_request(GPIO_FN_KEYOUT3,     NULL);
+        gpio_request(GPIO_FN_KEYOUT2,     NULL);
+        gpio_request(GPIO_FN_KEYOUT1,     NULL);
+        gpio_request(GPIO_FN_KEYOUT0,     NULL);
+
+        if (sw & SW41_B) {
+                /* SVGA */
+                lcdc_info.ch[0].lcd_cfg.xres         = 800;
+                lcdc_info.ch[0].lcd_cfg.yres         = 600;
+                lcdc_info.ch[0].lcd_cfg.left_margin  = 142;
+                lcdc_info.ch[0].lcd_cfg.right_margin = 52;
+                lcdc_info.ch[0].lcd_cfg.hsync_len    = 96;
+                lcdc_info.ch[0].lcd_cfg.upper_margin = 24;
+                lcdc_info.ch[0].lcd_cfg.lower_margin = 2;
+                lcdc_info.ch[0].lcd_cfg.vsync_len    = 2;
+        } else {
+                /* VGA */
+                lcdc_info.ch[0].lcd_cfg.xres         = 640;
+                lcdc_info.ch[0].lcd_cfg.yres         = 480;
+                lcdc_info.ch[0].lcd_cfg.left_margin  = 105;
+                lcdc_info.ch[0].lcd_cfg.right_margin = 50;
+                lcdc_info.ch[0].lcd_cfg.hsync_len    = 96;
+                lcdc_info.ch[0].lcd_cfg.upper_margin = 33;
+                lcdc_info.ch[0].lcd_cfg.lower_margin = 10;
+                lcdc_info.ch[0].lcd_cfg.vsync_len    = 2;
+        }
+
+        if (sw & SW41_A) {
+                /* Digital monitor */
+                lcdc_info.ch[0].interface_type = RGB18;
+                lcdc_info.ch[0].flags          = 0;
+        } else {
+                /* Analog monitor */
+                lcdc_info.ch[0].interface_type = RGB24;
+                lcdc_info.ch[0].flags          = LCDC_FLAGS_DWPOL;
+        }
+
+        return platform_add_devices(ms7724se_devices,
+                                ARRAY_SIZE(ms7724se_devices));
+}
+device_initcall(devices_setup);
+
+static struct sh_machine_vector mv_ms7724se __initmv = {
+        .mv_name        = "ms7724se",
+        .mv_init_irq    = init_se7724_IRQ,
+        .mv_nr_irqs     = SE7724_FPGA_IRQ_BASE + SE7724_FPGA_IRQ_NR,
+};
diff --git a/arch/sh/boards/mach-se/7751/Makefile b/arch/sh/boards/mach-se/7751/Makefile
index dbc29f3a9de5..e6f4341bfe6e 100644
--- a/arch/sh/boards/mach-se/7751/Makefile
+++ b/arch/sh/boards/mach-se/7751/Makefile
@@ -3,5 +3,3 @@
 #
 
 obj-y    := setup.o io.o irq.o
-
-obj-$(CONFIG_PCI) += pci.o
diff --git a/arch/sh/boards/mach-se/7751/io.c b/arch/sh/boards/mach-se/7751/io.c
index 6287ae570319..6e75bd4459e5 100644
--- a/arch/sh/boards/mach-se/7751/io.c
+++ b/arch/sh/boards/mach-se/7751/io.c
@@ -34,8 +34,6 @@ unsigned char sh7751se_inb(unsigned long port)
 {
         if (PXSEG(port))
                 return *(volatile unsigned char *)port;
-        else if (is_pci_ioaddr(port))
-                return *(volatile unsigned char *)pci_ioaddr(port);
         else
                 return (*port2adr(port)) & 0xff;
 }
@@ -46,8 +44,6 @@ unsigned char sh7751se_inb_p(unsigned long port)
 
         if (PXSEG(port))
                 v = *(volatile unsigned char *)port;
-        else if (is_pci_ioaddr(port))
-                v = *(volatile unsigned char *)pci_ioaddr(port);
         else
                 v = (*port2adr(port)) & 0xff;
         ctrl_delay();
@@ -58,8 +54,6 @@ unsigned short sh7751se_inw(unsigned long port)
 {
         if (PXSEG(port))
                 return *(volatile unsigned short *)port;
-        else if (is_pci_ioaddr(port))
-                return *(volatile unsigned short *)pci_ioaddr(port);
         else if (port >= 0x2000)
                 return *port2adr(port);
         else
@@ -71,8 +65,6 @@ unsigned int sh7751se_inl(unsigned long port)
 {
         if (PXSEG(port))
                 return *(volatile unsigned long *)port;
-        else if (is_pci_ioaddr(port))
-                return *(volatile unsigned int *)pci_ioaddr(port);
         else if (port >= 0x2000)
                 return *port2adr(port);
         else
@@ -85,8 +77,6 @@ void sh7751se_outb(unsigned char value, unsigned long port)
 
         if (PXSEG(port))
                 *(volatile unsigned char *)port = value;
-        else if (is_pci_ioaddr(port))
-                *((unsigned char*)pci_ioaddr(port)) = value;
         else
                 *(port2adr(port)) = value;
 }
@@ -95,8 +85,6 @@ void sh7751se_outb_p(unsigned char value, unsigned long port)
 {
         if (PXSEG(port))
                 *(volatile unsigned char *)port = value;
-        else if (is_pci_ioaddr(port))
-                *((unsigned char*)pci_ioaddr(port)) = value;
         else
                 *(port2adr(port)) = value;
         ctrl_delay();
@@ -106,8 +94,6 @@ void sh7751se_outw(unsigned short value, unsigned long port)
 {
         if (PXSEG(port))
                 *(volatile unsigned short *)port = value;
-        else if (is_pci_ioaddr(port))
-                *((unsigned short *)pci_ioaddr(port)) = value;
         else if (port >= 0x2000)
                 *port2adr(port) = value;
         else
@@ -118,8 +104,6 @@ void sh7751se_outl(unsigned int value, unsigned long port)
 {
         if (PXSEG(port))
                 *(volatile unsigned long *)port = value;
-        else if (is_pci_ioaddr(port))
-                *((unsigned long*)pci_ioaddr(port)) = value;
         else
                 maybebadio(port);
 }
diff --git a/arch/sh/boards/mach-se/7751/pci.c b/arch/sh/boards/mach-se/7751/pci.c
deleted file mode 100644
index 203b2923fe7f..000000000000
--- a/arch/sh/boards/mach-se/7751/pci.c
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
- * linux/arch/sh/boards/se/7751/pci.c
- *
- * Author:  Ian DaSilva (idasilva@mvista.com)
- *
- * Highly leveraged from pci-bigsur.c, written by Dustin McIntire.
- *
- * May be copied or modified under the terms of the GNU General Public
- * License.  See linux/COPYING for more information.
- *
- * PCI initialization for the Hitachi SH7751 Solution Engine board (MS7751SE01)
- */
-
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/pci.h>
-
-#include <asm/io.h>
-#include "../../../drivers/pci/pci-sh7751.h"
-
-#define PCIMCR_MRSET_OFF        0xBFFFFFFF
-#define PCIMCR_RFSH_OFF         0xFFFFFFFB
-
-/*
- * Only long word accesses of the PCIC's internal local registers and the
- * configuration registers from the CPU is supported.
- */
-#define PCIC_WRITE(x,v) writel((v), PCI_REG(x))
-#define PCIC_READ(x) readl(PCI_REG(x))
-
-/*
- * Description:  This function sets up and initializes the pcic, sets
- * up the BARS, maps the DRAM into the address space etc, etc.
- */
-int __init pcibios_init_platform(void)
-{
-   unsigned long bcr1, wcr1, wcr2, wcr3, mcr;
-   unsigned short bcr2;
-
-   /*
-    * Initialize the slave bus controller on the pcic.  The values used
-    * here should not be hardcoded, but they should be taken from the bsc
-    * on the processor, to make this function as generic as possible.
-    * (i.e. Another sbc may usr different SDRAM timing settings -- in order
-    * for the pcic to work, its settings need to be exactly the same.)
-    */
-   bcr1 = (*(volatile unsigned long*)(SH7751_BCR1));
-   bcr2 = (*(volatile unsigned short*)(SH7751_BCR2));
-   wcr1 = (*(volatile unsigned long*)(SH7751_WCR1));
-   wcr2 = (*(volatile unsigned long*)(SH7751_WCR2));
-   wcr3 = (*(volatile unsigned long*)(SH7751_WCR3));
-   mcr = (*(volatile unsigned long*)(SH7751_MCR));
-
-   bcr1 = bcr1 | 0x00080000;  /* Enable Bit 19, BREQEN */
-   (*(volatile unsigned long*)(SH7751_BCR1)) = bcr1;   
-
-   bcr1 = bcr1 | 0x40080000;  /* Enable Bit 19 BREQEN, set PCIC to slave */
-   PCIC_WRITE(SH7751_PCIBCR1, bcr1);     /* PCIC BCR1 */
-   PCIC_WRITE(SH7751_PCIBCR2, bcr2);     /* PCIC BCR2 */
-   PCIC_WRITE(SH7751_PCIWCR1, wcr1);     /* PCIC WCR1 */
-   PCIC_WRITE(SH7751_PCIWCR2, wcr2);     /* PCIC WCR2 */
-   PCIC_WRITE(SH7751_PCIWCR3, wcr3);     /* PCIC WCR3 */
-   mcr = (mcr & PCIMCR_MRSET_OFF) & PCIMCR_RFSH_OFF;
-   PCIC_WRITE(SH7751_PCIMCR, mcr);      /* PCIC MCR */
-
-
-   /* Enable all interrupts, so we know what to fix */
-   PCIC_WRITE(SH7751_PCIINTM, 0x0000c3ff);
-   PCIC_WRITE(SH7751_PCIAINTM, 0x0000380f);
-
-   /* Set up standard PCI config registers */
-   PCIC_WRITE(SH7751_PCICONF1,  0xF39000C7); /* Bus Master, Mem & I/O access */
-   PCIC_WRITE(SH7751_PCICONF2,  0x00000000); /* PCI Class code & Revision ID */
-   PCIC_WRITE(SH7751_PCICONF4,  0xab000001); /* PCI I/O address (local regs) */
-   PCIC_WRITE(SH7751_PCICONF5,  0x0c000000); /* PCI MEM address (local RAM)  */
-   PCIC_WRITE(SH7751_PCICONF6,  0xd0000000); /* PCI MEM address (unused)     */
-   PCIC_WRITE(SH7751_PCICONF11, 0x35051054); /* PCI Subsystem ID & Vendor ID */
-   PCIC_WRITE(SH7751_PCILSR0, 0x03f00000);   /* MEM (full 64M exposed)       */
-   PCIC_WRITE(SH7751_PCILSR1, 0x00000000);   /* MEM (unused)                 */
-   PCIC_WRITE(SH7751_PCILAR0, 0x0c000000);   /* MEM (direct map from PCI)    */
-   PCIC_WRITE(SH7751_PCILAR1, 0x00000000);   /* MEM (unused)                 */
-
-   /* Now turn it on... */
-   PCIC_WRITE(SH7751_PCICR, 0xa5000001);
-
-   /*
-    * Set PCIMBR and PCIIOBR here, assuming a single window
-    * (16M MEM, 256K IO) is enough.  If a larger space is
-    * needed, the readx/writex and inx/outx functions will
-    * have to do more (e.g. setting registers for each call).
-    */
-
-   /*
-    * Set the MBR so PCI address is one-to-one with window,
-    * meaning all calls go straight through... use BUG_ON to
-    * catch erroneous assumption.
-    */
-   BUG_ON(PCIBIOS_MIN_MEM != SH7751_PCI_MEMORY_BASE);
-
-   PCIC_WRITE(SH7751_PCIMBR, PCIBIOS_MIN_MEM);
-
-   /* Set IOBR for window containing area specified in pci.h */
-   PCIC_WRITE(SH7751_PCIIOBR, (PCIBIOS_MIN_IO & SH7751_PCIIOBR_MASK));
-
-   /* All done, may as well say so... */
-   printk("SH7751 PCI: Finished initialization of the PCI controller\n");
-
-   return 1;
-}
-
-int __init pcibios_map_platform_irq(u8 slot, u8 pin)
-{
-        switch (slot) {
-        case 0: return 13;
-        case 1: return 13;      /* AMD Ethernet controller */
-        case 2: return -1;
-        case 3: return -1;
-        case 4: return -1;
-        default:
-                printk("PCI: Bad IRQ mapping request for slot %d\n", slot);
-                return -1;
-        }
-}
-
-static struct resource sh7751_io_resource = {
-        .name   = "SH7751 IO",
-        .start  = SH7751_PCI_IO_BASE,
-        .end    = SH7751_PCI_IO_BASE + SH7751_PCI_IO_SIZE - 1,
-        .flags  = IORESOURCE_IO
-};
-
-static struct resource sh7751_mem_resource = {
-        .name   = "SH7751 mem",
-        .start  = SH7751_PCI_MEMORY_BASE,
-        .end    = SH7751_PCI_MEMORY_BASE + SH7751_PCI_MEM_SIZE - 1,
-        .flags  = IORESOURCE_MEM
-};
-
-extern struct pci_ops sh7751_pci_ops;
-
-struct pci_channel board_pci_channels[] = {
-        { &sh7751_pci_ops, &sh7751_io_resource, &sh7751_mem_resource, 0, 0xff },
-        { NULL, NULL, NULL, 0, 0 },
-};
-
diff --git a/arch/sh/boards/mach-se/7780/irq.c b/arch/sh/boards/mach-se/7780/irq.c
index 66ad292c9fc3..b8d43b638fcf 100644
--- a/arch/sh/boards/mach-se/7780/irq.c
+++ b/arch/sh/boards/mach-se/7780/irq.c
@@ -12,10 +12,13 @@
 #include <linux/init.h>
 #include <linux/irq.h>
 #include <linux/interrupt.h>
-#include <asm/irq.h>
-#include <asm/io.h>
+#include <linux/irq.h>
+#include <linux/io.h>
 #include <mach-se/mach/se7780.h>
 
+#define INTC_BASE       0xffd00000
+#define INTC_ICR1       (INTC_BASE+0x1c)
+
 /*
  * Initialize IRQ setting
  */
@@ -43,4 +46,24 @@ void __init init_se7780_IRQ(void)
         ctrl_outw((IRQPIN_PCCPW << IRQPOS_PCCPW), FPGA_INTSEL3);
 
         plat_irq_setup_pins(IRQ_MODE_IRQ); /* install handlers for IRQ0-7 */
+
+        /* ICR1: detect low level(for 2ndcut) */
+        ctrl_outl(0xAAAA0000, INTC_ICR1);
+
+        /*
+         * FPGA PCISEL register initialize
+         *
+         *  CPU  || SLOT1 | SLOT2 | S-ATA | USB
+         *  -------------------------------------
+         *  INTA || INTA  | INTD  |  --   | INTB
+         *  -------------------------------------
+         *  INTB || INTB  | INTA  |  --   | INTC
+         *  -------------------------------------
+         *  INTC || INTC  | INTB  | INTA  |  --
+         *  -------------------------------------
+         *  INTD || INTD  | INTC  |  --   | INTA
+         *  -------------------------------------
+         */
+        ctrl_outw(0x0013, FPGA_PCI_INTSEL1);
+        ctrl_outw(0xE402, FPGA_PCI_INTSEL2);
 }
diff --git a/arch/sh/boards/mach-se/Makefile b/arch/sh/boards/mach-se/Makefile
index 2de42bae4b4f..b537e238c6bc 100644
--- a/arch/sh/boards/mach-se/Makefile
+++ b/arch/sh/boards/mach-se/Makefile
@@ -7,3 +7,4 @@ obj-$(CONFIG_SH_7751_SOLUTION_ENGINE)	+= 7751/
 obj-$(CONFIG_SH_7780_SOLUTION_ENGINE)   += 7780/
 obj-$(CONFIG_SH_7343_SOLUTION_ENGINE)   += 7343/
 obj-$(CONFIG_SH_7721_SOLUTION_ENGINE)   += 7721/
+obj-$(CONFIG_SH_7724_SOLUTION_ENGINE)   += 7724/
diff --git a/arch/sh/boards/mach-sh03/rtc.c b/arch/sh/boards/mach-sh03/rtc.c
index 0a9266bb51c5..a8b9f844ab5b 100644
--- a/arch/sh/boards/mach-sh03/rtc.c
+++ b/arch/sh/boards/mach-sh03/rtc.c
@@ -35,13 +35,13 @@
 #define RTC_BUSY        1
 #define RTC_STOP        2
 
-extern spinlock_t rtc_lock;
+static DEFINE_SPINLOCK(sh03_rtc_lock);
 
 unsigned long get_cmos_time(void)
 {
         unsigned int year, mon, day, hour, min, sec;
 
-        spin_lock(&rtc_lock);
+        spin_lock(&sh03_rtc_lock);
  again:
         do {
                 sec  = (ctrl_inb(RTC_SEC1) & 0xf) + (ctrl_inb(RTC_SEC10) & 0x7) * 10;
@@ -73,7 +73,7 @@ unsigned long get_cmos_time(void)
                 goto again;
         }
 
-        spin_unlock(&rtc_lock);
+        spin_unlock(&sh03_rtc_lock);
         return mktime(year, mon, day, hour, min, sec);
 }
 
@@ -91,7 +91,7 @@ static int set_rtc_mmss(unsigned long nowtime)
         int i;
 
         /* gets recalled with irq locally disabled */
-        spin_lock(&rtc_lock);
+        spin_lock(&sh03_rtc_lock);
         for (i = 0 ; i < 1000000 ; i++) /* may take up to 1 second... */
                 if (!(ctrl_inb(RTC_CTL) & RTC_BUSY))
                         break;
@@ -113,7 +113,7 @@ static int set_rtc_mmss(unsigned long nowtime)
                        cmos_minutes, real_minutes);
                 retval = -1;
         }
-        spin_unlock(&rtc_lock);
+        spin_unlock(&sh03_rtc_lock);
 
         return retval;
 }
diff --git a/arch/sh/boards/mach-snapgear/io.c b/arch/sh/boards/mach-snapgear/io.c
index 0f4824264557..476650e42dbc 100644
--- a/arch/sh/boards/mach-snapgear/io.c
+++ b/arch/sh/boards/mach-snapgear/io.c
@@ -36,8 +36,6 @@ unsigned char snapgear_inb(unsigned long port)
 {
         if (PXSEG(port))
                 return *(volatile unsigned char *)port;
-        else if (is_pci_ioaddr(port))
-                return *(volatile unsigned char *)pci_ioaddr(port);
         else
                 return (*port2adr(port)) & 0xff;
 }
@@ -48,8 +46,6 @@ unsigned char snapgear_inb_p(unsigned long port)
 
         if (PXSEG(port))
                 v = *(volatile unsigned char *)port;
-        else if (is_pci_ioaddr(port))
-                v = *(volatile unsigned char *)pci_ioaddr(port);
         else
                 v = (*port2adr(port))&0xff;
         ctrl_delay();
@@ -60,8 +56,6 @@ unsigned short snapgear_inw(unsigned long port)
 {
         if (PXSEG(port))
                 return *(volatile unsigned short *)port;
-        else if (is_pci_ioaddr(port))
-                return *(volatile unsigned short *)pci_ioaddr(port);
         else if (port >= 0x2000)
                 return *port2adr(port);
         else
@@ -73,8 +67,6 @@ unsigned int snapgear_inl(unsigned long port)
 {
         if (PXSEG(port))
                 return *(volatile unsigned long *)port;
-        else if (is_pci_ioaddr(port))
-                return *(volatile unsigned int *)pci_ioaddr(port);
         else if (port >= 0x2000)
                 return *port2adr(port);
         else
@@ -87,8 +79,6 @@ void snapgear_outb(unsigned char value, unsigned long port)
 
         if (PXSEG(port))
                 *(volatile unsigned char *)port = value;
-        else if (is_pci_ioaddr(port))
-                *((unsigned char*)pci_ioaddr(port)) = value;
         else
                 *(port2adr(port)) = value;
 }
@@ -97,8 +87,6 @@ void snapgear_outb_p(unsigned char value, unsigned long port)
 {
         if (PXSEG(port))
                 *(volatile unsigned char *)port = value;
-        else if (is_pci_ioaddr(port))
-                *((unsigned char*)pci_ioaddr(port)) = value;
         else
                 *(port2adr(port)) = value;
         ctrl_delay();
@@ -108,8 +96,6 @@ void snapgear_outw(unsigned short value, unsigned long port)
 {
         if (PXSEG(port))
                 *(volatile unsigned short *)port = value;
-        else if (is_pci_ioaddr(port))
-                *((unsigned short *)pci_ioaddr(port)) = value;
         else if (port >= 0x2000)
                 *port2adr(port) = value;
         else
@@ -120,8 +106,6 @@ void snapgear_outl(unsigned int value, unsigned long port)
 {
         if (PXSEG(port))
                 *(volatile unsigned long *)port = value;
-        else if (is_pci_ioaddr(port))
-                *((unsigned long*)pci_ioaddr(port)) = value;
         else
                 maybebadio(port);
 }
diff --git a/arch/sh/boards/mach-systemh/io.c b/arch/sh/boards/mach-systemh/io.c
index dec3db0ee933..15577ff1f715 100644
--- a/arch/sh/boards/mach-systemh/io.c
+++ b/arch/sh/boards/mach-systemh/io.c
@@ -35,8 +35,6 @@ unsigned char sh7751systemh_inb(unsigned long port)
 {
         if (PXSEG(port))
                 return *(volatile unsigned char *)port;
-        else if (is_pci_ioaddr(port))
-                return *(volatile unsigned char *)pci_ioaddr(port);
         else if (port <= 0x3F1)
                 return *(volatile unsigned char *)ETHER_IOMAP(port);
         else
@@ -49,8 +47,6 @@ unsigned char sh7751systemh_inb_p(unsigned long port)
 
         if (PXSEG(port))
                 v = *(volatile unsigned char *)port;
-        else if (is_pci_ioaddr(port))
-                v = *(volatile unsigned char *)pci_ioaddr(port);
         else if (port <= 0x3F1)
                 v = *(volatile unsigned char *)ETHER_IOMAP(port);
         else
@@ -63,8 +59,6 @@ unsigned short sh7751systemh_inw(unsigned long port)
 {
         if (PXSEG(port))
                 return *(volatile unsigned short *)port;
-        else if (is_pci_ioaddr(port))
-                return *(volatile unsigned short *)pci_ioaddr(port);
         else if (port >= 0x2000)
                 return *port2adr(port);
         else if (port <= 0x3F1)
@@ -78,8 +72,6 @@ unsigned int sh7751systemh_inl(unsigned long port)
 {
         if (PXSEG(port))
                 return *(volatile unsigned long *)port;
-        else if (is_pci_ioaddr(port))
-                return *(volatile unsigned int *)pci_ioaddr(port);
         else if (port >= 0x2000)
                 return *port2adr(port);
         else if (port <= 0x3F1)
@@ -94,8 +86,6 @@ void sh7751systemh_outb(unsigned char value, unsigned long port)
 
         if (PXSEG(port))
                 *(volatile unsigned char *)port = value;
-        else if (is_pci_ioaddr(port))
-                *((unsigned char*)pci_ioaddr(port)) = value;
         else if (port <= 0x3F1)
                 *(volatile unsigned char *)ETHER_IOMAP(port) = value;
         else
@@ -106,8 +96,6 @@ void sh7751systemh_outb_p(unsigned char value, unsigned long port)
 {
         if (PXSEG(port))
                 *(volatile unsigned char *)port = value;
-        else if (is_pci_ioaddr(port))
-                *((unsigned char*)pci_ioaddr(port)) = value;
         else if (port <= 0x3F1)
                 *(volatile unsigned char *)ETHER_IOMAP(port) = value;
         else
@@ -119,8 +107,6 @@ void sh7751systemh_outw(unsigned short value, unsigned long port)
 {
         if (PXSEG(port))
                 *(volatile unsigned short *)port = value;
-        else if (is_pci_ioaddr(port))
-                *((unsigned short *)pci_ioaddr(port)) = value;
         else if (port >= 0x2000)
                 *port2adr(port) = value;
         else if (port <= 0x3F1)
@@ -133,8 +119,6 @@ void sh7751systemh_outl(unsigned int value, unsigned long port)
 {
         if (PXSEG(port))
                 *(volatile unsigned long *)port = value;
-        else if (is_pci_ioaddr(port))
-                *((unsigned long*)pci_ioaddr(port)) = value;
         else
                 maybebadio(port);
 }
diff --git a/arch/sh/boards/mach-titan/io.c b/arch/sh/boards/mach-titan/io.c
index 4badad4c6f30..0130e9826aca 100644
--- a/arch/sh/boards/mach-titan/io.c
+++ b/arch/sh/boards/mach-titan/io.c
@@ -17,8 +17,6 @@ u8 titan_inb(unsigned long port)
 {
         if (PXSEG(port))
                 return ctrl_inb(port);
-        else if (is_pci_ioaddr(port))
-                return ctrl_inb(pci_ioaddr(port));
         return ctrl_inw(port2adr(port)) & 0xff;
 }
 
@@ -28,8 +26,6 @@ u8 titan_inb_p(unsigned long port)
 
         if (PXSEG(port))
                 v = ctrl_inb(port);
-        else if (is_pci_ioaddr(port))
-                v = ctrl_inb(pci_ioaddr(port));
         else
                 v = ctrl_inw(port2adr(port)) & 0xff;
         ctrl_delay();
@@ -40,8 +36,6 @@ u16 titan_inw(unsigned long port)
 {
         if (PXSEG(port))
                 return ctrl_inw(port);
-        else if (is_pci_ioaddr(port))
-                return ctrl_inw(pci_ioaddr(port));
         else if (port >= 0x2000)
                 return ctrl_inw(port2adr(port));
         else
@@ -53,8 +47,6 @@ u32 titan_inl(unsigned long port)
 {
         if (PXSEG(port))
                 return ctrl_inl(port);
-        else if (is_pci_ioaddr(port))
-                return ctrl_inl(pci_ioaddr(port));
         else if (port >= 0x2000)
                 return ctrl_inw(port2adr(port));
         else
@@ -66,8 +58,6 @@ void titan_outb(u8 value, unsigned long port)
 {
         if (PXSEG(port))
                 ctrl_outb(value, port);
-        else if (is_pci_ioaddr(port))
-                ctrl_outb(value, pci_ioaddr(port));
         else
                 ctrl_outw(value, port2adr(port));
 }
@@ -76,8 +66,6 @@ void titan_outb_p(u8 value, unsigned long port)
 {
         if (PXSEG(port))
                 ctrl_outb(value, port);
-        else if (is_pci_ioaddr(port))
-                ctrl_outb(value, pci_ioaddr(port));
         else
                 ctrl_outw(value, port2adr(port));
         ctrl_delay();
@@ -87,8 +75,6 @@ void titan_outw(u16 value, unsigned long port)
 {
         if (PXSEG(port))
                 ctrl_outw(value, port);
-        else if (is_pci_ioaddr(port))
-                ctrl_outw(value, pci_ioaddr(port));
         else if (port >= 0x2000)
                 ctrl_outw(value, port2adr(port));
         else
@@ -99,8 +85,6 @@ void titan_outl(u32 value, unsigned long port)
 {
         if (PXSEG(port))
                 ctrl_outl(value, port);
-        else if (is_pci_ioaddr(port))
-                ctrl_outl(value, pci_ioaddr(port));
         else
                 maybebadio(port);
 }
@@ -117,10 +101,8 @@ void titan_outsl(unsigned long port, const void *src, unsigned long count)
 
 void __iomem *titan_ioport_map(unsigned long port, unsigned int size)
 {
-        if (PXSEG(port) || is_pci_memaddr(port))
+        if (PXSEG(port))
                 return (void __iomem *)port;
-        else if (is_pci_ioaddr(port))
-                return (void __iomem *)pci_ioaddr(port);
 
         return (void __iomem *)port2adr(port);
 }
diff --git a/arch/sh/boot/Makefile b/arch/sh/boot/Makefile
index 95483d161258..78efb04c28f3 100644
--- a/arch/sh/boot/Makefile
+++ b/arch/sh/boot/Makefile
@@ -20,9 +20,6 @@ CONFIG_BOOT_LINK_OFFSET	?= 0x00800000
 CONFIG_ZERO_PAGE_OFFSET ?= 0x00001000
 CONFIG_ENTRY_OFFSET     ?= 0x00001000
 
-export CONFIG_PAGE_OFFSET CONFIG_MEMORY_START CONFIG_BOOT_LINK_OFFSET \
-       CONFIG_ZERO_PAGE_OFFSET CONFIG_ENTRY_OFFSET
-
 targets := zImage vmlinux.srec uImage uImage.srec
 subdir- := compressed
 
@@ -43,6 +40,9 @@ KERNEL_MEMORY := $(shell /bin/bash -c 'printf "0x%08x" \
                      $$[$(CONFIG_MEMORY_START)]')
 endif
 
+export CONFIG_PAGE_OFFSET CONFIG_MEMORY_START CONFIG_BOOT_LINK_OFFSET \
+       CONFIG_ZERO_PAGE_OFFSET CONFIG_ENTRY_OFFSET KERNEL_MEMORY
+
 KERNEL_LOAD     := $(shell /bin/bash -c 'printf "0x%08x" \
                      $$[$(CONFIG_PAGE_OFFSET)  + \
                         $(KERNEL_MEMORY) + \
diff --git a/arch/sh/boot/compressed/Makefile b/arch/sh/boot/compressed/Makefile
index efb01dc3c8c3..9531bf1b7c2f 100644
--- a/arch/sh/boot/compressed/Makefile
+++ b/arch/sh/boot/compressed/Makefile
@@ -1,5 +1,47 @@
-ifeq ($(CONFIG_SUPERH32),y)
-include ${srctree}/arch/sh/boot/compressed/Makefile_32
-else
-include ${srctree}/arch/sh/boot/compressed/Makefile_64
+#
+# linux/arch/sh/boot/compressed/Makefile
+#
+# create a compressed vmlinux image from the original vmlinux
+#
+
+targets         := vmlinux vmlinux.bin vmlinux.bin.gz \
+                   head_$(BITS).o misc_$(BITS).o piggy.o
+
+OBJECTS = $(obj)/head_$(BITS).o $(obj)/misc_$(BITS).o $(obj)/cache.o
+
+ifdef CONFIG_SH_STANDARD_BIOS
+OBJECTS += $(obj)/../../kernel/sh_bios.o
 endif
+
+#
+# IMAGE_OFFSET is the load offset of the compression loader
+#
+IMAGE_OFFSET    := $(shell /bin/bash -c 'printf "0x%08x" \
+                     $$[$(CONFIG_PAGE_OFFSET)  + \
+                        $(KERNEL_MEMORY) + \
+                        $(CONFIG_BOOT_LINK_OFFSET)]')
+
+LIBGCC  := $(shell $(CC) $(KBUILD_CFLAGS) -print-libgcc-file-name)
+
+ifeq ($(CONFIG_FUNCTION_TRACER),y)
+ORIG_CFLAGS := $(KBUILD_CFLAGS)
+KBUILD_CFLAGS = $(subst -pg, , $(ORIG_CFLAGS))
+endif
+
+LDFLAGS_vmlinux := --oformat $(ld-bfd) -Ttext $(IMAGE_OFFSET) -e startup \
+                   -T $(obj)/../../kernel/vmlinux.lds
+
+$(obj)/vmlinux: $(OBJECTS) $(obj)/piggy.o $(LIBGCC) FORCE
+        $(call if_changed,ld)
+        @:
+
+$(obj)/vmlinux.bin: vmlinux FORCE
+        $(call if_changed,objcopy)
+
+$(obj)/vmlinux.bin.gz: $(obj)/vmlinux.bin FORCE
+        $(call if_changed,gzip)
+
+OBJCOPYFLAGS += -R .empty_zero_page
+
+$(obj)/piggy.o: $(obj)/piggy.S $(obj)/vmlinux.bin.gz FORCE
+        $(call if_changed,as_o_S)
diff --git a/arch/sh/boot/compressed/Makefile_32 b/arch/sh/boot/compressed/Makefile_32
deleted file mode 100644
index b96a055b053e..000000000000
--- a/arch/sh/boot/compressed/Makefile_32
+++ /dev/null
@@ -1,46 +0,0 @@
-#
-# linux/arch/sh/boot/compressed/Makefile
-#
-# create a compressed vmlinux image from the original vmlinux
-#
-
-targets         := vmlinux vmlinux.bin vmlinux.bin.gz \
-                   head_32.o misc_32.o piggy.o
-
-OBJECTS = $(obj)/head_32.o $(obj)/misc_32.o
-
-ifdef CONFIG_SH_STANDARD_BIOS
-OBJECTS += $(obj)/../../kernel/sh_bios.o
-endif
-
-#
-# IMAGE_OFFSET is the load offset of the compression loader
-#
-IMAGE_OFFSET    := $(shell /bin/bash -c 'printf "0x%08x" \
-                     $$[$(CONFIG_PAGE_OFFSET)  + \
-                        $(CONFIG_MEMORY_START) + \
-                        $(CONFIG_BOOT_LINK_OFFSET)]')
-
-LIBGCC  := $(shell $(CC) $(KBUILD_CFLAGS) -print-libgcc-file-name)
-
-ifeq ($(CONFIG_FUNCTION_TRACER),y)
-ORIG_CFLAGS := $(KBUILD_CFLAGS)
-KBUILD_CFLAGS = $(subst -pg, , $(ORIG_CFLAGS))
-endif
-
-LDFLAGS_vmlinux := -Ttext $(IMAGE_OFFSET) -e startup -T $(obj)/../../kernel/vmlinux.lds
-
-$(obj)/vmlinux: $(OBJECTS) $(obj)/piggy.o $(LIBGCC) FORCE
-        $(call if_changed,ld)
-        @:
-
-$(obj)/vmlinux.bin: vmlinux FORCE
-        $(call if_changed,objcopy)
-
-$(obj)/vmlinux.bin.gz: $(obj)/vmlinux.bin FORCE
-        $(call if_changed,gzip)
-
-OBJCOPYFLAGS += -R .empty_zero_page
-
-$(obj)/piggy.o: $(obj)/piggy.S $(obj)/vmlinux.bin.gz FORCE
-        $(call if_changed,as_o_S)
diff --git a/arch/sh/boot/compressed/Makefile_64 b/arch/sh/boot/compressed/Makefile_64
deleted file mode 100644
index 658d4f915556..000000000000
--- a/arch/sh/boot/compressed/Makefile_64
+++ /dev/null
@@ -1,43 +0,0 @@
-#
-# arch/sh/boot/compressed/Makefile_64
-#
-# create a compressed vmlinux image from the original vmlinux
-#
-# Copyright (C) 2002 Stuart Menefy
-# Copyright (C) 2004 Paul Mundt
-#
-# 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.
-#
-
-targets         := vmlinux vmlinux.bin vmlinux.bin.gz \
-                   head_64.o misc_64.o cache.o piggy.o
-
-OBJECTS         := $(obj)/vmlinux_64.lds $(obj)/head_64.o $(obj)/misc_64.o \
-                   $(obj)/cache.o
-
-#
-# ZIMAGE_OFFSET is the load offset of the compression loader
-# (4M for the kernel plus 64K for this loader)
-#
-ZIMAGE_OFFSET   := $(shell /bin/bash -c 'printf "0x%08x" \
-                     $$[$(CONFIG_PAGE_OFFSET)+0x400000+0x10000]')
-
-LDFLAGS_vmlinux := -Ttext $(ZIMAGE_OFFSET) -e startup \
-                    -T $(obj)/../../kernel/vmlinux.lds
-
-$(obj)/vmlinux: $(OBJECTS) $(obj)/piggy.o FORCE
-        $(call if_changed,ld)
-        @:
-
-$(obj)/vmlinux.bin: vmlinux FORCE
-        $(call if_changed,objcopy)
-
-$(obj)/vmlinux.bin.gz: $(obj)/vmlinux.bin FORCE
-        $(call if_changed,gzip)
-
-OBJCOPYFLAGS += -R .empty_zero_page
-
-$(obj)/piggy.o: $(obj)/piggy.S $(obj)/vmlinux.bin.gz FORCE
-        $(call if_changed,as_o_S)
diff --git a/arch/sh/boot/compressed/head_64.S b/arch/sh/boot/compressed/head_64.S
index 622eac3cf556..9993113c6713 100644
--- a/arch/sh/boot/compressed/head_64.S
+++ b/arch/sh/boot/compressed/head_64.S
@@ -14,6 +14,7 @@
  *   Copyright (C) 2002 Stuart Menefy (stuart.menefy@st.com)
  */
 #include <asm/cache.h>
+#include <asm/tlb.h>
 #include <cpu/mmu_context.h>
 #include <cpu/registers.h>
 
@@ -33,11 +34,7 @@
 #define ICCR0_INIT_VAL  ICCR0_ON | ICCR0_ICI            /* ICE + ICI */
 #define ICCR1_INIT_VAL  ICCR1_NOLOCK                    /* No locking */
 
-#if 1
 #define OCCR0_INIT_VAL  OCCR0_ON | OCCR0_OCI | OCCR0_WB /* OCE + OCI + WB */
-#else
-#define OCCR0_INIT_VAL  OCCR0_OFF
-#endif
 #define OCCR1_INIT_VAL  OCCR1_NOLOCK                    /* No locking */
 
         .text
diff --git a/arch/sh/boot/compressed/vmlinux_64.lds b/arch/sh/boot/compressed/vmlinux_64.lds
deleted file mode 100644
index 59c2ef4aeda5..000000000000
--- a/arch/sh/boot/compressed/vmlinux_64.lds
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * ld script to make compressed SuperH/shmedia Linux kernel+decompression
- *              bootstrap
- * Modified by Stuart Menefy from arch/sh/vmlinux.lds.S written by Niibe Yutaka
- */
-
-
-#ifdef CONFIG_LITTLE_ENDIAN
-/* OUTPUT_FORMAT("elf32-sh64l-linux", "elf32-sh64l-linux", "elf32-sh64l-linux") */
-#define NOP 0x6ff0fff0
-#else
-/* OUTPUT_FORMAT("elf32-sh64", "elf32-sh64", "elf32-sh64") */
-#define NOP 0xf0fff06f
-#endif
-
-OUTPUT_FORMAT("elf32-sh64-linux")
-OUTPUT_ARCH(sh)
-ENTRY(_start)
-
-#define ALIGNED_GAP(section, align) (((ADDR(section)+SIZEOF(section)+(align)-1) & ~((align)-1))-ADDR(section))
-#define FOLLOWING(section, align) AT (LOADADDR(section) + ALIGNED_GAP(section,align))
-
-SECTIONS
-{
-  _text = .;                    /* Text and read-only data */
-
-  .text : {
-        *(.text)
-        *(.text64)
-        *(.text..SHmedia32)
-        *(.fixup)
-        *(.gnu.warning)
-        } = NOP
-  . = ALIGN(4);
-  .rodata : { *(.rodata) }
-
-  /* There is no 'real' reason for eight byte alignment, four would work
-   * as well, but gdb downloads much (*4) faster with this.
-   */
-  . = ALIGN(8);
-  .image : { *(.image) }
-  . = ALIGN(4);
-  _etext = .;                   /* End of text section */
-
-  .data :                       /* Data */
-        FOLLOWING(.image, 4)
-        {
-        _data = .;
-        *(.data)
-        }
-  _data_image = LOADADDR(.data);/* Address of data section in ROM */
-
-  _edata = .;                   /* End of data section */
-
-  .stack : { stack = .;  _stack = .; }
-
-  . = ALIGN(4);
-  __bss_start = .;              /* BSS */
-  .bss : {
-        *(.bss)
-        }
-  . = ALIGN(4);
-  _end = . ;
-}
diff --git a/arch/sh/cchips/Kconfig b/arch/sh/cchips/Kconfig
index f43d18373f22..a5ab2eccdaa6 100644
--- a/arch/sh/cchips/Kconfig
+++ b/arch/sh/cchips/Kconfig
@@ -34,11 +34,6 @@ config HD64461_IRQ
 
           Do not change this unless you know what you are doing.
 
-config HD64461_IOBASE
-        hex "HD64461 start address"
-        depends on HD64461
-        default "0xb0000000"
-
 config HD64461_ENABLER
         bool "HD64461 PCMCIA enabler"
         depends on HD64461
diff --git a/arch/sh/cchips/hd6446x/hd64461.c b/arch/sh/cchips/hd6446x/hd64461.c
index 25ef91061521..50aa0c1f76ea 100644
--- a/arch/sh/cchips/hd6446x/hd64461.c
+++ b/arch/sh/cchips/hd6446x/hd64461.c
@@ -80,7 +80,7 @@ int __init setup_hd64461(void)
 
         printk(KERN_INFO
                "HD64461 configured at 0x%x on irq %d(mapped into %d to %d)\n",
-               CONFIG_HD64461_IOBASE, CONFIG_HD64461_IRQ, HD64461_IRQBASE,
+               HD64461_IOBASE, CONFIG_HD64461_IRQ, HD64461_IRQBASE,
                HD64461_IRQBASE + 15);
 
 /* Should be at processor specific part.. */
diff --git a/arch/sh/configs/ap325rxa_defconfig b/arch/sh/configs/ap325rxa_defconfig
index c8d982a8a2e6..022f70e0ea03 100644
--- a/arch/sh/configs/ap325rxa_defconfig
+++ b/arch/sh/configs/ap325rxa_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 17:46:53 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:42:06 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -74,6 +75,7 @@ CONFIG_EMBEDDED=y
 CONFIG_UID16=y
 CONFIG_SYSCTL_SYSCALL=y
 # CONFIG_KALLSYMS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -92,12 +94,15 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 CONFIG_HAVE_IOREMAP_PROT=y
 CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -110,7 +115,6 @@ CONFIG_MODULE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -159,6 +163,7 @@ CONFIG_ARCH_SHMOBILE=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 CONFIG_CPU_SUBTYPE_SH7723=y
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -168,8 +173,6 @@ CONFIG_CPU_SUBTYPE_SH7723=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -573,6 +576,7 @@ CONFIG_SCSI_WAIT_SCAN=m
 CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_ISCSI_TCP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_SCSI_DEBUG is not set
 # CONFIG_SCSI_DH is not set
 # CONFIG_SCSI_OSD_INITIATOR is not set
@@ -695,6 +699,7 @@ CONFIG_DEVKMEM=y
 #
 # Non-8250 serial port support
 #
+# CONFIG_SERIAL_MAX3100 is not set
 CONFIG_SERIAL_SH_SCI=y
 CONFIG_SERIAL_SH_SCI_NR_UARTS=6
 CONFIG_SERIAL_SH_SCI_CONSOLE=y
@@ -1030,6 +1035,7 @@ CONFIG_EXT2_FS_POSIX_ACL=y
 CONFIG_EXT2_FS_SECURITY=y
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 CONFIG_EXT3_FS_POSIX_ACL=y
 CONFIG_EXT3_FS_SECURITY=y
@@ -1052,6 +1058,11 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -1100,6 +1111,7 @@ CONFIG_MISC_FILESYSTEMS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
@@ -1191,10 +1203,24 @@ CONFIG_SYSCTL_SYSCALL_CHECK=y
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_PREEMPT_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -1303,6 +1329,7 @@ CONFIG_CRYPTO_CBC=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/cayman_defconfig b/arch/sh/configs/cayman_defconfig
index fa5fc1e1e980..40301f86a45c 100644
--- a/arch/sh/configs/cayman_defconfig
+++ b/arch/sh/configs/cayman_defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 17:49:14 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:42:53 2009
 #
 CONFIG_SUPERH=y
 # CONFIG_SUPERH32 is not set
@@ -40,6 +40,7 @@ CONFIG_LOCALVERSION_AUTO=y
 CONFIG_SWAP=y
 # CONFIG_SYSVIPC is not set
 CONFIG_POSIX_MQUEUE=y
+CONFIG_POSIX_MQUEUE_SYSCTL=y
 # CONFIG_BSD_PROCESS_ACCT is not set
 # CONFIG_TASKSTATS is not set
 # CONFIG_AUDIT is not set
@@ -70,6 +71,7 @@ CONFIG_SYSCTL_SYSCALL=y
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_ALL is not set
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -89,10 +91,13 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 CONFIG_HAVE_IOREMAP_PROT=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -105,7 +110,6 @@ CONFIG_MODULE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -127,39 +131,6 @@ CONFIG_DEFAULT_IOSCHED="cfq"
 # System type
 #
 CONFIG_CPU_SH5=y
-# CONFIG_CPU_SUBTYPE_SH7619 is not set
-# CONFIG_CPU_SUBTYPE_SH7201 is not set
-# CONFIG_CPU_SUBTYPE_SH7203 is not set
-# CONFIG_CPU_SUBTYPE_SH7206 is not set
-# CONFIG_CPU_SUBTYPE_SH7263 is not set
-# CONFIG_CPU_SUBTYPE_MXG is not set
-# CONFIG_CPU_SUBTYPE_SH7705 is not set
-# CONFIG_CPU_SUBTYPE_SH7706 is not set
-# CONFIG_CPU_SUBTYPE_SH7707 is not set
-# CONFIG_CPU_SUBTYPE_SH7708 is not set
-# CONFIG_CPU_SUBTYPE_SH7709 is not set
-# CONFIG_CPU_SUBTYPE_SH7710 is not set
-# CONFIG_CPU_SUBTYPE_SH7712 is not set
-# CONFIG_CPU_SUBTYPE_SH7720 is not set
-# CONFIG_CPU_SUBTYPE_SH7721 is not set
-# CONFIG_CPU_SUBTYPE_SH7750 is not set
-# CONFIG_CPU_SUBTYPE_SH7091 is not set
-# CONFIG_CPU_SUBTYPE_SH7750R is not set
-# CONFIG_CPU_SUBTYPE_SH7750S is not set
-# CONFIG_CPU_SUBTYPE_SH7751 is not set
-# CONFIG_CPU_SUBTYPE_SH7751R is not set
-# CONFIG_CPU_SUBTYPE_SH7760 is not set
-# CONFIG_CPU_SUBTYPE_SH4_202 is not set
-# CONFIG_CPU_SUBTYPE_SH7723 is not set
-# CONFIG_CPU_SUBTYPE_SH7763 is not set
-# CONFIG_CPU_SUBTYPE_SH7770 is not set
-# CONFIG_CPU_SUBTYPE_SH7780 is not set
-# CONFIG_CPU_SUBTYPE_SH7785 is not set
-# CONFIG_CPU_SUBTYPE_SH7786 is not set
-# CONFIG_CPU_SUBTYPE_SHX3 is not set
-# CONFIG_CPU_SUBTYPE_SH7343 is not set
-# CONFIG_CPU_SUBTYPE_SH7722 is not set
-# CONFIG_CPU_SUBTYPE_SH7366 is not set
 CONFIG_CPU_SUBTYPE_SH5_101=y
 # CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
@@ -279,8 +250,6 @@ CONFIG_BOOT_LINK_OFFSET=0x00800000
 #
 CONFIG_PCI=y
 CONFIG_SH_PCIDMA_NONCOHERENT=y
-CONFIG_PCI_AUTO=y
-CONFIG_PCI_AUTO_UPDATE_RESOURCES=y
 # CONFIG_PCIEPORTBUS is not set
 # CONFIG_ARCH_SUPPORTS_MSI is not set
 CONFIG_PCI_LEGACY=y
@@ -492,6 +461,7 @@ CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_SCSI_MPT2SAS is not set
 # CONFIG_SCSI_HPTIOP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_FCOE is not set
 # CONFIG_SCSI_DMX3191D is not set
 # CONFIG_SCSI_FUTURE_DOMAIN is not set
@@ -568,6 +538,7 @@ CONFIG_NETDEV_1000=y
 # CONFIG_E1000E is not set
 # CONFIG_IP1000 is not set
 # CONFIG_IGB is not set
+# CONFIG_IGBVF is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
@@ -591,6 +562,7 @@ CONFIG_CHELSIO_T3_DEPENDS=y
 # CONFIG_IXGBE is not set
 # CONFIG_IXGB is not set
 # CONFIG_S2IO is not set
+# CONFIG_VXGE is not set
 # CONFIG_MYRI10GE is not set
 # CONFIG_NETXEN_NIC is not set
 # CONFIG_NIU is not set
@@ -779,6 +751,7 @@ CONFIG_HWMON=y
 # CONFIG_SENSORS_F71805F is not set
 # CONFIG_SENSORS_F71882FG is not set
 # CONFIG_SENSORS_F75375S is not set
+# CONFIG_SENSORS_G760A is not set
 # CONFIG_SENSORS_GL518SM is not set
 # CONFIG_SENSORS_GL520SM is not set
 # CONFIG_SENSORS_IT87 is not set
@@ -1042,7 +1015,6 @@ CONFIG_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_USB_SUPPORT=y
 CONFIG_USB_ARCH_HAS_HCD=y
 CONFIG_USB_ARCH_HAS_OHCI=y
@@ -1082,6 +1054,7 @@ CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -1105,6 +1078,11 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -1146,8 +1124,13 @@ CONFIG_MINIX_FS=y
 # CONFIG_HPFS_FS is not set
 # CONFIG_QNX4FS_FS is not set
 CONFIG_ROMFS_FS=y
+CONFIG_ROMFS_BACKED_BY_BLOCK=y
+# CONFIG_ROMFS_BACKED_BY_MTD is not set
+# CONFIG_ROMFS_BACKED_BY_BOTH is not set
+CONFIG_ROMFS_ON_BLOCK=y
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
@@ -1208,6 +1191,9 @@ CONFIG_DEBUG_KERNEL=y
 CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC is not set
 CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE=0
+CONFIG_DETECT_HUNG_TASK=y
+# CONFIG_BOOTPARAM_HUNG_TASK_PANIC is not set
+CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE=0
 CONFIG_SCHED_DEBUG=y
 CONFIG_SCHEDSTATS=y
 # CONFIG_TIMER_STATS is not set
@@ -1241,15 +1227,21 @@ CONFIG_FRAME_POINTER=y
 # CONFIG_LATENCYTOP is not set
 # CONFIG_SYSCTL_SYSCALL_CHECK is not set
 # CONFIG_PAGE_POISONING is not set
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
 # CONFIG_SCHED_TRACER is not set
 # CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
 # CONFIG_BOOT_TRACER is not set
 # CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 # CONFIG_EARLY_SCIF_CONSOLE is not set
 # CONFIG_DEBUG_BOOTMEM is not set
@@ -1354,6 +1346,7 @@ CONFIG_CRYPTO=y
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
 # CONFIG_CRYPTO_DEV_HIFN_795X is not set
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/dreamcast_defconfig b/arch/sh/configs/dreamcast_defconfig
index 5c1123640142..1f3cc98330bf 100644
--- a/arch/sh/configs/dreamcast_defconfig
+++ b/arch/sh/configs/dreamcast_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 17:51:48 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:44:27 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -71,6 +72,7 @@ CONFIG_UID16=y
 # CONFIG_SYSCTL_SYSCALL is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -90,6 +92,7 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 CONFIG_PROFILING=y
+# CONFIG_MARKERS is not set
 # CONFIG_OPROFILE is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
@@ -98,6 +101,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -110,7 +115,6 @@ CONFIG_MODULE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -156,6 +160,7 @@ CONFIG_CPU_SUBTYPE_SH7091=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -165,8 +170,6 @@ CONFIG_CPU_SUBTYPE_SH7091=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -271,7 +274,7 @@ CONFIG_CPU_FREQ_GOV_USERSPACE=y
 CONFIG_SH_DMA_API=y
 CONFIG_SH_DMA=y
 CONFIG_SH_DMA_IRQ_MULTI=y
-CONFIG_NR_ONCHIP_DMA_CHANNELS=6
+CONFIG_NR_ONCHIP_DMA_CHANNELS=4
 CONFIG_NR_DMA_CHANNELS_BOOL=y
 CONFIG_NR_DMA_CHANNELS=9
 # CONFIG_PVR2_DMA is not set
@@ -320,7 +323,6 @@ CONFIG_CMDLINE="console=ttySC1,115200 panic=3"
 CONFIG_MAPLE=y
 CONFIG_PCI=y
 CONFIG_SH_PCIDMA_NONCOHERENT=y
-CONFIG_PCI_AUTO=y
 # CONFIG_PCIEPORTBUS is not set
 # CONFIG_ARCH_SUPPORTS_MSI is not set
 CONFIG_PCI_LEGACY=y
@@ -602,6 +604,7 @@ CONFIG_INPUT_MOUSE=y
 # CONFIG_MOUSE_APPLETOUCH is not set
 # CONFIG_MOUSE_BCM5974 is not set
 # CONFIG_MOUSE_VSXXXAA is not set
+# CONFIG_MOUSE_MAPLE is not set
 # CONFIG_INPUT_JOYSTICK is not set
 # CONFIG_INPUT_TABLET is not set
 # CONFIG_INPUT_TOUCHSCREEN is not set
@@ -812,7 +815,6 @@ CONFIG_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_USB_SUPPORT=y
 CONFIG_USB_ARCH_HAS_HCD=y
 CONFIG_USB_ARCH_HAS_OHCI=y
@@ -867,6 +869,11 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -910,6 +917,7 @@ CONFIG_MISC_FILESYSTEMS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 # CONFIG_NFS_FS is not set
 # CONFIG_NFSD is not set
@@ -947,10 +955,24 @@ CONFIG_FRAME_WARN=1024
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_PREEMPT_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -1051,6 +1073,7 @@ CONFIG_CRYPTO=y
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
 # CONFIG_CRYPTO_DEV_HIFN_795X is not set
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/edosk7705_defconfig b/arch/sh/configs/edosk7705_defconfig
index f4c34b039312..d7092457ddc7 100644
--- a/arch/sh/configs/edosk7705_defconfig
+++ b/arch/sh/configs/edosk7705_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 17:54:02 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:45:04 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_FIND_NEXT_BIT=y
@@ -56,6 +57,7 @@ CONFIG_EMBEDDED=y
 # CONFIG_UID16 is not set
 # CONFIG_SYSCTL_SYSCALL is not set
 # CONFIG_KALLSYMS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 # CONFIG_HOTPLUG is not set
 # CONFIG_PRINTK is not set
 # CONFIG_BUG is not set
@@ -74,12 +76,15 @@ CONFIG_SHMEM=y
 CONFIG_SLUB=y
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 CONFIG_HAVE_IOREMAP_PROT=y
 CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_BASE_SMALL=1
 # CONFIG_MODULES is not set
@@ -114,6 +119,7 @@ CONFIG_CPU_SUBTYPE_SH7705=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -123,8 +129,6 @@ CONFIG_CPU_SUBTYPE_SH7705=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -382,6 +386,10 @@ CONFIG_SSB_POSSIBLE=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+
+#
 # Pseudo filesystems
 #
 # CONFIG_PROC_FS is not set
@@ -409,10 +417,22 @@ CONFIG_FRAME_WARN=1024
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -426,6 +446,7 @@ CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SECURITYFS is not set
 # CONFIG_SECURITY_FILE_CAPABILITIES is not set
 # CONFIG_CRYPTO is not set
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/edosk7760_defconfig b/arch/sh/configs/edosk7760_defconfig
index 7825c2699f18..a822b1d8c116 100644
--- a/arch/sh/configs/edosk7760_defconfig
+++ b/arch/sh/configs/edosk7760_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 17:54:57 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:45:25 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -40,6 +41,7 @@ CONFIG_SWAP=y
 CONFIG_SYSVIPC=y
 CONFIG_SYSVIPC_SYSCTL=y
 CONFIG_POSIX_MQUEUE=y
+CONFIG_POSIX_MQUEUE_SYSCTL=y
 CONFIG_BSD_PROCESS_ACCT=y
 # CONFIG_BSD_PROCESS_ACCT_V3 is not set
 # CONFIG_TASKSTATS is not set
@@ -67,7 +69,6 @@ CONFIG_INITRAMFS_SOURCE=""
 CONFIG_RD_GZIP=y
 # CONFIG_RD_BZIP2 is not set
 # CONFIG_RD_LZMA is not set
-CONFIG_INITRAMFS_COMPRESSION_NONE=y
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
 CONFIG_SYSCTL=y
 CONFIG_ANON_INODES=y
@@ -77,6 +78,7 @@ CONFIG_SYSCTL_SYSCALL=y
 CONFIG_KALLSYMS=y
 CONFIG_KALLSYMS_ALL=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -96,6 +98,7 @@ CONFIG_COMPAT_BRK=y
 CONFIG_SLUB=y
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
 CONFIG_HAVE_IOREMAP_PROT=y
@@ -103,6 +106,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -115,7 +120,6 @@ CONFIG_MODULE_FORCE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -161,6 +165,7 @@ CONFIG_CPU_SH4=y
 CONFIG_CPU_SUBTYPE_SH7760=y
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -170,8 +175,6 @@ CONFIG_CPU_SUBTYPE_SH7760=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -815,6 +818,7 @@ CONFIG_EXT2_FS_XATTR=y
 # CONFIG_EXT2_FS_SECURITY is not set
 CONFIG_EXT2_FS_XIP=y
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -839,6 +843,11 @@ CONFIG_INOTIFY_USER=y
 CONFIG_GENERIC_ACL=y
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -883,6 +892,7 @@ CONFIG_MISC_FILESYSTEMS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 # CONFIG_NFS_V3 is not set
@@ -964,6 +974,9 @@ CONFIG_DEBUG_SHIRQ=y
 CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC is not set
 CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE=0
+CONFIG_DETECT_HUNG_TASK=y
+# CONFIG_BOOTPARAM_HUNG_TASK_PANIC is not set
+CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE=0
 # CONFIG_SCHED_DEBUG is not set
 # CONFIG_SCHEDSTATS is not set
 CONFIG_TIMER_STATS=y
@@ -1001,6 +1014,7 @@ CONFIG_SYSCTL_SYSCALL_CHECK=y
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
@@ -1010,9 +1024,14 @@ CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 # CONFIG_PREEMPT_TRACER is not set
 # CONFIG_SCHED_TRACER is not set
 # CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
 # CONFIG_BOOT_TRACER is not set
 # CONFIG_TRACE_BRANCH_PROFILING is not set
 # CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_KGDB is not set
@@ -1126,6 +1145,7 @@ CONFIG_CRYPTO_DES=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/espt_defconfig b/arch/sh/configs/espt_defconfig
index ebb4c37abaa6..c5b50077913d 100644
--- a/arch/sh/configs/espt_defconfig
+++ b/arch/sh/configs/espt_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 17:58:18 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:46:26 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -78,6 +79,7 @@ CONFIG_UID16=y
 # CONFIG_SYSCTL_SYSCALL is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -106,6 +108,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -117,7 +121,6 @@ CONFIG_MODULES=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -164,6 +167,7 @@ CONFIG_CPU_SH4A=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 CONFIG_CPU_SUBTYPE_SH7763=y
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -173,8 +177,6 @@ CONFIG_CPU_SUBTYPE_SH7763=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -548,6 +550,7 @@ CONFIG_SCSI_WAIT_SCAN=m
 CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_ISCSI_TCP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_SCSI_DEBUG is not set
 # CONFIG_SCSI_DH is not set
 # CONFIG_SCSI_OSD_INITIATOR is not set
@@ -919,6 +922,7 @@ CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -943,6 +947,11 @@ CONFIG_AUTOFS4_FS=y
 CONFIG_GENERIC_ACL=y
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -985,8 +994,13 @@ CONFIG_CRAMFS=y
 # CONFIG_HPFS_FS is not set
 # CONFIG_QNX4FS_FS is not set
 CONFIG_ROMFS_FS=y
+CONFIG_ROMFS_BACKED_BY_BLOCK=y
+# CONFIG_ROMFS_BACKED_BY_MTD is not set
+# CONFIG_ROMFS_BACKED_BY_BOTH is not set
+CONFIG_ROMFS_ON_BLOCK=y
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 # CONFIG_NFS_V3 is not set
@@ -1075,11 +1089,25 @@ CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 CONFIG_RING_BUFFER=y
 CONFIG_TRACING=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_FTRACE_STARTUP_TEST is not set
 # CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -1179,6 +1207,7 @@ CONFIG_CRYPTO=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
+CONFIG_BINARY_PRINTF=y
 
 #
 # Library routines
diff --git a/arch/sh/configs/hp6xx_defconfig b/arch/sh/configs/hp6xx_defconfig
index 82b113af08d3..8e13027eecc3 100644
--- a/arch/sh/configs/hp6xx_defconfig
+++ b/arch/sh/configs/hp6xx_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:01:05 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:47:15 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -67,6 +68,7 @@ CONFIG_UID16=y
 # CONFIG_SYSCTL_SYSCALL is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -85,12 +87,15 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 CONFIG_HAVE_IOREMAP_PROT=y
 CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -98,7 +103,6 @@ CONFIG_BASE_SMALL=0
 # CONFIG_MODULES is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -144,6 +148,7 @@ CONFIG_CPU_SUBTYPE_SH7709=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -153,8 +158,6 @@ CONFIG_CPU_SUBTYPE_SH7709=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -385,6 +388,7 @@ CONFIG_BLK_DEV_SD=y
 # CONFIG_SCSI_SRP_ATTRS is not set
 CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_SCSI_DEBUG is not set
 # CONFIG_SCSI_LOWLEVEL_PCMCIA is not set
 # CONFIG_SCSI_DH is not set
@@ -431,6 +435,7 @@ CONFIG_KEYBOARD_HP6XX=y
 # CONFIG_INPUT_JOYSTICK is not set
 # CONFIG_INPUT_TABLET is not set
 CONFIG_INPUT_TOUCHSCREEN=y
+# CONFIG_TOUCHSCREEN_AD7879 is not set
 # CONFIG_TOUCHSCREEN_FUJITSU is not set
 # CONFIG_TOUCHSCREEN_GUNZE is not set
 # CONFIG_TOUCHSCREEN_ELO is not set
@@ -674,6 +679,11 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -719,6 +729,7 @@ CONFIG_MISC_FILESYSTEMS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 
 #
 # Partition Types
@@ -786,10 +797,23 @@ CONFIG_FRAME_WARN=1024
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -898,6 +922,7 @@ CONFIG_CRYPTO_MD5=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 # CONFIG_CRYPTO_HW is not set
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/landisk_defconfig b/arch/sh/configs/landisk_defconfig
index b6fa4a7599d0..7f549aef0dfd 100644
--- a/arch/sh/configs/landisk_defconfig
+++ b/arch/sh/configs/landisk_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:02:54 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:47:48 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -69,6 +70,7 @@ CONFIG_UID16=y
 # CONFIG_SYSCTL_SYSCALL is not set
 CONFIG_KALLSYMS=y
 CONFIG_KALLSYMS_EXTRA_PASS=y
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -88,6 +90,7 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
 CONFIG_HAVE_IOREMAP_PROT=y
@@ -95,6 +98,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -107,7 +112,6 @@ CONFIG_MODULE_FORCE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -153,6 +157,7 @@ CONFIG_CPU_SUBTYPE_SH7751R=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -162,8 +167,6 @@ CONFIG_CPU_SUBTYPE_SH7751R=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -292,8 +295,6 @@ CONFIG_BOOT_LINK_OFFSET=0x00800000
 #
 CONFIG_PCI=y
 CONFIG_SH_PCIDMA_NONCOHERENT=y
-CONFIG_PCI_AUTO=y
-CONFIG_PCI_AUTO_UPDATE_RESOURCES=y
 # CONFIG_PCIEPORTBUS is not set
 # CONFIG_ARCH_SUPPORTS_MSI is not set
 CONFIG_PCI_LEGACY=y
@@ -602,6 +603,7 @@ CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_SCSI_MPT2SAS is not set
 # CONFIG_SCSI_HPTIOP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_FCOE is not set
 # CONFIG_SCSI_DMX3191D is not set
 # CONFIG_SCSI_FUTURE_DOMAIN is not set
@@ -706,6 +708,7 @@ CONFIG_NETDEV_1000=y
 # CONFIG_E1000E is not set
 # CONFIG_IP1000 is not set
 # CONFIG_IGB is not set
+# CONFIG_IGBVF is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
@@ -729,6 +732,7 @@ CONFIG_CHELSIO_T3_DEPENDS=y
 # CONFIG_IXGBE is not set
 # CONFIG_IXGB is not set
 # CONFIG_S2IO is not set
+# CONFIG_VXGE is not set
 # CONFIG_MYRI10GE is not set
 # CONFIG_NETXEN_NIC is not set
 # CONFIG_NIU is not set
@@ -922,6 +926,7 @@ CONFIG_VIDEO_HELPER_CHIPS_AUTO=y
 # CONFIG_SOC_CAMERA is not set
 CONFIG_V4L_USB_DRIVERS=y
 # CONFIG_USB_VIDEO_CLASS is not set
+CONFIG_USB_VIDEO_CLASS_INPUT_EVDEV=y
 # CONFIG_USB_GSPCA is not set
 # CONFIG_VIDEO_HDPVR is not set
 CONFIG_VIDEO_USBVIDEO=m
@@ -994,15 +999,17 @@ CONFIG_USB_HID=m
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_HID_A4TECH=m
 CONFIG_HID_APPLE=m
 CONFIG_HID_BELKIN=m
 CONFIG_HID_CHERRY=m
 CONFIG_HID_CHICONY=m
 CONFIG_HID_CYPRESS=m
+# CONFIG_DRAGONRISE_FF is not set
 CONFIG_HID_EZKEY=m
+# CONFIG_HID_KYE is not set
 CONFIG_HID_GYRATION=m
+# CONFIG_HID_KENSINGTON is not set
 CONFIG_HID_LOGITECH=m
 # CONFIG_LOGITECH_FF is not set
 # CONFIG_LOGIRUMBLEPAD2_FF is not set
@@ -1197,6 +1204,7 @@ CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -1222,6 +1230,11 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 CONFIG_ISO9660_FS=m
@@ -1270,10 +1283,15 @@ CONFIG_MISC_FILESYSTEMS=y
 # CONFIG_HPFS_FS is not set
 # CONFIG_QNX4FS_FS is not set
 CONFIG_ROMFS_FS=y
+CONFIG_ROMFS_BACKED_BY_BLOCK=y
+# CONFIG_ROMFS_BACKED_BY_MTD is not set
+# CONFIG_ROMFS_BACKED_BY_BOTH is not set
+CONFIG_ROMFS_ON_BLOCK=y
 # CONFIG_SYSV_FS is not set
 CONFIG_UFS_FS=m
 # CONFIG_UFS_FS_WRITE is not set
 # CONFIG_UFS_DEBUG is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=m
 CONFIG_NFS_V3=y
@@ -1364,10 +1382,23 @@ CONFIG_FRAME_WARN=1024
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 CONFIG_SH_STANDARD_BIOS=y
@@ -1469,6 +1500,7 @@ CONFIG_CRYPTO=y
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
 # CONFIG_CRYPTO_DEV_HIFN_795X is not set
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/lboxre2_defconfig b/arch/sh/configs/lboxre2_defconfig
index 92c515c4199f..a7db539f2800 100644
--- a/arch/sh/configs/lboxre2_defconfig
+++ b/arch/sh/configs/lboxre2_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:06:51 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:48:54 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -69,6 +70,7 @@ CONFIG_UID16=y
 # CONFIG_SYSCTL_SYSCALL is not set
 CONFIG_KALLSYMS=y
 CONFIG_KALLSYMS_EXTRA_PASS=y
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -88,6 +90,7 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
 CONFIG_HAVE_IOREMAP_PROT=y
@@ -95,6 +98,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -107,7 +112,6 @@ CONFIG_MODULE_FORCE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -153,6 +157,7 @@ CONFIG_CPU_SUBTYPE_SH7751R=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -162,8 +167,6 @@ CONFIG_CPU_SUBTYPE_SH7751R=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -293,8 +296,6 @@ CONFIG_CMDLINE="console=ttySC1,115200 root=/dev/sda1"
 #
 CONFIG_PCI=y
 CONFIG_SH_PCIDMA_NONCOHERENT=y
-CONFIG_PCI_AUTO=y
-CONFIG_PCI_AUTO_UPDATE_RESOURCES=y
 # CONFIG_PCIEPORTBUS is not set
 # CONFIG_ARCH_SUPPORTS_MSI is not set
 CONFIG_PCI_LEGACY=y
@@ -542,6 +543,7 @@ CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_SCSI_MPT2SAS is not set
 # CONFIG_SCSI_HPTIOP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_FCOE is not set
 # CONFIG_SCSI_DMX3191D is not set
 # CONFIG_SCSI_FUTURE_DOMAIN is not set
@@ -702,6 +704,7 @@ CONFIG_NETDEV_1000=y
 # CONFIG_E1000E is not set
 # CONFIG_IP1000 is not set
 # CONFIG_IGB is not set
+# CONFIG_IGBVF is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
@@ -725,6 +728,7 @@ CONFIG_CHELSIO_T3_DEPENDS=y
 # CONFIG_IXGBE is not set
 # CONFIG_IXGB is not set
 # CONFIG_S2IO is not set
+# CONFIG_VXGE is not set
 # CONFIG_MYRI10GE is not set
 # CONFIG_NETXEN_NIC is not set
 # CONFIG_NIU is not set
@@ -931,7 +935,6 @@ CONFIG_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_USB_SUPPORT=y
 CONFIG_USB_ARCH_HAS_HCD=y
 CONFIG_USB_ARCH_HAS_OHCI=y
@@ -1007,6 +1010,7 @@ CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -1029,6 +1033,11 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -1073,8 +1082,13 @@ CONFIG_MISC_FILESYSTEMS=y
 # CONFIG_HPFS_FS is not set
 # CONFIG_QNX4FS_FS is not set
 CONFIG_ROMFS_FS=y
+CONFIG_ROMFS_BACKED_BY_BLOCK=y
+# CONFIG_ROMFS_BACKED_BY_MTD is not set
+# CONFIG_ROMFS_BACKED_BY_BOTH is not set
+CONFIG_ROMFS_ON_BLOCK=y
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 # CONFIG_NFS_FS is not set
 # CONFIG_NFSD is not set
@@ -1151,10 +1165,23 @@ CONFIG_FRAME_WARN=1024
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 CONFIG_SH_STANDARD_BIOS=y
@@ -1256,6 +1283,7 @@ CONFIG_CRYPTO=y
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
 # CONFIG_CRYPTO_DEV_HIFN_795X is not set
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/magicpanelr2_defconfig b/arch/sh/configs/magicpanelr2_defconfig
index 26586c2d64ca..58bec61506fa 100644
--- a/arch/sh/configs/magicpanelr2_defconfig
+++ b/arch/sh/configs/magicpanelr2_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:07:39 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:49:32 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -39,6 +40,7 @@ CONFIG_SWAP=y
 CONFIG_SYSVIPC=y
 CONFIG_SYSVIPC_SYSCTL=y
 CONFIG_POSIX_MQUEUE=y
+CONFIG_POSIX_MQUEUE_SYSCTL=y
 CONFIG_BSD_PROCESS_ACCT=y
 CONFIG_BSD_PROCESS_ACCT_V3=y
 # CONFIG_TASKSTATS is not set
@@ -66,7 +68,6 @@ CONFIG_INITRAMFS_SOURCE=""
 CONFIG_RD_GZIP=y
 # CONFIG_RD_BZIP2 is not set
 # CONFIG_RD_LZMA is not set
-CONFIG_INITRAMFS_COMPRESSION_NONE=y
 # CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 CONFIG_SYSCTL=y
 CONFIG_ANON_INODES=y
@@ -76,6 +77,7 @@ CONFIG_SYSCTL_SYSCALL=y
 CONFIG_KALLSYMS=y
 CONFIG_KALLSYMS_ALL=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -94,6 +96,7 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
 CONFIG_HAVE_IOREMAP_PROT=y
@@ -101,6 +104,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -113,7 +118,6 @@ CONFIG_MODVERSIONS=y
 CONFIG_MODULE_SRCVERSION_ALL=y
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -159,6 +163,7 @@ CONFIG_CPU_SUBTYPE_SH7720=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -168,8 +173,6 @@ CONFIG_CPU_SUBTYPE_SH7720=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -813,6 +816,7 @@ CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 # CONFIG_EXT3_FS_XATTR is not set
 # CONFIG_EXT4_FS is not set
 CONFIG_JBD=y
@@ -831,6 +835,11 @@ CONFIG_FILE_LOCKING=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -884,6 +893,7 @@ CONFIG_JFFS2_RTIME=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
@@ -965,6 +975,7 @@ CONFIG_MAGIC_SYSRQ=y
 CONFIG_DEBUG_KERNEL=y
 # CONFIG_DEBUG_SHIRQ is not set
 # CONFIG_DETECT_SOFTLOCKUP is not set
+# CONFIG_DETECT_HUNG_TASK is not set
 # CONFIG_SCHED_DEBUG is not set
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_TIMER_STATS is not set
@@ -1000,6 +1011,7 @@ CONFIG_SYSCTL_SYSCALL_CHECK=y
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
@@ -1008,9 +1020,14 @@ CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 # CONFIG_IRQSOFF_TRACER is not set
 # CONFIG_SCHED_TRACER is not set
 # CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
 # CONFIG_BOOT_TRACER is not set
 # CONFIG_TRACE_BRANCH_PROFILING is not set
 # CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_KGDB is not set
@@ -1035,6 +1052,7 @@ CONFIG_DUMP_CODE=y
 # CONFIG_SECURITYFS is not set
 # CONFIG_SECURITY_FILE_CAPABILITIES is not set
 # CONFIG_CRYPTO is not set
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/microdev_defconfig b/arch/sh/configs/microdev_defconfig
index 75178355d69a..2886fc84bc1c 100644
--- a/arch/sh/configs/microdev_defconfig
+++ b/arch/sh/configs/microdev_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:11:13 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:50:51 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -65,7 +66,6 @@ CONFIG_INITRAMFS_SOURCE=""
 CONFIG_RD_GZIP=y
 # CONFIG_RD_BZIP2 is not set
 # CONFIG_RD_LZMA is not set
-CONFIG_INITRAMFS_COMPRESSION_NONE=y
 # CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 CONFIG_SYSCTL=y
 CONFIG_ANON_INODES=y
@@ -74,6 +74,7 @@ CONFIG_UID16=y
 # CONFIG_SYSCTL_SYSCALL is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -92,12 +93,15 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 CONFIG_HAVE_IOREMAP_PROT=y
 CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -105,7 +109,6 @@ CONFIG_BASE_SMALL=0
 # CONFIG_MODULES is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -151,6 +154,7 @@ CONFIG_CPU_SH4=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 CONFIG_CPU_SUBTYPE_SH4_202=y
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -160,8 +164,6 @@ CONFIG_CPU_SUBTYPE_SH4_202=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -647,6 +649,7 @@ CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -669,6 +672,11 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -715,6 +723,7 @@ CONFIG_MISC_FILESYSTEMS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
@@ -802,10 +811,24 @@ CONFIG_FRAME_WARN=1024
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_PREEMPT_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -914,6 +937,7 @@ CONFIG_CRYPTO_DES=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/migor_defconfig b/arch/sh/configs/migor_defconfig
index a8720f9c6047..8ecceb4bf27e 100644
--- a/arch/sh/configs/migor_defconfig
+++ b/arch/sh/configs/migor_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:14:03 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:51:34 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -67,7 +68,6 @@ CONFIG_INITRAMFS_SOURCE=""
 CONFIG_RD_GZIP=y
 # CONFIG_RD_BZIP2 is not set
 # CONFIG_RD_LZMA is not set
-CONFIG_INITRAMFS_COMPRESSION_NONE=y
 # CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 CONFIG_SYSCTL=y
 CONFIG_ANON_INODES=y
@@ -76,6 +76,7 @@ CONFIG_UID16=y
 # CONFIG_SYSCTL_SYSCALL is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -104,6 +105,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -115,7 +118,6 @@ CONFIG_MODULES=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -165,6 +167,7 @@ CONFIG_ARCH_SHMOBILE=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -174,8 +177,6 @@ CONFIG_ARCH_SHMOBILE=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 CONFIG_CPU_SUBTYPE_SH7722=y
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -577,6 +578,7 @@ CONFIG_SCSI_WAIT_SCAN=m
 CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_ISCSI_TCP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_SCSI_DEBUG is not set
 # CONFIG_SCSI_DH is not set
 # CONFIG_SCSI_OSD_INITIATOR is not set
@@ -873,7 +875,6 @@ CONFIG_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_USB_SUPPORT=y
 CONFIG_USB_ARCH_HAS_HCD=y
 # CONFIG_USB_ARCH_HAS_OHCI is not set
@@ -1012,6 +1013,11 @@ CONFIG_FILE_LOCKING=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -1056,6 +1062,7 @@ CONFIG_MISC_FILESYSTEMS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 # CONFIG_NFS_V3 is not set
@@ -1105,11 +1112,25 @@ CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 CONFIG_RING_BUFFER=y
 CONFIG_TRACING=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_FTRACE_STARTUP_TEST is not set
 # CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -1218,6 +1239,7 @@ CONFIG_CRYPTO_WORKQUEUE=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 # CONFIG_CRYPTO_HW is not set
+CONFIG_BINARY_PRINTF=y
 
 #
 # Library routines
diff --git a/arch/sh/configs/polaris_defconfig b/arch/sh/configs/polaris_defconfig
index df2d177d5346..2b9507286182 100644
--- a/arch/sh/configs/polaris_defconfig
+++ b/arch/sh/configs/polaris_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:16:48 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:52:19 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -40,6 +41,7 @@ CONFIG_LOCALVERSION=""
 CONFIG_SYSVIPC=y
 CONFIG_SYSVIPC_SYSCTL=y
 CONFIG_POSIX_MQUEUE=y
+CONFIG_POSIX_MQUEUE_SYSCTL=y
 CONFIG_BSD_PROCESS_ACCT=y
 CONFIG_BSD_PROCESS_ACCT_V3=y
 # CONFIG_TASKSTATS is not set
@@ -76,6 +78,7 @@ CONFIG_SYSCTL_SYSCALL=y
 CONFIG_KALLSYMS=y
 CONFIG_KALLSYMS_ALL=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -94,6 +97,7 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
 CONFIG_HAVE_IOREMAP_PROT=y
@@ -101,6 +105,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -113,7 +119,6 @@ CONFIG_MODVERSIONS=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -159,6 +164,7 @@ CONFIG_CPU_SUBTYPE_SH7709=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -168,8 +174,6 @@ CONFIG_CPU_SUBTYPE_SH7709=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -778,6 +782,11 @@ CONFIG_FILE_LOCKING=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -831,6 +840,7 @@ CONFIG_JFFS2_RTIME=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
@@ -874,6 +884,9 @@ CONFIG_DEBUG_SHIRQ=y
 CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC is not set
 CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE=0
+CONFIG_DETECT_HUNG_TASK=y
+# CONFIG_BOOTPARAM_HUNG_TASK_PANIC is not set
+CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE=0
 # CONFIG_SCHED_DEBUG is not set
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_TIMER_STATS is not set
@@ -914,6 +927,7 @@ CONFIG_SYSCTL_SYSCALL_CHECK=y
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
@@ -923,9 +937,14 @@ CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 # CONFIG_PREEMPT_TRACER is not set
 # CONFIG_SCHED_TRACER is not set
 # CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
 # CONFIG_BOOT_TRACER is not set
 # CONFIG_TRACE_BRANCH_PROFILING is not set
 # CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_KGDB is not set
@@ -950,6 +969,7 @@ CONFIG_DUMP_CODE=y
 # CONFIG_SECURITYFS is not set
 # CONFIG_SECURITY_FILE_CAPABILITIES is not set
 # CONFIG_CRYPTO is not set
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/r7780mp_defconfig b/arch/sh/configs/r7780mp_defconfig
index 7def4df46ddb..943da63a3852 100644
--- a/arch/sh/configs/r7780mp_defconfig
+++ b/arch/sh/configs/r7780mp_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:20:17 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:53:28 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -78,6 +79,7 @@ CONFIG_UID16=y
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_ALL is not set
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -107,6 +109,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_BASE_SMALL=0
@@ -118,7 +122,6 @@ CONFIG_MODULE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -165,6 +168,7 @@ CONFIG_CPU_SH4A=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 CONFIG_CPU_SUBTYPE_SH7780=y
@@ -174,8 +178,6 @@ CONFIG_CPU_SUBTYPE_SH7780=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -258,7 +260,7 @@ CONFIG_SH_R7780MP=y
 #
 CONFIG_SH_TMU=y
 CONFIG_SH_TIMER_IRQ=28
-CONFIG_SH_PCLK_FREQ=32000000
+CONFIG_SH_PCLK_FREQ=33333333
 # CONFIG_NO_HZ is not set
 # CONFIG_HIGH_RES_TIMERS is not set
 CONFIG_GENERIC_CLOCKEVENTS_BUILD=y
@@ -313,8 +315,6 @@ CONFIG_CMDLINE="console=ttySC0,115200 root=/dev/sda1"
 #
 CONFIG_PCI=y
 CONFIG_SH_PCIDMA_NONCOHERENT=y
-CONFIG_PCI_AUTO=y
-CONFIG_PCI_AUTO_UPDATE_RESOURCES=y
 # CONFIG_PCIEPORTBUS is not set
 # CONFIG_ARCH_SUPPORTS_MSI is not set
 CONFIG_PCI_LEGACY=y
@@ -536,6 +536,7 @@ CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_SCSI_MPT2SAS is not set
 # CONFIG_SCSI_HPTIOP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_FCOE is not set
 # CONFIG_SCSI_DMX3191D is not set
 # CONFIG_SCSI_FUTURE_DOMAIN is not set
@@ -696,6 +697,7 @@ CONFIG_E1000=m
 # CONFIG_E1000E is not set
 # CONFIG_IP1000 is not set
 # CONFIG_IGB is not set
+# CONFIG_IGBVF is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
@@ -719,6 +721,7 @@ CONFIG_CHELSIO_T3_DEPENDS=y
 # CONFIG_IXGBE is not set
 # CONFIG_IXGB is not set
 # CONFIG_S2IO is not set
+# CONFIG_VXGE is not set
 # CONFIG_MYRI10GE is not set
 # CONFIG_NETXEN_NIC is not set
 # CONFIG_NIU is not set
@@ -920,6 +923,7 @@ CONFIG_HWMON=y
 # CONFIG_SENSORS_F71805F is not set
 # CONFIG_SENSORS_F71882FG is not set
 # CONFIG_SENSORS_F75375S is not set
+# CONFIG_SENSORS_G760A is not set
 # CONFIG_SENSORS_GL518SM is not set
 # CONFIG_SENSORS_GL520SM is not set
 # CONFIG_SENSORS_IT87 is not set
@@ -1027,7 +1031,6 @@ CONFIG_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_USB_SUPPORT=y
 CONFIG_USB_ARCH_HAS_HCD=y
 CONFIG_USB_ARCH_HAS_OHCI=y
@@ -1120,6 +1123,7 @@ CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -1143,6 +1147,11 @@ CONFIG_INOTIFY_USER=y
 CONFIG_FUSE_FS=m
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -1191,6 +1200,7 @@ CONFIG_MINIX_FS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
@@ -1279,6 +1289,9 @@ CONFIG_DEBUG_KERNEL=y
 CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC is not set
 CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE=0
+CONFIG_DETECT_HUNG_TASK=y
+# CONFIG_BOOTPARAM_HUNG_TASK_PANIC is not set
+CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE=0
 CONFIG_SCHED_DEBUG=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_TIMER_STATS is not set
@@ -1316,6 +1329,7 @@ CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 CONFIG_RING_BUFFER=y
 CONFIG_TRACING=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
@@ -1325,11 +1339,16 @@ CONFIG_TRACING=y
 # CONFIG_PREEMPT_TRACER is not set
 # CONFIG_SCHED_TRACER is not set
 # CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
 # CONFIG_BOOT_TRACER is not set
 # CONFIG_TRACE_BRANCH_PROFILING is not set
 # CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_FTRACE_STARTUP_TEST is not set
 # CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_KGDB is not set
@@ -1449,6 +1468,7 @@ CONFIG_CRYPTO_DES=y
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
 # CONFIG_CRYPTO_DEV_HIFN_795X is not set
+CONFIG_BINARY_PRINTF=y
 
 #
 # Library routines
diff --git a/arch/sh/configs/r7785rp_defconfig b/arch/sh/configs/r7785rp_defconfig
index cb134ffc2118..82658f672398 100644
--- a/arch/sh/configs/r7785rp_defconfig
+++ b/arch/sh/configs/r7785rp_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:24:35 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:55:10 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -43,6 +44,7 @@ CONFIG_SWAP=y
 CONFIG_SYSVIPC=y
 CONFIG_SYSVIPC_SYSCTL=y
 CONFIG_POSIX_MQUEUE=y
+CONFIG_POSIX_MQUEUE_SYSCTL=y
 CONFIG_BSD_PROCESS_ACCT=y
 # CONFIG_BSD_PROCESS_ACCT_V3 is not set
 # CONFIG_TASKSTATS is not set
@@ -78,6 +80,7 @@ CONFIG_UID16=y
 CONFIG_KALLSYMS=y
 CONFIG_KALLSYMS_ALL=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -108,6 +111,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -120,7 +125,6 @@ CONFIG_MODULE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -168,6 +172,7 @@ CONFIG_CPU_SHX2=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -177,8 +182,6 @@ CONFIG_CPU_SUBTYPE_SH7785=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -266,7 +269,7 @@ CONFIG_SH_R7785RP=y
 #
 CONFIG_SH_TMU=y
 CONFIG_SH_TIMER_IRQ=28
-CONFIG_SH_PCLK_FREQ=50000000
+CONFIG_SH_PCLK_FREQ=33333333
 CONFIG_TICK_ONESHOT=y
 CONFIG_NO_HZ=y
 CONFIG_HIGH_RES_TIMERS=y
@@ -337,8 +340,6 @@ CONFIG_CMDLINE="console=ttySC0,115200 root=/dev/sda1"
 #
 CONFIG_PCI=y
 CONFIG_SH_PCIDMA_NONCOHERENT=y
-CONFIG_PCI_AUTO=y
-CONFIG_PCI_AUTO_UPDATE_RESOURCES=y
 # CONFIG_PCIEPORTBUS is not set
 # CONFIG_ARCH_SUPPORTS_MSI is not set
 # CONFIG_PCI_LEGACY is not set
@@ -561,6 +562,7 @@ CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_SCSI_MPT2SAS is not set
 # CONFIG_SCSI_HPTIOP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_FCOE is not set
 # CONFIG_SCSI_DMX3191D is not set
 # CONFIG_SCSI_FUTURE_DOMAIN is not set
@@ -698,6 +700,7 @@ CONFIG_NETDEV_1000=y
 # CONFIG_E1000E is not set
 # CONFIG_IP1000 is not set
 # CONFIG_IGB is not set
+# CONFIG_IGBVF is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
@@ -721,6 +724,7 @@ CONFIG_CHELSIO_T3_DEPENDS=y
 # CONFIG_IXGBE is not set
 # CONFIG_IXGB is not set
 # CONFIG_S2IO is not set
+# CONFIG_VXGE is not set
 # CONFIG_MYRI10GE is not set
 # CONFIG_NETXEN_NIC is not set
 # CONFIG_NIU is not set
@@ -948,6 +952,7 @@ CONFIG_HWMON=y
 # CONFIG_SENSORS_F71805F is not set
 # CONFIG_SENSORS_F71882FG is not set
 # CONFIG_SENSORS_F75375S is not set
+# CONFIG_SENSORS_G760A is not set
 # CONFIG_SENSORS_GL518SM is not set
 # CONFIG_SENSORS_GL520SM is not set
 # CONFIG_SENSORS_IT87 is not set
@@ -970,6 +975,7 @@ CONFIG_HWMON=y
 # CONFIG_SENSORS_PC87360 is not set
 # CONFIG_SENSORS_PC87427 is not set
 # CONFIG_SENSORS_PCF8591 is not set
+# CONFIG_SENSORS_SHT15 is not set
 # CONFIG_SENSORS_SIS5595 is not set
 # CONFIG_SENSORS_DME1737 is not set
 # CONFIG_SENSORS_SMSC47M1 is not set
@@ -1109,7 +1115,6 @@ CONFIG_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_USB_SUPPORT=y
 CONFIG_USB_ARCH_HAS_HCD=y
 CONFIG_USB_ARCH_HAS_OHCI=y
@@ -1202,6 +1207,7 @@ CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -1225,6 +1231,11 @@ CONFIG_INOTIFY_USER=y
 CONFIG_FUSE_FS=m
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -1273,6 +1284,7 @@ CONFIG_MINIX_FS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
@@ -1359,6 +1371,7 @@ CONFIG_DEBUG_FS=y
 CONFIG_DEBUG_KERNEL=y
 # CONFIG_DEBUG_SHIRQ is not set
 # CONFIG_DETECT_SOFTLOCKUP is not set
+# CONFIG_DETECT_HUNG_TASK is not set
 CONFIG_SCHED_DEBUG=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_TIMER_STATS is not set
@@ -1401,6 +1414,7 @@ CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 CONFIG_RING_BUFFER=y
 CONFIG_TRACING=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
@@ -1410,11 +1424,16 @@ CONFIG_TRACING=y
 # CONFIG_PREEMPT_TRACER is not set
 # CONFIG_SCHED_TRACER is not set
 # CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
 # CONFIG_BOOT_TRACER is not set
 # CONFIG_TRACE_BRANCH_PROFILING is not set
 # CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_FTRACE_STARTUP_TEST is not set
 # CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_KGDB is not set
@@ -1534,6 +1553,7 @@ CONFIG_CRYPTO_DES=y
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
 # CONFIG_CRYPTO_DEV_HIFN_795X is not set
+CONFIG_BINARY_PRINTF=y
 
 #
 # Library routines
diff --git a/arch/sh/configs/rsk7201_defconfig b/arch/sh/configs/rsk7201_defconfig
index a037c744b798..fa4395768d19 100644
--- a/arch/sh/configs/rsk7201_defconfig
+++ b/arch/sh/configs/rsk7201_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:29:08 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:56:29 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -65,7 +66,6 @@ CONFIG_INITRAMFS_SOURCE=""
 CONFIG_RD_GZIP=y
 # CONFIG_RD_BZIP2 is not set
 # CONFIG_RD_LZMA is not set
-CONFIG_INITRAMFS_COMPRESSION_NONE=y
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
 CONFIG_SYSCTL=y
 CONFIG_ANON_INODES=y
@@ -74,6 +74,7 @@ CONFIG_UID16=y
 CONFIG_SYSCTL_SYSCALL=y
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -100,6 +101,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_RT_MUTEXES=y
 CONFIG_BASE_SMALL=0
@@ -110,7 +113,6 @@ CONFIG_MODULES=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -157,6 +159,7 @@ CONFIG_CPU_SUBTYPE_SH7201=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -166,8 +169,6 @@ CONFIG_CPU_SUBTYPE_SH7201=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -603,6 +604,11 @@ CONFIG_EXT2_FS=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -651,8 +657,13 @@ CONFIG_JFFS2_RTIME=y
 # CONFIG_HPFS_FS is not set
 # CONFIG_QNX4FS_FS is not set
 CONFIG_ROMFS_FS=y
+CONFIG_ROMFS_BACKED_BY_BLOCK=y
+# CONFIG_ROMFS_BACKED_BY_MTD is not set
+# CONFIG_ROMFS_BACKED_BY_BOTH is not set
+CONFIG_ROMFS_ON_BLOCK=y
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 
 #
 # Partition Types
@@ -686,11 +697,24 @@ CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 CONFIG_RING_BUFFER=y
 CONFIG_TRACING=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_FTRACE_STARTUP_TEST is not set
 # CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -705,6 +729,7 @@ CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SECURITYFS is not set
 # CONFIG_SECURITY_FILE_CAPABILITIES is not set
 # CONFIG_CRYPTO is not set
+CONFIG_BINARY_PRINTF=y
 
 #
 # Library routines
diff --git a/arch/sh/configs/rsk7203_defconfig b/arch/sh/configs/rsk7203_defconfig
index 9ae28e88426c..e3a65f819f0a 100644
--- a/arch/sh/configs/rsk7203_defconfig
+++ b/arch/sh/configs/rsk7203_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:30:34 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:57:06 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -39,6 +40,7 @@ CONFIG_LOCALVERSION=""
 CONFIG_SYSVIPC=y
 CONFIG_SYSVIPC_SYSCTL=y
 CONFIG_POSIX_MQUEUE=y
+CONFIG_POSIX_MQUEUE_SYSCTL=y
 CONFIG_BSD_PROCESS_ACCT=y
 # CONFIG_BSD_PROCESS_ACCT_V3 is not set
 # CONFIG_TASKSTATS is not set
@@ -70,7 +72,6 @@ CONFIG_INITRAMFS_SOURCE=""
 CONFIG_RD_GZIP=y
 # CONFIG_RD_BZIP2 is not set
 # CONFIG_RD_LZMA is not set
-CONFIG_INITRAMFS_COMPRESSION_NONE=y
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
 CONFIG_SYSCTL=y
 CONFIG_ANON_INODES=y
@@ -80,6 +81,7 @@ CONFIG_SYSCTL_SYSCALL=y
 CONFIG_KALLSYMS=y
 CONFIG_KALLSYMS_ALL=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -106,6 +108,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_RT_MUTEXES=y
 CONFIG_BASE_SMALL=0
@@ -116,7 +120,6 @@ CONFIG_MODULES=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -163,6 +166,7 @@ CONFIG_CPU_SUBTYPE_SH7203=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -172,8 +176,6 @@ CONFIG_CPU_SUBTYPE_SH7203=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -750,15 +752,17 @@ CONFIG_USB_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_HID_A4TECH=y
 CONFIG_HID_APPLE=y
 CONFIG_HID_BELKIN=y
 CONFIG_HID_CHERRY=y
 CONFIG_HID_CHICONY=y
 CONFIG_HID_CYPRESS=y
+# CONFIG_DRAGONRISE_FF is not set
 CONFIG_HID_EZKEY=y
+# CONFIG_HID_KYE is not set
 CONFIG_HID_GYRATION=y
+# CONFIG_HID_KENSINGTON is not set
 CONFIG_HID_LOGITECH=y
 # CONFIG_LOGITECH_FF is not set
 # CONFIG_LOGIRUMBLEPAD2_FF is not set
@@ -874,6 +878,7 @@ CONFIG_LEDS_CLASS=y
 # LED drivers
 #
 CONFIG_LEDS_GPIO=y
+CONFIG_LEDS_GPIO_PLATFORM=y
 
 #
 # LED Triggers
@@ -882,6 +887,7 @@ CONFIG_LEDS_TRIGGERS=y
 CONFIG_LEDS_TRIGGER_TIMER=y
 CONFIG_LEDS_TRIGGER_HEARTBEAT=y
 CONFIG_LEDS_TRIGGER_BACKLIGHT=y
+# CONFIG_LEDS_TRIGGER_GPIO is not set
 CONFIG_LEDS_TRIGGER_DEFAULT_ON=y
 
 #
@@ -951,6 +957,11 @@ CONFIG_FILE_LOCKING=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -989,8 +1000,13 @@ CONFIG_MISC_FILESYSTEMS=y
 # CONFIG_HPFS_FS is not set
 # CONFIG_QNX4FS_FS is not set
 CONFIG_ROMFS_FS=y
+CONFIG_ROMFS_BACKED_BY_BLOCK=y
+# CONFIG_ROMFS_BACKED_BY_MTD is not set
+# CONFIG_ROMFS_BACKED_BY_BOTH is not set
+CONFIG_ROMFS_ON_BLOCK=y
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 # CONFIG_NFS_V3 is not set
@@ -1033,6 +1049,9 @@ CONFIG_DEBUG_SHIRQ=y
 CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC is not set
 CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE=0
+CONFIG_DETECT_HUNG_TASK=y
+# CONFIG_BOOTPARAM_HUNG_TASK_PANIC is not set
+CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE=0
 CONFIG_SCHED_DEBUG=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_TIMER_STATS is not set
@@ -1076,6 +1095,7 @@ CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 CONFIG_RING_BUFFER=y
 CONFIG_TRACING=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
@@ -1083,11 +1103,16 @@ CONFIG_TRACING=y
 # CONFIG_FUNCTION_TRACER is not set
 # CONFIG_SCHED_TRACER is not set
 # CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
 # CONFIG_BOOT_TRACER is not set
 # CONFIG_TRACE_BRANCH_PROFILING is not set
 # CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_FTRACE_STARTUP_TEST is not set
 # CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_KGDB is not set
@@ -1111,6 +1136,7 @@ CONFIG_DUMP_CODE=y
 # CONFIG_SECURITYFS is not set
 # CONFIG_SECURITY_FILE_CAPABILITIES is not set
 # CONFIG_CRYPTO is not set
+CONFIG_BINARY_PRINTF=y
 
 #
 # Library routines
diff --git a/arch/sh/configs/rts7751r2d1_defconfig b/arch/sh/configs/rts7751r2d1_defconfig
index c0f741af6da8..a4a59f6205ab 100644
--- a/arch/sh/configs/rts7751r2d1_defconfig
+++ b/arch/sh/configs/rts7751r2d1_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:33:25 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:58:13 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -70,6 +71,7 @@ CONFIG_UID16=y
 # CONFIG_SYSCTL_SYSCALL is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -99,6 +101,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -110,7 +114,6 @@ CONFIG_MODULES=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -156,6 +159,7 @@ CONFIG_CPU_SUBTYPE_SH7751R=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -165,8 +169,6 @@ CONFIG_CPU_SUBTYPE_SH7751R=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -302,8 +304,6 @@ CONFIG_CMDLINE="console=tty0 console=ttySC0,115200 root=/dev/sda1 earlyprintk=se
 #
 CONFIG_PCI=y
 CONFIG_SH_PCIDMA_NONCOHERENT=y
-CONFIG_PCI_AUTO=y
-CONFIG_PCI_AUTO_UPDATE_RESOURCES=y
 # CONFIG_PCIEPORTBUS is not set
 # CONFIG_ARCH_SUPPORTS_MSI is not set
 CONFIG_PCI_LEGACY=y
@@ -513,6 +513,7 @@ CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_SCSI_MPT2SAS is not set
 # CONFIG_SCSI_HPTIOP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_FCOE is not set
 # CONFIG_SCSI_DMX3191D is not set
 # CONFIG_SCSI_FUTURE_DOMAIN is not set
@@ -672,6 +673,7 @@ CONFIG_NETDEV_1000=y
 # CONFIG_E1000E is not set
 # CONFIG_IP1000 is not set
 # CONFIG_IGB is not set
+# CONFIG_IGBVF is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
@@ -695,6 +697,7 @@ CONFIG_CHELSIO_T3_DEPENDS=y
 # CONFIG_IXGBE is not set
 # CONFIG_IXGB is not set
 # CONFIG_S2IO is not set
+# CONFIG_VXGE is not set
 # CONFIG_MYRI10GE is not set
 # CONFIG_NETXEN_NIC is not set
 # CONFIG_NIU is not set
@@ -793,6 +796,7 @@ CONFIG_SERIAL_8250_RUNTIME_UARTS=4
 #
 # Non-8250 serial port support
 #
+# CONFIG_SERIAL_MAX3100 is not set
 CONFIG_SERIAL_SH_SCI=y
 CONFIG_SERIAL_SH_SCI_NR_UARTS=1
 CONFIG_SERIAL_SH_SCI_CONSOLE=y
@@ -1079,15 +1083,17 @@ CONFIG_USB_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_HID_A4TECH=y
 CONFIG_HID_APPLE=y
 CONFIG_HID_BELKIN=y
 CONFIG_HID_CHERRY=y
 CONFIG_HID_CHICONY=y
 CONFIG_HID_CYPRESS=y
+# CONFIG_DRAGONRISE_FF is not set
 CONFIG_HID_EZKEY=y
+# CONFIG_HID_KYE is not set
 CONFIG_HID_GYRATION=y
+# CONFIG_HID_KENSINGTON is not set
 CONFIG_HID_LOGITECH=y
 # CONFIG_LOGITECH_FF is not set
 # CONFIG_LOGIRUMBLEPAD2_FF is not set
@@ -1291,6 +1297,11 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -1337,6 +1348,7 @@ CONFIG_MINIX_FS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 # CONFIG_NFS_FS is not set
 # CONFIG_NFSD is not set
@@ -1417,11 +1429,25 @@ CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 CONFIG_RING_BUFFER=y
 CONFIG_TRACING=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_FTRACE_STARTUP_TEST is not set
 # CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -1524,6 +1550,7 @@ CONFIG_CRYPTO=y
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
 # CONFIG_CRYPTO_DEV_HIFN_795X is not set
+CONFIG_BINARY_PRINTF=y
 
 #
 # Library routines
diff --git a/arch/sh/configs/rts7751r2dplus_defconfig b/arch/sh/configs/rts7751r2dplus_defconfig
index 8feef629e49c..a860435b8847 100644
--- a/arch/sh/configs/rts7751r2dplus_defconfig
+++ b/arch/sh/configs/rts7751r2dplus_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:34:12 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:59:01 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -70,6 +71,7 @@ CONFIG_UID16=y
 # CONFIG_SYSCTL_SYSCALL is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -99,6 +101,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -110,7 +114,6 @@ CONFIG_MODULES=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -156,6 +159,7 @@ CONFIG_CPU_SUBTYPE_SH7751R=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -165,8 +169,6 @@ CONFIG_CPU_SUBTYPE_SH7751R=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -302,8 +304,6 @@ CONFIG_CMDLINE="console=tty0 console=ttySC0,115200 root=/dev/sda1 earlyprintk=se
 #
 CONFIG_PCI=y
 CONFIG_SH_PCIDMA_NONCOHERENT=y
-CONFIG_PCI_AUTO=y
-CONFIG_PCI_AUTO_UPDATE_RESOURCES=y
 # CONFIG_PCIEPORTBUS is not set
 # CONFIG_ARCH_SUPPORTS_MSI is not set
 CONFIG_PCI_LEGACY=y
@@ -424,7 +424,92 @@ CONFIG_FIRMWARE_IN_KERNEL=y
 CONFIG_EXTRA_FIRMWARE=""
 # CONFIG_SYS_HYPERVISOR is not set
 # CONFIG_CONNECTOR is not set
-# CONFIG_MTD is not set
+CONFIG_MTD=y
+# CONFIG_MTD_DEBUG is not set
+CONFIG_MTD_CONCAT=y
+CONFIG_MTD_PARTITIONS=y
+# CONFIG_MTD_TESTS is not set
+# CONFIG_MTD_REDBOOT_PARTS is not set
+CONFIG_MTD_CMDLINE_PARTS=y
+# CONFIG_MTD_AR7_PARTS is not set
+
+#
+# User Modules And Translation Layers
+#
+CONFIG_MTD_CHAR=y
+# CONFIG_MTD_BLKDEVS is not set
+# CONFIG_MTD_BLOCK is not set
+# CONFIG_MTD_BLOCK_RO is not set
+# CONFIG_FTL is not set
+# CONFIG_NFTL is not set
+# CONFIG_INFTL is not set
+# CONFIG_RFD_FTL is not set
+# CONFIG_SSFDC is not set
+# CONFIG_MTD_OOPS is not set
+
+#
+# RAM/ROM/Flash chip drivers
+#
+CONFIG_MTD_CFI=y
+# CONFIG_MTD_JEDECPROBE is not set
+CONFIG_MTD_GEN_PROBE=y
+# CONFIG_MTD_CFI_ADV_OPTIONS is not set
+CONFIG_MTD_MAP_BANK_WIDTH_1=y
+CONFIG_MTD_MAP_BANK_WIDTH_2=y
+CONFIG_MTD_MAP_BANK_WIDTH_4=y
+# CONFIG_MTD_MAP_BANK_WIDTH_8 is not set
+# CONFIG_MTD_MAP_BANK_WIDTH_16 is not set
+# CONFIG_MTD_MAP_BANK_WIDTH_32 is not set
+CONFIG_MTD_CFI_I1=y
+CONFIG_MTD_CFI_I2=y
+# CONFIG_MTD_CFI_I4 is not set
+# CONFIG_MTD_CFI_I8 is not set
+# CONFIG_MTD_CFI_INTELEXT is not set
+CONFIG_MTD_CFI_AMDSTD=y
+# CONFIG_MTD_CFI_STAA is not set
+CONFIG_MTD_CFI_UTIL=y
+# CONFIG_MTD_RAM is not set
+# CONFIG_MTD_ROM is not set
+# CONFIG_MTD_ABSENT is not set
+
+#
+# Mapping drivers for chip access
+#
+# CONFIG_MTD_COMPLEX_MAPPINGS is not set
+CONFIG_MTD_PHYSMAP=y
+# CONFIG_MTD_PHYSMAP_COMPAT is not set
+# CONFIG_MTD_INTEL_VR_NOR is not set
+# CONFIG_MTD_PLATRAM is not set
+
+#
+# Self-contained MTD device drivers
+#
+# CONFIG_MTD_PMC551 is not set
+# CONFIG_MTD_DATAFLASH is not set
+# CONFIG_MTD_M25P80 is not set
+# CONFIG_MTD_SLRAM is not set
+# CONFIG_MTD_PHRAM is not set
+# CONFIG_MTD_MTDRAM is not set
+# CONFIG_MTD_BLOCK2MTD is not set
+
+#
+# Disk-On-Chip Device Drivers
+#
+# CONFIG_MTD_DOC2000 is not set
+# CONFIG_MTD_DOC2001 is not set
+# CONFIG_MTD_DOC2001PLUS is not set
+# CONFIG_MTD_NAND is not set
+# CONFIG_MTD_ONENAND is not set
+
+#
+# LPDDR flash memory drivers
+#
+# CONFIG_MTD_LPDDR is not set
+
+#
+# UBI - Unsorted block images
+#
+# CONFIG_MTD_UBI is not set
 # CONFIG_PARPORT is not set
 CONFIG_BLK_DEV=y
 # CONFIG_BLK_CPQ_CISS_DA is not set
@@ -513,6 +598,7 @@ CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_SCSI_MPT2SAS is not set
 # CONFIG_SCSI_HPTIOP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_FCOE is not set
 # CONFIG_SCSI_DMX3191D is not set
 # CONFIG_SCSI_FUTURE_DOMAIN is not set
@@ -672,6 +758,7 @@ CONFIG_NETDEV_1000=y
 # CONFIG_E1000E is not set
 # CONFIG_IP1000 is not set
 # CONFIG_IGB is not set
+# CONFIG_IGBVF is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
@@ -695,6 +782,7 @@ CONFIG_CHELSIO_T3_DEPENDS=y
 # CONFIG_IXGBE is not set
 # CONFIG_IXGB is not set
 # CONFIG_S2IO is not set
+# CONFIG_VXGE is not set
 # CONFIG_MYRI10GE is not set
 # CONFIG_NETXEN_NIC is not set
 # CONFIG_NIU is not set
@@ -793,6 +881,7 @@ CONFIG_SERIAL_8250_RUNTIME_UARTS=4
 #
 # Non-8250 serial port support
 #
+# CONFIG_SERIAL_MAX3100 is not set
 CONFIG_SERIAL_SH_SCI=y
 CONFIG_SERIAL_SH_SCI_NR_UARTS=1
 CONFIG_SERIAL_SH_SCI_CONSOLE=y
@@ -1079,15 +1168,17 @@ CONFIG_USB_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_HID_A4TECH=y
 CONFIG_HID_APPLE=y
 CONFIG_HID_BELKIN=y
 CONFIG_HID_CHERRY=y
 CONFIG_HID_CHICONY=y
 CONFIG_HID_CYPRESS=y
+# CONFIG_DRAGONRISE_FF is not set
 CONFIG_HID_EZKEY=y
+# CONFIG_HID_KYE is not set
 CONFIG_HID_GYRATION=y
+# CONFIG_HID_KENSINGTON is not set
 CONFIG_HID_LOGITECH=y
 # CONFIG_LOGITECH_FF is not set
 # CONFIG_LOGIRUMBLEPAD2_FF is not set
@@ -1291,6 +1382,11 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -1337,6 +1433,7 @@ CONFIG_MINIX_FS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 # CONFIG_NFS_FS is not set
 # CONFIG_NFSD is not set
@@ -1417,11 +1514,25 @@ CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 CONFIG_RING_BUFFER=y
 CONFIG_TRACING=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_FTRACE_STARTUP_TEST is not set
 # CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -1524,6 +1635,7 @@ CONFIG_CRYPTO=y
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
 # CONFIG_CRYPTO_DEV_HIFN_795X is not set
+CONFIG_BINARY_PRINTF=y
 
 #
 # Library routines
diff --git a/arch/sh/configs/sdk7780_defconfig b/arch/sh/configs/sdk7780_defconfig
index 739e2299ae80..a629b79a1844 100644
--- a/arch/sh/configs/sdk7780_defconfig
+++ b/arch/sh/configs/sdk7780_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:34:43 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 12:59:32 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -41,6 +42,7 @@ CONFIG_SWAP=y
 CONFIG_SYSVIPC=y
 CONFIG_SYSVIPC_SYSCTL=y
 CONFIG_POSIX_MQUEUE=y
+CONFIG_POSIX_MQUEUE_SYSCTL=y
 CONFIG_BSD_PROCESS_ACCT=y
 # CONFIG_BSD_PROCESS_ACCT_V3 is not set
 # CONFIG_TASKSTATS is not set
@@ -73,6 +75,7 @@ CONFIG_SYSCTL_SYSCALL=y
 CONFIG_KALLSYMS=y
 CONFIG_KALLSYMS_ALL=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -93,6 +96,7 @@ CONFIG_COMPAT_BRK=y
 CONFIG_SLUB=y
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
 CONFIG_HAVE_IOREMAP_PROT=y
@@ -100,6 +104,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -112,7 +118,6 @@ CONFIG_MODULE_FORCE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 CONFIG_LBD=y
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -159,6 +164,7 @@ CONFIG_CPU_SH4A=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 CONFIG_CPU_SUBTYPE_SH7780=y
@@ -168,8 +174,6 @@ CONFIG_CPU_SUBTYPE_SH7780=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -310,8 +314,6 @@ CONFIG_CMDLINE="mem=128M console=tty0 console=ttySC0,115200 ip=bootp root=/dev/n
 #
 CONFIG_PCI=y
 CONFIG_SH_PCIDMA_NONCOHERENT=y
-CONFIG_PCI_AUTO=y
-CONFIG_PCI_AUTO_UPDATE_RESOURCES=y
 # CONFIG_PCIEPORTBUS is not set
 # CONFIG_ARCH_SUPPORTS_MSI is not set
 # CONFIG_PCI_LEGACY is not set
@@ -646,6 +648,7 @@ CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_SCSI_MPT2SAS is not set
 # CONFIG_SCSI_HPTIOP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_FCOE is not set
 # CONFIG_SCSI_DMX3191D is not set
 # CONFIG_SCSI_FUTURE_DOMAIN is not set
@@ -1091,15 +1094,17 @@ CONFIG_USB_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_HID_A4TECH=y
 CONFIG_HID_APPLE=y
 CONFIG_HID_BELKIN=y
 CONFIG_HID_CHERRY=y
 CONFIG_HID_CHICONY=y
 CONFIG_HID_CYPRESS=y
+# CONFIG_DRAGONRISE_FF is not set
 CONFIG_HID_EZKEY=y
+# CONFIG_HID_KYE is not set
 CONFIG_HID_GYRATION=y
+# CONFIG_HID_KENSINGTON is not set
 CONFIG_HID_LOGITECH=y
 # CONFIG_LOGITECH_FF is not set
 # CONFIG_LOGIRUMBLEPAD2_FF is not set
@@ -1257,6 +1262,7 @@ CONFIG_EXT2_FS_POSIX_ACL=y
 # CONFIG_EXT2_FS_SECURITY is not set
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 CONFIG_EXT3_FS_POSIX_ACL=y
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -1281,6 +1287,11 @@ CONFIG_AUTOFS4_FS=y
 CONFIG_GENERIC_ACL=y
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 CONFIG_ISO9660_FS=y
@@ -1331,6 +1342,7 @@ CONFIG_MINIX_FS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
@@ -1418,6 +1430,9 @@ CONFIG_DEBUG_KERNEL=y
 CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC is not set
 CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE=0
+CONFIG_DETECT_HUNG_TASK=y
+# CONFIG_BOOTPARAM_HUNG_TASK_PANIC is not set
+CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE=0
 # CONFIG_SCHED_DEBUG is not set
 # CONFIG_SCHEDSTATS is not set
 CONFIG_TIMER_STATS=y
@@ -1455,6 +1470,7 @@ CONFIG_SYSCTL_SYSCALL_CHECK=y
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
@@ -1464,9 +1480,14 @@ CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 # CONFIG_PREEMPT_TRACER is not set
 # CONFIG_SCHED_TRACER is not set
 # CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
 # CONFIG_BOOT_TRACER is not set
 # CONFIG_TRACE_BRANCH_PROFILING is not set
 # CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_KGDB is not set
@@ -1580,6 +1601,7 @@ CONFIG_CRYPTO_DES=y
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
 # CONFIG_CRYPTO_DEV_HIFN_795X is not set
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/se7206_defconfig b/arch/sh/configs/se7206_defconfig
index d30e0a7ad9f1..5caf85a3312d 100644
--- a/arch/sh/configs/se7206_defconfig
+++ b/arch/sh/configs/se7206_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:39:37 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:01:02 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -40,6 +41,7 @@ CONFIG_LOCALVERSION_AUTO=y
 CONFIG_SYSVIPC=y
 CONFIG_SYSVIPC_SYSCTL=y
 CONFIG_POSIX_MQUEUE=y
+CONFIG_POSIX_MQUEUE_SYSCTL=y
 CONFIG_BSD_PROCESS_ACCT=y
 # CONFIG_BSD_PROCESS_ACCT_V3 is not set
 # CONFIG_TASKSTATS is not set
@@ -63,6 +65,7 @@ CONFIG_CGROUP_DEBUG=y
 CONFIG_CGROUP_NS=y
 # CONFIG_CGROUP_FREEZER is not set
 CONFIG_CGROUP_DEVICE=y
+# CONFIG_CPUSETS is not set
 CONFIG_CGROUP_CPUACCT=y
 CONFIG_RESOURCE_COUNTERS=y
 CONFIG_CGROUP_MEM_RES_CTLR=y
@@ -80,7 +83,6 @@ CONFIG_INITRAMFS_SOURCE=""
 CONFIG_RD_GZIP=y
 # CONFIG_RD_BZIP2 is not set
 # CONFIG_RD_LZMA is not set
-CONFIG_INITRAMFS_COMPRESSION_NONE=y
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
 CONFIG_SYSCTL=y
 CONFIG_ANON_INODES=y
@@ -90,6 +92,7 @@ CONFIG_EMBEDDED=y
 CONFIG_KALLSYMS=y
 CONFIG_KALLSYMS_ALL=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -116,6 +119,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_RT_MUTEXES=y
 CONFIG_BASE_SMALL=0
@@ -127,7 +132,6 @@ CONFIG_MODULE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -174,6 +178,7 @@ CONFIG_CPU_SUBTYPE_SH7206=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -183,8 +188,6 @@ CONFIG_CPU_SUBTYPE_SH7206=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -746,6 +749,11 @@ CONFIG_FILE_LOCKING=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -785,8 +793,13 @@ CONFIG_CRAMFS=y
 # CONFIG_HPFS_FS is not set
 # CONFIG_QNX4FS_FS is not set
 CONFIG_ROMFS_FS=y
+CONFIG_ROMFS_BACKED_BY_BLOCK=y
+# CONFIG_ROMFS_BACKED_BY_MTD is not set
+# CONFIG_ROMFS_BACKED_BY_BOTH is not set
+CONFIG_ROMFS_ON_BLOCK=y
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
@@ -831,6 +844,9 @@ CONFIG_DEBUG_KERNEL=y
 CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC is not set
 CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE=0
+CONFIG_DETECT_HUNG_TASK=y
+# CONFIG_BOOTPARAM_HUNG_TASK_PANIC is not set
+CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE=0
 CONFIG_SCHED_DEBUG=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_TIMER_STATS is not set
@@ -869,6 +885,7 @@ CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 CONFIG_RING_BUFFER=y
 CONFIG_TRACING=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
@@ -876,11 +893,16 @@ CONFIG_TRACING=y
 # CONFIG_FUNCTION_TRACER is not set
 # CONFIG_SCHED_TRACER is not set
 # CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
 # CONFIG_BOOT_TRACER is not set
 # CONFIG_TRACE_BRANCH_PROFILING is not set
 # CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_FTRACE_STARTUP_TEST is not set
 # CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_KGDB is not set
@@ -991,6 +1013,7 @@ CONFIG_CRYPTO_LZO=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 # CONFIG_CRYPTO_HW is not set
+CONFIG_BINARY_PRINTF=y
 
 #
 # Library routines
diff --git a/arch/sh/configs/se7343_defconfig b/arch/sh/configs/se7343_defconfig
index fbb72d029e68..004d531716dc 100644
--- a/arch/sh/configs/se7343_defconfig
+++ b/arch/sh/configs/se7343_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:42:00 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:01:44 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -40,6 +41,7 @@ CONFIG_LOCALVERSION_AUTO=y
 CONFIG_SYSVIPC=y
 CONFIG_SYSVIPC_SYSCTL=y
 CONFIG_POSIX_MQUEUE=y
+CONFIG_POSIX_MQUEUE_SYSCTL=y
 # CONFIG_BSD_PROCESS_ACCT is not set
 # CONFIG_TASKSTATS is not set
 # CONFIG_AUDIT is not set
@@ -73,6 +75,7 @@ CONFIG_UID16=y
 # CONFIG_SYSCTL_SYSCALL is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -91,6 +94,7 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
 CONFIG_HAVE_IOREMAP_PROT=y
@@ -98,6 +102,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_BASE_SMALL=0
@@ -109,7 +115,6 @@ CONFIG_MODULE_FORCE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -158,6 +163,7 @@ CONFIG_ARCH_SHMOBILE=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -167,8 +173,6 @@ CONFIG_ARCH_SHMOBILE=y
 CONFIG_CPU_SUBTYPE_SH7343=y
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -769,6 +773,7 @@ CONFIG_VIDEO_HELPER_CHIPS_AUTO=y
 # CONFIG_SOC_CAMERA is not set
 CONFIG_V4L_USB_DRIVERS=y
 # CONFIG_USB_VIDEO_CLASS is not set
+CONFIG_USB_VIDEO_CLASS_INPUT_EVDEV=y
 CONFIG_USB_GSPCA=m
 # CONFIG_USB_M5602 is not set
 # CONFIG_USB_STV06XX is not set
@@ -800,6 +805,7 @@ CONFIG_USB_GSPCA=m
 # CONFIG_VIDEO_PVRUSB2 is not set
 # CONFIG_VIDEO_HDPVR is not set
 # CONFIG_VIDEO_EM28XX is not set
+# CONFIG_VIDEO_CX231XX is not set
 # CONFIG_VIDEO_USBVISION is not set
 # CONFIG_USB_VICAM is not set
 # CONFIG_USB_IBMCAM is not set
@@ -813,6 +819,7 @@ CONFIG_USB_GSPCA=m
 # CONFIG_USB_STV680 is not set
 # CONFIG_USB_ZC0301 is not set
 # CONFIG_USB_PWC is not set
+CONFIG_USB_PWC_INPUT_EVDEV=y
 # CONFIG_USB_ZR364XX is not set
 # CONFIG_USB_STKWEBCAM is not set
 # CONFIG_USB_S2255 is not set
@@ -914,15 +921,17 @@ CONFIG_USB_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_HID_A4TECH=y
 CONFIG_HID_APPLE=y
 CONFIG_HID_BELKIN=y
 CONFIG_HID_CHERRY=y
 CONFIG_HID_CHICONY=y
 CONFIG_HID_CYPRESS=y
+# CONFIG_DRAGONRISE_FF is not set
 CONFIG_HID_EZKEY=y
+# CONFIG_HID_KYE is not set
 CONFIG_HID_GYRATION=y
+# CONFIG_HID_KENSINGTON is not set
 CONFIG_HID_LOGITECH=y
 # CONFIG_LOGITECH_FF is not set
 # CONFIG_LOGIRUMBLEPAD2_FF is not set
@@ -1050,6 +1059,7 @@ CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -1071,6 +1081,11 @@ CONFIG_FILE_LOCKING=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -1125,6 +1140,7 @@ CONFIG_CRAMFS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
@@ -1174,10 +1190,23 @@ CONFIG_FRAME_WARN=1024
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -1279,6 +1308,7 @@ CONFIG_CRYPTO=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/se7619_defconfig b/arch/sh/configs/se7619_defconfig
index 125304e80f57..edbece52afc1 100644
--- a/arch/sh/configs/se7619_defconfig
+++ b/arch/sh/configs/se7619_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:44:53 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:02:32 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -61,6 +62,7 @@ CONFIG_EMBEDDED=y
 # CONFIG_UID16 is not set
 # CONFIG_SYSCTL_SYSCALL is not set
 # CONFIG_KALLSYMS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 # CONFIG_HOTPLUG is not set
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -78,11 +80,14 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_BASE_SMALL=1
@@ -134,6 +139,7 @@ CONFIG_CPU_SUBTYPE_SH7619=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -143,8 +149,6 @@ CONFIG_CPU_SUBTYPE_SH7619=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -513,7 +517,6 @@ CONFIG_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_USB_SUPPORT=y
 CONFIG_USB_ARCH_HAS_HCD=y
 # CONFIG_USB_ARCH_HAS_OHCI is not set
@@ -564,6 +567,11 @@ CONFIG_FILE_LOCKING=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -601,8 +609,13 @@ CONFIG_MISC_FILESYSTEMS=y
 # CONFIG_HPFS_FS is not set
 # CONFIG_QNX4FS_FS is not set
 CONFIG_ROMFS_FS=y
+CONFIG_ROMFS_BACKED_BY_BLOCK=y
+# CONFIG_ROMFS_BACKED_BY_MTD is not set
+# CONFIG_ROMFS_BACKED_BY_BOTH is not set
+CONFIG_ROMFS_ON_BLOCK=y
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 
 #
 # Partition Types
@@ -630,10 +643,21 @@ CONFIG_FRAME_WARN=1024
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -647,6 +671,7 @@ CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SECURITYFS is not set
 # CONFIG_SECURITY_FILE_CAPABILITIES is not set
 # CONFIG_CRYPTO is not set
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/se7705_defconfig b/arch/sh/configs/se7705_defconfig
index 0308abf52384..bae161c66835 100644
--- a/arch/sh/configs/se7705_defconfig
+++ b/arch/sh/configs/se7705_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:45:56 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:02:52 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -62,7 +63,6 @@ CONFIG_INITRAMFS_SOURCE=""
 CONFIG_RD_GZIP=y
 # CONFIG_RD_BZIP2 is not set
 # CONFIG_RD_LZMA is not set
-CONFIG_INITRAMFS_COMPRESSION_NONE=y
 # CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 CONFIG_SYSCTL=y
 CONFIG_ANON_INODES=y
@@ -70,6 +70,7 @@ CONFIG_EMBEDDED=y
 CONFIG_UID16=y
 # CONFIG_SYSCTL_SYSCALL is not set
 # CONFIG_KALLSYMS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 # CONFIG_HOTPLUG is not set
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -88,12 +89,15 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 CONFIG_HAVE_IOREMAP_PROT=y
 CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -150,6 +154,7 @@ CONFIG_CPU_SUBTYPE_SH7705=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -159,8 +164,6 @@ CONFIG_CPU_SUBTYPE_SH7705=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -698,7 +701,6 @@ CONFIG_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_USB_SUPPORT=y
 CONFIG_USB_ARCH_HAS_HCD=y
 # CONFIG_USB_ARCH_HAS_OHCI is not set
@@ -752,6 +754,11 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -804,6 +811,7 @@ CONFIG_JFFS2_RTIME=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 # CONFIG_NFS_V3 is not set
@@ -847,10 +855,23 @@ CONFIG_FRAME_WARN=1024
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_PREEMPT_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -949,6 +970,7 @@ CONFIG_CRYPTO=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/se7712_defconfig b/arch/sh/configs/se7712_defconfig
index a8c24b703489..330043f3c316 100644
--- a/arch/sh/configs/se7712_defconfig
+++ b/arch/sh/configs/se7712_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:48:18 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:03:27 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_FIND_NEXT_BIT=y
@@ -38,6 +39,7 @@ CONFIG_LOCALVERSION=""
 CONFIG_SYSVIPC=y
 CONFIG_SYSVIPC_SYSCTL=y
 CONFIG_POSIX_MQUEUE=y
+CONFIG_POSIX_MQUEUE_SYSCTL=y
 CONFIG_BSD_PROCESS_ACCT=y
 # CONFIG_BSD_PROCESS_ACCT_V3 is not set
 # CONFIG_TASKSTATS is not set
@@ -69,6 +71,7 @@ CONFIG_SYSCTL_SYSCALL=y
 CONFIG_KALLSYMS=y
 CONFIG_KALLSYMS_ALL=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 # CONFIG_BUG is not set
@@ -87,6 +90,7 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
 CONFIG_HAVE_IOREMAP_PROT=y
@@ -94,6 +98,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -105,7 +111,6 @@ CONFIG_MODULES=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -151,6 +156,7 @@ CONFIG_CPU_SUBTYPE_SH7712=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -160,8 +166,6 @@ CONFIG_CPU_SUBTYPE_SH7712=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -585,6 +589,7 @@ CONFIG_SCSI_WAIT_SCAN=m
 CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_ISCSI_TCP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_SCSI_DEBUG is not set
 # CONFIG_SCSI_DH is not set
 # CONFIG_SCSI_OSD_INITIATOR is not set
@@ -812,6 +817,7 @@ CONFIG_EXT2_FS_POSIX_ACL=y
 CONFIG_EXT2_FS_SECURITY=y
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -833,6 +839,11 @@ CONFIG_FILE_LOCKING=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -887,6 +898,7 @@ CONFIG_CRAMFS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 # CONFIG_NFS_V3 is not set
@@ -927,6 +939,7 @@ CONFIG_FRAME_WARN=1024
 CONFIG_DEBUG_KERNEL=y
 # CONFIG_DEBUG_SHIRQ is not set
 # CONFIG_DETECT_SOFTLOCKUP is not set
+# CONFIG_DETECT_HUNG_TASK is not set
 CONFIG_SCHED_DEBUG=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_TIMER_STATS is not set
@@ -961,6 +974,7 @@ CONFIG_SYSCTL_SYSCALL_CHECK=y
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
@@ -969,9 +983,14 @@ CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 # CONFIG_IRQSOFF_TRACER is not set
 # CONFIG_SCHED_TRACER is not set
 # CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
 # CONFIG_BOOT_TRACER is not set
 # CONFIG_TRACE_BRANCH_PROFILING is not set
 # CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_KGDB is not set
@@ -1090,6 +1109,7 @@ CONFIG_CRYPTO_DEFLATE=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/se7721_defconfig b/arch/sh/configs/se7721_defconfig
index 4b79c2567dc8..56478918440d 100644
--- a/arch/sh/configs/se7721_defconfig
+++ b/arch/sh/configs/se7721_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:51:44 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:04:19 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_FIND_NEXT_BIT=y
@@ -38,6 +39,7 @@ CONFIG_LOCALVERSION=""
 CONFIG_SYSVIPC=y
 CONFIG_SYSVIPC_SYSCTL=y
 CONFIG_POSIX_MQUEUE=y
+CONFIG_POSIX_MQUEUE_SYSCTL=y
 CONFIG_BSD_PROCESS_ACCT=y
 # CONFIG_BSD_PROCESS_ACCT_V3 is not set
 # CONFIG_TASKSTATS is not set
@@ -73,6 +75,7 @@ CONFIG_SYSCTL_SYSCALL=y
 CONFIG_KALLSYMS=y
 CONFIG_KALLSYMS_ALL=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 # CONFIG_BUG is not set
@@ -91,6 +94,7 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
 CONFIG_HAVE_IOREMAP_PROT=y
@@ -98,6 +102,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -109,7 +115,6 @@ CONFIG_MODULES=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -155,6 +160,7 @@ CONFIG_CPU_SUBTYPE_SH7721=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -164,8 +170,6 @@ CONFIG_CPU_SUBTYPE_SH7721=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -776,15 +780,17 @@ CONFIG_USB_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_HID_A4TECH=y
 CONFIG_HID_APPLE=y
 CONFIG_HID_BELKIN=y
 CONFIG_HID_CHERRY=y
 CONFIG_HID_CHICONY=y
 CONFIG_HID_CYPRESS=y
+# CONFIG_DRAGONRISE_FF is not set
 CONFIG_HID_EZKEY=y
+# CONFIG_HID_KYE is not set
 CONFIG_HID_GYRATION=y
+# CONFIG_HID_KENSINGTON is not set
 CONFIG_HID_LOGITECH=y
 # CONFIG_LOGITECH_FF is not set
 # CONFIG_LOGIRUMBLEPAD2_FF is not set
@@ -943,6 +949,7 @@ CONFIG_EXT2_FS_POSIX_ACL=y
 CONFIG_EXT2_FS_SECURITY=y
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -964,6 +971,11 @@ CONFIG_FILE_LOCKING=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -1021,6 +1033,7 @@ CONFIG_CRAMFS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 # CONFIG_NETWORK_FILESYSTEMS is not set
 
 #
@@ -1085,6 +1098,7 @@ CONFIG_FRAME_WARN=1024
 CONFIG_DEBUG_KERNEL=y
 # CONFIG_DEBUG_SHIRQ is not set
 # CONFIG_DETECT_SOFTLOCKUP is not set
+# CONFIG_DETECT_HUNG_TASK is not set
 CONFIG_SCHED_DEBUG=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_TIMER_STATS is not set
@@ -1119,6 +1133,7 @@ CONFIG_FRAME_POINTER=y
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
@@ -1127,9 +1142,14 @@ CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 # CONFIG_IRQSOFF_TRACER is not set
 # CONFIG_SCHED_TRACER is not set
 # CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
 # CONFIG_BOOT_TRACER is not set
 # CONFIG_TRACE_BRANCH_PROFILING is not set
 # CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_KGDB is not set
@@ -1248,6 +1268,7 @@ CONFIG_CRYPTO_DEFLATE=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/se7722_defconfig b/arch/sh/configs/se7722_defconfig
index 82bdaac45fb5..726fdbdb2807 100644
--- a/arch/sh/configs/se7722_defconfig
+++ b/arch/sh/configs/se7722_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:55:10 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:05:29 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -69,7 +70,6 @@ CONFIG_INITRAMFS_SOURCE=""
 CONFIG_RD_GZIP=y
 # CONFIG_RD_BZIP2 is not set
 # CONFIG_RD_LZMA is not set
-CONFIG_INITRAMFS_COMPRESSION_NONE=y
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
 CONFIG_SYSCTL=y
 CONFIG_ANON_INODES=y
@@ -78,6 +78,7 @@ CONFIG_UID16=y
 CONFIG_SYSCTL_SYSCALL=y
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -97,6 +98,7 @@ CONFIG_COMPAT_BRK=y
 CONFIG_SLUB=y
 # CONFIG_SLOB is not set
 CONFIG_PROFILING=y
+# CONFIG_MARKERS is not set
 # CONFIG_OPROFILE is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
@@ -105,6 +107,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -117,7 +121,6 @@ CONFIG_MODULE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -167,6 +170,7 @@ CONFIG_ARCH_SHMOBILE=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -176,8 +180,6 @@ CONFIG_ARCH_SHMOBILE=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 CONFIG_CPU_SUBTYPE_SH7722=y
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -486,6 +488,7 @@ CONFIG_SCSI_WAIT_SCAN=m
 CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_ISCSI_TCP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_SCSI_DEBUG is not set
 # CONFIG_SCSI_DH is not set
 # CONFIG_SCSI_OSD_INITIATOR is not set
@@ -692,7 +695,6 @@ CONFIG_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_USB_SUPPORT=y
 CONFIG_USB_ARCH_HAS_HCD=y
 # CONFIG_USB_ARCH_HAS_OHCI is not set
@@ -766,6 +768,7 @@ CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -789,6 +792,11 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -832,6 +840,7 @@ CONFIG_MISC_FILESYSTEMS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 # CONFIG_NFS_FS is not set
 # CONFIG_NFSD is not set
@@ -872,11 +881,25 @@ CONFIG_DEBUG_FS=y
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_PREEMPT_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 CONFIG_SH_STANDARD_BIOS=y
@@ -977,6 +1000,7 @@ CONFIG_CRYPTO=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/se7724_defconfig b/arch/sh/configs/se7724_defconfig
new file mode 100644
index 000000000000..96d2587467e6
--- /dev/null
+++ b/arch/sh/configs/se7724_defconfig
@@ -0,0 +1,1552 @@
+#
+# Automatically generated make config: don't edit
+# Linux kernel version: 2.6.30-rc6
+# Tue May 26 13:18:09 2009
+#
+CONFIG_SUPERH=y
+CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
+CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
+CONFIG_RWSEM_GENERIC_SPINLOCK=y
+CONFIG_GENERIC_BUG=y
+CONFIG_GENERIC_FIND_NEXT_BIT=y
+CONFIG_GENERIC_HWEIGHT=y
+CONFIG_GENERIC_HARDIRQS=y
+CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ=y
+CONFIG_GENERIC_IRQ_PROBE=y
+CONFIG_GENERIC_GPIO=y
+CONFIG_GENERIC_TIME=y
+CONFIG_GENERIC_CLOCKEVENTS=y
+CONFIG_ARCH_SUSPEND_POSSIBLE=y
+CONFIG_ARCH_HIBERNATION_POSSIBLE=y
+CONFIG_SYS_SUPPORTS_CMT=y
+CONFIG_SYS_SUPPORTS_TMU=y
+CONFIG_STACKTRACE_SUPPORT=y
+CONFIG_LOCKDEP_SUPPORT=y
+CONFIG_HAVE_LATENCYTOP_SUPPORT=y
+# CONFIG_ARCH_HAS_ILOG2_U32 is not set
+# CONFIG_ARCH_HAS_ILOG2_U64 is not set
+CONFIG_ARCH_NO_VIRT_TO_BUS=y
+CONFIG_ARCH_HAS_DEFAULT_IDLE=y
+CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config"
+
+#
+# General setup
+#
+CONFIG_EXPERIMENTAL=y
+CONFIG_BROKEN_ON_SMP=y
+CONFIG_LOCK_KERNEL=y
+CONFIG_INIT_ENV_ARG_LIMIT=32
+CONFIG_LOCALVERSION=""
+# CONFIG_LOCALVERSION_AUTO is not set
+CONFIG_SWAP=y
+CONFIG_SYSVIPC=y
+CONFIG_SYSVIPC_SYSCTL=y
+# CONFIG_POSIX_MQUEUE is not set
+CONFIG_BSD_PROCESS_ACCT=y
+# CONFIG_BSD_PROCESS_ACCT_V3 is not set
+# CONFIG_TASKSTATS is not set
+# CONFIG_AUDIT is not set
+
+#
+# RCU Subsystem
+#
+CONFIG_CLASSIC_RCU=y
+# CONFIG_TREE_RCU is not set
+# CONFIG_PREEMPT_RCU is not set
+# CONFIG_TREE_RCU_TRACE is not set
+# CONFIG_PREEMPT_RCU_TRACE is not set
+# CONFIG_IKCONFIG is not set
+CONFIG_LOG_BUF_SHIFT=14
+CONFIG_GROUP_SCHED=y
+CONFIG_FAIR_GROUP_SCHED=y
+# CONFIG_RT_GROUP_SCHED is not set
+CONFIG_USER_SCHED=y
+# CONFIG_CGROUP_SCHED is not set
+# CONFIG_CGROUPS is not set
+CONFIG_SYSFS_DEPRECATED=y
+CONFIG_SYSFS_DEPRECATED_V2=y
+# CONFIG_RELAY is not set
+# CONFIG_NAMESPACES is not set
+# CONFIG_BLK_DEV_INITRD is not set
+CONFIG_CC_OPTIMIZE_FOR_SIZE=y
+CONFIG_SYSCTL=y
+CONFIG_ANON_INODES=y
+CONFIG_EMBEDDED=y
+CONFIG_UID16=y
+CONFIG_SYSCTL_SYSCALL=y
+# CONFIG_KALLSYMS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
+CONFIG_HOTPLUG=y
+CONFIG_PRINTK=y
+CONFIG_BUG=y
+CONFIG_ELF_CORE=y
+CONFIG_BASE_FULL=y
+CONFIG_FUTEX=y
+CONFIG_EPOLL=y
+CONFIG_SIGNALFD=y
+CONFIG_TIMERFD=y
+CONFIG_EVENTFD=y
+CONFIG_SHMEM=y
+CONFIG_AIO=y
+CONFIG_VM_EVENT_COUNTERS=y
+CONFIG_COMPAT_BRK=y
+CONFIG_SLAB=y
+# CONFIG_SLUB is not set
+# CONFIG_SLOB is not set
+# CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
+CONFIG_HAVE_OPROFILE=y
+CONFIG_HAVE_IOREMAP_PROT=y
+CONFIG_HAVE_KPROBES=y
+CONFIG_HAVE_KRETPROBES=y
+CONFIG_HAVE_ARCH_TRACEHOOK=y
+CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
+CONFIG_HAVE_GENERIC_DMA_COHERENT=y
+CONFIG_SLABINFO=y
+CONFIG_RT_MUTEXES=y
+CONFIG_BASE_SMALL=0
+CONFIG_MODULES=y
+# CONFIG_MODULE_FORCE_LOAD is not set
+CONFIG_MODULE_UNLOAD=y
+# CONFIG_MODULE_FORCE_UNLOAD is not set
+# CONFIG_MODVERSIONS is not set
+# CONFIG_MODULE_SRCVERSION_ALL is not set
+CONFIG_BLOCK=y
+# CONFIG_LBD is not set
+# CONFIG_BLK_DEV_BSG is not set
+# CONFIG_BLK_DEV_INTEGRITY is not set
+
+#
+# IO Schedulers
+#
+CONFIG_IOSCHED_NOOP=y
+CONFIG_IOSCHED_AS=y
+CONFIG_IOSCHED_DEADLINE=y
+CONFIG_IOSCHED_CFQ=y
+# CONFIG_DEFAULT_AS is not set
+# CONFIG_DEFAULT_DEADLINE is not set
+CONFIG_DEFAULT_CFQ=y
+# CONFIG_DEFAULT_NOOP is not set
+CONFIG_DEFAULT_IOSCHED="cfq"
+# CONFIG_FREEZER is not set
+
+#
+# System type
+#
+CONFIG_CPU_SH4=y
+CONFIG_CPU_SH4A=y
+CONFIG_CPU_SHX2=y
+CONFIG_ARCH_SHMOBILE=y
+# CONFIG_CPU_SUBTYPE_SH7619 is not set
+# CONFIG_CPU_SUBTYPE_SH7201 is not set
+# CONFIG_CPU_SUBTYPE_SH7203 is not set
+# CONFIG_CPU_SUBTYPE_SH7206 is not set
+# CONFIG_CPU_SUBTYPE_SH7263 is not set
+# CONFIG_CPU_SUBTYPE_MXG is not set
+# CONFIG_CPU_SUBTYPE_SH7705 is not set
+# CONFIG_CPU_SUBTYPE_SH7706 is not set
+# CONFIG_CPU_SUBTYPE_SH7707 is not set
+# CONFIG_CPU_SUBTYPE_SH7708 is not set
+# CONFIG_CPU_SUBTYPE_SH7709 is not set
+# CONFIG_CPU_SUBTYPE_SH7710 is not set
+# CONFIG_CPU_SUBTYPE_SH7712 is not set
+# CONFIG_CPU_SUBTYPE_SH7720 is not set
+# CONFIG_CPU_SUBTYPE_SH7721 is not set
+# CONFIG_CPU_SUBTYPE_SH7750 is not set
+# CONFIG_CPU_SUBTYPE_SH7091 is not set
+# CONFIG_CPU_SUBTYPE_SH7750R is not set
+# CONFIG_CPU_SUBTYPE_SH7750S is not set
+# CONFIG_CPU_SUBTYPE_SH7751 is not set
+# CONFIG_CPU_SUBTYPE_SH7751R is not set
+# CONFIG_CPU_SUBTYPE_SH7760 is not set
+# CONFIG_CPU_SUBTYPE_SH4_202 is not set
+# CONFIG_CPU_SUBTYPE_SH7723 is not set
+CONFIG_CPU_SUBTYPE_SH7724=y
+# CONFIG_CPU_SUBTYPE_SH7763 is not set
+# CONFIG_CPU_SUBTYPE_SH7770 is not set
+# CONFIG_CPU_SUBTYPE_SH7780 is not set
+# CONFIG_CPU_SUBTYPE_SH7785 is not set
+# CONFIG_CPU_SUBTYPE_SH7786 is not set
+# CONFIG_CPU_SUBTYPE_SHX3 is not set
+# CONFIG_CPU_SUBTYPE_SH7343 is not set
+# CONFIG_CPU_SUBTYPE_SH7722 is not set
+# CONFIG_CPU_SUBTYPE_SH7366 is not set
+
+#
+# Memory management options
+#
+CONFIG_QUICKLIST=y
+CONFIG_MMU=y
+CONFIG_PAGE_OFFSET=0x80000000
+CONFIG_FORCE_MAX_ZONEORDER=11
+CONFIG_MEMORY_START=0x08000000
+CONFIG_MEMORY_SIZE=0x08000000
+CONFIG_29BIT=y
+# CONFIG_X2TLB is not set
+CONFIG_VSYSCALL=y
+CONFIG_ARCH_FLATMEM_ENABLE=y
+CONFIG_ARCH_SPARSEMEM_ENABLE=y
+CONFIG_ARCH_SPARSEMEM_DEFAULT=y
+CONFIG_MAX_ACTIVE_REGIONS=1
+CONFIG_ARCH_POPULATES_NODE_MAP=y
+CONFIG_ARCH_SELECT_MEMORY_MODEL=y
+CONFIG_PAGE_SIZE_4KB=y
+# CONFIG_PAGE_SIZE_8KB is not set
+# CONFIG_PAGE_SIZE_16KB is not set
+# CONFIG_PAGE_SIZE_64KB is not set
+CONFIG_SELECT_MEMORY_MODEL=y
+CONFIG_FLATMEM_MANUAL=y
+# CONFIG_DISCONTIGMEM_MANUAL is not set
+# CONFIG_SPARSEMEM_MANUAL is not set
+CONFIG_FLATMEM=y
+CONFIG_FLAT_NODE_MEM_MAP=y
+CONFIG_SPARSEMEM_STATIC=y
+CONFIG_PAGEFLAGS_EXTENDED=y
+CONFIG_SPLIT_PTLOCK_CPUS=4
+# CONFIG_PHYS_ADDR_T_64BIT is not set
+CONFIG_ZONE_DMA_FLAG=0
+CONFIG_NR_QUICK=2
+CONFIG_UNEVICTABLE_LRU=y
+CONFIG_HAVE_MLOCK=y
+CONFIG_HAVE_MLOCKED_PAGE_BIT=y
+
+#
+# Cache configuration
+#
+CONFIG_CACHE_WRITEBACK=y
+# CONFIG_CACHE_WRITETHROUGH is not set
+# CONFIG_CACHE_OFF is not set
+
+#
+# Processor features
+#
+CONFIG_CPU_LITTLE_ENDIAN=y
+# CONFIG_CPU_BIG_ENDIAN is not set
+CONFIG_SH_FPU=y
+# CONFIG_SH_STORE_QUEUES is not set
+CONFIG_CPU_HAS_INTEVT=y
+CONFIG_CPU_HAS_SR_RB=y
+CONFIG_CPU_HAS_PTEA=y
+CONFIG_CPU_HAS_FPU=y
+
+#
+# Board support
+#
+CONFIG_SOLUTION_ENGINE=y
+CONFIG_SH_7724_SOLUTION_ENGINE=y
+
+#
+# Timer and clock configuration
+#
+CONFIG_SH_TIMER_TMU=y
+# CONFIG_SH_TIMER_CMT is not set
+CONFIG_SH_PCLK_FREQ=33333333
+# CONFIG_NO_HZ is not set
+# CONFIG_HIGH_RES_TIMERS is not set
+CONFIG_GENERIC_CLOCKEVENTS_BUILD=y
+
+#
+# CPU Frequency scaling
+#
+# CONFIG_CPU_FREQ is not set
+
+#
+# DMA support
+#
+# CONFIG_SH_DMA is not set
+
+#
+# Companion Chips
+#
+
+#
+# Additional SuperH Device Drivers
+#
+CONFIG_HEARTBEAT=y
+# CONFIG_PUSH_SWITCH is not set
+
+#
+# Kernel features
+#
+# CONFIG_HZ_100 is not set
+CONFIG_HZ_250=y
+# CONFIG_HZ_300 is not set
+# CONFIG_HZ_1000 is not set
+CONFIG_HZ=250
+# CONFIG_SCHED_HRTICK is not set
+# CONFIG_KEXEC is not set
+# CONFIG_CRASH_DUMP is not set
+CONFIG_SECCOMP=y
+# CONFIG_PREEMPT_NONE is not set
+# CONFIG_PREEMPT_VOLUNTARY is not set
+CONFIG_PREEMPT=y
+CONFIG_GUSA=y
+
+#
+# Boot options
+#
+CONFIG_ZERO_PAGE_OFFSET=0x00001000
+CONFIG_BOOT_LINK_OFFSET=0x00800000
+CONFIG_ENTRY_OFFSET=0x00001000
+CONFIG_CMDLINE_BOOL=y
+CONFIG_CMDLINE="console=tty1 console=ttySC3,115200 root=/dev/nfs ip=dhcp memchunk.vpu=4m"
+
+#
+# Bus options
+#
+# CONFIG_ARCH_SUPPORTS_MSI is not set
+# CONFIG_PCCARD is not set
+
+#
+# Executable file formats
+#
+CONFIG_BINFMT_ELF=y
+# CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS is not set
+# CONFIG_HAVE_AOUT is not set
+# CONFIG_BINFMT_MISC is not set
+
+#
+# Power management options (EXPERIMENTAL)
+#
+# CONFIG_PM is not set
+# CONFIG_CPU_IDLE is not set
+CONFIG_NET=y
+
+#
+# Networking options
+#
+CONFIG_PACKET=y
+# CONFIG_PACKET_MMAP is not set
+CONFIG_UNIX=y
+# CONFIG_NET_KEY is not set
+CONFIG_INET=y
+# CONFIG_IP_MULTICAST is not set
+CONFIG_IP_ADVANCED_ROUTER=y
+CONFIG_ASK_IP_FIB_HASH=y
+# CONFIG_IP_FIB_TRIE is not set
+CONFIG_IP_FIB_HASH=y
+# CONFIG_IP_MULTIPLE_TABLES is not set
+# CONFIG_IP_ROUTE_MULTIPATH is not set
+# CONFIG_IP_ROUTE_VERBOSE is not set
+CONFIG_IP_PNP=y
+CONFIG_IP_PNP_DHCP=y
+# CONFIG_IP_PNP_BOOTP is not set
+# CONFIG_IP_PNP_RARP is not set
+# CONFIG_NET_IPIP is not set
+# CONFIG_NET_IPGRE is not set
+# CONFIG_ARPD is not set
+# CONFIG_SYN_COOKIES is not set
+# CONFIG_INET_AH is not set
+# CONFIG_INET_ESP is not set
+# CONFIG_INET_IPCOMP is not set
+# CONFIG_INET_XFRM_TUNNEL is not set
+# CONFIG_INET_TUNNEL is not set
+# CONFIG_INET_XFRM_MODE_TRANSPORT is not set
+# CONFIG_INET_XFRM_MODE_TUNNEL is not set
+# CONFIG_INET_XFRM_MODE_BEET is not set
+# CONFIG_INET_LRO is not set
+CONFIG_INET_DIAG=y
+CONFIG_INET_TCP_DIAG=y
+# CONFIG_TCP_CONG_ADVANCED is not set
+CONFIG_TCP_CONG_CUBIC=y
+CONFIG_DEFAULT_TCP_CONG="cubic"
+# CONFIG_TCP_MD5SIG is not set
+# CONFIG_IPV6 is not set
+# CONFIG_NETWORK_SECMARK is not set
+# CONFIG_NETFILTER is not set
+# CONFIG_IP_DCCP is not set
+# CONFIG_IP_SCTP is not set
+# CONFIG_TIPC is not set
+# CONFIG_ATM is not set
+# CONFIG_BRIDGE is not set
+# CONFIG_NET_DSA is not set
+# CONFIG_VLAN_8021Q is not set
+# CONFIG_DECNET is not set
+# CONFIG_LLC2 is not set
+# CONFIG_IPX is not set
+# CONFIG_ATALK is not set
+# CONFIG_X25 is not set
+# CONFIG_LAPB is not set
+# CONFIG_ECONET is not set
+# CONFIG_WAN_ROUTER is not set
+# CONFIG_PHONET is not set
+# CONFIG_NET_SCHED is not set
+# CONFIG_DCB is not set
+
+#
+# Network testing
+#
+# CONFIG_NET_PKTGEN is not set
+# CONFIG_HAMRADIO is not set
+# CONFIG_CAN is not set
+# CONFIG_IRDA is not set
+# CONFIG_BT is not set
+# CONFIG_AF_RXRPC is not set
+CONFIG_WIRELESS=y
+# CONFIG_CFG80211 is not set
+# CONFIG_WIRELESS_OLD_REGULATORY is not set
+# CONFIG_WIRELESS_EXT is not set
+# CONFIG_LIB80211 is not set
+# CONFIG_MAC80211 is not set
+# CONFIG_WIMAX is not set
+# CONFIG_RFKILL is not set
+# CONFIG_NET_9P is not set
+
+#
+# Device Drivers
+#
+
+#
+# Generic Driver Options
+#
+CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
+CONFIG_STANDALONE=y
+CONFIG_PREVENT_FIRMWARE_BUILD=y
+CONFIG_FW_LOADER=y
+CONFIG_FIRMWARE_IN_KERNEL=y
+CONFIG_EXTRA_FIRMWARE=""
+# CONFIG_SYS_HYPERVISOR is not set
+# CONFIG_CONNECTOR is not set
+CONFIG_MTD=y
+# CONFIG_MTD_DEBUG is not set
+CONFIG_MTD_CONCAT=y
+CONFIG_MTD_PARTITIONS=y
+# CONFIG_MTD_TESTS is not set
+# CONFIG_MTD_REDBOOT_PARTS is not set
+CONFIG_MTD_CMDLINE_PARTS=y
+# CONFIG_MTD_AR7_PARTS is not set
+
+#
+# User Modules And Translation Layers
+#
+CONFIG_MTD_CHAR=y
+CONFIG_MTD_BLKDEVS=y
+CONFIG_MTD_BLOCK=y
+# CONFIG_FTL is not set
+# CONFIG_NFTL is not set
+# CONFIG_INFTL is not set
+# CONFIG_RFD_FTL is not set
+# CONFIG_SSFDC is not set
+# CONFIG_MTD_OOPS is not set
+
+#
+# RAM/ROM/Flash chip drivers
+#
+CONFIG_MTD_CFI=y
+# CONFIG_MTD_JEDECPROBE is not set
+CONFIG_MTD_GEN_PROBE=y
+# CONFIG_MTD_CFI_ADV_OPTIONS is not set
+CONFIG_MTD_MAP_BANK_WIDTH_1=y
+CONFIG_MTD_MAP_BANK_WIDTH_2=y
+CONFIG_MTD_MAP_BANK_WIDTH_4=y
+# CONFIG_MTD_MAP_BANK_WIDTH_8 is not set
+# CONFIG_MTD_MAP_BANK_WIDTH_16 is not set
+# CONFIG_MTD_MAP_BANK_WIDTH_32 is not set
+CONFIG_MTD_CFI_I1=y
+CONFIG_MTD_CFI_I2=y
+# CONFIG_MTD_CFI_I4 is not set
+# CONFIG_MTD_CFI_I8 is not set
+# CONFIG_MTD_CFI_INTELEXT is not set
+CONFIG_MTD_CFI_AMDSTD=y
+# CONFIG_MTD_CFI_STAA is not set
+CONFIG_MTD_CFI_UTIL=y
+# CONFIG_MTD_RAM is not set
+# CONFIG_MTD_ROM is not set
+# CONFIG_MTD_ABSENT is not set
+
+#
+# Mapping drivers for chip access
+#
+# CONFIG_MTD_COMPLEX_MAPPINGS is not set
+CONFIG_MTD_PHYSMAP=y
+# CONFIG_MTD_PHYSMAP_COMPAT is not set
+# CONFIG_MTD_PLATRAM is not set
+
+#
+# Self-contained MTD device drivers
+#
+# CONFIG_MTD_DATAFLASH is not set
+# CONFIG_MTD_M25P80 is not set
+# CONFIG_MTD_SLRAM is not set
+# CONFIG_MTD_PHRAM is not set
+# CONFIG_MTD_MTDRAM is not set
+# CONFIG_MTD_BLOCK2MTD is not set
+
+#
+# Disk-On-Chip Device Drivers
+#
+# CONFIG_MTD_DOC2000 is not set
+# CONFIG_MTD_DOC2001 is not set
+# CONFIG_MTD_DOC2001PLUS is not set
+CONFIG_MTD_NAND=y
+# CONFIG_MTD_NAND_VERIFY_WRITE is not set
+# CONFIG_MTD_NAND_ECC_SMC is not set
+# CONFIG_MTD_NAND_MUSEUM_IDS is not set
+CONFIG_MTD_NAND_IDS=y
+# CONFIG_MTD_NAND_DISKONCHIP is not set
+# CONFIG_MTD_NAND_NANDSIM is not set
+# CONFIG_MTD_NAND_PLATFORM is not set
+# CONFIG_MTD_ALAUDA is not set
+# CONFIG_MTD_ONENAND is not set
+
+#
+# LPDDR flash memory drivers
+#
+# CONFIG_MTD_LPDDR is not set
+
+#
+# UBI - Unsorted block images
+#
+CONFIG_MTD_UBI=y
+CONFIG_MTD_UBI_WL_THRESHOLD=4096
+CONFIG_MTD_UBI_BEB_RESERVE=1
+# CONFIG_MTD_UBI_GLUEBI is not set
+
+#
+# UBI debugging options
+#
+# CONFIG_MTD_UBI_DEBUG is not set
+# CONFIG_PARPORT is not set
+CONFIG_BLK_DEV=y
+# CONFIG_BLK_DEV_COW_COMMON is not set
+# CONFIG_BLK_DEV_LOOP is not set
+# CONFIG_BLK_DEV_NBD is not set
+# CONFIG_BLK_DEV_UB is not set
+CONFIG_BLK_DEV_RAM=y
+CONFIG_BLK_DEV_RAM_COUNT=4
+CONFIG_BLK_DEV_RAM_SIZE=4096
+# CONFIG_BLK_DEV_XIP is not set
+# CONFIG_CDROM_PKTCDVD is not set
+# CONFIG_ATA_OVER_ETH is not set
+# CONFIG_BLK_DEV_HD is not set
+CONFIG_MISC_DEVICES=y
+# CONFIG_ICS932S401 is not set
+# CONFIG_ENCLOSURE_SERVICES is not set
+# CONFIG_ISL29003 is not set
+# CONFIG_C2PORT is not set
+
+#
+# EEPROM support
+#
+# CONFIG_EEPROM_AT24 is not set
+# CONFIG_EEPROM_AT25 is not set
+# CONFIG_EEPROM_LEGACY is not set
+# CONFIG_EEPROM_93CX6 is not set
+CONFIG_HAVE_IDE=y
+# CONFIG_IDE is not set
+
+#
+# SCSI device support
+#
+# CONFIG_RAID_ATTRS is not set
+CONFIG_SCSI=y
+CONFIG_SCSI_DMA=y
+# CONFIG_SCSI_TGT is not set
+# CONFIG_SCSI_NETLINK is not set
+CONFIG_SCSI_PROC_FS=y
+
+#
+# SCSI support type (disk, tape, CD-ROM)
+#
+CONFIG_BLK_DEV_SD=y
+# CONFIG_CHR_DEV_ST is not set
+# CONFIG_CHR_DEV_OSST is not set
+# CONFIG_BLK_DEV_SR is not set
+# CONFIG_CHR_DEV_SG is not set
+# CONFIG_CHR_DEV_SCH is not set
+
+#
+# Some SCSI devices (e.g. CD jukebox) support multiple LUNs
+#
+# CONFIG_SCSI_MULTI_LUN is not set
+# CONFIG_SCSI_CONSTANTS is not set
+# CONFIG_SCSI_LOGGING is not set
+# CONFIG_SCSI_SCAN_ASYNC is not set
+CONFIG_SCSI_WAIT_SCAN=m
+
+#
+# SCSI Transports
+#
+# CONFIG_SCSI_SPI_ATTRS is not set
+# CONFIG_SCSI_FC_ATTRS is not set
+# CONFIG_SCSI_ISCSI_ATTRS is not set
+# CONFIG_SCSI_SAS_LIBSAS is not set
+# CONFIG_SCSI_SRP_ATTRS is not set
+CONFIG_SCSI_LOWLEVEL=y
+# CONFIG_ISCSI_TCP is not set
+# CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
+# CONFIG_SCSI_DEBUG is not set
+# CONFIG_SCSI_DH is not set
+# CONFIG_SCSI_OSD_INITIATOR is not set
+# CONFIG_ATA is not set
+# CONFIG_MD is not set
+CONFIG_NETDEVICES=y
+CONFIG_COMPAT_NET_DEV_OPS=y
+# CONFIG_DUMMY is not set
+# CONFIG_BONDING is not set
+# CONFIG_MACVLAN is not set
+# CONFIG_EQUALIZER is not set
+# CONFIG_TUN is not set
+# CONFIG_VETH is not set
+CONFIG_PHYLIB=y
+
+#
+# MII PHY device drivers
+#
+# CONFIG_MARVELL_PHY is not set
+# CONFIG_DAVICOM_PHY is not set
+# CONFIG_QSEMI_PHY is not set
+# CONFIG_LXT_PHY is not set
+# CONFIG_CICADA_PHY is not set
+# CONFIG_VITESSE_PHY is not set
+CONFIG_SMSC_PHY=y
+# CONFIG_BROADCOM_PHY is not set
+# CONFIG_ICPLUS_PHY is not set
+# CONFIG_REALTEK_PHY is not set
+# CONFIG_NATIONAL_PHY is not set
+# CONFIG_STE10XP is not set
+# CONFIG_LSI_ET1011C_PHY is not set
+# CONFIG_FIXED_PHY is not set
+CONFIG_MDIO_BITBANG=y
+# CONFIG_MDIO_GPIO is not set
+CONFIG_NET_ETHERNET=y
+CONFIG_MII=y
+# CONFIG_AX88796 is not set
+# CONFIG_STNIC is not set
+CONFIG_SMC91X=y
+# CONFIG_ENC28J60 is not set
+# CONFIG_ETHOC is not set
+# CONFIG_SMC911X is not set
+# CONFIG_SMSC911X is not set
+# CONFIG_DNET is not set
+# CONFIG_IBM_NEW_EMAC_ZMII is not set
+# CONFIG_IBM_NEW_EMAC_RGMII is not set
+# CONFIG_IBM_NEW_EMAC_TAH is not set
+# CONFIG_IBM_NEW_EMAC_EMAC4 is not set
+# CONFIG_IBM_NEW_EMAC_NO_FLOW_CTRL is not set
+# CONFIG_IBM_NEW_EMAC_MAL_CLR_ICINTSTAT is not set
+# CONFIG_IBM_NEW_EMAC_MAL_COMMON_ERR is not set
+# CONFIG_B44 is not set
+# CONFIG_NETDEV_1000 is not set
+# CONFIG_NETDEV_10000 is not set
+
+#
+# Wireless LAN
+#
+# CONFIG_WLAN_PRE80211 is not set
+# CONFIG_WLAN_80211 is not set
+
+#
+# Enable WiMAX (Networking options) to see the WiMAX drivers
+#
+
+#
+# USB Network Adapters
+#
+# CONFIG_USB_CATC is not set
+# CONFIG_USB_KAWETH is not set
+# CONFIG_USB_PEGASUS is not set
+# CONFIG_USB_RTL8150 is not set
+# CONFIG_USB_USBNET is not set
+# CONFIG_WAN is not set
+# CONFIG_PPP is not set
+# CONFIG_SLIP is not set
+# CONFIG_NETCONSOLE is not set
+# CONFIG_NETPOLL is not set
+# CONFIG_NET_POLL_CONTROLLER is not set
+# CONFIG_ISDN is not set
+# CONFIG_PHONE is not set
+
+#
+# Input device support
+#
+CONFIG_INPUT=y
+# CONFIG_INPUT_FF_MEMLESS is not set
+# CONFIG_INPUT_POLLDEV is not set
+
+#
+# Userland interfaces
+#
+# CONFIG_INPUT_MOUSEDEV is not set
+# CONFIG_INPUT_JOYDEV is not set
+CONFIG_INPUT_EVDEV=y
+# CONFIG_INPUT_EVBUG is not set
+
+#
+# Input Device Drivers
+#
+CONFIG_INPUT_KEYBOARD=y
+# CONFIG_KEYBOARD_ATKBD is not set
+# CONFIG_KEYBOARD_SUNKBD is not set
+# CONFIG_KEYBOARD_LKKBD is not set
+# CONFIG_KEYBOARD_XTKBD is not set
+# CONFIG_KEYBOARD_NEWTON is not set
+# CONFIG_KEYBOARD_STOWAWAY is not set
+# CONFIG_KEYBOARD_GPIO is not set
+CONFIG_KEYBOARD_SH_KEYSC=y
+# CONFIG_INPUT_MOUSE is not set
+# CONFIG_INPUT_JOYSTICK is not set
+# CONFIG_INPUT_TABLET is not set
+# CONFIG_INPUT_TOUCHSCREEN is not set
+# CONFIG_INPUT_MISC is not set
+
+#
+# Hardware I/O ports
+#
+# CONFIG_SERIO is not set
+# CONFIG_GAMEPORT is not set
+
+#
+# Character devices
+#
+CONFIG_VT=y
+CONFIG_CONSOLE_TRANSLATIONS=y
+CONFIG_VT_CONSOLE=y
+CONFIG_HW_CONSOLE=y
+CONFIG_VT_HW_CONSOLE_BINDING=y
+CONFIG_DEVKMEM=y
+# CONFIG_SERIAL_NONSTANDARD is not set
+
+#
+# Serial drivers
+#
+# CONFIG_SERIAL_8250 is not set
+
+#
+# Non-8250 serial port support
+#
+# CONFIG_SERIAL_MAX3100 is not set
+CONFIG_SERIAL_SH_SCI=y
+CONFIG_SERIAL_SH_SCI_NR_UARTS=6
+CONFIG_SERIAL_SH_SCI_CONSOLE=y
+CONFIG_SERIAL_CORE=y
+CONFIG_SERIAL_CORE_CONSOLE=y
+CONFIG_UNIX98_PTYS=y
+# CONFIG_DEVPTS_MULTIPLE_INSTANCES is not set
+CONFIG_LEGACY_PTYS=y
+CONFIG_LEGACY_PTY_COUNT=256
+# CONFIG_IPMI_HANDLER is not set
+CONFIG_HW_RANDOM=y
+# CONFIG_HW_RANDOM_TIMERIOMEM is not set
+# CONFIG_R3964 is not set
+# CONFIG_RAW_DRIVER is not set
+# CONFIG_TCG_TPM is not set
+CONFIG_I2C=y
+CONFIG_I2C_BOARDINFO=y
+CONFIG_I2C_CHARDEV=y
+CONFIG_I2C_HELPER_AUTO=y
+
+#
+# I2C Hardware Bus support
+#
+
+#
+# I2C system bus drivers (mostly embedded / system-on-chip)
+#
+# CONFIG_I2C_GPIO is not set
+# CONFIG_I2C_OCORES is not set
+CONFIG_I2C_SH_MOBILE=y
+# CONFIG_I2C_SIMTEC is not set
+
+#
+# External I2C/SMBus adapter drivers
+#
+# CONFIG_I2C_PARPORT_LIGHT is not set
+# CONFIG_I2C_TAOS_EVM is not set
+# CONFIG_I2C_TINY_USB is not set
+
+#
+# Other I2C/SMBus bus drivers
+#
+# CONFIG_I2C_PCA_PLATFORM is not set
+# CONFIG_I2C_STUB is not set
+
+#
+# Miscellaneous I2C Chip support
+#
+# CONFIG_DS1682 is not set
+# CONFIG_SENSORS_PCF8574 is not set
+# CONFIG_PCF8575 is not set
+# CONFIG_SENSORS_PCA9539 is not set
+# CONFIG_SENSORS_MAX6875 is not set
+# CONFIG_SENSORS_TSL2550 is not set
+# CONFIG_I2C_DEBUG_CORE is not set
+# CONFIG_I2C_DEBUG_ALGO is not set
+# CONFIG_I2C_DEBUG_BUS is not set
+# CONFIG_I2C_DEBUG_CHIP is not set
+CONFIG_SPI=y
+CONFIG_SPI_MASTER=y
+
+#
+# SPI Master Controller Drivers
+#
+CONFIG_SPI_BITBANG=y
+# CONFIG_SPI_GPIO is not set
+# CONFIG_SPI_SH_SCI is not set
+
+#
+# SPI Protocol Masters
+#
+# CONFIG_SPI_SPIDEV is not set
+# CONFIG_SPI_TLE62X0 is not set
+CONFIG_ARCH_REQUIRE_GPIOLIB=y
+CONFIG_GPIOLIB=y
+# CONFIG_GPIO_SYSFS is not set
+
+#
+# Memory mapped GPIO expanders:
+#
+
+#
+# I2C GPIO expanders:
+#
+# CONFIG_GPIO_MAX732X is not set
+# CONFIG_GPIO_PCA953X is not set
+# CONFIG_GPIO_PCF857X is not set
+
+#
+# PCI GPIO expanders:
+#
+
+#
+# SPI GPIO expanders:
+#
+# CONFIG_GPIO_MAX7301 is not set
+# CONFIG_GPIO_MCP23S08 is not set
+# CONFIG_W1 is not set
+# CONFIG_POWER_SUPPLY is not set
+# CONFIG_HWMON is not set
+# CONFIG_THERMAL is not set
+# CONFIG_THERMAL_HWMON is not set
+# CONFIG_WATCHDOG is not set
+CONFIG_SSB_POSSIBLE=y
+
+#
+# Sonics Silicon Backplane
+#
+# CONFIG_SSB is not set
+
+#
+# Multifunction device drivers
+#
+# CONFIG_MFD_CORE is not set
+# CONFIG_MFD_SM501 is not set
+# CONFIG_HTC_PASIC3 is not set
+# CONFIG_TPS65010 is not set
+# CONFIG_TWL4030_CORE is not set
+# CONFIG_MFD_TMIO is not set
+# CONFIG_PMIC_DA903X is not set
+# CONFIG_MFD_WM8400 is not set
+# CONFIG_MFD_WM8350_I2C is not set
+# CONFIG_MFD_PCF50633 is not set
+# CONFIG_REGULATOR is not set
+
+#
+# Multimedia devices
+#
+
+#
+# Multimedia core support
+#
+CONFIG_VIDEO_DEV=y
+CONFIG_VIDEO_V4L2_COMMON=y
+# CONFIG_VIDEO_ALLOW_V4L1 is not set
+CONFIG_VIDEO_V4L1_COMPAT=y
+# CONFIG_DVB_CORE is not set
+CONFIG_VIDEO_MEDIA=y
+
+#
+# Multimedia drivers
+#
+# CONFIG_MEDIA_ATTACH is not set
+CONFIG_MEDIA_TUNER=y
+# CONFIG_MEDIA_TUNER_CUSTOMISE is not set
+CONFIG_MEDIA_TUNER_SIMPLE=y
+CONFIG_MEDIA_TUNER_TDA8290=y
+CONFIG_MEDIA_TUNER_TDA9887=y
+CONFIG_MEDIA_TUNER_TEA5761=y
+CONFIG_MEDIA_TUNER_TEA5767=y
+CONFIG_MEDIA_TUNER_MT20XX=y
+CONFIG_MEDIA_TUNER_XC2028=y
+CONFIG_MEDIA_TUNER_XC5000=y
+CONFIG_MEDIA_TUNER_MC44S803=y
+CONFIG_VIDEO_V4L2=y
+CONFIG_VIDEOBUF_GEN=y
+CONFIG_VIDEOBUF_DMA_CONTIG=y
+CONFIG_VIDEO_CAPTURE_DRIVERS=y
+# CONFIG_VIDEO_ADV_DEBUG is not set
+# CONFIG_VIDEO_FIXED_MINOR_RANGES is not set
+CONFIG_VIDEO_HELPER_CHIPS_AUTO=y
+# CONFIG_VIDEO_VIVI is not set
+# CONFIG_VIDEO_SAA5246A is not set
+# CONFIG_VIDEO_SAA5249 is not set
+CONFIG_SOC_CAMERA=y
+# CONFIG_SOC_CAMERA_MT9M001 is not set
+# CONFIG_SOC_CAMERA_MT9M111 is not set
+# CONFIG_SOC_CAMERA_MT9T031 is not set
+# CONFIG_SOC_CAMERA_MT9V022 is not set
+# CONFIG_SOC_CAMERA_TW9910 is not set
+# CONFIG_SOC_CAMERA_PLATFORM is not set
+CONFIG_SOC_CAMERA_OV772X=y
+CONFIG_VIDEO_SH_MOBILE_CEU=y
+CONFIG_V4L_USB_DRIVERS=y
+# CONFIG_USB_VIDEO_CLASS is not set
+CONFIG_USB_VIDEO_CLASS_INPUT_EVDEV=y
+CONFIG_USB_GSPCA=m
+# CONFIG_USB_M5602 is not set
+# CONFIG_USB_STV06XX is not set
+# CONFIG_USB_GSPCA_CONEX is not set
+# CONFIG_USB_GSPCA_ETOMS is not set
+# CONFIG_USB_GSPCA_FINEPIX is not set
+# CONFIG_USB_GSPCA_MARS is not set
+# CONFIG_USB_GSPCA_MR97310A is not set
+# CONFIG_USB_GSPCA_OV519 is not set
+# CONFIG_USB_GSPCA_OV534 is not set
+# CONFIG_USB_GSPCA_PAC207 is not set
+# CONFIG_USB_GSPCA_PAC7311 is not set
+# CONFIG_USB_GSPCA_SONIXB is not set
+# CONFIG_USB_GSPCA_SONIXJ is not set
+# CONFIG_USB_GSPCA_SPCA500 is not set
+# CONFIG_USB_GSPCA_SPCA501 is not set
+# CONFIG_USB_GSPCA_SPCA505 is not set
+# CONFIG_USB_GSPCA_SPCA506 is not set
+# CONFIG_USB_GSPCA_SPCA508 is not set
+# CONFIG_USB_GSPCA_SPCA561 is not set
+# CONFIG_USB_GSPCA_SQ905 is not set
+# CONFIG_USB_GSPCA_SQ905C is not set
+# CONFIG_USB_GSPCA_STK014 is not set
+# CONFIG_USB_GSPCA_SUNPLUS is not set
+# CONFIG_USB_GSPCA_T613 is not set
+# CONFIG_USB_GSPCA_TV8532 is not set
+# CONFIG_USB_GSPCA_VC032X is not set
+# CONFIG_USB_GSPCA_ZC3XX is not set
+# CONFIG_VIDEO_PVRUSB2 is not set
+# CONFIG_VIDEO_HDPVR is not set
+# CONFIG_VIDEO_EM28XX is not set
+# CONFIG_VIDEO_CX231XX is not set
+# CONFIG_VIDEO_USBVISION is not set
+# CONFIG_USB_ET61X251 is not set
+# CONFIG_USB_SN9C102 is not set
+# CONFIG_USB_ZC0301 is not set
+CONFIG_USB_PWC_INPUT_EVDEV=y
+# CONFIG_USB_ZR364XX is not set
+# CONFIG_USB_STKWEBCAM is not set
+# CONFIG_USB_S2255 is not set
+# CONFIG_RADIO_ADAPTERS is not set
+# CONFIG_DAB is not set
+
+#
+# Graphics support
+#
+# CONFIG_VGASTATE is not set
+# CONFIG_VIDEO_OUTPUT_CONTROL is not set
+CONFIG_FB=y
+# CONFIG_FIRMWARE_EDID is not set
+# CONFIG_FB_DDC is not set
+# CONFIG_FB_BOOT_VESA_SUPPORT is not set
+# CONFIG_FB_CFB_FILLRECT is not set
+# CONFIG_FB_CFB_COPYAREA is not set
+# CONFIG_FB_CFB_IMAGEBLIT is not set
+# CONFIG_FB_CFB_REV_PIXELS_IN_BYTE is not set
+CONFIG_FB_SYS_FILLRECT=y
+CONFIG_FB_SYS_COPYAREA=y
+CONFIG_FB_SYS_IMAGEBLIT=y
+# CONFIG_FB_FOREIGN_ENDIAN is not set
+CONFIG_FB_SYS_FOPS=y
+CONFIG_FB_DEFERRED_IO=y
+# CONFIG_FB_SVGALIB is not set
+# CONFIG_FB_MACMODES is not set
+# CONFIG_FB_BACKLIGHT is not set
+# CONFIG_FB_MODE_HELPERS is not set
+# CONFIG_FB_TILEBLITTING is not set
+
+#
+# Frame buffer hardware drivers
+#
+# CONFIG_FB_S1D13XXX is not set
+CONFIG_FB_SH_MOBILE_LCDC=y
+# CONFIG_FB_VIRTUAL is not set
+# CONFIG_FB_METRONOME is not set
+# CONFIG_FB_MB862XX is not set
+# CONFIG_FB_BROADSHEET is not set
+# CONFIG_BACKLIGHT_LCD_SUPPORT is not set
+
+#
+# Display device support
+#
+# CONFIG_DISPLAY_SUPPORT is not set
+
+#
+# Console display driver support
+#
+CONFIG_DUMMY_CONSOLE=y
+CONFIG_FRAMEBUFFER_CONSOLE=y
+# CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY is not set
+# CONFIG_FRAMEBUFFER_CONSOLE_ROTATION is not set
+# CONFIG_FONTS is not set
+CONFIG_FONT_8x8=y
+CONFIG_FONT_8x16=y
+CONFIG_LOGO=y
+# CONFIG_LOGO_LINUX_MONO is not set
+# CONFIG_LOGO_LINUX_VGA16 is not set
+# CONFIG_LOGO_LINUX_CLUT224 is not set
+# CONFIG_LOGO_SUPERH_MONO is not set
+# CONFIG_LOGO_SUPERH_VGA16 is not set
+CONFIG_LOGO_SUPERH_CLUT224=y
+# CONFIG_SOUND is not set
+CONFIG_HID_SUPPORT=y
+CONFIG_HID=y
+# CONFIG_HID_DEBUG is not set
+# CONFIG_HIDRAW is not set
+
+#
+# USB Input Devices
+#
+CONFIG_USB_HID=y
+# CONFIG_HID_PID is not set
+# CONFIG_USB_HIDDEV is not set
+
+#
+# Special HID drivers
+#
+# CONFIG_HID_A4TECH is not set
+# CONFIG_HID_APPLE is not set
+# CONFIG_HID_BELKIN is not set
+# CONFIG_HID_CHERRY is not set
+# CONFIG_HID_CHICONY is not set
+# CONFIG_HID_CYPRESS is not set
+# CONFIG_DRAGONRISE_FF is not set
+# CONFIG_HID_EZKEY is not set
+# CONFIG_HID_KYE is not set
+# CONFIG_HID_GYRATION is not set
+# CONFIG_HID_KENSINGTON is not set
+# CONFIG_HID_LOGITECH is not set
+# CONFIG_HID_MICROSOFT is not set
+# CONFIG_HID_MONTEREY is not set
+# CONFIG_HID_NTRIG is not set
+# CONFIG_HID_PANTHERLORD is not set
+# CONFIG_HID_PETALYNX is not set
+# CONFIG_HID_SAMSUNG is not set
+# CONFIG_HID_SONY is not set
+# CONFIG_HID_SUNPLUS is not set
+# CONFIG_GREENASIA_FF is not set
+# CONFIG_HID_TOPSEED is not set
+# CONFIG_THRUSTMASTER_FF is not set
+# CONFIG_ZEROPLUS_FF is not set
+CONFIG_USB_SUPPORT=y
+CONFIG_USB_ARCH_HAS_HCD=y
+# CONFIG_USB_ARCH_HAS_OHCI is not set
+# CONFIG_USB_ARCH_HAS_EHCI is not set
+CONFIG_USB=y
+# CONFIG_USB_DEBUG is not set
+# CONFIG_USB_ANNOUNCE_NEW_DEVICES is not set
+
+#
+# Miscellaneous USB options
+#
+# CONFIG_USB_DEVICEFS is not set
+CONFIG_USB_DEVICE_CLASS=y
+# CONFIG_USB_DYNAMIC_MINORS is not set
+# CONFIG_USB_OTG is not set
+# CONFIG_USB_OTG_WHITELIST is not set
+# CONFIG_USB_OTG_BLACKLIST_HUB is not set
+CONFIG_USB_MON=y
+# CONFIG_USB_WUSB is not set
+# CONFIG_USB_WUSB_CBAF is not set
+
+#
+# USB Host Controller Drivers
+#
+# CONFIG_USB_C67X00_HCD is not set
+# CONFIG_USB_OXU210HP_HCD is not set
+# CONFIG_USB_ISP116X_HCD is not set
+# CONFIG_USB_ISP1760_HCD is not set
+# CONFIG_USB_SL811_HCD is not set
+CONFIG_USB_R8A66597_HCD=y
+# CONFIG_USB_HWA_HCD is not set
+
+#
+# USB Device Class drivers
+#
+# CONFIG_USB_ACM is not set
+# CONFIG_USB_PRINTER is not set
+# CONFIG_USB_WDM is not set
+# CONFIG_USB_TMC is not set
+
+#
+# NOTE: USB_STORAGE depends on SCSI but BLK_DEV_SD may
+#
+
+#
+# also be needed; see USB_STORAGE Help for more info
+#
+CONFIG_USB_STORAGE=y
+# CONFIG_USB_STORAGE_DEBUG is not set
+# CONFIG_USB_STORAGE_DATAFAB is not set
+# CONFIG_USB_STORAGE_FREECOM is not set
+# CONFIG_USB_STORAGE_ISD200 is not set
+# CONFIG_USB_STORAGE_USBAT is not set
+# CONFIG_USB_STORAGE_SDDR09 is not set
+# CONFIG_USB_STORAGE_SDDR55 is not set
+# CONFIG_USB_STORAGE_JUMPSHOT is not set
+# CONFIG_USB_STORAGE_ALAUDA is not set
+# CONFIG_USB_STORAGE_ONETOUCH is not set
+# CONFIG_USB_STORAGE_KARMA is not set
+# CONFIG_USB_STORAGE_CYPRESS_ATACB is not set
+# CONFIG_USB_LIBUSUAL is not set
+
+#
+# USB Imaging devices
+#
+# CONFIG_USB_MDC800 is not set
+# CONFIG_USB_MICROTEK is not set
+
+#
+# USB port drivers
+#
+# CONFIG_USB_SERIAL is not set
+
+#
+# USB Miscellaneous drivers
+#
+# CONFIG_USB_EMI62 is not set
+# CONFIG_USB_EMI26 is not set
+# CONFIG_USB_ADUTUX is not set
+# CONFIG_USB_SEVSEG is not set
+# CONFIG_USB_RIO500 is not set
+# CONFIG_USB_LEGOTOWER is not set
+# CONFIG_USB_LCD is not set
+# CONFIG_USB_BERRY_CHARGE is not set
+# CONFIG_USB_LED is not set
+# CONFIG_USB_CYPRESS_CY7C63 is not set
+# CONFIG_USB_CYTHERM is not set
+# CONFIG_USB_IDMOUSE is not set
+# CONFIG_USB_FTDI_ELAN is not set
+# CONFIG_USB_APPLEDISPLAY is not set
+# CONFIG_USB_LD is not set
+# CONFIG_USB_TRANCEVIBRATOR is not set
+# CONFIG_USB_IOWARRIOR is not set
+# CONFIG_USB_ISIGHTFW is not set
+# CONFIG_USB_VST is not set
+# CONFIG_USB_GADGET is not set
+
+#
+# OTG and related infrastructure
+#
+# CONFIG_USB_GPIO_VBUS is not set
+# CONFIG_NOP_USB_XCEIV is not set
+CONFIG_MMC=y
+# CONFIG_MMC_DEBUG is not set
+# CONFIG_MMC_UNSAFE_RESUME is not set
+
+#
+# MMC/SD/SDIO Card Drivers
+#
+CONFIG_MMC_BLOCK=y
+CONFIG_MMC_BLOCK_BOUNCE=y
+# CONFIG_SDIO_UART is not set
+# CONFIG_MMC_TEST is not set
+
+#
+# MMC/SD/SDIO Host Controller Drivers
+#
+# CONFIG_MMC_SDHCI is not set
+CONFIG_MMC_SPI=y
+# CONFIG_MEMSTICK is not set
+# CONFIG_NEW_LEDS is not set
+# CONFIG_ACCESSIBILITY is not set
+CONFIG_RTC_LIB=y
+CONFIG_RTC_CLASS=y
+CONFIG_RTC_HCTOSYS=y
+CONFIG_RTC_HCTOSYS_DEVICE="rtc0"
+# CONFIG_RTC_DEBUG is not set
+
+#
+# RTC interfaces
+#
+CONFIG_RTC_INTF_SYSFS=y
+CONFIG_RTC_INTF_PROC=y
+CONFIG_RTC_INTF_DEV=y
+# CONFIG_RTC_INTF_DEV_UIE_EMUL is not set
+# CONFIG_RTC_DRV_TEST is not set
+
+#
+# I2C RTC drivers
+#
+# CONFIG_RTC_DRV_DS1307 is not set
+# CONFIG_RTC_DRV_DS1374 is not set
+# CONFIG_RTC_DRV_DS1672 is not set
+# CONFIG_RTC_DRV_MAX6900 is not set
+# CONFIG_RTC_DRV_RS5C372 is not set
+# CONFIG_RTC_DRV_ISL1208 is not set
+# CONFIG_RTC_DRV_X1205 is not set
+CONFIG_RTC_DRV_PCF8563=y
+# CONFIG_RTC_DRV_PCF8583 is not set
+# CONFIG_RTC_DRV_M41T80 is not set
+# CONFIG_RTC_DRV_S35390A is not set
+# CONFIG_RTC_DRV_FM3130 is not set
+# CONFIG_RTC_DRV_RX8581 is not set
+
+#
+# SPI RTC drivers
+#
+# CONFIG_RTC_DRV_M41T94 is not set
+# CONFIG_RTC_DRV_DS1305 is not set
+# CONFIG_RTC_DRV_DS1390 is not set
+# CONFIG_RTC_DRV_MAX6902 is not set
+# CONFIG_RTC_DRV_R9701 is not set
+# CONFIG_RTC_DRV_RS5C348 is not set
+# CONFIG_RTC_DRV_DS3234 is not set
+
+#
+# Platform RTC drivers
+#
+# CONFIG_RTC_DRV_DS1286 is not set
+# CONFIG_RTC_DRV_DS1511 is not set
+# CONFIG_RTC_DRV_DS1553 is not set
+# CONFIG_RTC_DRV_DS1742 is not set
+# CONFIG_RTC_DRV_STK17TA8 is not set
+# CONFIG_RTC_DRV_M48T86 is not set
+# CONFIG_RTC_DRV_M48T35 is not set
+# CONFIG_RTC_DRV_M48T59 is not set
+# CONFIG_RTC_DRV_BQ4802 is not set
+# CONFIG_RTC_DRV_V3020 is not set
+
+#
+# on-CPU RTC drivers
+#
+# CONFIG_RTC_DRV_SH is not set
+# CONFIG_RTC_DRV_GENERIC is not set
+# CONFIG_DMADEVICES is not set
+# CONFIG_AUXDISPLAY is not set
+CONFIG_UIO=y
+# CONFIG_UIO_PDRV is not set
+CONFIG_UIO_PDRV_GENIRQ=y
+# CONFIG_UIO_SMX is not set
+# CONFIG_UIO_SERCOS3 is not set
+# CONFIG_STAGING is not set
+
+#
+# File systems
+#
+CONFIG_EXT2_FS=y
+CONFIG_EXT2_FS_XATTR=y
+CONFIG_EXT2_FS_POSIX_ACL=y
+CONFIG_EXT2_FS_SECURITY=y
+# CONFIG_EXT2_FS_XIP is not set
+CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
+CONFIG_EXT3_FS_XATTR=y
+CONFIG_EXT3_FS_POSIX_ACL=y
+CONFIG_EXT3_FS_SECURITY=y
+# CONFIG_EXT4_FS is not set
+CONFIG_JBD=y
+CONFIG_FS_MBCACHE=y
+# CONFIG_REISERFS_FS is not set
+# CONFIG_JFS_FS is not set
+CONFIG_FS_POSIX_ACL=y
+CONFIG_FILE_LOCKING=y
+# CONFIG_XFS_FS is not set
+# CONFIG_OCFS2_FS is not set
+# CONFIG_BTRFS_FS is not set
+CONFIG_DNOTIFY=y
+CONFIG_INOTIFY=y
+CONFIG_INOTIFY_USER=y
+# CONFIG_QUOTA is not set
+# CONFIG_AUTOFS_FS is not set
+# CONFIG_AUTOFS4_FS is not set
+# CONFIG_FUSE_FS is not set
+
+#
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
+# CD-ROM/DVD Filesystems
+#
+# CONFIG_ISO9660_FS is not set
+# CONFIG_UDF_FS is not set
+
+#
+# DOS/FAT/NT Filesystems
+#
+CONFIG_FAT_FS=y
+# CONFIG_MSDOS_FS is not set
+CONFIG_VFAT_FS=y
+CONFIG_FAT_DEFAULT_CODEPAGE=437
+CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
+# CONFIG_NTFS_FS is not set
+
+#
+# Pseudo filesystems
+#
+CONFIG_PROC_FS=y
+CONFIG_PROC_KCORE=y
+CONFIG_PROC_SYSCTL=y
+CONFIG_PROC_PAGE_MONITOR=y
+CONFIG_SYSFS=y
+CONFIG_TMPFS=y
+# CONFIG_TMPFS_POSIX_ACL is not set
+# CONFIG_HUGETLBFS is not set
+# CONFIG_HUGETLB_PAGE is not set
+# CONFIG_CONFIGFS_FS is not set
+CONFIG_MISC_FILESYSTEMS=y
+# CONFIG_ADFS_FS is not set
+# CONFIG_AFFS_FS is not set
+# CONFIG_HFS_FS is not set
+# CONFIG_HFSPLUS_FS is not set
+# CONFIG_BEFS_FS is not set
+# CONFIG_BFS_FS is not set
+# CONFIG_EFS_FS is not set
+# CONFIG_JFFS2_FS is not set
+# CONFIG_UBIFS_FS is not set
+# CONFIG_CRAMFS is not set
+# CONFIG_SQUASHFS is not set
+# CONFIG_VXFS_FS is not set
+# CONFIG_MINIX_FS is not set
+# CONFIG_OMFS_FS is not set
+# CONFIG_HPFS_FS is not set
+# CONFIG_QNX4FS_FS is not set
+# CONFIG_ROMFS_FS is not set
+# CONFIG_SYSV_FS is not set
+# CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
+CONFIG_NETWORK_FILESYSTEMS=y
+CONFIG_NFS_FS=y
+CONFIG_NFS_V3=y
+# CONFIG_NFS_V3_ACL is not set
+# CONFIG_NFS_V4 is not set
+CONFIG_ROOT_NFS=y
+CONFIG_NFSD=y
+CONFIG_NFSD_V3=y
+# CONFIG_NFSD_V3_ACL is not set
+# CONFIG_NFSD_V4 is not set
+CONFIG_LOCKD=y
+CONFIG_LOCKD_V4=y
+CONFIG_EXPORTFS=y
+CONFIG_NFS_COMMON=y
+CONFIG_SUNRPC=y
+# CONFIG_RPCSEC_GSS_KRB5 is not set
+# CONFIG_RPCSEC_GSS_SPKM3 is not set
+# CONFIG_SMB_FS is not set
+# CONFIG_CIFS is not set
+# CONFIG_NCP_FS is not set
+# CONFIG_CODA_FS is not set
+# CONFIG_AFS_FS is not set
+
+#
+# Partition Types
+#
+# CONFIG_PARTITION_ADVANCED is not set
+CONFIG_MSDOS_PARTITION=y
+CONFIG_NLS=y
+CONFIG_NLS_DEFAULT="iso8859-1"
+CONFIG_NLS_CODEPAGE_437=y
+# CONFIG_NLS_CODEPAGE_737 is not set
+# CONFIG_NLS_CODEPAGE_775 is not set
+# CONFIG_NLS_CODEPAGE_850 is not set
+# CONFIG_NLS_CODEPAGE_852 is not set
+# CONFIG_NLS_CODEPAGE_855 is not set
+# CONFIG_NLS_CODEPAGE_857 is not set
+# CONFIG_NLS_CODEPAGE_860 is not set
+# CONFIG_NLS_CODEPAGE_861 is not set
+# CONFIG_NLS_CODEPAGE_862 is not set
+# CONFIG_NLS_CODEPAGE_863 is not set
+# CONFIG_NLS_CODEPAGE_864 is not set
+# CONFIG_NLS_CODEPAGE_865 is not set
+# CONFIG_NLS_CODEPAGE_866 is not set
+# CONFIG_NLS_CODEPAGE_869 is not set
+# CONFIG_NLS_CODEPAGE_936 is not set
+# CONFIG_NLS_CODEPAGE_950 is not set
+CONFIG_NLS_CODEPAGE_932=y
+# CONFIG_NLS_CODEPAGE_949 is not set
+# CONFIG_NLS_CODEPAGE_874 is not set
+# CONFIG_NLS_ISO8859_8 is not set
+# CONFIG_NLS_CODEPAGE_1250 is not set
+# CONFIG_NLS_CODEPAGE_1251 is not set
+# CONFIG_NLS_ASCII is not set
+CONFIG_NLS_ISO8859_1=y
+# CONFIG_NLS_ISO8859_2 is not set
+# CONFIG_NLS_ISO8859_3 is not set
+# CONFIG_NLS_ISO8859_4 is not set
+# CONFIG_NLS_ISO8859_5 is not set
+# CONFIG_NLS_ISO8859_6 is not set
+# CONFIG_NLS_ISO8859_7 is not set
+# CONFIG_NLS_ISO8859_9 is not set
+# CONFIG_NLS_ISO8859_13 is not set
+# CONFIG_NLS_ISO8859_14 is not set
+# CONFIG_NLS_ISO8859_15 is not set
+# CONFIG_NLS_KOI8_R is not set
+# CONFIG_NLS_KOI8_U is not set
+# CONFIG_NLS_UTF8 is not set
+# CONFIG_DLM is not set
+
+#
+# Kernel hacking
+#
+CONFIG_TRACE_IRQFLAGS_SUPPORT=y
+# CONFIG_PRINTK_TIME is not set
+CONFIG_ENABLE_WARN_DEPRECATED=y
+# CONFIG_ENABLE_MUST_CHECK is not set
+CONFIG_FRAME_WARN=1024
+# CONFIG_MAGIC_SYSRQ is not set
+# CONFIG_UNUSED_SYMBOLS is not set
+# CONFIG_DEBUG_FS is not set
+# CONFIG_HEADERS_CHECK is not set
+# CONFIG_DEBUG_KERNEL is not set
+# CONFIG_DEBUG_BUGVERBOSE is not set
+# CONFIG_DEBUG_MEMORY_INIT is not set
+# CONFIG_RCU_CPU_STALL_DETECTOR is not set
+# CONFIG_LATENCYTOP is not set
+CONFIG_SYSCTL_SYSCALL_CHECK=y
+CONFIG_HAVE_FUNCTION_TRACER=y
+CONFIG_HAVE_DYNAMIC_FTRACE=y
+CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
+
+#
+# Tracers
+#
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_PREEMPT_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
+# CONFIG_SAMPLES is not set
+CONFIG_HAVE_ARCH_KGDB=y
+# CONFIG_SH_STANDARD_BIOS is not set
+# CONFIG_EARLY_SCIF_CONSOLE is not set
+
+#
+# Security options
+#
+# CONFIG_KEYS is not set
+# CONFIG_SECURITY is not set
+# CONFIG_SECURITYFS is not set
+# CONFIG_SECURITY_FILE_CAPABILITIES is not set
+CONFIG_CRYPTO=y
+
+#
+# Crypto core or helper
+#
+# CONFIG_CRYPTO_FIPS is not set
+CONFIG_CRYPTO_ALGAPI=y
+CONFIG_CRYPTO_ALGAPI2=y
+CONFIG_CRYPTO_AEAD2=y
+CONFIG_CRYPTO_BLKCIPHER=y
+CONFIG_CRYPTO_BLKCIPHER2=y
+CONFIG_CRYPTO_HASH2=y
+CONFIG_CRYPTO_RNG2=y
+CONFIG_CRYPTO_PCOMP=y
+CONFIG_CRYPTO_MANAGER=y
+CONFIG_CRYPTO_MANAGER2=y
+# CONFIG_CRYPTO_GF128MUL is not set
+# CONFIG_CRYPTO_NULL is not set
+CONFIG_CRYPTO_WORKQUEUE=y
+# CONFIG_CRYPTO_CRYPTD is not set
+# CONFIG_CRYPTO_AUTHENC is not set
+# CONFIG_CRYPTO_TEST is not set
+
+#
+# Authenticated Encryption with Associated Data
+#
+# CONFIG_CRYPTO_CCM is not set
+# CONFIG_CRYPTO_GCM is not set
+# CONFIG_CRYPTO_SEQIV is not set
+
+#
+# Block modes
+#
+CONFIG_CRYPTO_CBC=y
+# CONFIG_CRYPTO_CTR is not set
+# CONFIG_CRYPTO_CTS is not set
+# CONFIG_CRYPTO_ECB is not set
+# CONFIG_CRYPTO_LRW is not set
+# CONFIG_CRYPTO_PCBC is not set
+# CONFIG_CRYPTO_XTS is not set
+
+#
+# Hash modes
+#
+# CONFIG_CRYPTO_HMAC is not set
+# CONFIG_CRYPTO_XCBC is not set
+
+#
+# Digest
+#
+# CONFIG_CRYPTO_CRC32C is not set
+# CONFIG_CRYPTO_MD4 is not set
+# CONFIG_CRYPTO_MD5 is not set
+# CONFIG_CRYPTO_MICHAEL_MIC is not set
+# CONFIG_CRYPTO_RMD128 is not set
+# CONFIG_CRYPTO_RMD160 is not set
+# CONFIG_CRYPTO_RMD256 is not set
+# CONFIG_CRYPTO_RMD320 is not set
+# CONFIG_CRYPTO_SHA1 is not set
+# CONFIG_CRYPTO_SHA256 is not set
+# CONFIG_CRYPTO_SHA512 is not set
+# CONFIG_CRYPTO_TGR192 is not set
+# CONFIG_CRYPTO_WP512 is not set
+
+#
+# Ciphers
+#
+# CONFIG_CRYPTO_AES is not set
+# CONFIG_CRYPTO_ANUBIS is not set
+# CONFIG_CRYPTO_ARC4 is not set
+# CONFIG_CRYPTO_BLOWFISH is not set
+# CONFIG_CRYPTO_CAMELLIA is not set
+# CONFIG_CRYPTO_CAST5 is not set
+# CONFIG_CRYPTO_CAST6 is not set
+# CONFIG_CRYPTO_DES is not set
+# CONFIG_CRYPTO_FCRYPT is not set
+# CONFIG_CRYPTO_KHAZAD is not set
+# CONFIG_CRYPTO_SALSA20 is not set
+# CONFIG_CRYPTO_SEED is not set
+# CONFIG_CRYPTO_SERPENT is not set
+# CONFIG_CRYPTO_TEA is not set
+# CONFIG_CRYPTO_TWOFISH is not set
+
+#
+# Compression
+#
+# CONFIG_CRYPTO_DEFLATE is not set
+# CONFIG_CRYPTO_ZLIB is not set
+# CONFIG_CRYPTO_LZO is not set
+
+#
+# Random Number Generation
+#
+# CONFIG_CRYPTO_ANSI_CPRNG is not set
+CONFIG_CRYPTO_HW=y
+# CONFIG_BINARY_PRINTF is not set
+
+#
+# Library routines
+#
+CONFIG_BITREVERSE=y
+CONFIG_GENERIC_FIND_LAST_BIT=y
+# CONFIG_CRC_CCITT is not set
+# CONFIG_CRC16 is not set
+CONFIG_CRC_T10DIF=y
+CONFIG_CRC_ITU_T=y
+CONFIG_CRC32=y
+CONFIG_CRC7=y
+# CONFIG_LIBCRC32C is not set
+CONFIG_HAS_IOMEM=y
+CONFIG_HAS_IOPORT=y
+CONFIG_HAS_DMA=y
+CONFIG_NLATTR=y
diff --git a/arch/sh/configs/se7750_defconfig b/arch/sh/configs/se7750_defconfig
index ceef6d9138ee..ed1a1230f636 100644
--- a/arch/sh/configs/se7750_defconfig
+++ b/arch/sh/configs/se7750_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:57:31 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:06:02 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -70,6 +71,7 @@ CONFIG_UID16=y
 # CONFIG_SYSCTL_SYSCALL is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 # CONFIG_HOTPLUG is not set
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -88,6 +90,7 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
 CONFIG_HAVE_IOREMAP_PROT=y
@@ -95,6 +98,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -106,7 +111,6 @@ CONFIG_MODULES=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -152,6 +156,7 @@ CONFIG_CPU_SUBTYPE_SH7750=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -161,8 +166,6 @@ CONFIG_CPU_SUBTYPE_SH7750=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -553,6 +556,7 @@ CONFIG_SCSI_WAIT_SCAN=m
 CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_ISCSI_TCP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_SCSI_DEBUG is not set
 # CONFIG_SCSI_DH is not set
 # CONFIG_SCSI_OSD_INITIATOR is not set
@@ -775,6 +779,11 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -829,6 +838,7 @@ CONFIG_JFFS2_RTIME=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 # CONFIG_NFS_V3 is not set
@@ -886,10 +896,23 @@ CONFIG_FRAME_WARN=1024
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -989,6 +1012,7 @@ CONFIG_CRYPTO=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/se7751_defconfig b/arch/sh/configs/se7751_defconfig
index 67fc26b3a7d0..55f3b788e0cb 100644
--- a/arch/sh/configs/se7751_defconfig
+++ b/arch/sh/configs/se7751_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 18:59:59 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:06:44 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -65,7 +66,6 @@ CONFIG_INITRAMFS_SOURCE=""
 CONFIG_RD_GZIP=y
 # CONFIG_RD_BZIP2 is not set
 # CONFIG_RD_LZMA is not set
-CONFIG_INITRAMFS_COMPRESSION_NONE=y
 # CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 CONFIG_SYSCTL=y
 CONFIG_ANON_INODES=y
@@ -74,6 +74,7 @@ CONFIG_UID16=y
 # CONFIG_SYSCTL_SYSCALL is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 # CONFIG_HOTPLUG is not set
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -92,6 +93,7 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
 CONFIG_HAVE_IOREMAP_PROT=y
@@ -99,6 +101,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -110,7 +114,6 @@ CONFIG_MODULES=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -156,6 +159,7 @@ CONFIG_CPU_SUBTYPE_SH7751=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -165,8 +169,6 @@ CONFIG_CPU_SUBTYPE_SH7751=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -742,6 +744,11 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -796,6 +803,7 @@ CONFIG_JFFS2_RTIME=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 # CONFIG_NFS_FS is not set
 # CONFIG_NFSD is not set
@@ -833,10 +841,23 @@ CONFIG_FRAME_WARN=1024
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -936,6 +957,7 @@ CONFIG_CRYPTO=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/se7780_defconfig b/arch/sh/configs/se7780_defconfig
index ebce23cc2ad8..c4f0af32efa9 100644
--- a/arch/sh/configs/se7780_defconfig
+++ b/arch/sh/configs/se7780_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 19:02:05 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:07:14 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -67,6 +68,7 @@ CONFIG_EMBEDDED=y
 CONFIG_UID16=y
 CONFIG_SYSCTL_SYSCALL=y
 # CONFIG_KALLSYMS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 # CONFIG_HOTPLUG is not set
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -86,12 +88,15 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 CONFIG_HAVE_IOREMAP_PROT=y
 CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -103,7 +108,6 @@ CONFIG_MODULE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
 #
@@ -149,6 +153,7 @@ CONFIG_CPU_SH4A=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 CONFIG_CPU_SUBTYPE_SH7780=y
@@ -158,8 +163,6 @@ CONFIG_CPU_SUBTYPE_SH7780=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -285,8 +288,6 @@ CONFIG_CMDLINE="console=ttySC0.115200 root=/dev/sda1"
 #
 CONFIG_PCI=y
 CONFIG_SH_PCIDMA_NONCOHERENT=y
-CONFIG_PCI_AUTO=y
-CONFIG_PCI_AUTO_UPDATE_RESOURCES=y
 # CONFIG_PCIEPORTBUS is not set
 # CONFIG_ARCH_SUPPORTS_MSI is not set
 CONFIG_PCI_LEGACY=y
@@ -558,6 +559,7 @@ CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_SCSI_MPT2SAS is not set
 # CONFIG_SCSI_HPTIOP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_FCOE is not set
 # CONFIG_SCSI_DMX3191D is not set
 # CONFIG_SCSI_FUTURE_DOMAIN is not set
@@ -957,15 +959,17 @@ CONFIG_USB_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_HID_A4TECH=y
 CONFIG_HID_APPLE=y
 CONFIG_HID_BELKIN=y
 CONFIG_HID_CHERRY=y
 CONFIG_HID_CHICONY=y
 CONFIG_HID_CYPRESS=y
+# CONFIG_DRAGONRISE_FF is not set
 CONFIG_HID_EZKEY=y
+# CONFIG_HID_KYE is not set
 CONFIG_HID_GYRATION=y
+# CONFIG_HID_KENSINGTON is not set
 CONFIG_HID_LOGITECH=y
 # CONFIG_LOGITECH_FF is not set
 # CONFIG_LOGIRUMBLEPAD2_FF is not set
@@ -1122,6 +1126,10 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -1245,11 +1253,24 @@ CONFIG_DEBUG_FS=y
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -1345,6 +1366,7 @@ CONFIG_CRYPTO=y
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
 # CONFIG_CRYPTO_DEV_HIFN_795X is not set
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/sh03_defconfig b/arch/sh/configs/sh03_defconfig
index 6fcdb090cf32..f9c6e51dc0b0 100644
--- a/arch/sh/configs/sh03_defconfig
+++ b/arch/sh/configs/sh03_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 19:04:59 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:07:56 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -41,6 +42,7 @@ CONFIG_SWAP=y
 CONFIG_SYSVIPC=y
 CONFIG_SYSVIPC_SYSCTL=y
 CONFIG_POSIX_MQUEUE=y
+CONFIG_POSIX_MQUEUE_SYSCTL=y
 CONFIG_BSD_PROCESS_ACCT=y
 # CONFIG_BSD_PROCESS_ACCT_V3 is not set
 # CONFIG_TASKSTATS is not set
@@ -67,7 +69,6 @@ CONFIG_INITRAMFS_SOURCE=""
 CONFIG_RD_GZIP=y
 # CONFIG_RD_BZIP2 is not set
 # CONFIG_RD_LZMA is not set
-CONFIG_INITRAMFS_COMPRESSION_NONE=y
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
 CONFIG_SYSCTL=y
 CONFIG_ANON_INODES=y
@@ -76,6 +77,7 @@ CONFIG_UID16=y
 # CONFIG_SYSCTL_SYSCALL is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -105,6 +107,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -117,7 +121,6 @@ CONFIG_MODVERSIONS=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -163,6 +166,7 @@ CONFIG_CPU_SUBTYPE_SH7751=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -172,8 +176,6 @@ CONFIG_CPU_SUBTYPE_SH7751=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -300,8 +302,6 @@ CONFIG_CMDLINE="console=ttySC1,115200 mem=64M root=/dev/nfs"
 #
 CONFIG_PCI=y
 CONFIG_SH_PCIDMA_NONCOHERENT=y
-CONFIG_PCI_AUTO=y
-CONFIG_PCI_AUTO_UPDATE_RESOURCES=y
 # CONFIG_PCIEPORTBUS is not set
 # CONFIG_ARCH_SUPPORTS_MSI is not set
 CONFIG_PCI_LEGACY=y
@@ -562,6 +562,7 @@ CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_SCSI_MPT2SAS is not set
 # CONFIG_SCSI_HPTIOP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_FCOE is not set
 # CONFIG_SCSI_DMX3191D is not set
 # CONFIG_SCSI_FUTURE_DOMAIN is not set
@@ -656,6 +657,7 @@ CONFIG_NETDEV_1000=y
 # CONFIG_E1000E is not set
 # CONFIG_IP1000 is not set
 # CONFIG_IGB is not set
+# CONFIG_IGBVF is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
@@ -679,6 +681,7 @@ CONFIG_CHELSIO_T3_DEPENDS=y
 # CONFIG_IXGBE is not set
 # CONFIG_IXGB is not set
 # CONFIG_S2IO is not set
+# CONFIG_VXGE is not set
 # CONFIG_MYRI10GE is not set
 # CONFIG_NETXEN_NIC is not set
 # CONFIG_NIU is not set
@@ -887,7 +890,6 @@ CONFIG_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_USB_SUPPORT=y
 CONFIG_USB_ARCH_HAS_HCD=y
 CONFIG_USB_ARCH_HAS_OHCI=y
@@ -929,6 +931,7 @@ CONFIG_EXT2_FS_XATTR=y
 # CONFIG_EXT2_FS_SECURITY is not set
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 CONFIG_EXT3_FS_POSIX_ACL=y
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -952,6 +955,11 @@ CONFIG_AUTOFS4_FS=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 CONFIG_ISO9660_FS=m
@@ -1001,6 +1009,7 @@ CONFIG_MISC_FILESYSTEMS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
@@ -1112,11 +1121,26 @@ CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 CONFIG_RING_BUFFER=y
 CONFIG_TRACING=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_PREEMPT_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_FTRACE_STARTUP_TEST is not set
 # CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 CONFIG_SH_STANDARD_BIOS=y
@@ -1228,6 +1252,7 @@ CONFIG_CRYPTO_DEFLATE=y
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
 # CONFIG_CRYPTO_DEV_HIFN_795X is not set
+CONFIG_BINARY_PRINTF=y
 
 #
 # Library routines
diff --git a/arch/sh/configs/sh7710voipgw_defconfig b/arch/sh/configs/sh7710voipgw_defconfig
index 1ab37c01da6e..48b58098cf84 100644
--- a/arch/sh/configs/sh7710voipgw_defconfig
+++ b/arch/sh/configs/sh7710voipgw_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 19:09:01 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:09:16 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -39,6 +40,7 @@ CONFIG_LOCALVERSION_AUTO=y
 CONFIG_SYSVIPC=y
 CONFIG_SYSVIPC_SYSCTL=y
 CONFIG_POSIX_MQUEUE=y
+CONFIG_POSIX_MQUEUE_SYSCTL=y
 # CONFIG_BSD_PROCESS_ACCT is not set
 # CONFIG_TASKSTATS is not set
 # CONFIG_AUDIT is not set
@@ -72,6 +74,7 @@ CONFIG_UID16=y
 # CONFIG_SYSCTL_SYSCALL is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -90,6 +93,7 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
 CONFIG_HAVE_IOREMAP_PROT=y
@@ -97,6 +101,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_BASE_SMALL=0
@@ -108,7 +114,6 @@ CONFIG_MODULE_FORCE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -154,6 +159,7 @@ CONFIG_CPU_SUBTYPE_SH7710=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -163,8 +169,6 @@ CONFIG_CPU_SUBTYPE_SH7710=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -728,7 +732,6 @@ CONFIG_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_USB_SUPPORT=y
 CONFIG_USB_ARCH_HAS_HCD=y
 # CONFIG_USB_ARCH_HAS_OHCI is not set
@@ -780,6 +783,11 @@ CONFIG_FILE_LOCKING=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -834,6 +842,7 @@ CONFIG_JFFS2_RTIME=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 # CONFIG_NFS_FS is not set
 # CONFIG_NFSD is not set
@@ -871,11 +880,24 @@ CONFIG_DEBUG_FS=y
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -975,6 +997,7 @@ CONFIG_CRYPTO=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/sh7724_generic_defconfig b/arch/sh/configs/sh7724_generic_defconfig
new file mode 100644
index 000000000000..ec8f18c7684c
--- /dev/null
+++ b/arch/sh/configs/sh7724_generic_defconfig
@@ -0,0 +1,707 @@
+#
+# Automatically generated make config: don't edit
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:09:47 2009
+#
+CONFIG_SUPERH=y
+CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
+CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
+CONFIG_RWSEM_GENERIC_SPINLOCK=y
+CONFIG_GENERIC_BUG=y
+CONFIG_GENERIC_FIND_NEXT_BIT=y
+CONFIG_GENERIC_HWEIGHT=y
+CONFIG_GENERIC_HARDIRQS=y
+CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ=y
+CONFIG_GENERIC_IRQ_PROBE=y
+# CONFIG_GENERIC_GPIO is not set
+CONFIG_GENERIC_TIME=y
+CONFIG_GENERIC_CLOCKEVENTS=y
+CONFIG_ARCH_SUSPEND_POSSIBLE=y
+CONFIG_ARCH_HIBERNATION_POSSIBLE=y
+CONFIG_SYS_SUPPORTS_CMT=y
+CONFIG_STACKTRACE_SUPPORT=y
+CONFIG_LOCKDEP_SUPPORT=y
+CONFIG_HAVE_LATENCYTOP_SUPPORT=y
+# CONFIG_ARCH_HAS_ILOG2_U32 is not set
+# CONFIG_ARCH_HAS_ILOG2_U64 is not set
+CONFIG_ARCH_NO_VIRT_TO_BUS=y
+CONFIG_ARCH_HAS_DEFAULT_IDLE=y
+CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config"
+
+#
+# General setup
+#
+CONFIG_EXPERIMENTAL=y
+CONFIG_BROKEN_ON_SMP=y
+CONFIG_INIT_ENV_ARG_LIMIT=32
+CONFIG_LOCALVERSION=""
+# CONFIG_LOCALVERSION_AUTO is not set
+CONFIG_SWAP=y
+CONFIG_SYSVIPC=y
+CONFIG_SYSVIPC_SYSCTL=y
+# CONFIG_BSD_PROCESS_ACCT is not set
+
+#
+# RCU Subsystem
+#
+# CONFIG_CLASSIC_RCU is not set
+CONFIG_TREE_RCU=y
+# CONFIG_PREEMPT_RCU is not set
+# CONFIG_RCU_TRACE is not set
+CONFIG_RCU_FANOUT=32
+# CONFIG_RCU_FANOUT_EXACT is not set
+# CONFIG_TREE_RCU_TRACE is not set
+# CONFIG_PREEMPT_RCU_TRACE is not set
+# CONFIG_IKCONFIG is not set
+CONFIG_LOG_BUF_SHIFT=17
+CONFIG_GROUP_SCHED=y
+CONFIG_FAIR_GROUP_SCHED=y
+CONFIG_RT_GROUP_SCHED=y
+CONFIG_USER_SCHED=y
+# CONFIG_CGROUP_SCHED is not set
+CONFIG_CGROUPS=y
+# CONFIG_CGROUP_DEBUG is not set
+# CONFIG_CGROUP_NS is not set
+# CONFIG_CGROUP_FREEZER is not set
+# CONFIG_CGROUP_DEVICE is not set
+# CONFIG_CPUSETS is not set
+# CONFIG_CGROUP_CPUACCT is not set
+# CONFIG_RESOURCE_COUNTERS is not set
+# CONFIG_RELAY is not set
+# CONFIG_NAMESPACES is not set
+# CONFIG_BLK_DEV_INITRD is not set
+CONFIG_CC_OPTIMIZE_FOR_SIZE=y
+CONFIG_SYSCTL=y
+CONFIG_ANON_INODES=y
+CONFIG_EMBEDDED=y
+# CONFIG_UID16 is not set
+CONFIG_SYSCTL_SYSCALL=y
+CONFIG_KALLSYMS=y
+# CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
+CONFIG_HOTPLUG=y
+CONFIG_PRINTK=y
+CONFIG_BUG=y
+CONFIG_ELF_CORE=y
+CONFIG_BASE_FULL=y
+CONFIG_FUTEX=y
+CONFIG_EPOLL=y
+CONFIG_SIGNALFD=y
+CONFIG_TIMERFD=y
+CONFIG_EVENTFD=y
+CONFIG_SHMEM=y
+CONFIG_AIO=y
+CONFIG_VM_EVENT_COUNTERS=y
+# CONFIG_COMPAT_BRK is not set
+# CONFIG_SLAB is not set
+CONFIG_SLUB=y
+# CONFIG_SLOB is not set
+CONFIG_PROFILING=y
+CONFIG_TRACEPOINTS=y
+# CONFIG_MARKERS is not set
+CONFIG_OPROFILE=y
+CONFIG_HAVE_OPROFILE=y
+CONFIG_HAVE_IOREMAP_PROT=y
+CONFIG_HAVE_KPROBES=y
+CONFIG_HAVE_KRETPROBES=y
+CONFIG_HAVE_ARCH_TRACEHOOK=y
+CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
+CONFIG_HAVE_GENERIC_DMA_COHERENT=y
+CONFIG_RT_MUTEXES=y
+CONFIG_BASE_SMALL=0
+# CONFIG_MODULES is not set
+CONFIG_BLOCK=y
+# CONFIG_LBD is not set
+# CONFIG_BLK_DEV_BSG is not set
+# CONFIG_BLK_DEV_INTEGRITY is not set
+
+#
+# IO Schedulers
+#
+CONFIG_IOSCHED_NOOP=y
+CONFIG_IOSCHED_AS=y
+CONFIG_IOSCHED_DEADLINE=y
+CONFIG_IOSCHED_CFQ=y
+CONFIG_DEFAULT_AS=y
+# CONFIG_DEFAULT_DEADLINE is not set
+# CONFIG_DEFAULT_CFQ is not set
+# CONFIG_DEFAULT_NOOP is not set
+CONFIG_DEFAULT_IOSCHED="anticipatory"
+CONFIG_FREEZER=y
+
+#
+# System type
+#
+CONFIG_CPU_SH4=y
+CONFIG_CPU_SH4A=y
+CONFIG_CPU_SHX2=y
+CONFIG_ARCH_SHMOBILE=y
+# CONFIG_CPU_SUBTYPE_SH7619 is not set
+# CONFIG_CPU_SUBTYPE_SH7201 is not set
+# CONFIG_CPU_SUBTYPE_SH7203 is not set
+# CONFIG_CPU_SUBTYPE_SH7206 is not set
+# CONFIG_CPU_SUBTYPE_SH7263 is not set
+# CONFIG_CPU_SUBTYPE_MXG is not set
+# CONFIG_CPU_SUBTYPE_SH7705 is not set
+# CONFIG_CPU_SUBTYPE_SH7706 is not set
+# CONFIG_CPU_SUBTYPE_SH7707 is not set
+# CONFIG_CPU_SUBTYPE_SH7708 is not set
+# CONFIG_CPU_SUBTYPE_SH7709 is not set
+# CONFIG_CPU_SUBTYPE_SH7710 is not set
+# CONFIG_CPU_SUBTYPE_SH7712 is not set
+# CONFIG_CPU_SUBTYPE_SH7720 is not set
+# CONFIG_CPU_SUBTYPE_SH7721 is not set
+# CONFIG_CPU_SUBTYPE_SH7750 is not set
+# CONFIG_CPU_SUBTYPE_SH7091 is not set
+# CONFIG_CPU_SUBTYPE_SH7750R is not set
+# CONFIG_CPU_SUBTYPE_SH7750S is not set
+# CONFIG_CPU_SUBTYPE_SH7751 is not set
+# CONFIG_CPU_SUBTYPE_SH7751R is not set
+# CONFIG_CPU_SUBTYPE_SH7760 is not set
+# CONFIG_CPU_SUBTYPE_SH4_202 is not set
+# CONFIG_CPU_SUBTYPE_SH7723 is not set
+CONFIG_CPU_SUBTYPE_SH7724=y
+# CONFIG_CPU_SUBTYPE_SH7763 is not set
+# CONFIG_CPU_SUBTYPE_SH7770 is not set
+# CONFIG_CPU_SUBTYPE_SH7780 is not set
+# CONFIG_CPU_SUBTYPE_SH7785 is not set
+# CONFIG_CPU_SUBTYPE_SH7786 is not set
+# CONFIG_CPU_SUBTYPE_SHX3 is not set
+# CONFIG_CPU_SUBTYPE_SH7343 is not set
+# CONFIG_CPU_SUBTYPE_SH7722 is not set
+# CONFIG_CPU_SUBTYPE_SH7366 is not set
+
+#
+# Memory management options
+#
+CONFIG_QUICKLIST=y
+CONFIG_MMU=y
+CONFIG_PAGE_OFFSET=0x80000000
+CONFIG_MEMORY_START=0x08000000
+CONFIG_MEMORY_SIZE=0x04000000
+CONFIG_29BIT=y
+# CONFIG_X2TLB is not set
+CONFIG_VSYSCALL=y
+CONFIG_ARCH_FLATMEM_ENABLE=y
+CONFIG_ARCH_SPARSEMEM_ENABLE=y
+CONFIG_ARCH_SPARSEMEM_DEFAULT=y
+CONFIG_MAX_ACTIVE_REGIONS=1
+CONFIG_ARCH_POPULATES_NODE_MAP=y
+CONFIG_ARCH_SELECT_MEMORY_MODEL=y
+CONFIG_ARCH_ENABLE_MEMORY_HOTPLUG=y
+CONFIG_ARCH_ENABLE_MEMORY_HOTREMOVE=y
+CONFIG_PAGE_SIZE_4KB=y
+# CONFIG_PAGE_SIZE_8KB is not set
+# CONFIG_PAGE_SIZE_16KB is not set
+# CONFIG_PAGE_SIZE_64KB is not set
+CONFIG_ENTRY_OFFSET=0x00001000
+CONFIG_SELECT_MEMORY_MODEL=y
+# CONFIG_FLATMEM_MANUAL is not set
+# CONFIG_DISCONTIGMEM_MANUAL is not set
+CONFIG_SPARSEMEM_MANUAL=y
+CONFIG_SPARSEMEM=y
+CONFIG_HAVE_MEMORY_PRESENT=y
+CONFIG_SPARSEMEM_STATIC=y
+
+#
+# Memory hotplug is currently incompatible with Software Suspend
+#
+CONFIG_PAGEFLAGS_EXTENDED=y
+CONFIG_SPLIT_PTLOCK_CPUS=4
+CONFIG_MIGRATION=y
+# CONFIG_PHYS_ADDR_T_64BIT is not set
+CONFIG_ZONE_DMA_FLAG=0
+CONFIG_NR_QUICK=2
+CONFIG_UNEVICTABLE_LRU=y
+CONFIG_HAVE_MLOCK=y
+CONFIG_HAVE_MLOCKED_PAGE_BIT=y
+
+#
+# Cache configuration
+#
+CONFIG_CACHE_WRITEBACK=y
+# CONFIG_CACHE_WRITETHROUGH is not set
+# CONFIG_CACHE_OFF is not set
+
+#
+# Processor features
+#
+CONFIG_CPU_LITTLE_ENDIAN=y
+# CONFIG_CPU_BIG_ENDIAN is not set
+CONFIG_SH_FPU=y
+# CONFIG_SH_STORE_QUEUES is not set
+CONFIG_CPU_HAS_INTEVT=y
+CONFIG_CPU_HAS_SR_RB=y
+CONFIG_CPU_HAS_PTEA=y
+CONFIG_CPU_HAS_FPU=y
+
+#
+# Board support
+#
+
+#
+# Timer and clock configuration
+#
+CONFIG_SH_TMU=y
+CONFIG_SH_TIMER_CMT=y
+CONFIG_SH_TIMER_IRQ=16
+CONFIG_SH_PCLK_FREQ=41666666
+CONFIG_TICK_ONESHOT=y
+CONFIG_NO_HZ=y
+CONFIG_HIGH_RES_TIMERS=y
+CONFIG_GENERIC_CLOCKEVENTS_BUILD=y
+
+#
+# CPU Frequency scaling
+#
+CONFIG_CPU_FREQ=y
+CONFIG_CPU_FREQ_TABLE=y
+# CONFIG_CPU_FREQ_DEBUG is not set
+CONFIG_CPU_FREQ_STAT=y
+# CONFIG_CPU_FREQ_STAT_DETAILS is not set
+CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE=y
+# CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE is not set
+# CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE is not set
+# CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND is not set
+# CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE is not set
+CONFIG_CPU_FREQ_GOV_PERFORMANCE=y
+# CONFIG_CPU_FREQ_GOV_POWERSAVE is not set
+# CONFIG_CPU_FREQ_GOV_USERSPACE is not set
+# CONFIG_CPU_FREQ_GOV_ONDEMAND is not set
+# CONFIG_CPU_FREQ_GOV_CONSERVATIVE is not set
+CONFIG_SH_CPU_FREQ=y
+
+#
+# DMA support
+#
+# CONFIG_SH_DMA is not set
+
+#
+# Companion Chips
+#
+
+#
+# Additional SuperH Device Drivers
+#
+# CONFIG_HEARTBEAT is not set
+# CONFIG_PUSH_SWITCH is not set
+
+#
+# Kernel features
+#
+# CONFIG_HZ_100 is not set
+CONFIG_HZ_250=y
+# CONFIG_HZ_300 is not set
+# CONFIG_HZ_1000 is not set
+CONFIG_HZ=250
+CONFIG_SCHED_HRTICK=y
+CONFIG_KEXEC=y
+# CONFIG_CRASH_DUMP is not set
+CONFIG_KEXEC_JUMP=y
+CONFIG_PREEMPT_NONE=y
+# CONFIG_PREEMPT_VOLUNTARY is not set
+# CONFIG_PREEMPT is not set
+CONFIG_GUSA=y
+
+#
+# Boot options
+#
+CONFIG_ZERO_PAGE_OFFSET=0x00001000
+CONFIG_BOOT_LINK_OFFSET=0x00800000
+# CONFIG_CMDLINE_BOOL is not set
+
+#
+# Bus options
+#
+# CONFIG_ARCH_SUPPORTS_MSI is not set
+# CONFIG_PCCARD is not set
+
+#
+# Executable file formats
+#
+CONFIG_BINFMT_ELF=y
+# CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS is not set
+# CONFIG_HAVE_AOUT is not set
+# CONFIG_BINFMT_MISC is not set
+
+#
+# Power management options (EXPERIMENTAL)
+#
+CONFIG_PM=y
+# CONFIG_PM_DEBUG is not set
+CONFIG_PM_SLEEP=y
+CONFIG_SUSPEND=y
+CONFIG_SUSPEND_FREEZER=y
+CONFIG_HIBERNATION=y
+CONFIG_PM_STD_PARTITION=""
+CONFIG_CPU_IDLE=y
+CONFIG_CPU_IDLE_GOV_LADDER=y
+CONFIG_CPU_IDLE_GOV_MENU=y
+# CONFIG_NET is not set
+
+#
+# Device Drivers
+#
+
+#
+# Generic Driver Options
+#
+CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
+CONFIG_STANDALONE=y
+# CONFIG_PREVENT_FIRMWARE_BUILD is not set
+CONFIG_FW_LOADER=y
+CONFIG_FIRMWARE_IN_KERNEL=y
+CONFIG_EXTRA_FIRMWARE=""
+# CONFIG_SYS_HYPERVISOR is not set
+# CONFIG_MTD is not set
+# CONFIG_PARPORT is not set
+CONFIG_BLK_DEV=y
+# CONFIG_BLK_DEV_COW_COMMON is not set
+# CONFIG_BLK_DEV_LOOP is not set
+# CONFIG_BLK_DEV_RAM is not set
+# CONFIG_CDROM_PKTCDVD is not set
+# CONFIG_BLK_DEV_HD is not set
+# CONFIG_MISC_DEVICES is not set
+CONFIG_HAVE_IDE=y
+# CONFIG_IDE is not set
+
+#
+# SCSI device support
+#
+# CONFIG_RAID_ATTRS is not set
+# CONFIG_SCSI is not set
+# CONFIG_SCSI_DMA is not set
+# CONFIG_SCSI_NETLINK is not set
+# CONFIG_ATA is not set
+# CONFIG_MD is not set
+# CONFIG_PHONE is not set
+
+#
+# Input device support
+#
+# CONFIG_INPUT is not set
+
+#
+# Hardware I/O ports
+#
+# CONFIG_SERIO is not set
+# CONFIG_GAMEPORT is not set
+
+#
+# Character devices
+#
+# CONFIG_VT is not set
+# CONFIG_DEVKMEM is not set
+# CONFIG_SERIAL_NONSTANDARD is not set
+
+#
+# Serial drivers
+#
+# CONFIG_SERIAL_8250 is not set
+
+#
+# Non-8250 serial port support
+#
+CONFIG_SERIAL_SH_SCI=y
+CONFIG_SERIAL_SH_SCI_NR_UARTS=6
+CONFIG_SERIAL_SH_SCI_CONSOLE=y
+CONFIG_SERIAL_CORE=y
+CONFIG_SERIAL_CORE_CONSOLE=y
+# CONFIG_UNIX98_PTYS is not set
+# CONFIG_LEGACY_PTYS is not set
+# CONFIG_IPMI_HANDLER is not set
+# CONFIG_HW_RANDOM is not set
+# CONFIG_R3964 is not set
+# CONFIG_RAW_DRIVER is not set
+# CONFIG_TCG_TPM is not set
+CONFIG_I2C=y
+CONFIG_I2C_BOARDINFO=y
+CONFIG_I2C_CHARDEV=y
+CONFIG_I2C_HELPER_AUTO=y
+
+#
+# I2C Hardware Bus support
+#
+
+#
+# I2C system bus drivers (mostly embedded / system-on-chip)
+#
+# CONFIG_I2C_OCORES is not set
+CONFIG_I2C_SH_MOBILE=y
+# CONFIG_I2C_SIMTEC is not set
+
+#
+# External I2C/SMBus adapter drivers
+#
+# CONFIG_I2C_PARPORT_LIGHT is not set
+# CONFIG_I2C_TAOS_EVM is not set
+
+#
+# Other I2C/SMBus bus drivers
+#
+# CONFIG_I2C_PCA_PLATFORM is not set
+
+#
+# Miscellaneous I2C Chip support
+#
+# CONFIG_DS1682 is not set
+# CONFIG_SENSORS_PCF8574 is not set
+# CONFIG_PCF8575 is not set
+# CONFIG_SENSORS_PCA9539 is not set
+# CONFIG_SENSORS_MAX6875 is not set
+# CONFIG_SENSORS_TSL2550 is not set
+# CONFIG_I2C_DEBUG_CORE is not set
+# CONFIG_I2C_DEBUG_ALGO is not set
+# CONFIG_I2C_DEBUG_BUS is not set
+# CONFIG_I2C_DEBUG_CHIP is not set
+# CONFIG_SPI is not set
+# CONFIG_W1 is not set
+# CONFIG_POWER_SUPPLY is not set
+# CONFIG_HWMON is not set
+# CONFIG_THERMAL is not set
+# CONFIG_THERMAL_HWMON is not set
+# CONFIG_WATCHDOG is not set
+CONFIG_SSB_POSSIBLE=y
+
+#
+# Sonics Silicon Backplane
+#
+# CONFIG_SSB is not set
+
+#
+# Multifunction device drivers
+#
+# CONFIG_MFD_CORE is not set
+# CONFIG_MFD_SM501 is not set
+# CONFIG_HTC_PASIC3 is not set
+# CONFIG_TWL4030_CORE is not set
+# CONFIG_MFD_TMIO is not set
+# CONFIG_PMIC_DA903X is not set
+# CONFIG_MFD_WM8400 is not set
+# CONFIG_MFD_WM8350_I2C is not set
+# CONFIG_MFD_PCF50633 is not set
+# CONFIG_REGULATOR is not set
+
+#
+# Multimedia devices
+#
+
+#
+# Multimedia core support
+#
+# CONFIG_VIDEO_DEV is not set
+# CONFIG_VIDEO_MEDIA is not set
+
+#
+# Multimedia drivers
+#
+# CONFIG_DAB is not set
+
+#
+# Graphics support
+#
+# CONFIG_VGASTATE is not set
+# CONFIG_VIDEO_OUTPUT_CONTROL is not set
+# CONFIG_FB is not set
+# CONFIG_BACKLIGHT_LCD_SUPPORT is not set
+
+#
+# Display device support
+#
+# CONFIG_DISPLAY_SUPPORT is not set
+# CONFIG_SOUND is not set
+# CONFIG_USB_SUPPORT is not set
+# CONFIG_MMC is not set
+# CONFIG_MEMSTICK is not set
+# CONFIG_NEW_LEDS is not set
+# CONFIG_ACCESSIBILITY is not set
+CONFIG_RTC_LIB=y
+CONFIG_RTC_CLASS=y
+CONFIG_RTC_HCTOSYS=y
+CONFIG_RTC_HCTOSYS_DEVICE="rtc0"
+# CONFIG_RTC_DEBUG is not set
+
+#
+# RTC interfaces
+#
+CONFIG_RTC_INTF_DEV=y
+# CONFIG_RTC_INTF_DEV_UIE_EMUL is not set
+# CONFIG_RTC_DRV_TEST is not set
+
+#
+# I2C RTC drivers
+#
+# CONFIG_RTC_DRV_DS1307 is not set
+# CONFIG_RTC_DRV_DS1374 is not set
+# CONFIG_RTC_DRV_DS1672 is not set
+# CONFIG_RTC_DRV_MAX6900 is not set
+# CONFIG_RTC_DRV_RS5C372 is not set
+# CONFIG_RTC_DRV_ISL1208 is not set
+# CONFIG_RTC_DRV_X1205 is not set
+# CONFIG_RTC_DRV_PCF8563 is not set
+# CONFIG_RTC_DRV_PCF8583 is not set
+# CONFIG_RTC_DRV_M41T80 is not set
+# CONFIG_RTC_DRV_S35390A is not set
+# CONFIG_RTC_DRV_FM3130 is not set
+# CONFIG_RTC_DRV_RX8581 is not set
+
+#
+# SPI RTC drivers
+#
+
+#
+# Platform RTC drivers
+#
+# CONFIG_RTC_DRV_DS1286 is not set
+# CONFIG_RTC_DRV_DS1511 is not set
+# CONFIG_RTC_DRV_DS1553 is not set
+# CONFIG_RTC_DRV_DS1742 is not set
+# CONFIG_RTC_DRV_STK17TA8 is not set
+# CONFIG_RTC_DRV_M48T86 is not set
+# CONFIG_RTC_DRV_M48T35 is not set
+# CONFIG_RTC_DRV_M48T59 is not set
+# CONFIG_RTC_DRV_BQ4802 is not set
+# CONFIG_RTC_DRV_V3020 is not set
+
+#
+# on-CPU RTC drivers
+#
+CONFIG_RTC_DRV_SH=y
+# CONFIG_DMADEVICES is not set
+# CONFIG_AUXDISPLAY is not set
+CONFIG_UIO=y
+# CONFIG_UIO_PDRV is not set
+CONFIG_UIO_PDRV_GENIRQ=y
+# CONFIG_UIO_SMX is not set
+# CONFIG_UIO_SERCOS3 is not set
+# CONFIG_STAGING is not set
+
+#
+# File systems
+#
+# CONFIG_EXT2_FS is not set
+# CONFIG_EXT3_FS is not set
+# CONFIG_EXT4_FS is not set
+# CONFIG_REISERFS_FS is not set
+# CONFIG_JFS_FS is not set
+# CONFIG_FS_POSIX_ACL is not set
+CONFIG_FILE_LOCKING=y
+# CONFIG_XFS_FS is not set
+# CONFIG_BTRFS_FS is not set
+# CONFIG_DNOTIFY is not set
+# CONFIG_INOTIFY is not set
+# CONFIG_QUOTA is not set
+# CONFIG_AUTOFS_FS is not set
+# CONFIG_AUTOFS4_FS is not set
+# CONFIG_FUSE_FS is not set
+
+#
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
+# CD-ROM/DVD Filesystems
+#
+# CONFIG_ISO9660_FS is not set
+# CONFIG_UDF_FS is not set
+
+#
+# DOS/FAT/NT Filesystems
+#
+# CONFIG_MSDOS_FS is not set
+# CONFIG_VFAT_FS is not set
+# CONFIG_NTFS_FS is not set
+
+#
+# Pseudo filesystems
+#
+# CONFIG_PROC_FS is not set
+# CONFIG_SYSFS is not set
+# CONFIG_TMPFS is not set
+# CONFIG_HUGETLBFS is not set
+# CONFIG_HUGETLB_PAGE is not set
+# CONFIG_MISC_FILESYSTEMS is not set
+
+#
+# Partition Types
+#
+# CONFIG_PARTITION_ADVANCED is not set
+CONFIG_MSDOS_PARTITION=y
+# CONFIG_NLS is not set
+
+#
+# Kernel hacking
+#
+CONFIG_TRACE_IRQFLAGS_SUPPORT=y
+# CONFIG_PRINTK_TIME is not set
+# CONFIG_ENABLE_WARN_DEPRECATED is not set
+# CONFIG_ENABLE_MUST_CHECK is not set
+CONFIG_FRAME_WARN=1024
+# CONFIG_MAGIC_SYSRQ is not set
+# CONFIG_UNUSED_SYMBOLS is not set
+CONFIG_DEBUG_FS=y
+# CONFIG_HEADERS_CHECK is not set
+# CONFIG_DEBUG_KERNEL is not set
+CONFIG_STACKTRACE=y
+# CONFIG_DEBUG_BUGVERBOSE is not set
+# CONFIG_DEBUG_MEMORY_INIT is not set
+# CONFIG_RCU_CPU_STALL_DETECTOR is not set
+# CONFIG_LATENCYTOP is not set
+# CONFIG_SYSCTL_SYSCALL_CHECK is not set
+CONFIG_NOP_TRACER=y
+CONFIG_HAVE_FUNCTION_TRACER=y
+CONFIG_HAVE_DYNAMIC_FTRACE=y
+CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_RING_BUFFER=y
+CONFIG_TRACING=y
+CONFIG_TRACING_SUPPORT=y
+
+#
+# Tracers
+#
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_FTRACE_STARTUP_TEST is not set
+# CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_DMA_API_DEBUG is not set
+# CONFIG_SAMPLES is not set
+CONFIG_HAVE_ARCH_KGDB=y
+# CONFIG_SH_STANDARD_BIOS is not set
+# CONFIG_EARLY_SCIF_CONSOLE is not set
+# CONFIG_MORE_COMPILE_OPTIONS is not set
+
+#
+# Security options
+#
+# CONFIG_KEYS is not set
+# CONFIG_SECURITYFS is not set
+# CONFIG_SECURITY_FILE_CAPABILITIES is not set
+# CONFIG_CRYPTO is not set
+CONFIG_BINARY_PRINTF=y
+
+#
+# Library routines
+#
+CONFIG_GENERIC_FIND_LAST_BIT=y
+# CONFIG_CRC_CCITT is not set
+# CONFIG_CRC16 is not set
+# CONFIG_CRC_T10DIF is not set
+# CONFIG_CRC_ITU_T is not set
+# CONFIG_CRC32 is not set
+# CONFIG_CRC7 is not set
+# CONFIG_LIBCRC32C is not set
+CONFIG_HAS_IOMEM=y
+CONFIG_HAS_IOPORT=y
+CONFIG_HAS_DMA=y
diff --git a/arch/sh/configs/sh7763rdp_defconfig b/arch/sh/configs/sh7763rdp_defconfig
index c79bb84ec305..f77bc7998d2f 100644
--- a/arch/sh/configs/sh7763rdp_defconfig
+++ b/arch/sh/configs/sh7763rdp_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 19:10:57 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:10:12 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -78,6 +79,7 @@ CONFIG_UID16=y
 # CONFIG_SYSCTL_SYSCALL is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -106,6 +108,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -117,7 +121,6 @@ CONFIG_MODULES=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -164,6 +167,7 @@ CONFIG_CPU_SH4A=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 CONFIG_CPU_SUBTYPE_SH7763=y
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -173,8 +177,6 @@ CONFIG_CPU_SUBTYPE_SH7763=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -555,6 +557,7 @@ CONFIG_SCSI_WAIT_SCAN=m
 CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_ISCSI_TCP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_SCSI_DEBUG is not set
 # CONFIG_SCSI_DH is not set
 # CONFIG_SCSI_OSD_INITIATOR is not set
@@ -941,6 +944,7 @@ CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -965,6 +969,11 @@ CONFIG_AUTOFS4_FS=y
 CONFIG_GENERIC_ACL=y
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -1012,6 +1021,7 @@ CONFIG_MISC_FILESYSTEMS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 # CONFIG_NFS_V3 is not set
@@ -1100,11 +1110,25 @@ CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 CONFIG_RING_BUFFER=y
 CONFIG_TRACING=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_FTRACE_STARTUP_TEST is not set
 # CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -1204,6 +1228,7 @@ CONFIG_CRYPTO=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
+CONFIG_BINARY_PRINTF=y
 
 #
 # Library routines
diff --git a/arch/sh/configs/sh7770_generic_defconfig b/arch/sh/configs/sh7770_generic_defconfig
new file mode 100644
index 000000000000..d6489b46ca5b
--- /dev/null
+++ b/arch/sh/configs/sh7770_generic_defconfig
@@ -0,0 +1,700 @@
+#
+# Automatically generated make config: don't edit
+# Linux kernel version: 2.6.30-rc4
+# Tue May 12 14:48:21 2009
+#
+CONFIG_SUPERH=y
+CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
+CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
+CONFIG_RWSEM_GENERIC_SPINLOCK=y
+CONFIG_GENERIC_BUG=y
+CONFIG_GENERIC_FIND_NEXT_BIT=y
+CONFIG_GENERIC_HWEIGHT=y
+CONFIG_GENERIC_HARDIRQS=y
+CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ=y
+CONFIG_GENERIC_IRQ_PROBE=y
+# CONFIG_GENERIC_GPIO is not set
+CONFIG_GENERIC_TIME=y
+CONFIG_GENERIC_CLOCKEVENTS=y
+# CONFIG_ARCH_SUSPEND_POSSIBLE is not set
+CONFIG_ARCH_HIBERNATION_POSSIBLE=y
+CONFIG_SYS_SUPPORTS_TMU=y
+CONFIG_STACKTRACE_SUPPORT=y
+CONFIG_LOCKDEP_SUPPORT=y
+CONFIG_HAVE_LATENCYTOP_SUPPORT=y
+# CONFIG_ARCH_HAS_ILOG2_U32 is not set
+# CONFIG_ARCH_HAS_ILOG2_U64 is not set
+CONFIG_ARCH_NO_VIRT_TO_BUS=y
+CONFIG_ARCH_HAS_DEFAULT_IDLE=y
+CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config"
+
+#
+# General setup
+#
+CONFIG_EXPERIMENTAL=y
+CONFIG_BROKEN_ON_SMP=y
+CONFIG_INIT_ENV_ARG_LIMIT=32
+CONFIG_LOCALVERSION=""
+# CONFIG_LOCALVERSION_AUTO is not set
+CONFIG_SWAP=y
+CONFIG_SYSVIPC=y
+CONFIG_SYSVIPC_SYSCTL=y
+# CONFIG_BSD_PROCESS_ACCT is not set
+
+#
+# RCU Subsystem
+#
+# CONFIG_CLASSIC_RCU is not set
+CONFIG_TREE_RCU=y
+# CONFIG_PREEMPT_RCU is not set
+# CONFIG_RCU_TRACE is not set
+CONFIG_RCU_FANOUT=32
+# CONFIG_RCU_FANOUT_EXACT is not set
+# CONFIG_TREE_RCU_TRACE is not set
+# CONFIG_PREEMPT_RCU_TRACE is not set
+# CONFIG_IKCONFIG is not set
+CONFIG_LOG_BUF_SHIFT=17
+CONFIG_GROUP_SCHED=y
+CONFIG_FAIR_GROUP_SCHED=y
+CONFIG_RT_GROUP_SCHED=y
+CONFIG_USER_SCHED=y
+# CONFIG_CGROUP_SCHED is not set
+CONFIG_CGROUPS=y
+# CONFIG_CGROUP_DEBUG is not set
+# CONFIG_CGROUP_NS is not set
+# CONFIG_CGROUP_FREEZER is not set
+# CONFIG_CGROUP_DEVICE is not set
+# CONFIG_CPUSETS is not set
+# CONFIG_CGROUP_CPUACCT is not set
+# CONFIG_RESOURCE_COUNTERS is not set
+# CONFIG_RELAY is not set
+# CONFIG_NAMESPACES is not set
+# CONFIG_BLK_DEV_INITRD is not set
+CONFIG_CC_OPTIMIZE_FOR_SIZE=y
+CONFIG_SYSCTL=y
+CONFIG_ANON_INODES=y
+CONFIG_EMBEDDED=y
+# CONFIG_UID16 is not set
+CONFIG_SYSCTL_SYSCALL=y
+CONFIG_KALLSYMS=y
+# CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
+CONFIG_HOTPLUG=y
+CONFIG_PRINTK=y
+CONFIG_BUG=y
+CONFIG_ELF_CORE=y
+CONFIG_BASE_FULL=y
+CONFIG_FUTEX=y
+CONFIG_EPOLL=y
+CONFIG_SIGNALFD=y
+CONFIG_TIMERFD=y
+CONFIG_EVENTFD=y
+CONFIG_SHMEM=y
+CONFIG_AIO=y
+CONFIG_VM_EVENT_COUNTERS=y
+# CONFIG_COMPAT_BRK is not set
+# CONFIG_SLAB is not set
+CONFIG_SLUB=y
+# CONFIG_SLOB is not set
+CONFIG_PROFILING=y
+CONFIG_TRACEPOINTS=y
+# CONFIG_MARKERS is not set
+CONFIG_OPROFILE=y
+CONFIG_HAVE_OPROFILE=y
+CONFIG_HAVE_IOREMAP_PROT=y
+CONFIG_HAVE_KPROBES=y
+CONFIG_HAVE_KRETPROBES=y
+CONFIG_HAVE_ARCH_TRACEHOOK=y
+CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
+CONFIG_HAVE_GENERIC_DMA_COHERENT=y
+CONFIG_RT_MUTEXES=y
+CONFIG_BASE_SMALL=0
+# CONFIG_MODULES is not set
+CONFIG_BLOCK=y
+# CONFIG_LBD is not set
+# CONFIG_BLK_DEV_BSG is not set
+# CONFIG_BLK_DEV_INTEGRITY is not set
+
+#
+# IO Schedulers
+#
+CONFIG_IOSCHED_NOOP=y
+CONFIG_IOSCHED_AS=y
+CONFIG_IOSCHED_DEADLINE=y
+CONFIG_IOSCHED_CFQ=y
+CONFIG_DEFAULT_AS=y
+# CONFIG_DEFAULT_DEADLINE is not set
+# CONFIG_DEFAULT_CFQ is not set
+# CONFIG_DEFAULT_NOOP is not set
+CONFIG_DEFAULT_IOSCHED="anticipatory"
+CONFIG_FREEZER=y
+
+#
+# System type
+#
+CONFIG_CPU_SH4=y
+CONFIG_CPU_SH4A=y
+# CONFIG_CPU_SUBTYPE_SH7619 is not set
+# CONFIG_CPU_SUBTYPE_SH7201 is not set
+# CONFIG_CPU_SUBTYPE_SH7203 is not set
+# CONFIG_CPU_SUBTYPE_SH7206 is not set
+# CONFIG_CPU_SUBTYPE_SH7263 is not set
+# CONFIG_CPU_SUBTYPE_MXG is not set
+# CONFIG_CPU_SUBTYPE_SH7705 is not set
+# CONFIG_CPU_SUBTYPE_SH7706 is not set
+# CONFIG_CPU_SUBTYPE_SH7707 is not set
+# CONFIG_CPU_SUBTYPE_SH7708 is not set
+# CONFIG_CPU_SUBTYPE_SH7709 is not set
+# CONFIG_CPU_SUBTYPE_SH7710 is not set
+# CONFIG_CPU_SUBTYPE_SH7712 is not set
+# CONFIG_CPU_SUBTYPE_SH7720 is not set
+# CONFIG_CPU_SUBTYPE_SH7721 is not set
+# CONFIG_CPU_SUBTYPE_SH7750 is not set
+# CONFIG_CPU_SUBTYPE_SH7091 is not set
+# CONFIG_CPU_SUBTYPE_SH7750R is not set
+# CONFIG_CPU_SUBTYPE_SH7750S is not set
+# CONFIG_CPU_SUBTYPE_SH7751 is not set
+# CONFIG_CPU_SUBTYPE_SH7751R is not set
+# CONFIG_CPU_SUBTYPE_SH7760 is not set
+# CONFIG_CPU_SUBTYPE_SH4_202 is not set
+# CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
+# CONFIG_CPU_SUBTYPE_SH7763 is not set
+CONFIG_CPU_SUBTYPE_SH7770=y
+# CONFIG_CPU_SUBTYPE_SH7780 is not set
+# CONFIG_CPU_SUBTYPE_SH7785 is not set
+# CONFIG_CPU_SUBTYPE_SH7786 is not set
+# CONFIG_CPU_SUBTYPE_SHX3 is not set
+# CONFIG_CPU_SUBTYPE_SH7343 is not set
+# CONFIG_CPU_SUBTYPE_SH7722 is not set
+# CONFIG_CPU_SUBTYPE_SH7366 is not set
+
+#
+# Memory management options
+#
+CONFIG_QUICKLIST=y
+CONFIG_MMU=y
+CONFIG_PAGE_OFFSET=0x80000000
+CONFIG_MEMORY_START=0x08000000
+CONFIG_MEMORY_SIZE=0x04000000
+CONFIG_29BIT=y
+CONFIG_VSYSCALL=y
+CONFIG_ARCH_FLATMEM_ENABLE=y
+CONFIG_ARCH_SPARSEMEM_ENABLE=y
+CONFIG_ARCH_SPARSEMEM_DEFAULT=y
+CONFIG_MAX_ACTIVE_REGIONS=1
+CONFIG_ARCH_POPULATES_NODE_MAP=y
+CONFIG_ARCH_SELECT_MEMORY_MODEL=y
+CONFIG_ARCH_ENABLE_MEMORY_HOTPLUG=y
+CONFIG_ARCH_ENABLE_MEMORY_HOTREMOVE=y
+CONFIG_PAGE_SIZE_4KB=y
+# CONFIG_PAGE_SIZE_8KB is not set
+# CONFIG_PAGE_SIZE_16KB is not set
+# CONFIG_PAGE_SIZE_64KB is not set
+CONFIG_SELECT_MEMORY_MODEL=y
+# CONFIG_FLATMEM_MANUAL is not set
+# CONFIG_DISCONTIGMEM_MANUAL is not set
+CONFIG_SPARSEMEM_MANUAL=y
+CONFIG_SPARSEMEM=y
+CONFIG_HAVE_MEMORY_PRESENT=y
+CONFIG_SPARSEMEM_STATIC=y
+
+#
+# Memory hotplug is currently incompatible with Software Suspend
+#
+CONFIG_PAGEFLAGS_EXTENDED=y
+CONFIG_SPLIT_PTLOCK_CPUS=4
+CONFIG_MIGRATION=y
+# CONFIG_PHYS_ADDR_T_64BIT is not set
+CONFIG_ZONE_DMA_FLAG=0
+CONFIG_NR_QUICK=2
+CONFIG_UNEVICTABLE_LRU=y
+CONFIG_HAVE_MLOCK=y
+CONFIG_HAVE_MLOCKED_PAGE_BIT=y
+
+#
+# Cache configuration
+#
+CONFIG_CACHE_WRITEBACK=y
+# CONFIG_CACHE_WRITETHROUGH is not set
+# CONFIG_CACHE_OFF is not set
+
+#
+# Processor features
+#
+CONFIG_CPU_LITTLE_ENDIAN=y
+# CONFIG_CPU_BIG_ENDIAN is not set
+CONFIG_SH_FPU=y
+# CONFIG_SH_STORE_QUEUES is not set
+CONFIG_CPU_HAS_INTEVT=y
+CONFIG_CPU_HAS_SR_RB=y
+CONFIG_CPU_HAS_FPU=y
+
+#
+# Board support
+#
+
+#
+# Timer and clock configuration
+#
+CONFIG_SH_TMU=y
+CONFIG_SH_TIMER_IRQ=16
+CONFIG_SH_PCLK_FREQ=41666666
+CONFIG_TICK_ONESHOT=y
+CONFIG_NO_HZ=y
+CONFIG_HIGH_RES_TIMERS=y
+CONFIG_GENERIC_CLOCKEVENTS_BUILD=y
+
+#
+# CPU Frequency scaling
+#
+CONFIG_CPU_FREQ=y
+CONFIG_CPU_FREQ_TABLE=y
+# CONFIG_CPU_FREQ_DEBUG is not set
+CONFIG_CPU_FREQ_STAT=y
+# CONFIG_CPU_FREQ_STAT_DETAILS is not set
+CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE=y
+# CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE is not set
+# CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE is not set
+# CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND is not set
+# CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE is not set
+CONFIG_CPU_FREQ_GOV_PERFORMANCE=y
+# CONFIG_CPU_FREQ_GOV_POWERSAVE is not set
+# CONFIG_CPU_FREQ_GOV_USERSPACE is not set
+# CONFIG_CPU_FREQ_GOV_ONDEMAND is not set
+# CONFIG_CPU_FREQ_GOV_CONSERVATIVE is not set
+CONFIG_SH_CPU_FREQ=y
+
+#
+# DMA support
+#
+# CONFIG_SH_DMA is not set
+
+#
+# Companion Chips
+#
+
+#
+# Additional SuperH Device Drivers
+#
+# CONFIG_HEARTBEAT is not set
+# CONFIG_PUSH_SWITCH is not set
+
+#
+# Kernel features
+#
+# CONFIG_HZ_100 is not set
+CONFIG_HZ_250=y
+# CONFIG_HZ_300 is not set
+# CONFIG_HZ_1000 is not set
+CONFIG_HZ=250
+CONFIG_SCHED_HRTICK=y
+CONFIG_KEXEC=y
+# CONFIG_CRASH_DUMP is not set
+CONFIG_KEXEC_JUMP=y
+CONFIG_PREEMPT_NONE=y
+# CONFIG_PREEMPT_VOLUNTARY is not set
+# CONFIG_PREEMPT is not set
+CONFIG_GUSA=y
+
+#
+# Boot options
+#
+CONFIG_ZERO_PAGE_OFFSET=0x00001000
+CONFIG_BOOT_LINK_OFFSET=0x00800000
+CONFIG_ENTRY_OFFSET=0x00001000
+# CONFIG_CMDLINE_BOOL is not set
+
+#
+# Bus options
+#
+# CONFIG_ARCH_SUPPORTS_MSI is not set
+# CONFIG_PCCARD is not set
+
+#
+# Executable file formats
+#
+CONFIG_BINFMT_ELF=y
+# CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS is not set
+# CONFIG_HAVE_AOUT is not set
+# CONFIG_BINFMT_MISC is not set
+
+#
+# Power management options (EXPERIMENTAL)
+#
+CONFIG_PM=y
+# CONFIG_PM_DEBUG is not set
+CONFIG_PM_SLEEP=y
+CONFIG_HIBERNATION=y
+CONFIG_PM_STD_PARTITION=""
+CONFIG_CPU_IDLE=y
+CONFIG_CPU_IDLE_GOV_LADDER=y
+CONFIG_CPU_IDLE_GOV_MENU=y
+# CONFIG_NET is not set
+
+#
+# Device Drivers
+#
+
+#
+# Generic Driver Options
+#
+CONFIG_UEVENT_HELPER_PATH="/sbin/hotplug"
+CONFIG_STANDALONE=y
+# CONFIG_PREVENT_FIRMWARE_BUILD is not set
+CONFIG_FW_LOADER=y
+CONFIG_FIRMWARE_IN_KERNEL=y
+CONFIG_EXTRA_FIRMWARE=""
+# CONFIG_SYS_HYPERVISOR is not set
+# CONFIG_MTD is not set
+# CONFIG_PARPORT is not set
+CONFIG_BLK_DEV=y
+# CONFIG_BLK_DEV_COW_COMMON is not set
+# CONFIG_BLK_DEV_LOOP is not set
+# CONFIG_BLK_DEV_RAM is not set
+# CONFIG_CDROM_PKTCDVD is not set
+# CONFIG_BLK_DEV_HD is not set
+# CONFIG_MISC_DEVICES is not set
+CONFIG_HAVE_IDE=y
+# CONFIG_IDE is not set
+
+#
+# SCSI device support
+#
+# CONFIG_RAID_ATTRS is not set
+# CONFIG_SCSI is not set
+# CONFIG_SCSI_DMA is not set
+# CONFIG_SCSI_NETLINK is not set
+# CONFIG_ATA is not set
+# CONFIG_MD is not set
+# CONFIG_PHONE is not set
+
+#
+# Input device support
+#
+# CONFIG_INPUT is not set
+
+#
+# Hardware I/O ports
+#
+# CONFIG_SERIO is not set
+# CONFIG_GAMEPORT is not set
+
+#
+# Character devices
+#
+# CONFIG_VT is not set
+# CONFIG_DEVKMEM is not set
+# CONFIG_SERIAL_NONSTANDARD is not set
+
+#
+# Serial drivers
+#
+# CONFIG_SERIAL_8250 is not set
+
+#
+# Non-8250 serial port support
+#
+CONFIG_SERIAL_SH_SCI=y
+CONFIG_SERIAL_SH_SCI_NR_UARTS=6
+CONFIG_SERIAL_SH_SCI_CONSOLE=y
+CONFIG_SERIAL_CORE=y
+CONFIG_SERIAL_CORE_CONSOLE=y
+# CONFIG_UNIX98_PTYS is not set
+# CONFIG_LEGACY_PTYS is not set
+# CONFIG_IPMI_HANDLER is not set
+# CONFIG_HW_RANDOM is not set
+# CONFIG_R3964 is not set
+# CONFIG_RAW_DRIVER is not set
+# CONFIG_TCG_TPM is not set
+CONFIG_I2C=y
+CONFIG_I2C_BOARDINFO=y
+CONFIG_I2C_CHARDEV=y
+CONFIG_I2C_HELPER_AUTO=y
+
+#
+# I2C Hardware Bus support
+#
+
+#
+# I2C system bus drivers (mostly embedded / system-on-chip)
+#
+# CONFIG_I2C_OCORES is not set
+CONFIG_I2C_SH_MOBILE=y
+# CONFIG_I2C_SIMTEC is not set
+
+#
+# External I2C/SMBus adapter drivers
+#
+# CONFIG_I2C_PARPORT_LIGHT is not set
+# CONFIG_I2C_TAOS_EVM is not set
+
+#
+# Other I2C/SMBus bus drivers
+#
+# CONFIG_I2C_PCA_PLATFORM is not set
+
+#
+# Miscellaneous I2C Chip support
+#
+# CONFIG_DS1682 is not set
+# CONFIG_SENSORS_PCF8574 is not set
+# CONFIG_PCF8575 is not set
+# CONFIG_SENSORS_PCA9539 is not set
+# CONFIG_SENSORS_MAX6875 is not set
+# CONFIG_SENSORS_TSL2550 is not set
+# CONFIG_I2C_DEBUG_CORE is not set
+# CONFIG_I2C_DEBUG_ALGO is not set
+# CONFIG_I2C_DEBUG_BUS is not set
+# CONFIG_I2C_DEBUG_CHIP is not set
+# CONFIG_SPI is not set
+# CONFIG_W1 is not set
+# CONFIG_POWER_SUPPLY is not set
+# CONFIG_HWMON is not set
+# CONFIG_THERMAL is not set
+# CONFIG_THERMAL_HWMON is not set
+# CONFIG_WATCHDOG is not set
+CONFIG_SSB_POSSIBLE=y
+
+#
+# Sonics Silicon Backplane
+#
+# CONFIG_SSB is not set
+
+#
+# Multifunction device drivers
+#
+# CONFIG_MFD_CORE is not set
+# CONFIG_MFD_SM501 is not set
+# CONFIG_HTC_PASIC3 is not set
+# CONFIG_TWL4030_CORE is not set
+# CONFIG_MFD_TMIO is not set
+# CONFIG_PMIC_DA903X is not set
+# CONFIG_MFD_WM8400 is not set
+# CONFIG_MFD_WM8350_I2C is not set
+# CONFIG_MFD_PCF50633 is not set
+# CONFIG_REGULATOR is not set
+
+#
+# Multimedia devices
+#
+
+#
+# Multimedia core support
+#
+# CONFIG_VIDEO_DEV is not set
+# CONFIG_VIDEO_MEDIA is not set
+
+#
+# Multimedia drivers
+#
+# CONFIG_DAB is not set
+
+#
+# Graphics support
+#
+# CONFIG_VGASTATE is not set
+# CONFIG_VIDEO_OUTPUT_CONTROL is not set
+# CONFIG_FB is not set
+# CONFIG_BACKLIGHT_LCD_SUPPORT is not set
+
+#
+# Display device support
+#
+# CONFIG_DISPLAY_SUPPORT is not set
+# CONFIG_SOUND is not set
+# CONFIG_USB_SUPPORT is not set
+# CONFIG_MMC is not set
+# CONFIG_MEMSTICK is not set
+# CONFIG_NEW_LEDS is not set
+# CONFIG_ACCESSIBILITY is not set
+CONFIG_RTC_LIB=y
+CONFIG_RTC_CLASS=y
+CONFIG_RTC_HCTOSYS=y
+CONFIG_RTC_HCTOSYS_DEVICE="rtc0"
+# CONFIG_RTC_DEBUG is not set
+
+#
+# RTC interfaces
+#
+CONFIG_RTC_INTF_DEV=y
+# CONFIG_RTC_INTF_DEV_UIE_EMUL is not set
+# CONFIG_RTC_DRV_TEST is not set
+
+#
+# I2C RTC drivers
+#
+# CONFIG_RTC_DRV_DS1307 is not set
+# CONFIG_RTC_DRV_DS1374 is not set
+# CONFIG_RTC_DRV_DS1672 is not set
+# CONFIG_RTC_DRV_MAX6900 is not set
+# CONFIG_RTC_DRV_RS5C372 is not set
+# CONFIG_RTC_DRV_ISL1208 is not set
+# CONFIG_RTC_DRV_X1205 is not set
+# CONFIG_RTC_DRV_PCF8563 is not set
+# CONFIG_RTC_DRV_PCF8583 is not set
+# CONFIG_RTC_DRV_M41T80 is not set
+# CONFIG_RTC_DRV_S35390A is not set
+# CONFIG_RTC_DRV_FM3130 is not set
+# CONFIG_RTC_DRV_RX8581 is not set
+
+#
+# SPI RTC drivers
+#
+
+#
+# Platform RTC drivers
+#
+# CONFIG_RTC_DRV_DS1286 is not set
+# CONFIG_RTC_DRV_DS1511 is not set
+# CONFIG_RTC_DRV_DS1553 is not set
+# CONFIG_RTC_DRV_DS1742 is not set
+# CONFIG_RTC_DRV_STK17TA8 is not set
+# CONFIG_RTC_DRV_M48T86 is not set
+# CONFIG_RTC_DRV_M48T35 is not set
+# CONFIG_RTC_DRV_M48T59 is not set
+# CONFIG_RTC_DRV_BQ4802 is not set
+# CONFIG_RTC_DRV_V3020 is not set
+
+#
+# on-CPU RTC drivers
+#
+CONFIG_RTC_DRV_SH=y
+# CONFIG_RTC_DRV_GENERIC is not set
+# CONFIG_DMADEVICES is not set
+# CONFIG_AUXDISPLAY is not set
+CONFIG_UIO=y
+# CONFIG_UIO_PDRV is not set
+CONFIG_UIO_PDRV_GENIRQ=y
+# CONFIG_UIO_SMX is not set
+# CONFIG_UIO_SERCOS3 is not set
+# CONFIG_STAGING is not set
+
+#
+# File systems
+#
+# CONFIG_EXT2_FS is not set
+# CONFIG_EXT3_FS is not set
+# CONFIG_EXT4_FS is not set
+# CONFIG_REISERFS_FS is not set
+# CONFIG_JFS_FS is not set
+# CONFIG_FS_POSIX_ACL is not set
+CONFIG_FILE_LOCKING=y
+# CONFIG_XFS_FS is not set
+# CONFIG_BTRFS_FS is not set
+# CONFIG_DNOTIFY is not set
+# CONFIG_INOTIFY is not set
+# CONFIG_QUOTA is not set
+# CONFIG_AUTOFS_FS is not set
+# CONFIG_AUTOFS4_FS is not set
+# CONFIG_FUSE_FS is not set
+
+#
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
+# CD-ROM/DVD Filesystems
+#
+# CONFIG_ISO9660_FS is not set
+# CONFIG_UDF_FS is not set
+
+#
+# DOS/FAT/NT Filesystems
+#
+# CONFIG_MSDOS_FS is not set
+# CONFIG_VFAT_FS is not set
+# CONFIG_NTFS_FS is not set
+
+#
+# Pseudo filesystems
+#
+# CONFIG_PROC_FS is not set
+# CONFIG_SYSFS is not set
+# CONFIG_TMPFS is not set
+# CONFIG_HUGETLBFS is not set
+# CONFIG_HUGETLB_PAGE is not set
+# CONFIG_MISC_FILESYSTEMS is not set
+
+#
+# Partition Types
+#
+# CONFIG_PARTITION_ADVANCED is not set
+CONFIG_MSDOS_PARTITION=y
+# CONFIG_NLS is not set
+
+#
+# Kernel hacking
+#
+CONFIG_TRACE_IRQFLAGS_SUPPORT=y
+# CONFIG_PRINTK_TIME is not set
+# CONFIG_ENABLE_WARN_DEPRECATED is not set
+# CONFIG_ENABLE_MUST_CHECK is not set
+CONFIG_FRAME_WARN=1024
+# CONFIG_MAGIC_SYSRQ is not set
+# CONFIG_UNUSED_SYMBOLS is not set
+CONFIG_DEBUG_FS=y
+# CONFIG_HEADERS_CHECK is not set
+# CONFIG_DEBUG_KERNEL is not set
+CONFIG_STACKTRACE=y
+# CONFIG_DEBUG_BUGVERBOSE is not set
+# CONFIG_DEBUG_MEMORY_INIT is not set
+# CONFIG_RCU_CPU_STALL_DETECTOR is not set
+# CONFIG_LATENCYTOP is not set
+# CONFIG_SYSCTL_SYSCALL_CHECK is not set
+CONFIG_NOP_TRACER=y
+CONFIG_HAVE_FUNCTION_TRACER=y
+CONFIG_HAVE_DYNAMIC_FTRACE=y
+CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_RING_BUFFER=y
+CONFIG_TRACING=y
+CONFIG_TRACING_SUPPORT=y
+
+#
+# Tracers
+#
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_FTRACE_STARTUP_TEST is not set
+# CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_DMA_API_DEBUG is not set
+# CONFIG_SAMPLES is not set
+CONFIG_HAVE_ARCH_KGDB=y
+# CONFIG_SH_STANDARD_BIOS is not set
+# CONFIG_EARLY_SCIF_CONSOLE is not set
+
+#
+# Security options
+#
+# CONFIG_KEYS is not set
+# CONFIG_SECURITYFS is not set
+# CONFIG_SECURITY_FILE_CAPABILITIES is not set
+# CONFIG_CRYPTO is not set
+CONFIG_BINARY_PRINTF=y
+
+#
+# Library routines
+#
+CONFIG_GENERIC_FIND_LAST_BIT=y
+# CONFIG_CRC_CCITT is not set
+# CONFIG_CRC16 is not set
+# CONFIG_CRC_T10DIF is not set
+# CONFIG_CRC_ITU_T is not set
+# CONFIG_CRC32 is not set
+# CONFIG_CRC7 is not set
+# CONFIG_LIBCRC32C is not set
+CONFIG_HAS_IOMEM=y
+CONFIG_HAS_IOPORT=y
+CONFIG_HAS_DMA=y
diff --git a/arch/sh/configs/sh7785lcr_32bit_defconfig b/arch/sh/configs/sh7785lcr_32bit_defconfig
index a6cf4505741c..1c55b800d124 100644
--- a/arch/sh/configs/sh7785lcr_32bit_defconfig
+++ b/arch/sh/configs/sh7785lcr_32bit_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 19:12:18 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:10:53 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -79,6 +80,7 @@ CONFIG_SYSCTL_SYSCALL=y
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_ALL is not set
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -98,6 +100,7 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 CONFIG_PROFILING=y
+# CONFIG_MARKERS is not set
 # CONFIG_OPROFILE is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
@@ -106,6 +109,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -118,7 +123,6 @@ CONFIG_MODULE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -166,6 +170,7 @@ CONFIG_CPU_SHX2=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -175,8 +180,6 @@ CONFIG_CPU_SUBTYPE_SH7785=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -310,8 +313,6 @@ CONFIG_BOOT_LINK_OFFSET=0x00800000
 #
 CONFIG_PCI=y
 CONFIG_SH_PCIDMA_NONCOHERENT=y
-CONFIG_PCI_AUTO=y
-CONFIG_PCI_AUTO_UPDATE_RESOURCES=y
 # CONFIG_PCIEPORTBUS is not set
 # CONFIG_ARCH_SUPPORTS_MSI is not set
 CONFIG_PCI_LEGACY=y
@@ -672,6 +673,7 @@ CONFIG_NETDEV_1000=y
 # CONFIG_E1000E is not set
 # CONFIG_IP1000 is not set
 # CONFIG_IGB is not set
+# CONFIG_IGBVF is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
@@ -1009,15 +1011,17 @@ CONFIG_USB_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_HID_A4TECH=y
 CONFIG_HID_APPLE=y
 CONFIG_HID_BELKIN=y
 CONFIG_HID_CHERRY=y
 CONFIG_HID_CHICONY=y
 CONFIG_HID_CYPRESS=y
+# CONFIG_DRAGONRISE_FF is not set
 CONFIG_HID_EZKEY=y
+# CONFIG_HID_KYE is not set
 CONFIG_HID_GYRATION=y
+# CONFIG_HID_KENSINGTON is not set
 CONFIG_HID_LOGITECH=y
 # CONFIG_LOGITECH_FF is not set
 # CONFIG_LOGIRUMBLEPAD2_FF is not set
@@ -1218,6 +1222,7 @@ CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -1240,6 +1245,11 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -1289,6 +1299,7 @@ CONFIG_MINIX_FS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
@@ -1377,6 +1388,9 @@ CONFIG_DEBUG_KERNEL=y
 CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC is not set
 CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE=0
+CONFIG_DETECT_HUNG_TASK=y
+# CONFIG_BOOTPARAM_HUNG_TASK_PANIC is not set
+CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE=0
 CONFIG_SCHED_DEBUG=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_TIMER_STATS is not set
@@ -1413,6 +1427,7 @@ CONFIG_SYSCTL_SYSCALL_CHECK=y
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
@@ -1422,9 +1437,14 @@ CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 # CONFIG_PREEMPT_TRACER is not set
 # CONFIG_SCHED_TRACER is not set
 # CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
 # CONFIG_BOOT_TRACER is not set
 # CONFIG_TRACE_BRANCH_PROFILING is not set
 # CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_KGDB is not set
@@ -1542,6 +1562,7 @@ CONFIG_CRYPTO_DES=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 # CONFIG_CRYPTO_HW is not set
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/sh7785lcr_defconfig b/arch/sh/configs/sh7785lcr_defconfig
index e4fac2efc055..4385fe97a780 100644
--- a/arch/sh/configs/sh7785lcr_defconfig
+++ b/arch/sh/configs/sh7785lcr_defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.30-rc2
-# Wed Apr 22 19:17:56 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:11:48 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
@@ -307,8 +307,6 @@ CONFIG_BOOT_LINK_OFFSET=0x00800000
 #
 CONFIG_PCI=y
 CONFIG_SH_PCIDMA_NONCOHERENT=y
-CONFIG_PCI_AUTO=y
-CONFIG_PCI_AUTO_UPDATE_RESOURCES=y
 # CONFIG_PCIEPORTBUS is not set
 # CONFIG_ARCH_SUPPORTS_MSI is not set
 CONFIG_PCI_LEGACY=y
diff --git a/arch/sh/configs/shmin_defconfig b/arch/sh/configs/shmin_defconfig
index d695e9061874..4e120256ec63 100644
--- a/arch/sh/configs/shmin_defconfig
+++ b/arch/sh/configs/shmin_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 19:19:03 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:12:41 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_FIND_NEXT_BIT=y
@@ -63,6 +64,7 @@ CONFIG_EMBEDDED=y
 # CONFIG_UID16 is not set
 # CONFIG_SYSCTL_SYSCALL is not set
 # CONFIG_KALLSYMS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 # CONFIG_HOTPLUG is not set
 CONFIG_PRINTK=y
 # CONFIG_BUG is not set
@@ -81,12 +83,15 @@ CONFIG_COMPAT_BRK=y
 # CONFIG_SLUB is not set
 CONFIG_SLOB=y
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 CONFIG_HAVE_IOREMAP_PROT=y
 CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_BASE_SMALL=1
 # CONFIG_MODULES is not set
@@ -137,6 +142,7 @@ CONFIG_CPU_SUBTYPE_SH7706=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -146,8 +152,6 @@ CONFIG_CPU_SUBTYPE_SH7706=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -675,6 +679,11 @@ CONFIG_FILE_LOCKING=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -718,6 +727,7 @@ CONFIG_CRAMFS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
@@ -762,10 +772,22 @@ CONFIG_FRAME_WARN=1024
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 CONFIG_SH_STANDARD_BIOS=y
@@ -864,6 +886,7 @@ CONFIG_CRYPTO=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/shx3_defconfig b/arch/sh/configs/shx3_defconfig
index e3651f574399..c088144925fa 100644
--- a/arch/sh/configs/shx3_defconfig
+++ b/arch/sh/configs/shx3_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 19:20:54 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:13:12 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -42,6 +43,7 @@ CONFIG_SWAP=y
 CONFIG_SYSVIPC=y
 CONFIG_SYSVIPC_SYSCTL=y
 CONFIG_POSIX_MQUEUE=y
+CONFIG_POSIX_MQUEUE_SYSCTL=y
 CONFIG_BSD_PROCESS_ACCT=y
 # CONFIG_BSD_PROCESS_ACCT_V3 is not set
 # CONFIG_TASKSTATS is not set
@@ -96,6 +98,7 @@ CONFIG_SYSCTL_SYSCALL=y
 CONFIG_KALLSYMS=y
 CONFIG_KALLSYMS_ALL=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -126,6 +129,8 @@ CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_USE_GENERIC_SMP_HELPERS=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_RT_MUTEXES=y
 CONFIG_BASE_SMALL=0
@@ -138,7 +143,6 @@ CONFIG_MODULE_UNLOAD=y
 CONFIG_STOP_MACHINE=y
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -186,6 +190,7 @@ CONFIG_CPU_SHX3=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -195,8 +200,6 @@ CONFIG_CPU_SUBTYPE_SHX3=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -553,6 +556,7 @@ CONFIG_SCSI_WAIT_SCAN=m
 CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_ISCSI_TCP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_SCSI_DEBUG is not set
 # CONFIG_SCSI_DH is not set
 # CONFIG_SCSI_OSD_INITIATOR is not set
@@ -646,6 +650,7 @@ CONFIG_DEVKMEM=y
 #
 # Non-8250 serial port support
 #
+# CONFIG_SERIAL_MAX3100 is not set
 CONFIG_SERIAL_SH_SCI=y
 CONFIG_SERIAL_SH_SCI_NR_UARTS=2
 CONFIG_SERIAL_SH_SCI_CONSOLE=y
@@ -985,6 +990,7 @@ CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -1008,6 +1014,11 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -1051,6 +1062,7 @@ CONFIG_MISC_FILESYSTEMS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 # CONFIG_NFS_FS is not set
 # CONFIG_NFSD is not set
@@ -1085,6 +1097,9 @@ CONFIG_DEBUG_SHIRQ=y
 CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC is not set
 CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE=0
+CONFIG_DETECT_HUNG_TASK=y
+# CONFIG_BOOTPARAM_HUNG_TASK_PANIC is not set
+CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE=0
 CONFIG_SCHED_DEBUG=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_TIMER_STATS is not set
@@ -1124,6 +1139,7 @@ CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 CONFIG_RING_BUFFER=y
 CONFIG_TRACING=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
@@ -1133,11 +1149,16 @@ CONFIG_TRACING=y
 # CONFIG_PREEMPT_TRACER is not set
 # CONFIG_SCHED_TRACER is not set
 # CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
 # CONFIG_BOOT_TRACER is not set
 # CONFIG_TRACE_BRANCH_PROFILING is not set
 # CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_FTRACE_STARTUP_TEST is not set
 # CONFIG_DYNAMIC_DEBUG is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_KGDB is not set
@@ -1245,6 +1266,7 @@ CONFIG_CRYPTO=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
+CONFIG_BINARY_PRINTF=y
 
 #
 # Library routines
diff --git a/arch/sh/configs/snapgear_defconfig b/arch/sh/configs/snapgear_defconfig
index 6960f60bf52e..54a7a3c41f34 100644
--- a/arch/sh/configs/snapgear_defconfig
+++ b/arch/sh/configs/snapgear_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 19:21:39 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:14:00 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -64,7 +65,6 @@ CONFIG_INITRAMFS_SOURCE=""
 CONFIG_RD_GZIP=y
 # CONFIG_RD_BZIP2 is not set
 # CONFIG_RD_LZMA is not set
-CONFIG_INITRAMFS_COMPRESSION_NONE=y
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
 CONFIG_SYSCTL=y
 CONFIG_ANON_INODES=y
@@ -73,6 +73,7 @@ CONFIG_UID16=y
 # CONFIG_SYSCTL_SYSCALL is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 # CONFIG_HOTPLUG is not set
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -92,12 +93,15 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 CONFIG_HAVE_IOREMAP_PROT=y
 CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -105,7 +109,6 @@ CONFIG_BASE_SMALL=0
 # CONFIG_MODULES is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -151,6 +154,7 @@ CONFIG_CPU_SUBTYPE_SH7751R=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -160,8 +164,6 @@ CONFIG_CPU_SUBTYPE_SH7751R=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -295,8 +297,6 @@ CONFIG_BOOT_LINK_OFFSET=0x00800000
 #
 CONFIG_PCI=y
 CONFIG_SH_PCIDMA_NONCOHERENT=y
-CONFIG_PCI_AUTO=y
-CONFIG_PCI_AUTO_UPDATE_RESOURCES=y
 # CONFIG_PCIEPORTBUS is not set
 # CONFIG_ARCH_SUPPORTS_MSI is not set
 CONFIG_PCI_LEGACY=y
@@ -763,6 +763,11 @@ CONFIG_FILE_LOCKING=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -805,8 +810,13 @@ CONFIG_CRAMFS=y
 # CONFIG_HPFS_FS is not set
 # CONFIG_QNX4FS_FS is not set
 CONFIG_ROMFS_FS=y
+CONFIG_ROMFS_BACKED_BY_BLOCK=y
+# CONFIG_ROMFS_BACKED_BY_MTD is not set
+# CONFIG_ROMFS_BACKED_BY_BOTH is not set
+CONFIG_ROMFS_ON_BLOCK=y
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 # CONFIG_NFS_FS is not set
 # CONFIG_NFSD is not set
@@ -844,10 +854,23 @@ CONFIG_FRAME_WARN=1024
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -862,6 +885,7 @@ CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SECURITYFS is not set
 # CONFIG_SECURITY_FILE_CAPABILITIES is not set
 # CONFIG_CRYPTO is not set
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/systemh_defconfig b/arch/sh/configs/systemh_defconfig
index 7ea639bc5936..dbe7e546f0bb 100644
--- a/arch/sh/configs/systemh_defconfig
+++ b/arch/sh/configs/systemh_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 19:23:31 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:14:33 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -61,7 +62,6 @@ CONFIG_INITRAMFS_SOURCE=""
 CONFIG_RD_GZIP=y
 # CONFIG_RD_BZIP2 is not set
 # CONFIG_RD_LZMA is not set
-CONFIG_INITRAMFS_COMPRESSION_NONE=y
 # CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 CONFIG_SYSCTL=y
 CONFIG_ANON_INODES=y
@@ -70,6 +70,7 @@ CONFIG_UID16=y
 # CONFIG_SYSCTL_SYSCALL is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 # CONFIG_HOTPLUG is not set
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -88,6 +89,7 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
 CONFIG_HAVE_IOREMAP_PROT=y
@@ -95,6 +97,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -107,7 +111,6 @@ CONFIG_MODULE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -153,6 +156,7 @@ CONFIG_CPU_SUBTYPE_SH7751R=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -162,8 +166,6 @@ CONFIG_CPU_SUBTYPE_SH7751R=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -506,6 +508,11 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -547,8 +554,13 @@ CONFIG_CRAMFS=y
 # CONFIG_HPFS_FS is not set
 # CONFIG_QNX4FS_FS is not set
 CONFIG_ROMFS_FS=y
+CONFIG_ROMFS_BACKED_BY_BLOCK=y
+# CONFIG_ROMFS_BACKED_BY_MTD is not set
+# CONFIG_ROMFS_BACKED_BY_BOTH is not set
+CONFIG_ROMFS_ON_BLOCK=y
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 
 #
 # Partition Types
@@ -577,10 +589,24 @@ CONFIG_FRAME_WARN=1024
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_PREEMPT_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -595,6 +621,7 @@ CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SECURITYFS is not set
 # CONFIG_SECURITY_FILE_CAPABILITIES is not set
 # CONFIG_CRYPTO is not set
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/titan_defconfig b/arch/sh/configs/titan_defconfig
index bbeb4c6ebb95..8ca94ef74278 100644
--- a/arch/sh/configs/titan_defconfig
+++ b/arch/sh/configs/titan_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 19:24:55 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:14:55 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -40,6 +41,7 @@ CONFIG_SWAP=y
 CONFIG_SYSVIPC=y
 CONFIG_SYSVIPC_SYSCTL=y
 CONFIG_POSIX_MQUEUE=y
+CONFIG_POSIX_MQUEUE_SYSCTL=y
 # CONFIG_BSD_PROCESS_ACCT is not set
 # CONFIG_TASKSTATS is not set
 # CONFIG_AUDIT is not set
@@ -66,7 +68,6 @@ CONFIG_INITRAMFS_SOURCE=""
 CONFIG_RD_GZIP=y
 # CONFIG_RD_BZIP2 is not set
 # CONFIG_RD_LZMA is not set
-CONFIG_INITRAMFS_COMPRESSION_NONE=y
 # CONFIG_CC_OPTIMIZE_FOR_SIZE is not set
 CONFIG_SYSCTL=y
 CONFIG_ANON_INODES=y
@@ -76,6 +77,7 @@ CONFIG_UID16=y
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_ALL is not set
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -95,6 +97,7 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 # CONFIG_PROFILING is not set
+# CONFIG_MARKERS is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
 CONFIG_HAVE_IOREMAP_PROT=y
@@ -102,6 +105,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -114,7 +119,6 @@ CONFIG_MODULE_FORCE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -160,6 +164,7 @@ CONFIG_CPU_SUBTYPE_SH7751R=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -169,8 +174,6 @@ CONFIG_CPU_SUBTYPE_SH7751R=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -305,8 +308,6 @@ CONFIG_CMDLINE="console=ttySC1,38400N81 root=/dev/nfs ip=:::::eth1:autoconf rw"
 #
 CONFIG_PCI=y
 CONFIG_SH_PCIDMA_NONCOHERENT=y
-CONFIG_PCI_AUTO=y
-CONFIG_PCI_AUTO_UPDATE_RESOURCES=y
 # CONFIG_PCIEPORTBUS is not set
 # CONFIG_ARCH_SUPPORTS_MSI is not set
 CONFIG_PCI_LEGACY=y
@@ -789,6 +790,7 @@ CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_SCSI_MPT2SAS is not set
 # CONFIG_SCSI_HPTIOP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_FCOE is not set
 # CONFIG_SCSI_DMX3191D is not set
 # CONFIG_SCSI_FUTURE_DOMAIN is not set
@@ -906,6 +908,7 @@ CONFIG_NETDEV_1000=y
 # CONFIG_E1000E is not set
 # CONFIG_IP1000 is not set
 # CONFIG_IGB is not set
+# CONFIG_IGBVF is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
@@ -929,6 +932,7 @@ CONFIG_CHELSIO_T3_DEPENDS=y
 # CONFIG_IXGBE is not set
 # CONFIG_IXGB is not set
 # CONFIG_S2IO is not set
+# CONFIG_VXGE is not set
 # CONFIG_MYRI10GE is not set
 # CONFIG_NETXEN_NIC is not set
 # CONFIG_NIU is not set
@@ -1182,7 +1186,6 @@ CONFIG_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_USB_SUPPORT=y
 CONFIG_USB_ARCH_HAS_HCD=y
 CONFIG_USB_ARCH_HAS_OHCI=y
@@ -1393,6 +1396,7 @@ CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 # CONFIG_EXT3_FS_XATTR is not set
 # CONFIG_EXT4_FS is not set
 CONFIG_JBD=y
@@ -1419,6 +1423,11 @@ CONFIG_INOTIFY_USER=y
 CONFIG_FUSE_FS=m
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 CONFIG_ISO9660_FS=m
@@ -1467,8 +1476,13 @@ CONFIG_MISC_FILESYSTEMS=y
 # CONFIG_HPFS_FS is not set
 # CONFIG_QNX4FS_FS is not set
 CONFIG_ROMFS_FS=y
+CONFIG_ROMFS_BACKED_BY_BLOCK=y
+# CONFIG_ROMFS_BACKED_BY_MTD is not set
+# CONFIG_ROMFS_BACKED_BY_BOTH is not set
+CONFIG_ROMFS_ON_BLOCK=y
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
@@ -1576,6 +1590,7 @@ CONFIG_MAGIC_SYSRQ=y
 CONFIG_DEBUG_KERNEL=y
 # CONFIG_DEBUG_SHIRQ is not set
 # CONFIG_DETECT_SOFTLOCKUP is not set
+# CONFIG_DETECT_HUNG_TASK is not set
 CONFIG_SCHED_DEBUG=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_TIMER_STATS is not set
@@ -1610,6 +1625,7 @@ CONFIG_SCHED_DEBUG=y
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
@@ -1618,9 +1634,14 @@ CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
 # CONFIG_IRQSOFF_TRACER is not set
 # CONFIG_SCHED_TRACER is not set
 # CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
 # CONFIG_BOOT_TRACER is not set
 # CONFIG_TRACE_BRANCH_PROFILING is not set
 # CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_KGDB is not set
@@ -1741,6 +1762,7 @@ CONFIG_CRYPTO_DEFLATE=y
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
 # CONFIG_CRYPTO_DEV_HIFN_795X is not set
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/ul2_defconfig b/arch/sh/configs/ul2_defconfig
index 34f5192a3241..bfb4d9806892 100644
--- a/arch/sh/configs/ul2_defconfig
+++ b/arch/sh/configs/ul2_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 19:30:27 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 13:17:05 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -69,7 +70,6 @@ CONFIG_INITRAMFS_SOURCE=""
 CONFIG_RD_GZIP=y
 # CONFIG_RD_BZIP2 is not set
 # CONFIG_RD_LZMA is not set
-CONFIG_INITRAMFS_COMPRESSION_NONE=y
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
 CONFIG_SYSCTL=y
 CONFIG_ANON_INODES=y
@@ -78,6 +78,7 @@ CONFIG_UID16=y
 CONFIG_SYSCTL_SYSCALL=y
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -97,6 +98,7 @@ CONFIG_COMPAT_BRK=y
 CONFIG_SLUB=y
 # CONFIG_SLOB is not set
 CONFIG_PROFILING=y
+# CONFIG_MARKERS is not set
 # CONFIG_OPROFILE is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
@@ -105,6 +107,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -117,7 +121,6 @@ CONFIG_MODULE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -167,6 +170,7 @@ CONFIG_ARCH_SHMOBILE=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -176,8 +180,6 @@ CONFIG_ARCH_SHMOBILE=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 CONFIG_CPU_SUBTYPE_SH7366=y
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -584,6 +586,7 @@ CONFIG_SCSI_WAIT_SCAN=m
 CONFIG_SCSI_LOWLEVEL=y
 # CONFIG_ISCSI_TCP is not set
 # CONFIG_LIBFC is not set
+# CONFIG_LIBFCOE is not set
 # CONFIG_SCSI_DEBUG is not set
 # CONFIG_SCSI_DH is not set
 # CONFIG_SCSI_OSD_INITIATOR is not set
@@ -936,6 +939,7 @@ CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -958,6 +962,11 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -1005,6 +1014,7 @@ CONFIG_CRAMFS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 # CONFIG_NFS_V3 is not set
@@ -1095,10 +1105,24 @@ CONFIG_FRAME_WARN=1024
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_PREEMPT_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -1208,6 +1232,7 @@ CONFIG_CRYPTO_ARC4=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/configs/urquell_defconfig b/arch/sh/configs/urquell_defconfig
index d174b1a4d802..512664fed66c 100644
--- a/arch/sh/configs/urquell_defconfig
+++ b/arch/sh/configs/urquell_defconfig
@@ -1,10 +1,11 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.29
-# Thu Apr  2 19:33:39 2009
+# Linux kernel version: 2.6.30-rc3
+# Mon Apr 27 14:02:55 2009
 #
 CONFIG_SUPERH=y
 CONFIG_SUPERH32=y
+# CONFIG_SUPERH64 is not set
 CONFIG_ARCH_DEFCONFIG="arch/sh/configs/shx3_defconfig"
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_BUG=y
@@ -76,6 +77,7 @@ CONFIG_UID16=y
 CONFIG_SYSCTL_SYSCALL=y
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
+# CONFIG_STRIP_ASM_SYMS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
@@ -94,6 +96,7 @@ CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 CONFIG_PROFILING=y
+# CONFIG_MARKERS is not set
 # CONFIG_OPROFILE is not set
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
@@ -102,6 +105,8 @@ CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_CLK=y
+CONFIG_HAVE_DMA_API_DEBUG=y
+# CONFIG_SLOW_WORK is not set
 CONFIG_HAVE_GENERIC_DMA_COHERENT=y
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
@@ -114,7 +119,6 @@ CONFIG_MODULE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 CONFIG_BLOCK=y
 # CONFIG_LBD is not set
-# CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_BLK_DEV_BSG is not set
 # CONFIG_BLK_DEV_INTEGRITY is not set
 
@@ -162,6 +166,7 @@ CONFIG_CPU_SHX3=y
 # CONFIG_CPU_SUBTYPE_SH7760 is not set
 # CONFIG_CPU_SUBTYPE_SH4_202 is not set
 # CONFIG_CPU_SUBTYPE_SH7723 is not set
+# CONFIG_CPU_SUBTYPE_SH7724 is not set
 # CONFIG_CPU_SUBTYPE_SH7763 is not set
 # CONFIG_CPU_SUBTYPE_SH7770 is not set
 # CONFIG_CPU_SUBTYPE_SH7780 is not set
@@ -171,8 +176,6 @@ CONFIG_CPU_SUBTYPE_SH7786=y
 # CONFIG_CPU_SUBTYPE_SH7343 is not set
 # CONFIG_CPU_SUBTYPE_SH7722 is not set
 # CONFIG_CPU_SUBTYPE_SH7366 is not set
-# CONFIG_CPU_SUBTYPE_SH5_101 is not set
-# CONFIG_CPU_SUBTYPE_SH5_103 is not set
 
 #
 # Memory management options
@@ -900,15 +903,17 @@ CONFIG_USB_HID=y
 #
 # Special HID drivers
 #
-CONFIG_HID_COMPAT=y
 CONFIG_HID_A4TECH=y
 CONFIG_HID_APPLE=y
 CONFIG_HID_BELKIN=y
 CONFIG_HID_CHERRY=y
 CONFIG_HID_CHICONY=y
 CONFIG_HID_CYPRESS=y
+# CONFIG_DRAGONRISE_FF is not set
 CONFIG_HID_EZKEY=y
+# CONFIG_HID_KYE is not set
 CONFIG_HID_GYRATION=y
+# CONFIG_HID_KENSINGTON is not set
 CONFIG_HID_LOGITECH=y
 # CONFIG_LOGITECH_FF is not set
 # CONFIG_LOGIRUMBLEPAD2_FF is not set
@@ -1046,6 +1051,7 @@ CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
+# CONFIG_EXT3_DEFAULTS_TO_ORDERED is not set
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
 # CONFIG_EXT3_FS_SECURITY is not set
@@ -1068,6 +1074,11 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_FUSE_FS is not set
 
 #
+# Caches
+#
+# CONFIG_FSCACHE is not set
+
+#
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
@@ -1117,6 +1128,7 @@ CONFIG_MINIX_FS=y
 # CONFIG_ROMFS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
+# CONFIG_NILFS2_FS is not set
 CONFIG_NETWORK_FILESYSTEMS=y
 CONFIG_NFS_FS=y
 CONFIG_NFS_V3=y
@@ -1209,10 +1221,24 @@ CONFIG_SYSCTL_SYSCALL_CHECK=y
 CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
 CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_TRACING_SUPPORT=y
 
 #
 # Tracers
 #
+# CONFIG_FUNCTION_TRACER is not set
+# CONFIG_IRQSOFF_TRACER is not set
+# CONFIG_PREEMPT_TRACER is not set
+# CONFIG_SCHED_TRACER is not set
+# CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_EVENT_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_KMEMTRACE is not set
+# CONFIG_WORKQUEUE_TRACER is not set
+# CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_DMA_API_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_SH_STANDARD_BIOS is not set
@@ -1322,6 +1348,7 @@ CONFIG_CRYPTO_DES=y
 #
 # CONFIG_CRYPTO_ANSI_CPRNG is not set
 # CONFIG_CRYPTO_HW is not set
+# CONFIG_BINARY_PRINTF is not set
 
 #
 # Library routines
diff --git a/arch/sh/drivers/dma/Kconfig b/arch/sh/drivers/dma/Kconfig
index 666713ac5fcf..63e9dd30b41c 100644
--- a/arch/sh/drivers/dma/Kconfig
+++ b/arch/sh/drivers/dma/Kconfig
@@ -16,7 +16,8 @@ config SH_DMA_IRQ_MULTI
                      CPU_SUBTYPE_SH7750S || CPU_SUBTYPE_SH7750R || \
                      CPU_SUBTYPE_SH7751R || CPU_SUBTYPE_SH7091  || \
                      CPU_SUBTYPE_SH7763  || CPU_SUBTYPE_SH7764  || \
-                     CPU_SUBTYPE_SH7780  || CPU_SUBTYPE_SH7785
+                     CPU_SUBTYPE_SH7780  || CPU_SUBTYPE_SH7785  || \
+                     CPU_SUBTYPE_SH7760
 
 config NR_ONCHIP_DMA_CHANNELS
         int
diff --git a/arch/sh/drivers/pci/Kconfig b/arch/sh/drivers/pci/Kconfig
index 7e816ededed7..e8db585a6638 100644
--- a/arch/sh/drivers/pci/Kconfig
+++ b/arch/sh/drivers/pci/Kconfig
@@ -17,21 +17,3 @@ config SH_PCIDMA_NONCOHERENT
           code will not have to flush the CPU's caches. If you have a PCI host
           bridge integrated with your SH CPU, refer carefully to the chip specs
           to see if you can say 'N' here. Otherwise, leave it as 'Y'.
-
-# This is also board-specific
-config PCI_AUTO
-        bool
-        depends on PCI
-        default y
-
-config PCI_AUTO_UPDATE_RESOURCES
-        bool
-        depends on PCI_AUTO
-        default y if !SH_DREAMCAST
-        help
-          Selecting this option will cause the PCI auto code to leave your
-          BAR values alone. Otherwise they will be updated automatically. If
-          for some reason, you have a board that simply refuses to work
-          with its resources updated beyond what they are when the device
-          is powered up, set this to N. Everyone else will want this as Y.
-
diff --git a/arch/sh/drivers/pci/Makefile b/arch/sh/drivers/pci/Makefile
index 847e90894d1b..d2ffc477549a 100644
--- a/arch/sh/drivers/pci/Makefile
+++ b/arch/sh/drivers/pci/Makefile
@@ -1,9 +1,7 @@
 #
 # Makefile for the PCI specific kernel interface routines under Linux.
 #
-
 obj-y                                   += pci.o
-obj-$(CONFIG_PCI_AUTO)                  += pci-auto.o
 
 obj-$(CONFIG_CPU_SUBTYPE_SH7751)        += pci-sh7751.o ops-sh4.o
 obj-$(CONFIG_CPU_SUBTYPE_SH7751R)       += pci-sh7751.o ops-sh4.o
@@ -12,15 +10,17 @@ obj-$(CONFIG_CPU_SUBTYPE_SH7780)	+= pci-sh7780.o ops-sh4.o
 obj-$(CONFIG_CPU_SUBTYPE_SH7785)        += pci-sh7780.o ops-sh4.o
 obj-$(CONFIG_CPU_SH5)                   += pci-sh5.o ops-sh5.o
 
-obj-$(CONFIG_SH_DREAMCAST)              += ops-dreamcast.o fixups-dreamcast.o
-obj-$(CONFIG_SH_SECUREEDGE5410)         += ops-snapgear.o
-obj-$(CONFIG_SH_RTS7751R2D)             += ops-rts7751r2d.o fixups-rts7751r2d.o
-obj-$(CONFIG_SH_SH03)                   += ops-sh03.o fixups-sh03.o
-obj-$(CONFIG_SH_HIGHLANDER)             += ops-r7780rp.o fixups-r7780rp.o
-obj-$(CONFIG_SH_SDK7780)                += ops-sdk7780.o fixups-sdk7780.o
-obj-$(CONFIG_SH_TITAN)                  += ops-titan.o
-obj-$(CONFIG_SH_LANDISK)                += ops-landisk.o
-obj-$(CONFIG_SH_LBOX_RE2)               += ops-lboxre2.o fixups-lboxre2.o
-obj-$(CONFIG_SH_7780_SOLUTION_ENGINE)   += ops-se7780.o fixups-se7780.o
-obj-$(CONFIG_SH_CAYMAN)                 += ops-cayman.o
-obj-$(CONFIG_SH_SH7785LCR)              += ops-sh7785lcr.o fixups-sh7785lcr.o
+obj-$(CONFIG_SH_DREAMCAST)              += ops-dreamcast.o fixups-dreamcast.o \
+                                           pci-dreamcast.o
+obj-$(CONFIG_SH_SECUREEDGE5410)         += fixups-snapgear.o
+obj-$(CONFIG_SH_7751_SOLUTION_ENGINE)   += fixups-se7751.o
+obj-$(CONFIG_SH_RTS7751R2D)             += fixups-rts7751r2d.o
+obj-$(CONFIG_SH_SH03)                   += fixups-sh03.o
+obj-$(CONFIG_SH_HIGHLANDER)             += fixups-r7780rp.o
+obj-$(CONFIG_SH_SH7785LCR)              += fixups-r7780rp.o
+obj-$(CONFIG_SH_SDK7780)                += fixups-sdk7780.o
+obj-$(CONFIG_SH_7780_SOLUTION_ENGINE)   += fixups-sdk7780.o
+obj-$(CONFIG_SH_TITAN)                  += fixups-titan.o
+obj-$(CONFIG_SH_LANDISK)                += fixups-landisk.o
+obj-$(CONFIG_SH_LBOX_RE2)               += fixups-rts7751r2d.o
+obj-$(CONFIG_SH_CAYMAN)                 += fixups-cayman.o
diff --git a/arch/sh/drivers/pci/ops-cayman.c b/arch/sh/drivers/pci/fixups-cayman.c
index 38ef76207af6..b68b61d22c6c 100644
--- a/arch/sh/drivers/pci/ops-cayman.c
+++ b/arch/sh/drivers/pci/fixups-cayman.c
@@ -75,15 +75,3 @@ int __init pcibios_map_platform_irq(struct pci_dev *dev, u8 slot, u8 pin)
 
         return result;
 }
-
-struct pci_channel board_pci_channels[] = {
-        { &sh5_pci_ops, NULL, NULL, 0, 0xff },
-        { NULL, NULL, NULL, 0, 0 },
-};
-EXPORT_SYMBOL(board_pci_channels);
-
-int __init pcibios_init_platform(void)
-{
-        return sh5pci_init(__pa(memory_start),
-                           __pa(memory_end) - __pa(memory_start));
-}
diff --git a/arch/sh/drivers/pci/fixups-dreamcast.c b/arch/sh/drivers/pci/fixups-dreamcast.c
index 2bf85cf091e1..ed7f489936f1 100644
--- a/arch/sh/drivers/pci/fixups-dreamcast.c
+++ b/arch/sh/drivers/pci/fixups-dreamcast.c
@@ -30,7 +30,7 @@
 
 static void __init gapspci_fixup_resources(struct pci_dev *dev)
 {
-        struct pci_channel *p = board_pci_channels;
+        struct pci_channel *p = dev->sysdata;
 
         printk(KERN_NOTICE "PCI: Fixing up device %s\n", pci_name(dev));
 
@@ -41,6 +41,13 @@ static void __init gapspci_fixup_resources(struct pci_dev *dev)
                  */
                 dev->resource[1].start  = p->io_resource->start  + 0x100;
                 dev->resource[1].end    = dev->resource[1].start + 0x200 - 1;
+
+                /*
+                 * This is not a normal BAR, prevent any attempts to move
+                 * the BAR, as this will result in a bus lock.
+                 */
+                dev->resource[1].flags |= IORESOURCE_PCI_FIXED;
+
                 /*
                  * Redirect dma memory allocations to special memory window.
                  */
diff --git a/arch/sh/drivers/pci/ops-landisk.c b/arch/sh/drivers/pci/fixups-landisk.c
index bff09ecf3419..bb1a6bb5149e 100644
--- a/arch/sh/drivers/pci/ops-landisk.c
+++ b/arch/sh/drivers/pci/fixups-landisk.c
@@ -15,39 +15,6 @@
 #include <linux/pci.h>
 #include "pci-sh4.h"
 
-static struct resource sh7751_io_resource = {
-        .name = "SH7751 IO",
-        .start = SH7751_PCI_IO_BASE,
-        .end = SH7751_PCI_IO_BASE + SH7751_PCI_IO_SIZE - 1,
-        .flags = IORESOURCE_IO
-};
-
-static struct resource sh7751_mem_resource = {
-        .name = "SH7751 mem",
-        .start = SH7751_PCI_MEMORY_BASE,
-        .end = SH7751_PCI_MEMORY_BASE + SH7751_PCI_MEM_SIZE - 1,
-        .flags = IORESOURCE_MEM
-};
-
-struct pci_channel board_pci_channels[] = {
-        {&sh4_pci_ops, &sh7751_io_resource, &sh7751_mem_resource, 0, 0x3ff},
-        {NULL, NULL, NULL, 0, 0},
-};
-
-static struct sh4_pci_address_map sh7751_pci_map = {
-        .window0 = {
-                .base   = SH7751_CS3_BASE_ADDR,
-                .size   = (64 << 20),   /* 64MB */
-        },
-
-        .flags = SH4_PCIC_NO_RESET,
-};
-
-int __init pcibios_init_platform(void)
-{
-        return sh7751_pcic_init(&sh7751_pci_map);
-}
-
 int pcibios_map_platform_irq(struct pci_dev *pdev, u8 slot, u8 pin)
 {
         /*
diff --git a/arch/sh/drivers/pci/fixups-lboxre2.c b/arch/sh/drivers/pci/fixups-lboxre2.c
deleted file mode 100644
index 1c1d41255ec0..000000000000
--- a/arch/sh/drivers/pci/fixups-lboxre2.c
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * arch/sh/drivers/pci/fixups-lboxre2.c
- *
- * L-BOX RE2 PCI fixups
- *
- * Copyright (C) 2007 Nobuhiro Iwamatsu
- *
- * 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.
- */
-#include "pci-sh4.h"
-
-#define PCIMCR_MRSET_OFF        0xBFFFFFFF
-#define PCIMCR_RFSH_OFF         0xFFFFFFFB
-
-int pci_fixup_pcic(void)
-{
-        unsigned long bcr1, mcr;
-
-        bcr1 = ctrl_inl(SH7751_BCR1);
-        bcr1 |= 0x40080000;     /* Enable Bit 19 BREQEN, set PCIC to slave */
-        pci_write_reg(bcr1, SH4_PCIBCR1);
-
-        /* Enable all interrupts, so we known what to fix */
-        pci_write_reg(0x0000c3ff, SH4_PCIINTM);
-        pci_write_reg(0x0000380f, SH4_PCIAINTM);
-        pci_write_reg(0xfb900047, SH7751_PCICONF1);
-        pci_write_reg(0xab000001, SH7751_PCICONF4);
-
-        mcr = ctrl_inl(SH7751_MCR);
-        mcr = (mcr & PCIMCR_MRSET_OFF) & PCIMCR_RFSH_OFF;
-        pci_write_reg(mcr, SH4_PCIMCR);
-
-        pci_write_reg(0x0c000000, SH7751_PCICONF5);
-        pci_write_reg(0xd0000000, SH7751_PCICONF6);
-        pci_write_reg(0x0c000000, SH4_PCILAR0);
-        pci_write_reg(0x00000000, SH4_PCILAR1);
-
-        return 0;
-}
diff --git a/arch/sh/drivers/pci/fixups-r7780rp.c b/arch/sh/drivers/pci/fixups-r7780rp.c
index 3e321df65d22..15ca65cb667e 100644
--- a/arch/sh/drivers/pci/fixups-r7780rp.c
+++ b/arch/sh/drivers/pci/fixups-r7780rp.c
@@ -11,35 +11,26 @@
  * for more details.
  */
 #include <linux/pci.h>
+#include <linux/io.h>
 #include "pci-sh4.h"
-#include <asm/io.h>
 
-int pci_fixup_pcic(void)
-{
-        pci_write_reg(0x000043ff, SH4_PCIINTM);
-        pci_write_reg(0x0000380f, SH4_PCIAINTM);
-
-        pci_write_reg(0xfbb00047, SH7780_PCICMD);
-        pci_write_reg(0x00000000, SH7780_PCIIBAR);
-
-        pci_write_reg(0x00011912, SH7780_PCISVID);
-        pci_write_reg(0x08000000, SH7780_PCICSCR0);
-        pci_write_reg(0x0000001b, SH7780_PCICSAR0);
-        pci_write_reg(0xfd000000, SH7780_PCICSCR1);
-        pci_write_reg(0x0000000f, SH7780_PCICSAR1);
-
-        pci_write_reg(0xfd000000, SH7780_PCIMBR0);
-        pci_write_reg(0x00fc0000, SH7780_PCIMBMR0);
+static char irq_tab[] __initdata = {
+        65, 66, 67, 68,
+};
 
-#ifdef CONFIG_32BIT
-        pci_write_reg(0xc0000000, SH7780_PCIMBR2);
-        pci_write_reg(0x20000000 - SH7780_PCI_IO_SIZE, SH7780_PCIMBMR2);
-#endif
+int __init pcibios_map_platform_irq(struct pci_dev *pdev, u8 slot, u8 pin)
+{
+        return irq_tab[slot];
+}
 
-        /* Set IOBR for windows containing area specified in pci.h */
-        pci_write_reg((PCIBIOS_MIN_IO & ~(SH7780_PCI_IO_SIZE - 1)),
-                      SH7780_PCIIOBR);
-        pci_write_reg(((SH7780_PCI_IO_SIZE-1) & (7<<18)), SH7780_PCIIOBMR);
+int pci_fixup_pcic(struct pci_channel *chan)
+{
+        pci_write_reg(chan, 0x000043ff, SH4_PCIINTM);
+        pci_write_reg(chan, 0x00000000, SH7780_PCIIBAR);
+        pci_write_reg(chan, 0x08000000, SH7780_PCICSCR0);
+        pci_write_reg(chan, 0x0000001b, SH7780_PCICSAR0);
+        pci_write_reg(chan, 0xfd000000, SH7780_PCICSCR1);
+        pci_write_reg(chan, 0x0000000f, SH7780_PCICSAR1);
 
         return 0;
 }
diff --git a/arch/sh/drivers/pci/fixups-rts7751r2d.c b/arch/sh/drivers/pci/fixups-rts7751r2d.c
index 904bce8768d3..052b354236dc 100644
--- a/arch/sh/drivers/pci/fixups-rts7751r2d.c
+++ b/arch/sh/drivers/pci/fixups-rts7751r2d.c
@@ -1,43 +1,67 @@
 /*
  * arch/sh/drivers/pci/fixups-rts7751r2d.c
  *
- * RTS7751R2D PCI fixups
+ * RTS7751R2D / LBOXRE2 PCI fixups
  *
  * Copyright (C) 2003  Lineo uSolutions, Inc.
  * Copyright (C) 2004  Paul Mundt
+ * Copyright (C) 2007  Nobuhiro Iwamatsu
  *
  * 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.
  */
+#include <linux/pci.h>
+#include <mach/lboxre2.h>
+#include <mach/r2d.h>
 #include "pci-sh4.h"
+#include <asm/machtypes.h>
 
 #define PCIMCR_MRSET_OFF        0xBFFFFFFF
 #define PCIMCR_RFSH_OFF         0xFFFFFFFB
 
-int pci_fixup_pcic(void)
+static u8 rts7751r2d_irq_tab[] __initdata = {
+        IRQ_PCI_INTA,
+        IRQ_PCI_INTB,
+        IRQ_PCI_INTC,
+        IRQ_PCI_INTD,
+};
+
+static char lboxre2_irq_tab[] __initdata = {
+        IRQ_ETH0, IRQ_ETH1, IRQ_INTA, IRQ_INTD,
+};
+
+int __init pcibios_map_platform_irq(struct pci_dev *pdev, u8 slot, u8 pin)
+{
+        if (mach_is_lboxre2())
+                return lboxre2_irq_tab[slot];
+        else
+                return rts7751r2d_irq_tab[slot];
+}
+
+int pci_fixup_pcic(struct pci_channel *chan)
 {
         unsigned long bcr1, mcr;
 
         bcr1 = ctrl_inl(SH7751_BCR1);
         bcr1 |= 0x40080000;     /* Enable Bit 19 BREQEN, set PCIC to slave */
-        pci_write_reg(bcr1, SH4_PCIBCR1);
+        pci_write_reg(chan, bcr1, SH4_PCIBCR1);
 
         /* Enable all interrupts, so we known what to fix */
-        pci_write_reg(0x0000c3ff, SH4_PCIINTM);
-        pci_write_reg(0x0000380f, SH4_PCIAINTM);
+        pci_write_reg(chan, 0x0000c3ff, SH4_PCIINTM);
+        pci_write_reg(chan, 0x0000380f, SH4_PCIAINTM);
 
-        pci_write_reg(0xfb900047, SH7751_PCICONF1);
-        pci_write_reg(0xab000001, SH7751_PCICONF4);
+        pci_write_reg(chan, 0xfb900047, SH7751_PCICONF1);
+        pci_write_reg(chan, 0xab000001, SH7751_PCICONF4);
 
         mcr = ctrl_inl(SH7751_MCR);
         mcr = (mcr & PCIMCR_MRSET_OFF) & PCIMCR_RFSH_OFF;
-        pci_write_reg(mcr, SH4_PCIMCR);
+        pci_write_reg(chan, mcr, SH4_PCIMCR);
 
-        pci_write_reg(0x0c000000, SH7751_PCICONF5);
-        pci_write_reg(0xd0000000, SH7751_PCICONF6);
-        pci_write_reg(0x0c000000, SH4_PCILAR0);
-        pci_write_reg(0x00000000, SH4_PCILAR1);
+        pci_write_reg(chan, 0x0c000000, SH7751_PCICONF5);
+        pci_write_reg(chan, 0xd0000000, SH7751_PCICONF6);
+        pci_write_reg(chan, 0x0c000000, SH4_PCILAR0);
+        pci_write_reg(chan, 0x00000000, SH4_PCILAR1);
 
         return 0;
 }
diff --git a/arch/sh/drivers/pci/fixups-sdk7780.c b/arch/sh/drivers/pci/fixups-sdk7780.c
index 2f8863099dd1..250b0edd7365 100644
--- a/arch/sh/drivers/pci/fixups-sdk7780.c
+++ b/arch/sh/drivers/pci/fixups-sdk7780.c
@@ -5,55 +5,48 @@
  *
  * Copyright (C) 2003  Lineo uSolutions, Inc.
  * Copyright (C) 2004 - 2006  Paul Mundt
+ * Copyright (C) 2006  Nobuhiro Iwamatsu
  *
  * 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.
  */
 #include <linux/pci.h>
+#include <linux/io.h>
 #include "pci-sh4.h"
-#include <asm/io.h>
 
-int pci_fixup_pcic(void)
+/* IDSEL [16][17][18][19][20][21][22][23][24][25][26][27][28][29][30][31] */
+static char sdk7780_irq_tab[4][16] __initdata = {
+        /* INTA */
+        { 65, 68, 67, 68, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
+        /* INTB */
+        { 66, 65, -1, 65, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
+        /* INTC */
+        { 67, 66, -1, 66, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
+        /* INTD */
+        { 68, 67, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
+};
+
+int __init pcibios_map_platform_irq(struct pci_dev *pdev, u8 slot, u8 pin)
+{
+       return sdk7780_irq_tab[pin-1][slot];
+}
+int pci_fixup_pcic(struct pci_channel *chan)
 {
-        ctrl_outl(0x00000001, SH7780_PCI_VCR2);
-
         /* Enable all interrupts, so we know what to fix */
-        pci_write_reg(0x0000C3FF, SH7780_PCIIMR);
-        pci_write_reg(0x0000380F, SH7780_PCIAINTM);
+        pci_write_reg(chan, 0x0000C3FF, SH7780_PCIIMR);
 
         /* Set up standard PCI config registers */
-        pci_write_reg(0xFB00, SH7780_PCISTATUS);
-        pci_write_reg(0x0047, SH7780_PCICMD);
-        pci_write_reg(0x00, SH7780_PCIPIF);
-        pci_write_reg(0x00, SH7780_PCISUB);
-        pci_write_reg(0x06, SH7780_PCIBCC);
-        pci_write_reg(0x1912, SH7780_PCISVID);
-        pci_write_reg(0x0001, SH7780_PCISID);
-
-        pci_write_reg(0x08000000, SH7780_PCIMBAR0);     /* PCI */
-        pci_write_reg(0x08000000, SH7780_PCILAR0);      /* SHwy */
-        pci_write_reg(0x07F00001, SH7780_PCILSR);       /* size 128M w/ MBAR */
-
-        pci_write_reg(0x00000000, SH7780_PCIMBAR1);
-        pci_write_reg(0x00000000, SH7780_PCILAR1);
-        pci_write_reg(0x00000000, SH7780_PCILSR1);
-
-        pci_write_reg(0xAB000801, SH7780_PCIIBAR);
-
-        /*
-         * Set the MBR so PCI address is one-to-one with window,
-         * meaning all calls go straight through... use ifdef to
-         * catch erroneous assumption.
-         */
-        pci_write_reg(0xFD000000 , SH7780_PCIMBR0);
-        pci_write_reg(0x00FC0000 , SH7780_PCIMBMR0);    /* 16M */
+        pci_write_reg(chan, 0x08000000, SH7780_PCIMBAR0);       /* PCI */
+        pci_write_reg(chan, 0x08000000, SH4_PCILAR0);   /* SHwy */
+        pci_write_reg(chan, 0x07F00001, SH4_PCILSR0);   /* size 128M w/ MBAR */
 
-        /* Set IOBR for window containing area specified in pci.h */
-        pci_write_reg(PCIBIOS_MIN_IO & ~(SH7780_PCI_IO_SIZE-1), SH7780_PCIIOBR);
-        pci_write_reg((SH7780_PCI_IO_SIZE-1) & (7 << 18), SH7780_PCIIOBMR);
+        pci_write_reg(chan, 0x00000000, SH7780_PCIMBAR1);
+        pci_write_reg(chan, 0x00000000, SH4_PCILAR1);
+        pci_write_reg(chan, 0x00000000, SH4_PCILSR1);
 
-        pci_write_reg(0xA5000C01, SH7780_PCICR);
+        pci_write_reg(chan, 0xAB000801, SH7780_PCIIBAR);
+        pci_write_reg(chan, 0xA5000C01, SH4_PCICR);
 
         return 0;
 }
diff --git a/arch/sh/drivers/pci/fixups-se7751.c b/arch/sh/drivers/pci/fixups-se7751.c
new file mode 100644
index 000000000000..475fa9f0fe2c
--- /dev/null
+++ b/arch/sh/drivers/pci/fixups-se7751.c
@@ -0,0 +1,111 @@
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/pci.h>
+#include <linux/io.h>
+#include "pci-sh4.h"
+
+int __init pcibios_map_platform_irq(u8 slot, u8 pin)
+{
+        switch (slot) {
+        case 0: return 13;
+        case 1: return 13;      /* AMD Ethernet controller */
+        case 2: return -1;
+        case 3: return -1;
+        case 4: return -1;
+        default:
+                printk("PCI: Bad IRQ mapping request for slot %d\n", slot);
+                return -1;
+        }
+}
+
+#define PCIMCR_MRSET_OFF        0xBFFFFFFF
+#define PCIMCR_RFSH_OFF         0xFFFFFFFB
+
+/*
+ * Only long word accesses of the PCIC's internal local registers and the
+ * configuration registers from the CPU is supported.
+ */
+#define PCIC_WRITE(x,v) writel((v), PCI_REG(x))
+#define PCIC_READ(x) readl(PCI_REG(x))
+
+/*
+ * Description:  This function sets up and initializes the pcic, sets
+ * up the BARS, maps the DRAM into the address space etc, etc.
+ */
+int pci_fixup_pcic(struct pci_channel *chan)
+{
+        unsigned long bcr1, wcr1, wcr2, wcr3, mcr;
+        unsigned short bcr2;
+
+        /*
+        * Initialize the slave bus controller on the pcic.  The values used
+        * here should not be hardcoded, but they should be taken from the bsc
+        * on the processor, to make this function as generic as possible.
+        * (i.e. Another sbc may usr different SDRAM timing settings -- in order
+        * for the pcic to work, its settings need to be exactly the same.)
+        */
+        bcr1 = (*(volatile unsigned long*)(SH7751_BCR1));
+        bcr2 = (*(volatile unsigned short*)(SH7751_BCR2));
+        wcr1 = (*(volatile unsigned long*)(SH7751_WCR1));
+        wcr2 = (*(volatile unsigned long*)(SH7751_WCR2));
+        wcr3 = (*(volatile unsigned long*)(SH7751_WCR3));
+        mcr = (*(volatile unsigned long*)(SH7751_MCR));
+
+        bcr1 = bcr1 | 0x00080000;  /* Enable Bit 19, BREQEN */
+        (*(volatile unsigned long*)(SH7751_BCR1)) = bcr1;
+
+        bcr1 = bcr1 | 0x40080000;  /* Enable Bit 19 BREQEN, set PCIC to slave */
+        PCIC_WRITE(SH7751_PCIBCR1, bcr1);        /* PCIC BCR1 */
+        PCIC_WRITE(SH7751_PCIBCR2, bcr2);     /* PCIC BCR2 */
+        PCIC_WRITE(SH7751_PCIWCR1, wcr1);     /* PCIC WCR1 */
+        PCIC_WRITE(SH7751_PCIWCR2, wcr2);     /* PCIC WCR2 */
+        PCIC_WRITE(SH7751_PCIWCR3, wcr3);     /* PCIC WCR3 */
+        mcr = (mcr & PCIMCR_MRSET_OFF) & PCIMCR_RFSH_OFF;
+        PCIC_WRITE(SH7751_PCIMCR, mcr);      /* PCIC MCR */
+
+
+        /* Enable all interrupts, so we know what to fix */
+        PCIC_WRITE(SH7751_PCIINTM, 0x0000c3ff);
+        PCIC_WRITE(SH7751_PCIAINTM, 0x0000380f);
+
+        /* Set up standard PCI config registers */
+        PCIC_WRITE(SH7751_PCICONF1,     0xF39000C7); /* Bus Master, Mem & I/O access */
+        PCIC_WRITE(SH7751_PCICONF2,     0x00000000); /* PCI Class code & Revision ID */
+        PCIC_WRITE(SH7751_PCICONF4,     0xab000001); /* PCI I/O address (local regs) */
+        PCIC_WRITE(SH7751_PCICONF5,     0x0c000000); /* PCI MEM address (local RAM)  */
+        PCIC_WRITE(SH7751_PCICONF6,     0xd0000000); /* PCI MEM address (unused)     */
+        PCIC_WRITE(SH7751_PCICONF11, 0x35051054); /* PCI Subsystem ID & Vendor ID */
+        PCIC_WRITE(SH7751_PCILSR0, 0x03f00000);   /* MEM (full 64M exposed)       */
+        PCIC_WRITE(SH7751_PCILSR1, 0x00000000);   /* MEM (unused)                 */
+        PCIC_WRITE(SH7751_PCILAR0, 0x0c000000);   /* MEM (direct map from PCI)    */
+        PCIC_WRITE(SH7751_PCILAR1, 0x00000000);   /* MEM (unused)                 */
+
+        /* Now turn it on... */
+        PCIC_WRITE(SH7751_PCICR, 0xa5000001);
+
+        /*
+        * Set PCIMBR and PCIIOBR here, assuming a single window
+        * (16M MEM, 256K IO) is enough.  If a larger space is
+        * needed, the readx/writex and inx/outx functions will
+        * have to do more (e.g. setting registers for each call).
+        */
+
+        /*
+        * Set the MBR so PCI address is one-to-one with window,
+        * meaning all calls go straight through... use BUG_ON to
+        * catch erroneous assumption.
+        */
+        BUG_ON(chan->mem_resource->start != SH7751_PCI_MEMORY_BASE);
+
+        PCIC_WRITE(SH7751_PCIMBR, chan->mem_resource->start);
+
+        /* Set IOBR for window containing area specified in pci.h */
+        PCIC_WRITE(SH7751_PCIIOBR, (chan->io_resource->start & SH7751_PCIIOBR_MASK));
+
+        /* All done, may as well say so... */
+        printk("SH7751 PCI: Finished initialization of the PCI controller\n");
+
+        return 1;
+}
diff --git a/arch/sh/drivers/pci/fixups-se7780.c b/arch/sh/drivers/pci/fixups-se7780.c
deleted file mode 100644
index 880cea1c0d89..000000000000
--- a/arch/sh/drivers/pci/fixups-se7780.c
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * arch/sh/drivers/pci/fixups-se7780.c
- *
- * HITACHI UL Solution Engine 7780  PCI fixups
- *
- * Copyright (C) 2003  Lineo uSolutions, Inc.
- * Copyright (C) 2004 - 2006  Paul Mundt
- * Copyright (C) 2006  Nobuhiro Iwamatsu
- *
- * 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.
- */
-#include <linux/pci.h>
-#include "pci-sh4.h"
-#include <asm/io.h>
-
-int pci_fixup_pcic(void)
-{
-        ctrl_outl(0x00000001, SH7780_PCI_VCR2);
-
-        /* Enable all interrupts, so we know what to fix */
-        pci_write_reg(0x0000C3FF, SH7780_PCIIMR);
-        pci_write_reg(0x0000380F, SH7780_PCIAINTM);
-
-        /* Set up standard PCI config registers */
-        ctrl_outw(0xFB00, PCI_REG(SH7780_PCISTATUS));
-        ctrl_outw(0x0047, PCI_REG(SH7780_PCICMD));
-        ctrl_outb(  0x00, PCI_REG(SH7780_PCIPIF));
-        ctrl_outb(  0x00, PCI_REG(SH7780_PCISUB));
-        ctrl_outb(  0x06, PCI_REG(SH7780_PCIBCC));
-        ctrl_outw(0x1912, PCI_REG(SH7780_PCISVID));
-        ctrl_outw(0x0001, PCI_REG(SH7780_PCISID));
-
-        pci_write_reg(0x08000000, SH7780_PCIMBAR0);     /* PCI */
-        pci_write_reg(0x08000000, SH7780_PCILAR0);     /* SHwy */
-        pci_write_reg(0x07F00001, SH7780_PCILSR);      /* size 128M w/ MBAR */
-
-        pci_write_reg(0x00000000, SH7780_PCIMBAR1);
-        pci_write_reg(0x00000000, SH7780_PCILAR1);
-        pci_write_reg(0x00000000, SH7780_PCILSR1);
-
-        pci_write_reg(0xAB000801, SH7780_PCIIBAR);
-
-        /*
-         * Set the MBR so PCI address is one-to-one with window,
-         * meaning all calls go straight through... use ifdef to
-         * catch erroneous assumption.
-         */
-        pci_write_reg(0xFD000000 , SH7780_PCIMBR0);
-        pci_write_reg(0x00FC0000 , SH7780_PCIMBMR0);    /* 16M */
-
-        /* Set IOBR for window containing area specified in pci.h */
-        pci_write_reg(PCIBIOS_MIN_IO & ~(SH7780_PCI_IO_SIZE-1), SH7780_PCIIOBR);
-        pci_write_reg((SH7780_PCI_IO_SIZE-1) & (7 << 18), SH7780_PCIIOBMR);
-
-        pci_write_reg(0xA5000C01, SH7780_PCICR);
-
-        return 0;
-}
diff --git a/arch/sh/drivers/pci/fixups-sh7785lcr.c b/arch/sh/drivers/pci/fixups-sh7785lcr.c
deleted file mode 100644
index 4949e601387a..000000000000
--- a/arch/sh/drivers/pci/fixups-sh7785lcr.c
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * arch/sh/drivers/pci/fixups-sh7785lcr.c
- *
- * R0P7785LC0011RL PCI fixups
- * Copyright (C) 2008  Yoshihiro Shimoda
- *
- * Based on arch/sh/drivers/pci/fixups-r7780rp.c
- * Copyright (C) 2003  Lineo uSolutions, Inc.
- * Copyright (C) 2004 - 2006  Paul Mundt
- *
- * 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.
- */
-#include <linux/pci.h>
-#include "pci-sh4.h"
-
-int pci_fixup_pcic(void)
-{
-        pci_write_reg(0x000043ff, SH4_PCIINTM);
-        pci_write_reg(0x0000380f, SH4_PCIAINTM);
-
-        pci_write_reg(0xfbb00047, SH7780_PCICMD);
-        pci_write_reg(0x00000000, SH7780_PCIIBAR);
-
-        pci_write_reg(0x00011912, SH7780_PCISVID);
-        pci_write_reg(0x08000000, SH7780_PCICSCR0);
-        pci_write_reg(0x0000001b, SH7780_PCICSAR0);
-        pci_write_reg(0xfd000000, SH7780_PCICSCR1);
-        pci_write_reg(0x0000000f, SH7780_PCICSAR1);
-
-        pci_write_reg(0xfd000000, SH7780_PCIMBR0);
-        pci_write_reg(0x00fc0000, SH7780_PCIMBMR0);
-
-#ifdef CONFIG_32BIT
-        pci_write_reg(0xc0000000, SH7780_PCIMBR2);
-        pci_write_reg(0x20000000 - SH7780_PCI_IO_SIZE, SH7780_PCIMBMR2);
-#endif
-
-        /* Set IOBR for windows containing area specified in pci.h */
-        pci_write_reg((PCIBIOS_MIN_IO & ~(SH7780_PCI_IO_SIZE - 1)),
-                      SH7780_PCIIOBR);
-        pci_write_reg(((SH7780_PCI_IO_SIZE - 1) & (7 << 18)), SH7780_PCIIOBMR);
-
-        return 0;
-}
diff --git a/arch/sh/drivers/pci/fixups-snapgear.c b/arch/sh/drivers/pci/fixups-snapgear.c
new file mode 100644
index 000000000000..5a39ecc1adb8
--- /dev/null
+++ b/arch/sh/drivers/pci/fixups-snapgear.c
@@ -0,0 +1,38 @@
+/*
+ * arch/sh/drivers/pci/ops-snapgear.c
+ *
+ * Author:  David McCullough <davidm@snapgear.com>
+ *
+ * Ported to new API by Paul Mundt <lethal@linux-sh.org>
+ *
+ * Highly leveraged from pci-bigsur.c, written by Dustin McIntire.
+ *
+ * May be copied or modified under the terms of the GNU General Public
+ * License.  See linux/COPYING for more information.
+ *
+ * PCI initialization for the SnapGear boards
+ */
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/init.h>
+#include <linux/pci.h>
+#include "pci-sh4.h"
+
+int __init pcibios_map_platform_irq(struct pci_dev *pdev, u8 slot, u8 pin)
+{
+        int irq = -1;
+
+        switch (slot) {
+        case 8:  /* the PCI bridge */ break;
+        case 11: irq = 8;  break; /* USB    */
+        case 12: irq = 11; break; /* PCMCIA */
+        case 13: irq = 5;  break; /* eth0   */
+        case 14: irq = 8;  break; /* eth1   */
+        case 15: irq = 11; break; /* safenet (unused) */
+        }
+
+        printk("PCI: Mapping SnapGear IRQ for slot %d, pin %c to irq %d\n",
+               slot, pin - 1 + 'A', irq);
+
+        return irq;
+}
diff --git a/arch/sh/drivers/pci/ops-titan.c b/arch/sh/drivers/pci/fixups-titan.c
index a8f7801a34af..3a79fa8254a6 100644
--- a/arch/sh/drivers/pci/ops-titan.c
+++ b/arch/sh/drivers/pci/fixups-titan.c
@@ -36,42 +36,3 @@ int __init pcibios_map_platform_irq(struct pci_dev *pdev, u8 slot, u8 pin)
 
         return irq;
 }
-
-static struct resource sh7751_io_resource = {
-        .name   = "SH7751_IO",
-        .start  = SH7751_PCI_IO_BASE,
-        .end    = SH7751_PCI_IO_BASE + SH7751_PCI_IO_SIZE - 1,
-        .flags  = IORESOURCE_IO
-};
-
-static struct resource sh7751_mem_resource = {
-        .name   = "SH7751_mem",
-        .start  = SH7751_PCI_MEMORY_BASE,
-        .end    = SH7751_PCI_MEMORY_BASE + SH7751_PCI_MEM_SIZE - 1,
-        .flags  = IORESOURCE_MEM
-};
-
-struct pci_channel board_pci_channels[] = {
-        { &sh4_pci_ops, &sh7751_io_resource, &sh7751_mem_resource, 0, 0xff },
-        { NULL, NULL, NULL, 0, 0 },
-};
-EXPORT_SYMBOL(board_pci_channels);
-
-static struct sh4_pci_address_map sh7751_pci_map = {
-        .window0        = {
-                .base   = SH7751_CS2_BASE_ADDR,
-                .size   = SH7751_MEM_REGION_SIZE*2,     /* cs2 and cs3 */
-        },
-
-        .window1        = {
-                .base   = SH7751_CS2_BASE_ADDR,
-                .size   = SH7751_MEM_REGION_SIZE*2,
-        },
-
-        .flags  = SH4_PCIC_NO_RESET,
-};
-
-int __init pcibios_init_platform(void)
-{
-        return sh7751_pcic_init(&sh7751_pci_map);
-}
diff --git a/arch/sh/drivers/pci/ops-dreamcast.c b/arch/sh/drivers/pci/ops-dreamcast.c
index f5d2a2aa6f3f..e83d0d3aabe2 100644
--- a/arch/sh/drivers/pci/ops-dreamcast.c
+++ b/arch/sh/drivers/pci/ops-dreamcast.c
@@ -1,15 +1,9 @@
 /*
- * arch/sh/drivers/pci/ops-dreamcast.c
- *
  * PCI operations for the Sega Dreamcast
  *
  * Copyright (C) 2001, 2002  M. R. Brown
  * Copyright (C) 2002, 2003  Paul Mundt
  *
- * This file originally bore the message (with enclosed-$):
- *      Id: pci.c,v 1.3 2003/05/04 19:29:46 lethal Exp
- *      Dreamcast PCI: Supports SEGA Broadband Adaptor only.
- *
  * 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.
@@ -23,34 +17,10 @@
 #include <linux/irq.h>
 #include <linux/pci.h>
 #include <linux/module.h>
-
-#include <asm/io.h>
-#include <asm/irq.h>
+#include <linux/io.h>
+#include <linux/irq.h>
 #include <mach/pci.h>
 
-static struct resource gapspci_io_resource = {
-        .name   = "GAPSPCI IO",
-        .start  = GAPSPCI_BBA_CONFIG,
-        .end    = GAPSPCI_BBA_CONFIG + GAPSPCI_BBA_CONFIG_SIZE - 1,
-        .flags  = IORESOURCE_IO,
-};
-
-static struct resource gapspci_mem_resource = {
-        .name   = "GAPSPCI mem",
-        .start  = GAPSPCI_DMA_BASE,
-        .end    = GAPSPCI_DMA_BASE + GAPSPCI_DMA_SIZE - 1,
-        .flags  = IORESOURCE_MEM,
-};
-
-static struct pci_ops gapspci_pci_ops;
-
-struct pci_channel board_pci_channels[] = {
-        { &gapspci_pci_ops, &gapspci_io_resource,
-          &gapspci_mem_resource, 0, 1 },
-        { 0, }
-};
-EXPORT_SYMBOL(board_pci_channels);
-
 /*
  * The !gapspci_config_access case really shouldn't happen, ever, unless
  * someone implicitly messes around with the last devfn value.. otherwise we
@@ -85,10 +55,10 @@ static int gapspci_read(struct pci_bus *bus, unsigned int devfn, int where, int
                 return PCIBIOS_DEVICE_NOT_FOUND;
 
         switch (size) {
-                case 1: *val = inb(GAPSPCI_BBA_CONFIG+where); break;
-                case 2: *val = inw(GAPSPCI_BBA_CONFIG+where); break;
-                case 4: *val = inl(GAPSPCI_BBA_CONFIG+where); break;
-        }       
+        case 1: *val = inb(GAPSPCI_BBA_CONFIG+where); break;
+        case 2: *val = inw(GAPSPCI_BBA_CONFIG+where); break;
+        case 4: *val = inl(GAPSPCI_BBA_CONFIG+where); break;
+        }
 
         return PCIBIOS_SUCCESSFUL;
 }
@@ -99,72 +69,15 @@ static int gapspci_write(struct pci_bus *bus, unsigned int devfn, int where, int
                 return PCIBIOS_DEVICE_NOT_FOUND;
 
         switch (size) {
-                case 1: outb(( u8)val, GAPSPCI_BBA_CONFIG+where); break;
-                case 2: outw((u16)val, GAPSPCI_BBA_CONFIG+where); break;
-                case 4: outl((u32)val, GAPSPCI_BBA_CONFIG+where); break;
+        case 1: outb(( u8)val, GAPSPCI_BBA_CONFIG+where); break;
+        case 2: outw((u16)val, GAPSPCI_BBA_CONFIG+where); break;
+        case 4: outl((u32)val, GAPSPCI_BBA_CONFIG+where); break;
         }
 
         return PCIBIOS_SUCCESSFUL;
 }
 
-static struct pci_ops gapspci_pci_ops = {
+struct pci_ops gapspci_pci_ops = {
         .read   = gapspci_read,
         .write  = gapspci_write,
 };
-
-/*
- * gapspci init
- */
-
-int __init gapspci_init(void)
-{
-        char idbuf[16];
-        int i;
-
-        /*
-         * FIXME: All of this wants documenting to some degree,
-         * even some basic register definitions would be nice.
-         *
-         * I haven't seen anything this ugly since.. maple.
-         */
-
-        for (i=0; i<16; i++)
-                idbuf[i] = inb(GAPSPCI_REGS+i);
-
-        if (strncmp(idbuf, "GAPSPCI_BRIDGE_2", 16))
-                return -ENODEV;
-
-        outl(0x5a14a501, GAPSPCI_REGS+0x18);
-
-        for (i=0; i<1000000; i++)
-                ;
-
-        if (inl(GAPSPCI_REGS+0x18) != 1)
-                return -EINVAL;
-
-        outl(0x01000000, GAPSPCI_REGS+0x20);
-        outl(0x01000000, GAPSPCI_REGS+0x24);
-
-        outl(GAPSPCI_DMA_BASE, GAPSPCI_REGS+0x28);
-        outl(GAPSPCI_DMA_BASE+GAPSPCI_DMA_SIZE, GAPSPCI_REGS+0x2c);
-
-        outl(1, GAPSPCI_REGS+0x14);
-        outl(1, GAPSPCI_REGS+0x34);
-
-        /* Setting Broadband Adapter */
-        outw(0xf900, GAPSPCI_BBA_CONFIG+0x06);
-        outl(0x00000000, GAPSPCI_BBA_CONFIG+0x30);
-        outb(0x00, GAPSPCI_BBA_CONFIG+0x3c);
-        outb(0xf0, GAPSPCI_BBA_CONFIG+0x0d);
-        outw(0x0006, GAPSPCI_BBA_CONFIG+0x04);
-        outl(0x00002001, GAPSPCI_BBA_CONFIG+0x10);
-        outl(0x01000000, GAPSPCI_BBA_CONFIG+0x14);
-
-        return 0;
-}
-
-/* Haven't done anything here as yet */
-char * __devinit pcibios_setup(char *str)
-{
-        return str;
-}
diff --git a/arch/sh/drivers/pci/ops-lboxre2.c b/arch/sh/drivers/pci/ops-lboxre2.c
deleted file mode 100644
index 86c0b6fb7375..000000000000
--- a/arch/sh/drivers/pci/ops-lboxre2.c
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * linux/arch/sh/drivers/pci/ops-lboxre2.c
- *
- * Copyright (C) 2007 Nobuhiro Iwamatsu
- *
- * PCI initialization for the NTT COMWARE L-BOX RE2
- */
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/init.h>
-#include <linux/pci.h>
-#include <linux/io.h>
-#include <mach/lboxre2.h>
-#include "pci-sh4.h"
-
-static char lboxre2_irq_tab[] __initdata = {
-        IRQ_ETH0, IRQ_ETH1, IRQ_INTA, IRQ_INTD,
-};
-
-int __init pcibios_map_platform_irq(struct pci_dev *pdev, u8 slot, u8 pin)
-{
-        return lboxre2_irq_tab[slot];
-}
-
-static struct resource sh7751_io_resource = {
-        .name   = "SH7751_IO",
-        .start  = SH7751_PCI_IO_BASE ,
-        .end    = SH7751_PCI_IO_BASE + SH7751_PCI_IO_SIZE - 1,
-        .flags  = IORESOURCE_IO
-};
-
-static struct resource sh7751_mem_resource = {
-        .name   = "SH7751_mem",
-        .start  = SH7751_PCI_MEMORY_BASE,
-        .end    = SH7751_PCI_MEMORY_BASE + SH7751_PCI_MEM_SIZE - 1,
-        .flags  = IORESOURCE_MEM
-};
-
-extern struct pci_ops sh7751_pci_ops;
-
-struct pci_channel board_pci_channels[] = {
-        { &sh4_pci_ops, &sh7751_io_resource, &sh7751_mem_resource, 0, 0xff },
-        { NULL, NULL, NULL, 0, 0 },
-};
-
-EXPORT_SYMBOL(board_pci_channels);
-
-static struct sh4_pci_address_map sh7751_pci_map = {
-        .window0        = {
-                .base   = SH7751_CS3_BASE_ADDR,
-                .size   = 0x04000000,
-        },
-        .window1        = {
-                .base   = 0x00000000,   /* Unused */
-                .size   = 0x00000000,   /* Unused */
-        },
-        .flags  = SH4_PCIC_NO_RESET,
-};
-
-int __init pcibios_init_platform(void)
-{
-        return sh7751_pcic_init(&sh7751_pci_map);
-}
diff --git a/arch/sh/drivers/pci/ops-r7780rp.c b/arch/sh/drivers/pci/ops-r7780rp.c
deleted file mode 100644
index 8555238e63eb..000000000000
--- a/arch/sh/drivers/pci/ops-r7780rp.c
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Author:  Ian DaSilva (idasilva@mvista.com)
- *
- * Highly leveraged from pci-bigsur.c, written by Dustin McIntire.
- *
- * May be copied or modified under the terms of the GNU General Public
- * License.  See linux/COPYING for more information.
- *
- * PCI initialization for the Renesas SH7780 Highlander R7780RP-1 board
- */
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/pci.h>
-#include <mach/highlander.h>
-#include <asm/io.h>
-#include "pci-sh4.h"
-
-static char irq_tab[] __initdata = {
-        65, 66, 67, 68,
-};
-
-int __init pcibios_map_platform_irq(struct pci_dev *pdev, u8 slot, u8 pin)
-{
-        return irq_tab[slot];
-}
-
-static struct resource sh7780_io_resource = {
-        .name   = "SH7780_IO",
-        .start  = SH7780_PCI_IO_BASE,
-        .end    = SH7780_PCI_IO_BASE + SH7780_PCI_IO_SIZE - 1,
-        .flags  = IORESOURCE_IO
-};
-
-static struct resource sh7780_mem_resource = {
-        .name   = "SH7780_mem",
-        .start  = SH7780_PCI_MEMORY_BASE,
-        .end    = SH7780_PCI_MEMORY_BASE + SH7780_PCI_MEM_SIZE - 1,
-        .flags  = IORESOURCE_MEM
-};
-
-extern struct pci_ops sh7780_pci_ops;
-
-struct pci_channel board_pci_channels[] = {
-        { &sh4_pci_ops, &sh7780_io_resource, &sh7780_mem_resource, 0, 0xff },
-        { NULL, NULL, NULL, 0, 0 },
-};
-EXPORT_SYMBOL(board_pci_channels);
-
-static struct sh4_pci_address_map sh7780_pci_map = {
-        .window0        = {
-                .base   = SH7780_CS2_BASE_ADDR,
-                .size   = 0x04000000,
-        },
-
-        .window1        = {
-                .base   = SH7780_CS3_BASE_ADDR,
-                .size   = 0x04000000,
-        },
-
-        .flags  = SH4_PCIC_NO_RESET,
-};
-
-int __init pcibios_init_platform(void)
-{
-        return sh7780_pcic_init(&sh7780_pci_map);
-}
diff --git a/arch/sh/drivers/pci/ops-rts7751r2d.c b/arch/sh/drivers/pci/ops-rts7751r2d.c
deleted file mode 100644
index d6ca74b25d5f..000000000000
--- a/arch/sh/drivers/pci/ops-rts7751r2d.c
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * linux/arch/sh/drivers/pci/ops-rts7751r2d.c
- *
- * Author:  Ian DaSilva (idasilva@mvista.com)
- *
- * Highly leveraged from pci-bigsur.c, written by Dustin McIntire.
- *
- * May be copied or modified under the terms of the GNU General Public
- * License.  See linux/COPYING for more information.
- *
- * PCI initialization for the Renesas SH7751R RTS7751R2D board
- */
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/init.h>
-#include <linux/pci.h>
-#include <linux/io.h>
-#include <mach/r2d.h>
-#include "pci-sh4.h"
-
-static u8 rts7751r2d_irq_tab[] __initdata = {
-        IRQ_PCI_INTA,
-        IRQ_PCI_INTB,
-        IRQ_PCI_INTC,
-        IRQ_PCI_INTD,
-};
-
-int __init pcibios_map_platform_irq(struct pci_dev *pdev, u8 slot, u8 pin)
-{
-        return rts7751r2d_irq_tab[slot];
-}
-
-static struct resource sh7751_io_resource = {
-        .name   = "SH7751_IO",
-        .start  = 0x4000,
-        .end    = SH7751_PCI_IO_SIZE - 1,
-        .flags  = IORESOURCE_IO
-};
-
-static struct resource sh7751_mem_resource = {
-        .name   = "SH7751_mem",
-        .start  = SH7751_PCI_MEMORY_BASE,
-        .end    = SH7751_PCI_MEMORY_BASE + SH7751_PCI_MEM_SIZE - 1,
-        .flags  = IORESOURCE_MEM
-};
-
-extern struct pci_ops sh7751_pci_ops;
-
-struct pci_channel board_pci_channels[] = {
-        { &sh4_pci_ops, &sh7751_io_resource, &sh7751_mem_resource, 0, 0xff },
-        { NULL, NULL, NULL, 0, 0 },
-};
-EXPORT_SYMBOL(board_pci_channels);
-
-static struct sh4_pci_address_map sh7751_pci_map = {
-        .window0        = {
-                .base   = SH7751_CS3_BASE_ADDR,
-                .size   = 0x04000000,
-        },
-
-        .window1        = {
-                .base   = 0x00000000,   /* Unused */
-                .size   = 0x00000000,   /* Unused */
-        },
-
-        .flags  = SH4_PCIC_NO_RESET,
-};
-
-int __init pcibios_init_platform(void)
-{
-        __set_io_port_base(SH7751_PCI_IO_BASE);
-        return sh7751_pcic_init(&sh7751_pci_map);
-}
-
diff --git a/arch/sh/drivers/pci/ops-sdk7780.c b/arch/sh/drivers/pci/ops-sdk7780.c
deleted file mode 100644
index 4dcc64184b23..000000000000
--- a/arch/sh/drivers/pci/ops-sdk7780.c
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * linux/arch/sh/drivers/pci/ops-sdk7780.c
- *
- * Copyright (C) 2006  Nobuhiro Iwamatsu
- *
- * PCI initialization for the SDK7780SE03
- *
- * May be copied or modified under the terms of the GNU General Public
- * License.  See linux/COPYING for more information.
- */
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/pci.h>
-#include <mach/sdk7780.h>
-#include <asm/io.h>
-#include "pci-sh4.h"
-
-/* IDSEL [16][17][18][19][20][21][22][23][24][25][26][27][28][29][30][31] */
-static char sdk7780_irq_tab[4][16] __initdata = {
-        /* INTA */
-        { 65, 68, 67, 68, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
-        /* INTB */
-        { 66, 65, -1, 65, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
-        /* INTC */
-        { 67, 66, -1, 66, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
-        /* INTD */
-        { 68, 67, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
-};
-
-int __init pcibios_map_platform_irq(struct pci_dev *pdev, u8 slot, u8 pin)
-{
-       return sdk7780_irq_tab[pin-1][slot];
-}
-
-static struct resource sdk7780_io_resource = {
-        .name   = "SH7780_IO",
-        .start  = SH7780_PCI_IO_BASE,
-        .end    = SH7780_PCI_IO_BASE + SH7780_PCI_IO_SIZE - 1,
-        .flags  = IORESOURCE_IO
-};
-
-static struct resource sdk7780_mem_resource = {
-        .name   = "SH7780_mem",
-        .start  = SH7780_PCI_MEMORY_BASE,
-        .end    = SH7780_PCI_MEMORY_BASE + SH7780_PCI_MEM_SIZE - 1,
-        .flags  = IORESOURCE_MEM
-};
-
-struct pci_channel board_pci_channels[] = {
-        { &sh4_pci_ops, &sdk7780_io_resource, &sdk7780_mem_resource, 0, 0xff },
-        { NULL, NULL, NULL, 0, 0 },
-};
-EXPORT_SYMBOL(board_pci_channels);
-
-static struct sh4_pci_address_map sdk7780_pci_map = {
-        .window0        = {
-                .base   = SH7780_CS2_BASE_ADDR,
-                .size   = 0x04000000,
-        },
-        .window1        = {
-                .base   = SH7780_CS3_BASE_ADDR,
-                .size   = 0x04000000,
-        },
-        .flags  = SH4_PCIC_NO_RESET,
-};
-
-int __init pcibios_init_platform(void)
-{
-        printk(KERN_INFO "SH7780 PCI: Finished initializing PCI controller\n");
-        return sh7780_pcic_init(&sdk7780_pci_map);
-}
diff --git a/arch/sh/drivers/pci/ops-se7780.c b/arch/sh/drivers/pci/ops-se7780.c
deleted file mode 100644
index 3145c62484d6..000000000000
--- a/arch/sh/drivers/pci/ops-se7780.c
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * linux/arch/sh/drivers/pci/ops-se7780.c
- *
- * Copyright (C) 2006  Nobuhiro Iwamatsu
- *
- * PCI initialization for the Hitachi UL Solution Engine 7780SE03
- *
- * May be copied or modified under the terms of the GNU General Public
- * License.  See linux/COPYING for more information.
- */
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/pci.h>
-#include <mach-se/mach/se7780.h>
-#include <asm/io.h>
-#include "pci-sh4.h"
-
-/*
- * IDSEL = AD16  PCI slot
- * IDSEL = AD17  PCI slot
- * IDSEL = AD18  Serial ATA Controller (Silicon Image SiL3512A)
- * IDSEL = AD19  USB Host Controller (NEC uPD7210100A)
- */
-
-/* IDSEL [16][17][18][19][20][21][22][23][24][25][26][27][28][29][30][31] */
-static char se7780_irq_tab[4][16] __initdata = {
-        /* INTA */
-        { 65, 68, 67, 68, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
-        /* INTB */
-        { 66, 65, -1, 65, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
-        /* INTC */
-        { 67, 66, -1, 66, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
-        /* INTD */
-        { 68, 67, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 },
-};
-
-int __init pcibios_map_platform_irq(struct pci_dev *pdev, u8 slot, u8 pin)
-{
-       return se7780_irq_tab[pin-1][slot];
-}
-
-static struct resource se7780_io_resource = {
-        .name   = "SH7780_IO",
-        .start  = SH7780_PCI_IO_BASE,
-        .end    = SH7780_PCI_IO_BASE + SH7780_PCI_IO_SIZE - 1,
-        .flags  = IORESOURCE_IO
-};
-
-static struct resource se7780_mem_resource = {
-        .name   = "SH7780_mem",
-        .start  = SH7780_PCI_MEMORY_BASE,
-        .end    = SH7780_PCI_MEMORY_BASE + SH7780_PCI_MEM_SIZE - 1,
-        .flags  = IORESOURCE_MEM
-};
-
-extern struct pci_ops se7780_pci_ops;
-
-struct pci_channel board_pci_channels[] = {
-        { &sh4_pci_ops, &se7780_io_resource, &se7780_mem_resource, 0, 0xff },
-        { NULL, NULL, NULL, 0, 0 },
-};
-EXPORT_SYMBOL(board_pci_channels);
-
-static struct sh4_pci_address_map se7780_pci_map = {
-        .window0        = {
-                .base   = SH7780_CS2_BASE_ADDR,
-                .size   = 0x04000000,
-        },
-        .flags  = SH4_PCIC_NO_RESET,
-};
-
-int __init pcibios_init_platform(void)
-{
-        printk("SH7780 PCI: Finished initialization of the PCI controller\n");
-
-        /*
-         * FPGA PCISEL register initialize
-         *
-         *  CPU  || SLOT1 | SLOT2 | S-ATA | USB
-         *  -------------------------------------
-         *  INTA || INTA  | INTD  |  --   | INTB
-         *  -------------------------------------
-         *  INTB || INTB  | INTA  |  --   | INTC
-         *  -------------------------------------
-         *  INTC || INTC  | INTB  | INTA  |  --
-         *  -------------------------------------
-         *  INTD || INTD  | INTC  |  --   | INTA
-         *  -------------------------------------
-         */
-        ctrl_outw(0x0013, FPGA_PCI_INTSEL1);
-        ctrl_outw(0xE402, FPGA_PCI_INTSEL2);
-
-        return sh7780_pcic_init(&se7780_pci_map);
-}
diff --git a/arch/sh/drivers/pci/ops-sh03.c b/arch/sh/drivers/pci/ops-sh03.c
deleted file mode 100644
index e1703ff5a4d2..000000000000
--- a/arch/sh/drivers/pci/ops-sh03.c
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * linux/arch/sh/drivers/pci/ops-sh03.c
- *
- * PCI initialization for the Interface CTP/PCI-SH03 board
- */
-
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/pci.h>
-#include <asm/io.h>
-#include "pci-sh7751.h"
-
-/*
- * Description:  This function sets up and initializes the pcic, sets
- * up the BARS, maps the DRAM into the address space etc, etc.
- */
-int __init pcibios_init_platform(void)
-{
-        __set_io_port_base(SH7751_PCI_IO_BASE);
-        return 1;
-}
-
-static struct resource sh7751_io_resource = {
-        .name   = "SH03 IO",
-        .start  = SH7751_PCI_IO_BASE,
-        .end    = SH7751_PCI_IO_BASE + SH7751_PCI_IO_SIZE - 1,
-        .flags  = IORESOURCE_IO
-};
-
-static struct resource sh7751_mem_resource = {
-        .name   = "SH03 mem",
-        .start  = SH7751_PCI_MEMORY_BASE,
-        .end    = SH7751_PCI_MEMORY_BASE + SH7751_PCI_MEM_SIZE - 1,
-        .flags  = IORESOURCE_MEM
-};
-
-extern struct pci_ops sh4_pci_ops;
-
-struct pci_channel board_pci_channels[] = {
-        { &sh4_pci_ops, &sh7751_io_resource, &sh7751_mem_resource, 0, 0xff },
-        { NULL, NULL, NULL, 0, 0 },
-};
-
diff --git a/arch/sh/drivers/pci/ops-sh4.c b/arch/sh/drivers/pci/ops-sh4.c
index 710a3b0306e5..78bebebdc99c 100644
--- a/arch/sh/drivers/pci/ops-sh4.c
+++ b/arch/sh/drivers/pci/ops-sh4.c
@@ -1,22 +1,22 @@
 /*
  * Generic SH-4 / SH-4A PCIC operations (SH7751, SH7780).
  *
- * Copyright (C) 2002 - 2006  Paul Mundt
+ * Copyright (C) 2002 - 2009  Paul Mundt
  *
  * This file is subject to the terms and conditions of the GNU General Public
  * License v2. See the file "COPYING" in the main directory of this archive
  * for more details.
  */
 #include <linux/pci.h>
+#include <linux/io.h>
 #include <asm/addrspace.h>
-#include <asm/io.h>
 #include "pci-sh4.h"
 
 /*
  * Direct access to PCI hardware...
  */
 #define CONFIG_CMD(bus, devfn, where) \
-        P1SEGADDR((bus->number << 16) | (devfn << 8) | (where & ~3))
+        (P1SEG | (bus->number << 16) | (devfn << 8) | (where & ~3))
 
 static DEFINE_SPINLOCK(sh4_pci_lock);
 
@@ -26,6 +26,7 @@ static DEFINE_SPINLOCK(sh4_pci_lock);
 static int sh4_pci_read(struct pci_bus *bus, unsigned int devfn,
                            int where, int size, u32 *val)
 {
+        struct pci_channel *chan = bus->sysdata;
         unsigned long flags;
         u32 data;
 
@@ -34,8 +35,8 @@ static int sh4_pci_read(struct pci_bus *bus, unsigned int devfn,
          * so we must do byte alignment by hand
          */
         spin_lock_irqsave(&sh4_pci_lock, flags);
-        pci_write_reg(CONFIG_CMD(bus, devfn, where), SH4_PCIPAR);
-        data = pci_read_reg(SH4_PCIPDR);
+        pci_write_reg(chan, CONFIG_CMD(bus, devfn, where), SH4_PCIPAR);
+        data = pci_read_reg(chan, SH4_PCIPDR);
         spin_unlock_irqrestore(&sh4_pci_lock, flags);
 
         switch (size) {
@@ -63,13 +64,14 @@ static int sh4_pci_read(struct pci_bus *bus, unsigned int devfn,
 static int sh4_pci_write(struct pci_bus *bus, unsigned int devfn,
                          int where, int size, u32 val)
 {
+        struct pci_channel *chan = bus->sysdata;
         unsigned long flags;
         int shift;
         u32 data;
 
         spin_lock_irqsave(&sh4_pci_lock, flags);
-        pci_write_reg(CONFIG_CMD(bus, devfn, where), SH4_PCIPAR);
-        data = pci_read_reg(SH4_PCIPDR);
+        pci_write_reg(chan, CONFIG_CMD(bus, devfn, where), SH4_PCIPAR);
+        data = pci_read_reg(chan, SH4_PCIPDR);
         spin_unlock_irqrestore(&sh4_pci_lock, flags);
 
         switch (size) {
@@ -90,7 +92,7 @@ static int sh4_pci_write(struct pci_bus *bus, unsigned int devfn,
                 return PCIBIOS_FUNC_NOT_SUPPORTED;
         }
 
-        pci_write_reg(data, SH4_PCIPDR);
+        pci_write_reg(chan, data, SH4_PCIPDR);
 
         return PCIBIOS_SUCCESSFUL;
 }
@@ -104,66 +106,31 @@ struct pci_ops sh4_pci_ops = {
  * Not really related to pci_ops, but it's common and not worth shoving
  * somewhere else for now..
  */
-static unsigned int pci_probe = PCI_PROBE_CONF1;
-
-int __init sh4_pci_check_direct(void)
+int __init sh4_pci_check_direct(struct pci_channel *chan)
 {
         /*
          * Check if configuration works.
          */
-        if (pci_probe & PCI_PROBE_CONF1) {
-                unsigned int tmp = pci_read_reg(SH4_PCIPAR);
-
-                pci_write_reg(P1SEG, SH4_PCIPAR);
+        unsigned int tmp = pci_read_reg(chan, SH4_PCIPAR);
 
-                if (pci_read_reg(SH4_PCIPAR) == P1SEG) {
-                        pci_write_reg(tmp, SH4_PCIPAR);
-                        printk(KERN_INFO "PCI: Using configuration type 1\n");
-                        request_region(PCI_REG(SH4_PCIPAR), 8, "PCI conf1");
+        pci_write_reg(chan, P1SEG, SH4_PCIPAR);
 
-                        return 0;
-                }
-
-                pci_write_reg(tmp, SH4_PCIPAR);
+        if (pci_read_reg(chan, SH4_PCIPAR) == P1SEG) {
+                pci_write_reg(chan, tmp, SH4_PCIPAR);
+                printk(KERN_INFO "PCI: Using configuration type 1\n");
+                request_region(chan->reg_base + SH4_PCIPAR, 8,
+                               "PCI conf1");
+                return 0;
         }
 
-        pr_debug("PCI: pci_check_direct failed\n");
-        return -EINVAL;
-}
+        pci_write_reg(chan, tmp, SH4_PCIPAR);
 
-/* Handle generic fixups */
-static void __init pci_fixup_ide_bases(struct pci_dev *d)
-{
-        int i;
+        printk(KERN_ERR "PCI: %s failed\n", __func__);
 
-        /*
-         * PCI IDE controllers use non-standard I/O port decoding, respect it.
-         */
-        if ((d->class >> 8) != PCI_CLASS_STORAGE_IDE)
-                return;
-        pr_debug("PCI: IDE base address fixup for %s\n", pci_name(d));
-        for(i = 0; i < 4; i++) {
-                struct resource *r = &d->resource[i];
-
-                if ((r->start & ~0x80) == 0x374) {
-                        r->start |= 2;
-                        r->end = r->start;
-                }
-        }
-}
-DECLARE_PCI_FIXUP_HEADER(PCI_ANY_ID, PCI_ANY_ID, pci_fixup_ide_bases);
-
-char * __devinit pcibios_setup(char *str)
-{
-        if (!strcmp(str, "off")) {
-                pci_probe = 0;
-                return NULL;
-        }
-
-        return str;
+        return -EINVAL;
 }
 
-int __attribute__((weak)) pci_fixup_pcic(void)
+int __attribute__((weak)) pci_fixup_pcic(struct pci_channel *chan)
 {
         /* Nothing to do. */
         return 0;
diff --git a/arch/sh/drivers/pci/ops-sh5.c b/arch/sh/drivers/pci/ops-sh5.c
index 729e38a6fe07..4ce95a001b80 100644
--- a/arch/sh/drivers/pci/ops-sh5.c
+++ b/arch/sh/drivers/pci/ops-sh5.c
@@ -22,31 +22,6 @@
 #include <asm/io.h>
 #include "pci-sh5.h"
 
-static void __init pci_fixup_ide_bases(struct pci_dev *d)
-{
-        int i;
-
-        /*
-         * PCI IDE controllers use non-standard I/O port decoding, respect it.
-         */
-        if ((d->class >> 8) != PCI_CLASS_STORAGE_IDE)
-                return;
-        printk("PCI: IDE base address fixup for %s\n", pci_name(d));
-        for(i=0; i<4; i++) {
-                struct resource *r = &d->resource[i];
-                if ((r->start & ~0x80) == 0x374) {
-                        r->start |= 2;
-                        r->end = r->start;
-                }
-        }
-}
-DECLARE_PCI_FIXUP_HEADER(PCI_ANY_ID, PCI_ANY_ID, pci_fixup_ide_bases);
-
-char * __devinit pcibios_setup(char *str)
-{
-        return str;
-}
-
 static int sh5pci_read(struct pci_bus *bus, unsigned int devfn, int where,
                         int size, u32 *val)
 {
diff --git a/arch/sh/drivers/pci/ops-sh7785lcr.c b/arch/sh/drivers/pci/ops-sh7785lcr.c
deleted file mode 100644
index fb0869f0bef8..000000000000
--- a/arch/sh/drivers/pci/ops-sh7785lcr.c
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Author:  Ian DaSilva (idasilva@mvista.com)
- *
- * Highly leveraged from pci-bigsur.c, written by Dustin McIntire.
- *
- * May be copied or modified under the terms of the GNU General Public
- * License.  See linux/COPYING for more information.
- *
- * PCI initialization for the Renesas R0P7785LC0011RL board
- * Based on arch/sh/drivers/pci/ops-r7780rp.c
- *
- */
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/init.h>
-#include <linux/delay.h>
-#include <linux/pci.h>
-#include "pci-sh4.h"
-
-static char irq_tab[] __initdata = {
-        65, 66, 67, 68,
-};
-
-int __init pcibios_map_platform_irq(struct pci_dev *pdev, u8 slot, u8 pin)
-{
-        return irq_tab[slot];
-}
-
-static struct resource sh7785_io_resource = {
-        .name   = "SH7785_IO",
-        .start  = SH7780_PCI_IO_BASE,
-        .end    = SH7780_PCI_IO_BASE + SH7780_PCI_IO_SIZE - 1,
-        .flags  = IORESOURCE_IO
-};
-
-static struct resource sh7785_mem_resource = {
-        .name   = "SH7785_mem",
-        .start  = SH7780_PCI_MEMORY_BASE,
-        .end    = SH7780_PCI_MEMORY_BASE + SH7780_PCI_MEM_SIZE - 1,
-        .flags  = IORESOURCE_MEM
-};
-
-struct pci_channel board_pci_channels[] = {
-        { &sh4_pci_ops, &sh7785_io_resource, &sh7785_mem_resource, 0, 0xff },
-        { NULL, NULL, NULL, 0, 0 },
-};
-EXPORT_SYMBOL(board_pci_channels);
-
-static struct sh4_pci_address_map sh7785_pci_map = {
-        .window0        = {
-#if defined(CONFIG_32BIT)
-                .base   = SH7780_32BIT_DDR_BASE_ADDR,
-                .size   = 0x40000000,
-#else
-                .base   = SH7780_CS0_BASE_ADDR,
-                .size   = 0x20000000,
-#endif
-        },
-
-        .flags  = SH4_PCIC_NO_RESET,
-};
-
-int __init pcibios_init_platform(void)
-{
-        return sh7780_pcic_init(&sh7785_pci_map);
-}
diff --git a/arch/sh/drivers/pci/ops-snapgear.c b/arch/sh/drivers/pci/ops-snapgear.c
deleted file mode 100644
index 53dd893d4e54..000000000000
--- a/arch/sh/drivers/pci/ops-snapgear.c
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * arch/sh/drivers/pci/ops-snapgear.c
- *
- * Author:  David McCullough <davidm@snapgear.com>
- *
- * Ported to new API by Paul Mundt <lethal@linux-sh.org>
- *
- * Highly leveraged from pci-bigsur.c, written by Dustin McIntire.
- *
- * May be copied or modified under the terms of the GNU General Public
- * License.  See linux/COPYING for more information.
- *
- * PCI initialization for the SnapGear boards
- */
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <linux/init.h>
-#include <linux/pci.h>
-#include "pci-sh4.h"
-
-#define SNAPGEAR_PCI_IO         0x4000
-#define SNAPGEAR_PCI_MEM        0xfd000000
-
-/* PCI: default LOCAL memory window sizes (seen from PCI bus) */
-#define SNAPGEAR_LSR0_SIZE    (64*(1<<20)) //64MB
-#define SNAPGEAR_LSR1_SIZE    (64*(1<<20)) //64MB
-
-static struct resource sh7751_io_resource = {
-        .name           = "SH7751 IO",
-        .start          = SNAPGEAR_PCI_IO,
-        .end            = SNAPGEAR_PCI_IO + (64*1024) - 1, /* 64KiB I/O */
-        .flags          = IORESOURCE_IO,
-};
-
-static struct resource sh7751_mem_resource = {
-        .name           = "SH7751 mem",
-        .start          = SNAPGEAR_PCI_MEM,
-        .end            = SNAPGEAR_PCI_MEM + (64*1024*1024) - 1, /* 64MiB mem */
-        .flags          = IORESOURCE_MEM,
-};
-
-struct pci_channel board_pci_channels[] = {
-        { &sh4_pci_ops, &sh7751_io_resource, &sh7751_mem_resource, 0, 0xff },
-        { 0, }
-};
-
-static struct sh4_pci_address_map sh7751_pci_map = {
-        .window0        = {
-                .base   = SH7751_CS2_BASE_ADDR,
-                .size   = SNAPGEAR_LSR0_SIZE,
-        },
-
-        .window1        = {
-                .base   = SH7751_CS2_BASE_ADDR,
-                .size   = SNAPGEAR_LSR1_SIZE,
-        },
-
-        .flags  = SH4_PCIC_NO_RESET,
-};
-
-/*
- * Initialize the SnapGear PCI interface
- * Setup hardware to be Central Funtion
- * Copy the BSR regs to the PCI interface
- * Setup PCI windows into local RAM
- */
-int __init pcibios_init_platform(void)
-{
-        return sh7751_pcic_init(&sh7751_pci_map);
-}
-
-int __init pcibios_map_platform_irq(struct pci_dev *pdev, u8 slot, u8 pin)
-{
-        int irq = -1;
-
-        switch (slot) {
-        case 8:  /* the PCI bridge */ break;
-        case 11: irq = 8;  break; /* USB    */
-        case 12: irq = 11; break; /* PCMCIA */
-        case 13: irq = 5;  break; /* eth0   */
-        case 14: irq = 8;  break; /* eth1   */
-        case 15: irq = 11; break; /* safenet (unused) */
-        }
-
-        printk("PCI: Mapping SnapGear IRQ for slot %d, pin %c to irq %d\n",
-               slot, pin - 1 + 'A', irq);
-
-        return irq;
-}
-
-void __init pcibios_fixup(void)
-{
-        /* Nothing to fixup .. */
-}
diff --git a/arch/sh/drivers/pci/pci-auto.c b/arch/sh/drivers/pci/pci-auto.c
deleted file mode 100644
index cf48b12ee58c..000000000000
--- a/arch/sh/drivers/pci/pci-auto.c
+++ /dev/null
@@ -1,545 +0,0 @@
-/*
- * PCI autoconfiguration library
- *
- * Author: Matt Porter <mporter@mvista.com>
- *
- * Copyright 2000, 2001 MontaVista Software Inc.
- * Copyright 2001 Bradley D. LaRonde <brad@ltc.com>
- * Copyright 2003 Paul Mundt <lethal@linux-sh.org>
- *
- * This program is free software; you can redistribute  it and/or modify it
- * under  the terms of  the GNU General  Public License as published by the
- * Free Software Foundation;  either version 2 of the  License, or (at your
- * option) any later version.
- */
-
-/*
- * Modified for MIPS by Jun Sun, jsun@mvista.com
- *
- * . Simplify the interface between pci_auto and the rest: a single function.
- * . Assign resources from low address to upper address.
- * . change most int to u32.
- *
- * Further modified to include it as mips generic code, ppopov@mvista.com.
- *
- * 2001-10-26  Bradley D. LaRonde <brad@ltc.com>
- * - Add a top_bus argument to the "early config" functions so that
- *   they can set a fake parent bus pointer to convince the underlying
- *   pci ops to use type 1 configuration for sub busses.
- * - Set bridge base and limit registers correctly.
- * - Align io and memory base properly before and after bridge setup.
- * - Don't fall through to pci_setup_bars for bridge.
- * - Reformat the debug output to look more like lspci's output.
- *
- * Cloned for SuperH by M. R. Brown, mrbrown@0xd6.org
- *
- * 2003-08-05  Paul Mundt <lethal@linux-sh.org>
- * - Don't update the BAR values on systems that already have valid addresses
- *   and don't want these updated for whatever reason, by way of a new config
- *   option check. However, we still read in the old BAR values so that they
- *   can still be reported through the debug output.
- */
-
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/types.h>
-#include <linux/pci.h>
-
-#define DEBUG
-#ifdef  DEBUG
-#define DBG(x...)       printk(x)
-#else
-#define DBG(x...)
-#endif
-
-/*
- * These functions are used early on before PCI scanning is done
- * and all of the pci_dev and pci_bus structures have been created.
- */
-static struct pci_dev *fake_pci_dev(struct pci_channel *hose,
-        int top_bus, int busnr, int devfn)
-{
-        static struct pci_dev dev;
-        static struct pci_bus bus;
-
-        dev.bus = &bus;
-        dev.sysdata = hose;
-        dev.devfn = devfn;
-        bus.number = busnr;
-        bus.ops = hose->pci_ops;
-
-        if(busnr != top_bus)
-                /* Fake a parent bus structure. */
-                bus.parent = &bus;
-        else
-                bus.parent = NULL;
-
-        return &dev;
-}
-
-#define EARLY_PCI_OP(rw, size, type)                                    \
-static int early_##rw##_config_##size(struct pci_channel *hose,         \
-        int top_bus, int bus, int devfn, int offset, type value)        \
-{                                                                       \
-        return pci_##rw##_config_##size(                                \
-                fake_pci_dev(hose, top_bus, bus, devfn),                \
-                offset, value);                                         \
-}
-
-EARLY_PCI_OP(read, byte, u8 *)
-EARLY_PCI_OP(read, word, u16 *)
-EARLY_PCI_OP(read, dword, u32 *)
-EARLY_PCI_OP(write, byte, u8)
-EARLY_PCI_OP(write, word, u16)
-EARLY_PCI_OP(write, dword, u32)
-
-static struct resource *io_resource_inuse;
-static struct resource *mem_resource_inuse;
-
-static u32 pciauto_lower_iospc;
-static u32 pciauto_upper_iospc;
-
-static u32 pciauto_lower_memspc;
-static u32 pciauto_upper_memspc;
-
-static void __init
-pciauto_setup_bars(struct pci_channel *hose,
-                   int top_bus,
-                   int current_bus,
-                   int pci_devfn,
-                   int bar_limit)
-{
-        u32 bar_response, bar_size, bar_value;
-        u32 bar, addr_mask, bar_nr = 0;
-        u32 * upper_limit;
-        u32 * lower_limit;
-        int found_mem64 = 0;
-
-        for (bar = PCI_BASE_ADDRESS_0; bar <= bar_limit; bar+=4) {
-                u32 bar_addr;
-
-                /* Read the old BAR value */
-                early_read_config_dword(hose, top_bus,
-                                        current_bus,
-                                        pci_devfn,
-                                        bar,
-                                        &bar_addr);
-
-                /* Tickle the BAR and get the response */
-                early_write_config_dword(hose, top_bus,
-                                         current_bus,
-                                         pci_devfn,
-                                         bar,
-                                         0xffffffff);
-
-                early_read_config_dword(hose, top_bus,
-                                        current_bus,
-                                        pci_devfn,
-                                        bar,
-                                        &bar_response);
-
-                /*
-                 * Write the old BAR value back out, only update the BAR
-                 * if we implicitly want resources to be updated, which
-                 * is done by the generic code further down. -- PFM.
-                 */
-                early_write_config_dword(hose, top_bus,
-                                         current_bus,
-                                         pci_devfn,
-                                         bar,
-                                         bar_addr);
-
-                /* If BAR is not implemented go to the next BAR */
-                if (!bar_response)
-                        continue;
-
-                /*
-                 * Workaround for a BAR that doesn't use its upper word,
-                 * like the ALi 1535D+ PCI DC-97 Controller Modem (M5457).
-                 * bdl <brad@ltc.com>
-                 */
-                if (!(bar_response & 0xffff0000))
-                        bar_response |= 0xffff0000;
-
-retry:
-                /* Check the BAR type and set our address mask */
-                if (bar_response & PCI_BASE_ADDRESS_SPACE) {
-                        addr_mask = PCI_BASE_ADDRESS_IO_MASK;
-                        upper_limit = &pciauto_upper_iospc;
-                        lower_limit = &pciauto_lower_iospc;
-                        DBG("        I/O");
-                } else {
-                        if ((bar_response & PCI_BASE_ADDRESS_MEM_TYPE_MASK) ==
-                            PCI_BASE_ADDRESS_MEM_TYPE_64)
-                                found_mem64 = 1;
-
-                        addr_mask = PCI_BASE_ADDRESS_MEM_MASK;
-                        upper_limit = &pciauto_upper_memspc;
-                        lower_limit = &pciauto_lower_memspc;
-                        DBG("        Mem");
-                }
-
-
-                /* Calculate requested size */
-                bar_size = ~(bar_response & addr_mask) + 1;
-
-                /* Allocate a base address */
-                bar_value = ((*lower_limit - 1) & ~(bar_size - 1)) + bar_size;
-
-                if ((bar_value + bar_size) > *upper_limit) {
-                        if (bar_response & PCI_BASE_ADDRESS_SPACE) {
-                                if (io_resource_inuse->child) {
-                                        io_resource_inuse =
-                                                io_resource_inuse->child;
-                                        pciauto_lower_iospc =
-                                                io_resource_inuse->start;
-                                        pciauto_upper_iospc =
-                                                io_resource_inuse->end + 1;
-                                        goto retry;
-                                }
-
-                        } else {
-                                if (mem_resource_inuse->child) {
-                                        mem_resource_inuse =
-                                                mem_resource_inuse->child;
-                                        pciauto_lower_memspc =
-                                                mem_resource_inuse->start;
-                                        pciauto_upper_memspc =
-                                                mem_resource_inuse->end + 1;
-                                        goto retry;
-                                }
-                        }
-                        DBG(" unavailable -- skipping, value %x size %x\n",
-                                        bar_value, bar_size);
-                        continue;
-                }
-
-                if (bar_value < *lower_limit || (bar_value + bar_size) >= *upper_limit) {
-                        DBG(" unavailable -- skipping, value %x size %x\n",
-                                        bar_value, bar_size);
-                        continue;
-                }
-
-#ifdef CONFIG_PCI_AUTO_UPDATE_RESOURCES
-                /* Write it out and update our limit */
-                early_write_config_dword(hose, top_bus, current_bus, pci_devfn,
-                                         bar, bar_value);
-#endif
-
-                *lower_limit = bar_value + bar_size;
-
-                /*
-                 * If we are a 64-bit decoder then increment to the
-                 * upper 32 bits of the bar and force it to locate
-                 * in the lower 4GB of memory.
-                 */
-                if (found_mem64) {
-                        bar += 4;
-                        early_write_config_dword(hose, top_bus,
-                                                 current_bus,
-                                                 pci_devfn,
-                                                 bar,
-                                                 0x00000000);
-                }
-
-                DBG(" at 0x%.8x [size=0x%x]\n", bar_value, bar_size);
-
-                bar_nr++;
-        }
-
-}
-
-static void __init
-pciauto_prescan_setup_bridge(struct pci_channel *hose,
-                             int top_bus,
-                             int current_bus,
-                             int pci_devfn,
-                             int sub_bus)
-{
-        /* Configure bus number registers */
-        early_write_config_byte(hose, top_bus, current_bus, pci_devfn,
-                                PCI_PRIMARY_BUS, current_bus);
-        early_write_config_byte(hose, top_bus, current_bus, pci_devfn,
-                                PCI_SECONDARY_BUS, sub_bus + 1);
-        early_write_config_byte(hose, top_bus, current_bus, pci_devfn,
-                                PCI_SUBORDINATE_BUS, 0xff);
-
-        /* Align memory and I/O to 1MB and 4KB boundaries. */
-        pciauto_lower_memspc = (pciauto_lower_memspc + (0x100000 - 1))
-                & ~(0x100000 - 1);
-        pciauto_lower_iospc = (pciauto_lower_iospc + (0x1000 - 1))
-                & ~(0x1000 - 1);
-
-        /* Set base (lower limit) of address range behind bridge. */
-        early_write_config_word(hose, top_bus, current_bus, pci_devfn,
-                PCI_MEMORY_BASE, pciauto_lower_memspc >> 16);
-        early_write_config_byte(hose, top_bus, current_bus, pci_devfn,
-                PCI_IO_BASE, (pciauto_lower_iospc & 0x0000f000) >> 8);
-        early_write_config_word(hose, top_bus, current_bus, pci_devfn,
-                PCI_IO_BASE_UPPER16, pciauto_lower_iospc >> 16);
-
-        /* We don't support prefetchable memory for now, so disable */
-        early_write_config_word(hose, top_bus, current_bus, pci_devfn,
-                                PCI_PREF_MEMORY_BASE, 0);
-        early_write_config_word(hose, top_bus, current_bus, pci_devfn,
-                                PCI_PREF_MEMORY_LIMIT, 0);
-}
-
-static void __init
-pciauto_postscan_setup_bridge(struct pci_channel *hose,
-                              int top_bus,
-                              int current_bus,
-                              int pci_devfn,
-                              int sub_bus)
-{
-        u32 temp;
-
-        /*
-         * [jsun] we always bump up baselines a little, so that if there
-         * nothing behind P2P bridge, we don't wind up overlapping IO/MEM
-         * spaces.
-         */
-        pciauto_lower_memspc += 1;
-        pciauto_lower_iospc += 1;
-
-        /* Configure bus number registers */
-        early_write_config_byte(hose, top_bus, current_bus, pci_devfn,
-                                PCI_SUBORDINATE_BUS, sub_bus);
-
-        /* Set upper limit of address range behind bridge. */
-        early_write_config_word(hose, top_bus, current_bus, pci_devfn,
-                PCI_MEMORY_LIMIT, pciauto_lower_memspc >> 16);
-        early_write_config_byte(hose, top_bus, current_bus, pci_devfn,
-                PCI_IO_LIMIT, (pciauto_lower_iospc & 0x0000f000) >> 8);
-        early_write_config_word(hose, top_bus, current_bus, pci_devfn,
-                PCI_IO_LIMIT_UPPER16, pciauto_lower_iospc >> 16);
-
-        /* Align memory and I/O to 1MB and 4KB boundaries. */
-        pciauto_lower_memspc = (pciauto_lower_memspc + (0x100000 - 1))
-                & ~(0x100000 - 1);
-        pciauto_lower_iospc = (pciauto_lower_iospc + (0x1000 - 1))
-                & ~(0x1000 - 1);
-
-        /* Enable memory and I/O accesses, enable bus master */
-        early_read_config_dword(hose, top_bus, current_bus, pci_devfn,
-                PCI_COMMAND, &temp);
-        early_write_config_dword(hose, top_bus, current_bus, pci_devfn,
-                PCI_COMMAND, temp | PCI_COMMAND_IO | PCI_COMMAND_MEMORY
-                | PCI_COMMAND_MASTER);
-}
-
-static void __init
-pciauto_prescan_setup_cardbus_bridge(struct pci_channel *hose,
-                        int top_bus,
-                        int current_bus,
-                        int pci_devfn,
-                        int sub_bus)
-{
-        /* Configure bus number registers */
-        early_write_config_byte(hose, top_bus, current_bus, pci_devfn,
-                                PCI_PRIMARY_BUS, current_bus);
-        early_write_config_byte(hose, top_bus, current_bus, pci_devfn,
-                                PCI_SECONDARY_BUS, sub_bus + 1);
-        early_write_config_byte(hose, top_bus, current_bus, pci_devfn,
-                                PCI_SUBORDINATE_BUS, 0xff);
-
-        /* Align memory and I/O to 4KB and 4 byte boundaries. */
-        pciauto_lower_memspc = (pciauto_lower_memspc + (0x1000 - 1))
-                & ~(0x1000 - 1);
-        pciauto_lower_iospc = (pciauto_lower_iospc + (0x4 - 1))
-                & ~(0x4 - 1);
-
-        early_write_config_dword(hose, top_bus, current_bus, pci_devfn,
-                PCI_CB_MEMORY_BASE_0, pciauto_lower_memspc);
-        early_write_config_dword(hose, top_bus, current_bus, pci_devfn,
-                PCI_CB_IO_BASE_0, pciauto_lower_iospc);
-}
-
-static void __init
-pciauto_postscan_setup_cardbus_bridge(struct pci_channel *hose,
-                        int top_bus,
-                        int current_bus,
-                        int pci_devfn,
-                        int sub_bus)
-{
-        u32 temp;
-
-        /*
-         * [jsun] we always bump up baselines a little, so that if there
-         * nothing behind P2P bridge, we don't wind up overlapping IO/MEM
-         * spaces.
-         */
-        pciauto_lower_memspc += 1;
-        pciauto_lower_iospc += 1;
-
-        /*
-         * Configure subordinate bus number.  The PCI subsystem
-         * bus scan will renumber buses (reserving three additional
-         * for this PCI<->CardBus bridge for the case where a CardBus
-         * adapter contains a P2P or CB2CB bridge.
-         */
-
-        early_write_config_byte(hose, top_bus, current_bus, pci_devfn,
-                                PCI_SUBORDINATE_BUS, sub_bus);
-
-        /*
-         * Reserve an additional 4MB for mem space and 16KB for
-         * I/O space.  This should cover any additional space
-         * requirement of unusual CardBus devices with
-         * additional bridges that can consume more address space.
-         *
-         * Although pcmcia-cs currently will reprogram bridge
-         * windows, the goal is to add an option to leave them
-         * alone and use the bridge window ranges as the regions
-         * that are searched for free resources upon hot-insertion
-         * of a device.  This will allow a PCI<->CardBus bridge
-         * configured by this routine to happily live behind a
-         * P2P bridge in a system.
-         */
-        /* Align memory and I/O to 4KB and 4 byte boundaries. */
-        pciauto_lower_memspc = (pciauto_lower_memspc + (0x1000 - 1))
-                & ~(0x1000 - 1);
-        pciauto_lower_iospc = (pciauto_lower_iospc + (0x4 - 1))
-                & ~(0x4 - 1);
-        /* Set up memory and I/O filter limits, assume 32-bit I/O space */
-        early_write_config_dword(hose, top_bus, current_bus, pci_devfn,
-                PCI_CB_MEMORY_LIMIT_0, pciauto_lower_memspc - 1);
-        early_write_config_dword(hose, top_bus, current_bus, pci_devfn,
-                PCI_CB_IO_LIMIT_0, pciauto_lower_iospc - 1);
-
-        /* Enable memory and I/O accesses, enable bus master */
-        early_read_config_dword(hose, top_bus, current_bus, pci_devfn,
-                PCI_COMMAND, &temp);
-        early_write_config_dword(hose, top_bus, current_bus, pci_devfn,
-                PCI_COMMAND, temp | PCI_COMMAND_IO | PCI_COMMAND_MEMORY |
-                PCI_COMMAND_MASTER);
-}
-
-#define PCIAUTO_IDE_MODE_MASK           0x05
-
-static int __init
-pciauto_bus_scan(struct pci_channel *hose, int top_bus, int current_bus)
-{
-        int sub_bus;
-        u32 pci_devfn, pci_class, cmdstat, found_multi=0;
-        unsigned short vid, did;
-        unsigned char header_type;
-        int devfn_start = 0;
-        int devfn_stop = 0xff;
-
-        sub_bus = current_bus;
-
-        if (hose->first_devfn)
-                devfn_start = hose->first_devfn;
-        if (hose->last_devfn)
-                devfn_stop = hose->last_devfn;
-
-        for (pci_devfn=devfn_start; pci_devfn<devfn_stop; pci_devfn++) {
-
-                if (PCI_FUNC(pci_devfn) && !found_multi)
-                        continue;
-
-                early_read_config_word(hose, top_bus, current_bus, pci_devfn,
-                                       PCI_VENDOR_ID, &vid);
-
-                if (vid == 0xffff) continue;
-
-                early_read_config_byte(hose, top_bus, current_bus, pci_devfn,
-                                       PCI_HEADER_TYPE, &header_type);
-
-                if (!PCI_FUNC(pci_devfn))
-                        found_multi = header_type & 0x80;
-
-                early_read_config_word(hose, top_bus, current_bus, pci_devfn,
-                                       PCI_DEVICE_ID, &did);
-
-                early_read_config_dword(hose, top_bus, current_bus, pci_devfn,
-                                        PCI_CLASS_REVISION, &pci_class);
-
-                DBG("%.2x:%.2x.%x Class %.4x: %.4x:%.4x",
-                        current_bus, PCI_SLOT(pci_devfn), PCI_FUNC(pci_devfn),
-                        pci_class >> 16, vid, did);
-                if (pci_class & 0xff)
-                        DBG(" (rev %.2x)", pci_class & 0xff);
-                DBG("\n");
-
-                if ((pci_class >> 16) == PCI_CLASS_BRIDGE_PCI) {
-                        DBG("        Bridge: primary=%.2x, secondary=%.2x\n",
-                                current_bus, sub_bus + 1);
-                        pciauto_prescan_setup_bridge(hose, top_bus, current_bus,
-                                                     pci_devfn, sub_bus);
-                        DBG("Scanning sub bus %.2x, I/O 0x%.8x, Mem 0x%.8x\n",
-                                sub_bus + 1,
-                                pciauto_lower_iospc, pciauto_lower_memspc);
-                        sub_bus = pciauto_bus_scan(hose, top_bus, sub_bus+1);
-                        DBG("Back to bus %.2x\n", current_bus);
-                        pciauto_postscan_setup_bridge(hose, top_bus, current_bus,
-                                                        pci_devfn, sub_bus);
-                        continue;
-                } else if ((pci_class >> 16) == PCI_CLASS_BRIDGE_CARDBUS) {
-                        DBG("  CARDBUS  Bridge: primary=%.2x, secondary=%.2x\n",
-                                current_bus, sub_bus + 1);
-                        DBG("PCI Autoconfig: Found CardBus bridge, device %d function %d\n", PCI_SLOT(pci_devfn), PCI_FUNC(pci_devfn));
-                        /* Place CardBus Socket/ExCA registers */
-                        pciauto_setup_bars(hose, top_bus, current_bus, pci_devfn, PCI_BASE_ADDRESS_0);
-
-                        pciauto_prescan_setup_cardbus_bridge(hose, top_bus,
-                                        current_bus, pci_devfn, sub_bus);
-
-                        DBG("Scanning sub bus %.2x, I/O 0x%.8x, Mem 0x%.8x\n",
-                                sub_bus + 1,
-                                pciauto_lower_iospc, pciauto_lower_memspc);
-                        sub_bus = pciauto_bus_scan(hose, top_bus, sub_bus+1);
-                        DBG("Back to bus %.2x, sub_bus is %x\n", current_bus, sub_bus);
-                        pciauto_postscan_setup_cardbus_bridge(hose, top_bus,
-                                        current_bus, pci_devfn, sub_bus);
-                        continue;
-                } else if ((pci_class >> 16) == PCI_CLASS_STORAGE_IDE) {
-
-                        unsigned char prg_iface;
-
-                        early_read_config_byte(hose, top_bus, current_bus,
-                                pci_devfn, PCI_CLASS_PROG, &prg_iface);
-                        if (!(prg_iface & PCIAUTO_IDE_MODE_MASK)) {
-                                DBG("Skipping legacy mode IDE controller\n");
-                                continue;
-                        }
-                }
-
-                /*
-                 * Found a peripheral, enable some standard
-                 * settings
-                 */
-                early_read_config_dword(hose, top_bus, current_bus, pci_devfn,
-                                        PCI_COMMAND, &cmdstat);
-                early_write_config_dword(hose, top_bus, current_bus, pci_devfn,
-                                         PCI_COMMAND, cmdstat | PCI_COMMAND_IO |
-                                         PCI_COMMAND_MEMORY |
-                                         PCI_COMMAND_MASTER);
-                early_write_config_byte(hose, top_bus, current_bus, pci_devfn,
-                                        PCI_LATENCY_TIMER, 0x80);
-
-                /* Allocate PCI I/O and/or memory space */
-                pciauto_setup_bars(hose, top_bus, current_bus, pci_devfn, PCI_BASE_ADDRESS_5);
-        }
-        return sub_bus;
-}
-
-int __init
-pciauto_assign_resources(int busno, struct pci_channel *hose)
-{
-        /* setup resource limits */
-        io_resource_inuse = hose->io_resource;
-        mem_resource_inuse = hose->mem_resource;
-
-        pciauto_lower_iospc = io_resource_inuse->start;
-        pciauto_upper_iospc = io_resource_inuse->end + 1;
-        pciauto_lower_memspc = mem_resource_inuse->start;
-        pciauto_upper_memspc = mem_resource_inuse->end + 1;
-        DBG("Autoconfig PCI channel 0x%p\n", hose);
-        DBG("Scanning bus %.2x, I/O 0x%.8x:0x%.8x, Mem 0x%.8x:0x%.8x\n",
-                busno, pciauto_lower_iospc, pciauto_upper_iospc, 
-                pciauto_lower_memspc, pciauto_upper_memspc);
-
-        return pciauto_bus_scan(hose, busno, busno);
-}
diff --git a/arch/sh/drivers/pci/pci-dreamcast.c b/arch/sh/drivers/pci/pci-dreamcast.c
new file mode 100644
index 000000000000..210f9d4af141
--- /dev/null
+++ b/arch/sh/drivers/pci/pci-dreamcast.c
@@ -0,0 +1,102 @@
+/*
+ * PCI support for the Sega Dreamcast
+ *
+ * Copyright (C) 2001, 2002  M. R. Brown
+ * Copyright (C) 2002, 2003  Paul Mundt
+ *
+ * This file originally bore the message (with enclosed-$):
+ *      Id: pci.c,v 1.3 2003/05/04 19:29:46 lethal Exp
+ *      Dreamcast PCI: Supports SEGA Broadband Adaptor only.
+ *
+ * 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.
+ */
+
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <linux/param.h>
+#include <linux/interrupt.h>
+#include <linux/init.h>
+#include <linux/irq.h>
+#include <linux/pci.h>
+#include <linux/module.h>
+#include <asm/io.h>
+#include <asm/irq.h>
+#include <mach/pci.h>
+
+static struct resource gapspci_io_resource = {
+        .name   = "GAPSPCI IO",
+        .start  = GAPSPCI_BBA_CONFIG,
+        .end    = GAPSPCI_BBA_CONFIG + GAPSPCI_BBA_CONFIG_SIZE - 1,
+        .flags  = IORESOURCE_IO,
+};
+
+static struct resource gapspci_mem_resource = {
+        .name   = "GAPSPCI mem",
+        .start  = GAPSPCI_DMA_BASE,
+        .end    = GAPSPCI_DMA_BASE + GAPSPCI_DMA_SIZE - 1,
+        .flags  = IORESOURCE_MEM,
+};
+
+static struct pci_channel dreamcast_pci_controller = {
+        .pci_ops        = &gapspci_pci_ops,
+        .io_resource    = &gapspci_io_resource,
+        .io_offset      = 0x00000000,
+        .mem_resource   = &gapspci_mem_resource,
+        .mem_offset     = 0x00000000,
+};
+
+/*
+ * gapspci init
+ */
+
+static int __init gapspci_init(void)
+{
+        char idbuf[16];
+        int i;
+
+        /*
+         * FIXME: All of this wants documenting to some degree,
+         * even some basic register definitions would be nice.
+         *
+         * I haven't seen anything this ugly since.. maple.
+         */
+
+        for (i=0; i<16; i++)
+                idbuf[i] = inb(GAPSPCI_REGS+i);
+
+        if (strncmp(idbuf, "GAPSPCI_BRIDGE_2", 16))
+                return -ENODEV;
+
+        outl(0x5a14a501, GAPSPCI_REGS+0x18);
+
+        for (i=0; i<1000000; i++)
+                cpu_relax();
+
+        if (inl(GAPSPCI_REGS+0x18) != 1)
+                return -EINVAL;
+
+        outl(0x01000000, GAPSPCI_REGS+0x20);
+        outl(0x01000000, GAPSPCI_REGS+0x24);
+
+        outl(GAPSPCI_DMA_BASE, GAPSPCI_REGS+0x28);
+        outl(GAPSPCI_DMA_BASE+GAPSPCI_DMA_SIZE, GAPSPCI_REGS+0x2c);
+
+        outl(1, GAPSPCI_REGS+0x14);
+        outl(1, GAPSPCI_REGS+0x34);
+
+        /* Setting Broadband Adapter */
+        outw(0xf900, GAPSPCI_BBA_CONFIG+0x06);
+        outl(0x00000000, GAPSPCI_BBA_CONFIG+0x30);
+        outb(0x00, GAPSPCI_BBA_CONFIG+0x3c);
+        outb(0xf0, GAPSPCI_BBA_CONFIG+0x0d);
+        outw(0x0006, GAPSPCI_BBA_CONFIG+0x04);
+        outl(0x00002001, GAPSPCI_BBA_CONFIG+0x10);
+        outl(0x01000000, GAPSPCI_BBA_CONFIG+0x14);
+
+        register_pci_controller(&dreamcast_pci_controller);
+
+        return 0;
+}
+arch_initcall(gapspci_init);
diff --git a/arch/sh/drivers/pci/pci-sh4.h b/arch/sh/drivers/pci/pci-sh4.h
index a83dcf70c13b..3d5296cde622 100644
--- a/arch/sh/drivers/pci/pci-sh4.h
+++ b/arch/sh/drivers/pci/pci-sh4.h
@@ -149,13 +149,10 @@
   #define SH4_PCIPDTR_PB0         0x000000001   /* Port 0 Enable */
 #define SH4_PCIPDR              0x220           /* Port IO Data Register */
 
-/* Flags */
-#define SH4_PCIC_NO_RESET       0x0001
-
 /* arch/sh/kernel/drivers/pci/ops-sh4.c */
 extern struct pci_ops sh4_pci_ops;
-int sh4_pci_check_direct(void);
-int pci_fixup_pcic(void);
+int sh4_pci_check_direct(struct pci_channel *chan);
+int pci_fixup_pcic(struct pci_channel *chan);
 
 struct sh4_pci_address_space {
         unsigned long base;
@@ -165,16 +162,18 @@ struct sh4_pci_address_space {
 struct sh4_pci_address_map {
         struct sh4_pci_address_space window0;
         struct sh4_pci_address_space window1;
-        unsigned long flags;
 };
 
-static inline void pci_write_reg(unsigned long val, unsigned long reg)
+static inline void pci_write_reg(struct pci_channel *chan,
+                                 unsigned long val, unsigned long reg)
 {
-        ctrl_outl(val, PCI_REG(reg));
+        ctrl_outl(val, chan->reg_base + reg);
 }
 
-static inline unsigned long pci_read_reg(unsigned long reg)
+static inline unsigned long pci_read_reg(struct pci_channel *chan,
+                                         unsigned long reg)
 {
-        return ctrl_inl(PCI_REG(reg));
+        return ctrl_inl(chan->reg_base + reg);
 }
+
 #endif /* __PCI_SH4_H */
diff --git a/arch/sh/drivers/pci/pci-sh5.c b/arch/sh/drivers/pci/pci-sh5.c
index 7a97438762c8..873ed2b44055 100644
--- a/arch/sh/drivers/pci/pci-sh5.c
+++ b/arch/sh/drivers/pci/pci-sh5.c
@@ -89,8 +89,21 @@ static irqreturn_t pcish5_serr_irq(int irq, void *dev_id)
         return IRQ_NONE;
 }
 
-int __init sh5pci_init(unsigned long memStart, unsigned long memSize)
+static struct resource sh5_io_resource = { /* place holder */ };
+static struct resource sh5_mem_resource = { /* place holder */ };
+
+static struct pci_channel sh5pci_controller = {
+        .pci_ops                = &sh5_pci_ops,
+        .mem_resource           = &sh5_mem_resource,
+        .mem_offset             = 0x00000000,
+        .io_resource            = &sh5_io_resource,
+        .io_offset              = 0x00000000,
+};
+
+static int __init sh5pci_init(void)
 {
+        unsigned long memStart = __pa(memory_start);
+        unsigned long memSize = __pa(memory_end) - memStart;
         u32 lsr0;
         u32 uval;
 
@@ -106,12 +119,12 @@ int __init sh5pci_init(unsigned long memStart, unsigned long memSize)
                 return -EINVAL;
         }
 
-        pcicr_virt = onchip_remap(SH5PCI_ICR_BASE, 1024, "PCICR");
+        pcicr_virt = (unsigned long)ioremap_nocache(SH5PCI_ICR_BASE, 1024);
         if (!pcicr_virt) {
                 panic("Unable to remap PCICR\n");
         }
 
-        PCI_IO_AREA = onchip_remap(SH5PCI_IO_BASE, 0x10000, "PCIIO");
+        PCI_IO_AREA = (unsigned long)ioremap_nocache(SH5PCI_IO_BASE, 0x10000);
         if (!PCI_IO_AREA) {
                 panic("Unable to remap PCIIO\n");
         }
@@ -197,32 +210,14 @@ int __init sh5pci_init(unsigned long memStart, unsigned long memSize)
         SH5PCI_WRITE(AINTM, ~0);
         SH5PCI_WRITE(PINTM, ~0);
 
-        return 0;
-}
+        sh5_io_resource.start = PCI_IO_AREA;
+        sh5_io_resource.end = PCI_IO_AREA + 0x10000;
 
-void __devinit pcibios_fixup_bus(struct pci_bus *bus)
-{
-        struct pci_dev *dev = bus->self;
-        int i;
-
-        if (dev) {
-                for (i= 0; i < 3; i++) {
-                        bus->resource[i] =
-                                &dev->resource[PCI_BRIDGE_RESOURCES+i];
-                        bus->resource[i]->name = bus->name;
-                }
-                bus->resource[0]->flags |= IORESOURCE_IO;
-                bus->resource[1]->flags |= IORESOURCE_MEM;
-
-                /* For now, propagate host limits to the bus;
-                 * we'll adjust them later. */
-                bus->resource[0]->end = 64*1024 - 1 ;
-                bus->resource[1]->end = PCIBIOS_MIN_MEM+(256*1024*1024)-1;
-                bus->resource[0]->start = PCIBIOS_MIN_IO;
-                bus->resource[1]->start = PCIBIOS_MIN_MEM;
-
-                /* Turn off downstream PF memory address range by default */
-                bus->resource[2]->start = 1024*1024;
-                bus->resource[2]->end = bus->resource[2]->start - 1;
-        }
+        sh5_mem_resource.start = memStart;
+        sh5_mem_resource.end = memStart + memSize;
+
+        register_pci_controller(&sh5pci_controller);
+
+        return 0;
 }
+arch_initcall(sh5pci_init);
diff --git a/arch/sh/drivers/pci/pci-sh5.h b/arch/sh/drivers/pci/pci-sh5.h
index 7cff3fc04d30..f277628221f3 100644
--- a/arch/sh/drivers/pci/pci-sh5.h
+++ b/arch/sh/drivers/pci/pci-sh5.h
@@ -107,7 +107,4 @@ extern unsigned long pcicr_virt;
 
 extern struct pci_ops sh5_pci_ops;
 
-/* arch/sh/drivers/pci/pci-sh5.c */
-int sh5pci_init(unsigned long memStart, unsigned long memSize);
-
 #endif /* __PCI_SH5_H */
diff --git a/arch/sh/drivers/pci/pci-sh7751.c b/arch/sh/drivers/pci/pci-sh7751.c
index 3065eb184f01..70c1999a0ec4 100644
--- a/arch/sh/drivers/pci/pci-sh7751.c
+++ b/arch/sh/drivers/pci/pci-sh7751.c
@@ -1,88 +1,100 @@
 /*
- *      Low-Level PCI Support for the SH7751
+ * Low-Level PCI Support for the SH7751
  *
- *  Dustin McIntire (dustin@sensoria.com)
- *      Derived from arch/i386/kernel/pci-*.c which bore the message:
- *      (c) 1999--2000 Martin Mares <mj@ucw.cz>
+ *  Copyright (C) 2003 - 2009  Paul Mundt
+ *  Copyright (C) 2001  Dustin McIntire
  *
- *  Ported to the new API by Paul Mundt <lethal@linux-sh.org>
- *  With cleanup by Paul van Gool <pvangool@mimotech.com>
- *
- *  May be copied or modified under the terms of the GNU General Public
- *  License.  See linux/COPYING for more information.
+ *  With cleanup by Paul van Gool <pvangool@mimotech.com>, 2003.
  *
+ * 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/init.h>
 #include <linux/pci.h>
 #include <linux/types.h>
 #include <linux/errno.h>
-#include <linux/delay.h>
+#include <linux/io.h>
 #include "pci-sh4.h"
 #include <asm/addrspace.h>
-#include <asm/io.h>
 
-/*
- * Initialization. Try all known PCI access methods. Note that we support
- * using both PCI BIOS and direct access: in such cases, we use I/O ports
- * to access config space.
- *
- * Note that the platform specific initialization (BSC registers, and memory
- * space mapping) will be called via the platform defined function
- * pcibios_init_platform().
- */
-static int __init sh7751_pci_init(void)
+static int __init __area_sdram_check(struct pci_channel *chan,
+                                     unsigned int area)
 {
-        unsigned int id;
-        int ret;
-
-        pr_debug("PCI: Starting intialization.\n");
+        unsigned long word;
 
-        /* check for SH7751/SH7751R hardware */
-        id = pci_read_reg(SH7751_PCICONF0);
-        if (id != ((SH7751_DEVICE_ID << 16) | SH7751_VENDOR_ID) &&
-            id != ((SH7751R_DEVICE_ID << 16) | SH7751_VENDOR_ID)) {
-                pr_debug("PCI: This is not an SH7751(R) (%x)\n", id);
-                return -ENODEV;
-        }
-
-        if ((ret = sh4_pci_check_direct()) != 0)
-                return ret;
-
-        return pcibios_init_platform();
-}
-subsys_initcall(sh7751_pci_init);
-
-static int __init __area_sdram_check(unsigned int area)
-{
-        u32 word;
-
-        word = ctrl_inl(SH7751_BCR1);
+        word = __raw_readl(SH7751_BCR1);
         /* check BCR for SDRAM in area */
         if (((word >> area) & 1) == 0) {
-                printk("PCI: Area %d is not configured for SDRAM. BCR1=0x%x\n",
+                printk("PCI: Area %d is not configured for SDRAM. BCR1=0x%lx\n",
                        area, word);
                 return 0;
         }
-        pci_write_reg(word, SH4_PCIBCR1);
+        pci_write_reg(chan, word, SH4_PCIBCR1);
 
-        word = (u16)ctrl_inw(SH7751_BCR2);
+        word = __raw_readw(SH7751_BCR2);
         /* check BCR2 for 32bit SDRAM interface*/
         if (((word >> (area << 1)) & 0x3) != 0x3) {
-                printk("PCI: Area %d is not 32 bit SDRAM. BCR2=0x%x\n",
+                printk("PCI: Area %d is not 32 bit SDRAM. BCR2=0x%lx\n",
                        area, word);
                 return 0;
         }
-        pci_write_reg(word, SH4_PCIBCR2);
+        pci_write_reg(chan, word, SH4_PCIBCR2);
 
         return 1;
 }
 
-int __init sh7751_pcic_init(struct sh4_pci_address_map *map)
+static struct resource sh7751_io_resource = {
+        .name   = "SH7751_IO",
+        .start  = SH7751_PCI_IO_BASE,
+        .end    = SH7751_PCI_IO_BASE + SH7751_PCI_IO_SIZE - 1,
+        .flags  = IORESOURCE_IO
+};
+
+static struct resource sh7751_mem_resource = {
+        .name   = "SH7751_mem",
+        .start  = SH7751_PCI_MEMORY_BASE,
+        .end    = SH7751_PCI_MEMORY_BASE + SH7751_PCI_MEM_SIZE - 1,
+        .flags  = IORESOURCE_MEM
+};
+
+static struct pci_channel sh7751_pci_controller = {
+        .pci_ops        = &sh4_pci_ops,
+        .mem_resource   = &sh7751_mem_resource,
+        .mem_offset     = 0x00000000,
+        .io_resource    = &sh7751_io_resource,
+        .io_offset      = 0x00000000,
+        .io_map_base    = SH7751_PCI_IO_BASE,
+};
+
+static struct sh4_pci_address_map sh7751_pci_map = {
+        .window0        = {
+                .base   = SH7751_CS3_BASE_ADDR,
+                .size   = 0x04000000,
+        },
+};
+
+static int __init sh7751_pci_init(void)
 {
-        u32 reg;
-        u32 word;
+        struct pci_channel *chan = &sh7751_pci_controller;
+        unsigned int id;
+        u32 word, reg;
+        int ret;
+
+        printk(KERN_NOTICE "PCI: Starting intialization.\n");
+
+        chan->reg_base = 0xfe200000;
+
+        /* check for SH7751/SH7751R hardware */
+        id = pci_read_reg(chan, SH7751_PCICONF0);
+        if (id != ((SH7751_DEVICE_ID << 16) | SH7751_VENDOR_ID) &&
+            id != ((SH7751R_DEVICE_ID << 16) | SH7751_VENDOR_ID)) {
+                pr_debug("PCI: This is not an SH7751(R) (%x)\n", id);
+                return -ENODEV;
+        }
+
+        if ((ret = sh4_pci_check_direct(chan)) != 0)
+                return ret;
 
         /* Set the BCR's to enable PCI access */
         reg = ctrl_inl(SH7751_BCR1);
@@ -90,25 +102,10 @@ int __init sh7751_pcic_init(struct sh4_pci_address_map *map)
         ctrl_outl(reg, SH7751_BCR1);
 
         /* Turn the clocks back on (not done in reset)*/
-        pci_write_reg(0, SH4_PCICLKR);
+        pci_write_reg(chan, 0, SH4_PCICLKR);
         /* Clear Powerdown IRQ's (not done in reset) */
         word = SH4_PCIPINT_D3 | SH4_PCIPINT_D0;
-        pci_write_reg(word, SH4_PCIPINT);
-
-        /*
-         * This code is unused for some boards as it is done in the
-         * bootloader and doing it here means the MAC addresses loaded
-         * by the bootloader get lost.
-         */
-        if (!(map->flags & SH4_PCIC_NO_RESET)) {
-                /* toggle PCI reset pin */
-                word = SH4_PCICR_PREFIX | SH4_PCICR_PRST;
-                pci_write_reg(word, SH4_PCICR);
-                /* Wait for a long time... not 1 sec. but long enough */
-                mdelay(100);
-                word = SH4_PCICR_PREFIX;
-                pci_write_reg(word, SH4_PCICR);
-        }
+        pci_write_reg(chan, word, SH4_PCIPINT);
 
         /* set the command/status bits to:
          * Wait Cycle Control + Parity Enable + Bus Master +
@@ -116,89 +113,75 @@ int __init sh7751_pcic_init(struct sh4_pci_address_map *map)
          */
         word = SH7751_PCICONF1_WCC | SH7751_PCICONF1_PER |
                SH7751_PCICONF1_BUM | SH7751_PCICONF1_MES;
-        pci_write_reg(word, SH7751_PCICONF1);
+        pci_write_reg(chan, word, SH7751_PCICONF1);
 
         /* define this host as the host bridge */
         word = PCI_BASE_CLASS_BRIDGE << 24;
-        pci_write_reg(word, SH7751_PCICONF2);
+        pci_write_reg(chan, word, SH7751_PCICONF2);
 
         /* Set IO and Mem windows to local address
          * Make PCI and local address the same for easy 1 to 1 mapping
-         * Window0 = map->window0.size @ non-cached area base = SDRAM
-         * Window1 = map->window1.size @ cached area base = SDRAM
          */
-        word = map->window0.size - 1;
-        pci_write_reg(word, SH4_PCILSR0);
-        word = map->window1.size - 1;
-        pci_write_reg(word, SH4_PCILSR1);
+        word = sh7751_pci_map.window0.size - 1;
+        pci_write_reg(chan, word, SH4_PCILSR0);
         /* Set the values on window 0 PCI config registers */
-        word = P2SEGADDR(map->window0.base);
-        pci_write_reg(word, SH4_PCILAR0);
-        pci_write_reg(word, SH7751_PCICONF5);
-        /* Set the values on window 1 PCI config registers */
-        word =  PHYSADDR(map->window1.base);
-        pci_write_reg(word, SH4_PCILAR1);
-        pci_write_reg(word, SH7751_PCICONF6);
+        word = P2SEGADDR(sh7751_pci_map.window0.base);
+        pci_write_reg(chan, word, SH4_PCILAR0);
+        pci_write_reg(chan, word, SH7751_PCICONF5);
 
         /* Set the local 16MB PCI memory space window to
          * the lowest PCI mapped address
          */
-        word = PCIBIOS_MIN_MEM & SH4_PCIMBR_MASK;
+        word = chan->mem_resource->start & SH4_PCIMBR_MASK;
         pr_debug("PCI: Setting upper bits of Memory window to 0x%x\n", word);
-        pci_write_reg(word , SH4_PCIMBR);
-
-        /* Map IO space into PCI IO window
-         * The IO window is 64K-PCIBIOS_MIN_IO in size
-         * IO addresses will be translated to the
-         * PCI IO window base address
-         */
-        pr_debug("PCI: Mapping IO address 0x%x - 0x%x to base 0x%x\n",
-                 PCIBIOS_MIN_IO, (64 << 10),
-                 SH7751_PCI_IO_BASE + PCIBIOS_MIN_IO);
+        pci_write_reg(chan, word , SH4_PCIMBR);
 
         /* Make sure the MSB's of IO window are set to access PCI space
          * correctly */
-        word = PCIBIOS_MIN_IO & SH4_PCIIOBR_MASK;
+        word = chan->io_resource->start & SH4_PCIIOBR_MASK;
         pr_debug("PCI: Setting upper bits of IO window to 0x%x\n", word);
-        pci_write_reg(word, SH4_PCIIOBR);
+        pci_write_reg(chan, word, SH4_PCIIOBR);
 
         /* Set PCI WCRx, BCRx's, copy from BSC locations */
 
         /* check BCR for SDRAM in specified area */
-        switch (map->window0.base) {
-        case SH7751_CS0_BASE_ADDR: word = __area_sdram_check(0); break;
-        case SH7751_CS1_BASE_ADDR: word = __area_sdram_check(1); break;
-        case SH7751_CS2_BASE_ADDR: word = __area_sdram_check(2); break;
-        case SH7751_CS3_BASE_ADDR: word = __area_sdram_check(3); break;
-        case SH7751_CS4_BASE_ADDR: word = __area_sdram_check(4); break;
-        case SH7751_CS5_BASE_ADDR: word = __area_sdram_check(5); break;
-        case SH7751_CS6_BASE_ADDR: word = __area_sdram_check(6); break;
+        switch (sh7751_pci_map.window0.base) {
+        case SH7751_CS0_BASE_ADDR: word = __area_sdram_check(chan, 0); break;
+        case SH7751_CS1_BASE_ADDR: word = __area_sdram_check(chan, 1); break;
+        case SH7751_CS2_BASE_ADDR: word = __area_sdram_check(chan, 2); break;
+        case SH7751_CS3_BASE_ADDR: word = __area_sdram_check(chan, 3); break;
+        case SH7751_CS4_BASE_ADDR: word = __area_sdram_check(chan, 4); break;
+        case SH7751_CS5_BASE_ADDR: word = __area_sdram_check(chan, 5); break;
+        case SH7751_CS6_BASE_ADDR: word = __area_sdram_check(chan, 6); break;
         }
 
         if (!word)
-                return 0;
+                return -1;
 
         /* configure the wait control registers */
         word = ctrl_inl(SH7751_WCR1);
-        pci_write_reg(word, SH4_PCIWCR1);
+        pci_write_reg(chan, word, SH4_PCIWCR1);
         word = ctrl_inl(SH7751_WCR2);
-        pci_write_reg(word, SH4_PCIWCR2);
+        pci_write_reg(chan, word, SH4_PCIWCR2);
         word = ctrl_inl(SH7751_WCR3);
-        pci_write_reg(word, SH4_PCIWCR3);
+        pci_write_reg(chan, word, SH4_PCIWCR3);
         word = ctrl_inl(SH7751_MCR);
-        pci_write_reg(word, SH4_PCIMCR);
+        pci_write_reg(chan, word, SH4_PCIMCR);
 
         /* NOTE: I'm ignoring the PCI error IRQs for now..
          * TODO: add support for the internal error interrupts and
          * DMA interrupts...
          */
 
-        pci_fixup_pcic();
+        pci_fixup_pcic(chan);
 
         /* SH7751 init done, set central function init complete */
         /* use round robin mode to stop a device starving/overruning */
         word = SH4_PCICR_PREFIX | SH4_PCICR_CFIN | SH4_PCICR_ARBM;
-        pci_write_reg(word, SH4_PCICR);
+        pci_write_reg(chan, word, SH4_PCICR);
 
-        return 1;
+        register_pci_controller(chan);
+
+        return 0;
 }
+arch_initcall(sh7751_pci_init);
diff --git a/arch/sh/drivers/pci/pci-sh7751.h b/arch/sh/drivers/pci/pci-sh7751.h
index 68e3cb5e6bec..4983a4d20355 100644
--- a/arch/sh/drivers/pci/pci-sh7751.h
+++ b/arch/sh/drivers/pci/pci-sh7751.h
@@ -26,7 +26,6 @@
 #define SH7751_PCI_IO_SIZE           0x40000     /* Size of IO window */
 
 #define SH7751_PCIREG_BASE           0xFE200000  /* PCI regs base address */
-#define PCI_REG(n)                  (SH7751_PCIREG_BASE+ n)
 
 #define SH7751_PCICONF0            0x0           /* PCI Config Reg 0 */
   #define SH7751_PCICONF0_DEVID      0xFFFF0000  /* Device ID */
@@ -58,7 +57,7 @@
   #define SH7751_PCICONF2_SCC        0x00FF0000  /* Sub-Class Code */
   #define SH7751_PCICONF2_RLPI       0x0000FF00  /* Programming Interface */
   #define SH7751_PCICONF2_REV        0x000000FF  /* Revision ID */
-#define SH7751_PCICONF3            0xC           /* PCI Config Reg 3 */ 
+#define SH7751_PCICONF3            0xC           /* PCI Config Reg 3 */
   #define SH7751_PCICONF3_BIST7      0x80000000  /* Bist Supported */
   #define SH7751_PCICONF3_BIST6      0x40000000  /* Bist Executing */
   #define SH7751_PCICONF3_BIST3_0    0x0F000000  /* Bist Passed */
@@ -73,12 +72,12 @@
   #define SH7751_PCICONF5_BASE       0xFFFFFFF0  /* Mem Space Base Addr */
   #define SH7751_PCICONF5_LAP        0x00000008  /* Prefetch Enabled */
   #define SH7751_PCICONF5_LAT        0x00000006  /* Local Memory type */
-  #define SH7751_PCICONF5_ASI        0x00000001  /* Address Space Type */  
+  #define SH7751_PCICONF5_ASI        0x00000001  /* Address Space Type */
 #define SH7751_PCICONF6            0x18          /* PCI Config Reg 6 */
   #define SH7751_PCICONF6_BASE       0xFFFFFFF0  /* Mem Space Base Addr */
   #define SH7751_PCICONF6_LAP        0x00000008  /* Prefetch Enabled */
   #define SH7751_PCICONF6_LAT        0x00000006  /* Local Memory type */
-  #define SH7751_PCICONF6_ASI        0x00000001  /* Address Space Type */  
+  #define SH7751_PCICONF6_ASI        0x00000001  /* Address Space Type */
 /* PCICONF7 - PCICONF10 are undefined */
 #define SH7751_PCICONF11           0x2C          /* PCI Config Reg 11 */
   #define SH7751_PCICONF11_SSID      0xFFFF0000  /* Subsystem ID */
@@ -127,9 +126,4 @@
 #define SH7751_CS5_BASE_ADDR       (SH7751_CS4_BASE_ADDR + SH7751_MEM_REGION_SIZE)
 #define SH7751_CS6_BASE_ADDR       (SH7751_CS5_BASE_ADDR + SH7751_MEM_REGION_SIZE)
 
-struct sh4_pci_address_map;
-
-/* arch/sh/drivers/pci/pci-sh7751.c */
-int sh7751_pcic_init(struct sh4_pci_address_map *map);
-
 #endif /* _PCI_SH7751_H_ */
diff --git a/arch/sh/drivers/pci/pci-sh7780.c b/arch/sh/drivers/pci/pci-sh7780.c
index bae6a2cf047d..323b92d565fe 100644
--- a/arch/sh/drivers/pci/pci-sh7780.c
+++ b/arch/sh/drivers/pci/pci-sh7780.c
@@ -1,19 +1,12 @@
 /*
- *      Low-Level PCI Support for the SH7780
+ * Low-Level PCI Support for the SH7780
  *
- *  Dustin McIntire (dustin@sensoria.com)
- *      Derived from arch/i386/kernel/pci-*.c which bore the message:
- *      (c) 1999--2000 Martin Mares <mj@ucw.cz>
- *
- *  Ported to the new API by Paul Mundt <lethal@linux-sh.org>
- *  With cleanup by Paul van Gool <pvangool@mimotech.com>
- *
- *  May be copied or modified under the terms of the GNU General Public
- *  License.  See linux/COPYING for more information.
+ *  Copyright (C) 2005 - 2009  Paul Mundt
  *
+ * 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/types.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -22,135 +15,132 @@
 #include <linux/delay.h>
 #include "pci-sh4.h"
 
-#define INTC_BASE       0xffd00000
-#define INTC_ICR0       (INTC_BASE+0x0)
-#define INTC_ICR1       (INTC_BASE+0x1c)
-#define INTC_INTPRI     (INTC_BASE+0x10)
-#define INTC_INTREQ     (INTC_BASE+0x24)
-#define INTC_INTMSK0    (INTC_BASE+0x44)
-#define INTC_INTMSK1    (INTC_BASE+0x48)
-#define INTC_INTMSK2    (INTC_BASE+0x40080)
-#define INTC_INTMSKCLR0 (INTC_BASE+0x64)
-#define INTC_INTMSKCLR1 (INTC_BASE+0x68)
-#define INTC_INTMSKCLR2 (INTC_BASE+0x40084)
-#define INTC_INT2MSKR   (INTC_BASE+0x40038)
-#define INTC_INT2MSKCR  (INTC_BASE+0x4003c)
+static struct resource sh7785_io_resource = {
+        .name   = "SH7785_IO",
+        .start  = SH7780_PCI_IO_BASE,
+        .end    = SH7780_PCI_IO_BASE + SH7780_PCI_IO_SIZE - 1,
+        .flags  = IORESOURCE_IO
+};
+
+static struct resource sh7785_mem_resource = {
+        .name   = "SH7785_mem",
+        .start  = SH7780_PCI_MEMORY_BASE,
+        .end    = SH7780_PCI_MEMORY_BASE + SH7780_PCI_MEM_SIZE - 1,
+        .flags  = IORESOURCE_MEM
+};
+
+static struct pci_channel sh7780_pci_controller = {
+        .pci_ops        = &sh4_pci_ops,
+        .mem_resource   = &sh7785_mem_resource,
+        .mem_offset     = 0x00000000,
+        .io_resource    = &sh7785_io_resource,
+        .io_offset      = 0x00000000,
+        .io_map_base    = SH7780_PCI_IO_BASE,
+};
+
+static struct sh4_pci_address_map sh7780_pci_map = {
+        .window0        = {
+#if defined(CONFIG_32BIT)
+                .base   = SH7780_32BIT_DDR_BASE_ADDR,
+                .size   = 0x40000000,
+#else
+                .base   = SH7780_CS0_BASE_ADDR,
+                .size   = 0x20000000,
+#endif
+        },
+};
 
-/*
- * Initialization. Try all known PCI access methods. Note that we support
- * using both PCI BIOS and direct access: in such cases, we use I/O ports
- * to access config space.
- *
- * Note that the platform specific initialization (BSC registers, and memory
- * space mapping) will be called via the platform defined function
- * pcibios_init_platform().
- */
 static int __init sh7780_pci_init(void)
 {
+        struct pci_channel *chan = &sh7780_pci_controller;
         unsigned int id;
-        int ret, match = 0;
-
-        pr_debug("PCI: Starting intialization.\n");
-
-        ctrl_outl(0x00000001, SH7780_PCI_VCR2); /* Enable PCIC */
-
-        /* check for SH7780/SH7780R hardware */
-        id = pci_read_reg(SH7780_PCIVID);
-        if ((id & 0xffff) == SH7780_VENDOR_ID) {
-                switch ((id >> 16) & 0xffff) {
-                case SH7763_DEVICE_ID:
-                case SH7780_DEVICE_ID:
-                case SH7781_DEVICE_ID:
-                case SH7785_DEVICE_ID:
-                        match = 1;
-                        break;
-                }
-        }
+        const char *type = NULL;
+        int ret;
+        u32 word;
 
-        if (unlikely(!match)) {
-                printk(KERN_ERR "PCI: This is not an SH7780 (%x)\n", id);
+        printk(KERN_NOTICE "PCI: Starting intialization.\n");
+
+        chan->reg_base = 0xfe040000;
+
+        /* Enable CPU access to the PCIC registers. */
+        __raw_writel(PCIECR_ENBL, PCIECR);
+
+        id = __raw_readw(chan->reg_base + SH7780_PCIVID);
+        if (id != SH7780_VENDOR_ID) {
+                printk(KERN_ERR "PCI: Unknown vendor ID 0x%04x.\n", id);
                 return -ENODEV;
         }
 
-        /* Setup the INTC */
-        if (mach_is_7780se()) {
-                /* ICR0: IRL=use separately */
-                ctrl_outl(0x00C00020, INTC_ICR0);
-                /* ICR1: detect low level(for 2ndcut) */
-                ctrl_outl(0xAAAA0000, INTC_ICR1);
-                /* INTPRI: priority=3(all) */
-                ctrl_outl(0x33333333, INTC_INTPRI);
+        id = __raw_readw(chan->reg_base + SH7780_PCIDID);
+        type = (id == SH7763_DEVICE_ID) ? "SH7763" :
+               (id == SH7780_DEVICE_ID) ? "SH7780" :
+               (id == SH7781_DEVICE_ID) ? "SH7781" :
+               (id == SH7785_DEVICE_ID) ? "SH7785" :
+                                          NULL;
+        if (unlikely(!type)) {
+                printk(KERN_ERR "PCI: Found an unsupported Renesas host "
+                       "controller, device id 0x%04x.\n", id);
+                return -EINVAL;
         }
 
-        if ((ret = sh4_pci_check_direct()) != 0)
-                return ret;
+        printk(KERN_NOTICE "PCI: Found a Renesas %s host "
+               "controller, revision %d.\n", type,
+               __raw_readb(chan->reg_base + SH7780_PCIRID));
 
-        return pcibios_init_platform();
-}
-core_initcall(sh7780_pci_init);
-
-int __init sh7780_pcic_init(struct sh4_pci_address_map *map)
-{
-        u32 word;
+        if ((ret = sh4_pci_check_direct(chan)) != 0)
+                return ret;
 
         /*
-         * This code is unused for some boards as it is done in the
-         * bootloader and doing it here means the MAC addresses loaded
-         * by the bootloader get lost.
-         */
-        if (!(map->flags & SH4_PCIC_NO_RESET)) {
-                /* toggle PCI reset pin */
-                word = SH4_PCICR_PREFIX | SH4_PCICR_PRST;
-                pci_write_reg(word, SH4_PCICR);
-                /* Wait for a long time... not 1 sec. but long enough */
-                mdelay(100);
-                word = SH4_PCICR_PREFIX;
-                pci_write_reg(word, SH4_PCICR);
-        }
-
-        /* set the command/status bits to:
-         * Wait Cycle Control + Parity Enable + Bus Master +
-         * Mem space enable
+         * Set the class and sub-class codes.
          */
-        pci_write_reg(0x00000046, SH7780_PCICMD);
-
-        /* define this host as the host bridge */
-        word = PCI_BASE_CLASS_BRIDGE << 24;
-        pci_write_reg(word, SH7780_PCIRID);
+        __raw_writeb(PCI_CLASS_BRIDGE_HOST >> 8,
+                     chan->reg_base + SH7780_PCIBCC);
+        __raw_writeb(PCI_CLASS_BRIDGE_HOST & 0xff,
+                     chan->reg_base + SH7780_PCISUB);
 
-        /* Set IO and Mem windows to local address
+        /*
+         * Set IO and Mem windows to local address
          * Make PCI and local address the same for easy 1 to 1 mapping
          */
-        pci_write_reg(map->window0.size - 0xfffff, SH4_PCILSR0);
-        pci_write_reg(map->window1.size - 0xfffff, SH4_PCILSR1);
+        pci_write_reg(chan, sh7780_pci_map.window0.size - 0xfffff, SH4_PCILSR0);
         /* Set the values on window 0 PCI config registers */
-        pci_write_reg(map->window0.base, SH4_PCILAR0);
-        pci_write_reg(map->window0.base, SH7780_PCIMBAR0);
-        /* Set the values on window 1 PCI config registers */
-        pci_write_reg(map->window1.base, SH4_PCILAR1);
-        pci_write_reg(map->window1.base, SH7780_PCIMBAR1);
-
-        /* Map IO space into PCI IO window
-         * The IO window is 64K-PCIBIOS_MIN_IO in size
-         * IO addresses will be translated to the
-         * PCI IO window base address
-         */
-        pr_debug("PCI: Mapping IO address 0x%x - 0x%x to base 0x%x\n",
-                 PCIBIOS_MIN_IO, (64 << 10),
-                 SH7780_PCI_IO_BASE + PCIBIOS_MIN_IO);
+        pci_write_reg(chan, sh7780_pci_map.window0.base, SH4_PCILAR0);
+        pci_write_reg(chan, sh7780_pci_map.window0.base, SH7780_PCIMBAR0);
 
-        /* NOTE: I'm ignoring the PCI error IRQs for now..
-         * TODO: add support for the internal error interrupts and
-         * DMA interrupts...
-         */
+        pci_write_reg(chan, 0x0000380f, SH4_PCIAINTM);
+
+        /* Set up standard PCI config registers */
+        __raw_writew(0xFB00, chan->reg_base + SH7780_PCISTATUS);
+        __raw_writew(0x0047, chan->reg_base + SH7780_PCICMD);
+        __raw_writew(0x1912, chan->reg_base + SH7780_PCISVID);
+        __raw_writew(0x0001, chan->reg_base + SH7780_PCISID);
+
+        __raw_writeb(0x00, chan->reg_base + SH7780_PCIPIF);
 
         /* Apply any last-minute PCIC fixups */
-        pci_fixup_pcic();
+        pci_fixup_pcic(chan);
+
+        pci_write_reg(chan, 0xfd000000, SH7780_PCIMBR0);
+        pci_write_reg(chan, 0x00fc0000, SH7780_PCIMBMR0);
+
+#ifdef CONFIG_32BIT
+        pci_write_reg(chan, 0xc0000000, SH7780_PCIMBR2);
+        pci_write_reg(chan, 0x20000000 - SH7780_PCI_IO_SIZE, SH7780_PCIMBMR2);
+#endif
+
+        /* Set IOBR for windows containing area specified in pci.h */
+        pci_write_reg(chan, chan->io_resource->start & ~(SH7780_PCI_IO_SIZE-1),
+                      SH7780_PCIIOBR);
+        pci_write_reg(chan, ((SH7780_PCI_IO_SIZE-1) & (7<<18)),
+                      SH7780_PCIIOBMR);
 
         /* SH7780 init done, set central function init complete */
         /* use round robin mode to stop a device starving/overruning */
         word = SH4_PCICR_PREFIX | SH4_PCICR_CFIN | SH4_PCICR_FTO;
-        pci_write_reg(word, SH4_PCICR);
+        pci_write_reg(chan, word, SH4_PCICR);
+
+        register_pci_controller(chan);
 
-        return 1;
+        return 0;
 }
+arch_initcall(sh7780_pci_init);
diff --git a/arch/sh/drivers/pci/pci-sh7780.h b/arch/sh/drivers/pci/pci-sh7780.h
index 93adc7119b79..4a52478c97cf 100644
--- a/arch/sh/drivers/pci/pci-sh7780.h
+++ b/arch/sh/drivers/pci/pci-sh7780.h
@@ -20,9 +20,8 @@
 #define SH7785_DEVICE_ID        0x0007
 
 /* SH7780 Control Registers */
-#define SH7780_PCI_VCR0         0xFE000000
-#define SH7780_PCI_VCR1         0xFE000004
-#define SH7780_PCI_VCR2         0xFE000008
+#define PCIECR                  0xFE000008
+#define PCIECR_ENBL             0x01
 
 /* SH7780 Specific Values */
 #define SH7780_PCI_CONFIG_BASE  0xFD000000      /* Config space base addr */
@@ -35,7 +34,6 @@
 #define SH7780_PCI_IO_SIZE      0x00400000      /* Size of IO window */
 
 #define SH7780_PCIREG_BASE      0xFE040000      /* PCI regs base address */
-#define PCI_REG(n)              (SH7780_PCIREG_BASE+n)
 
 /* SH7780 PCI Config Registers */
 #define SH7780_PCIVID           0x000           /* Vendor ID */
@@ -67,11 +65,6 @@
 #define SH7780_PCIPMCSR_BSE     0x046
 #define SH7780_PCICDD           0x047
 
-#define SH7780_PCICR            0x100           /* PCI Control Register */
-#define SH7780_PCILSR           0x104           /* PCI Local Space Register0 */
-#define SH7780_PCILSR1          0x108           /* PCI Local Space Register1 */
-#define SH7780_PCILAR0          0x10C           /* PCI Local Address Register1 */
-#define SH7780_PCILAR1          0x110           /* PCI Local Address Register1 */
 #define SH7780_PCIIR            0x114           /* PCI Interrupt Register */
 #define SH7780_PCIIMR           0x118           /* PCI Interrupt Mask Register */
 #define SH7780_PCIAIR           0x11C           /* Error Address Register */
@@ -106,9 +99,4 @@
 
 #define SH7780_32BIT_DDR_BASE_ADDR      0x40000000
 
-struct sh4_pci_address_map;
-
-/* arch/sh/drivers/pci/pci-sh7780.c */
-int sh7780_pcic_init(struct sh4_pci_address_map *map);
-
 #endif /* _PCI_SH7780_H_ */
diff --git a/arch/sh/drivers/pci/pci.c b/arch/sh/drivers/pci/pci.c
index 0d6ac7a1db49..54d77cbb8b39 100644
--- a/arch/sh/drivers/pci/pci.c
+++ b/arch/sh/drivers/pci/pci.c
@@ -1,67 +1,156 @@
 /*
- * arch/sh/drivers/pci/pci.c
+ * New-style PCI core.
  *
- * Copyright (c) 2002 M. R. Brown  <mrbrown@linux-sh.org>
- * Copyright (c) 2004 - 2006 Paul Mundt  <lethal@linux-sh.org>
+ * Copyright (c) 2004 - 2009  Paul Mundt
+ * Copyright (c) 2002  M. R. Brown
  *
- * These functions are collected here to reduce duplication of common
- * code amongst the many platform-specific PCI support code files.
- *
- * These routines require the following board-specific routines:
- * void pcibios_fixup_irqs();
- *
- * See include/asm-sh/pci.h for more information.
+ * Modelled after arch/mips/pci/pci.c:
+ *  Copyright (C) 2003, 04 Ralf Baechle (ralf@linux-mips.org)
  *
  * 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.
  */
 #include <linux/kernel.h>
+#include <linux/mm.h>
 #include <linux/pci.h>
 #include <linux/init.h>
+#include <linux/types.h>
 #include <linux/dma-debug.h>
-#include <asm/io.h>
+#include <linux/io.h>
+#include <linux/mutex.h>
 
-static int __init pcibios_init(void)
+unsigned long PCIBIOS_MIN_IO = 0x0000;
+unsigned long PCIBIOS_MIN_MEM = 0;
+
+/*
+ * The PCI controller list.
+ */
+static struct pci_channel *hose_head, **hose_tail = &hose_head;
+
+static int pci_initialized;
+
+static void __devinit pcibios_scanbus(struct pci_channel *hose)
 {
-        struct pci_channel *p;
+        static int next_busno;
         struct pci_bus *bus;
-        int busno;
 
-#ifdef CONFIG_PCI_AUTO
-        /* assign resources */
-        busno = 0;
-        for (p = board_pci_channels; p->pci_ops != NULL; p++)
-                busno = pciauto_assign_resources(busno, p) + 1;
-#endif
+        bus = pci_scan_bus(next_busno, hose->pci_ops, hose);
+        if (bus) {
+                next_busno = bus->subordinate + 1;
+                /* Don't allow 8-bit bus number overflow inside the hose -
+                   reserve some space for bridges. */
+                if (next_busno > 224)
+                        next_busno = 0;
+
+                pci_bus_size_bridges(bus);
+                pci_bus_assign_resources(bus);
+                pci_enable_bridges(bus);
+        }
+}
+
+static DEFINE_MUTEX(pci_scan_mutex);
 
-        /* scan the buses */
-        busno = 0;
-        for (p = board_pci_channels; p->pci_ops != NULL; p++) {
-                bus = pci_scan_bus(busno, p->pci_ops, p);
-                busno = bus->subordinate + 1;
+void __devinit register_pci_controller(struct pci_channel *hose)
+{
+        if (request_resource(&iomem_resource, hose->mem_resource) < 0)
+                goto out;
+        if (request_resource(&ioport_resource, hose->io_resource) < 0) {
+                release_resource(hose->mem_resource);
+                goto out;
         }
 
+        *hose_tail = hose;
+        hose_tail = &hose->next;
+
+        /*
+         * Do not panic here but later - this might hapen before console init.
+         */
+        if (!hose->io_map_base) {
+                printk(KERN_WARNING
+                       "registering PCI controller with io_map_base unset\n");
+        }
+
+        /*
+         * Scan the bus if it is register after the PCI subsystem
+         * initialization.
+         */
+        if (pci_initialized) {
+                mutex_lock(&pci_scan_mutex);
+                pcibios_scanbus(hose);
+                mutex_unlock(&pci_scan_mutex);
+        }
+
+        return;
+
+out:
+        printk(KERN_WARNING
+               "Skipping PCI bus scan due to resource conflict\n");
+}
+
+static int __init pcibios_init(void)
+{
+        struct pci_channel *hose;
+
+        /* Scan all of the recorded PCI controllers.  */
+        for (hose = hose_head; hose; hose = hose->next)
+                pcibios_scanbus(hose);
+
         pci_fixup_irqs(pci_common_swizzle, pcibios_map_platform_irq);
 
         dma_debug_add_bus(&pci_bus_type);
 
+        pci_initialized = 1;
+
         return 0;
 }
 subsys_initcall(pcibios_init);
 
+static void pcibios_fixup_device_resources(struct pci_dev *dev,
+        struct pci_bus *bus)
+{
+        /* Update device resources.  */
+        struct pci_channel *hose = bus->sysdata;
+        unsigned long offset = 0;
+        int i;
+
+        for (i = 0; i < PCI_NUM_RESOURCES; i++) {
+                if (!dev->resource[i].start)
+                        continue;
+                if (dev->resource[i].flags & IORESOURCE_PCI_FIXED)
+                        continue;
+                if (dev->resource[i].flags & IORESOURCE_IO)
+                        offset = hose->io_offset;
+                else if (dev->resource[i].flags & IORESOURCE_MEM)
+                        offset = hose->mem_offset;
+
+                dev->resource[i].start += offset;
+                dev->resource[i].end += offset;
+        }
+}
+
 /*
  *  Called after each bus is probed, but before its children
  *  are examined.
  */
-void __devinit __weak pcibios_fixup_bus(struct pci_bus *bus)
+void __devinit pcibios_fixup_bus(struct pci_bus *bus)
 {
-        pci_read_bridge_bases(bus);
-}
+        struct pci_dev *dev = bus->self;
+        struct list_head *ln;
+        struct pci_channel *chan = bus->sysdata;
 
-void pcibios_align_resource(void *data, struct resource *res,
-                            resource_size_t size, resource_size_t align)
-                            __attribute__ ((weak));
+        if (!dev) {
+                bus->resource[0] = chan->io_resource;
+                bus->resource[1] = chan->mem_resource;
+        }
+
+        for (ln = bus->devices.next; ln != &bus->devices; ln = ln->next) {
+                dev = pci_dev_b(ln);
+
+                if ((dev->class >> 8) != PCI_CLASS_BRIDGE_PCI)
+                        pcibios_fixup_device_resources(dev, bus);
+        }
+}
 
 /*
  * We need to avoid collisions with `mirrored' VGA ports
@@ -72,14 +161,58 @@ void pcibios_align_resource(void *data, struct resource *res,
 void pcibios_align_resource(void *data, struct resource *res,
                             resource_size_t size, resource_size_t align)
 {
+        struct pci_dev *dev = data;
+        struct pci_channel *chan = dev->sysdata;
+        resource_size_t start = res->start;
+
         if (res->flags & IORESOURCE_IO) {
-                resource_size_t start = res->start;
+                if (start < PCIBIOS_MIN_IO + chan->io_resource->start)
+                        start = PCIBIOS_MIN_IO + chan->io_resource->start;
 
+                /*
+                 * Put everything into 0x00-0xff region modulo 0x400.
+                 */
                 if (start & 0x300) {
                         start = (start + 0x3ff) & ~0x3ff;
                         res->start = start;
                 }
+        } else if (res->flags & IORESOURCE_MEM) {
+                if (start < PCIBIOS_MIN_MEM + chan->mem_resource->start)
+                        start = PCIBIOS_MIN_MEM + chan->mem_resource->start;
         }
+
+        res->start = start;
+}
+
+void pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region,
+                         struct resource *res)
+{
+        struct pci_channel *hose = dev->sysdata;
+        unsigned long offset = 0;
+
+        if (res->flags & IORESOURCE_IO)
+                offset = hose->io_offset;
+        else if (res->flags & IORESOURCE_MEM)
+                offset = hose->mem_offset;
+
+        region->start = res->start - offset;
+        region->end = res->end - offset;
+}
+
+void __devinit
+pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
+                        struct pci_bus_region *region)
+{
+        struct pci_channel *hose = dev->sysdata;
+        unsigned long offset = 0;
+
+        if (res->flags & IORESOURCE_IO)
+                offset = hose->io_offset;
+        else if (res->flags & IORESOURCE_MEM)
+                offset = hose->mem_offset;
+
+        res->start = region->start + offset;
+        res->end = region->end + offset;
 }
 
 int pcibios_enable_device(struct pci_dev *dev, int mask)
@@ -90,13 +223,21 @@ int pcibios_enable_device(struct pci_dev *dev, int mask)
 
         pci_read_config_word(dev, PCI_COMMAND, &cmd);
         old_cmd = cmd;
-        for(idx=0; idx<6; idx++) {
-                if (!(mask & (1 << idx)))
+        for (idx=0; idx < PCI_NUM_RESOURCES; idx++) {
+                /* Only set up the requested stuff */
+                if (!(mask & (1<<idx)))
                         continue;
+
                 r = &dev->resource[idx];
+                if (!(r->flags & (IORESOURCE_IO | IORESOURCE_MEM)))
+                        continue;
+                if ((idx == PCI_ROM_RESOURCE) &&
+                                (!(r->flags & IORESOURCE_ROM_ENABLE)))
+                        continue;
                 if (!r->start && r->end) {
-                        printk(KERN_ERR "PCI: Device %s not available because "
-                               "of resource collisions\n", pci_name(dev));
+                        printk(KERN_ERR "PCI: Device %s not available "
+                               "because of resource collisions\n",
+                               pci_name(dev));
                         return -EINVAL;
                 }
                 if (r->flags & IORESOURCE_IO)
@@ -104,10 +245,8 @@ int pcibios_enable_device(struct pci_dev *dev, int mask)
                 if (r->flags & IORESOURCE_MEM)
                         cmd |= PCI_COMMAND_MEMORY;
         }
-        if (dev->resource[PCI_ROM_RESOURCE].start)
-                cmd |= PCI_COMMAND_MEMORY;
         if (cmd != old_cmd) {
-                printk(KERN_INFO "PCI: Enabling device %s (%04x -> %04x)\n",
+                printk("PCI: Enabling device %s (%04x -> %04x)\n",
                        pci_name(dev), old_cmd, cmd);
                 pci_write_config_word(dev, PCI_COMMAND, cmd);
         }
@@ -140,6 +279,43 @@ void __init pcibios_update_irq(struct pci_dev *dev, int irq)
         pci_write_config_byte(dev, PCI_INTERRUPT_LINE, irq);
 }
 
+char * __devinit pcibios_setup(char *str)
+{
+        return str;
+}
+
+int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
+                        enum pci_mmap_state mmap_state, int write_combine)
+{
+        /*
+         * I/O space can be accessed via normal processor loads and stores on
+         * this platform but for now we elect not to do this and portable
+         * drivers should not do this anyway.
+         */
+        if (mmap_state == pci_mmap_io)
+                return -EINVAL;
+
+        /*
+         * Ignore write-combine; for now only return uncached mappings.
+         */
+        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
+
+        return remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
+                               vma->vm_end - vma->vm_start,
+                               vma->vm_page_prot);
+}
+
+static void __iomem *ioport_map_pci(struct pci_dev *dev,
+                                    unsigned long port, unsigned int nr)
+{
+        struct pci_channel *chan = dev->sysdata;
+
+        if (!chan->io_map_base)
+                chan->io_map_base = generic_io_base;
+
+        return (void __iomem *)(chan->io_map_base + port);
+}
+
 void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen)
 {
         resource_size_t start = pci_resource_start(dev, bar);
@@ -151,20 +327,24 @@ void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen)
         if (maxlen && len > maxlen)
                 len = maxlen;
 
+        if (flags & IORESOURCE_IO)
+                return ioport_map_pci(dev, start, len);
+
         /*
          * Presently the IORESOURCE_MEM case is a bit special, most
          * SH7751 style PCI controllers have PCI memory at a fixed
-         * location in the address space where no remapping is desired
-         * (typically at 0xfd000000, but is_pci_memaddr() will know
-         * best). With the IORESOURCE_MEM case more care has to be taken
+         * location in the address space where no remapping is desired.
+         * With the IORESOURCE_MEM case more care has to be taken
          * to inhibit page table mapping for legacy cores, but this is
          * punted off to __ioremap().
          *                                      -- PFM.
          */
-        if (flags & IORESOURCE_IO)
-                return ioport_map(start, len);
-        if (flags & IORESOURCE_MEM)
-                return ioremap(start, len);
+        if (flags & IORESOURCE_MEM) {
+                if (flags & IORESOURCE_CACHEABLE)
+                        return ioremap(start, len);
+
+                return ioremap_nocache(start, len);
+        }
 
         return NULL;
 }
@@ -175,3 +355,10 @@ void pci_iounmap(struct pci_dev *dev, void __iomem *addr)
         iounmap(addr);
 }
 EXPORT_SYMBOL(pci_iounmap);
+
+#ifdef CONFIG_HOTPLUG
+EXPORT_SYMBOL(pcibios_resource_to_bus);
+EXPORT_SYMBOL(pcibios_bus_to_resource);
+EXPORT_SYMBOL(PCIBIOS_MIN_IO);
+EXPORT_SYMBOL(PCIBIOS_MIN_MEM);
+#endif
diff --git a/arch/sh/include/asm/atomic-llsc.h b/arch/sh/include/asm/atomic-llsc.h
index 4b00b78e3f4f..b040e1e08610 100644
--- a/arch/sh/include/asm/atomic-llsc.h
+++ b/arch/sh/include/asm/atomic-llsc.h
@@ -104,4 +104,31 @@ static inline void atomic_set_mask(unsigned int mask, atomic_t *v)
         : "t");
 }
 
+#define atomic_cmpxchg(v, o, n) (cmpxchg(&((v)->counter), (o), (n)))
+
+/**
+ * atomic_add_unless - add unless the number is a given value
+ * @v: pointer of type atomic_t
+ * @a: the amount to add to v...
+ * @u: ...unless v is equal to u.
+ *
+ * Atomically adds @a to @v, so long as it was not @u.
+ * Returns non-zero if @v was not @u, and zero otherwise.
+ */
+static inline int atomic_add_unless(atomic_t *v, int a, int u)
+{
+        int c, old;
+        c = atomic_read(v);
+        for (;;) {
+                if (unlikely(c == (u)))
+                        break;
+                old = atomic_cmpxchg((v), c, c + (a));
+                if (likely(old == c))
+                        break;
+                c = old;
+        }
+
+        return c != (u);
+}
+
 #endif /* __ASM_SH_ATOMIC_LLSC_H */
diff --git a/arch/sh/include/asm/atomic.h b/arch/sh/include/asm/atomic.h
index 6327ffbb1992..978b58efb1e9 100644
--- a/arch/sh/include/asm/atomic.h
+++ b/arch/sh/include/asm/atomic.h
@@ -45,7 +45,7 @@
 #define atomic_inc(v) atomic_add(1,(v))
 #define atomic_dec(v) atomic_sub(1,(v))
 
-#ifndef CONFIG_GUSA_RB
+#if !defined(CONFIG_GUSA_RB) && !defined(CONFIG_CPU_SH4A)
 static inline int atomic_cmpxchg(atomic_t *v, int old, int new)
 {
         int ret;
@@ -73,7 +73,7 @@ static inline int atomic_add_unless(atomic_t *v, int a, int u)
 
         return ret != u;
 }
-#endif
+#endif /* !CONFIG_GUSA_RB && !CONFIG_CPU_SH4A */
 
 #define atomic_xchg(v, new) (xchg(&((v)->counter), new))
 #define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)
diff --git a/arch/sh/include/asm/cacheflush.h b/arch/sh/include/asm/cacheflush.h
index 09acbc32d6c7..4c5462daa74c 100644
--- a/arch/sh/include/asm/cacheflush.h
+++ b/arch/sh/include/asm/cacheflush.h
@@ -75,7 +75,5 @@ extern void copy_from_user_page(struct vm_area_struct *vma,
 #define flush_cache_vmap(start, end)            flush_cache_all()
 #define flush_cache_vunmap(start, end)          flush_cache_all()
 
-#define HAVE_ARCH_UNMAPPED_AREA
-
 #endif /* __KERNEL__ */
 #endif /* __ASM_SH_CACHEFLUSH_H */
diff --git a/arch/sh/include/asm/clock.h b/arch/sh/include/asm/clock.h
index 2f6c9627bc1f..9fe7d7f8af40 100644
--- a/arch/sh/include/asm/clock.h
+++ b/arch/sh/include/asm/clock.h
@@ -1,9 +1,9 @@
 #ifndef __ASM_SH_CLOCK_H
 #define __ASM_SH_CLOCK_H
 
-#include <linux/kref.h>
 #include <linux/list.h>
 #include <linux/seq_file.h>
+#include <linux/cpufreq.h>
 #include <linux/clk.h>
 #include <linux/err.h>
 
@@ -11,9 +11,9 @@ struct clk;
 
 struct clk_ops {
         void (*init)(struct clk *clk);
-        void (*enable)(struct clk *clk);
+        int (*enable)(struct clk *clk);
         void (*disable)(struct clk *clk);
-        void (*recalc)(struct clk *clk);
+        unsigned long (*recalc)(struct clk *clk);
         int (*set_rate)(struct clk *clk, unsigned long rate, int algo_id);
         int (*set_parent)(struct clk *clk, struct clk *parent);
         long (*round_rate)(struct clk *clk, unsigned long rate);
@@ -28,43 +28,47 @@ struct clk {
         struct clk              *parent;
         struct clk_ops          *ops;
 
-        struct kref             kref;
+        struct list_head        children;
+        struct list_head        sibling;        /* node for children */
+
+        int                     usecount;
 
         unsigned long           rate;
         unsigned long           flags;
+
+        void __iomem            *enable_reg;
+        unsigned int            enable_bit;
+
         unsigned long           arch_flags;
+        void                    *priv;
+        struct dentry           *dentry;
+        struct cpufreq_frequency_table *freq_table;
+};
+
+struct clk_lookup {
+        struct list_head        node;
+        const char              *dev_id;
+        const char              *con_id;
+        struct clk              *clk;
 };
 
-#define CLK_ALWAYS_ENABLED      (1 << 0)
-#define CLK_RATE_PROPAGATES     (1 << 1)
+#define CLK_ENABLE_ON_INIT      (1 << 0)
 
 /* Should be defined by processor-specific code */
-void arch_init_clk_ops(struct clk_ops **, int type);
+void __deprecated arch_init_clk_ops(struct clk_ops **, int type);
 int __init arch_clk_init(void);
 
 /* arch/sh/kernel/cpu/clock.c */
 int clk_init(void);
-
-void clk_recalc_rate(struct clk *);
-
+unsigned long followparent_recalc(struct clk *);
+void recalculate_root_clocks(void);
+void propagate_rate(struct clk *);
+int clk_reparent(struct clk *child, struct clk *parent);
 int clk_register(struct clk *);
 void clk_unregister(struct clk *);
 
-static inline int clk_always_enable(const char *id)
-{
-        struct clk *clk;
-        int ret;
-
-        clk = clk_get(NULL, id);
-        if (IS_ERR(clk))
-                return PTR_ERR(clk);
-
-        ret = clk_enable(clk);
-        if (ret)
-                clk_put(clk);
-
-        return ret;
-}
+/* arch/sh/kernel/cpu/clock-cpg.c */
+int __init __deprecated cpg_clk_init(void);
 
 /* the exported API, in addition to clk_set_rate */
 /**
@@ -96,4 +100,63 @@ enum clk_sh_algo_id {
 
         IP_N1,
 };
+
+struct clk_div_mult_table {
+        unsigned int *divisors;
+        unsigned int nr_divisors;
+        unsigned int *multipliers;
+        unsigned int nr_multipliers;
+};
+
+struct cpufreq_frequency_table;
+void clk_rate_table_build(struct clk *clk,
+                          struct cpufreq_frequency_table *freq_table,
+                          int nr_freqs,
+                          struct clk_div_mult_table *src_table,
+                          unsigned long *bitmap);
+
+long clk_rate_table_round(struct clk *clk,
+                          struct cpufreq_frequency_table *freq_table,
+                          unsigned long rate);
+
+int clk_rate_table_find(struct clk *clk,
+                        struct cpufreq_frequency_table *freq_table,
+                        unsigned long rate);
+
+#define SH_CLK_MSTP32(_name, _id, _parent, _enable_reg, \
+            _enable_bit, _flags)                        \
+{                                                       \
+        .name           = _name,                        \
+        .id             = _id,                          \
+        .parent         = _parent,                      \
+        .enable_reg     = (void __iomem *)_enable_reg,  \
+        .enable_bit     = _enable_bit,                  \
+        .flags          = _flags,                       \
+}
+
+int sh_clk_mstp32_register(struct clk *clks, int nr);
+
+#define SH_CLK_DIV4(_name, _parent, _reg, _shift, _div_bitmap, _flags)  \
+{                                                                       \
+        .name = _name,                                                  \
+        .parent = _parent,                                              \
+        .enable_reg = (void __iomem *)_reg,                             \
+        .enable_bit = _shift,                                           \
+        .arch_flags = _div_bitmap,                                      \
+        .flags = _flags,                                                \
+}
+
+int sh_clk_div4_register(struct clk *clks, int nr,
+                         struct clk_div_mult_table *table);
+
+#define SH_CLK_DIV6(_name, _parent, _reg, _flags)       \
+{                                                       \
+        .name = _name,                                  \
+        .parent = _parent,                              \
+        .enable_reg = (void __iomem *)_reg,             \
+        .flags = _flags,                                \
+}
+
+int sh_clk_div6_register(struct clk *clks, int nr);
+
 #endif /* __ASM_SH_CLOCK_H */
diff --git a/arch/sh/include/asm/cmpxchg-llsc.h b/arch/sh/include/asm/cmpxchg-llsc.h
index 0fac3da536ca..47136661a203 100644
--- a/arch/sh/include/asm/cmpxchg-llsc.h
+++ b/arch/sh/include/asm/cmpxchg-llsc.h
@@ -55,7 +55,7 @@ __cmpxchg_u32(volatile int *m, unsigned long old, unsigned long new)
                 "mov            %0, %1                          \n\t"
                 "cmp/eq         %1, %3                          \n\t"
                 "bf             2f                              \n\t"
-                "mov            %3, %0                          \n\t"
+                "mov            %4, %0                          \n\t"
                 "2:                                             \n\t"
                 "movco.l        %0, @%2                         \n\t"
                 "bf             1b                              \n\t"
diff --git a/arch/sh/include/asm/device.h b/arch/sh/include/asm/device.h
index efd511d0803a..8688a88303ee 100644
--- a/arch/sh/include/asm/device.h
+++ b/arch/sh/include/asm/device.h
@@ -10,3 +10,5 @@ struct platform_device;
 int platform_resource_setup_memory(struct platform_device *pdev,
                                    char *name, unsigned long memsize);
 
+void plat_early_device_setup(void);
+
diff --git a/arch/sh/include/asm/hd64461.h b/arch/sh/include/asm/hd64461.h
index 52b4b6238277..977355f0a483 100644
--- a/arch/sh/include/asm/hd64461.h
+++ b/arch/sh/include/asm/hd64461.h
@@ -13,18 +13,20 @@
 #define HD64461_PCC_WINDOW      0x01000000
 
 /* Area 6 - Slot 0 - memory and/or IO card */
-#define HD64461_PCC0_BASE       (CONFIG_HD64461_IOBASE + 0x8000000)
+#define HD64461_IOBASE          0xb0000000
+#define HD64461_IO_OFFSET(x)    (HD64461_IOBASE + (x))
+#define HD64461_PCC0_BASE       HD64461_IO_OFFSET(0x8000000)
 #define HD64461_PCC0_ATTR       (HD64461_PCC0_BASE)                             /* 0xb80000000 */
 #define HD64461_PCC0_COMM       (HD64461_PCC0_BASE+HD64461_PCC_WINDOW)          /* 0xb90000000 */
 #define HD64461_PCC0_IO         (HD64461_PCC0_BASE+2*HD64461_PCC_WINDOW)        /* 0xba0000000 */
 
 /* Area 5 - Slot 1 - memory card only */
-#define HD64461_PCC1_BASE       (CONFIG_HD64461_IOBASE + 0x4000000)
+#define HD64461_PCC1_BASE       HD64461_IO_OFFSET(0x4000000)
 #define HD64461_PCC1_ATTR       (HD64461_PCC1_BASE)                             /* 0xb4000000 */
 #define HD64461_PCC1_COMM       (HD64461_PCC1_BASE+HD64461_PCC_WINDOW)          /* 0xb5000000 */
 
 /* Standby Control Register for HD64461 */
-#define HD64461_STBCR                   CONFIG_HD64461_IOBASE
+#define HD64461_STBCR                   HD64461_IO_OFFSET(0x00000000)
 #define HD64461_STBCR_CKIO_STBY         0x2000
 #define HD64461_STBCR_SAFECKE_IST       0x1000
 #define HD64461_STBCR_SLCKE_IST         0x0800
@@ -41,19 +43,19 @@
 #define HD64461_STBCR_SURTST            0x0001
 
 /* System Configuration Register */
-#define HD64461_SYSCR           (CONFIG_HD64461_IOBASE + 0x02)
+#define HD64461_SYSCR           HD64461_IO_OFFSET(0x02)
 
 /* CPU Data Bus Control Register */
-#define HD64461_SCPUCR          (CONFIG_HD64461_IOBASE + 0x04)
+#define HD64461_SCPUCR          HD64461_IO_OFFSET(0x04)
 
 /* Base Address Register */
-#define HD64461_LCDCBAR         (CONFIG_HD64461_IOBASE + 0x1000)
+#define HD64461_LCDCBAR         HD64461_IO_OFFSET(0x1000)
 
 /* Line increment address */
-#define HD64461_LCDCLOR         (CONFIG_HD64461_IOBASE + 0x1002)
+#define HD64461_LCDCLOR         HD64461_IO_OFFSET(0x1002)
 
 /* Controls LCD controller */
-#define HD64461_LCDCCR          (CONFIG_HD64461_IOBASE + 0x1004)
+#define HD64461_LCDCCR          HD64461_IO_OFFSET(0x1004)
 
 /* LCCDR control bits */
 #define HD64461_LCDCCR_STBACK   0x0400  /* Standby Back */
@@ -64,30 +66,30 @@
 #define HD64461_LCDCCR_SPON     0x0010  /* Start Power On */
 
 /* Controls LCD (1) */
-#define HD64461_LDR1            (CONFIG_HD64461_IOBASE + 0x1010)
+#define HD64461_LDR1            HD64461_IO_OFFSET(0x1010)
 #define HD64461_LDR1_DON        0x01    /* Display On */
 #define HD64461_LDR1_DINV       0x80    /* Display Invert */
 
 /* Controls LCD (2) */
-#define HD64461_LDR2            (CONFIG_HD64461_IOBASE + 0x1012)
-#define HD64461_LDHNCR          (CONFIG_HD64461_IOBASE + 0x1014)        /* Number of horizontal characters */
-#define HD64461_LDHNSR          (CONFIG_HD64461_IOBASE + 0x1016)        /* Specify output start position + width of CL1 */
-#define HD64461_LDVNTR          (CONFIG_HD64461_IOBASE + 0x1018)        /* Specify total vertical lines */
-#define HD64461_LDVNDR          (CONFIG_HD64461_IOBASE + 0x101a)        /* specify number of display vertical lines */
-#define HD64461_LDVSPR          (CONFIG_HD64461_IOBASE + 0x101c)        /* specify vertical synchronization pos and AC nr */
+#define HD64461_LDR2            HD64461_IO_OFFSET(0x1012)
+#define HD64461_LDHNCR          HD64461_IO_OFFSET(0x1014)       /* Number of horizontal characters */
+#define HD64461_LDHNSR          HD64461_IO_OFFSET(0x1016)       /* Specify output start position + width of CL1 */
+#define HD64461_LDVNTR          HD64461_IO_OFFSET(0x1018)       /* Specify total vertical lines */
+#define HD64461_LDVNDR          HD64461_IO_OFFSET(0x101a)       /* specify number of display vertical lines */
+#define HD64461_LDVSPR          HD64461_IO_OFFSET(0x101c)       /* specify vertical synchronization pos and AC nr */
 
 /* Controls LCD (3) */
-#define HD64461_LDR3            (CONFIG_HD64461_IOBASE + 0x101e)
+#define HD64461_LDR3            HD64461_IO_OFFSET(0x101e)
 
 /* Palette Registers */
-#define HD64461_CPTWAR          (CONFIG_HD64461_IOBASE + 0x1030)        /* Color Palette Write Address Register */
-#define HD64461_CPTWDR          (CONFIG_HD64461_IOBASE + 0x1032)        /* Color Palette Write Data Register */
-#define HD64461_CPTRAR          (CONFIG_HD64461_IOBASE + 0x1034)        /* Color Palette Read Address Register */
-#define HD64461_CPTRDR          (CONFIG_HD64461_IOBASE + 0x1036)        /* Color Palette Read Data Register */
+#define HD64461_CPTWAR          HD64461_IO_OFFSET(0x1030)       /* Color Palette Write Address Register */
+#define HD64461_CPTWDR          HD64461_IO_OFFSET(0x1032)       /* Color Palette Write Data Register */
+#define HD64461_CPTRAR          HD64461_IO_OFFSET(0x1034)       /* Color Palette Read Address Register */
+#define HD64461_CPTRDR          HD64461_IO_OFFSET(0x1036)       /* Color Palette Read Data Register */
 
-#define HD64461_GRDOR           (CONFIG_HD64461_IOBASE + 0x1040)        /* Display Resolution Offset Register */
-#define HD64461_GRSCR           (CONFIG_HD64461_IOBASE + 0x1042)        /* Solid Color Register */
-#define HD64461_GRCFGR          (CONFIG_HD64461_IOBASE + 0x1044)        /* Accelerator Configuration Register */
+#define HD64461_GRDOR           HD64461_IO_OFFSET(0x1040)       /* Display Resolution Offset Register */
+#define HD64461_GRSCR           HD64461_IO_OFFSET(0x1042)       /* Solid Color Register */
+#define HD64461_GRCFGR          HD64461_IO_OFFSET(0x1044)       /* Accelerator Configuration Register */
 
 #define HD64461_GRCFGR_ACCSTATUS        0x10    /* Accelerator Status */
 #define HD64461_GRCFGR_ACCRESET         0x08    /* Accelerator Reset */
@@ -97,41 +99,41 @@
 #define HD64461_GRCFGR_COLORDEPTH8      0x01    /* Sets Colordepth 8 for Accelerator */
 
 /* Line Drawing Registers */
-#define HD64461_LNSARH          (CONFIG_HD64461_IOBASE + 0x1046)        /* Line Start Address Register (H) */
-#define HD64461_LNSARL          (CONFIG_HD64461_IOBASE + 0x1048)        /* Line Start Address Register (L) */
-#define HD64461_LNAXLR          (CONFIG_HD64461_IOBASE + 0x104a)        /* Axis Pixel Length Register */
-#define HD64461_LNDGR           (CONFIG_HD64461_IOBASE + 0x104c)        /* Diagonal Register */
-#define HD64461_LNAXR           (CONFIG_HD64461_IOBASE + 0x104e)        /* Axial Register */
-#define HD64461_LNERTR          (CONFIG_HD64461_IOBASE + 0x1050)        /* Start Error Term Register */
-#define HD64461_LNMDR           (CONFIG_HD64461_IOBASE + 0x1052)        /* Line Mode Register */
+#define HD64461_LNSARH          HD64461_IO_OFFSET(0x1046)       /* Line Start Address Register (H) */
+#define HD64461_LNSARL          HD64461_IO_OFFSET(0x1048)       /* Line Start Address Register (L) */
+#define HD64461_LNAXLR          HD64461_IO_OFFSET(0x104a)       /* Axis Pixel Length Register */
+#define HD64461_LNDGR           HD64461_IO_OFFSET(0x104c)       /* Diagonal Register */
+#define HD64461_LNAXR           HD64461_IO_OFFSET(0x104e)       /* Axial Register */
+#define HD64461_LNERTR          HD64461_IO_OFFSET(0x1050)       /* Start Error Term Register */
+#define HD64461_LNMDR           HD64461_IO_OFFSET(0x1052)       /* Line Mode Register */
 
 /* BitBLT Registers */
-#define HD64461_BBTSSARH        (CONFIG_HD64461_IOBASE + 0x1054)        /* Source Start Address Register (H) */
-#define HD64461_BBTSSARL        (CONFIG_HD64461_IOBASE + 0x1056)        /* Source Start Address Register (L) */
-#define HD64461_BBTDSARH        (CONFIG_HD64461_IOBASE + 0x1058)        /* Destination Start Address Register (H) */
-#define HD64461_BBTDSARL        (CONFIG_HD64461_IOBASE + 0x105a)        /* Destination Start Address Register (L) */
-#define HD64461_BBTDWR          (CONFIG_HD64461_IOBASE + 0x105c)        /* Destination Block Width Register */
-#define HD64461_BBTDHR          (CONFIG_HD64461_IOBASE + 0x105e)        /* Destination Block Height Register */
-#define HD64461_BBTPARH         (CONFIG_HD64461_IOBASE + 0x1060)        /* Pattern Start Address Register (H) */
-#define HD64461_BBTPARL         (CONFIG_HD64461_IOBASE + 0x1062)        /* Pattern Start Address Register (L) */
-#define HD64461_BBTMARH         (CONFIG_HD64461_IOBASE + 0x1064)        /* Mask Start Address Register (H) */
-#define HD64461_BBTMARL         (CONFIG_HD64461_IOBASE + 0x1066)        /* Mask Start Address Register (L) */
-#define HD64461_BBTROPR         (CONFIG_HD64461_IOBASE + 0x1068)        /* ROP Register */
-#define HD64461_BBTMDR          (CONFIG_HD64461_IOBASE + 0x106a)        /* BitBLT Mode Register */
+#define HD64461_BBTSSARH        HD64461_IO_OFFSET(0x1054)       /* Source Start Address Register (H) */
+#define HD64461_BBTSSARL        HD64461_IO_OFFSET(0x1056)       /* Source Start Address Register (L) */
+#define HD64461_BBTDSARH        HD64461_IO_OFFSET(0x1058)       /* Destination Start Address Register (H) */
+#define HD64461_BBTDSARL        HD64461_IO_OFFSET(0x105a)       /* Destination Start Address Register (L) */
+#define HD64461_BBTDWR          HD64461_IO_OFFSET(0x105c)       /* Destination Block Width Register */
+#define HD64461_BBTDHR          HD64461_IO_OFFSET(0x105e)       /* Destination Block Height Register */
+#define HD64461_BBTPARH         HD64461_IO_OFFSET(0x1060)       /* Pattern Start Address Register (H) */
+#define HD64461_BBTPARL         HD64461_IO_OFFSET(0x1062)       /* Pattern Start Address Register (L) */
+#define HD64461_BBTMARH         HD64461_IO_OFFSET(0x1064)       /* Mask Start Address Register (H) */
+#define HD64461_BBTMARL         HD64461_IO_OFFSET(0x1066)       /* Mask Start Address Register (L) */
+#define HD64461_BBTROPR         HD64461_IO_OFFSET(0x1068)       /* ROP Register */
+#define HD64461_BBTMDR          HD64461_IO_OFFSET(0x106a)       /* BitBLT Mode Register */
 
 /* PC Card Controller Registers */
 /* Maps to Physical Area 6 */
-#define HD64461_PCC0ISR         (CONFIG_HD64461_IOBASE + 0x2000)        /* socket 0 interface status */
-#define HD64461_PCC0GCR         (CONFIG_HD64461_IOBASE + 0x2002)        /* socket 0 general control */
-#define HD64461_PCC0CSCR        (CONFIG_HD64461_IOBASE + 0x2004)        /* socket 0 card status change */
-#define HD64461_PCC0CSCIER      (CONFIG_HD64461_IOBASE + 0x2006)        /* socket 0 card status change interrupt enable */
-#define HD64461_PCC0SCR         (CONFIG_HD64461_IOBASE + 0x2008)        /* socket 0 software control */
+#define HD64461_PCC0ISR         HD64461_IO_OFFSET(0x2000)       /* socket 0 interface status */
+#define HD64461_PCC0GCR         HD64461_IO_OFFSET(0x2002)       /* socket 0 general control */
+#define HD64461_PCC0CSCR        HD64461_IO_OFFSET(0x2004)       /* socket 0 card status change */
+#define HD64461_PCC0CSCIER      HD64461_IO_OFFSET(0x2006)       /* socket 0 card status change interrupt enable */
+#define HD64461_PCC0SCR         HD64461_IO_OFFSET(0x2008)       /* socket 0 software control */
 /* Maps to Physical Area 5 */
-#define HD64461_PCC1ISR         (CONFIG_HD64461_IOBASE + 0x2010)        /* socket 1 interface status */
-#define HD64461_PCC1GCR         (CONFIG_HD64461_IOBASE + 0x2012)        /* socket 1 general control */
-#define HD64461_PCC1CSCR        (CONFIG_HD64461_IOBASE + 0x2014)        /* socket 1 card status change */
-#define HD64461_PCC1CSCIER      (CONFIG_HD64461_IOBASE + 0x2016)        /* socket 1 card status change interrupt enable */
-#define HD64461_PCC1SCR         (CONFIG_HD64461_IOBASE + 0x2018)        /* socket 1 software control */
+#define HD64461_PCC1ISR         HD64461_IO_OFFSET(0x2010)       /* socket 1 interface status */
+#define HD64461_PCC1GCR         HD64461_IO_OFFSET(0x2012)       /* socket 1 general control */
+#define HD64461_PCC1CSCR        HD64461_IO_OFFSET(0x2014)       /* socket 1 card status change */
+#define HD64461_PCC1CSCIER      HD64461_IO_OFFSET(0x2016)       /* socket 1 card status change interrupt enable */
+#define HD64461_PCC1SCR         HD64461_IO_OFFSET(0x2018)       /* socket 1 software control */
 
 /* PCC Interface Status Register */
 #define HD64461_PCCISR_READY            0x80    /* card ready */
@@ -189,41 +191,41 @@
 #define HD64461_PCCSCR_SWP              0x01    /* write protect */
 
 /* PCC0 Output Pins Control Register */
-#define HD64461_P0OCR           (CONFIG_HD64461_IOBASE + 0x202a)
+#define HD64461_P0OCR           HD64461_IO_OFFSET(0x202a)
 
 /* PCC1 Output Pins Control Register */
-#define HD64461_P1OCR           (CONFIG_HD64461_IOBASE + 0x202c)
+#define HD64461_P1OCR           HD64461_IO_OFFSET(0x202c)
 
 /* PC Card General Control Register */
-#define HD64461_PGCR            (CONFIG_HD64461_IOBASE + 0x202e)
+#define HD64461_PGCR            HD64461_IO_OFFSET(0x202e)
 
 /* Port Control Registers */
-#define HD64461_GPACR           (CONFIG_HD64461_IOBASE + 0x4000)        /* Port A - Handles IRDA/TIMER */
-#define HD64461_GPBCR           (CONFIG_HD64461_IOBASE + 0x4002)        /* Port B - Handles UART */
-#define HD64461_GPCCR           (CONFIG_HD64461_IOBASE + 0x4004)        /* Port C - Handles PCMCIA 1 */
-#define HD64461_GPDCR           (CONFIG_HD64461_IOBASE + 0x4006)        /* Port D - Handles PCMCIA 1 */
+#define HD64461_GPACR           HD64461_IO_OFFSET(0x4000)       /* Port A - Handles IRDA/TIMER */
+#define HD64461_GPBCR           HD64461_IO_OFFSET(0x4002)       /* Port B - Handles UART */
+#define HD64461_GPCCR           HD64461_IO_OFFSET(0x4004)       /* Port C - Handles PCMCIA 1 */
+#define HD64461_GPDCR           HD64461_IO_OFFSET(0x4006)       /* Port D - Handles PCMCIA 1 */
 
 /* Port Control Data Registers */
-#define HD64461_GPADR           (CONFIG_HD64461_IOBASE + 0x4010)        /* A */
-#define HD64461_GPBDR           (CONFIG_HD64461_IOBASE + 0x4012)        /* B */
-#define HD64461_GPCDR           (CONFIG_HD64461_IOBASE + 0x4014)        /* C */
-#define HD64461_GPDDR           (CONFIG_HD64461_IOBASE + 0x4016)        /* D */
+#define HD64461_GPADR           HD64461_IO_OFFSET(0x4010)       /* A */
+#define HD64461_GPBDR           HD64461_IO_OFFSET(0x4012)       /* B */
+#define HD64461_GPCDR           HD64461_IO_OFFSET(0x4014)       /* C */
+#define HD64461_GPDDR           HD64461_IO_OFFSET(0x4016)       /* D */
 
 /* Interrupt Control Registers */
-#define HD64461_GPAICR          (CONFIG_HD64461_IOBASE + 0x4020)        /* A */
-#define HD64461_GPBICR          (CONFIG_HD64461_IOBASE + 0x4022)        /* B */
-#define HD64461_GPCICR          (CONFIG_HD64461_IOBASE + 0x4024)        /* C */
-#define HD64461_GPDICR          (CONFIG_HD64461_IOBASE + 0x4026)        /* D */
+#define HD64461_GPAICR          HD64461_IO_OFFSET(0x4020)       /* A */
+#define HD64461_GPBICR          HD64461_IO_OFFSET(0x4022)       /* B */
+#define HD64461_GPCICR          HD64461_IO_OFFSET(0x4024)       /* C */
+#define HD64461_GPDICR          HD64461_IO_OFFSET(0x4026)       /* D */
 
 /* Interrupt Status Registers */
-#define HD64461_GPAISR          (CONFIG_HD64461_IOBASE + 0x4040)        /* A */
-#define HD64461_GPBISR          (CONFIG_HD64461_IOBASE + 0x4042)        /* B */
-#define HD64461_GPCISR          (CONFIG_HD64461_IOBASE + 0x4044)        /* C */
-#define HD64461_GPDISR          (CONFIG_HD64461_IOBASE + 0x4046)        /* D */
+#define HD64461_GPAISR          HD64461_IO_OFFSET(0x4040)       /* A */
+#define HD64461_GPBISR          HD64461_IO_OFFSET(0x4042)       /* B */
+#define HD64461_GPCISR          HD64461_IO_OFFSET(0x4044)       /* C */
+#define HD64461_GPDISR          HD64461_IO_OFFSET(0x4046)       /* D */
 
 /* Interrupt Request Register & Interrupt Mask Register */
-#define HD64461_NIRR            (CONFIG_HD64461_IOBASE + 0x5000)
-#define HD64461_NIMR            (CONFIG_HD64461_IOBASE + 0x5002)
+#define HD64461_NIRR            HD64461_IO_OFFSET(0x5000)
+#define HD64461_NIMR            HD64461_IO_OFFSET(0x5002)
 
 #define HD64461_IRQBASE         OFFCHIP_IRQ_BASE
 #define OFFCHIP_IRQ_BASE        64
diff --git a/arch/sh/include/asm/io.h b/arch/sh/include/asm/io.h
index 0454f8d68059..25348141674b 100644
--- a/arch/sh/include/asm/io.h
+++ b/arch/sh/include/asm/io.h
@@ -123,10 +123,15 @@ static inline void __raw_reads##bwlq(volatile void __iomem *mem,	\
 
 __BUILD_MEMORY_STRING(b, u8)
 __BUILD_MEMORY_STRING(w, u16)
-__BUILD_MEMORY_STRING(q, u64)
 
+#ifdef CONFIG_SUPERH32
 void __raw_writesl(void __iomem *addr, const void *data, int longlen);
 void __raw_readsl(const void __iomem *addr, void *data, int longlen);
+#else
+__BUILD_MEMORY_STRING(l, u32)
+#endif
+
+__BUILD_MEMORY_STRING(q, u64)
 
 #define writesb                 __raw_writesb
 #define writesw                 __raw_writesw
@@ -224,17 +229,6 @@ void __iomem *__ioremap(unsigned long offset, unsigned long size,
                         unsigned long flags);
 void __iounmap(void __iomem *addr);
 
-/* arch/sh/mm/ioremap_64.c */
-unsigned long onchip_remap(unsigned long addr, unsigned long size,
-                           const char *name);
-extern void onchip_unmap(unsigned long vaddr);
-#else
-#define __ioremap(offset, size, flags)  ((void __iomem *)(offset))
-#define __iounmap(addr)                 do { } while (0)
-#define onchip_remap(addr, size, name)  (addr)
-#define onchip_unmap(addr)              do { } while (0)
-#endif /* CONFIG_MMU */
-
 static inline void __iomem *
 __ioremap_mode(unsigned long offset, unsigned long size, unsigned long flags)
 {
@@ -268,6 +262,10 @@ __ioremap_mode(unsigned long offset, unsigned long size, unsigned long flags)
 
         return __ioremap(offset, size, flags);
 }
+#else
+#define __ioremap_mode(offset, size, flags)     ((void __iomem *)(offset))
+#define __iounmap(addr)                         do { } while (0)
+#endif /* CONFIG_MMU */
 
 #define ioremap(offset, size)                           \
         __ioremap_mode((offset), (size), 0)
diff --git a/arch/sh/include/asm/irq.h b/arch/sh/include/asm/irq.h
index d319baaf4fbd..a2b8c99cc06f 100644
--- a/arch/sh/include/asm/irq.h
+++ b/arch/sh/include/asm/irq.h
@@ -8,7 +8,8 @@
  * advised to cap this at the hard limit that they're interested in
  * through the machvec.
  */
-#define NR_IRQS 256
+#define NR_IRQS                 256
+#define NR_IRQS_LEGACY          8       /* Legacy external IRQ0-7 */
 
 /*
  * Convert back and forth between INTEVT and IRQ values.
diff --git a/arch/sh/include/asm/kprobes.h b/arch/sh/include/asm/kprobes.h
index 613644a758e8..036c3311233c 100644
--- a/arch/sh/include/asm/kprobes.h
+++ b/arch/sh/include/asm/kprobes.h
@@ -6,7 +6,7 @@
 #include <linux/types.h>
 #include <linux/ptrace.h>
 
-typedef u16 kprobe_opcode_t;
+typedef insn_size_t kprobe_opcode_t;
 #define BREAKPOINT_INSTRUCTION  0xc33a
 
 #define MAX_INSN_SIZE 16
diff --git a/arch/sh/include/asm/machvec.h b/arch/sh/include/asm/machvec.h
index 64b1c16a0f03..84dd37761f56 100644
--- a/arch/sh/include/asm/machvec.h
+++ b/arch/sh/include/asm/machvec.h
@@ -46,6 +46,9 @@ struct sh_machine_vector {
 
         void __iomem *(*mv_ioport_map)(unsigned long port, unsigned int size);
         void (*mv_ioport_unmap)(void __iomem *);
+
+        int (*mv_clk_init)(void);
+        int (*mv_mode_pins)(void);
 };
 
 extern struct sh_machine_vector sh_mv;
diff --git a/arch/sh/include/asm/pci.h b/arch/sh/include/asm/pci.h
index df1d383e18a5..ae0da6f48b6d 100644
--- a/arch/sh/include/asm/pci.h
+++ b/arch/sh/include/asm/pci.h
@@ -17,54 +17,29 @@
  * external) PCI controllers.
  */
 struct pci_channel {
-        struct pci_ops *pci_ops;
-        struct resource *io_resource;
-        struct resource *mem_resource;
-        int first_devfn;
-        int last_devfn;
-};
+        struct pci_channel      *next;
 
-/*
- * Each board initializes this array and terminates it with a NULL entry.
- */
-extern struct pci_channel board_pci_channels[];
+        struct pci_ops          *pci_ops;
+        struct resource         *io_resource;
+        struct resource         *mem_resource;
 
-#define PCIBIOS_MIN_IO          board_pci_channels->io_resource->start
-#define PCIBIOS_MIN_MEM         board_pci_channels->mem_resource->start
+        unsigned long           io_offset;
+        unsigned long           mem_offset;
 
-/*
- * I/O routine helpers
- */
-#if defined(CONFIG_CPU_SUBTYPE_SH7780) || defined(CONFIG_CPU_SUBTYPE_SH7785)
-#define PCI_IO_AREA             0xFE400000
-#define PCI_IO_SIZE             0x00400000
-#elif defined(CONFIG_CPU_SH5)
-extern unsigned long PCI_IO_AREA;
-#define PCI_IO_SIZE             0x00010000
-#else
-#define PCI_IO_AREA             0xFE240000
-#define PCI_IO_SIZE             0x00040000
-#endif
+        unsigned long           reg_base;
 
-#define PCI_MEM_SIZE            0x01000000
+        unsigned long           io_map_base;
+};
 
-#define SH4_PCIIOBR_MASK        0xFFFC0000
-#define pci_ioaddr(addr)        (PCI_IO_AREA + (addr & ~SH4_PCIIOBR_MASK))
+extern void register_pci_controller(struct pci_channel *hose);
 
-#if defined(CONFIG_PCI)
-#define is_pci_ioaddr(port)             \
-        (((port) >= PCIBIOS_MIN_IO) &&  \
-         ((port) < (PCIBIOS_MIN_IO + PCI_IO_SIZE)))
-#define is_pci_memaddr(port)            \
-        (((port) >= PCIBIOS_MIN_MEM) && \
-         ((port) < (PCIBIOS_MIN_MEM + PCI_MEM_SIZE)))
-#else
-#define is_pci_ioaddr(port)     (0)
-#define is_pci_memaddr(port)    (0)
-#endif
+extern unsigned long PCIBIOS_MIN_IO, PCIBIOS_MIN_MEM;
 
 struct pci_dev;
 
+#define HAVE_PCI_MMAP
+extern int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
+        enum pci_mmap_state mmap_state, int write_combine);
 extern void pcibios_set_master(struct pci_dev *dev);
 
 static inline void pcibios_penalize_isa_irq(int irq, int active)
@@ -114,31 +89,76 @@ static inline void pcibios_penalize_isa_irq(int irq, int active)
 #endif
 
 #ifdef CONFIG_PCI
+/*
+ * None of the SH PCI controllers support MWI, it is always treated as a
+ * direct memory write.
+ */
+#define PCI_DISABLE_MWI
+
 static inline void pci_dma_burst_advice(struct pci_dev *pdev,
                                         enum pci_dma_burst_strategy *strat,
                                         unsigned long *strategy_parameter)
 {
-        *strat = PCI_DMA_BURST_INFINITY;
-        *strategy_parameter = ~0UL;
+        unsigned long cacheline_size;
+        u8 byte;
+
+        pci_read_config_byte(pdev, PCI_CACHE_LINE_SIZE, &byte);
+
+        if (byte == 0)
+                cacheline_size = L1_CACHE_BYTES;
+        else
+                cacheline_size = byte << 2;
+
+        *strat = PCI_DMA_BURST_MULTIPLE;
+        *strategy_parameter = cacheline_size;
 }
 #endif
 
+#ifdef CONFIG_SUPERH32
+/*
+ * If we're on an SH7751 or SH7780 PCI controller, PCI memory is mapped
+ * at the end of the address space in a special non-translatable area.
+ */
+#define PCI_MEM_FIXED_START     0xfd000000
+#define PCI_MEM_FIXED_END       (PCI_MEM_FIXED_START + 0x01000000)
+
+#define is_pci_memory_fixed_range(s, e) \
+        ((s) >= PCI_MEM_FIXED_START && (e) < PCI_MEM_FIXED_END)
+#else
+#define is_pci_memory_fixed_range(s, e) (0)
+#endif
+
 /* Board-specific fixup routines. */
-void pcibios_fixup(void);
-int pcibios_init_platform(void);
 int pcibios_map_platform_irq(struct pci_dev *dev, u8 slot, u8 pin);
 
-#ifdef CONFIG_PCI_AUTO
-int pciauto_assign_resources(int busno, struct pci_channel *hose);
-#endif
+extern void pcibios_resource_to_bus(struct pci_dev *dev,
+        struct pci_bus_region *region, struct resource *res);
 
-#endif /* __KERNEL__ */
+extern void pcibios_bus_to_resource(struct pci_dev *dev, struct resource *res,
+                                    struct pci_bus_region *region);
 
-/* generic pci stuff */
-#include <asm-generic/pci.h>
+static inline struct resource *
+pcibios_select_root(struct pci_dev *pdev, struct resource *res)
+{
+        struct resource *root = NULL;
+
+        if (res->flags & IORESOURCE_IO)
+                root = &ioport_resource;
+        if (res->flags & IORESOURCE_MEM)
+                root = &iomem_resource;
+
+        return root;
+}
+
+/* Chances are this interrupt is wired PC-style ...  */
+static inline int pci_get_legacy_ide_irq(struct pci_dev *dev, int channel)
+{
+        return channel ? 15 : 14;
+}
 
 /* generic DMA-mapping stuff */
 #include <asm-generic/pci-dma-compat.h>
 
+#endif /* __KERNEL__ */
 #endif /* __ASM_SH_PCI_H */
 
diff --git a/arch/sh/include/asm/pgtable.h b/arch/sh/include/asm/pgtable.h
index b517ae08b9c0..2a011b18090b 100644
--- a/arch/sh/include/asm/pgtable.h
+++ b/arch/sh/include/asm/pgtable.h
@@ -154,6 +154,10 @@ extern void kmap_coherent_init(void);
 #define kmap_coherent_init()    do { } while (0)
 #endif
 
+/* arch/sh/mm/mmap.c */
+#define HAVE_ARCH_UNMAPPED_AREA
+#define HAVE_ARCH_UNMAPPED_AREA_TOPDOWN
+
 #include <asm-generic/pgtable.h>
 
 #endif /* __ASM_SH_PGTABLE_H */
diff --git a/arch/sh/include/asm/processor.h b/arch/sh/include/asm/processor.h
index 1fd58b421438..ff7daaf9a620 100644
--- a/arch/sh/include/asm/processor.h
+++ b/arch/sh/include/asm/processor.h
@@ -32,7 +32,7 @@ enum cpu_type {
 
         /* SH-4A types */
         CPU_SH7763, CPU_SH7770, CPU_SH7780, CPU_SH7781, CPU_SH7785, CPU_SH7786,
-        CPU_SH7723, CPU_SHX3,
+        CPU_SH7723, CPU_SH7724, CPU_SHX3,
 
         /* SH4AL-DSP types */
         CPU_SH7343, CPU_SH7722, CPU_SH7366,
@@ -94,6 +94,27 @@ extern struct pt_regs fake_swapper_regs;
 const char *get_cpu_subtype(struct sh_cpuinfo *c);
 extern const struct seq_operations cpuinfo_op;
 
+/* processor boot mode configuration */
+#define MODE_PIN0 (1 << 0)
+#define MODE_PIN1 (1 << 1)
+#define MODE_PIN2 (1 << 2)
+#define MODE_PIN3 (1 << 3)
+#define MODE_PIN4 (1 << 4)
+#define MODE_PIN5 (1 << 5)
+#define MODE_PIN6 (1 << 6)
+#define MODE_PIN7 (1 << 7)
+#define MODE_PIN8 (1 << 8)
+#define MODE_PIN9 (1 << 9)
+#define MODE_PIN10 (1 << 10)
+#define MODE_PIN11 (1 << 11)
+#define MODE_PIN12 (1 << 12)
+#define MODE_PIN13 (1 << 13)
+#define MODE_PIN14 (1 << 14)
+#define MODE_PIN15 (1 << 15)
+
+int generic_mode_pins(void);
+int test_mode_pin(int pin);
+
 #ifdef CONFIG_VSYSCALL
 int vsyscall_init(void);
 #else
diff --git a/arch/sh/include/asm/ptrace.h b/arch/sh/include/asm/ptrace.h
index 68e20ff9aa9b..1dc12cb44a2d 100644
--- a/arch/sh/include/asm/ptrace.h
+++ b/arch/sh/include/asm/ptrace.h
@@ -102,6 +102,11 @@ struct pt_dspregs {
 #define PTRACE_GETDSPREGS       55      /* DSP registers */
 #define PTRACE_SETDSPREGS       56
 
+#define PT_TEXT_END_ADDR        240
+#define PT_TEXT_ADDR            244     /* &(struct user)->start_code */
+#define PT_DATA_ADDR            248     /* &(struct user)->start_data */
+#define PT_TEXT_LEN             252
+
 #ifdef __KERNEL__
 #include <asm/addrspace.h>
 
diff --git a/arch/sh/include/asm/rtc.h b/arch/sh/include/asm/rtc.h
index f7b010d48af7..52b0c2dba979 100644
--- a/arch/sh/include/asm/rtc.h
+++ b/arch/sh/include/asm/rtc.h
@@ -6,6 +6,17 @@ extern void (*board_time_init)(void);
 extern void (*rtc_sh_get_time)(struct timespec *);
 extern int (*rtc_sh_set_time)(const time_t);
 
+/* some dummy definitions */
+#define RTC_BATT_BAD 0x100      /* battery bad */
+#define RTC_SQWE 0x08           /* enable square-wave output */
+#define RTC_DM_BINARY 0x04      /* all time/date values are BCD if clear */
+#define RTC_24H 0x02            /* 24 hour mode - else hours bit 7 means pm */
+#define RTC_DST_EN 0x01         /* auto switch DST - works f. USA only */
+
+struct rtc_time;
+unsigned int get_rtc_time(struct rtc_time *);
+int set_rtc_time(struct rtc_time *);
+
 #define RTC_CAP_4_DIGIT_YEAR    (1 << 0)
 
 struct sh_rtc_platform_info {
diff --git a/arch/sh/include/asm/spinlock.h b/arch/sh/include/asm/spinlock.h
index 60283565f89b..a28c9f0053fd 100644
--- a/arch/sh/include/asm/spinlock.h
+++ b/arch/sh/include/asm/spinlock.h
@@ -26,7 +26,7 @@
 #define __raw_spin_is_locked(x)         ((x)->lock <= 0)
 #define __raw_spin_lock_flags(lock, flags) __raw_spin_lock(lock)
 #define __raw_spin_unlock_wait(x) \
-        do { cpu_relax(); } while ((x)->lock)
+        do { while (__raw_spin_is_locked(x)) cpu_relax(); } while (0)
 
 /*
  * Simple spin lock operations.  There are two variants, one clears IRQ's
diff --git a/arch/sh/include/asm/swab.h b/arch/sh/include/asm/swab.h
index e69315935107..0e08fe54ad71 100644
--- a/arch/sh/include/asm/swab.h
+++ b/arch/sh/include/asm/swab.h
@@ -14,15 +14,15 @@ static inline __attribute_const__ __u32 __arch_swab32(__u32 x)
 {
         __asm__(
 #ifdef __SH5__
-                "byterev        %0, %0\n\t"
+                "byterev        %1, %0\n\t"
                 "shari          %0, 32, %0"
 #else
-                "swap.b         %0, %0\n\t"
+                "swap.b         %1, %0\n\t"
                 "swap.w         %0, %0\n\t"
                 "swap.b         %0, %0"
 #endif
                 : "=r" (x)
-                : "0" (x));
+                : "r" (x));
 
         return x;
 }
@@ -32,13 +32,13 @@ static inline __attribute_const__ __u16 __arch_swab16(__u16 x)
 {
         __asm__(
 #ifdef __SH5__
-                "byterev        %0, %0\n\t"
+                "byterev        %1, %0\n\t"
                 "shari          %0, 32, %0"
 #else
-                "swap.b         %0, %0"
+                "swap.b         %1, %0"
 #endif
                 : "=r" (x)
-                :  "0" (x));
+                :  "r" (x));
 
         return x;
 }
diff --git a/arch/sh/include/asm/system_32.h b/arch/sh/include/asm/system_32.h
index 240b31e1142c..6c68a51f1cc5 100644
--- a/arch/sh/include/asm/system_32.h
+++ b/arch/sh/include/asm/system_32.h
@@ -198,7 +198,7 @@ do {							\
 })
 #endif
 
-int handle_unaligned_access(opcode_t instruction, struct pt_regs *regs,
+int handle_unaligned_access(insn_size_t instruction, struct pt_regs *regs,
                             struct mem_access *ma);
 
 asmlinkage void do_address_error(struct pt_regs *regs,
diff --git a/arch/sh/include/asm/timer.h b/arch/sh/include/asm/timer.h
deleted file mode 100644
index 4c3b66e30af2..000000000000
--- a/arch/sh/include/asm/timer.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef __ASM_SH_TIMER_H
-#define __ASM_SH_TIMER_H
-
-#include <linux/sysdev.h>
-#include <linux/clocksource.h>
-#include <cpu/timer.h>
-
-struct sys_timer_ops {
-        int (*init)(void);
-        int (*start)(void);
-        int (*stop)(void);
-#ifndef CONFIG_GENERIC_TIME
-        unsigned long (*get_offset)(void);
-#endif
-};
-
-struct sys_timer {
-        const char              *name;
-
-        struct sys_device       dev;
-        struct sys_timer_ops    *ops;
-};
-
-#define TICK_SIZE (tick_nsec / 1000)
-
-extern struct sys_timer tmu_timer, cmt_timer, mtu2_timer;
-extern struct sys_timer *sys_timer;
-
-#ifndef CONFIG_GENERIC_TIME
-static inline unsigned long get_timer_offset(void)
-{
-        return sys_timer->ops->get_offset();
-}
-#endif
-
-/* arch/sh/kernel/timers/timer.c */
-struct sys_timer *get_sys_timer(void);
-
-/* arch/sh/kernel/time.c */
-void handle_timer_tick(void);
-
-extern struct clocksource clocksource_sh;
-
-#endif /* __ASM_SH_TIMER_H */
diff --git a/arch/sh/include/asm/types.h b/arch/sh/include/asm/types.h
index beea4e6f8dfd..b13caca62a76 100644
--- a/arch/sh/include/asm/types.h
+++ b/arch/sh/include/asm/types.h
@@ -23,9 +23,9 @@ typedef unsigned short umode_t;
 typedef u32 dma_addr_t;
 
 #ifdef CONFIG_SUPERH32
-typedef u16 opcode_t;
+typedef u16 insn_size_t;
 #else
-typedef u32 opcode_t;
+typedef u32 insn_size_t;
 #endif
 
 #endif /* __ASSEMBLY__ */
diff --git a/arch/sh/include/asm/ubc.h b/arch/sh/include/asm/ubc.h
index a7b9028bbfbb..4ca4b7717371 100644
--- a/arch/sh/include/asm/ubc.h
+++ b/arch/sh/include/asm/ubc.h
@@ -42,12 +42,23 @@
 
 #define BRCR_CMFA               (1 << 15)
 #define BRCR_CMFB               (1 << 14)
+
+#if defined CONFIG_CPU_SH2A
+#define BRCR_CMFCA              (1 << 15)
+#define BRCR_CMFCB              (1 << 14)
+#define BRCR_CMFDA              (1 << 13)
+#define BRCR_CMFDB              (1 << 12)
+#define BRCR_PCBB               (1 << 6)        /* 1: after execution */
+#define BRCR_PCBA               (1 << 5)        /* 1: after execution */
+#define BRCR_PCTE               0
+#else
 #define BRCR_PCTE               (1 << 11)
 #define BRCR_PCBA               (1 << 10)       /* 1: after execution */
 #define BRCR_DBEB               (1 << 7)
 #define BRCR_PCBB               (1 << 6)
 #define BRCR_SEQ                (1 << 3)
 #define BRCR_UBDE               (1 << 0)
+#endif
 
 #ifndef __ASSEMBLY__
 /* arch/sh/kernel/cpu/ubc.S */
diff --git a/arch/sh/include/asm/unaligned-sh4a.h b/arch/sh/include/asm/unaligned-sh4a.h
index d8f89770275b..9f4dd252c981 100644
--- a/arch/sh/include/asm/unaligned-sh4a.h
+++ b/arch/sh/include/asm/unaligned-sh4a.h
@@ -3,9 +3,9 @@
 
 /*
  * SH-4A has support for unaligned 32-bit loads, and 32-bit loads only.
- * Support for 16 and 64-bit accesses are done through shifting and
- * masking relative to the endianness. Unaligned stores are not supported
- * by the instruction encoding, so these continue to use the packed
+ * Support for 64-bit accesses are done through shifting and masking
+ * relative to the endianness. Unaligned stores are not supported by the
+ * instruction encoding, so these continue to use the packed
  * struct.
  *
  * The same note as with the movli.l/movco.l pair applies here, as long
@@ -41,9 +41,9 @@ struct __una_u64 { u64 x __attribute__((packed)); };
 static inline u16 __get_unaligned_cpu16(const u8 *p)
 {
 #ifdef __LITTLE_ENDIAN
-        return __get_unaligned_cpu32(p) & 0xffff;
+        return p[0] | p[1] << 8;
 #else
-        return __get_unaligned_cpu32(p) >> 16;
+        return p[0] << 8 | p[1];
 #endif
 }
 
diff --git a/arch/sh/include/asm/unistd_32.h b/arch/sh/include/asm/unistd_32.h
index 2efb819e2db3..65197086a1c5 100644
--- a/arch/sh/include/asm/unistd_32.h
+++ b/arch/sh/include/asm/unistd_32.h
@@ -343,8 +343,9 @@
 #define __NR_inotify_init1      332
 #define __NR_preadv             333
 #define __NR_pwritev            334
+#define __NR_rt_tgsigqueueinfo  335
 
-#define NR_syscalls 335
+#define NR_syscalls 336
 
 #ifdef __KERNEL__
 
diff --git a/arch/sh/include/asm/unistd_64.h b/arch/sh/include/asm/unistd_64.h
index 6eb9d2934c0f..8014aea88ec3 100644
--- a/arch/sh/include/asm/unistd_64.h
+++ b/arch/sh/include/asm/unistd_64.h
@@ -383,10 +383,11 @@
 #define __NR_inotify_init1      360
 #define __NR_preadv             361
 #define __NR_pwritev            362
+#define __NR_rt_tgsigqueueinfo  363
 
 #ifdef __KERNEL__
 
-#define NR_syscalls 363
+#define NR_syscalls 364
 
 #define __ARCH_WANT_IPC_PARSE_VERSION
 #define __ARCH_WANT_OLD_READDIR
diff --git a/arch/sh/include/cpu-sh2a/cpu/ubc.h b/arch/sh/include/cpu-sh2a/cpu/ubc.h
index 8ce2fc1cf625..1192e1c761a7 100644
--- a/arch/sh/include/cpu-sh2a/cpu/ubc.h
+++ b/arch/sh/include/cpu-sh2a/cpu/ubc.h
@@ -1 +1,28 @@
-#include <cpu-sh2/cpu/ubc.h>
+/*
+ * SH-2A UBC definitions
+ *
+ * Copyright (C) 2008 Kieran Bingham
+ *
+ * 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.
+ */
+
+#ifndef __ASM_CPU_SH2A_UBC_H
+#define __ASM_CPU_SH2A_UBC_H
+
+#define UBC_BARA                0xfffc0400
+#define UBC_BAMRA               0xfffc0404
+#define UBC_BBRA                0xfffc04a0      /* 16 bit access */
+#define UBC_BDRA                0xfffc0408
+#define UBC_BDMRA               0xfffc040c
+
+#define UBC_BARB                0xfffc0410
+#define UBC_BAMRB               0xfffc0414
+#define UBC_BBRB                0xfffc04b0      /* 16 bit access */
+#define UBC_BDRB                0xfffc0418
+#define UBC_BDMRB               0xfffc041c
+
+#define UBC_BRCR                0xfffc04c0
+
+#endif /* __ASM_CPU_SH2A_UBC_H */
diff --git a/arch/sh/include/cpu-sh3/cpu/timer.h b/arch/sh/include/cpu-sh3/cpu/timer.h
deleted file mode 100644
index 793acf12aa08..000000000000
--- a/arch/sh/include/cpu-sh3/cpu/timer.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * include/asm-sh/cpu-sh3/timer.h
- *
- * Copyright (C) 2004 Lineo Solutions, Inc.
- *
- * 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.
- */
-#ifndef __ASM_CPU_SH3_TIMER_H
-#define __ASM_CPU_SH3_TIMER_H
-
-/*
- * ---------------------------------------------------------------------------
- * TMU Common definitions for SH3 processors
- *      SH7706
- *      SH7709S
- *      SH7727
- *      SH7729R
- *      SH7710
- *      SH7720
- *      SH7710
- * ---------------------------------------------------------------------------
- */
-
-#if  !defined(CONFIG_CPU_SUBTYPE_SH7720) && !defined(CONFIG_CPU_SUBTYPE_SH7721)
-#define TMU_TOCR        0xfffffe90      /* Byte access */
-#endif
-
-#if defined(CONFIG_CPU_SUBTYPE_SH7710) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7720) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7721)
-#define TMU_012_TSTR    0xa412fe92      /* Byte access */
-
-#define TMU0_TCOR       0xa412fe94      /* Long access */
-#define TMU0_TCNT       0xa412fe98      /* Long access */
-#define TMU0_TCR        0xa412fe9c      /* Word access */
-
-#define TMU1_TCOR       0xa412fea0      /* Long access */
-#define TMU1_TCNT       0xa412fea4      /* Long access */
-#define TMU1_TCR        0xa412fea8      /* Word access */
-
-#define TMU2_TCOR       0xa412feac      /* Long access */
-#define TMU2_TCNT       0xa412feb0      /* Long access */
-#define TMU2_TCR        0xa412feb4      /* Word access */
-
-#else
-#define TMU_012_TSTR    0xfffffe92      /* Byte access */
-
-#define TMU0_TCOR       0xfffffe94      /* Long access */
-#define TMU0_TCNT       0xfffffe98      /* Long access */
-#define TMU0_TCR        0xfffffe9c      /* Word access */
-
-#define TMU1_TCOR       0xfffffea0      /* Long access */
-#define TMU1_TCNT       0xfffffea4      /* Long access */
-#define TMU1_TCR        0xfffffea8      /* Word access */
-
-#define TMU2_TCOR       0xfffffeac      /* Long access */
-#define TMU2_TCNT       0xfffffeb0      /* Long access */
-#define TMU2_TCR        0xfffffeb4      /* Word access */
-#if !defined(CONFIG_CPU_SUBTYPE_SH7720) && !defined(CONFIG_CPU_SUBTYPE_SH7721)
-#define TMU2_TCPR2      0xfffffeb8      /* Long access */
-#endif
-#endif
-
-#endif /* __ASM_CPU_SH3_TIMER_H */
-
diff --git a/arch/sh/include/cpu-sh4/cpu/cache.h b/arch/sh/include/cpu-sh4/cpu/cache.h
index 1c61ebf5c8e3..7bfb9e8b069c 100644
--- a/arch/sh/include/cpu-sh4/cpu/cache.h
+++ b/arch/sh/include/cpu-sh4/cpu/cache.h
@@ -38,5 +38,7 @@
 #define CACHE_IC_ADDRESS_ARRAY  0xf0000000
 #define CACHE_OC_ADDRESS_ARRAY  0xf4000000
 
+#define RAMCR                   0xFF000074
+
 #endif /* __ASM_CPU_SH4_CACHE_H */
 
diff --git a/arch/sh/include/cpu-sh4/cpu/freq.h b/arch/sh/include/cpu-sh4/cpu/freq.h
index 749d1c434337..ccf1d999db6d 100644
--- a/arch/sh/include/cpu-sh4/cpu/freq.h
+++ b/arch/sh/include/cpu-sh4/cpu/freq.h
@@ -25,6 +25,24 @@
 #elif defined(CONFIG_CPU_SUBTYPE_SH7763) || \
       defined(CONFIG_CPU_SUBTYPE_SH7780)
 #define FRQCR                   0xffc80000
+#elif defined(CONFIG_CPU_SUBTYPE_SH7724)
+#define FRQCRA                  0xa4150000
+#define FRQCRB                  0xa4150004
+#define VCLKCR                  0xa4150048
+
+#define FCLKACR                 0xa4150008
+#define FCLKBCR                 0xa415000c
+#define FRQCR                   FRQCRA
+#define SCLKACR                 FCLKACR
+#define SCLKBCR                 FCLKBCR
+#define FCLKACR                 0xa4150008
+#define FCLKBCR                 0xa415000c
+#define IrDACLKCR               0xa4150018
+
+#define MSTPCR0                 0xa4150030
+#define MSTPCR1                 0xa4150034
+#define MSTPCR2                 0xa4150038
+
 #elif defined(CONFIG_CPU_SUBTYPE_SH7785)
 #define FRQCR0                  0xffc80000
 #define FRQCR1                  0xffc80004
diff --git a/arch/sh/include/cpu-sh4/cpu/sh7722.h b/arch/sh/include/cpu-sh4/cpu/sh7722.h
index 4b3096f5307b..738ea43c5038 100644
--- a/arch/sh/include/cpu-sh4/cpu/sh7722.h
+++ b/arch/sh/include/cpu-sh4/cpu/sh7722.h
@@ -1,6 +1,20 @@
 #ifndef __ASM_SH7722_H__
 #define __ASM_SH7722_H__
 
+/* Boot Mode Pins:
+ *
+ * MD0: CPG - Clock Mode 0->3
+ * MD1: CPG - Clock Mode 0->3
+ * MD2: CPG - Reserved (L: Normal operation)
+ * MD3: BSC - Area0 Bus Width (16/32-bit) [CS0BCR.9,10]
+ * MD5: BSC - Endian Mode (L: Big, H: Little) [CMNCR.3]
+ * MD8: Test Mode
+ */
+
+/* Pin Function Controller:
+ * GPIO_FN_xx - GPIO used to select pin function
+ * GPIO_Pxx - GPIO mapped to real I/O pin on CPU
+ */
 enum {
         /* PTA */
         GPIO_PTA7, GPIO_PTA6, GPIO_PTA5, GPIO_PTA4,
diff --git a/arch/sh/include/cpu-sh4/cpu/sh7723.h b/arch/sh/include/cpu-sh4/cpu/sh7723.h
index 9d2f6d7aa938..14c8ca936781 100644
--- a/arch/sh/include/cpu-sh4/cpu/sh7723.h
+++ b/arch/sh/include/cpu-sh4/cpu/sh7723.h
@@ -1,6 +1,20 @@
 #ifndef __ASM_SH7723_H__
 #define __ASM_SH7723_H__
 
+/* Boot Mode Pins:
+ *
+ * MD0: CPG - Clock Mode 0->3
+ * MD1: CPG - Clock Mode 0->3
+ * MD2: CPG - Reserved (L: Normal operation)
+ * MD3: BSC - Area0 Bus Width (16/32-bit) [CS0BCR.9,10]
+ * MD5: BSC - Endian Mode (L: Big, H: Little) [CMNCR.3]
+ * MD8: Test Mode
+ */
+
+/* Pin Function Controller:
+ * GPIO_FN_xx - GPIO used to select pin function
+ * GPIO_Pxx - GPIO mapped to real I/O pin on CPU
+ */
 enum {
         /* PTA */
         GPIO_PTA7, GPIO_PTA6, GPIO_PTA5, GPIO_PTA4,
diff --git a/arch/sh/include/cpu-sh4/cpu/sh7724.h b/arch/sh/include/cpu-sh4/cpu/sh7724.h
new file mode 100644
index 000000000000..66fd1184359e
--- /dev/null
+++ b/arch/sh/include/cpu-sh4/cpu/sh7724.h
@@ -0,0 +1,269 @@
+#ifndef __ASM_SH7724_H__
+#define __ASM_SH7724_H__
+
+/* Boot Mode Pins:
+ *
+ * MD0: CPG - Clock Mode 0->7
+ * MD1: CPG - Clock Mode 0->7
+ * MD2: CPG - Clock Mode 0->7
+ * MD3: BSC - Area0 Bus Width (16/32-bit) [CS0BCR.9,10]
+ * MD5: BSC - Endian Mode (L: Big, H: Little) [CMNCR.3]
+ * MD8: Test Mode
+ */
+
+/* Pin Function Controller:
+ * GPIO_FN_xx - GPIO used to select pin function
+ * GPIO_Pxx - GPIO mapped to real I/O pin on CPU
+ */
+enum {
+        /* PTA */
+        GPIO_PTA7, GPIO_PTA6, GPIO_PTA5, GPIO_PTA4,
+        GPIO_PTA3, GPIO_PTA2, GPIO_PTA1, GPIO_PTA0,
+
+        /* PTB */
+        GPIO_PTB7, GPIO_PTB6, GPIO_PTB5, GPIO_PTB4,
+        GPIO_PTB3, GPIO_PTB2, GPIO_PTB1, GPIO_PTB0,
+
+        /* PTC */
+        GPIO_PTC7, GPIO_PTC6, GPIO_PTC5, GPIO_PTC4,
+        GPIO_PTC3, GPIO_PTC2, GPIO_PTC1, GPIO_PTC0,
+
+        /* PTD */
+        GPIO_PTD7, GPIO_PTD6, GPIO_PTD5, GPIO_PTD4,
+        GPIO_PTD3, GPIO_PTD2, GPIO_PTD1, GPIO_PTD0,
+
+        /* PTE */
+        GPIO_PTE7, GPIO_PTE6, GPIO_PTE5, GPIO_PTE4,
+        GPIO_PTE3, GPIO_PTE2, GPIO_PTE1, GPIO_PTE0,
+
+        /* PTF */
+        GPIO_PTF7, GPIO_PTF6, GPIO_PTF5, GPIO_PTF4,
+        GPIO_PTF3, GPIO_PTF2, GPIO_PTF1, GPIO_PTF0,
+
+        /* PTG */
+                              GPIO_PTG5, GPIO_PTG4,
+        GPIO_PTG3, GPIO_PTG2, GPIO_PTG1, GPIO_PTG0,
+
+        /* PTH */
+        GPIO_PTH7, GPIO_PTH6, GPIO_PTH5, GPIO_PTH4,
+        GPIO_PTH3, GPIO_PTH2, GPIO_PTH1, GPIO_PTH0,
+
+        /* PTJ */
+        GPIO_PTJ7, GPIO_PTJ6, GPIO_PTJ5,
+        GPIO_PTJ3, GPIO_PTJ2, GPIO_PTJ1, GPIO_PTJ0,
+
+        /* PTK */
+        GPIO_PTK7, GPIO_PTK6, GPIO_PTK5, GPIO_PTK4,
+        GPIO_PTK3, GPIO_PTK2, GPIO_PTK1, GPIO_PTK0,
+
+        /* PTL */
+        GPIO_PTL7, GPIO_PTL6, GPIO_PTL5, GPIO_PTL4,
+        GPIO_PTL3, GPIO_PTL2, GPIO_PTL1, GPIO_PTL0,
+
+        /* PTM */
+        GPIO_PTM7, GPIO_PTM6, GPIO_PTM5, GPIO_PTM4,
+        GPIO_PTM3, GPIO_PTM2, GPIO_PTM1, GPIO_PTM0,
+
+        /* PTN */
+        GPIO_PTN7, GPIO_PTN6, GPIO_PTN5, GPIO_PTN4,
+        GPIO_PTN3, GPIO_PTN2, GPIO_PTN1, GPIO_PTN0,
+
+        /* PTQ */
+        GPIO_PTQ7, GPIO_PTQ6, GPIO_PTQ5, GPIO_PTQ4,
+        GPIO_PTQ3, GPIO_PTQ2, GPIO_PTQ1, GPIO_PTQ0,
+
+        /* PTR */
+        GPIO_PTR7, GPIO_PTR6, GPIO_PTR5, GPIO_PTR4,
+        GPIO_PTR3, GPIO_PTR2, GPIO_PTR1, GPIO_PTR0,
+
+        /* PTS */
+                   GPIO_PTS6, GPIO_PTS5, GPIO_PTS4,
+        GPIO_PTS3, GPIO_PTS2, GPIO_PTS1, GPIO_PTS0,
+
+        /* PTT */
+        GPIO_PTT7, GPIO_PTT6, GPIO_PTT5, GPIO_PTT4,
+        GPIO_PTT3, GPIO_PTT2, GPIO_PTT1, GPIO_PTT0,
+
+        /* PTU */
+        GPIO_PTU7, GPIO_PTU6, GPIO_PTU5, GPIO_PTU4,
+        GPIO_PTU3, GPIO_PTU2, GPIO_PTU1, GPIO_PTU0,
+
+        /* PTV */
+        GPIO_PTV7, GPIO_PTV6, GPIO_PTV5, GPIO_PTV4,
+        GPIO_PTV3, GPIO_PTV2, GPIO_PTV1, GPIO_PTV0,
+
+        /* PTW */
+        GPIO_PTW7, GPIO_PTW6, GPIO_PTW5, GPIO_PTW4,
+        GPIO_PTW3, GPIO_PTW2, GPIO_PTW1, GPIO_PTW0,
+
+        /* PTX */
+        GPIO_PTX7, GPIO_PTX6, GPIO_PTX5, GPIO_PTX4,
+        GPIO_PTX3, GPIO_PTX2, GPIO_PTX1, GPIO_PTX0,
+
+        /* PTY */
+        GPIO_PTY7, GPIO_PTY6, GPIO_PTY5, GPIO_PTY4,
+        GPIO_PTY3, GPIO_PTY2, GPIO_PTY1, GPIO_PTY0,
+
+        /* PTZ */
+        GPIO_PTZ7, GPIO_PTZ6, GPIO_PTZ5, GPIO_PTZ4,
+        GPIO_PTZ3, GPIO_PTZ2, GPIO_PTZ1, GPIO_PTZ0,
+
+        /* BSC (PTA/PTB/PTJ/PTQ/PTR/PTT) */
+        GPIO_FN_D31, GPIO_FN_D30, GPIO_FN_D29, GPIO_FN_D28,
+        GPIO_FN_D27, GPIO_FN_D26, GPIO_FN_D25, GPIO_FN_D24,
+        GPIO_FN_D23, GPIO_FN_D22, GPIO_FN_D21, GPIO_FN_D20,
+        GPIO_FN_D19, GPIO_FN_D18, GPIO_FN_D17, GPIO_FN_D16,
+        GPIO_FN_D15, GPIO_FN_D14, GPIO_FN_D13, GPIO_FN_D12,
+        GPIO_FN_D11, GPIO_FN_D10, GPIO_FN_D9,  GPIO_FN_D8,
+        GPIO_FN_D7,  GPIO_FN_D6,  GPIO_FN_D5,  GPIO_FN_D4,
+        GPIO_FN_D3,  GPIO_FN_D2,  GPIO_FN_D1,  GPIO_FN_D0,
+        GPIO_FN_A25, GPIO_FN_A24, GPIO_FN_A23, GPIO_FN_A22,
+        GPIO_FN_CS6B_CE1B,  GPIO_FN_CS6A_CE2B,
+        GPIO_FN_CS5B_CE1A,  GPIO_FN_CS5A_CE2A,
+        GPIO_FN_WE3_ICIOWR, GPIO_FN_WE2_ICIORD,
+        GPIO_FN_IOIS16,     GPIO_FN_WAIT,
+        GPIO_FN_BS,
+
+        /* KEYSC (PTA/PTB)*/
+        GPIO_FN_KEYOUT5_IN5, GPIO_FN_KEYOUT4_IN6, GPIO_FN_KEYIN4,
+        GPIO_FN_KEYIN3,  GPIO_FN_KEYIN2,  GPIO_FN_KEYIN1,  GPIO_FN_KEYIN0,
+        GPIO_FN_KEYOUT3, GPIO_FN_KEYOUT2, GPIO_FN_KEYOUT1, GPIO_FN_KEYOUT0,
+
+        /* ATAPI (PTA/PTB/PTK/PTR/PTS/PTW) */
+        GPIO_FN_IDED15, GPIO_FN_IDED14, GPIO_FN_IDED13, GPIO_FN_IDED12,
+        GPIO_FN_IDED11, GPIO_FN_IDED10, GPIO_FN_IDED9,  GPIO_FN_IDED8,
+        GPIO_FN_IDED7,  GPIO_FN_IDED6,  GPIO_FN_IDED5,  GPIO_FN_IDED4,
+        GPIO_FN_IDED3,  GPIO_FN_IDED2,  GPIO_FN_IDED1,  GPIO_FN_IDED0,
+        GPIO_FN_IDEA2,     GPIO_FN_IDEA1,     GPIO_FN_IDEA0,  GPIO_FN_IDEIOWR,
+        GPIO_FN_IODREQ,    GPIO_FN_IDECS0,    GPIO_FN_IDECS1, GPIO_FN_IDEIORD,
+        GPIO_FN_DIRECTION, GPIO_FN_EXBUF_ENB, GPIO_FN_IDERST, GPIO_FN_IODACK,
+        GPIO_FN_IDEINT,    GPIO_FN_IDEIORDY,
+
+        /* TPU (PTB/PTR/PTS) */
+        GPIO_FN_TPUTO3, GPIO_FN_TPUTO2, GPIO_FN_TPUTO1, GPIO_FN_TPUTO0,
+        GPIO_FN_TPUTI3, GPIO_FN_TPUTI2,
+
+        /* LCDC (PTC/PTD/PTE/PTF/PTM/PTR) */
+        GPIO_FN_LCDD23, GPIO_FN_LCDD22, GPIO_FN_LCDD21, GPIO_FN_LCDD20,
+        GPIO_FN_LCDD19, GPIO_FN_LCDD18, GPIO_FN_LCDD17, GPIO_FN_LCDD16,
+        GPIO_FN_LCDD15, GPIO_FN_LCDD14, GPIO_FN_LCDD13, GPIO_FN_LCDD12,
+        GPIO_FN_LCDD11, GPIO_FN_LCDD10, GPIO_FN_LCDD9,  GPIO_FN_LCDD8,
+        GPIO_FN_LCDD7,  GPIO_FN_LCDD6,  GPIO_FN_LCDD5,  GPIO_FN_LCDD4,
+        GPIO_FN_LCDD3,  GPIO_FN_LCDD2,  GPIO_FN_LCDD1,  GPIO_FN_LCDD0,
+        GPIO_FN_LCDVSYN,  GPIO_FN_LCDDISP,  GPIO_FN_LCDRS,  GPIO_FN_LCDHSYN,
+        GPIO_FN_LCDCS,    GPIO_FN_LCDDON,   GPIO_FN_LCDDCK, GPIO_FN_LCDWR,
+        GPIO_FN_LCDVEPWC, GPIO_FN_LCDVCPWC, GPIO_FN_LCDRD,  GPIO_FN_LCDLCLK,
+
+        /* SCIF0 (PTF/PTM) */
+        GPIO_FN_SCIF0_TXD, GPIO_FN_SCIF0_RXD, GPIO_FN_SCIF0_SCK,
+
+        /* SCIF1 (PTL) */
+        GPIO_FN_SCIF1_SCK, GPIO_FN_SCIF1_RXD, GPIO_FN_SCIF1_TXD,
+
+        /* SCIF2 (PTE/PTF/PTN) with LCDC, VOU */
+        GPIO_FN_SCIF2_L_TXD, GPIO_FN_SCIF2_L_SCK, GPIO_FN_SCIF2_L_RXD,
+        GPIO_FN_SCIF2_V_TXD, GPIO_FN_SCIF2_V_SCK, GPIO_FN_SCIF2_V_RXD,
+
+        /* SCIF3 (PTL/PTN/PTZ) with VOU, IRQ */
+        GPIO_FN_SCIF3_V_SCK, GPIO_FN_SCIF3_V_RXD, GPIO_FN_SCIF3_V_TXD,
+        GPIO_FN_SCIF3_V_CTS, GPIO_FN_SCIF3_V_RTS,
+        GPIO_FN_SCIF3_I_SCK, GPIO_FN_SCIF3_I_RXD, GPIO_FN_SCIF3_I_TXD,
+        GPIO_FN_SCIF3_I_CTS, GPIO_FN_SCIF3_I_RTS,
+
+        /* SCIF4 (PTE) */
+        GPIO_FN_SCIF4_SCK, GPIO_FN_SCIF4_RXD, GPIO_FN_SCIF4_TXD,
+
+        /* SCIF5 (PTS) */
+        GPIO_FN_SCIF5_SCK, GPIO_FN_SCIF5_RXD, GPIO_FN_SCIF5_TXD,
+
+        /* FSI (PTE/PTU/PTV) */
+        GPIO_FN_FSIMCKB,   GPIO_FN_FSIMCKA,    GPIO_FN_FSIOASD,
+        GPIO_FN_FSIIABCK,  GPIO_FN_FSIIALRCK,  GPIO_FN_FSIOABCK,
+        GPIO_FN_FSIOALRCK, GPIO_FN_CLKAUDIOAO, GPIO_FN_FSIIBSD,
+        GPIO_FN_FSIOBSD,   GPIO_FN_FSIIBBCK,   GPIO_FN_FSIIBLRCK,
+        GPIO_FN_FSIOBBCK,  GPIO_FN_FSIOBLRCK,  GPIO_FN_CLKAUDIOBO,
+        GPIO_FN_FSIIASD,
+
+        /* AUD (PTG) */
+        GPIO_FN_AUDCK,   GPIO_FN_AUDSYNC, GPIO_FN_AUDATA3,
+        GPIO_FN_AUDATA2, GPIO_FN_AUDATA1, GPIO_FN_AUDATA0,
+
+        /* VIO (PTS) (common?) */
+        GPIO_FN_VIO_CKO,
+
+        /* VIO0 (PTH/PTK) */
+        GPIO_FN_VIO0_D15, GPIO_FN_VIO0_D14, GPIO_FN_VIO0_D13, GPIO_FN_VIO0_D12,
+        GPIO_FN_VIO0_D11, GPIO_FN_VIO0_D10, GPIO_FN_VIO0_D9,  GPIO_FN_VIO0_D8,
+        GPIO_FN_VIO0_D7,  GPIO_FN_VIO0_D6,  GPIO_FN_VIO0_D5,  GPIO_FN_VIO0_D4,
+        GPIO_FN_VIO0_D3,  GPIO_FN_VIO0_D2,  GPIO_FN_VIO0_D1,  GPIO_FN_VIO0_D0,
+        GPIO_FN_VIO0_VD,  GPIO_FN_VIO0_CLK,
+        GPIO_FN_VIO0_FLD, GPIO_FN_VIO0_HD,
+
+        /* VIO1 (PTK/PTS) */
+        GPIO_FN_VIO1_D7,  GPIO_FN_VIO1_D6, GPIO_FN_VIO1_D5, GPIO_FN_VIO1_D4,
+        GPIO_FN_VIO1_D3,  GPIO_FN_VIO1_D2, GPIO_FN_VIO1_D1, GPIO_FN_VIO1_D0,
+        GPIO_FN_VIO1_FLD, GPIO_FN_VIO1_HD, GPIO_FN_VIO1_VD, GPIO_FN_VIO1_CLK,
+
+        /* Eth  (PTL/PTN/PTX) */
+        GPIO_FN_RMII_RXD0,    GPIO_FN_RMII_RXD1,
+        GPIO_FN_RMII_TXD0,    GPIO_FN_RMII_TXD1,
+        GPIO_FN_RMII_REF_CLK, GPIO_FN_RMII_TX_EN,
+        GPIO_FN_RMII_RX_ER,   GPIO_FN_RMII_CRS_DV,
+        GPIO_FN_LNKSTA,       GPIO_FN_MDIO,
+        GPIO_FN_MDC,
+
+        /* System (PTJ) */
+        GPIO_FN_PDSTATUS, GPIO_FN_STATUS2, GPIO_FN_STATUS0,
+
+        /* VOU (PTL/PTM/PTN*/
+        GPIO_FN_DV_D15,  GPIO_FN_DV_D14, GPIO_FN_DV_D13,   GPIO_FN_DV_D12,
+        GPIO_FN_DV_D11,  GPIO_FN_DV_D10, GPIO_FN_DV_D9,    GPIO_FN_DV_D8,
+        GPIO_FN_DV_D7,   GPIO_FN_DV_D6,  GPIO_FN_DV_D5,    GPIO_FN_DV_D4,
+        GPIO_FN_DV_D3,   GPIO_FN_DV_D2,  GPIO_FN_DV_D1,    GPIO_FN_DV_D0,
+        GPIO_FN_DV_CLKI, GPIO_FN_DV_CLK, GPIO_FN_DV_VSYNC, GPIO_FN_DV_HSYNC,
+
+        /* MSIOF0 (PTL/PTM) */
+        GPIO_FN_MSIOF0_RXD,   GPIO_FN_MSIOF0_TXD,
+        GPIO_FN_MSIOF0_MCK,   GPIO_FN_MSIOF0_TSCK,
+        GPIO_FN_MSIOF0_SS1,   GPIO_FN_MSIOF0_SS2,
+        GPIO_FN_MSIOF0_TSYNC, GPIO_FN_MSIOF0_RSCK,
+        GPIO_FN_MSIOF0_RSYNC,
+
+        /* MSIOF1 (PTV) */
+        GPIO_FN_MSIOF1_RXD,   GPIO_FN_MSIOF1_TXD,
+        GPIO_FN_MSIOF1_MCK,   GPIO_FN_MSIOF1_TSCK,
+        GPIO_FN_MSIOF1_SS1,   GPIO_FN_MSIOF1_SS2,
+        GPIO_FN_MSIOF1_TSYNC, GPIO_FN_MSIOF1_RSCK,
+        GPIO_FN_MSIOF1_RSYNC,
+
+        /* DMAC (PTU/PTX) */
+        GPIO_FN_DMAC_DACK0, GPIO_FN_DMAC_DREQ0,
+        GPIO_FN_DMAC_DACK1, GPIO_FN_DMAC_DREQ1,
+
+        /* SDHI0 (PTY) */
+        GPIO_FN_SDHI0CD, GPIO_FN_SDHI0WP, GPIO_FN_SDHI0CMD, GPIO_FN_SDHI0CLK,
+        GPIO_FN_SDHI0D3, GPIO_FN_SDHI0D2, GPIO_FN_SDHI0D1,  GPIO_FN_SDHI0D0,
+
+        /* SDHI1 (PTW) */
+        GPIO_FN_SDHI1CD, GPIO_FN_SDHI1WP, GPIO_FN_SDHI1CMD, GPIO_FN_SDHI1CLK,
+        GPIO_FN_SDHI1D3, GPIO_FN_SDHI1D2, GPIO_FN_SDHI1D1,  GPIO_FN_SDHI1D0,
+
+        /* MMC (PTW/PTX)*/
+        GPIO_FN_MMC_D7,  GPIO_FN_MMC_D6,  GPIO_FN_MMC_D5, GPIO_FN_MMC_D4,
+        GPIO_FN_MMC_D3,  GPIO_FN_MMC_D2,  GPIO_FN_MMC_D1, GPIO_FN_MMC_D0,
+        GPIO_FN_MMC_CLK, GPIO_FN_MMC_CMD,
+
+        /* IrDA (PTX) */
+        GPIO_FN_IRDA_OUT, GPIO_FN_IRDA_IN,
+
+        /* TSIF (PTX) */
+        GPIO_FN_TSIF_TS0_SDAT, GPIO_FN_TSIF_TS0_SCK,
+        GPIO_FN_TSIF_TS0_SDEN, GPIO_FN_TSIF_TS0_SPSYNC,
+
+        /* IRQ (PTZ) */
+        GPIO_FN_INTC_IRQ7, GPIO_FN_INTC_IRQ6, GPIO_FN_INTC_IRQ5,
+        GPIO_FN_INTC_IRQ4, GPIO_FN_INTC_IRQ3, GPIO_FN_INTC_IRQ2,
+        GPIO_FN_INTC_IRQ1, GPIO_FN_INTC_IRQ0,
+};
+
+#endif /* __ASM_SH7724_H__ */
diff --git a/arch/sh/include/cpu-sh4/cpu/sh7785.h b/arch/sh/include/cpu-sh4/cpu/sh7785.h
index e4006afb735e..9dc9d91e0a8e 100644
--- a/arch/sh/include/cpu-sh4/cpu/sh7785.h
+++ b/arch/sh/include/cpu-sh4/cpu/sh7785.h
@@ -1,6 +1,31 @@
 #ifndef __ASM_SH7785_H__
 #define __ASM_SH7785_H__
 
+/* Boot Mode Pins:
+ *
+ * MODE0: CPG - Initial Pck/Bck Frequency [FRQMR1]
+ * MODE1: CPG - Initial Uck/SHck/DDRck Frequency [FRQMR1]
+ * MODE2: CPG - Reserved (L: Normal operation)
+ * MODE3: CPG - Reserved (L: Normal operation)
+ * MODE4: CPG - Initial PLL setting (72x/36x)
+ * MODE5: LBSC - Area0 Memory Type / Bus Width [CS0BCR.8]
+ * MODE6: LBSC - Area0 Memory Type / Bus Width [CS0BCR.9]
+ * MODE7: LBSC - Area0 Memory Type / Bus Width [CS0BCR.3]
+ * MODE8: LBSC - Endian Mode (L: Big, H: Little) [BCR.31]
+ * MODE9: LBSC - Master/Slave Mode (L: Slave) [BCR.30]
+ * MODE10: CPG - Clock Input (L: Ext Clk, H: Crystal)
+ * MODE11: PCI - Pin Mode (LL: PCI host, LH: PCI slave)
+ * MODE12: PCI - Pin Mode (HL: Local bus, HH: DU)
+ * MODE13: Boot Address Mode (L: 29-bit, H: 32-bit)
+ * MODE14: Reserved (H: Normal operation)
+ *
+ * More information in sh7785 manual Rev.1.00, page 1628.
+ */
+
+/* Pin Function Controller:
+ * GPIO_FN_xx - GPIO used to select pin function
+ * GPIO_Pxx - GPIO mapped to real I/O pin on CPU
+ */
 enum {
         /* PA */
         GPIO_PA7, GPIO_PA6, GPIO_PA5, GPIO_PA4,
diff --git a/arch/sh/include/cpu-sh4/cpu/timer.h b/arch/sh/include/cpu-sh4/cpu/timer.h
deleted file mode 100644
index d1e796b96888..000000000000
--- a/arch/sh/include/cpu-sh4/cpu/timer.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * include/asm-sh/cpu-sh4/timer.h
- *
- * Copyright (C) 2004 Lineo Solutions, Inc.
- *
- * 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.
- */
-#ifndef __ASM_CPU_SH4_TIMER_H
-#define __ASM_CPU_SH4_TIMER_H
-
-/*
- * ---------------------------------------------------------------------------
- * TMU Common definitions for SH4 processors
- *      SH7750S/SH7750R
- *      SH7751/SH7751R
- *      SH7760
- *      SH-X3
- * ---------------------------------------------------------------------------
- */
-#ifdef CONFIG_CPU_SUBTYPE_SHX3
-#define TMU_012_BASE    0xffc10000
-#define TMU_345_BASE    0xffc20000
-#else
-#define TMU_012_BASE    0xffd80000
-#define TMU_345_BASE    0xfe100000
-#endif
-
-#define TMU_TOCR        TMU_012_BASE    /* Not supported on all CPUs */
-
-#define TMU_012_TSTR    (TMU_012_BASE + 0x04)
-#define TMU_345_TSTR    (TMU_345_BASE + 0x04)
-
-#define TMU0_TCOR       (TMU_012_BASE + 0x08)
-#define TMU0_TCNT       (TMU_012_BASE + 0x0c)
-#define TMU0_TCR        (TMU_012_BASE + 0x10)
-
-#define TMU1_TCOR       (TMU_012_BASE + 0x14)
-#define TMU1_TCNT       (TMU_012_BASE + 0x18)
-#define TMU1_TCR        (TMU_012_BASE + 0x1c)
-
-#define TMU2_TCOR       (TMU_012_BASE + 0x20)
-#define TMU2_TCNT       (TMU_012_BASE + 0x24)
-#define TMU2_TCR        (TMU_012_BASE + 0x28)
-#define TMU2_TCPR       (TMU_012_BASE + 0x2c)
-
-#define TMU3_TCOR       (TMU_345_BASE + 0x08)
-#define TMU3_TCNT       (TMU_345_BASE + 0x0c)
-#define TMU3_TCR        (TMU_345_BASE + 0x10)
-
-#define TMU4_TCOR       (TMU_345_BASE + 0x14)
-#define TMU4_TCNT       (TMU_345_BASE + 0x18)
-#define TMU4_TCR        (TMU_345_BASE + 0x1c)
-
-#define TMU5_TCOR       (TMU_345_BASE + 0x20)
-#define TMU5_TCNT       (TMU_345_BASE + 0x24)
-#define TMU5_TCR        (TMU_345_BASE + 0x28)
-
-#endif /* __ASM_CPU_SH4_TIMER_H */
diff --git a/arch/sh/include/cpu-sh5/cpu/irq.h b/arch/sh/include/cpu-sh5/cpu/irq.h
index f0f0756e6e84..0ccf257a72d1 100644
--- a/arch/sh/include/cpu-sh5/cpu/irq.h
+++ b/arch/sh/include/cpu-sh5/cpu/irq.h
@@ -111,7 +111,6 @@
 #define TOP_PRIORITY    15
 
 extern int intc_evt_to_irq[(0xE20/0x20)+1];
-int intc_irq_describe(char* p, int irq);
 extern int platform_int_priority[NR_INTC_IRQS];
 
 #endif /* __ASM_SH_CPU_SH5_IRQ_H */
diff --git a/arch/sh/include/mach-common/mach/sh7785lcr.h b/arch/sh/include/mach-common/mach/sh7785lcr.h
index 1ce27d5c7491..90011d435f30 100644
--- a/arch/sh/include/mach-common/mach/sh7785lcr.h
+++ b/arch/sh/include/mach-common/mach/sh7785lcr.h
@@ -9,11 +9,11 @@
  * -----------------------------+---------------+---------------
  * 0x00000000 - 0x03ffffff(CS0) | NOR Flash     | NOR Flash
  * 0x04000000 - 0x05ffffff(CS1) | PLD           | PLD
- * 0x06000000 - 0x07ffffff(CS1) | reserved      | I2C
+ * 0x06000000 - 0x07ffffff(CS1) | I2C           | I2C
  * 0x08000000 - 0x0bffffff(CS2) | USB           | DDR SDRAM
  * 0x0c000000 - 0x0fffffff(CS3) | SD            | DDR SDRAM
  * 0x10000000 - 0x13ffffff(CS4) | SM107         | SM107
- * 0x14000000 - 0x17ffffff(CS5) | I2C           | USB
+ * 0x14000000 - 0x17ffffff(CS5) | reserved      | USB
  * 0x18000000 - 0x1bffffff(CS6) | reserved      | SD
  * 0x40000000 - 0x5fffffff      | DDR SDRAM     | (cannot use)
  *
@@ -32,6 +32,9 @@
 #define PLD_VERSR               (PLD_BASE_ADDR + 0x0c)
 #define PLD_MMSR                (PLD_BASE_ADDR + 0x0e)
 
+#define PCA9564_ADDR            0x06000000      /* I2C */
+#define PCA9564_SIZE            0x00000100
+
 #define SM107_MEM_ADDR          0x10000000
 #define SM107_MEM_SIZE          0x00e00000
 #define SM107_REG_ADDR          0x13e00000
@@ -40,16 +43,13 @@
 #if defined(CONFIG_SH_SH7785LCR_29BIT_PHYSMAPS)
 #define R8A66597_ADDR           0x14000000      /* USB */
 #define CG200_ADDR              0x18000000      /* SD */
-#define PCA9564_ADDR            0x06000000      /* I2C */
 #else
 #define R8A66597_ADDR           0x08000000
 #define CG200_ADDR              0x0c000000
-#define PCA9564_ADDR            0x14000000
 #endif
 
 #define R8A66597_SIZE           0x00000100
 #define CG200_SIZE              0x00010000
-#define PCA9564_SIZE            0x00000100
 
 #endif  /* __ASM_SH_RENESAS_SH7785LCR_H */
 
diff --git a/arch/sh/include/mach-dreamcast/mach/pci.h b/arch/sh/include/mach-dreamcast/mach/pci.h
index 75fc9009e092..0314d975e626 100644
--- a/arch/sh/include/mach-dreamcast/mach/pci.h
+++ b/arch/sh/include/mach-dreamcast/mach/pci.h
@@ -21,5 +21,7 @@
 
 #define GAPSPCI_IRQ             HW_EVENT_EXTERNAL
 
+extern struct pci_ops gapspci_pci_ops;
+
 #endif /* __ASM_SH_DREAMCAST_PCI_H */
 
diff --git a/arch/sh/include/mach-se/mach/se7724.h b/arch/sh/include/mach-se/mach/se7724.h
new file mode 100644
index 000000000000..74164b60d0db
--- /dev/null
+++ b/arch/sh/include/mach-se/mach/se7724.h
@@ -0,0 +1,67 @@
+#ifndef __ASM_SH_SE7724_H
+#define __ASM_SH_SE7724_H
+
+/*
+ * linux/include/asm-sh/se7724.h
+ *
+ * Copyright (C) 2009 Renesas Solutions Corp.
+ *
+ * Kuninori Morimoto <morimoto.kuninori@renesas.com>
+ *
+ * Hitachi UL SolutionEngine 7724 Support.
+ *
+ * Based on se7722.h
+ * Copyright (C) 2007  Nobuhiro Iwamatsu
+ *
+ * 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.
+ *
+ */
+#include <asm/addrspace.h>
+
+#define PA_LED          (0xba203000)    /* 8bit LED */
+#define IRQ_MODE        (0xba200010)
+#define IRQ0_SR         (0xba200014)
+#define IRQ1_SR         (0xba200018)
+#define IRQ2_SR         (0xba20001c)
+#define IRQ0_MR         (0xba200020)
+#define IRQ1_MR         (0xba200024)
+#define IRQ2_MR         (0xba200028)
+
+/* IRQ */
+#define IRQ0_IRQ        32
+#define IRQ1_IRQ        33
+#define IRQ2_IRQ        34
+
+/* Bits in IRQ012 registers */
+#define SE7724_FPGA_IRQ_BASE    220
+
+/* IRQ0 */
+#define IRQ0_BASE       SE7724_FPGA_IRQ_BASE
+#define IRQ0_KEY        (IRQ0_BASE + 12)
+#define IRQ0_RMII       (IRQ0_BASE + 13)
+#define IRQ0_SMC        (IRQ0_BASE + 14)
+#define IRQ0_MASK       0x7fff
+#define IRQ0_END        IRQ0_SMC
+/* IRQ1 */
+#define IRQ1_BASE       (IRQ0_END + 1)
+#define IRQ1_TS         (IRQ1_BASE + 0)
+#define IRQ1_MASK       0x0001
+#define IRQ1_END        IRQ1_TS
+/* IRQ2 */
+#define IRQ2_BASE       (IRQ1_END + 1)
+#define IRQ2_USB0       (IRQ1_BASE + 0)
+#define IRQ2_USB1       (IRQ1_BASE + 1)
+#define IRQ2_MASK       0x0003
+#define IRQ2_END        IRQ2_USB1
+
+#define SE7724_FPGA_IRQ_NR      (IRQ2_END - IRQ0_BASE)
+
+/* arch/sh/boards/se/7724/irq.c */
+void init_se7724_IRQ(void);
+
+#define __IO_PREFIX             se7724
+#include <asm/io_generic.h>
+
+#endif  /* __ASM_SH_SE7724_H */
diff --git a/arch/sh/kernel/Makefile_32 b/arch/sh/kernel/Makefile_32
index 82a3a150c00d..9411e3e31e68 100644
--- a/arch/sh/kernel/Makefile_32
+++ b/arch/sh/kernel/Makefile_32
@@ -11,10 +11,10 @@ endif
 
 obj-y   := debugtraps.o idle.o io.o io_generic.o irq.o                  \
            machvec.o process_32.o ptrace_32.o setup.o signal_32.o       \
-           sys_sh.o sys_sh32.o syscalls_32.o time_32.o topology.o       \
+           sys_sh.o sys_sh32.o syscalls_32.o time.o topology.o  \
            traps.o traps_32.o
 
-obj-y                           += cpu/ timers/
+obj-y                           += cpu/
 obj-$(CONFIG_VSYSCALL)          += vsyscall/
 obj-$(CONFIG_SMP)               += smp.o
 obj-$(CONFIG_SH_STANDARD_BIOS)  += sh_bios.o
@@ -32,4 +32,6 @@ obj-$(CONFIG_DYNAMIC_FTRACE)	+= ftrace.o
 obj-$(CONFIG_DUMP_CODE)         += disassemble.o
 obj-$(CONFIG_HIBERNATION)       += swsusp.o
 
+obj-$(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST)     += localtimer.o
+
 EXTRA_CFLAGS += -Werror
diff --git a/arch/sh/kernel/Makefile_64 b/arch/sh/kernel/Makefile_64
index fe425d7f6871..67b9f6c6326b 100644
--- a/arch/sh/kernel/Makefile_64
+++ b/arch/sh/kernel/Makefile_64
@@ -2,19 +2,18 @@ extra-y	:= head_64.o init_task.o vmlinux.lds
 
 obj-y   := debugtraps.o idle.o io.o io_generic.o irq.o machvec.o process_64.o \
            ptrace_64.o setup.o signal_64.o sys_sh.o sys_sh64.o \
-           syscalls_64.o time_64.o topology.o traps.o traps_64.o
+           syscalls_64.o time.o topology.o traps.o traps_64.o
 
-obj-y                           += cpu/ timers/
-obj-$(CONFIG_VSYSCALL)          += vsyscall/
+obj-y                           += cpu/
 obj-$(CONFIG_SMP)               += smp.o
-obj-$(CONFIG_SH_STANDARD_BIOS)  += sh_bios.o
 obj-$(CONFIG_SH_CPU_FREQ)       += cpufreq.o
 obj-$(CONFIG_MODULES)           += sh_ksyms_64.o module.o
 obj-$(CONFIG_EARLY_PRINTK)      += early_printk.o
-obj-$(CONFIG_KEXEC)             += machine_kexec.o relocate_kernel.o
 obj-$(CONFIG_CRASH_DUMP)        += crash_dump.o
 obj-$(CONFIG_STACKTRACE)        += stacktrace.o
 obj-$(CONFIG_IO_TRAPPED)        += io_trapped.o
 obj-$(CONFIG_GENERIC_GPIO)      += gpio.o
 
+obj-$(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST)     += localtimer.o
+
 EXTRA_CFLAGS += -Werror
diff --git a/arch/sh/kernel/cpu/Makefile b/arch/sh/kernel/cpu/Makefile
index 2600641a483f..eecad7cbd61e 100644
--- a/arch/sh/kernel/cpu/Makefile
+++ b/arch/sh/kernel/cpu/Makefile
@@ -17,5 +17,6 @@ obj-$(CONFIG_ARCH_SHMOBILE)	+= shmobile/
 
 obj-$(CONFIG_UBC_WAKEUP)        += ubc.o
 obj-$(CONFIG_SH_ADC)            += adc.o
+obj-$(CONFIG_SH_CLK_CPG)        += clock-cpg.o
 
 obj-y   += irq/ init.o clock.o
diff --git a/arch/sh/kernel/cpu/clock-cpg.c b/arch/sh/kernel/cpu/clock-cpg.c
new file mode 100644
index 000000000000..275942e58e4f
--- /dev/null
+++ b/arch/sh/kernel/cpu/clock-cpg.c
@@ -0,0 +1,256 @@
+#include <linux/clk.h>
+#include <linux/compiler.h>
+#include <linux/bootmem.h>
+#include <linux/io.h>
+#include <asm/clock.h>
+
+static int sh_clk_mstp32_enable(struct clk *clk)
+{
+        __raw_writel(__raw_readl(clk->enable_reg) & ~(1 << clk->enable_bit),
+                     clk->enable_reg);
+        return 0;
+}
+
+static void sh_clk_mstp32_disable(struct clk *clk)
+{
+        __raw_writel(__raw_readl(clk->enable_reg) | (1 << clk->enable_bit),
+                     clk->enable_reg);
+}
+
+static struct clk_ops sh_clk_mstp32_clk_ops = {
+        .enable         = sh_clk_mstp32_enable,
+        .disable        = sh_clk_mstp32_disable,
+        .recalc         = followparent_recalc,
+};
+
+int __init sh_clk_mstp32_register(struct clk *clks, int nr)
+{
+        struct clk *clkp;
+        int ret = 0;
+        int k;
+
+        for (k = 0; !ret && (k < nr); k++) {
+                clkp = clks + k;
+                clkp->ops = &sh_clk_mstp32_clk_ops;
+                ret |= clk_register(clkp);
+        }
+
+        return ret;
+}
+
+static long sh_clk_div_round_rate(struct clk *clk, unsigned long rate)
+{
+        return clk_rate_table_round(clk, clk->freq_table, rate);
+}
+
+static int sh_clk_div6_divisors[64] = {
+        1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+        17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+        33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
+        49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64
+};
+
+static struct clk_div_mult_table sh_clk_div6_table = {
+        .divisors = sh_clk_div6_divisors,
+        .nr_divisors = ARRAY_SIZE(sh_clk_div6_divisors),
+};
+
+static unsigned long sh_clk_div6_recalc(struct clk *clk)
+{
+        struct clk_div_mult_table *table = &sh_clk_div6_table;
+        unsigned int idx;
+
+        clk_rate_table_build(clk, clk->freq_table, table->nr_divisors,
+                             table, NULL);
+
+        idx = __raw_readl(clk->enable_reg) & 0x003f;
+
+        return clk->freq_table[idx].frequency;
+}
+
+static int sh_clk_div6_set_rate(struct clk *clk,
+                                unsigned long rate, int algo_id)
+{
+        unsigned long value;
+        int idx;
+
+        idx = clk_rate_table_find(clk, clk->freq_table, rate);
+        if (idx < 0)
+                return idx;
+
+        value = __raw_readl(clk->enable_reg);
+        value &= ~0x3f;
+        value |= idx;
+        __raw_writel(value, clk->enable_reg);
+        return 0;
+}
+
+static int sh_clk_div6_enable(struct clk *clk)
+{
+        unsigned long value;
+        int ret;
+
+        ret = sh_clk_div6_set_rate(clk, clk->rate, 0);
+        if (ret == 0) {
+                value = __raw_readl(clk->enable_reg);
+                value &= ~0x100; /* clear stop bit to enable clock */
+                __raw_writel(value, clk->enable_reg);
+        }
+        return ret;
+}
+
+static void sh_clk_div6_disable(struct clk *clk)
+{
+        unsigned long value;
+
+        value = __raw_readl(clk->enable_reg);
+        value |= 0x100; /* stop clock */
+        value |= 0x3f; /* VDIV bits must be non-zero, overwrite divider */
+        __raw_writel(value, clk->enable_reg);
+}
+
+static struct clk_ops sh_clk_div6_clk_ops = {
+        .recalc         = sh_clk_div6_recalc,
+        .round_rate     = sh_clk_div_round_rate,
+        .set_rate       = sh_clk_div6_set_rate,
+        .enable         = sh_clk_div6_enable,
+        .disable        = sh_clk_div6_disable,
+};
+
+int __init sh_clk_div6_register(struct clk *clks, int nr)
+{
+        struct clk *clkp;
+        void *freq_table;
+        int nr_divs = sh_clk_div6_table.nr_divisors;
+        int freq_table_size = sizeof(struct cpufreq_frequency_table);
+        int ret = 0;
+        int k;
+
+        freq_table_size *= (nr_divs + 1);
+
+        freq_table = alloc_bootmem(freq_table_size * nr);
+        if (!freq_table)
+                return -ENOMEM;
+
+        for (k = 0; !ret && (k < nr); k++) {
+                clkp = clks + k;
+
+                clkp->ops = &sh_clk_div6_clk_ops;
+                clkp->id = -1;
+                clkp->freq_table = freq_table + (k * freq_table_size);
+                clkp->freq_table[nr_divs].frequency = CPUFREQ_TABLE_END;
+
+                ret = clk_register(clkp);
+        }
+
+        return ret;
+}
+
+static unsigned long sh_clk_div4_recalc(struct clk *clk)
+{
+        struct clk_div_mult_table *table = clk->priv;
+        unsigned int idx;
+
+        clk_rate_table_build(clk, clk->freq_table, table->nr_divisors,
+                             table, &clk->arch_flags);
+
+        idx = (__raw_readl(clk->enable_reg) >> clk->enable_bit) & 0x000f;
+
+        return clk->freq_table[idx].frequency;
+}
+
+static struct clk_ops sh_clk_div4_clk_ops = {
+        .recalc         = sh_clk_div4_recalc,
+        .round_rate     = sh_clk_div_round_rate,
+};
+
+int __init sh_clk_div4_register(struct clk *clks, int nr,
+                                struct clk_div_mult_table *table)
+{
+        struct clk *clkp;
+        void *freq_table;
+        int nr_divs = table->nr_divisors;
+        int freq_table_size = sizeof(struct cpufreq_frequency_table);
+        int ret = 0;
+        int k;
+
+        freq_table_size *= (nr_divs + 1);
+
+        freq_table = alloc_bootmem(freq_table_size * nr);
+        if (!freq_table)
+                return -ENOMEM;
+
+        for (k = 0; !ret && (k < nr); k++) {
+                clkp = clks + k;
+
+                clkp->ops = &sh_clk_div4_clk_ops;
+                clkp->id = -1;
+                clkp->priv = table;
+
+                clkp->freq_table = freq_table + (k * freq_table_size);
+                clkp->freq_table[nr_divs].frequency = CPUFREQ_TABLE_END;
+
+                ret = clk_register(clkp);
+        }
+
+        return ret;
+}
+
+#ifdef CONFIG_SH_CLK_CPG_LEGACY
+static struct clk master_clk = {
+        .name           = "master_clk",
+        .flags          = CLK_ENABLE_ON_INIT,
+        .rate           = CONFIG_SH_PCLK_FREQ,
+};
+
+static struct clk peripheral_clk = {
+        .name           = "peripheral_clk",
+        .parent         = &master_clk,
+        .flags          = CLK_ENABLE_ON_INIT,
+};
+
+static struct clk bus_clk = {
+        .name           = "bus_clk",
+        .parent         = &master_clk,
+        .flags          = CLK_ENABLE_ON_INIT,
+};
+
+static struct clk cpu_clk = {
+        .name           = "cpu_clk",
+        .parent         = &master_clk,
+        .flags          = CLK_ENABLE_ON_INIT,
+};
+
+/*
+ * The ordering of these clocks matters, do not change it.
+ */
+static struct clk *onchip_clocks[] = {
+        &master_clk,
+        &peripheral_clk,
+        &bus_clk,
+        &cpu_clk,
+};
+
+int __init __deprecated cpg_clk_init(void)
+{
+        int i, ret = 0;
+
+        for (i = 0; i < ARRAY_SIZE(onchip_clocks); i++) {
+                struct clk *clk = onchip_clocks[i];
+                arch_init_clk_ops(&clk->ops, i);
+                if (clk->ops)
+                        ret |= clk_register(clk);
+        }
+
+        return ret;
+}
+
+/*
+ * Placeholder for compatability, until the lazy CPUs do this
+ * on their own.
+ */
+int __init __weak arch_clk_init(void)
+{
+        return cpg_clk_init();
+}
+#endif /* CONFIG_SH_CPG_CLK_LEGACY */
diff --git a/arch/sh/kernel/cpu/clock.c b/arch/sh/kernel/cpu/clock.c
index 1dc896483b59..f3a46be2ae81 100644
--- a/arch/sh/kernel/cpu/clock.c
+++ b/arch/sh/kernel/cpu/clock.c
@@ -1,15 +1,19 @@
 /*
  * arch/sh/kernel/cpu/clock.c - SuperH clock framework
  *
- *  Copyright (C) 2005, 2006, 2007  Paul Mundt
+ *  Copyright (C) 2005 - 2009  Paul Mundt
  *
  * This clock framework is derived from the OMAP version by:
  *
- *      Copyright (C) 2004 - 2005 Nokia Corporation
+ *      Copyright (C) 2004 - 2008 Nokia Corporation
  *      Written by Tuukka Tikkanen <tuukka.tikkanen@elektrobit.com>
  *
  *  Modified for omap shared clock framework by Tony Lindgren <tony@atomide.com>
  *
+ *  With clkdev bits:
+ *
+ *      Copyright (C) 2008 Russell King.
+ *
  * 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.
@@ -19,134 +23,159 @@
 #include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/list.h>
-#include <linux/kref.h>
 #include <linux/kobject.h>
 #include <linux/sysdev.h>
 #include <linux/seq_file.h>
 #include <linux/err.h>
 #include <linux/platform_device.h>
-#include <linux/proc_fs.h>
+#include <linux/debugfs.h>
+#include <linux/cpufreq.h>
 #include <asm/clock.h>
-#include <asm/timer.h>
+#include <asm/machvec.h>
 
 static LIST_HEAD(clock_list);
 static DEFINE_SPINLOCK(clock_lock);
 static DEFINE_MUTEX(clock_list_sem);
 
-/*
- * Each subtype is expected to define the init routines for these clocks,
- * as each subtype (or processor family) will have these clocks at the
- * very least. These are all provided through the CPG, which even some of
- * the more quirky parts (such as ST40, SH4-202, etc.) still have.
- *
- * The processor-specific code is expected to register any additional
- * clock sources that are of interest.
- */
-static struct clk master_clk = {
-        .name           = "master_clk",
-        .flags          = CLK_ALWAYS_ENABLED | CLK_RATE_PROPAGATES,
-        .rate           = CONFIG_SH_PCLK_FREQ,
-};
+void clk_rate_table_build(struct clk *clk,
+                          struct cpufreq_frequency_table *freq_table,
+                          int nr_freqs,
+                          struct clk_div_mult_table *src_table,
+                          unsigned long *bitmap)
+{
+        unsigned long mult, div;
+        unsigned long freq;
+        int i;
 
-static struct clk module_clk = {
-        .name           = "module_clk",
-        .parent         = &master_clk,
-        .flags          = CLK_ALWAYS_ENABLED | CLK_RATE_PROPAGATES,
-};
+        for (i = 0; i < nr_freqs; i++) {
+                div = 1;
+                mult = 1;
 
-static struct clk bus_clk = {
-        .name           = "bus_clk",
-        .parent         = &master_clk,
-        .flags          = CLK_ALWAYS_ENABLED | CLK_RATE_PROPAGATES,
-};
+                if (src_table->divisors && i < src_table->nr_divisors)
+                        div = src_table->divisors[i];
 
-static struct clk cpu_clk = {
-        .name           = "cpu_clk",
-        .parent         = &master_clk,
-        .flags          = CLK_ALWAYS_ENABLED,
-};
+                if (src_table->multipliers && i < src_table->nr_multipliers)
+                        mult = src_table->multipliers[i];
 
-/*
- * The ordering of these clocks matters, do not change it.
- */
-static struct clk *onchip_clocks[] = {
-        &master_clk,
-        &module_clk,
-        &bus_clk,
-        &cpu_clk,
-};
+                if (!div || !mult || (bitmap && !test_bit(i, bitmap)))
+                        freq = CPUFREQ_ENTRY_INVALID;
+                else
+                        freq = clk->parent->rate * mult / div;
 
-static void propagate_rate(struct clk *clk)
+                freq_table[i].index = i;
+                freq_table[i].frequency = freq;
+        }
+
+        /* Termination entry */
+        freq_table[i].index = i;
+        freq_table[i].frequency = CPUFREQ_TABLE_END;
+}
+
+long clk_rate_table_round(struct clk *clk,
+                          struct cpufreq_frequency_table *freq_table,
+                          unsigned long rate)
 {
-        struct clk *clkp;
+        unsigned long rate_error, rate_error_prev = ~0UL;
+        unsigned long rate_best_fit = rate;
+        unsigned long highest, lowest;
+        int i;
+
+        highest = lowest = 0;
+
+        for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
+                unsigned long freq = freq_table[i].frequency;
 
-        list_for_each_entry(clkp, &clock_list, node) {
-                if (likely(clkp->parent != clk))
+                if (freq == CPUFREQ_ENTRY_INVALID)
                         continue;
-                if (likely(clkp->ops && clkp->ops->recalc))
-                        clkp->ops->recalc(clkp);
-                if (unlikely(clkp->flags & CLK_RATE_PROPAGATES))
-                        propagate_rate(clkp);
+
+                if (freq > highest)
+                        highest = freq;
+                if (freq < lowest)
+                        lowest = freq;
+
+                rate_error = abs(freq - rate);
+                if (rate_error < rate_error_prev) {
+                        rate_best_fit = freq;
+                        rate_error_prev = rate_error;
+                }
+
+                if (rate_error == 0)
+                        break;
         }
+
+        if (rate >= highest)
+                rate_best_fit = highest;
+        if (rate <= lowest)
+                rate_best_fit = lowest;
+
+        return rate_best_fit;
 }
 
-static int __clk_enable(struct clk *clk)
+int clk_rate_table_find(struct clk *clk,
+                        struct cpufreq_frequency_table *freq_table,
+                        unsigned long rate)
 {
-        /*
-         * See if this is the first time we're enabling the clock, some
-         * clocks that are always enabled still require "special"
-         * initialization. This is especially true if the clock mode
-         * changes and the clock needs to hunt for the proper set of
-         * divisors to use before it can effectively recalc.
-         */
-        if (unlikely(atomic_read(&clk->kref.refcount) == 1))
-                if (clk->ops && clk->ops->init)
-                        clk->ops->init(clk);
+        int i;
 
-        kref_get(&clk->kref);
+        for (i = 0; freq_table[i].frequency != CPUFREQ_TABLE_END; i++) {
+                unsigned long freq = freq_table[i].frequency;
 
-        if (clk->flags & CLK_ALWAYS_ENABLED)
-                return 0;
+                if (freq == CPUFREQ_ENTRY_INVALID)
+                        continue;
 
-        if (likely(clk->ops && clk->ops->enable))
-                clk->ops->enable(clk);
+                if (freq == rate)
+                        return i;
+        }
 
-        return 0;
+        return -ENOENT;
 }
 
-int clk_enable(struct clk *clk)
+/* Used for clocks that always have same value as the parent clock */
+unsigned long followparent_recalc(struct clk *clk)
 {
-        unsigned long flags;
-        int ret;
-
-        if (!clk)
-                return -EINVAL;
+        return clk->parent ? clk->parent->rate : 0;
+}
 
-        clk_enable(clk->parent);
+int clk_reparent(struct clk *child, struct clk *parent)
+{
+        list_del_init(&child->sibling);
+        if (parent)
+                list_add(&child->sibling, &parent->children);
+        child->parent = parent;
 
-        spin_lock_irqsave(&clock_lock, flags);
-        ret = __clk_enable(clk);
-        spin_unlock_irqrestore(&clock_lock, flags);
+        /* now do the debugfs renaming to reattach the child
+           to the proper parent */
 
-        return ret;
+        return 0;
 }
-EXPORT_SYMBOL_GPL(clk_enable);
 
-static void clk_kref_release(struct kref *kref)
+/* Propagate rate to children */
+void propagate_rate(struct clk *tclk)
 {
-        /* Nothing to do */
+        struct clk *clkp;
+
+        list_for_each_entry(clkp, &tclk->children, sibling) {
+                if (clkp->ops && clkp->ops->recalc)
+                        clkp->rate = clkp->ops->recalc(clkp);
+
+                propagate_rate(clkp);
+        }
 }
 
 static void __clk_disable(struct clk *clk)
 {
-        int count = kref_put(&clk->kref, clk_kref_release);
-
-        if (clk->flags & CLK_ALWAYS_ENABLED)
+        if (clk->usecount == 0) {
+                printk(KERN_ERR "Trying disable clock %s with 0 usecount\n",
+                       clk->name);
+                WARN_ON(1);
                 return;
+        }
 
-        if (!count) {   /* count reaches zero, disable the clock */
+        if (!(--clk->usecount)) {
                 if (likely(clk->ops && clk->ops->disable))
                         clk->ops->disable(clk);
+                if (likely(clk->parent))
+                        __clk_disable(clk->parent);
         }
 }
 
@@ -160,28 +189,97 @@ void clk_disable(struct clk *clk)
         spin_lock_irqsave(&clock_lock, flags);
         __clk_disable(clk);
         spin_unlock_irqrestore(&clock_lock, flags);
-
-        clk_disable(clk->parent);
 }
 EXPORT_SYMBOL_GPL(clk_disable);
 
+static int __clk_enable(struct clk *clk)
+{
+        int ret = 0;
+
+        if (clk->usecount++ == 0) {
+                if (clk->parent) {
+                        ret = __clk_enable(clk->parent);
+                        if (unlikely(ret))
+                                goto err;
+                }
+
+                if (clk->ops && clk->ops->enable) {
+                        ret = clk->ops->enable(clk);
+                        if (ret) {
+                                if (clk->parent)
+                                        __clk_disable(clk->parent);
+                                goto err;
+                        }
+                }
+        }
+
+        return ret;
+err:
+        clk->usecount--;
+        return ret;
+}
+
+int clk_enable(struct clk *clk)
+{
+        unsigned long flags;
+        int ret;
+
+        if (!clk)
+                return -EINVAL;
+
+        spin_lock_irqsave(&clock_lock, flags);
+        ret = __clk_enable(clk);
+        spin_unlock_irqrestore(&clock_lock, flags);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(clk_enable);
+
+static LIST_HEAD(root_clks);
+
+/**
+ * recalculate_root_clocks - recalculate and propagate all root clocks
+ *
+ * Recalculates all root clocks (clocks with no parent), which if the
+ * clock's .recalc is set correctly, should also propagate their rates.
+ * Called at init.
+ */
+void recalculate_root_clocks(void)
+{
+        struct clk *clkp;
+
+        list_for_each_entry(clkp, &root_clks, sibling) {
+                if (clkp->ops && clkp->ops->recalc)
+                        clkp->rate = clkp->ops->recalc(clkp);
+                propagate_rate(clkp);
+        }
+}
+
 int clk_register(struct clk *clk)
 {
+        if (clk == NULL || IS_ERR(clk))
+                return -EINVAL;
+
+        /*
+         * trap out already registered clocks
+         */
+        if (clk->node.next || clk->node.prev)
+                return 0;
+
         mutex_lock(&clock_list_sem);
 
-        list_add(&clk->node, &clock_list);
-        kref_init(&clk->kref);
+        INIT_LIST_HEAD(&clk->children);
+        clk->usecount = 0;
 
-        mutex_unlock(&clock_list_sem);
+        if (clk->parent)
+                list_add(&clk->sibling, &clk->parent->children);
+        else
+                list_add(&clk->sibling, &root_clks);
 
-        if (clk->flags & CLK_ALWAYS_ENABLED) {
-                pr_debug( "Clock '%s' is ALWAYS_ENABLED\n", clk->name);
-                if (clk->ops && clk->ops->init)
-                        clk->ops->init(clk);
-                if (clk->ops && clk->ops->enable)
-                        clk->ops->enable(clk);
-                pr_debug( "Enabled.");
-        }
+        list_add(&clk->node, &clock_list);
+        if (clk->ops && clk->ops->init)
+                clk->ops->init(clk);
+        mutex_unlock(&clock_list_sem);
 
         return 0;
 }
@@ -190,11 +288,21 @@ EXPORT_SYMBOL_GPL(clk_register);
 void clk_unregister(struct clk *clk)
 {
         mutex_lock(&clock_list_sem);
+        list_del(&clk->sibling);
         list_del(&clk->node);
         mutex_unlock(&clock_list_sem);
 }
 EXPORT_SYMBOL_GPL(clk_unregister);
 
+static void clk_enable_init_clocks(void)
+{
+        struct clk *clkp;
+
+        list_for_each_entry(clkp, &clock_list, node)
+                if (clkp->flags & CLK_ENABLE_ON_INIT)
+                        clk_enable(clkp);
+}
+
 unsigned long clk_get_rate(struct clk *clk)
 {
         return clk->rate;
@@ -210,56 +318,59 @@ EXPORT_SYMBOL_GPL(clk_set_rate);
 int clk_set_rate_ex(struct clk *clk, unsigned long rate, int algo_id)
 {
         int ret = -EOPNOTSUPP;
+        unsigned long flags;
 
-        if (likely(clk->ops && clk->ops->set_rate)) {
-                unsigned long flags;
+        spin_lock_irqsave(&clock_lock, flags);
 
-                spin_lock_irqsave(&clock_lock, flags);
+        if (likely(clk->ops && clk->ops->set_rate)) {
                 ret = clk->ops->set_rate(clk, rate, algo_id);
-                spin_unlock_irqrestore(&clock_lock, flags);
+                if (ret != 0)
+                        goto out_unlock;
+        } else {
+                clk->rate = rate;
+                ret = 0;
         }
 
-        if (unlikely(clk->flags & CLK_RATE_PROPAGATES))
-                propagate_rate(clk);
+        if (clk->ops && clk->ops->recalc)
+                clk->rate = clk->ops->recalc(clk);
 
-        return ret;
-}
-EXPORT_SYMBOL_GPL(clk_set_rate_ex);
+        propagate_rate(clk);
 
-void clk_recalc_rate(struct clk *clk)
-{
-        if (likely(clk->ops && clk->ops->recalc)) {
-                unsigned long flags;
-
-                spin_lock_irqsave(&clock_lock, flags);
-                clk->ops->recalc(clk);
-                spin_unlock_irqrestore(&clock_lock, flags);
-        }
+out_unlock:
+        spin_unlock_irqrestore(&clock_lock, flags);
 
-        if (unlikely(clk->flags & CLK_RATE_PROPAGATES))
-                propagate_rate(clk);
+        return ret;
 }
-EXPORT_SYMBOL_GPL(clk_recalc_rate);
+EXPORT_SYMBOL_GPL(clk_set_rate_ex);
 
 int clk_set_parent(struct clk *clk, struct clk *parent)
 {
+        unsigned long flags;
         int ret = -EINVAL;
-        struct clk *old;
 
         if (!parent || !clk)
                 return ret;
+        if (clk->parent == parent)
+                return 0;
 
-        old = clk->parent;
-        if (likely(clk->ops && clk->ops->set_parent)) {
-                unsigned long flags;
-                spin_lock_irqsave(&clock_lock, flags);
-                ret = clk->ops->set_parent(clk, parent);
-                spin_unlock_irqrestore(&clock_lock, flags);
-                clk->parent = (ret ? old : parent);
-        }
+        spin_lock_irqsave(&clock_lock, flags);
+        if (clk->usecount == 0) {
+                if (clk->ops->set_parent)
+                        ret = clk->ops->set_parent(clk, parent);
+                else
+                        ret = clk_reparent(clk, parent);
+
+                if (ret == 0) {
+                        pr_debug("clock: set parent of %s to %s (new rate %ld)\n",
+                                 clk->name, clk->parent->name, clk->rate);
+                        if (clk->ops->recalc)
+                                clk->rate = clk->ops->recalc(clk);
+                        propagate_rate(clk);
+                }
+        } else
+                ret = -EBUSY;
+        spin_unlock_irqrestore(&clock_lock, flags);
 
-        if (unlikely(clk->flags & CLK_RATE_PROPAGATES))
-                propagate_rate(clk);
         return ret;
 }
 EXPORT_SYMBOL_GPL(clk_set_parent);
@@ -287,14 +398,69 @@ long clk_round_rate(struct clk *clk, unsigned long rate)
 EXPORT_SYMBOL_GPL(clk_round_rate);
 
 /*
+ * Find the correct struct clk for the device and connection ID.
+ * We do slightly fuzzy matching here:
+ *  An entry with a NULL ID is assumed to be a wildcard.
+ *  If an entry has a device ID, it must match
+ *  If an entry has a connection ID, it must match
+ * Then we take the most specific entry - with the following
+ * order of precidence: dev+con > dev only > con only.
+ */
+static struct clk *clk_find(const char *dev_id, const char *con_id)
+{
+        struct clk_lookup *p;
+        struct clk *clk = NULL;
+        int match, best = 0;
+
+        list_for_each_entry(p, &clock_list, node) {
+                match = 0;
+                if (p->dev_id) {
+                        if (!dev_id || strcmp(p->dev_id, dev_id))
+                                continue;
+                        match += 2;
+                }
+                if (p->con_id) {
+                        if (!con_id || strcmp(p->con_id, con_id))
+                                continue;
+                        match += 1;
+                }
+                if (match == 0)
+                        continue;
+
+                if (match > best) {
+                        clk = p->clk;
+                        best = match;
+                }
+        }
+        return clk;
+}
+
+struct clk *clk_get_sys(const char *dev_id, const char *con_id)
+{
+        struct clk *clk;
+
+        mutex_lock(&clock_list_sem);
+        clk = clk_find(dev_id, con_id);
+        mutex_unlock(&clock_list_sem);
+
+        return clk ? clk : ERR_PTR(-ENOENT);
+}
+EXPORT_SYMBOL_GPL(clk_get_sys);
+
+/*
  * Returns a clock. Note that we first try to use device id on the bus
  * and clock name. If this fails, we try to use clock name only.
  */
 struct clk *clk_get(struct device *dev, const char *id)
 {
+        const char *dev_id = dev ? dev_name(dev) : NULL;
         struct clk *p, *clk = ERR_PTR(-ENOENT);
         int idno;
 
+        clk = clk_get_sys(dev_id, id);
+        if (clk && !IS_ERR(clk))
+                return clk;
+
         if (dev == NULL || dev->bus != &platform_bus_type)
                 idno = -1;
         else
@@ -330,36 +496,6 @@ void clk_put(struct clk *clk)
 }
 EXPORT_SYMBOL_GPL(clk_put);
 
-void __init __attribute__ ((weak))
-arch_init_clk_ops(struct clk_ops **ops, int type)
-{
-}
-
-int __init __attribute__ ((weak))
-arch_clk_init(void)
-{
-        return 0;
-}
-
-static int show_clocks(char *buf, char **start, off_t off,
-                       int len, int *eof, void *data)
-{
-        struct clk *clk;
-        char *p = buf;
-
-        list_for_each_entry_reverse(clk, &clock_list, node) {
-                unsigned long rate = clk_get_rate(clk);
-
-                p += sprintf(p, "%-12s\t: %ld.%02ldMHz\t%s\n", clk->name,
-                             rate / 1000000, (rate % 1000000) / 10000,
-                             ((clk->flags & CLK_ALWAYS_ENABLED) ||
-                              (atomic_read(&clk->kref.refcount) != 1)) ?
-                             "enabled" : "disabled");
-        }
-
-        return p - buf;
-}
-
 #ifdef CONFIG_PM
 static int clks_sysdev_suspend(struct sys_device *dev, pm_message_t state)
 {
@@ -369,20 +505,22 @@ static int clks_sysdev_suspend(struct sys_device *dev, pm_message_t state)
         switch (state.event) {
         case PM_EVENT_ON:
                 /* Resumeing from hibernation */
-                if (prev_state.event == PM_EVENT_FREEZE) {
-                        list_for_each_entry(clkp, &clock_list, node)
-                                if (likely(clkp->ops)) {
-                                        unsigned long rate = clkp->rate;
-
-                                        if (likely(clkp->ops->set_parent))
-                                                clkp->ops->set_parent(clkp,
-                                                        clkp->parent);
-                                        if (likely(clkp->ops->set_rate))
-                                                clkp->ops->set_rate(clkp,
-                                                        rate, NO_CHANGE);
-                                        else if (likely(clkp->ops->recalc))
-                                                clkp->ops->recalc(clkp);
-                                        }
+                if (prev_state.event != PM_EVENT_FREEZE)
+                        break;
+
+                list_for_each_entry(clkp, &clock_list, node) {
+                        if (likely(clkp->ops)) {
+                                unsigned long rate = clkp->rate;
+
+                                if (likely(clkp->ops->set_parent))
+                                        clkp->ops->set_parent(clkp,
+                                                clkp->parent);
+                                if (likely(clkp->ops->set_rate))
+                                        clkp->ops->set_rate(clkp,
+                                                rate, NO_CHANGE);
+                                else if (likely(clkp->ops->recalc))
+                                        clkp->rate = clkp->ops->recalc(clkp);
+                        }
                 }
                 break;
         case PM_EVENT_FREEZE:
@@ -426,34 +564,116 @@ subsys_initcall(clk_sysdev_init);
 
 int __init clk_init(void)
 {
-        int i, ret = 0;
-
-        BUG_ON(!master_clk.rate);
-
-        for (i = 0; i < ARRAY_SIZE(onchip_clocks); i++) {
-                struct clk *clk = onchip_clocks[i];
+        int ret;
 
-                arch_init_clk_ops(&clk->ops, i);
-                ret |= clk_register(clk);
+        ret = arch_clk_init();
+        if (unlikely(ret)) {
+                pr_err("%s: CPU clock registration failed.\n", __func__);
+                return ret;
         }
 
-        ret |= arch_clk_init();
+        if (sh_mv.mv_clk_init) {
+                ret = sh_mv.mv_clk_init();
+                if (unlikely(ret)) {
+                        pr_err("%s: machvec clock initialization failed.\n",
+                               __func__);
+                        return ret;
+                }
+        }
 
         /* Kick the child clocks.. */
-        propagate_rate(&master_clk);
-        propagate_rate(&bus_clk);
+        recalculate_root_clocks();
+
+        /* Enable the necessary init clocks */
+        clk_enable_init_clocks();
 
         return ret;
 }
 
-static int __init clk_proc_init(void)
+/*
+ *      debugfs support to trace clock tree hierarchy and attributes
+ */
+static struct dentry *clk_debugfs_root;
+
+static int clk_debugfs_register_one(struct clk *c)
 {
-        struct proc_dir_entry *p;
-        p = create_proc_read_entry("clocks", S_IRUSR, NULL,
-                                   show_clocks, NULL);
-        if (unlikely(!p))
-                return -EINVAL;
+        int err;
+        struct dentry *d, *child;
+        struct clk *pa = c->parent;
+        char s[255];
+        char *p = s;
+
+        p += sprintf(p, "%s", c->name);
+        if (c->id >= 0)
+                sprintf(p, ":%d", c->id);
+        d = debugfs_create_dir(s, pa ? pa->dentry : clk_debugfs_root);
+        if (!d)
+                return -ENOMEM;
+        c->dentry = d;
+
+        d = debugfs_create_u8("usecount", S_IRUGO, c->dentry, (u8 *)&c->usecount);
+        if (!d) {
+                err = -ENOMEM;
+                goto err_out;
+        }
+        d = debugfs_create_u32("rate", S_IRUGO, c->dentry, (u32 *)&c->rate);
+        if (!d) {
+                err = -ENOMEM;
+                goto err_out;
+        }
+        d = debugfs_create_x32("flags", S_IRUGO, c->dentry, (u32 *)&c->flags);
+        if (!d) {
+                err = -ENOMEM;
+                goto err_out;
+        }
+        return 0;
 
+err_out:
+        d = c->dentry;
+        list_for_each_entry(child, &d->d_subdirs, d_u.d_child)
+                debugfs_remove(child);
+        debugfs_remove(c->dentry);
+        return err;
+}
+
+static int clk_debugfs_register(struct clk *c)
+{
+        int err;
+        struct clk *pa = c->parent;
+
+        if (pa && !pa->dentry) {
+                err = clk_debugfs_register(pa);
+                if (err)
+                        return err;
+        }
+
+        if (!c->dentry) {
+                err = clk_debugfs_register_one(c);
+                if (err)
+                        return err;
+        }
+        return 0;
+}
+
+static int __init clk_debugfs_init(void)
+{
+        struct clk *c;
+        struct dentry *d;
+        int err;
+
+        d = debugfs_create_dir("clock", NULL);
+        if (!d)
+                return -ENOMEM;
+        clk_debugfs_root = d;
+
+        list_for_each_entry(c, &clock_list, node) {
+                err = clk_debugfs_register(c);
+                if (err)
+                        goto err_out;
+        }
         return 0;
+err_out:
+        debugfs_remove(clk_debugfs_root); /* REVISIT: Cleanup correctly */
+        return err;
 }
-subsys_initcall(clk_proc_init);
+late_initcall(clk_debugfs_init);
diff --git a/arch/sh/kernel/cpu/init.c b/arch/sh/kernel/cpu/init.c
index d29e69c156f0..ad85421099cd 100644
--- a/arch/sh/kernel/cpu/init.c
+++ b/arch/sh/kernel/cpu/init.c
@@ -62,6 +62,11 @@ static void __init speculative_execution_init(void)
 #define speculative_execution_init()    do { } while (0)
 #endif
 
+/* 2nd-level cache init */
+void __uses_jump_to_uncached __attribute__ ((weak)) l2_cache_init(void)
+{
+}
+
 /*
  * Generic first-level cache init
  */
@@ -146,6 +151,8 @@ static void __uses_jump_to_uncached cache_init(void)
         flags &= ~CCR_CACHE_ENABLE;
 #endif
 
+        l2_cache_init();
+
         ctrl_outl(flags, CCR);
         back_to_cached();
 }
diff --git a/arch/sh/kernel/cpu/irq/imask.c b/arch/sh/kernel/cpu/irq/imask.c
index 301b505c4278..6b5d191eec3a 100644
--- a/arch/sh/kernel/cpu/irq/imask.c
+++ b/arch/sh/kernel/cpu/irq/imask.c
@@ -18,38 +18,17 @@
 #include <linux/spinlock.h>
 #include <linux/cache.h>
 #include <linux/irq.h>
+#include <linux/bitmap.h>
 #include <asm/system.h>
 #include <asm/irq.h>
 
 /* Bitmap of IRQ masked */
-static unsigned long imask_mask = 0x7fff;
-static int interrupt_priority = 0;
-
-static void enable_imask_irq(unsigned int irq);
-static void disable_imask_irq(unsigned int irq);
-static void shutdown_imask_irq(unsigned int irq);
-static void mask_and_ack_imask(unsigned int);
-static void end_imask_irq(unsigned int irq);
-
 #define IMASK_PRIORITY  15
 
-static unsigned int startup_imask_irq(unsigned int irq)
-{
-        /* Nothing to do */
-        return 0; /* never anything pending */
-}
+static DECLARE_BITMAP(imask_mask, IMASK_PRIORITY);
+static int interrupt_priority;
 
-static struct hw_interrupt_type imask_irq_type = {
-        .typename = "SR.IMASK",
-        .startup = startup_imask_irq,
-        .shutdown = shutdown_imask_irq,
-        .enable = enable_imask_irq,
-        .disable = disable_imask_irq,
-        .ack = mask_and_ack_imask,
-        .end = end_imask_irq
-};
-
-void static inline set_interrupt_registers(int ip)
+static inline void set_interrupt_registers(int ip)
 {
         unsigned long __dummy;
 
@@ -72,42 +51,31 @@ void static inline set_interrupt_registers(int ip)
                      : "t");
 }
 
-static void disable_imask_irq(unsigned int irq)
+static void mask_imask_irq(unsigned int irq)
 {
-        clear_bit(irq, &imask_mask);
+        clear_bit(irq, imask_mask);
         if (interrupt_priority < IMASK_PRIORITY - irq)
                 interrupt_priority = IMASK_PRIORITY - irq;
-
         set_interrupt_registers(interrupt_priority);
 }
 
-static void enable_imask_irq(unsigned int irq)
+static void unmask_imask_irq(unsigned int irq)
 {
-        set_bit(irq, &imask_mask);
-        interrupt_priority = IMASK_PRIORITY - ffz(imask_mask);
-
+        set_bit(irq, imask_mask);
+        interrupt_priority = IMASK_PRIORITY -
+                find_first_zero_bit(imask_mask, IMASK_PRIORITY);
         set_interrupt_registers(interrupt_priority);
 }
 
-static void mask_and_ack_imask(unsigned int irq)
-{
-        disable_imask_irq(irq);
-}
-
-static void end_imask_irq(unsigned int irq)
-{
-        if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS)))
-                enable_imask_irq(irq);
-}
-
-static void shutdown_imask_irq(unsigned int irq)
-{
-        /* Nothing to do */
-}
+static struct irq_chip imask_irq_chip = {
+        .typename       = "SR.IMASK",
+        .mask           = mask_imask_irq,
+        .unmask         = unmask_imask_irq,
+        .mask_ack       = mask_imask_irq,
+};
 
 void make_imask_irq(unsigned int irq)
 {
-        disable_irq_nosync(irq);
-        irq_desc[irq].chip = &imask_irq_type;
-        enable_irq(irq);
+        set_irq_chip_and_handler_name(irq, &imask_irq_chip,
+                                      handle_level_irq, "level");
 }
diff --git a/arch/sh/kernel/cpu/irq/intc-sh5.c b/arch/sh/kernel/cpu/irq/intc-sh5.c
index 726f0335da76..6c092f1f5557 100644
--- a/arch/sh/kernel/cpu/irq/intc-sh5.c
+++ b/arch/sh/kernel/cpu/irq/intc-sh5.c
@@ -84,7 +84,7 @@ static void disable_intc_irq(unsigned int irq);
 static void mask_and_ack_intc(unsigned int);
 static void end_intc_irq(unsigned int irq);
 
-static struct hw_interrupt_type intc_irq_type = {
+static struct irq_chip intc_irq_type = {
         .typename = "INTC",
         .startup = startup_intc_irq,
         .shutdown = shutdown_intc_irq,
@@ -152,43 +152,13 @@ static void end_intc_irq(unsigned int irq)
         enable_intc_irq(irq);
 }
 
-/* For future use, if we ever support IRLM=0) */
-void make_intc_irq(unsigned int irq)
-{
-        disable_irq_nosync(irq);
-        irq_desc[irq].chip = &intc_irq_type;
-        disable_intc_irq(irq);
-}
-
-#if defined(CONFIG_PROC_FS) && defined(CONFIG_SYSCTL)
-static int IRQ_to_vectorN[NR_INTC_IRQS] = {
-        0x12, 0x15, 0x18, 0x1B, 0x40, 0x41, 0x42, 0x43, /*  0- 7 */
-          -1,   -1,   -1,   -1, 0x50, 0x51, 0x52, 0x53, /*  8-15 */
-        0x54, 0x55, 0x32, 0x33, 0x34, 0x35, 0x36,   -1, /* 16-23 */
-          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, /* 24-31 */
-        0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x38, /* 32-39 */
-        0x39, 0x3A, 0x3B,   -1,   -1,   -1,   -1,   -1, /* 40-47 */
-          -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, /* 48-55 */
-          -1,   -1,   -1,   -1,   -1,   -1,   -1, 0x2B, /* 56-63 */
-
-};
-
-int intc_irq_describe(char* p, int irq)
-{
-        if (irq < NR_INTC_IRQS)
-                return sprintf(p, "(0x%3x)", IRQ_to_vectorN[irq]*0x20);
-        else
-                return 0;
-}
-#endif
-
 void __init plat_irq_setup(void)
 {
         unsigned long long __dummy0, __dummy1=~0x00000000100000f0;
         unsigned long reg;
         int i;
 
-        intc_virt = onchip_remap(INTC_BASE, 1024, "INTC");
+        intc_virt = (unsigned long)ioremap_nocache(INTC_BASE, 1024);
         if (!intc_virt) {
                 panic("Unable to remap INTC\n");
         }
@@ -196,7 +166,7 @@ void __init plat_irq_setup(void)
 
         /* Set default: per-line enable/disable, priority driven ack/eoi */
         for (i = 0; i < NR_INTC_IRQS; i++)
-                irq_desc[i].chip = &intc_irq_type;
+                set_irq_chip_and_handler(i, &intc_irq_type, handle_level_irq);
 
 
         /* Disable all interrupts and set all priorities to 0 to avoid trouble */
diff --git a/arch/sh/kernel/cpu/irq/ipr.c b/arch/sh/kernel/cpu/irq/ipr.c
index 3eb17ee5540e..808d99a48efb 100644
--- a/arch/sh/kernel/cpu/irq/ipr.c
+++ b/arch/sh/kernel/cpu/irq/ipr.c
@@ -21,6 +21,7 @@
 #include <linux/module.h>
 #include <linux/io.h>
 #include <linux/interrupt.h>
+#include <linux/topology.h>
 
 static inline struct ipr_desc *get_ipr_desc(unsigned int irq)
 {
@@ -59,10 +60,18 @@ void register_ipr_controller(struct ipr_desc *desc)
 
         for (i = 0; i < desc->nr_irqs; i++) {
                 struct ipr_data *p = desc->ipr_data + i;
+                struct irq_desc *irq_desc;
 
                 BUG_ON(p->ipr_idx >= desc->nr_offsets);
                 BUG_ON(!desc->ipr_offsets[p->ipr_idx]);
 
+                irq_desc = irq_to_desc_alloc_node(p->irq, numa_node_id());
+                if (unlikely(!irq_desc)) {
+                        printk(KERN_INFO "can not get irq_desc for %d\n",
+                               p->irq);
+                        continue;
+                }
+
                 disable_irq_nosync(p->irq);
                 set_irq_chip_and_handler_name(p->irq, &desc->chip,
                                       handle_level_irq, "level");
diff --git a/arch/sh/kernel/cpu/sh2/clock-sh7619.c b/arch/sh/kernel/cpu/sh2/clock-sh7619.c
index d2c157917999..4fe863170e31 100644
--- a/arch/sh/kernel/cpu/sh2/clock-sh7619.c
+++ b/arch/sh/kernel/cpu/sh2/clock-sh7619.c
@@ -38,32 +38,27 @@ static struct clk_ops sh7619_master_clk_ops = {
         .init           = master_clk_init,
 };
 
-static void module_clk_recalc(struct clk *clk)
+static unsigned long module_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inw(FREQCR) & 0x0007);
-        clk->rate = clk->parent->rate / pfc_divisors[idx];
+        return clk->parent->rate / pfc_divisors[idx];
 }
 
 static struct clk_ops sh7619_module_clk_ops = {
         .recalc         = module_clk_recalc,
 };
 
-static void bus_clk_recalc(struct clk *clk)
+static unsigned long bus_clk_recalc(struct clk *clk)
 {
-        clk->rate = clk->parent->rate / pll1rate[(ctrl_inw(FREQCR) >> 8) & 7];
+        return clk->parent->rate / pll1rate[(ctrl_inw(FREQCR) >> 8) & 7];
 }
 
 static struct clk_ops sh7619_bus_clk_ops = {
         .recalc         = bus_clk_recalc,
 };
 
-static void cpu_clk_recalc(struct clk *clk)
-{
-        clk->rate = clk->parent->rate;
-}
-
 static struct clk_ops sh7619_cpu_clk_ops = {
-        .recalc         = cpu_clk_recalc,
+        .recalc         = followparent_recalc,
 };
 
 static struct clk_ops *sh7619_clk_ops[] = {
@@ -78,4 +73,3 @@ void __init arch_init_clk_ops(struct clk_ops **ops, int idx)
         if (idx < ARRAY_SIZE(sh7619_clk_ops))
                 *ops = sh7619_clk_ops[idx];
 }
-
diff --git a/arch/sh/kernel/cpu/sh2/setup-sh7619.c b/arch/sh/kernel/cpu/sh2/setup-sh7619.c
index 0e32d8e448ca..13798733f2db 100644
--- a/arch/sh/kernel/cpu/sh2/setup-sh7619.c
+++ b/arch/sh/kernel/cpu/sh2/setup-sh7619.c
@@ -12,6 +12,8 @@
 #include <linux/init.h>
 #include <linux/serial.h>
 #include <linux/serial_sci.h>
+#include <linux/sh_timer.h>
+#include <linux/io.h>
 
 enum {
         UNUSED = 0,
@@ -109,9 +111,75 @@ static struct platform_device eth_device = {
         .resource = eth_resources,
 };
 
+static struct sh_timer_config cmt0_platform_data = {
+        .name = "CMT0",
+        .channel_offset = 0x02,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 125,
+        .clocksource_rating = 0, /* disabled due to code generation issues */
+};
+
+static struct resource cmt0_resources[] = {
+        [0] = {
+                .name   = "CMT0",
+                .start  = 0xf84a0072,
+                .end    = 0xf84a0077,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 86,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device cmt0_device = {
+        .name           = "sh_cmt",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &cmt0_platform_data,
+        },
+        .resource       = cmt0_resources,
+        .num_resources  = ARRAY_SIZE(cmt0_resources),
+};
+
+static struct sh_timer_config cmt1_platform_data = {
+        .name = "CMT1",
+        .channel_offset = 0x08,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 125,
+        .clocksource_rating = 0, /* disabled due to code generation issues */
+};
+
+static struct resource cmt1_resources[] = {
+        [0] = {
+                .name   = "CMT1",
+                .start  = 0xf84a0078,
+                .end    = 0xf84a007d,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 87,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device cmt1_device = {
+        .name           = "sh_cmt",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &cmt1_platform_data,
+        },
+        .resource       = cmt1_resources,
+        .num_resources  = ARRAY_SIZE(cmt1_resources),
+};
+
 static struct platform_device *sh7619_devices[] __initdata = {
         &sci_device,
         &eth_device,
+        &cmt0_device,
+        &cmt1_device,
 };
 
 static int __init sh7619_devices_setup(void)
@@ -125,3 +193,19 @@ void __init plat_irq_setup(void)
 {
         register_intc_controller(&intc_desc);
 }
+
+static struct platform_device *sh7619_early_devices[] __initdata = {
+        &cmt0_device,
+        &cmt1_device,
+};
+
+#define STBCR3 0xf80a0000
+
+void __init plat_early_device_setup(void)
+{
+        /* enable CMT clock */
+        __raw_writeb(__raw_readb(STBCR3) & ~0x10, STBCR3);
+
+        early_platform_add_devices(sh7619_early_devices,
+                                   ARRAY_SIZE(sh7619_early_devices));
+}
diff --git a/arch/sh/kernel/cpu/sh2a/clock-sh7201.c b/arch/sh/kernel/cpu/sh2a/clock-sh7201.c
index 4a5e59732334..7814c76159a7 100644
--- a/arch/sh/kernel/cpu/sh2a/clock-sh7201.c
+++ b/arch/sh/kernel/cpu/sh2a/clock-sh7201.c
@@ -34,37 +34,37 @@ static const int pfc_divisors[]={1,2,3,4,6,8,12};
 
 static void master_clk_init(struct clk *clk)
 {
-        clk->rate = 10000000 * PLL2 * pll1rate[(ctrl_inw(FREQCR) >> 8) & 0x0007];
+        return 10000000 * PLL2 * pll1rate[(ctrl_inw(FREQCR) >> 8) & 0x0007];
 }
 
 static struct clk_ops sh7201_master_clk_ops = {
         .init           = master_clk_init,
 };
 
-static void module_clk_recalc(struct clk *clk)
+static unsigned long module_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inw(FREQCR) & 0x0007);
-        clk->rate = clk->parent->rate / pfc_divisors[idx];
+        return clk->parent->rate / pfc_divisors[idx];
 }
 
 static struct clk_ops sh7201_module_clk_ops = {
         .recalc         = module_clk_recalc,
 };
 
-static void bus_clk_recalc(struct clk *clk)
+static unsigned long bus_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inw(FREQCR) & 0x0007);
-        clk->rate = clk->parent->rate / pfc_divisors[idx];
+        return clk->parent->rate / pfc_divisors[idx];
 }
 
 static struct clk_ops sh7201_bus_clk_ops = {
         .recalc         = bus_clk_recalc,
 };
 
-static void cpu_clk_recalc(struct clk *clk)
+static unsigned long cpu_clk_recalc(struct clk *clk)
 {
         int idx = ((ctrl_inw(FREQCR) >> 4) & 0x0007);
-        clk->rate = clk->parent->rate / ifc_divisors[idx];
+        return clk->parent->rate / ifc_divisors[idx];
 }
 
 static struct clk_ops sh7201_cpu_clk_ops = {
diff --git a/arch/sh/kernel/cpu/sh2a/clock-sh7203.c b/arch/sh/kernel/cpu/sh2a/clock-sh7203.c
index fb781329848a..940986965102 100644
--- a/arch/sh/kernel/cpu/sh2a/clock-sh7203.c
+++ b/arch/sh/kernel/cpu/sh2a/clock-sh7203.c
@@ -46,33 +46,28 @@ static struct clk_ops sh7203_master_clk_ops = {
         .init           = master_clk_init,
 };
 
-static void module_clk_recalc(struct clk *clk)
+static unsigned long module_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inw(FREQCR) & 0x0007);
-        clk->rate = clk->parent->rate / pfc_divisors[idx];
+        return clk->parent->rate / pfc_divisors[idx];
 }
 
 static struct clk_ops sh7203_module_clk_ops = {
         .recalc         = module_clk_recalc,
 };
 
-static void bus_clk_recalc(struct clk *clk)
+static unsigned long bus_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inw(FREQCR) & 0x0007);
-        clk->rate = clk->parent->rate / pfc_divisors[idx-2];
+        return clk->parent->rate / pfc_divisors[idx-2];
 }
 
 static struct clk_ops sh7203_bus_clk_ops = {
         .recalc         = bus_clk_recalc,
 };
 
-static void cpu_clk_recalc(struct clk *clk)
-{
-        clk->rate = clk->parent->rate;
-}
-
 static struct clk_ops sh7203_cpu_clk_ops = {
-        .recalc         = cpu_clk_recalc,
+        .recalc         = followparent_recalc,
 };
 
 static struct clk_ops *sh7203_clk_ops[] = {
diff --git a/arch/sh/kernel/cpu/sh2a/clock-sh7206.c b/arch/sh/kernel/cpu/sh2a/clock-sh7206.c
index 82d7f991ef6b..c2268bdeceeb 100644
--- a/arch/sh/kernel/cpu/sh2a/clock-sh7206.c
+++ b/arch/sh/kernel/cpu/sh2a/clock-sh7206.c
@@ -41,29 +41,29 @@ static struct clk_ops sh7206_master_clk_ops = {
         .init           = master_clk_init,
 };
 
-static void module_clk_recalc(struct clk *clk)
+static unsigned long module_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inw(FREQCR) & 0x0007);
-        clk->rate = clk->parent->rate / pfc_divisors[idx];
+        return clk->parent->rate / pfc_divisors[idx];
 }
 
 static struct clk_ops sh7206_module_clk_ops = {
         .recalc         = module_clk_recalc,
 };
 
-static void bus_clk_recalc(struct clk *clk)
+static unsigned long bus_clk_recalc(struct clk *clk)
 {
-        clk->rate = clk->parent->rate / pll1rate[(ctrl_inw(FREQCR) >> 8) & 0x0007];
+        return clk->parent->rate / pll1rate[(ctrl_inw(FREQCR) >> 8) & 0x0007];
 }
 
 static struct clk_ops sh7206_bus_clk_ops = {
         .recalc         = bus_clk_recalc,
 };
 
-static void cpu_clk_recalc(struct clk *clk)
+static unsigned long cpu_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inw(FREQCR) & 0x0007);
-        clk->rate = clk->parent->rate / ifc_divisors[idx];
+        return clk->parent->rate / ifc_divisors[idx];
 }
 
 static struct clk_ops sh7206_cpu_clk_ops = {
diff --git a/arch/sh/kernel/cpu/sh2a/setup-mxg.c b/arch/sh/kernel/cpu/sh2a/setup-mxg.c
index 844293723cfc..869c2da4820b 100644
--- a/arch/sh/kernel/cpu/sh2a/setup-mxg.c
+++ b/arch/sh/kernel/cpu/sh2a/setup-mxg.c
@@ -11,6 +11,7 @@
 #include <linux/init.h>
 #include <linux/serial.h>
 #include <linux/serial_sci.h>
+#include <linux/sh_timer.h>
 
 enum {
         UNUSED = 0,
@@ -24,7 +25,7 @@ enum {
 
         SCIF0, SCIF1,
 
-        MTU2_GROUP1, MTU2_GROUP2, MTU2_GROUP3, MTU2_GROUP4, MTU2_GROUP5
+        MTU2_GROUP1, MTU2_GROUP2, MTU2_GROUP3, MTU2_GROUP4, MTU2_GROUP5,
         MTU2_TGI3B, MTU2_TGI3C,
 
         /* interrupt groups */
@@ -113,6 +114,99 @@ static struct intc_mask_reg mask_registers[] __initdata = {
 static DECLARE_INTC_DESC(intc_desc, "mxg", vectors, groups,
                          mask_registers, prio_registers, NULL);
 
+static struct sh_timer_config mtu2_0_platform_data = {
+        .name = "MTU2_0",
+        .channel_offset = -0x80,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource mtu2_0_resources[] = {
+        [0] = {
+                .name   = "MTU2_0",
+                .start  = 0xff801300,
+                .end    = 0xff801326,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 228,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device mtu2_0_device = {
+        .name           = "sh_mtu2",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &mtu2_0_platform_data,
+        },
+        .resource       = mtu2_0_resources,
+        .num_resources  = ARRAY_SIZE(mtu2_0_resources),
+};
+
+static struct sh_timer_config mtu2_1_platform_data = {
+        .name = "MTU2_1",
+        .channel_offset = -0x100,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource mtu2_1_resources[] = {
+        [0] = {
+                .name   = "MTU2_1",
+                .start  = 0xff801380,
+                .end    = 0xff801390,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 234,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device mtu2_1_device = {
+        .name           = "sh_mtu2",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &mtu2_1_platform_data,
+        },
+        .resource       = mtu2_1_resources,
+        .num_resources  = ARRAY_SIZE(mtu2_1_resources),
+};
+
+static struct sh_timer_config mtu2_2_platform_data = {
+        .name = "MTU2_2",
+        .channel_offset = 0x80,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource mtu2_2_resources[] = {
+        [0] = {
+                .name   = "MTU2_2",
+                .start  = 0xff801000,
+                .end    = 0xff80100a,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 240,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device mtu2_2_device = {
+        .name           = "sh_mtu2",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &mtu2_2_platform_data,
+        },
+        .resource       = mtu2_2_resources,
+        .num_resources  = ARRAY_SIZE(mtu2_2_resources),
+};
+
 static struct plat_sci_port sci_platform_data[] = {
         {
                 .mapbase        = 0xff804000,
@@ -134,6 +228,9 @@ static struct platform_device sci_device = {
 
 static struct platform_device *mxg_devices[] __initdata = {
         &sci_device,
+        &mtu2_0_device,
+        &mtu2_1_device,
+        &mtu2_2_device,
 };
 
 static int __init mxg_devices_setup(void)
@@ -147,3 +244,15 @@ void __init plat_irq_setup(void)
 {
         register_intc_controller(&intc_desc);
 }
+
+static struct platform_device *mxg_early_devices[] __initdata = {
+        &mtu2_0_device,
+        &mtu2_1_device,
+        &mtu2_2_device,
+};
+
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(mxg_early_devices,
+                                   ARRAY_SIZE(mxg_early_devices));
+}
diff --git a/arch/sh/kernel/cpu/sh2a/setup-sh7201.c b/arch/sh/kernel/cpu/sh2a/setup-sh7201.c
index 00f42f9e3f5c..d8febe128066 100644
--- a/arch/sh/kernel/cpu/sh2a/setup-sh7201.c
+++ b/arch/sh/kernel/cpu/sh2a/setup-sh7201.c
@@ -12,6 +12,8 @@
 #include <linux/init.h>
 #include <linux/serial.h>
 #include <linux/serial_sci.h>
+#include <linux/sh_timer.h>
+#include <linux/io.h>
 
 enum {
         UNUSED = 0,
@@ -249,9 +251,105 @@ static struct platform_device rtc_device = {
         .resource       = rtc_resources,
 };
 
+static struct sh_timer_config mtu2_0_platform_data = {
+        .name = "MTU2_0",
+        .channel_offset = -0x80,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource mtu2_0_resources[] = {
+        [0] = {
+                .name   = "MTU2_0",
+                .start  = 0xfffe4300,
+                .end    = 0xfffe4326,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 108,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device mtu2_0_device = {
+        .name           = "sh_mtu2",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &mtu2_0_platform_data,
+        },
+        .resource       = mtu2_0_resources,
+        .num_resources  = ARRAY_SIZE(mtu2_0_resources),
+};
+
+static struct sh_timer_config mtu2_1_platform_data = {
+        .name = "MTU2_1",
+        .channel_offset = -0x100,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource mtu2_1_resources[] = {
+        [0] = {
+                .name   = "MTU2_1",
+                .start  = 0xfffe4380,
+                .end    = 0xfffe4390,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 116,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device mtu2_1_device = {
+        .name           = "sh_mtu2",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &mtu2_1_platform_data,
+        },
+        .resource       = mtu2_1_resources,
+        .num_resources  = ARRAY_SIZE(mtu2_1_resources),
+};
+
+static struct sh_timer_config mtu2_2_platform_data = {
+        .name = "MTU2_2",
+        .channel_offset = 0x80,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource mtu2_2_resources[] = {
+        [0] = {
+                .name   = "MTU2_2",
+                .start  = 0xfffe4000,
+                .end    = 0xfffe400a,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 124,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device mtu2_2_device = {
+        .name           = "sh_mtu2",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &mtu2_2_platform_data,
+        },
+        .resource       = mtu2_2_resources,
+        .num_resources  = ARRAY_SIZE(mtu2_2_resources),
+};
+
 static struct platform_device *sh7201_devices[] __initdata = {
         &sci_device,
         &rtc_device,
+        &mtu2_0_device,
+        &mtu2_1_device,
+        &mtu2_2_device,
 };
 
 static int __init sh7201_devices_setup(void)
@@ -265,3 +363,20 @@ void __init plat_irq_setup(void)
 {
         register_intc_controller(&intc_desc);
 }
+
+static struct platform_device *sh7201_early_devices[] __initdata = {
+        &mtu2_0_device,
+        &mtu2_1_device,
+        &mtu2_2_device,
+};
+
+#define STBCR3 0xfffe0408
+
+void __init plat_early_device_setup(void)
+{
+        /* enable MTU2 clock */
+        __raw_writeb(__raw_readb(STBCR3) & ~0x20, STBCR3);
+
+        early_platform_add_devices(sh7201_early_devices,
+                                   ARRAY_SIZE(sh7201_early_devices));
+}
diff --git a/arch/sh/kernel/cpu/sh2a/setup-sh7203.c b/arch/sh/kernel/cpu/sh2a/setup-sh7203.c
index 820dfb2e8656..62e3039d2398 100644
--- a/arch/sh/kernel/cpu/sh2a/setup-sh7203.c
+++ b/arch/sh/kernel/cpu/sh2a/setup-sh7203.c
@@ -11,6 +11,8 @@
 #include <linux/init.h>
 #include <linux/serial.h>
 #include <linux/serial_sci.h>
+#include <linux/sh_timer.h>
+#include <linux/io.h>
 
 enum {
         UNUSED = 0,
@@ -205,6 +207,132 @@ static struct platform_device sci_device = {
         },
 };
 
+static struct sh_timer_config cmt0_platform_data = {
+        .name = "CMT0",
+        .channel_offset = 0x02,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 125,
+        .clocksource_rating = 0, /* disabled due to code generation issues */
+};
+
+static struct resource cmt0_resources[] = {
+        [0] = {
+                .name   = "CMT0",
+                .start  = 0xfffec002,
+                .end    = 0xfffec007,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 142,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device cmt0_device = {
+        .name           = "sh_cmt",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &cmt0_platform_data,
+        },
+        .resource       = cmt0_resources,
+        .num_resources  = ARRAY_SIZE(cmt0_resources),
+};
+
+static struct sh_timer_config cmt1_platform_data = {
+        .name = "CMT1",
+        .channel_offset = 0x08,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 125,
+        .clocksource_rating = 0, /* disabled due to code generation issues */
+};
+
+static struct resource cmt1_resources[] = {
+        [0] = {
+                .name   = "CMT1",
+                .start  = 0xfffec008,
+                .end    = 0xfffec00d,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 143,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device cmt1_device = {
+        .name           = "sh_cmt",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &cmt1_platform_data,
+        },
+        .resource       = cmt1_resources,
+        .num_resources  = ARRAY_SIZE(cmt1_resources),
+};
+
+static struct sh_timer_config mtu2_0_platform_data = {
+        .name = "MTU2_0",
+        .channel_offset = -0x80,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource mtu2_0_resources[] = {
+        [0] = {
+                .name   = "MTU2_0",
+                .start  = 0xfffe4300,
+                .end    = 0xfffe4326,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 146,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device mtu2_0_device = {
+        .name           = "sh_mtu2",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &mtu2_0_platform_data,
+        },
+        .resource       = mtu2_0_resources,
+        .num_resources  = ARRAY_SIZE(mtu2_0_resources),
+};
+
+static struct sh_timer_config mtu2_1_platform_data = {
+        .name = "MTU2_1",
+        .channel_offset = -0x100,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource mtu2_1_resources[] = {
+        [0] = {
+                .name   = "MTU2_1",
+                .start  = 0xfffe4380,
+                .end    = 0xfffe4390,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 153,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device mtu2_1_device = {
+        .name           = "sh_mtu2",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &mtu2_1_platform_data,
+        },
+        .resource       = mtu2_1_resources,
+        .num_resources  = ARRAY_SIZE(mtu2_1_resources),
+};
+
 static struct resource rtc_resources[] = {
         [0] = {
                 .start  = 0xffff2000,
@@ -227,6 +355,10 @@ static struct platform_device rtc_device = {
 
 static struct platform_device *sh7203_devices[] __initdata = {
         &sci_device,
+        &cmt0_device,
+        &cmt1_device,
+        &mtu2_0_device,
+        &mtu2_1_device,
         &rtc_device,
 };
 
@@ -241,3 +373,25 @@ void __init plat_irq_setup(void)
 {
         register_intc_controller(&intc_desc);
 }
+
+static struct platform_device *sh7203_early_devices[] __initdata = {
+        &cmt0_device,
+        &cmt1_device,
+        &mtu2_0_device,
+        &mtu2_1_device,
+};
+
+#define STBCR3 0xfffe0408
+#define STBCR4 0xfffe040c
+
+void __init plat_early_device_setup(void)
+{
+        /* enable CMT clock */
+        __raw_writeb(__raw_readb(STBCR4) & ~0x04, STBCR4);
+
+        /* enable MTU2 clock */
+        __raw_writeb(__raw_readb(STBCR3) & ~0x20, STBCR3);
+
+        early_platform_add_devices(sh7203_early_devices,
+                                   ARRAY_SIZE(sh7203_early_devices));
+}
diff --git a/arch/sh/kernel/cpu/sh2a/setup-sh7206.c b/arch/sh/kernel/cpu/sh2a/setup-sh7206.c
index c46a8355726d..3e6f3d7a58be 100644
--- a/arch/sh/kernel/cpu/sh2a/setup-sh7206.c
+++ b/arch/sh/kernel/cpu/sh2a/setup-sh7206.c
@@ -12,6 +12,8 @@
 #include <linux/init.h>
 #include <linux/serial.h>
 #include <linux/serial_sci.h>
+#include <linux/sh_timer.h>
+#include <linux/io.h>
 
 enum {
         UNUSED = 0,
@@ -165,8 +167,170 @@ static struct platform_device sci_device = {
         },
 };
 
+static struct sh_timer_config cmt0_platform_data = {
+        .name = "CMT0",
+        .channel_offset = 0x02,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 125,
+        .clocksource_rating = 0, /* disabled due to code generation issues */
+};
+
+static struct resource cmt0_resources[] = {
+        [0] = {
+                .name   = "CMT0",
+                .start  = 0xfffec002,
+                .end    = 0xfffec007,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 140,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device cmt0_device = {
+        .name           = "sh_cmt",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &cmt0_platform_data,
+        },
+        .resource       = cmt0_resources,
+        .num_resources  = ARRAY_SIZE(cmt0_resources),
+};
+
+static struct sh_timer_config cmt1_platform_data = {
+        .name = "CMT1",
+        .channel_offset = 0x08,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 125,
+        .clocksource_rating = 0, /* disabled due to code generation issues */
+};
+
+static struct resource cmt1_resources[] = {
+        [0] = {
+                .name   = "CMT1",
+                .start  = 0xfffec008,
+                .end    = 0xfffec00d,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 144,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device cmt1_device = {
+        .name           = "sh_cmt",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &cmt1_platform_data,
+        },
+        .resource       = cmt1_resources,
+        .num_resources  = ARRAY_SIZE(cmt1_resources),
+};
+
+static struct sh_timer_config mtu2_0_platform_data = {
+        .name = "MTU2_0",
+        .channel_offset = -0x80,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource mtu2_0_resources[] = {
+        [0] = {
+                .name   = "MTU2_0",
+                .start  = 0xfffe4300,
+                .end    = 0xfffe4326,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 156,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device mtu2_0_device = {
+        .name           = "sh_mtu2",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &mtu2_0_platform_data,
+        },
+        .resource       = mtu2_0_resources,
+        .num_resources  = ARRAY_SIZE(mtu2_0_resources),
+};
+
+static struct sh_timer_config mtu2_1_platform_data = {
+        .name = "MTU2_1",
+        .channel_offset = -0x100,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource mtu2_1_resources[] = {
+        [0] = {
+                .name   = "MTU2_1",
+                .start  = 0xfffe4380,
+                .end    = 0xfffe4390,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 164,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device mtu2_1_device = {
+        .name           = "sh_mtu2",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &mtu2_1_platform_data,
+        },
+        .resource       = mtu2_1_resources,
+        .num_resources  = ARRAY_SIZE(mtu2_1_resources),
+};
+
+static struct sh_timer_config mtu2_2_platform_data = {
+        .name = "MTU2_2",
+        .channel_offset = 0x80,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource mtu2_2_resources[] = {
+        [0] = {
+                .name   = "MTU2_2",
+                .start  = 0xfffe4000,
+                .end    = 0xfffe400a,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 180,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device mtu2_2_device = {
+        .name           = "sh_mtu2",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &mtu2_2_platform_data,
+        },
+        .resource       = mtu2_2_resources,
+        .num_resources  = ARRAY_SIZE(mtu2_2_resources),
+};
+
 static struct platform_device *sh7206_devices[] __initdata = {
         &sci_device,
+        &cmt0_device,
+        &cmt1_device,
+        &mtu2_0_device,
+        &mtu2_1_device,
+        &mtu2_2_device,
 };
 
 static int __init sh7206_devices_setup(void)
@@ -180,3 +344,26 @@ void __init plat_irq_setup(void)
 {
         register_intc_controller(&intc_desc);
 }
+
+static struct platform_device *sh7206_early_devices[] __initdata = {
+        &cmt0_device,
+        &cmt1_device,
+        &mtu2_0_device,
+        &mtu2_1_device,
+        &mtu2_2_device,
+};
+
+#define STBCR3 0xfffe0408
+#define STBCR4 0xfffe040c
+
+void __init plat_early_device_setup(void)
+{
+        /* enable CMT clock */
+        __raw_writeb(__raw_readb(STBCR4) & ~0x04, STBCR4);
+
+        /* enable MTU2 clock */
+        __raw_writeb(__raw_readb(STBCR3) & ~0x20, STBCR3);
+
+        early_platform_add_devices(sh7206_early_devices,
+                                   ARRAY_SIZE(sh7206_early_devices));
+}
diff --git a/arch/sh/kernel/cpu/sh3/clock-sh3.c b/arch/sh/kernel/cpu/sh3/clock-sh3.c
index c3c945958baf..27b8738f0b09 100644
--- a/arch/sh/kernel/cpu/sh3/clock-sh3.c
+++ b/arch/sh/kernel/cpu/sh3/clock-sh3.c
@@ -38,36 +38,36 @@ static struct clk_ops sh3_master_clk_ops = {
         .init           = master_clk_init,
 };
 
-static void module_clk_recalc(struct clk *clk)
+static unsigned long module_clk_recalc(struct clk *clk)
 {
         int frqcr = ctrl_inw(FRQCR);
         int idx = ((frqcr & 0x2000) >> 11) | (frqcr & 0x0003);
 
-        clk->rate = clk->parent->rate / pfc_divisors[idx];
+        return clk->parent->rate / pfc_divisors[idx];
 }
 
 static struct clk_ops sh3_module_clk_ops = {
         .recalc         = module_clk_recalc,
 };
 
-static void bus_clk_recalc(struct clk *clk)
+static unsigned long bus_clk_recalc(struct clk *clk)
 {
         int frqcr = ctrl_inw(FRQCR);
         int idx = ((frqcr & 0x8000) >> 13) | ((frqcr & 0x0030) >> 4);
 
-        clk->rate = clk->parent->rate / stc_multipliers[idx];
+        return clk->parent->rate / stc_multipliers[idx];
 }
 
 static struct clk_ops sh3_bus_clk_ops = {
         .recalc         = bus_clk_recalc,
 };
 
-static void cpu_clk_recalc(struct clk *clk)
+static unsigned long cpu_clk_recalc(struct clk *clk)
 {
         int frqcr = ctrl_inw(FRQCR);
         int idx = ((frqcr & 0x4000) >> 12) | ((frqcr & 0x000c) >> 2);
 
-        clk->rate = clk->parent->rate / ifc_divisors[idx];
+        return clk->parent->rate / ifc_divisors[idx];
 }
 
 static struct clk_ops sh3_cpu_clk_ops = {
diff --git a/arch/sh/kernel/cpu/sh3/clock-sh7705.c b/arch/sh/kernel/cpu/sh3/clock-sh7705.c
index dfdbf3277fd7..0ca8f2c3646c 100644
--- a/arch/sh/kernel/cpu/sh3/clock-sh7705.c
+++ b/arch/sh/kernel/cpu/sh3/clock-sh7705.c
@@ -39,30 +39,30 @@ static struct clk_ops sh7705_master_clk_ops = {
         .init           = master_clk_init,
 };
 
-static void module_clk_recalc(struct clk *clk)
+static unsigned long module_clk_recalc(struct clk *clk)
 {
         int idx = ctrl_inw(FRQCR) & 0x0003;
-        clk->rate = clk->parent->rate / pfc_divisors[idx];
+        return clk->parent->rate / pfc_divisors[idx];
 }
 
 static struct clk_ops sh7705_module_clk_ops = {
         .recalc         = module_clk_recalc,
 };
 
-static void bus_clk_recalc(struct clk *clk)
+static unsigned long bus_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inw(FRQCR) & 0x0300) >> 8;
-        clk->rate = clk->parent->rate / stc_multipliers[idx];
+        return clk->parent->rate / stc_multipliers[idx];
 }
 
 static struct clk_ops sh7705_bus_clk_ops = {
         .recalc         = bus_clk_recalc,
 };
 
-static void cpu_clk_recalc(struct clk *clk)
+static unsigned long cpu_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inw(FRQCR) & 0x0030) >> 4;
-        clk->rate = clk->parent->rate / ifc_divisors[idx];
+        return clk->parent->rate / ifc_divisors[idx];
 }
 
 static struct clk_ops sh7705_cpu_clk_ops = {
diff --git a/arch/sh/kernel/cpu/sh3/clock-sh7706.c b/arch/sh/kernel/cpu/sh3/clock-sh7706.c
index 0cf96f9833bc..4bf7887d310a 100644
--- a/arch/sh/kernel/cpu/sh3/clock-sh7706.c
+++ b/arch/sh/kernel/cpu/sh3/clock-sh7706.c
@@ -34,36 +34,36 @@ static struct clk_ops sh7706_master_clk_ops = {
         .init           = master_clk_init,
 };
 
-static void module_clk_recalc(struct clk *clk)
+static unsigned long module_clk_recalc(struct clk *clk)
 {
         int frqcr = ctrl_inw(FRQCR);
         int idx = ((frqcr & 0x2000) >> 11) | (frqcr & 0x0003);
 
-        clk->rate = clk->parent->rate / pfc_divisors[idx];
+        return clk->parent->rate / pfc_divisors[idx];
 }
 
 static struct clk_ops sh7706_module_clk_ops = {
         .recalc         = module_clk_recalc,
 };
 
-static void bus_clk_recalc(struct clk *clk)
+static unsigned long bus_clk_recalc(struct clk *clk)
 {
         int frqcr = ctrl_inw(FRQCR);
         int idx = ((frqcr & 0x8000) >> 13) | ((frqcr & 0x0030) >> 4);
 
-        clk->rate = clk->parent->rate / stc_multipliers[idx];
+        return clk->parent->rate / stc_multipliers[idx];
 }
 
 static struct clk_ops sh7706_bus_clk_ops = {
         .recalc         = bus_clk_recalc,
 };
 
-static void cpu_clk_recalc(struct clk *clk)
+static unsigned long cpu_clk_recalc(struct clk *clk)
 {
         int frqcr = ctrl_inw(FRQCR);
         int idx = ((frqcr & 0x4000) >> 12) | ((frqcr & 0x000c) >> 2);
 
-        clk->rate = clk->parent->rate / ifc_divisors[idx];
+        return clk->parent->rate / ifc_divisors[idx];
 }
 
 static struct clk_ops sh7706_cpu_clk_ops = {
diff --git a/arch/sh/kernel/cpu/sh3/clock-sh7709.c b/arch/sh/kernel/cpu/sh3/clock-sh7709.c
index b791a29fdb62..fa30b6017730 100644
--- a/arch/sh/kernel/cpu/sh3/clock-sh7709.c
+++ b/arch/sh/kernel/cpu/sh3/clock-sh7709.c
@@ -41,12 +41,12 @@ static struct clk_ops sh7709_master_clk_ops = {
         .init           = master_clk_init,
 };
 
-static void module_clk_recalc(struct clk *clk)
+static unsigned long module_clk_recalc(struct clk *clk)
 {
         int frqcr = ctrl_inw(FRQCR);
         int idx = ((frqcr & 0x2000) >> 11) | (frqcr & 0x0003);
 
-        clk->rate = clk->parent->rate / pfc_divisors[idx];
+        return clk->parent->rate / pfc_divisors[idx];
 }
 
 static struct clk_ops sh7709_module_clk_ops = {
@@ -56,25 +56,25 @@ static struct clk_ops sh7709_module_clk_ops = {
         .recalc         = module_clk_recalc,
 };
 
-static void bus_clk_recalc(struct clk *clk)
+static unsigned long bus_clk_recalc(struct clk *clk)
 {
         int frqcr = ctrl_inw(FRQCR);
         int idx = (frqcr & 0x0080) ?
                 ((frqcr & 0x8000) >> 13) | ((frqcr & 0x0030) >> 4) : 1;
 
-        clk->rate = clk->parent->rate * stc_multipliers[idx];
+        return clk->parent->rate * stc_multipliers[idx];
 }
 
 static struct clk_ops sh7709_bus_clk_ops = {
         .recalc         = bus_clk_recalc,
 };
 
-static void cpu_clk_recalc(struct clk *clk)
+static unsigned long cpu_clk_recalc(struct clk *clk)
 {
         int frqcr = ctrl_inw(FRQCR);
         int idx = ((frqcr & 0x4000) >> 12) | ((frqcr & 0x000c) >> 2);
 
-        clk->rate = clk->parent->rate / ifc_divisors[idx];
+        return clk->parent->rate / ifc_divisors[idx];
 }
 
 static struct clk_ops sh7709_cpu_clk_ops = {
diff --git a/arch/sh/kernel/cpu/sh3/clock-sh7710.c b/arch/sh/kernel/cpu/sh3/clock-sh7710.c
index 4744c50ec449..030a58ba18a5 100644
--- a/arch/sh/kernel/cpu/sh3/clock-sh7710.c
+++ b/arch/sh/kernel/cpu/sh3/clock-sh7710.c
@@ -33,30 +33,30 @@ static struct clk_ops sh7710_master_clk_ops = {
         .init           = master_clk_init,
 };
 
-static void module_clk_recalc(struct clk *clk)
+static unsigned long module_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inw(FRQCR) & 0x0007);
-        clk->rate = clk->parent->rate / md_table[idx];
+        return clk->parent->rate / md_table[idx];
 }
 
 static struct clk_ops sh7710_module_clk_ops = {
         .recalc         = module_clk_recalc,
 };
 
-static void bus_clk_recalc(struct clk *clk)
+static unsigned long bus_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inw(FRQCR) & 0x0700) >> 8;
-        clk->rate = clk->parent->rate / md_table[idx];
+        return clk->parent->rate / md_table[idx];
 }
 
 static struct clk_ops sh7710_bus_clk_ops = {
         .recalc         = bus_clk_recalc,
 };
 
-static void cpu_clk_recalc(struct clk *clk)
+static unsigned long cpu_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inw(FRQCR) & 0x0070) >> 4;
-        clk->rate = clk->parent->rate / md_table[idx];
+        return clk->parent->rate / md_table[idx];
 }
 
 static struct clk_ops sh7710_cpu_clk_ops = {
diff --git a/arch/sh/kernel/cpu/sh3/clock-sh7712.c b/arch/sh/kernel/cpu/sh3/clock-sh7712.c
index 54f54df51ef0..6428ee6c77ed 100644
--- a/arch/sh/kernel/cpu/sh3/clock-sh7712.c
+++ b/arch/sh/kernel/cpu/sh3/clock-sh7712.c
@@ -33,24 +33,24 @@ static struct clk_ops sh7712_master_clk_ops = {
         .init           = master_clk_init,
 };
 
-static void module_clk_recalc(struct clk *clk)
+static unsigned long module_clk_recalc(struct clk *clk)
 {
         int frqcr = ctrl_inw(FRQCR);
         int idx = frqcr & 0x0007;
 
-        clk->rate = clk->parent->rate / divisors[idx];
+        return clk->parent->rate / divisors[idx];
 }
 
 static struct clk_ops sh7712_module_clk_ops = {
         .recalc         = module_clk_recalc,
 };
 
-static void cpu_clk_recalc(struct clk *clk)
+static unsigned long cpu_clk_recalc(struct clk *clk)
 {
         int frqcr = ctrl_inw(FRQCR);
         int idx = (frqcr & 0x0030) >> 4;
 
-        clk->rate = clk->parent->rate / divisors[idx];
+        return clk->parent->rate / divisors[idx];
 }
 
 static struct clk_ops sh7712_cpu_clk_ops = {
diff --git a/arch/sh/kernel/cpu/sh3/setup-sh7705.c b/arch/sh/kernel/cpu/sh3/setup-sh7705.c
index 63b67badd67e..88f742fed9ed 100644
--- a/arch/sh/kernel/cpu/sh3/setup-sh7705.c
+++ b/arch/sh/kernel/cpu/sh3/setup-sh7705.c
@@ -13,6 +13,7 @@
 #include <linux/irq.h>
 #include <linux/serial.h>
 #include <linux/serial_sci.h>
+#include <linux/sh_timer.h>
 #include <asm/rtc.h>
 
 enum {
@@ -116,7 +117,102 @@ static struct platform_device rtc_device = {
         },
 };
 
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x02,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = 0xfffffe94,
+                .end    = 0xfffffe9f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 16,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0xe,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = 0xfffffea0,
+                .end    = 0xfffffeab,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 17,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1a,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = 0xfffffeac,
+                .end    = 0xfffffebb,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 18,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
 static struct platform_device *sh7705_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
         &sci_device,
         &rtc_device,
 };
@@ -128,6 +224,18 @@ static int __init sh7705_devices_setup(void)
 }
 __initcall(sh7705_devices_setup);
 
+static struct platform_device *sh7705_early_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+};
+
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(sh7705_early_devices,
+                                   ARRAY_SIZE(sh7705_early_devices));
+}
+
 void __init plat_irq_setup(void)
 {
         register_intc_controller(&intc_desc);
diff --git a/arch/sh/kernel/cpu/sh3/setup-sh770x.c b/arch/sh/kernel/cpu/sh3/setup-sh770x.c
index a74f960b5e79..c56306798584 100644
--- a/arch/sh/kernel/cpu/sh3/setup-sh770x.c
+++ b/arch/sh/kernel/cpu/sh3/setup-sh770x.c
@@ -18,6 +18,7 @@
 #include <linux/platform_device.h>
 #include <linux/serial.h>
 #include <linux/serial_sci.h>
+#include <linux/sh_timer.h>
 
 enum {
         UNUSED = 0,
@@ -144,7 +145,102 @@ static struct platform_device sci_device = {
         },
 };
 
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x02,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = 0xfffffe94,
+                .end    = 0xfffffe9f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 16,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0xe,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = 0xfffffea0,
+                .end    = 0xfffffeab,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 17,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1a,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = 0xfffffeac,
+                .end    = 0xfffffebb,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 18,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
 static struct platform_device *sh770x_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
         &sci_device,
         &rtc_device,
 };
@@ -156,6 +252,18 @@ static int __init sh770x_devices_setup(void)
 }
 __initcall(sh770x_devices_setup);
 
+static struct platform_device *sh770x_early_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+};
+
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(sh770x_early_devices,
+                                   ARRAY_SIZE(sh770x_early_devices));
+}
+
 void __init plat_irq_setup(void)
 {
         register_intc_controller(&intc_desc);
diff --git a/arch/sh/kernel/cpu/sh3/setup-sh7710.c b/arch/sh/kernel/cpu/sh3/setup-sh7710.c
index 335098b66e2f..efa76c8148f4 100644
--- a/arch/sh/kernel/cpu/sh3/setup-sh7710.c
+++ b/arch/sh/kernel/cpu/sh3/setup-sh7710.c
@@ -13,6 +13,7 @@
 #include <linux/irq.h>
 #include <linux/serial.h>
 #include <linux/serial_sci.h>
+#include <linux/sh_timer.h>
 #include <asm/rtc.h>
 
 enum {
@@ -120,7 +121,102 @@ static struct platform_device sci_device = {
         },
 };
 
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x02,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = 0xa412fe94,
+                .end    = 0xa412fe9f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 16,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0xe,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = 0xa412fea0,
+                .end    = 0xa412feab,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 17,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1a,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = 0xa412feac,
+                .end    = 0xa412feb5,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 18,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
 static struct platform_device *sh7710_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
         &sci_device,
         &rtc_device,
 };
@@ -132,6 +228,18 @@ static int __init sh7710_devices_setup(void)
 }
 __initcall(sh7710_devices_setup);
 
+static struct platform_device *sh7710_early_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+};
+
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(sh7710_early_devices,
+                                   ARRAY_SIZE(sh7710_early_devices));
+}
+
 void __init plat_irq_setup(void)
 {
         register_intc_controller(&intc_desc);
diff --git a/arch/sh/kernel/cpu/sh3/setup-sh7720.c b/arch/sh/kernel/cpu/sh3/setup-sh7720.c
index 003874a2fd2a..5b2107798edb 100644
--- a/arch/sh/kernel/cpu/sh3/setup-sh7720.c
+++ b/arch/sh/kernel/cpu/sh3/setup-sh7720.c
@@ -18,6 +18,7 @@
 #include <linux/serial.h>
 #include <linux/io.h>
 #include <linux/serial_sci.h>
+#include <linux/sh_timer.h>
 #include <asm/rtc.h>
 
 static struct resource rtc_resources[] = {
@@ -123,7 +124,259 @@ static struct platform_device usbf_device = {
         .resource       = usbf_resources,
 };
 
+static struct sh_timer_config cmt0_platform_data = {
+        .name = "CMT0",
+        .channel_offset = 0x10,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 125,
+        .clocksource_rating = 125,
+};
+
+static struct resource cmt0_resources[] = {
+        [0] = {
+                .name   = "CMT0",
+                .start  = 0x044a0010,
+                .end    = 0x044a001b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 104,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device cmt0_device = {
+        .name           = "sh_cmt",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &cmt0_platform_data,
+        },
+        .resource       = cmt0_resources,
+        .num_resources  = ARRAY_SIZE(cmt0_resources),
+};
+
+static struct sh_timer_config cmt1_platform_data = {
+        .name = "CMT1",
+        .channel_offset = 0x20,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+};
+
+static struct resource cmt1_resources[] = {
+        [0] = {
+                .name   = "CMT1",
+                .start  = 0x044a0020,
+                .end    = 0x044a002b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 104,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device cmt1_device = {
+        .name           = "sh_cmt",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &cmt1_platform_data,
+        },
+        .resource       = cmt1_resources,
+        .num_resources  = ARRAY_SIZE(cmt1_resources),
+};
+
+static struct sh_timer_config cmt2_platform_data = {
+        .name = "CMT2",
+        .channel_offset = 0x30,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource cmt2_resources[] = {
+        [0] = {
+                .name   = "CMT2",
+                .start  = 0x044a0030,
+                .end    = 0x044a003b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 104,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device cmt2_device = {
+        .name           = "sh_cmt",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &cmt2_platform_data,
+        },
+        .resource       = cmt2_resources,
+        .num_resources  = ARRAY_SIZE(cmt2_resources),
+};
+
+static struct sh_timer_config cmt3_platform_data = {
+        .name = "CMT3",
+        .channel_offset = 0x40,
+        .timer_bit = 3,
+        .clk = "peripheral_clk",
+};
+
+static struct resource cmt3_resources[] = {
+        [0] = {
+                .name   = "CMT3",
+                .start  = 0x044a0040,
+                .end    = 0x044a004b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 104,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device cmt3_device = {
+        .name           = "sh_cmt",
+        .id             = 3,
+        .dev = {
+                .platform_data  = &cmt3_platform_data,
+        },
+        .resource       = cmt3_resources,
+        .num_resources  = ARRAY_SIZE(cmt3_resources),
+};
+
+static struct sh_timer_config cmt4_platform_data = {
+        .name = "CMT4",
+        .channel_offset = 0x50,
+        .timer_bit = 4,
+        .clk = "peripheral_clk",
+};
+
+static struct resource cmt4_resources[] = {
+        [0] = {
+                .name   = "CMT4",
+                .start  = 0x044a0050,
+                .end    = 0x044a005b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 104,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device cmt4_device = {
+        .name           = "sh_cmt",
+        .id             = 4,
+        .dev = {
+                .platform_data  = &cmt4_platform_data,
+        },
+        .resource       = cmt4_resources,
+        .num_resources  = ARRAY_SIZE(cmt4_resources),
+};
+
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x02,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = 0xa412fe94,
+                .end    = 0xa412fe9f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 16,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0xe,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = 0xa412fea0,
+                .end    = 0xa412feab,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 17,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1a,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = 0xa412feac,
+                .end    = 0xa412feb5,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 18,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
 static struct platform_device *sh7720_devices[] __initdata = {
+        &cmt0_device,
+        &cmt1_device,
+        &cmt2_device,
+        &cmt3_device,
+        &cmt4_device,
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
         &rtc_device,
         &sci_device,
         &usb_ohci_device,
@@ -137,6 +390,23 @@ static int __init sh7720_devices_setup(void)
 }
 __initcall(sh7720_devices_setup);
 
+static struct platform_device *sh7720_early_devices[] __initdata = {
+        &cmt0_device,
+        &cmt1_device,
+        &cmt2_device,
+        &cmt3_device,
+        &cmt4_device,
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+};
+
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(sh7720_early_devices,
+                                   ARRAY_SIZE(sh7720_early_devices));
+}
+
 enum {
         UNUSED = 0,
 
diff --git a/arch/sh/kernel/cpu/sh4/clock-sh4-202.c b/arch/sh/kernel/cpu/sh4/clock-sh4-202.c
index a33429463e96..21421e34e7d5 100644
--- a/arch/sh/kernel/cpu/sh4/clock-sh4-202.c
+++ b/arch/sh/kernel/cpu/sh4/clock-sh4-202.c
@@ -21,10 +21,10 @@
 static int frqcr3_divisors[] = { 1, 2, 3, 4, 6, 8, 16 };
 static int frqcr3_values[]   = { 0, 1, 2, 3, 4, 5, 6  };
 
-static void emi_clk_recalc(struct clk *clk)
+static unsigned long emi_clk_recalc(struct clk *clk)
 {
         int idx = ctrl_inl(CPG2_FRQCR3) & 0x0007;
-        clk->rate = clk->parent->rate / frqcr3_divisors[idx];
+        return clk->parent->rate / frqcr3_divisors[idx];
 }
 
 static inline int frqcr3_lookup(struct clk *clk, unsigned long rate)
@@ -46,14 +46,14 @@ static struct clk_ops sh4202_emi_clk_ops = {
 
 static struct clk sh4202_emi_clk = {
         .name           = "emi_clk",
-        .flags          = CLK_ALWAYS_ENABLED,
+        .flags          = CLK_ENABLE_ON_INIT,
         .ops            = &sh4202_emi_clk_ops,
 };
 
-static void femi_clk_recalc(struct clk *clk)
+static unsigned long femi_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inl(CPG2_FRQCR3) >> 3) & 0x0007;
-        clk->rate = clk->parent->rate / frqcr3_divisors[idx];
+        return clk->parent->rate / frqcr3_divisors[idx];
 }
 
 static struct clk_ops sh4202_femi_clk_ops = {
@@ -62,7 +62,7 @@ static struct clk_ops sh4202_femi_clk_ops = {
 
 static struct clk sh4202_femi_clk = {
         .name           = "femi_clk",
-        .flags          = CLK_ALWAYS_ENABLED,
+        .flags          = CLK_ENABLE_ON_INIT,
         .ops            = &sh4202_femi_clk_ops,
 };
 
@@ -90,10 +90,10 @@ static void shoc_clk_init(struct clk *clk)
         WARN_ON(i == ARRAY_SIZE(frqcr3_divisors));      /* Undefined clock */
 }
 
-static void shoc_clk_recalc(struct clk *clk)
+static unsigned long shoc_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inl(CPG2_FRQCR3) >> 6) & 0x0007;
-        clk->rate = clk->parent->rate / frqcr3_divisors[idx];
+        return clk->parent->rate / frqcr3_divisors[idx];
 }
 
 static int shoc_clk_verify_rate(struct clk *clk, unsigned long rate)
@@ -140,7 +140,7 @@ static struct clk_ops sh4202_shoc_clk_ops = {
 
 static struct clk sh4202_shoc_clk = {
         .name           = "shoc_clk",
-        .flags          = CLK_ALWAYS_ENABLED,
+        .flags          = CLK_ENABLE_ON_INIT,
         .ops            = &sh4202_shoc_clk_ops,
 };
 
@@ -150,31 +150,22 @@ static struct clk *sh4202_onchip_clocks[] = {
         &sh4202_shoc_clk,
 };
 
-static int __init sh4202_clk_init(void)
+int __init arch_clk_init(void)
 {
-        struct clk *clk = clk_get(NULL, "master_clk");
-        int i;
+        struct clk *clk;
+        int i, ret = 0;
+
+        cpg_clk_init();
 
+        clk = clk_get(NULL, "master_clk");
         for (i = 0; i < ARRAY_SIZE(sh4202_onchip_clocks); i++) {
                 struct clk *clkp = sh4202_onchip_clocks[i];
 
                 clkp->parent = clk;
-                clk_register(clkp);
-                clk_enable(clkp);
+                ret |= clk_register(clkp);
         }
 
-        /*
-         * Now that we have the rest of the clocks registered, we need to
-         * force the parent clock to propagate so that these clocks will
-         * automatically figure out their rate. We cheat by handing the
-         * parent clock its current rate and forcing child propagation.
-         */
-        clk_set_rate(clk, clk_get_rate(clk));
-
         clk_put(clk);
 
-        return 0;
+        return ret;
 }
-
-arch_initcall(sh4202_clk_init);
-
diff --git a/arch/sh/kernel/cpu/sh4/clock-sh4.c b/arch/sh/kernel/cpu/sh4/clock-sh4.c
index dca9f87a12d6..73294d9cd049 100644
--- a/arch/sh/kernel/cpu/sh4/clock-sh4.c
+++ b/arch/sh/kernel/cpu/sh4/clock-sh4.c
@@ -35,30 +35,30 @@ static struct clk_ops sh4_master_clk_ops = {
         .init           = master_clk_init,
 };
 
-static void module_clk_recalc(struct clk *clk)
+static unsigned long module_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inw(FRQCR) & 0x0007);
-        clk->rate = clk->parent->rate / pfc_divisors[idx];
+        return clk->parent->rate / pfc_divisors[idx];
 }
 
 static struct clk_ops sh4_module_clk_ops = {
         .recalc         = module_clk_recalc,
 };
 
-static void bus_clk_recalc(struct clk *clk)
+static unsigned long bus_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inw(FRQCR) >> 3) & 0x0007;
-        clk->rate = clk->parent->rate / bfc_divisors[idx];
+        return clk->parent->rate / bfc_divisors[idx];
 }
 
 static struct clk_ops sh4_bus_clk_ops = {
         .recalc         = bus_clk_recalc,
 };
 
-static void cpu_clk_recalc(struct clk *clk)
+static unsigned long cpu_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inw(FRQCR) >> 6) & 0x0007;
-        clk->rate = clk->parent->rate / ifc_divisors[idx];
+        return clk->parent->rate / ifc_divisors[idx];
 }
 
 static struct clk_ops sh4_cpu_clk_ops = {
diff --git a/arch/sh/kernel/cpu/sh4/probe.c b/arch/sh/kernel/cpu/sh4/probe.c
index 91e3677ae09d..6c78d0a9c857 100644
--- a/arch/sh/kernel/cpu/sh4/probe.c
+++ b/arch/sh/kernel/cpu/sh4/probe.c
@@ -60,12 +60,18 @@ int __init detect_cpu_and_cache_system(void)
                 if ((cvr & 0x10000000) == 0)
                         boot_cpu_data.flags |= CPU_HAS_DSP;
 
-                boot_cpu_data.flags |= CPU_HAS_LLSC;
+                boot_cpu_data.flags |= CPU_HAS_LLSC | CPU_HAS_PERF_COUNTER;
                 boot_cpu_data.cut_major = pvr & 0x7f;
+
+                boot_cpu_data.icache.ways = 4;
+                boot_cpu_data.dcache.ways = 4;
+        } else {
+                /* And some SH-4 defaults.. */
+                boot_cpu_data.flags |= CPU_HAS_PTEA;
         }
 
         /* FPU detection works for everyone */
-        if ((cvr & 0x20000000) == 1)
+        if ((cvr & 0x20000000))
                 boot_cpu_data.flags |= CPU_HAS_FPU;
 
         /* Mask off the upper chip ID */
@@ -78,25 +84,20 @@ int __init detect_cpu_and_cache_system(void)
         switch (pvr) {
         case 0x205:
                 boot_cpu_data.type = CPU_SH7750;
-                boot_cpu_data.flags |= CPU_HAS_P2_FLUSH_BUG | CPU_HAS_FPU |
-                                   CPU_HAS_PERF_COUNTER;
+                boot_cpu_data.flags |= CPU_HAS_P2_FLUSH_BUG |
+                                       CPU_HAS_PERF_COUNTER;
                 break;
         case 0x206:
                 boot_cpu_data.type = CPU_SH7750S;
-                boot_cpu_data.flags |= CPU_HAS_P2_FLUSH_BUG | CPU_HAS_FPU |
-                                   CPU_HAS_PERF_COUNTER;
+                boot_cpu_data.flags |= CPU_HAS_P2_FLUSH_BUG |
+                                       CPU_HAS_PERF_COUNTER;
                 break;
         case 0x1100:
                 boot_cpu_data.type = CPU_SH7751;
-                boot_cpu_data.flags |= CPU_HAS_FPU;
                 break;
         case 0x2001:
         case 0x2004:
                 boot_cpu_data.type = CPU_SH7770;
-                boot_cpu_data.icache.ways = 4;
-                boot_cpu_data.dcache.ways = 4;
-
-                boot_cpu_data.flags |= CPU_HAS_FPU | CPU_HAS_LLSC;
                 break;
         case 0x2006:
         case 0x200A:
@@ -107,45 +108,26 @@ int __init detect_cpu_and_cache_system(void)
                 else
                         boot_cpu_data.type = CPU_SH7780;
 
-                boot_cpu_data.icache.ways = 4;
-                boot_cpu_data.dcache.ways = 4;
-
-                boot_cpu_data.flags |= CPU_HAS_FPU | CPU_HAS_PERF_COUNTER |
-                                   CPU_HAS_LLSC;
                 break;
         case 0x3000:
         case 0x3003:
         case 0x3009:
                 boot_cpu_data.type = CPU_SH7343;
-                boot_cpu_data.icache.ways = 4;
-                boot_cpu_data.dcache.ways = 4;
-                boot_cpu_data.flags |= CPU_HAS_LLSC;
                 break;
         case 0x3004:
         case 0x3007:
                 boot_cpu_data.type = CPU_SH7785;
-                boot_cpu_data.icache.ways = 4;
-                boot_cpu_data.dcache.ways = 4;
-                boot_cpu_data.flags |= CPU_HAS_FPU | CPU_HAS_PERF_COUNTER |
-                                          CPU_HAS_LLSC;
                 break;
         case 0x4004:
                 boot_cpu_data.type = CPU_SH7786;
-                boot_cpu_data.icache.ways = 4;
-                boot_cpu_data.dcache.ways = 4;
-                boot_cpu_data.flags |= CPU_HAS_FPU | CPU_HAS_PERF_COUNTER |
-                        CPU_HAS_LLSC | CPU_HAS_PTEAEX;
+                boot_cpu_data.flags |= CPU_HAS_PTEAEX | CPU_HAS_L2_CACHE;
                 break;
         case 0x3008:
-                boot_cpu_data.icache.ways = 4;
-                boot_cpu_data.dcache.ways = 4;
-                boot_cpu_data.flags |= CPU_HAS_LLSC;
-
                 switch (prr) {
                 case 0x50:
                 case 0x51:
                         boot_cpu_data.type = CPU_SH7723;
-                        boot_cpu_data.flags |= CPU_HAS_FPU | CPU_HAS_L2_CACHE;
+                        boot_cpu_data.flags |= CPU_HAS_L2_CACHE;
                         break;
                 case 0x70:
                         boot_cpu_data.type = CPU_SH7366;
@@ -156,13 +138,13 @@ int __init detect_cpu_and_cache_system(void)
                         break;
                 }
                 break;
+        case 0x300b:
+                boot_cpu_data.type = CPU_SH7724;
+                boot_cpu_data.flags |= CPU_HAS_L2_CACHE;
+                break;
         case 0x4000:    /* 1st cut */
         case 0x4001:    /* 2nd cut */
                 boot_cpu_data.type = CPU_SHX3;
-                boot_cpu_data.icache.ways = 4;
-                boot_cpu_data.dcache.ways = 4;
-                boot_cpu_data.flags |= CPU_HAS_FPU | CPU_HAS_PERF_COUNTER |
-                                          CPU_HAS_LLSC;
                 break;
         case 0x700:
                 boot_cpu_data.type = CPU_SH4_501;
@@ -173,7 +155,6 @@ int __init detect_cpu_and_cache_system(void)
                 boot_cpu_data.type = CPU_SH4_202;
                 boot_cpu_data.icache.ways = 2;
                 boot_cpu_data.dcache.ways = 2;
-                boot_cpu_data.flags |= CPU_HAS_FPU;
                 break;
         case 0x500 ... 0x501:
                 switch (prr) {
@@ -191,18 +172,12 @@ int __init detect_cpu_and_cache_system(void)
                 boot_cpu_data.icache.ways = 2;
                 boot_cpu_data.dcache.ways = 2;
 
-                boot_cpu_data.flags |= CPU_HAS_FPU;
-
                 break;
         default:
                 boot_cpu_data.type = CPU_SH_NONE;
                 break;
         }
 
-#ifdef CONFIG_CPU_HAS_PTEA
-        boot_cpu_data.flags |= CPU_HAS_PTEA;
-#endif
-
         /*
          * On anything that's not a direct-mapped cache, look to the CVR
          * for I/D-cache specifics.
@@ -222,43 +197,48 @@ int __init detect_cpu_and_cache_system(void)
         }
 
         /*
-         * Setup the L2 cache desc
-         *
          * SH-4A's have an optional PIPT L2.
          */
         if (boot_cpu_data.flags & CPU_HAS_L2_CACHE) {
-                /* Bug if we can't decode the L2 info */
-                BUG_ON(!(cvr & 0xf));
-
-                /* Silicon and specifications have clearly never met.. */
-                cvr ^= 0xf;
-
                 /*
-                 * Size calculation is much more sensible
-                 * than it is for the L1.
-                 *
-                 * Sizes are 128KB, 258KB, 512KB, and 1MB.
+                 * Verify that it really has something hooked up, this
+                 * is the safety net for CPUs that have optional L2
+                 * support yet do not implement it.
                  */
-                size = (cvr & 0xf) << 17;
-
-                BUG_ON(!size);
-
-                boot_cpu_data.scache.way_incr           = (1 << 16);
-                boot_cpu_data.scache.entry_shift        = 5;
-                boot_cpu_data.scache.ways               = 4;
-                boot_cpu_data.scache.linesz             = L1_CACHE_BYTES;
-
-                boot_cpu_data.scache.entry_mask =
-                        (boot_cpu_data.scache.way_incr -
-                         boot_cpu_data.scache.linesz);
-
-                boot_cpu_data.scache.sets       = size /
-                        (boot_cpu_data.scache.linesz *
-                         boot_cpu_data.scache.ways);
-
-                boot_cpu_data.scache.way_size   =
-                        (boot_cpu_data.scache.sets *
-                         boot_cpu_data.scache.linesz);
+                if ((cvr & 0xf) == 0)
+                        boot_cpu_data.flags &= ~CPU_HAS_L2_CACHE;
+                else {
+                        /*
+                         * Silicon and specifications have clearly never
+                         * met..
+                         */
+                        cvr ^= 0xf;
+
+                        /*
+                         * Size calculation is much more sensible
+                         * than it is for the L1.
+                         *
+                         * Sizes are 128KB, 258KB, 512KB, and 1MB.
+                         */
+                        size = (cvr & 0xf) << 17;
+
+                        boot_cpu_data.scache.way_incr           = (1 << 16);
+                        boot_cpu_data.scache.entry_shift        = 5;
+                        boot_cpu_data.scache.ways               = 4;
+                        boot_cpu_data.scache.linesz             = L1_CACHE_BYTES;
+
+                        boot_cpu_data.scache.entry_mask =
+                                (boot_cpu_data.scache.way_incr -
+                                 boot_cpu_data.scache.linesz);
+
+                        boot_cpu_data.scache.sets       = size /
+                                (boot_cpu_data.scache.linesz *
+                                 boot_cpu_data.scache.ways);
+
+                        boot_cpu_data.scache.way_size   =
+                                (boot_cpu_data.scache.sets *
+                                 boot_cpu_data.scache.linesz);
+                }
         }
 
         return 0;
diff --git a/arch/sh/kernel/cpu/sh4/setup-sh4-202.c b/arch/sh/kernel/cpu/sh4/setup-sh4-202.c
index 7371abf64f80..6d088d123591 100644
--- a/arch/sh/kernel/cpu/sh4/setup-sh4-202.c
+++ b/arch/sh/kernel/cpu/sh4/setup-sh4-202.c
@@ -2,6 +2,7 @@
  * SH4-202 Setup
  *
  *  Copyright (C) 2006  Paul Mundt
+ *  Copyright (C) 2009  Magnus Damm
  *
  * 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
@@ -11,6 +12,8 @@
 #include <linux/init.h>
 #include <linux/serial.h>
 #include <linux/serial_sci.h>
+#include <linux/sh_timer.h>
+#include <linux/io.h>
 
 static struct plat_sci_port sci_platform_data[] = {
         {
@@ -31,8 +34,103 @@ static struct platform_device sci_device = {
         },
 };
 
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = 0xffd80008,
+                .end    = 0xffd80013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 16,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = 0xffd80014,
+                .end    = 0xffd8001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 17,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = 0xffd80020,
+                .end    = 0xffd8002f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 18,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
 static struct platform_device *sh4202_devices[] __initdata = {
         &sci_device,
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
 };
 
 static int __init sh4202_devices_setup(void)
@@ -42,7 +140,71 @@ static int __init sh4202_devices_setup(void)
 }
 __initcall(sh4202_devices_setup);
 
+static struct platform_device *sh4202_early_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+};
+
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(sh4202_early_devices,
+                                   ARRAY_SIZE(sh4202_early_devices));
+}
+
+enum {
+        UNUSED = 0,
+
+        /* interrupt sources */
+        IRL0, IRL1, IRL2, IRL3, /* only IRLM mode supported */
+        HUDI, TMU0, TMU1, TMU2, RTC, SCIF, WDT,
+};
+
+static struct intc_vect vectors[] __initdata = {
+        INTC_VECT(HUDI, 0x600),
+        INTC_VECT(TMU0, 0x400), INTC_VECT(TMU1, 0x420),
+        INTC_VECT(TMU2, 0x440), INTC_VECT(TMU2, 0x460),
+        INTC_VECT(RTC, 0x480), INTC_VECT(RTC, 0x4a0),
+        INTC_VECT(RTC, 0x4c0),
+        INTC_VECT(SCIF, 0x700), INTC_VECT(SCIF, 0x720),
+        INTC_VECT(SCIF, 0x740), INTC_VECT(SCIF, 0x760),
+        INTC_VECT(WDT, 0x560),
+};
+
+static struct intc_prio_reg prio_registers[] __initdata = {
+        { 0xffd00004, 0, 16, 4, /* IPRA */ { TMU0, TMU1, TMU2, RTC } },
+        { 0xffd00008, 0, 16, 4, /* IPRB */ { WDT, 0, 0, 0 } },
+        { 0xffd0000c, 0, 16, 4, /* IPRC */ { 0, 0, SCIF, HUDI } },
+        { 0xffd00010, 0, 16, 4, /* IPRD */ { IRL0, IRL1, IRL2, IRL3 } },
+};
+
+static DECLARE_INTC_DESC(intc_desc, "sh4-202", vectors, NULL,
+                         NULL, prio_registers, NULL);
+
+static struct intc_vect vectors_irlm[] __initdata = {
+        INTC_VECT(IRL0, 0x240), INTC_VECT(IRL1, 0x2a0),
+        INTC_VECT(IRL2, 0x300), INTC_VECT(IRL3, 0x360),
+};
+
+static DECLARE_INTC_DESC(intc_desc_irlm, "sh4-202_irlm", vectors_irlm, NULL,
+                         NULL, prio_registers, NULL);
+
 void __init plat_irq_setup(void)
 {
-        /* do nothing - all IRL interrupts are handled by the board code */
+        register_intc_controller(&intc_desc);
+}
+
+#define INTC_ICR        0xffd00000UL
+#define INTC_ICR_IRLM   (1<<7)
+
+void __init plat_irq_setup_pins(int mode)
+{
+        switch (mode) {
+        case IRQ_MODE_IRQ: /* individual interrupt mode for IRL3-0 */
+                ctrl_outw(ctrl_inw(INTC_ICR) | INTC_ICR_IRLM, INTC_ICR);
+                register_intc_controller(&intc_desc_irlm);
+                break;
+        default:
+                BUG();
+        }
 }
diff --git a/arch/sh/kernel/cpu/sh4/setup-sh7750.c b/arch/sh/kernel/cpu/sh4/setup-sh7750.c
index a1c80d909cd6..851672d15cf4 100644
--- a/arch/sh/kernel/cpu/sh4/setup-sh7750.c
+++ b/arch/sh/kernel/cpu/sh4/setup-sh7750.c
@@ -12,6 +12,7 @@
 #include <linux/init.h>
 #include <linux/serial.h>
 #include <linux/io.h>
+#include <linux/sh_timer.h>
 #include <linux/serial_sci.h>
 
 static struct resource rtc_resources[] = {
@@ -60,9 +61,177 @@ static struct platform_device sci_device = {
         },
 };
 
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = 0xffd80008,
+                .end    = 0xffd80013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 16,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = 0xffd80014,
+                .end    = 0xffd8001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 17,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = 0xffd80020,
+                .end    = 0xffd8002f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 18,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
+/* SH7750R, SH7751 and SH7751R all have two extra timer channels */
+#if defined(CONFIG_CPU_SUBTYPE_SH7750R) || \
+        defined(CONFIG_CPU_SUBTYPE_SH7751) || \
+        defined(CONFIG_CPU_SUBTYPE_SH7751R)
+
+static struct sh_timer_config tmu3_platform_data = {
+        .name = "TMU3",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu3_resources[] = {
+        [0] = {
+                .name   = "TMU3",
+                .start  = 0xfe100008,
+                .end    = 0xfe100013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 72,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu3_device = {
+        .name           = "sh_tmu",
+        .id             = 3,
+        .dev = {
+                .platform_data  = &tmu3_platform_data,
+        },
+        .resource       = tmu3_resources,
+        .num_resources  = ARRAY_SIZE(tmu3_resources),
+};
+
+static struct sh_timer_config tmu4_platform_data = {
+        .name = "TMU4",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu4_resources[] = {
+        [0] = {
+                .name   = "TMU4",
+                .start  = 0xfe100014,
+                .end    = 0xfe10001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 76,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu4_device = {
+        .name           = "sh_tmu",
+        .id             = 4,
+        .dev = {
+                .platform_data  = &tmu4_platform_data,
+        },
+        .resource       = tmu4_resources,
+        .num_resources  = ARRAY_SIZE(tmu4_resources),
+};
+
+#endif
+
 static struct platform_device *sh7750_devices[] __initdata = {
         &rtc_device,
         &sci_device,
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+#if defined(CONFIG_CPU_SUBTYPE_SH7750R) || \
+        defined(CONFIG_CPU_SUBTYPE_SH7751) || \
+        defined(CONFIG_CPU_SUBTYPE_SH7751R)
+        &tmu3_device,
+        &tmu4_device,
+#endif
 };
 
 static int __init sh7750_devices_setup(void)
@@ -72,6 +241,24 @@ static int __init sh7750_devices_setup(void)
 }
 __initcall(sh7750_devices_setup);
 
+static struct platform_device *sh7750_early_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+#if defined(CONFIG_CPU_SUBTYPE_SH7750R) || \
+        defined(CONFIG_CPU_SUBTYPE_SH7751) || \
+        defined(CONFIG_CPU_SUBTYPE_SH7751R)
+        &tmu3_device,
+        &tmu4_device,
+#endif
+};
+
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(sh7750_early_devices,
+                                   ARRAY_SIZE(sh7750_early_devices));
+}
+
 enum {
         UNUSED = 0,
 
diff --git a/arch/sh/kernel/cpu/sh4/setup-sh7760.c b/arch/sh/kernel/cpu/sh4/setup-sh7760.c
index d9bdc931ac09..5b822519bd90 100644
--- a/arch/sh/kernel/cpu/sh4/setup-sh7760.c
+++ b/arch/sh/kernel/cpu/sh4/setup-sh7760.c
@@ -10,6 +10,7 @@
 #include <linux/platform_device.h>
 #include <linux/init.h>
 #include <linux/serial.h>
+#include <linux/sh_timer.h>
 #include <linux/serial_sci.h>
 #include <linux/io.h>
 
@@ -18,10 +19,7 @@ enum {
 
         /* interrupt sources */
         IRL0, IRL1, IRL2, IRL3,
-        HUDI, GPIOI,
-        DMAC_DMTE0, DMAC_DMTE1, DMAC_DMTE2, DMAC_DMTE3,
-        DMAC_DMTE4, DMAC_DMTE5, DMAC_DMTE6, DMAC_DMTE7,
-        DMAC_DMAE,
+        HUDI, GPIOI, DMAC,
         IRQ4, IRQ5, IRQ6, IRQ7,
         HCAN20, HCAN21,
         SSI0, SSI1,
@@ -36,21 +34,20 @@ enum {
         HSPI,
         MMCIF0, MMCIF1, MMCIF2, MMCIF3,
         MFI, ADC, CMT,
-        TMU0, TMU1, TMU2_TUNI, TMU2_TICPI,
-        WDT,
-        REF_RCMI, REF_ROVI,
+        TMU0, TMU1, TMU2,
+        WDT, REF,
 
         /* interrupt groups */
-        DMAC, DMABRG, SCIF0, SCIF1, SCIF2, SIM, MMCIF, TMU2, REF,
+        DMABRG, SCIF0, SCIF1, SCIF2, SIM, MMCIF,
 };
 
 static struct intc_vect vectors[] __initdata = {
         INTC_VECT(HUDI, 0x600), INTC_VECT(GPIOI, 0x620),
-        INTC_VECT(DMAC_DMTE0, 0x640), INTC_VECT(DMAC_DMTE1, 0x660),
-        INTC_VECT(DMAC_DMTE2, 0x680), INTC_VECT(DMAC_DMTE3, 0x6a0),
-        INTC_VECT(DMAC_DMTE4, 0x780), INTC_VECT(DMAC_DMTE5, 0x7a0),
-        INTC_VECT(DMAC_DMTE6, 0x7c0), INTC_VECT(DMAC_DMTE7, 0x7e0),
-        INTC_VECT(DMAC_DMAE, 0x6c0),
+        INTC_VECT(DMAC, 0x640), INTC_VECT(DMAC, 0x660),
+        INTC_VECT(DMAC, 0x680), INTC_VECT(DMAC, 0x6a0),
+        INTC_VECT(DMAC, 0x780), INTC_VECT(DMAC, 0x7a0),
+        INTC_VECT(DMAC, 0x7c0), INTC_VECT(DMAC, 0x7e0),
+        INTC_VECT(DMAC, 0x6c0),
         INTC_VECT(IRQ4, 0x800), INTC_VECT(IRQ5, 0x820),
         INTC_VECT(IRQ6, 0x840), INTC_VECT(IRQ6, 0x860),
         INTC_VECT(HCAN20, 0x900), INTC_VECT(HCAN21, 0x920),
@@ -74,23 +71,18 @@ static struct intc_vect vectors[] __initdata = {
         INTC_VECT(MFI, 0xe80), /* 0xf80 according to data sheet */
         INTC_VECT(ADC, 0xf80), INTC_VECT(CMT, 0xfa0),
         INTC_VECT(TMU0, 0x400), INTC_VECT(TMU1, 0x420),
-        INTC_VECT(TMU2_TUNI, 0x440), INTC_VECT(TMU2_TICPI, 0x460),
+        INTC_VECT(TMU2, 0x440), INTC_VECT(TMU2, 0x460),
         INTC_VECT(WDT, 0x560),
-        INTC_VECT(REF_RCMI, 0x580), INTC_VECT(REF_ROVI, 0x5a0),
+        INTC_VECT(REF, 0x580), INTC_VECT(REF, 0x5a0),
 };
 
 static struct intc_group groups[] __initdata = {
-        INTC_GROUP(DMAC, DMAC_DMTE0, DMAC_DMTE1, DMAC_DMTE2,
-                   DMAC_DMTE3, DMAC_DMTE4, DMAC_DMTE5,
-                   DMAC_DMTE6, DMAC_DMTE7, DMAC_DMAE),
         INTC_GROUP(DMABRG, DMABRG0, DMABRG1, DMABRG2),
         INTC_GROUP(SCIF0, SCIF0_ERI, SCIF0_RXI, SCIF0_BRI, SCIF0_TXI),
         INTC_GROUP(SCIF1, SCIF1_ERI, SCIF1_RXI, SCIF1_BRI, SCIF1_TXI),
         INTC_GROUP(SCIF2, SCIF2_ERI, SCIF2_RXI, SCIF2_BRI, SCIF2_TXI),
         INTC_GROUP(SIM, SIM_ERI, SIM_RXI, SIM_TXI, SIM_TEI),
         INTC_GROUP(MMCIF, MMCIF0, MMCIF1, MMCIF2, MMCIF3),
-        INTC_GROUP(TMU2, TMU2_TUNI, TMU2_TICPI),
-        INTC_GROUP(REF, REF_RCMI, REF_ROVI),
 };
 
 static struct intc_mask_reg mask_registers[] __initdata = {
@@ -168,8 +160,104 @@ static struct platform_device sci_device = {
         },
 };
 
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = 0xffd80008,
+                .end    = 0xffd80013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 16,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = 0xffd80014,
+                .end    = 0xffd8001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 17,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = 0xffd80020,
+                .end    = 0xffd8002f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 18,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
+
 static struct platform_device *sh7760_devices[] __initdata = {
         &sci_device,
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
 };
 
 static int __init sh7760_devices_setup(void)
@@ -179,6 +267,18 @@ static int __init sh7760_devices_setup(void)
 }
 __initcall(sh7760_devices_setup);
 
+static struct platform_device *sh7760_early_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+};
+
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(sh7760_early_devices,
+                                   ARRAY_SIZE(sh7760_early_devices));
+}
+
 #define INTC_ICR        0xffd00000UL
 #define INTC_ICR_IRLM   (1 << 7)
 
diff --git a/arch/sh/kernel/cpu/sh4a/Makefile b/arch/sh/kernel/cpu/sh4a/Makefile
index 1a92361feeb9..96ea09ca8cc1 100644
--- a/arch/sh/kernel/cpu/sh4a/Makefile
+++ b/arch/sh/kernel/cpu/sh4a/Makefile
@@ -11,6 +11,7 @@ obj-$(CONFIG_CPU_SUBTYPE_SH7786)	+= setup-sh7786.o
 obj-$(CONFIG_CPU_SUBTYPE_SH7343)        += setup-sh7343.o
 obj-$(CONFIG_CPU_SUBTYPE_SH7722)        += setup-sh7722.o
 obj-$(CONFIG_CPU_SUBTYPE_SH7723)        += setup-sh7723.o
+obj-$(CONFIG_CPU_SUBTYPE_SH7724)        += setup-sh7724.o
 obj-$(CONFIG_CPU_SUBTYPE_SH7366)        += setup-sh7366.o
 obj-$(CONFIG_CPU_SUBTYPE_SHX3)          += setup-shx3.o
 
@@ -23,15 +24,17 @@ clock-$(CONFIG_CPU_SUBTYPE_SH7770)	:= clock-sh7770.o
 clock-$(CONFIG_CPU_SUBTYPE_SH7780)      := clock-sh7780.o
 clock-$(CONFIG_CPU_SUBTYPE_SH7785)      := clock-sh7785.o
 clock-$(CONFIG_CPU_SUBTYPE_SH7786)      := clock-sh7786.o
-clock-$(CONFIG_CPU_SUBTYPE_SH7343)      := clock-sh7722.o
+clock-$(CONFIG_CPU_SUBTYPE_SH7343)      := clock-sh7343.o
 clock-$(CONFIG_CPU_SUBTYPE_SH7722)      := clock-sh7722.o
-clock-$(CONFIG_CPU_SUBTYPE_SH7723)      := clock-sh7722.o
-clock-$(CONFIG_CPU_SUBTYPE_SH7366)      := clock-sh7722.o
+clock-$(CONFIG_CPU_SUBTYPE_SH7723)      := clock-sh7723.o
+clock-$(CONFIG_CPU_SUBTYPE_SH7724)      := clock-sh7724.o
+clock-$(CONFIG_CPU_SUBTYPE_SH7366)      := clock-sh7366.o
 clock-$(CONFIG_CPU_SUBTYPE_SHX3)        := clock-shx3.o
 
 # Pinmux setup
 pinmux-$(CONFIG_CPU_SUBTYPE_SH7722)     := pinmux-sh7722.o
 pinmux-$(CONFIG_CPU_SUBTYPE_SH7723)     := pinmux-sh7723.o
+pinmux-$(CONFIG_CPU_SUBTYPE_SH7724)     := pinmux-sh7724.o
 pinmux-$(CONFIG_CPU_SUBTYPE_SH7785)     := pinmux-sh7785.o
 pinmux-$(CONFIG_CPU_SUBTYPE_SH7786)     := pinmux-sh7786.o
 
diff --git a/arch/sh/kernel/cpu/sh4a/clock-sh7343.c b/arch/sh/kernel/cpu/sh4a/clock-sh7343.c
new file mode 100644
index 000000000000..0ee3ee861252
--- /dev/null
+++ b/arch/sh/kernel/cpu/sh4a/clock-sh7343.c
@@ -0,0 +1,211 @@
+/*
+ * arch/sh/kernel/cpu/sh4a/clock-sh7343.c
+ *
+ * SH7343 clock framework support
+ *
+ * Copyright (C) 2009 Magnus Damm
+ *
+ * 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
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/io.h>
+#include <asm/clock.h>
+
+/* SH7343 registers */
+#define FRQCR           0xa4150000
+#define VCLKCR          0xa4150004
+#define SCLKACR         0xa4150008
+#define SCLKBCR         0xa415000c
+#define PLLCR           0xa4150024
+#define MSTPCR0         0xa4150030
+#define MSTPCR1         0xa4150034
+#define MSTPCR2         0xa4150038
+#define DLLFRQ          0xa4150050
+
+/* Fixed 32 KHz root clock for RTC and Power Management purposes */
+static struct clk r_clk = {
+        .name           = "rclk",
+        .id             = -1,
+        .rate           = 32768,
+};
+
+/*
+ * Default rate for the root input clock, reset this with clk_set_rate()
+ * from the platform code.
+ */
+struct clk extal_clk = {
+        .name           = "extal",
+        .id             = -1,
+        .rate           = 33333333,
+};
+
+/* The dll block multiplies the 32khz r_clk, may be used instead of extal */
+static unsigned long dll_recalc(struct clk *clk)
+{
+        unsigned long mult;
+
+        if (__raw_readl(PLLCR) & 0x1000)
+                mult = __raw_readl(DLLFRQ);
+        else
+                mult = 0;
+
+        return clk->parent->rate * mult;
+}
+
+static struct clk_ops dll_clk_ops = {
+        .recalc         = dll_recalc,
+};
+
+static struct clk dll_clk = {
+        .name           = "dll_clk",
+        .id             = -1,
+        .ops            = &dll_clk_ops,
+        .parent         = &r_clk,
+        .flags          = CLK_ENABLE_ON_INIT,
+};
+
+static unsigned long pll_recalc(struct clk *clk)
+{
+        unsigned long mult = 1;
+
+        if (__raw_readl(PLLCR) & 0x4000)
+                mult = (((__raw_readl(FRQCR) >> 24) & 0x1f) + 1);
+
+        return clk->parent->rate * mult;
+}
+
+static struct clk_ops pll_clk_ops = {
+        .recalc         = pll_recalc,
+};
+
+static struct clk pll_clk = {
+        .name           = "pll_clk",
+        .id             = -1,
+        .ops            = &pll_clk_ops,
+        .flags          = CLK_ENABLE_ON_INIT,
+};
+
+struct clk *main_clks[] = {
+        &r_clk,
+        &extal_clk,
+        &dll_clk,
+        &pll_clk,
+};
+
+static int multipliers[] = { 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
+static int divisors[] = { 1, 3, 2, 5, 3, 4, 5, 6, 8, 10, 12, 16, 20 };
+
+static struct clk_div_mult_table div4_table = {
+        .divisors = divisors,
+        .nr_divisors = ARRAY_SIZE(divisors),
+        .multipliers = multipliers,
+        .nr_multipliers = ARRAY_SIZE(multipliers),
+};
+
+enum { DIV4_I, DIV4_U, DIV4_SH, DIV4_B, DIV4_B3, DIV4_P,
+       DIV4_SIUA, DIV4_SIUB, DIV4_NR };
+
+#define DIV4(_str, _reg, _bit, _mask, _flags) \
+  SH_CLK_DIV4(_str, &pll_clk, _reg, _bit, _mask, _flags)
+
+struct clk div4_clks[DIV4_NR] = {
+        [DIV4_I] = DIV4("cpu_clk", FRQCR, 20, 0x1fff, CLK_ENABLE_ON_INIT),
+        [DIV4_U] = DIV4("umem_clk", FRQCR, 16, 0x1fff, CLK_ENABLE_ON_INIT),
+        [DIV4_SH] = DIV4("shyway_clk", FRQCR, 12, 0x1fff, CLK_ENABLE_ON_INIT),
+        [DIV4_B] = DIV4("bus_clk", FRQCR, 8, 0x1fff, CLK_ENABLE_ON_INIT),
+        [DIV4_B3] = DIV4("b3_clk", FRQCR, 4, 0x1fff, CLK_ENABLE_ON_INIT),
+        [DIV4_P] = DIV4("peripheral_clk", FRQCR, 0, 0x1fff, 0),
+        [DIV4_SIUA] = DIV4("siua_clk", SCLKACR, 0, 0x1fff, 0),
+        [DIV4_SIUB] = DIV4("siub_clk", SCLKBCR, 0, 0x1fff, 0),
+};
+
+struct clk div6_clks[] = {
+        SH_CLK_DIV6("video_clk", &pll_clk, VCLKCR, 0),
+};
+
+#define MSTP(_str, _parent, _reg, _bit, _flags) \
+  SH_CLK_MSTP32(_str, -1, _parent, _reg, _bit, _flags)
+
+static struct clk mstp_clks[] = {
+        MSTP("tlb0", &div4_clks[DIV4_I], MSTPCR0, 31, CLK_ENABLE_ON_INIT),
+        MSTP("ic0", &div4_clks[DIV4_I], MSTPCR0, 30, CLK_ENABLE_ON_INIT),
+        MSTP("oc0", &div4_clks[DIV4_I], MSTPCR0, 29, CLK_ENABLE_ON_INIT),
+        MSTP("uram0", &div4_clks[DIV4_U], MSTPCR0, 28, CLK_ENABLE_ON_INIT),
+        MSTP("xymem0", &div4_clks[DIV4_B], MSTPCR0, 26, CLK_ENABLE_ON_INIT),
+        MSTP("intc3", &div4_clks[DIV4_P], MSTPCR0, 23, 0),
+        MSTP("intc0", &div4_clks[DIV4_P], MSTPCR0, 22, 0),
+        MSTP("dmac0", &div4_clks[DIV4_P], MSTPCR0, 21, 0),
+        MSTP("sh0", &div4_clks[DIV4_P], MSTPCR0, 20, 0),
+        MSTP("hudi0", &div4_clks[DIV4_P], MSTPCR0, 19, 0),
+        MSTP("ubc0", &div4_clks[DIV4_P], MSTPCR0, 17, 0),
+        MSTP("tmu0", &div4_clks[DIV4_P], MSTPCR0, 15, 0),
+        MSTP("cmt0", &r_clk, MSTPCR0, 14, 0),
+        MSTP("rwdt0", &r_clk, MSTPCR0, 13, 0),
+        MSTP("mfi0", &div4_clks[DIV4_P], MSTPCR0, 11, 0),
+        MSTP("flctl0", &div4_clks[DIV4_P], MSTPCR0, 10, 0),
+        MSTP("scif0", &div4_clks[DIV4_P], MSTPCR0, 7, 0),
+        MSTP("scif1", &div4_clks[DIV4_P], MSTPCR0, 6, 0),
+        MSTP("scif2", &div4_clks[DIV4_P], MSTPCR0, 5, 0),
+        MSTP("scif3", &div4_clks[DIV4_P], MSTPCR0, 4, 0),
+        MSTP("sio0", &div4_clks[DIV4_P], MSTPCR0, 3, 0),
+        MSTP("siof0", &div4_clks[DIV4_P], MSTPCR0, 2, 0),
+        MSTP("siof1", &div4_clks[DIV4_P], MSTPCR0, 1, 0),
+
+        MSTP("i2c0", &div4_clks[DIV4_P], MSTPCR1, 9, 0),
+        MSTP("i2c1", &div4_clks[DIV4_P], MSTPCR1, 8, 0),
+
+        MSTP("tpu0", &div4_clks[DIV4_P], MSTPCR2, 25, 0),
+        MSTP("irda0", &div4_clks[DIV4_P], MSTPCR2, 24, 0),
+        MSTP("sdhi0", &div4_clks[DIV4_P], MSTPCR2, 18, 0),
+        MSTP("mmcif0", &div4_clks[DIV4_P], MSTPCR2, 17, 0),
+        MSTP("sim0", &div4_clks[DIV4_P], MSTPCR2, 16, 0),
+        MSTP("keysc0", &r_clk, MSTPCR2, 14, 0),
+        MSTP("tsif0", &div4_clks[DIV4_P], MSTPCR2, 13, 0),
+        MSTP("s3d40", &div4_clks[DIV4_P], MSTPCR2, 12, 0),
+        MSTP("usbf0", &div4_clks[DIV4_P], MSTPCR2, 11, 0),
+        MSTP("siu0", &div4_clks[DIV4_B], MSTPCR2, 8, 0),
+        MSTP("jpu0", &div4_clks[DIV4_B], MSTPCR2, 6, CLK_ENABLE_ON_INIT),
+        MSTP("vou0", &div4_clks[DIV4_B], MSTPCR2, 5, 0),
+        MSTP("beu0", &div4_clks[DIV4_B], MSTPCR2, 4, 0),
+        MSTP("ceu0", &div4_clks[DIV4_B], MSTPCR2, 3, 0),
+        MSTP("veu0", &div4_clks[DIV4_B], MSTPCR2, 2, CLK_ENABLE_ON_INIT),
+        MSTP("vpu0", &div4_clks[DIV4_B], MSTPCR2, 1, CLK_ENABLE_ON_INIT),
+        MSTP("lcdc0", &div4_clks[DIV4_B], MSTPCR2, 0, 0),
+};
+
+int __init arch_clk_init(void)
+{
+        int k, ret = 0;
+
+        /* autodetect extal or dll configuration */
+        if (__raw_readl(PLLCR) & 0x1000)
+                pll_clk.parent = &dll_clk;
+        else
+                pll_clk.parent = &extal_clk;
+
+        for (k = 0; !ret && (k < ARRAY_SIZE(main_clks)); k++)
+                ret = clk_register(main_clks[k]);
+
+        if (!ret)
+                ret = sh_clk_div4_register(div4_clks, DIV4_NR, &div4_table);
+
+        if (!ret)
+                ret = sh_clk_div6_register(div6_clks, ARRAY_SIZE(div6_clks));
+
+        if (!ret)
+                ret = sh_clk_mstp32_register(mstp_clks, ARRAY_SIZE(mstp_clks));
+
+        return ret;
+}
diff --git a/arch/sh/kernel/cpu/sh4a/clock-sh7366.c b/arch/sh/kernel/cpu/sh4a/clock-sh7366.c
new file mode 100644
index 000000000000..a95ebaba095c
--- /dev/null
+++ b/arch/sh/kernel/cpu/sh4a/clock-sh7366.c
@@ -0,0 +1,211 @@
+/*
+ * arch/sh/kernel/cpu/sh4a/clock-sh7366.c
+ *
+ * SH7366 clock framework support
+ *
+ * Copyright (C) 2009 Magnus Damm
+ *
+ * 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
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/io.h>
+#include <asm/clock.h>
+
+/* SH7366 registers */
+#define FRQCR           0xa4150000
+#define VCLKCR          0xa4150004
+#define SCLKACR         0xa4150008
+#define SCLKBCR         0xa415000c
+#define PLLCR           0xa4150024
+#define MSTPCR0         0xa4150030
+#define MSTPCR1         0xa4150034
+#define MSTPCR2         0xa4150038
+#define DLLFRQ          0xa4150050
+
+/* Fixed 32 KHz root clock for RTC and Power Management purposes */
+static struct clk r_clk = {
+        .name           = "rclk",
+        .id             = -1,
+        .rate           = 32768,
+};
+
+/*
+ * Default rate for the root input clock, reset this with clk_set_rate()
+ * from the platform code.
+ */
+struct clk extal_clk = {
+        .name           = "extal",
+        .id             = -1,
+        .rate           = 33333333,
+};
+
+/* The dll block multiplies the 32khz r_clk, may be used instead of extal */
+static unsigned long dll_recalc(struct clk *clk)
+{
+        unsigned long mult;
+
+        if (__raw_readl(PLLCR) & 0x1000)
+                mult = __raw_readl(DLLFRQ);
+        else
+                mult = 0;
+
+        return clk->parent->rate * mult;
+}
+
+static struct clk_ops dll_clk_ops = {
+        .recalc         = dll_recalc,
+};
+
+static struct clk dll_clk = {
+        .name           = "dll_clk",
+        .id             = -1,
+        .ops            = &dll_clk_ops,
+        .parent         = &r_clk,
+        .flags          = CLK_ENABLE_ON_INIT,
+};
+
+static unsigned long pll_recalc(struct clk *clk)
+{
+        unsigned long mult = 1;
+        unsigned long div = 1;
+
+        if (__raw_readl(PLLCR) & 0x4000)
+                mult = (((__raw_readl(FRQCR) >> 24) & 0x1f) + 1);
+        else
+                div = 2;
+
+        return (clk->parent->rate * mult) / div;
+}
+
+static struct clk_ops pll_clk_ops = {
+        .recalc         = pll_recalc,
+};
+
+static struct clk pll_clk = {
+        .name           = "pll_clk",
+        .id             = -1,
+        .ops            = &pll_clk_ops,
+        .flags          = CLK_ENABLE_ON_INIT,
+};
+
+struct clk *main_clks[] = {
+        &r_clk,
+        &extal_clk,
+        &dll_clk,
+        &pll_clk,
+};
+
+static int multipliers[] = { 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
+static int divisors[] = { 1, 3, 2, 5, 3, 4, 5, 6, 8, 10, 12, 16, 20 };
+
+static struct clk_div_mult_table div4_table = {
+        .divisors = divisors,
+        .nr_divisors = ARRAY_SIZE(divisors),
+        .multipliers = multipliers,
+        .nr_multipliers = ARRAY_SIZE(multipliers),
+};
+
+enum { DIV4_I, DIV4_U, DIV4_SH, DIV4_B, DIV4_B3, DIV4_P,
+       DIV4_SIUA, DIV4_SIUB, DIV4_NR };
+
+#define DIV4(_str, _reg, _bit, _mask, _flags) \
+  SH_CLK_DIV4(_str, &pll_clk, _reg, _bit, _mask, _flags)
+
+struct clk div4_clks[DIV4_NR] = {
+        [DIV4_I] = DIV4("cpu_clk", FRQCR, 20, 0x1fef, CLK_ENABLE_ON_INIT),
+        [DIV4_U] = DIV4("umem_clk", FRQCR, 16, 0x1fff, CLK_ENABLE_ON_INIT),
+        [DIV4_SH] = DIV4("shyway_clk", FRQCR, 12, 0x1fff, CLK_ENABLE_ON_INIT),
+        [DIV4_B] = DIV4("bus_clk", FRQCR, 8, 0x1fff, CLK_ENABLE_ON_INIT),
+        [DIV4_B3] = DIV4("b3_clk", FRQCR, 4, 0x1fff, CLK_ENABLE_ON_INIT),
+        [DIV4_P] = DIV4("peripheral_clk", FRQCR, 0, 0x1fff, 0),
+        [DIV4_SIUA] = DIV4("siua_clk", SCLKACR, 0, 0x1fff, 0),
+        [DIV4_SIUB] = DIV4("siub_clk", SCLKBCR, 0, 0x1fff, 0),
+};
+
+struct clk div6_clks[] = {
+        SH_CLK_DIV6("video_clk", &pll_clk, VCLKCR, 0),
+};
+
+#define MSTP(_str, _parent, _reg, _bit, _flags) \
+  SH_CLK_MSTP32(_str, -1, _parent, _reg, _bit, _flags)
+
+static struct clk mstp_clks[] = {
+        /* See page 52 of Datasheet V0.40: Overview -> Block Diagram */
+        MSTP("tlb0", &div4_clks[DIV4_I], MSTPCR0, 31, CLK_ENABLE_ON_INIT),
+        MSTP("ic0", &div4_clks[DIV4_I], MSTPCR0, 30, CLK_ENABLE_ON_INIT),
+        MSTP("oc0", &div4_clks[DIV4_I], MSTPCR0, 29, CLK_ENABLE_ON_INIT),
+        MSTP("rsmem0", &div4_clks[DIV4_SH], MSTPCR0, 28, CLK_ENABLE_ON_INIT),
+        MSTP("xymem0", &div4_clks[DIV4_B], MSTPCR0, 26, CLK_ENABLE_ON_INIT),
+        MSTP("intc3", &div4_clks[DIV4_P], MSTPCR0, 23, 0),
+        MSTP("intc0", &div4_clks[DIV4_P], MSTPCR0, 22, 0),
+        MSTP("dmac0", &div4_clks[DIV4_P], MSTPCR0, 21, 0),
+        MSTP("sh0", &div4_clks[DIV4_P], MSTPCR0, 20, 0),
+        MSTP("hudi0", &div4_clks[DIV4_P], MSTPCR0, 19, 0),
+        MSTP("ubc0", &div4_clks[DIV4_P], MSTPCR0, 17, 0),
+        MSTP("tmu0", &div4_clks[DIV4_P], MSTPCR0, 15, 0),
+        MSTP("cmt0", &r_clk, MSTPCR0, 14, 0),
+        MSTP("rwdt0", &r_clk, MSTPCR0, 13, 0),
+        MSTP("mfi0", &div4_clks[DIV4_P], MSTPCR0, 11, 0),
+        MSTP("flctl0", &div4_clks[DIV4_P], MSTPCR0, 10, 0),
+        MSTP("scif0", &div4_clks[DIV4_P], MSTPCR0, 7, 0),
+        MSTP("scif1", &div4_clks[DIV4_P], MSTPCR0, 6, 0),
+        MSTP("scif2", &div4_clks[DIV4_P], MSTPCR0, 5, 0),
+        MSTP("msiof0", &div4_clks[DIV4_P], MSTPCR0, 2, 0),
+        MSTP("sbr0", &div4_clks[DIV4_P], MSTPCR0, 1, 0),
+
+        MSTP("i2c0", &div4_clks[DIV4_P], MSTPCR1, 9, 0),
+
+        MSTP("icb0", &div4_clks[DIV4_P], MSTPCR2, 27, 0),
+        MSTP("meram0", &div4_clks[DIV4_P], MSTPCR2, 26, 0),
+        MSTP("dacy1", &div4_clks[DIV4_P], MSTPCR2, 24, 0),
+        MSTP("dacy0", &div4_clks[DIV4_P], MSTPCR2, 23, 0),
+        MSTP("tsif0", &div4_clks[DIV4_P], MSTPCR2, 22, 0),
+        MSTP("sdhi0", &div4_clks[DIV4_P], MSTPCR2, 18, 0),
+        MSTP("mmcif0", &div4_clks[DIV4_P], MSTPCR2, 17, 0),
+        MSTP("usbf0", &div4_clks[DIV4_P], MSTPCR2, 11, 0),
+        MSTP("siu0", &div4_clks[DIV4_B], MSTPCR2, 9, 0),
+        MSTP("veu1", &div4_clks[DIV4_B], MSTPCR2, 7, CLK_ENABLE_ON_INIT),
+        MSTP("vou0", &div4_clks[DIV4_B], MSTPCR2, 5, 0),
+        MSTP("beu0", &div4_clks[DIV4_B], MSTPCR2, 4, 0),
+        MSTP("ceu0", &div4_clks[DIV4_B], MSTPCR2, 3, 0),
+        MSTP("veu0", &div4_clks[DIV4_B], MSTPCR2, 2, CLK_ENABLE_ON_INIT),
+        MSTP("vpu0", &div4_clks[DIV4_B], MSTPCR2, 1, CLK_ENABLE_ON_INIT),
+        MSTP("lcdc0", &div4_clks[DIV4_B], MSTPCR2, 0, 0),
+};
+
+int __init arch_clk_init(void)
+{
+        int k, ret = 0;
+
+        /* autodetect extal or dll configuration */
+        if (__raw_readl(PLLCR) & 0x1000)
+                pll_clk.parent = &dll_clk;
+        else
+                pll_clk.parent = &extal_clk;
+
+        for (k = 0; !ret && (k < ARRAY_SIZE(main_clks)); k++)
+                ret = clk_register(main_clks[k]);
+
+        if (!ret)
+                ret = sh_clk_div4_register(div4_clks, DIV4_NR, &div4_table);
+
+        if (!ret)
+                ret = sh_clk_div6_register(div6_clks, ARRAY_SIZE(div6_clks));
+
+        if (!ret)
+                ret = sh_clk_mstp32_register(mstp_clks, ARRAY_SIZE(mstp_clks));
+
+        return ret;
+}
diff --git a/arch/sh/kernel/cpu/sh4a/clock-sh7722.c b/arch/sh/kernel/cpu/sh4a/clock-sh7722.c
index 0e174af21874..40f859354f79 100644
--- a/arch/sh/kernel/cpu/sh4a/clock-sh7722.c
+++ b/arch/sh/kernel/cpu/sh4a/clock-sh7722.c
@@ -1,844 +1,197 @@
 /*
  * arch/sh/kernel/cpu/sh4a/clock-sh7722.c
  *
- * SH7343, SH7722, SH7723 & SH7366 support for the clock framework
+ * SH7722 clock framework support
  *
- * Copyright (c) 2006-2007 Nomad Global Solutions Inc
- * Based on code for sh7343 by Paul Mundt
+ * Copyright (C) 2009 Magnus Damm
  *
- * 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.
+ * 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
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/io.h>
-#include <linux/errno.h>
-#include <linux/stringify.h>
 #include <asm/clock.h>
-#include <asm/freq.h>
-
-#define N  (-1)
-#define NM (-2)
-#define ROUND_NEAREST 0
-#define ROUND_DOWN -1
-#define ROUND_UP   +1
-
-static int adjust_algos[][3] = {
-        {},     /* NO_CHANGE */
-        { NM, N, 1 },   /* N:1, N:1 */
-        { 3, 2, 2 },    /* 3:2:2 */
-        { 5, 2, 2 },    /* 5:2:2 */
-        { N, 1, 1 },    /* N:1:1 */
-
-        { N, 1 },       /* N:1 */
 
-        { N, 1 },       /* N:1 */
-        { 3, 2 },
-        { 4, 3 },
-        { 5, 4 },
-
-        { N, 1 }
+/* SH7722 registers */
+#define FRQCR           0xa4150000
+#define VCLKCR          0xa4150004
+#define SCLKACR         0xa4150008
+#define SCLKBCR         0xa415000c
+#define IRDACLKCR       0xa4150018
+#define PLLCR           0xa4150024
+#define MSTPCR0         0xa4150030
+#define MSTPCR1         0xa4150034
+#define MSTPCR2         0xa4150038
+#define DLLFRQ          0xa4150050
+
+/* Fixed 32 KHz root clock for RTC and Power Management purposes */
+static struct clk r_clk = {
+        .name           = "rclk",
+        .id             = -1,
+        .rate           = 32768,
 };
 
-static unsigned long adjust_pair_of_clocks(unsigned long r1, unsigned long r2,
-                        int m1, int m2, int round_flag)
-{
-        unsigned long rem, div;
-        int the_one = 0;
-
-        pr_debug( "Actual values: r1 = %ld\n", r1);
-        pr_debug( "...............r2 = %ld\n", r2);
-
-        if (m1 == m2) {
-                r2 = r1;
-                pr_debug( "setting equal rates: r2 now %ld\n", r2);
-        } else if ((m2 == N  && m1 == 1) ||
-                   (m2 == NM && m1 == N)) { /* N:1 or NM:N */
-                pr_debug( "Setting rates as 1:N (N:N*M)\n");
-                rem = r2 % r1;
-                pr_debug( "...remainder = %ld\n", rem);
-                if (rem) {
-                        div = r2 / r1;
-                        pr_debug( "...div = %ld\n", div);
-                        switch (round_flag) {
-                        case ROUND_NEAREST:
-                                the_one = rem >= r1/2 ? 1 : 0; break;
-                        case ROUND_UP:
-                                the_one = 1; break;
-                        case ROUND_DOWN:
-                                the_one = 0; break;
-                        }
-
-                        r2 = r1 * (div + the_one);
-                        pr_debug( "...setting r2 to %ld\n", r2);
-                }
-        } else if ((m2 == 1  && m1 == N) ||
-                   (m2 == N && m1 == NM)) { /* 1:N or N:NM */
-                pr_debug( "Setting rates as N:1 (N*M:N)\n");
-                rem = r1 % r2;
-                pr_debug( "...remainder = %ld\n", rem);
-                if (rem) {
-                        div = r1 / r2;
-                        pr_debug( "...div = %ld\n", div);
-                        switch (round_flag) {
-                        case ROUND_NEAREST:
-                                the_one = rem > r2/2 ? 1 : 0; break;
-                        case ROUND_UP:
-                                the_one = 0; break;
-                        case ROUND_DOWN:
-                                the_one = 1; break;
-                        }
-
-                        r2 = r1 / (div + the_one);
-                        pr_debug( "...setting r2 to %ld\n", r2);
-                }
-        } else { /* value:value */
-                pr_debug( "Setting rates as %d:%d\n", m1, m2);
-                div = r1 / m1;
-                r2 = div * m2;
-                pr_debug( "...div = %ld\n", div);
-                pr_debug( "...setting r2 to %ld\n", r2);
-        }
-
-        return r2;
-}
-
-static void adjust_clocks(int originate, int *l, unsigned long v[],
-                          int n_in_line)
-{
-        int x;
-
-        pr_debug( "Go down from %d...\n", originate);
-        /* go up recalculation clocks */
-        for (x = originate; x>0; x -- )
-                v[x-1] = adjust_pair_of_clocks(v[x], v[x-1],
-                                        l[x], l[x-1],
-                                        ROUND_UP);
-
-        pr_debug( "Go up from %d...\n", originate);
-        /* go down recalculation clocks */
-        for (x = originate; x<n_in_line - 1; x ++ )
-                v[x+1] = adjust_pair_of_clocks(v[x], v[x+1],
-                                        l[x], l[x+1],
-                                        ROUND_UP);
-}
-
-
 /*
- * SH7722 uses a common set of multipliers and divisors, so this
- * is quite simple..
+ * Default rate for the root input clock, reset this with clk_set_rate()
+ * from the platform code.
  */
-
-/*
- * Instead of having two separate multipliers/divisors set, like this:
- *
- * static int multipliers[] = { 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
- * static int divisors[] = { 1, 3, 2, 5, 3, 4, 5, 6, 8, 10, 12, 16, 20 };
- *
- * I created the divisors2 array, which is used to calculate rate like
- *   rate = parent * 2 / divisors2[ divisor ];
-*/
-static int divisors2[] = { 2, 3, 4, 5, 6, 8, 10, 12, 16, 20, 24, 32, 40 };
-
-static void master_clk_recalc(struct clk *clk)
-{
-        unsigned frqcr = ctrl_inl(FRQCR);
-
-        clk->rate = CONFIG_SH_PCLK_FREQ * (((frqcr >> 24) & 0x1f) + 1);
-}
-
-static void master_clk_init(struct clk *clk)
-{
-        clk->parent = NULL;
-        clk->flags |= CLK_RATE_PROPAGATES;
-        clk->rate = CONFIG_SH_PCLK_FREQ;
-        master_clk_recalc(clk);
-}
-
-
-static void module_clk_recalc(struct clk *clk)
-{
-        unsigned long frqcr = ctrl_inl(FRQCR);
-
-        clk->rate = clk->parent->rate / (((frqcr >> 24) & 0x1f) + 1);
-}
-
-static int master_clk_setrate(struct clk *clk, unsigned long rate, int id)
-{
-        int div = rate / clk->rate;
-        int master_divs[] = { 2, 3, 4, 6, 8, 16 };
-        int index;
-        unsigned long frqcr;
-
-        for (index = 1; index < ARRAY_SIZE(master_divs); index++)
-                if (div >= master_divs[index - 1] && div < master_divs[index])
-                        break;
-
-        if (index >= ARRAY_SIZE(master_divs))
-                index = ARRAY_SIZE(master_divs);
-        div = master_divs[index - 1];
-
-        frqcr = ctrl_inl(FRQCR);
-        frqcr &= ~(0xF << 24);
-        frqcr |= ( (div-1) << 24);
-        ctrl_outl(frqcr, FRQCR);
-
-        return 0;
-}
-
-static struct clk_ops sh7722_master_clk_ops = {
-        .init = master_clk_init,
-        .recalc = master_clk_recalc,
-        .set_rate = master_clk_setrate,
-};
-
-static struct clk_ops sh7722_module_clk_ops = {
-       .recalc = module_clk_recalc,
-};
-
-struct frqcr_context {
-        unsigned mask;
-        unsigned shift;
-};
-
-struct frqcr_context sh7722_get_clk_context(const char *name)
-{
-        struct frqcr_context ctx = { 0, };
-
-        if (!strcmp(name, "peripheral_clk")) {
-                ctx.shift = 0;
-                ctx.mask = 0xF;
-        } else if (!strcmp(name, "sdram_clk")) {
-                ctx.shift = 4;
-                ctx.mask = 0xF;
-        } else if (!strcmp(name, "bus_clk")) {
-                ctx.shift = 8;
-                ctx.mask = 0xF;
-        } else if (!strcmp(name, "sh_clk")) {
-                ctx.shift = 12;
-                ctx.mask = 0xF;
-        } else if (!strcmp(name, "umem_clk")) {
-                ctx.shift = 16;
-                ctx.mask = 0xF;
-        } else if (!strcmp(name, "cpu_clk")) {
-                ctx.shift = 20;
-                ctx.mask = 7;
-        }
-        return ctx;
-}
-
-/**
- * sh7722_find_div_index - find divisor for setting rate
- *
- * All sh7722 clocks use the same set of multipliers/divisors. This function
- * chooses correct divisor to set the rate of clock with parent clock that
- * generates frequency of 'parent_rate'
- *
- * @parent_rate: rate of parent clock
- * @rate: requested rate to be set
- */
-static int sh7722_find_div_index(unsigned long parent_rate, unsigned rate)
-{
-        unsigned div2 = parent_rate * 2 / rate;
-        int index;
-
-        if (rate > parent_rate)
-                return -EINVAL;
-
-        for (index = 1; index < ARRAY_SIZE(divisors2); index++) {
-                if (div2 > divisors2[index - 1] && div2 <= divisors2[index])
-                        break;
-        }
-        if (index >= ARRAY_SIZE(divisors2))
-                index = ARRAY_SIZE(divisors2) - 1;
-        return index;
-}
-
-static void sh7722_frqcr_recalc(struct clk *clk)
-{
-        struct frqcr_context ctx = sh7722_get_clk_context(clk->name);
-        unsigned long frqcr = ctrl_inl(FRQCR);
-        int index;
-
-        index = (frqcr >> ctx.shift) & ctx.mask;
-        clk->rate = clk->parent->rate * 2 / divisors2[index];
-}
-
-static int sh7722_frqcr_set_rate(struct clk *clk, unsigned long rate,
-                                 int algo_id)
-{
-        struct frqcr_context ctx = sh7722_get_clk_context(clk->name);
-        unsigned long parent_rate = clk->parent->rate;
-        int div;
-        unsigned long frqcr;
-        int err = 0;
-
-        /* pretty invalid */
-        if (parent_rate < rate)
-                return -EINVAL;
-
-        /* look for multiplier/divisor pair */
-        div = sh7722_find_div_index(parent_rate, rate);
-        if (div<0)
-                return div;
-
-        /* calculate new value of clock rate */
-        clk->rate = parent_rate * 2 / divisors2[div];
-        frqcr = ctrl_inl(FRQCR);
-
-        /* FIXME: adjust as algo_id specifies */
-        if (algo_id != NO_CHANGE) {
-                int originator;
-                char *algo_group_1[] = { "cpu_clk", "umem_clk", "sh_clk" };
-                char *algo_group_2[] = { "sh_clk", "bus_clk" };
-                char *algo_group_3[] = { "sh_clk", "sdram_clk" };
-                char *algo_group_4[] = { "bus_clk", "peripheral_clk" };
-                char *algo_group_5[] = { "cpu_clk", "peripheral_clk" };
-                char **algo_current = NULL;
-                /* 3 is the maximum number of clocks in relation */
-                struct clk *ck[3];
-                unsigned long values[3]; /* the same comment as above */
-                int part_length = -1;
-                int i;
-
-                /*
-                 * all the steps below only required if adjustion was
-                 * requested
-                 */
-                if (algo_id == IUS_N1_N1 ||
-                    algo_id == IUS_322 ||
-                    algo_id == IUS_522 ||
-                    algo_id == IUS_N11) {
-                        algo_current = algo_group_1;
-                        part_length = 3;
-                }
-                if (algo_id == SB_N1) {
-                        algo_current = algo_group_2;
-                        part_length = 2;
-                }
-                if (algo_id == SB3_N1 ||
-                    algo_id == SB3_32 ||
-                    algo_id == SB3_43 ||
-                    algo_id == SB3_54) {
-                        algo_current = algo_group_3;
-                        part_length = 2;
-                }
-                if (algo_id == BP_N1) {
-                        algo_current = algo_group_4;
-                        part_length = 2;
-                }
-                if (algo_id == IP_N1) {
-                        algo_current = algo_group_5;
-                        part_length = 2;
-                }
-                if (!algo_current)
-                        goto incorrect_algo_id;
-
-                originator = -1;
-                for (i = 0; i < part_length; i ++ ) {
-                        if (originator >= 0 && !strcmp(clk->name,
-                                                       algo_current[i]))
-                                originator = i;
-                        ck[i] = clk_get(NULL, algo_current[i]);
-                        values[i] = clk_get_rate(ck[i]);
-                }
-
-                if (originator >= 0)
-                        adjust_clocks(originator, adjust_algos[algo_id],
-                                      values, part_length);
-
-                for (i = 0; i < part_length; i ++ ) {
-                        struct frqcr_context part_ctx;
-                        int part_div;
-
-                        if (likely(!err)) {
-                                part_div = sh7722_find_div_index(parent_rate,
-                                                                rate);
-                                if (part_div > 0) {
-                                        part_ctx = sh7722_get_clk_context(
-                                                                ck[i]->name);
-                                        frqcr &= ~(part_ctx.mask <<
-                                                   part_ctx.shift);
-                                        frqcr |= part_div << part_ctx.shift;
-                                } else
-                                        err = part_div;
-                        }
-
-                        ck[i]->ops->recalc(ck[i]);
-                        clk_put(ck[i]);
-                }
-        }
-
-        /* was there any error during recalculation ? If so, bail out.. */
-        if (unlikely(err!=0))
-                goto out_err;
-
-        /* clear FRQCR bits */
-        frqcr &= ~(ctx.mask << ctx.shift);
-        frqcr |= div << ctx.shift;
-
-        /* ...and perform actual change */
-        ctrl_outl(frqcr, FRQCR);
-        return 0;
-
-incorrect_algo_id:
-        return -EINVAL;
-out_err:
-        return err;
-}
-
-static long sh7722_frqcr_round_rate(struct clk *clk, unsigned long rate)
-{
-        unsigned long parent_rate = clk->parent->rate;
-        int div;
-
-        /* look for multiplier/divisor pair */
-        div = sh7722_find_div_index(parent_rate, rate);
-        if (div < 0)
-                return clk->rate;
-
-        /* calculate new value of clock rate */
-        return parent_rate * 2 / divisors2[div];
-}
-
-static struct clk_ops sh7722_frqcr_clk_ops = {
-        .recalc = sh7722_frqcr_recalc,
-        .set_rate = sh7722_frqcr_set_rate,
-        .round_rate = sh7722_frqcr_round_rate,
+struct clk extal_clk = {
+        .name           = "extal",
+        .id             = -1,
+        .rate           = 33333333,
 };
 
-/*
- * clock ops methods for SIU A/B and IrDA clock
- *
- */
-
-#ifndef CONFIG_CPU_SUBTYPE_SH7343
-
-static int sh7722_siu_set_rate(struct clk *clk, unsigned long rate, int algo_id)
-{
-        unsigned long r;
-        int div;
-
-        r = ctrl_inl(clk->arch_flags);
-        div = sh7722_find_div_index(clk->parent->rate, rate);
-        if (div < 0)
-                return div;
-        r = (r & ~0xF) | div;
-        ctrl_outl(r, clk->arch_flags);
-        return 0;
-}
-
-static void sh7722_siu_recalc(struct clk *clk)
-{
-        unsigned long r;
-
-        r = ctrl_inl(clk->arch_flags);
-        clk->rate = clk->parent->rate * 2 / divisors2[r & 0xF];
-}
-
-static int sh7722_siu_start_stop(struct clk *clk, int enable)
+/* The dll block multiplies the 32khz r_clk, may be used instead of extal */
+static unsigned long dll_recalc(struct clk *clk)
 {
-        unsigned long r;
+        unsigned long mult;
 
-        r = ctrl_inl(clk->arch_flags);
-        if (enable)
-                ctrl_outl(r & ~(1 << 8), clk->arch_flags);
+        if (__raw_readl(PLLCR) & 0x1000)
+                mult = __raw_readl(DLLFRQ);
         else
-                ctrl_outl(r | (1 << 8), clk->arch_flags);
-        return 0;
-}
-
-static void sh7722_siu_enable(struct clk *clk)
-{
-        sh7722_siu_start_stop(clk, 1);
-}
+                mult = 0;
 
-static void sh7722_siu_disable(struct clk *clk)
-{
-        sh7722_siu_start_stop(clk, 0);
+        return clk->parent->rate * mult;
 }
 
-static struct clk_ops sh7722_siu_clk_ops = {
-        .recalc = sh7722_siu_recalc,
-        .set_rate = sh7722_siu_set_rate,
-        .enable = sh7722_siu_enable,
-        .disable = sh7722_siu_disable,
+static struct clk_ops dll_clk_ops = {
+        .recalc         = dll_recalc,
 };
 
-#endif /* CONFIG_CPU_SUBTYPE_SH7343 */
-
-static void sh7722_video_enable(struct clk *clk)
-{
-        unsigned long r;
-
-        r = ctrl_inl(VCLKCR);
-        ctrl_outl( r & ~(1<<8), VCLKCR);
-}
-
-static void sh7722_video_disable(struct clk *clk)
-{
-        unsigned long r;
-
-        r = ctrl_inl(VCLKCR);
-        ctrl_outl( r | (1<<8), VCLKCR);
-}
+static struct clk dll_clk = {
+        .name           = "dll_clk",
+        .id             = -1,
+        .ops            = &dll_clk_ops,
+        .parent         = &r_clk,
+        .flags          = CLK_ENABLE_ON_INIT,
+};
 
-static int sh7722_video_set_rate(struct clk *clk, unsigned long rate,
-                                 int algo_id)
+static unsigned long pll_recalc(struct clk *clk)
 {
-        unsigned long r;
-
-        r = ctrl_inl(VCLKCR);
-        r &= ~0x3F;
-        r |= ((clk->parent->rate / rate - 1) & 0x3F);
-        ctrl_outl(r, VCLKCR);
-        return 0;
-}
+        unsigned long mult = 1;
+        unsigned long div = 1;
 
-static void sh7722_video_recalc(struct clk *clk)
-{
-        unsigned long r;
+        if (__raw_readl(PLLCR) & 0x4000)
+                mult = (((__raw_readl(FRQCR) >> 24) & 0x1f) + 1);
+        else
+                div = 2;
 
-        r = ctrl_inl(VCLKCR);
-        clk->rate = clk->parent->rate / ((r & 0x3F) + 1);
+        return (clk->parent->rate * mult) / div;
 }
 
-static struct clk_ops sh7722_video_clk_ops = {
-        .recalc = sh7722_video_recalc,
-        .set_rate = sh7722_video_set_rate,
-        .enable = sh7722_video_enable,
-        .disable = sh7722_video_disable,
-};
-/*
- * and at last, clock definitions themselves
- */
-static struct clk sh7722_umem_clock = {
-        .name = "umem_clk",
-        .ops = &sh7722_frqcr_clk_ops,
-        .flags = CLK_RATE_PROPAGATES,
+static struct clk_ops pll_clk_ops = {
+        .recalc         = pll_recalc,
 };
 
-static struct clk sh7722_sh_clock = {
-        .name = "sh_clk",
-        .ops = &sh7722_frqcr_clk_ops,
-        .flags = CLK_RATE_PROPAGATES,
+static struct clk pll_clk = {
+        .name           = "pll_clk",
+        .id             = -1,
+        .ops            = &pll_clk_ops,
+        .flags          = CLK_ENABLE_ON_INIT,
 };
 
-static struct clk sh7722_peripheral_clock = {
-        .name = "peripheral_clk",
-        .ops = &sh7722_frqcr_clk_ops,
-        .flags = CLK_RATE_PROPAGATES,
+struct clk *main_clks[] = {
+        &r_clk,
+        &extal_clk,
+        &dll_clk,
+        &pll_clk,
 };
 
-static struct clk sh7722_sdram_clock = {
-        .name = "sdram_clk",
-        .ops = &sh7722_frqcr_clk_ops,
-};
+static int multipliers[] = { 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
+static int divisors[] = { 1, 3, 2, 5, 3, 4, 5, 6, 8, 10, 12, 16, 20 };
 
-static struct clk sh7722_r_clock = {
-        .name = "r_clk",
-        .rate = 32768,
-        .flags = CLK_RATE_PROPAGATES,
+static struct clk_div_mult_table div4_table = {
+        .divisors = divisors,
+        .nr_divisors = ARRAY_SIZE(divisors),
+        .multipliers = multipliers,
+        .nr_multipliers = ARRAY_SIZE(multipliers),
 };
 
-#ifndef CONFIG_CPU_SUBTYPE_SH7343
-
-/*
- * these three clocks - SIU A, SIU B, IrDA - share the same clk_ops
- * methods of clk_ops determine which register they should access by
- * examining clk->name field
- */
-static struct clk sh7722_siu_a_clock = {
-        .name = "siu_a_clk",
-        .arch_flags = SCLKACR,
-        .ops = &sh7722_siu_clk_ops,
-};
+enum { DIV4_I, DIV4_U, DIV4_SH, DIV4_B, DIV4_B3, DIV4_P,
+       DIV4_SIUA, DIV4_SIUB, DIV4_IRDA, DIV4_NR };
 
-static struct clk sh7722_siu_b_clock = {
-        .name = "siu_b_clk",
-        .arch_flags = SCLKBCR,
-        .ops = &sh7722_siu_clk_ops,
-};
+#define DIV4(_str, _reg, _bit, _mask, _flags) \
+  SH_CLK_DIV4(_str, &pll_clk, _reg, _bit, _mask, _flags)
 
-#if defined(CONFIG_CPU_SUBTYPE_SH7722)
-static struct clk sh7722_irda_clock = {
-        .name = "irda_clk",
-        .arch_flags = IrDACLKCR,
-        .ops = &sh7722_siu_clk_ops,
+struct clk div4_clks[DIV4_NR] = {
+        [DIV4_I] = DIV4("cpu_clk", FRQCR, 20, 0x1fef, CLK_ENABLE_ON_INIT),
+        [DIV4_U] = DIV4("umem_clk", FRQCR, 16, 0x1fff, CLK_ENABLE_ON_INIT),
+        [DIV4_SH] = DIV4("shyway_clk", FRQCR, 12, 0x1fff, CLK_ENABLE_ON_INIT),
+        [DIV4_B] = DIV4("bus_clk", FRQCR, 8, 0x1fff, CLK_ENABLE_ON_INIT),
+        [DIV4_B3] = DIV4("b3_clk", FRQCR, 4, 0x1fff, CLK_ENABLE_ON_INIT),
+        [DIV4_P] = DIV4("peripheral_clk", FRQCR, 0, 0x1fff, 0),
+        [DIV4_SIUA] = DIV4("siua_clk", SCLKACR, 0, 0x1fff, 0),
+        [DIV4_SIUB] = DIV4("siub_clk", SCLKBCR, 0, 0x1fff, 0),
+        [DIV4_IRDA] = DIV4("irda_clk", IRDACLKCR, 0, 0x1fff, 0),
 };
-#endif
-#endif /* CONFIG_CPU_SUBTYPE_SH7343 */
 
-static struct clk sh7722_video_clock = {
-        .name = "video_clk",
-        .ops = &sh7722_video_clk_ops,
+struct clk div6_clks[] = {
+        SH_CLK_DIV6("video_clk", &pll_clk, VCLKCR, 0),
 };
 
-#define MSTPCR_ARCH_FLAGS(reg, bit) (((reg) << 8) | (bit))
-#define MSTPCR_ARCH_FLAGS_REG(value) ((value) >> 8)
-#define MSTPCR_ARCH_FLAGS_BIT(value) ((value) & 0xff)
-
-static int sh7722_mstpcr_start_stop(struct clk *clk, int enable)
-{
-        unsigned long bit = MSTPCR_ARCH_FLAGS_BIT(clk->arch_flags);
-        unsigned long reg;
-        unsigned long r;
-
-        switch(MSTPCR_ARCH_FLAGS_REG(clk->arch_flags)) {
-        case 0:
-                reg = MSTPCR0;
-                break;
-        case 1:
-                reg = MSTPCR1;
-                break;
-        case 2:
-                reg = MSTPCR2;
-                break;
-        default:
-                return -EINVAL;
-        }  
-
-        r = ctrl_inl(reg);
-
-        if (enable)
-                r &= ~(1 << bit);
-        else
-                r |= (1 << bit);
+#define MSTP(_str, _parent, _reg, _bit, _flags) \
+  SH_CLK_MSTP32(_str, -1, _parent, _reg, _bit, _flags)
 
-        ctrl_outl(r, reg);
-        return 0;
-}
+static struct clk mstp_clks[] = {
+        MSTP("uram0", &div4_clks[DIV4_U], MSTPCR0, 28, CLK_ENABLE_ON_INIT),
+        MSTP("xymem0", &div4_clks[DIV4_B], MSTPCR0, 26, CLK_ENABLE_ON_INIT),
+        MSTP("tmu0", &div4_clks[DIV4_P], MSTPCR0, 15, 0),
+        MSTP("cmt0", &r_clk, MSTPCR0, 14, 0),
+        MSTP("rwdt0", &r_clk, MSTPCR0, 13, 0),
+        MSTP("flctl0", &div4_clks[DIV4_P], MSTPCR0, 10, 0),
+        MSTP("scif0", &div4_clks[DIV4_P], MSTPCR0, 7, 0),
+        MSTP("scif1", &div4_clks[DIV4_P], MSTPCR0, 6, 0),
+        MSTP("scif2", &div4_clks[DIV4_P], MSTPCR0, 5, 0),
 
-static void sh7722_mstpcr_enable(struct clk *clk)
-{
-        sh7722_mstpcr_start_stop(clk, 1);
-}
+        MSTP("i2c0", &div4_clks[DIV4_P], MSTPCR1, 9, 0),
+        MSTP("rtc0", &r_clk, MSTPCR1, 8, 0),
 
-static void sh7722_mstpcr_disable(struct clk *clk)
-{
-        sh7722_mstpcr_start_stop(clk, 0);
-}
-
-static void sh7722_mstpcr_recalc(struct clk *clk)
-{
-        if (clk->parent)
-                clk->rate = clk->parent->rate;
-}
-
-static struct clk_ops sh7722_mstpcr_clk_ops = {
-        .enable = sh7722_mstpcr_enable,
-        .disable = sh7722_mstpcr_disable,
-        .recalc = sh7722_mstpcr_recalc,
-};
-
-#define MSTPCR(_name, _parent, regnr, bitnr) \
-{                                               \
-        .name = _name,                          \
-        .arch_flags = MSTPCR_ARCH_FLAGS(regnr, bitnr),  \
-        .ops = (void *)_parent,         \
-}
-
-static struct clk sh7722_mstpcr_clocks[] = {
-#if defined(CONFIG_CPU_SUBTYPE_SH7722)
-        MSTPCR("uram0", "umem_clk", 0, 28),
-        MSTPCR("xymem0", "bus_clk", 0, 26),
-        MSTPCR("tmu0", "peripheral_clk", 0, 15),
-        MSTPCR("cmt0", "r_clk", 0, 14),
-        MSTPCR("rwdt0", "r_clk", 0, 13),
-        MSTPCR("flctl0", "peripheral_clk", 0, 10),
-        MSTPCR("scif0", "peripheral_clk", 0, 7),
-        MSTPCR("scif1", "peripheral_clk", 0, 6),
-        MSTPCR("scif2", "peripheral_clk", 0, 5),
-        MSTPCR("i2c0", "peripheral_clk", 1, 9),
-        MSTPCR("rtc0", "r_clk", 1, 8),
-        MSTPCR("sdhi0", "peripheral_clk", 2, 18),
-        MSTPCR("keysc0", "r_clk", 2, 14),
-        MSTPCR("usbf0", "peripheral_clk", 2, 11),
-        MSTPCR("2dg0", "bus_clk", 2, 9),
-        MSTPCR("siu0", "bus_clk", 2, 8),
-        MSTPCR("vou0", "bus_clk", 2, 5),
-        MSTPCR("jpu0", "bus_clk", 2, 6),
-        MSTPCR("beu0", "bus_clk", 2, 4),
-        MSTPCR("ceu0", "bus_clk", 2, 3),
-        MSTPCR("veu0", "bus_clk", 2, 2),
-        MSTPCR("vpu0", "bus_clk", 2, 1),
-        MSTPCR("lcdc0", "bus_clk", 2, 0),
-#endif
-#if defined(CONFIG_CPU_SUBTYPE_SH7723)
-        /* See page 60 of Datasheet V1.0: Overview -> Block Diagram */
-        MSTPCR("tlb0", "cpu_clk", 0, 31),
-        MSTPCR("ic0", "cpu_clk", 0, 30),
-        MSTPCR("oc0", "cpu_clk", 0, 29),
-        MSTPCR("l2c0", "sh_clk", 0, 28),
-        MSTPCR("ilmem0", "cpu_clk", 0, 27),
-        MSTPCR("fpu0", "cpu_clk", 0, 24),
-        MSTPCR("intc0", "cpu_clk", 0, 22),
-        MSTPCR("dmac0", "bus_clk", 0, 21),
-        MSTPCR("sh0", "sh_clk", 0, 20),
-        MSTPCR("hudi0", "peripheral_clk", 0, 19),
-        MSTPCR("ubc0", "cpu_clk", 0, 17),
-        MSTPCR("tmu0", "peripheral_clk", 0, 15),
-        MSTPCR("cmt0", "r_clk", 0, 14),
-        MSTPCR("rwdt0", "r_clk", 0, 13),
-        MSTPCR("dmac1", "bus_clk", 0, 12),
-        MSTPCR("tmu1", "peripheral_clk", 0, 11),
-        MSTPCR("flctl0", "peripheral_clk", 0, 10),
-        MSTPCR("scif0", "peripheral_clk", 0, 9),
-        MSTPCR("scif1", "peripheral_clk", 0, 8),
-        MSTPCR("scif2", "peripheral_clk", 0, 7),
-        MSTPCR("scif3", "bus_clk", 0, 6),
-        MSTPCR("scif4", "bus_clk", 0, 5),
-        MSTPCR("scif5", "bus_clk", 0, 4),
-        MSTPCR("msiof0", "bus_clk", 0, 2),
-        MSTPCR("msiof1", "bus_clk", 0, 1),
-        MSTPCR("meram0", "sh_clk", 0, 0),
-        MSTPCR("i2c0", "peripheral_clk", 1, 9),
-        MSTPCR("rtc0", "r_clk", 1, 8),
-        MSTPCR("atapi0", "sh_clk", 2, 28),
-        MSTPCR("adc0", "peripheral_clk", 2, 28),
-        MSTPCR("tpu0", "bus_clk", 2, 25),
-        MSTPCR("irda0", "peripheral_clk", 2, 24),
-        MSTPCR("tsif0", "bus_clk", 2, 22),
-        MSTPCR("icb0", "bus_clk", 2, 21),
-        MSTPCR("sdhi0", "bus_clk", 2, 18),
-        MSTPCR("sdhi1", "bus_clk", 2, 17),
-        MSTPCR("keysc0", "r_clk", 2, 14),
-        MSTPCR("usb0", "bus_clk", 2, 11),
-        MSTPCR("2dg0", "bus_clk", 2, 10),
-        MSTPCR("siu0", "bus_clk", 2, 8),
-        MSTPCR("veu1", "bus_clk", 2, 6),
-        MSTPCR("vou0", "bus_clk", 2, 5),
-        MSTPCR("beu0", "bus_clk", 2, 4),
-        MSTPCR("ceu0", "bus_clk", 2, 3),
-        MSTPCR("veu0", "bus_clk", 2, 2),
-        MSTPCR("vpu0", "bus_clk", 2, 1),
-        MSTPCR("lcdc0", "bus_clk", 2, 0),
-#endif
-#if defined(CONFIG_CPU_SUBTYPE_SH7343)
-        MSTPCR("uram0", "umem_clk", 0, 28),
-        MSTPCR("xymem0", "bus_clk", 0, 26),
-        MSTPCR("tmu0", "peripheral_clk", 0, 15),
-        MSTPCR("cmt0", "r_clk", 0, 14),
-        MSTPCR("rwdt0", "r_clk", 0, 13),
-        MSTPCR("scif0", "peripheral_clk", 0, 7),
-        MSTPCR("scif1", "peripheral_clk", 0, 6),
-        MSTPCR("scif2", "peripheral_clk", 0, 5),
-        MSTPCR("scif3", "peripheral_clk", 0, 4),
-        MSTPCR("i2c0", "peripheral_clk", 1, 9),
-        MSTPCR("i2c1", "peripheral_clk", 1, 8),
-        MSTPCR("sdhi0", "peripheral_clk", 2, 18),
-        MSTPCR("keysc0", "r_clk", 2, 14),
-        MSTPCR("usbf0", "peripheral_clk", 2, 11),
-        MSTPCR("siu0", "bus_clk", 2, 8),
-        MSTPCR("jpu0", "bus_clk", 2, 6),
-        MSTPCR("vou0", "bus_clk", 2, 5),
-        MSTPCR("beu0", "bus_clk", 2, 4),
-        MSTPCR("ceu0", "bus_clk", 2, 3),
-        MSTPCR("veu0", "bus_clk", 2, 2),
-        MSTPCR("vpu0", "bus_clk", 2, 1),
-        MSTPCR("lcdc0", "bus_clk", 2, 0),
-#endif
-#if defined(CONFIG_CPU_SUBTYPE_SH7366)
-        /* See page 52 of Datasheet V0.40: Overview -> Block Diagram */
-        MSTPCR("tlb0", "cpu_clk", 0, 31),
-        MSTPCR("ic0", "cpu_clk", 0, 30),
-        MSTPCR("oc0", "cpu_clk", 0, 29),
-        MSTPCR("rsmem0", "sh_clk", 0, 28),
-        MSTPCR("xymem0", "cpu_clk", 0, 26),
-        MSTPCR("intc30", "peripheral_clk", 0, 23),
-        MSTPCR("intc0", "peripheral_clk", 0, 22),
-        MSTPCR("dmac0", "bus_clk", 0, 21),
-        MSTPCR("sh0", "sh_clk", 0, 20),
-        MSTPCR("hudi0", "peripheral_clk", 0, 19),
-        MSTPCR("ubc0", "cpu_clk", 0, 17),
-        MSTPCR("tmu0", "peripheral_clk", 0, 15),
-        MSTPCR("cmt0", "r_clk", 0, 14),
-        MSTPCR("rwdt0", "r_clk", 0, 13),
-        MSTPCR("flctl0", "peripheral_clk", 0, 10),
-        MSTPCR("scif0", "peripheral_clk", 0, 7),
-        MSTPCR("scif1", "bus_clk", 0, 6),
-        MSTPCR("scif2", "bus_clk", 0, 5),
-        MSTPCR("msiof0", "peripheral_clk", 0, 2),
-        MSTPCR("sbr0", "peripheral_clk", 0, 1),
-        MSTPCR("i2c0", "peripheral_clk", 1, 9),
-        MSTPCR("icb0", "bus_clk", 2, 27),
-        MSTPCR("meram0", "sh_clk", 2, 26),
-        MSTPCR("dacc0", "peripheral_clk", 2, 24),
-        MSTPCR("dacy0", "peripheral_clk", 2, 23),
-        MSTPCR("tsif0", "bus_clk", 2, 22),
-        MSTPCR("sdhi0", "bus_clk", 2, 18),
-        MSTPCR("mmcif0", "bus_clk", 2, 17),
-        MSTPCR("usb0", "bus_clk", 2, 11),
-        MSTPCR("siu0", "bus_clk", 2, 8),
-        MSTPCR("veu1", "bus_clk", 2, 7),
-        MSTPCR("vou0", "bus_clk", 2, 5),
-        MSTPCR("beu0", "bus_clk", 2, 4),
-        MSTPCR("ceu0", "bus_clk", 2, 3),
-        MSTPCR("veu0", "bus_clk", 2, 2),
-        MSTPCR("vpu0", "bus_clk", 2, 1),
-        MSTPCR("lcdc0", "bus_clk", 2, 0),
-#endif
-};
-
-static struct clk *sh7722_clocks[] = {
-        &sh7722_umem_clock,
-        &sh7722_sh_clock,
-        &sh7722_peripheral_clock,
-        &sh7722_sdram_clock,
-#ifndef CONFIG_CPU_SUBTYPE_SH7343
-        &sh7722_siu_a_clock,
-        &sh7722_siu_b_clock,
-#if defined(CONFIG_CPU_SUBTYPE_SH7722)
-        &sh7722_irda_clock,
-#endif
-#endif
-        &sh7722_video_clock,
+        MSTP("sdhi0", &div4_clks[DIV4_P], MSTPCR2, 18, 0),
+        MSTP("keysc0", &r_clk, MSTPCR2, 14, 0),
+        MSTP("usbf0", &div4_clks[DIV4_P], MSTPCR2, 11, 0),
+        MSTP("2dg0", &div4_clks[DIV4_B], MSTPCR2, 9, 0),
+        MSTP("siu0", &div4_clks[DIV4_B], MSTPCR2, 8, 0),
+        MSTP("vou0", &div4_clks[DIV4_B], MSTPCR2, 5, 0),
+        MSTP("jpu0", &div4_clks[DIV4_B], MSTPCR2, 6, CLK_ENABLE_ON_INIT),
+        MSTP("beu0", &div4_clks[DIV4_B], MSTPCR2, 4, 0),
+        MSTP("ceu0", &div4_clks[DIV4_B], MSTPCR2, 3, 0),
+        MSTP("veu0", &div4_clks[DIV4_B], MSTPCR2, 2, CLK_ENABLE_ON_INIT),
+        MSTP("vpu0", &div4_clks[DIV4_B], MSTPCR2, 1, CLK_ENABLE_ON_INIT),
+        MSTP("lcdc0", &div4_clks[DIV4_B], MSTPCR2, 0, 0),
 };
 
-/*
- * init in order: master, module, bus, cpu
- */
-struct clk_ops *onchip_ops[] = {
-        &sh7722_master_clk_ops,
-        &sh7722_module_clk_ops,
-        &sh7722_frqcr_clk_ops,
-        &sh7722_frqcr_clk_ops,
-};
-
-void __init
-arch_init_clk_ops(struct clk_ops **ops, int type)
-{
-        BUG_ON(type < 0 || type > ARRAY_SIZE(onchip_ops));
-        *ops = onchip_ops[type];
-}
-
 int __init arch_clk_init(void)
 {
-        struct clk *clk;
-        int i;
+        int k, ret = 0;
+
+        /* autodetect extal or dll configuration */
+        if (__raw_readl(PLLCR) & 0x1000)
+                pll_clk.parent = &dll_clk;
+        else
+                pll_clk.parent = &extal_clk;
 
-        clk = clk_get(NULL, "master_clk");
-        for (i = 0; i < ARRAY_SIZE(sh7722_clocks); i++) {
-                pr_debug( "Registering clock '%s'\n", sh7722_clocks[i]->name);
-                sh7722_clocks[i]->parent = clk;
-                clk_register(sh7722_clocks[i]);
-        }
-        clk_put(clk);
+        for (k = 0; !ret && (k < ARRAY_SIZE(main_clks)); k++)
+                ret = clk_register(main_clks[k]);
 
-        clk_register(&sh7722_r_clock);
+        if (!ret)
+                ret = sh_clk_div4_register(div4_clks, DIV4_NR, &div4_table);
 
-        for (i = 0; i < ARRAY_SIZE(sh7722_mstpcr_clocks); i++) {
-                pr_debug( "Registering mstpcr clock '%s'\n",
-                          sh7722_mstpcr_clocks[i].name);
-                clk = clk_get(NULL, (void *) sh7722_mstpcr_clocks[i].ops);
-                sh7722_mstpcr_clocks[i].parent = clk;
-                sh7722_mstpcr_clocks[i].ops = &sh7722_mstpcr_clk_ops;
-                clk_register(&sh7722_mstpcr_clocks[i]);
-                clk_put(clk);
-        }
+        if (!ret)
+                ret = sh_clk_div6_register(div6_clks, ARRAY_SIZE(div6_clks));
 
-        clk_recalc_rate(&sh7722_r_clock); /* make sure rate gets propagated */
+        if (!ret)
+                ret = sh_clk_mstp32_register(mstp_clks, ARRAY_SIZE(mstp_clks));
 
-        return 0;
+        return ret;
 }
diff --git a/arch/sh/kernel/cpu/sh4a/clock-sh7723.c b/arch/sh/kernel/cpu/sh4a/clock-sh7723.c
new file mode 100644
index 000000000000..e67c2678b8ae
--- /dev/null
+++ b/arch/sh/kernel/cpu/sh4a/clock-sh7723.c
@@ -0,0 +1,222 @@
+/*
+ * arch/sh/kernel/cpu/sh4a/clock-sh7723.c
+ *
+ * SH7723 clock framework support
+ *
+ * Copyright (C) 2009 Magnus Damm
+ *
+ * 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
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/io.h>
+#include <asm/clock.h>
+
+/* SH7723 registers */
+#define FRQCR           0xa4150000
+#define VCLKCR          0xa4150004
+#define SCLKACR         0xa4150008
+#define SCLKBCR         0xa415000c
+#define IRDACLKCR       0xa4150018
+#define PLLCR           0xa4150024
+#define MSTPCR0         0xa4150030
+#define MSTPCR1         0xa4150034
+#define MSTPCR2         0xa4150038
+#define DLLFRQ          0xa4150050
+
+/* Fixed 32 KHz root clock for RTC and Power Management purposes */
+static struct clk r_clk = {
+        .name           = "rclk",
+        .id             = -1,
+        .rate           = 32768,
+};
+
+/*
+ * Default rate for the root input clock, reset this with clk_set_rate()
+ * from the platform code.
+ */
+struct clk extal_clk = {
+        .name           = "extal",
+        .id             = -1,
+        .rate           = 33333333,
+};
+
+/* The dll multiplies the 32khz r_clk, may be used instead of extal */
+static unsigned long dll_recalc(struct clk *clk)
+{
+        unsigned long mult;
+
+        if (__raw_readl(PLLCR) & 0x1000)
+                mult = __raw_readl(DLLFRQ);
+        else
+                mult = 0;
+
+        return clk->parent->rate * mult;
+}
+
+static struct clk_ops dll_clk_ops = {
+        .recalc         = dll_recalc,
+};
+
+static struct clk dll_clk = {
+        .name           = "dll_clk",
+        .id             = -1,
+        .ops            = &dll_clk_ops,
+        .parent         = &r_clk,
+        .flags          = CLK_ENABLE_ON_INIT,
+};
+
+static unsigned long pll_recalc(struct clk *clk)
+{
+        unsigned long mult = 1;
+        unsigned long div = 1;
+
+        if (__raw_readl(PLLCR) & 0x4000)
+                mult = (((__raw_readl(FRQCR) >> 24) & 0x1f) + 1);
+        else
+                div = 2;
+
+        return (clk->parent->rate * mult) / div;
+}
+
+static struct clk_ops pll_clk_ops = {
+        .recalc         = pll_recalc,
+};
+
+static struct clk pll_clk = {
+        .name           = "pll_clk",
+        .id             = -1,
+        .ops            = &pll_clk_ops,
+        .flags          = CLK_ENABLE_ON_INIT,
+};
+
+struct clk *main_clks[] = {
+        &r_clk,
+        &extal_clk,
+        &dll_clk,
+        &pll_clk,
+};
+
+static int multipliers[] = { 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
+static int divisors[] = { 1, 3, 2, 5, 3, 4, 5, 6, 8, 10, 12, 16, 20 };
+
+static struct clk_div_mult_table div4_table = {
+        .divisors = divisors,
+        .nr_divisors = ARRAY_SIZE(divisors),
+        .multipliers = multipliers,
+        .nr_multipliers = ARRAY_SIZE(multipliers),
+};
+
+enum { DIV4_I, DIV4_U, DIV4_SH, DIV4_B, DIV4_B3, DIV4_P,
+       DIV4_SIUA, DIV4_SIUB, DIV4_IRDA, DIV4_NR };
+
+#define DIV4(_str, _reg, _bit, _mask, _flags) \
+  SH_CLK_DIV4(_str, &pll_clk, _reg, _bit, _mask, _flags)
+
+struct clk div4_clks[DIV4_NR] = {
+        [DIV4_I] = DIV4("cpu_clk", FRQCR, 20, 0x0dbf, CLK_ENABLE_ON_INIT),
+        [DIV4_U] = DIV4("umem_clk", FRQCR, 16, 0x0dbf, CLK_ENABLE_ON_INIT),
+        [DIV4_SH] = DIV4("shyway_clk", FRQCR, 12, 0x0dbf, CLK_ENABLE_ON_INIT),
+        [DIV4_B] = DIV4("bus_clk", FRQCR, 8, 0x0dbf, CLK_ENABLE_ON_INIT),
+        [DIV4_B3] = DIV4("b3_clk", FRQCR, 4, 0x0db4, CLK_ENABLE_ON_INIT),
+        [DIV4_P] = DIV4("peripheral_clk", FRQCR, 0, 0x0dbf, 0),
+        [DIV4_SIUA] = DIV4("siua_clk", SCLKACR, 0, 0x0dbf, 0),
+        [DIV4_SIUB] = DIV4("siub_clk", SCLKBCR, 0, 0x0dbf, 0),
+        [DIV4_IRDA] = DIV4("irda_clk", IRDACLKCR, 0, 0x0dbf, 0),
+};
+
+struct clk div6_clks[] = {
+        SH_CLK_DIV6("video_clk", &pll_clk, VCLKCR, 0),
+};
+
+#define MSTP(_str, _parent, _reg, _bit, _force_on, _need_cpg, _need_ram) \
+  SH_CLK_MSTP32(_str, -1, _parent, _reg, _bit, _force_on * CLK_ENABLE_ON_INIT)
+
+static struct clk mstp_clks[] = {
+        /* See page 60 of Datasheet V1.0: Overview -> Block Diagram */
+        MSTP("tlb0", &div4_clks[DIV4_I], MSTPCR0, 31, 1, 1, 0),
+        MSTP("ic0", &div4_clks[DIV4_I], MSTPCR0, 30, 1, 1, 0),
+        MSTP("oc0", &div4_clks[DIV4_I], MSTPCR0, 29, 1, 1, 0),
+        MSTP("l2c0", &div4_clks[DIV4_SH], MSTPCR0, 28, 1, 1, 0),
+        MSTP("ilmem0", &div4_clks[DIV4_I], MSTPCR0, 27, 1, 1, 0),
+        MSTP("fpu0", &div4_clks[DIV4_I], MSTPCR0, 24, 1, 1, 0),
+        MSTP("intc0", &div4_clks[DIV4_I], MSTPCR0, 22, 1, 1, 0),
+        MSTP("dmac0", &div4_clks[DIV4_B], MSTPCR0, 21, 0, 1, 1),
+        MSTP("sh0", &div4_clks[DIV4_SH], MSTPCR0, 20, 0, 1, 0),
+        MSTP("hudi0", &div4_clks[DIV4_P], MSTPCR0, 19, 0, 1, 0),
+        MSTP("ubc0", &div4_clks[DIV4_I], MSTPCR0, 17, 0, 1, 0),
+        MSTP("tmu0", &div4_clks[DIV4_P], MSTPCR0, 15, 0, 1, 0),
+        MSTP("cmt0", &r_clk, MSTPCR0, 14, 0, 0, 0),
+        MSTP("rwdt0", &r_clk, MSTPCR0, 13, 0, 0, 0),
+        MSTP("dmac1", &div4_clks[DIV4_B], MSTPCR0, 12, 0, 1, 1),
+        MSTP("tmu1", &div4_clks[DIV4_P], MSTPCR0, 11, 0, 1, 0),
+        MSTP("flctl0", &div4_clks[DIV4_P], MSTPCR0, 10, 0, 1, 0),
+        MSTP("scif0", &div4_clks[DIV4_P], MSTPCR0, 9, 0, 1, 0),
+        MSTP("scif1", &div4_clks[DIV4_P], MSTPCR0, 8, 0, 1, 0),
+        MSTP("scif2", &div4_clks[DIV4_P], MSTPCR0, 7, 0, 1, 0),
+        MSTP("scif3", &div4_clks[DIV4_B], MSTPCR0, 6, 0, 1, 0),
+        MSTP("scif4", &div4_clks[DIV4_B], MSTPCR0, 5, 0, 1, 0),
+        MSTP("scif5", &div4_clks[DIV4_B], MSTPCR0, 4, 0, 1, 0),
+        MSTP("msiof0", &div4_clks[DIV4_B], MSTPCR0, 2, 0, 1, 0),
+        MSTP("msiof1", &div4_clks[DIV4_B], MSTPCR0, 1, 0, 1, 0),
+        MSTP("meram0", &div4_clks[DIV4_SH], MSTPCR0, 0, 1, 1, 0),
+
+        MSTP("i2c0", &div4_clks[DIV4_P], MSTPCR1, 9, 0, 1, 0),
+        MSTP("rtc0", &r_clk, MSTPCR1, 8, 0, 0, 0),
+
+        MSTP("atapi0", &div4_clks[DIV4_SH], MSTPCR2, 28, 0, 1, 0),
+        MSTP("adc0", &div4_clks[DIV4_P], MSTPCR2, 27, 0, 1, 0),
+        MSTP("tpu0", &div4_clks[DIV4_B], MSTPCR2, 25, 0, 1, 0),
+        MSTP("irda0", &div4_clks[DIV4_P], MSTPCR2, 24, 0, 1, 0),
+        MSTP("tsif0", &div4_clks[DIV4_B], MSTPCR2, 22, 0, 1, 0),
+        MSTP("icb0", &div4_clks[DIV4_B], MSTPCR2, 21, 0, 1, 1),
+        MSTP("sdhi0", &div4_clks[DIV4_B], MSTPCR2, 18, 0, 1, 0),
+        MSTP("sdhi1", &div4_clks[DIV4_B], MSTPCR2, 17, 0, 1, 0),
+        MSTP("keysc0", &r_clk, MSTPCR2, 14, 0, 0, 0),
+        MSTP("usb0", &div4_clks[DIV4_B], MSTPCR2, 11, 0, 1, 0),
+        MSTP("2dg0", &div4_clks[DIV4_B], MSTPCR2, 10, 0, 1, 1),
+        MSTP("siu0", &div4_clks[DIV4_B], MSTPCR2, 8, 0, 1, 0),
+        MSTP("veu1", &div4_clks[DIV4_B], MSTPCR2, 6, 1, 1, 1),
+        MSTP("vou0", &div4_clks[DIV4_B], MSTPCR2, 5, 0, 1, 1),
+        MSTP("beu0", &div4_clks[DIV4_B], MSTPCR2, 4, 0, 1, 1),
+        MSTP("ceu0", &div4_clks[DIV4_B], MSTPCR2, 3, 0, 1, 1),
+        MSTP("veu0", &div4_clks[DIV4_B], MSTPCR2, 2, 1, 1, 1),
+        MSTP("vpu0", &div4_clks[DIV4_B], MSTPCR2, 1, 1, 1, 1),
+        MSTP("lcdc0", &div4_clks[DIV4_B], MSTPCR2, 0, 0, 1, 1),
+};
+
+int __init arch_clk_init(void)
+{
+        int k, ret = 0;
+
+        /* autodetect extal or dll configuration */
+        if (__raw_readl(PLLCR) & 0x1000)
+                pll_clk.parent = &dll_clk;
+        else
+                pll_clk.parent = &extal_clk;
+
+        for (k = 0; !ret && (k < ARRAY_SIZE(main_clks)); k++)
+                ret = clk_register(main_clks[k]);
+
+        if (!ret)
+                ret = sh_clk_div4_register(div4_clks, DIV4_NR, &div4_table);
+
+        if (!ret)
+                ret = sh_clk_div6_register(div6_clks, ARRAY_SIZE(div6_clks));
+
+        if (!ret)
+                ret = sh_clk_mstp32_register(mstp_clks, ARRAY_SIZE(mstp_clks));
+
+        return ret;
+}
diff --git a/arch/sh/kernel/cpu/sh4a/clock-sh7724.c b/arch/sh/kernel/cpu/sh4a/clock-sh7724.c
new file mode 100644
index 000000000000..5d5c9b952883
--- /dev/null
+++ b/arch/sh/kernel/cpu/sh4a/clock-sh7724.c
@@ -0,0 +1,242 @@
+/*
+ * arch/sh/kernel/cpu/sh4a/clock-sh7724.c
+ *
+ * SH7724 clock framework support
+ *
+ * Copyright (C) 2009 Magnus Damm
+ *
+ * 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
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/io.h>
+#include <asm/clock.h>
+
+/* SH7724 registers */
+#define FRQCRA          0xa4150000
+#define FRQCRB          0xa4150004
+#define VCLKCR          0xa4150048
+#define FCLKACR         0xa4150008
+#define FCLKBCR         0xa415000c
+#define IRDACLKCR       0xa4150018
+#define PLLCR           0xa4150024
+#define MSTPCR0         0xa4150030
+#define MSTPCR1         0xa4150034
+#define MSTPCR2         0xa4150038
+#define SPUCLKCR        0xa415003c
+#define FLLFRQ          0xa4150050
+#define LSTATS          0xa4150060
+
+/* Fixed 32 KHz root clock for RTC and Power Management purposes */
+static struct clk r_clk = {
+        .name           = "rclk",
+        .id             = -1,
+        .rate           = 32768,
+};
+
+/*
+ * Default rate for the root input clock, reset this with clk_set_rate()
+ * from the platform code.
+ */
+struct clk extal_clk = {
+        .name           = "extal",
+        .id             = -1,
+        .rate           = 33333333,
+};
+
+/* The fll multiplies the 32khz r_clk, may be used instead of extal */
+static unsigned long fll_recalc(struct clk *clk)
+{
+        unsigned long mult = 0;
+        unsigned long div = 1;
+
+        if (__raw_readl(PLLCR) & 0x1000)
+                mult = __raw_readl(FLLFRQ) & 0x3ff;
+
+        if (__raw_readl(FLLFRQ) & 0x4000)
+                div = 2;
+
+        return (clk->parent->rate * mult) / div;
+}
+
+static struct clk_ops fll_clk_ops = {
+        .recalc         = fll_recalc,
+};
+
+static struct clk fll_clk = {
+        .name           = "fll_clk",
+        .id             = -1,
+        .ops            = &fll_clk_ops,
+        .parent         = &r_clk,
+        .flags          = CLK_ENABLE_ON_INIT,
+};
+
+static unsigned long pll_recalc(struct clk *clk)
+{
+        unsigned long mult = 1;
+
+        if (__raw_readl(PLLCR) & 0x4000)
+                mult = (((__raw_readl(FRQCRA) >> 24) & 0x3f) + 1) * 2;
+
+        return clk->parent->rate * mult;
+}
+
+static struct clk_ops pll_clk_ops = {
+        .recalc         = pll_recalc,
+};
+
+static struct clk pll_clk = {
+        .name           = "pll_clk",
+        .id             = -1,
+        .ops            = &pll_clk_ops,
+        .flags          = CLK_ENABLE_ON_INIT,
+};
+
+/* A fixed divide-by-3 block use by the div6 clocks */
+static unsigned long div3_recalc(struct clk *clk)
+{
+        return clk->parent->rate / 3;
+}
+
+static struct clk_ops div3_clk_ops = {
+        .recalc         = div3_recalc,
+};
+
+static struct clk div3_clk = {
+        .name           = "div3_clk",
+        .id             = -1,
+        .ops            = &div3_clk_ops,
+        .parent         = &pll_clk,
+};
+
+struct clk *main_clks[] = {
+        &r_clk,
+        &extal_clk,
+        &fll_clk,
+        &pll_clk,
+        &div3_clk,
+};
+
+static int divisors[] = { 2, 0, 4, 6, 8, 12, 16, 0, 24, 32, 36, 48, 0, 72 };
+
+static struct clk_div_mult_table div4_table = {
+        .divisors = divisors,
+        .nr_divisors = ARRAY_SIZE(divisors),
+};
+
+enum { DIV4_I, DIV4_SH, DIV4_B, DIV4_P, DIV4_M1, DIV4_NR };
+
+#define DIV4(_str, _reg, _bit, _mask, _flags) \
+  SH_CLK_DIV4(_str, &pll_clk, _reg, _bit, _mask, _flags)
+
+struct clk div4_clks[DIV4_NR] = {
+        [DIV4_I] = DIV4("cpu_clk", FRQCRA, 20, 0x2f7d, CLK_ENABLE_ON_INIT),
+        [DIV4_SH] = DIV4("shyway_clk", FRQCRA, 12, 0x2f7c, CLK_ENABLE_ON_INIT),
+        [DIV4_B] = DIV4("bus_clk", FRQCRA, 8, 0x2f7c, CLK_ENABLE_ON_INIT),
+        [DIV4_P] = DIV4("peripheral_clk", FRQCRA, 0, 0x2f7c, 0),
+        [DIV4_M1] = DIV4("vpu_clk", FRQCRB, 4, 0x2f7c, 0),
+};
+
+struct clk div6_clks[] = {
+        SH_CLK_DIV6("video_clk", &div3_clk, VCLKCR, 0),
+        SH_CLK_DIV6("fsia_clk", &div3_clk, FCLKACR, 0),
+        SH_CLK_DIV6("fsib_clk", &div3_clk, FCLKBCR, 0),
+        SH_CLK_DIV6("irda_clk", &div3_clk, IRDACLKCR, 0),
+        SH_CLK_DIV6("spu_clk", &div3_clk, SPUCLKCR, 0),
+};
+
+#define MSTP(_str, _parent, _reg, _bit, _force_on, _need_cpg, _need_ram) \
+  SH_CLK_MSTP32(_str, -1, _parent, _reg, _bit, _force_on * CLK_ENABLE_ON_INIT)
+
+static struct clk mstp_clks[] = {
+        MSTP("tlb0", &div4_clks[DIV4_I], MSTPCR0, 31, 1, 1, 0),
+        MSTP("ic0", &div4_clks[DIV4_I], MSTPCR0, 30, 1, 1, 0),
+        MSTP("oc0", &div4_clks[DIV4_I], MSTPCR0, 29, 1, 1, 0),
+        MSTP("rs0", &div4_clks[DIV4_B], MSTPCR0, 28, 1, 1, 0),
+        MSTP("ilmem0", &div4_clks[DIV4_I], MSTPCR0, 27, 1, 1, 0),
+        MSTP("l2c0", &div4_clks[DIV4_SH], MSTPCR0, 26, 1, 1, 0),
+        MSTP("fpu0", &div4_clks[DIV4_I], MSTPCR0, 24, 1, 1, 0),
+        MSTP("intc0", &div4_clks[DIV4_P], MSTPCR0, 22, 1, 1, 0),
+        MSTP("dmac0", &div4_clks[DIV4_B], MSTPCR0, 21, 0, 1, 1),
+        MSTP("sh0", &div4_clks[DIV4_SH], MSTPCR0, 20, 0, 1, 0),
+        MSTP("hudi0", &div4_clks[DIV4_P], MSTPCR0, 19, 0, 1, 0),
+        MSTP("ubc0", &div4_clks[DIV4_I], MSTPCR0, 17, 0, 1, 0),
+        MSTP("tmu0", &div4_clks[DIV4_P], MSTPCR0, 15, 0, 1, 0),
+        MSTP("cmt0", &r_clk, MSTPCR0, 14, 0, 0, 0),
+        MSTP("rwdt0", &r_clk, MSTPCR0, 13, 0, 0, 0),
+        MSTP("dmac1", &div4_clks[DIV4_B], MSTPCR0, 12, 0, 1, 1),
+        MSTP("tmu1", &div4_clks[DIV4_P], MSTPCR0, 10, 0, 1, 0),
+        MSTP("scif0", &div4_clks[DIV4_P], MSTPCR0, 9, 0, 1, 0),
+        MSTP("scif1", &div4_clks[DIV4_P], MSTPCR0, 8, 0, 1, 0),
+        MSTP("scif2", &div4_clks[DIV4_P], MSTPCR0, 7, 0, 1, 0),
+        MSTP("scif3", &div4_clks[DIV4_B], MSTPCR0, 6, 0, 1, 0),
+        MSTP("scif4", &div4_clks[DIV4_B], MSTPCR0, 5, 0, 1, 0),
+        MSTP("scif5", &div4_clks[DIV4_B], MSTPCR0, 4, 0, 1, 0),
+        MSTP("msiof0", &div4_clks[DIV4_B], MSTPCR0, 2, 0, 1, 0),
+        MSTP("msiof1", &div4_clks[DIV4_B], MSTPCR0, 1, 0, 1, 0),
+
+        MSTP("keysc0", &r_clk, MSTPCR1, 12, 0, 0, 0),
+        MSTP("rtc0", &r_clk, MSTPCR1, 11, 0, 0, 0),
+        MSTP("i2c0", &div4_clks[DIV4_P], MSTPCR1, 9, 0, 1, 0),
+        MSTP("i2c1", &div4_clks[DIV4_P], MSTPCR1, 8, 0, 1, 0),
+
+        MSTP("mmc0", &div4_clks[DIV4_B], MSTPCR2, 29, 0, 1, 0),
+        MSTP("eth0", &div4_clks[DIV4_B], MSTPCR2, 28, 0, 1, 0),
+        MSTP("atapi0", &div4_clks[DIV4_B], MSTPCR2, 26, 0, 1, 0),
+        MSTP("tpu0", &div4_clks[DIV4_B], MSTPCR2, 25, 0, 1, 0),
+        MSTP("irda0", &div4_clks[DIV4_P], MSTPCR2, 24, 0, 1, 0),
+        MSTP("tsif0", &div4_clks[DIV4_B], MSTPCR2, 22, 0, 1, 0),
+        MSTP("usb1", &div4_clks[DIV4_B], MSTPCR2, 21, 0, 1, 1),
+        MSTP("usb0", &div4_clks[DIV4_B], MSTPCR2, 20, 0, 1, 1),
+        MSTP("2dg0", &div4_clks[DIV4_B], MSTPCR2, 19, 0, 1, 1),
+        MSTP("sdhi0", &div4_clks[DIV4_B], MSTPCR2, 18, 0, 1, 0),
+        MSTP("sdhi1", &div4_clks[DIV4_B], MSTPCR2, 17, 0, 1, 0),
+        MSTP("veu1", &div4_clks[DIV4_B], MSTPCR2, 15, 1, 1, 1),
+        MSTP("ceu1", &div4_clks[DIV4_B], MSTPCR2, 13, 0, 1, 1),
+        MSTP("beu1", &div4_clks[DIV4_B], MSTPCR2, 12, 0, 1, 1),
+        MSTP("2ddmac0", &div4_clks[DIV4_SH], MSTPCR2, 10, 0, 1, 1),
+        MSTP("spu0", &div4_clks[DIV4_B], MSTPCR2, 9, 0, 1, 0),
+        MSTP("jpu0", &div4_clks[DIV4_B], MSTPCR2, 6, 1, 1, 1),
+        MSTP("vou0", &div4_clks[DIV4_B], MSTPCR2, 5, 0, 1, 1),
+        MSTP("beu0", &div4_clks[DIV4_B], MSTPCR2, 4, 0, 1, 1),
+        MSTP("ceu0", &div4_clks[DIV4_B], MSTPCR2, 3, 0, 1, 1),
+        MSTP("veu0", &div4_clks[DIV4_B], MSTPCR2, 2, 1, 1, 1),
+        MSTP("vpu0", &div4_clks[DIV4_B], MSTPCR2, 1, 1, 1, 1),
+        MSTP("lcdc0", &div4_clks[DIV4_B], MSTPCR2, 0, 0, 1, 1),
+};
+
+int __init arch_clk_init(void)
+{
+        int k, ret = 0;
+
+        /* autodetect extal or fll configuration */
+        if (__raw_readl(PLLCR) & 0x1000)
+                pll_clk.parent = &fll_clk;
+        else
+                pll_clk.parent = &extal_clk;
+
+        for (k = 0; !ret && (k < ARRAY_SIZE(main_clks)); k++)
+                ret = clk_register(main_clks[k]);
+
+        if (!ret)
+                ret = sh_clk_div4_register(div4_clks, DIV4_NR, &div4_table);
+
+        if (!ret)
+                ret = sh_clk_div6_register(div6_clks, ARRAY_SIZE(div6_clks));
+
+        if (!ret)
+                ret = sh_clk_mstp32_register(mstp_clks, ARRAY_SIZE(mstp_clks));
+
+        return ret;
+}
diff --git a/arch/sh/kernel/cpu/sh4a/clock-sh7763.c b/arch/sh/kernel/cpu/sh4a/clock-sh7763.c
index 3177d0d1e06d..370cd47642ef 100644
--- a/arch/sh/kernel/cpu/sh4a/clock-sh7763.c
+++ b/arch/sh/kernel/cpu/sh4a/clock-sh7763.c
@@ -29,33 +29,28 @@ static struct clk_ops sh7763_master_clk_ops = {
         .init           = master_clk_init,
 };
 
-static void module_clk_recalc(struct clk *clk)
+static unsigned long module_clk_recalc(struct clk *clk)
 {
         int idx = ((ctrl_inl(FRQCR) >> 4) & 0x07);
-        clk->rate = clk->parent->rate / p0fc_divisors[idx];
+        return clk->parent->rate / p0fc_divisors[idx];
 }
 
 static struct clk_ops sh7763_module_clk_ops = {
         .recalc         = module_clk_recalc,
 };
 
-static void bus_clk_recalc(struct clk *clk)
+static unsigned long bus_clk_recalc(struct clk *clk)
 {
         int idx = ((ctrl_inl(FRQCR) >> 16) & 0x07);
-        clk->rate = clk->parent->rate / bfc_divisors[idx];
+        return clk->parent->rate / bfc_divisors[idx];
 }
 
 static struct clk_ops sh7763_bus_clk_ops = {
         .recalc         = bus_clk_recalc,
 };
 
-static void cpu_clk_recalc(struct clk *clk)
-{
-        clk->rate = clk->parent->rate;
-}
-
 static struct clk_ops sh7763_cpu_clk_ops = {
-        .recalc         = cpu_clk_recalc,
+        .recalc         = followparent_recalc,
 };
 
 static struct clk_ops *sh7763_clk_ops[] = {
@@ -71,10 +66,10 @@ void __init arch_init_clk_ops(struct clk_ops **ops, int idx)
                 *ops = sh7763_clk_ops[idx];
 }
 
-static void shyway_clk_recalc(struct clk *clk)
+static unsigned long shyway_clk_recalc(struct clk *clk)
 {
         int idx = ((ctrl_inl(FRQCR) >> 20) & 0x07);
-        clk->rate = clk->parent->rate / cfc_divisors[idx];
+        return clk->parent->rate / cfc_divisors[idx];
 }
 
 static struct clk_ops sh7763_shyway_clk_ops = {
@@ -83,7 +78,7 @@ static struct clk_ops sh7763_shyway_clk_ops = {
 
 static struct clk sh7763_shyway_clk = {
         .name           = "shyway_clk",
-        .flags          = CLK_ALWAYS_ENABLED,
+        .flags          = CLK_ENABLE_ON_INIT,
         .ops            = &sh7763_shyway_clk_ops,
 };
 
@@ -95,31 +90,22 @@ static struct clk *sh7763_onchip_clocks[] = {
         &sh7763_shyway_clk,
 };
 
-static int __init sh7763_clk_init(void)
+int __init arch_clk_init(void)
 {
-        struct clk *clk = clk_get(NULL, "master_clk");
-        int i;
+        struct clk *clk;
+        int i, ret = 0;
+
+        cpg_clk_init();
 
+        clk = clk_get(NULL, "master_clk");
         for (i = 0; i < ARRAY_SIZE(sh7763_onchip_clocks); i++) {
                 struct clk *clkp = sh7763_onchip_clocks[i];
 
                 clkp->parent = clk;
-                clk_register(clkp);
-                clk_enable(clkp);
+                ret |= clk_register(clkp);
         }
 
-        /*
-         * Now that we have the rest of the clocks registered, we need to
-         * force the parent clock to propagate so that these clocks will
-         * automatically figure out their rate. We cheat by handing the
-         * parent clock its current rate and forcing child propagation.
-         */
-        clk_set_rate(clk, clk_get_rate(clk));
-
         clk_put(clk);
 
-        return 0;
+        return ret;
 }
-
-arch_initcall(sh7763_clk_init);
-
diff --git a/arch/sh/kernel/cpu/sh4a/clock-sh7770.c b/arch/sh/kernel/cpu/sh4a/clock-sh7770.c
index 8e236062c721..e0b896769205 100644
--- a/arch/sh/kernel/cpu/sh4a/clock-sh7770.c
+++ b/arch/sh/kernel/cpu/sh4a/clock-sh7770.c
@@ -28,30 +28,30 @@ static struct clk_ops sh7770_master_clk_ops = {
         .init           = master_clk_init,
 };
 
-static void module_clk_recalc(struct clk *clk)
+static unsigned long module_clk_recalc(struct clk *clk)
 {
         int idx = ((ctrl_inl(FRQCR) >> 28) & 0x000f);
-        clk->rate = clk->parent->rate / pfc_divisors[idx];
+        return clk->parent->rate / pfc_divisors[idx];
 }
 
 static struct clk_ops sh7770_module_clk_ops = {
         .recalc         = module_clk_recalc,
 };
 
-static void bus_clk_recalc(struct clk *clk)
+static unsigned long bus_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inl(FRQCR) & 0x000f);
-        clk->rate = clk->parent->rate / bfc_divisors[idx];
+        return clk->parent->rate / bfc_divisors[idx];
 }
 
 static struct clk_ops sh7770_bus_clk_ops = {
         .recalc         = bus_clk_recalc,
 };
 
-static void cpu_clk_recalc(struct clk *clk)
+static unsigned long cpu_clk_recalc(struct clk *clk)
 {
         int idx = ((ctrl_inl(FRQCR) >> 24) & 0x000f);
-        clk->rate = clk->parent->rate / ifc_divisors[idx];
+        return clk->parent->rate / ifc_divisors[idx];
 }
 
 static struct clk_ops sh7770_cpu_clk_ops = {
diff --git a/arch/sh/kernel/cpu/sh4a/clock-sh7780.c b/arch/sh/kernel/cpu/sh4a/clock-sh7780.c
index 01f3da619d3d..a249d823578e 100644
--- a/arch/sh/kernel/cpu/sh4a/clock-sh7780.c
+++ b/arch/sh/kernel/cpu/sh4a/clock-sh7780.c
@@ -29,30 +29,30 @@ static struct clk_ops sh7780_master_clk_ops = {
         .init           = master_clk_init,
 };
 
-static void module_clk_recalc(struct clk *clk)
+static unsigned long module_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inl(FRQCR) & 0x0003);
-        clk->rate = clk->parent->rate / pfc_divisors[idx];
+        return clk->parent->rate / pfc_divisors[idx];
 }
 
 static struct clk_ops sh7780_module_clk_ops = {
         .recalc         = module_clk_recalc,
 };
 
-static void bus_clk_recalc(struct clk *clk)
+static unsigned long bus_clk_recalc(struct clk *clk)
 {
         int idx = ((ctrl_inl(FRQCR) >> 16) & 0x0007);
-        clk->rate = clk->parent->rate / bfc_divisors[idx];
+        return clk->parent->rate / bfc_divisors[idx];
 }
 
 static struct clk_ops sh7780_bus_clk_ops = {
         .recalc         = bus_clk_recalc,
 };
 
-static void cpu_clk_recalc(struct clk *clk)
+static unsigned long cpu_clk_recalc(struct clk *clk)
 {
         int idx = ((ctrl_inl(FRQCR) >> 24) & 0x0001);
-        clk->rate = clk->parent->rate / ifc_divisors[idx];
+        return clk->parent->rate / ifc_divisors[idx];
 }
 
 static struct clk_ops sh7780_cpu_clk_ops = {
@@ -72,10 +72,10 @@ void __init arch_init_clk_ops(struct clk_ops **ops, int idx)
                 *ops = sh7780_clk_ops[idx];
 }
 
-static void shyway_clk_recalc(struct clk *clk)
+static unsigned long shyway_clk_recalc(struct clk *clk)
 {
         int idx = ((ctrl_inl(FRQCR) >> 20) & 0x0007);
-        clk->rate = clk->parent->rate / cfc_divisors[idx];
+        return clk->parent->rate / cfc_divisors[idx];
 }
 
 static struct clk_ops sh7780_shyway_clk_ops = {
@@ -84,7 +84,7 @@ static struct clk_ops sh7780_shyway_clk_ops = {
 
 static struct clk sh7780_shyway_clk = {
         .name           = "shyway_clk",
-        .flags          = CLK_ALWAYS_ENABLED,
+        .flags          = CLK_ENABLE_ON_INIT,
         .ops            = &sh7780_shyway_clk_ops,
 };
 
@@ -96,31 +96,22 @@ static struct clk *sh7780_onchip_clocks[] = {
         &sh7780_shyway_clk,
 };
 
-static int __init sh7780_clk_init(void)
+int __init arch_clk_init(void)
 {
-        struct clk *clk = clk_get(NULL, "master_clk");
-        int i;
+        struct clk *clk;
+        int i, ret = 0;
 
+        cpg_clk_init();
+
+        clk = clk_get(NULL, "master_clk");
         for (i = 0; i < ARRAY_SIZE(sh7780_onchip_clocks); i++) {
                 struct clk *clkp = sh7780_onchip_clocks[i];
 
                 clkp->parent = clk;
-                clk_register(clkp);
-                clk_enable(clkp);
+                ret |= clk_register(clkp);
         }
 
-        /*
-         * Now that we have the rest of the clocks registered, we need to
-         * force the parent clock to propagate so that these clocks will
-         * automatically figure out their rate. We cheat by handing the
-         * parent clock its current rate and forcing child propagation.
-         */
-        clk_set_rate(clk, clk_get_rate(clk));
-
         clk_put(clk);
 
-        return 0;
+        return ret;
 }
-
-arch_initcall(sh7780_clk_init);
-
diff --git a/arch/sh/kernel/cpu/sh4a/clock-sh7785.c b/arch/sh/kernel/cpu/sh4a/clock-sh7785.c
index 27fa81bef6a0..73abfbf2f16d 100644
--- a/arch/sh/kernel/cpu/sh4a/clock-sh7785.c
+++ b/arch/sh/kernel/cpu/sh4a/clock-sh7785.c
@@ -3,7 +3,7 @@
  *
  * SH7785 support for the clock framework
  *
- *  Copyright (C) 2007  Paul Mundt
+ *  Copyright (C) 2007 - 2009  Paul Mundt
  *
  * 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
@@ -11,152 +11,116 @@
  */
 #include <linux/init.h>
 #include <linux/kernel.h>
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/cpufreq.h>
 #include <asm/clock.h>
 #include <asm/freq.h>
-#include <asm/io.h>
-
-static int ifc_divisors[] = { 1, 2, 4, 6 };
-static int ufc_divisors[] = { 1, 1, 4, 6 };
-static int sfc_divisors[] = { 1, 1, 4, 6 };
-static int bfc_divisors[] = { 1, 1, 1, 1, 1, 12, 16, 18,
-                             24, 32, 36, 48, 1, 1, 1, 1 };
-static int mfc_divisors[] = { 1, 1, 4, 6 };
-static int pfc_divisors[] = { 1, 1, 1, 1, 1, 1, 1, 18,
-                              24, 32, 36, 48, 1, 1, 1, 1 };
-
-static void master_clk_init(struct clk *clk)
-{
-        clk->rate *= pfc_divisors[ctrl_inl(FRQMR1) & 0x000f];
-}
+#include <cpu/sh7785.h>
 
-static struct clk_ops sh7785_master_clk_ops = {
-        .init           = master_clk_init,
+/*
+ * Default rate for the root input clock, reset this with clk_set_rate()
+ * from the platform code.
+ */
+static struct clk extal_clk = {
+        .name           = "extal",
+        .id             = -1,
+        .rate           = 33333333,
 };
 
-static void module_clk_recalc(struct clk *clk)
+static unsigned long pll_recalc(struct clk *clk)
 {
-        int idx = (ctrl_inl(FRQMR1) & 0x000f);
-        clk->rate = clk->parent->rate / pfc_divisors[idx];
-}
+        int multiplier;
 
-static struct clk_ops sh7785_module_clk_ops = {
-        .recalc         = module_clk_recalc,
-};
+        multiplier = test_mode_pin(MODE_PIN4) ? 36 : 72;
 
-static void bus_clk_recalc(struct clk *clk)
-{
-        int idx = ((ctrl_inl(FRQMR1) >> 16) & 0x000f);
-        clk->rate = clk->parent->rate / bfc_divisors[idx];
+        return clk->parent->rate * multiplier;
 }
 
-static struct clk_ops sh7785_bus_clk_ops = {
-        .recalc         = bus_clk_recalc,
+static struct clk_ops pll_clk_ops = {
+        .recalc         = pll_recalc,
 };
 
-static void cpu_clk_recalc(struct clk *clk)
-{
-        int idx = ((ctrl_inl(FRQMR1) >> 28) & 0x0003);
-        clk->rate = clk->parent->rate / ifc_divisors[idx];
-}
-
-static struct clk_ops sh7785_cpu_clk_ops = {
-        .recalc         = cpu_clk_recalc,
+static struct clk pll_clk = {
+        .name           = "pll_clk",
+        .id             = -1,
+        .ops            = &pll_clk_ops,
+        .parent         = &extal_clk,
+        .flags          = CLK_ENABLE_ON_INIT,
 };
 
-static struct clk_ops *sh7785_clk_ops[] = {
-        &sh7785_master_clk_ops,
-        &sh7785_module_clk_ops,
-        &sh7785_bus_clk_ops,
-        &sh7785_cpu_clk_ops,
+static struct clk *clks[] = {
+        &extal_clk,
+        &pll_clk,
 };
 
-void __init arch_init_clk_ops(struct clk_ops **ops, int idx)
-{
-        if (idx < ARRAY_SIZE(sh7785_clk_ops))
-                *ops = sh7785_clk_ops[idx];
-}
-
-static void shyway_clk_recalc(struct clk *clk)
-{
-        int idx = ((ctrl_inl(FRQMR1) >> 20) & 0x0003);
-        clk->rate = clk->parent->rate / sfc_divisors[idx];
-}
+static unsigned int div2[] = { 1, 2, 4, 6, 8, 12, 16, 18,
+                               24, 32, 36, 48 };
 
-static struct clk_ops sh7785_shyway_clk_ops = {
-        .recalc         = shyway_clk_recalc,
+static struct clk_div_mult_table div4_table = {
+        .divisors = div2,
+        .nr_divisors = ARRAY_SIZE(div2),
 };
 
-static struct clk sh7785_shyway_clk = {
-        .name           = "shyway_clk",
-        .flags          = CLK_ALWAYS_ENABLED,
-        .ops            = &sh7785_shyway_clk_ops,
+enum { DIV4_I, DIV4_U, DIV4_SH, DIV4_B, DIV4_DDR, DIV4_GA,
+        DIV4_DU, DIV4_P, DIV4_NR };
+
+#define DIV4(_str, _bit, _mask, _flags) \
+  SH_CLK_DIV4(_str, &pll_clk, FRQMR1, _bit, _mask, _flags)
+
+struct clk div4_clks[DIV4_NR] = {
+        [DIV4_P] = DIV4("peripheral_clk", 0, 0x0f80, 0),
+        [DIV4_DU] = DIV4("du_clk", 4, 0x0ff0, 0),
+        [DIV4_GA] = DIV4("ga_clk", 8, 0x0030, 0),
+        [DIV4_DDR] = DIV4("ddr_clk", 12, 0x000c, CLK_ENABLE_ON_INIT),
+        [DIV4_B] = DIV4("bus_clk", 16, 0x0fe0, CLK_ENABLE_ON_INIT),
+        [DIV4_SH] = DIV4("shyway_clk", 20, 0x000c, CLK_ENABLE_ON_INIT),
+        [DIV4_U] = DIV4("umem_clk", 24, 0x000c, CLK_ENABLE_ON_INIT),
+        [DIV4_I] = DIV4("cpu_clk", 28, 0x000e, CLK_ENABLE_ON_INIT),
 };
 
-static void ddr_clk_recalc(struct clk *clk)
-{
-        int idx = ((ctrl_inl(FRQMR1) >> 12) & 0x0003);
-        clk->rate = clk->parent->rate / mfc_divisors[idx];
-}
-
-static struct clk_ops sh7785_ddr_clk_ops = {
-        .recalc         = ddr_clk_recalc,
-};
-
-static struct clk sh7785_ddr_clk = {
-        .name           = "ddr_clk",
-        .flags          = CLK_ALWAYS_ENABLED,
-        .ops            = &sh7785_ddr_clk_ops,
-};
-
-static void ram_clk_recalc(struct clk *clk)
-{
-        int idx = ((ctrl_inl(FRQMR1) >> 24) & 0x0003);
-        clk->rate = clk->parent->rate / ufc_divisors[idx];
-}
-
-static struct clk_ops sh7785_ram_clk_ops = {
-        .recalc         = ram_clk_recalc,
+#define MSTPCR0         0xffc80030
+#define MSTPCR1         0xffc80034
+
+static struct clk mstp_clks[] = {
+        /* MSTPCR0 */
+        SH_CLK_MSTP32("scif_fck", 5, &div4_clks[DIV4_P], MSTPCR0, 29, 0),
+        SH_CLK_MSTP32("scif_fck", 4, &div4_clks[DIV4_P], MSTPCR0, 28, 0),
+        SH_CLK_MSTP32("scif_fck", 3, &div4_clks[DIV4_P], MSTPCR0, 27, 0),
+        SH_CLK_MSTP32("scif_fck", 2, &div4_clks[DIV4_P], MSTPCR0, 26, 0),
+        SH_CLK_MSTP32("scif_fck", 1, &div4_clks[DIV4_P], MSTPCR0, 25, 0),
+        SH_CLK_MSTP32("scif_fck", 0, &div4_clks[DIV4_P], MSTPCR0, 24, 0),
+        SH_CLK_MSTP32("ssi_fck", 1, &div4_clks[DIV4_P], MSTPCR0, 21, 0),
+        SH_CLK_MSTP32("ssi_fck", 0, &div4_clks[DIV4_P], MSTPCR0, 20, 0),
+        SH_CLK_MSTP32("hac_fck", 1, &div4_clks[DIV4_P], MSTPCR0, 17, 0),
+        SH_CLK_MSTP32("hac_fck", 0, &div4_clks[DIV4_P], MSTPCR0, 16, 0),
+        SH_CLK_MSTP32("mmcif_fck", -1, &div4_clks[DIV4_P], MSTPCR0, 13, 0),
+        SH_CLK_MSTP32("flctl_fck", -1, &div4_clks[DIV4_P], MSTPCR0, 12, 0),
+        SH_CLK_MSTP32("tmu345_fck", -1, &div4_clks[DIV4_P], MSTPCR0, 9, 0),
+        SH_CLK_MSTP32("tmu012_fck", -1, &div4_clks[DIV4_P], MSTPCR0, 8, 0),
+        SH_CLK_MSTP32("siof_fck", -1, &div4_clks[DIV4_P], MSTPCR0, 3, 0),
+        SH_CLK_MSTP32("hspi_fck", -1, &div4_clks[DIV4_P], MSTPCR0, 2, 0),
+
+        /* MSTPCR1 */
+        SH_CLK_MSTP32("hudi_fck", -1, NULL, MSTPCR1, 19, 0),
+        SH_CLK_MSTP32("ubc_fck", -1, NULL, MSTPCR1, 17, 0),
+        SH_CLK_MSTP32("dmac_11_6_fck", -1, NULL, MSTPCR1, 5, 0),
+        SH_CLK_MSTP32("dmac_5_0_fck", -1, NULL, MSTPCR1, 4, 0),
+        SH_CLK_MSTP32("gdta_fck", -1, NULL, MSTPCR1, 0, 0),
 };
 
-static struct clk sh7785_ram_clk = {
-        .name           = "ram_clk",
-        .flags          = CLK_ALWAYS_ENABLED,
-        .ops            = &sh7785_ram_clk_ops,
-};
-
-/*
- * Additional SH7785-specific on-chip clocks that aren't already part of the
- * clock framework
- */
-static struct clk *sh7785_onchip_clocks[] = {
-        &sh7785_shyway_clk,
-        &sh7785_ddr_clk,
-        &sh7785_ram_clk,
-};
-
-static int __init sh7785_clk_init(void)
+int __init arch_clk_init(void)
 {
-        struct clk *clk = clk_get(NULL, "master_clk");
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(sh7785_onchip_clocks); i++) {
-                struct clk *clkp = sh7785_onchip_clocks[i];
-
-                clkp->parent = clk;
-                clk_register(clkp);
-                clk_enable(clkp);
-        }
+        int i, ret = 0;
 
-        /*
-         * Now that we have the rest of the clocks registered, we need to
-         * force the parent clock to propagate so that these clocks will
-         * automatically figure out their rate. We cheat by handing the
-         * parent clock its current rate and forcing child propagation.
-         */
-        clk_set_rate(clk, clk_get_rate(clk));
+        for (i = 0; i < ARRAY_SIZE(clks); i++)
+                ret |= clk_register(clks[i]);
 
-        clk_put(clk);
+        if (!ret)
+                ret = sh_clk_div4_register(div4_clks, ARRAY_SIZE(div4_clks),
+                                           &div4_table);
+        if (!ret)
+                ret = sh_clk_mstp32_register(mstp_clks, ARRAY_SIZE(mstp_clks));
 
-        return 0;
+        return ret;
 }
-arch_initcall(sh7785_clk_init);
diff --git a/arch/sh/kernel/cpu/sh4a/clock-sh7786.c b/arch/sh/kernel/cpu/sh4a/clock-sh7786.c
index f84a9c134471..a0e8869071ac 100644
--- a/arch/sh/kernel/cpu/sh4a/clock-sh7786.c
+++ b/arch/sh/kernel/cpu/sh4a/clock-sh7786.c
@@ -36,30 +36,30 @@ static struct clk_ops sh7786_master_clk_ops = {
         .init           = master_clk_init,
 };
 
-static void module_clk_recalc(struct clk *clk)
+static unsigned long module_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inl(FRQMR1) & 0x000f);
-        clk->rate = clk->parent->rate / pfc_divisors[idx];
+        return clk->parent->rate / pfc_divisors[idx];
 }
 
 static struct clk_ops sh7786_module_clk_ops = {
         .recalc         = module_clk_recalc,
 };
 
-static void bus_clk_recalc(struct clk *clk)
+static unsigned long bus_clk_recalc(struct clk *clk)
 {
         int idx = ((ctrl_inl(FRQMR1) >> 16) & 0x000f);
-        clk->rate = clk->parent->rate / bfc_divisors[idx];
+        return clk->parent->rate / bfc_divisors[idx];
 }
 
 static struct clk_ops sh7786_bus_clk_ops = {
         .recalc         = bus_clk_recalc,
 };
 
-static void cpu_clk_recalc(struct clk *clk)
+static unsigned long cpu_clk_recalc(struct clk *clk)
 {
         int idx = ((ctrl_inl(FRQMR1) >> 28) & 0x0003);
-        clk->rate = clk->parent->rate / ifc_divisors[idx];
+        return clk->parent->rate / ifc_divisors[idx];
 }
 
 static struct clk_ops sh7786_cpu_clk_ops = {
@@ -79,10 +79,10 @@ void __init arch_init_clk_ops(struct clk_ops **ops, int idx)
                 *ops = sh7786_clk_ops[idx];
 }
 
-static void shyway_clk_recalc(struct clk *clk)
+static unsigned long shyway_clk_recalc(struct clk *clk)
 {
         int idx = ((ctrl_inl(FRQMR1) >> 20) & 0x0003);
-        clk->rate = clk->parent->rate / sfc_divisors[idx];
+        return clk->parent->rate / sfc_divisors[idx];
 }
 
 static struct clk_ops sh7786_shyway_clk_ops = {
@@ -91,14 +91,14 @@ static struct clk_ops sh7786_shyway_clk_ops = {
 
 static struct clk sh7786_shyway_clk = {
         .name           = "shyway_clk",
-        .flags          = CLK_ALWAYS_ENABLED,
+        .flags          = CLK_ENABLE_ON_INIT,
         .ops            = &sh7786_shyway_clk_ops,
 };
 
-static void ddr_clk_recalc(struct clk *clk)
+static unsigned long ddr_clk_recalc(struct clk *clk)
 {
         int idx = ((ctrl_inl(FRQMR1) >> 12) & 0x0003);
-        clk->rate = clk->parent->rate / mfc_divisors[idx];
+        return clk->parent->rate / mfc_divisors[idx];
 }
 
 static struct clk_ops sh7786_ddr_clk_ops = {
@@ -107,7 +107,7 @@ static struct clk_ops sh7786_ddr_clk_ops = {
 
 static struct clk sh7786_ddr_clk = {
         .name           = "ddr_clk",
-        .flags          = CLK_ALWAYS_ENABLED,
+        .flags          = CLK_ENABLE_ON_INIT,
         .ops            = &sh7786_ddr_clk_ops,
 };
 
@@ -120,29 +120,22 @@ static struct clk *sh7786_onchip_clocks[] = {
         &sh7786_ddr_clk,
 };
 
-static int __init sh7786_clk_init(void)
+int __init arch_clk_init(void)
 {
-        struct clk *clk = clk_get(NULL, "master_clk");
-        int i;
+        struct clk *clk;
+        int i, ret = 0;
 
+        cpg_clk_init();
+
+        clk = clk_get(NULL, "master_clk");
         for (i = 0; i < ARRAY_SIZE(sh7786_onchip_clocks); i++) {
                 struct clk *clkp = sh7786_onchip_clocks[i];
 
                 clkp->parent = clk;
-                clk_register(clkp);
-                clk_enable(clkp);
+                ret |= clk_register(clkp);
         }
 
-        /*
-         * Now that we have the rest of the clocks registered, we need to
-         * force the parent clock to propagate so that these clocks will
-         * automatically figure out their rate. We cheat by handing the
-         * parent clock its current rate and forcing child propagation.
-         */
-        clk_set_rate(clk, clk_get_rate(clk));
-
         clk_put(clk);
 
-        return 0;
+        return ret;
 }
-arch_initcall(sh7786_clk_init);
diff --git a/arch/sh/kernel/cpu/sh4a/clock-shx3.c b/arch/sh/kernel/cpu/sh4a/clock-shx3.c
index c630b29e06a8..23c27d32d982 100644
--- a/arch/sh/kernel/cpu/sh4a/clock-shx3.c
+++ b/arch/sh/kernel/cpu/sh4a/clock-shx3.c
@@ -40,30 +40,30 @@ static struct clk_ops shx3_master_clk_ops = {
         .init           = master_clk_init,
 };
 
-static void module_clk_recalc(struct clk *clk)
+static unsigned long module_clk_recalc(struct clk *clk)
 {
         int idx = ((ctrl_inl(FRQCR) >> PFC_POS) & PFC_MSK);
-        clk->rate = clk->parent->rate / pfc_divisors[idx];
+        return clk->parent->rate / pfc_divisors[idx];
 }
 
 static struct clk_ops shx3_module_clk_ops = {
         .recalc         = module_clk_recalc,
 };
 
-static void bus_clk_recalc(struct clk *clk)
+static unsigned long bus_clk_recalc(struct clk *clk)
 {
         int idx = ((ctrl_inl(FRQCR) >> BFC_POS) & BFC_MSK);
-        clk->rate = clk->parent->rate / bfc_divisors[idx];
+        return clk->parent->rate / bfc_divisors[idx];
 }
 
 static struct clk_ops shx3_bus_clk_ops = {
         .recalc         = bus_clk_recalc,
 };
 
-static void cpu_clk_recalc(struct clk *clk)
+static unsigned long cpu_clk_recalc(struct clk *clk)
 {
         int idx = ((ctrl_inl(FRQCR) >> IFC_POS) & IFC_MSK);
-        clk->rate = clk->parent->rate / ifc_divisors[idx];
+        return clk->parent->rate / ifc_divisors[idx];
 }
 
 static struct clk_ops shx3_cpu_clk_ops = {
@@ -83,10 +83,10 @@ void __init arch_init_clk_ops(struct clk_ops **ops, int idx)
                 *ops = shx3_clk_ops[idx];
 }
 
-static void shyway_clk_recalc(struct clk *clk)
+static unsigned long shyway_clk_recalc(struct clk *clk)
 {
         int idx = ((ctrl_inl(FRQCR) >> CFC_POS) & CFC_MSK);
-        clk->rate = clk->parent->rate / cfc_divisors[idx];
+        return clk->parent->rate / cfc_divisors[idx];
 }
 
 static struct clk_ops shx3_shyway_clk_ops = {
@@ -95,7 +95,7 @@ static struct clk_ops shx3_shyway_clk_ops = {
 
 static struct clk shx3_shyway_clk = {
         .name           = "shyway_clk",
-        .flags          = CLK_ALWAYS_ENABLED,
+        .flags          = CLK_ENABLE_ON_INIT,
         .ops            = &shx3_shyway_clk_ops,
 };
 
@@ -107,29 +107,22 @@ static struct clk *shx3_onchip_clocks[] = {
         &shx3_shyway_clk,
 };
 
-static int __init shx3_clk_init(void)
+int __init arch_clk_init(void)
 {
-        struct clk *clk = clk_get(NULL, "master_clk");
-        int i;
+        struct clk *clk;
+        int i, ret = 0;
 
+        cpg_clk_init();
+
+        clk = clk_get(NULL, "master_clk");
         for (i = 0; i < ARRAY_SIZE(shx3_onchip_clocks); i++) {
                 struct clk *clkp = shx3_onchip_clocks[i];
 
                 clkp->parent = clk;
-                clk_register(clkp);
-                clk_enable(clkp);
+                ret |= clk_register(clkp);
         }
 
-        /*
-         * Now that we have the rest of the clocks registered, we need to
-         * force the parent clock to propagate so that these clocks will
-         * automatically figure out their rate. We cheat by handing the
-         * parent clock its current rate and forcing child propagation.
-         */
-        clk_set_rate(clk, clk_get_rate(clk));
-
         clk_put(clk);
 
-        return 0;
+        return ret;
 }
-arch_initcall(shx3_clk_init);
diff --git a/arch/sh/kernel/cpu/sh4a/pinmux-sh7724.c b/arch/sh/kernel/cpu/sh4a/pinmux-sh7724.c
new file mode 100644
index 000000000000..1af0f9586379
--- /dev/null
+++ b/arch/sh/kernel/cpu/sh4a/pinmux-sh7724.c
@@ -0,0 +1,2230 @@
+/*
+ * SH7724 Pinmux
+ *
+ * Copyright (C) 2009 Renesas Solutions Corp.
+ *
+ * Kuninori Morimoto <morimoto.kuninori@renesas.com>
+ *
+ * Based on SH7723 Pinmux
+ *  Copyright (C) 2008  Magnus Damm
+ *
+ * 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.
+ */
+
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/gpio.h>
+#include <cpu/sh7724.h>
+
+enum {
+        PINMUX_RESERVED = 0,
+
+        PINMUX_DATA_BEGIN,
+        PTA7_DATA, PTA6_DATA, PTA5_DATA, PTA4_DATA,
+        PTA3_DATA, PTA2_DATA, PTA1_DATA, PTA0_DATA,
+        PTB7_DATA, PTB6_DATA, PTB5_DATA, PTB4_DATA,
+        PTB3_DATA, PTB2_DATA, PTB1_DATA, PTB0_DATA,
+        PTC7_DATA, PTC6_DATA, PTC5_DATA, PTC4_DATA,
+        PTC3_DATA, PTC2_DATA, PTC1_DATA, PTC0_DATA,
+        PTD7_DATA, PTD6_DATA, PTD5_DATA, PTD4_DATA,
+        PTD3_DATA, PTD2_DATA, PTD1_DATA, PTD0_DATA,
+        PTE7_DATA, PTE6_DATA, PTE5_DATA, PTE4_DATA,
+        PTE3_DATA, PTE2_DATA, PTE1_DATA, PTE0_DATA,
+        PTF7_DATA, PTF6_DATA, PTF5_DATA, PTF4_DATA,
+        PTF3_DATA, PTF2_DATA, PTF1_DATA, PTF0_DATA,
+                              PTG5_DATA, PTG4_DATA,
+        PTG3_DATA, PTG2_DATA, PTG1_DATA, PTG0_DATA,
+        PTH7_DATA, PTH6_DATA, PTH5_DATA, PTH4_DATA,
+        PTH3_DATA, PTH2_DATA, PTH1_DATA, PTH0_DATA,
+        PTJ7_DATA, PTJ6_DATA, PTJ5_DATA,
+        PTJ3_DATA, PTJ2_DATA, PTJ1_DATA, PTJ0_DATA,
+        PTK7_DATA, PTK6_DATA, PTK5_DATA, PTK4_DATA,
+        PTK3_DATA, PTK2_DATA, PTK1_DATA, PTK0_DATA,
+        PTL7_DATA, PTL6_DATA, PTL5_DATA, PTL4_DATA,
+        PTL3_DATA, PTL2_DATA, PTL1_DATA, PTL0_DATA,
+        PTM7_DATA, PTM6_DATA, PTM5_DATA, PTM4_DATA,
+        PTM3_DATA, PTM2_DATA, PTM1_DATA, PTM0_DATA,
+        PTN7_DATA, PTN6_DATA, PTN5_DATA, PTN4_DATA,
+        PTN3_DATA, PTN2_DATA, PTN1_DATA, PTN0_DATA,
+        PTQ7_DATA, PTQ6_DATA, PTQ5_DATA, PTQ4_DATA,
+        PTQ3_DATA, PTQ2_DATA, PTQ1_DATA, PTQ0_DATA,
+        PTR7_DATA, PTR6_DATA, PTR5_DATA, PTR4_DATA,
+        PTR3_DATA, PTR2_DATA, PTR1_DATA, PTR0_DATA,
+                   PTS6_DATA, PTS5_DATA, PTS4_DATA,
+        PTS3_DATA, PTS2_DATA, PTS1_DATA, PTS0_DATA,
+        PTT7_DATA, PTT6_DATA, PTT5_DATA, PTT4_DATA,
+        PTT3_DATA, PTT2_DATA, PTT1_DATA, PTT0_DATA,
+        PTU7_DATA, PTU6_DATA, PTU5_DATA, PTU4_DATA,
+        PTU3_DATA, PTU2_DATA, PTU1_DATA, PTU0_DATA,
+        PTV7_DATA, PTV6_DATA, PTV5_DATA, PTV4_DATA,
+        PTV3_DATA, PTV2_DATA, PTV1_DATA, PTV0_DATA,
+        PTW7_DATA, PTW6_DATA, PTW5_DATA, PTW4_DATA,
+        PTW3_DATA, PTW2_DATA, PTW1_DATA, PTW0_DATA,
+        PTX7_DATA, PTX6_DATA, PTX5_DATA, PTX4_DATA,
+        PTX3_DATA, PTX2_DATA, PTX1_DATA, PTX0_DATA,
+        PTY7_DATA, PTY6_DATA, PTY5_DATA, PTY4_DATA,
+        PTY3_DATA, PTY2_DATA, PTY1_DATA, PTY0_DATA,
+        PTZ7_DATA, PTZ6_DATA, PTZ5_DATA, PTZ4_DATA,
+        PTZ3_DATA, PTZ2_DATA, PTZ1_DATA, PTZ0_DATA,
+        PINMUX_DATA_END,
+
+        PINMUX_INPUT_BEGIN,
+        PTA7_IN, PTA6_IN, PTA5_IN, PTA4_IN,
+        PTA3_IN, PTA2_IN, PTA1_IN, PTA0_IN,
+        PTB7_IN, PTB6_IN, PTB5_IN, PTB4_IN,
+        PTB3_IN, PTB2_IN, PTB1_IN, PTB0_IN,
+        PTC7_IN, PTC6_IN, PTC5_IN, PTC4_IN,
+        PTC3_IN, PTC2_IN, PTC1_IN, PTC0_IN,
+        PTD7_IN, PTD6_IN, PTD5_IN, PTD4_IN,
+        PTD3_IN, PTD2_IN, PTD1_IN, PTD0_IN,
+        PTE7_IN, PTE6_IN, PTE5_IN, PTE4_IN,
+        PTE3_IN, PTE2_IN, PTE1_IN, PTE0_IN,
+        PTF7_IN, PTF6_IN, PTF5_IN, PTF4_IN,
+        PTF3_IN, PTF2_IN, PTF1_IN, PTF0_IN,
+        PTH7_IN, PTH6_IN, PTH5_IN, PTH4_IN,
+        PTH3_IN, PTH2_IN, PTH1_IN, PTH0_IN,
+        PTJ3_IN, PTJ2_IN, PTJ1_IN, PTJ0_IN,
+        PTK7_IN, PTK6_IN, PTK5_IN, PTK4_IN,
+        PTK3_IN, PTK2_IN, PTK1_IN, PTK0_IN,
+        PTL7_IN, PTL6_IN, PTL5_IN, PTL4_IN,
+        PTL3_IN, PTL2_IN, PTL1_IN, PTL0_IN,
+        PTM7_IN, PTM6_IN, PTM5_IN, PTM4_IN,
+        PTM3_IN, PTM2_IN, PTM1_IN, PTM0_IN,
+        PTN7_IN, PTN6_IN, PTN5_IN, PTN4_IN,
+        PTN3_IN, PTN2_IN, PTN1_IN, PTN0_IN,
+        PTQ7_IN, PTQ6_IN, PTQ5_IN, PTQ4_IN,
+        PTQ3_IN, PTQ2_IN, PTQ1_IN, PTQ0_IN,
+        PTR7_IN, PTR6_IN, PTR5_IN, PTR4_IN,
+        PTR3_IN, PTR2_IN, PTR1_IN, PTR0_IN,
+                 PTS6_IN, PTS5_IN, PTS4_IN,
+        PTS3_IN, PTS2_IN, PTS1_IN, PTS0_IN,
+        PTT7_IN, PTT6_IN, PTT5_IN, PTT4_IN,
+        PTT3_IN, PTT2_IN, PTT1_IN, PTT0_IN,
+        PTU7_IN, PTU6_IN, PTU5_IN, PTU4_IN,
+        PTU3_IN, PTU2_IN, PTU1_IN, PTU0_IN,
+        PTV7_IN, PTV6_IN, PTV5_IN, PTV4_IN,
+        PTV3_IN, PTV2_IN, PTV1_IN, PTV0_IN,
+        PTW7_IN, PTW6_IN, PTW5_IN, PTW4_IN,
+        PTW3_IN, PTW2_IN, PTW1_IN, PTW0_IN,
+        PTX7_IN, PTX6_IN, PTX5_IN, PTX4_IN,
+        PTX3_IN, PTX2_IN, PTX1_IN, PTX0_IN,
+        PTY7_IN, PTY6_IN, PTY5_IN, PTY4_IN,
+        PTY3_IN, PTY2_IN, PTY1_IN, PTY0_IN,
+        PTZ7_IN, PTZ6_IN, PTZ5_IN, PTZ4_IN,
+        PTZ3_IN, PTZ2_IN, PTZ1_IN, PTZ0_IN,
+        PINMUX_INPUT_END,
+
+        PINMUX_INPUT_PULLUP_BEGIN,
+        PTA7_IN_PU, PTA6_IN_PU, PTA5_IN_PU, PTA4_IN_PU,
+        PTA3_IN_PU, PTA2_IN_PU, PTA1_IN_PU, PTA0_IN_PU,
+        PTB7_IN_PU, PTB6_IN_PU, PTB5_IN_PU, PTB4_IN_PU,
+        PTB3_IN_PU, PTB2_IN_PU, PTB1_IN_PU, PTB0_IN_PU,
+        PTC7_IN_PU, PTC6_IN_PU, PTC5_IN_PU, PTC4_IN_PU,
+        PTC3_IN_PU, PTC2_IN_PU, PTC1_IN_PU, PTC0_IN_PU,
+        PTD7_IN_PU, PTD6_IN_PU, PTD5_IN_PU, PTD4_IN_PU,
+        PTD3_IN_PU, PTD2_IN_PU, PTD1_IN_PU, PTD0_IN_PU,
+        PTE7_IN_PU, PTE6_IN_PU, PTE5_IN_PU, PTE4_IN_PU,
+        PTE3_IN_PU, PTE2_IN_PU, PTE1_IN_PU, PTE0_IN_PU,
+        PTF7_IN_PU, PTF6_IN_PU, PTF5_IN_PU, PTF4_IN_PU,
+        PTF3_IN_PU, PTF2_IN_PU, PTF1_IN_PU, PTF0_IN_PU,
+        PTH7_IN_PU, PTH6_IN_PU, PTH5_IN_PU, PTH4_IN_PU,
+        PTH3_IN_PU, PTH2_IN_PU, PTH1_IN_PU, PTH0_IN_PU,
+        PTJ3_IN_PU, PTJ2_IN_PU, PTJ1_IN_PU, PTJ0_IN_PU,
+        PTK7_IN_PU, PTK6_IN_PU, PTK5_IN_PU, PTK4_IN_PU,
+        PTK3_IN_PU, PTK2_IN_PU, PTK1_IN_PU, PTK0_IN_PU,
+        PTL7_IN_PU, PTL6_IN_PU, PTL5_IN_PU, PTL4_IN_PU,
+        PTL3_IN_PU, PTL2_IN_PU, PTL1_IN_PU, PTL0_IN_PU,
+        PTM7_IN_PU, PTM6_IN_PU, PTM5_IN_PU, PTM4_IN_PU,
+        PTM3_IN_PU, PTM2_IN_PU, PTM1_IN_PU, PTM0_IN_PU,
+        PTN7_IN_PU, PTN6_IN_PU, PTN5_IN_PU, PTN4_IN_PU,
+        PTN3_IN_PU, PTN2_IN_PU, PTN1_IN_PU, PTN0_IN_PU,
+        PTQ7_IN_PU, PTQ6_IN_PU, PTQ5_IN_PU, PTQ4_IN_PU,
+        PTQ3_IN_PU, PTQ2_IN_PU, PTQ1_IN_PU, PTQ0_IN_PU,
+        PTR7_IN_PU, PTR6_IN_PU, PTR5_IN_PU, PTR4_IN_PU,
+        PTR3_IN_PU, PTR2_IN_PU, PTR1_IN_PU, PTR0_IN_PU,
+                    PTS6_IN_PU, PTS5_IN_PU, PTS4_IN_PU,
+        PTS3_IN_PU, PTS2_IN_PU, PTS1_IN_PU, PTS0_IN_PU,
+        PTT7_IN_PU, PTT6_IN_PU, PTT5_IN_PU, PTT4_IN_PU,
+        PTT3_IN_PU, PTT2_IN_PU, PTT1_IN_PU, PTT0_IN_PU,
+        PTU7_IN_PU, PTU6_IN_PU, PTU5_IN_PU, PTU4_IN_PU,
+        PTU3_IN_PU, PTU2_IN_PU, PTU1_IN_PU, PTU0_IN_PU,
+        PTV7_IN_PU, PTV6_IN_PU, PTV5_IN_PU, PTV4_IN_PU,
+        PTV3_IN_PU, PTV2_IN_PU, PTV1_IN_PU, PTV0_IN_PU,
+        PTW7_IN_PU, PTW6_IN_PU, PTW5_IN_PU, PTW4_IN_PU,
+        PTW3_IN_PU, PTW2_IN_PU, PTW1_IN_PU, PTW0_IN_PU,
+        PTX7_IN_PU, PTX6_IN_PU, PTX5_IN_PU, PTX4_IN_PU,
+        PTX3_IN_PU, PTX2_IN_PU, PTX1_IN_PU, PTX0_IN_PU,
+        PTY7_IN_PU, PTY6_IN_PU, PTY5_IN_PU, PTY4_IN_PU,
+        PTY3_IN_PU, PTY2_IN_PU, PTY1_IN_PU, PTY0_IN_PU,
+        PTZ7_IN_PU, PTZ6_IN_PU, PTZ5_IN_PU, PTZ4_IN_PU,
+        PTZ3_IN_PU, PTZ2_IN_PU, PTZ1_IN_PU, PTZ0_IN_PU,
+        PINMUX_INPUT_PULLUP_END,
+
+        PINMUX_OUTPUT_BEGIN,
+        PTA7_OUT, PTA6_OUT, PTA5_OUT, PTA4_OUT,
+        PTA3_OUT, PTA2_OUT, PTA1_OUT, PTA0_OUT,
+        PTB7_OUT, PTB6_OUT, PTB5_OUT, PTB4_OUT,
+        PTB3_OUT, PTB2_OUT, PTB1_OUT, PTB0_OUT,
+        PTC7_OUT, PTC6_OUT, PTC5_OUT, PTC4_OUT,
+        PTC3_OUT, PTC2_OUT, PTC1_OUT, PTC0_OUT,
+        PTD7_OUT, PTD6_OUT, PTD5_OUT, PTD4_OUT,
+        PTD3_OUT, PTD2_OUT, PTD1_OUT, PTD0_OUT,
+        PTE7_OUT, PTE6_OUT, PTE5_OUT, PTE4_OUT,
+        PTE3_OUT, PTE2_OUT, PTE1_OUT, PTE0_OUT,
+        PTF7_OUT, PTF6_OUT, PTF5_OUT, PTF4_OUT,
+        PTF3_OUT, PTF2_OUT, PTF1_OUT, PTF0_OUT,
+                            PTG5_OUT, PTG4_OUT,
+        PTG3_OUT, PTG2_OUT, PTG1_OUT, PTG0_OUT,
+        PTH7_OUT, PTH6_OUT, PTH5_OUT, PTH4_OUT,
+        PTH3_OUT, PTH2_OUT, PTH1_OUT, PTH0_OUT,
+        PTJ7_OUT, PTJ6_OUT, PTJ5_OUT,
+        PTJ3_OUT, PTJ2_OUT, PTJ1_OUT, PTJ0_OUT,
+        PTK7_OUT, PTK6_OUT, PTK5_OUT, PTK4_OUT,
+        PTK3_OUT, PTK2_OUT, PTK1_OUT, PTK0_OUT,
+        PTL7_OUT, PTL6_OUT, PTL5_OUT, PTL4_OUT,
+        PTL3_OUT, PTL2_OUT, PTL1_OUT, PTL0_OUT,
+        PTM7_OUT, PTM6_OUT, PTM5_OUT, PTM4_OUT,
+        PTM3_OUT, PTM2_OUT, PTM1_OUT, PTM0_OUT,
+        PTN7_OUT, PTN6_OUT, PTN5_OUT, PTN4_OUT,
+        PTN3_OUT, PTN2_OUT, PTN1_OUT, PTN0_OUT,
+        PTQ7_OUT, PTQ6_OUT, PTQ5_OUT, PTQ4_OUT,
+        PTQ3_OUT, PTQ2_OUT, PTQ1_OUT, PTQ0_OUT,
+        PTR7_OUT, PTR6_OUT, PTR5_OUT, PTR4_OUT,
+                            PTR1_OUT, PTR0_OUT,
+                  PTS6_OUT, PTS5_OUT, PTS4_OUT,
+        PTS3_OUT, PTS2_OUT, PTS1_OUT, PTS0_OUT,
+        PTT7_OUT, PTT6_OUT, PTT5_OUT, PTT4_OUT,
+        PTT3_OUT, PTT2_OUT, PTT1_OUT, PTT0_OUT,
+        PTU7_OUT, PTU6_OUT, PTU5_OUT, PTU4_OUT,
+        PTU3_OUT, PTU2_OUT, PTU1_OUT, PTU0_OUT,
+        PTV7_OUT, PTV6_OUT, PTV5_OUT, PTV4_OUT,
+        PTV3_OUT, PTV2_OUT, PTV1_OUT, PTV0_OUT,
+        PTW7_OUT, PTW6_OUT, PTW5_OUT, PTW4_OUT,
+        PTW3_OUT, PTW2_OUT, PTW1_OUT, PTW0_OUT,
+        PTX7_OUT, PTX6_OUT, PTX5_OUT, PTX4_OUT,
+        PTX3_OUT, PTX2_OUT, PTX1_OUT, PTX0_OUT,
+        PTY7_OUT, PTY6_OUT, PTY5_OUT, PTY4_OUT,
+        PTY3_OUT, PTY2_OUT, PTY1_OUT, PTY0_OUT,
+        PTZ7_OUT, PTZ6_OUT, PTZ5_OUT, PTZ4_OUT,
+        PTZ3_OUT, PTZ2_OUT, PTZ1_OUT, PTZ0_OUT,
+        PINMUX_OUTPUT_END,
+
+        PINMUX_FUNCTION_BEGIN,
+        PTA7_FN, PTA6_FN, PTA5_FN, PTA4_FN,
+        PTA3_FN, PTA2_FN, PTA1_FN, PTA0_FN,
+        PTB7_FN, PTB6_FN, PTB5_FN, PTB4_FN,
+        PTB3_FN, PTB2_FN, PTB1_FN, PTB0_FN,
+        PTC7_FN, PTC6_FN, PTC5_FN, PTC4_FN,
+        PTC3_FN, PTC2_FN, PTC1_FN, PTC0_FN,
+        PTD7_FN, PTD6_FN, PTD5_FN, PTD4_FN,
+        PTD3_FN, PTD2_FN, PTD1_FN, PTD0_FN,
+        PTE7_FN, PTE6_FN, PTE5_FN, PTE4_FN,
+        PTE3_FN, PTE2_FN, PTE1_FN, PTE0_FN,
+        PTF7_FN, PTF6_FN, PTF5_FN, PTF4_FN,
+        PTF3_FN, PTF2_FN, PTF1_FN, PTF0_FN,
+                          PTG5_FN, PTG4_FN,
+        PTG3_FN, PTG2_FN, PTG1_FN, PTG0_FN,
+        PTH7_FN, PTH6_FN, PTH5_FN, PTH4_FN,
+        PTH3_FN, PTH2_FN, PTH1_FN, PTH0_FN,
+        PTJ7_FN, PTJ6_FN, PTJ5_FN,
+        PTJ3_FN, PTJ2_FN, PTJ1_FN, PTJ0_FN,
+        PTK7_FN, PTK6_FN, PTK5_FN, PTK4_FN,
+        PTK3_FN, PTK2_FN, PTK1_FN, PTK0_FN,
+        PTL7_FN, PTL6_FN, PTL5_FN, PTL4_FN,
+        PTL3_FN, PTL2_FN, PTL1_FN, PTL0_FN,
+        PTM7_FN, PTM6_FN, PTM5_FN, PTM4_FN,
+        PTM3_FN, PTM2_FN, PTM1_FN, PTM0_FN,
+        PTN7_FN, PTN6_FN, PTN5_FN, PTN4_FN,
+        PTN3_FN, PTN2_FN, PTN1_FN, PTN0_FN,
+        PTQ7_FN, PTQ6_FN, PTQ5_FN, PTQ4_FN,
+        PTQ3_FN, PTQ2_FN, PTQ1_FN, PTQ0_FN,
+        PTR7_FN, PTR6_FN, PTR5_FN, PTR4_FN,
+        PTR3_FN, PTR2_FN, PTR1_FN, PTR0_FN,
+                 PTS6_FN, PTS5_FN, PTS4_FN,
+        PTS3_FN, PTS2_FN, PTS1_FN, PTS0_FN,
+        PTT7_FN, PTT6_FN, PTT5_FN, PTT4_FN,
+        PTT3_FN, PTT2_FN, PTT1_FN, PTT0_FN,
+        PTU7_FN, PTU6_FN, PTU5_FN, PTU4_FN,
+        PTU3_FN, PTU2_FN, PTU1_FN, PTU0_FN,
+        PTV7_FN, PTV6_FN, PTV5_FN, PTV4_FN,
+        PTV3_FN, PTV2_FN, PTV1_FN, PTV0_FN,
+        PTW7_FN, PTW6_FN, PTW5_FN, PTW4_FN,
+        PTW3_FN, PTW2_FN, PTW1_FN, PTW0_FN,
+        PTX7_FN, PTX6_FN, PTX5_FN, PTX4_FN,
+        PTX3_FN, PTX2_FN, PTX1_FN, PTX0_FN,
+        PTY7_FN, PTY6_FN, PTY5_FN, PTY4_FN,
+        PTY3_FN, PTY2_FN, PTY1_FN, PTY0_FN,
+        PTZ7_FN, PTZ6_FN, PTZ5_FN, PTZ4_FN,
+        PTZ3_FN, PTZ2_FN, PTZ1_FN, PTZ0_FN,
+
+
+        PSA15_0, PSA15_1,
+        PSA14_0, PSA14_1,
+        PSA13_0, PSA13_1,
+        PSA12_0, PSA12_1,
+        PSA10_0, PSA10_1,
+        PSA9_0,  PSA9_1,
+        PSA8_0,  PSA8_1,
+        PSA7_0,  PSA7_1,
+        PSA6_0,  PSA6_1,
+        PSA5_0,  PSA5_1,
+        PSA3_0,  PSA3_1,
+        PSA2_0,  PSA2_1,
+        PSA1_0,  PSA1_1,
+        PSA0_0,  PSA0_1,
+
+        PSB14_0, PSB14_1,
+        PSB13_0, PSB13_1,
+        PSB12_0, PSB12_1,
+        PSB11_0, PSB11_1,
+        PSB10_0, PSB10_1,
+        PSB9_0,  PSB9_1,
+        PSB8_0,  PSB8_1,
+        PSB7_0,  PSB7_1,
+        PSB6_0,  PSB6_1,
+        PSB5_0,  PSB5_1,
+        PSB4_0,  PSB4_1,
+        PSB3_0,  PSB3_1,
+        PSB2_0,  PSB2_1,
+        PSB1_0,  PSB1_1,
+        PSB0_0,  PSB0_1,
+
+        PSC15_0, PSC15_1,
+        PSC14_0, PSC14_1,
+        PSC13_0, PSC13_1,
+        PSC12_0, PSC12_1,
+        PSC11_0, PSC11_1,
+        PSC10_0, PSC10_1,
+        PSC9_0,  PSC9_1,
+        PSC8_0,  PSC8_1,
+        PSC7_0,  PSC7_1,
+        PSC6_0,  PSC6_1,
+        PSC5_0,  PSC5_1,
+        PSC4_0,  PSC4_1,
+        PSC2_0,  PSC2_1,
+        PSC1_0,  PSC1_1,
+        PSC0_0,  PSC0_1,
+
+        PSD15_0, PSD15_1,
+        PSD14_0, PSD14_1,
+        PSD13_0, PSD13_1,
+        PSD12_0, PSD12_1,
+        PSD11_0, PSD11_1,
+        PSD10_0, PSD10_1,
+        PSD9_0,  PSD9_1,
+        PSD8_0,  PSD8_1,
+        PSD7_0,  PSD7_1,
+        PSD6_0,  PSD6_1,
+        PSD5_0,  PSD5_1,
+        PSD4_0,  PSD4_1,
+        PSD3_0,  PSD3_1,
+        PSD2_0,  PSD2_1,
+        PSD1_0,  PSD1_1,
+        PSD0_0,  PSD0_1,
+
+        PSE15_0, PSE15_1,
+        PSE14_0, PSE14_1,
+        PSE13_0, PSE13_1,
+        PSE12_0, PSE12_1,
+        PSE11_0, PSE11_1,
+        PSE10_0, PSE10_1,
+        PSE9_0,  PSE9_1,
+        PSE8_0,  PSE8_1,
+        PSE7_0,  PSE7_1,
+        PSE6_0,  PSE6_1,
+        PSE5_0,  PSE5_1,
+        PSE4_0,  PSE4_1,
+        PSE3_0,  PSE3_1,
+        PSE2_0,  PSE2_1,
+        PSE1_0,  PSE1_1,
+        PSE0_0,  PSE0_1,
+        PINMUX_FUNCTION_END,
+
+        PINMUX_MARK_BEGIN,
+        /*PTA*/
+        D23_MARK,       KEYOUT2_MARK,           IDED15_MARK,
+        D22_MARK,       KEYOUT1_MARK,           IDED14_MARK,
+        D21_MARK,       KEYOUT0_MARK,           IDED13_MARK,
+        D20_MARK,       KEYIN4_MARK,            IDED12_MARK,
+        D19_MARK,       KEYIN3_MARK,            IDED11_MARK,
+        D18_MARK,       KEYIN2_MARK,            IDED10_MARK,
+        D17_MARK,       KEYIN1_MARK,            IDED9_MARK,
+        D16_MARK,       KEYIN0_MARK,            IDED8_MARK,
+
+        /*PTB*/
+        D31_MARK,       TPUTO1_MARK,            IDEA1_MARK,
+        D30_MARK,       TPUTO0_MARK,            IDEA0_MARK,
+        D29_MARK,                               IODREQ_MARK,
+        D28_MARK,                               IDECS0_MARK,
+        D27_MARK,                               IDECS1_MARK,
+        D26_MARK,       KEYOUT5_IN5_MARK,       IDEIORD_MARK,
+        D25_MARK,       KEYOUT4_IN6_MARK,       IDEIOWR_MARK,
+        D24_MARK,       KEYOUT3_MARK,           IDEINT_MARK,
+
+        /*PTC*/
+        LCDD7_MARK,
+        LCDD6_MARK,
+        LCDD5_MARK,
+        LCDD4_MARK,
+        LCDD3_MARK,
+        LCDD2_MARK,
+        LCDD1_MARK,
+        LCDD0_MARK,
+
+        /*PTD*/
+        LCDD15_MARK,
+        LCDD14_MARK,
+        LCDD13_MARK,
+        LCDD12_MARK,
+        LCDD11_MARK,
+        LCDD10_MARK,
+        LCDD9_MARK,
+        LCDD8_MARK,
+
+        /*PTE*/
+        FSIMCKB_MARK,
+        FSIMCKA_MARK,
+        LCDD21_MARK,    SCIF2_L_TXD_MARK,
+        LCDD20_MARK,    SCIF4_SCK_MARK,
+        LCDD19_MARK,    SCIF4_RXD_MARK,
+        LCDD18_MARK,    SCIF4_TXD_MARK,
+        LCDD17_MARK,
+        LCDD16_MARK,
+
+        /*PTF*/
+        LCDVSYN_MARK,
+        LCDDISP_MARK,   LCDRS_MARK,
+        LCDHSYN_MARK,   LCDCS_MARK,
+        LCDDON_MARK,
+        LCDDCK_MARK,    LCDWR_MARK,
+        LCDVEPWC_MARK,  SCIF0_TXD_MARK,
+        LCDD23_MARK,    SCIF2_L_SCK_MARK,
+        LCDD22_MARK,    SCIF2_L_RXD_MARK,
+
+        /*PTG*/
+        AUDCK_MARK,
+        AUDSYNC_MARK,
+        AUDATA3_MARK,
+        AUDATA2_MARK,
+        AUDATA1_MARK,
+        AUDATA0_MARK,
+
+        /*PTH*/
+        VIO0_VD_MARK,
+        VIO0_CLK_MARK,
+        VIO0_D7_MARK,
+        VIO0_D6_MARK,
+        VIO0_D5_MARK,
+        VIO0_D4_MARK,
+        VIO0_D3_MARK,
+        VIO0_D2_MARK,
+
+        /*PTJ*/
+        PDSTATUS_MARK,
+        STATUS2_MARK,
+        STATUS0_MARK,
+        A25_MARK,               BS_MARK,
+        A24_MARK,
+        A23_MARK,
+        A22_MARK,
+
+        /*PTK*/
+        VIO1_D5_MARK,   VIO0_D13_MARK,  IDED5_MARK,
+        VIO1_D4_MARK,   VIO0_D12_MARK,  IDED4_MARK,
+        VIO1_D3_MARK,   VIO0_D11_MARK,  IDED3_MARK,
+        VIO1_D2_MARK,   VIO0_D10_MARK,  IDED2_MARK,
+        VIO1_D1_MARK,   VIO0_D9_MARK,   IDED1_MARK,
+        VIO1_D0_MARK,   VIO0_D8_MARK,   IDED0_MARK,
+        VIO0_FLD_MARK,
+        VIO0_HD_MARK,
+
+        /*PTL*/
+        DV_D5_MARK,     SCIF3_V_SCK_MARK,       RMII_RXD0_MARK,
+        DV_D4_MARK,     SCIF3_V_RXD_MARK,       RMII_RXD1_MARK,
+        DV_D3_MARK,     SCIF3_V_TXD_MARK,       RMII_REF_CLK_MARK,
+        DV_D2_MARK,     SCIF1_SCK_MARK,         RMII_TX_EN_MARK,
+        DV_D1_MARK,     SCIF1_RXD_MARK,         RMII_TXD0_MARK,
+        DV_D0_MARK,     SCIF1_TXD_MARK,         RMII_TXD1_MARK,
+        DV_D15_MARK,
+        DV_D14_MARK,    MSIOF0_MCK_MARK,
+
+        /*PTM*/
+        DV_D13_MARK,    MSIOF0_TSCK_MARK,
+        DV_D12_MARK,    MSIOF0_RXD_MARK,
+        DV_D11_MARK,    MSIOF0_TXD_MARK,
+        DV_D10_MARK,    MSIOF0_TSYNC_MARK,
+        DV_D9_MARK,     MSIOF0_SS1_MARK,        MSIOF0_RSCK_MARK,
+        DV_D8_MARK,     MSIOF0_SS2_MARK,        MSIOF0_RSYNC_MARK,
+        LCDVCPWC_MARK,  SCIF0_RXD_MARK,
+        LCDRD_MARK,     SCIF0_SCK_MARK,
+
+        /*PTN*/
+        VIO0_D1_MARK,
+        VIO0_D0_MARK,
+        DV_CLKI_MARK,
+        DV_CLK_MARK,    SCIF2_V_SCK_MARK,
+        DV_VSYNC_MARK,  SCIF2_V_RXD_MARK,
+        DV_HSYNC_MARK,  SCIF2_V_TXD_MARK,
+        DV_D7_MARK,     SCIF3_V_CTS_MARK,       RMII_RX_ER_MARK,
+        DV_D6_MARK,     SCIF3_V_RTS_MARK,       RMII_CRS_DV_MARK,
+
+        /*PTQ*/
+        D7_MARK,
+        D6_MARK,
+        D5_MARK,
+        D4_MARK,
+        D3_MARK,
+        D2_MARK,
+        D1_MARK,
+        D0_MARK,
+
+        /*PTR*/
+        CS6B_CE1B_MARK,
+        CS6A_CE2B_MARK,
+        CS5B_CE1A_MARK,
+        CS5A_CE2A_MARK,
+        IOIS16_MARK,            LCDLCLK_MARK,
+        WAIT_MARK,
+        WE3_ICIOWR_MARK,        TPUTO3_MARK,    TPUTI3_MARK,
+        WE2_ICIORD_MARK,        TPUTO2_MARK,    IDEA2_MARK,
+
+        /*PTS*/
+        VIO_CKO_MARK,
+        VIO1_FLD_MARK,  TPUTI2_MARK,            IDEIORDY_MARK,
+        VIO1_HD_MARK,   SCIF5_SCK_MARK,
+        VIO1_VD_MARK,   SCIF5_RXD_MARK,
+        VIO1_CLK_MARK,  SCIF5_TXD_MARK,
+        VIO1_D7_MARK,   VIO0_D15_MARK,          IDED7_MARK,
+        VIO1_D6_MARK,   VIO0_D14_MARK,          IDED6_MARK,
+
+        /*PTT*/
+        D15_MARK,
+        D14_MARK,
+        D13_MARK,
+        D12_MARK,
+        D11_MARK,
+        D10_MARK,
+        D9_MARK,
+        D8_MARK,
+
+        /*PTU*/
+        DMAC_DACK0_MARK,
+        DMAC_DREQ0_MARK,
+        FSIOASD_MARK,
+        FSIIABCK_MARK,
+        FSIIALRCK_MARK,
+        FSIOABCK_MARK,
+        FSIOALRCK_MARK,
+        CLKAUDIOAO_MARK,
+
+        /*PTV*/
+        FSIIBSD_MARK,           MSIOF1_SS2_MARK,        MSIOF1_RSYNC_MARK,
+        FSIOBSD_MARK,           MSIOF1_SS1_MARK,        MSIOF1_RSCK_MARK,
+        FSIIBBCK_MARK,          MSIOF1_RXD_MARK,
+        FSIIBLRCK_MARK,         MSIOF1_TSYNC_MARK,
+        FSIOBBCK_MARK,          MSIOF1_TSCK_MARK,
+        FSIOBLRCK_MARK,         MSIOF1_TXD_MARK,
+        CLKAUDIOBO_MARK,        MSIOF1_MCK_MARK,
+        FSIIASD_MARK,
+
+        /*PTW*/
+        MMC_D7_MARK,            SDHI1CD_MARK,           IODACK_MARK,
+        MMC_D6_MARK,            SDHI1WP_MARK,           IDERST_MARK,
+        MMC_D5_MARK,            SDHI1D3_MARK,           EXBUF_ENB_MARK,
+        MMC_D4_MARK,            SDHI1D2_MARK,           DIRECTION_MARK,
+        MMC_D3_MARK,            SDHI1D1_MARK,
+        MMC_D2_MARK,            SDHI1D0_MARK,
+        MMC_D1_MARK,            SDHI1CMD_MARK,
+        MMC_D0_MARK,            SDHI1CLK_MARK,
+
+        /*PTX*/
+        DMAC_DACK1_MARK,        IRDA_OUT_MARK,
+        DMAC_DREQ1_MARK,        IRDA_IN_MARK,
+        TSIF_TS0_SDAT_MARK,                             LNKSTA_MARK,
+        TSIF_TS0_SCK_MARK,                              MDIO_MARK,
+        TSIF_TS0_SDEN_MARK,                             MDC_MARK,
+        TSIF_TS0_SPSYNC_MARK,
+        MMC_CLK_MARK,
+        MMC_CMD_MARK,
+
+        /*PTY*/
+        SDHI0CD_MARK,
+        SDHI0WP_MARK,
+        SDHI0D3_MARK,
+        SDHI0D2_MARK,
+        SDHI0D1_MARK,
+        SDHI0D0_MARK,
+        SDHI0CMD_MARK,
+        SDHI0CLK_MARK,
+
+        /*PTZ*/
+        INTC_IRQ7_MARK,         SCIF3_I_CTS_MARK,
+        INTC_IRQ6_MARK,         SCIF3_I_RTS_MARK,
+        INTC_IRQ5_MARK,         SCIF3_I_SCK_MARK,
+        INTC_IRQ4_MARK,         SCIF3_I_RXD_MARK,
+        INTC_IRQ3_MARK,         SCIF3_I_TXD_MARK,
+        INTC_IRQ2_MARK,
+        INTC_IRQ1_MARK,
+        INTC_IRQ0_MARK,
+        PINMUX_MARK_END,
+};
+
+static pinmux_enum_t pinmux_data[] = {
+        /* PTA GPIO */
+        PINMUX_DATA(PTA7_DATA, PTA7_IN, PTA7_OUT, PTA7_IN_PU),
+        PINMUX_DATA(PTA6_DATA, PTA6_IN, PTA6_OUT, PTA6_IN_PU),
+        PINMUX_DATA(PTA5_DATA, PTA5_IN, PTA5_OUT, PTA5_IN_PU),
+        PINMUX_DATA(PTA4_DATA, PTA4_IN, PTA4_OUT, PTA4_IN_PU),
+        PINMUX_DATA(PTA3_DATA, PTA3_IN, PTA3_OUT, PTA3_IN_PU),
+        PINMUX_DATA(PTA2_DATA, PTA2_IN, PTA2_OUT, PTA2_IN_PU),
+        PINMUX_DATA(PTA1_DATA, PTA1_IN, PTA1_OUT, PTA1_IN_PU),
+        PINMUX_DATA(PTA0_DATA, PTA0_IN, PTA0_OUT, PTA0_IN_PU),
+
+        /* PTB GPIO */
+        PINMUX_DATA(PTB7_DATA, PTB7_IN, PTB7_OUT, PTB7_IN_PU),
+        PINMUX_DATA(PTB6_DATA, PTB6_IN, PTB6_OUT, PTB6_IN_PU),
+        PINMUX_DATA(PTB5_DATA, PTB5_IN, PTB5_OUT, PTB5_IN_PU),
+        PINMUX_DATA(PTB4_DATA, PTB4_IN, PTB4_OUT, PTB4_IN_PU),
+        PINMUX_DATA(PTB3_DATA, PTB3_IN, PTB3_OUT, PTB3_IN_PU),
+        PINMUX_DATA(PTB2_DATA, PTB2_IN, PTB2_OUT, PTB2_IN_PU),
+        PINMUX_DATA(PTB1_DATA, PTB1_IN, PTB1_OUT, PTB1_IN_PU),
+        PINMUX_DATA(PTB0_DATA, PTB0_IN, PTB0_OUT, PTB0_IN_PU),
+
+        /* PTC GPIO */
+        PINMUX_DATA(PTC7_DATA, PTC7_IN, PTC7_OUT, PTC7_IN_PU),
+        PINMUX_DATA(PTC6_DATA, PTC6_IN, PTC6_OUT, PTC6_IN_PU),
+        PINMUX_DATA(PTC5_DATA, PTC5_IN, PTC5_OUT, PTC5_IN_PU),
+        PINMUX_DATA(PTC4_DATA, PTC4_IN, PTC4_OUT, PTC4_IN_PU),
+        PINMUX_DATA(PTC3_DATA, PTC3_IN, PTC3_OUT, PTC3_IN_PU),
+        PINMUX_DATA(PTC2_DATA, PTC2_IN, PTC2_OUT, PTC2_IN_PU),
+        PINMUX_DATA(PTC1_DATA, PTC1_IN, PTC1_OUT, PTC1_IN_PU),
+        PINMUX_DATA(PTC0_DATA, PTC0_IN, PTC0_OUT, PTC0_IN_PU),
+
+        /* PTD GPIO */
+        PINMUX_DATA(PTD7_DATA, PTD7_IN, PTD7_OUT, PTD7_IN_PU),
+        PINMUX_DATA(PTD6_DATA, PTD6_IN, PTD6_OUT, PTD6_IN_PU),
+        PINMUX_DATA(PTD5_DATA, PTD5_IN, PTD5_OUT, PTD5_IN_PU),
+        PINMUX_DATA(PTD4_DATA, PTD4_IN, PTD4_OUT, PTD4_IN_PU),
+        PINMUX_DATA(PTD3_DATA, PTD3_IN, PTD3_OUT, PTD3_IN_PU),
+        PINMUX_DATA(PTD2_DATA, PTD2_IN, PTD2_OUT, PTD2_IN_PU),
+        PINMUX_DATA(PTD1_DATA, PTD1_IN, PTD1_OUT, PTD1_IN_PU),
+        PINMUX_DATA(PTD0_DATA, PTD0_IN, PTD0_OUT, PTD0_IN_PU),
+
+        /* PTE GPIO */
+        PINMUX_DATA(PTE7_DATA, PTE7_IN, PTE7_OUT, PTE7_IN_PU),
+        PINMUX_DATA(PTE6_DATA, PTE6_IN, PTE6_OUT, PTE6_IN_PU),
+        PINMUX_DATA(PTE5_DATA, PTE5_IN, PTE5_OUT, PTE5_IN_PU),
+        PINMUX_DATA(PTE4_DATA, PTE4_IN, PTE4_OUT, PTE4_IN_PU),
+        PINMUX_DATA(PTE3_DATA, PTE3_IN, PTE3_OUT, PTE3_IN_PU),
+        PINMUX_DATA(PTE2_DATA, PTE2_IN, PTE2_OUT, PTE2_IN_PU),
+        PINMUX_DATA(PTE1_DATA, PTE1_IN, PTE1_OUT, PTE1_IN_PU),
+        PINMUX_DATA(PTE0_DATA, PTE0_IN, PTE0_OUT, PTE0_IN_PU),
+
+        /* PTF GPIO */
+        PINMUX_DATA(PTF7_DATA, PTF7_IN, PTF7_OUT, PTF7_IN_PU),
+        PINMUX_DATA(PTF6_DATA, PTF6_IN, PTF6_OUT, PTF6_IN_PU),
+        PINMUX_DATA(PTF5_DATA, PTF5_IN, PTF5_OUT, PTF5_IN_PU),
+        PINMUX_DATA(PTF4_DATA, PTF4_IN, PTF4_OUT, PTF4_IN_PU),
+        PINMUX_DATA(PTF3_DATA, PTF3_IN, PTF3_OUT, PTF3_IN_PU),
+        PINMUX_DATA(PTF2_DATA, PTF2_IN, PTF2_OUT, PTF2_IN_PU),
+        PINMUX_DATA(PTF1_DATA, PTF1_IN, PTF1_OUT, PTF1_IN_PU),
+        PINMUX_DATA(PTF0_DATA, PTF0_IN, PTF0_OUT, PTF0_IN_PU),
+
+        /* PTG GPIO */
+        PINMUX_DATA(PTG5_DATA, PTG5_OUT),
+        PINMUX_DATA(PTG4_DATA, PTG4_OUT),
+        PINMUX_DATA(PTG3_DATA, PTG3_OUT),
+        PINMUX_DATA(PTG2_DATA, PTG2_OUT),
+        PINMUX_DATA(PTG1_DATA, PTG1_OUT),
+        PINMUX_DATA(PTG0_DATA, PTG0_OUT),
+
+        /* PTH GPIO */
+        PINMUX_DATA(PTH7_DATA, PTH7_IN, PTH7_OUT, PTH7_IN_PU),
+        PINMUX_DATA(PTH6_DATA, PTH6_IN, PTH6_OUT, PTH6_IN_PU),
+        PINMUX_DATA(PTH5_DATA, PTH5_IN, PTH5_OUT, PTH5_IN_PU),
+        PINMUX_DATA(PTH4_DATA, PTH4_IN, PTH4_OUT, PTH4_IN_PU),
+        PINMUX_DATA(PTH3_DATA, PTH3_IN, PTH3_OUT, PTH3_IN_PU),
+        PINMUX_DATA(PTH2_DATA, PTH2_IN, PTH2_OUT, PTH2_IN_PU),
+        PINMUX_DATA(PTH1_DATA, PTH1_IN, PTH1_OUT, PTH1_IN_PU),
+        PINMUX_DATA(PTH0_DATA, PTH0_IN, PTH0_OUT, PTH0_IN_PU),
+
+        /* PTJ GPIO */
+        PINMUX_DATA(PTJ7_DATA, PTJ7_OUT),
+        PINMUX_DATA(PTJ6_DATA, PTJ6_OUT),
+        PINMUX_DATA(PTJ5_DATA, PTJ5_OUT),
+        PINMUX_DATA(PTJ3_DATA, PTJ3_IN, PTJ3_OUT, PTJ3_IN_PU),
+        PINMUX_DATA(PTJ2_DATA, PTJ2_IN, PTJ2_OUT, PTJ2_IN_PU),
+        PINMUX_DATA(PTJ1_DATA, PTJ1_IN, PTJ1_OUT, PTJ1_IN_PU),
+        PINMUX_DATA(PTJ0_DATA, PTJ0_IN, PTJ0_OUT, PTJ0_IN_PU),
+
+        /* PTK GPIO */
+        PINMUX_DATA(PTK7_DATA, PTK7_IN, PTK7_OUT, PTK7_IN_PU),
+        PINMUX_DATA(PTK6_DATA, PTK6_IN, PTK6_OUT, PTK6_IN_PU),
+        PINMUX_DATA(PTK5_DATA, PTK5_IN, PTK5_OUT, PTK5_IN_PU),
+        PINMUX_DATA(PTK4_DATA, PTK4_IN, PTK4_OUT, PTK4_IN_PU),
+        PINMUX_DATA(PTK3_DATA, PTK3_IN, PTK3_OUT, PTK3_IN_PU),
+        PINMUX_DATA(PTK2_DATA, PTK2_IN, PTK2_OUT, PTK2_IN_PU),
+        PINMUX_DATA(PTK1_DATA, PTK1_IN, PTK1_OUT, PTK1_IN_PU),
+        PINMUX_DATA(PTK0_DATA, PTK0_IN, PTK0_OUT, PTK0_IN_PU),
+
+        /* PTL GPIO */
+        PINMUX_DATA(PTL7_DATA, PTL7_IN, PTL7_OUT, PTL7_IN_PU),
+        PINMUX_DATA(PTL6_DATA, PTL6_IN, PTL6_OUT, PTL6_IN_PU),
+        PINMUX_DATA(PTL5_DATA, PTL5_IN, PTL5_OUT, PTL5_IN_PU),
+        PINMUX_DATA(PTL4_DATA, PTL4_IN, PTL4_OUT, PTL4_IN_PU),
+        PINMUX_DATA(PTL3_DATA, PTL3_IN, PTL3_OUT, PTL3_IN_PU),
+        PINMUX_DATA(PTL2_DATA, PTL2_IN, PTL2_OUT, PTL2_IN_PU),
+        PINMUX_DATA(PTL1_DATA, PTL1_IN, PTL1_OUT, PTL1_IN_PU),
+        PINMUX_DATA(PTL0_DATA, PTL0_IN, PTL0_OUT, PTL0_IN_PU),
+
+        /* PTM GPIO */
+        PINMUX_DATA(PTM7_DATA, PTM7_IN, PTM7_OUT, PTM7_IN_PU),
+        PINMUX_DATA(PTM6_DATA, PTM6_IN, PTM6_OUT, PTM6_IN_PU),
+        PINMUX_DATA(PTM5_DATA, PTM5_IN, PTM5_OUT, PTM5_IN_PU),
+        PINMUX_DATA(PTM4_DATA, PTM4_IN, PTM4_OUT, PTM4_IN_PU),
+        PINMUX_DATA(PTM3_DATA, PTM3_IN, PTM3_OUT, PTM3_IN_PU),
+        PINMUX_DATA(PTM2_DATA, PTM2_IN, PTM2_OUT, PTM2_IN_PU),
+        PINMUX_DATA(PTM1_DATA, PTM1_IN, PTM1_OUT, PTM1_IN_PU),
+        PINMUX_DATA(PTM0_DATA, PTM0_IN, PTM0_OUT, PTM0_IN_PU),
+
+        /* PTN GPIO */
+        PINMUX_DATA(PTN7_DATA, PTN7_IN, PTN7_OUT, PTN7_IN_PU),
+        PINMUX_DATA(PTN6_DATA, PTN6_IN, PTN6_OUT, PTN6_IN_PU),
+        PINMUX_DATA(PTN5_DATA, PTN5_IN, PTN5_OUT, PTN5_IN_PU),
+        PINMUX_DATA(PTN4_DATA, PTN4_IN, PTN4_OUT, PTN4_IN_PU),
+        PINMUX_DATA(PTN3_DATA, PTN3_IN, PTN3_OUT, PTN3_IN_PU),
+        PINMUX_DATA(PTN2_DATA, PTN2_IN, PTN2_OUT, PTN2_IN_PU),
+        PINMUX_DATA(PTN1_DATA, PTN1_IN, PTN1_OUT, PTN1_IN_PU),
+        PINMUX_DATA(PTN0_DATA, PTN0_IN, PTN0_OUT, PTN0_IN_PU),
+
+        /* PTQ GPIO */
+        PINMUX_DATA(PTQ7_DATA, PTQ7_IN, PTQ7_OUT, PTQ7_IN_PU),
+        PINMUX_DATA(PTQ6_DATA, PTQ6_IN, PTQ6_OUT, PTQ6_IN_PU),
+        PINMUX_DATA(PTQ5_DATA, PTQ5_IN, PTQ5_OUT, PTQ5_IN_PU),
+        PINMUX_DATA(PTQ4_DATA, PTQ4_IN, PTQ4_OUT, PTQ4_IN_PU),
+        PINMUX_DATA(PTQ3_DATA, PTQ3_IN, PTQ3_OUT, PTQ3_IN_PU),
+        PINMUX_DATA(PTQ2_DATA, PTQ2_IN, PTQ2_OUT, PTQ2_IN_PU),
+        PINMUX_DATA(PTQ1_DATA, PTQ1_IN, PTQ1_OUT, PTQ1_IN_PU),
+        PINMUX_DATA(PTQ0_DATA, PTQ0_IN, PTQ0_OUT, PTQ0_IN_PU),
+
+        /* PTR GPIO */
+        PINMUX_DATA(PTR7_DATA, PTR7_IN, PTR7_OUT, PTR7_IN_PU),
+        PINMUX_DATA(PTR6_DATA, PTR6_IN, PTR6_OUT, PTR6_IN_PU),
+        PINMUX_DATA(PTR5_DATA, PTR5_IN, PTR5_OUT, PTR5_IN_PU),
+        PINMUX_DATA(PTR4_DATA, PTR4_IN, PTR4_OUT, PTR4_IN_PU),
+        PINMUX_DATA(PTR3_DATA, PTR3_IN,           PTR3_IN_PU),
+        PINMUX_DATA(PTR2_DATA, PTR2_IN,           PTR2_IN_PU),
+        PINMUX_DATA(PTR1_DATA, PTR1_IN, PTR1_OUT, PTR1_IN_PU),
+        PINMUX_DATA(PTR0_DATA, PTR0_IN, PTR0_OUT, PTR0_IN_PU),
+
+        /* PTS GPIO */
+        PINMUX_DATA(PTS6_DATA, PTS6_IN, PTS6_OUT, PTS6_IN_PU),
+        PINMUX_DATA(PTS5_DATA, PTS5_IN, PTS5_OUT, PTS5_IN_PU),
+        PINMUX_DATA(PTS4_DATA, PTS4_IN, PTS4_OUT, PTS4_IN_PU),
+        PINMUX_DATA(PTS3_DATA, PTS3_IN, PTS3_OUT, PTS3_IN_PU),
+        PINMUX_DATA(PTS2_DATA, PTS2_IN, PTS2_OUT, PTS2_IN_PU),
+        PINMUX_DATA(PTS1_DATA, PTS1_IN, PTS1_OUT, PTS1_IN_PU),
+        PINMUX_DATA(PTS0_DATA, PTS0_IN, PTS0_OUT, PTS0_IN_PU),
+
+        /* PTT GPIO */
+        PINMUX_DATA(PTT7_DATA, PTT7_IN, PTT7_OUT, PTT7_IN_PU),
+        PINMUX_DATA(PTT6_DATA, PTT6_IN, PTT6_OUT, PTT6_IN_PU),
+        PINMUX_DATA(PTT5_DATA, PTT5_IN, PTT5_OUT, PTT5_IN_PU),
+        PINMUX_DATA(PTT4_DATA, PTT4_IN, PTT4_OUT, PTT4_IN_PU),
+        PINMUX_DATA(PTT3_DATA, PTT3_IN, PTT3_OUT, PTT3_IN_PU),
+        PINMUX_DATA(PTT2_DATA, PTT2_IN, PTT2_OUT, PTT2_IN_PU),
+        PINMUX_DATA(PTT1_DATA, PTT1_IN, PTT1_OUT, PTT1_IN_PU),
+        PINMUX_DATA(PTT0_DATA, PTT0_IN, PTT0_OUT, PTT0_IN_PU),
+
+        /* PTU GPIO */
+        PINMUX_DATA(PTU7_DATA, PTU7_IN, PTU7_OUT, PTU7_IN_PU),
+        PINMUX_DATA(PTU6_DATA, PTU6_IN, PTU6_OUT, PTU6_IN_PU),
+        PINMUX_DATA(PTU5_DATA, PTU5_IN, PTU5_OUT, PTU5_IN_PU),
+        PINMUX_DATA(PTU4_DATA, PTU4_IN, PTU4_OUT, PTU4_IN_PU),
+        PINMUX_DATA(PTU3_DATA, PTU3_IN, PTU3_OUT, PTU3_IN_PU),
+        PINMUX_DATA(PTU2_DATA, PTU2_IN, PTU2_OUT, PTU2_IN_PU),
+        PINMUX_DATA(PTU1_DATA, PTU1_IN, PTU1_OUT, PTU1_IN_PU),
+        PINMUX_DATA(PTU0_DATA, PTU0_IN, PTU0_OUT, PTU0_IN_PU),
+
+        /* PTV GPIO */
+        PINMUX_DATA(PTV7_DATA, PTV7_IN, PTV7_OUT, PTV7_IN_PU),
+        PINMUX_DATA(PTV6_DATA, PTV6_IN, PTV6_OUT, PTV6_IN_PU),
+        PINMUX_DATA(PTV5_DATA, PTV5_IN, PTV5_OUT, PTV5_IN_PU),
+        PINMUX_DATA(PTV4_DATA, PTV4_IN, PTV4_OUT, PTV4_IN_PU),
+        PINMUX_DATA(PTV3_DATA, PTV3_IN, PTV3_OUT, PTV3_IN_PU),
+        PINMUX_DATA(PTV2_DATA, PTV2_IN, PTV2_OUT, PTV2_IN_PU),
+        PINMUX_DATA(PTV1_DATA, PTV1_IN, PTV1_OUT, PTV1_IN_PU),
+        PINMUX_DATA(PTV0_DATA, PTV0_IN, PTV0_OUT, PTV0_IN_PU),
+
+        /* PTW GPIO */
+        PINMUX_DATA(PTW7_DATA, PTW7_IN, PTW7_OUT, PTW7_IN_PU),
+        PINMUX_DATA(PTW6_DATA, PTW6_IN, PTW6_OUT, PTW6_IN_PU),
+        PINMUX_DATA(PTW5_DATA, PTW5_IN, PTW5_OUT, PTW5_IN_PU),
+        PINMUX_DATA(PTW4_DATA, PTW4_IN, PTW4_OUT, PTW4_IN_PU),
+        PINMUX_DATA(PTW3_DATA, PTW3_IN, PTW3_OUT, PTW3_IN_PU),
+        PINMUX_DATA(PTW2_DATA, PTW2_IN, PTW2_OUT, PTW2_IN_PU),
+        PINMUX_DATA(PTW1_DATA, PTW1_IN, PTW1_OUT, PTW1_IN_PU),
+        PINMUX_DATA(PTW0_DATA, PTW0_IN, PTW0_OUT, PTW0_IN_PU),
+
+        /* PTX GPIO */
+        PINMUX_DATA(PTX7_DATA, PTX7_IN, PTX7_OUT, PTX7_IN_PU),
+        PINMUX_DATA(PTX6_DATA, PTX6_IN, PTX6_OUT, PTX6_IN_PU),
+        PINMUX_DATA(PTX5_DATA, PTX5_IN, PTX5_OUT, PTX5_IN_PU),
+        PINMUX_DATA(PTX4_DATA, PTX4_IN, PTX4_OUT, PTX4_IN_PU),
+        PINMUX_DATA(PTX3_DATA, PTX3_IN, PTX3_OUT, PTX3_IN_PU),
+        PINMUX_DATA(PTX2_DATA, PTX2_IN, PTX2_OUT, PTX2_IN_PU),
+        PINMUX_DATA(PTX1_DATA, PTX1_IN, PTX1_OUT, PTX1_IN_PU),
+        PINMUX_DATA(PTX0_DATA, PTX0_IN, PTX0_OUT, PTX0_IN_PU),
+
+        /* PTY GPIO */
+        PINMUX_DATA(PTY7_DATA, PTY7_IN, PTY7_OUT, PTY7_IN_PU),
+        PINMUX_DATA(PTY6_DATA, PTY6_IN, PTY6_OUT, PTY6_IN_PU),
+        PINMUX_DATA(PTY5_DATA, PTY5_IN, PTY5_OUT, PTY5_IN_PU),
+        PINMUX_DATA(PTY4_DATA, PTY4_IN, PTY4_OUT, PTY4_IN_PU),
+        PINMUX_DATA(PTY3_DATA, PTY3_IN, PTY3_OUT, PTY3_IN_PU),
+        PINMUX_DATA(PTY2_DATA, PTY2_IN, PTY2_OUT, PTY2_IN_PU),
+        PINMUX_DATA(PTY1_DATA, PTY1_IN, PTY1_OUT, PTY1_IN_PU),
+        PINMUX_DATA(PTY0_DATA, PTY0_IN, PTY0_OUT, PTY0_IN_PU),
+
+        /* PTZ GPIO */
+        PINMUX_DATA(PTZ7_DATA, PTZ7_IN, PTZ7_OUT, PTZ7_IN_PU),
+        PINMUX_DATA(PTZ6_DATA, PTZ6_IN, PTZ6_OUT, PTZ6_IN_PU),
+        PINMUX_DATA(PTZ5_DATA, PTZ5_IN, PTZ5_OUT, PTZ5_IN_PU),
+        PINMUX_DATA(PTZ4_DATA, PTZ4_IN, PTZ4_OUT, PTZ4_IN_PU),
+        PINMUX_DATA(PTZ3_DATA, PTZ3_IN, PTZ3_OUT, PTZ3_IN_PU),
+        PINMUX_DATA(PTZ2_DATA, PTZ2_IN, PTZ2_OUT, PTZ2_IN_PU),
+        PINMUX_DATA(PTZ1_DATA, PTZ1_IN, PTZ1_OUT, PTZ1_IN_PU),
+        PINMUX_DATA(PTZ0_DATA, PTZ0_IN, PTZ0_OUT, PTZ0_IN_PU),
+
+        /* PTA FN */
+        PINMUX_DATA(D23_MARK,   PSA15_0, PSA14_0, PTA7_FN),
+        PINMUX_DATA(D22_MARK,   PSA15_0, PSA14_0, PTA6_FN),
+        PINMUX_DATA(D21_MARK,   PSA15_0, PSA14_0, PTA5_FN),
+        PINMUX_DATA(D20_MARK,   PSA15_0, PSA14_0, PTA4_FN),
+        PINMUX_DATA(D19_MARK,   PSA15_0, PSA14_0, PTA3_FN),
+        PINMUX_DATA(D18_MARK,   PSA15_0, PSA14_0, PTA2_FN),
+        PINMUX_DATA(D17_MARK,   PSA15_0, PSA14_0, PTA1_FN),
+        PINMUX_DATA(D16_MARK,   PSA15_0, PSA14_0, PTA0_FN),
+
+        PINMUX_DATA(KEYOUT2_MARK,       PSA15_0, PSA14_1, PTA7_FN),
+        PINMUX_DATA(KEYOUT1_MARK,       PSA15_0, PSA14_1, PTA6_FN),
+        PINMUX_DATA(KEYOUT0_MARK,       PSA15_0, PSA14_1, PTA5_FN),
+        PINMUX_DATA(KEYIN4_MARK,        PSA15_0, PSA14_1, PTA4_FN),
+        PINMUX_DATA(KEYIN3_MARK,        PSA15_0, PSA14_1, PTA3_FN),
+        PINMUX_DATA(KEYIN2_MARK,        PSA15_0, PSA14_1, PTA2_FN),
+        PINMUX_DATA(KEYIN1_MARK,        PSA15_0, PSA14_1, PTA1_FN),
+        PINMUX_DATA(KEYIN0_MARK,        PSA15_0, PSA14_1, PTA0_FN),
+
+        PINMUX_DATA(IDED15_MARK,        PSA15_1, PSA14_0, PTA7_FN),
+        PINMUX_DATA(IDED14_MARK,        PSA15_1, PSA14_0, PTA6_FN),
+        PINMUX_DATA(IDED13_MARK,        PSA15_1, PSA14_0, PTA5_FN),
+        PINMUX_DATA(IDED12_MARK,        PSA15_1, PSA14_0, PTA4_FN),
+        PINMUX_DATA(IDED11_MARK,        PSA15_1, PSA14_0, PTA3_FN),
+        PINMUX_DATA(IDED10_MARK,        PSA15_1, PSA14_0, PTA2_FN),
+        PINMUX_DATA(IDED9_MARK,         PSA15_1, PSA14_0, PTA1_FN),
+        PINMUX_DATA(IDED8_MARK,         PSA15_1, PSA14_0, PTA0_FN),
+
+        /* PTB FN */
+        PINMUX_DATA(D31_MARK,           PSE15_0, PSE14_0, PTB7_FN),
+        PINMUX_DATA(D30_MARK,           PSE15_0, PSE14_0, PTB6_FN),
+        PINMUX_DATA(D29_MARK,           PSE11_0,          PTB5_FN),
+        PINMUX_DATA(D28_MARK,           PSE11_0,          PTB4_FN),
+        PINMUX_DATA(D27_MARK,           PSE11_0,          PTB3_FN),
+        PINMUX_DATA(D26_MARK,           PSA15_0, PSA14_0, PTB2_FN),
+        PINMUX_DATA(D25_MARK,           PSA15_0, PSA14_0, PTB1_FN),
+        PINMUX_DATA(D24_MARK,           PSA15_0, PSA14_0, PTB0_FN),
+
+        PINMUX_DATA(IDEA1_MARK,         PSE15_1, PSE14_0, PTB7_FN),
+        PINMUX_DATA(IDEA0_MARK,         PSE15_1, PSE14_0, PTB6_FN),
+        PINMUX_DATA(IODREQ_MARK,        PSE11_1,          PTB5_FN),
+        PINMUX_DATA(IDECS0_MARK,        PSE11_1,          PTB4_FN),
+        PINMUX_DATA(IDECS1_MARK,        PSE11_1,          PTB3_FN),
+        PINMUX_DATA(IDEIORD_MARK,       PSA15_1, PSA14_0, PTB2_FN),
+        PINMUX_DATA(IDEIOWR_MARK,       PSA15_1, PSA14_0, PTB1_FN),
+        PINMUX_DATA(IDEINT_MARK,        PSA15_1, PSA14_0, PTB0_FN),
+
+        PINMUX_DATA(TPUTO1_MARK,        PSE15_0, PSE14_1, PTB7_FN),
+        PINMUX_DATA(TPUTO0_MARK,        PSE15_0, PSE14_1, PTB6_FN),
+
+        PINMUX_DATA(KEYOUT5_IN5_MARK,   PSA15_0, PSA14_1, PTB2_FN),
+        PINMUX_DATA(KEYOUT4_IN6_MARK,   PSA15_0, PSA14_1, PTB1_FN),
+        PINMUX_DATA(KEYOUT3_MARK,       PSA15_0, PSA14_1, PTB0_FN),
+
+        /* PTC FN */
+        PINMUX_DATA(LCDD7_MARK, PSD5_0, PTC7_FN),
+        PINMUX_DATA(LCDD6_MARK, PSD5_0, PTC6_FN),
+        PINMUX_DATA(LCDD5_MARK, PSD5_0, PTC5_FN),
+        PINMUX_DATA(LCDD4_MARK, PSD5_0, PTC4_FN),
+        PINMUX_DATA(LCDD3_MARK, PSD5_0, PTC3_FN),
+        PINMUX_DATA(LCDD2_MARK, PSD5_0, PTC2_FN),
+        PINMUX_DATA(LCDD1_MARK, PSD5_0, PTC1_FN),
+        PINMUX_DATA(LCDD0_MARK, PSD5_0, PTC0_FN),
+
+        /* PTD FN */
+        PINMUX_DATA(LCDD15_MARK, PSD5_0, PTD7_FN),
+        PINMUX_DATA(LCDD14_MARK, PSD5_0, PTD6_FN),
+        PINMUX_DATA(LCDD13_MARK, PSD5_0, PTD5_FN),
+        PINMUX_DATA(LCDD12_MARK, PSD5_0, PTD4_FN),
+        PINMUX_DATA(LCDD11_MARK, PSD5_0, PTD3_FN),
+        PINMUX_DATA(LCDD10_MARK, PSD5_0, PTD2_FN),
+        PINMUX_DATA(LCDD9_MARK,  PSD5_0, PTD1_FN),
+        PINMUX_DATA(LCDD8_MARK,  PSD5_0, PTD0_FN),
+
+        /* PTE FN */
+        PINMUX_DATA(FSIMCKB_MARK, PTE7_FN),
+        PINMUX_DATA(FSIMCKA_MARK, PTE6_FN),
+
+        PINMUX_DATA(LCDD21_MARK,        PSC5_0, PSC4_0, PTE5_FN),
+        PINMUX_DATA(LCDD20_MARK,        PSD3_0, PSD2_0, PTE4_FN),
+        PINMUX_DATA(LCDD19_MARK,        PSA3_0, PSA2_0, PTE3_FN),
+        PINMUX_DATA(LCDD18_MARK,        PSA3_0, PSA2_0, PTE2_FN),
+        PINMUX_DATA(LCDD17_MARK,        PSD5_0,         PTE1_FN),
+        PINMUX_DATA(LCDD16_MARK,        PSD5_0,         PTE0_FN),
+
+        PINMUX_DATA(SCIF2_L_TXD_MARK,   PSC5_0, PSC4_1, PTE5_FN),
+        PINMUX_DATA(SCIF4_SCK_MARK,     PSD3_0, PSD2_1, PTE4_FN),
+        PINMUX_DATA(SCIF4_RXD_MARK,     PSA3_0, PSA2_1, PTE3_FN),
+        PINMUX_DATA(SCIF4_TXD_MARK,     PSA3_0, PSA2_1, PTE2_FN),
+
+        /* PTF FN */
+        PINMUX_DATA(LCDVSYN_MARK,       PSD8_0,          PTF7_FN),
+        PINMUX_DATA(LCDDISP_MARK,       PSD10_0, PSD9_0, PTF6_FN),
+        PINMUX_DATA(LCDHSYN_MARK,       PSD10_0, PSD9_0, PTF5_FN),
+        PINMUX_DATA(LCDDON_MARK,        PSD8_0,          PTF4_FN),
+        PINMUX_DATA(LCDDCK_MARK,        PSD10_0, PSD9_0, PTF3_FN),
+        PINMUX_DATA(LCDVEPWC_MARK,      PSA6_0,          PTF2_FN),
+        PINMUX_DATA(LCDD23_MARK,        PSC7_0,  PSC6_0, PTF1_FN),
+        PINMUX_DATA(LCDD22_MARK,        PSC5_0,  PSC4_0, PTF0_FN),
+
+        PINMUX_DATA(LCDRS_MARK,         PSD10_0, PSD9_1, PTF6_FN),
+        PINMUX_DATA(LCDCS_MARK,         PSD10_0, PSD9_1, PTF5_FN),
+        PINMUX_DATA(LCDWR_MARK,         PSD10_0, PSD9_1, PTF3_FN),
+
+        PINMUX_DATA(SCIF0_TXD_MARK,     PSA6_1,          PTF2_FN),
+        PINMUX_DATA(SCIF2_L_SCK_MARK,   PSC7_0,  PSC6_1, PTF1_FN),
+        PINMUX_DATA(SCIF2_L_RXD_MARK,   PSC5_0,  PSC4_1, PTF0_FN),
+
+        /* PTG FN */
+        PINMUX_DATA(AUDCK_MARK,   PTG5_FN),
+        PINMUX_DATA(AUDSYNC_MARK, PTG4_FN),
+        PINMUX_DATA(AUDATA3_MARK, PTG3_FN),
+        PINMUX_DATA(AUDATA2_MARK, PTG2_FN),
+        PINMUX_DATA(AUDATA1_MARK, PTG1_FN),
+        PINMUX_DATA(AUDATA0_MARK, PTG0_FN),
+
+        /* PTH FN */
+        PINMUX_DATA(VIO0_VD_MARK,  PTH7_FN),
+        PINMUX_DATA(VIO0_CLK_MARK, PTH6_FN),
+        PINMUX_DATA(VIO0_D7_MARK,  PTH5_FN),
+        PINMUX_DATA(VIO0_D6_MARK,  PTH4_FN),
+        PINMUX_DATA(VIO0_D5_MARK,  PTH3_FN),
+        PINMUX_DATA(VIO0_D4_MARK,  PTH2_FN),
+        PINMUX_DATA(VIO0_D3_MARK,  PTH1_FN),
+        PINMUX_DATA(VIO0_D2_MARK,  PTH0_FN),
+
+        /* PTJ FN */
+        PINMUX_DATA(PDSTATUS_MARK,      PTJ7_FN),
+        PINMUX_DATA(STATUS2_MARK,       PTJ6_FN),
+        PINMUX_DATA(STATUS0_MARK,       PTJ5_FN),
+        PINMUX_DATA(A25_MARK,           PSA8_0, PTJ3_FN),
+        PINMUX_DATA(BS_MARK,            PSA8_1, PTJ3_FN),
+        PINMUX_DATA(A24_MARK,           PTJ2_FN),
+        PINMUX_DATA(A23_MARK,           PTJ1_FN),
+        PINMUX_DATA(A22_MARK,           PTJ0_FN),
+
+        /* PTK FN */
+        PINMUX_DATA(VIO1_D5_MARK,       PSB7_0, PSB6_0, PTK7_FN),
+        PINMUX_DATA(VIO1_D4_MARK,       PSB7_0, PSB6_0, PTK6_FN),
+        PINMUX_DATA(VIO1_D3_MARK,       PSB7_0, PSB6_0, PTK5_FN),
+        PINMUX_DATA(VIO1_D2_MARK,       PSB7_0, PSB6_0, PTK4_FN),
+        PINMUX_DATA(VIO1_D1_MARK,       PSB7_0, PSB6_0, PTK3_FN),
+        PINMUX_DATA(VIO1_D0_MARK,       PSB7_0, PSB6_0, PTK2_FN),
+
+        PINMUX_DATA(VIO0_D13_MARK,      PSB7_0, PSB6_1, PTK7_FN),
+        PINMUX_DATA(VIO0_D12_MARK,      PSB7_0, PSB6_1, PTK6_FN),
+        PINMUX_DATA(VIO0_D11_MARK,      PSB7_0, PSB6_1, PTK5_FN),
+        PINMUX_DATA(VIO0_D10_MARK,      PSB7_0, PSB6_1, PTK4_FN),
+        PINMUX_DATA(VIO0_D9_MARK,       PSB7_0, PSB6_1, PTK3_FN),
+        PINMUX_DATA(VIO0_D8_MARK,       PSB7_0, PSB6_1, PTK2_FN),
+
+        PINMUX_DATA(IDED5_MARK,         PSB7_1, PSB6_0, PTK7_FN),
+        PINMUX_DATA(IDED4_MARK,         PSB7_1, PSB6_0, PTK6_FN),
+        PINMUX_DATA(IDED3_MARK,         PSB7_1, PSB6_0, PTK5_FN),
+        PINMUX_DATA(IDED2_MARK,         PSB7_1, PSB6_0, PTK4_FN),
+        PINMUX_DATA(IDED1_MARK,         PSB7_1, PSB6_0, PTK3_FN),
+        PINMUX_DATA(IDED0_MARK,         PSB7_1, PSB6_0, PTK2_FN),
+
+        PINMUX_DATA(VIO0_FLD_MARK,      PTK1_FN),
+        PINMUX_DATA(VIO0_HD_MARK,       PTK0_FN),
+
+        /* PTL FN */
+        PINMUX_DATA(DV_D5_MARK,         PSB9_0, PSB8_0, PTL7_FN),
+        PINMUX_DATA(DV_D4_MARK,         PSB9_0, PSB8_0, PTL6_FN),
+        PINMUX_DATA(DV_D3_MARK,         PSE7_0, PSE6_0, PTL5_FN),
+        PINMUX_DATA(DV_D2_MARK,         PSC9_0, PSC8_0, PTL4_FN),
+        PINMUX_DATA(DV_D1_MARK,         PSC9_0, PSC8_0, PTL3_FN),
+        PINMUX_DATA(DV_D0_MARK,         PSC9_0, PSC8_0, PTL2_FN),
+        PINMUX_DATA(DV_D15_MARK,        PSD4_0,         PTL1_FN),
+        PINMUX_DATA(DV_D14_MARK,        PSE5_0, PSE4_0, PTL0_FN),
+
+        PINMUX_DATA(SCIF3_V_SCK_MARK,   PSB9_0, PSB8_1, PTL7_FN),
+        PINMUX_DATA(SCIF3_V_RXD_MARK,   PSB9_0, PSB8_1, PTL6_FN),
+        PINMUX_DATA(SCIF3_V_TXD_MARK,   PSE7_0, PSE6_1, PTL5_FN),
+        PINMUX_DATA(SCIF1_SCK_MARK,     PSC9_0, PSC8_1, PTL4_FN),
+        PINMUX_DATA(SCIF1_RXD_MARK,     PSC9_0, PSC8_1, PTL3_FN),
+        PINMUX_DATA(SCIF1_TXD_MARK,     PSC9_0, PSC8_1, PTL2_FN),
+
+        PINMUX_DATA(RMII_RXD0_MARK,     PSB9_1, PSB8_0, PTL7_FN),
+        PINMUX_DATA(RMII_RXD1_MARK,     PSB9_1, PSB8_0, PTL6_FN),
+        PINMUX_DATA(RMII_REF_CLK_MARK,  PSE7_1, PSE6_0, PTL5_FN),
+        PINMUX_DATA(RMII_TX_EN_MARK,    PSC9_1, PSC8_0, PTL4_FN),
+        PINMUX_DATA(RMII_TXD0_MARK,     PSC9_1, PSC8_0, PTL3_FN),
+        PINMUX_DATA(RMII_TXD1_MARK,     PSC9_1, PSC8_0, PTL2_FN),
+
+        PINMUX_DATA(MSIOF0_MCK_MARK,    PSE5_0, PSE4_1, PTL0_FN),
+
+        /* PTM FN */
+        PINMUX_DATA(DV_D13_MARK,        PSC13_0, PSC12_0, PTM7_FN),
+        PINMUX_DATA(DV_D12_MARK,        PSC13_0, PSC12_0, PTM6_FN),
+        PINMUX_DATA(DV_D11_MARK,        PSC13_0, PSC12_0, PTM5_FN),
+        PINMUX_DATA(DV_D10_MARK,        PSC13_0, PSC12_0, PTM4_FN),
+        PINMUX_DATA(DV_D9_MARK,         PSC11_0, PSC10_0, PTM3_FN),
+        PINMUX_DATA(DV_D8_MARK,         PSC11_0, PSC10_0, PTM2_FN),
+
+        PINMUX_DATA(MSIOF0_TSCK_MARK,   PSC13_0, PSC12_1, PTM7_FN),
+        PINMUX_DATA(MSIOF0_RXD_MARK,    PSC13_0, PSC12_1, PTM6_FN),
+        PINMUX_DATA(MSIOF0_TXD_MARK,    PSC13_0, PSC12_1, PTM5_FN),
+        PINMUX_DATA(MSIOF0_TSYNC_MARK,  PSC13_0, PSC12_1, PTM4_FN),
+        PINMUX_DATA(MSIOF0_SS1_MARK,    PSC11_0, PSC10_1, PTM3_FN),
+        PINMUX_DATA(MSIOF0_RSCK_MARK,   PSC11_1, PSC10_0, PTM3_FN),
+        PINMUX_DATA(MSIOF0_SS2_MARK,    PSC11_0, PSC10_1, PTM2_FN),
+        PINMUX_DATA(MSIOF0_RSYNC_MARK,  PSC11_1, PSC10_0, PTM2_FN),
+
+        PINMUX_DATA(LCDVCPWC_MARK,      PSA6_0, PTM1_FN),
+        PINMUX_DATA(LCDRD_MARK,         PSA7_0, PTM0_FN),
+
+        PINMUX_DATA(SCIF0_RXD_MARK,     PSA6_1, PTM1_FN),
+        PINMUX_DATA(SCIF0_SCK_MARK,     PSA7_1, PTM0_FN),
+
+        /* PTN FN */
+        PINMUX_DATA(VIO0_D1_MARK,       PTN7_FN),
+        PINMUX_DATA(VIO0_D0_MARK,       PTN6_FN),
+
+        PINMUX_DATA(DV_CLKI_MARK,       PSD11_0,          PTN5_FN),
+        PINMUX_DATA(DV_CLK_MARK,        PSD13_0, PSD12_0, PTN4_FN),
+        PINMUX_DATA(DV_VSYNC_MARK,      PSD15_0, PSD14_0, PTN3_FN),
+        PINMUX_DATA(DV_HSYNC_MARK,      PSB5_0,  PSB4_0,  PTN2_FN),
+        PINMUX_DATA(DV_D7_MARK,         PSB3_0,  PSB2_0,  PTN1_FN),
+        PINMUX_DATA(DV_D6_MARK,         PSB1_0,  PSB0_0,  PTN0_FN),
+
+        PINMUX_DATA(SCIF2_V_SCK_MARK,   PSD13_0, PSD12_1, PTN4_FN),
+        PINMUX_DATA(SCIF2_V_RXD_MARK,   PSD15_0, PSD14_1, PTN3_FN),
+        PINMUX_DATA(SCIF2_V_TXD_MARK,   PSB5_0,  PSB4_1,  PTN2_FN),
+        PINMUX_DATA(SCIF3_V_CTS_MARK,   PSB3_0,  PSB2_1,  PTN1_FN),
+        PINMUX_DATA(SCIF3_V_RTS_MARK,   PSB1_0,  PSB0_1,  PTN0_FN),
+
+        PINMUX_DATA(RMII_RX_ER_MARK,    PSB3_1, PSB2_0, PTN1_FN),
+        PINMUX_DATA(RMII_CRS_DV_MARK,   PSB1_1, PSB0_0, PTN0_FN),
+
+        /* PTQ FN */
+        PINMUX_DATA(D7_MARK, PTQ7_FN),
+        PINMUX_DATA(D6_MARK, PTQ6_FN),
+        PINMUX_DATA(D5_MARK, PTQ5_FN),
+        PINMUX_DATA(D4_MARK, PTQ4_FN),
+        PINMUX_DATA(D3_MARK, PTQ3_FN),
+        PINMUX_DATA(D2_MARK, PTQ2_FN),
+        PINMUX_DATA(D1_MARK, PTQ1_FN),
+        PINMUX_DATA(D0_MARK, PTQ0_FN),
+
+        /* PTR FN */
+        PINMUX_DATA(CS6B_CE1B_MARK,                     PTR7_FN),
+        PINMUX_DATA(CS6A_CE2B_MARK,                     PTR6_FN),
+        PINMUX_DATA(CS5B_CE1A_MARK,                     PTR5_FN),
+        PINMUX_DATA(CS5A_CE2A_MARK,                     PTR4_FN),
+        PINMUX_DATA(IOIS16_MARK,        PSA5_0,         PTR3_FN),
+        PINMUX_DATA(WAIT_MARK,                          PTR2_FN),
+        PINMUX_DATA(WE3_ICIOWR_MARK,    PSA1_0, PSA0_0, PTR1_FN),
+        PINMUX_DATA(WE2_ICIORD_MARK,    PSD1_0, PSD0_0, PTR0_FN),
+
+        PINMUX_DATA(LCDLCLK_MARK,       PSA5_1,         PTR3_FN),
+
+        PINMUX_DATA(IDEA2_MARK,         PSD1_1, PSD0_0, PTR0_FN),
+
+        PINMUX_DATA(TPUTO3_MARK,        PSA1_0, PSA0_1, PTR1_FN),
+        PINMUX_DATA(TPUTI3_MARK,        PSA1_1, PSA0_0, PTR1_FN),
+        PINMUX_DATA(TPUTO2_MARK,        PSD1_0, PSD0_1, PTR0_FN),
+
+        /* PTS FN */
+        PINMUX_DATA(VIO_CKO_MARK,       PTS6_FN),
+
+        PINMUX_DATA(TPUTI2_MARK,        PSE9_0, PSE8_1, PTS5_FN),
+
+        PINMUX_DATA(IDEIORDY_MARK,      PSE9_1, PSE8_0, PTS5_FN),
+
+        PINMUX_DATA(VIO1_FLD_MARK,      PSE9_0, PSE8_0, PTS5_FN),
+        PINMUX_DATA(VIO1_HD_MARK,       PSA10_0,        PTS4_FN),
+        PINMUX_DATA(VIO1_VD_MARK,       PSA9_0,         PTS3_FN),
+        PINMUX_DATA(VIO1_CLK_MARK,      PSA9_0,         PTS2_FN),
+        PINMUX_DATA(VIO1_D7_MARK,       PSB7_0, PSB6_0, PTS1_FN),
+        PINMUX_DATA(VIO1_D6_MARK,       PSB7_0, PSB6_0, PTS0_FN),
+
+        PINMUX_DATA(SCIF5_SCK_MARK,     PSA10_1, PTS4_FN),
+        PINMUX_DATA(SCIF5_RXD_MARK,     PSA9_1,  PTS3_FN),
+        PINMUX_DATA(SCIF5_TXD_MARK,     PSA9_1,  PTS2_FN),
+
+        PINMUX_DATA(VIO0_D15_MARK,      PSB7_0, PSB6_1, PTS1_FN),
+        PINMUX_DATA(VIO0_D14_MARK,      PSB7_0, PSB6_1, PTS0_FN),
+
+        PINMUX_DATA(IDED7_MARK,         PSB7_1, PSB6_0, PTS1_FN),
+        PINMUX_DATA(IDED6_MARK,         PSB7_1, PSB6_0, PTS0_FN),
+
+        /* PTT FN */
+        PINMUX_DATA(D15_MARK, PTT7_FN),
+        PINMUX_DATA(D14_MARK, PTT6_FN),
+        PINMUX_DATA(D13_MARK, PTT5_FN),
+        PINMUX_DATA(D12_MARK, PTT4_FN),
+        PINMUX_DATA(D11_MARK, PTT3_FN),
+        PINMUX_DATA(D10_MARK, PTT2_FN),
+        PINMUX_DATA(D9_MARK,  PTT1_FN),
+        PINMUX_DATA(D8_MARK,  PTT0_FN),
+
+        /* PTU FN */
+        PINMUX_DATA(DMAC_DACK0_MARK, PTU7_FN),
+        PINMUX_DATA(DMAC_DREQ0_MARK, PTU6_FN),
+
+        PINMUX_DATA(FSIOASD_MARK,       PSE1_0, PTU5_FN),
+        PINMUX_DATA(FSIIABCK_MARK,      PSE1_0, PTU4_FN),
+        PINMUX_DATA(FSIIALRCK_MARK,     PSE1_0, PTU3_FN),
+        PINMUX_DATA(FSIOABCK_MARK,      PSE1_0, PTU2_FN),
+        PINMUX_DATA(FSIOALRCK_MARK,     PSE1_0, PTU1_FN),
+        PINMUX_DATA(CLKAUDIOAO_MARK,    PSE0_0, PTU0_FN),
+
+        /* PTV FN */
+        PINMUX_DATA(FSIIBSD_MARK,       PSD7_0,  PSD6_0,  PTV7_FN),
+        PINMUX_DATA(FSIOBSD_MARK,       PSD7_0,  PSD6_0,  PTV6_FN),
+        PINMUX_DATA(FSIIBBCK_MARK,      PSC15_0, PSC14_0, PTV5_FN),
+        PINMUX_DATA(FSIIBLRCK_MARK,     PSC15_0, PSC14_0, PTV4_FN),
+        PINMUX_DATA(FSIOBBCK_MARK,      PSC15_0, PSC14_0, PTV3_FN),
+        PINMUX_DATA(FSIOBLRCK_MARK,     PSC15_0, PSC14_0, PTV2_FN),
+        PINMUX_DATA(CLKAUDIOBO_MARK,    PSE3_0,  PSE2_0,  PTV1_FN),
+        PINMUX_DATA(FSIIASD_MARK,       PSE10_0,          PTV0_FN),
+
+        PINMUX_DATA(MSIOF1_SS2_MARK,    PSD7_0,  PSD6_1,  PTV7_FN),
+        PINMUX_DATA(MSIOF1_RSYNC_MARK,  PSD7_1,  PSD6_0,  PTV7_FN),
+        PINMUX_DATA(MSIOF1_SS1_MARK,    PSD7_0,  PSD6_1,  PTV6_FN),
+        PINMUX_DATA(MSIOF1_RSCK_MARK,   PSD7_1,  PSD6_0,  PTV6_FN),
+        PINMUX_DATA(MSIOF1_RXD_MARK,    PSC15_0, PSC14_1, PTV5_FN),
+        PINMUX_DATA(MSIOF1_TSYNC_MARK,  PSC15_0, PSC14_1, PTV4_FN),
+        PINMUX_DATA(MSIOF1_TSCK_MARK,   PSC15_0, PSC14_1, PTV3_FN),
+        PINMUX_DATA(MSIOF1_TXD_MARK,    PSC15_0, PSC14_1, PTV2_FN),
+        PINMUX_DATA(MSIOF1_MCK_MARK,    PSE3_0,  PSE2_1,  PTV1_FN),
+
+        /* PTW FN */
+        PINMUX_DATA(MMC_D7_MARK,        PSE13_0, PSE12_0, PTW7_FN),
+        PINMUX_DATA(MMC_D6_MARK,        PSE13_0, PSE12_0, PTW6_FN),
+        PINMUX_DATA(MMC_D5_MARK,        PSE13_0, PSE12_0, PTW5_FN),
+        PINMUX_DATA(MMC_D4_MARK,        PSE13_0, PSE12_0, PTW4_FN),
+        PINMUX_DATA(MMC_D3_MARK,        PSA13_0,          PTW3_FN),
+        PINMUX_DATA(MMC_D2_MARK,        PSA13_0,          PTW2_FN),
+        PINMUX_DATA(MMC_D1_MARK,        PSA13_0,          PTW1_FN),
+        PINMUX_DATA(MMC_D0_MARK,        PSA13_0,          PTW0_FN),
+
+        PINMUX_DATA(SDHI1CD_MARK,       PSE13_0, PSE12_1, PTW7_FN),
+        PINMUX_DATA(SDHI1WP_MARK,       PSE13_0, PSE12_1, PTW6_FN),
+        PINMUX_DATA(SDHI1D3_MARK,       PSE13_0, PSE12_1, PTW5_FN),
+        PINMUX_DATA(SDHI1D2_MARK,       PSE13_0, PSE12_1, PTW4_FN),
+        PINMUX_DATA(SDHI1D1_MARK,       PSA13_1,          PTW3_FN),
+        PINMUX_DATA(SDHI1D0_MARK,       PSA13_1,          PTW2_FN),
+        PINMUX_DATA(SDHI1CMD_MARK,      PSA13_1,          PTW1_FN),
+        PINMUX_DATA(SDHI1CLK_MARK,      PSA13_1,          PTW0_FN),
+
+        PINMUX_DATA(IODACK_MARK,        PSE13_1, PSE12_0, PTW7_FN),
+        PINMUX_DATA(IDERST_MARK,        PSE13_1, PSE12_0, PTW6_FN),
+        PINMUX_DATA(EXBUF_ENB_MARK,     PSE13_1, PSE12_0, PTW5_FN),
+        PINMUX_DATA(DIRECTION_MARK,     PSE13_1, PSE12_0, PTW4_FN),
+
+        /* PTX FN */
+        PINMUX_DATA(DMAC_DACK1_MARK,    PSA12_0, PTX7_FN),
+        PINMUX_DATA(DMAC_DREQ1_MARK,    PSA12_0, PTX6_FN),
+
+        PINMUX_DATA(IRDA_OUT_MARK,      PSA12_1, PTX7_FN),
+        PINMUX_DATA(IRDA_IN_MARK,       PSA12_1, PTX6_FN),
+
+        PINMUX_DATA(TSIF_TS0_SDAT_MARK, PSC0_0, PTX5_FN),
+        PINMUX_DATA(TSIF_TS0_SCK_MARK,  PSC1_0, PTX4_FN),
+        PINMUX_DATA(TSIF_TS0_SDEN_MARK, PSC2_0, PTX3_FN),
+        PINMUX_DATA(TSIF_TS0_SPSYNC_MARK,       PTX2_FN),
+
+        PINMUX_DATA(LNKSTA_MARK,        PSC0_1, PTX5_FN),
+        PINMUX_DATA(MDIO_MARK,          PSC1_1, PTX4_FN),
+        PINMUX_DATA(MDC_MARK,           PSC2_1, PTX3_FN),
+
+        PINMUX_DATA(MMC_CLK_MARK, PTX1_FN),
+        PINMUX_DATA(MMC_CMD_MARK, PTX0_FN),
+
+        /* PTY FN */
+        PINMUX_DATA(SDHI0CD_MARK,  PTY7_FN),
+        PINMUX_DATA(SDHI0WP_MARK,  PTY6_FN),
+        PINMUX_DATA(SDHI0D3_MARK,  PTY5_FN),
+        PINMUX_DATA(SDHI0D2_MARK,  PTY4_FN),
+        PINMUX_DATA(SDHI0D1_MARK,  PTY3_FN),
+        PINMUX_DATA(SDHI0D0_MARK,  PTY2_FN),
+        PINMUX_DATA(SDHI0CMD_MARK, PTY1_FN),
+        PINMUX_DATA(SDHI0CLK_MARK, PTY0_FN),
+
+        /* PTZ FN */
+        PINMUX_DATA(INTC_IRQ7_MARK,     PSB10_0, PTZ7_FN),
+        PINMUX_DATA(INTC_IRQ6_MARK,     PSB11_0, PTZ6_FN),
+        PINMUX_DATA(INTC_IRQ5_MARK,     PSB12_0, PTZ5_FN),
+        PINMUX_DATA(INTC_IRQ4_MARK,     PSB13_0, PTZ4_FN),
+        PINMUX_DATA(INTC_IRQ3_MARK,     PSB14_0, PTZ3_FN),
+        PINMUX_DATA(INTC_IRQ2_MARK,              PTZ2_FN),
+        PINMUX_DATA(INTC_IRQ1_MARK,              PTZ1_FN),
+        PINMUX_DATA(INTC_IRQ0_MARK,              PTZ0_FN),
+
+        PINMUX_DATA(SCIF3_I_CTS_MARK,   PSB10_1, PTZ7_FN),
+        PINMUX_DATA(SCIF3_I_RTS_MARK,   PSB11_1, PTZ6_FN),
+        PINMUX_DATA(SCIF3_I_SCK_MARK,   PSB12_1, PTZ5_FN),
+        PINMUX_DATA(SCIF3_I_RXD_MARK,   PSB13_1, PTZ4_FN),
+        PINMUX_DATA(SCIF3_I_TXD_MARK,   PSB14_1, PTZ3_FN),
+};
+
+static struct pinmux_gpio pinmux_gpios[] = {
+        /* PTA */
+        PINMUX_GPIO(GPIO_PTA7, PTA7_DATA),
+        PINMUX_GPIO(GPIO_PTA6, PTA6_DATA),
+        PINMUX_GPIO(GPIO_PTA5, PTA5_DATA),
+        PINMUX_GPIO(GPIO_PTA4, PTA4_DATA),
+        PINMUX_GPIO(GPIO_PTA3, PTA3_DATA),
+        PINMUX_GPIO(GPIO_PTA2, PTA2_DATA),
+        PINMUX_GPIO(GPIO_PTA1, PTA1_DATA),
+        PINMUX_GPIO(GPIO_PTA0, PTA0_DATA),
+
+        /* PTB */
+        PINMUX_GPIO(GPIO_PTB7, PTB7_DATA),
+        PINMUX_GPIO(GPIO_PTB6, PTB6_DATA),
+        PINMUX_GPIO(GPIO_PTB5, PTB5_DATA),
+        PINMUX_GPIO(GPIO_PTB4, PTB4_DATA),
+        PINMUX_GPIO(GPIO_PTB3, PTB3_DATA),
+        PINMUX_GPIO(GPIO_PTB2, PTB2_DATA),
+        PINMUX_GPIO(GPIO_PTB1, PTB1_DATA),
+        PINMUX_GPIO(GPIO_PTB0, PTB0_DATA),
+
+        /* PTC */
+        PINMUX_GPIO(GPIO_PTC7, PTC7_DATA),
+        PINMUX_GPIO(GPIO_PTC6, PTC6_DATA),
+        PINMUX_GPIO(GPIO_PTC5, PTC5_DATA),
+        PINMUX_GPIO(GPIO_PTC4, PTC4_DATA),
+        PINMUX_GPIO(GPIO_PTC3, PTC3_DATA),
+        PINMUX_GPIO(GPIO_PTC2, PTC2_DATA),
+        PINMUX_GPIO(GPIO_PTC1, PTC1_DATA),
+        PINMUX_GPIO(GPIO_PTC0, PTC0_DATA),
+
+        /* PTD */
+        PINMUX_GPIO(GPIO_PTD7, PTD7_DATA),
+        PINMUX_GPIO(GPIO_PTD6, PTD6_DATA),
+        PINMUX_GPIO(GPIO_PTD5, PTD5_DATA),
+        PINMUX_GPIO(GPIO_PTD4, PTD4_DATA),
+        PINMUX_GPIO(GPIO_PTD3, PTD3_DATA),
+        PINMUX_GPIO(GPIO_PTD2, PTD2_DATA),
+        PINMUX_GPIO(GPIO_PTD1, PTD1_DATA),
+        PINMUX_GPIO(GPIO_PTD0, PTD0_DATA),
+
+        /* PTE */
+        PINMUX_GPIO(GPIO_PTE7, PTE7_DATA),
+        PINMUX_GPIO(GPIO_PTE6, PTE6_DATA),
+        PINMUX_GPIO(GPIO_PTE5, PTE5_DATA),
+        PINMUX_GPIO(GPIO_PTE4, PTE4_DATA),
+        PINMUX_GPIO(GPIO_PTE3, PTE3_DATA),
+        PINMUX_GPIO(GPIO_PTE2, PTE2_DATA),
+        PINMUX_GPIO(GPIO_PTE1, PTE1_DATA),
+        PINMUX_GPIO(GPIO_PTE0, PTE0_DATA),
+
+        /* PTF */
+        PINMUX_GPIO(GPIO_PTF7, PTF7_DATA),
+        PINMUX_GPIO(GPIO_PTF6, PTF6_DATA),
+        PINMUX_GPIO(GPIO_PTF5, PTF5_DATA),
+        PINMUX_GPIO(GPIO_PTF4, PTF4_DATA),
+        PINMUX_GPIO(GPIO_PTF3, PTF3_DATA),
+        PINMUX_GPIO(GPIO_PTF2, PTF2_DATA),
+        PINMUX_GPIO(GPIO_PTF1, PTF1_DATA),
+        PINMUX_GPIO(GPIO_PTF0, PTF0_DATA),
+
+        /* PTG */
+        PINMUX_GPIO(GPIO_PTG5, PTG5_DATA),
+        PINMUX_GPIO(GPIO_PTG4, PTG4_DATA),
+        PINMUX_GPIO(GPIO_PTG3, PTG3_DATA),
+        PINMUX_GPIO(GPIO_PTG2, PTG2_DATA),
+        PINMUX_GPIO(GPIO_PTG1, PTG1_DATA),
+        PINMUX_GPIO(GPIO_PTG0, PTG0_DATA),
+
+        /* PTH */
+        PINMUX_GPIO(GPIO_PTH7, PTH7_DATA),
+        PINMUX_GPIO(GPIO_PTH6, PTH6_DATA),
+        PINMUX_GPIO(GPIO_PTH5, PTH5_DATA),
+        PINMUX_GPIO(GPIO_PTH4, PTH4_DATA),
+        PINMUX_GPIO(GPIO_PTH3, PTH3_DATA),
+        PINMUX_GPIO(GPIO_PTH2, PTH2_DATA),
+        PINMUX_GPIO(GPIO_PTH1, PTH1_DATA),
+        PINMUX_GPIO(GPIO_PTH0, PTH0_DATA),
+
+        /* PTJ */
+        PINMUX_GPIO(GPIO_PTJ7, PTJ7_DATA),
+        PINMUX_GPIO(GPIO_PTJ6, PTJ6_DATA),
+        PINMUX_GPIO(GPIO_PTJ5, PTJ5_DATA),
+        PINMUX_GPIO(GPIO_PTJ3, PTJ3_DATA),
+        PINMUX_GPIO(GPIO_PTJ2, PTJ2_DATA),
+        PINMUX_GPIO(GPIO_PTJ1, PTJ1_DATA),
+        PINMUX_GPIO(GPIO_PTJ0, PTJ0_DATA),
+
+        /* PTK */
+        PINMUX_GPIO(GPIO_PTK7, PTK7_DATA),
+        PINMUX_GPIO(GPIO_PTK6, PTK6_DATA),
+        PINMUX_GPIO(GPIO_PTK5, PTK5_DATA),
+        PINMUX_GPIO(GPIO_PTK4, PTK4_DATA),
+        PINMUX_GPIO(GPIO_PTK3, PTK3_DATA),
+        PINMUX_GPIO(GPIO_PTK2, PTK2_DATA),
+        PINMUX_GPIO(GPIO_PTK1, PTK1_DATA),
+        PINMUX_GPIO(GPIO_PTK0, PTK0_DATA),
+
+        /* PTL */
+        PINMUX_GPIO(GPIO_PTL7, PTL7_DATA),
+        PINMUX_GPIO(GPIO_PTL6, PTL6_DATA),
+        PINMUX_GPIO(GPIO_PTL5, PTL5_DATA),
+        PINMUX_GPIO(GPIO_PTL4, PTL4_DATA),
+        PINMUX_GPIO(GPIO_PTL3, PTL3_DATA),
+        PINMUX_GPIO(GPIO_PTL2, PTL2_DATA),
+        PINMUX_GPIO(GPIO_PTL1, PTL1_DATA),
+        PINMUX_GPIO(GPIO_PTL0, PTL0_DATA),
+
+        /* PTM */
+        PINMUX_GPIO(GPIO_PTM7, PTM7_DATA),
+        PINMUX_GPIO(GPIO_PTM6, PTM6_DATA),
+        PINMUX_GPIO(GPIO_PTM5, PTM5_DATA),
+        PINMUX_GPIO(GPIO_PTM4, PTM4_DATA),
+        PINMUX_GPIO(GPIO_PTM3, PTM3_DATA),
+        PINMUX_GPIO(GPIO_PTM2, PTM2_DATA),
+        PINMUX_GPIO(GPIO_PTM1, PTM1_DATA),
+        PINMUX_GPIO(GPIO_PTM0, PTM0_DATA),
+
+        /* PTN */
+        PINMUX_GPIO(GPIO_PTN7, PTN7_DATA),
+        PINMUX_GPIO(GPIO_PTN6, PTN6_DATA),
+        PINMUX_GPIO(GPIO_PTN5, PTN5_DATA),
+        PINMUX_GPIO(GPIO_PTN4, PTN4_DATA),
+        PINMUX_GPIO(GPIO_PTN3, PTN3_DATA),
+        PINMUX_GPIO(GPIO_PTN2, PTN2_DATA),
+        PINMUX_GPIO(GPIO_PTN1, PTN1_DATA),
+        PINMUX_GPIO(GPIO_PTN0, PTN0_DATA),
+
+        /* PTQ */
+        PINMUX_GPIO(GPIO_PTQ7, PTQ7_DATA),
+        PINMUX_GPIO(GPIO_PTQ6, PTQ6_DATA),
+        PINMUX_GPIO(GPIO_PTQ5, PTQ5_DATA),
+        PINMUX_GPIO(GPIO_PTQ4, PTQ4_DATA),
+        PINMUX_GPIO(GPIO_PTQ3, PTQ3_DATA),
+        PINMUX_GPIO(GPIO_PTQ2, PTQ2_DATA),
+        PINMUX_GPIO(GPIO_PTQ1, PTQ1_DATA),
+        PINMUX_GPIO(GPIO_PTQ0, PTQ0_DATA),
+
+        /* PTR */
+        PINMUX_GPIO(GPIO_PTR7, PTR7_DATA),
+        PINMUX_GPIO(GPIO_PTR6, PTR6_DATA),
+        PINMUX_GPIO(GPIO_PTR5, PTR5_DATA),
+        PINMUX_GPIO(GPIO_PTR4, PTR4_DATA),
+        PINMUX_GPIO(GPIO_PTR3, PTR3_DATA),
+        PINMUX_GPIO(GPIO_PTR2, PTR2_DATA),
+        PINMUX_GPIO(GPIO_PTR1, PTR1_DATA),
+        PINMUX_GPIO(GPIO_PTR0, PTR0_DATA),
+
+        /* PTS */
+        PINMUX_GPIO(GPIO_PTS6, PTS6_DATA),
+        PINMUX_GPIO(GPIO_PTS5, PTS5_DATA),
+        PINMUX_GPIO(GPIO_PTS4, PTS4_DATA),
+        PINMUX_GPIO(GPIO_PTS3, PTS3_DATA),
+        PINMUX_GPIO(GPIO_PTS2, PTS2_DATA),
+        PINMUX_GPIO(GPIO_PTS1, PTS1_DATA),
+        PINMUX_GPIO(GPIO_PTS0, PTS0_DATA),
+
+        /* PTT */
+        PINMUX_GPIO(GPIO_PTT7, PTT7_DATA),
+        PINMUX_GPIO(GPIO_PTT6, PTT6_DATA),
+        PINMUX_GPIO(GPIO_PTT5, PTT5_DATA),
+        PINMUX_GPIO(GPIO_PTT4, PTT4_DATA),
+        PINMUX_GPIO(GPIO_PTT3, PTT3_DATA),
+        PINMUX_GPIO(GPIO_PTT2, PTT2_DATA),
+        PINMUX_GPIO(GPIO_PTT1, PTT1_DATA),
+        PINMUX_GPIO(GPIO_PTT0, PTT0_DATA),
+
+        /* PTU */
+        PINMUX_GPIO(GPIO_PTU7, PTU7_DATA),
+        PINMUX_GPIO(GPIO_PTU6, PTU6_DATA),
+        PINMUX_GPIO(GPIO_PTU5, PTU5_DATA),
+        PINMUX_GPIO(GPIO_PTU4, PTU4_DATA),
+        PINMUX_GPIO(GPIO_PTU3, PTU3_DATA),
+        PINMUX_GPIO(GPIO_PTU2, PTU2_DATA),
+        PINMUX_GPIO(GPIO_PTU1, PTU1_DATA),
+        PINMUX_GPIO(GPIO_PTU0, PTU0_DATA),
+
+        /* PTV */
+        PINMUX_GPIO(GPIO_PTV7, PTV7_DATA),
+        PINMUX_GPIO(GPIO_PTV6, PTV6_DATA),
+        PINMUX_GPIO(GPIO_PTV5, PTV5_DATA),
+        PINMUX_GPIO(GPIO_PTV4, PTV4_DATA),
+        PINMUX_GPIO(GPIO_PTV3, PTV3_DATA),
+        PINMUX_GPIO(GPIO_PTV2, PTV2_DATA),
+        PINMUX_GPIO(GPIO_PTV1, PTV1_DATA),
+        PINMUX_GPIO(GPIO_PTV0, PTV0_DATA),
+
+        /* PTW */
+        PINMUX_GPIO(GPIO_PTW7, PTW7_DATA),
+        PINMUX_GPIO(GPIO_PTW6, PTW6_DATA),
+        PINMUX_GPIO(GPIO_PTW5, PTW5_DATA),
+        PINMUX_GPIO(GPIO_PTW4, PTW4_DATA),
+        PINMUX_GPIO(GPIO_PTW3, PTW3_DATA),
+        PINMUX_GPIO(GPIO_PTW2, PTW2_DATA),
+        PINMUX_GPIO(GPIO_PTW1, PTW1_DATA),
+        PINMUX_GPIO(GPIO_PTW0, PTW0_DATA),
+
+        /* PTX */
+        PINMUX_GPIO(GPIO_PTX7, PTX7_DATA),
+        PINMUX_GPIO(GPIO_PTX6, PTX6_DATA),
+        PINMUX_GPIO(GPIO_PTX5, PTX5_DATA),
+        PINMUX_GPIO(GPIO_PTX4, PTX4_DATA),
+        PINMUX_GPIO(GPIO_PTX3, PTX3_DATA),
+        PINMUX_GPIO(GPIO_PTX2, PTX2_DATA),
+        PINMUX_GPIO(GPIO_PTX1, PTX1_DATA),
+        PINMUX_GPIO(GPIO_PTX0, PTX0_DATA),
+
+        /* PTY */
+        PINMUX_GPIO(GPIO_PTY7, PTY7_DATA),
+        PINMUX_GPIO(GPIO_PTY6, PTY6_DATA),
+        PINMUX_GPIO(GPIO_PTY5, PTY5_DATA),
+        PINMUX_GPIO(GPIO_PTY4, PTY4_DATA),
+        PINMUX_GPIO(GPIO_PTY3, PTY3_DATA),
+        PINMUX_GPIO(GPIO_PTY2, PTY2_DATA),
+        PINMUX_GPIO(GPIO_PTY1, PTY1_DATA),
+        PINMUX_GPIO(GPIO_PTY0, PTY0_DATA),
+
+        /* PTZ */
+        PINMUX_GPIO(GPIO_PTZ7, PTZ7_DATA),
+        PINMUX_GPIO(GPIO_PTZ6, PTZ6_DATA),
+        PINMUX_GPIO(GPIO_PTZ5, PTZ5_DATA),
+        PINMUX_GPIO(GPIO_PTZ4, PTZ4_DATA),
+        PINMUX_GPIO(GPIO_PTZ3, PTZ3_DATA),
+        PINMUX_GPIO(GPIO_PTZ2, PTZ2_DATA),
+        PINMUX_GPIO(GPIO_PTZ1, PTZ1_DATA),
+        PINMUX_GPIO(GPIO_PTZ0, PTZ0_DATA),
+
+        /* BSC */
+        PINMUX_GPIO(GPIO_FN_D31,        D31_MARK),
+        PINMUX_GPIO(GPIO_FN_D30,        D30_MARK),
+        PINMUX_GPIO(GPIO_FN_D29,        D29_MARK),
+        PINMUX_GPIO(GPIO_FN_D28,        D28_MARK),
+        PINMUX_GPIO(GPIO_FN_D27,        D27_MARK),
+        PINMUX_GPIO(GPIO_FN_D26,        D26_MARK),
+        PINMUX_GPIO(GPIO_FN_D25,        D25_MARK),
+        PINMUX_GPIO(GPIO_FN_D24,        D24_MARK),
+        PINMUX_GPIO(GPIO_FN_D23,        D23_MARK),
+        PINMUX_GPIO(GPIO_FN_D22,        D22_MARK),
+        PINMUX_GPIO(GPIO_FN_D21,        D21_MARK),
+        PINMUX_GPIO(GPIO_FN_D20,        D20_MARK),
+        PINMUX_GPIO(GPIO_FN_D19,        D19_MARK),
+        PINMUX_GPIO(GPIO_FN_D18,        D18_MARK),
+        PINMUX_GPIO(GPIO_FN_D17,        D17_MARK),
+        PINMUX_GPIO(GPIO_FN_D16,        D16_MARK),
+        PINMUX_GPIO(GPIO_FN_D15,        D15_MARK),
+        PINMUX_GPIO(GPIO_FN_D14,        D14_MARK),
+        PINMUX_GPIO(GPIO_FN_D13,        D13_MARK),
+        PINMUX_GPIO(GPIO_FN_D12,        D12_MARK),
+        PINMUX_GPIO(GPIO_FN_D11,        D11_MARK),
+        PINMUX_GPIO(GPIO_FN_D10,        D10_MARK),
+        PINMUX_GPIO(GPIO_FN_D9,         D9_MARK),
+        PINMUX_GPIO(GPIO_FN_D8,         D8_MARK),
+        PINMUX_GPIO(GPIO_FN_D7,         D7_MARK),
+        PINMUX_GPIO(GPIO_FN_D6,         D6_MARK),
+        PINMUX_GPIO(GPIO_FN_D5,         D5_MARK),
+        PINMUX_GPIO(GPIO_FN_D4,         D4_MARK),
+        PINMUX_GPIO(GPIO_FN_D3,         D3_MARK),
+        PINMUX_GPIO(GPIO_FN_D2,         D2_MARK),
+        PINMUX_GPIO(GPIO_FN_D1,         D1_MARK),
+        PINMUX_GPIO(GPIO_FN_D0,         D0_MARK),
+        PINMUX_GPIO(GPIO_FN_A25,        A25_MARK),
+        PINMUX_GPIO(GPIO_FN_A24,        A24_MARK),
+        PINMUX_GPIO(GPIO_FN_A23,        A23_MARK),
+        PINMUX_GPIO(GPIO_FN_A22,        A22_MARK),
+        PINMUX_GPIO(GPIO_FN_CS6B_CE1B,  CS6B_CE1B_MARK),
+        PINMUX_GPIO(GPIO_FN_CS6A_CE2B,  CS6A_CE2B_MARK),
+        PINMUX_GPIO(GPIO_FN_CS5B_CE1A,  CS5B_CE1A_MARK),
+        PINMUX_GPIO(GPIO_FN_CS5A_CE2A,  CS5A_CE2A_MARK),
+        PINMUX_GPIO(GPIO_FN_WE3_ICIOWR, WE3_ICIOWR_MARK),
+        PINMUX_GPIO(GPIO_FN_WE2_ICIORD, WE2_ICIORD_MARK),
+        PINMUX_GPIO(GPIO_FN_IOIS16,     IOIS16_MARK),
+        PINMUX_GPIO(GPIO_FN_WAIT,       WAIT_MARK),
+        PINMUX_GPIO(GPIO_FN_BS,         BS_MARK),
+
+        /* KEYSC */
+        PINMUX_GPIO(GPIO_FN_KEYOUT5_IN5,        KEYOUT5_IN5_MARK),
+        PINMUX_GPIO(GPIO_FN_KEYOUT4_IN6,        KEYOUT4_IN6_MARK),
+        PINMUX_GPIO(GPIO_FN_KEYIN4,             KEYIN4_MARK),
+        PINMUX_GPIO(GPIO_FN_KEYIN3,             KEYIN3_MARK),
+        PINMUX_GPIO(GPIO_FN_KEYIN2,             KEYIN2_MARK),
+        PINMUX_GPIO(GPIO_FN_KEYIN1,             KEYIN1_MARK),
+        PINMUX_GPIO(GPIO_FN_KEYIN0,             KEYIN0_MARK),
+        PINMUX_GPIO(GPIO_FN_KEYOUT3,            KEYOUT3_MARK),
+        PINMUX_GPIO(GPIO_FN_KEYOUT2,            KEYOUT2_MARK),
+        PINMUX_GPIO(GPIO_FN_KEYOUT1,            KEYOUT1_MARK),
+        PINMUX_GPIO(GPIO_FN_KEYOUT0,            KEYOUT0_MARK),
+
+        /* ATAPI */
+        PINMUX_GPIO(GPIO_FN_IDED15,     IDED15_MARK),
+        PINMUX_GPIO(GPIO_FN_IDED14,     IDED14_MARK),
+        PINMUX_GPIO(GPIO_FN_IDED13,     IDED13_MARK),
+        PINMUX_GPIO(GPIO_FN_IDED12,     IDED12_MARK),
+        PINMUX_GPIO(GPIO_FN_IDED11,     IDED11_MARK),
+        PINMUX_GPIO(GPIO_FN_IDED10,     IDED10_MARK),
+        PINMUX_GPIO(GPIO_FN_IDED9,      IDED9_MARK),
+        PINMUX_GPIO(GPIO_FN_IDED8,      IDED8_MARK),
+        PINMUX_GPIO(GPIO_FN_IDED7,      IDED7_MARK),
+        PINMUX_GPIO(GPIO_FN_IDED6,      IDED6_MARK),
+        PINMUX_GPIO(GPIO_FN_IDED5,      IDED5_MARK),
+        PINMUX_GPIO(GPIO_FN_IDED4,      IDED4_MARK),
+        PINMUX_GPIO(GPIO_FN_IDED3,      IDED3_MARK),
+        PINMUX_GPIO(GPIO_FN_IDED2,      IDED2_MARK),
+        PINMUX_GPIO(GPIO_FN_IDED1,      IDED1_MARK),
+        PINMUX_GPIO(GPIO_FN_IDED0,      IDED0_MARK),
+        PINMUX_GPIO(GPIO_FN_IDEA2,      IDEA2_MARK),
+        PINMUX_GPIO(GPIO_FN_IDEA1,      IDEA1_MARK),
+        PINMUX_GPIO(GPIO_FN_IDEA0,      IDEA0_MARK),
+        PINMUX_GPIO(GPIO_FN_IDEIOWR,    IDEIOWR_MARK),
+        PINMUX_GPIO(GPIO_FN_IODREQ,     IODREQ_MARK),
+        PINMUX_GPIO(GPIO_FN_IDECS0,     IDECS0_MARK),
+        PINMUX_GPIO(GPIO_FN_IDECS1,     IDECS1_MARK),
+        PINMUX_GPIO(GPIO_FN_IDEIORD,    IDEIORD_MARK),
+        PINMUX_GPIO(GPIO_FN_DIRECTION,  DIRECTION_MARK),
+        PINMUX_GPIO(GPIO_FN_EXBUF_ENB,  EXBUF_ENB_MARK),
+        PINMUX_GPIO(GPIO_FN_IDERST,     IDERST_MARK),
+        PINMUX_GPIO(GPIO_FN_IODACK,     IODACK_MARK),
+        PINMUX_GPIO(GPIO_FN_IDEINT,     IDEINT_MARK),
+        PINMUX_GPIO(GPIO_FN_IDEIORDY,   IDEIORDY_MARK),
+
+        /* TPU */
+        PINMUX_GPIO(GPIO_FN_TPUTO3,     TPUTO3_MARK),
+        PINMUX_GPIO(GPIO_FN_TPUTO2,     TPUTO2_MARK),
+        PINMUX_GPIO(GPIO_FN_TPUTO1,     TPUTO1_MARK),
+        PINMUX_GPIO(GPIO_FN_TPUTO0,     TPUTO0_MARK),
+        PINMUX_GPIO(GPIO_FN_TPUTI3,     TPUTI3_MARK),
+        PINMUX_GPIO(GPIO_FN_TPUTI2,     TPUTI2_MARK),
+
+        /* LCDC */
+        PINMUX_GPIO(GPIO_FN_LCDD23,     LCDD23_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD22,     LCDD22_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD21,     LCDD21_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD20,     LCDD20_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD19,     LCDD19_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD18,     LCDD18_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD17,     LCDD17_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD16,     LCDD16_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD15,     LCDD15_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD14,     LCDD14_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD13,     LCDD13_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD12,     LCDD12_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD11,     LCDD11_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD10,     LCDD10_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD9,      LCDD9_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD8,      LCDD8_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD7,      LCDD7_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD6,      LCDD6_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD5,      LCDD5_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD4,      LCDD4_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD3,      LCDD3_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD2,      LCDD2_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD1,      LCDD1_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDD0,      LCDD0_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDVSYN,    LCDVSYN_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDDISP,    LCDDISP_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDRS,      LCDRS_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDHSYN,    LCDHSYN_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDCS,      LCDCS_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDDON,     LCDDON_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDDCK,     LCDDCK_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDWR,      LCDWR_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDVEPWC,   LCDVEPWC_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDVCPWC,   LCDVCPWC_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDRD,      LCDRD_MARK),
+        PINMUX_GPIO(GPIO_FN_LCDLCLK,    LCDLCLK_MARK),
+
+        /* SCIF0 */
+        PINMUX_GPIO(GPIO_FN_SCIF0_TXD,  SCIF0_TXD_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF0_RXD,  SCIF0_RXD_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF0_SCK,  SCIF0_SCK_MARK),
+
+        /* SCIF1 */
+        PINMUX_GPIO(GPIO_FN_SCIF1_SCK,  SCIF1_SCK_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF1_RXD,  SCIF1_RXD_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF1_TXD,  SCIF1_TXD_MARK),
+
+        /* SCIF2 */
+        PINMUX_GPIO(GPIO_FN_SCIF2_L_TXD,        SCIF2_L_TXD_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF2_L_SCK,        SCIF2_L_SCK_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF2_L_RXD,        SCIF2_L_RXD_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF2_V_TXD,        SCIF2_V_TXD_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF2_V_SCK,        SCIF2_V_SCK_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF2_V_RXD,        SCIF2_V_RXD_MARK),
+
+        /* SCIF3 */
+        PINMUX_GPIO(GPIO_FN_SCIF3_V_SCK,        SCIF3_V_SCK_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF3_V_RXD,        SCIF3_V_RXD_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF3_V_TXD,        SCIF3_V_TXD_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF3_V_CTS,        SCIF3_V_CTS_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF3_V_RTS,        SCIF3_V_RTS_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF3_I_SCK,        SCIF3_I_SCK_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF3_I_RXD,        SCIF3_I_RXD_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF3_I_TXD,        SCIF3_I_TXD_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF3_I_CTS,        SCIF3_I_CTS_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF3_I_RTS,        SCIF3_I_RTS_MARK),
+
+        /* SCIF4 */
+        PINMUX_GPIO(GPIO_FN_SCIF4_SCK,  SCIF4_SCK_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF4_RXD,  SCIF4_RXD_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF4_TXD,  SCIF4_TXD_MARK),
+
+        /* SCIF5 */
+        PINMUX_GPIO(GPIO_FN_SCIF5_SCK,  SCIF5_SCK_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF5_RXD,  SCIF5_RXD_MARK),
+        PINMUX_GPIO(GPIO_FN_SCIF5_TXD,  SCIF5_TXD_MARK),
+
+        /* FSI */
+        PINMUX_GPIO(GPIO_FN_FSIMCKB,    FSIMCKB_MARK),
+        PINMUX_GPIO(GPIO_FN_FSIMCKA,    FSIMCKA_MARK),
+        PINMUX_GPIO(GPIO_FN_FSIOASD,    FSIOASD_MARK),
+        PINMUX_GPIO(GPIO_FN_FSIIABCK,   FSIIABCK_MARK),
+        PINMUX_GPIO(GPIO_FN_FSIIALRCK,  FSIIALRCK_MARK),
+        PINMUX_GPIO(GPIO_FN_FSIOABCK,   FSIOABCK_MARK),
+        PINMUX_GPIO(GPIO_FN_FSIOALRCK,  FSIOALRCK_MARK),
+        PINMUX_GPIO(GPIO_FN_CLKAUDIOAO, CLKAUDIOAO_MARK),
+        PINMUX_GPIO(GPIO_FN_FSIIBSD,    FSIIBSD_MARK),
+        PINMUX_GPIO(GPIO_FN_FSIOBSD,    FSIOBSD_MARK),
+        PINMUX_GPIO(GPIO_FN_FSIIBBCK,   FSIIBBCK_MARK),
+        PINMUX_GPIO(GPIO_FN_FSIIBLRCK,  FSIIBLRCK_MARK),
+        PINMUX_GPIO(GPIO_FN_FSIOBBCK,   FSIOBBCK_MARK),
+        PINMUX_GPIO(GPIO_FN_FSIOBLRCK,  FSIOBLRCK_MARK),
+        PINMUX_GPIO(GPIO_FN_CLKAUDIOBO, CLKAUDIOBO_MARK),
+        PINMUX_GPIO(GPIO_FN_FSIIASD,    FSIIASD_MARK),
+
+        /* AUD */
+        PINMUX_GPIO(GPIO_FN_AUDCK,      AUDCK_MARK),
+        PINMUX_GPIO(GPIO_FN_AUDSYNC,    AUDSYNC_MARK),
+        PINMUX_GPIO(GPIO_FN_AUDATA3,    AUDATA3_MARK),
+        PINMUX_GPIO(GPIO_FN_AUDATA2,    AUDATA2_MARK),
+        PINMUX_GPIO(GPIO_FN_AUDATA1,    AUDATA1_MARK),
+        PINMUX_GPIO(GPIO_FN_AUDATA0,    AUDATA0_MARK),
+
+        /* VIO */
+        PINMUX_GPIO(GPIO_FN_VIO_CKO,    VIO_CKO_MARK),
+
+        /* VIO0 */
+        PINMUX_GPIO(GPIO_FN_VIO0_D15,   VIO0_D15_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_D14,   VIO0_D14_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_D13,   VIO0_D13_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_D12,   VIO0_D12_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_D11,   VIO0_D11_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_D10,   VIO0_D10_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_D9,    VIO0_D9_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_D8,    VIO0_D8_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_D7,    VIO0_D7_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_D6,    VIO0_D6_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_D5,    VIO0_D5_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_D4,    VIO0_D4_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_D3,    VIO0_D3_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_D2,    VIO0_D2_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_D1,    VIO0_D1_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_D0,    VIO0_D0_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_VD,    VIO0_VD_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_CLK,   VIO0_CLK_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_FLD,   VIO0_FLD_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO0_HD,    VIO0_HD_MARK),
+
+        /* VIO1 */
+        PINMUX_GPIO(GPIO_FN_VIO1_D7,    VIO1_D7_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO1_D6,    VIO1_D6_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO1_D5,    VIO1_D5_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO1_D4,    VIO1_D4_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO1_D3,    VIO1_D3_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO1_D2,    VIO1_D2_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO1_D1,    VIO1_D1_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO1_D0,    VIO1_D0_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO1_FLD,   VIO1_FLD_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO1_HD,    VIO1_HD_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO1_VD,    VIO1_VD_MARK),
+        PINMUX_GPIO(GPIO_FN_VIO1_CLK,   VIO1_CLK_MARK),
+
+        /* Eth */
+        PINMUX_GPIO(GPIO_FN_RMII_RXD0,          RMII_RXD0_MARK),
+        PINMUX_GPIO(GPIO_FN_RMII_RXD1,          RMII_RXD1_MARK),
+        PINMUX_GPIO(GPIO_FN_RMII_TXD0,          RMII_TXD0_MARK),
+        PINMUX_GPIO(GPIO_FN_RMII_TXD1,          RMII_TXD1_MARK),
+        PINMUX_GPIO(GPIO_FN_RMII_REF_CLK,       RMII_REF_CLK_MARK),
+        PINMUX_GPIO(GPIO_FN_RMII_TX_EN,         RMII_TX_EN_MARK),
+        PINMUX_GPIO(GPIO_FN_RMII_RX_ER,         RMII_RX_ER_MARK),
+        PINMUX_GPIO(GPIO_FN_RMII_CRS_DV,        RMII_CRS_DV_MARK),
+        PINMUX_GPIO(GPIO_FN_LNKSTA,             LNKSTA_MARK),
+        PINMUX_GPIO(GPIO_FN_MDIO,               MDIO_MARK),
+        PINMUX_GPIO(GPIO_FN_MDC,                MDC_MARK),
+
+        /* System */
+        PINMUX_GPIO(GPIO_FN_PDSTATUS,   PDSTATUS_MARK),
+        PINMUX_GPIO(GPIO_FN_STATUS2,    STATUS2_MARK),
+        PINMUX_GPIO(GPIO_FN_STATUS0,    STATUS0_MARK),
+
+        /* VOU */
+        PINMUX_GPIO(GPIO_FN_DV_D15,     DV_D15_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_D14,     DV_D14_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_D13,     DV_D13_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_D12,     DV_D12_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_D11,     DV_D11_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_D10,     DV_D10_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_D9,      DV_D9_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_D8,      DV_D8_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_D7,      DV_D7_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_D6,      DV_D6_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_D5,      DV_D5_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_D4,      DV_D4_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_D3,      DV_D3_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_D2,      DV_D2_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_D1,      DV_D1_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_D0,      DV_D0_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_CLKI,    DV_CLKI_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_CLK,     DV_CLK_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_VSYNC,   DV_VSYNC_MARK),
+        PINMUX_GPIO(GPIO_FN_DV_HSYNC,   DV_HSYNC_MARK),
+
+        /* MSIOF0 */
+        PINMUX_GPIO(GPIO_FN_MSIOF0_RXD,         MSIOF0_RXD_MARK),
+        PINMUX_GPIO(GPIO_FN_MSIOF0_TXD,         MSIOF0_TXD_MARK),
+        PINMUX_GPIO(GPIO_FN_MSIOF0_MCK,         MSIOF0_MCK_MARK),
+        PINMUX_GPIO(GPIO_FN_MSIOF0_TSCK,        MSIOF0_TSCK_MARK),
+        PINMUX_GPIO(GPIO_FN_MSIOF0_SS1,         MSIOF0_SS1_MARK),
+        PINMUX_GPIO(GPIO_FN_MSIOF0_SS2,         MSIOF0_SS2_MARK),
+        PINMUX_GPIO(GPIO_FN_MSIOF0_TSYNC,       MSIOF0_TSYNC_MARK),
+        PINMUX_GPIO(GPIO_FN_MSIOF0_RSCK,        MSIOF0_RSCK_MARK),
+        PINMUX_GPIO(GPIO_FN_MSIOF0_RSYNC,       MSIOF0_RSYNC_MARK),
+
+        /* MSIOF1 */
+        PINMUX_GPIO(GPIO_FN_MSIOF1_RXD,         MSIOF1_RXD_MARK),
+        PINMUX_GPIO(GPIO_FN_MSIOF1_TXD,         MSIOF1_TXD_MARK),
+        PINMUX_GPIO(GPIO_FN_MSIOF1_MCK,         MSIOF1_MCK_MARK),
+        PINMUX_GPIO(GPIO_FN_MSIOF1_TSCK,        MSIOF1_TSCK_MARK),
+        PINMUX_GPIO(GPIO_FN_MSIOF1_SS1,         MSIOF1_SS1_MARK),
+        PINMUX_GPIO(GPIO_FN_MSIOF1_SS2,         MSIOF1_SS2_MARK),
+        PINMUX_GPIO(GPIO_FN_MSIOF1_TSYNC,       MSIOF1_TSYNC_MARK),
+        PINMUX_GPIO(GPIO_FN_MSIOF1_RSCK,        MSIOF1_RSCK_MARK),
+        PINMUX_GPIO(GPIO_FN_MSIOF1_RSYNC,       MSIOF1_RSYNC_MARK),
+
+        /* DMAC */
+        PINMUX_GPIO(GPIO_FN_DMAC_DACK0, DMAC_DACK0_MARK),
+        PINMUX_GPIO(GPIO_FN_DMAC_DREQ0, DMAC_DREQ0_MARK),
+        PINMUX_GPIO(GPIO_FN_DMAC_DACK1, DMAC_DACK1_MARK),
+        PINMUX_GPIO(GPIO_FN_DMAC_DREQ1, DMAC_DREQ1_MARK),
+
+        /* SDHI0 */
+        PINMUX_GPIO(GPIO_FN_SDHI0CD,    SDHI0CD_MARK),
+        PINMUX_GPIO(GPIO_FN_SDHI0WP,    SDHI0WP_MARK),
+        PINMUX_GPIO(GPIO_FN_SDHI0CMD,   SDHI0CMD_MARK),
+        PINMUX_GPIO(GPIO_FN_SDHI0CLK,   SDHI0CLK_MARK),
+        PINMUX_GPIO(GPIO_FN_SDHI0D3,    SDHI0D3_MARK),
+        PINMUX_GPIO(GPIO_FN_SDHI0D2,    SDHI0D2_MARK),
+        PINMUX_GPIO(GPIO_FN_SDHI0D1,    SDHI0D1_MARK),
+        PINMUX_GPIO(GPIO_FN_SDHI0D0,    SDHI0D0_MARK),
+
+        /* SDHI1 */
+        PINMUX_GPIO(GPIO_FN_SDHI1CD,    SDHI1CD_MARK),
+        PINMUX_GPIO(GPIO_FN_SDHI1WP,    SDHI1WP_MARK),
+        PINMUX_GPIO(GPIO_FN_SDHI1CMD,   SDHI1CMD_MARK),
+        PINMUX_GPIO(GPIO_FN_SDHI1CLK,   SDHI1CLK_MARK),
+        PINMUX_GPIO(GPIO_FN_SDHI1D3,    SDHI1D3_MARK),
+        PINMUX_GPIO(GPIO_FN_SDHI1D2,    SDHI1D2_MARK),
+        PINMUX_GPIO(GPIO_FN_SDHI1D1,    SDHI1D1_MARK),
+        PINMUX_GPIO(GPIO_FN_SDHI1D0,    SDHI1D0_MARK),
+
+        /* MMC */
+        PINMUX_GPIO(GPIO_FN_MMC_D7,     MMC_D7_MARK),
+        PINMUX_GPIO(GPIO_FN_MMC_D6,     MMC_D6_MARK),
+        PINMUX_GPIO(GPIO_FN_MMC_D5,     MMC_D5_MARK),
+        PINMUX_GPIO(GPIO_FN_MMC_D4,     MMC_D4_MARK),
+        PINMUX_GPIO(GPIO_FN_MMC_D3,     MMC_D3_MARK),
+        PINMUX_GPIO(GPIO_FN_MMC_D2,     MMC_D2_MARK),
+        PINMUX_GPIO(GPIO_FN_MMC_D1,     MMC_D1_MARK),
+        PINMUX_GPIO(GPIO_FN_MMC_D0,     MMC_D0_MARK),
+        PINMUX_GPIO(GPIO_FN_MMC_CLK,    MMC_CLK_MARK),
+        PINMUX_GPIO(GPIO_FN_MMC_CMD,    MMC_CMD_MARK),
+
+        /* IrDA */
+        PINMUX_GPIO(GPIO_FN_IRDA_OUT,   IRDA_OUT_MARK),
+        PINMUX_GPIO(GPIO_FN_IRDA_IN,    IRDA_IN_MARK),
+
+        /* TSIF */
+        PINMUX_GPIO(GPIO_FN_TSIF_TS0_SDAT,      TSIF_TS0_SDAT_MARK),
+        PINMUX_GPIO(GPIO_FN_TSIF_TS0_SCK,       TSIF_TS0_SCK_MARK),
+        PINMUX_GPIO(GPIO_FN_TSIF_TS0_SDEN,      TSIF_TS0_SDEN_MARK),
+        PINMUX_GPIO(GPIO_FN_TSIF_TS0_SPSYNC,    TSIF_TS0_SPSYNC_MARK),
+
+        /* IRQ */
+        PINMUX_GPIO(GPIO_FN_INTC_IRQ7,  INTC_IRQ7_MARK),
+        PINMUX_GPIO(GPIO_FN_INTC_IRQ6,  INTC_IRQ6_MARK),
+        PINMUX_GPIO(GPIO_FN_INTC_IRQ5,  INTC_IRQ5_MARK),
+        PINMUX_GPIO(GPIO_FN_INTC_IRQ4,  INTC_IRQ4_MARK),
+        PINMUX_GPIO(GPIO_FN_INTC_IRQ3,  INTC_IRQ3_MARK),
+        PINMUX_GPIO(GPIO_FN_INTC_IRQ2,  INTC_IRQ2_MARK),
+        PINMUX_GPIO(GPIO_FN_INTC_IRQ1,  INTC_IRQ1_MARK),
+        PINMUX_GPIO(GPIO_FN_INTC_IRQ0,  INTC_IRQ0_MARK),
+ };
+
+static struct pinmux_cfg_reg pinmux_config_regs[] = {
+        { PINMUX_CFG_REG("PACR", 0xa4050100, 16, 2) {
+                PTA7_FN, PTA7_OUT, PTA7_IN_PU, PTA7_IN,
+                PTA6_FN, PTA6_OUT, PTA6_IN_PU, PTA6_IN,
+                PTA5_FN, PTA5_OUT, PTA5_IN_PU, PTA5_IN,
+                PTA4_FN, PTA4_OUT, PTA4_IN_PU, PTA4_IN,
+                PTA3_FN, PTA3_OUT, PTA3_IN_PU, PTA3_IN,
+                PTA2_FN, PTA2_OUT, PTA2_IN_PU, PTA2_IN,
+                PTA1_FN, PTA1_OUT, PTA1_IN_PU, PTA1_IN,
+                PTA0_FN, PTA0_OUT, PTA0_IN_PU, PTA0_IN }
+        },
+        { PINMUX_CFG_REG("PBCR", 0xa4050102, 16, 2) {
+                PTB7_FN, PTB7_OUT, PTB7_IN_PU, PTB7_IN,
+                PTB6_FN, PTB6_OUT, PTB6_IN_PU, PTB6_IN,
+                PTB5_FN, PTB5_OUT, PTB5_IN_PU, PTB5_IN,
+                PTB4_FN, PTB4_OUT, PTB4_IN_PU, PTB4_IN,
+                PTB3_FN, PTB3_OUT, PTB3_IN_PU, PTB3_IN,
+                PTB2_FN, PTB2_OUT, PTB2_IN_PU, PTB2_IN,
+                PTB1_FN, PTB1_OUT, PTB1_IN_PU, PTB1_IN,
+                PTB0_FN, PTB0_OUT, PTB0_IN_PU, PTB0_IN }
+        },
+        { PINMUX_CFG_REG("PCCR", 0xa4050104, 16, 2) {
+                PTC7_FN, PTC7_OUT, PTC7_IN_PU, PTC7_IN,
+                PTC6_FN, PTC6_OUT, PTC6_IN_PU, PTC6_IN,
+                PTC5_FN, PTC5_OUT, PTC5_IN_PU, PTC5_IN,
+                PTC4_FN, PTC4_OUT, PTC4_IN_PU, PTC4_IN,
+                PTC3_FN, PTC3_OUT, PTC3_IN_PU, PTC3_IN,
+                PTC2_FN, PTC2_OUT, PTC2_IN_PU, PTC2_IN,
+                PTC1_FN, PTC1_OUT, PTC1_IN_PU, PTC1_IN,
+                PTC0_FN, PTC0_OUT, PTC0_IN_PU, PTC0_IN }
+        },
+        { PINMUX_CFG_REG("PDCR", 0xa4050106, 16, 2) {
+                PTD7_FN, PTD7_OUT, PTD7_IN_PU, PTD7_IN,
+                PTD6_FN, PTD6_OUT, PTD6_IN_PU, PTD6_IN,
+                PTD5_FN, PTD5_OUT, PTD5_IN_PU, PTD5_IN,
+                PTD4_FN, PTD4_OUT, PTD4_IN_PU, PTD4_IN,
+                PTD3_FN, PTD3_OUT, PTD3_IN_PU, PTD3_IN,
+                PTD2_FN, PTD2_OUT, PTD2_IN_PU, PTD2_IN,
+                PTD1_FN, PTD1_OUT, PTD1_IN_PU, PTD1_IN,
+                PTD0_FN, PTD0_OUT, PTD0_IN_PU, PTD0_IN }
+        },
+        { PINMUX_CFG_REG("PECR", 0xa4050108, 16, 2) {
+                PTE7_FN, PTE7_OUT, PTE7_IN_PU, PTE7_IN,
+                PTE6_FN, PTE6_OUT, PTE6_IN_PU, PTE6_IN,
+                PTE5_FN, PTE5_OUT, PTE5_IN_PU, PTE5_IN,
+                PTE4_FN, PTE4_OUT, PTE4_IN_PU, PTE4_IN,
+                PTE3_FN, PTE3_OUT, PTE3_IN_PU, PTE3_IN,
+                PTE2_FN, PTE2_OUT, PTE2_IN_PU, PTE2_IN,
+                PTE1_FN, PTE1_OUT, PTE1_IN_PU, PTE1_IN,
+                PTE0_FN, PTE0_OUT, PTE0_IN_PU, PTE0_IN }
+        },
+        { PINMUX_CFG_REG("PFCR", 0xa405010a, 16, 2) {
+                PTF7_FN, PTF7_OUT, PTF7_IN_PU, PTF7_IN,
+                PTF6_FN, PTF6_OUT, PTF6_IN_PU, PTF6_IN,
+                PTF5_FN, PTF5_OUT, PTF5_IN_PU, PTF5_IN,
+                PTF4_FN, PTF4_OUT, PTF4_IN_PU, PTF4_IN,
+                PTF3_FN, PTF3_OUT, PTF3_IN_PU, PTF3_IN,
+                PTF2_FN, PTF2_OUT, PTF2_IN_PU, PTF2_IN,
+                PTF1_FN, PTF1_OUT, PTF1_IN_PU, PTF1_IN,
+                PTF0_FN, PTF0_OUT, PTF0_IN_PU, PTF0_IN }
+        },
+        { PINMUX_CFG_REG("PGCR", 0xa405010c, 16, 2) {
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                PTG5_FN, PTG5_OUT, 0, 0,
+                PTG4_FN, PTG4_OUT, 0, 0,
+                PTG3_FN, PTG3_OUT, 0, 0,
+                PTG2_FN, PTG2_OUT, 0, 0,
+                PTG1_FN, PTG1_OUT, 0, 0,
+                PTG0_FN, PTG0_OUT, 0, 0 }
+        },
+        { PINMUX_CFG_REG("PHCR", 0xa405010e, 16, 2) {
+                PTH7_FN, PTH7_OUT, PTH7_IN_PU, PTH7_IN,
+                PTH6_FN, PTH6_OUT, PTH6_IN_PU, PTH6_IN,
+                PTH5_FN, PTH5_OUT, PTH5_IN_PU, PTH5_IN,
+                PTH4_FN, PTH4_OUT, PTH4_IN_PU, PTH4_IN,
+                PTH3_FN, PTH3_OUT, PTH3_IN_PU, PTH3_IN,
+                PTH2_FN, PTH2_OUT, PTH2_IN_PU, PTH2_IN,
+                PTH1_FN, PTH1_OUT, PTH1_IN_PU, PTH1_IN,
+                PTH0_FN, PTH0_OUT, PTH0_IN_PU, PTH0_IN }
+        },
+        { PINMUX_CFG_REG("PJCR", 0xa4050110, 16, 2) {
+                PTJ7_FN, PTJ7_OUT, 0, 0,
+                PTJ6_FN, PTJ6_OUT, 0, 0,
+                PTJ5_FN, PTJ5_OUT, 0, 0,
+                0, 0, 0, 0,
+                PTJ3_FN, PTJ3_OUT, PTJ3_IN_PU, PTJ3_IN,
+                PTJ2_FN, PTJ2_OUT, PTJ2_IN_PU, PTJ2_IN,
+                PTJ1_FN, PTJ1_OUT, PTJ1_IN_PU, PTJ1_IN,
+                PTJ0_FN, PTJ0_OUT, PTJ0_IN_PU, PTJ0_IN }
+        },
+        { PINMUX_CFG_REG("PKCR", 0xa4050112, 16, 2) {
+                PTK7_FN, PTK7_OUT, PTK7_IN_PU, PTK7_IN,
+                PTK6_FN, PTK6_OUT, PTK6_IN_PU, PTK6_IN,
+                PTK5_FN, PTK5_OUT, PTK5_IN_PU, PTK5_IN,
+                PTK4_FN, PTK4_OUT, PTK4_IN_PU, PTK4_IN,
+                PTK3_FN, PTK3_OUT, PTK3_IN_PU, PTK3_IN,
+                PTK2_FN, PTK2_OUT, PTK2_IN_PU, PTK2_IN,
+                PTK1_FN, PTK1_OUT, PTK1_IN_PU, PTK1_IN,
+                PTK0_FN, PTK0_OUT, PTK0_IN_PU, PTK0_IN }
+        },
+        { PINMUX_CFG_REG("PLCR", 0xa4050114, 16, 2) {
+                PTL7_FN, PTL7_OUT, PTL7_IN_PU, PTL7_IN,
+                PTL6_FN, PTL6_OUT, PTL6_IN_PU, PTL6_IN,
+                PTL5_FN, PTL5_OUT, PTL5_IN_PU, PTL5_IN,
+                PTL4_FN, PTL4_OUT, PTL4_IN_PU, PTL4_IN,
+                PTL3_FN, PTL3_OUT, PTL3_IN_PU, PTL3_IN,
+                PTL2_FN, PTL2_OUT, PTL2_IN_PU, PTL2_IN,
+                PTL1_FN, PTL1_OUT, PTL1_IN_PU, PTL1_IN,
+                PTL0_FN, PTL0_OUT, PTL0_IN_PU, PTL0_IN }
+        },
+        { PINMUX_CFG_REG("PMCR", 0xa4050116, 16, 2) {
+                PTM7_FN, PTM7_OUT, PTM7_IN_PU, PTM7_IN,
+                PTM6_FN, PTM6_OUT, PTM6_IN_PU, PTM6_IN,
+                PTM5_FN, PTM5_OUT, PTM5_IN_PU, PTM5_IN,
+                PTM4_FN, PTM4_OUT, PTM4_IN_PU, PTM4_IN,
+                PTM3_FN, PTM3_OUT, PTM3_IN_PU, PTM3_IN,
+                PTM2_FN, PTM2_OUT, PTM2_IN_PU, PTM2_IN,
+                PTM1_FN, PTM1_OUT, PTM1_IN_PU, PTM1_IN,
+                PTM0_FN, PTM0_OUT, PTM0_IN_PU, PTM0_IN }
+        },
+        { PINMUX_CFG_REG("PNCR", 0xa4050118, 16, 2) {
+                PTN7_FN, PTN7_OUT, PTN7_IN_PU, PTN7_IN,
+                PTN6_FN, PTN6_OUT, PTN6_IN_PU, PTN6_IN,
+                PTN5_FN, PTN5_OUT, PTN5_IN_PU, PTN5_IN,
+                PTN4_FN, PTN4_OUT, PTN4_IN_PU, PTN4_IN,
+                PTN3_FN, PTN3_OUT, PTN3_IN_PU, PTN3_IN,
+                PTN2_FN, PTN2_OUT, PTN2_IN_PU, PTN2_IN,
+                PTN1_FN, PTN1_OUT, PTN1_IN_PU, PTN1_IN,
+                PTN0_FN, PTN0_OUT, PTN0_IN_PU, PTN0_IN }
+        },
+        { PINMUX_CFG_REG("PQCR", 0xa405011a, 16, 2) {
+                PTQ7_FN, PTQ7_OUT, PTQ7_IN_PU, PTQ7_IN,
+                PTQ6_FN, PTQ6_OUT, PTQ6_IN_PU, PTQ6_IN,
+                PTQ5_FN, PTQ5_OUT, PTQ5_IN_PU, PTQ5_IN,
+                PTQ4_FN, PTQ4_OUT, PTQ4_IN_PU, PTQ4_IN,
+                PTQ3_FN, PTQ3_OUT, PTQ3_IN_PU, PTQ3_IN,
+                PTQ2_FN, PTQ2_OUT, PTQ2_IN_PU, PTQ2_IN,
+                PTQ1_FN, PTQ1_OUT, PTQ1_IN_PU, PTQ1_IN,
+                PTQ0_FN, PTQ0_OUT, PTQ0_IN_PU, PTQ0_IN }
+        },
+        { PINMUX_CFG_REG("PRCR", 0xa405011c, 16, 2) {
+                PTR7_FN, PTR7_OUT, PTR7_IN_PU, PTR7_IN,
+                PTR6_FN, PTR6_OUT, PTR6_IN_PU, PTR6_IN,
+                PTR5_FN, PTR5_OUT, PTR5_IN_PU, PTR5_IN,
+                PTR4_FN, PTR4_OUT, PTR4_IN_PU, PTR4_IN,
+                PTR3_FN, 0,        PTR3_IN_PU, PTR3_IN,
+                PTR2_FN, 0,        PTR2_IN_PU, PTR2_IN,
+                PTR1_FN, PTR1_OUT, PTR1_IN_PU, PTR1_IN,
+                PTR0_FN, PTR0_OUT, PTR0_IN_PU, PTR0_IN }
+        },
+        { PINMUX_CFG_REG("PSCR", 0xa405011e, 16, 2) {
+                0, 0, 0, 0,
+                PTS6_FN, PTS6_OUT, PTS6_IN_PU, PTS6_IN,
+                PTS5_FN, PTS5_OUT, PTS5_IN_PU, PTS5_IN,
+                PTS4_FN, PTS4_OUT, PTS4_IN_PU, PTS4_IN,
+                PTS3_FN, PTS3_OUT, PTS3_IN_PU, PTS3_IN,
+                PTS2_FN, PTS2_OUT, PTS2_IN_PU, PTS2_IN,
+                PTS1_FN, PTS1_OUT, PTS1_IN_PU, PTS1_IN,
+                PTS0_FN, PTS0_OUT, PTS0_IN_PU, PTS0_IN }
+        },
+        { PINMUX_CFG_REG("PTCR", 0xa4050140, 16, 2) {
+                PTT7_FN, PTT7_OUT, PTT7_IN_PU, PTT7_IN,
+                PTT6_FN, PTT6_OUT, PTT6_IN_PU, PTT6_IN,
+                PTT5_FN, PTT5_OUT, PTT5_IN_PU, PTT5_IN,
+                PTT4_FN, PTT4_OUT, PTT4_IN_PU, PTT4_IN,
+                PTT3_FN, PTT3_OUT, PTT3_IN_PU, PTT3_IN,
+                PTT2_FN, PTT2_OUT, PTT2_IN_PU, PTT2_IN,
+                PTT1_FN, PTT1_OUT, PTT1_IN_PU, PTT1_IN,
+                PTT0_FN, PTT0_OUT, PTT0_IN_PU, PTT0_IN }
+        },
+        { PINMUX_CFG_REG("PUCR", 0xa4050142, 16, 2) {
+                PTU7_FN, PTU7_OUT, PTU7_IN_PU, PTU7_IN,
+                PTU6_FN, PTU6_OUT, PTU6_IN_PU, PTU6_IN,
+                PTU5_FN, PTU5_OUT, PTU5_IN_PU, PTU5_IN,
+                PTU4_FN, PTU4_OUT, PTU4_IN_PU, PTU4_IN,
+                PTU3_FN, PTU3_OUT, PTU3_IN_PU, PTU3_IN,
+                PTU2_FN, PTU2_OUT, PTU2_IN_PU, PTU2_IN,
+                PTU1_FN, PTU1_OUT, PTU1_IN_PU, PTU1_IN,
+                PTU0_FN, PTU0_OUT, PTU0_IN_PU, PTU0_IN }
+        },
+        { PINMUX_CFG_REG("PVCR", 0xa4050144, 16, 2) {
+                PTV7_FN, PTV7_OUT, PTV7_IN_PU, PTV7_IN,
+                PTV6_FN, PTV6_OUT, PTV6_IN_PU, PTV6_IN,
+                PTV5_FN, PTV5_OUT, PTV5_IN_PU, PTV5_IN,
+                PTV4_FN, PTV4_OUT, PTV4_IN_PU, PTV4_IN,
+                PTV3_FN, PTV3_OUT, PTV3_IN_PU, PTV3_IN,
+                PTV2_FN, PTV2_OUT, PTV2_IN_PU, PTV2_IN,
+                PTV1_FN, PTV1_OUT, PTV1_IN_PU, PTV1_IN,
+                PTV0_FN, PTV0_OUT, PTV0_IN_PU, PTV0_IN }
+        },
+        { PINMUX_CFG_REG("PWCR", 0xa4050146, 16, 2) {
+                PTW7_FN, PTW7_OUT, PTW7_IN_PU, PTW7_IN,
+                PTW6_FN, PTW6_OUT, PTW6_IN_PU, PTW6_IN,
+                PTW5_FN, PTW5_OUT, PTW5_IN_PU, PTW5_IN,
+                PTW4_FN, PTW4_OUT, PTW4_IN_PU, PTW4_IN,
+                PTW3_FN, PTW3_OUT, PTW3_IN_PU, PTW3_IN,
+                PTW2_FN, PTW2_OUT, PTW2_IN_PU, PTW2_IN,
+                PTW1_FN, PTW1_OUT, PTW1_IN_PU, PTW1_IN,
+                PTW0_FN, PTW0_OUT, PTW0_IN_PU, PTW0_IN }
+        },
+        { PINMUX_CFG_REG("PXCR", 0xa4050148, 16, 2) {
+                PTX7_FN, PTX7_OUT, PTX7_IN_PU, PTX7_IN,
+                PTX6_FN, PTX6_OUT, PTX6_IN_PU, PTX6_IN,
+                PTX5_FN, PTX5_OUT, PTX5_IN_PU, PTX5_IN,
+                PTX4_FN, PTX4_OUT, PTX4_IN_PU, PTX4_IN,
+                PTX3_FN, PTX3_OUT, PTX3_IN_PU, PTX3_IN,
+                PTX2_FN, PTX2_OUT, PTX2_IN_PU, PTX2_IN,
+                PTX1_FN, PTX1_OUT, PTX1_IN_PU, PTX1_IN,
+                PTX0_FN, PTX0_OUT, PTX0_IN_PU, PTX0_IN }
+        },
+        { PINMUX_CFG_REG("PYCR", 0xa405014a, 16, 2) {
+                PTY7_FN, PTY7_OUT, PTY7_IN_PU, PTY7_IN,
+                PTY6_FN, PTY6_OUT, PTY6_IN_PU, PTY6_IN,
+                PTY5_FN, PTY5_OUT, PTY5_IN_PU, PTY5_IN,
+                PTY4_FN, PTY4_OUT, PTY4_IN_PU, PTY4_IN,
+                PTY3_FN, PTY3_OUT, PTY3_IN_PU, PTY3_IN,
+                PTY2_FN, PTY2_OUT, PTY2_IN_PU, PTY2_IN,
+                PTY1_FN, PTY1_OUT, PTY1_IN_PU, PTY1_IN,
+                PTY0_FN, PTY0_OUT, PTY0_IN_PU, PTY0_IN }
+        },
+        { PINMUX_CFG_REG("PZCR", 0xa405014c, 16, 2) {
+                PTZ7_FN, PTZ7_OUT, PTZ7_IN_PU, PTZ7_IN,
+                PTZ6_FN, PTZ6_OUT, PTZ6_IN_PU, PTZ6_IN,
+                PTZ5_FN, PTZ5_OUT, PTZ5_IN_PU, PTZ5_IN,
+                PTZ4_FN, PTZ4_OUT, PTZ4_IN_PU, PTZ4_IN,
+                PTZ3_FN, PTZ3_OUT, PTZ3_IN_PU, PTZ3_IN,
+                PTZ2_FN, PTZ2_OUT, PTZ2_IN_PU, PTZ2_IN,
+                PTZ1_FN, PTZ1_OUT, PTZ1_IN_PU, PTZ1_IN,
+                PTZ0_FN, PTZ0_OUT, PTZ0_IN_PU, PTZ0_IN }
+        },
+        { PINMUX_CFG_REG("PSELA", 0xa405014e, 16, 1) {
+                PSA15_0, PSA15_1,
+                PSA14_0, PSA14_1,
+                PSA13_0, PSA13_1,
+                PSA12_0, PSA12_1,
+                0, 0,
+                PSA10_0, PSA10_1,
+                PSA9_0,  PSA9_1,
+                PSA8_0,  PSA8_1,
+                PSA7_0,  PSA7_1,
+                PSA6_0,  PSA6_1,
+                PSA5_0,  PSA5_1,
+                0, 0,
+                PSA3_0,  PSA3_1,
+                PSA2_0,  PSA2_1,
+                PSA1_0,  PSA1_1,
+                PSA0_0,  PSA0_1}
+        },
+        { PINMUX_CFG_REG("PSELB", 0xa4050150, 16, 1) {
+                0, 0,
+                PSB14_0, PSB14_1,
+                PSB13_0, PSB13_1,
+                PSB12_0, PSB12_1,
+                PSB11_0, PSB11_1,
+                PSB10_0, PSB10_1,
+                PSB9_0,  PSB9_1,
+                PSB8_0,  PSB8_1,
+                PSB7_0,  PSB7_1,
+                PSB6_0,  PSB6_1,
+                PSB5_0,  PSB5_1,
+                PSB4_0,  PSB4_1,
+                PSB3_0,  PSB3_1,
+                PSB2_0,  PSB2_1,
+                PSB1_0,  PSB1_1,
+                PSB0_0,  PSB0_1}
+        },
+        { PINMUX_CFG_REG("PSELC", 0xa4050152, 16, 1) {
+                PSC15_0, PSC15_1,
+                PSC14_0, PSC14_1,
+                PSC13_0, PSC13_1,
+                PSC12_0, PSC12_1,
+                PSC11_0, PSC11_1,
+                PSC10_0, PSC10_1,
+                PSC9_0,  PSC9_1,
+                PSC8_0,  PSC8_1,
+                PSC7_0,  PSC7_1,
+                PSC6_0,  PSC6_1,
+                PSC5_0,  PSC5_1,
+                PSC4_0,  PSC4_1,
+                0, 0,
+                PSC2_0,  PSC2_1,
+                PSC1_0,  PSC1_1,
+                PSC0_0,  PSC0_1}
+        },
+        { PINMUX_CFG_REG("PSELD", 0xa4050154, 16, 1) {
+                PSD15_0, PSD15_1,
+                PSD14_0, PSD14_1,
+                PSD13_0, PSD13_1,
+                PSD12_0, PSD12_1,
+                PSD11_0, PSD11_1,
+                PSD10_0, PSD10_1,
+                PSD9_0,  PSD9_1,
+                PSD8_0,  PSD8_1,
+                PSD7_0,  PSD7_1,
+                PSD6_0,  PSD6_1,
+                PSD5_0,  PSD5_1,
+                PSD4_0,  PSD4_1,
+                PSD3_0,  PSD3_1,
+                PSD2_0,  PSD2_1,
+                PSD1_0,  PSD1_1,
+                PSD0_0,  PSD0_1}
+        },
+        { PINMUX_CFG_REG("PSELE", 0xa4050156, 16, 1) {
+                PSE15_0, PSE15_1,
+                PSE14_0, PSE14_1,
+                PSE13_0, PSE13_1,
+                PSE12_0, PSE12_1,
+                PSE11_0, PSE11_1,
+                PSE10_0, PSE10_1,
+                PSE9_0,  PSE9_1,
+                PSE8_0,  PSE8_1,
+                PSE7_0,  PSE7_1,
+                PSE6_0,  PSE6_1,
+                PSE5_0,  PSE5_1,
+                PSE4_0,  PSE4_1,
+                PSE3_0,  PSE3_1,
+                PSE2_0,  PSE2_1,
+                PSE1_0,  PSE1_1,
+                PSE0_0,  PSE0_1}
+        },
+        {}
+};
+
+static struct pinmux_data_reg pinmux_data_regs[] = {
+        { PINMUX_DATA_REG("PADR", 0xa4050120, 8) {
+                PTA7_DATA, PTA6_DATA, PTA5_DATA, PTA4_DATA,
+                PTA3_DATA, PTA2_DATA, PTA1_DATA, PTA0_DATA }
+        },
+        { PINMUX_DATA_REG("PBDR", 0xa4050122, 8) {
+                PTB7_DATA, PTB6_DATA, PTB5_DATA, PTB4_DATA,
+                PTB3_DATA, PTB2_DATA, PTB1_DATA, PTB0_DATA }
+        },
+        { PINMUX_DATA_REG("PCDR", 0xa4050124, 8) {
+                PTC7_DATA, PTC6_DATA, PTC5_DATA, PTC4_DATA,
+                PTC3_DATA, PTC2_DATA, PTC1_DATA, PTC0_DATA }
+        },
+        { PINMUX_DATA_REG("PDDR", 0xa4050126, 8) {
+                PTD7_DATA, PTD6_DATA, PTD5_DATA, PTD4_DATA,
+                PTD3_DATA, PTD2_DATA, PTD1_DATA, PTD0_DATA }
+        },
+        { PINMUX_DATA_REG("PEDR", 0xa4050128, 8) {
+                PTE7_DATA, PTE6_DATA, PTE5_DATA, PTE4_DATA,
+                PTE3_DATA, PTE2_DATA, PTE1_DATA, PTE0_DATA }
+        },
+        { PINMUX_DATA_REG("PFDR", 0xa405012a, 8) {
+                PTF7_DATA, PTF6_DATA, PTF5_DATA, PTF4_DATA,
+                PTF3_DATA, PTF2_DATA, PTF1_DATA, PTF0_DATA }
+        },
+        { PINMUX_DATA_REG("PGDR", 0xa405012c, 8) {
+                0,         0,         PTG5_DATA, PTG4_DATA,
+                PTG3_DATA, PTG2_DATA, PTG1_DATA, PTG0_DATA }
+        },
+        { PINMUX_DATA_REG("PHDR", 0xa405012e, 8) {
+                PTH7_DATA, PTH6_DATA, PTH5_DATA, PTH4_DATA,
+                PTH3_DATA, PTH2_DATA, PTH1_DATA, PTH0_DATA }
+        },
+        { PINMUX_DATA_REG("PJDR", 0xa4050130, 8) {
+                PTJ7_DATA, PTJ6_DATA, PTJ5_DATA, 0,
+                PTJ3_DATA, PTJ2_DATA, PTJ1_DATA, PTJ0_DATA }
+        },
+        { PINMUX_DATA_REG("PKDR", 0xa4050132, 8) {
+                PTK7_DATA, PTK6_DATA, PTK5_DATA, PTK4_DATA,
+                PTK3_DATA, PTK2_DATA, PTK1_DATA, PTK0_DATA }
+        },
+        { PINMUX_DATA_REG("PLDR", 0xa4050134, 8) {
+                PTL7_DATA, PTL6_DATA, PTL5_DATA, PTL4_DATA,
+                PTL3_DATA, PTL2_DATA, PTL1_DATA, PTL0_DATA }
+        },
+        { PINMUX_DATA_REG("PMDR", 0xa4050136, 8) {
+                PTM7_DATA, PTM6_DATA, PTM5_DATA, PTM4_DATA,
+                PTM3_DATA, PTM2_DATA, PTM1_DATA, PTM0_DATA }
+        },
+        { PINMUX_DATA_REG("PNDR", 0xa4050138, 8) {
+                PTN7_DATA, PTN6_DATA, PTN5_DATA, PTN4_DATA,
+                PTN3_DATA, PTN2_DATA, PTN1_DATA, PTN0_DATA }
+        },
+        { PINMUX_DATA_REG("PQDR", 0xa405013a, 8) {
+                PTQ7_DATA, PTQ6_DATA, PTQ5_DATA, PTQ4_DATA,
+                PTQ3_DATA, PTQ2_DATA, PTQ1_DATA, PTQ0_DATA }
+        },
+        { PINMUX_DATA_REG("PRDR", 0xa405013c, 8) {
+                PTR7_DATA, PTR6_DATA, PTR5_DATA, PTR4_DATA,
+                PTR3_DATA, PTR2_DATA, PTR1_DATA, PTR0_DATA }
+        },
+        { PINMUX_DATA_REG("PSDR", 0xa405013e, 8) {
+                0,         PTS6_DATA, PTS5_DATA, PTS4_DATA,
+                PTS3_DATA, PTS2_DATA, PTS1_DATA, PTS0_DATA }
+        },
+        { PINMUX_DATA_REG("PTDR", 0xa4050160, 8) {
+                PTT7_DATA, PTT6_DATA, PTT5_DATA, PTT4_DATA,
+                PTT3_DATA, PTT2_DATA, PTT1_DATA, PTT0_DATA }
+        },
+        { PINMUX_DATA_REG("PUDR", 0xa4050162, 8) {
+                PTU7_DATA, PTU6_DATA, PTU5_DATA, PTU4_DATA,
+                PTU3_DATA, PTU2_DATA, PTU1_DATA, PTU0_DATA }
+        },
+        { PINMUX_DATA_REG("PVDR", 0xa4050164, 8) {
+                PTV7_DATA, PTV6_DATA, PTV5_DATA, PTV4_DATA,
+                PTV3_DATA, PTV2_DATA, PTV1_DATA, PTV0_DATA }
+        },
+        { PINMUX_DATA_REG("PWDR", 0xa4050166, 8) {
+                PTW7_DATA, PTW6_DATA, PTW5_DATA, PTW4_DATA,
+                PTW3_DATA, PTW2_DATA, PTW1_DATA, PTW0_DATA }
+        },
+        { PINMUX_DATA_REG("PXDR", 0xa4050168, 8) {
+                PTX7_DATA, PTX6_DATA, PTX5_DATA, PTX4_DATA,
+                PTX3_DATA, PTX2_DATA, PTX1_DATA, PTX0_DATA }
+        },
+        { PINMUX_DATA_REG("PYDR", 0xa405016a, 8) {
+                PTY7_DATA, PTY6_DATA, PTY5_DATA, PTY4_DATA,
+                PTY3_DATA, PTY2_DATA, PTY1_DATA, PTY0_DATA }
+        },
+        { PINMUX_DATA_REG("PZDR", 0xa405016c, 8) {
+                PTZ7_DATA, PTZ6_DATA, PTZ5_DATA, PTZ4_DATA,
+                PTZ3_DATA, PTZ2_DATA, PTZ1_DATA, PTZ0_DATA }
+        },
+        { },
+};
+
+static struct pinmux_info sh7724_pinmux_info = {
+        .name = "sh7724_pfc",
+        .reserved_id = PINMUX_RESERVED,
+        .data = { PINMUX_DATA_BEGIN, PINMUX_DATA_END },
+        .input = { PINMUX_INPUT_BEGIN, PINMUX_INPUT_END },
+        .input_pu = { PINMUX_INPUT_PULLUP_BEGIN, PINMUX_INPUT_PULLUP_END },
+        .output = { PINMUX_OUTPUT_BEGIN, PINMUX_OUTPUT_END },
+        .mark = { PINMUX_MARK_BEGIN, PINMUX_MARK_END },
+        .function = { PINMUX_FUNCTION_BEGIN, PINMUX_FUNCTION_END },
+
+        .first_gpio = GPIO_PTA7,
+        .last_gpio = GPIO_FN_INTC_IRQ0,
+
+        .gpios = pinmux_gpios,
+        .cfg_regs = pinmux_config_regs,
+        .data_regs = pinmux_data_regs,
+
+        .gpio_data = pinmux_data,
+        .gpio_data_size = ARRAY_SIZE(pinmux_data),
+};
+
+static int __init plat_pinmux_setup(void)
+{
+        return register_pinmux(&sh7724_pinmux_info);
+}
+arch_initcall(plat_pinmux_setup);
diff --git a/arch/sh/kernel/cpu/sh4a/setup-sh7343.c b/arch/sh/kernel/cpu/sh4a/setup-sh7343.c
index c1549382c87c..6307e087c864 100644
--- a/arch/sh/kernel/cpu/sh4a/setup-sh7343.c
+++ b/arch/sh/kernel/cpu/sh4a/setup-sh7343.c
@@ -12,7 +12,7 @@
 #include <linux/serial.h>
 #include <linux/serial_sci.h>
 #include <linux/uio_driver.h>
-#include <linux/sh_cmt.h>
+#include <linux/sh_timer.h>
 #include <asm/clock.h>
 
 static struct resource iic0_resources[] = {
@@ -141,7 +141,7 @@ static struct platform_device jpu_device = {
         .num_resources  = ARRAY_SIZE(jpu_resources),
 };
 
-static struct sh_cmt_config cmt_platform_data = {
+static struct sh_timer_config cmt_platform_data = {
         .name = "CMT",
         .channel_offset = 0x60,
         .timer_bit = 5,
@@ -173,27 +173,123 @@ static struct platform_device cmt_device = {
         .num_resources  = ARRAY_SIZE(cmt_resources),
 };
 
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "tmu0",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = 0xffd80008,
+                .end    = 0xffd80013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 16,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "tmu0",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = 0xffd80014,
+                .end    = 0xffd8001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 17,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "tmu0",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = 0xffd80020,
+                .end    = 0xffd8002b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 18,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
 static struct plat_sci_port sci_platform_data[] = {
         {
                 .mapbase        = 0xffe00000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIF,
                 .irqs           = { 80, 80, 80, 80 },
+                .clk            = "scif0",
         }, {
                 .mapbase        = 0xffe10000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIF,
                 .irqs           = { 81, 81, 81, 81 },
+                .clk            = "scif1",
         }, {
                 .mapbase        = 0xffe20000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIF,
                 .irqs           = { 82, 82, 82, 82 },
+                .clk            = "scif2",
         }, {
                 .mapbase        = 0xffe30000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIF,
                 .irqs           = { 83, 83, 83, 83 },
+                .clk            = "scif3",
         }, {
                 .flags = 0,
         }
@@ -209,6 +305,9 @@ static struct platform_device sci_device = {
 
 static struct platform_device *sh7343_devices[] __initdata = {
         &cmt_device,
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
         &iic0_device,
         &iic1_device,
         &sci_device,
@@ -219,12 +318,6 @@ static struct platform_device *sh7343_devices[] __initdata = {
 
 static int __init sh7343_devices_setup(void)
 {
-        clk_always_enable("uram0"); /* URAM */
-        clk_always_enable("xymem0"); /* XYMEM */
-        clk_always_enable("veu0"); /* VEU */
-        clk_always_enable("vpu0"); /* VPU */
-        clk_always_enable("jpu0"); /* JPU */
-
         platform_resource_setup_memory(&vpu_device, "vpu", 1 << 20);
         platform_resource_setup_memory(&veu_device, "veu", 2 << 20);
         platform_resource_setup_memory(&jpu_device, "jpu", 2 << 20);
@@ -234,6 +327,19 @@ static int __init sh7343_devices_setup(void)
 }
 __initcall(sh7343_devices_setup);
 
+static struct platform_device *sh7343_early_devices[] __initdata = {
+        &cmt_device,
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+};
+
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(sh7343_early_devices,
+                                   ARRAY_SIZE(sh7343_early_devices));
+}
+
 enum {
         UNUSED = 0,
 
diff --git a/arch/sh/kernel/cpu/sh4a/setup-sh7366.c b/arch/sh/kernel/cpu/sh4a/setup-sh7366.c
index 93ecf8ed5c6c..318516f6bfad 100644
--- a/arch/sh/kernel/cpu/sh4a/setup-sh7366.c
+++ b/arch/sh/kernel/cpu/sh4a/setup-sh7366.c
@@ -14,7 +14,7 @@
 #include <linux/serial.h>
 #include <linux/serial_sci.h>
 #include <linux/uio_driver.h>
-#include <linux/sh_cmt.h>
+#include <linux/sh_timer.h>
 #include <asm/clock.h>
 
 static struct resource iic_resources[] = {
@@ -148,7 +148,7 @@ static struct platform_device veu1_device = {
         .num_resources  = ARRAY_SIZE(veu1_resources),
 };
 
-static struct sh_cmt_config cmt_platform_data = {
+static struct sh_timer_config cmt_platform_data = {
         .name = "CMT",
         .channel_offset = 0x60,
         .timer_bit = 5,
@@ -180,12 +180,105 @@ static struct platform_device cmt_device = {
         .num_resources  = ARRAY_SIZE(cmt_resources),
 };
 
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "tmu0",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = 0xffd80008,
+                .end    = 0xffd80013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 16,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "tmu0",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = 0xffd80014,
+                .end    = 0xffd8001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 17,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "tmu0",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = 0xffd80020,
+                .end    = 0xffd8002b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 18,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
 static struct plat_sci_port sci_platform_data[] = {
         {
                 .mapbase        = 0xffe00000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIF,
                 .irqs           = { 80, 80, 80, 80 },
+                .clk            = "scif0",
         }, {
                 .flags = 0,
         }
@@ -201,6 +294,9 @@ static struct platform_device sci_device = {
 
 static struct platform_device *sh7366_devices[] __initdata = {
         &cmt_device,
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
         &iic_device,
         &sci_device,
         &usb_host_device,
@@ -211,12 +307,6 @@ static struct platform_device *sh7366_devices[] __initdata = {
 
 static int __init sh7366_devices_setup(void)
 {
-        clk_always_enable("rsmem0"); /* RSMEM */
-        clk_always_enable("xymem0"); /* XYMEM */
-        clk_always_enable("veu1"); /* VEU-2 */
-        clk_always_enable("veu0"); /* VEU-1 */
-        clk_always_enable("vpu0"); /* VPU */
-
         platform_resource_setup_memory(&vpu_device, "vpu", 2 << 20);
         platform_resource_setup_memory(&veu0_device, "veu0", 2 << 20);
         platform_resource_setup_memory(&veu1_device, "veu1", 2 << 20);
@@ -226,6 +316,19 @@ static int __init sh7366_devices_setup(void)
 }
 __initcall(sh7366_devices_setup);
 
+static struct platform_device *sh7366_early_devices[] __initdata = {
+        &cmt_device,
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+};
+
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(sh7366_early_devices,
+                                   ARRAY_SIZE(sh7366_early_devices));
+}
+
 enum {
         UNUSED=0,
 
diff --git a/arch/sh/kernel/cpu/sh4a/setup-sh7722.c b/arch/sh/kernel/cpu/sh4a/setup-sh7722.c
index 406747f07dc0..ea524a2da3e4 100644
--- a/arch/sh/kernel/cpu/sh4a/setup-sh7722.c
+++ b/arch/sh/kernel/cpu/sh4a/setup-sh7722.c
@@ -13,7 +13,7 @@
 #include <linux/serial_sci.h>
 #include <linux/mm.h>
 #include <linux/uio_driver.h>
-#include <linux/sh_cmt.h>
+#include <linux/sh_timer.h>
 #include <asm/clock.h>
 #include <asm/mmzone.h>
 
@@ -177,13 +177,13 @@ static struct platform_device jpu_device = {
         .num_resources  = ARRAY_SIZE(jpu_resources),
 };
 
-static struct sh_cmt_config cmt_platform_data = {
+static struct sh_timer_config cmt_platform_data = {
         .name = "CMT",
         .channel_offset = 0x60,
         .timer_bit = 5,
         .clk = "cmt0",
         .clockevent_rating = 125,
-        .clocksource_rating = 200,
+        .clocksource_rating = 125,
 };
 
 static struct resource cmt_resources[] = {
@@ -209,24 +209,119 @@ static struct platform_device cmt_device = {
         .num_resources  = ARRAY_SIZE(cmt_resources),
 };
 
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "tmu0",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = 0xffd80008,
+                .end    = 0xffd80013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 16,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "tmu0",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = 0xffd80014,
+                .end    = 0xffd8001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 17,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "tmu0",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = 0xffd80020,
+                .end    = 0xffd8002b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 18,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
 static struct plat_sci_port sci_platform_data[] = {
         {
                 .mapbase        = 0xffe00000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIF,
                 .irqs           = { 80, 80, 80, 80 },
+                .clk            = "scif0",
         },
         {
                 .mapbase        = 0xffe10000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIF,
                 .irqs           = { 81, 81, 81, 81 },
+                .clk            = "scif1",
         },
         {
                 .mapbase        = 0xffe20000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIF,
                 .irqs           = { 82, 82, 82, 82 },
+                .clk            = "scif2",
         },
         {
                 .flags = 0,
@@ -243,6 +338,9 @@ static struct platform_device sci_device = {
 
 static struct platform_device *sh7722_devices[] __initdata = {
         &cmt_device,
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
         &rtc_device,
         &usbf_device,
         &iic_device,
@@ -254,12 +352,6 @@ static struct platform_device *sh7722_devices[] __initdata = {
 
 static int __init sh7722_devices_setup(void)
 {
-        clk_always_enable("uram0"); /* URAM */
-        clk_always_enable("xymem0"); /* XYMEM */
-        clk_always_enable("veu0"); /* VEU */
-        clk_always_enable("vpu0"); /* VPU */
-        clk_always_enable("jpu0"); /* JPU */
-
         platform_resource_setup_memory(&vpu_device, "vpu", 1 << 20);
         platform_resource_setup_memory(&veu_device, "veu", 2 << 20);
         platform_resource_setup_memory(&jpu_device, "jpu", 2 << 20);
@@ -269,6 +361,19 @@ static int __init sh7722_devices_setup(void)
 }
 __initcall(sh7722_devices_setup);
 
+static struct platform_device *sh7722_early_devices[] __initdata = {
+        &cmt_device,
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+};
+
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(sh7722_early_devices,
+                                   ARRAY_SIZE(sh7722_early_devices));
+}
+
 enum {
         UNUSED=0,
 
diff --git a/arch/sh/kernel/cpu/sh4a/setup-sh7723.c b/arch/sh/kernel/cpu/sh4a/setup-sh7723.c
index a800466b938c..d8f4a13aeff9 100644
--- a/arch/sh/kernel/cpu/sh4a/setup-sh7723.c
+++ b/arch/sh/kernel/cpu/sh4a/setup-sh7723.c
@@ -13,7 +13,8 @@
 #include <linux/mm.h>
 #include <linux/serial_sci.h>
 #include <linux/uio_driver.h>
-#include <linux/sh_cmt.h>
+#include <linux/sh_timer.h>
+#include <linux/io.h>
 #include <asm/clock.h>
 #include <asm/mmzone.h>
 
@@ -101,13 +102,13 @@ static struct platform_device veu1_device = {
         .num_resources  = ARRAY_SIZE(veu1_resources),
 };
 
-static struct sh_cmt_config cmt_platform_data = {
+static struct sh_timer_config cmt_platform_data = {
         .name = "CMT",
         .channel_offset = 0x60,
         .timer_bit = 5,
         .clk = "cmt0",
         .clockevent_rating = 125,
-        .clocksource_rating = 200,
+        .clocksource_rating = 125,
 };
 
 static struct resource cmt_resources[] = {
@@ -133,37 +134,225 @@ static struct platform_device cmt_device = {
         .num_resources  = ARRAY_SIZE(cmt_resources),
 };
 
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "tmu0",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = 0xffd80008,
+                .end    = 0xffd80013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 16,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "tmu0",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = 0xffd80014,
+                .end    = 0xffd8001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 17,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "tmu0",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = 0xffd80020,
+                .end    = 0xffd8002b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 18,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
+static struct sh_timer_config tmu3_platform_data = {
+        .name = "TMU3",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "tmu1",
+};
+
+static struct resource tmu3_resources[] = {
+        [0] = {
+                .name   = "TMU3",
+                .start  = 0xffd90008,
+                .end    = 0xffd90013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 57,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu3_device = {
+        .name           = "sh_tmu",
+        .id             = 3,
+        .dev = {
+                .platform_data  = &tmu3_platform_data,
+        },
+        .resource       = tmu3_resources,
+        .num_resources  = ARRAY_SIZE(tmu3_resources),
+};
+
+static struct sh_timer_config tmu4_platform_data = {
+        .name = "TMU4",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "tmu1",
+};
+
+static struct resource tmu4_resources[] = {
+        [0] = {
+                .name   = "TMU4",
+                .start  = 0xffd90014,
+                .end    = 0xffd9001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 58,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu4_device = {
+        .name           = "sh_tmu",
+        .id             = 4,
+        .dev = {
+                .platform_data  = &tmu4_platform_data,
+        },
+        .resource       = tmu4_resources,
+        .num_resources  = ARRAY_SIZE(tmu4_resources),
+};
+
+static struct sh_timer_config tmu5_platform_data = {
+        .name = "TMU5",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "tmu1",
+};
+
+static struct resource tmu5_resources[] = {
+        [0] = {
+                .name   = "TMU5",
+                .start  = 0xffd90020,
+                .end    = 0xffd9002b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 57,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu5_device = {
+        .name           = "sh_tmu",
+        .id             = 5,
+        .dev = {
+                .platform_data  = &tmu5_platform_data,
+        },
+        .resource       = tmu5_resources,
+        .num_resources  = ARRAY_SIZE(tmu5_resources),
+};
+
 static struct plat_sci_port sci_platform_data[] = {
         {
                 .mapbase        = 0xffe00000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIF,
                 .irqs           = { 80, 80, 80, 80 },
+                .clk            = "scif0",
         },{
                 .mapbase        = 0xffe10000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIF,
                 .irqs           = { 81, 81, 81, 81 },
+                .clk            = "scif1",
         },{
                 .mapbase        = 0xffe20000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIF,
                 .irqs           = { 82, 82, 82, 82 },
+                .clk            = "scif2",
         },{
                 .mapbase        = 0xa4e30000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIFA,
                 .irqs           = { 56, 56, 56, 56 },
+                .clk            = "scif3",
         },{
                 .mapbase        = 0xa4e40000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIFA,
                 .irqs           = { 88, 88, 88, 88 },
+                .clk            = "scif4",
         },{
                 .mapbase        = 0xa4e50000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIFA,
                 .irqs           = { 109, 109, 109, 109 },
+                .clk            = "scif5",
         }, {
                 .flags = 0,
         }
@@ -255,6 +444,12 @@ static struct platform_device iic_device = {
 
 static struct platform_device *sh7723_devices[] __initdata = {
         &cmt_device,
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+        &tmu3_device,
+        &tmu4_device,
+        &tmu5_device,
         &sci_device,
         &rtc_device,
         &iic_device,
@@ -266,11 +461,6 @@ static struct platform_device *sh7723_devices[] __initdata = {
 
 static int __init sh7723_devices_setup(void)
 {
-        clk_always_enable("meram0"); /* MERAM */
-        clk_always_enable("veu1"); /* VEU2H1 */
-        clk_always_enable("veu0"); /* VEU2H0 */
-        clk_always_enable("vpu0"); /* VPU */
-
         platform_resource_setup_memory(&vpu_device, "vpu", 2 << 20);
         platform_resource_setup_memory(&veu0_device, "veu0", 2 << 20);
         platform_resource_setup_memory(&veu1_device, "veu1", 2 << 20);
@@ -280,6 +470,31 @@ static int __init sh7723_devices_setup(void)
 }
 __initcall(sh7723_devices_setup);
 
+static struct platform_device *sh7723_early_devices[] __initdata = {
+        &cmt_device,
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+        &tmu3_device,
+        &tmu4_device,
+        &tmu5_device,
+};
+
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(sh7723_early_devices,
+                                   ARRAY_SIZE(sh7723_early_devices));
+}
+
+#define RAMCR_CACHE_L2FC        0x0002
+#define RAMCR_CACHE_L2E         0x0001
+#define L2_CACHE_ENABLE         (RAMCR_CACHE_L2E|RAMCR_CACHE_L2FC)
+void __uses_jump_to_uncached l2_cache_init(void)
+{
+        /* Enable L2 cache */
+        ctrl_outl(L2_CACHE_ENABLE, RAMCR);
+}
+
 enum {
         UNUSED=0,
 
diff --git a/arch/sh/kernel/cpu/sh4a/setup-sh7724.c b/arch/sh/kernel/cpu/sh4a/setup-sh7724.c
new file mode 100644
index 000000000000..e5ac9eb11c63
--- /dev/null
+++ b/arch/sh/kernel/cpu/sh4a/setup-sh7724.c
@@ -0,0 +1,786 @@
+/*
+ * SH7724 Setup
+ *
+ * Copyright (C) 2009 Renesas Solutions Corp.
+ *
+ * Kuninori Morimoto <morimoto.kuninori@renesas.com>
+ *
+ * Based on SH7723 Setup
+ * Copyright (C) 2008  Paul Mundt
+ *
+ * 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.
+ */
+#include <linux/platform_device.h>
+#include <linux/init.h>
+#include <linux/serial.h>
+#include <linux/mm.h>
+#include <linux/serial_sci.h>
+#include <linux/uio_driver.h>
+#include <linux/sh_timer.h>
+#include <linux/io.h>
+#include <asm/clock.h>
+#include <asm/mmzone.h>
+
+/* Serial */
+static struct plat_sci_port sci_platform_data[] = {
+        {
+                .mapbase        = 0xffe00000,
+                .flags          = UPF_BOOT_AUTOCONF,
+                .type           = PORT_SCIF,
+                .irqs           = { 80, 80, 80, 80 },
+                .clk            = "scif0",
+        }, {
+                .mapbase        = 0xffe10000,
+                .flags          = UPF_BOOT_AUTOCONF,
+                .type           = PORT_SCIF,
+                .irqs           = { 81, 81, 81, 81 },
+                .clk            = "scif1",
+        }, {
+                .mapbase        = 0xffe20000,
+                .flags          = UPF_BOOT_AUTOCONF,
+                .type           = PORT_SCIF,
+                .irqs           = { 82, 82, 82, 82 },
+                .clk            = "scif2",
+        }, {
+                .mapbase        = 0xa4e30000,
+                .flags          = UPF_BOOT_AUTOCONF,
+                .type           = PORT_SCIFA,
+                .irqs           = { 56, 56, 56, 56 },
+                .clk            = "scif3",
+        }, {
+                .mapbase        = 0xa4e40000,
+                .flags          = UPF_BOOT_AUTOCONF,
+                .type           = PORT_SCIFA,
+                .irqs           = { 88, 88, 88, 88 },
+                .clk            = "scif4",
+        }, {
+                .mapbase        = 0xa4e50000,
+                .flags          = UPF_BOOT_AUTOCONF,
+                .type           = PORT_SCIFA,
+                .irqs           = { 109, 109, 109, 109 },
+                .clk            = "scif5",
+        }, {
+                .flags = 0,
+        }
+};
+
+static struct platform_device sci_device = {
+        .name           = "sh-sci",
+        .id             = -1,
+        .dev            = {
+                .platform_data  = sci_platform_data,
+        },
+};
+
+/* RTC */
+static struct resource rtc_resources[] = {
+        [0] = {
+                .start  = 0xa465fec0,
+                .end    = 0xa465fec0 + 0x58 - 1,
+                .flags  = IORESOURCE_IO,
+        },
+        [1] = {
+                /* Period IRQ */
+                .start  = 69,
+                .flags  = IORESOURCE_IRQ,
+        },
+        [2] = {
+                /* Carry IRQ */
+                .start  = 70,
+                .flags  = IORESOURCE_IRQ,
+        },
+        [3] = {
+                /* Alarm IRQ */
+                .start  = 68,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device rtc_device = {
+        .name           = "sh-rtc",
+        .id             = -1,
+        .num_resources  = ARRAY_SIZE(rtc_resources),
+        .resource       = rtc_resources,
+};
+
+/* I2C0 */
+static struct resource iic0_resources[] = {
+        [0] = {
+                .name   = "IIC0",
+                .start  = 0x04470000,
+                .end    = 0x04470018 - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 96,
+                .end    = 99,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device iic0_device = {
+        .name           = "i2c-sh_mobile",
+        .id             = 0, /* "i2c0" clock */
+        .num_resources  = ARRAY_SIZE(iic0_resources),
+        .resource       = iic0_resources,
+};
+
+/* I2C1 */
+static struct resource iic1_resources[] = {
+        [0] = {
+                .name   = "IIC1",
+                .start  = 0x04750000,
+                .end    = 0x04750018 - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 92,
+                .end    = 95,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device iic1_device = {
+        .name           = "i2c-sh_mobile",
+        .id             = 1, /* "i2c1" clock */
+        .num_resources  = ARRAY_SIZE(iic1_resources),
+        .resource       = iic1_resources,
+};
+
+/* VPU */
+static struct uio_info vpu_platform_data = {
+        .name = "VPU5F",
+        .version = "0",
+        .irq = 60,
+};
+
+static struct resource vpu_resources[] = {
+        [0] = {
+                .name   = "VPU",
+                .start  = 0xfe900000,
+                .end    = 0xfe902807,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                /* place holder for contiguous memory */
+        },
+};
+
+static struct platform_device vpu_device = {
+        .name           = "uio_pdrv_genirq",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &vpu_platform_data,
+        },
+        .resource       = vpu_resources,
+        .num_resources  = ARRAY_SIZE(vpu_resources),
+};
+
+/* VEU0 */
+static struct uio_info veu0_platform_data = {
+        .name = "VEU3F0",
+        .version = "0",
+        .irq = 83,
+};
+
+static struct resource veu0_resources[] = {
+        [0] = {
+                .name   = "VEU3F0",
+                .start  = 0xfe920000,
+                .end    = 0xfe9200cb - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                /* place holder for contiguous memory */
+        },
+};
+
+static struct platform_device veu0_device = {
+        .name           = "uio_pdrv_genirq",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &veu0_platform_data,
+        },
+        .resource       = veu0_resources,
+        .num_resources  = ARRAY_SIZE(veu0_resources),
+};
+
+/* VEU1 */
+static struct uio_info veu1_platform_data = {
+        .name = "VEU3F1",
+        .version = "0",
+        .irq = 54,
+};
+
+static struct resource veu1_resources[] = {
+        [0] = {
+                .name   = "VEU3F1",
+                .start  = 0xfe924000,
+                .end    = 0xfe9240cb - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                /* place holder for contiguous memory */
+        },
+};
+
+static struct platform_device veu1_device = {
+        .name           = "uio_pdrv_genirq",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &veu1_platform_data,
+        },
+        .resource       = veu1_resources,
+        .num_resources  = ARRAY_SIZE(veu1_resources),
+};
+
+static struct sh_timer_config cmt_platform_data = {
+        .name = "CMT",
+        .channel_offset = 0x60,
+        .timer_bit = 5,
+        .clk = "cmt0",
+        .clockevent_rating = 125,
+        .clocksource_rating = 200,
+};
+
+static struct resource cmt_resources[] = {
+        [0] = {
+                .name   = "CMT",
+                .start  = 0x044a0060,
+                .end    = 0x044a006b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 104,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device cmt_device = {
+        .name           = "sh_cmt",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &cmt_platform_data,
+        },
+        .resource       = cmt_resources,
+        .num_resources  = ARRAY_SIZE(cmt_resources),
+};
+
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "tmu0",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = 0xffd80008,
+                .end    = 0xffd80013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 16,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "tmu0",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = 0xffd80014,
+                .end    = 0xffd8001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 17,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "tmu0",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = 0xffd80020,
+                .end    = 0xffd8002b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 18,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
+
+static struct sh_timer_config tmu3_platform_data = {
+        .name = "TMU3",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "tmu1",
+};
+
+static struct resource tmu3_resources[] = {
+        [0] = {
+                .name   = "TMU3",
+                .start  = 0xffd90008,
+                .end    = 0xffd90013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 57,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu3_device = {
+        .name           = "sh_tmu",
+        .id             = 3,
+        .dev = {
+                .platform_data  = &tmu3_platform_data,
+        },
+        .resource       = tmu3_resources,
+        .num_resources  = ARRAY_SIZE(tmu3_resources),
+};
+
+static struct sh_timer_config tmu4_platform_data = {
+        .name = "TMU4",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "tmu1",
+};
+
+static struct resource tmu4_resources[] = {
+        [0] = {
+                .name   = "TMU4",
+                .start  = 0xffd90014,
+                .end    = 0xffd9001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 58,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu4_device = {
+        .name           = "sh_tmu",
+        .id             = 4,
+        .dev = {
+                .platform_data  = &tmu4_platform_data,
+        },
+        .resource       = tmu4_resources,
+        .num_resources  = ARRAY_SIZE(tmu4_resources),
+};
+
+static struct sh_timer_config tmu5_platform_data = {
+        .name = "TMU5",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "tmu1",
+};
+
+static struct resource tmu5_resources[] = {
+        [0] = {
+                .name   = "TMU5",
+                .start  = 0xffd90020,
+                .end    = 0xffd9002b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 57,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu5_device = {
+        .name           = "sh_tmu",
+        .id             = 5,
+        .dev = {
+                .platform_data  = &tmu5_platform_data,
+        },
+        .resource       = tmu5_resources,
+        .num_resources  = ARRAY_SIZE(tmu5_resources),
+};
+
+/* JPU */
+static struct uio_info jpu_platform_data = {
+        .name = "JPU",
+        .version = "0",
+        .irq = 27,
+};
+
+static struct resource jpu_resources[] = {
+        [0] = {
+                .name   = "JPU",
+                .start  = 0xfe980000,
+                .end    = 0xfe9902d3,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                /* place holder for contiguous memory */
+        },
+};
+
+static struct platform_device jpu_device = {
+        .name           = "uio_pdrv_genirq",
+        .id             = 3,
+        .dev = {
+                .platform_data  = &jpu_platform_data,
+        },
+        .resource       = jpu_resources,
+        .num_resources  = ARRAY_SIZE(jpu_resources),
+};
+
+static struct platform_device *sh7724_devices[] __initdata = {
+        &cmt_device,
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+        &tmu3_device,
+        &tmu4_device,
+        &tmu5_device,
+        &sci_device,
+        &rtc_device,
+        &iic0_device,
+        &iic1_device,
+        &vpu_device,
+        &veu0_device,
+        &veu1_device,
+        &jpu_device,
+};
+
+static int __init sh7724_devices_setup(void)
+{
+        platform_resource_setup_memory(&vpu_device, "vpu", 2 << 20);
+        platform_resource_setup_memory(&veu0_device, "veu0", 2 << 20);
+        platform_resource_setup_memory(&veu1_device, "veu1", 2 << 20);
+        platform_resource_setup_memory(&jpu_device,  "jpu",  2 << 20);
+
+        return platform_add_devices(sh7724_devices,
+                                    ARRAY_SIZE(sh7724_devices));
+}
+device_initcall(sh7724_devices_setup);
+
+static struct platform_device *sh7724_early_devices[] __initdata = {
+        &cmt_device,
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+        &tmu3_device,
+        &tmu4_device,
+        &tmu5_device,
+};
+
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(sh7724_early_devices,
+                                   ARRAY_SIZE(sh7724_early_devices));
+}
+
+#define RAMCR_CACHE_L2FC        0x0002
+#define RAMCR_CACHE_L2E         0x0001
+#define L2_CACHE_ENABLE         (RAMCR_CACHE_L2E|RAMCR_CACHE_L2FC)
+void __uses_jump_to_uncached l2_cache_init(void)
+{
+        /* Enable L2 cache */
+        ctrl_outl(L2_CACHE_ENABLE, RAMCR);
+}
+
+enum {
+        UNUSED = 0,
+
+        /* interrupt sources */
+        IRQ0, IRQ1, IRQ2, IRQ3, IRQ4, IRQ5, IRQ6, IRQ7,
+        HUDI,
+        DMAC1A_DEI0, DMAC1A_DEI1, DMAC1A_DEI2, DMAC1A_DEI3,
+        _2DG_TRI, _2DG_INI, _2DG_CEI,
+        DMAC0A_DEI0, DMAC0A_DEI1, DMAC0A_DEI2, DMAC0A_DEI3,
+        VIO_CEU0, VIO_BEU0, VIO_VEU1, VIO_VOU,
+        SCIFA3,
+        VPU,
+        TPU,
+        CEU1,
+        BEU1,
+        USB0, USB1,
+        ATAPI,
+        RTC_ATI, RTC_PRI, RTC_CUI,
+        DMAC1B_DEI4, DMAC1B_DEI5, DMAC1B_DADERR,
+        DMAC0B_DEI4, DMAC0B_DEI5, DMAC0B_DADERR,
+        KEYSC,
+        SCIF_SCIF0, SCIF_SCIF1, SCIF_SCIF2,
+        VEU0,
+        MSIOF_MSIOFI0, MSIOF_MSIOFI1,
+        SPU_SPUI0, SPU_SPUI1,
+        SCIFA4,
+        ICB,
+        ETHI,
+        I2C1_ALI, I2C1_TACKI, I2C1_WAITI, I2C1_DTEI,
+        I2C0_ALI, I2C0_TACKI, I2C0_WAITI, I2C0_DTEI,
+        SDHI0_SDHII0, SDHI0_SDHII1, SDHI0_SDHII2, SDHI0_SDHII3,
+        CMT,
+        TSIF,
+        FSI,
+        SCIFA5,
+        TMU0_TUNI0, TMU0_TUNI1, TMU0_TUNI2,
+        IRDA,
+        SDHI1_SDHII0, SDHI1_SDHII1, SDHI1_SDHII2,
+        JPU,
+        _2DDMAC,
+        MMC_MMC2I, MMC_MMC3I,
+        LCDC,
+        TMU1_TUNI0, TMU1_TUNI1, TMU1_TUNI2,
+
+        /* interrupt groups */
+        DMAC1A, _2DG, DMAC0A, VIO, USB, RTC,
+        DMAC1B, DMAC0B, I2C0, I2C1, SDHI0, SDHI1, SPU, MMCIF,
+};
+
+static struct intc_vect vectors[] __initdata = {
+        INTC_VECT(IRQ0, 0x600), INTC_VECT(IRQ1, 0x620),
+        INTC_VECT(IRQ2, 0x640), INTC_VECT(IRQ3, 0x660),
+        INTC_VECT(IRQ4, 0x680), INTC_VECT(IRQ5, 0x6a0),
+        INTC_VECT(IRQ6, 0x6c0), INTC_VECT(IRQ7, 0x6e0),
+
+        INTC_VECT(DMAC1A_DEI0, 0x700),
+        INTC_VECT(DMAC1A_DEI1, 0x720),
+        INTC_VECT(DMAC1A_DEI2, 0x740),
+        INTC_VECT(DMAC1A_DEI3, 0x760),
+
+        INTC_VECT(_2DG_TRI, 0x780),
+        INTC_VECT(_2DG_INI, 0x7A0),
+        INTC_VECT(_2DG_CEI, 0x7C0),
+
+        INTC_VECT(DMAC0A_DEI0, 0x800),
+        INTC_VECT(DMAC0A_DEI1, 0x820),
+        INTC_VECT(DMAC0A_DEI2, 0x840),
+        INTC_VECT(DMAC0A_DEI3, 0x860),
+
+        INTC_VECT(VIO_CEU0, 0x880),
+        INTC_VECT(VIO_BEU0, 0x8A0),
+        INTC_VECT(VIO_VEU1, 0x8C0),
+        INTC_VECT(VIO_VOU,  0x8E0),
+
+        INTC_VECT(SCIFA3, 0x900),
+        INTC_VECT(VPU,    0x980),
+        INTC_VECT(TPU,    0x9A0),
+        INTC_VECT(CEU1,   0x9E0),
+        INTC_VECT(BEU1,   0xA00),
+        INTC_VECT(USB0,   0xA20),
+        INTC_VECT(USB1,   0xA40),
+        INTC_VECT(ATAPI,  0xA60),
+
+        INTC_VECT(RTC_ATI, 0xA80),
+        INTC_VECT(RTC_PRI, 0xAA0),
+        INTC_VECT(RTC_CUI, 0xAC0),
+
+        INTC_VECT(DMAC1B_DEI4, 0xB00),
+        INTC_VECT(DMAC1B_DEI5, 0xB20),
+        INTC_VECT(DMAC1B_DADERR, 0xB40),
+
+        INTC_VECT(DMAC0B_DEI4, 0xB80),
+        INTC_VECT(DMAC0B_DEI5, 0xBA0),
+        INTC_VECT(DMAC0B_DADERR, 0xBC0),
+
+        INTC_VECT(KEYSC,      0xBE0),
+        INTC_VECT(SCIF_SCIF0, 0xC00),
+        INTC_VECT(SCIF_SCIF1, 0xC20),
+        INTC_VECT(SCIF_SCIF2, 0xC40),
+        INTC_VECT(VEU0,       0xC60),
+        INTC_VECT(MSIOF_MSIOFI0, 0xC80),
+        INTC_VECT(MSIOF_MSIOFI1, 0xCA0),
+        INTC_VECT(SPU_SPUI0, 0xCC0),
+        INTC_VECT(SPU_SPUI1, 0xCE0),
+        INTC_VECT(SCIFA4,    0xD00),
+
+        INTC_VECT(ICB,  0xD20),
+        INTC_VECT(ETHI, 0xD60),
+
+        INTC_VECT(I2C1_ALI, 0xD80),
+        INTC_VECT(I2C1_TACKI, 0xDA0),
+        INTC_VECT(I2C1_WAITI, 0xDC0),
+        INTC_VECT(I2C1_DTEI, 0xDE0),
+
+        INTC_VECT(I2C0_ALI, 0xE00),
+        INTC_VECT(I2C0_TACKI, 0xE20),
+        INTC_VECT(I2C0_WAITI, 0xE40),
+        INTC_VECT(I2C0_DTEI, 0xE60),
+
+        INTC_VECT(SDHI0_SDHII0, 0xE80),
+        INTC_VECT(SDHI0_SDHII1, 0xEA0),
+        INTC_VECT(SDHI0_SDHII2, 0xEC0),
+        INTC_VECT(SDHI0_SDHII3, 0xEE0),
+
+        INTC_VECT(CMT,    0xF00),
+        INTC_VECT(TSIF,   0xF20),
+        INTC_VECT(FSI,    0xF80),
+        INTC_VECT(SCIFA5, 0xFA0),
+
+        INTC_VECT(TMU0_TUNI0, 0x400),
+        INTC_VECT(TMU0_TUNI1, 0x420),
+        INTC_VECT(TMU0_TUNI2, 0x440),
+
+        INTC_VECT(IRDA,    0x480),
+
+        INTC_VECT(SDHI1_SDHII0, 0x4E0),
+        INTC_VECT(SDHI1_SDHII1, 0x500),
+        INTC_VECT(SDHI1_SDHII2, 0x520),
+
+        INTC_VECT(JPU, 0x560),
+        INTC_VECT(_2DDMAC, 0x4A0),
+
+        INTC_VECT(MMC_MMC2I, 0x5A0),
+        INTC_VECT(MMC_MMC3I, 0x5C0),
+
+        INTC_VECT(LCDC, 0xF40),
+
+        INTC_VECT(TMU1_TUNI0, 0x920),
+        INTC_VECT(TMU1_TUNI1, 0x940),
+        INTC_VECT(TMU1_TUNI2, 0x960),
+};
+
+static struct intc_group groups[] __initdata = {
+        INTC_GROUP(DMAC1A, DMAC1A_DEI0, DMAC1A_DEI1, DMAC1A_DEI2, DMAC1A_DEI3),
+        INTC_GROUP(_2DG, _2DG_TRI, _2DG_INI, _2DG_CEI),
+        INTC_GROUP(DMAC0A, DMAC0A_DEI0, DMAC0A_DEI1, DMAC0A_DEI2, DMAC0A_DEI3),
+        INTC_GROUP(VIO, VIO_CEU0, VIO_BEU0, VIO_VEU1, VIO_VOU),
+        INTC_GROUP(USB, USB0, USB1),
+        INTC_GROUP(RTC, RTC_ATI, RTC_PRI, RTC_CUI),
+        INTC_GROUP(DMAC1B, DMAC1B_DEI4, DMAC1B_DEI5, DMAC1B_DADERR),
+        INTC_GROUP(DMAC0B, DMAC0B_DEI4, DMAC0B_DEI5, DMAC0B_DADERR),
+        INTC_GROUP(I2C0, I2C0_ALI, I2C0_TACKI, I2C0_WAITI, I2C0_DTEI),
+        INTC_GROUP(I2C1, I2C1_ALI, I2C1_TACKI, I2C1_WAITI, I2C1_DTEI),
+        INTC_GROUP(SDHI0, SDHI0_SDHII0, SDHI0_SDHII1, SDHI0_SDHII2, SDHI0_SDHII3),
+        INTC_GROUP(SDHI1, SDHI1_SDHII0, SDHI1_SDHII1, SDHI1_SDHII2),
+        INTC_GROUP(SPU, SPU_SPUI0, SPU_SPUI1),
+        INTC_GROUP(MMCIF, MMC_MMC2I, MMC_MMC3I),
+};
+
+static struct intc_mask_reg mask_registers[] __initdata = {
+        { 0xa4080080, 0xa40800c0, 8, /* IMR0 / IMCR0 */
+          { 0, TMU1_TUNI2, TMU1_TUNI1, TMU1_TUNI0,
+            0, SDHI1_SDHII2, SDHI1_SDHII1, SDHI1_SDHII0 } },
+        { 0xa4080084, 0xa40800c4, 8, /* IMR1 / IMCR1 */
+          { VIO_VOU, VIO_VEU1, VIO_BEU0, VIO_CEU0,
+            DMAC0A_DEI3, DMAC0A_DEI2, DMAC0A_DEI1, DMAC0A_DEI0 } },
+        { 0xa4080088, 0xa40800c8, 8, /* IMR2 / IMCR2 */
+          { 0, 0, 0, VPU, ATAPI, ETHI, 0, SCIFA3 } },
+        { 0xa408008c, 0xa40800cc, 8, /* IMR3 / IMCR3 */
+          { DMAC1A_DEI3, DMAC1A_DEI2, DMAC1A_DEI1, DMAC1A_DEI0,
+            SPU_SPUI1, SPU_SPUI0, BEU1, IRDA } },
+        { 0xa4080090, 0xa40800d0, 8, /* IMR4 / IMCR4 */
+          { 0, TMU0_TUNI2, TMU0_TUNI1, TMU0_TUNI0,
+            JPU, 0, 0, LCDC } },
+        { 0xa4080094, 0xa40800d4, 8, /* IMR5 / IMCR5 */
+          { KEYSC, DMAC0B_DADERR, DMAC0B_DEI5, DMAC0B_DEI4,
+            VEU0, SCIF_SCIF2, SCIF_SCIF1, SCIF_SCIF0 } },
+        { 0xa4080098, 0xa40800d8, 8, /* IMR6 / IMCR6 */
+          { 0, 0, ICB, SCIFA4,
+            CEU1, 0, MSIOF_MSIOFI1, MSIOF_MSIOFI0 } },
+        { 0xa408009c, 0xa40800dc, 8, /* IMR7 / IMCR7 */
+          { I2C0_DTEI, I2C0_WAITI, I2C0_TACKI, I2C0_ALI,
+            I2C1_DTEI, I2C1_WAITI, I2C1_TACKI, I2C1_ALI } },
+        { 0xa40800a0, 0xa40800e0, 8, /* IMR8 / IMCR8 */
+          { SDHI0_SDHII3, SDHI0_SDHII2, SDHI0_SDHII1, SDHI0_SDHII0,
+            0, 0, SCIFA5, FSI } },
+        { 0xa40800a4, 0xa40800e4, 8, /* IMR9 / IMCR9 */
+          { 0, 0, 0, CMT, 0, USB1, USB0, 0 } },
+        { 0xa40800a8, 0xa40800e8, 8, /* IMR10 / IMCR10 */
+          { 0, DMAC1B_DADERR, DMAC1B_DEI5, DMAC1B_DEI4,
+            0, RTC_CUI, RTC_PRI, RTC_ATI } },
+        { 0xa40800ac, 0xa40800ec, 8, /* IMR11 / IMCR11 */
+          { 0, _2DG_CEI, _2DG_INI, _2DG_TRI,
+            0, TPU, 0, TSIF } },
+        { 0xa40800b0, 0xa40800f0, 8, /* IMR12 / IMCR12 */
+          { 0, 0, MMC_MMC3I, MMC_MMC2I, 0, 0, 0, _2DDMAC } },
+        { 0xa4140044, 0xa4140064, 8, /* INTMSK00 / INTMSKCLR00 */
+          { IRQ0, IRQ1, IRQ2, IRQ3, IRQ4, IRQ5, IRQ6, IRQ7 } },
+};
+
+static struct intc_prio_reg prio_registers[] __initdata = {
+        { 0xa4080000, 0, 16, 4, /* IPRA */ { TMU0_TUNI0, TMU0_TUNI1,
+                                             TMU0_TUNI2, IRDA } },
+        { 0xa4080004, 0, 16, 4, /* IPRB */ { JPU, LCDC, DMAC1A, BEU1 } },
+        { 0xa4080008, 0, 16, 4, /* IPRC */ { TMU1_TUNI0, TMU1_TUNI1,
+                                             TMU1_TUNI2, SPU } },
+        { 0xa408000c, 0, 16, 4, /* IPRD */ { 0, MMCIF, 0, ATAPI } },
+        { 0xa4080010, 0, 16, 4, /* IPRE */ { DMAC0A, VIO, SCIFA3, VPU } },
+        { 0xa4080014, 0, 16, 4, /* IPRF */ { KEYSC, DMAC0B, USB, CMT } },
+        { 0xa4080018, 0, 16, 4, /* IPRG */ { SCIF_SCIF0, SCIF_SCIF1,
+                                             SCIF_SCIF2, VEU0 } },
+        { 0xa408001c, 0, 16, 4, /* IPRH */ { MSIOF_MSIOFI0, MSIOF_MSIOFI1,
+                                             I2C1, I2C0 } },
+        { 0xa4080020, 0, 16, 4, /* IPRI */ { SCIFA4, ICB, TSIF, _2DG } },
+        { 0xa4080024, 0, 16, 4, /* IPRJ */ { CEU1, ETHI, FSI, SDHI1 } },
+        { 0xa4080028, 0, 16, 4, /* IPRK */ { RTC, DMAC1B, 0, SDHI0 } },
+        { 0xa408002c, 0, 16, 4, /* IPRL */ { SCIFA5, 0, TPU, _2DDMAC } },
+        { 0xa4140010, 0, 32, 4, /* INTPRI00 */
+          { IRQ0, IRQ1, IRQ2, IRQ3, IRQ4, IRQ5, IRQ6, IRQ7 } },
+};
+
+static struct intc_sense_reg sense_registers[] __initdata = {
+        { 0xa414001c, 16, 2, /* ICR1 */
+          { IRQ0, IRQ1, IRQ2, IRQ3, IRQ4, IRQ5, IRQ6, IRQ7 } },
+};
+
+static struct intc_mask_reg ack_registers[] __initdata = {
+        { 0xa4140024, 0, 8, /* INTREQ00 */
+          { IRQ0, IRQ1, IRQ2, IRQ3, IRQ4, IRQ5, IRQ6, IRQ7 } },
+};
+
+static DECLARE_INTC_DESC_ACK(intc_desc, "sh7724", vectors, groups,
+                             mask_registers, prio_registers, sense_registers,
+                             ack_registers);
+
+void __init plat_irq_setup(void)
+{
+        register_intc_controller(&intc_desc);
+}
diff --git a/arch/sh/kernel/cpu/sh4a/setup-sh7763.c b/arch/sh/kernel/cpu/sh4a/setup-sh7763.c
index bdf0f61ae1ed..f1e0c0d36da7 100644
--- a/arch/sh/kernel/cpu/sh4a/setup-sh7763.c
+++ b/arch/sh/kernel/cpu/sh4a/setup-sh7763.c
@@ -12,6 +12,7 @@
 #include <linux/platform_device.h>
 #include <linux/init.h>
 #include <linux/serial.h>
+#include <linux/sh_timer.h>
 #include <linux/io.h>
 #include <linux/serial_sci.h>
 
@@ -113,7 +114,195 @@ static struct platform_device usbf_device = {
         .resource       = usbf_resources,
 };
 
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = 0xffd80008,
+                .end    = 0xffd80013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 28,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = 0xffd80014,
+                .end    = 0xffd8001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 29,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = 0xffd80020,
+                .end    = 0xffd8002f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 30,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
+static struct sh_timer_config tmu3_platform_data = {
+        .name = "TMU3",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu3_resources[] = {
+        [0] = {
+                .name   = "TMU3",
+                .start  = 0xffd88008,
+                .end    = 0xffd88013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 96,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu3_device = {
+        .name           = "sh_tmu",
+        .id             = 3,
+        .dev = {
+                .platform_data  = &tmu3_platform_data,
+        },
+        .resource       = tmu3_resources,
+        .num_resources  = ARRAY_SIZE(tmu3_resources),
+};
+
+static struct sh_timer_config tmu4_platform_data = {
+        .name = "TMU4",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu4_resources[] = {
+        [0] = {
+                .name   = "TMU4",
+                .start  = 0xffd88014,
+                .end    = 0xffd8801f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 97,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu4_device = {
+        .name           = "sh_tmu",
+        .id             = 4,
+        .dev = {
+                .platform_data  = &tmu4_platform_data,
+        },
+        .resource       = tmu4_resources,
+        .num_resources  = ARRAY_SIZE(tmu4_resources),
+};
+
+static struct sh_timer_config tmu5_platform_data = {
+        .name = "TMU5",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu5_resources[] = {
+        [0] = {
+                .name   = "TMU5",
+                .start  = 0xffd88020,
+                .end    = 0xffd8802b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 98,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu5_device = {
+        .name           = "sh_tmu",
+        .id             = 5,
+        .dev = {
+                .platform_data  = &tmu5_platform_data,
+        },
+        .resource       = tmu5_resources,
+        .num_resources  = ARRAY_SIZE(tmu5_resources),
+};
+
 static struct platform_device *sh7763_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+        &tmu3_device,
+        &tmu4_device,
+        &tmu5_device,
         &rtc_device,
         &sci_device,
         &usb_ohci_device,
@@ -127,6 +316,21 @@ static int __init sh7763_devices_setup(void)
 }
 __initcall(sh7763_devices_setup);
 
+static struct platform_device *sh7763_early_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+        &tmu3_device,
+        &tmu4_device,
+        &tmu5_device,
+};
+
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(sh7763_early_devices,
+                                   ARRAY_SIZE(sh7763_early_devices));
+}
+
 enum {
         UNUSED = 0,
 
diff --git a/arch/sh/kernel/cpu/sh4a/setup-sh7770.c b/arch/sh/kernel/cpu/sh4a/setup-sh7770.c
index b73578ee295d..1e86209db284 100644
--- a/arch/sh/kernel/cpu/sh4a/setup-sh7770.c
+++ b/arch/sh/kernel/cpu/sh4a/setup-sh7770.c
@@ -11,6 +11,8 @@
 #include <linux/init.h>
 #include <linux/serial.h>
 #include <linux/serial_sci.h>
+#include <linux/sh_timer.h>
+#include <linux/io.h>
 
 static struct plat_sci_port sci_platform_data[] = {
         {
@@ -76,7 +78,288 @@ static struct platform_device sci_device = {
         },
 };
 
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = 0xffd80008,
+                .end    = 0xffd80013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 16,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = 0xffd80014,
+                .end    = 0xffd8001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 17,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = 0xffd80020,
+                .end    = 0xffd8002f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 18,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
+static struct sh_timer_config tmu3_platform_data = {
+        .name = "TMU3",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu3_resources[] = {
+        [0] = {
+                .name   = "TMU3",
+                .start  = 0xffd81008,
+                .end    = 0xffd81013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 19,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu3_device = {
+        .name           = "sh_tmu",
+        .id             = 3,
+        .dev = {
+                .platform_data  = &tmu3_platform_data,
+        },
+        .resource       = tmu3_resources,
+        .num_resources  = ARRAY_SIZE(tmu3_resources),
+};
+
+static struct sh_timer_config tmu4_platform_data = {
+        .name = "TMU4",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu4_resources[] = {
+        [0] = {
+                .name   = "TMU4",
+                .start  = 0xffd81014,
+                .end    = 0xffd8101f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 20,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu4_device = {
+        .name           = "sh_tmu",
+        .id             = 4,
+        .dev = {
+                .platform_data  = &tmu4_platform_data,
+        },
+        .resource       = tmu4_resources,
+        .num_resources  = ARRAY_SIZE(tmu4_resources),
+};
+
+static struct sh_timer_config tmu5_platform_data = {
+        .name = "TMU5",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu5_resources[] = {
+        [0] = {
+                .name   = "TMU5",
+                .start  = 0xffd81020,
+                .end    = 0xffd8102f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 21,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu5_device = {
+        .name           = "sh_tmu",
+        .id             = 5,
+        .dev = {
+                .platform_data  = &tmu5_platform_data,
+        },
+        .resource       = tmu5_resources,
+        .num_resources  = ARRAY_SIZE(tmu5_resources),
+};
+
+static struct sh_timer_config tmu6_platform_data = {
+        .name = "TMU6",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu6_resources[] = {
+        [0] = {
+                .name   = "TMU6",
+                .start  = 0xffd82008,
+                .end    = 0xffd82013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 22,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu6_device = {
+        .name           = "sh_tmu",
+        .id             = 6,
+        .dev = {
+                .platform_data  = &tmu6_platform_data,
+        },
+        .resource       = tmu6_resources,
+        .num_resources  = ARRAY_SIZE(tmu6_resources),
+};
+
+static struct sh_timer_config tmu7_platform_data = {
+        .name = "TMU7",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu7_resources[] = {
+        [0] = {
+                .name   = "TMU7",
+                .start  = 0xffd82014,
+                .end    = 0xffd8201f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 23,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu7_device = {
+        .name           = "sh_tmu",
+        .id             = 7,
+        .dev = {
+                .platform_data  = &tmu7_platform_data,
+        },
+        .resource       = tmu7_resources,
+        .num_resources  = ARRAY_SIZE(tmu7_resources),
+};
+
+static struct sh_timer_config tmu8_platform_data = {
+        .name = "TMU8",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu8_resources[] = {
+        [0] = {
+                .name   = "TMU8",
+                .start  = 0xffd82020,
+                .end    = 0xffd8202b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 24,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu8_device = {
+        .name           = "sh_tmu",
+        .id             = 8,
+        .dev = {
+                .platform_data  = &tmu8_platform_data,
+        },
+        .resource       = tmu8_resources,
+        .num_resources  = ARRAY_SIZE(tmu8_resources),
+};
+
 static struct platform_device *sh7770_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+        &tmu3_device,
+        &tmu4_device,
+        &tmu5_device,
+        &tmu6_device,
+        &tmu7_device,
+        &tmu8_device,
         &sci_device,
 };
 
@@ -87,6 +370,269 @@ static int __init sh7770_devices_setup(void)
 }
 __initcall(sh7770_devices_setup);
 
+static struct platform_device *sh7770_early_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+        &tmu3_device,
+        &tmu4_device,
+        &tmu5_device,
+        &tmu6_device,
+        &tmu7_device,
+        &tmu8_device,
+};
+
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(sh7770_early_devices,
+                                   ARRAY_SIZE(sh7770_early_devices));
+}
+
+enum {
+        UNUSED = 0,
+
+        /* interrupt sources */
+        IRL_LLLL, IRL_LLLH, IRL_LLHL, IRL_LLHH,
+        IRL_LHLL, IRL_LHLH, IRL_LHHL, IRL_LHHH,
+        IRL_HLLL, IRL_HLLH, IRL_HLHL, IRL_HLHH,
+        IRL_HHLL, IRL_HHLH, IRL_HHHL,
+
+        IRQ0, IRQ1, IRQ2, IRQ3, IRQ4, IRQ5,
+
+        GPIO,
+        TMU0, TMU1, TMU2, TMU2_TICPI,
+        TMU3, TMU4, TMU5, TMU5_TICPI,
+        TMU6, TMU7, TMU8,
+        HAC, IPI, SPDIF, HUDI, I2C,
+        DMAC0_DMINT0, DMAC0_DMINT1, DMAC0_DMINT2,
+        I2S0, I2S1, I2S2, I2S3,
+        SRC_RX, SRC_TX, SRC_SPDIF,
+        DU, VIDEO_IN, REMOTE, YUV, USB, ATAPI, CAN, GPS, GFX2D,
+        GFX3D_MBX, GFX3D_DMAC,
+        EXBUS_ATA,
+        SPI0, SPI1,
+        SCIF089, SCIF1234, SCIF567,
+        ADC,
+        BBDMAC_0_3, BBDMAC_4_7, BBDMAC_8_10, BBDMAC_11_14,
+        BBDMAC_15_18, BBDMAC_19_22, BBDMAC_23_26, BBDMAC_27,
+        BBDMAC_28, BBDMAC_29, BBDMAC_30, BBDMAC_31,
+
+        /* interrupt groups */
+        TMU, DMAC, I2S, SRC, GFX3D, SPI, SCIF, BBDMAC,
+};
+
+static struct intc_vect vectors[] __initdata = {
+        INTC_VECT(GPIO, 0x3e0),
+        INTC_VECT(TMU0, 0x400), INTC_VECT(TMU1, 0x420),
+        INTC_VECT(TMU2, 0x440), INTC_VECT(TMU2_TICPI, 0x460),
+        INTC_VECT(TMU3, 0x480), INTC_VECT(TMU4, 0x4a0),
+        INTC_VECT(TMU5, 0x4c0), INTC_VECT(TMU5_TICPI, 0x4e0),
+        INTC_VECT(TMU6, 0x500), INTC_VECT(TMU7, 0x520),
+        INTC_VECT(TMU8, 0x540),
+        INTC_VECT(HAC, 0x580), INTC_VECT(IPI, 0x5c0),
+        INTC_VECT(SPDIF, 0x5e0),
+        INTC_VECT(HUDI, 0x600), INTC_VECT(I2C, 0x620),
+        INTC_VECT(DMAC0_DMINT0, 0x640), INTC_VECT(DMAC0_DMINT1, 0x660),
+        INTC_VECT(DMAC0_DMINT2, 0x680),
+        INTC_VECT(I2S0, 0x6a0), INTC_VECT(I2S1, 0x6c0),
+        INTC_VECT(I2S2, 0x6e0), INTC_VECT(I2S3, 0x700),
+        INTC_VECT(SRC_RX, 0x720), INTC_VECT(SRC_TX, 0x740),
+        INTC_VECT(SRC_SPDIF, 0x760),
+        INTC_VECT(DU, 0x780), INTC_VECT(VIDEO_IN, 0x7a0),
+        INTC_VECT(REMOTE, 0x7c0), INTC_VECT(YUV, 0x7e0),
+        INTC_VECT(USB, 0x840), INTC_VECT(ATAPI, 0x860),
+        INTC_VECT(CAN, 0x880), INTC_VECT(GPS, 0x8a0),
+        INTC_VECT(GFX2D, 0x8c0),
+        INTC_VECT(GFX3D_MBX, 0x900), INTC_VECT(GFX3D_DMAC, 0x920),
+        INTC_VECT(EXBUS_ATA, 0x940),
+        INTC_VECT(SPI0, 0x960), INTC_VECT(SPI1, 0x980),
+        INTC_VECT(SCIF089, 0x9a0), INTC_VECT(SCIF1234, 0x9c0),
+        INTC_VECT(SCIF1234, 0x9e0), INTC_VECT(SCIF1234, 0xa00),
+        INTC_VECT(SCIF1234, 0xa20), INTC_VECT(SCIF567, 0xa40),
+        INTC_VECT(SCIF567, 0xa60), INTC_VECT(SCIF567, 0xa80),
+        INTC_VECT(SCIF089, 0xaa0), INTC_VECT(SCIF089, 0xac0),
+        INTC_VECT(ADC, 0xb20),
+        INTC_VECT(BBDMAC_0_3, 0xba0), INTC_VECT(BBDMAC_0_3, 0xbc0),
+        INTC_VECT(BBDMAC_0_3, 0xbe0), INTC_VECT(BBDMAC_0_3, 0xc00),
+        INTC_VECT(BBDMAC_4_7, 0xc20), INTC_VECT(BBDMAC_4_7, 0xc40),
+        INTC_VECT(BBDMAC_4_7, 0xc60), INTC_VECT(BBDMAC_4_7, 0xc80),
+        INTC_VECT(BBDMAC_8_10, 0xca0), INTC_VECT(BBDMAC_8_10, 0xcc0),
+        INTC_VECT(BBDMAC_8_10, 0xce0), INTC_VECT(BBDMAC_11_14, 0xd00),
+        INTC_VECT(BBDMAC_11_14, 0xd20), INTC_VECT(BBDMAC_11_14, 0xd40),
+        INTC_VECT(BBDMAC_11_14, 0xd60), INTC_VECT(BBDMAC_15_18, 0xd80),
+        INTC_VECT(BBDMAC_15_18, 0xda0), INTC_VECT(BBDMAC_15_18, 0xdc0),
+        INTC_VECT(BBDMAC_15_18, 0xde0), INTC_VECT(BBDMAC_19_22, 0xe00),
+        INTC_VECT(BBDMAC_19_22, 0xe20), INTC_VECT(BBDMAC_19_22, 0xe40),
+        INTC_VECT(BBDMAC_19_22, 0xe60), INTC_VECT(BBDMAC_23_26, 0xe80),
+        INTC_VECT(BBDMAC_23_26, 0xea0), INTC_VECT(BBDMAC_23_26, 0xec0),
+        INTC_VECT(BBDMAC_23_26, 0xee0), INTC_VECT(BBDMAC_27, 0xf00),
+        INTC_VECT(BBDMAC_28, 0xf20), INTC_VECT(BBDMAC_29, 0xf40),
+        INTC_VECT(BBDMAC_30, 0xf60), INTC_VECT(BBDMAC_31, 0xf80),
+};
+
+static struct intc_group groups[] __initdata = {
+        INTC_GROUP(TMU, TMU0, TMU1, TMU2, TMU2_TICPI, TMU3, TMU4, TMU5,
+                   TMU5_TICPI, TMU6, TMU7, TMU8),
+        INTC_GROUP(DMAC, DMAC0_DMINT0, DMAC0_DMINT1, DMAC0_DMINT2),
+        INTC_GROUP(I2S, I2S0, I2S1, I2S2, I2S3),
+        INTC_GROUP(SRC, SRC_RX, SRC_TX, SRC_SPDIF),
+        INTC_GROUP(GFX3D, GFX3D_MBX, GFX3D_DMAC),
+        INTC_GROUP(SPI, SPI0, SPI1),
+        INTC_GROUP(SCIF, SCIF089, SCIF1234, SCIF567),
+        INTC_GROUP(BBDMAC,
+                   BBDMAC_0_3, BBDMAC_4_7, BBDMAC_8_10, BBDMAC_11_14,
+                   BBDMAC_15_18, BBDMAC_19_22, BBDMAC_23_26, BBDMAC_27,
+                   BBDMAC_28, BBDMAC_29, BBDMAC_30, BBDMAC_31),
+};
+
+static struct intc_mask_reg mask_registers[] __initdata = {
+        { 0xffe00040, 0xffe00044, 32, /* INT2MSKR / INT2MSKCR */
+          { 0, BBDMAC, ADC, SCIF, SPI, EXBUS_ATA, GFX3D, GFX2D,
+            GPS, CAN, ATAPI, USB, YUV, REMOTE, VIDEO_IN, DU, SRC, I2S,
+            DMAC, I2C, HUDI, SPDIF, IPI, HAC, TMU, GPIO } },
+};
+
+static struct intc_prio_reg prio_registers[] __initdata = {
+        { 0xffe00000, 0, 32, 8, /* INT2PRI0 */ { GPIO, TMU0, 0, HAC } },
+        { 0xffe00004, 0, 32, 8, /* INT2PRI1 */ { IPI, SPDIF, HUDI, I2C } },
+        { 0xffe00008, 0, 32, 8, /* INT2PRI2 */ { DMAC, I2S, SRC, DU } },
+        { 0xffe0000c, 0, 32, 8, /* INT2PRI3 */ { VIDEO_IN, REMOTE, YUV, USB } },
+        { 0xffe00010, 0, 32, 8, /* INT2PRI4 */ { ATAPI, CAN, GPS, GFX2D } },
+        { 0xffe00014, 0, 32, 8, /* INT2PRI5 */ { 0, GFX3D, EXBUS_ATA, SPI } },
+        { 0xffe00018, 0, 32, 8, /* INT2PRI6 */ { SCIF1234, SCIF567, SCIF089 } },
+        { 0xffe0001c, 0, 32, 8, /* INT2PRI7 */ { ADC, 0, 0, BBDMAC_0_3 } },
+        { 0xffe00020, 0, 32, 8, /* INT2PRI8 */
+          { BBDMAC_4_7, BBDMAC_8_10, BBDMAC_11_14, BBDMAC_15_18 } },
+        { 0xffe00024, 0, 32, 8, /* INT2PRI9 */
+          { BBDMAC_19_22, BBDMAC_23_26, BBDMAC_27, BBDMAC_28 } },
+        { 0xffe00028, 0, 32, 8, /* INT2PRI10 */
+          { BBDMAC_29, BBDMAC_30, BBDMAC_31 } },
+        { 0xffe0002c, 0, 32, 8, /* INT2PRI11 */
+          { TMU1, TMU2, TMU2_TICPI, TMU3 } },
+        { 0xffe00030, 0, 32, 8, /* INT2PRI12 */
+          { TMU4, TMU5, TMU5_TICPI, TMU6 } },
+        { 0xffe00034, 0, 32, 8, /* INT2PRI13 */
+          { TMU7, TMU8 } },
+};
+
+static DECLARE_INTC_DESC(intc_desc, "sh7770", vectors, groups,
+                         mask_registers, prio_registers, NULL);
+
+/* Support for external interrupt pins in IRQ mode */
+static struct intc_vect irq_vectors[] __initdata = {
+        INTC_VECT(IRQ0, 0x240), INTC_VECT(IRQ1, 0x280),
+        INTC_VECT(IRQ2, 0x2c0), INTC_VECT(IRQ3, 0x300),
+        INTC_VECT(IRQ4, 0x340), INTC_VECT(IRQ5, 0x380),
+};
+
+static struct intc_mask_reg irq_mask_registers[] __initdata = {
+        { 0xffd00044, 0xffd00064, 32, /* INTMSK0 / INTMSKCLR0 */
+          { IRQ0, IRQ1, IRQ2, IRQ3, IRQ4, IRQ5, } },
+};
+
+static struct intc_prio_reg irq_prio_registers[] __initdata = {
+        { 0xffd00010, 0, 32, 4, /* INTPRI */ { IRQ0, IRQ1, IRQ2, IRQ3,
+                                               IRQ4, IRQ5, } },
+};
+
+static struct intc_sense_reg irq_sense_registers[] __initdata = {
+        { 0xffd0001c, 32, 2, /* ICR1 */   { IRQ0, IRQ1, IRQ2, IRQ3,
+                                            IRQ4, IRQ5, } },
+};
+
+static DECLARE_INTC_DESC(intc_irq_desc, "sh7770-irq", irq_vectors,
+                         NULL, irq_mask_registers, irq_prio_registers,
+                         irq_sense_registers);
+
+/* External interrupt pins in IRL mode */
+static struct intc_vect irl_vectors[] __initdata = {
+        INTC_VECT(IRL_LLLL, 0x200), INTC_VECT(IRL_LLLH, 0x220),
+        INTC_VECT(IRL_LLHL, 0x240), INTC_VECT(IRL_LLHH, 0x260),
+        INTC_VECT(IRL_LHLL, 0x280), INTC_VECT(IRL_LHLH, 0x2a0),
+        INTC_VECT(IRL_LHHL, 0x2c0), INTC_VECT(IRL_LHHH, 0x2e0),
+        INTC_VECT(IRL_HLLL, 0x300), INTC_VECT(IRL_HLLH, 0x320),
+        INTC_VECT(IRL_HLHL, 0x340), INTC_VECT(IRL_HLHH, 0x360),
+        INTC_VECT(IRL_HHLL, 0x380), INTC_VECT(IRL_HHLH, 0x3a0),
+        INTC_VECT(IRL_HHHL, 0x3c0),
+};
+
+static struct intc_mask_reg irl3210_mask_registers[] __initdata = {
+        { 0xffd40080, 0xffd40084, 32, /* INTMSK2 / INTMSKCLR2 */
+          { IRL_LLLL, IRL_LLLH, IRL_LLHL, IRL_LLHH,
+            IRL_LHLL, IRL_LHLH, IRL_LHHL, IRL_LHHH,
+            IRL_HLLL, IRL_HLLH, IRL_HLHL, IRL_HLHH,
+            IRL_HHLL, IRL_HHLH, IRL_HHHL, } },
+};
+
+static struct intc_mask_reg irl7654_mask_registers[] __initdata = {
+        { 0xffd40080, 0xffd40084, 32, /* INTMSK2 / INTMSKCLR2 */
+          { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            IRL_LLLL, IRL_LLLH, IRL_LLHL, IRL_LLHH,
+            IRL_LHLL, IRL_LHLH, IRL_LHHL, IRL_LHHH,
+            IRL_HLLL, IRL_HLLH, IRL_HLHL, IRL_HLHH,
+            IRL_HHLL, IRL_HHLH, IRL_HHHL, } },
+};
+
+static DECLARE_INTC_DESC(intc_irl7654_desc, "sh7780-irl7654", irl_vectors,
+                         NULL, irl7654_mask_registers, NULL, NULL);
+
+static DECLARE_INTC_DESC(intc_irl3210_desc, "sh7780-irl3210", irl_vectors,
+                         NULL, irl3210_mask_registers, NULL, NULL);
+
+#define INTC_ICR0       0xffd00000
+#define INTC_INTMSK0    0xffd00044
+#define INTC_INTMSK1    0xffd00048
+#define INTC_INTMSK2    0xffd40080
+#define INTC_INTMSKCLR1 0xffd00068
+#define INTC_INTMSKCLR2 0xffd40084
+
 void __init plat_irq_setup(void)
 {
+        /* disable IRQ7-0 */
+        ctrl_outl(0xff000000, INTC_INTMSK0);
+
+        /* disable IRL3-0 + IRL7-4 */
+        ctrl_outl(0xc0000000, INTC_INTMSK1);
+        ctrl_outl(0xfffefffe, INTC_INTMSK2);
+
+        /* select IRL mode for IRL3-0 + IRL7-4 */
+        ctrl_outl(ctrl_inl(INTC_ICR0) & ~0x00c00000, INTC_ICR0);
+
+        /* disable holding function, ie enable "SH-4 Mode" */
+        ctrl_outl(ctrl_inl(INTC_ICR0) | 0x00200000, INTC_ICR0);
+
+        register_intc_controller(&intc_desc);
+}
+
+void __init plat_irq_setup_pins(int mode)
+{
+        switch (mode) {
+        case IRQ_MODE_IRQ:
+                /* select IRQ mode for IRL3-0 + IRL7-4 */
+                ctrl_outl(ctrl_inl(INTC_ICR0) | 0x00c00000, INTC_ICR0);
+                register_intc_controller(&intc_irq_desc);
+                break;
+        case IRQ_MODE_IRL7654:
+                /* enable IRL7-4 but don't provide any masking */
+                ctrl_outl(0x40000000, INTC_INTMSKCLR1);
+                ctrl_outl(0x0000fffe, INTC_INTMSKCLR2);
+                break;
+        case IRQ_MODE_IRL3210:
+                /* enable IRL0-3 but don't provide any masking */
+                ctrl_outl(0x80000000, INTC_INTMSKCLR1);
+                ctrl_outl(0xfffe0000, INTC_INTMSKCLR2);
+                break;
+        case IRQ_MODE_IRL7654_MASK:
+                /* enable IRL7-4 and mask using cpu intc controller */
+                ctrl_outl(0x40000000, INTC_INTMSKCLR1);
+                register_intc_controller(&intc_irl7654_desc);
+                break;
+        case IRQ_MODE_IRL3210_MASK:
+                /* enable IRL0-3 and mask using cpu intc controller */
+                ctrl_outl(0x80000000, INTC_INTMSKCLR1);
+                register_intc_controller(&intc_irl3210_desc);
+                break;
+        default:
+                BUG();
+        }
 }
diff --git a/arch/sh/kernel/cpu/sh4a/setup-sh7780.c b/arch/sh/kernel/cpu/sh4a/setup-sh7780.c
index 6f7227cd65bf..715e05b431e5 100644
--- a/arch/sh/kernel/cpu/sh4a/setup-sh7780.c
+++ b/arch/sh/kernel/cpu/sh4a/setup-sh7780.c
@@ -12,6 +12,189 @@
 #include <linux/serial.h>
 #include <linux/io.h>
 #include <linux/serial_sci.h>
+#include <linux/sh_timer.h>
+
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = 0xffd80008,
+                .end    = 0xffd80013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 28,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = 0xffd80014,
+                .end    = 0xffd8001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 29,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = 0xffd80020,
+                .end    = 0xffd8002f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 30,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
+static struct sh_timer_config tmu3_platform_data = {
+        .name = "TMU3",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu3_resources[] = {
+        [0] = {
+                .name   = "TMU3",
+                .start  = 0xffdc0008,
+                .end    = 0xffdc0013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 96,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu3_device = {
+        .name           = "sh_tmu",
+        .id             = 3,
+        .dev = {
+                .platform_data  = &tmu3_platform_data,
+        },
+        .resource       = tmu3_resources,
+        .num_resources  = ARRAY_SIZE(tmu3_resources),
+};
+
+static struct sh_timer_config tmu4_platform_data = {
+        .name = "TMU4",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu4_resources[] = {
+        [0] = {
+                .name   = "TMU4",
+                .start  = 0xffdc0014,
+                .end    = 0xffdc001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 97,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu4_device = {
+        .name           = "sh_tmu",
+        .id             = 4,
+        .dev = {
+                .platform_data  = &tmu4_platform_data,
+        },
+        .resource       = tmu4_resources,
+        .num_resources  = ARRAY_SIZE(tmu4_resources),
+};
+
+static struct sh_timer_config tmu5_platform_data = {
+        .name = "TMU5",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu5_resources[] = {
+        [0] = {
+                .name   = "TMU5",
+                .start  = 0xffdc0020,
+                .end    = 0xffdc002b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 98,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu5_device = {
+        .name           = "sh_tmu",
+        .id             = 5,
+        .dev = {
+                .platform_data  = &tmu5_platform_data,
+        },
+        .resource       = tmu5_resources,
+        .num_resources  = ARRAY_SIZE(tmu5_resources),
+};
 
 static struct resource rtc_resources[] = {
         [0] = {
@@ -58,6 +241,12 @@ static struct platform_device sci_device = {
 };
 
 static struct platform_device *sh7780_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+        &tmu3_device,
+        &tmu4_device,
+        &tmu5_device,
         &rtc_device,
         &sci_device,
 };
@@ -69,6 +258,21 @@ static int __init sh7780_devices_setup(void)
 }
 __initcall(sh7780_devices_setup);
 
+static struct platform_device *sh7780_early_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+        &tmu3_device,
+        &tmu4_device,
+        &tmu5_device,
+};
+
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(sh7780_early_devices,
+                                   ARRAY_SIZE(sh7780_early_devices));
+}
+
 enum {
         UNUSED = 0,
 
diff --git a/arch/sh/kernel/cpu/sh4a/setup-sh7785.c b/arch/sh/kernel/cpu/sh4a/setup-sh7785.c
index d80802a49dbd..af561402570b 100644
--- a/arch/sh/kernel/cpu/sh4a/setup-sh7785.c
+++ b/arch/sh/kernel/cpu/sh4a/setup-sh7785.c
@@ -13,39 +13,228 @@
 #include <linux/serial_sci.h>
 #include <linux/io.h>
 #include <linux/mm.h>
+#include <linux/sh_timer.h>
 #include <asm/mmzone.h>
 
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "tmu012_fck",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = 0xffd80008,
+                .end    = 0xffd80013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 28,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "tmu012_fck",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = 0xffd80014,
+                .end    = 0xffd8001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 29,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "tmu012_fck",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = 0xffd80020,
+                .end    = 0xffd8002f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 30,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
+static struct sh_timer_config tmu3_platform_data = {
+        .name = "TMU3",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "tmu345_fck",
+};
+
+static struct resource tmu3_resources[] = {
+        [0] = {
+                .name   = "TMU3",
+                .start  = 0xffdc0008,
+                .end    = 0xffdc0013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 96,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu3_device = {
+        .name           = "sh_tmu",
+        .id             = 3,
+        .dev = {
+                .platform_data  = &tmu3_platform_data,
+        },
+        .resource       = tmu3_resources,
+        .num_resources  = ARRAY_SIZE(tmu3_resources),
+};
+
+static struct sh_timer_config tmu4_platform_data = {
+        .name = "TMU4",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "tmu345_fck",
+};
+
+static struct resource tmu4_resources[] = {
+        [0] = {
+                .name   = "TMU4",
+                .start  = 0xffdc0014,
+                .end    = 0xffdc001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 97,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu4_device = {
+        .name           = "sh_tmu",
+        .id             = 4,
+        .dev = {
+                .platform_data  = &tmu4_platform_data,
+        },
+        .resource       = tmu4_resources,
+        .num_resources  = ARRAY_SIZE(tmu4_resources),
+};
+
+static struct sh_timer_config tmu5_platform_data = {
+        .name = "TMU5",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "tmu345_fck",
+};
+
+static struct resource tmu5_resources[] = {
+        [0] = {
+                .name   = "TMU5",
+                .start  = 0xffdc0020,
+                .end    = 0xffdc002b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 98,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu5_device = {
+        .name           = "sh_tmu",
+        .id             = 5,
+        .dev = {
+                .platform_data  = &tmu5_platform_data,
+        },
+        .resource       = tmu5_resources,
+        .num_resources  = ARRAY_SIZE(tmu5_resources),
+};
+
 static struct plat_sci_port sci_platform_data[] = {
         {
                 .mapbase        = 0xffea0000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIF,
                 .irqs           = { 40, 40, 40, 40 },
+                .clk            = "scif_fck",
         }, {
                 .mapbase        = 0xffeb0000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIF,
                 .irqs           = { 44, 44, 44, 44 },
+                .clk            = "scif_fck",
         }, {
                 .mapbase        = 0xffec0000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIF,
                 .irqs           = { 60, 60, 60, 60 },
+                .clk            = "scif_fck",
         }, {
                 .mapbase        = 0xffed0000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIF,
                 .irqs           = { 61, 61, 61, 61 },
+                .clk            = "scif_fck",
         }, {
                 .mapbase        = 0xffee0000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIF,
                 .irqs           = { 62, 62, 62, 62 },
+                .clk            = "scif_fck",
         }, {
                 .mapbase        = 0xffef0000,
                 .flags          = UPF_BOOT_AUTOCONF,
                 .type           = PORT_SCIF,
                 .irqs           = { 63, 63, 63, 63 },
+                .clk            = "scif_fck",
         }, {
                 .flags = 0,
         }
@@ -60,6 +249,12 @@ static struct platform_device sci_device = {
 };
 
 static struct platform_device *sh7785_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+        &tmu3_device,
+        &tmu4_device,
+        &tmu5_device,
         &sci_device,
 };
 
@@ -70,6 +265,21 @@ static int __init sh7785_devices_setup(void)
 }
 __initcall(sh7785_devices_setup);
 
+static struct platform_device *sh7785_early_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+        &tmu3_device,
+        &tmu4_device,
+        &tmu5_device,
+};
+
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(sh7785_early_devices,
+                                   ARRAY_SIZE(sh7785_early_devices));
+}
+
 enum {
         UNUSED = 0,
 
diff --git a/arch/sh/kernel/cpu/sh4a/setup-sh7786.c b/arch/sh/kernel/cpu/sh4a/setup-sh7786.c
index 90e8cfff55fd..93e0d2c017e8 100644
--- a/arch/sh/kernel/cpu/sh4a/setup-sh7786.c
+++ b/arch/sh/kernel/cpu/sh4a/setup-sh7786.c
@@ -3,6 +3,7 @@
  *
  * Copyright (C) 2009  Renesas Solutions Corp.
  * Kuninori Morimoto <morimoto.kuninori@renesas.com>
+ * Paul Mundt <paul.mundt@renesas.com>
  *
  * Based on SH7785 Setup
  *
@@ -19,6 +20,7 @@
 #include <linux/io.h>
 #include <linux/mm.h>
 #include <linux/dma-mapping.h>
+#include <linux/sh_timer.h>
 #include <asm/mmzone.h>
 
 static struct plat_sci_port sci_platform_data[] = {
@@ -69,6 +71,368 @@ static struct platform_device sci_device = {
         },
 };
 
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = 0xffd80008,
+                .end    = 0xffd80013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 16,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = 0xffd80014,
+                .end    = 0xffd8001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 17,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = 0xffd80020,
+                .end    = 0xffd8002f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 18,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
+static struct sh_timer_config tmu3_platform_data = {
+        .name = "TMU3",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu3_resources[] = {
+        [0] = {
+                .name   = "TMU3",
+                .start  = 0xffda0008,
+                .end    = 0xffda0013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 20,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu3_device = {
+        .name           = "sh_tmu",
+        .id             = 3,
+        .dev = {
+                .platform_data  = &tmu3_platform_data,
+        },
+        .resource       = tmu3_resources,
+        .num_resources  = ARRAY_SIZE(tmu3_resources),
+};
+
+static struct sh_timer_config tmu4_platform_data = {
+        .name = "TMU4",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu4_resources[] = {
+        [0] = {
+                .name   = "TMU4",
+                .start  = 0xffda0014,
+                .end    = 0xffda001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 21,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu4_device = {
+        .name           = "sh_tmu",
+        .id             = 4,
+        .dev = {
+                .platform_data  = &tmu4_platform_data,
+        },
+        .resource       = tmu4_resources,
+        .num_resources  = ARRAY_SIZE(tmu4_resources),
+};
+
+static struct sh_timer_config tmu5_platform_data = {
+        .name = "TMU5",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu5_resources[] = {
+        [0] = {
+                .name   = "TMU5",
+                .start  = 0xffda0020,
+                .end    = 0xffda002b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 22,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu5_device = {
+        .name           = "sh_tmu",
+        .id             = 5,
+        .dev = {
+                .platform_data  = &tmu5_platform_data,
+        },
+        .resource       = tmu5_resources,
+        .num_resources  = ARRAY_SIZE(tmu5_resources),
+};
+
+static struct sh_timer_config tmu6_platform_data = {
+        .name = "TMU6",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu6_resources[] = {
+        [0] = {
+                .name   = "TMU6",
+                .start  = 0xffdc0008,
+                .end    = 0xffdc0013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 45,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu6_device = {
+        .name           = "sh_tmu",
+        .id             = 6,
+        .dev = {
+                .platform_data  = &tmu6_platform_data,
+        },
+        .resource       = tmu6_resources,
+        .num_resources  = ARRAY_SIZE(tmu6_resources),
+};
+
+static struct sh_timer_config tmu7_platform_data = {
+        .name = "TMU7",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu7_resources[] = {
+        [0] = {
+                .name   = "TMU7",
+                .start  = 0xffdc0014,
+                .end    = 0xffdc001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 45,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu7_device = {
+        .name           = "sh_tmu",
+        .id             = 7,
+        .dev = {
+                .platform_data  = &tmu7_platform_data,
+        },
+        .resource       = tmu7_resources,
+        .num_resources  = ARRAY_SIZE(tmu7_resources),
+};
+
+static struct sh_timer_config tmu8_platform_data = {
+        .name = "TMU8",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu8_resources[] = {
+        [0] = {
+                .name   = "TMU8",
+                .start  = 0xffdc0020,
+                .end    = 0xffdc002b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 45,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu8_device = {
+        .name           = "sh_tmu",
+        .id             = 8,
+        .dev = {
+                .platform_data  = &tmu8_platform_data,
+        },
+        .resource       = tmu8_resources,
+        .num_resources  = ARRAY_SIZE(tmu8_resources),
+};
+
+static struct sh_timer_config tmu9_platform_data = {
+        .name = "TMU9",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu9_resources[] = {
+        [0] = {
+                .name   = "TMU9",
+                .start  = 0xffde0008,
+                .end    = 0xffde0013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 46,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu9_device = {
+        .name           = "sh_tmu",
+        .id             = 9,
+        .dev = {
+                .platform_data  = &tmu9_platform_data,
+        },
+        .resource       = tmu9_resources,
+        .num_resources  = ARRAY_SIZE(tmu9_resources),
+};
+
+static struct sh_timer_config tmu10_platform_data = {
+        .name = "TMU10",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu10_resources[] = {
+        [0] = {
+                .name   = "TMU10",
+                .start  = 0xffde0014,
+                .end    = 0xffde001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 46,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu10_device = {
+        .name           = "sh_tmu",
+        .id             = 10,
+        .dev = {
+                .platform_data  = &tmu10_platform_data,
+        },
+        .resource       = tmu10_resources,
+        .num_resources  = ARRAY_SIZE(tmu10_resources),
+};
+
+static struct sh_timer_config tmu11_platform_data = {
+        .name = "TMU11",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu11_resources[] = {
+        [0] = {
+                .name   = "TMU11",
+                .start  = 0xffde0020,
+                .end    = 0xffde002b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 46,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu11_device = {
+        .name           = "sh_tmu",
+        .id             = 11,
+        .dev = {
+                .platform_data  = &tmu11_platform_data,
+        },
+        .resource       = tmu11_resources,
+        .num_resources  = ARRAY_SIZE(tmu11_resources),
+};
+
 static struct resource usb_ohci_resources[] = {
         [0] = {
                 .start  = 0xffe70400,
@@ -94,6 +458,21 @@ static struct platform_device usb_ohci_device = {
         .resource       = usb_ohci_resources,
 };
 
+static struct platform_device *sh7786_early_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+        &tmu3_device,
+        &tmu4_device,
+        &tmu5_device,
+        &tmu6_device,
+        &tmu7_device,
+        &tmu8_device,
+        &tmu9_device,
+        &tmu10_device,
+        &tmu11_device,
+};
+
 static struct platform_device *sh7786_devices[] __initdata = {
         &sci_device,
         &usb_ohci_device,
@@ -156,12 +535,26 @@ static void __init sh7786_usb_setup(void)
 
 static int __init sh7786_devices_setup(void)
 {
+        int ret;
+
         sh7786_usb_setup();
+
+        ret = platform_add_devices(sh7786_early_devices,
+                                   ARRAY_SIZE(sh7786_early_devices));
+        if (unlikely(ret != 0))
+                return ret;
+
         return platform_add_devices(sh7786_devices,
                                     ARRAY_SIZE(sh7786_devices));
 }
 device_initcall(sh7786_devices_setup);
 
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(sh7786_early_devices,
+                                   ARRAY_SIZE(sh7786_early_devices));
+}
+
 enum {
         UNUSED = 0,
 
diff --git a/arch/sh/kernel/cpu/sh4a/setup-shx3.c b/arch/sh/kernel/cpu/sh4a/setup-shx3.c
index bd35f32534b9..53c65fd9ccef 100644
--- a/arch/sh/kernel/cpu/sh4a/setup-shx3.c
+++ b/arch/sh/kernel/cpu/sh4a/setup-shx3.c
@@ -1,7 +1,7 @@
 /*
- * SH-X3 Setup
+ * SH-X3 Prototype Setup
  *
- *  Copyright (C) 2007  Paul Mundt
+ *  Copyright (C) 2007 - 2009  Paul Mundt
  *
  * 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
@@ -12,6 +12,7 @@
 #include <linux/serial.h>
 #include <linux/serial_sci.h>
 #include <linux/io.h>
+#include <linux/sh_timer.h>
 #include <asm/mmzone.h>
 
 static struct plat_sci_port sci_platform_data[] = {
@@ -48,17 +49,221 @@ static struct platform_device sci_device = {
         },
 };
 
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = 0xffc10008,
+                .end    = 0xffc10013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 16,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = 0xffc10014,
+                .end    = 0xffc1001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 17,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = 0xffc10020,
+                .end    = 0xffc1002f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 18,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
+static struct sh_timer_config tmu3_platform_data = {
+        .name = "TMU3",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu3_resources[] = {
+        [0] = {
+                .name   = "TMU3",
+                .start  = 0xffc20008,
+                .end    = 0xffc20013,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 19,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu3_device = {
+        .name           = "sh_tmu",
+        .id             = 3,
+        .dev = {
+                .platform_data  = &tmu3_platform_data,
+        },
+        .resource       = tmu3_resources,
+        .num_resources  = ARRAY_SIZE(tmu3_resources),
+};
+
+static struct sh_timer_config tmu4_platform_data = {
+        .name = "TMU4",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu4_resources[] = {
+        [0] = {
+                .name   = "TMU4",
+                .start  = 0xffc20014,
+                .end    = 0xffc2001f,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 20,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu4_device = {
+        .name           = "sh_tmu",
+        .id             = 4,
+        .dev = {
+                .platform_data  = &tmu4_platform_data,
+        },
+        .resource       = tmu4_resources,
+        .num_resources  = ARRAY_SIZE(tmu4_resources),
+};
+
+static struct sh_timer_config tmu5_platform_data = {
+        .name = "TMU5",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu5_resources[] = {
+        [0] = {
+                .name   = "TMU5",
+                .start  = 0xffc20020,
+                .end    = 0xffc2002b,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = 21,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu5_device = {
+        .name           = "sh_tmu",
+        .id             = 5,
+        .dev = {
+                .platform_data  = &tmu5_platform_data,
+        },
+        .resource       = tmu5_resources,
+        .num_resources  = ARRAY_SIZE(tmu5_resources),
+};
+
+static struct platform_device *shx3_early_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+        &tmu3_device,
+        &tmu4_device,
+        &tmu5_device,
+};
+
 static struct platform_device *shx3_devices[] __initdata = {
         &sci_device,
 };
 
 static int __init shx3_devices_setup(void)
 {
+        int ret;
+
+        ret = platform_add_devices(shx3_early_devices,
+                                   ARRAY_SIZE(shx3_early_devices));
+        if (unlikely(ret != 0))
+                return ret;
+
         return platform_add_devices(shx3_devices,
                                     ARRAY_SIZE(shx3_devices));
 }
 __initcall(shx3_devices_setup);
 
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(shx3_early_devices,
+                                   ARRAY_SIZE(shx3_early_devices));
+}
+
 enum {
         UNUSED = 0,
 
diff --git a/arch/sh/kernel/cpu/sh5/Makefile b/arch/sh/kernel/cpu/sh5/Makefile
index ce4602ea23a8..a184a31e686e 100644
--- a/arch/sh/kernel/cpu/sh5/Makefile
+++ b/arch/sh/kernel/cpu/sh5/Makefile
@@ -6,6 +6,9 @@ obj-y := entry.o probe.o switchto.o
 obj-$(CONFIG_SH_FPU)            += fpu.o
 obj-$(CONFIG_KALLSYMS)          += unwind.o
 
+# CPU subtype setup
+obj-$(CONFIG_CPU_SH5)           += setup-sh5.o
+
 # Primary on-chip clocks (common)
 clock-$(CONFIG_CPU_SH5)         := clock-sh5.o
 
diff --git a/arch/sh/kernel/cpu/sh5/clock-sh5.c b/arch/sh/kernel/cpu/sh5/clock-sh5.c
index 52c49248833a..7f864ebc51d3 100644
--- a/arch/sh/kernel/cpu/sh5/clock-sh5.c
+++ b/arch/sh/kernel/cpu/sh5/clock-sh5.c
@@ -32,30 +32,30 @@ static struct clk_ops sh5_master_clk_ops = {
         .init           = master_clk_init,
 };
 
-static void module_clk_recalc(struct clk *clk)
+static unsigned long module_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inw(cprc_base) >> 12) & 0x0007;
-        clk->rate = clk->parent->rate / ifc_table[idx];
+        return clk->parent->rate / ifc_table[idx];
 }
 
 static struct clk_ops sh5_module_clk_ops = {
         .recalc         = module_clk_recalc,
 };
 
-static void bus_clk_recalc(struct clk *clk)
+static unsigned long bus_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inw(cprc_base) >> 3) & 0x0007;
-        clk->rate = clk->parent->rate / ifc_table[idx];
+        return clk->parent->rate / ifc_table[idx];
 }
 
 static struct clk_ops sh5_bus_clk_ops = {
         .recalc         = bus_clk_recalc,
 };
 
-static void cpu_clk_recalc(struct clk *clk)
+static unsigned long cpu_clk_recalc(struct clk *clk)
 {
         int idx = (ctrl_inw(cprc_base) & 0x0007);
-        clk->rate = clk->parent->rate / ifc_table[idx];
+        return clk->parent->rate / ifc_table[idx];
 }
 
 static struct clk_ops sh5_cpu_clk_ops = {
@@ -71,7 +71,7 @@ static struct clk_ops *sh5_clk_ops[] = {
 
 void __init arch_init_clk_ops(struct clk_ops **ops, int idx)
 {
-        cprc_base = onchip_remap(CPRC_BASE, 1024, "CPRC");
+        cprc_base = (unsigned long)ioremap_nocache(CPRC_BASE, 1024);
         BUG_ON(!cprc_base);
 
         if (idx < ARRAY_SIZE(sh5_clk_ops))
diff --git a/arch/sh/kernel/cpu/sh5/entry.S b/arch/sh/kernel/cpu/sh5/entry.S
index 7e49cb812f8b..b0aacf675258 100644
--- a/arch/sh/kernel/cpu/sh5/entry.S
+++ b/arch/sh/kernel/cpu/sh5/entry.S
@@ -812,27 +812,6 @@ no_underflow:
         ! exceptions
         add     SP, ZERO, r14
 
-#ifdef CONFIG_POOR_MANS_STRACE
-        /* We've pushed all the registers now, so only r2-r4 hold anything
-         * useful. Move them into callee save registers */
-        or      r2, ZERO, r28
-        or      r3, ZERO, r29
-        or      r4, ZERO, r30
-
-        /* Preserve r2 as the event code */
-        movi    evt_debug, r3
-        ori     r3, 1, r3
-        ptabs   r3, tr0
-
-        or      SP, ZERO, r6
-        getcon  TRA, r5
-        blink   tr0, LINK
-
-        or      r28, ZERO, r2
-        or      r29, ZERO, r3
-        or      r30, ZERO, r4
-#endif
-
         /* For syscall and debug race condition, get TRA now */
         getcon  TRA, r5
 
@@ -887,11 +866,6 @@ no_underflow:
  */
         .global ret_from_irq
 ret_from_irq:
-#ifdef CONFIG_POOR_MANS_STRACE
-        pta     evt_debug_ret_from_irq, tr0
-        ori     SP, 0, r2
-        blink   tr0, LINK
-#endif
         ld.q    SP, FRAME_S(FSSR), r6
         shlri   r6, 30, r6
         andi    r6, 1, r6
@@ -905,12 +879,6 @@ ret_from_irq:
 ret_from_exception:
         preempt_stop()
 
-#ifdef CONFIG_POOR_MANS_STRACE
-        pta     evt_debug_ret_from_exc, tr0
-        ori     SP, 0, r2
-        blink   tr0, LINK
-#endif
-
         ld.q    SP, FRAME_S(FSSR), r6
         shlri   r6, 30, r6
         andi    r6, 1, r6
@@ -1236,18 +1204,6 @@ syscall_bad:
         .global syscall_ret
 syscall_ret:
         st.q    SP, FRAME_R(9), r2      /* Expecting SP back to BASIC frame */
-
-#ifdef CONFIG_POOR_MANS_STRACE
-        /* nothing useful in registers at this point */
-
-        movi    evt_debug2, r5
-        ori     r5, 1, r5
-        ptabs   r5, tr0
-        ld.q    SP, FRAME_R(9), r2
-        or      SP, ZERO, r3
-        blink   tr0, LINK
-#endif
-
         ld.q    SP, FRAME_S(FSPC), r2
         addi    r2, 4, r2               /* Move PC, being pre-execution event */
         st.q    SP, FRAME_S(FSPC), r2
@@ -1268,25 +1224,12 @@ ret_from_fork:
         ptabs   r5, tr0
         blink   tr0, LINK
 
-#ifdef CONFIG_POOR_MANS_STRACE
-        /* nothing useful in registers at this point */
-
-        movi    evt_debug2, r5
-        ori     r5, 1, r5
-        ptabs   r5, tr0
-        ld.q    SP, FRAME_R(9), r2
-        or      SP, ZERO, r3
-        blink   tr0, LINK
-#endif
-
         ld.q    SP, FRAME_S(FSPC), r2
         addi    r2, 4, r2               /* Move PC, being pre-execution event */
         st.q    SP, FRAME_S(FSPC), r2
         pta     ret_from_syscall, tr0
         blink   tr0, ZERO
 
-
-
 syscall_allowed:
         /* Use LINK to deflect the exit point, default is syscall_ret */
         pta     syscall_ret, tr0
@@ -1410,8 +1353,8 @@ peek_real_address_q:
            r2(out) : result quadword
 
            This is provided as a cheapskate way of manipulating device
-           registers for debugging (to avoid the need to onchip_remap the debug
-           module, and to avoid the need to onchip_remap the watchpoint
+           registers for debugging (to avoid the need to ioremap the debug
+           module, and to avoid the need to ioremap the watchpoint
            controller in a way that identity maps sufficient bits to avoid the
            SH5-101 cut2 silicon defect).
 
@@ -1459,8 +1402,8 @@ poke_real_address_q:
            r3 : quadword value to write.
 
            This is provided as a cheapskate way of manipulating device
-           registers for debugging (to avoid the need to onchip_remap the debug
-           module, and to avoid the need to onchip_remap the watchpoint
+           registers for debugging (to avoid the need to ioremap the debug
+           module, and to avoid the need to ioremap the watchpoint
            controller in a way that identity maps sufficient bits to avoid the
            SH5-101 cut2 silicon defect).
 
diff --git a/arch/sh/kernel/cpu/sh5/setup-sh5.c b/arch/sh/kernel/cpu/sh5/setup-sh5.c
new file mode 100644
index 000000000000..f5ff1ac57fc2
--- /dev/null
+++ b/arch/sh/kernel/cpu/sh5/setup-sh5.c
@@ -0,0 +1,195 @@
+/*
+ * SH5-101/SH5-103 CPU Setup
+ *
+ *  Copyright (C) 2009  Paul Mundt
+ *
+ * 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.
+ */
+#include <linux/platform_device.h>
+#include <linux/init.h>
+#include <linux/serial.h>
+#include <linux/serial_sci.h>
+#include <linux/io.h>
+#include <linux/mm.h>
+#include <linux/sh_timer.h>
+#include <asm/addrspace.h>
+
+static struct plat_sci_port sci_platform_data[] = {
+        {
+                .mapbase        = PHYS_PERIPHERAL_BLOCK + 0x01030000,
+                .flags          = UPF_BOOT_AUTOCONF | UPF_IOREMAP,
+                .type           = PORT_SCIF,
+                .irqs           = { 39, 40, 42, 0 },
+        }, {
+                .flags = 0,
+        }
+};
+
+static struct platform_device sci_device = {
+        .name           = "sh-sci",
+        .id             = -1,
+        .dev            = {
+                .platform_data  = sci_platform_data,
+        },
+};
+
+static struct resource rtc_resources[] = {
+        [0] = {
+                .start  = PHYS_PERIPHERAL_BLOCK + 0x01040000,
+                .end    = PHYS_PERIPHERAL_BLOCK + 0x01040000 + 0x58 - 1,
+                .flags  = IORESOURCE_IO,
+        },
+        [1] = {
+                /* Period IRQ */
+                .start  = IRQ_PRI,
+                .flags  = IORESOURCE_IRQ,
+        },
+        [2] = {
+                /* Carry IRQ */
+                .start  = IRQ_CUI,
+                .flags  = IORESOURCE_IRQ,
+        },
+        [3] = {
+                /* Alarm IRQ */
+                .start  = IRQ_ATI,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device rtc_device = {
+        .name           = "sh-rtc",
+        .id             = -1,
+        .num_resources  = ARRAY_SIZE(rtc_resources),
+        .resource       = rtc_resources,
+};
+
+#define TMU_BLOCK_OFF   0x01020000
+#define TMU_BASE        PHYS_PERIPHERAL_BLOCK + TMU_BLOCK_OFF
+#define TMU0_BASE       (TMU_BASE + 0x8 + (0xc * 0x0))
+#define TMU1_BASE       (TMU_BASE + 0x8 + (0xc * 0x1))
+#define TMU2_BASE       (TMU_BASE + 0x8 + (0xc * 0x2))
+
+static struct sh_timer_config tmu0_platform_data = {
+        .name = "TMU0",
+        .channel_offset = 0x04,
+        .timer_bit = 0,
+        .clk = "peripheral_clk",
+        .clockevent_rating = 200,
+};
+
+static struct resource tmu0_resources[] = {
+        [0] = {
+                .name   = "TMU0",
+                .start  = TMU0_BASE,
+                .end    = TMU0_BASE + 0xc - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = IRQ_TUNI0,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu0_device = {
+        .name           = "sh_tmu",
+        .id             = 0,
+        .dev = {
+                .platform_data  = &tmu0_platform_data,
+        },
+        .resource       = tmu0_resources,
+        .num_resources  = ARRAY_SIZE(tmu0_resources),
+};
+
+static struct sh_timer_config tmu1_platform_data = {
+        .name = "TMU1",
+        .channel_offset = 0x10,
+        .timer_bit = 1,
+        .clk = "peripheral_clk",
+        .clocksource_rating = 200,
+};
+
+static struct resource tmu1_resources[] = {
+        [0] = {
+                .name   = "TMU1",
+                .start  = TMU1_BASE,
+                .end    = TMU1_BASE + 0xc - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = IRQ_TUNI1,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu1_device = {
+        .name           = "sh_tmu",
+        .id             = 1,
+        .dev = {
+                .platform_data  = &tmu1_platform_data,
+        },
+        .resource       = tmu1_resources,
+        .num_resources  = ARRAY_SIZE(tmu1_resources),
+};
+
+static struct sh_timer_config tmu2_platform_data = {
+        .name = "TMU2",
+        .channel_offset = 0x1c,
+        .timer_bit = 2,
+        .clk = "peripheral_clk",
+};
+
+static struct resource tmu2_resources[] = {
+        [0] = {
+                .name   = "TMU2",
+                .start  = TMU2_BASE,
+                .end    = TMU2_BASE + 0xc - 1,
+                .flags  = IORESOURCE_MEM,
+        },
+        [1] = {
+                .start  = IRQ_TUNI2,
+                .flags  = IORESOURCE_IRQ,
+        },
+};
+
+static struct platform_device tmu2_device = {
+        .name           = "sh_tmu",
+        .id             = 2,
+        .dev = {
+                .platform_data  = &tmu2_platform_data,
+        },
+        .resource       = tmu2_resources,
+        .num_resources  = ARRAY_SIZE(tmu2_resources),
+};
+
+static struct platform_device *sh5_early_devices[] __initdata = {
+        &tmu0_device,
+        &tmu1_device,
+        &tmu2_device,
+};
+
+static struct platform_device *sh5_devices[] __initdata = {
+        &sci_device,
+        &rtc_device,
+};
+
+static int __init sh5_devices_setup(void)
+{
+        int ret;
+
+        ret = platform_add_devices(sh5_early_devices,
+                                   ARRAY_SIZE(sh5_early_devices));
+        if (unlikely(ret != 0))
+                return ret;
+
+        return platform_add_devices(sh5_devices,
+                                    ARRAY_SIZE(sh5_devices));
+}
+__initcall(sh5_devices_setup);
+
+void __init plat_early_device_setup(void)
+{
+        early_platform_add_devices(sh5_early_devices,
+                                   ARRAY_SIZE(sh5_early_devices));
+}
diff --git a/arch/sh/kernel/io.c b/arch/sh/kernel/io.c
index 29cf4588fc05..4f85fffaa557 100644
--- a/arch/sh/kernel/io.c
+++ b/arch/sh/kernel/io.c
@@ -12,6 +12,7 @@
  * for more details.
  */
 #include <linux/module.h>
+#include <linux/pci.h>
 #include <asm/machvec.h>
 #include <asm/io.h>
 
diff --git a/arch/sh/kernel/io_trapped.c b/arch/sh/kernel/io_trapped.c
index c22853b059ef..77dfecb64373 100644
--- a/arch/sh/kernel/io_trapped.c
+++ b/arch/sh/kernel/io_trapped.c
@@ -267,7 +267,7 @@ static struct mem_access trapped_io_access = {
 int handle_trapped_io(struct pt_regs *regs, unsigned long address)
 {
         mm_segment_t oldfs;
-        opcode_t instruction;
+        insn_size_t instruction;
         int tmp;
 
         if (!lookup_tiop(address))
diff --git a/arch/sh/kernel/irq.c b/arch/sh/kernel/irq.c
index 3f1372eb0091..3d09062f4682 100644
--- a/arch/sh/kernel/irq.c
+++ b/arch/sh/kernel/irq.c
@@ -31,39 +31,64 @@ void ack_bad_irq(unsigned int irq)
 }
 
 #if defined(CONFIG_PROC_FS)
+/*
+ * /proc/interrupts printing:
+ */
+static int show_other_interrupts(struct seq_file *p, int prec)
+{
+        seq_printf(p, "%*s: %10u\n", prec, "ERR", atomic_read(&irq_err_count));
+        return 0;
+}
+
 int show_interrupts(struct seq_file *p, void *v)
 {
-        int i = *(loff_t *) v, j;
-        struct irqaction * action;
-        unsigned long flags;
+        unsigned long flags, any_count = 0;
+        int i = *(loff_t *)v, j, prec;
+        struct irqaction *action;
+        struct irq_desc *desc;
+
+        if (i > nr_irqs)
+                return 0;
+
+        for (prec = 3, j = 1000; prec < 10 && j <= nr_irqs; ++prec)
+                j *= 10;
+
+        if (i == nr_irqs)
+                return show_other_interrupts(p, prec);
 
         if (i == 0) {
-                seq_puts(p, "           ");
+                seq_printf(p, "%*s", prec + 8, "");
                 for_each_online_cpu(j)
-                        seq_printf(p, "CPU%d       ",j);
+                        seq_printf(p, "CPU%-8d", j);
                 seq_putc(p, '\n');
         }
 
-        if (i < sh_mv.mv_nr_irqs) {
-                spin_lock_irqsave(&irq_desc[i].lock, flags);
-                action = irq_desc[i].action;
-                if (!action)
-                        goto unlock;
-                seq_printf(p, "%3d: ",i);
-                for_each_online_cpu(j)
-                        seq_printf(p, "%10u ", kstat_irqs_cpu(i, j));
-                seq_printf(p, " %14s", irq_desc[i].chip->name);
-                seq_printf(p, "-%-8s", irq_desc[i].name);
-                seq_printf(p, "  %s", action->name);
+        desc = irq_to_desc(i);
+        if (!desc)
+                return 0;
+
+        spin_lock_irqsave(&desc->lock, flags);
+        for_each_online_cpu(j)
+                any_count |= kstat_irqs_cpu(i, j);
+        action = desc->action;
+        if (!action && !any_count)
+                goto out;
+
+        seq_printf(p, "%*d: ", prec, i);
+        for_each_online_cpu(j)
+                seq_printf(p, "%10u ", kstat_irqs_cpu(i, j));
+        seq_printf(p, " %14s", desc->chip->name);
+        seq_printf(p, "-%-8s", desc->name);
 
-                for (action=action->next; action; action = action->next)
+        if (action) {
+                seq_printf(p, "  %s", action->name);
+                while ((action = action->next) != NULL)
                         seq_printf(p, ", %s", action->name);
-                seq_putc(p, '\n');
-unlock:
-                spin_unlock_irqrestore(&irq_desc[i].lock, flags);
-        } else if (i == sh_mv.mv_nr_irqs)
-                seq_printf(p, "Err: %10u\n", atomic_read(&irq_err_count));
+        }
 
+        seq_putc(p, '\n');
+out:
+        spin_unlock_irqrestore(&desc->lock, flags);
         return 0;
 }
 #endif
@@ -254,3 +279,11 @@ void __init init_IRQ(void)
 
         irq_ctx_init(smp_processor_id());
 }
+
+#ifdef CONFIG_SPARSE_IRQ
+int __init arch_probe_nr_irqs(void)
+{
+        nr_irqs = sh_mv.mv_nr_irqs;
+        return 0;
+}
+#endif
diff --git a/arch/sh/kernel/kgdb.c b/arch/sh/kernel/kgdb.c
index 7c747e7d71b8..305aad742aec 100644
--- a/arch/sh/kernel/kgdb.c
+++ b/arch/sh/kernel/kgdb.c
@@ -47,7 +47,7 @@ char in_nmi = 0;	/* Set during NMI to prevent re-entry */
 /* Calculate the new address for after a step */
 static short *get_step_address(struct pt_regs *linux_regs)
 {
-        opcode_t op = __raw_readw(linux_regs->pc);
+        insn_size_t op = __raw_readw(linux_regs->pc);
         long addr;
 
         /* BT */
@@ -134,7 +134,7 @@ static short *get_step_address(struct pt_regs *linux_regs)
  */
 
 static unsigned long stepped_address;
-static opcode_t stepped_opcode;
+static insn_size_t stepped_opcode;
 
 static void do_single_step(struct pt_regs *linux_regs)
 {
diff --git a/arch/sh/kernel/timers/timer-broadcast.c b/arch/sh/kernel/localtimer.c
index 96e8eaea1e62..96e8eaea1e62 100644
--- a/arch/sh/kernel/timers/timer-broadcast.c
+++ b/arch/sh/kernel/localtimer.c
diff --git a/arch/sh/kernel/machvec.c b/arch/sh/kernel/machvec.c
index c1ea41e5812a..548f6607fd0f 100644
--- a/arch/sh/kernel/machvec.c
+++ b/arch/sh/kernel/machvec.c
@@ -129,6 +129,7 @@ void __init sh_mv_setup(void)
         mv_set(ioport_map);
         mv_set(ioport_unmap);
         mv_set(irq_demux);
+        mv_set(mode_pins);
 
         if (!sh_mv.mv_nr_irqs)
                 sh_mv.mv_nr_irqs = NR_IRQS;
diff --git a/arch/sh/kernel/module.c b/arch/sh/kernel/module.c
index c43081039dd5..c19b0f7d2cc1 100644
--- a/arch/sh/kernel/module.c
+++ b/arch/sh/kernel/module.c
@@ -90,7 +90,7 @@ int apply_relocate_add(Elf32_Shdr *sechdrs,
                  * SHmedia, the LSB of the symbol needs to be asserted
                  * for the CPU to be in SHmedia mode when it starts executing
                  * the branch target. */
-                relocation |= (sym->st_other & 4);
+                relocation |= !!(sym->st_other & 4);
 #endif
 
                 switch (ELF32_R_TYPE(rel[i].r_info)) {
diff --git a/arch/sh/kernel/process_32.c b/arch/sh/kernel/process_32.c
index 6d94725d22f2..9289ede29c7b 100644
--- a/arch/sh/kernel/process_32.c
+++ b/arch/sh/kernel/process_32.c
@@ -251,7 +251,8 @@ static void ubc_set_tracing(int asid, unsigned long pc)
 
         if (current_cpu_data.type == CPU_SH7729 ||
             current_cpu_data.type == CPU_SH7710 ||
-            current_cpu_data.type == CPU_SH7712) {
+            current_cpu_data.type == CPU_SH7712 ||
+            current_cpu_data.type == CPU_SH7203){
                 ctrl_outw(BBR_INST | BBR_READ | BBR_CPU, UBC_BBRA);
                 ctrl_outl(BRCR_PCBA | BRCR_PCTE, UBC_BRCR);
         } else {
@@ -407,6 +408,7 @@ asmlinkage void break_point_trap(void)
 #else
         ctrl_outw(0, UBC_BBRA);
         ctrl_outw(0, UBC_BBRB);
+        ctrl_outl(0, UBC_BRCR);
 #endif
         current->thread.ubc_pc = 0;
         ubc_usercnt -= 1;
diff --git a/arch/sh/kernel/ptrace_32.c b/arch/sh/kernel/ptrace_32.c
index f7b22dd83b0c..3392e835a374 100644
--- a/arch/sh/kernel/ptrace_32.c
+++ b/arch/sh/kernel/ptrace_32.c
@@ -334,6 +334,14 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
                                         [(addr - (long)&dummy->fpu) >> 2];
                 } else if (addr == (long) &dummy->u_fpvalid)
                         tmp = !!tsk_used_math(child);
+                else if (addr == PT_TEXT_ADDR)
+                        tmp = child->mm->start_code;
+                else if (addr == PT_DATA_ADDR)
+                        tmp = child->mm->start_data;
+                else if (addr == PT_TEXT_END_ADDR)
+                        tmp = child->mm->end_code;
+                else if (addr == PT_TEXT_LEN)
+                        tmp = child->mm->end_code - child->mm->start_code;
                 else
                         tmp = 0;
                 ret = put_user(tmp, datap);
diff --git a/arch/sh/kernel/setup.c b/arch/sh/kernel/setup.c
index 04a6004fccc4..dd38338553ef 100644
--- a/arch/sh/kernel/setup.c
+++ b/arch/sh/kernel/setup.c
@@ -29,6 +29,7 @@
 #include <linux/mmzone.h>
 #include <linux/clk.h>
 #include <linux/delay.h>
+#include <linux/platform_device.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include <asm/page.h>
@@ -155,7 +156,7 @@ static void __init reserve_crashkernel(void)
                         &crash_size, &crash_base);
         if (ret == 0 && crash_size) {
                 if (crash_base <= 0) {
-                        vp = alloc_bootmem_nopanic(crash_size); 
+                        vp = alloc_bootmem_nopanic(crash_size);
                         if (!vp) {
                                 printk(KERN_INFO "crashkernel allocation "
                                        "failed\n");
@@ -184,7 +185,6 @@ static inline void __init reserve_crashkernel(void)
 {}
 #endif
 
-#ifndef CONFIG_GENERIC_CALIBRATE_DELAY
 void __cpuinit calibrate_delay(void)
 {
         struct clk *clk = clk_get(NULL, "cpu_clk");
@@ -200,7 +200,6 @@ void __cpuinit calibrate_delay(void)
                          (loops_per_jiffy/(5000/HZ)) % 100,
                          loops_per_jiffy);
 }
-#endif
 
 void __init __add_active_range(unsigned int nid, unsigned long start_pfn,
                                                 unsigned long end_pfn)
@@ -328,6 +327,10 @@ static int __init parse_elfcorehdr(char *arg)
 early_param("elfcorehdr", parse_elfcorehdr);
 #endif
 
+void __init __attribute__ ((weak)) plat_early_device_setup(void)
+{
+}
+
 void __init setup_arch(char **cmdline_p)
 {
         enable_mmu();
@@ -381,6 +384,8 @@ void __init setup_arch(char **cmdline_p)
 
         parse_early_param();
 
+        plat_early_device_setup();
+
         sh_mv_setup();
 
         /*
@@ -415,6 +420,18 @@ void __init setup_arch(char **cmdline_p)
 #endif
 }
 
+/* processor boot mode configuration */
+int generic_mode_pins(void)
+{
+        pr_warning("generic_mode_pins(): missing mode pin configuration\n");
+        return 0;
+}
+
+int test_mode_pin(int pin)
+{
+        return sh_mv.mv_mode_pins() & pin;
+}
+
 static const char *cpu_name[] = {
         [CPU_SH7201]    = "SH7201",
         [CPU_SH7203]    = "SH7203",     [CPU_SH7263]    = "SH7263",
@@ -435,7 +452,8 @@ static const char *cpu_name[] = {
         [CPU_SH7722]    = "SH7722",     [CPU_SHX3]      = "SH-X3",
         [CPU_SH5_101]   = "SH5-101",    [CPU_SH5_103]   = "SH5-103",
         [CPU_MXG]       = "MX-G",       [CPU_SH7723]    = "SH7723",
-        [CPU_SH7366]    = "SH7366",     [CPU_SH_NONE]   = "Unknown"
+        [CPU_SH7366]    = "SH7366",     [CPU_SH7724]    = "SH7724",
+        [CPU_SH_NONE]   = "Unknown"
 };
 
 const char *get_cpu_subtype(struct sh_cpuinfo *c)
diff --git a/arch/sh/kernel/sh_ksyms_32.c b/arch/sh/kernel/sh_ksyms_32.c
index 528de2955c81..fcc5de31f83b 100644
--- a/arch/sh/kernel/sh_ksyms_32.c
+++ b/arch/sh/kernel/sh_ksyms_32.c
@@ -19,14 +19,10 @@
 #include <asm/ftrace.h>
 
 extern int dump_fpu(struct pt_regs *, elf_fpregset_t *);
-extern struct hw_interrupt_type no_irq_type;
 
 /* platform dependent support */
 EXPORT_SYMBOL(dump_fpu);
 EXPORT_SYMBOL(kernel_thread);
-EXPORT_SYMBOL(irq_desc);
-EXPORT_SYMBOL(no_irq_type);
-
 EXPORT_SYMBOL(strlen);
 
 /* PCI exports */
@@ -41,11 +37,6 @@ EXPORT_SYMBOL(memcpy);
 EXPORT_SYMBOL(memset);
 EXPORT_SYMBOL(memmove);
 EXPORT_SYMBOL(__copy_user);
-
-#ifdef CONFIG_MMU
-EXPORT_SYMBOL(get_vm_area);
-#endif
-
 EXPORT_SYMBOL(__udelay);
 EXPORT_SYMBOL(__ndelay);
 EXPORT_SYMBOL(__const_udelay);
diff --git a/arch/sh/kernel/sh_ksyms_64.c b/arch/sh/kernel/sh_ksyms_64.c
index 0d74d6b8774e..8f54ef0cfbca 100644
--- a/arch/sh/kernel/sh_ksyms_64.c
+++ b/arch/sh/kernel/sh_ksyms_64.c
@@ -76,5 +76,7 @@ EXPORT_SYMBOL(strcpy);
 #define DECLARE_EXPORT(name) extern void name(void);EXPORT_SYMBOL(name)
 
 DECLARE_EXPORT(__sdivsi3);
+DECLARE_EXPORT(__sdivsi3_1);
+DECLARE_EXPORT(__sdivsi3_2);
 DECLARE_EXPORT(__udivsi3);
 DECLARE_EXPORT(__div_table);
diff --git a/arch/sh/kernel/syscalls_32.S b/arch/sh/kernel/syscalls_32.S
index 05202edd8e21..a9fff9f731ec 100644
--- a/arch/sh/kernel/syscalls_32.S
+++ b/arch/sh/kernel/syscalls_32.S
@@ -350,4 +350,5 @@ ENTRY(sys_call_table)
         .long sys_pipe2
         .long sys_inotify_init1
         .long sys_preadv
-        .long sys_writev
+        .long sys_pwritev
+        .long sys_rt_tgsigqueueinfo     /* 335 */
diff --git a/arch/sh/kernel/syscalls_64.S b/arch/sh/kernel/syscalls_64.S
index a083609f9284..75c1889af1ed 100644
--- a/arch/sh/kernel/syscalls_64.S
+++ b/arch/sh/kernel/syscalls_64.S
@@ -389,3 +389,4 @@ sys_call_table:
         .long sys_inotify_init1         /* 360 */
         .long sys_preadv
         .long sys_pwritev
+        .long sys_rt_tgsigqueueinfo
diff --git a/arch/sh/kernel/time.c b/arch/sh/kernel/time.c
new file mode 100644
index 000000000000..2edde32c764b
--- /dev/null
+++ b/arch/sh/kernel/time.c
@@ -0,0 +1,125 @@
+/*
+ *  arch/sh/kernel/time.c
+ *
+ *  Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
+ *  Copyright (C) 2000  Philipp Rumpf <prumpf@tux.org>
+ *  Copyright (C) 2002 - 2009  Paul Mundt
+ *  Copyright (C) 2002  M. R. Brown  <mrbrown@linux-sh.org>
+ *
+ * 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.
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/profile.h>
+#include <linux/timex.h>
+#include <linux/sched.h>
+#include <linux/clockchips.h>
+#include <linux/platform_device.h>
+#include <linux/smp.h>
+#include <linux/rtc.h>
+#include <asm/clock.h>
+#include <asm/rtc.h>
+
+/* Dummy RTC ops */
+static void null_rtc_get_time(struct timespec *tv)
+{
+        tv->tv_sec = mktime(2000, 1, 1, 0, 0, 0);
+        tv->tv_nsec = 0;
+}
+
+static int null_rtc_set_time(const time_t secs)
+{
+        return 0;
+}
+
+void (*rtc_sh_get_time)(struct timespec *) = null_rtc_get_time;
+int (*rtc_sh_set_time)(const time_t) = null_rtc_set_time;
+
+#ifdef CONFIG_GENERIC_CMOS_UPDATE
+unsigned long read_persistent_clock(void)
+{
+        struct timespec tv;
+        rtc_sh_get_time(&tv);
+        return tv.tv_sec;
+}
+
+int update_persistent_clock(struct timespec now)
+{
+        return rtc_sh_set_time(now.tv_sec);
+}
+#endif
+
+unsigned int get_rtc_time(struct rtc_time *tm)
+{
+        if (rtc_sh_get_time != null_rtc_get_time) {
+                struct timespec tv;
+
+                rtc_sh_get_time(&tv);
+                rtc_time_to_tm(tv.tv_sec, tm);
+        }
+
+        return RTC_24H;
+}
+EXPORT_SYMBOL(get_rtc_time);
+
+int set_rtc_time(struct rtc_time *tm)
+{
+        unsigned long secs;
+
+        rtc_tm_to_time(tm, &secs);
+        return rtc_sh_set_time(secs);
+}
+EXPORT_SYMBOL(set_rtc_time);
+
+static int __init rtc_generic_init(void)
+{
+        struct platform_device *pdev;
+
+        if (rtc_sh_get_time == null_rtc_get_time)
+                return -ENODEV;
+
+        pdev = platform_device_register_simple("rtc-generic", -1, NULL, 0);
+        if (IS_ERR(pdev))
+                return PTR_ERR(pdev);
+
+        return 0;
+}
+module_init(rtc_generic_init);
+
+void (*board_time_init)(void);
+
+unsigned long long sched_clock(void)
+{
+        return (jiffies_64 - INITIAL_JIFFIES) * (NSEC_PER_SEC / HZ);
+}
+
+static void __init sh_late_time_init(void)
+{
+        /*
+         * Make sure all compiled-in early timers register themselves.
+         * Run probe() for one "earlytimer" device.
+         */
+        early_platform_driver_register_all("earlytimer");
+        early_platform_driver_probe("earlytimer", 1, 0);
+}
+
+void __init time_init(void)
+{
+        if (board_time_init)
+                board_time_init();
+
+        clk_init();
+
+        rtc_sh_get_time(&xtime);
+        set_normalized_timespec(&wall_to_monotonic,
+                                -xtime.tv_sec, -xtime.tv_nsec);
+
+#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
+        local_timer_setup(smp_processor_id());
+#endif
+
+        late_time_init = sh_late_time_init;
+}
diff --git a/arch/sh/kernel/time_32.c b/arch/sh/kernel/time_32.c
deleted file mode 100644
index 1700d2465f6c..000000000000
--- a/arch/sh/kernel/time_32.c
+++ /dev/null
@@ -1,240 +0,0 @@
-/*
- *  arch/sh/kernel/time_32.c
- *
- *  Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
- *  Copyright (C) 2000  Philipp Rumpf <prumpf@tux.org>
- *  Copyright (C) 2002 - 2008  Paul Mundt
- *  Copyright (C) 2002  M. R. Brown  <mrbrown@linux-sh.org>
- *
- *  Some code taken from i386 version.
- *    Copyright (C) 1991, 1992, 1995  Linus Torvalds
- */
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/profile.h>
-#include <linux/timex.h>
-#include <linux/sched.h>
-#include <linux/clockchips.h>
-#include <linux/mc146818rtc.h>  /* for rtc_lock */
-#include <linux/smp.h>
-#include <asm/clock.h>
-#include <asm/rtc.h>
-#include <asm/timer.h>
-#include <asm/kgdb.h>
-
-struct sys_timer *sys_timer;
-
-/* Move this somewhere more sensible.. */
-DEFINE_SPINLOCK(rtc_lock);
-EXPORT_SYMBOL(rtc_lock);
-
-/* Dummy RTC ops */
-static void null_rtc_get_time(struct timespec *tv)
-{
-        tv->tv_sec = mktime(2000, 1, 1, 0, 0, 0);
-        tv->tv_nsec = 0;
-}
-
-static int null_rtc_set_time(const time_t secs)
-{
-        return 0;
-}
-
-void (*rtc_sh_get_time)(struct timespec *) = null_rtc_get_time;
-int (*rtc_sh_set_time)(const time_t) = null_rtc_set_time;
-
-#ifndef CONFIG_GENERIC_TIME
-void do_gettimeofday(struct timeval *tv)
-{
-        unsigned long flags;
-        unsigned long seq;
-        unsigned long usec, sec;
-
-        do {
-                /*
-                 * Turn off IRQs when grabbing xtime_lock, so that
-                 * the sys_timer get_offset code doesn't have to handle it.
-                 */
-                seq = read_seqbegin_irqsave(&xtime_lock, flags);
-                usec = get_timer_offset();
-                sec = xtime.tv_sec;
-                usec += xtime.tv_nsec / NSEC_PER_USEC;
-        } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
-
-        while (usec >= 1000000) {
-                usec -= 1000000;
-                sec++;
-        }
-
-        tv->tv_sec = sec;
-        tv->tv_usec = usec;
-}
-EXPORT_SYMBOL(do_gettimeofday);
-
-int do_settimeofday(struct timespec *tv)
-{
-        time_t wtm_sec, sec = tv->tv_sec;
-        long wtm_nsec, nsec = tv->tv_nsec;
-
-        if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
-                return -EINVAL;
-
-        write_seqlock_irq(&xtime_lock);
-        /*
-         * This is revolting. We need to set "xtime" correctly. However, the
-         * value in this location is the value at the most recent update of
-         * wall time.  Discover what correction gettimeofday() would have
-         * made, and then undo it!
-         */
-        nsec -= get_timer_offset() * NSEC_PER_USEC;
-
-        wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
-        wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
-
-        set_normalized_timespec(&xtime, sec, nsec);
-        set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
-
-        ntp_clear();
-        write_sequnlock_irq(&xtime_lock);
-        clock_was_set();
-
-        return 0;
-}
-EXPORT_SYMBOL(do_settimeofday);
-#endif /* !CONFIG_GENERIC_TIME */
-
-/* last time the RTC clock got updated */
-static long last_rtc_update;
-
-/*
- * handle_timer_tick() needs to keep up the real-time clock,
- * as well as call the "do_timer()" routine every clocktick
- */
-void handle_timer_tick(void)
-{
-        if (current->pid)
-                profile_tick(CPU_PROFILING);
-
-        /*
-         * Here we are in the timer irq handler. We just have irqs locally
-         * disabled but we don't know if the timer_bh is running on the other
-         * CPU. We need to avoid to SMP race with it. NOTE: we don' t need
-         * the irq version of write_lock because as just said we have irq
-         * locally disabled. -arca
-         */
-        write_seqlock(&xtime_lock);
-        do_timer(1);
-
-        /*
-         * If we have an externally synchronized Linux clock, then update
-         * RTC clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
-         * called as close as possible to 500 ms before the new second starts.
-         */
-        if (ntp_synced() &&
-            xtime.tv_sec > last_rtc_update + 660 &&
-            (xtime.tv_nsec / 1000) >= 500000 - ((unsigned) TICK_SIZE) / 2 &&
-            (xtime.tv_nsec / 1000) <= 500000 + ((unsigned) TICK_SIZE) / 2) {
-                if (rtc_sh_set_time(xtime.tv_sec) == 0)
-                        last_rtc_update = xtime.tv_sec;
-                else
-                        /* do it again in 60s */
-                        last_rtc_update = xtime.tv_sec - 600;
-        }
-        write_sequnlock(&xtime_lock);
-
-#ifndef CONFIG_SMP
-        update_process_times(user_mode(get_irq_regs()));
-#endif
-}
-
-#ifdef CONFIG_PM
-int timer_suspend(struct sys_device *dev, pm_message_t state)
-{
-        struct sys_timer *sys_timer = container_of(dev, struct sys_timer, dev);
-
-        sys_timer->ops->stop();
-
-        return 0;
-}
-
-int timer_resume(struct sys_device *dev)
-{
-        struct sys_timer *sys_timer = container_of(dev, struct sys_timer, dev);
-
-        sys_timer->ops->start();
-
-        return 0;
-}
-#else
-#define timer_suspend NULL
-#define timer_resume NULL
-#endif
-
-static struct sysdev_class timer_sysclass = {
-        .name    = "timer",
-        .suspend = timer_suspend,
-        .resume  = timer_resume,
-};
-
-static int __init timer_init_sysfs(void)
-{
-        int ret;
-
-        if (!sys_timer)
-                return 0;
-
-        ret = sysdev_class_register(&timer_sysclass);
-        if (ret != 0)
-                return ret;
-
-        sys_timer->dev.cls = &timer_sysclass;
-        return sysdev_register(&sys_timer->dev);
-}
-device_initcall(timer_init_sysfs);
-
-void (*board_time_init)(void);
-
-struct clocksource clocksource_sh = {
-        .name           = "SuperH",
-};
-
-#ifdef CONFIG_GENERIC_TIME
-unsigned long long sched_clock(void)
-{
-        unsigned long long cycles;
-
-        /* jiffies based sched_clock if no clocksource is installed */
-        if (!clocksource_sh.rating)
-                return (unsigned long long)jiffies * (NSEC_PER_SEC / HZ);
-
-        cycles = clocksource_sh.read(&clocksource_sh);
-        return cyc2ns(&clocksource_sh, cycles);
-}
-#endif
-
-void __init time_init(void)
-{
-        if (board_time_init)
-                board_time_init();
-
-        clk_init();
-
-        rtc_sh_get_time(&xtime);
-        set_normalized_timespec(&wall_to_monotonic,
-                                -xtime.tv_sec, -xtime.tv_nsec);
-
-#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
-        local_timer_setup(smp_processor_id());
-#endif
-
-        /*
-         * Find the timer to use as the system timer, it will be
-         * initialized for us.
-         */
-        sys_timer = get_sys_timer();
-        if (unlikely(!sys_timer))
-                panic("System timer missing.\n");
-
-        printk(KERN_INFO "Using %s for system timer\n", sys_timer->name);
-}
diff --git a/arch/sh/kernel/time_64.c b/arch/sh/kernel/time_64.c
deleted file mode 100644
index 988c77c37231..000000000000
--- a/arch/sh/kernel/time_64.c
+++ /dev/null
@@ -1,363 +0,0 @@
-/*
- * arch/sh/kernel/time_64.c
- *
- * Copyright (C) 2000, 2001  Paolo Alberelli
- * Copyright (C) 2003 - 2007  Paul Mundt
- * Copyright (C) 2003  Richard Curnow
- *
- *    Original TMU/RTC code taken from sh version.
- *    Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
- *      Some code taken from i386 version.
- *      Copyright (C) 1991, 1992, 1995  Linus Torvalds
- *
- * 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.
- */
-#include <linux/errno.h>
-#include <linux/rwsem.h>
-#include <linux/sched.h>
-#include <linux/kernel.h>
-#include <linux/param.h>
-#include <linux/string.h>
-#include <linux/mm.h>
-#include <linux/interrupt.h>
-#include <linux/time.h>
-#include <linux/delay.h>
-#include <linux/init.h>
-#include <linux/profile.h>
-#include <linux/smp.h>
-#include <linux/module.h>
-#include <linux/bcd.h>
-#include <linux/timex.h>
-#include <linux/irq.h>
-#include <linux/io.h>
-#include <linux/platform_device.h>
-#include <cpu/registers.h>       /* required by inline __asm__ stmt. */
-#include <cpu/irq.h>
-#include <asm/addrspace.h>
-#include <asm/processor.h>
-#include <asm/uaccess.h>
-#include <asm/delay.h>
-#include <asm/clock.h>
-
-#define TMU_TOCR_INIT   0x00
-#define TMU0_TCR_INIT   0x0020
-#define TMU_TSTR_INIT   1
-#define TMU_TSTR_OFF    0
-
-/* Real Time Clock */
-#define RTC_BLOCK_OFF   0x01040000
-#define RTC_BASE        PHYS_PERIPHERAL_BLOCK + RTC_BLOCK_OFF
-#define RTC_RCR1_CIE    0x10    /* Carry Interrupt Enable */
-#define RTC_RCR1        (rtc_base + 0x38)
-
-/* Time Management Unit */
-#define TMU_BLOCK_OFF   0x01020000
-#define TMU_BASE        PHYS_PERIPHERAL_BLOCK + TMU_BLOCK_OFF
-#define TMU0_BASE       tmu_base + 0x8 + (0xc * 0x0)
-#define TMU1_BASE       tmu_base + 0x8 + (0xc * 0x1)
-#define TMU2_BASE       tmu_base + 0x8 + (0xc * 0x2)
-
-#define TMU_TOCR        tmu_base+0x0    /* Byte access */
-#define TMU_TSTR        tmu_base+0x4    /* Byte access */
-
-#define TMU0_TCOR       TMU0_BASE+0x0   /* Long access */
-#define TMU0_TCNT       TMU0_BASE+0x4   /* Long access */
-#define TMU0_TCR        TMU0_BASE+0x8   /* Word access */
-
-#define TICK_SIZE (tick_nsec / 1000)
-
-static unsigned long tmu_base, rtc_base;
-unsigned long cprc_base;
-
-/* Variables to allow interpolation of time of day to resolution better than a
- * jiffy. */
-
-/* This is effectively protected by xtime_lock */
-static unsigned long ctc_last_interrupt;
-static unsigned long long usecs_per_jiffy = 1000000/HZ; /* Approximation */
-
-#define CTC_JIFFY_SCALE_SHIFT 40
-
-/* 2**CTC_JIFFY_SCALE_SHIFT / ctc_ticks_per_jiffy */
-static unsigned long long scaled_recip_ctc_ticks_per_jiffy;
-
-/* Estimate number of microseconds that have elapsed since the last timer tick,
-   by scaling the delta that has occurred in the CTC register.
-
-   WARNING WARNING WARNING : This algorithm relies on the CTC decrementing at
-   the CPU clock rate.  If the CPU sleeps, the CTC stops counting.  Bear this
-   in mind if enabling SLEEP_WORKS in process.c.  In that case, this algorithm
-   probably needs to use TMU.TCNT0 instead.  This will work even if the CPU is
-   sleeping, though will be coarser.
-
-   FIXME : What if usecs_per_tick is moving around too much, e.g. if an adjtime
-   is running or if the freq or tick arguments of adjtimex are modified after
-   we have calibrated the scaling factor?  This will result in either a jump at
-   the end of a tick period, or a wrap backwards at the start of the next one,
-   if the application is reading the time of day often enough.  I think we
-   ought to do better than this.  For this reason, usecs_per_jiffy is left
-   separated out in the calculation below.  This allows some future hook into
-   the adjtime-related stuff in kernel/timer.c to remove this hazard.
-
-*/
-
-static unsigned long usecs_since_tick(void)
-{
-        unsigned long long current_ctc;
-        long ctc_ticks_since_interrupt;
-        unsigned long long ull_ctc_ticks_since_interrupt;
-        unsigned long result;
-
-        unsigned long long mul1_out;
-        unsigned long long mul1_out_high;
-        unsigned long long mul2_out_low, mul2_out_high;
-
-        /* Read CTC register */
-        asm ("getcon cr62, %0" : "=r" (current_ctc));
-        /* Note, the CTC counts down on each CPU clock, not up.
-           Note(2), use long type to get correct wraparound arithmetic when
-           the counter crosses zero. */
-        ctc_ticks_since_interrupt = (long) ctc_last_interrupt - (long) current_ctc;
-        ull_ctc_ticks_since_interrupt = (unsigned long long) ctc_ticks_since_interrupt;
-
-        /* Inline assembly to do 32x32x32->64 multiplier */
-        asm volatile ("mulu.l %1, %2, %0" :
-             "=r" (mul1_out) :
-             "r" (ull_ctc_ticks_since_interrupt), "r" (usecs_per_jiffy));
-
-        mul1_out_high = mul1_out >> 32;
-
-        asm volatile ("mulu.l %1, %2, %0" :
-             "=r" (mul2_out_low) :
-             "r" (mul1_out), "r" (scaled_recip_ctc_ticks_per_jiffy));
-
-#if 1
-        asm volatile ("mulu.l %1, %2, %0" :
-             "=r" (mul2_out_high) :
-             "r" (mul1_out_high), "r" (scaled_recip_ctc_ticks_per_jiffy));
-#endif
-
-        result = (unsigned long) (((mul2_out_high << 32) + mul2_out_low) >> CTC_JIFFY_SCALE_SHIFT);
-
-        return result;
-}
-
-void do_gettimeofday(struct timeval *tv)
-{
-        unsigned long flags;
-        unsigned long seq;
-        unsigned long usec, sec;
-
-        do {
-                seq = read_seqbegin_irqsave(&xtime_lock, flags);
-                usec = usecs_since_tick();
-                sec = xtime.tv_sec;
-                usec += xtime.tv_nsec / 1000;
-        } while (read_seqretry_irqrestore(&xtime_lock, seq, flags));
-
-        while (usec >= 1000000) {
-                usec -= 1000000;
-                sec++;
-        }
-
-        tv->tv_sec = sec;
-        tv->tv_usec = usec;
-}
-EXPORT_SYMBOL(do_gettimeofday);
-
-int do_settimeofday(struct timespec *tv)
-{
-        time_t wtm_sec, sec = tv->tv_sec;
-        long wtm_nsec, nsec = tv->tv_nsec;
-
-        if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
-                return -EINVAL;
-
-        write_seqlock_irq(&xtime_lock);
-        /*
-         * This is revolting. We need to set "xtime" correctly. However, the
-         * value in this location is the value at the most recent update of
-         * wall time.  Discover what correction gettimeofday() would have
-         * made, and then undo it!
-         */
-        nsec -= 1000 * usecs_since_tick();
-
-        wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
-        wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
-
-        set_normalized_timespec(&xtime, sec, nsec);
-        set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
-
-        ntp_clear();
-        write_sequnlock_irq(&xtime_lock);
-        clock_was_set();
-
-        return 0;
-}
-EXPORT_SYMBOL(do_settimeofday);
-
-/* Dummy RTC ops */
-static void null_rtc_get_time(struct timespec *tv)
-{
-        tv->tv_sec = mktime(2000, 1, 1, 0, 0, 0);
-        tv->tv_nsec = 0;
-}
-
-static int null_rtc_set_time(const time_t secs)
-{
-        return 0;
-}
-
-void (*rtc_sh_get_time)(struct timespec *) = null_rtc_get_time;
-int (*rtc_sh_set_time)(const time_t) = null_rtc_set_time;
-
-/* last time the RTC clock got updated */
-static long last_rtc_update;
-
-/*
- * timer_interrupt() needs to keep up the real-time clock,
- * as well as call the "do_timer()" routine every clocktick
- */
-static inline void do_timer_interrupt(void)
-{
-        unsigned long long current_ctc;
-
-        if (current->pid)
-                profile_tick(CPU_PROFILING);
-
-        /*
-         * Here we are in the timer irq handler. We just have irqs locally
-         * disabled but we don't know if the timer_bh is running on the other
-         * CPU. We need to avoid to SMP race with it. NOTE: we don' t need
-         * the irq version of write_lock because as just said we have irq
-         * locally disabled. -arca
-         */
-        write_seqlock(&xtime_lock);
-        asm ("getcon cr62, %0" : "=r" (current_ctc));
-        ctc_last_interrupt = (unsigned long) current_ctc;
-
-        do_timer(1);
-
-        /*
-         * If we have an externally synchronized Linux clock, then update
-         * RTC clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
-         * called as close as possible to 500 ms before the new second starts.
-         */
-        if (ntp_synced() &&
-            xtime.tv_sec > last_rtc_update + 660 &&
-            (xtime.tv_nsec / 1000) >= 500000 - ((unsigned) TICK_SIZE) / 2 &&
-            (xtime.tv_nsec / 1000) <= 500000 + ((unsigned) TICK_SIZE) / 2) {
-                if (rtc_sh_set_time(xtime.tv_sec) == 0)
-                        last_rtc_update = xtime.tv_sec;
-                else
-                        /* do it again in 60 s */
-                        last_rtc_update = xtime.tv_sec - 600;
-        }
-        write_sequnlock(&xtime_lock);
-
-#ifndef CONFIG_SMP
-        update_process_times(user_mode(get_irq_regs()));
-#endif
-}
-
-/*
- * This is the same as the above, except we _also_ save the current
- * Time Stamp Counter value at the time of the timer interrupt, so that
- * we later on can estimate the time of day more exactly.
- */
-static irqreturn_t timer_interrupt(int irq, void *dev_id)
-{
-        unsigned long timer_status;
-
-        /* Clear UNF bit */
-        timer_status = ctrl_inw(TMU0_TCR);
-        timer_status &= ~0x100;
-        ctrl_outw(timer_status, TMU0_TCR);
-
-        do_timer_interrupt();
-
-        return IRQ_HANDLED;
-}
-
-static struct irqaction irq0  = {
-        .handler = timer_interrupt,
-        .flags = IRQF_DISABLED,
-        .name = "timer",
-};
-
-void __init time_init(void)
-{
-        unsigned long interval;
-        struct clk *clk;
-
-        tmu_base = onchip_remap(TMU_BASE, 1024, "TMU");
-        if (!tmu_base) {
-                panic("Unable to remap TMU\n");
-        }
-
-        rtc_base = onchip_remap(RTC_BASE, 1024, "RTC");
-        if (!rtc_base) {
-                panic("Unable to remap RTC\n");
-        }
-
-        clk = clk_get(NULL, "cpu_clk");
-        scaled_recip_ctc_ticks_per_jiffy = ((1ULL << CTC_JIFFY_SCALE_SHIFT) /
-                        (unsigned long long)(clk_get_rate(clk) / HZ));
-
-        rtc_sh_get_time(&xtime);
-
-        setup_irq(TIMER_IRQ, &irq0);
-
-        clk = clk_get(NULL, "module_clk");
-        interval = (clk_get_rate(clk)/(HZ*4));
-
-        printk("Interval = %ld\n", interval);
-
-        /* Start TMU0 */
-        ctrl_outb(TMU_TSTR_OFF, TMU_TSTR);
-        ctrl_outb(TMU_TOCR_INIT, TMU_TOCR);
-        ctrl_outw(TMU0_TCR_INIT, TMU0_TCR);
-        ctrl_outl(interval, TMU0_TCOR);
-        ctrl_outl(interval, TMU0_TCNT);
-        ctrl_outb(TMU_TSTR_INIT, TMU_TSTR);
-}
-
-static struct resource rtc_resources[] = {
-        [0] = {
-                /* RTC base, filled in by rtc_init */
-                .flags  = IORESOURCE_IO,
-        },
-        [1] = {
-                /* Period IRQ */
-                .start  = IRQ_PRI,
-                .flags  = IORESOURCE_IRQ,
-        },
-        [2] = {
-                /* Carry IRQ */
-                .start  = IRQ_CUI,
-                .flags  = IORESOURCE_IRQ,
-        },
-        [3] = {
-                /* Alarm IRQ */
-                .start  = IRQ_ATI,
-                .flags  = IORESOURCE_IRQ,
-        },
-};
-
-static struct platform_device rtc_device = {
-        .name           = "sh-rtc",
-        .id             = -1,
-        .num_resources  = ARRAY_SIZE(rtc_resources),
-        .resource       = rtc_resources,
-};
-
-static int __init rtc_init(void)
-{
-        rtc_resources[0].start  = rtc_base;
-        rtc_resources[0].end    = rtc_resources[0].start + 0x58 - 1;
-
-        return platform_device_register(&rtc_device);
-}
-device_initcall(rtc_init);
diff --git a/arch/sh/kernel/timers/Makefile b/arch/sh/kernel/timers/Makefile
deleted file mode 100644
index 0b7f8577193f..000000000000
--- a/arch/sh/kernel/timers/Makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-#
-# Makefile for the various Linux/SuperH timers
-#
-
-obj-y   := timer.o
-
-obj-$(CONFIG_SH_TMU)            += timer-tmu.o
-obj-$(CONFIG_SH_MTU2)           += timer-mtu2.o
-obj-$(CONFIG_SH_CMT)            += timer-cmt.o
-
-obj-$(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST)     += timer-broadcast.o
diff --git a/arch/sh/kernel/timers/timer-cmt.c b/arch/sh/kernel/timers/timer-cmt.c
deleted file mode 100644
index 9aa348658ae3..000000000000
--- a/arch/sh/kernel/timers/timer-cmt.c
+++ /dev/null
@@ -1,188 +0,0 @@
-/*
- * arch/sh/kernel/timers/timer-cmt.c - CMT Timer Support
- *
- *  Copyright (C) 2005  Yoshinori Sato
- *
- * 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.
- */
-
-#include <linux/init.h>
-#include <linux/kernel.h>
-#include <linux/interrupt.h>
-#include <linux/seqlock.h>
-#include <asm/timer.h>
-#include <asm/rtc.h>
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/clock.h>
-
-#if defined(CONFIG_CPU_SUBTYPE_SH7619)
-#define CMT_CMSTR       0xf84a0070
-#define CMT_CMCSR_0     0xf84a0072
-#define CMT_CMCNT_0     0xf84a0074
-#define CMT_CMCOR_0     0xf84a0076
-#define CMT_CMCSR_1     0xf84a0078
-#define CMT_CMCNT_1     0xf84a007a
-#define CMT_CMCOR_1     0xf84a007c
-
-#define STBCR3          0xf80a0000
-#define cmt_clock_enable() do { ctrl_outb(ctrl_inb(STBCR3) & ~0x10, STBCR3); } while(0)
-#define CMT_CMCSR_INIT  0x0040
-#define CMT_CMCSR_CALIB 0x0000
-#elif defined(CONFIG_CPU_SUBTYPE_SH7203) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7206) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7263)
-#define CMT_CMSTR       0xfffec000
-#define CMT_CMCSR_0     0xfffec002
-#define CMT_CMCNT_0     0xfffec004
-#define CMT_CMCOR_0     0xfffec006
-
-#define STBCR4          0xfffe040c
-#define cmt_clock_enable() do { ctrl_outb(ctrl_inb(STBCR4) & ~0x04, STBCR4); } while(0)
-#define CMT_CMCSR_INIT  0x0040
-#define CMT_CMCSR_CALIB 0x0000
-#else
-#error "Unknown CPU SUBTYPE"
-#endif
-
-static unsigned long cmt_timer_get_offset(void)
-{
-        int count;
-        static unsigned short count_p = 0xffff;    /* for the first call after boot */
-        static unsigned long jiffies_p = 0;
-
-        /*
-         * cache volatile jiffies temporarily; we have IRQs turned off.
-         */
-        unsigned long jiffies_t;
-
-        /* timer count may underflow right here */
-        count =  ctrl_inw(CMT_CMCOR_0);
-        count -= ctrl_inw(CMT_CMCNT_0);
-
-        jiffies_t = jiffies;
-
-        /*
-         * avoiding timer inconsistencies (they are rare, but they happen)...
-         * there is one kind of problem that must be avoided here:
-         *  1. the timer counter underflows
-         */
-
-        if (jiffies_t == jiffies_p) {
-                if (count > count_p) {
-                        /* the nutcase */
-                        if (ctrl_inw(CMT_CMCSR_0) & 0x80) { /* Check CMF bit */
-                                count -= LATCH;
-                        } else {
-                                printk("%s (): hardware timer problem?\n",
-                                       __func__);
-                        }
-                }
-        } else
-                jiffies_p = jiffies_t;
-
-        count_p = count;
-
-        count = ((LATCH-1) - count) * TICK_SIZE;
-        count = (count + LATCH/2) / LATCH;
-
-        return count;
-}
-
-static irqreturn_t cmt_timer_interrupt(int irq, void *dev_id)
-{
-        unsigned long timer_status;
-
-        /* Clear CMF bit */
-        timer_status = ctrl_inw(CMT_CMCSR_0);
-        timer_status &= ~0x80;
-        ctrl_outw(timer_status, CMT_CMCSR_0);
-
-        handle_timer_tick();
-
-        return IRQ_HANDLED;
-}
-
-static struct irqaction cmt_irq = {
-        .name           = "timer",
-        .handler        = cmt_timer_interrupt,
-        .flags          = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL,
-};
-
-static void cmt_clk_init(struct clk *clk)
-{
-        u8 divisor = CMT_CMCSR_INIT & 0x3;
-        ctrl_inw(CMT_CMCSR_0);
-        ctrl_outw(CMT_CMCSR_INIT, CMT_CMCSR_0);
-        clk->parent = clk_get(NULL, "module_clk");
-        clk->rate = clk->parent->rate / (8 << (divisor << 1));
-}
-
-static void cmt_clk_recalc(struct clk *clk)
-{
-        u8 divisor = ctrl_inw(CMT_CMCSR_0) & 0x3;
-        clk->rate = clk->parent->rate / (8 << (divisor << 1));
-}
-
-static struct clk_ops cmt_clk_ops = {
-        .init           = cmt_clk_init,
-        .recalc         = cmt_clk_recalc,
-};
-
-static struct clk cmt0_clk = {
-        .name           = "cmt0_clk",
-        .ops            = &cmt_clk_ops,
-};
-
-static int cmt_timer_start(void)
-{
-        ctrl_outw(ctrl_inw(CMT_CMSTR) | 0x01, CMT_CMSTR);
-        return 0;
-}
-
-static int cmt_timer_stop(void)
-{
-        ctrl_outw(ctrl_inw(CMT_CMSTR) & ~0x01, CMT_CMSTR);
-        return 0;
-}
-
-static int cmt_timer_init(void)
-{
-        unsigned long interval;
-
-        cmt_clock_enable();
-
-        setup_irq(CONFIG_SH_TIMER_IRQ, &cmt_irq);
-
-        cmt0_clk.parent = clk_get(NULL, "module_clk");
-
-        cmt_timer_stop();
-
-        interval = cmt0_clk.parent->rate / 8 / HZ;
-        printk(KERN_INFO "Interval = %ld\n", interval);
-
-        ctrl_outw(interval, CMT_CMCOR_0);
-
-        clk_register(&cmt0_clk);
-        clk_enable(&cmt0_clk);
-
-        cmt_timer_start();
-
-        return 0;
-}
-
-static struct sys_timer_ops cmt_timer_ops = {
-        .init           = cmt_timer_init,
-        .start          = cmt_timer_start,
-        .stop           = cmt_timer_stop,
-#ifndef CONFIG_GENERIC_TIME
-        .get_offset     = cmt_timer_get_offset,
-#endif
-};
-
-struct sys_timer cmt_timer = {
-        .name   = "cmt",
-        .ops    = &cmt_timer_ops,
-};
diff --git a/arch/sh/kernel/timers/timer-mtu2.c b/arch/sh/kernel/timers/timer-mtu2.c
deleted file mode 100644
index 9b0ef0126479..000000000000
--- a/arch/sh/kernel/timers/timer-mtu2.c
+++ /dev/null
@@ -1,202 +0,0 @@
-/*
- * arch/sh/kernel/timers/timer-mtu2.c - MTU2 Timer Support
- *
- *  Copyright (C) 2005  Paul Mundt
- *
- * Based off of arch/sh/kernel/timers/timer-tmu.c
- *
- * 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.
- */
-#include <linux/init.h>
-#include <linux/kernel.h>
-#include <linux/interrupt.h>
-#include <linux/seqlock.h>
-#include <asm/timer.h>
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/clock.h>
-
-/*
- * We use channel 1 for our lowly system timer. Channel 2 would be the other
- * likely candidate, but we leave it alone as it has higher divisors that
- * would be of more use to other more interesting applications.
- *
- * TODO: Presently we only implement a 16-bit single-channel system timer.
- * However, we can implement channel cascade if we go the overflow route and
- * get away with using 2 MTU2 channels as a 32-bit timer.
- */
-#define MTU2_TSTR       0xfffe4280
-#define MTU2_TCR_1      0xfffe4380
-#define MTU2_TMDR_1     0xfffe4381
-#define MTU2_TIOR_1     0xfffe4382
-#define MTU2_TIER_1     0xfffe4384
-#define MTU2_TSR_1      0xfffe4385
-#define MTU2_TCNT_1     0xfffe4386      /* 16-bit counter */
-
-#if defined(CONFIG_CPU_SUBTYPE_SH7201) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7203)
-#define MTU2_TGRA_1     0xfffe4388
-#else
-#define MTU2_TGRA_1     0xfffe438a
-#endif
-
-#define STBCR3          0xfffe0408
-
-#define MTU2_TSTR_CST1  (1 << 1)        /* Counter Start 1 */
-
-#define MTU2_TSR_TGFA   (1 << 0)        /* GRA compare match */
-
-#define MTU2_TIER_TGIEA (1 << 0)        /* GRA compare match  interrupt enable */
-
-#define MTU2_TCR_INIT   0x22
-
-#define MTU2_TCR_CALIB  0x00
-
-static unsigned long mtu2_timer_get_offset(void)
-{
-        int count;
-        static int count_p = 0x7fff;    /* for the first call after boot */
-        static unsigned long jiffies_p = 0;
-
-        /*
-         * cache volatile jiffies temporarily; we have IRQs turned off.
-         */
-        unsigned long jiffies_t;
-
-        /* timer count may underflow right here */
-        count = ctrl_inw(MTU2_TCNT_1);  /* read the latched count */
-
-        jiffies_t = jiffies;
-
-        /*
-         * avoiding timer inconsistencies (they are rare, but they happen)...
-         * there is one kind of problem that must be avoided here:
-         *  1. the timer counter underflows
-         */
-
-        if (jiffies_t == jiffies_p) {
-                if (count > count_p) {
-                        if (ctrl_inb(MTU2_TSR_1) & MTU2_TSR_TGFA) {
-                                count -= LATCH;
-                        } else {
-                                printk("%s (): hardware timer problem?\n",
-                                       __func__);
-                        }
-                }
-        } else
-                jiffies_p = jiffies_t;
-
-        count_p = count;
-
-        count = ((LATCH-1) - count) * TICK_SIZE;
-        count = (count + LATCH/2) / LATCH;
-
-        return count;
-}
-
-static irqreturn_t mtu2_timer_interrupt(int irq, void *dev_id)
-{
-        unsigned long timer_status;
-
-        /* Clear TGFA bit */
-        timer_status = ctrl_inb(MTU2_TSR_1);
-        timer_status &= ~MTU2_TSR_TGFA;
-        ctrl_outb(timer_status, MTU2_TSR_1);
-
-        /* Do timer tick */
-        handle_timer_tick();
-
-        return IRQ_HANDLED;
-}
-
-static struct irqaction mtu2_irq = {
-        .name           = "timer",
-        .handler        = mtu2_timer_interrupt,
-        .flags          = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL,
-};
-
-static unsigned int divisors[] = { 1, 4, 16, 64, 1, 1, 256 };
-
-static void mtu2_clk_init(struct clk *clk)
-{
-        u8 idx = MTU2_TCR_INIT & 0x7;
-
-        clk->rate = clk->parent->rate / divisors[idx];
-        /* Start TCNT counting */
-        ctrl_outb(ctrl_inb(MTU2_TSTR) | MTU2_TSTR_CST1, MTU2_TSTR);
-
-}
-
-static void mtu2_clk_recalc(struct clk *clk)
-{
-        u8 idx = ctrl_inb(MTU2_TCR_1) & 0x7;
-        clk->rate = clk->parent->rate / divisors[idx];
-}
-
-static struct clk_ops mtu2_clk_ops = {
-        .init           = mtu2_clk_init,
-        .recalc         = mtu2_clk_recalc,
-};
-
-static struct clk mtu2_clk1 = {
-        .name           = "mtu2_clk1",
-        .ops            = &mtu2_clk_ops,
-};
-
-static int mtu2_timer_start(void)
-{
-        ctrl_outb(ctrl_inb(MTU2_TSTR) | MTU2_TSTR_CST1, MTU2_TSTR);
-        return 0;
-}
-
-static int mtu2_timer_stop(void)
-{
-        ctrl_outb(ctrl_inb(MTU2_TSTR) & ~MTU2_TSTR_CST1, MTU2_TSTR);
-        return 0;
-}
-
-static int mtu2_timer_init(void)
-{
-        unsigned long interval;
-
-        setup_irq(CONFIG_SH_TIMER_IRQ, &mtu2_irq);
-
-        mtu2_clk1.parent = clk_get(NULL, "module_clk");
-
-        ctrl_outb(ctrl_inb(STBCR3) & (~0x20), STBCR3);
-
-        /* Normal operation */
-        ctrl_outb(0, MTU2_TMDR_1);
-        ctrl_outb(MTU2_TCR_INIT, MTU2_TCR_1);
-        ctrl_outb(0x01, MTU2_TIOR_1);
-
-        /* Enable underflow interrupt */
-        ctrl_outb(ctrl_inb(MTU2_TIER_1) | MTU2_TIER_TGIEA, MTU2_TIER_1);
-
-        interval = CONFIG_SH_PCLK_FREQ / 16 / HZ;
-        printk(KERN_INFO "Interval = %ld\n", interval);
-
-        ctrl_outw(interval, MTU2_TGRA_1);
-        ctrl_outw(0, MTU2_TCNT_1);
-
-        clk_register(&mtu2_clk1);
-        clk_enable(&mtu2_clk1);
-
-        return 0;
-}
-
-struct sys_timer_ops mtu2_timer_ops = {
-        .init           = mtu2_timer_init,
-        .start          = mtu2_timer_start,
-        .stop           = mtu2_timer_stop,
-#ifndef CONFIG_GENERIC_TIME
-        .get_offset     = mtu2_timer_get_offset,
-#endif
-};
-
-struct sys_timer mtu2_timer = {
-        .name   = "mtu2",
-        .ops    = &mtu2_timer_ops,
-};
diff --git a/arch/sh/kernel/timers/timer-tmu.c b/arch/sh/kernel/timers/timer-tmu.c
deleted file mode 100644
index fe8d8930ccb6..000000000000
--- a/arch/sh/kernel/timers/timer-tmu.c
+++ /dev/null
@@ -1,297 +0,0 @@
-/*
- * arch/sh/kernel/timers/timer-tmu.c - TMU Timer Support
- *
- *  Copyright (C) 2005 - 2007  Paul Mundt
- *
- * TMU handling code hacked out of arch/sh/kernel/time.c
- *
- *  Copyright (C) 1999  Tetsuya Okada & Niibe Yutaka
- *  Copyright (C) 2000  Philipp Rumpf <prumpf@tux.org>
- *  Copyright (C) 2002, 2003, 2004  Paul Mundt
- *  Copyright (C) 2002  M. R. Brown  <mrbrown@linux-sh.org>
- *
- * 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.
- */
-#include <linux/init.h>
-#include <linux/kernel.h>
-#include <linux/interrupt.h>
-#include <linux/seqlock.h>
-#include <linux/clockchips.h>
-#include <asm/timer.h>
-#include <asm/rtc.h>
-#include <asm/io.h>
-#include <asm/irq.h>
-#include <asm/clock.h>
-
-#define TMU_TOCR_INIT   0x00
-#define TMU_TCR_INIT    0x0020
-
-#define TMU0            (0)
-#define TMU1            (1)
-
-static inline void _tmu_start(int tmu_num)
-{
-        ctrl_outb(ctrl_inb(TMU_012_TSTR) | (0x1<<tmu_num), TMU_012_TSTR);
-}
-
-static inline void _tmu_set_irq(int tmu_num, int enabled)
-{
-        register unsigned long tmu_tcr = TMU0_TCR + (0xc*tmu_num);
-        ctrl_outw( (enabled ? ctrl_inw(tmu_tcr) | (1<<5) : ctrl_inw(tmu_tcr) & ~(1<<5)), tmu_tcr);
-}
-
-static inline void _tmu_stop(int tmu_num)
-{
-        ctrl_outb(ctrl_inb(TMU_012_TSTR) & ~(0x1<<tmu_num), TMU_012_TSTR);
-}
-
-static inline void _tmu_clear_status(int tmu_num)
-{
-        register unsigned long tmu_tcr = TMU0_TCR + (0xc*tmu_num);
-        /* Clear UNF bit */
-        ctrl_outw(ctrl_inw(tmu_tcr) & ~0x100, tmu_tcr);
-}
-
-static inline unsigned long _tmu_read(int tmu_num)
-{
-        return ctrl_inl(TMU0_TCNT+0xC*tmu_num);
-}
-
-static int tmu_timer_start(void)
-{
-        _tmu_start(TMU0);
-        _tmu_start(TMU1);
-        _tmu_set_irq(TMU0,1);
-        return 0;
-}
-
-static int tmu_timer_stop(void)
-{
-        _tmu_stop(TMU0);
-        _tmu_stop(TMU1);
-        _tmu_clear_status(TMU0);
-        return 0;
-}
-
-/*
- * also when the module_clk is scaled the TMU1
- * will show the same frequency
- */
-static int tmus_are_scaled;
-
-static cycle_t tmu_timer_read(struct clocksource *cs)
-{
-        return ((cycle_t)(~_tmu_read(TMU1)))<<tmus_are_scaled;
-}
-
-
-static unsigned long tmu_latest_interval[3];
-static void tmu_timer_set_interval(int tmu_num, unsigned long interval, unsigned int reload)
-{
-        unsigned long tmu_tcnt = TMU0_TCNT + tmu_num*0xC;
-        unsigned long tmu_tcor = TMU0_TCOR + tmu_num*0xC;
-
-        _tmu_stop(tmu_num);
-
-        ctrl_outl(interval, tmu_tcnt);
-        tmu_latest_interval[tmu_num] = interval;
-
-        /*
-         * TCNT reloads from TCOR on underflow, clear it if we don't
-         * intend to auto-reload
-         */
-        ctrl_outl( reload ? interval : 0 , tmu_tcor);
-
-        _tmu_start(tmu_num);
-}
-
-static int tmu_set_next_event(unsigned long cycles,
-                              struct clock_event_device *evt)
-{
-        tmu_timer_set_interval(TMU0,cycles, evt->mode == CLOCK_EVT_MODE_PERIODIC);
-        _tmu_set_irq(TMU0,1);
-        return 0;
-}
-
-static void tmu_set_mode(enum clock_event_mode mode,
-                         struct clock_event_device *evt)
-{
-        switch (mode) {
-        case CLOCK_EVT_MODE_PERIODIC:
-                ctrl_outl(tmu_latest_interval[TMU0], TMU0_TCOR);
-                break;
-        case CLOCK_EVT_MODE_ONESHOT:
-                ctrl_outl(0, TMU0_TCOR);
-                break;
-        case CLOCK_EVT_MODE_UNUSED:
-        case CLOCK_EVT_MODE_SHUTDOWN:
-        case CLOCK_EVT_MODE_RESUME:
-                break;
-        }
-}
-
-static struct clock_event_device tmu0_clockevent = {
-        .name           = "tmu0",
-        .shift          = 32,
-        .features       = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT,
-        .set_mode       = tmu_set_mode,
-        .set_next_event = tmu_set_next_event,
-};
-
-static irqreturn_t tmu_timer_interrupt(int irq, void *dummy)
-{
-        struct clock_event_device *evt = &tmu0_clockevent;
-        _tmu_clear_status(TMU0);
-        _tmu_set_irq(TMU0,tmu0_clockevent.mode != CLOCK_EVT_MODE_ONESHOT);
-
-        switch (tmu0_clockevent.mode) {
-        case CLOCK_EVT_MODE_ONESHOT:
-        case CLOCK_EVT_MODE_PERIODIC:
-                evt->event_handler(evt);
-                break;
-        default:
-                break;
-        }
-
-        return IRQ_HANDLED;
-}
-
-static struct irqaction tmu0_irq = {
-        .name           = "periodic/oneshot timer",
-        .handler        = tmu_timer_interrupt,
-        .flags          = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL,
-};
-
-static void __init tmu_clk_init(struct clk *clk)
-{
-        u8 divisor  = TMU_TCR_INIT & 0x7;
-        int tmu_num = clk->name[3]-'0';
-        ctrl_outw(TMU_TCR_INIT, TMU0_TCR+(tmu_num*0xC));
-        clk->rate = clk_get_rate(clk->parent) / (4 << (divisor << 1));
-}
-
-static void tmu_clk_recalc(struct clk *clk)
-{
-        int tmu_num = clk->name[3]-'0';
-        unsigned long prev_rate = clk_get_rate(clk);
-        unsigned long flags;
-        u8 divisor = ctrl_inw(TMU0_TCR+tmu_num*0xC) & 0x7;
-        clk->rate  = clk_get_rate(clk->parent) / (4 << (divisor << 1));
-
-        if(prev_rate==clk_get_rate(clk))
-                return;
-
-        if(tmu_num)
-                return; /* No more work on TMU1 */
-
-        local_irq_save(flags);
-        tmus_are_scaled = (prev_rate > clk->rate);
-
-        _tmu_stop(TMU0);
-
-        tmu0_clockevent.mult = div_sc(clk->rate, NSEC_PER_SEC,
-                                tmu0_clockevent.shift);
-        tmu0_clockevent.max_delta_ns =
-                        clockevent_delta2ns(-1, &tmu0_clockevent);
-        tmu0_clockevent.min_delta_ns =
-                        clockevent_delta2ns(1, &tmu0_clockevent);
-
-        if (tmus_are_scaled)
-                tmu_latest_interval[TMU0] >>= 1;
-        else
-                tmu_latest_interval[TMU0] <<= 1;
-
-        tmu_timer_set_interval(TMU0,
-                tmu_latest_interval[TMU0],
-                tmu0_clockevent.mode == CLOCK_EVT_MODE_PERIODIC);
-
-        _tmu_start(TMU0);
-
-        local_irq_restore(flags);
-}
-
-static struct clk_ops tmu_clk_ops = {
-        .init           = tmu_clk_init,
-        .recalc         = tmu_clk_recalc,
-};
-
-static struct clk tmu0_clk = {
-        .name           = "tmu0_clk",
-        .ops            = &tmu_clk_ops,
-};
-
-static struct clk tmu1_clk = {
-        .name           = "tmu1_clk",
-        .ops            = &tmu_clk_ops,
-};
-
-static int tmu_timer_init(void)
-{
-        unsigned long interval;
-        unsigned long frequency;
-
-        setup_irq(CONFIG_SH_TIMER_IRQ, &tmu0_irq);
-
-        tmu0_clk.parent = clk_get(NULL, "module_clk");
-        tmu1_clk.parent = clk_get(NULL, "module_clk");
-
-        tmu_timer_stop();
-
-#if !defined(CONFIG_CPU_SUBTYPE_SH7720) && \
-    !defined(CONFIG_CPU_SUBTYPE_SH7721) && \
-    !defined(CONFIG_CPU_SUBTYPE_SH7760) && \
-    !defined(CONFIG_CPU_SUBTYPE_SH7785) && \
-    !defined(CONFIG_CPU_SUBTYPE_SH7786) && \
-    !defined(CONFIG_CPU_SUBTYPE_SHX3)
-        ctrl_outb(TMU_TOCR_INIT, TMU_TOCR);
-#endif
-
-        clk_register(&tmu0_clk);
-        clk_register(&tmu1_clk);
-        clk_enable(&tmu0_clk);
-        clk_enable(&tmu1_clk);
-
-        frequency = clk_get_rate(&tmu0_clk);
-        interval = (frequency + HZ / 2) / HZ;
-
-        tmu_timer_set_interval(TMU0,interval, 1);
-        tmu_timer_set_interval(TMU1,~0,1);
-
-        _tmu_start(TMU1);
-
-        clocksource_sh.rating = 200;
-        clocksource_sh.mask = CLOCKSOURCE_MASK(32);
-        clocksource_sh.read = tmu_timer_read;
-        clocksource_sh.shift = 10;
-        clocksource_sh.mult = clocksource_hz2mult(clk_get_rate(&tmu1_clk),
-                                                  clocksource_sh.shift);
-        clocksource_sh.flags = CLOCK_SOURCE_IS_CONTINUOUS;
-        clocksource_register(&clocksource_sh);
-
-        tmu0_clockevent.mult = div_sc(frequency, NSEC_PER_SEC,
-                                      tmu0_clockevent.shift);
-        tmu0_clockevent.max_delta_ns =
-                        clockevent_delta2ns(-1, &tmu0_clockevent);
-        tmu0_clockevent.min_delta_ns =
-                        clockevent_delta2ns(1, &tmu0_clockevent);
-
-        tmu0_clockevent.cpumask = cpumask_of(0);
-        tmu0_clockevent.rating = 100;
-
-        clockevents_register_device(&tmu0_clockevent);
-
-        return 0;
-}
-
-static struct sys_timer_ops tmu_timer_ops = {
-        .init           = tmu_timer_init,
-        .start          = tmu_timer_start,
-        .stop           = tmu_timer_stop,
-};
-
-struct sys_timer tmu_timer = {
-        .name   = "tmu",
-        .ops    = &tmu_timer_ops,
-};
diff --git a/arch/sh/kernel/timers/timer.c b/arch/sh/kernel/timers/timer.c
deleted file mode 100644
index 4e7e747d1b69..000000000000
--- a/arch/sh/kernel/timers/timer.c
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * arch/sh/kernel/timers/timer.c - Common timer code
- *
- *  Copyright (C) 2005  Paul Mundt
- *
- * 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.
- */
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/timer.h>
-#include <linux/string.h>
-#include <asm/timer.h>
-
-static struct sys_timer *sys_timers[] = {
-#ifdef CONFIG_SH_TMU
-        &tmu_timer,
-#endif
-#ifdef CONFIG_SH_MTU2
-        &mtu2_timer,
-#endif
-#ifdef CONFIG_SH_CMT
-        &cmt_timer,
-#endif
-        NULL,
-};
-
-static char timer_override[10];
-static int __init timer_setup(char *str)
-{
-        if (str)
-                strlcpy(timer_override, str, sizeof(timer_override));
-        return 1;
-}
-__setup("timer=", timer_setup);
-
-struct sys_timer *get_sys_timer(void)
-{
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(sys_timers); i++) {
-                struct sys_timer *t = sys_timers[i];
-
-                if (unlikely(!t))
-                        break;
-                if (unlikely(timer_override[0]))
-                        if ((strcmp(timer_override, t->name) != 0))
-                                continue;
-                if (likely(t->ops->init() == 0))
-                        return t;
-        }
-
-        return NULL;
-}
diff --git a/arch/sh/kernel/traps.c b/arch/sh/kernel/traps.c
index 438f1ebcc453..46348ed07cc3 100644
--- a/arch/sh/kernel/traps.c
+++ b/arch/sh/kernel/traps.c
@@ -22,11 +22,11 @@ static void handle_BUG(struct pt_regs *regs)
 
 int is_valid_bugaddr(unsigned long addr)
 {
-        unsigned short opcode;
+        insn_size_t opcode;
 
         if (addr < PAGE_OFFSET)
                 return 0;
-        if (probe_kernel_address((u16 *)addr, opcode))
+        if (probe_kernel_address((insn_size_t *)addr, opcode))
                 return 0;
 
         return opcode == TRAPA_BUG_OPCODE;
@@ -66,7 +66,7 @@ BUILD_TRAP_HANDLER(bug)
 
 #ifdef CONFIG_BUG
         if (__kernel_text_address(instruction_pointer(regs))) {
-                opcode_t insn = *(opcode_t *)instruction_pointer(regs);
+                insn_size_t insn = *(insn_size_t *)instruction_pointer(regs);
                 if (insn == TRAPA_BUG_OPCODE)
                         handle_BUG(regs);
         }
diff --git a/arch/sh/kernel/traps_32.c b/arch/sh/kernel/traps_32.c
index 30ca9c51e52d..2b772776fcda 100644
--- a/arch/sh/kernel/traps_32.c
+++ b/arch/sh/kernel/traps_32.c
@@ -34,6 +34,7 @@
 # define TRAP_ILLEGAL_SLOT_INST 6
 # define TRAP_ADDRESS_ERROR     9
 # ifdef CONFIG_CPU_SH2A
+#  define TRAP_UBC              12
 #  define TRAP_FPU_ERROR        13
 #  define TRAP_DIVZERO_ERROR    17
 #  define TRAP_DIVOVF_ERROR     18
@@ -176,7 +177,7 @@ static struct mem_access user_mem_access = {
  *   (if that instruction is in a branch delay slot)
  * - return 0 if emulation okay, -EFAULT on existential error
  */
-static int handle_unaligned_ins(opcode_t instruction, struct pt_regs *regs,
+static int handle_unaligned_ins(insn_size_t instruction, struct pt_regs *regs,
                                 struct mem_access *ma)
 {
         int ret, index, count;
@@ -321,10 +322,10 @@ static int handle_unaligned_ins(opcode_t instruction, struct pt_regs *regs,
  * - fetches the instruction from PC+2
  */
 static inline int handle_delayslot(struct pt_regs *regs,
-                                   opcode_t old_instruction,
+                                   insn_size_t old_instruction,
                                    struct mem_access *ma)
 {
-        opcode_t instruction;
+        insn_size_t instruction;
         void __user *addr = (void __user *)(regs->pc +
                 instruction_size(old_instruction));
 
@@ -364,7 +365,7 @@ static inline int handle_delayslot(struct pt_regs *regs,
 
 static int handle_unaligned_notify_count = 10;
 
-int handle_unaligned_access(opcode_t instruction, struct pt_regs *regs,
+int handle_unaligned_access(insn_size_t instruction, struct pt_regs *regs,
                             struct mem_access *ma)
 {
         u_int rm;
@@ -522,7 +523,7 @@ asmlinkage void do_address_error(struct pt_regs *regs,
         unsigned long error_code = 0;
         mm_segment_t oldfs;
         siginfo_t info;
-        opcode_t instruction;
+        insn_size_t instruction;
         int tmp;
 
         /* Intentional ifdef */
@@ -849,6 +850,10 @@ void __init trap_init(void)
 #endif
 #endif
 
+#ifdef TRAP_UBC
+        set_exception_table_vec(TRAP_UBC, break_point_trap);
+#endif
+
         /* Setup VBR for boot cpu */
         per_cpu_trap_init();
 }
diff --git a/arch/sh/kernel/traps_64.c b/arch/sh/kernel/traps_64.c
index a85831cbf18b..267e5ebbb475 100644
--- a/arch/sh/kernel/traps_64.c
+++ b/arch/sh/kernel/traps_64.c
@@ -370,7 +370,6 @@ static int generate_and_check_address(struct pt_regs *regs,
                 return -1;
         }
 
-#if defined(CONFIG_SH64_USER_MISALIGNED_FIXUP)
         /* Check accessible.  For misaligned access in the kernel, assume the
            address is always accessible (and if not, just fault when the
            load/store gets done.) */
@@ -380,18 +379,13 @@ static int generate_and_check_address(struct pt_regs *regs,
                 }
                 /* Do access_ok check later - it depends on whether it's a load or a store. */
         }
-#endif
 
         *address = addr;
         return 0;
 }
 
-/* Default value as for sh */
-#if defined(CONFIG_SH64_USER_MISALIGNED_FIXUP)
 static int user_mode_unaligned_fixup_count = 10;
 static int user_mode_unaligned_fixup_enable = 1;
-#endif
-
 static int kernel_mode_unaligned_fixup_count = 32;
 
 static void misaligned_kernel_word_load(__u64 address, int do_sign_extend, __u64 *result)
@@ -440,7 +434,6 @@ static int misaligned_load(struct pt_regs *regs,
         }
 
         destreg = (opcode >> 4) & 0x3f;
-#if defined(CONFIG_SH64_USER_MISALIGNED_FIXUP)
         if (user_mode(regs)) {
                 __u64 buffer;
 
@@ -470,9 +463,7 @@ static int misaligned_load(struct pt_regs *regs,
                                 width_shift, (unsigned long) regs->pc);
                         break;
                 }
-        } else
-#endif
-        {
+        } else {
                 /* kernel mode - we can take short cuts since if we fault, it's a genuine bug */
                 __u64 lo, hi;
 
@@ -519,7 +510,6 @@ static int misaligned_store(struct pt_regs *regs,
         }
 
         srcreg = (opcode >> 4) & 0x3f;
-#if defined(CONFIG_SH64_USER_MISALIGNED_FIXUP)
         if (user_mode(regs)) {
                 __u64 buffer;
 
@@ -546,9 +536,7 @@ static int misaligned_store(struct pt_regs *regs,
                 if (__copy_user((void *)(int)address, &buffer, (1 << width_shift)) > 0) {
                         return -1; /* fault */
                 }
-        } else
-#endif
-        {
+        } else {
                 /* kernel mode - we can take short cuts since if we fault, it's a genuine bug */
                 __u64 val = regs->regs[srcreg];
 
@@ -576,7 +564,6 @@ static int misaligned_store(struct pt_regs *regs,
 
 }
 
-#if defined(CONFIG_SH64_USER_MISALIGNED_FIXUP)
 /* Never need to fix up misaligned FPU accesses within the kernel since that's a real
    error. */
 static int misaligned_fpu_load(struct pt_regs *regs,
@@ -727,7 +714,6 @@ static int misaligned_fpu_store(struct pt_regs *regs,
                 return -1;
         }
 }
-#endif
 
 static int misaligned_fixup(struct pt_regs *regs)
 {
@@ -735,12 +721,8 @@ static int misaligned_fixup(struct pt_regs *regs)
         int error;
         int major, minor;
 
-#if !defined(CONFIG_SH64_USER_MISALIGNED_FIXUP)
-        /* Never fixup user mode misaligned accesses without this option enabled. */
-        return -1;
-#else
-        if (!user_mode_unaligned_fixup_enable) return -1;
-#endif
+        if (!user_mode_unaligned_fixup_enable)
+                return -1;
 
         error = read_opcode(regs->pc, &opcode, user_mode(regs));
         if (error < 0) {
@@ -749,15 +731,12 @@ static int misaligned_fixup(struct pt_regs *regs)
         major = (opcode >> 26) & 0x3f;
         minor = (opcode >> 16) & 0xf;
 
-#if defined(CONFIG_SH64_USER_MISALIGNED_FIXUP)
         if (user_mode(regs) && (user_mode_unaligned_fixup_count > 0)) {
                 --user_mode_unaligned_fixup_count;
                 /* Only do 'count' worth of these reports, to remove a potential DoS against syslog */
                 printk("Fixing up unaligned userspace access in \"%s\" pid=%d pc=0x%08x ins=0x%08lx\n",
                        current->comm, task_pid_nr(current), (__u32)regs->pc, opcode);
-        } else
-#endif
-        if (!user_mode(regs) && (kernel_mode_unaligned_fixup_count > 0)) {
+        } else if (!user_mode(regs) && (kernel_mode_unaligned_fixup_count > 0)) {
                 --kernel_mode_unaligned_fixup_count;
                 if (in_interrupt()) {
                         printk("Fixing up unaligned kernelspace access in interrupt pc=0x%08x ins=0x%08lx\n",
@@ -830,7 +809,6 @@ static int misaligned_fixup(struct pt_regs *regs)
                         }
                         break;
 
-#if defined(CONFIG_SH64_USER_MISALIGNED_FIXUP)
                 case (0x94>>2): /* FLD.S */
                         error = misaligned_fpu_load(regs, opcode, 1, 2, 0);
                         break;
@@ -881,7 +859,6 @@ static int misaligned_fixup(struct pt_regs *regs)
                                 break;
                         }
                         break;
-#endif
 
                 default:
                         /* Fault */
@@ -907,7 +884,6 @@ static ctl_table unaligned_table[] = {
                 .mode           = 0644,
                 .proc_handler   = &proc_dointvec
         },
-#if defined(CONFIG_SH64_USER_MISALIGNED_FIXUP)
         {
                 .ctl_name       = CTL_UNNUMBERED,
                 .procname       = "user_reports",
@@ -923,7 +899,6 @@ static ctl_table unaligned_table[] = {
                 .maxlen         = sizeof(int),
                 .mode           = 0644,
                 .proc_handler   = &proc_dointvec},
-#endif
         {}
 };
 
diff --git a/arch/sh/kernel/vmlinux.lds.S b/arch/sh/kernel/vmlinux.lds.S
index d7d4991f32af..f53c76acaede 100644
--- a/arch/sh/kernel/vmlinux.lds.S
+++ b/arch/sh/kernel/vmlinux.lds.S
@@ -1,5 +1,178 @@
-#ifdef CONFIG_SUPERH32
-# include "vmlinux_32.lds.S"
+/*
+ * ld script to make SuperH Linux kernel
+ * Written by Niibe Yutaka and Paul Mundt
+ */
+#ifdef CONFIG_SUPERH64
+#define LOAD_OFFSET     CONFIG_PAGE_OFFSET
+OUTPUT_ARCH(sh:sh5)
 #else
-# include "vmlinux_64.lds.S"
+#define LOAD_OFFSET     0
+OUTPUT_ARCH(sh)
 #endif
+
+#include <asm/thread_info.h>
+#include <asm/cache.h>
+#include <asm-generic/vmlinux.lds.h>
+
+ENTRY(_start)
+SECTIONS
+{
+#ifdef CONFIG_PMB_FIXED
+        . = CONFIG_PAGE_OFFSET + (CONFIG_MEMORY_START & 0x1fffffff) +
+            CONFIG_ZERO_PAGE_OFFSET;
+#elif defined(CONFIG_32BIT)
+        . = CONFIG_PAGE_OFFSET + CONFIG_ZERO_PAGE_OFFSET;
+#else
+        . = CONFIG_PAGE_OFFSET + CONFIG_MEMORY_START + CONFIG_ZERO_PAGE_OFFSET;
+#endif
+
+        _text = .;              /* Text and read-only data */
+
+        .empty_zero_page : AT(ADDR(.empty_zero_page) - LOAD_OFFSET) {
+                *(.empty_zero_page)
+        } = 0
+
+        .text : AT(ADDR(.text) - LOAD_OFFSET) {
+                HEAD_TEXT
+                TEXT_TEXT
+
+#ifdef CONFIG_SUPERH64
+                *(.text64)
+                *(.text..SHmedia32)
+#endif
+
+                SCHED_TEXT
+                LOCK_TEXT
+                KPROBES_TEXT
+                IRQENTRY_TEXT
+                *(.fixup)
+                *(.gnu.warning)
+                _etext = .;             /* End of text section */
+        } = 0x0009
+
+        . = ALIGN(16);          /* Exception table */
+        __ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) {
+                __start___ex_table = .;
+                *(__ex_table)
+                __stop___ex_table = .;
+        }
+
+        NOTES
+        RO_DATA(PAGE_SIZE)
+
+        /*
+         * Code which must be executed uncached and the associated data
+         */
+        . = ALIGN(PAGE_SIZE);
+        .uncached : AT(ADDR(.uncached) - LOAD_OFFSET) {
+                __uncached_start = .;
+                *(.uncached.text)
+                *(.uncached.data)
+                __uncached_end = .;
+        }
+
+        . = ALIGN(THREAD_SIZE);
+        .data : AT(ADDR(.data) - LOAD_OFFSET) {         /* Data */
+                *(.data.init_task)
+
+                . = ALIGN(L1_CACHE_BYTES);
+                *(.data.cacheline_aligned)
+
+                . = ALIGN(L1_CACHE_BYTES);
+                *(.data.read_mostly)
+
+                . = ALIGN(PAGE_SIZE);
+                *(.data.page_aligned)
+
+                __nosave_begin = .;
+                *(.data.nosave)
+                . = ALIGN(PAGE_SIZE);
+                __nosave_end = .;
+
+                DATA_DATA
+                CONSTRUCTORS
+        }
+
+        _edata = .;                     /* End of data section */
+
+        . = ALIGN(PAGE_SIZE);           /* Init code and data */
+        .init.text : AT(ADDR(.init.text) - LOAD_OFFSET) {
+                __init_begin = .;
+                _sinittext = .;
+                INIT_TEXT
+                _einittext = .;
+        }
+
+        .init.data : AT(ADDR(.init.data) - LOAD_OFFSET) { INIT_DATA }
+
+        . = ALIGN(16);
+        .init.setup : AT(ADDR(.init.setup) - LOAD_OFFSET) {
+                __setup_start = .;
+                *(.init.setup)
+                __setup_end = .;
+        }
+
+        .initcall.init : AT(ADDR(.initcall.init) - LOAD_OFFSET) {
+                __initcall_start = .;
+                INITCALLS
+                __initcall_end = .;
+        }
+
+        .con_initcall.init : AT(ADDR(.con_initcall.init) - LOAD_OFFSET) {
+                __con_initcall_start = .;
+                *(.con_initcall.init)
+                __con_initcall_end = .;
+        }
+
+        SECURITY_INIT
+
+#ifdef CONFIG_BLK_DEV_INITRD
+        . = ALIGN(PAGE_SIZE);
+        .init.ramfs : AT(ADDR(.init.ramfs) - LOAD_OFFSET) {
+                __initramfs_start = .;
+                *(.init.ramfs)
+                __initramfs_end = .;
+        }
+#endif
+
+        . = ALIGN(4);
+        .machvec.init : AT(ADDR(.machvec.init) - LOAD_OFFSET) {
+                __machvec_start = .;
+                *(.machvec.init)
+                __machvec_end = .;
+        }
+
+        PERCPU(PAGE_SIZE)
+
+        /*
+         * .exit.text is discarded at runtime, not link time, to deal with
+         * references from __bug_table
+         */
+        .exit.text : AT(ADDR(.exit.text) - LOAD_OFFSET) { EXIT_TEXT }
+        .exit.data : AT(ADDR(.exit.data) - LOAD_OFFSET) { EXIT_DATA }
+
+        . = ALIGN(PAGE_SIZE);
+        .bss : AT(ADDR(.bss) - LOAD_OFFSET) {
+                __init_end = .;
+                __bss_start = .;                /* BSS */
+                *(.bss.page_aligned)
+                *(.bss)
+                *(COMMON)
+                . = ALIGN(4);
+                _ebss = .;                      /* uClinux MTD sucks */
+                _end = . ;
+        }
+
+        /*
+         * When something in the kernel is NOT compiled as a module, the
+         * module cleanup code and data are put into these segments. Both
+         * can then be thrown away, as cleanup code is never called unless
+         * it's a module.
+         */
+        /DISCARD/ : {
+                *(.exitcall.exit)
+        }
+
+        STABS_DEBUG
+        DWARF_DEBUG
+}
diff --git a/arch/sh/kernel/vmlinux_32.lds.S b/arch/sh/kernel/vmlinux_32.lds.S
deleted file mode 100644
index dd9b2ee1312d..000000000000
--- a/arch/sh/kernel/vmlinux_32.lds.S
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- * ld script to make SuperH Linux kernel
- * Written by Niibe Yutaka
- */
-#include <asm/thread_info.h>
-#include <asm/cache.h>
-#include <asm-generic/vmlinux.lds.h>
-
-#ifdef CONFIG_CPU_LITTLE_ENDIAN
-OUTPUT_FORMAT("elf32-sh-linux", "elf32-sh-linux", "elf32-sh-linux")
-#else
-OUTPUT_FORMAT("elf32-shbig-linux", "elf32-shbig-linux", "elf32-shbig-linux")
-#endif
-OUTPUT_ARCH(sh)
-ENTRY(_start)
-SECTIONS
-{
-#ifdef CONFIG_PMB_FIXED
-        . = CONFIG_PAGE_OFFSET + (CONFIG_MEMORY_START & 0x1fffffff) +
-            CONFIG_ZERO_PAGE_OFFSET;
-#elif defined(CONFIG_32BIT)
-        . = CONFIG_PAGE_OFFSET + CONFIG_ZERO_PAGE_OFFSET;
-#else
-        . = CONFIG_PAGE_OFFSET + CONFIG_MEMORY_START + CONFIG_ZERO_PAGE_OFFSET;
-#endif
-
-        _text = .;                      /* Text and read-only data */
-
-        .empty_zero_page : {
-                *(.empty_zero_page)
-        } = 0
-
-        .text : {
-                HEAD_TEXT
-                TEXT_TEXT
-                SCHED_TEXT
-                LOCK_TEXT
-                KPROBES_TEXT
-                *(.fixup)
-                *(.gnu.warning)
-        } = 0x0009
-
-        . = ALIGN(16);          /* Exception table */
-        __start___ex_table = .;
-        __ex_table : { *(__ex_table) }
-        __stop___ex_table = .;
-
-        _etext = .;                     /* End of text section */
-
-        NOTES
-        RO_DATA(PAGE_SIZE)
-
-        /*
-         * Code which must be executed uncached and the associated data
-         */
-        . = ALIGN(PAGE_SIZE);
-        __uncached_start = .;
-        .uncached.text : { *(.uncached.text) }
-        .uncached.data : { *(.uncached.data) }
-        __uncached_end = .;
-
-        . = ALIGN(THREAD_SIZE);
-        .data : {                       /* Data */
-                *(.data.init_task)
-
-                . = ALIGN(L1_CACHE_BYTES);
-                *(.data.cacheline_aligned)
-
-                . = ALIGN(L1_CACHE_BYTES);
-                *(.data.read_mostly)
-
-                . = ALIGN(PAGE_SIZE);
-                *(.data.page_aligned)
-
-                __nosave_begin = .;
-                *(.data.nosave)
-                . = ALIGN(PAGE_SIZE);
-                __nosave_end = .;
-
-                DATA_DATA
-                CONSTRUCTORS
-        }
-
-        _edata = .;                     /* End of data section */
-
-        . = ALIGN(PAGE_SIZE);           /* Init code and data */
-        __init_begin = .;
-        _sinittext = .;
-        .init.text : { INIT_TEXT }
-        _einittext = .;
-        .init.data : { INIT_DATA }
-
-        . = ALIGN(16);
-        __setup_start = .;
-        .init.setup : { *(.init.setup) }
-        __setup_end = .;
-
-        __initcall_start = .;
-        .initcall.init : {
-                INITCALLS
-        }
-        __initcall_end = .;
-        __con_initcall_start = .;
-        .con_initcall.init : { *(.con_initcall.init) }
-        __con_initcall_end = .;
-
-        SECURITY_INIT
-
-#ifdef CONFIG_BLK_DEV_INITRD
-        . = ALIGN(PAGE_SIZE);
-        __initramfs_start = .;
-        .init.ramfs : { *(.init.ramfs) }
-        __initramfs_end = .;
-#endif
-
-        . = ALIGN(4);
-        __machvec_start = .;
-        .machvec.init : { *(.machvec.init) }
-        __machvec_end = .;
-
-        PERCPU(PAGE_SIZE)
-
-        /*
-         * .exit.text is discarded at runtime, not link time, to deal with
-         * references from __bug_table
-         */
-        .exit.text : { EXIT_TEXT }
-        .exit.data : { EXIT_DATA }
-
-        . = ALIGN(PAGE_SIZE);
-        .bss : {
-                __init_end = .;
-                __bss_start = .;                /* BSS */
-                *(.bss.page_aligned)
-                *(.bss)
-                *(COMMON)
-                . = ALIGN(4);
-                _ebss = .;                      /* uClinux MTD sucks */
-                _end = . ;
-        }
-
-        /*
-         * When something in the kernel is NOT compiled as a module, the
-         * module cleanup code and data are put into these segments. Both
-         * can then be thrown away, as cleanup code is never called unless
-         * it's a module.
-         */
-        /DISCARD/ : {
-                *(.exitcall.exit)
-        }
-
-        STABS_DEBUG
-        DWARF_DEBUG
-}
diff --git a/arch/sh/kernel/vmlinux_64.lds.S b/arch/sh/kernel/vmlinux_64.lds.S
deleted file mode 100644
index 69664460c688..000000000000
--- a/arch/sh/kernel/vmlinux_64.lds.S
+++ /dev/null
@@ -1,163 +0,0 @@
-/*
- * ld script to make SH64 Linux kernel
- *
- * Copyright (C) 2000, 2001  Paolo Alberelli
- *
- * benedict.gaster@superh.com:   2nd May 2002
- *    Add definition of empty_zero_page to be the first page of kernel image.
- *
- * benedict.gaster@superh.com:   3rd May 2002
- *    Added support for ramdisk, removing statically linked romfs at the
- *    same time.
- *
- * lethal@linux-sh.org:          9th May 2003
- *    Kill off GLOBAL_NAME() usage and other CDC-isms.
- *
- * lethal@linux-sh.org:         19th May 2003
- *    Remove support for ancient toolchains.
- *
- * 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.
- */
-#include <asm/page.h>
-#include <asm/cache.h>
-#include <asm/thread_info.h>
-
-#define LOAD_OFFSET     CONFIG_PAGE_OFFSET
-#include <asm-generic/vmlinux.lds.h>
-
-OUTPUT_ARCH(sh:sh5)
-
-#define C_PHYS(x) AT (ADDR(x) - LOAD_OFFSET)
-
-ENTRY(__start)
-SECTIONS
-{
-        . = CONFIG_PAGE_OFFSET + CONFIG_MEMORY_START + PAGE_SIZE;
-        _text = .;                      /* Text and read-only data */
-
-        .empty_zero_page : C_PHYS(.empty_zero_page) {
-                *(.empty_zero_page)
-        } = 0
-
-        .text : C_PHYS(.text) {
-                HEAD_TEXT
-                TEXT_TEXT
-                *(.text64)
-                *(.text..SHmedia32)
-                SCHED_TEXT
-                LOCK_TEXT
-                KPROBES_TEXT
-                *(.fixup)
-                *(.gnu.warning)
-#ifdef CONFIG_CPU_LITTLE_ENDIAN
-        } = 0x6ff0fff0
-#else
-        } = 0xf0fff06f
-#endif
-
-        /* We likely want __ex_table to be Cache Line aligned */
-        . = ALIGN(L1_CACHE_BYTES);              /* Exception table */
-        __start___ex_table = .;
-        __ex_table : C_PHYS(__ex_table) { *(__ex_table) }
-        __stop___ex_table = .;
-
-        _etext = .;                     /* End of text section */
-
-        NOTES 
-        RO_DATA(PAGE_SIZE)
-
-        . = ALIGN(THREAD_SIZE);
-        .data : C_PHYS(.data) {                 /* Data */
-                *(.data.init_task)
-
-                . = ALIGN(L1_CACHE_BYTES);
-                *(.data.cacheline_aligned)
-
-                . = ALIGN(L1_CACHE_BYTES);
-                *(.data.read_mostly)
-
-                . = ALIGN(PAGE_SIZE);
-                *(.data.page_aligned)
-
-                __nosave_begin = .;
-                *(.data.nosave)
-                . = ALIGN(PAGE_SIZE);
-                __nosave_end = .;
-
-                DATA_DATA
-                CONSTRUCTORS
-        }
-
-        _edata = .;                     /* End of data section */
-
-        . = ALIGN(PAGE_SIZE);           /* Init code and data */
-        __init_begin = .;
-        _sinittext = .;
-        .init.text : C_PHYS(.init.text) { INIT_TEXT }
-        _einittext = .;
-        .init.data : C_PHYS(.init.data) { INIT_DATA }
-        . = ALIGN(L1_CACHE_BYTES);      /* Better if Cache Line aligned */
-        __setup_start = .;
-        .init.setup : C_PHYS(.init.setup) { *(.init.setup) }
-        __setup_end = .;
-        __initcall_start = .;
-        .initcall.init : C_PHYS(.initcall.init) {
-                INITCALLS
-        }
-        __initcall_end = .;
-        __con_initcall_start = .;
-        .con_initcall.init : C_PHYS(.con_initcall.init) {
-                *(.con_initcall.init)
-        }
-        __con_initcall_end = .;
-
-        SECURITY_INIT
-
-#ifdef CONFIG_BLK_DEV_INITRD
-        . = ALIGN(PAGE_SIZE);
-        __initramfs_start = .;
-        .init.ramfs : C_PHYS(.init.ramfs) { *(.init.ramfs) }
-        __initramfs_end = .;
-#endif
-
-        . = ALIGN(8);
-        __machvec_start = .;
-        .machvec.init : C_PHYS(.machvec.init) { *(.machvec.init) }
-        __machvec_end = .;
-
-        PERCPU(PAGE_SIZE)
-
-        /*
-         * .exit.text is discarded at runtime, not link time, to deal with
-         * references from __bug_table
-         */
-        .exit.text : C_PHYS(.exit.text) { EXIT_TEXT }
-        .exit.data : C_PHYS(.exit.data) { EXIT_DATA }
-
-        . = ALIGN(PAGE_SIZE);
-        .bss : C_PHYS(.bss) {
-                __init_end = .;
-                __bss_start = .;                /* BSS */
-                *(.bss.page_aligned)
-                *(.bss)
-                *(COMMON)
-                . = ALIGN(4);
-                _ebss = .;                      /* uClinux MTD sucks */
-                _end = . ;
-        }
-
-        /*
-         * When something in the kernel is NOT compiled as a module, the
-         * module cleanup code and data are put into these segments. Both
-         * can then be thrown away, as cleanup code is never called unless
-         * it's a module.
-         */
-        /DISCARD/ : {
-                *(.exitcall.exit)
-        }
-
-        STABS_DEBUG
-        DWARF_DEBUG
-}
diff --git a/arch/sh/lib64/.gitignore b/arch/sh/lib64/.gitignore
deleted file mode 100644
index 3508c2cb23c4..000000000000
--- a/arch/sh/lib64/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-syscalltab.h
diff --git a/arch/sh/lib64/dbg.c b/arch/sh/lib64/dbg.c
index 2fb8eaf6de60..6152a6a6d9c6 100644
--- a/arch/sh/lib64/dbg.c
+++ b/arch/sh/lib64/dbg.c
@@ -135,140 +135,6 @@ void print_itlb(void)
             (" =============================================================\n");
 }
 
-/* ======================================================================= */
-
-#ifdef CONFIG_POOR_MANS_STRACE
-
-#include "syscalltab.h"
-
-struct ring_node {
-        int evt;
-        int ret_addr;
-        int event;
-        int tra;
-        int pid;
-        unsigned long sp;
-        unsigned long pc;
-};
-
-static struct ring_node event_ring[16];
-static int event_ptr = 0;
-
-struct stored_syscall_data {
-        int pid;
-        int syscall_number;
-};
-
-#define N_STORED_SYSCALLS 16
-
-static struct stored_syscall_data stored_syscalls[N_STORED_SYSCALLS];
-static int syscall_next=0;
-static int syscall_next_print=0;
-
-void evt_debug(int evt, int ret_addr, int event, int tra, struct pt_regs *regs)
-{
-        int syscallno = tra & 0xff;
-        unsigned long sp;
-        unsigned long stack_bottom;
-        int pid;
-        struct ring_node *rr;
-
-        pid = current->pid;
-        stack_bottom = (unsigned long) task_stack_page(current);
-        asm volatile("ori r15, 0, %0" : "=r" (sp));
-        rr = event_ring + event_ptr;
-        rr->evt = evt;
-        rr->ret_addr = ret_addr;
-        rr->event = event;
-        rr->tra = tra;
-        rr->pid = pid;
-        rr->sp = sp;
-        rr->pc = regs->pc;
-
-        if (sp < stack_bottom + 3092) {
-                int i, j;
-                printk("evt_debug : stack underflow report\n");
-                for (j=0, i = event_ptr; j<16; j++) {
-                        rr = event_ring + i;
-                        printk("evt=%08x event=%08x tra=%08x pid=%5d sp=%08lx pc=%08lx\n",
-                                rr->evt, rr->event, rr->tra, rr->pid, rr->sp, rr->pc);
-                        i--;
-                        i &= 15;
-                }
-                panic("STACK UNDERFLOW\n");
-        }
-
-        event_ptr = (event_ptr + 1) & 15;
-
-        if ((event == 2) && (evt == 0x160)) {
-                if (syscallno < NUM_SYSCALL_INFO_ENTRIES) {
-                        /* Store the syscall information to print later.  We
-                         * can't print this now - currently we're running with
-                         * SR.BL=1, so we can't take a tlbmiss (which could occur
-                         * in the console drivers under printk).
-                         *
-                         * Just overwrite old entries on ring overflow - this
-                         * is only for last-hope debugging. */
-                        stored_syscalls[syscall_next].pid = current->pid;
-                        stored_syscalls[syscall_next].syscall_number = syscallno;
-                        syscall_next++;
-                        syscall_next &= (N_STORED_SYSCALLS - 1);
-                }
-        }
-}
-
-static void drain_syscalls(void) {
-        while (syscall_next_print != syscall_next) {
-                printk("Task %d: %s()\n",
-                        stored_syscalls[syscall_next_print].pid,
-                        syscall_info_table[stored_syscalls[syscall_next_print].syscall_number].name);
-                        syscall_next_print++;
-                        syscall_next_print &= (N_STORED_SYSCALLS - 1);
-        }
-}
-
-void evt_debug2(unsigned int ret)
-{
-        drain_syscalls();
-        printk("Task %d: syscall returns %08x\n", current->pid, ret);
-}
-
-void evt_debug_ret_from_irq(struct pt_regs *regs)
-{
-        int pid;
-        struct ring_node *rr;
-
-        pid = current->pid;
-        rr = event_ring + event_ptr;
-        rr->evt = 0xffff;
-        rr->ret_addr = 0;
-        rr->event = 0;
-        rr->tra = 0;
-        rr->pid = pid;
-        rr->pc = regs->pc;
-        event_ptr = (event_ptr + 1) & 15;
-}
-
-void evt_debug_ret_from_exc(struct pt_regs *regs)
-{
-        int pid;
-        struct ring_node *rr;
-
-        pid = current->pid;
-        rr = event_ring + event_ptr;
-        rr->evt = 0xfffe;
-        rr->ret_addr = 0;
-        rr->event = 0;
-        rr->tra = 0;
-        rr->pid = pid;
-        rr->pc = regs->pc;
-        event_ptr = (event_ptr + 1) & 15;
-}
-
-#endif /* CONFIG_POOR_MANS_STRACE */
-
-/* ======================================================================= */
-
 void show_excp_regs(char *from, int trapnr, int signr, struct pt_regs *regs)
 {
 
@@ -380,51 +246,3 @@ void show_excp_regs(char *from, int trapnr, int signr, struct pt_regs *regs)
         print_dtlb();
         print_itlb();
 }
-
-/* ======================================================================= */
-
-/*
-** Depending on <base> scan the MMU, Data or Instruction side
-** looking for a valid mapping matching Eaddr & asid.
-** Return -1 if not found or the TLB id entry otherwise.
-** Note: it works only for 4k pages!
-*/
-static unsigned long
-lookup_mmu_side(unsigned long base, unsigned long Eaddr, unsigned long asid)
-{
-        regType_t pteH;
-        unsigned long epn;
-        int count;
-
-        epn = Eaddr & 0xfffff000;
-
-        for (count = 0; count < MAX_TLBs; count++, base += TLB_STEP) {
-                pteH = getConfigReg(base);
-                if (GET_VALID(pteH))
-                        if ((unsigned long) GET_EPN(pteH) == epn)
-                                if ((unsigned long) GET_ASID(pteH) == asid)
-                                        break;
-        }
-        return ((unsigned long) ((count < MAX_TLBs) ? base : -1));
-}
-
-unsigned long lookup_dtlb(unsigned long Eaddr)
-{
-        unsigned long asid = get_asid();
-        return (lookup_mmu_side((u64) DTLB_BASE, Eaddr, asid));
-}
-
-unsigned long lookup_itlb(unsigned long Eaddr)
-{
-        unsigned long asid = get_asid();
-        return (lookup_mmu_side((u64) ITLB_BASE, Eaddr, asid));
-}
-
-void print_page(struct page *page)
-{
-        printk("  page[%p] -> index 0x%lx,  count 0x%x,  flags 0x%lx\n",
-               page, page->index, page_count(page), page->flags);
-        printk("       address_space = %p, pages =%ld\n", page->mapping,
-               page->mapping->nrpages);
-
-}
diff --git a/arch/sh/lib64/panic.c b/arch/sh/lib64/panic.c
index da32ba7b5fcc..38c954e04f6a 100644
--- a/arch/sh/lib64/panic.c
+++ b/arch/sh/lib64/panic.c
@@ -6,53 +6,10 @@
  * for more details.
  */
 
-#include <linux/kernel.h>
-#include <asm/io.h>
-#include <cpu/registers.h>
-
-/* THIS IS A PHYSICAL ADDRESS */
-#define HDSP2534_ADDR (0x04002100)
-
-#ifdef CONFIG_SH_CAYMAN
-
-static void poor_mans_delay(void)
-{
-        int i;
-        for (i = 0; i < 2500000; i++) {
-        }               /* poor man's delay */
-}
-
-static void show_value(unsigned long x)
-{
-        int i;
-        unsigned nibble;
-        for (i = 0; i < 8; i++) {
-                nibble = ((x >> (i * 4)) & 0xf);
-
-                ctrl_outb(nibble + ((nibble > 9) ? 55 : 48),
-                          HDSP2534_ADDR + 0xe0 + ((7 - i) << 2));
-        }
-}
-
-#endif
-
 void
 panic_handler(unsigned long panicPC, unsigned long panicSSR,
               unsigned long panicEXPEVT)
 {
-#ifdef CONFIG_SH_CAYMAN
-        while (1) {
-                /* This piece of code displays the PC on the LED display */
-                show_value(panicPC);
-                poor_mans_delay();
-                show_value(panicSSR);
-                poor_mans_delay();
-                show_value(panicEXPEVT);
-                poor_mans_delay();
-        }
-#endif
-
         /* Never return from the panic handler */
         for (;;) ;
-
 }
diff --git a/arch/sh/lib64/sdivsi3.S b/arch/sh/lib64/sdivsi3.S
index 6a800c6a4904..1963bbd42288 100644
--- a/arch/sh/lib64/sdivsi3.S
+++ b/arch/sh/lib64/sdivsi3.S
@@ -1,4 +1,6 @@
         .global __sdivsi3
+        .global __sdivsi3_1
+        .global __sdivsi3_2
         .section        .text..SHmedia32,"ax"
         .align  2
 
@@ -6,13 +8,15 @@
         /* clobbered: r1,r18,r19,r20,r21,r25,tr0 */
         /* result in r0 */
 __sdivsi3:
+__sdivsi3_1:
         ptb __div_table,tr0
+        gettr tr0,r20
 
+__sdivsi3_2:
         nsb r5, r1
         shlld r5, r1, r25    /* normalize; [-2 ..1, 1..2) in s2.62 */
         shari r25, 58, r21   /* extract 5(6) bit index (s2.4 with hole -1..1) */
         /* bubble */
-        gettr tr0,r20
         ldx.ub r20, r21, r19 /* u0.8 */
         shari r25, 32, r25   /* normalize to s2.30 */
         shlli r21, 1, r21
diff --git a/arch/sh/lib64/udelay.c b/arch/sh/lib64/udelay.c
index d76bd801194f..f215b063da70 100644
--- a/arch/sh/lib64/udelay.c
+++ b/arch/sh/lib64/udelay.c
@@ -33,7 +33,7 @@ void __delay(unsigned long loops)
                              :"0"(loops));
 }
 
-inline void __const_udelay(unsigned long xloops)
+void __const_udelay(unsigned long xloops)
 {
         __delay(xloops * (HZ * cpu_data[raw_smp_processor_id()].loops_per_jiffy));
 }
diff --git a/arch/sh/mm/Kconfig b/arch/sh/mm/Kconfig
index d4079cab2d58..2795618e4f07 100644
--- a/arch/sh/mm/Kconfig
+++ b/arch/sh/mm/Kconfig
@@ -21,6 +21,29 @@ config PAGE_OFFSET
         default "0x20000000" if MMU && SUPERH64
         default "0x00000000"
 
+config FORCE_MAX_ZONEORDER
+        int "Maximum zone order"
+        range 9 64 if PAGE_SIZE_16KB
+        default "9" if PAGE_SIZE_16KB
+        range 7 64 if PAGE_SIZE_64KB
+        default "7" if PAGE_SIZE_64KB
+        range 11 64
+        default "14" if !MMU
+        default "11"
+        help
+          The kernel memory allocator divides physically contiguous memory
+          blocks into "zones", where each zone is a power of two number of
+          pages.  This option selects the largest power of two that the kernel
+          keeps in the memory allocator.  If you need to allocate very large
+          blocks of physically contiguous memory, then you may need to
+          increase this value.
+
+          This config option is actually maximum order plus one. For example,
+          a value of 11 means that the largest free memory block is 2^10 pages.
+
+          The page size is not necessarily 4KB. Keep this in mind when
+          choosing a value for this option.
+
 config MEMORY_START
         hex "Physical memory start address"
         default "0x08000000"
@@ -201,14 +224,6 @@ config PAGE_SIZE_64KB
 
 endchoice
 
-config ENTRY_OFFSET
-        hex
-        default "0x00001000" if PAGE_SIZE_4KB
-        default "0x00002000" if PAGE_SIZE_8KB
-        default "0x00004000" if PAGE_SIZE_16KB
-        default "0x00010000" if PAGE_SIZE_64KB
-        default "0x00000000"
-
 choice
         prompt "HugeTLB page size"
         depends on HUGETLB_PAGE && (CPU_SH4 || CPU_SH5) && MMU
diff --git a/arch/sh/mm/cache-sh5.c b/arch/sh/mm/cache-sh5.c
index 9e277ec7d536..86762092508c 100644
--- a/arch/sh/mm/cache-sh5.c
+++ b/arch/sh/mm/cache-sh5.c
@@ -60,7 +60,7 @@ static inline void sh64_teardown_dtlb_cache_slot(void)
 static inline void sh64_icache_inv_all(void)
 {
         unsigned long long addr, flag, data;
-        unsigned int flags;
+        unsigned long flags;
 
         addr = ICCR0;
         flag = ICCR0_ICI;
@@ -172,7 +172,7 @@ static void sh64_icache_inv_user_page_range(struct mm_struct *mm,
                 unsigned long eaddr;
                 unsigned long after_last_page_start;
                 unsigned long mm_asid, current_asid;
-                unsigned long long flags = 0ULL;
+                unsigned long flags = 0;
 
                 mm_asid = cpu_asid(smp_processor_id(), mm);
                 current_asid = get_asid();
@@ -236,7 +236,7 @@ static void sh64_icache_inv_user_small_range(struct mm_struct *mm,
         unsigned long long eaddr = start;
         unsigned long long eaddr_end = start + len;
         unsigned long current_asid, mm_asid;
-        unsigned long long flags;
+        unsigned long flags;
         unsigned long long epage_start;
 
         /*
@@ -342,7 +342,7 @@ static void inline sh64_dcache_purge_sets(int sets_to_purge_base, int n_sets)
                          * alloco is a NOP if the cache is write-through.
                          */
                         if (test_bit(SH_CACHE_MODE_WT, &(cpu_data->dcache.flags)))
-                                ctrl_inb(eaddr);
+                                __raw_readb((unsigned long)eaddr);
                 }
         }
 
diff --git a/arch/sh/mm/init.c b/arch/sh/mm/init.c
index 3edf297c829b..ee8e6bbe882c 100644
--- a/arch/sh/mm/init.c
+++ b/arch/sh/mm/init.c
@@ -184,7 +184,6 @@ void __init paging_init(void)
 }
 
 static struct kcore_list kcore_mem, kcore_vmalloc;
-int after_bootmem = 0;
 
 void __init mem_init(void)
 {
@@ -217,8 +216,6 @@ void __init mem_init(void)
         memset(empty_zero_page, 0, PAGE_SIZE);
         __flush_wback_region(empty_zero_page, PAGE_SIZE);
 
-        after_bootmem = 1;
-
         codesize =  (unsigned long) &_etext - (unsigned long) &_text;
         datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
         initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
diff --git a/arch/sh/mm/ioremap_32.c b/arch/sh/mm/ioremap_32.c
index 60cc486d2c2c..da2f4186f2cd 100644
--- a/arch/sh/mm/ioremap_32.c
+++ b/arch/sh/mm/ioremap_32.c
@@ -46,17 +46,15 @@ void __iomem *__ioremap(unsigned long phys_addr, unsigned long size,
                 return NULL;
 
         /*
-         * If we're on an SH7751 or SH7780 PCI controller, PCI memory is
-         * mapped at the end of the address space (typically 0xfd000000)
-         * in a non-translatable area, so mapping through page tables for
-         * this area is not only pointless, but also fundamentally
-         * broken. Just return the physical address instead.
+         * If we're in the fixed PCI memory range, mapping through page
+         * tables is not only pointless, but also fundamentally broken.
+         * Just return the physical address instead.
          *
          * For boards that map a small PCI memory aperture somewhere in
          * P1/P2 space, ioremap() will already do the right thing,
          * and we'll never get this far.
          */
-        if (is_pci_memaddr(phys_addr) && is_pci_memaddr(last_addr))
+        if (is_pci_memory_fixed_range(phys_addr, size))
                 return (void __iomem *)phys_addr;
 
 #if !defined(CONFIG_PMB_FIXED)
@@ -121,7 +119,9 @@ void __iounmap(void __iomem *addr)
         unsigned long seg = PXSEG(vaddr);
         struct vm_struct *p;
 
-        if (seg < P3SEG || vaddr >= P3_ADDR_MAX || is_pci_memaddr(vaddr))
+        if (seg < P3SEG || vaddr >= P3_ADDR_MAX)
+                return;
+        if (is_pci_memory_fixed_range(vaddr, 0))
                 return;
 
 #ifdef CONFIG_PMB
diff --git a/arch/sh/mm/ioremap_64.c b/arch/sh/mm/ioremap_64.c
index 31e1bb5effbe..828c8597219d 100644
--- a/arch/sh/mm/ioremap_64.c
+++ b/arch/sh/mm/ioremap_64.c
@@ -20,6 +20,7 @@
 #include <linux/io.h>
 #include <linux/bootmem.h>
 #include <linux/proc_fs.h>
+#include <linux/slab.h>
 #include <asm/page.h>
 #include <asm/pgalloc.h>
 #include <asm/addrspace.h>
@@ -27,88 +28,17 @@
 #include <asm/tlbflush.h>
 #include <asm/mmu.h>
 
-static void shmedia_mapioaddr(unsigned long, unsigned long);
-static unsigned long shmedia_ioremap(struct resource *, u32, int);
-
-/*
- * Generic mapping function (not visible outside):
- */
-
-/*
- * Remap an arbitrary physical address space into the kernel virtual
- * address space. Needed when the kernel wants to access high addresses
- * directly.
- *
- * NOTE! We need to allow non-page-aligned mappings too: we will obviously
- * have to convert them into an offset in a page-aligned mapping, but the
- * caller shouldn't need to know that small detail.
- */
-void *__ioremap(unsigned long phys_addr, unsigned long size,
-                unsigned long flags)
-{
-        void * addr;
-        struct vm_struct * area;
-        unsigned long offset, last_addr;
-        pgprot_t pgprot;
-
-        /* Don't allow wraparound or zero size */
-        last_addr = phys_addr + size - 1;
-        if (!size || last_addr < phys_addr)
-                return NULL;
-
-        pgprot = __pgprot(_PAGE_PRESENT  | _PAGE_READ   |
-                          _PAGE_WRITE    | _PAGE_DIRTY  |
-                          _PAGE_ACCESSED | _PAGE_SHARED | flags);
-
-        /*
-         * Mappings have to be page-aligned
-         */
-        offset = phys_addr & ~PAGE_MASK;
-        phys_addr &= PAGE_MASK;
-        size = PAGE_ALIGN(last_addr + 1) - phys_addr;
-
-        /*
-         * Ok, go for it..
-         */
-        area = get_vm_area(size, VM_IOREMAP);
-        if (!area)
-                return NULL;
-        pr_debug("Get vm_area returns %p addr %p\n", area, area->addr);
-        area->phys_addr = phys_addr;
-        addr = area->addr;
-        if (ioremap_page_range((unsigned long)addr, (unsigned long)addr + size,
-                               phys_addr, pgprot)) {
-                vunmap(addr);
-                return NULL;
-        }
-        return (void *) (offset + (char *)addr);
-}
-EXPORT_SYMBOL(__ioremap);
-
-void __iounmap(void *addr)
-{
-        struct vm_struct *area;
-
-        vfree((void *) (PAGE_MASK & (unsigned long) addr));
-        area = remove_vm_area((void *) (PAGE_MASK & (unsigned long) addr));
-        if (!area) {
-                printk(KERN_ERR "iounmap: bad address %p\n", addr);
-                return;
-        }
-
-        kfree(area);
-}
-EXPORT_SYMBOL(__iounmap);
-
 static struct resource shmedia_iomap = {
         .name   = "shmedia_iomap",
         .start  = IOBASE_VADDR + PAGE_SIZE,
         .end    = IOBASE_END - 1,
 };
 
-static void shmedia_mapioaddr(unsigned long pa, unsigned long va);
+static void shmedia_mapioaddr(unsigned long pa, unsigned long va,
+                              unsigned long flags);
 static void shmedia_unmapioaddr(unsigned long vaddr);
-static unsigned long shmedia_ioremap(struct resource *res, u32 pa, int sz);
+static void __iomem *shmedia_ioremap(struct resource *res, u32 pa,
+                                     int sz, unsigned long flags);
 
 /*
  * We have the same problem as the SPARC, so lets have the same comment:
@@ -130,18 +60,18 @@ static struct xresource xresv[XNRES];
 
 static struct xresource *xres_alloc(void)
 {
-        struct xresource *xrp;
-        int n;
-
-        xrp = xresv;
-        for (n = 0; n < XNRES; n++) {
-                if (xrp->xflag == 0) {
-                        xrp->xflag = 1;
-                        return xrp;
-                }
-                xrp++;
-        }
-        return NULL;
+        struct xresource *xrp;
+        int n;
+
+        xrp = xresv;
+        for (n = 0; n < XNRES; n++) {
+                if (xrp->xflag == 0) {
+                        xrp->xflag = 1;
+                        return xrp;
+                }
+                xrp++;
+        }
+        return NULL;
 }
 
 static void xres_free(struct xresource *xrp)
@@ -161,76 +91,71 @@ static struct resource *shmedia_find_resource(struct resource *root,
         return NULL;
 }
 
-static unsigned long shmedia_alloc_io(unsigned long phys, unsigned long size,
-                                      const char *name)
+static void __iomem *shmedia_alloc_io(unsigned long phys, unsigned long size,
+                                      const char *name, unsigned long flags)
 {
-        static int printed_full = 0;
-        struct xresource *xres;
-        struct resource *res;
-        char *tack;
-        int tlen;
-
-        if (name == NULL) name = "???";
-
-        if ((xres = xres_alloc()) != 0) {
-                tack = xres->xname;
-                res = &xres->xres;
-        } else {
-                if (!printed_full) {
-                        printk("%s: done with statics, switching to kmalloc\n",
-                               __func__);
-                        printed_full = 1;
-                }
-                tlen = strlen(name);
-                tack = kmalloc(sizeof (struct resource) + tlen + 1, GFP_KERNEL);
-                if (!tack)
-                        return -ENOMEM;
-                memset(tack, 0, sizeof(struct resource));
-                res = (struct resource *) tack;
-                tack += sizeof (struct resource);
-        }
-
-        strncpy(tack, name, XNMLN);
-        tack[XNMLN] = 0;
-        res->name = tack;
-
-        return shmedia_ioremap(res, phys, size);
+        static int printed_full;
+        struct xresource *xres;
+        struct resource *res;
+        char *tack;
+        int tlen;
+
+        if (name == NULL)
+                name = "???";
+
+        xres = xres_alloc();
+        if (xres != 0) {
+                tack = xres->xname;
+                res = &xres->xres;
+        } else {
+                if (!printed_full) {
+                        printk(KERN_NOTICE "%s: done with statics, "
+                               "switching to kmalloc\n", __func__);
+                        printed_full = 1;
+                }
+                tlen = strlen(name);
+                tack = kmalloc(sizeof(struct resource) + tlen + 1, GFP_KERNEL);
+                if (!tack)
+                        return NULL;
+                memset(tack, 0, sizeof(struct resource));
+                res = (struct resource *) tack;
+                tack += sizeof(struct resource);
+        }
+
+        strncpy(tack, name, XNMLN);
+        tack[XNMLN] = 0;
+        res->name = tack;
+
+        return shmedia_ioremap(res, phys, size, flags);
 }
 
-static unsigned long shmedia_ioremap(struct resource *res, u32 pa, int sz)
+static void __iomem *shmedia_ioremap(struct resource *res, u32 pa, int sz,
+                                     unsigned long flags)
 {
-        unsigned long offset = ((unsigned long) pa) & (~PAGE_MASK);
+        unsigned long offset = ((unsigned long) pa) & (~PAGE_MASK);
         unsigned long round_sz = (offset + sz + PAGE_SIZE-1) & PAGE_MASK;
-        unsigned long va;
-        unsigned int psz;
+        unsigned long va;
+        unsigned int psz;
 
-        if (allocate_resource(&shmedia_iomap, res, round_sz,
+        if (allocate_resource(&shmedia_iomap, res, round_sz,
                               shmedia_iomap.start, shmedia_iomap.end,
                               PAGE_SIZE, NULL, NULL) != 0) {
-                panic("alloc_io_res(%s): cannot occupy\n",
-                    (res->name != NULL)? res->name: "???");
-        }
+                panic("alloc_io_res(%s): cannot occupy\n",
+                      (res->name != NULL) ? res->name : "???");
+        }
 
-        va = res->start;
-        pa &= PAGE_MASK;
+        va = res->start;
+        pa &= PAGE_MASK;
 
         psz = (res->end - res->start + (PAGE_SIZE - 1)) / PAGE_SIZE;
 
-        /* log at boot time ... */
-        printk("mapioaddr: %6s  [%2d page%s]  va 0x%08lx   pa 0x%08x\n",
-               ((res->name != NULL) ? res->name : "???"),
-               psz, psz == 1 ? " " : "s", va, pa);
-
-        for (psz = res->end - res->start + 1; psz != 0; psz -= PAGE_SIZE) {
-                shmedia_mapioaddr(pa, va);
-                va += PAGE_SIZE;
-                pa += PAGE_SIZE;
-        }
-
-        res->start += offset;
-        res->end = res->start + sz - 1;         /* not strictly necessary.. */
+        for (psz = res->end - res->start + 1; psz != 0; psz -= PAGE_SIZE) {
+                shmedia_mapioaddr(pa, va, flags);
+                va += PAGE_SIZE;
+                pa += PAGE_SIZE;
+        }
 
-        return res->start;
+        return (void __iomem *)(unsigned long)(res->start + offset);
 }
 
 static void shmedia_free_io(struct resource *res)
@@ -249,14 +174,12 @@ static void shmedia_free_io(struct resource *res)
 
 static __init_refok void *sh64_get_page(void)
 {
-        extern int after_bootmem;
         void *page;
 
-        if (after_bootmem) {
-                page = (void *)get_zeroed_page(GFP_ATOMIC);
-        } else {
+        if (slab_is_available())
+                page = (void *)get_zeroed_page(GFP_KERNEL);
+        else
                 page = alloc_bootmem_pages(PAGE_SIZE);
-        }
 
         if (!page || ((unsigned long)page & ~PAGE_MASK))
                 panic("sh64_get_page: Out of memory already?\n");
@@ -264,17 +187,20 @@ static __init_refok void *sh64_get_page(void)
         return page;
 }
 
-static void shmedia_mapioaddr(unsigned long pa, unsigned long va)
+static void shmedia_mapioaddr(unsigned long pa, unsigned long va,
+                              unsigned long flags)
 {
         pgd_t *pgdp;
         pud_t *pudp;
         pmd_t *pmdp;
         pte_t *ptep, pte;
         pgprot_t prot;
-        unsigned long flags = 1; /* 1 = CB0-1 device */
 
         pr_debug("shmedia_mapiopage pa %08lx va %08lx\n",  pa, va);
 
+        if (!flags)
+                flags = 1; /* 1 = CB0-1 device */
+
         pgdp = pgd_offset_k(va);
         if (pgd_none(*pgdp) || !pgd_present(*pgdp)) {
                 pudp = (pud_t *)sh64_get_page();
@@ -288,7 +214,7 @@ static void shmedia_mapioaddr(unsigned long pa, unsigned long va)
         }
 
         pmdp = pmd_offset(pudp, va);
-        if (pmd_none(*pmdp) || !pmd_present(*pmdp) ) {
+        if (pmd_none(*pmdp) || !pmd_present(*pmdp)) {
                 ptep = (pte_t *)sh64_get_page();
                 set_pmd(pmdp, __pmd((unsigned long)ptep + _PAGE_TABLE));
         }
@@ -336,17 +262,19 @@ static void shmedia_unmapioaddr(unsigned long vaddr)
         pte_clear(&init_mm, vaddr, ptep);
 }
 
-unsigned long onchip_remap(unsigned long phys, unsigned long size, const char *name)
+void __iomem *__ioremap(unsigned long offset, unsigned long size,
+                        unsigned long flags)
 {
-        if (size < PAGE_SIZE)
-                size = PAGE_SIZE;
+        char name[14];
 
-        return shmedia_alloc_io(phys, size, name);
+        sprintf(name, "phys_%08x", (u32)offset);
+        return shmedia_alloc_io(offset, size, name, flags);
 }
-EXPORT_SYMBOL(onchip_remap);
+EXPORT_SYMBOL(__ioremap);
 
-void onchip_unmap(unsigned long vaddr)
+void __iounmap(void __iomem *virtual)
 {
+        unsigned long vaddr = (unsigned long)virtual & PAGE_MASK;
         struct resource *res;
         unsigned int psz;
 
@@ -357,10 +285,7 @@ void onchip_unmap(unsigned long vaddr)
                 return;
         }
 
-        psz = (res->end - res->start + (PAGE_SIZE - 1)) / PAGE_SIZE;
-
-        printk(KERN_DEBUG "unmapioaddr: %6s  [%2d page%s] freed\n",
-               res->name, psz, psz == 1 ? " " : "s");
+        psz = (res->end - res->start + (PAGE_SIZE - 1)) / PAGE_SIZE;
 
         shmedia_free_io(res);
 
@@ -371,9 +296,8 @@ void onchip_unmap(unsigned long vaddr)
                 kfree(res);
         }
 }
-EXPORT_SYMBOL(onchip_unmap);
+EXPORT_SYMBOL(__iounmap);
 
-#ifdef CONFIG_PROC_FS
 static int
 ioremap_proc_info(char *buf, char **start, off_t fpos, int length, int *eof,
                   void *data)
@@ -385,7 +309,10 @@ ioremap_proc_info(char *buf, char **start, off_t fpos, int length, int *eof,
         for (r = ((struct resource *)data)->child; r != NULL; r = r->sibling) {
                 if (p + 32 >= e)        /* Better than nothing */
                         break;
-                if ((nm = r->name) == 0) nm = "???";
+                nm = r->name;
+                if (nm == NULL)
+                        nm = "???";
+
                 p += sprintf(p, "%08lx-%08lx: %s\n",
                              (unsigned long)r->start,
                              (unsigned long)r->end, nm);
@@ -393,14 +320,11 @@ ioremap_proc_info(char *buf, char **start, off_t fpos, int length, int *eof,
 
         return p-buf;
 }
-#endif /* CONFIG_PROC_FS */
 
 static int __init register_proc_onchip(void)
 {
-#ifdef CONFIG_PROC_FS
-        create_proc_read_entry("io_map",0,0, ioremap_proc_info, &shmedia_iomap);
-#endif
+        create_proc_read_entry("io_map", 0, 0, ioremap_proc_info,
+                               &shmedia_iomap);
         return 0;
 }
-
-__initcall(register_proc_onchip);
+late_initcall(register_proc_onchip);
diff --git a/arch/sh/mm/mmap.c b/arch/sh/mm/mmap.c
index 931f4d003fa0..1b5fdfb4e0c2 100644
--- a/arch/sh/mm/mmap.c
+++ b/arch/sh/mm/mmap.c
@@ -1,7 +1,7 @@
 /*
  * arch/sh/mm/mmap.c
  *
- * Copyright (C) 2008  Paul Mundt
+ * Copyright (C) 2008 - 2009  Paul Mundt
  *
  * 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
@@ -21,9 +21,26 @@ EXPORT_SYMBOL(shm_align_mask);
 /*
  * To avoid cache aliases, we map the shared page with same color.
  */
-#define COLOUR_ALIGN(addr, pgoff)                               \
-        ((((addr) + shm_align_mask) & ~shm_align_mask) +        \
-         (((pgoff) << PAGE_SHIFT) & shm_align_mask))
+static inline unsigned long COLOUR_ALIGN(unsigned long addr,
+                                         unsigned long pgoff)
+{
+        unsigned long base = (addr + shm_align_mask) & ~shm_align_mask;
+        unsigned long off = (pgoff << PAGE_SHIFT) & shm_align_mask;
+
+        return base + off;
+}
+
+static inline unsigned long COLOUR_ALIGN_DOWN(unsigned long addr,
+                                              unsigned long pgoff)
+{
+        unsigned long base = addr & ~shm_align_mask;
+        unsigned long off = (pgoff << PAGE_SHIFT) & shm_align_mask;
+
+        if (base + off <= addr)
+                return base + off;
+
+        return base - off;
+}
 
 unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr,
         unsigned long len, unsigned long pgoff, unsigned long flags)
@@ -103,6 +120,117 @@ full_search:
                         addr = COLOUR_ALIGN(addr, pgoff);
         }
 }
+
+unsigned long
+arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0,
+                          const unsigned long len, const unsigned long pgoff,
+                          const unsigned long flags)
+{
+        struct vm_area_struct *vma;
+        struct mm_struct *mm = current->mm;
+        unsigned long addr = addr0;
+        int do_colour_align;
+
+        if (flags & MAP_FIXED) {
+                /* We do not accept a shared mapping if it would violate
+                 * cache aliasing constraints.
+                 */
+                if ((flags & MAP_SHARED) &&
+                    ((addr - (pgoff << PAGE_SHIFT)) & shm_align_mask))
+                        return -EINVAL;
+                return addr;
+        }
+
+        if (unlikely(len > TASK_SIZE))
+                return -ENOMEM;
+
+        do_colour_align = 0;
+        if (filp || (flags & MAP_SHARED))
+                do_colour_align = 1;
+
+        /* requesting a specific address */
+        if (addr) {
+                if (do_colour_align)
+                        addr = COLOUR_ALIGN(addr, pgoff);
+                else
+                        addr = PAGE_ALIGN(addr);
+
+                vma = find_vma(mm, addr);
+                if (TASK_SIZE - len >= addr &&
+                    (!vma || addr + len <= vma->vm_start))
+                        return addr;
+        }
+
+        /* check if free_area_cache is useful for us */
+        if (len <= mm->cached_hole_size) {
+                mm->cached_hole_size = 0;
+                mm->free_area_cache = mm->mmap_base;
+        }
+
+        /* either no address requested or can't fit in requested address hole */
+        addr = mm->free_area_cache;
+        if (do_colour_align) {
+                unsigned long base = COLOUR_ALIGN_DOWN(addr-len, pgoff);
+
+                addr = base + len;
+        }
+
+        /* make sure it can fit in the remaining address space */
+        if (likely(addr > len)) {
+                vma = find_vma(mm, addr-len);
+                if (!vma || addr <= vma->vm_start) {
+                        /* remember the address as a hint for next time */
+                        return (mm->free_area_cache = addr-len);
+                }
+        }
+
+        if (unlikely(mm->mmap_base < len))
+                goto bottomup;
+
+        addr = mm->mmap_base-len;
+        if (do_colour_align)
+                addr = COLOUR_ALIGN_DOWN(addr, pgoff);
+
+        do {
+                /*
+                 * Lookup failure means no vma is above this address,
+                 * else if new region fits below vma->vm_start,
+                 * return with success:
+                 */
+                vma = find_vma(mm, addr);
+                if (likely(!vma || addr+len <= vma->vm_start)) {
+                        /* remember the address as a hint for next time */
+                        return (mm->free_area_cache = addr);
+                }
+
+                /* remember the largest hole we saw so far */
+                if (addr + mm->cached_hole_size < vma->vm_start)
+                        mm->cached_hole_size = vma->vm_start - addr;
+
+                /* try just below the current vma->vm_start */
+                addr = vma->vm_start-len;
+                if (do_colour_align)
+                        addr = COLOUR_ALIGN_DOWN(addr, pgoff);
+        } while (likely(len < vma->vm_start));
+
+bottomup:
+        /*
+         * A failed mmap() very likely causes application failure,
+         * so fall back to the bottom-up function here. This scenario
+         * can happen with large stack limits and large mmap()
+         * allocations.
+         */
+        mm->cached_hole_size = ~0UL;
+        mm->free_area_cache = TASK_UNMAPPED_BASE;
+        addr = arch_get_unmapped_area(filp, addr0, len, pgoff, flags);
+        /*
+         * Restore the topdown base:
+         */
+        mm->free_area_cache = mm->mmap_base;
+        mm->cached_hole_size = ~0UL;
+
+        return addr;
+}
 #endif /* CONFIG_MMU */
 
 /*
diff --git a/arch/sh/oprofile/common.c b/arch/sh/oprofile/common.c
index 1b9d4304b3bf..44f4e31c6d63 100644
--- a/arch/sh/oprofile/common.c
+++ b/arch/sh/oprofile/common.c
@@ -109,6 +109,7 @@ int __init oprofile_arch_init(struct oprofile_operations *ops)
         case CPU_SH7785:
         case CPU_SH7786:
         case CPU_SH7723:
+        case CPU_SH7724:
         case CPU_SHX3:
                 lmodel = &op_model_sh4a_ops;
                 break;
diff --git a/arch/sh/tools/mach-types b/arch/sh/tools/mach-types
index 8477b5d884fd..fec3a53b8650 100644
--- a/arch/sh/tools/mach-types
+++ b/arch/sh/tools/mach-types
@@ -23,6 +23,7 @@ HD64461			HD64461
 7619SE                  SH_7619_SOLUTION_ENGINE
 7721SE                  SH_7721_SOLUTION_ENGINE
 7722SE                  SH_7722_SOLUTION_ENGINE
+7724SE                  SH_7724_SOLUTION_ENGINE
 7751SE                  SH_7751_SOLUTION_ENGINE
 7780SE                  SH_7780_SOLUTION_ENGINE
 7751SYSTEMH             SH_7751_SYSTEMH
diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c
index f934225fd8ef..aa9e926e13d7 100644
--- a/arch/um/drivers/ubd_kern.c
+++ b/arch/um/drivers/ubd_kern.c
@@ -451,23 +451,6 @@ static void do_ubd_request(struct request_queue * q);
 
 /* Only changed by ubd_init, which is an initcall. */
 static int thread_fd = -1;
-
-static void ubd_end_request(struct request *req, int bytes, int error)
-{
-        blk_end_request(req, error, bytes);
-}
-
-/* Callable only from interrupt context - otherwise you need to do
- * spin_lock_irq()/spin_lock_irqsave() */
-static inline void ubd_finish(struct request *req, int bytes)
-{
-        if(bytes < 0){
-                ubd_end_request(req, 0, -EIO);
-                return;
-        }
-        ubd_end_request(req, bytes, 0);
-}
-
 static LIST_HEAD(restart);
 
 /* XXX - move this inside ubd_intr. */
@@ -475,7 +458,6 @@ static LIST_HEAD(restart);
 static void ubd_handler(void)
 {
         struct io_thread_req *req;
-        struct request *rq;
         struct ubd *ubd;
         struct list_head *list, *next_ele;
         unsigned long flags;
@@ -492,10 +474,7 @@ static void ubd_handler(void)
                         return;
                 }
 
-                rq = req->req;
-                rq->nr_sectors -= req->length >> 9;
-                if(rq->nr_sectors == 0)
-                        ubd_finish(rq, rq->hard_nr_sectors << 9);
+                blk_end_request(req->req, 0, req->length);
                 kfree(req);
         }
         reactivate_fd(thread_fd, UBD_IRQ);
@@ -1243,27 +1222,26 @@ static void do_ubd_request(struct request_queue *q)
 {
         struct io_thread_req *io_req;
         struct request *req;
-        int n, last_sectors;
+        sector_t sector;
+        int n;
 
         while(1){
                 struct ubd *dev = q->queuedata;
                 if(dev->end_sg == 0){
-                        struct request *req = elv_next_request(q);
+                        struct request *req = blk_fetch_request(q);
                         if(req == NULL)
                                 return;
 
                         dev->request = req;
-                        blkdev_dequeue_request(req);
                         dev->start_sg = 0;
                         dev->end_sg = blk_rq_map_sg(q, req, dev->sg);
                 }
 
                 req = dev->request;
-                last_sectors = 0;
+                sector = blk_rq_pos(req);
                 while(dev->start_sg < dev->end_sg){
                         struct scatterlist *sg = &dev->sg[dev->start_sg];
 
-                        req->sector += last_sectors;
                         io_req = kmalloc(sizeof(struct io_thread_req),
                                          GFP_ATOMIC);
                         if(io_req == NULL){
@@ -1272,10 +1250,10 @@ static void do_ubd_request(struct request_queue *q)
                                 return;
                         }
                         prepare_request(req, io_req,
-                                        (unsigned long long) req->sector << 9,
+                                        (unsigned long long)sector << 9,
                                         sg->offset, sg->length, sg_page(sg));
 
-                        last_sectors = sg->length >> 9;
+                        sector += sg->length >> 9;
                         n = os_write_file(thread_fd, &io_req,
                                           sizeof(struct io_thread_req *));
                         if(n != sizeof(struct io_thread_req *)){
diff --git a/arch/x86/include/asm/cpufeature.h b/arch/x86/include/asm/cpufeature.h
index 19af42138f78..4a28d22d4793 100644
--- a/arch/x86/include/asm/cpufeature.h
+++ b/arch/x86/include/asm/cpufeature.h
@@ -116,6 +116,8 @@
 #define X86_FEATURE_XMM4_1      (4*32+19) /* "sse4_1" SSE-4.1 */
 #define X86_FEATURE_XMM4_2      (4*32+20) /* "sse4_2" SSE-4.2 */
 #define X86_FEATURE_X2APIC      (4*32+21) /* x2APIC */
+#define X86_FEATURE_MOVBE       (4*32+22) /* MOVBE instruction */
+#define X86_FEATURE_POPCNT      (4*32+23) /* POPCNT instruction */
 #define X86_FEATURE_AES         (4*32+25) /* AES instructions */
 #define X86_FEATURE_XSAVE       (4*32+26) /* XSAVE/XRSTOR/XSETBV/XGETBV */
 #define X86_FEATURE_OSXSAVE     (4*32+27) /* "" XSAVE enabled in the OS */
diff --git a/arch/x86/include/asm/kvm.h b/arch/x86/include/asm/kvm.h
index dc3f6cf11704..125be8b19568 100644
--- a/arch/x86/include/asm/kvm.h
+++ b/arch/x86/include/asm/kvm.h
@@ -16,6 +16,7 @@
 #define __KVM_HAVE_MSI
 #define __KVM_HAVE_USER_NMI
 #define __KVM_HAVE_GUEST_DEBUG
+#define __KVM_HAVE_MSIX
 
 /* Architectural interrupt line count. */
 #define KVM_NR_INTERRUPTS 256
diff --git a/arch/x86/include/asm/kvm_host.h b/arch/x86/include/asm/kvm_host.h
index f0faf58044ff..eabdc1cfab5c 100644
--- a/arch/x86/include/asm/kvm_host.h
+++ b/arch/x86/include/asm/kvm_host.h
@@ -185,6 +185,7 @@ union kvm_mmu_page_role {
                 unsigned access:3;
                 unsigned invalid:1;
                 unsigned cr4_pge:1;
+                unsigned nxe:1;
         };
 };
 
@@ -212,7 +213,6 @@ struct kvm_mmu_page {
         int multimapped;         /* More than one parent_pte? */
         int root_count;          /* Currently serving as active root */
         bool unsync;
-        bool global;
         unsigned int unsync_children;
         union {
                 u64 *parent_pte;               /* !multimapped */
@@ -261,13 +261,11 @@ struct kvm_mmu {
         union kvm_mmu_page_role base_role;
 
         u64 *pae_root;
+        u64 rsvd_bits_mask[2][4];
 };
 
 struct kvm_vcpu_arch {
         u64 host_tsc;
-        int interrupt_window_open;
-        unsigned long irq_summary; /* bit vector: 1 per word in irq_pending */
-        DECLARE_BITMAP(irq_pending, KVM_NR_INTERRUPTS);
         /*
          * rip and regs accesses must go through
          * kvm_{register,rip}_{read,write} functions.
@@ -286,6 +284,7 @@ struct kvm_vcpu_arch {
         u64 shadow_efer;
         u64 apic_base;
         struct kvm_lapic *apic;    /* kernel irqchip context */
+        int32_t apic_arb_prio;
         int mp_state;
         int sipi_vector;
         u64 ia32_misc_enable_msr;
@@ -320,6 +319,8 @@ struct kvm_vcpu_arch {
         struct kvm_pio_request pio;
         void *pio_data;
 
+        u8 event_exit_inst_len;
+
         struct kvm_queued_exception {
                 bool pending;
                 bool has_error_code;
@@ -329,11 +330,12 @@ struct kvm_vcpu_arch {
 
         struct kvm_queued_interrupt {
                 bool pending;
+                bool soft;
                 u8 nr;
         } interrupt;
 
         struct {
-                int active;
+                int vm86_active;
                 u8 save_iopl;
                 struct kvm_save_segment {
                         u16 selector;
@@ -356,9 +358,9 @@ struct kvm_vcpu_arch {
         unsigned int time_offset;
         struct page *time_page;
 
+        bool singlestep; /* guest is single stepped by KVM */
         bool nmi_pending;
         bool nmi_injected;
-        bool nmi_window_open;
 
         struct mtrr_state_type mtrr_state;
         u32 pat;
@@ -392,15 +394,14 @@ struct kvm_arch{
          */
         struct list_head active_mmu_pages;
         struct list_head assigned_dev_head;
-        struct list_head oos_global_pages;
         struct iommu_domain *iommu_domain;
+        int iommu_flags;
         struct kvm_pic *vpic;
         struct kvm_ioapic *vioapic;
         struct kvm_pit *vpit;
         struct hlist_head irq_ack_notifier_list;
         int vapics_in_nmi_mode;
 
-        int round_robin_prev_vcpu;
         unsigned int tss_addr;
         struct page *apic_access_page;
 
@@ -423,7 +424,6 @@ struct kvm_vm_stat {
         u32 mmu_recycled;
         u32 mmu_cache_miss;
         u32 mmu_unsync;
-        u32 mmu_unsync_global;
         u32 remote_tlb_flush;
         u32 lpages;
 };
@@ -443,7 +443,6 @@ struct kvm_vcpu_stat {
         u32 halt_exits;
         u32 halt_wakeup;
         u32 request_irq_exits;
-        u32 request_nmi_exits;
         u32 irq_exits;
         u32 host_state_reload;
         u32 efer_reload;
@@ -511,20 +510,22 @@ struct kvm_x86_ops {
         void (*run)(struct kvm_vcpu *vcpu, struct kvm_run *run);
         int (*handle_exit)(struct kvm_run *run, struct kvm_vcpu *vcpu);
         void (*skip_emulated_instruction)(struct kvm_vcpu *vcpu);
+        void (*set_interrupt_shadow)(struct kvm_vcpu *vcpu, int mask);
+        u32 (*get_interrupt_shadow)(struct kvm_vcpu *vcpu, int mask);
         void (*patch_hypercall)(struct kvm_vcpu *vcpu,
                                 unsigned char *hypercall_addr);
-        int (*get_irq)(struct kvm_vcpu *vcpu);
-        void (*set_irq)(struct kvm_vcpu *vcpu, int vec);
+        void (*set_irq)(struct kvm_vcpu *vcpu);
+        void (*set_nmi)(struct kvm_vcpu *vcpu);
         void (*queue_exception)(struct kvm_vcpu *vcpu, unsigned nr,
                                 bool has_error_code, u32 error_code);
-        bool (*exception_injected)(struct kvm_vcpu *vcpu);
-        void (*inject_pending_irq)(struct kvm_vcpu *vcpu);
-        void (*inject_pending_vectors)(struct kvm_vcpu *vcpu,
-                                       struct kvm_run *run);
-
+        int (*interrupt_allowed)(struct kvm_vcpu *vcpu);
+        int (*nmi_allowed)(struct kvm_vcpu *vcpu);
+        void (*enable_nmi_window)(struct kvm_vcpu *vcpu);
+        void (*enable_irq_window)(struct kvm_vcpu *vcpu);
+        void (*update_cr8_intercept)(struct kvm_vcpu *vcpu, int tpr, int irr);
         int (*set_tss_addr)(struct kvm *kvm, unsigned int addr);
         int (*get_tdp_level)(void);
-        int (*get_mt_mask_shift)(void);
+        u64 (*get_mt_mask)(struct kvm_vcpu *vcpu, gfn_t gfn, bool is_mmio);
 };
 
 extern struct kvm_x86_ops *kvm_x86_ops;
@@ -538,7 +539,7 @@ int kvm_mmu_setup(struct kvm_vcpu *vcpu);
 void kvm_mmu_set_nonpresent_ptes(u64 trap_pte, u64 notrap_pte);
 void kvm_mmu_set_base_ptes(u64 base_pte);
 void kvm_mmu_set_mask_ptes(u64 user_mask, u64 accessed_mask,
-                u64 dirty_mask, u64 nx_mask, u64 x_mask, u64 mt_mask);
+                u64 dirty_mask, u64 nx_mask, u64 x_mask);
 
 int kvm_mmu_reset_context(struct kvm_vcpu *vcpu);
 void kvm_mmu_slot_remove_write_access(struct kvm *kvm, int slot);
@@ -552,6 +553,7 @@ int emulator_write_phys(struct kvm_vcpu *vcpu, gpa_t gpa,
                           const void *val, int bytes);
 int kvm_pv_mmu_op(struct kvm_vcpu *vcpu, unsigned long bytes,
                   gpa_t addr, unsigned long *ret);
+u8 kvm_get_guest_memory_type(struct kvm_vcpu *vcpu, gfn_t gfn);
 
 extern bool tdp_enabled;
 
@@ -563,6 +565,7 @@ enum emulation_result {
 
 #define EMULTYPE_NO_DECODE          (1 << 0)
 #define EMULTYPE_TRAP_UD            (1 << 1)
+#define EMULTYPE_SKIP               (1 << 2)
 int emulate_instruction(struct kvm_vcpu *vcpu, struct kvm_run *run,
                         unsigned long cr2, u16 error_code, int emulation_type);
 void kvm_report_emulation_failure(struct kvm_vcpu *cvpu, const char *context);
@@ -638,7 +641,6 @@ void __kvm_mmu_free_some_pages(struct kvm_vcpu *vcpu);
 int kvm_mmu_load(struct kvm_vcpu *vcpu);
 void kvm_mmu_unload(struct kvm_vcpu *vcpu);
 void kvm_mmu_sync_roots(struct kvm_vcpu *vcpu);
-void kvm_mmu_sync_global(struct kvm_vcpu *vcpu);
 
 int kvm_emulate_hypercall(struct kvm_vcpu *vcpu);
 
@@ -769,6 +771,8 @@ enum {
 #define HF_GIF_MASK             (1 << 0)
 #define HF_HIF_MASK             (1 << 1)
 #define HF_VINTR_MASK           (1 << 2)
+#define HF_NMI_MASK             (1 << 3)
+#define HF_IRET_MASK            (1 << 4)
 
 /*
  * Hardware virtualization extension instructions may fault if a
@@ -791,5 +795,6 @@ asmlinkage void kvm_handle_fault_on_reboot(void);
 #define KVM_ARCH_WANT_MMU_NOTIFIER
 int kvm_unmap_hva(struct kvm *kvm, unsigned long hva);
 int kvm_age_hva(struct kvm *kvm, unsigned long hva);
+int cpuid_maxphyaddr(struct kvm_vcpu *vcpu);
 
 #endif /* _ASM_X86_KVM_HOST_H */
diff --git a/arch/x86/include/asm/kvm_x86_emulate.h b/arch/x86/include/asm/kvm_x86_emulate.h
index 6a159732881a..b7ed2c423116 100644
--- a/arch/x86/include/asm/kvm_x86_emulate.h
+++ b/arch/x86/include/asm/kvm_x86_emulate.h
@@ -143,6 +143,9 @@ struct decode_cache {
         struct fetch_cache fetch;
 };
 
+#define X86_SHADOW_INT_MOV_SS  1
+#define X86_SHADOW_INT_STI     2
+
 struct x86_emulate_ctxt {
         /* Register state before/after emulation. */
         struct kvm_vcpu *vcpu;
@@ -152,6 +155,9 @@ struct x86_emulate_ctxt {
         int mode;
         u32 cs_base;
 
+        /* interruptibility state, as a result of execution of STI or MOV SS */
+        int interruptibility;
+
         /* decode cache */
         struct decode_cache decode;
 };
diff --git a/arch/x86/include/asm/msr.h b/arch/x86/include/asm/msr.h
index 638bf6241807..22603764e7db 100644
--- a/arch/x86/include/asm/msr.h
+++ b/arch/x86/include/asm/msr.h
@@ -12,6 +12,17 @@
 
 #include <asm/asm.h>
 #include <asm/errno.h>
+#include <asm/cpumask.h>
+
+struct msr {
+        union {
+                struct {
+                        u32 l;
+                        u32 h;
+                };
+                u64 q;
+        };
+};
 
 static inline unsigned long long native_read_tscp(unsigned int *aux)
 {
@@ -216,6 +227,8 @@ do {                                                            \
 #ifdef CONFIG_SMP
 int rdmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h);
 int wrmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h);
+void rdmsr_on_cpus(const cpumask_t *mask, u32 msr_no, struct msr *msrs);
+void wrmsr_on_cpus(const cpumask_t *mask, u32 msr_no, struct msr *msrs);
 int rdmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h);
 int wrmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h);
 #else  /*  CONFIG_SMP  */
@@ -229,6 +242,16 @@ static inline int wrmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h)
         wrmsr(msr_no, l, h);
         return 0;
 }
+static inline void rdmsr_on_cpus(const cpumask_t *m, u32 msr_no,
+                                struct msr *msrs)
+{
+       rdmsr_on_cpu(0, msr_no, &(msrs[0].l), &(msrs[0].h));
+}
+static inline void wrmsr_on_cpus(const cpumask_t *m, u32 msr_no,
+                                struct msr *msrs)
+{
+       wrmsr_on_cpu(0, msr_no, msrs[0].l, msrs[0].h);
+}
 static inline int rdmsr_safe_on_cpu(unsigned int cpu, u32 msr_no,
                                     u32 *l, u32 *h)
 {
diff --git a/arch/x86/include/asm/svm.h b/arch/x86/include/asm/svm.h
index 82ada75f3ebf..85574b7c1bc1 100644
--- a/arch/x86/include/asm/svm.h
+++ b/arch/x86/include/asm/svm.h
@@ -225,6 +225,7 @@ struct __attribute__ ((__packed__)) vmcb {
 #define SVM_EVTINJ_VALID_ERR (1 << 11)
 
 #define SVM_EXITINTINFO_VEC_MASK SVM_EVTINJ_VEC_MASK
+#define SVM_EXITINTINFO_TYPE_MASK SVM_EVTINJ_TYPE_MASK
 
 #define SVM_EXITINTINFO_TYPE_INTR SVM_EVTINJ_TYPE_INTR
 #define SVM_EXITINTINFO_TYPE_NMI SVM_EVTINJ_TYPE_NMI
diff --git a/arch/x86/include/asm/termios.h b/arch/x86/include/asm/termios.h
index f72956331c49..c4ee8056baca 100644
--- a/arch/x86/include/asm/termios.h
+++ b/arch/x86/include/asm/termios.h
@@ -67,6 +67,7 @@ static inline int user_termio_to_kernel_termios(struct ktermios *termios,
         SET_LOW_TERMIOS_BITS(termios, termio, c_oflag);
         SET_LOW_TERMIOS_BITS(termios, termio, c_cflag);
         SET_LOW_TERMIOS_BITS(termios, termio, c_lflag);
+        get_user(termios->c_line, &termio->c_line);
         return copy_from_user(termios->c_cc, termio->c_cc, NCC);
 }
 
diff --git a/arch/x86/include/asm/vmx.h b/arch/x86/include/asm/vmx.h
index 498f944010b9..11be5ad2e0e9 100644
--- a/arch/x86/include/asm/vmx.h
+++ b/arch/x86/include/asm/vmx.h
@@ -247,6 +247,7 @@ enum vmcs_field {
 #define EXIT_REASON_MSR_READ            31
 #define EXIT_REASON_MSR_WRITE           32
 #define EXIT_REASON_MWAIT_INSTRUCTION   36
+#define EXIT_REASON_MCE_DURING_VMENTRY   41
 #define EXIT_REASON_TPR_BELOW_THRESHOLD 43
 #define EXIT_REASON_APIC_ACCESS         44
 #define EXIT_REASON_EPT_VIOLATION       48
diff --git a/arch/x86/kernel/cpu/mcheck/mce_64.c b/arch/x86/kernel/cpu/mcheck/mce_64.c
index 09dd1d414fc3..289cc4815028 100644
--- a/arch/x86/kernel/cpu/mcheck/mce_64.c
+++ b/arch/x86/kernel/cpu/mcheck/mce_64.c
@@ -420,6 +420,7 @@ void do_machine_check(struct pt_regs * regs, long error_code)
  out2:
         atomic_dec(&mce_entry);
 }
+EXPORT_SYMBOL_GPL(do_machine_check);
 
 #ifdef CONFIG_X86_MCE_INTEL
 /***
diff --git a/arch/x86/kernel/kvm.c b/arch/x86/kernel/kvm.c
index 6551dedee20c..a78ecad0c900 100644
--- a/arch/x86/kernel/kvm.c
+++ b/arch/x86/kernel/kvm.c
@@ -27,6 +27,7 @@
 #include <linux/mm.h>
 #include <linux/highmem.h>
 #include <linux/hardirq.h>
+#include <asm/timer.h>
 
 #define MMU_QUEUE_SIZE 1024
 
@@ -230,6 +231,9 @@ static void paravirt_ops_setup(void)
                 pv_mmu_ops.lazy_mode.enter = kvm_enter_lazy_mmu;
                 pv_mmu_ops.lazy_mode.leave = kvm_leave_lazy_mmu;
         }
+#ifdef CONFIG_X86_IO_APIC
+        no_timer_check = 1;
+#endif
 }
 
 void __init kvm_guest_init(void)
diff --git a/arch/x86/kernel/smp.c b/arch/x86/kernel/smp.c
index f6db48c405b8..28f5fb495a66 100644
--- a/arch/x86/kernel/smp.c
+++ b/arch/x86/kernel/smp.c
@@ -172,6 +172,9 @@ void smp_reschedule_interrupt(struct pt_regs *regs)
 {
         ack_APIC_irq();
         inc_irq_stat(irq_resched_count);
+        /*
+         * KVM uses this interrupt to force a cpu out of guest mode
+         */
 }
 
 void smp_call_function_interrupt(struct pt_regs *regs)
diff --git a/arch/x86/kvm/Kconfig b/arch/x86/kvm/Kconfig
index a58504ea78cc..8600a09e0c6c 100644
--- a/arch/x86/kvm/Kconfig
+++ b/arch/x86/kvm/Kconfig
@@ -50,6 +50,9 @@ config KVM_INTEL
           Provides support for KVM on Intel processors equipped with the VT
           extensions.
 
+          To compile this as a module, choose M here: the module
+          will be called kvm-intel.
+
 config KVM_AMD
         tristate "KVM for AMD processors support"
         depends on KVM
@@ -57,6 +60,9 @@ config KVM_AMD
           Provides support for KVM on AMD processors equipped with the AMD-V
           (SVM) extensions.
 
+          To compile this as a module, choose M here: the module
+          will be called kvm-amd.
+
 config KVM_TRACE
         bool "KVM trace support"
         depends on KVM && SYSFS
diff --git a/arch/x86/kvm/Makefile b/arch/x86/kvm/Makefile
index d3ec292f00f2..b43c4efafe80 100644
--- a/arch/x86/kvm/Makefile
+++ b/arch/x86/kvm/Makefile
@@ -14,7 +14,7 @@ endif
 EXTRA_CFLAGS += -Ivirt/kvm -Iarch/x86/kvm
 
 kvm-objs := $(common-objs) x86.o mmu.o x86_emulate.o i8259.o irq.o lapic.o \
-        i8254.o
+        i8254.o timer.o
 obj-$(CONFIG_KVM) += kvm.o
 kvm-intel-objs = vmx.o
 obj-$(CONFIG_KVM_INTEL) += kvm-intel.o
diff --git a/arch/x86/kvm/i8254.c b/arch/x86/kvm/i8254.c
index c13bb92d3157..4d6f0d293ee2 100644
--- a/arch/x86/kvm/i8254.c
+++ b/arch/x86/kvm/i8254.c
@@ -98,6 +98,37 @@ static int pit_get_gate(struct kvm *kvm, int channel)
         return kvm->arch.vpit->pit_state.channels[channel].gate;
 }
 
+static s64 __kpit_elapsed(struct kvm *kvm)
+{
+        s64 elapsed;
+        ktime_t remaining;
+        struct kvm_kpit_state *ps = &kvm->arch.vpit->pit_state;
+
+        /*
+         * The Counter does not stop when it reaches zero. In
+         * Modes 0, 1, 4, and 5 the Counter ``wraps around'' to
+         * the highest count, either FFFF hex for binary counting
+         * or 9999 for BCD counting, and continues counting.
+         * Modes 2 and 3 are periodic; the Counter reloads
+         * itself with the initial count and continues counting
+         * from there.
+         */
+        remaining = hrtimer_expires_remaining(&ps->pit_timer.timer);
+        elapsed = ps->pit_timer.period - ktime_to_ns(remaining);
+        elapsed = mod_64(elapsed, ps->pit_timer.period);
+
+        return elapsed;
+}
+
+static s64 kpit_elapsed(struct kvm *kvm, struct kvm_kpit_channel_state *c,
+                        int channel)
+{
+        if (channel == 0)
+                return __kpit_elapsed(kvm);
+
+        return ktime_to_ns(ktime_sub(ktime_get(), c->count_load_time));
+}
+
 static int pit_get_count(struct kvm *kvm, int channel)
 {
         struct kvm_kpit_channel_state *c =
@@ -107,7 +138,7 @@ static int pit_get_count(struct kvm *kvm, int channel)
 
         WARN_ON(!mutex_is_locked(&kvm->arch.vpit->pit_state.lock));
 
-        t = ktime_to_ns(ktime_sub(ktime_get(), c->count_load_time));
+        t = kpit_elapsed(kvm, c, channel);
         d = muldiv64(t, KVM_PIT_FREQ, NSEC_PER_SEC);
 
         switch (c->mode) {
@@ -137,7 +168,7 @@ static int pit_get_out(struct kvm *kvm, int channel)
 
         WARN_ON(!mutex_is_locked(&kvm->arch.vpit->pit_state.lock));
 
-        t = ktime_to_ns(ktime_sub(ktime_get(), c->count_load_time));
+        t = kpit_elapsed(kvm, c, channel);
         d = muldiv64(t, KVM_PIT_FREQ, NSEC_PER_SEC);
 
         switch (c->mode) {
@@ -193,28 +224,6 @@ static void pit_latch_status(struct kvm *kvm, int channel)
         }
 }
 
-static int __pit_timer_fn(struct kvm_kpit_state *ps)
-{
-        struct kvm_vcpu *vcpu0 = ps->pit->kvm->vcpus[0];
-        struct kvm_kpit_timer *pt = &ps->pit_timer;
-
-        if (!atomic_inc_and_test(&pt->pending))
-                set_bit(KVM_REQ_PENDING_TIMER, &vcpu0->requests);
-
-        if (!pt->reinject)
-                atomic_set(&pt->pending, 1);
-
-        if (vcpu0 && waitqueue_active(&vcpu0->wq))
-                wake_up_interruptible(&vcpu0->wq);
-
-        hrtimer_add_expires_ns(&pt->timer, pt->period);
-        pt->scheduled = hrtimer_get_expires_ns(&pt->timer);
-        if (pt->period)
-                ps->channels[0].count_load_time = ktime_get();
-
-        return (pt->period == 0 ? 0 : 1);
-}
-
 int pit_has_pending_timer(struct kvm_vcpu *vcpu)
 {
         struct kvm_pit *pit = vcpu->kvm->arch.vpit;
@@ -235,21 +244,6 @@ static void kvm_pit_ack_irq(struct kvm_irq_ack_notifier *kian)
         spin_unlock(&ps->inject_lock);
 }
 
-static enum hrtimer_restart pit_timer_fn(struct hrtimer *data)
-{
-        struct kvm_kpit_state *ps;
-        int restart_timer = 0;
-
-        ps = container_of(data, struct kvm_kpit_state, pit_timer.timer);
-
-        restart_timer = __pit_timer_fn(ps);
-
-        if (restart_timer)
-                return HRTIMER_RESTART;
-        else
-                return HRTIMER_NORESTART;
-}
-
 void __kvm_migrate_pit_timer(struct kvm_vcpu *vcpu)
 {
         struct kvm_pit *pit = vcpu->kvm->arch.vpit;
@@ -263,15 +257,26 @@ void __kvm_migrate_pit_timer(struct kvm_vcpu *vcpu)
                 hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
 }
 
-static void destroy_pit_timer(struct kvm_kpit_timer *pt)
+static void destroy_pit_timer(struct kvm_timer *pt)
 {
         pr_debug("pit: execute del timer!\n");
         hrtimer_cancel(&pt->timer);
 }
 
+static bool kpit_is_periodic(struct kvm_timer *ktimer)
+{
+        struct kvm_kpit_state *ps = container_of(ktimer, struct kvm_kpit_state,
+                                                 pit_timer);
+        return ps->is_periodic;
+}
+
+static struct kvm_timer_ops kpit_ops = {
+        .is_periodic = kpit_is_periodic,
+};
+
 static void create_pit_timer(struct kvm_kpit_state *ps, u32 val, int is_period)
 {
-        struct kvm_kpit_timer *pt = &ps->pit_timer;
+        struct kvm_timer *pt = &ps->pit_timer;
         s64 interval;
 
         interval = muldiv64(val, NSEC_PER_SEC, KVM_PIT_FREQ);
@@ -280,8 +285,14 @@ static void create_pit_timer(struct kvm_kpit_state *ps, u32 val, int is_period)
 
         /* TODO The new value only affected after the retriggered */
         hrtimer_cancel(&pt->timer);
-        pt->period = (is_period == 0) ? 0 : interval;
-        pt->timer.function = pit_timer_fn;
+        pt->period = interval;
+        ps->is_periodic = is_period;
+
+        pt->timer.function = kvm_timer_fn;
+        pt->t_ops = &kpit_ops;
+        pt->kvm = ps->pit->kvm;
+        pt->vcpu_id = 0;
+
         atomic_set(&pt->pending, 0);
         ps->irq_ack = 1;
 
@@ -298,23 +309,23 @@ static void pit_load_count(struct kvm *kvm, int channel, u32 val)
         pr_debug("pit: load_count val is %d, channel is %d\n", val, channel);
 
         /*
-         * Though spec said the state of 8254 is undefined after power-up,
-         * seems some tricky OS like Windows XP depends on IRQ0 interrupt
-         * when booting up.
-         * So here setting initialize rate for it, and not a specific number
+         * The largest possible initial count is 0; this is equivalent
+         * to 216 for binary counting and 104 for BCD counting.
          */
         if (val == 0)
                 val = 0x10000;
 
-        ps->channels[channel].count_load_time = ktime_get();
         ps->channels[channel].count = val;
 
-        if (channel != 0)
+        if (channel != 0) {
+                ps->channels[channel].count_load_time = ktime_get();
                 return;
+        }
 
         /* Two types of timer
          * mode 1 is one shot, mode 2 is period, otherwise del timer */
         switch (ps->channels[0].mode) {
+        case 0:
         case 1:
         /* FIXME: enhance mode 4 precision */
         case 4:
diff --git a/arch/x86/kvm/i8254.h b/arch/x86/kvm/i8254.h
index 6acbe4b505d5..bbd863ff60b7 100644
--- a/arch/x86/kvm/i8254.h
+++ b/arch/x86/kvm/i8254.h
@@ -3,15 +3,6 @@
 
 #include "iodev.h"
 
-struct kvm_kpit_timer {
-        struct hrtimer timer;
-        int irq;
-        s64 period; /* unit: ns */
-        s64 scheduled;
-        atomic_t pending;
-        bool reinject;
-};
-
 struct kvm_kpit_channel_state {
         u32 count; /* can be 65536 */
         u16 latched_count;
@@ -30,7 +21,8 @@ struct kvm_kpit_channel_state {
 
 struct kvm_kpit_state {
         struct kvm_kpit_channel_state channels[3];
-        struct kvm_kpit_timer pit_timer;
+        struct kvm_timer pit_timer;
+        bool is_periodic;
         u32    speaker_data_on;
         struct mutex lock;
         struct kvm_pit *pit;
diff --git a/arch/x86/kvm/irq.c b/arch/x86/kvm/irq.c
index cf17ed52f6fb..96dfbb6ad2a9 100644
--- a/arch/x86/kvm/irq.c
+++ b/arch/x86/kvm/irq.c
@@ -24,6 +24,7 @@
 
 #include "irq.h"
 #include "i8254.h"
+#include "x86.h"
 
 /*
  * check if there are pending timer events
@@ -48,6 +49,9 @@ int kvm_cpu_has_interrupt(struct kvm_vcpu *v)
 {
         struct kvm_pic *s;
 
+        if (!irqchip_in_kernel(v->kvm))
+                return v->arch.interrupt.pending;
+
         if (kvm_apic_has_interrupt(v) == -1) {  /* LAPIC */
                 if (kvm_apic_accept_pic_intr(v)) {
                         s = pic_irqchip(v->kvm);        /* PIC */
@@ -67,6 +71,9 @@ int kvm_cpu_get_interrupt(struct kvm_vcpu *v)
         struct kvm_pic *s;
         int vector;
 
+        if (!irqchip_in_kernel(v->kvm))
+                return v->arch.interrupt.nr;
+
         vector = kvm_get_apic_interrupt(v);     /* APIC */
         if (vector == -1) {
                 if (kvm_apic_accept_pic_intr(v)) {
diff --git a/arch/x86/kvm/kvm_timer.h b/arch/x86/kvm/kvm_timer.h
new file mode 100644
index 000000000000..26bd6ba74e1c
--- /dev/null
+++ b/arch/x86/kvm/kvm_timer.h
@@ -0,0 +1,18 @@
+
+struct kvm_timer {
+        struct hrtimer timer;
+        s64 period;                             /* unit: ns */
+        atomic_t pending;                       /* accumulated triggered timers */
+        bool reinject;
+        struct kvm_timer_ops *t_ops;
+        struct kvm *kvm;
+        int vcpu_id;
+};
+
+struct kvm_timer_ops {
+        bool (*is_periodic)(struct kvm_timer *);
+};
+
+
+enum hrtimer_restart kvm_timer_fn(struct hrtimer *data);
+
diff --git a/arch/x86/kvm/lapic.c b/arch/x86/kvm/lapic.c
index f0b67f2cdd69..ae99d83f81a3 100644
--- a/arch/x86/kvm/lapic.c
+++ b/arch/x86/kvm/lapic.c
@@ -196,20 +196,15 @@ int kvm_lapic_find_highest_irr(struct kvm_vcpu *vcpu)
 }
 EXPORT_SYMBOL_GPL(kvm_lapic_find_highest_irr);
 
-int kvm_apic_set_irq(struct kvm_vcpu *vcpu, u8 vec, u8 trig)
+static int __apic_accept_irq(struct kvm_lapic *apic, int delivery_mode,
+                             int vector, int level, int trig_mode);
+
+int kvm_apic_set_irq(struct kvm_vcpu *vcpu, struct kvm_lapic_irq *irq)
 {
         struct kvm_lapic *apic = vcpu->arch.apic;
 
-        if (!apic_test_and_set_irr(vec, apic)) {
-                /* a new pending irq is set in IRR */
-                if (trig)
-                        apic_set_vector(vec, apic->regs + APIC_TMR);
-                else
-                        apic_clear_vector(vec, apic->regs + APIC_TMR);
-                kvm_vcpu_kick(apic->vcpu);
-                return 1;
-        }
-        return 0;
+        return __apic_accept_irq(apic, irq->delivery_mode, irq->vector,
+                        irq->level, irq->trig_mode);
 }
 
 static inline int apic_find_highest_isr(struct kvm_lapic *apic)
@@ -250,7 +245,7 @@ static void apic_set_tpr(struct kvm_lapic *apic, u32 tpr)
 
 int kvm_apic_match_physical_addr(struct kvm_lapic *apic, u16 dest)
 {
-        return kvm_apic_id(apic) == dest;
+        return dest == 0xff || kvm_apic_id(apic) == dest;
 }
 
 int kvm_apic_match_logical_addr(struct kvm_lapic *apic, u8 mda)
@@ -279,37 +274,34 @@ int kvm_apic_match_logical_addr(struct kvm_lapic *apic, u8 mda)
         return result;
 }
 
-static int apic_match_dest(struct kvm_vcpu *vcpu, struct kvm_lapic *source,
+int kvm_apic_match_dest(struct kvm_vcpu *vcpu, struct kvm_lapic *source,
                            int short_hand, int dest, int dest_mode)
 {
         int result = 0;
         struct kvm_lapic *target = vcpu->arch.apic;
 
         apic_debug("target %p, source %p, dest 0x%x, "
-                   "dest_mode 0x%x, short_hand 0x%x",
+                   "dest_mode 0x%x, short_hand 0x%x\n",
                    target, source, dest, dest_mode, short_hand);
 
         ASSERT(!target);
         switch (short_hand) {
         case APIC_DEST_NOSHORT:
-                if (dest_mode == 0) {
+                if (dest_mode == 0)
                         /* Physical mode. */
-                        if ((dest == 0xFF) || (dest == kvm_apic_id(target)))
-                                result = 1;
-                } else
+                        result = kvm_apic_match_physical_addr(target, dest);
+                else
                         /* Logical mode. */
                         result = kvm_apic_match_logical_addr(target, dest);
                 break;
         case APIC_DEST_SELF:
-                if (target == source)
-                        result = 1;
+                result = (target == source);
                 break;
         case APIC_DEST_ALLINC:
                 result = 1;
                 break;
         case APIC_DEST_ALLBUT:
-                if (target != source)
-                        result = 1;
+                result = (target != source);
                 break;
         default:
                 printk(KERN_WARNING "Bad dest shorthand value %x\n",
@@ -327,20 +319,22 @@ static int apic_match_dest(struct kvm_vcpu *vcpu, struct kvm_lapic *source,
 static int __apic_accept_irq(struct kvm_lapic *apic, int delivery_mode,
                              int vector, int level, int trig_mode)
 {
-        int orig_irr, result = 0;
+        int result = 0;
         struct kvm_vcpu *vcpu = apic->vcpu;
 
         switch (delivery_mode) {
-        case APIC_DM_FIXED:
         case APIC_DM_LOWEST:
+                vcpu->arch.apic_arb_prio++;
+        case APIC_DM_FIXED:
                 /* FIXME add logic for vcpu on reset */
                 if (unlikely(!apic_enabled(apic)))
                         break;
 
-                orig_irr = apic_test_and_set_irr(vector, apic);
-                if (orig_irr && trig_mode) {
-                        apic_debug("level trig mode repeatedly for vector %d",
-                                   vector);
+                result = !apic_test_and_set_irr(vector, apic);
+                if (!result) {
+                        if (trig_mode)
+                                apic_debug("level trig mode repeatedly for "
+                                                "vector %d", vector);
                         break;
                 }
 
@@ -349,10 +343,7 @@ static int __apic_accept_irq(struct kvm_lapic *apic, int delivery_mode,
                         apic_set_vector(vector, apic->regs + APIC_TMR);
                 } else
                         apic_clear_vector(vector, apic->regs + APIC_TMR);
-
                 kvm_vcpu_kick(vcpu);
-
-                result = (orig_irr == 0);
                 break;
 
         case APIC_DM_REMRD:
@@ -364,12 +355,14 @@ static int __apic_accept_irq(struct kvm_lapic *apic, int delivery_mode,
                 break;
 
         case APIC_DM_NMI:
+                result = 1;
                 kvm_inject_nmi(vcpu);
                 kvm_vcpu_kick(vcpu);
                 break;
 
         case APIC_DM_INIT:
                 if (level) {
+                        result = 1;
                         if (vcpu->arch.mp_state == KVM_MP_STATE_RUNNABLE)
                                 printk(KERN_DEBUG
                                        "INIT on a runnable vcpu %d\n",
@@ -386,6 +379,7 @@ static int __apic_accept_irq(struct kvm_lapic *apic, int delivery_mode,
                 apic_debug("SIPI to vcpu %d vector 0x%02x\n",
                            vcpu->vcpu_id, vector);
                 if (vcpu->arch.mp_state == KVM_MP_STATE_INIT_RECEIVED) {
+                        result = 1;
                         vcpu->arch.sipi_vector = vector;
                         vcpu->arch.mp_state = KVM_MP_STATE_SIPI_RECEIVED;
                         kvm_vcpu_kick(vcpu);
@@ -408,43 +402,9 @@ static int __apic_accept_irq(struct kvm_lapic *apic, int delivery_mode,
         return result;
 }
 
-static struct kvm_lapic *kvm_apic_round_robin(struct kvm *kvm, u8 vector,
-                                       unsigned long bitmap)
-{
-        int last;
-        int next;
-        struct kvm_lapic *apic = NULL;
-
-        last = kvm->arch.round_robin_prev_vcpu;
-        next = last;
-
-        do {
-                if (++next == KVM_MAX_VCPUS)
-                        next = 0;
-                if (kvm->vcpus[next] == NULL || !test_bit(next, &bitmap))
-                        continue;
-                apic = kvm->vcpus[next]->arch.apic;
-                if (apic && apic_enabled(apic))
-                        break;
-                apic = NULL;
-        } while (next != last);
-        kvm->arch.round_robin_prev_vcpu = next;
-
-        if (!apic)
-                printk(KERN_DEBUG "vcpu not ready for apic_round_robin\n");
-
-        return apic;
-}
-
-struct kvm_vcpu *kvm_get_lowest_prio_vcpu(struct kvm *kvm, u8 vector,
-                unsigned long bitmap)
+int kvm_apic_compare_prio(struct kvm_vcpu *vcpu1, struct kvm_vcpu *vcpu2)
 {
-        struct kvm_lapic *apic;
-
-        apic = kvm_apic_round_robin(kvm, vector, bitmap);
-        if (apic)
-                return apic->vcpu;
-        return NULL;
+        return vcpu1->arch.apic_arb_prio - vcpu2->arch.apic_arb_prio;
 }
 
 static void apic_set_eoi(struct kvm_lapic *apic)
@@ -472,47 +432,24 @@ static void apic_send_ipi(struct kvm_lapic *apic)
 {
         u32 icr_low = apic_get_reg(apic, APIC_ICR);
         u32 icr_high = apic_get_reg(apic, APIC_ICR2);
+        struct kvm_lapic_irq irq;
 
-        unsigned int dest = GET_APIC_DEST_FIELD(icr_high);
-        unsigned int short_hand = icr_low & APIC_SHORT_MASK;
-        unsigned int trig_mode = icr_low & APIC_INT_LEVELTRIG;
-        unsigned int level = icr_low & APIC_INT_ASSERT;
-        unsigned int dest_mode = icr_low & APIC_DEST_MASK;
-        unsigned int delivery_mode = icr_low & APIC_MODE_MASK;
-        unsigned int vector = icr_low & APIC_VECTOR_MASK;
-
-        struct kvm_vcpu *target;
-        struct kvm_vcpu *vcpu;
-        unsigned long lpr_map = 0;
-        int i;
+        irq.vector = icr_low & APIC_VECTOR_MASK;
+        irq.delivery_mode = icr_low & APIC_MODE_MASK;
+        irq.dest_mode = icr_low & APIC_DEST_MASK;
+        irq.level = icr_low & APIC_INT_ASSERT;
+        irq.trig_mode = icr_low & APIC_INT_LEVELTRIG;
+        irq.shorthand = icr_low & APIC_SHORT_MASK;
+        irq.dest_id = GET_APIC_DEST_FIELD(icr_high);
 
         apic_debug("icr_high 0x%x, icr_low 0x%x, "
                    "short_hand 0x%x, dest 0x%x, trig_mode 0x%x, level 0x%x, "
                    "dest_mode 0x%x, delivery_mode 0x%x, vector 0x%x\n",
-                   icr_high, icr_low, short_hand, dest,
-                   trig_mode, level, dest_mode, delivery_mode, vector);
-
-        for (i = 0; i < KVM_MAX_VCPUS; i++) {
-                vcpu = apic->vcpu->kvm->vcpus[i];
-                if (!vcpu)
-                        continue;
-
-                if (vcpu->arch.apic &&
-                    apic_match_dest(vcpu, apic, short_hand, dest, dest_mode)) {
-                        if (delivery_mode == APIC_DM_LOWEST)
-                                set_bit(vcpu->vcpu_id, &lpr_map);
-                        else
-                                __apic_accept_irq(vcpu->arch.apic, delivery_mode,
-                                                  vector, level, trig_mode);
-                }
-        }
+                   icr_high, icr_low, irq.shorthand, irq.dest_id,
+                   irq.trig_mode, irq.level, irq.dest_mode, irq.delivery_mode,
+                   irq.vector);
 
-        if (delivery_mode == APIC_DM_LOWEST) {
-                target = kvm_get_lowest_prio_vcpu(vcpu->kvm, vector, lpr_map);
-                if (target != NULL)
-                        __apic_accept_irq(target->arch.apic, delivery_mode,
-                                          vector, level, trig_mode);
-        }
+        kvm_irq_delivery_to_apic(apic->vcpu->kvm, apic, &irq);
 }
 
 static u32 apic_get_tmcct(struct kvm_lapic *apic)
@@ -527,12 +464,13 @@ static u32 apic_get_tmcct(struct kvm_lapic *apic)
         if (apic_get_reg(apic, APIC_TMICT) == 0)
                 return 0;
 
-        remaining = hrtimer_expires_remaining(&apic->timer.dev);
+        remaining = hrtimer_expires_remaining(&apic->lapic_timer.timer);
         if (ktime_to_ns(remaining) < 0)
                 remaining = ktime_set(0, 0);
 
-        ns = mod_64(ktime_to_ns(remaining), apic->timer.period);
-        tmcct = div64_u64(ns, (APIC_BUS_CYCLE_NS * apic->timer.divide_count));
+        ns = mod_64(ktime_to_ns(remaining), apic->lapic_timer.period);
+        tmcct = div64_u64(ns,
+                         (APIC_BUS_CYCLE_NS * apic->divide_count));
 
         return tmcct;
 }
@@ -619,25 +557,25 @@ static void update_divide_count(struct kvm_lapic *apic)
         tdcr = apic_get_reg(apic, APIC_TDCR);
         tmp1 = tdcr & 0xf;
         tmp2 = ((tmp1 & 0x3) | ((tmp1 & 0x8) >> 1)) + 1;
-        apic->timer.divide_count = 0x1 << (tmp2 & 0x7);
+        apic->divide_count = 0x1 << (tmp2 & 0x7);
 
         apic_debug("timer divide count is 0x%x\n",
-                                   apic->timer.divide_count);
+                                   apic->divide_count);
 }
 
 static void start_apic_timer(struct kvm_lapic *apic)
 {
-        ktime_t now = apic->timer.dev.base->get_time();
+        ktime_t now = apic->lapic_timer.timer.base->get_time();
 
-        apic->timer.period = apic_get_reg(apic, APIC_TMICT) *
-                    APIC_BUS_CYCLE_NS * apic->timer.divide_count;
-        atomic_set(&apic->timer.pending, 0);
+        apic->lapic_timer.period = apic_get_reg(apic, APIC_TMICT) *
+                    APIC_BUS_CYCLE_NS * apic->divide_count;
+        atomic_set(&apic->lapic_timer.pending, 0);
 
-        if (!apic->timer.period)
+        if (!apic->lapic_timer.period)
                 return;
 
-        hrtimer_start(&apic->timer.dev,
-                      ktime_add_ns(now, apic->timer.period),
+        hrtimer_start(&apic->lapic_timer.timer,
+                      ktime_add_ns(now, apic->lapic_timer.period),
                       HRTIMER_MODE_ABS);
 
         apic_debug("%s: bus cycle is %" PRId64 "ns, now 0x%016"
@@ -646,9 +584,9 @@ static void start_apic_timer(struct kvm_lapic *apic)
                            "expire @ 0x%016" PRIx64 ".\n", __func__,
                            APIC_BUS_CYCLE_NS, ktime_to_ns(now),
                            apic_get_reg(apic, APIC_TMICT),
-                           apic->timer.period,
+                           apic->lapic_timer.period,
                            ktime_to_ns(ktime_add_ns(now,
-                                        apic->timer.period)));
+                                        apic->lapic_timer.period)));
 }
 
 static void apic_manage_nmi_watchdog(struct kvm_lapic *apic, u32 lvt0_val)
@@ -730,7 +668,7 @@ static void apic_mmio_write(struct kvm_io_device *this,
                                 apic_set_reg(apic, APIC_LVTT + 0x10 * i,
                                              lvt_val | APIC_LVT_MASKED);
                         }
-                        atomic_set(&apic->timer.pending, 0);
+                        atomic_set(&apic->lapic_timer.pending, 0);
 
                 }
                 break;
@@ -762,7 +700,7 @@ static void apic_mmio_write(struct kvm_io_device *this,
                 break;
 
         case APIC_TMICT:
-                hrtimer_cancel(&apic->timer.dev);
+                hrtimer_cancel(&apic->lapic_timer.timer);
                 apic_set_reg(apic, APIC_TMICT, val);
                 start_apic_timer(apic);
                 return;
@@ -802,7 +740,7 @@ void kvm_free_lapic(struct kvm_vcpu *vcpu)
         if (!vcpu->arch.apic)
                 return;
 
-        hrtimer_cancel(&vcpu->arch.apic->timer.dev);
+        hrtimer_cancel(&vcpu->arch.apic->lapic_timer.timer);
 
         if (vcpu->arch.apic->regs_page)
                 __free_page(vcpu->arch.apic->regs_page);
@@ -880,7 +818,7 @@ void kvm_lapic_reset(struct kvm_vcpu *vcpu)
         ASSERT(apic != NULL);
 
         /* Stop the timer in case it's a reset to an active apic */
-        hrtimer_cancel(&apic->timer.dev);
+        hrtimer_cancel(&apic->lapic_timer.timer);
 
         apic_set_reg(apic, APIC_ID, vcpu->vcpu_id << 24);
         apic_set_reg(apic, APIC_LVR, APIC_VERSION);
@@ -905,11 +843,13 @@ void kvm_lapic_reset(struct kvm_vcpu *vcpu)
                 apic_set_reg(apic, APIC_TMR + 0x10 * i, 0);
         }
         update_divide_count(apic);
-        atomic_set(&apic->timer.pending, 0);
+        atomic_set(&apic->lapic_timer.pending, 0);
         if (vcpu->vcpu_id == 0)
                 vcpu->arch.apic_base |= MSR_IA32_APICBASE_BSP;
         apic_update_ppr(apic);
 
+        vcpu->arch.apic_arb_prio = 0;
+
         apic_debug(KERN_INFO "%s: vcpu=%p, id=%d, base_msr="
                    "0x%016" PRIx64 ", base_address=0x%0lx.\n", __func__,
                    vcpu, kvm_apic_id(apic),
@@ -917,16 +857,14 @@ void kvm_lapic_reset(struct kvm_vcpu *vcpu)
 }
 EXPORT_SYMBOL_GPL(kvm_lapic_reset);
 
-int kvm_lapic_enabled(struct kvm_vcpu *vcpu)
+bool kvm_apic_present(struct kvm_vcpu *vcpu)
 {
-        struct kvm_lapic *apic = vcpu->arch.apic;
-        int ret = 0;
-
-        if (!apic)
-                return 0;
-        ret = apic_enabled(apic);
+        return vcpu->arch.apic && apic_hw_enabled(vcpu->arch.apic);
+}
 
-        return ret;
+int kvm_lapic_enabled(struct kvm_vcpu *vcpu)
+{
+        return kvm_apic_present(vcpu) && apic_sw_enabled(vcpu->arch.apic);
 }
 EXPORT_SYMBOL_GPL(kvm_lapic_enabled);
 
@@ -936,22 +874,11 @@ EXPORT_SYMBOL_GPL(kvm_lapic_enabled);
  *----------------------------------------------------------------------
  */
 
-/* TODO: make sure __apic_timer_fn runs in current pCPU */
-static int __apic_timer_fn(struct kvm_lapic *apic)
+static bool lapic_is_periodic(struct kvm_timer *ktimer)
 {
-        int result = 0;
-        wait_queue_head_t *q = &apic->vcpu->wq;
-
-        if(!atomic_inc_and_test(&apic->timer.pending))
-                set_bit(KVM_REQ_PENDING_TIMER, &apic->vcpu->requests);
-        if (waitqueue_active(q))
-                wake_up_interruptible(q);
-
-        if (apic_lvtt_period(apic)) {
-                result = 1;
-                hrtimer_add_expires_ns(&apic->timer.dev, apic->timer.period);
-        }
-        return result;
+        struct kvm_lapic *apic = container_of(ktimer, struct kvm_lapic,
+                                              lapic_timer);
+        return apic_lvtt_period(apic);
 }
 
 int apic_has_pending_timer(struct kvm_vcpu *vcpu)
@@ -959,7 +886,7 @@ int apic_has_pending_timer(struct kvm_vcpu *vcpu)
         struct kvm_lapic *lapic = vcpu->arch.apic;
 
         if (lapic && apic_enabled(lapic) && apic_lvt_enabled(lapic, APIC_LVTT))
-                return atomic_read(&lapic->timer.pending);
+                return atomic_read(&lapic->lapic_timer.pending);
 
         return 0;
 }
@@ -986,20 +913,9 @@ void kvm_apic_nmi_wd_deliver(struct kvm_vcpu *vcpu)
                 kvm_apic_local_deliver(apic, APIC_LVT0);
 }
 
-static enum hrtimer_restart apic_timer_fn(struct hrtimer *data)
-{
-        struct kvm_lapic *apic;
-        int restart_timer = 0;
-
-        apic = container_of(data, struct kvm_lapic, timer.dev);
-
-        restart_timer = __apic_timer_fn(apic);
-
-        if (restart_timer)
-                return HRTIMER_RESTART;
-        else
-                return HRTIMER_NORESTART;
-}
+static struct kvm_timer_ops lapic_timer_ops = {
+        .is_periodic = lapic_is_periodic,
+};
 
 int kvm_create_lapic(struct kvm_vcpu *vcpu)
 {
@@ -1024,8 +940,13 @@ int kvm_create_lapic(struct kvm_vcpu *vcpu)
         memset(apic->regs, 0, PAGE_SIZE);
         apic->vcpu = vcpu;
 
-        hrtimer_init(&apic->timer.dev, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
-        apic->timer.dev.function = apic_timer_fn;
+        hrtimer_init(&apic->lapic_timer.timer, CLOCK_MONOTONIC,
+                     HRTIMER_MODE_ABS);
+        apic->lapic_timer.timer.function = kvm_timer_fn;
+        apic->lapic_timer.t_ops = &lapic_timer_ops;
+        apic->lapic_timer.kvm = vcpu->kvm;
+        apic->lapic_timer.vcpu_id = vcpu->vcpu_id;
+
         apic->base_address = APIC_DEFAULT_PHYS_BASE;
         vcpu->arch.apic_base = APIC_DEFAULT_PHYS_BASE;
 
@@ -1078,9 +999,9 @@ void kvm_inject_apic_timer_irqs(struct kvm_vcpu *vcpu)
 {
         struct kvm_lapic *apic = vcpu->arch.apic;
 
-        if (apic && atomic_read(&apic->timer.pending) > 0) {
+        if (apic && atomic_read(&apic->lapic_timer.pending) > 0) {
                 if (kvm_apic_local_deliver(apic, APIC_LVTT))
-                        atomic_dec(&apic->timer.pending);
+                        atomic_dec(&apic->lapic_timer.pending);
         }
 }
 
@@ -1106,7 +1027,7 @@ void kvm_apic_post_state_restore(struct kvm_vcpu *vcpu)
                              MSR_IA32_APICBASE_BASE;
         apic_set_reg(apic, APIC_LVR, APIC_VERSION);
         apic_update_ppr(apic);
-        hrtimer_cancel(&apic->timer.dev);
+        hrtimer_cancel(&apic->lapic_timer.timer);
         update_divide_count(apic);
         start_apic_timer(apic);
 }
@@ -1119,7 +1040,7 @@ void __kvm_migrate_apic_timer(struct kvm_vcpu *vcpu)
         if (!apic)
                 return;
 
-        timer = &apic->timer.dev;
+        timer = &apic->lapic_timer.timer;
         if (hrtimer_cancel(timer))
                 hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
 }
diff --git a/arch/x86/kvm/lapic.h b/arch/x86/kvm/lapic.h
index 45ab6ee71209..a587f8349c46 100644
--- a/arch/x86/kvm/lapic.h
+++ b/arch/x86/kvm/lapic.h
@@ -2,18 +2,15 @@
 #define __KVM_X86_LAPIC_H
 
 #include "iodev.h"
+#include "kvm_timer.h"
 
 #include <linux/kvm_host.h>
 
 struct kvm_lapic {
         unsigned long base_address;
         struct kvm_io_device dev;
-        struct {
-                atomic_t pending;
-                s64 period;     /* unit: ns */
-                u32 divide_count;
-                struct hrtimer dev;
-        } timer;
+        struct kvm_timer lapic_timer;
+        u32 divide_count;
         struct kvm_vcpu *vcpu;
         struct page *regs_page;
         void *regs;
@@ -34,12 +31,13 @@ u64 kvm_lapic_get_base(struct kvm_vcpu *vcpu);
 
 int kvm_apic_match_physical_addr(struct kvm_lapic *apic, u16 dest);
 int kvm_apic_match_logical_addr(struct kvm_lapic *apic, u8 mda);
-int kvm_apic_set_irq(struct kvm_vcpu *vcpu, u8 vec, u8 trig);
+int kvm_apic_set_irq(struct kvm_vcpu *vcpu, struct kvm_lapic_irq *irq);
 
 u64 kvm_get_apic_base(struct kvm_vcpu *vcpu);
 void kvm_set_apic_base(struct kvm_vcpu *vcpu, u64 data);
 void kvm_apic_post_state_restore(struct kvm_vcpu *vcpu);
 int kvm_lapic_enabled(struct kvm_vcpu *vcpu);
+bool kvm_apic_present(struct kvm_vcpu *vcpu);
 int kvm_lapic_find_highest_irr(struct kvm_vcpu *vcpu);
 
 void kvm_lapic_set_vapic_addr(struct kvm_vcpu *vcpu, gpa_t vapic_addr);
diff --git a/arch/x86/kvm/mmu.c b/arch/x86/kvm/mmu.c
index 32cf11e5728a..5c3d6e81a7dc 100644
--- a/arch/x86/kvm/mmu.c
+++ b/arch/x86/kvm/mmu.c
@@ -126,6 +126,7 @@ module_param(oos_shadow, bool, 0644);
 #define PFERR_PRESENT_MASK (1U << 0)
 #define PFERR_WRITE_MASK (1U << 1)
 #define PFERR_USER_MASK (1U << 2)
+#define PFERR_RSVD_MASK (1U << 3)
 #define PFERR_FETCH_MASK (1U << 4)
 
 #define PT_DIRECTORY_LEVEL 2
@@ -177,7 +178,11 @@ static u64 __read_mostly shadow_x_mask;	/* mutual exclusive with nx_mask */
 static u64 __read_mostly shadow_user_mask;
 static u64 __read_mostly shadow_accessed_mask;
 static u64 __read_mostly shadow_dirty_mask;
-static u64 __read_mostly shadow_mt_mask;
+
+static inline u64 rsvd_bits(int s, int e)
+{
+        return ((1ULL << (e - s + 1)) - 1) << s;
+}
 
 void kvm_mmu_set_nonpresent_ptes(u64 trap_pte, u64 notrap_pte)
 {
@@ -193,14 +198,13 @@ void kvm_mmu_set_base_ptes(u64 base_pte)
 EXPORT_SYMBOL_GPL(kvm_mmu_set_base_ptes);
 
 void kvm_mmu_set_mask_ptes(u64 user_mask, u64 accessed_mask,
-                u64 dirty_mask, u64 nx_mask, u64 x_mask, u64 mt_mask)
+                u64 dirty_mask, u64 nx_mask, u64 x_mask)
 {
         shadow_user_mask = user_mask;
         shadow_accessed_mask = accessed_mask;
         shadow_dirty_mask = dirty_mask;
         shadow_nx_mask = nx_mask;
         shadow_x_mask = x_mask;
-        shadow_mt_mask = mt_mask;
 }
 EXPORT_SYMBOL_GPL(kvm_mmu_set_mask_ptes);
 
@@ -219,11 +223,6 @@ static int is_nx(struct kvm_vcpu *vcpu)
         return vcpu->arch.shadow_efer & EFER_NX;
 }
 
-static int is_present_pte(unsigned long pte)
-{
-        return pte & PT_PRESENT_MASK;
-}
-
 static int is_shadow_present_pte(u64 pte)
 {
         return pte != shadow_trap_nonpresent_pte
@@ -1074,18 +1073,10 @@ static struct kvm_mmu_page *kvm_mmu_lookup_page(struct kvm *kvm, gfn_t gfn)
         return NULL;
 }
 
-static void kvm_unlink_unsync_global(struct kvm *kvm, struct kvm_mmu_page *sp)
-{
-        list_del(&sp->oos_link);
-        --kvm->stat.mmu_unsync_global;
-}
-
 static void kvm_unlink_unsync_page(struct kvm *kvm, struct kvm_mmu_page *sp)
 {
         WARN_ON(!sp->unsync);
         sp->unsync = 0;
-        if (sp->global)
-                kvm_unlink_unsync_global(kvm, sp);
         --kvm->stat.mmu_unsync;
 }
 
@@ -1248,7 +1239,6 @@ static struct kvm_mmu_page *kvm_mmu_get_page(struct kvm_vcpu *vcpu,
         pgprintk("%s: adding gfn %lx role %x\n", __func__, gfn, role.word);
         sp->gfn = gfn;
         sp->role = role;
-        sp->global = 0;
         hlist_add_head(&sp->hash_link, bucket);
         if (!direct) {
                 if (rmap_write_protect(vcpu->kvm, gfn))
@@ -1616,7 +1606,7 @@ static int get_mtrr_type(struct mtrr_state_type *mtrr_state,
         return mtrr_state->def_type;
 }
 
-static u8 get_memory_type(struct kvm_vcpu *vcpu, gfn_t gfn)
+u8 kvm_get_guest_memory_type(struct kvm_vcpu *vcpu, gfn_t gfn)
 {
         u8 mtrr;
 
@@ -1626,6 +1616,7 @@ static u8 get_memory_type(struct kvm_vcpu *vcpu, gfn_t gfn)
                 mtrr = MTRR_TYPE_WRBACK;
         return mtrr;
 }
+EXPORT_SYMBOL_GPL(kvm_get_guest_memory_type);
 
 static int kvm_unsync_page(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp)
 {
@@ -1646,11 +1637,7 @@ static int kvm_unsync_page(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp)
         ++vcpu->kvm->stat.mmu_unsync;
         sp->unsync = 1;
 
-        if (sp->global) {
-                list_add(&sp->oos_link, &vcpu->kvm->arch.oos_global_pages);
-                ++vcpu->kvm->stat.mmu_unsync_global;
-        } else
-                kvm_mmu_mark_parents_unsync(vcpu, sp);
+        kvm_mmu_mark_parents_unsync(vcpu, sp);
 
         mmu_convert_notrap(sp);
         return 0;
@@ -1677,21 +1664,11 @@ static int mmu_need_write_protect(struct kvm_vcpu *vcpu, gfn_t gfn,
 static int set_spte(struct kvm_vcpu *vcpu, u64 *shadow_pte,
                     unsigned pte_access, int user_fault,
                     int write_fault, int dirty, int largepage,
-                    int global, gfn_t gfn, pfn_t pfn, bool speculative,
+                    gfn_t gfn, pfn_t pfn, bool speculative,
                     bool can_unsync)
 {
         u64 spte;
         int ret = 0;
-        u64 mt_mask = shadow_mt_mask;
-        struct kvm_mmu_page *sp = page_header(__pa(shadow_pte));
-
-        if (!global && sp->global) {
-                sp->global = 0;
-                if (sp->unsync) {
-                        kvm_unlink_unsync_global(vcpu->kvm, sp);
-                        kvm_mmu_mark_parents_unsync(vcpu, sp);
-                }
-        }
 
         /*
          * We don't set the accessed bit, since we sometimes want to see
@@ -1711,16 +1688,9 @@ static int set_spte(struct kvm_vcpu *vcpu, u64 *shadow_pte,
                 spte |= shadow_user_mask;
         if (largepage)
                 spte |= PT_PAGE_SIZE_MASK;
-        if (mt_mask) {
-                if (!kvm_is_mmio_pfn(pfn)) {
-                        mt_mask = get_memory_type(vcpu, gfn) <<
-                                kvm_x86_ops->get_mt_mask_shift();
-                        mt_mask |= VMX_EPT_IGMT_BIT;
-                } else
-                        mt_mask = MTRR_TYPE_UNCACHABLE <<
-                                kvm_x86_ops->get_mt_mask_shift();
-                spte |= mt_mask;
-        }
+        if (tdp_enabled)
+                spte |= kvm_x86_ops->get_mt_mask(vcpu, gfn,
+                        kvm_is_mmio_pfn(pfn));
 
         spte |= (u64)pfn << PAGE_SHIFT;
 
@@ -1765,8 +1735,8 @@ set_pte:
 static void mmu_set_spte(struct kvm_vcpu *vcpu, u64 *shadow_pte,
                          unsigned pt_access, unsigned pte_access,
                          int user_fault, int write_fault, int dirty,
-                         int *ptwrite, int largepage, int global,
-                         gfn_t gfn, pfn_t pfn, bool speculative)
+                         int *ptwrite, int largepage, gfn_t gfn,
+                         pfn_t pfn, bool speculative)
 {
         int was_rmapped = 0;
         int was_writeble = is_writeble_pte(*shadow_pte);
@@ -1795,7 +1765,7 @@ static void mmu_set_spte(struct kvm_vcpu *vcpu, u64 *shadow_pte,
                         was_rmapped = 1;
         }
         if (set_spte(vcpu, shadow_pte, pte_access, user_fault, write_fault,
-                      dirty, largepage, global, gfn, pfn, speculative, true)) {
+                      dirty, largepage, gfn, pfn, speculative, true)) {
                 if (write_fault)
                         *ptwrite = 1;
                 kvm_x86_ops->tlb_flush(vcpu);
@@ -1843,7 +1813,7 @@ static int __direct_map(struct kvm_vcpu *vcpu, gpa_t v, int write,
                     || (largepage && iterator.level == PT_DIRECTORY_LEVEL)) {
                         mmu_set_spte(vcpu, iterator.sptep, ACC_ALL, ACC_ALL,
                                      0, write, 1, &pt_write,
-                                     largepage, 0, gfn, pfn, false);
+                                     largepage, gfn, pfn, false);
                         ++vcpu->stat.pf_fixed;
                         break;
                 }
@@ -1942,7 +1912,19 @@ static void mmu_free_roots(struct kvm_vcpu *vcpu)
         vcpu->arch.mmu.root_hpa = INVALID_PAGE;
 }
 
-static void mmu_alloc_roots(struct kvm_vcpu *vcpu)
+static int mmu_check_root(struct kvm_vcpu *vcpu, gfn_t root_gfn)
+{
+        int ret = 0;
+
+        if (!kvm_is_visible_gfn(vcpu->kvm, root_gfn)) {
+                set_bit(KVM_REQ_TRIPLE_FAULT, &vcpu->requests);
+                ret = 1;
+        }
+
+        return ret;
+}
+
+static int mmu_alloc_roots(struct kvm_vcpu *vcpu)
 {
         int i;
         gfn_t root_gfn;
@@ -1957,13 +1939,15 @@ static void mmu_alloc_roots(struct kvm_vcpu *vcpu)
                 ASSERT(!VALID_PAGE(root));
                 if (tdp_enabled)
                         direct = 1;
+                if (mmu_check_root(vcpu, root_gfn))
+                        return 1;
                 sp = kvm_mmu_get_page(vcpu, root_gfn, 0,
                                       PT64_ROOT_LEVEL, direct,
                                       ACC_ALL, NULL);
                 root = __pa(sp->spt);
                 ++sp->root_count;
                 vcpu->arch.mmu.root_hpa = root;
-                return;
+                return 0;
         }
         direct = !is_paging(vcpu);
         if (tdp_enabled)
@@ -1980,6 +1964,8 @@ static void mmu_alloc_roots(struct kvm_vcpu *vcpu)
                         root_gfn = vcpu->arch.pdptrs[i] >> PAGE_SHIFT;
                 } else if (vcpu->arch.mmu.root_level == 0)
                         root_gfn = 0;
+                if (mmu_check_root(vcpu, root_gfn))
+                        return 1;
                 sp = kvm_mmu_get_page(vcpu, root_gfn, i << 30,
                                       PT32_ROOT_LEVEL, direct,
                                       ACC_ALL, NULL);
@@ -1988,6 +1974,7 @@ static void mmu_alloc_roots(struct kvm_vcpu *vcpu)
                 vcpu->arch.mmu.pae_root[i] = root | PT_PRESENT_MASK;
         }
         vcpu->arch.mmu.root_hpa = __pa(vcpu->arch.mmu.pae_root);
+        return 0;
 }
 
 static void mmu_sync_roots(struct kvm_vcpu *vcpu)
@@ -2006,7 +1993,7 @@ static void mmu_sync_roots(struct kvm_vcpu *vcpu)
         for (i = 0; i < 4; ++i) {
                 hpa_t root = vcpu->arch.mmu.pae_root[i];
 
-                if (root) {
+                if (root && VALID_PAGE(root)) {
                         root &= PT64_BASE_ADDR_MASK;
                         sp = page_header(root);
                         mmu_sync_children(vcpu, sp);
@@ -2014,15 +2001,6 @@ static void mmu_sync_roots(struct kvm_vcpu *vcpu)
         }
 }
 
-static void mmu_sync_global(struct kvm_vcpu *vcpu)
-{
-        struct kvm *kvm = vcpu->kvm;
-        struct kvm_mmu_page *sp, *n;
-
-        list_for_each_entry_safe(sp, n, &kvm->arch.oos_global_pages, oos_link)
-                kvm_sync_page(vcpu, sp);
-}
-
 void kvm_mmu_sync_roots(struct kvm_vcpu *vcpu)
 {
         spin_lock(&vcpu->kvm->mmu_lock);
@@ -2030,13 +2008,6 @@ void kvm_mmu_sync_roots(struct kvm_vcpu *vcpu)
         spin_unlock(&vcpu->kvm->mmu_lock);
 }
 
-void kvm_mmu_sync_global(struct kvm_vcpu *vcpu)
-{
-        spin_lock(&vcpu->kvm->mmu_lock);
-        mmu_sync_global(vcpu);
-        spin_unlock(&vcpu->kvm->mmu_lock);
-}
-
 static gpa_t nonpaging_gva_to_gpa(struct kvm_vcpu *vcpu, gva_t vaddr)
 {
         return vaddr;
@@ -2151,6 +2122,14 @@ static void paging_free(struct kvm_vcpu *vcpu)
         nonpaging_free(vcpu);
 }
 
+static bool is_rsvd_bits_set(struct kvm_vcpu *vcpu, u64 gpte, int level)
+{
+        int bit7;
+
+        bit7 = (gpte >> 7) & 1;
+        return (gpte & vcpu->arch.mmu.rsvd_bits_mask[bit7][level-1]) != 0;
+}
+
 #define PTTYPE 64
 #include "paging_tmpl.h"
 #undef PTTYPE
@@ -2159,6 +2138,59 @@ static void paging_free(struct kvm_vcpu *vcpu)
 #include "paging_tmpl.h"
 #undef PTTYPE
 
+static void reset_rsvds_bits_mask(struct kvm_vcpu *vcpu, int level)
+{
+        struct kvm_mmu *context = &vcpu->arch.mmu;
+        int maxphyaddr = cpuid_maxphyaddr(vcpu);
+        u64 exb_bit_rsvd = 0;
+
+        if (!is_nx(vcpu))
+                exb_bit_rsvd = rsvd_bits(63, 63);
+        switch (level) {
+        case PT32_ROOT_LEVEL:
+                /* no rsvd bits for 2 level 4K page table entries */
+                context->rsvd_bits_mask[0][1] = 0;
+                context->rsvd_bits_mask[0][0] = 0;
+                if (is_cpuid_PSE36())
+                        /* 36bits PSE 4MB page */
+                        context->rsvd_bits_mask[1][1] = rsvd_bits(17, 21);
+                else
+                        /* 32 bits PSE 4MB page */
+                        context->rsvd_bits_mask[1][1] = rsvd_bits(13, 21);
+                context->rsvd_bits_mask[1][0] = ~0ull;
+                break;
+        case PT32E_ROOT_LEVEL:
+                context->rsvd_bits_mask[0][2] =
+                        rsvd_bits(maxphyaddr, 63) |
+                        rsvd_bits(7, 8) | rsvd_bits(1, 2);      /* PDPTE */
+                context->rsvd_bits_mask[0][1] = exb_bit_rsvd |
+                        rsvd_bits(maxphyaddr, 62);      /* PDE */
+                context->rsvd_bits_mask[0][0] = exb_bit_rsvd |
+                        rsvd_bits(maxphyaddr, 62);      /* PTE */
+                context->rsvd_bits_mask[1][1] = exb_bit_rsvd |
+                        rsvd_bits(maxphyaddr, 62) |
+                        rsvd_bits(13, 20);              /* large page */
+                context->rsvd_bits_mask[1][0] = ~0ull;
+                break;
+        case PT64_ROOT_LEVEL:
+                context->rsvd_bits_mask[0][3] = exb_bit_rsvd |
+                        rsvd_bits(maxphyaddr, 51) | rsvd_bits(7, 8);
+                context->rsvd_bits_mask[0][2] = exb_bit_rsvd |
+                        rsvd_bits(maxphyaddr, 51) | rsvd_bits(7, 8);
+                context->rsvd_bits_mask[0][1] = exb_bit_rsvd |
+                        rsvd_bits(maxphyaddr, 51);
+                context->rsvd_bits_mask[0][0] = exb_bit_rsvd |
+                        rsvd_bits(maxphyaddr, 51);
+                context->rsvd_bits_mask[1][3] = context->rsvd_bits_mask[0][3];
+                context->rsvd_bits_mask[1][2] = context->rsvd_bits_mask[0][2];
+                context->rsvd_bits_mask[1][1] = exb_bit_rsvd |
+                        rsvd_bits(maxphyaddr, 51) |
+                        rsvd_bits(13, 20);              /* large page */
+                context->rsvd_bits_mask[1][0] = ~0ull;
+                break;
+        }
+}
+
 static int paging64_init_context_common(struct kvm_vcpu *vcpu, int level)
 {
         struct kvm_mmu *context = &vcpu->arch.mmu;
@@ -2179,6 +2211,7 @@ static int paging64_init_context_common(struct kvm_vcpu *vcpu, int level)
 
 static int paging64_init_context(struct kvm_vcpu *vcpu)
 {
+        reset_rsvds_bits_mask(vcpu, PT64_ROOT_LEVEL);
         return paging64_init_context_common(vcpu, PT64_ROOT_LEVEL);
 }
 
@@ -2186,6 +2219,7 @@ static int paging32_init_context(struct kvm_vcpu *vcpu)
 {
         struct kvm_mmu *context = &vcpu->arch.mmu;
 
+        reset_rsvds_bits_mask(vcpu, PT32_ROOT_LEVEL);
         context->new_cr3 = paging_new_cr3;
         context->page_fault = paging32_page_fault;
         context->gva_to_gpa = paging32_gva_to_gpa;
@@ -2201,6 +2235,7 @@ static int paging32_init_context(struct kvm_vcpu *vcpu)
 
 static int paging32E_init_context(struct kvm_vcpu *vcpu)
 {
+        reset_rsvds_bits_mask(vcpu, PT32E_ROOT_LEVEL);
         return paging64_init_context_common(vcpu, PT32E_ROOT_LEVEL);
 }
 
@@ -2221,12 +2256,15 @@ static int init_kvm_tdp_mmu(struct kvm_vcpu *vcpu)
                 context->gva_to_gpa = nonpaging_gva_to_gpa;
                 context->root_level = 0;
         } else if (is_long_mode(vcpu)) {
+                reset_rsvds_bits_mask(vcpu, PT64_ROOT_LEVEL);
                 context->gva_to_gpa = paging64_gva_to_gpa;
                 context->root_level = PT64_ROOT_LEVEL;
         } else if (is_pae(vcpu)) {
+                reset_rsvds_bits_mask(vcpu, PT32E_ROOT_LEVEL);
                 context->gva_to_gpa = paging64_gva_to_gpa;
                 context->root_level = PT32E_ROOT_LEVEL;
         } else {
+                reset_rsvds_bits_mask(vcpu, PT32_ROOT_LEVEL);
                 context->gva_to_gpa = paging32_gva_to_gpa;
                 context->root_level = PT32_ROOT_LEVEL;
         }
@@ -2290,9 +2328,11 @@ int kvm_mmu_load(struct kvm_vcpu *vcpu)
                 goto out;
         spin_lock(&vcpu->kvm->mmu_lock);
         kvm_mmu_free_some_pages(vcpu);
-        mmu_alloc_roots(vcpu);
+        r = mmu_alloc_roots(vcpu);
         mmu_sync_roots(vcpu);
         spin_unlock(&vcpu->kvm->mmu_lock);
+        if (r)
+                goto out;
         kvm_x86_ops->set_cr3(vcpu, vcpu->arch.mmu.root_hpa);
         kvm_mmu_flush_tlb(vcpu);
 out:
@@ -2638,14 +2678,6 @@ EXPORT_SYMBOL_GPL(kvm_disable_tdp);
 
 static void free_mmu_pages(struct kvm_vcpu *vcpu)
 {
-        struct kvm_mmu_page *sp;
-
-        while (!list_empty(&vcpu->kvm->arch.active_mmu_pages)) {
-                sp = container_of(vcpu->kvm->arch.active_mmu_pages.next,
-                                  struct kvm_mmu_page, link);
-                kvm_mmu_zap_page(vcpu->kvm, sp);
-                cond_resched();
-        }
         free_page((unsigned long)vcpu->arch.mmu.pae_root);
 }
 
@@ -2710,7 +2742,6 @@ void kvm_mmu_slot_remove_write_access(struct kvm *kvm, int slot)
 {
         struct kvm_mmu_page *sp;
 
-        spin_lock(&kvm->mmu_lock);
         list_for_each_entry(sp, &kvm->arch.active_mmu_pages, link) {
                 int i;
                 u64 *pt;
@@ -2725,7 +2756,6 @@ void kvm_mmu_slot_remove_write_access(struct kvm *kvm, int slot)
                                 pt[i] &= ~PT_WRITABLE_MASK;
         }
         kvm_flush_remote_tlbs(kvm);
-        spin_unlock(&kvm->mmu_lock);
 }
 
 void kvm_mmu_zap_all(struct kvm *kvm)
@@ -3007,11 +3037,13 @@ static void audit_mappings_page(struct kvm_vcpu *vcpu, u64 page_pte,
                                        " in nonleaf level: levels %d gva %lx"
                                        " level %d pte %llx\n", audit_msg,
                                        vcpu->arch.mmu.root_level, va, level, ent);
-
-                        audit_mappings_page(vcpu, ent, va, level - 1);
+                        else
+                                audit_mappings_page(vcpu, ent, va, level - 1);
                 } else {
                         gpa_t gpa = vcpu->arch.mmu.gva_to_gpa(vcpu, va);
-                        hpa_t hpa = (hpa_t)gpa_to_pfn(vcpu, gpa) << PAGE_SHIFT;
+                        gfn_t gfn = gpa >> PAGE_SHIFT;
+                        pfn_t pfn = gfn_to_pfn(vcpu->kvm, gfn);
+                        hpa_t hpa = (hpa_t)pfn << PAGE_SHIFT;
 
                         if (is_shadow_present_pte(ent)
                             && (ent & PT64_BASE_ADDR_MASK) != hpa)
diff --git a/arch/x86/kvm/mmu.h b/arch/x86/kvm/mmu.h
index eaab2145f62b..3494a2fb136e 100644
--- a/arch/x86/kvm/mmu.h
+++ b/arch/x86/kvm/mmu.h
@@ -75,4 +75,9 @@ static inline int is_paging(struct kvm_vcpu *vcpu)
         return vcpu->arch.cr0 & X86_CR0_PG;
 }
 
+static inline int is_present_pte(unsigned long pte)
+{
+        return pte & PT_PRESENT_MASK;
+}
+
 #endif
diff --git a/arch/x86/kvm/paging_tmpl.h b/arch/x86/kvm/paging_tmpl.h
index 6bd70206c561..258e4591e1ca 100644
--- a/arch/x86/kvm/paging_tmpl.h
+++ b/arch/x86/kvm/paging_tmpl.h
@@ -123,6 +123,7 @@ static int FNAME(walk_addr)(struct guest_walker *walker,
         gfn_t table_gfn;
         unsigned index, pt_access, pte_access;
         gpa_t pte_gpa;
+        int rsvd_fault = 0;
 
         pgprintk("%s: addr %lx\n", __func__, addr);
 walk:
@@ -157,6 +158,10 @@ walk:
                 if (!is_present_pte(pte))
                         goto not_present;
 
+                rsvd_fault = is_rsvd_bits_set(vcpu, pte, walker->level);
+                if (rsvd_fault)
+                        goto access_error;
+
                 if (write_fault && !is_writeble_pte(pte))
                         if (user_fault || is_write_protection(vcpu))
                                 goto access_error;
@@ -209,7 +214,6 @@ walk:
                 if (ret)
                         goto walk;
                 pte |= PT_DIRTY_MASK;
-                kvm_mmu_pte_write(vcpu, pte_gpa, (u8 *)&pte, sizeof(pte), 0);
                 walker->ptes[walker->level - 1] = pte;
         }
 
@@ -233,6 +237,8 @@ err:
                 walker->error_code |= PFERR_USER_MASK;
         if (fetch_fault)
                 walker->error_code |= PFERR_FETCH_MASK;
+        if (rsvd_fault)
+                walker->error_code |= PFERR_RSVD_MASK;
         return 0;
 }
 
@@ -262,8 +268,7 @@ static void FNAME(update_pte)(struct kvm_vcpu *vcpu, struct kvm_mmu_page *page,
         kvm_get_pfn(pfn);
         mmu_set_spte(vcpu, spte, page->role.access, pte_access, 0, 0,
                      gpte & PT_DIRTY_MASK, NULL, largepage,
-                     gpte & PT_GLOBAL_MASK, gpte_to_gfn(gpte),
-                     pfn, true);
+                     gpte_to_gfn(gpte), pfn, true);
 }
 
 /*
@@ -297,7 +302,6 @@ static u64 *FNAME(fetch)(struct kvm_vcpu *vcpu, gva_t addr,
                                      user_fault, write_fault,
                                      gw->ptes[gw->level-1] & PT_DIRTY_MASK,
                                      ptwrite, largepage,
-                                     gw->ptes[gw->level-1] & PT_GLOBAL_MASK,
                                      gw->gfn, pfn, false);
                         break;
                 }
@@ -380,7 +384,7 @@ static int FNAME(page_fault)(struct kvm_vcpu *vcpu, gva_t addr,
                 return r;
 
         /*
-         * Look up the shadow pte for the faulting address.
+         * Look up the guest pte for the faulting address.
          */
         r = FNAME(walk_addr)(&walker, vcpu, addr, write_fault, user_fault,
                              fetch_fault);
@@ -586,7 +590,7 @@ static int FNAME(sync_page)(struct kvm_vcpu *vcpu, struct kvm_mmu_page *sp)
                 nr_present++;
                 pte_access = sp->role.access & FNAME(gpte_access)(vcpu, gpte);
                 set_spte(vcpu, &sp->spt[i], pte_access, 0, 0,
-                         is_dirty_pte(gpte), 0, gpte & PT_GLOBAL_MASK, gfn,
+                         is_dirty_pte(gpte), 0, gfn,
                          spte_to_pfn(sp->spt[i]), true, false);
         }
 
diff --git a/arch/x86/kvm/svm.c b/arch/x86/kvm/svm.c
index 1f8510c51d6e..71510e07e69e 100644
--- a/arch/x86/kvm/svm.c
+++ b/arch/x86/kvm/svm.c
@@ -19,6 +19,7 @@
 #include "irq.h"
 #include "mmu.h"
 #include "kvm_cache_regs.h"
+#include "x86.h"
 
 #include <linux/module.h>
 #include <linux/kernel.h>
@@ -69,7 +70,6 @@ module_param(npt, int, S_IRUGO);
 static int nested = 0;
 module_param(nested, int, S_IRUGO);
 
-static void kvm_reput_irq(struct vcpu_svm *svm);
 static void svm_flush_tlb(struct kvm_vcpu *vcpu);
 
 static int nested_svm_exit_handled(struct vcpu_svm *svm, bool kvm_override);
@@ -132,24 +132,6 @@ static inline u32 svm_has(u32 feat)
         return svm_features & feat;
 }
 
-static inline u8 pop_irq(struct kvm_vcpu *vcpu)
-{
-        int word_index = __ffs(vcpu->arch.irq_summary);
-        int bit_index = __ffs(vcpu->arch.irq_pending[word_index]);
-        int irq = word_index * BITS_PER_LONG + bit_index;
-
-        clear_bit(bit_index, &vcpu->arch.irq_pending[word_index]);
-        if (!vcpu->arch.irq_pending[word_index])
-                clear_bit(word_index, &vcpu->arch.irq_summary);
-        return irq;
-}
-
-static inline void push_irq(struct kvm_vcpu *vcpu, u8 irq)
-{
-        set_bit(irq, vcpu->arch.irq_pending);
-        set_bit(irq / BITS_PER_LONG, &vcpu->arch.irq_summary);
-}
-
 static inline void clgi(void)
 {
         asm volatile (__ex(SVM_CLGI));
@@ -214,17 +196,31 @@ static void svm_queue_exception(struct kvm_vcpu *vcpu, unsigned nr,
         svm->vmcb->control.event_inj_err = error_code;
 }
 
-static bool svm_exception_injected(struct kvm_vcpu *vcpu)
+static int is_external_interrupt(u32 info)
+{
+        info &= SVM_EVTINJ_TYPE_MASK | SVM_EVTINJ_VALID;
+        return info == (SVM_EVTINJ_VALID | SVM_EVTINJ_TYPE_INTR);
+}
+
+static u32 svm_get_interrupt_shadow(struct kvm_vcpu *vcpu, int mask)
 {
         struct vcpu_svm *svm = to_svm(vcpu);
+        u32 ret = 0;
 
-        return !(svm->vmcb->control.exit_int_info & SVM_EXITINTINFO_VALID);
+        if (svm->vmcb->control.int_state & SVM_INTERRUPT_SHADOW_MASK)
+                ret |= X86_SHADOW_INT_STI | X86_SHADOW_INT_MOV_SS;
+        return ret & mask;
 }
 
-static int is_external_interrupt(u32 info)
+static void svm_set_interrupt_shadow(struct kvm_vcpu *vcpu, int mask)
 {
-        info &= SVM_EVTINJ_TYPE_MASK | SVM_EVTINJ_VALID;
-        return info == (SVM_EVTINJ_VALID | SVM_EVTINJ_TYPE_INTR);
+        struct vcpu_svm *svm = to_svm(vcpu);
+
+        if (mask == 0)
+                svm->vmcb->control.int_state &= ~SVM_INTERRUPT_SHADOW_MASK;
+        else
+                svm->vmcb->control.int_state |= SVM_INTERRUPT_SHADOW_MASK;
+
 }
 
 static void skip_emulated_instruction(struct kvm_vcpu *vcpu)
@@ -232,7 +228,9 @@ static void skip_emulated_instruction(struct kvm_vcpu *vcpu)
         struct vcpu_svm *svm = to_svm(vcpu);
 
         if (!svm->next_rip) {
-                printk(KERN_DEBUG "%s: NOP\n", __func__);
+                if (emulate_instruction(vcpu, vcpu->run, 0, 0, EMULTYPE_SKIP) !=
+                                EMULATE_DONE)
+                        printk(KERN_DEBUG "%s: NOP\n", __func__);
                 return;
         }
         if (svm->next_rip - kvm_rip_read(vcpu) > MAX_INST_SIZE)
@@ -240,9 +238,7 @@ static void skip_emulated_instruction(struct kvm_vcpu *vcpu)
                        __func__, kvm_rip_read(vcpu), svm->next_rip);
 
         kvm_rip_write(vcpu, svm->next_rip);
-        svm->vmcb->control.int_state &= ~SVM_INTERRUPT_SHADOW_MASK;
-
-        vcpu->arch.interrupt_window_open = (svm->vcpu.arch.hflags & HF_GIF_MASK);
+        svm_set_interrupt_shadow(vcpu, 0);
 }
 
 static int has_svm(void)
@@ -830,6 +826,15 @@ static void svm_get_segment(struct kvm_vcpu *vcpu,
                 if (!var->unusable)
                         var->type |= 0x1;
                 break;
+        case VCPU_SREG_SS:
+                /* On AMD CPUs sometimes the DB bit in the segment
+                 * descriptor is left as 1, although the whole segment has
+                 * been made unusable. Clear it here to pass an Intel VMX
+                 * entry check when cross vendor migrating.
+                 */
+                if (var->unusable)
+                        var->db = 0;
+                break;
         }
 }
 
@@ -960,15 +965,16 @@ static void svm_set_segment(struct kvm_vcpu *vcpu,
 
 }
 
-static int svm_guest_debug(struct kvm_vcpu *vcpu, struct kvm_guest_debug *dbg)
+static void update_db_intercept(struct kvm_vcpu *vcpu)
 {
-        int old_debug = vcpu->guest_debug;
         struct vcpu_svm *svm = to_svm(vcpu);
 
-        vcpu->guest_debug = dbg->control;
-
         svm->vmcb->control.intercept_exceptions &=
                 ~((1 << DB_VECTOR) | (1 << BP_VECTOR));
+
+        if (vcpu->arch.singlestep)
+                svm->vmcb->control.intercept_exceptions |= (1 << DB_VECTOR);
+
         if (vcpu->guest_debug & KVM_GUESTDBG_ENABLE) {
                 if (vcpu->guest_debug &
                     (KVM_GUESTDBG_SINGLESTEP | KVM_GUESTDBG_USE_HW_BP))
@@ -979,6 +985,16 @@ static int svm_guest_debug(struct kvm_vcpu *vcpu, struct kvm_guest_debug *dbg)
                                 1 << BP_VECTOR;
         } else
                 vcpu->guest_debug = 0;
+}
+
+static int svm_guest_debug(struct kvm_vcpu *vcpu, struct kvm_guest_debug *dbg)
+{
+        int old_debug = vcpu->guest_debug;
+        struct vcpu_svm *svm = to_svm(vcpu);
+
+        vcpu->guest_debug = dbg->control;
+
+        update_db_intercept(vcpu);
 
         if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP)
                 svm->vmcb->save.dr7 = dbg->arch.debugreg[7];
@@ -993,16 +1009,6 @@ static int svm_guest_debug(struct kvm_vcpu *vcpu, struct kvm_guest_debug *dbg)
         return 0;
 }
 
-static int svm_get_irq(struct kvm_vcpu *vcpu)
-{
-        struct vcpu_svm *svm = to_svm(vcpu);
-        u32 exit_int_info = svm->vmcb->control.exit_int_info;
-
-        if (is_external_interrupt(exit_int_info))
-                return exit_int_info & SVM_EVTINJ_VEC_MASK;
-        return -1;
-}
-
 static void load_host_msrs(struct kvm_vcpu *vcpu)
 {
 #ifdef CONFIG_X86_64
@@ -1107,17 +1113,8 @@ static void svm_set_dr(struct kvm_vcpu *vcpu, int dr, unsigned long value,
 
 static int pf_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
 {
-        u32 exit_int_info = svm->vmcb->control.exit_int_info;
-        struct kvm *kvm = svm->vcpu.kvm;
         u64 fault_address;
         u32 error_code;
-        bool event_injection = false;
-
-        if (!irqchip_in_kernel(kvm) &&
-            is_external_interrupt(exit_int_info)) {
-                event_injection = true;
-                push_irq(&svm->vcpu, exit_int_info & SVM_EVTINJ_VEC_MASK);
-        }
 
         fault_address  = svm->vmcb->control.exit_info_2;
         error_code = svm->vmcb->control.exit_info_1;
@@ -1137,23 +1134,40 @@ static int pf_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
          */
         if (npt_enabled)
                 svm_flush_tlb(&svm->vcpu);
-
-        if (!npt_enabled && event_injection)
-                kvm_mmu_unprotect_page_virt(&svm->vcpu, fault_address);
+        else {
+                if (kvm_event_needs_reinjection(&svm->vcpu))
+                        kvm_mmu_unprotect_page_virt(&svm->vcpu, fault_address);
+        }
         return kvm_mmu_page_fault(&svm->vcpu, fault_address, error_code);
 }
 
 static int db_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
 {
         if (!(svm->vcpu.guest_debug &
-              (KVM_GUESTDBG_SINGLESTEP | KVM_GUESTDBG_USE_HW_BP))) {
+              (KVM_GUESTDBG_SINGLESTEP | KVM_GUESTDBG_USE_HW_BP)) &&
+                !svm->vcpu.arch.singlestep) {
                 kvm_queue_exception(&svm->vcpu, DB_VECTOR);
                 return 1;
         }
-        kvm_run->exit_reason = KVM_EXIT_DEBUG;
-        kvm_run->debug.arch.pc = svm->vmcb->save.cs.base + svm->vmcb->save.rip;
-        kvm_run->debug.arch.exception = DB_VECTOR;
-        return 0;
+
+        if (svm->vcpu.arch.singlestep) {
+                svm->vcpu.arch.singlestep = false;
+                if (!(svm->vcpu.guest_debug & KVM_GUESTDBG_SINGLESTEP))
+                        svm->vmcb->save.rflags &=
+                                ~(X86_EFLAGS_TF | X86_EFLAGS_RF);
+                update_db_intercept(&svm->vcpu);
+        }
+
+        if (svm->vcpu.guest_debug &
+            (KVM_GUESTDBG_SINGLESTEP | KVM_GUESTDBG_USE_HW_BP)){
+                kvm_run->exit_reason = KVM_EXIT_DEBUG;
+                kvm_run->debug.arch.pc =
+                        svm->vmcb->save.cs.base + svm->vmcb->save.rip;
+                kvm_run->debug.arch.exception = DB_VECTOR;
+                return 0;
+        }
+
+        return 1;
 }
 
 static int bp_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
@@ -1842,17 +1856,51 @@ static int task_switch_interception(struct vcpu_svm *svm,
                                     struct kvm_run *kvm_run)
 {
         u16 tss_selector;
+        int reason;
+        int int_type = svm->vmcb->control.exit_int_info &
+                SVM_EXITINTINFO_TYPE_MASK;
+        int int_vec = svm->vmcb->control.exit_int_info & SVM_EVTINJ_VEC_MASK;
+        uint32_t type =
+                svm->vmcb->control.exit_int_info & SVM_EXITINTINFO_TYPE_MASK;
+        uint32_t idt_v =
+                svm->vmcb->control.exit_int_info & SVM_EXITINTINFO_VALID;
 
         tss_selector = (u16)svm->vmcb->control.exit_info_1;
+
         if (svm->vmcb->control.exit_info_2 &
             (1ULL << SVM_EXITINFOSHIFT_TS_REASON_IRET))
-                return kvm_task_switch(&svm->vcpu, tss_selector,
-                                       TASK_SWITCH_IRET);
-        if (svm->vmcb->control.exit_info_2 &
-            (1ULL << SVM_EXITINFOSHIFT_TS_REASON_JMP))
-                return kvm_task_switch(&svm->vcpu, tss_selector,
-                                       TASK_SWITCH_JMP);
-        return kvm_task_switch(&svm->vcpu, tss_selector, TASK_SWITCH_CALL);
+                reason = TASK_SWITCH_IRET;
+        else if (svm->vmcb->control.exit_info_2 &
+                 (1ULL << SVM_EXITINFOSHIFT_TS_REASON_JMP))
+                reason = TASK_SWITCH_JMP;
+        else if (idt_v)
+                reason = TASK_SWITCH_GATE;
+        else
+                reason = TASK_SWITCH_CALL;
+
+        if (reason == TASK_SWITCH_GATE) {
+                switch (type) {
+                case SVM_EXITINTINFO_TYPE_NMI:
+                        svm->vcpu.arch.nmi_injected = false;
+                        break;
+                case SVM_EXITINTINFO_TYPE_EXEPT:
+                        kvm_clear_exception_queue(&svm->vcpu);
+                        break;
+                case SVM_EXITINTINFO_TYPE_INTR:
+                        kvm_clear_interrupt_queue(&svm->vcpu);
+                        break;
+                default:
+                        break;
+                }
+        }
+
+        if (reason != TASK_SWITCH_GATE ||
+            int_type == SVM_EXITINTINFO_TYPE_SOFT ||
+            (int_type == SVM_EXITINTINFO_TYPE_EXEPT &&
+             (int_vec == OF_VECTOR || int_vec == BP_VECTOR)))
+                skip_emulated_instruction(&svm->vcpu);
+
+        return kvm_task_switch(&svm->vcpu, tss_selector, reason);
 }
 
 static int cpuid_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
@@ -1862,6 +1910,14 @@ static int cpuid_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
         return 1;
 }
 
+static int iret_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
+{
+        ++svm->vcpu.stat.nmi_window_exits;
+        svm->vmcb->control.intercept &= ~(1UL << INTERCEPT_IRET);
+        svm->vcpu.arch.hflags |= HF_IRET_MASK;
+        return 1;
+}
+
 static int invlpg_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
 {
         if (emulate_instruction(&svm->vcpu, kvm_run, 0, 0, 0) != EMULATE_DONE)
@@ -1879,8 +1935,14 @@ static int emulate_on_interception(struct vcpu_svm *svm,
 
 static int cr8_write_interception(struct vcpu_svm *svm, struct kvm_run *kvm_run)
 {
+        u8 cr8_prev = kvm_get_cr8(&svm->vcpu);
+        /* instruction emulation calls kvm_set_cr8() */
         emulate_instruction(&svm->vcpu, NULL, 0, 0, 0);
-        if (irqchip_in_kernel(svm->vcpu.kvm))
+        if (irqchip_in_kernel(svm->vcpu.kvm)) {
+                svm->vmcb->control.intercept_cr_write &= ~INTERCEPT_CR8_MASK;
+                return 1;
+        }
+        if (cr8_prev <= kvm_get_cr8(&svm->vcpu))
                 return 1;
         kvm_run->exit_reason = KVM_EXIT_SET_TPR;
         return 0;
@@ -2090,8 +2152,9 @@ static int interrupt_window_interception(struct vcpu_svm *svm,
          * If the user space waits to inject interrupts, exit as soon as
          * possible
          */
-        if (kvm_run->request_interrupt_window &&
-            !svm->vcpu.arch.irq_summary) {
+        if (!irqchip_in_kernel(svm->vcpu.kvm) &&
+            kvm_run->request_interrupt_window &&
+            !kvm_cpu_has_interrupt(&svm->vcpu)) {
                 ++svm->vcpu.stat.irq_window_exits;
                 kvm_run->exit_reason = KVM_EXIT_IRQ_WINDOW_OPEN;
                 return 0;
@@ -2134,6 +2197,7 @@ static int (*svm_exit_handlers[])(struct vcpu_svm *svm,
         [SVM_EXIT_VINTR]                        = interrupt_window_interception,
         /* [SVM_EXIT_CR0_SEL_WRITE]             = emulate_on_interception, */
         [SVM_EXIT_CPUID]                        = cpuid_interception,
+        [SVM_EXIT_IRET]                         = iret_interception,
         [SVM_EXIT_INVD]                         = emulate_on_interception,
         [SVM_EXIT_HLT]                          = halt_interception,
         [SVM_EXIT_INVLPG]                       = invlpg_interception,
@@ -2194,7 +2258,6 @@ static int handle_exit(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu)
                 }
         }
 
-        kvm_reput_irq(svm);
 
         if (svm->vmcb->control.exit_code == SVM_EXIT_ERR) {
                 kvm_run->exit_reason = KVM_EXIT_FAIL_ENTRY;
@@ -2205,7 +2268,7 @@ static int handle_exit(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu)
 
         if (is_external_interrupt(svm->vmcb->control.exit_int_info) &&
             exit_code != SVM_EXIT_EXCP_BASE + PF_VECTOR &&
-            exit_code != SVM_EXIT_NPF)
+            exit_code != SVM_EXIT_NPF && exit_code != SVM_EXIT_TASK_SWITCH)
                 printk(KERN_ERR "%s: unexpected exit_ini_info 0x%x "
                        "exit_code 0x%x\n",
                        __func__, svm->vmcb->control.exit_int_info,
@@ -2242,6 +2305,15 @@ static void pre_svm_run(struct vcpu_svm *svm)
                 new_asid(svm, svm_data);
 }
 
+static void svm_inject_nmi(struct kvm_vcpu *vcpu)
+{
+        struct vcpu_svm *svm = to_svm(vcpu);
+
+        svm->vmcb->control.event_inj = SVM_EVTINJ_VALID | SVM_EVTINJ_TYPE_NMI;
+        vcpu->arch.hflags |= HF_NMI_MASK;
+        svm->vmcb->control.intercept |= (1UL << INTERCEPT_IRET);
+        ++vcpu->stat.nmi_injections;
+}
 
 static inline void svm_inject_irq(struct vcpu_svm *svm, int irq)
 {
@@ -2257,134 +2329,71 @@ static inline void svm_inject_irq(struct vcpu_svm *svm, int irq)
                 ((/*control->int_vector >> 4*/ 0xf) << V_INTR_PRIO_SHIFT);
 }
 
-static void svm_set_irq(struct kvm_vcpu *vcpu, int irq)
+static void svm_queue_irq(struct kvm_vcpu *vcpu, unsigned nr)
 {
         struct vcpu_svm *svm = to_svm(vcpu);
 
-        nested_svm_intr(svm);
-
-        svm_inject_irq(svm, irq);
+        svm->vmcb->control.event_inj = nr |
+                SVM_EVTINJ_VALID | SVM_EVTINJ_TYPE_INTR;
 }
 
-static void update_cr8_intercept(struct kvm_vcpu *vcpu)
+static void svm_set_irq(struct kvm_vcpu *vcpu)
 {
         struct vcpu_svm *svm = to_svm(vcpu);
-        struct vmcb *vmcb = svm->vmcb;
-        int max_irr, tpr;
 
-        if (!irqchip_in_kernel(vcpu->kvm) || vcpu->arch.apic->vapic_addr)
-                return;
+        nested_svm_intr(svm);
 
-        vmcb->control.intercept_cr_write &= ~INTERCEPT_CR8_MASK;
+        svm_queue_irq(vcpu, vcpu->arch.interrupt.nr);
+}
 
-        max_irr = kvm_lapic_find_highest_irr(vcpu);
-        if (max_irr == -1)
-                return;
+static void update_cr8_intercept(struct kvm_vcpu *vcpu, int tpr, int irr)
+{
+        struct vcpu_svm *svm = to_svm(vcpu);
 
-        tpr = kvm_lapic_get_cr8(vcpu) << 4;
+        if (irr == -1)
+                return;
 
-        if (tpr >= (max_irr & 0xf0))
-                vmcb->control.intercept_cr_write |= INTERCEPT_CR8_MASK;
+        if (tpr >= irr)
+                svm->vmcb->control.intercept_cr_write |= INTERCEPT_CR8_MASK;
 }
 
-static void svm_intr_assist(struct kvm_vcpu *vcpu)
+static int svm_nmi_allowed(struct kvm_vcpu *vcpu)
 {
         struct vcpu_svm *svm = to_svm(vcpu);
         struct vmcb *vmcb = svm->vmcb;
-        int intr_vector = -1;
-
-        if ((vmcb->control.exit_int_info & SVM_EVTINJ_VALID) &&
-            ((vmcb->control.exit_int_info & SVM_EVTINJ_TYPE_MASK) == 0)) {
-                intr_vector = vmcb->control.exit_int_info &
-                              SVM_EVTINJ_VEC_MASK;
-                vmcb->control.exit_int_info = 0;
-                svm_inject_irq(svm, intr_vector);
-                goto out;
-        }
-
-        if (vmcb->control.int_ctl & V_IRQ_MASK)
-                goto out;
-
-        if (!kvm_cpu_has_interrupt(vcpu))
-                goto out;
-
-        if (nested_svm_intr(svm))
-                goto out;
-
-        if (!(svm->vcpu.arch.hflags & HF_GIF_MASK))
-                goto out;
-
-        if (!(vmcb->save.rflags & X86_EFLAGS_IF) ||
-            (vmcb->control.int_state & SVM_INTERRUPT_SHADOW_MASK) ||
-            (vmcb->control.event_inj & SVM_EVTINJ_VALID)) {
-                /* unable to deliver irq, set pending irq */
-                svm_set_vintr(svm);
-                svm_inject_irq(svm, 0x0);
-                goto out;
-        }
-        /* Okay, we can deliver the interrupt: grab it and update PIC state. */
-        intr_vector = kvm_cpu_get_interrupt(vcpu);
-        svm_inject_irq(svm, intr_vector);
-out:
-        update_cr8_intercept(vcpu);
+        return !(vmcb->control.int_state & SVM_INTERRUPT_SHADOW_MASK) &&
+                !(svm->vcpu.arch.hflags & HF_NMI_MASK);
 }
 
-static void kvm_reput_irq(struct vcpu_svm *svm)
+static int svm_interrupt_allowed(struct kvm_vcpu *vcpu)
 {
-        struct vmcb_control_area *control = &svm->vmcb->control;
-
-        if ((control->int_ctl & V_IRQ_MASK)
-            && !irqchip_in_kernel(svm->vcpu.kvm)) {
-                control->int_ctl &= ~V_IRQ_MASK;
-                push_irq(&svm->vcpu, control->int_vector);
-        }
-
-        svm->vcpu.arch.interrupt_window_open =
-                !(control->int_state & SVM_INTERRUPT_SHADOW_MASK) &&
-                 (svm->vcpu.arch.hflags & HF_GIF_MASK);
+        struct vcpu_svm *svm = to_svm(vcpu);
+        struct vmcb *vmcb = svm->vmcb;
+        return (vmcb->save.rflags & X86_EFLAGS_IF) &&
+                !(vmcb->control.int_state & SVM_INTERRUPT_SHADOW_MASK) &&
+                (svm->vcpu.arch.hflags & HF_GIF_MASK);
 }
 
-static void svm_do_inject_vector(struct vcpu_svm *svm)
+static void enable_irq_window(struct kvm_vcpu *vcpu)
 {
-        struct kvm_vcpu *vcpu = &svm->vcpu;
-        int word_index = __ffs(vcpu->arch.irq_summary);
-        int bit_index = __ffs(vcpu->arch.irq_pending[word_index]);
-        int irq = word_index * BITS_PER_LONG + bit_index;
-
-        clear_bit(bit_index, &vcpu->arch.irq_pending[word_index]);
-        if (!vcpu->arch.irq_pending[word_index])
-                clear_bit(word_index, &vcpu->arch.irq_summary);
-        svm_inject_irq(svm, irq);
+        svm_set_vintr(to_svm(vcpu));
+        svm_inject_irq(to_svm(vcpu), 0x0);
 }
 
-static void do_interrupt_requests(struct kvm_vcpu *vcpu,
-                                       struct kvm_run *kvm_run)
+static void enable_nmi_window(struct kvm_vcpu *vcpu)
 {
         struct vcpu_svm *svm = to_svm(vcpu);
-        struct vmcb_control_area *control = &svm->vmcb->control;
-
-        if (nested_svm_intr(svm))
-                return;
 
-        svm->vcpu.arch.interrupt_window_open =
-                (!(control->int_state & SVM_INTERRUPT_SHADOW_MASK) &&
-                 (svm->vmcb->save.rflags & X86_EFLAGS_IF) &&
-                 (svm->vcpu.arch.hflags & HF_GIF_MASK));
+        if ((svm->vcpu.arch.hflags & (HF_NMI_MASK | HF_IRET_MASK))
+            == HF_NMI_MASK)
+                return; /* IRET will cause a vm exit */
 
-        if (svm->vcpu.arch.interrupt_window_open && svm->vcpu.arch.irq_summary)
-                /*
-                 * If interrupts enabled, and not blocked by sti or mov ss. Good.
-                 */
-                svm_do_inject_vector(svm);
-
-        /*
-         * Interrupts blocked.  Wait for unblock.
-         */
-        if (!svm->vcpu.arch.interrupt_window_open &&
-            (svm->vcpu.arch.irq_summary || kvm_run->request_interrupt_window))
-                svm_set_vintr(svm);
-        else
-                svm_clear_vintr(svm);
+        /* Something prevents NMI from been injected. Single step over
+           possible problem (IRET or exception injection or interrupt
+           shadow) */
+        vcpu->arch.singlestep = true;
+        svm->vmcb->save.rflags |= (X86_EFLAGS_TF | X86_EFLAGS_RF);
+        update_db_intercept(vcpu);
 }
 
 static int svm_set_tss_addr(struct kvm *kvm, unsigned int addr)
@@ -2407,7 +2416,7 @@ static inline void sync_cr8_to_lapic(struct kvm_vcpu *vcpu)
 
         if (!(svm->vmcb->control.intercept_cr_write & INTERCEPT_CR8_MASK)) {
                 int cr8 = svm->vmcb->control.int_ctl & V_TPR_MASK;
-                kvm_lapic_set_tpr(vcpu, cr8);
+                kvm_set_cr8(vcpu, cr8);
         }
 }
 
@@ -2416,14 +2425,54 @@ static inline void sync_lapic_to_cr8(struct kvm_vcpu *vcpu)
         struct vcpu_svm *svm = to_svm(vcpu);
         u64 cr8;
 
-        if (!irqchip_in_kernel(vcpu->kvm))
-                return;
-
         cr8 = kvm_get_cr8(vcpu);
         svm->vmcb->control.int_ctl &= ~V_TPR_MASK;
         svm->vmcb->control.int_ctl |= cr8 & V_TPR_MASK;
 }
 
+static void svm_complete_interrupts(struct vcpu_svm *svm)
+{
+        u8 vector;
+        int type;
+        u32 exitintinfo = svm->vmcb->control.exit_int_info;
+
+        if (svm->vcpu.arch.hflags & HF_IRET_MASK)
+                svm->vcpu.arch.hflags &= ~(HF_NMI_MASK | HF_IRET_MASK);
+
+        svm->vcpu.arch.nmi_injected = false;
+        kvm_clear_exception_queue(&svm->vcpu);
+        kvm_clear_interrupt_queue(&svm->vcpu);
+
+        if (!(exitintinfo & SVM_EXITINTINFO_VALID))
+                return;
+
+        vector = exitintinfo & SVM_EXITINTINFO_VEC_MASK;
+        type = exitintinfo & SVM_EXITINTINFO_TYPE_MASK;
+
+        switch (type) {
+        case SVM_EXITINTINFO_TYPE_NMI:
+                svm->vcpu.arch.nmi_injected = true;
+                break;
+        case SVM_EXITINTINFO_TYPE_EXEPT:
+                /* In case of software exception do not reinject an exception
+                   vector, but re-execute and instruction instead */
+                if (kvm_exception_is_soft(vector))
+                        break;
+                if (exitintinfo & SVM_EXITINTINFO_VALID_ERR) {
+                        u32 err = svm->vmcb->control.exit_int_info_err;
+                        kvm_queue_exception_e(&svm->vcpu, vector, err);
+
+                } else
+                        kvm_queue_exception(&svm->vcpu, vector);
+                break;
+        case SVM_EXITINTINFO_TYPE_INTR:
+                kvm_queue_interrupt(&svm->vcpu, vector, false);
+                break;
+        default:
+                break;
+        }
+}
+
 #ifdef CONFIG_X86_64
 #define R "r"
 #else
@@ -2552,6 +2601,8 @@ static void svm_vcpu_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
         sync_cr8_to_lapic(vcpu);
 
         svm->next_rip = 0;
+
+        svm_complete_interrupts(svm);
 }
 
 #undef R
@@ -2617,7 +2668,7 @@ static int get_npt_level(void)
 #endif
 }
 
-static int svm_get_mt_mask_shift(void)
+static u64 svm_get_mt_mask(struct kvm_vcpu *vcpu, gfn_t gfn, bool is_mmio)
 {
         return 0;
 }
@@ -2667,17 +2718,21 @@ static struct kvm_x86_ops svm_x86_ops = {
         .run = svm_vcpu_run,
         .handle_exit = handle_exit,
         .skip_emulated_instruction = skip_emulated_instruction,
+        .set_interrupt_shadow = svm_set_interrupt_shadow,
+        .get_interrupt_shadow = svm_get_interrupt_shadow,
         .patch_hypercall = svm_patch_hypercall,
-        .get_irq = svm_get_irq,
         .set_irq = svm_set_irq,
+        .set_nmi = svm_inject_nmi,
         .queue_exception = svm_queue_exception,
-        .exception_injected = svm_exception_injected,
-        .inject_pending_irq = svm_intr_assist,
-        .inject_pending_vectors = do_interrupt_requests,
+        .interrupt_allowed = svm_interrupt_allowed,
+        .nmi_allowed = svm_nmi_allowed,
+        .enable_nmi_window = enable_nmi_window,
+        .enable_irq_window = enable_irq_window,
+        .update_cr8_intercept = update_cr8_intercept,
 
         .set_tss_addr = svm_set_tss_addr,
         .get_tdp_level = get_npt_level,
-        .get_mt_mask_shift = svm_get_mt_mask_shift,
+        .get_mt_mask = svm_get_mt_mask,
 };
 
 static int __init svm_init(void)
diff --git a/arch/x86/kvm/timer.c b/arch/x86/kvm/timer.c
new file mode 100644
index 000000000000..86dbac072d0c
--- /dev/null
+++ b/arch/x86/kvm/timer.c
@@ -0,0 +1,46 @@
+#include <linux/kvm_host.h>
+#include <linux/kvm.h>
+#include <linux/hrtimer.h>
+#include <asm/atomic.h>
+#include "kvm_timer.h"
+
+static int __kvm_timer_fn(struct kvm_vcpu *vcpu, struct kvm_timer *ktimer)
+{
+        int restart_timer = 0;
+        wait_queue_head_t *q = &vcpu->wq;
+
+        /* FIXME: this code should not know anything about vcpus */
+        if (!atomic_inc_and_test(&ktimer->pending))
+                set_bit(KVM_REQ_PENDING_TIMER, &vcpu->requests);
+
+        if (!ktimer->reinject)
+                atomic_set(&ktimer->pending, 1);
+
+        if (waitqueue_active(q))
+                wake_up_interruptible(q);
+
+        if (ktimer->t_ops->is_periodic(ktimer)) {
+                hrtimer_add_expires_ns(&ktimer->timer, ktimer->period);
+                restart_timer = 1;
+        }
+
+        return restart_timer;
+}
+
+enum hrtimer_restart kvm_timer_fn(struct hrtimer *data)
+{
+        int restart_timer;
+        struct kvm_vcpu *vcpu;
+        struct kvm_timer *ktimer = container_of(data, struct kvm_timer, timer);
+
+        vcpu = ktimer->kvm->vcpus[ktimer->vcpu_id];
+        if (!vcpu)
+                return HRTIMER_NORESTART;
+
+        restart_timer = __kvm_timer_fn(vcpu, ktimer);
+        if (restart_timer)
+                return HRTIMER_RESTART;
+        else
+                return HRTIMER_NORESTART;
+}
+
diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c
index bb481330716f..32d6ae8fb60e 100644
--- a/arch/x86/kvm/vmx.c
+++ b/arch/x86/kvm/vmx.c
@@ -32,26 +32,27 @@
 #include <asm/desc.h>
 #include <asm/vmx.h>
 #include <asm/virtext.h>
+#include <asm/mce.h>
 
 #define __ex(x) __kvm_handle_fault_on_reboot(x)
 
 MODULE_AUTHOR("Qumranet");
 MODULE_LICENSE("GPL");
 
-static int bypass_guest_pf = 1;
-module_param(bypass_guest_pf, bool, 0);
+static int __read_mostly bypass_guest_pf = 1;
+module_param(bypass_guest_pf, bool, S_IRUGO);
 
-static int enable_vpid = 1;
-module_param(enable_vpid, bool, 0);
+static int __read_mostly enable_vpid = 1;
+module_param_named(vpid, enable_vpid, bool, 0444);
 
-static int flexpriority_enabled = 1;
-module_param(flexpriority_enabled, bool, 0);
+static int __read_mostly flexpriority_enabled = 1;
+module_param_named(flexpriority, flexpriority_enabled, bool, S_IRUGO);
 
-static int enable_ept = 1;
-module_param(enable_ept, bool, 0);
+static int __read_mostly enable_ept = 1;
+module_param_named(ept, enable_ept, bool, S_IRUGO);
 
-static int emulate_invalid_guest_state = 0;
-module_param(emulate_invalid_guest_state, bool, 0);
+static int __read_mostly emulate_invalid_guest_state = 0;
+module_param(emulate_invalid_guest_state, bool, S_IRUGO);
 
 struct vmcs {
         u32 revision_id;
@@ -97,6 +98,7 @@ struct vcpu_vmx {
         int soft_vnmi_blocked;
         ktime_t entry_time;
         s64 vnmi_blocked_time;
+        u32 exit_reason;
 };
 
 static inline struct vcpu_vmx *to_vmx(struct kvm_vcpu *vcpu)
@@ -111,9 +113,10 @@ static DEFINE_PER_CPU(struct vmcs *, vmxarea);
 static DEFINE_PER_CPU(struct vmcs *, current_vmcs);
 static DEFINE_PER_CPU(struct list_head, vcpus_on_cpu);
 
-static struct page *vmx_io_bitmap_a;
-static struct page *vmx_io_bitmap_b;
-static struct page *vmx_msr_bitmap;
+static unsigned long *vmx_io_bitmap_a;
+static unsigned long *vmx_io_bitmap_b;
+static unsigned long *vmx_msr_bitmap_legacy;
+static unsigned long *vmx_msr_bitmap_longmode;
 
 static DECLARE_BITMAP(vmx_vpid_bitmap, VMX_NR_VPIDS);
 static DEFINE_SPINLOCK(vmx_vpid_lock);
@@ -213,70 +216,78 @@ static inline int is_external_interrupt(u32 intr_info)
                 == (INTR_TYPE_EXT_INTR | INTR_INFO_VALID_MASK);
 }
 
+static inline int is_machine_check(u32 intr_info)
+{
+        return (intr_info & (INTR_INFO_INTR_TYPE_MASK | INTR_INFO_VECTOR_MASK |
+                             INTR_INFO_VALID_MASK)) ==
+                (INTR_TYPE_HARD_EXCEPTION | MC_VECTOR | INTR_INFO_VALID_MASK);
+}
+
 static inline int cpu_has_vmx_msr_bitmap(void)
 {
-        return (vmcs_config.cpu_based_exec_ctrl & CPU_BASED_USE_MSR_BITMAPS);
+        return vmcs_config.cpu_based_exec_ctrl & CPU_BASED_USE_MSR_BITMAPS;
 }
 
 static inline int cpu_has_vmx_tpr_shadow(void)
 {
-        return (vmcs_config.cpu_based_exec_ctrl & CPU_BASED_TPR_SHADOW);
+        return vmcs_config.cpu_based_exec_ctrl & CPU_BASED_TPR_SHADOW;
 }
 
 static inline int vm_need_tpr_shadow(struct kvm *kvm)
 {
-        return ((cpu_has_vmx_tpr_shadow()) && (irqchip_in_kernel(kvm)));
+        return (cpu_has_vmx_tpr_shadow()) && (irqchip_in_kernel(kvm));
 }
 
 static inline int cpu_has_secondary_exec_ctrls(void)
 {
-        return (vmcs_config.cpu_based_exec_ctrl &
-                CPU_BASED_ACTIVATE_SECONDARY_CONTROLS);
+        return vmcs_config.cpu_based_exec_ctrl &
+                CPU_BASED_ACTIVATE_SECONDARY_CONTROLS;
 }
 
 static inline bool cpu_has_vmx_virtualize_apic_accesses(void)
 {
-        return flexpriority_enabled
-                && (vmcs_config.cpu_based_2nd_exec_ctrl &
-                    SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES);
+        return vmcs_config.cpu_based_2nd_exec_ctrl &
+                SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES;
+}
+
+static inline bool cpu_has_vmx_flexpriority(void)
+{
+        return cpu_has_vmx_tpr_shadow() &&
+                cpu_has_vmx_virtualize_apic_accesses();
 }
 
 static inline int cpu_has_vmx_invept_individual_addr(void)
 {
-        return (!!(vmx_capability.ept & VMX_EPT_EXTENT_INDIVIDUAL_BIT));
+        return !!(vmx_capability.ept & VMX_EPT_EXTENT_INDIVIDUAL_BIT);
 }
 
 static inline int cpu_has_vmx_invept_context(void)
 {
-        return (!!(vmx_capability.ept & VMX_EPT_EXTENT_CONTEXT_BIT));
+        return !!(vmx_capability.ept & VMX_EPT_EXTENT_CONTEXT_BIT);
 }
 
 static inline int cpu_has_vmx_invept_global(void)
 {
-        return (!!(vmx_capability.ept & VMX_EPT_EXTENT_GLOBAL_BIT));
+        return !!(vmx_capability.ept & VMX_EPT_EXTENT_GLOBAL_BIT);
 }
 
 static inline int cpu_has_vmx_ept(void)
 {
-        return (vmcs_config.cpu_based_2nd_exec_ctrl &
-                SECONDARY_EXEC_ENABLE_EPT);
-}
-
-static inline int vm_need_ept(void)
-{
-        return (cpu_has_vmx_ept() && enable_ept);
+        return vmcs_config.cpu_based_2nd_exec_ctrl &
+                SECONDARY_EXEC_ENABLE_EPT;
 }
 
 static inline int vm_need_virtualize_apic_accesses(struct kvm *kvm)
 {
-        return ((cpu_has_vmx_virtualize_apic_accesses()) &&
-                (irqchip_in_kernel(kvm)));
+        return flexpriority_enabled &&
+                (cpu_has_vmx_virtualize_apic_accesses()) &&
+                (irqchip_in_kernel(kvm));
 }
 
 static inline int cpu_has_vmx_vpid(void)
 {
-        return (vmcs_config.cpu_based_2nd_exec_ctrl &
-                SECONDARY_EXEC_ENABLE_VPID);
+        return vmcs_config.cpu_based_2nd_exec_ctrl &
+                SECONDARY_EXEC_ENABLE_VPID;
 }
 
 static inline int cpu_has_virtual_nmis(void)
@@ -284,6 +295,11 @@ static inline int cpu_has_virtual_nmis(void)
         return vmcs_config.pin_based_exec_ctrl & PIN_BASED_VIRTUAL_NMIS;
 }
 
+static inline bool report_flexpriority(void)
+{
+        return flexpriority_enabled;
+}
+
 static int __find_msr_index(struct vcpu_vmx *vmx, u32 msr)
 {
         int i;
@@ -381,7 +397,7 @@ static inline void ept_sync_global(void)
 
 static inline void ept_sync_context(u64 eptp)
 {
-        if (vm_need_ept()) {
+        if (enable_ept) {
                 if (cpu_has_vmx_invept_context())
                         __invept(VMX_EPT_EXTENT_CONTEXT, eptp, 0);
                 else
@@ -391,7 +407,7 @@ static inline void ept_sync_context(u64 eptp)
 
 static inline void ept_sync_individual_addr(u64 eptp, gpa_t gpa)
 {
-        if (vm_need_ept()) {
+        if (enable_ept) {
                 if (cpu_has_vmx_invept_individual_addr())
                         __invept(VMX_EPT_EXTENT_INDIVIDUAL_ADDR,
                                         eptp, gpa);
@@ -478,7 +494,7 @@ static void update_exception_bitmap(struct kvm_vcpu *vcpu)
 {
         u32 eb;
 
-        eb = (1u << PF_VECTOR) | (1u << UD_VECTOR);
+        eb = (1u << PF_VECTOR) | (1u << UD_VECTOR) | (1u << MC_VECTOR);
         if (!vcpu->fpu_active)
                 eb |= 1u << NM_VECTOR;
         if (vcpu->guest_debug & KVM_GUESTDBG_ENABLE) {
@@ -488,9 +504,9 @@ static void update_exception_bitmap(struct kvm_vcpu *vcpu)
                 if (vcpu->guest_debug & KVM_GUESTDBG_USE_SW_BP)
                         eb |= 1u << BP_VECTOR;
         }
-        if (vcpu->arch.rmode.active)
+        if (vcpu->arch.rmode.vm86_active)
                 eb = ~0;
-        if (vm_need_ept())
+        if (enable_ept)
                 eb &= ~(1u << PF_VECTOR); /* bypass_guest_pf = 0 */
         vmcs_write32(EXCEPTION_BITMAP, eb);
 }
@@ -724,29 +740,50 @@ static unsigned long vmx_get_rflags(struct kvm_vcpu *vcpu)
 
 static void vmx_set_rflags(struct kvm_vcpu *vcpu, unsigned long rflags)
 {
-        if (vcpu->arch.rmode.active)
+        if (vcpu->arch.rmode.vm86_active)
                 rflags |= X86_EFLAGS_IOPL | X86_EFLAGS_VM;
         vmcs_writel(GUEST_RFLAGS, rflags);
 }
 
+static u32 vmx_get_interrupt_shadow(struct kvm_vcpu *vcpu, int mask)
+{
+        u32 interruptibility = vmcs_read32(GUEST_INTERRUPTIBILITY_INFO);
+        int ret = 0;
+
+        if (interruptibility & GUEST_INTR_STATE_STI)
+                ret |= X86_SHADOW_INT_STI;
+        if (interruptibility & GUEST_INTR_STATE_MOV_SS)
+                ret |= X86_SHADOW_INT_MOV_SS;
+
+        return ret & mask;
+}
+
+static void vmx_set_interrupt_shadow(struct kvm_vcpu *vcpu, int mask)
+{
+        u32 interruptibility_old = vmcs_read32(GUEST_INTERRUPTIBILITY_INFO);
+        u32 interruptibility = interruptibility_old;
+
+        interruptibility &= ~(GUEST_INTR_STATE_STI | GUEST_INTR_STATE_MOV_SS);
+
+        if (mask & X86_SHADOW_INT_MOV_SS)
+                interruptibility |= GUEST_INTR_STATE_MOV_SS;
+        if (mask & X86_SHADOW_INT_STI)
+                interruptibility |= GUEST_INTR_STATE_STI;
+
+        if ((interruptibility != interruptibility_old))
+                vmcs_write32(GUEST_INTERRUPTIBILITY_INFO, interruptibility);
+}
+
 static void skip_emulated_instruction(struct kvm_vcpu *vcpu)
 {
         unsigned long rip;
-        u32 interruptibility;
 
         rip = kvm_rip_read(vcpu);
         rip += vmcs_read32(VM_EXIT_INSTRUCTION_LEN);
         kvm_rip_write(vcpu, rip);
 
-        /*
-         * We emulated an instruction, so temporary interrupt blocking
-         * should be removed, if set.
-         */
-        interruptibility = vmcs_read32(GUEST_INTERRUPTIBILITY_INFO);
-        if (interruptibility & 3)
-                vmcs_write32(GUEST_INTERRUPTIBILITY_INFO,
-                             interruptibility & ~3);
-        vcpu->arch.interrupt_window_open = 1;
+        /* skipping an emulated instruction also counts */
+        vmx_set_interrupt_shadow(vcpu, 0);
 }
 
 static void vmx_queue_exception(struct kvm_vcpu *vcpu, unsigned nr,
@@ -760,7 +797,7 @@ static void vmx_queue_exception(struct kvm_vcpu *vcpu, unsigned nr,
                 intr_info |= INTR_INFO_DELIVER_CODE_MASK;
         }
 
-        if (vcpu->arch.rmode.active) {
+        if (vcpu->arch.rmode.vm86_active) {
                 vmx->rmode.irq.pending = true;
                 vmx->rmode.irq.vector = nr;
                 vmx->rmode.irq.rip = kvm_rip_read(vcpu);
@@ -773,8 +810,9 @@ static void vmx_queue_exception(struct kvm_vcpu *vcpu, unsigned nr,
                 return;
         }
 
-        if (nr == BP_VECTOR || nr == OF_VECTOR) {
-                vmcs_write32(VM_ENTRY_INSTRUCTION_LEN, 1);
+        if (kvm_exception_is_soft(nr)) {
+                vmcs_write32(VM_ENTRY_INSTRUCTION_LEN,
+                             vmx->vcpu.arch.event_exit_inst_len);
                 intr_info |= INTR_TYPE_SOFT_EXCEPTION;
         } else
                 intr_info |= INTR_TYPE_HARD_EXCEPTION;
@@ -782,11 +820,6 @@ static void vmx_queue_exception(struct kvm_vcpu *vcpu, unsigned nr,
         vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, intr_info);
 }
 
-static bool vmx_exception_injected(struct kvm_vcpu *vcpu)
-{
-        return false;
-}
-
 /*
  * Swap MSR entry in host/guest MSR entry array.
  */
@@ -812,6 +845,7 @@ static void move_msr_up(struct vcpu_vmx *vmx, int from, int to)
 static void setup_msrs(struct vcpu_vmx *vmx)
 {
         int save_nmsrs;
+        unsigned long *msr_bitmap;
 
         vmx_load_host_state(vmx);
         save_nmsrs = 0;
@@ -847,6 +881,15 @@ static void setup_msrs(struct vcpu_vmx *vmx)
                 __find_msr_index(vmx, MSR_KERNEL_GS_BASE);
 #endif
         vmx->msr_offset_efer = __find_msr_index(vmx, MSR_EFER);
+
+        if (cpu_has_vmx_msr_bitmap()) {
+                if (is_long_mode(&vmx->vcpu))
+                        msr_bitmap = vmx_msr_bitmap_longmode;
+                else
+                        msr_bitmap = vmx_msr_bitmap_legacy;
+
+                vmcs_write64(MSR_BITMAP, __pa(msr_bitmap));
+        }
 }
 
 /*
@@ -1034,13 +1077,6 @@ static int set_guest_debug(struct kvm_vcpu *vcpu, struct kvm_guest_debug *dbg)
         return 0;
 }
 
-static int vmx_get_irq(struct kvm_vcpu *vcpu)
-{
-        if (!vcpu->arch.interrupt.pending)
-                return -1;
-        return vcpu->arch.interrupt.nr;
-}
-
 static __init int cpu_has_kvm_support(void)
 {
         return cpu_has_vmx();
@@ -1294,6 +1330,18 @@ static __init int hardware_setup(void)
         if (boot_cpu_has(X86_FEATURE_NX))
                 kvm_enable_efer_bits(EFER_NX);
 
+        if (!cpu_has_vmx_vpid())
+                enable_vpid = 0;
+
+        if (!cpu_has_vmx_ept())
+                enable_ept = 0;
+
+        if (!cpu_has_vmx_flexpriority())
+                flexpriority_enabled = 0;
+
+        if (!cpu_has_vmx_tpr_shadow())
+                kvm_x86_ops->update_cr8_intercept = NULL;
+
         return alloc_kvm_area();
 }
 
@@ -1324,7 +1372,7 @@ static void enter_pmode(struct kvm_vcpu *vcpu)
         struct vcpu_vmx *vmx = to_vmx(vcpu);
 
         vmx->emulation_required = 1;
-        vcpu->arch.rmode.active = 0;
+        vcpu->arch.rmode.vm86_active = 0;
 
         vmcs_writel(GUEST_TR_BASE, vcpu->arch.rmode.tr.base);
         vmcs_write32(GUEST_TR_LIMIT, vcpu->arch.rmode.tr.limit);
@@ -1386,7 +1434,7 @@ static void enter_rmode(struct kvm_vcpu *vcpu)
         struct vcpu_vmx *vmx = to_vmx(vcpu);
 
         vmx->emulation_required = 1;
-        vcpu->arch.rmode.active = 1;
+        vcpu->arch.rmode.vm86_active = 1;
 
         vcpu->arch.rmode.tr.base = vmcs_readl(GUEST_TR_BASE);
         vmcs_writel(GUEST_TR_BASE, rmode_tss_base(vcpu->kvm));
@@ -1485,7 +1533,7 @@ static void exit_lmode(struct kvm_vcpu *vcpu)
 static void vmx_flush_tlb(struct kvm_vcpu *vcpu)
 {
         vpid_sync_vcpu_all(to_vmx(vcpu));
-        if (vm_need_ept())
+        if (enable_ept)
                 ept_sync_context(construct_eptp(vcpu->arch.mmu.root_hpa));
 }
 
@@ -1555,10 +1603,10 @@ static void vmx_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0)
 
         vmx_fpu_deactivate(vcpu);
 
-        if (vcpu->arch.rmode.active && (cr0 & X86_CR0_PE))
+        if (vcpu->arch.rmode.vm86_active && (cr0 & X86_CR0_PE))
                 enter_pmode(vcpu);
 
-        if (!vcpu->arch.rmode.active && !(cr0 & X86_CR0_PE))
+        if (!vcpu->arch.rmode.vm86_active && !(cr0 & X86_CR0_PE))
                 enter_rmode(vcpu);
 
 #ifdef CONFIG_X86_64
@@ -1570,7 +1618,7 @@ static void vmx_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0)
         }
 #endif
 
-        if (vm_need_ept())
+        if (enable_ept)
                 ept_update_paging_mode_cr0(&hw_cr0, cr0, vcpu);
 
         vmcs_writel(CR0_READ_SHADOW, cr0);
@@ -1599,7 +1647,7 @@ static void vmx_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3)
         u64 eptp;
 
         guest_cr3 = cr3;
-        if (vm_need_ept()) {
+        if (enable_ept) {
                 eptp = construct_eptp(cr3);
                 vmcs_write64(EPT_POINTER, eptp);
                 ept_sync_context(eptp);
@@ -1616,11 +1664,11 @@ static void vmx_set_cr3(struct kvm_vcpu *vcpu, unsigned long cr3)
 
 static void vmx_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4)
 {
-        unsigned long hw_cr4 = cr4 | (vcpu->arch.rmode.active ?
+        unsigned long hw_cr4 = cr4 | (vcpu->arch.rmode.vm86_active ?
                     KVM_RMODE_VM_CR4_ALWAYS_ON : KVM_PMODE_VM_CR4_ALWAYS_ON);
 
         vcpu->arch.cr4 = cr4;
-        if (vm_need_ept())
+        if (enable_ept)
                 ept_update_paging_mode_cr4(&hw_cr4, vcpu);
 
         vmcs_writel(CR4_READ_SHADOW, cr4);
@@ -1699,7 +1747,7 @@ static void vmx_set_segment(struct kvm_vcpu *vcpu,
         struct kvm_vmx_segment_field *sf = &kvm_vmx_segment_fields[seg];
         u32 ar;
 
-        if (vcpu->arch.rmode.active && seg == VCPU_SREG_TR) {
+        if (vcpu->arch.rmode.vm86_active && seg == VCPU_SREG_TR) {
                 vcpu->arch.rmode.tr.selector = var->selector;
                 vcpu->arch.rmode.tr.base = var->base;
                 vcpu->arch.rmode.tr.limit = var->limit;
@@ -1709,7 +1757,7 @@ static void vmx_set_segment(struct kvm_vcpu *vcpu,
         vmcs_writel(sf->base, var->base);
         vmcs_write32(sf->limit, var->limit);
         vmcs_write16(sf->selector, var->selector);
-        if (vcpu->arch.rmode.active && var->s) {
+        if (vcpu->arch.rmode.vm86_active && var->s) {
                 /*
                  * Hack real-mode segments into vm86 compatibility.
                  */
@@ -1982,7 +2030,7 @@ static int init_rmode_identity_map(struct kvm *kvm)
         pfn_t identity_map_pfn;
         u32 tmp;
 
-        if (!vm_need_ept())
+        if (!enable_ept)
                 return 1;
         if (unlikely(!kvm->arch.ept_identity_pagetable)) {
                 printk(KERN_ERR "EPT: identity-mapping pagetable "
@@ -2071,7 +2119,7 @@ static void allocate_vpid(struct vcpu_vmx *vmx)
         int vpid;
 
         vmx->vpid = 0;
-        if (!enable_vpid || !cpu_has_vmx_vpid())
+        if (!enable_vpid)
                 return;
         spin_lock(&vmx_vpid_lock);
         vpid = find_first_zero_bit(vmx_vpid_bitmap, VMX_NR_VPIDS);
@@ -2082,9 +2130,9 @@ static void allocate_vpid(struct vcpu_vmx *vmx)
         spin_unlock(&vmx_vpid_lock);
 }
 
-static void vmx_disable_intercept_for_msr(struct page *msr_bitmap, u32 msr)
+static void __vmx_disable_intercept_for_msr(unsigned long *msr_bitmap, u32 msr)
 {
-        void *va;
+        int f = sizeof(unsigned long);
 
         if (!cpu_has_vmx_msr_bitmap())
                 return;
@@ -2094,16 +2142,21 @@ static void vmx_disable_intercept_for_msr(struct page *msr_bitmap, u32 msr)
          * have the write-low and read-high bitmap offsets the wrong way round.
          * We can control MSRs 0x00000000-0x00001fff and 0xc0000000-0xc0001fff.
          */
-        va = kmap(msr_bitmap);
         if (msr <= 0x1fff) {
-                __clear_bit(msr, va + 0x000); /* read-low */
-                __clear_bit(msr, va + 0x800); /* write-low */
+                __clear_bit(msr, msr_bitmap + 0x000 / f); /* read-low */
+                __clear_bit(msr, msr_bitmap + 0x800 / f); /* write-low */
         } else if ((msr >= 0xc0000000) && (msr <= 0xc0001fff)) {
                 msr &= 0x1fff;
-                __clear_bit(msr, va + 0x400); /* read-high */
-                __clear_bit(msr, va + 0xc00); /* write-high */
+                __clear_bit(msr, msr_bitmap + 0x400 / f); /* read-high */
+                __clear_bit(msr, msr_bitmap + 0xc00 / f); /* write-high */
         }
-        kunmap(msr_bitmap);
+}
+
+static void vmx_disable_intercept_for_msr(u32 msr, bool longmode_only)
+{
+        if (!longmode_only)
+                __vmx_disable_intercept_for_msr(vmx_msr_bitmap_legacy, msr);
+        __vmx_disable_intercept_for_msr(vmx_msr_bitmap_longmode, msr);
 }
 
 /*
@@ -2121,11 +2174,11 @@ static int vmx_vcpu_setup(struct vcpu_vmx *vmx)
         u32 exec_control;
 
         /* I/O */
-        vmcs_write64(IO_BITMAP_A, page_to_phys(vmx_io_bitmap_a));
-        vmcs_write64(IO_BITMAP_B, page_to_phys(vmx_io_bitmap_b));
+        vmcs_write64(IO_BITMAP_A, __pa(vmx_io_bitmap_a));
+        vmcs_write64(IO_BITMAP_B, __pa(vmx_io_bitmap_b));
 
         if (cpu_has_vmx_msr_bitmap())
-                vmcs_write64(MSR_BITMAP, page_to_phys(vmx_msr_bitmap));
+                vmcs_write64(MSR_BITMAP, __pa(vmx_msr_bitmap_legacy));
 
         vmcs_write64(VMCS_LINK_POINTER, -1ull); /* 22.3.1.5 */
 
@@ -2141,7 +2194,7 @@ static int vmx_vcpu_setup(struct vcpu_vmx *vmx)
                                 CPU_BASED_CR8_LOAD_EXITING;
 #endif
         }
-        if (!vm_need_ept())
+        if (!enable_ept)
                 exec_control |= CPU_BASED_CR3_STORE_EXITING |
                                 CPU_BASED_CR3_LOAD_EXITING  |
                                 CPU_BASED_INVLPG_EXITING;
@@ -2154,7 +2207,7 @@ static int vmx_vcpu_setup(struct vcpu_vmx *vmx)
                                 ~SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES;
                 if (vmx->vpid == 0)
                         exec_control &= ~SECONDARY_EXEC_ENABLE_VPID;
-                if (!vm_need_ept())
+                if (!enable_ept)
                         exec_control &= ~SECONDARY_EXEC_ENABLE_EPT;
                 vmcs_write32(SECONDARY_VM_EXEC_CONTROL, exec_control);
         }
@@ -2273,7 +2326,7 @@ static int vmx_vcpu_reset(struct kvm_vcpu *vcpu)
                 goto out;
         }
 
-        vmx->vcpu.arch.rmode.active = 0;
+        vmx->vcpu.arch.rmode.vm86_active = 0;
 
         vmx->soft_vnmi_blocked = 0;
 
@@ -2402,14 +2455,16 @@ static void enable_nmi_window(struct kvm_vcpu *vcpu)
         vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control);
 }
 
-static void vmx_inject_irq(struct kvm_vcpu *vcpu, int irq)
+static void vmx_inject_irq(struct kvm_vcpu *vcpu)
 {
         struct vcpu_vmx *vmx = to_vmx(vcpu);
+        uint32_t intr;
+        int irq = vcpu->arch.interrupt.nr;
 
         KVMTRACE_1D(INJ_VIRQ, vcpu, (u32)irq, handler);
 
         ++vcpu->stat.irq_injections;
-        if (vcpu->arch.rmode.active) {
+        if (vcpu->arch.rmode.vm86_active) {
                 vmx->rmode.irq.pending = true;
                 vmx->rmode.irq.vector = irq;
                 vmx->rmode.irq.rip = kvm_rip_read(vcpu);
@@ -2419,8 +2474,14 @@ static void vmx_inject_irq(struct kvm_vcpu *vcpu, int irq)
                 kvm_rip_write(vcpu, vmx->rmode.irq.rip - 1);
                 return;
         }
-        vmcs_write32(VM_ENTRY_INTR_INFO_FIELD,
-                        irq | INTR_TYPE_EXT_INTR | INTR_INFO_VALID_MASK);
+        intr = irq | INTR_INFO_VALID_MASK;
+        if (vcpu->arch.interrupt.soft) {
+                intr |= INTR_TYPE_SOFT_INTR;
+                vmcs_write32(VM_ENTRY_INSTRUCTION_LEN,
+                             vmx->vcpu.arch.event_exit_inst_len);
+        } else
+                intr |= INTR_TYPE_EXT_INTR;
+        vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, intr);
 }
 
 static void vmx_inject_nmi(struct kvm_vcpu *vcpu)
@@ -2441,7 +2502,7 @@ static void vmx_inject_nmi(struct kvm_vcpu *vcpu)
         }
 
         ++vcpu->stat.nmi_injections;
-        if (vcpu->arch.rmode.active) {
+        if (vcpu->arch.rmode.vm86_active) {
                 vmx->rmode.irq.pending = true;
                 vmx->rmode.irq.vector = NMI_VECTOR;
                 vmx->rmode.irq.rip = kvm_rip_read(vcpu);
@@ -2456,76 +2517,21 @@ static void vmx_inject_nmi(struct kvm_vcpu *vcpu)
                         INTR_TYPE_NMI_INTR | INTR_INFO_VALID_MASK | NMI_VECTOR);
 }
 
-static void vmx_update_window_states(struct kvm_vcpu *vcpu)
+static int vmx_nmi_allowed(struct kvm_vcpu *vcpu)
 {
-        u32 guest_intr = vmcs_read32(GUEST_INTERRUPTIBILITY_INFO);
-
-        vcpu->arch.nmi_window_open =
-                !(guest_intr & (GUEST_INTR_STATE_STI |
-                                GUEST_INTR_STATE_MOV_SS |
-                                GUEST_INTR_STATE_NMI));
         if (!cpu_has_virtual_nmis() && to_vmx(vcpu)->soft_vnmi_blocked)
-                vcpu->arch.nmi_window_open = 0;
-
-        vcpu->arch.interrupt_window_open =
-                ((vmcs_readl(GUEST_RFLAGS) & X86_EFLAGS_IF) &&
-                 !(guest_intr & (GUEST_INTR_STATE_STI |
-                                 GUEST_INTR_STATE_MOV_SS)));
-}
-
-static void kvm_do_inject_irq(struct kvm_vcpu *vcpu)
-{
-        int word_index = __ffs(vcpu->arch.irq_summary);
-        int bit_index = __ffs(vcpu->arch.irq_pending[word_index]);
-        int irq = word_index * BITS_PER_LONG + bit_index;
+                return 0;
 
-        clear_bit(bit_index, &vcpu->arch.irq_pending[word_index]);
-        if (!vcpu->arch.irq_pending[word_index])
-                clear_bit(word_index, &vcpu->arch.irq_summary);
-        kvm_queue_interrupt(vcpu, irq);
+        return  !(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) &
+                        (GUEST_INTR_STATE_STI | GUEST_INTR_STATE_MOV_SS |
+                                GUEST_INTR_STATE_NMI));
 }
 
-static void do_interrupt_requests(struct kvm_vcpu *vcpu,
-                                       struct kvm_run *kvm_run)
+static int vmx_interrupt_allowed(struct kvm_vcpu *vcpu)
 {
-        vmx_update_window_states(vcpu);
-
-        if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP)
-                vmcs_clear_bits(GUEST_INTERRUPTIBILITY_INFO,
-                                GUEST_INTR_STATE_STI |
-                                GUEST_INTR_STATE_MOV_SS);
-
-        if (vcpu->arch.nmi_pending && !vcpu->arch.nmi_injected) {
-                if (vcpu->arch.interrupt.pending) {
-                        enable_nmi_window(vcpu);
-                } else if (vcpu->arch.nmi_window_open) {
-                        vcpu->arch.nmi_pending = false;
-                        vcpu->arch.nmi_injected = true;
-                } else {
-                        enable_nmi_window(vcpu);
-                        return;
-                }
-        }
-        if (vcpu->arch.nmi_injected) {
-                vmx_inject_nmi(vcpu);
-                if (vcpu->arch.nmi_pending)
-                        enable_nmi_window(vcpu);
-                else if (vcpu->arch.irq_summary
-                         || kvm_run->request_interrupt_window)
-                        enable_irq_window(vcpu);
-                return;
-        }
-
-        if (vcpu->arch.interrupt_window_open) {
-                if (vcpu->arch.irq_summary && !vcpu->arch.interrupt.pending)
-                        kvm_do_inject_irq(vcpu);
-
-                if (vcpu->arch.interrupt.pending)
-                        vmx_inject_irq(vcpu, vcpu->arch.interrupt.nr);
-        }
-        if (!vcpu->arch.interrupt_window_open &&
-            (vcpu->arch.irq_summary || kvm_run->request_interrupt_window))
-                enable_irq_window(vcpu);
+        return (vmcs_readl(GUEST_RFLAGS) & X86_EFLAGS_IF) &&
+                !(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) &
+                        (GUEST_INTR_STATE_STI | GUEST_INTR_STATE_MOV_SS));
 }
 
 static int vmx_set_tss_addr(struct kvm *kvm, unsigned int addr)
@@ -2585,6 +2591,31 @@ static int handle_rmode_exception(struct kvm_vcpu *vcpu,
         return 0;
 }
 
+/*
+ * Trigger machine check on the host. We assume all the MSRs are already set up
+ * by the CPU and that we still run on the same CPU as the MCE occurred on.
+ * We pass a fake environment to the machine check handler because we want
+ * the guest to be always treated like user space, no matter what context
+ * it used internally.
+ */
+static void kvm_machine_check(void)
+{
+#if defined(CONFIG_X86_MCE) && defined(CONFIG_X86_64)
+        struct pt_regs regs = {
+                .cs = 3, /* Fake ring 3 no matter what the guest ran on */
+                .flags = X86_EFLAGS_IF,
+        };
+
+        do_machine_check(&regs, 0);
+#endif
+}
+
+static int handle_machine_check(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+{
+        /* already handled by vcpu_run */
+        return 1;
+}
+
 static int handle_exception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 {
         struct vcpu_vmx *vmx = to_vmx(vcpu);
@@ -2596,17 +2627,14 @@ static int handle_exception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
         vect_info = vmx->idt_vectoring_info;
         intr_info = vmcs_read32(VM_EXIT_INTR_INFO);
 
+        if (is_machine_check(intr_info))
+                return handle_machine_check(vcpu, kvm_run);
+
         if ((vect_info & VECTORING_INFO_VALID_MASK) &&
                                                 !is_page_fault(intr_info))
                 printk(KERN_ERR "%s: unexpected, vectoring info 0x%x "
                        "intr info 0x%x\n", __func__, vect_info, intr_info);
 
-        if (!irqchip_in_kernel(vcpu->kvm) && is_external_interrupt(vect_info)) {
-                int irq = vect_info & VECTORING_INFO_VECTOR_MASK;
-                set_bit(irq, vcpu->arch.irq_pending);
-                set_bit(irq / BITS_PER_LONG, &vcpu->arch.irq_summary);
-        }
-
         if ((intr_info & INTR_INFO_INTR_TYPE_MASK) == INTR_TYPE_NMI_INTR)
                 return 1;  /* already handled by vmx_vcpu_run() */
 
@@ -2628,17 +2656,17 @@ static int handle_exception(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
                 error_code = vmcs_read32(VM_EXIT_INTR_ERROR_CODE);
         if (is_page_fault(intr_info)) {
                 /* EPT won't cause page fault directly */
-                if (vm_need_ept())
+                if (enable_ept)
                         BUG();
                 cr2 = vmcs_readl(EXIT_QUALIFICATION);
                 KVMTRACE_3D(PAGE_FAULT, vcpu, error_code, (u32)cr2,
                             (u32)((u64)cr2 >> 32), handler);
-                if (vcpu->arch.interrupt.pending || vcpu->arch.exception.pending)
+                if (kvm_event_needs_reinjection(vcpu))
                         kvm_mmu_unprotect_page_virt(vcpu, cr2);
                 return kvm_mmu_page_fault(vcpu, cr2, error_code);
         }
 
-        if (vcpu->arch.rmode.active &&
+        if (vcpu->arch.rmode.vm86_active &&
             handle_rmode_exception(vcpu, intr_info & INTR_INFO_VECTOR_MASK,
                                                                 error_code)) {
                 if (vcpu->arch.halt_request) {
@@ -2753,13 +2781,18 @@ static int handle_cr(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
                         kvm_set_cr4(vcpu, kvm_register_read(vcpu, reg));
                         skip_emulated_instruction(vcpu);
                         return 1;
-                case 8:
-                        kvm_set_cr8(vcpu, kvm_register_read(vcpu, reg));
-                        skip_emulated_instruction(vcpu);
-                        if (irqchip_in_kernel(vcpu->kvm))
-                                return 1;
-                        kvm_run->exit_reason = KVM_EXIT_SET_TPR;
-                        return 0;
+                case 8: {
+                                u8 cr8_prev = kvm_get_cr8(vcpu);
+                                u8 cr8 = kvm_register_read(vcpu, reg);
+                                kvm_set_cr8(vcpu, cr8);
+                                skip_emulated_instruction(vcpu);
+                                if (irqchip_in_kernel(vcpu->kvm))
+                                        return 1;
+                                if (cr8_prev <= cr8)
+                                        return 1;
+                                kvm_run->exit_reason = KVM_EXIT_SET_TPR;
+                                return 0;
+                        }
                 };
                 break;
         case 2: /* clts */
@@ -2957,8 +2990,9 @@ static int handle_interrupt_window(struct kvm_vcpu *vcpu,
          * If the user space waits to inject interrupts, exit as soon as
          * possible
          */
-        if (kvm_run->request_interrupt_window &&
-            !vcpu->arch.irq_summary) {
+        if (!irqchip_in_kernel(vcpu->kvm) &&
+            kvm_run->request_interrupt_window &&
+            !kvm_cpu_has_interrupt(vcpu)) {
                 kvm_run->exit_reason = KVM_EXIT_IRQ_WINDOW_OPEN;
                 return 0;
         }
@@ -2980,7 +3014,7 @@ static int handle_vmcall(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 
 static int handle_invlpg(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 {
-        u64 exit_qualification = vmcs_read64(EXIT_QUALIFICATION);
+        unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
 
         kvm_mmu_invlpg(vcpu, exit_qualification);
         skip_emulated_instruction(vcpu);
@@ -2996,11 +3030,11 @@ static int handle_wbinvd(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 
 static int handle_apic_access(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 {
-        u64 exit_qualification;
+        unsigned long exit_qualification;
         enum emulation_result er;
         unsigned long offset;
 
-        exit_qualification = vmcs_read64(EXIT_QUALIFICATION);
+        exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
         offset = exit_qualification & 0xffful;
 
         er = emulate_instruction(vcpu, kvm_run, 0, 0, 0);
@@ -3019,22 +3053,41 @@ static int handle_task_switch(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
         struct vcpu_vmx *vmx = to_vmx(vcpu);
         unsigned long exit_qualification;
         u16 tss_selector;
-        int reason;
+        int reason, type, idt_v;
+
+        idt_v = (vmx->idt_vectoring_info & VECTORING_INFO_VALID_MASK);
+        type = (vmx->idt_vectoring_info & VECTORING_INFO_TYPE_MASK);
 
         exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
 
         reason = (u32)exit_qualification >> 30;
-        if (reason == TASK_SWITCH_GATE && vmx->vcpu.arch.nmi_injected &&
-            (vmx->idt_vectoring_info & VECTORING_INFO_VALID_MASK) &&
-            (vmx->idt_vectoring_info & VECTORING_INFO_TYPE_MASK)
-            == INTR_TYPE_NMI_INTR) {
-                vcpu->arch.nmi_injected = false;
-                if (cpu_has_virtual_nmis())
-                        vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO,
-                                      GUEST_INTR_STATE_NMI);
+        if (reason == TASK_SWITCH_GATE && idt_v) {
+                switch (type) {
+                case INTR_TYPE_NMI_INTR:
+                        vcpu->arch.nmi_injected = false;
+                        if (cpu_has_virtual_nmis())
+                                vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO,
+                                              GUEST_INTR_STATE_NMI);
+                        break;
+                case INTR_TYPE_EXT_INTR:
+                case INTR_TYPE_SOFT_INTR:
+                        kvm_clear_interrupt_queue(vcpu);
+                        break;
+                case INTR_TYPE_HARD_EXCEPTION:
+                case INTR_TYPE_SOFT_EXCEPTION:
+                        kvm_clear_exception_queue(vcpu);
+                        break;
+                default:
+                        break;
+                }
         }
         tss_selector = exit_qualification;
 
+        if (!idt_v || (type != INTR_TYPE_HARD_EXCEPTION &&
+                       type != INTR_TYPE_EXT_INTR &&
+                       type != INTR_TYPE_NMI_INTR))
+                skip_emulated_instruction(vcpu);
+
         if (!kvm_task_switch(vcpu, tss_selector, reason))
                 return 0;
 
@@ -3051,11 +3104,11 @@ static int handle_task_switch(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 
 static int handle_ept_violation(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 {
-        u64 exit_qualification;
+        unsigned long exit_qualification;
         gpa_t gpa;
         int gla_validity;
 
-        exit_qualification = vmcs_read64(EXIT_QUALIFICATION);
+        exit_qualification = vmcs_readl(EXIT_QUALIFICATION);
 
         if (exit_qualification & (1 << 6)) {
                 printk(KERN_ERR "EPT: GPA exceeds GAW!\n");
@@ -3067,7 +3120,7 @@ static int handle_ept_violation(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
                 printk(KERN_ERR "EPT: Handling EPT violation failed!\n");
                 printk(KERN_ERR "EPT: GPA: 0x%lx, GVA: 0x%lx\n",
                         (long unsigned int)vmcs_read64(GUEST_PHYSICAL_ADDRESS),
-                        (long unsigned int)vmcs_read64(GUEST_LINEAR_ADDRESS));
+                        vmcs_readl(GUEST_LINEAR_ADDRESS));
                 printk(KERN_ERR "EPT: Exit qualification is 0x%lx\n",
                         (long unsigned int)exit_qualification);
                 kvm_run->exit_reason = KVM_EXIT_UNKNOWN;
@@ -3150,6 +3203,7 @@ static int (*kvm_vmx_exit_handlers[])(struct kvm_vcpu *vcpu,
         [EXIT_REASON_WBINVD]                  = handle_wbinvd,
         [EXIT_REASON_TASK_SWITCH]             = handle_task_switch,
         [EXIT_REASON_EPT_VIOLATION]           = handle_ept_violation,
+        [EXIT_REASON_MCE_DURING_VMENTRY]      = handle_machine_check,
 };
 
 static const int kvm_vmx_max_exit_handlers =
@@ -3159,10 +3213,10 @@ static const int kvm_vmx_max_exit_handlers =
  * The guest has exited.  See if we can fix it or if we need userspace
  * assistance.
  */
-static int kvm_handle_exit(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu)
+static int vmx_handle_exit(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu)
 {
-        u32 exit_reason = vmcs_read32(VM_EXIT_REASON);
         struct vcpu_vmx *vmx = to_vmx(vcpu);
+        u32 exit_reason = vmx->exit_reason;
         u32 vectoring_info = vmx->idt_vectoring_info;
 
         KVMTRACE_3D(VMEXIT, vcpu, exit_reason, (u32)kvm_rip_read(vcpu),
@@ -3178,7 +3232,7 @@ static int kvm_handle_exit(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu)
 
         /* Access CR3 don't cause VMExit in paging mode, so we need
          * to sync with guest real CR3. */
-        if (vm_need_ept() && is_paging(vcpu)) {
+        if (enable_ept && is_paging(vcpu)) {
                 vcpu->arch.cr3 = vmcs_readl(GUEST_CR3);
                 ept_load_pdptrs(vcpu);
         }
@@ -3199,9 +3253,8 @@ static int kvm_handle_exit(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu)
                        __func__, vectoring_info, exit_reason);
 
         if (unlikely(!cpu_has_virtual_nmis() && vmx->soft_vnmi_blocked)) {
-                if (vcpu->arch.interrupt_window_open) {
+                if (vmx_interrupt_allowed(vcpu)) {
                         vmx->soft_vnmi_blocked = 0;
-                        vcpu->arch.nmi_window_open = 1;
                 } else if (vmx->vnmi_blocked_time > 1000000000LL &&
                            vcpu->arch.nmi_pending) {
                         /*
@@ -3214,7 +3267,6 @@ static int kvm_handle_exit(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu)
                                "state on VCPU %d after 1 s timeout\n",
                                __func__, vcpu->vcpu_id);
                         vmx->soft_vnmi_blocked = 0;
-                        vmx->vcpu.arch.nmi_window_open = 1;
                 }
         }
 
@@ -3228,122 +3280,107 @@ static int kvm_handle_exit(struct kvm_run *kvm_run, struct kvm_vcpu *vcpu)
         return 0;
 }
 
-static void update_tpr_threshold(struct kvm_vcpu *vcpu)
+static void update_cr8_intercept(struct kvm_vcpu *vcpu, int tpr, int irr)
 {
-        int max_irr, tpr;
-
-        if (!vm_need_tpr_shadow(vcpu->kvm))
-                return;
-
-        if (!kvm_lapic_enabled(vcpu) ||
-            ((max_irr = kvm_lapic_find_highest_irr(vcpu)) == -1)) {
+        if (irr == -1 || tpr < irr) {
                 vmcs_write32(TPR_THRESHOLD, 0);
                 return;
         }
 
-        tpr = (kvm_lapic_get_cr8(vcpu) & 0x0f) << 4;
-        vmcs_write32(TPR_THRESHOLD, (max_irr > tpr) ? tpr >> 4 : max_irr >> 4);
+        vmcs_write32(TPR_THRESHOLD, irr);
 }
 
 static void vmx_complete_interrupts(struct vcpu_vmx *vmx)
 {
         u32 exit_intr_info;
-        u32 idt_vectoring_info;
+        u32 idt_vectoring_info = vmx->idt_vectoring_info;
         bool unblock_nmi;
         u8 vector;
         int type;
         bool idtv_info_valid;
-        u32 error;
 
         exit_intr_info = vmcs_read32(VM_EXIT_INTR_INFO);
+
+        vmx->exit_reason = vmcs_read32(VM_EXIT_REASON);
+
+        /* Handle machine checks before interrupts are enabled */
+        if ((vmx->exit_reason == EXIT_REASON_MCE_DURING_VMENTRY)
+            || (vmx->exit_reason == EXIT_REASON_EXCEPTION_NMI
+                && is_machine_check(exit_intr_info)))
+                kvm_machine_check();
+
+        /* We need to handle NMIs before interrupts are enabled */
+        if ((exit_intr_info & INTR_INFO_INTR_TYPE_MASK) == INTR_TYPE_NMI_INTR &&
+            (exit_intr_info & INTR_INFO_VALID_MASK)) {
+                KVMTRACE_0D(NMI, &vmx->vcpu, handler);
+                asm("int $2");
+        }
+
+        idtv_info_valid = idt_vectoring_info & VECTORING_INFO_VALID_MASK;
+
         if (cpu_has_virtual_nmis()) {
                 unblock_nmi = (exit_intr_info & INTR_INFO_UNBLOCK_NMI) != 0;
                 vector = exit_intr_info & INTR_INFO_VECTOR_MASK;
                 /*
-                 * SDM 3: 25.7.1.2
+                 * SDM 3: 27.7.1.2 (September 2008)
                  * Re-set bit "block by NMI" before VM entry if vmexit caused by
                  * a guest IRET fault.
+                 * SDM 3: 23.2.2 (September 2008)
+                 * Bit 12 is undefined in any of the following cases:
+                 *  If the VM exit sets the valid bit in the IDT-vectoring
+                 *   information field.
+                 *  If the VM exit is due to a double fault.
                  */
-                if (unblock_nmi && vector != DF_VECTOR)
+                if ((exit_intr_info & INTR_INFO_VALID_MASK) && unblock_nmi &&
+                    vector != DF_VECTOR && !idtv_info_valid)
                         vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO,
                                       GUEST_INTR_STATE_NMI);
         } else if (unlikely(vmx->soft_vnmi_blocked))
                 vmx->vnmi_blocked_time +=
                         ktime_to_ns(ktime_sub(ktime_get(), vmx->entry_time));
 
-        idt_vectoring_info = vmx->idt_vectoring_info;
-        idtv_info_valid = idt_vectoring_info & VECTORING_INFO_VALID_MASK;
+        vmx->vcpu.arch.nmi_injected = false;
+        kvm_clear_exception_queue(&vmx->vcpu);
+        kvm_clear_interrupt_queue(&vmx->vcpu);
+
+        if (!idtv_info_valid)
+                return;
+
         vector = idt_vectoring_info & VECTORING_INFO_VECTOR_MASK;
         type = idt_vectoring_info & VECTORING_INFO_TYPE_MASK;
-        if (vmx->vcpu.arch.nmi_injected) {
+
+        switch (type) {
+        case INTR_TYPE_NMI_INTR:
+                vmx->vcpu.arch.nmi_injected = true;
                 /*
-                 * SDM 3: 25.7.1.2
-                 * Clear bit "block by NMI" before VM entry if a NMI delivery
-                 * faulted.
+                 * SDM 3: 27.7.1.2 (September 2008)
+                 * Clear bit "block by NMI" before VM entry if a NMI
+                 * delivery faulted.
                  */
-                if (idtv_info_valid && type == INTR_TYPE_NMI_INTR)
-                        vmcs_clear_bits(GUEST_INTERRUPTIBILITY_INFO,
-                                        GUEST_INTR_STATE_NMI);
-                else
-                        vmx->vcpu.arch.nmi_injected = false;
-        }
-        kvm_clear_exception_queue(&vmx->vcpu);
-        if (idtv_info_valid && (type == INTR_TYPE_HARD_EXCEPTION ||
-                                type == INTR_TYPE_SOFT_EXCEPTION)) {
+                vmcs_clear_bits(GUEST_INTERRUPTIBILITY_INFO,
+                                GUEST_INTR_STATE_NMI);
+                break;
+        case INTR_TYPE_SOFT_EXCEPTION:
+                vmx->vcpu.arch.event_exit_inst_len =
+                        vmcs_read32(VM_EXIT_INSTRUCTION_LEN);
+                /* fall through */
+        case INTR_TYPE_HARD_EXCEPTION:
                 if (idt_vectoring_info & VECTORING_INFO_DELIVER_CODE_MASK) {
-                        error = vmcs_read32(IDT_VECTORING_ERROR_CODE);
-                        kvm_queue_exception_e(&vmx->vcpu, vector, error);
+                        u32 err = vmcs_read32(IDT_VECTORING_ERROR_CODE);
+                        kvm_queue_exception_e(&vmx->vcpu, vector, err);
                 } else
                         kvm_queue_exception(&vmx->vcpu, vector);
-                vmx->idt_vectoring_info = 0;
-        }
-        kvm_clear_interrupt_queue(&vmx->vcpu);
-        if (idtv_info_valid && type == INTR_TYPE_EXT_INTR) {
-                kvm_queue_interrupt(&vmx->vcpu, vector);
-                vmx->idt_vectoring_info = 0;
-        }
-}
-
-static void vmx_intr_assist(struct kvm_vcpu *vcpu)
-{
-        update_tpr_threshold(vcpu);
-
-        vmx_update_window_states(vcpu);
-
-        if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP)
-                vmcs_clear_bits(GUEST_INTERRUPTIBILITY_INFO,
-                                GUEST_INTR_STATE_STI |
-                                GUEST_INTR_STATE_MOV_SS);
-
-        if (vcpu->arch.nmi_pending && !vcpu->arch.nmi_injected) {
-                if (vcpu->arch.interrupt.pending) {
-                        enable_nmi_window(vcpu);
-                } else if (vcpu->arch.nmi_window_open) {
-                        vcpu->arch.nmi_pending = false;
-                        vcpu->arch.nmi_injected = true;
-                } else {
-                        enable_nmi_window(vcpu);
-                        return;
-                }
-        }
-        if (vcpu->arch.nmi_injected) {
-                vmx_inject_nmi(vcpu);
-                if (vcpu->arch.nmi_pending)
-                        enable_nmi_window(vcpu);
-                else if (kvm_cpu_has_interrupt(vcpu))
-                        enable_irq_window(vcpu);
-                return;
-        }
-        if (!vcpu->arch.interrupt.pending && kvm_cpu_has_interrupt(vcpu)) {
-                if (vcpu->arch.interrupt_window_open)
-                        kvm_queue_interrupt(vcpu, kvm_cpu_get_interrupt(vcpu));
-                else
-                        enable_irq_window(vcpu);
-        }
-        if (vcpu->arch.interrupt.pending) {
-                vmx_inject_irq(vcpu, vcpu->arch.interrupt.nr);
-                if (kvm_cpu_has_interrupt(vcpu))
-                        enable_irq_window(vcpu);
+                break;
+        case INTR_TYPE_SOFT_INTR:
+                vmx->vcpu.arch.event_exit_inst_len =
+                        vmcs_read32(VM_EXIT_INSTRUCTION_LEN);
+                /* fall through */
+        case INTR_TYPE_EXT_INTR:
+                kvm_queue_interrupt(&vmx->vcpu, vector,
+                        type == INTR_TYPE_SOFT_INTR);
+                break;
+        default:
+                break;
         }
 }
 
@@ -3381,7 +3418,6 @@ static void fixup_rmode_irq(struct vcpu_vmx *vmx)
 static void vmx_vcpu_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 {
         struct vcpu_vmx *vmx = to_vmx(vcpu);
-        u32 intr_info;
 
         /* Record the guest's net vcpu time for enforced NMI injections. */
         if (unlikely(!cpu_has_virtual_nmis() && vmx->soft_vnmi_blocked))
@@ -3505,20 +3541,9 @@ static void vmx_vcpu_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
         if (vmx->rmode.irq.pending)
                 fixup_rmode_irq(vmx);
 
-        vmx_update_window_states(vcpu);
-
         asm("mov %0, %%ds; mov %0, %%es" : : "r"(__USER_DS));
         vmx->launched = 1;
 
-        intr_info = vmcs_read32(VM_EXIT_INTR_INFO);
-
-        /* We need to handle NMIs before interrupts are enabled */
-        if ((intr_info & INTR_INFO_INTR_TYPE_MASK) == INTR_TYPE_NMI_INTR &&
-            (intr_info & INTR_INFO_VALID_MASK)) {
-                KVMTRACE_0D(NMI, vcpu, handler);
-                asm("int $2");
-        }
-
         vmx_complete_interrupts(vmx);
 }
 
@@ -3593,7 +3618,7 @@ static struct kvm_vcpu *vmx_create_vcpu(struct kvm *kvm, unsigned int id)
                 if (alloc_apic_access_page(kvm) != 0)
                         goto free_vmcs;
 
-        if (vm_need_ept())
+        if (enable_ept)
                 if (alloc_identity_pagetable(kvm) != 0)
                         goto free_vmcs;
 
@@ -3631,9 +3656,32 @@ static int get_ept_level(void)
         return VMX_EPT_DEFAULT_GAW + 1;
 }
 
-static int vmx_get_mt_mask_shift(void)
+static u64 vmx_get_mt_mask(struct kvm_vcpu *vcpu, gfn_t gfn, bool is_mmio)
 {
-        return VMX_EPT_MT_EPTE_SHIFT;
+        u64 ret;
+
+        /* For VT-d and EPT combination
+         * 1. MMIO: always map as UC
+         * 2. EPT with VT-d:
+         *   a. VT-d without snooping control feature: can't guarantee the
+         *      result, try to trust guest.
+         *   b. VT-d with snooping control feature: snooping control feature of
+         *      VT-d engine can guarantee the cache correctness. Just set it
+         *      to WB to keep consistent with host. So the same as item 3.
+         * 3. EPT without VT-d: always map as WB and set IGMT=1 to keep
+         *    consistent with host MTRR
+         */
+        if (is_mmio)
+                ret = MTRR_TYPE_UNCACHABLE << VMX_EPT_MT_EPTE_SHIFT;
+        else if (vcpu->kvm->arch.iommu_domain &&
+                !(vcpu->kvm->arch.iommu_flags & KVM_IOMMU_CACHE_COHERENCY))
+                ret = kvm_get_guest_memory_type(vcpu, gfn) <<
+                      VMX_EPT_MT_EPTE_SHIFT;
+        else
+                ret = (MTRR_TYPE_WRBACK << VMX_EPT_MT_EPTE_SHIFT)
+                        | VMX_EPT_IGMT_BIT;
+
+        return ret;
 }
 
 static struct kvm_x86_ops vmx_x86_ops = {
@@ -3644,7 +3692,7 @@ static struct kvm_x86_ops vmx_x86_ops = {
         .check_processor_compatibility = vmx_check_processor_compat,
         .hardware_enable = hardware_enable,
         .hardware_disable = hardware_disable,
-        .cpu_has_accelerated_tpr = cpu_has_vmx_virtualize_apic_accesses,
+        .cpu_has_accelerated_tpr = report_flexpriority,
 
         .vcpu_create = vmx_create_vcpu,
         .vcpu_free = vmx_free_vcpu,
@@ -3678,78 +3726,82 @@ static struct kvm_x86_ops vmx_x86_ops = {
         .tlb_flush = vmx_flush_tlb,
 
         .run = vmx_vcpu_run,
-        .handle_exit = kvm_handle_exit,
+        .handle_exit = vmx_handle_exit,
         .skip_emulated_instruction = skip_emulated_instruction,
+        .set_interrupt_shadow = vmx_set_interrupt_shadow,
+        .get_interrupt_shadow = vmx_get_interrupt_shadow,
         .patch_hypercall = vmx_patch_hypercall,
-        .get_irq = vmx_get_irq,
         .set_irq = vmx_inject_irq,
+        .set_nmi = vmx_inject_nmi,
         .queue_exception = vmx_queue_exception,
-        .exception_injected = vmx_exception_injected,
-        .inject_pending_irq = vmx_intr_assist,
-        .inject_pending_vectors = do_interrupt_requests,
+        .interrupt_allowed = vmx_interrupt_allowed,
+        .nmi_allowed = vmx_nmi_allowed,
+        .enable_nmi_window = enable_nmi_window,
+        .enable_irq_window = enable_irq_window,
+        .update_cr8_intercept = update_cr8_intercept,
 
         .set_tss_addr = vmx_set_tss_addr,
         .get_tdp_level = get_ept_level,
-        .get_mt_mask_shift = vmx_get_mt_mask_shift,
+        .get_mt_mask = vmx_get_mt_mask,
 };
 
 static int __init vmx_init(void)
 {
-        void *va;
         int r;
 
-        vmx_io_bitmap_a = alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
+        vmx_io_bitmap_a = (unsigned long *)__get_free_page(GFP_KERNEL);
         if (!vmx_io_bitmap_a)
                 return -ENOMEM;
 
-        vmx_io_bitmap_b = alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
+        vmx_io_bitmap_b = (unsigned long *)__get_free_page(GFP_KERNEL);
         if (!vmx_io_bitmap_b) {
                 r = -ENOMEM;
                 goto out;
         }
 
-        vmx_msr_bitmap = alloc_page(GFP_KERNEL | __GFP_HIGHMEM);
-        if (!vmx_msr_bitmap) {
+        vmx_msr_bitmap_legacy = (unsigned long *)__get_free_page(GFP_KERNEL);
+        if (!vmx_msr_bitmap_legacy) {
                 r = -ENOMEM;
                 goto out1;
         }
 
+        vmx_msr_bitmap_longmode = (unsigned long *)__get_free_page(GFP_KERNEL);
+        if (!vmx_msr_bitmap_longmode) {
+                r = -ENOMEM;
+                goto out2;
+        }
+
         /*
          * Allow direct access to the PC debug port (it is often used for I/O
          * delays, but the vmexits simply slow things down).
          */
-        va = kmap(vmx_io_bitmap_a);
-        memset(va, 0xff, PAGE_SIZE);
-        clear_bit(0x80, va);
-        kunmap(vmx_io_bitmap_a);
+        memset(vmx_io_bitmap_a, 0xff, PAGE_SIZE);
+        clear_bit(0x80, vmx_io_bitmap_a);
 
-        va = kmap(vmx_io_bitmap_b);
-        memset(va, 0xff, PAGE_SIZE);
-        kunmap(vmx_io_bitmap_b);
+        memset(vmx_io_bitmap_b, 0xff, PAGE_SIZE);
 
-        va = kmap(vmx_msr_bitmap);
-        memset(va, 0xff, PAGE_SIZE);
-        kunmap(vmx_msr_bitmap);
+        memset(vmx_msr_bitmap_legacy, 0xff, PAGE_SIZE);
+        memset(vmx_msr_bitmap_longmode, 0xff, PAGE_SIZE);
 
         set_bit(0, vmx_vpid_bitmap); /* 0 is reserved for host */
 
         r = kvm_init(&vmx_x86_ops, sizeof(struct vcpu_vmx), THIS_MODULE);
         if (r)
-                goto out2;
+                goto out3;
 
-        vmx_disable_intercept_for_msr(vmx_msr_bitmap, MSR_FS_BASE);
-        vmx_disable_intercept_for_msr(vmx_msr_bitmap, MSR_GS_BASE);
-        vmx_disable_intercept_for_msr(vmx_msr_bitmap, MSR_IA32_SYSENTER_CS);
-        vmx_disable_intercept_for_msr(vmx_msr_bitmap, MSR_IA32_SYSENTER_ESP);
-        vmx_disable_intercept_for_msr(vmx_msr_bitmap, MSR_IA32_SYSENTER_EIP);
+        vmx_disable_intercept_for_msr(MSR_FS_BASE, false);
+        vmx_disable_intercept_for_msr(MSR_GS_BASE, false);
+        vmx_disable_intercept_for_msr(MSR_KERNEL_GS_BASE, true);
+        vmx_disable_intercept_for_msr(MSR_IA32_SYSENTER_CS, false);
+        vmx_disable_intercept_for_msr(MSR_IA32_SYSENTER_ESP, false);
+        vmx_disable_intercept_for_msr(MSR_IA32_SYSENTER_EIP, false);
 
-        if (vm_need_ept()) {
+        if (enable_ept) {
                 bypass_guest_pf = 0;
                 kvm_mmu_set_base_ptes(VMX_EPT_READABLE_MASK |
                         VMX_EPT_WRITABLE_MASK);
                 kvm_mmu_set_mask_ptes(0ull, 0ull, 0ull, 0ull,
-                                VMX_EPT_EXECUTABLE_MASK,
-                                VMX_EPT_DEFAULT_MT << VMX_EPT_MT_EPTE_SHIFT);
+                                VMX_EPT_EXECUTABLE_MASK);
                 kvm_enable_tdp();
         } else
                 kvm_disable_tdp();
@@ -3761,20 +3813,23 @@ static int __init vmx_init(void)
 
         return 0;
 
+out3:
+        free_page((unsigned long)vmx_msr_bitmap_longmode);
 out2:
-        __free_page(vmx_msr_bitmap);
+        free_page((unsigned long)vmx_msr_bitmap_legacy);
 out1:
-        __free_page(vmx_io_bitmap_b);
+        free_page((unsigned long)vmx_io_bitmap_b);
 out:
-        __free_page(vmx_io_bitmap_a);
+        free_page((unsigned long)vmx_io_bitmap_a);
         return r;
 }
 
 static void __exit vmx_exit(void)
 {
-        __free_page(vmx_msr_bitmap);
-        __free_page(vmx_io_bitmap_b);
-        __free_page(vmx_io_bitmap_a);
+        free_page((unsigned long)vmx_msr_bitmap_legacy);
+        free_page((unsigned long)vmx_msr_bitmap_longmode);
+        free_page((unsigned long)vmx_io_bitmap_b);
+        free_page((unsigned long)vmx_io_bitmap_a);
 
         kvm_exit();
 }
diff --git a/arch/x86/kvm/x86.c b/arch/x86/kvm/x86.c
index 3944e917e794..249540f98513 100644
--- a/arch/x86/kvm/x86.c
+++ b/arch/x86/kvm/x86.c
@@ -91,7 +91,6 @@ struct kvm_stats_debugfs_item debugfs_entries[] = {
         { "halt_wakeup", VCPU_STAT(halt_wakeup) },
         { "hypercalls", VCPU_STAT(hypercalls) },
         { "request_irq", VCPU_STAT(request_irq_exits) },
-        { "request_nmi", VCPU_STAT(request_nmi_exits) },
         { "irq_exits", VCPU_STAT(irq_exits) },
         { "host_state_reload", VCPU_STAT(host_state_reload) },
         { "efer_reload", VCPU_STAT(efer_reload) },
@@ -108,7 +107,6 @@ struct kvm_stats_debugfs_item debugfs_entries[] = {
         { "mmu_recycled", VM_STAT(mmu_recycled) },
         { "mmu_cache_miss", VM_STAT(mmu_cache_miss) },
         { "mmu_unsync", VM_STAT(mmu_unsync) },
-        { "mmu_unsync_global", VM_STAT(mmu_unsync_global) },
         { "remote_tlb_flush", VM_STAT(remote_tlb_flush) },
         { "largepages", VM_STAT(lpages) },
         { NULL }
@@ -234,7 +232,8 @@ int load_pdptrs(struct kvm_vcpu *vcpu, unsigned long cr3)
                 goto out;
         }
         for (i = 0; i < ARRAY_SIZE(pdpte); ++i) {
-                if ((pdpte[i] & 1) && (pdpte[i] & 0xfffffff0000001e6ull)) {
+                if (is_present_pte(pdpte[i]) &&
+                    (pdpte[i] & vcpu->arch.mmu.rsvd_bits_mask[0][2])) {
                         ret = 0;
                         goto out;
                 }
@@ -321,7 +320,6 @@ void kvm_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0)
         kvm_x86_ops->set_cr0(vcpu, cr0);
         vcpu->arch.cr0 = cr0;
 
-        kvm_mmu_sync_global(vcpu);
         kvm_mmu_reset_context(vcpu);
         return;
 }
@@ -370,7 +368,6 @@ void kvm_set_cr4(struct kvm_vcpu *vcpu, unsigned long cr4)
         kvm_x86_ops->set_cr4(vcpu, cr4);
         vcpu->arch.cr4 = cr4;
         vcpu->arch.mmu.base_role.cr4_pge = (cr4 & X86_CR4_PGE) && !tdp_enabled;
-        kvm_mmu_sync_global(vcpu);
         kvm_mmu_reset_context(vcpu);
 }
 EXPORT_SYMBOL_GPL(kvm_set_cr4);
@@ -523,6 +520,9 @@ static void set_efer(struct kvm_vcpu *vcpu, u64 efer)
         efer |= vcpu->arch.shadow_efer & EFER_LMA;
 
         vcpu->arch.shadow_efer = efer;
+
+        vcpu->arch.mmu.base_role.nxe = (efer & EFER_NX) && !tdp_enabled;
+        kvm_mmu_reset_context(vcpu);
 }
 
 void kvm_enable_efer_bits(u64 mask)
@@ -630,14 +630,17 @@ static void kvm_write_guest_time(struct kvm_vcpu *v)
         unsigned long flags;
         struct kvm_vcpu_arch *vcpu = &v->arch;
         void *shared_kaddr;
+        unsigned long this_tsc_khz;
 
         if ((!vcpu->time_page))
                 return;
 
-        if (unlikely(vcpu->hv_clock_tsc_khz != __get_cpu_var(cpu_tsc_khz))) {
-                kvm_set_time_scale(__get_cpu_var(cpu_tsc_khz), &vcpu->hv_clock);
-                vcpu->hv_clock_tsc_khz = __get_cpu_var(cpu_tsc_khz);
+        this_tsc_khz = get_cpu_var(cpu_tsc_khz);
+        if (unlikely(vcpu->hv_clock_tsc_khz != this_tsc_khz)) {
+                kvm_set_time_scale(this_tsc_khz, &vcpu->hv_clock);
+                vcpu->hv_clock_tsc_khz = this_tsc_khz;
         }
+        put_cpu_var(cpu_tsc_khz);
 
         /* Keep irq disabled to prevent changes to the clock */
         local_irq_save(flags);
@@ -893,6 +896,8 @@ int kvm_get_msr_common(struct kvm_vcpu *vcpu, u32 msr, u64 *pdata)
         case MSR_IA32_LASTINTFROMIP:
         case MSR_IA32_LASTINTTOIP:
         case MSR_VM_HSAVE_PA:
+        case MSR_P6_EVNTSEL0:
+        case MSR_P6_EVNTSEL1:
                 data = 0;
                 break;
         case MSR_MTRRcap:
@@ -1024,6 +1029,7 @@ int kvm_dev_ioctl_check_extension(long ext)
         case KVM_CAP_SYNC_MMU:
         case KVM_CAP_REINJECT_CONTROL:
         case KVM_CAP_IRQ_INJECT_STATUS:
+        case KVM_CAP_ASSIGN_DEV_IRQ:
                 r = 1;
                 break;
         case KVM_CAP_COALESCED_MMIO:
@@ -1241,41 +1247,53 @@ static void do_cpuid_1_ent(struct kvm_cpuid_entry2 *entry, u32 function,
         entry->flags = 0;
 }
 
+#define F(x) bit(X86_FEATURE_##x)
+
 static void do_cpuid_ent(struct kvm_cpuid_entry2 *entry, u32 function,
                          u32 index, int *nent, int maxnent)
 {
-        const u32 kvm_supported_word0_x86_features = bit(X86_FEATURE_FPU) |
-                bit(X86_FEATURE_VME) | bit(X86_FEATURE_DE) |
-                bit(X86_FEATURE_PSE) | bit(X86_FEATURE_TSC) |
-                bit(X86_FEATURE_MSR) | bit(X86_FEATURE_PAE) |
-                bit(X86_FEATURE_CX8) | bit(X86_FEATURE_APIC) |
-                bit(X86_FEATURE_SEP) | bit(X86_FEATURE_PGE) |
-                bit(X86_FEATURE_CMOV) | bit(X86_FEATURE_PSE36) |
-                bit(X86_FEATURE_CLFLSH) | bit(X86_FEATURE_MMX) |
-                bit(X86_FEATURE_FXSR) | bit(X86_FEATURE_XMM) |
-                bit(X86_FEATURE_XMM2) | bit(X86_FEATURE_SELFSNOOP);
-        const u32 kvm_supported_word1_x86_features = bit(X86_FEATURE_FPU) |
-                bit(X86_FEATURE_VME) | bit(X86_FEATURE_DE) |
-                bit(X86_FEATURE_PSE) | bit(X86_FEATURE_TSC) |
-                bit(X86_FEATURE_MSR) | bit(X86_FEATURE_PAE) |
-                bit(X86_FEATURE_CX8) | bit(X86_FEATURE_APIC) |
-                bit(X86_FEATURE_PGE) |
-                bit(X86_FEATURE_CMOV) | bit(X86_FEATURE_PSE36) |
-                bit(X86_FEATURE_MMX) | bit(X86_FEATURE_FXSR) |
-                bit(X86_FEATURE_SYSCALL) |
-                (is_efer_nx() ? bit(X86_FEATURE_NX) : 0) |
+        unsigned f_nx = is_efer_nx() ? F(NX) : 0;
 #ifdef CONFIG_X86_64
-                bit(X86_FEATURE_LM) |
+        unsigned f_lm = F(LM);
+#else
+        unsigned f_lm = 0;
 #endif
-                bit(X86_FEATURE_FXSR_OPT) |
-                bit(X86_FEATURE_MMXEXT) |
-                bit(X86_FEATURE_3DNOWEXT) |
-                bit(X86_FEATURE_3DNOW);
-        const u32 kvm_supported_word3_x86_features =
-                bit(X86_FEATURE_XMM3) | bit(X86_FEATURE_CX16);
+
+        /* cpuid 1.edx */
+        const u32 kvm_supported_word0_x86_features =
+                F(FPU) | F(VME) | F(DE) | F(PSE) |
+                F(TSC) | F(MSR) | F(PAE) | F(MCE) |
+                F(CX8) | F(APIC) | 0 /* Reserved */ | F(SEP) |
+                F(MTRR) | F(PGE) | F(MCA) | F(CMOV) |
+                F(PAT) | F(PSE36) | 0 /* PSN */ | F(CLFLSH) |
+                0 /* Reserved, DS, ACPI */ | F(MMX) |
+                F(FXSR) | F(XMM) | F(XMM2) | F(SELFSNOOP) |
+                0 /* HTT, TM, Reserved, PBE */;
+        /* cpuid 0x80000001.edx */
+        const u32 kvm_supported_word1_x86_features =
+                F(FPU) | F(VME) | F(DE) | F(PSE) |
+                F(TSC) | F(MSR) | F(PAE) | F(MCE) |
+                F(CX8) | F(APIC) | 0 /* Reserved */ | F(SYSCALL) |
+                F(MTRR) | F(PGE) | F(MCA) | F(CMOV) |
+                F(PAT) | F(PSE36) | 0 /* Reserved */ |
+                f_nx | 0 /* Reserved */ | F(MMXEXT) | F(MMX) |
+                F(FXSR) | F(FXSR_OPT) | 0 /* GBPAGES */ | 0 /* RDTSCP */ |
+                0 /* Reserved */ | f_lm | F(3DNOWEXT) | F(3DNOW);
+        /* cpuid 1.ecx */
+        const u32 kvm_supported_word4_x86_features =
+                F(XMM3) | 0 /* Reserved, DTES64, MONITOR */ |
+                0 /* DS-CPL, VMX, SMX, EST */ |
+                0 /* TM2 */ | F(SSSE3) | 0 /* CNXT-ID */ | 0 /* Reserved */ |
+                0 /* Reserved */ | F(CX16) | 0 /* xTPR Update, PDCM */ |
+                0 /* Reserved, DCA */ | F(XMM4_1) |
+                F(XMM4_2) | 0 /* x2APIC */ | F(MOVBE) | F(POPCNT) |
+                0 /* Reserved, XSAVE, OSXSAVE */;
+        /* cpuid 0x80000001.ecx */
         const u32 kvm_supported_word6_x86_features =
-                bit(X86_FEATURE_LAHF_LM) | bit(X86_FEATURE_CMP_LEGACY) |
-                bit(X86_FEATURE_SVM);
+                F(LAHF_LM) | F(CMP_LEGACY) | F(SVM) | 0 /* ExtApicSpace */ |
+                F(CR8_LEGACY) | F(ABM) | F(SSE4A) | F(MISALIGNSSE) |
+                F(3DNOWPREFETCH) | 0 /* OSVW */ | 0 /* IBS */ | F(SSE5) |
+                0 /* SKINIT */ | 0 /* WDT */;
 
         /* all calls to cpuid_count() should be made on the same cpu */
         get_cpu();
@@ -1288,7 +1306,7 @@ static void do_cpuid_ent(struct kvm_cpuid_entry2 *entry, u32 function,
                 break;
         case 1:
                 entry->edx &= kvm_supported_word0_x86_features;
-                entry->ecx &= kvm_supported_word3_x86_features;
+                entry->ecx &= kvm_supported_word4_x86_features;
                 break;
         /* function 2 entries are STATEFUL. That is, repeated cpuid commands
          * may return different values. This forces us to get_cpu() before
@@ -1350,6 +1368,8 @@ static void do_cpuid_ent(struct kvm_cpuid_entry2 *entry, u32 function,
         put_cpu();
 }
 
+#undef F
+
 static int kvm_dev_ioctl_get_supported_cpuid(struct kvm_cpuid2 *cpuid,
                                      struct kvm_cpuid_entry2 __user *entries)
 {
@@ -1421,8 +1441,7 @@ static int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu,
                 return -ENXIO;
         vcpu_load(vcpu);
 
-        set_bit(irq->irq, vcpu->arch.irq_pending);
-        set_bit(irq->irq / BITS_PER_LONG, &vcpu->arch.irq_summary);
+        kvm_queue_interrupt(vcpu, irq->irq, false);
 
         vcpu_put(vcpu);
 
@@ -1584,8 +1603,7 @@ long kvm_arch_vcpu_ioctl(struct file *filp,
                 r = -EINVAL;
         }
 out:
-        if (lapic)
-                kfree(lapic);
+        kfree(lapic);
         return r;
 }
 
@@ -1606,10 +1624,12 @@ static int kvm_vm_ioctl_set_nr_mmu_pages(struct kvm *kvm,
                 return -EINVAL;
 
         down_write(&kvm->slots_lock);
+        spin_lock(&kvm->mmu_lock);
 
         kvm_mmu_change_mmu_pages(kvm, kvm_nr_mmu_pages);
         kvm->arch.n_requested_mmu_pages = kvm_nr_mmu_pages;
 
+        spin_unlock(&kvm->mmu_lock);
         up_write(&kvm->slots_lock);
         return 0;
 }
@@ -1785,7 +1805,9 @@ int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
 
         /* If nothing is dirty, don't bother messing with page tables. */
         if (is_dirty) {
+                spin_lock(&kvm->mmu_lock);
                 kvm_mmu_slot_remove_write_access(kvm, log->slot);
+                spin_unlock(&kvm->mmu_lock);
                 kvm_flush_remote_tlbs(kvm);
                 memslot = &kvm->memslots[log->slot];
                 n = ALIGN(memslot->npages, BITS_PER_LONG) / 8;
@@ -2360,7 +2382,7 @@ int emulate_instruction(struct kvm_vcpu *vcpu,
                         u16 error_code,
                         int emulation_type)
 {
-        int r;
+        int r, shadow_mask;
         struct decode_cache *c;
 
         kvm_clear_exception_queue(vcpu);
@@ -2408,7 +2430,16 @@ int emulate_instruction(struct kvm_vcpu *vcpu,
                 }
         }
 
+        if (emulation_type & EMULTYPE_SKIP) {
+                kvm_rip_write(vcpu, vcpu->arch.emulate_ctxt.decode.eip);
+                return EMULATE_DONE;
+        }
+
         r = x86_emulate_insn(&vcpu->arch.emulate_ctxt, &emulate_ops);
+        shadow_mask = vcpu->arch.emulate_ctxt.interruptibility;
+
+        if (r == 0)
+                kvm_x86_ops->set_interrupt_shadow(vcpu, shadow_mask);
 
         if (vcpu->arch.pio.string)
                 return EMULATE_DO_MMIO;
@@ -2761,7 +2792,7 @@ int kvm_arch_init(void *opaque)
         kvm_mmu_set_nonpresent_ptes(0ull, 0ull);
         kvm_mmu_set_base_ptes(PT_PRESENT_MASK);
         kvm_mmu_set_mask_ptes(PT_USER_MASK, PT_ACCESSED_MASK,
-                        PT_DIRTY_MASK, PT64_NX_MASK, 0, 0);
+                        PT_DIRTY_MASK, PT64_NX_MASK, 0);
 
         for_each_possible_cpu(cpu)
                 per_cpu(cpu_tsc_khz, cpu) = tsc_khz;
@@ -3012,6 +3043,16 @@ struct kvm_cpuid_entry2 *kvm_find_cpuid_entry(struct kvm_vcpu *vcpu,
         return best;
 }
 
+int cpuid_maxphyaddr(struct kvm_vcpu *vcpu)
+{
+        struct kvm_cpuid_entry2 *best;
+
+        best = kvm_find_cpuid_entry(vcpu, 0x80000008, 0);
+        if (best)
+                return best->eax & 0xff;
+        return 36;
+}
+
 void kvm_emulate_cpuid(struct kvm_vcpu *vcpu)
 {
         u32 function, index;
@@ -3048,10 +3089,9 @@ EXPORT_SYMBOL_GPL(kvm_emulate_cpuid);
 static int dm_request_for_irq_injection(struct kvm_vcpu *vcpu,
                                           struct kvm_run *kvm_run)
 {
-        return (!vcpu->arch.irq_summary &&
+        return (!irqchip_in_kernel(vcpu->kvm) && !kvm_cpu_has_interrupt(vcpu) &&
                 kvm_run->request_interrupt_window &&
-                vcpu->arch.interrupt_window_open &&
-                (kvm_x86_ops->get_rflags(vcpu) & X86_EFLAGS_IF));
+                kvm_arch_interrupt_allowed(vcpu));
 }
 
 static void post_kvm_run_save(struct kvm_vcpu *vcpu,
@@ -3064,8 +3104,9 @@ static void post_kvm_run_save(struct kvm_vcpu *vcpu,
                 kvm_run->ready_for_interrupt_injection = 1;
         else
                 kvm_run->ready_for_interrupt_injection =
-                                        (vcpu->arch.interrupt_window_open &&
-                                         vcpu->arch.irq_summary == 0);
+                        kvm_arch_interrupt_allowed(vcpu) &&
+                        !kvm_cpu_has_interrupt(vcpu) &&
+                        !kvm_event_needs_reinjection(vcpu);
 }
 
 static void vapic_enter(struct kvm_vcpu *vcpu)
@@ -3094,9 +3135,63 @@ static void vapic_exit(struct kvm_vcpu *vcpu)
         up_read(&vcpu->kvm->slots_lock);
 }
 
+static void update_cr8_intercept(struct kvm_vcpu *vcpu)
+{
+        int max_irr, tpr;
+
+        if (!kvm_x86_ops->update_cr8_intercept)
+                return;
+
+        if (!vcpu->arch.apic->vapic_addr)
+                max_irr = kvm_lapic_find_highest_irr(vcpu);
+        else
+                max_irr = -1;
+
+        if (max_irr != -1)
+                max_irr >>= 4;
+
+        tpr = kvm_lapic_get_cr8(vcpu);
+
+        kvm_x86_ops->update_cr8_intercept(vcpu, tpr, max_irr);
+}
+
+static void inject_pending_irq(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
+{
+        if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP)
+                kvm_x86_ops->set_interrupt_shadow(vcpu, 0);
+
+        /* try to reinject previous events if any */
+        if (vcpu->arch.nmi_injected) {
+                kvm_x86_ops->set_nmi(vcpu);
+                return;
+        }
+
+        if (vcpu->arch.interrupt.pending) {
+                kvm_x86_ops->set_irq(vcpu);
+                return;
+        }
+
+        /* try to inject new event if pending */
+        if (vcpu->arch.nmi_pending) {
+                if (kvm_x86_ops->nmi_allowed(vcpu)) {
+                        vcpu->arch.nmi_pending = false;
+                        vcpu->arch.nmi_injected = true;
+                        kvm_x86_ops->set_nmi(vcpu);
+                }
+        } else if (kvm_cpu_has_interrupt(vcpu)) {
+                if (kvm_x86_ops->interrupt_allowed(vcpu)) {
+                        kvm_queue_interrupt(vcpu, kvm_cpu_get_interrupt(vcpu),
+                                            false);
+                        kvm_x86_ops->set_irq(vcpu);
+                }
+        }
+}
+
 static int vcpu_enter_guest(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 {
         int r;
+        bool req_int_win = !irqchip_in_kernel(vcpu->kvm) &&
+                kvm_run->request_interrupt_window;
 
         if (vcpu->requests)
                 if (test_and_clear_bit(KVM_REQ_MMU_RELOAD, &vcpu->requests))
@@ -3128,9 +3223,6 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
                 }
         }
 
-        clear_bit(KVM_REQ_PENDING_TIMER, &vcpu->requests);
-        kvm_inject_pending_timer_irqs(vcpu);
-
         preempt_disable();
 
         kvm_x86_ops->prepare_guest_switch(vcpu);
@@ -3138,6 +3230,9 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 
         local_irq_disable();
 
+        clear_bit(KVM_REQ_KICK, &vcpu->requests);
+        smp_mb__after_clear_bit();
+
         if (vcpu->requests || need_resched() || signal_pending(current)) {
                 local_irq_enable();
                 preempt_enable();
@@ -3145,21 +3240,21 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
                 goto out;
         }
 
-        vcpu->guest_mode = 1;
-        /*
-         * Make sure that guest_mode assignment won't happen after
-         * testing the pending IRQ vector bitmap.
-         */
-        smp_wmb();
-
         if (vcpu->arch.exception.pending)
                 __queue_exception(vcpu);
-        else if (irqchip_in_kernel(vcpu->kvm))
-                kvm_x86_ops->inject_pending_irq(vcpu);
         else
-                kvm_x86_ops->inject_pending_vectors(vcpu, kvm_run);
+                inject_pending_irq(vcpu, kvm_run);
 
-        kvm_lapic_sync_to_vapic(vcpu);
+        /* enable NMI/IRQ window open exits if needed */
+        if (vcpu->arch.nmi_pending)
+                kvm_x86_ops->enable_nmi_window(vcpu);
+        else if (kvm_cpu_has_interrupt(vcpu) || req_int_win)
+                kvm_x86_ops->enable_irq_window(vcpu);
+
+        if (kvm_lapic_enabled(vcpu)) {
+                update_cr8_intercept(vcpu);
+                kvm_lapic_sync_to_vapic(vcpu);
+        }
 
         up_read(&vcpu->kvm->slots_lock);
 
@@ -3193,7 +3288,7 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
         set_debugreg(vcpu->arch.host_dr6, 6);
         set_debugreg(vcpu->arch.host_dr7, 7);
 
-        vcpu->guest_mode = 0;
+        set_bit(KVM_REQ_KICK, &vcpu->requests);
         local_irq_enable();
 
         ++vcpu->stat.exits;
@@ -3220,8 +3315,6 @@ static int vcpu_enter_guest(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
                 profile_hit(KVM_PROFILING, (void *)rip);
         }
 
-        if (vcpu->arch.exception.pending && kvm_x86_ops->exception_injected(vcpu))
-                vcpu->arch.exception.pending = false;
 
         kvm_lapic_sync_from_vapic(vcpu);
 
@@ -3230,6 +3323,7 @@ out:
         return r;
 }
 
+
 static int __vcpu_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
 {
         int r;
@@ -3256,29 +3350,42 @@ static int __vcpu_run(struct kvm_vcpu *vcpu, struct kvm_run *kvm_run)
                         kvm_vcpu_block(vcpu);
                         down_read(&vcpu->kvm->slots_lock);
                         if (test_and_clear_bit(KVM_REQ_UNHALT, &vcpu->requests))
-                                if (vcpu->arch.mp_state == KVM_MP_STATE_HALTED)
+                        {
+                                switch(vcpu->arch.mp_state) {
+                                case KVM_MP_STATE_HALTED:
                                         vcpu->arch.mp_state =
-                                                        KVM_MP_STATE_RUNNABLE;
-                        if (vcpu->arch.mp_state != KVM_MP_STATE_RUNNABLE)
-                                r = -EINTR;
+                                                KVM_MP_STATE_RUNNABLE;
+                                case KVM_MP_STATE_RUNNABLE:
+                                        break;
+                                case KVM_MP_STATE_SIPI_RECEIVED:
+                                default:
+                                        r = -EINTR;
+                                        break;
+                                }
+                        }
                 }
 
-                if (r > 0) {
-                        if (dm_request_for_irq_injection(vcpu, kvm_run)) {
-                                r = -EINTR;
-                                kvm_run->exit_reason = KVM_EXIT_INTR;
-                                ++vcpu->stat.request_irq_exits;
-                        }
-                        if (signal_pending(current)) {
-                                r = -EINTR;
-                                kvm_run->exit_reason = KVM_EXIT_INTR;
-                                ++vcpu->stat.signal_exits;
-                        }
-                        if (need_resched()) {
-                                up_read(&vcpu->kvm->slots_lock);
-                                kvm_resched(vcpu);
-                                down_read(&vcpu->kvm->slots_lock);
-                        }
+                if (r <= 0)
+                        break;
+
+                clear_bit(KVM_REQ_PENDING_TIMER, &vcpu->requests);
+                if (kvm_cpu_has_pending_timer(vcpu))
+                        kvm_inject_pending_timer_irqs(vcpu);
+
+                if (dm_request_for_irq_injection(vcpu, kvm_run)) {
+                        r = -EINTR;
+                        kvm_run->exit_reason = KVM_EXIT_INTR;
+                        ++vcpu->stat.request_irq_exits;
+                }
+                if (signal_pending(current)) {
+                        r = -EINTR;
+                        kvm_run->exit_reason = KVM_EXIT_INTR;
+                        ++vcpu->stat.signal_exits;
+                }
+                if (need_resched()) {
+                        up_read(&vcpu->kvm->slots_lock);
+                        kvm_resched(vcpu);
+                        down_read(&vcpu->kvm->slots_lock);
                 }
         }
 
@@ -3442,7 +3549,6 @@ int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
                                   struct kvm_sregs *sregs)
 {
         struct descriptor_table dt;
-        int pending_vec;
 
         vcpu_load(vcpu);
 
@@ -3472,16 +3578,11 @@ int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu *vcpu,
         sregs->efer = vcpu->arch.shadow_efer;
         sregs->apic_base = kvm_get_apic_base(vcpu);
 
-        if (irqchip_in_kernel(vcpu->kvm)) {
-                memset(sregs->interrupt_bitmap, 0,
-                       sizeof sregs->interrupt_bitmap);
-                pending_vec = kvm_x86_ops->get_irq(vcpu);
-                if (pending_vec >= 0)
-                        set_bit(pending_vec,
-                                (unsigned long *)sregs->interrupt_bitmap);
-        } else
-                memcpy(sregs->interrupt_bitmap, vcpu->arch.irq_pending,
-                       sizeof sregs->interrupt_bitmap);
+        memset(sregs->interrupt_bitmap, 0, sizeof sregs->interrupt_bitmap);
+
+        if (vcpu->arch.interrupt.pending && !vcpu->arch.interrupt.soft)
+                set_bit(vcpu->arch.interrupt.nr,
+                        (unsigned long *)sregs->interrupt_bitmap);
 
         vcpu_put(vcpu);
 
@@ -3688,7 +3789,6 @@ static void save_state_to_tss32(struct kvm_vcpu *vcpu,
         tss->fs = get_segment_selector(vcpu, VCPU_SREG_FS);
         tss->gs = get_segment_selector(vcpu, VCPU_SREG_GS);
         tss->ldt_selector = get_segment_selector(vcpu, VCPU_SREG_LDTR);
-        tss->prev_task_link = get_segment_selector(vcpu, VCPU_SREG_TR);
 }
 
 static int load_state_from_tss32(struct kvm_vcpu *vcpu,
@@ -3785,8 +3885,8 @@ static int load_state_from_tss16(struct kvm_vcpu *vcpu,
 }
 
 static int kvm_task_switch_16(struct kvm_vcpu *vcpu, u16 tss_selector,
-                       u32 old_tss_base,
-                       struct desc_struct *nseg_desc)
+                              u16 old_tss_sel, u32 old_tss_base,
+                              struct desc_struct *nseg_desc)
 {
         struct tss_segment_16 tss_segment_16;
         int ret = 0;
@@ -3805,6 +3905,16 @@ static int kvm_task_switch_16(struct kvm_vcpu *vcpu, u16 tss_selector,
                            &tss_segment_16, sizeof tss_segment_16))
                 goto out;
 
+        if (old_tss_sel != 0xffff) {
+                tss_segment_16.prev_task_link = old_tss_sel;
+
+                if (kvm_write_guest(vcpu->kvm,
+                                    get_tss_base_addr(vcpu, nseg_desc),
+                                    &tss_segment_16.prev_task_link,
+                                    sizeof tss_segment_16.prev_task_link))
+                        goto out;
+        }
+
         if (load_state_from_tss16(vcpu, &tss_segment_16))
                 goto out;
 
@@ -3814,7 +3924,7 @@ out:
 }
 
 static int kvm_task_switch_32(struct kvm_vcpu *vcpu, u16 tss_selector,
-                       u32 old_tss_base,
+                       u16 old_tss_sel, u32 old_tss_base,
                        struct desc_struct *nseg_desc)
 {
         struct tss_segment_32 tss_segment_32;
@@ -3834,6 +3944,16 @@ static int kvm_task_switch_32(struct kvm_vcpu *vcpu, u16 tss_selector,
                            &tss_segment_32, sizeof tss_segment_32))
                 goto out;
 
+        if (old_tss_sel != 0xffff) {
+                tss_segment_32.prev_task_link = old_tss_sel;
+
+                if (kvm_write_guest(vcpu->kvm,
+                                    get_tss_base_addr(vcpu, nseg_desc),
+                                    &tss_segment_32.prev_task_link,
+                                    sizeof tss_segment_32.prev_task_link))
+                        goto out;
+        }
+
         if (load_state_from_tss32(vcpu, &tss_segment_32))
                 goto out;
 
@@ -3887,14 +4007,22 @@ int kvm_task_switch(struct kvm_vcpu *vcpu, u16 tss_selector, int reason)
                 kvm_x86_ops->set_rflags(vcpu, eflags & ~X86_EFLAGS_NT);
         }
 
-        kvm_x86_ops->skip_emulated_instruction(vcpu);
+        /* set back link to prev task only if NT bit is set in eflags
+           note that old_tss_sel is not used afetr this point */
+        if (reason != TASK_SWITCH_CALL && reason != TASK_SWITCH_GATE)
+                old_tss_sel = 0xffff;
+
+        /* set back link to prev task only if NT bit is set in eflags
+           note that old_tss_sel is not used afetr this point */
+        if (reason != TASK_SWITCH_CALL && reason != TASK_SWITCH_GATE)
+                old_tss_sel = 0xffff;
 
         if (nseg_desc.type & 8)
-                ret = kvm_task_switch_32(vcpu, tss_selector, old_tss_base,
-                                         &nseg_desc);
+                ret = kvm_task_switch_32(vcpu, tss_selector, old_tss_sel,
+                                         old_tss_base, &nseg_desc);
         else
-                ret = kvm_task_switch_16(vcpu, tss_selector, old_tss_base,
-                                         &nseg_desc);
+                ret = kvm_task_switch_16(vcpu, tss_selector, old_tss_sel,
+                                         old_tss_base, &nseg_desc);
 
         if (reason == TASK_SWITCH_CALL || reason == TASK_SWITCH_GATE) {
                 u32 eflags = kvm_x86_ops->get_rflags(vcpu);
@@ -3920,7 +4048,7 @@ int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
                                   struct kvm_sregs *sregs)
 {
         int mmu_reset_needed = 0;
-        int i, pending_vec, max_bits;
+        int pending_vec, max_bits;
         struct descriptor_table dt;
 
         vcpu_load(vcpu);
@@ -3934,7 +4062,13 @@ int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
 
         vcpu->arch.cr2 = sregs->cr2;
         mmu_reset_needed |= vcpu->arch.cr3 != sregs->cr3;
-        vcpu->arch.cr3 = sregs->cr3;
+
+        down_read(&vcpu->kvm->slots_lock);
+        if (gfn_to_memslot(vcpu->kvm, sregs->cr3 >> PAGE_SHIFT))
+                vcpu->arch.cr3 = sregs->cr3;
+        else
+                set_bit(KVM_REQ_TRIPLE_FAULT, &vcpu->requests);
+        up_read(&vcpu->kvm->slots_lock);
 
         kvm_set_cr8(vcpu, sregs->cr8);
 
@@ -3956,25 +4090,14 @@ int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu *vcpu,
         if (mmu_reset_needed)
                 kvm_mmu_reset_context(vcpu);
 
-        if (!irqchip_in_kernel(vcpu->kvm)) {
-                memcpy(vcpu->arch.irq_pending, sregs->interrupt_bitmap,
-                       sizeof vcpu->arch.irq_pending);
-                vcpu->arch.irq_summary = 0;
-                for (i = 0; i < ARRAY_SIZE(vcpu->arch.irq_pending); ++i)
-                        if (vcpu->arch.irq_pending[i])
-                                __set_bit(i, &vcpu->arch.irq_summary);
-        } else {
-                max_bits = (sizeof sregs->interrupt_bitmap) << 3;
-                pending_vec = find_first_bit(
-                        (const unsigned long *)sregs->interrupt_bitmap,
-                        max_bits);
-                /* Only pending external irq is handled here */
-                if (pending_vec < max_bits) {
-                        kvm_x86_ops->set_irq(vcpu, pending_vec);
-                        pr_debug("Set back pending irq %d\n",
-                                 pending_vec);
-                }
-                kvm_pic_clear_isr_ack(vcpu->kvm);
+        max_bits = (sizeof sregs->interrupt_bitmap) << 3;
+        pending_vec = find_first_bit(
+                (const unsigned long *)sregs->interrupt_bitmap, max_bits);
+        if (pending_vec < max_bits) {
+                kvm_queue_interrupt(vcpu, pending_vec, false);
+                pr_debug("Set back pending irq %d\n", pending_vec);
+                if (irqchip_in_kernel(vcpu->kvm))
+                        kvm_pic_clear_isr_ack(vcpu->kvm);
         }
 
         kvm_set_segment(vcpu, &sregs->cs, VCPU_SREG_CS);
@@ -4308,7 +4431,6 @@ struct  kvm *kvm_arch_create_vm(void)
                 return ERR_PTR(-ENOMEM);
 
         INIT_LIST_HEAD(&kvm->arch.active_mmu_pages);
-        INIT_LIST_HEAD(&kvm->arch.oos_global_pages);
         INIT_LIST_HEAD(&kvm->arch.assigned_dev_head);
 
         /* Reserve bit 0 of irq_sources_bitmap for userspace irq source */
@@ -4411,12 +4533,14 @@ int kvm_arch_set_memory_region(struct kvm *kvm,
                 }
         }
 
+        spin_lock(&kvm->mmu_lock);
         if (!kvm->arch.n_requested_mmu_pages) {
                 unsigned int nr_mmu_pages = kvm_mmu_calculate_mmu_pages(kvm);
                 kvm_mmu_change_mmu_pages(kvm, nr_mmu_pages);
         }
 
         kvm_mmu_slot_remove_write_access(kvm, mem->slot);
+        spin_unlock(&kvm->mmu_lock);
         kvm_flush_remote_tlbs(kvm);
 
         return 0;
@@ -4425,6 +4549,7 @@ int kvm_arch_set_memory_region(struct kvm *kvm,
 void kvm_arch_flush_shadow(struct kvm *kvm)
 {
         kvm_mmu_zap_all(kvm);
+        kvm_reload_remote_mmus(kvm);
 }
 
 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
@@ -4434,28 +4559,24 @@ int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
                || vcpu->arch.nmi_pending;
 }
 
-static void vcpu_kick_intr(void *info)
-{
-#ifdef DEBUG
-        struct kvm_vcpu *vcpu = (struct kvm_vcpu *)info;
-        printk(KERN_DEBUG "vcpu_kick_intr %p \n", vcpu);
-#endif
-}
-
 void kvm_vcpu_kick(struct kvm_vcpu *vcpu)
 {
-        int ipi_pcpu = vcpu->cpu;
-        int cpu = get_cpu();
+        int me;
+        int cpu = vcpu->cpu;
 
         if (waitqueue_active(&vcpu->wq)) {
                 wake_up_interruptible(&vcpu->wq);
                 ++vcpu->stat.halt_wakeup;
         }
-        /*
-         * We may be called synchronously with irqs disabled in guest mode,
-         * So need not to call smp_call_function_single() in that case.
-         */
-        if (vcpu->guest_mode && vcpu->cpu != cpu)
-                smp_call_function_single(ipi_pcpu, vcpu_kick_intr, vcpu, 0);
+
+        me = get_cpu();
+        if (cpu != me && (unsigned)cpu < nr_cpu_ids && cpu_online(cpu))
+                if (!test_and_set_bit(KVM_REQ_KICK, &vcpu->requests))
+                        smp_send_reschedule(cpu);
         put_cpu();
 }
+
+int kvm_arch_interrupt_allowed(struct kvm_vcpu *vcpu)
+{
+        return kvm_x86_ops->interrupt_allowed(vcpu);
+}
diff --git a/arch/x86/kvm/x86.h b/arch/x86/kvm/x86.h
index 6a4be78a7384..4c8e10af78e8 100644
--- a/arch/x86/kvm/x86.h
+++ b/arch/x86/kvm/x86.h
@@ -8,9 +8,11 @@ static inline void kvm_clear_exception_queue(struct kvm_vcpu *vcpu)
         vcpu->arch.exception.pending = false;
 }
 
-static inline void kvm_queue_interrupt(struct kvm_vcpu *vcpu, u8 vector)
+static inline void kvm_queue_interrupt(struct kvm_vcpu *vcpu, u8 vector,
+        bool soft)
 {
         vcpu->arch.interrupt.pending = true;
+        vcpu->arch.interrupt.soft = soft;
         vcpu->arch.interrupt.nr = vector;
 }
 
@@ -19,4 +21,14 @@ static inline void kvm_clear_interrupt_queue(struct kvm_vcpu *vcpu)
         vcpu->arch.interrupt.pending = false;
 }
 
+static inline bool kvm_event_needs_reinjection(struct kvm_vcpu *vcpu)
+{
+        return vcpu->arch.exception.pending || vcpu->arch.interrupt.pending ||
+                vcpu->arch.nmi_injected;
+}
+
+static inline bool kvm_exception_is_soft(unsigned int nr)
+{
+        return (nr == BP_VECTOR) || (nr == OF_VECTOR);
+}
 #endif
diff --git a/arch/x86/kvm/x86_emulate.c b/arch/x86/kvm/x86_emulate.c
index ca91749d2083..c1b6c232e02b 100644
--- a/arch/x86/kvm/x86_emulate.c
+++ b/arch/x86/kvm/x86_emulate.c
@@ -59,13 +59,14 @@
 #define SrcImm      (5<<4)      /* Immediate operand. */
 #define SrcImmByte  (6<<4)      /* 8-bit sign-extended immediate operand. */
 #define SrcOne      (7<<4)      /* Implied '1' */
-#define SrcMask     (7<<4)
+#define SrcImmUByte (8<<4)      /* 8-bit unsigned immediate operand. */
+#define SrcMask     (0xf<<4)
 /* Generic ModRM decode. */
-#define ModRM       (1<<7)
+#define ModRM       (1<<8)
 /* Destination is only written; never read. */
-#define Mov         (1<<8)
-#define BitOp       (1<<9)
-#define MemAbs      (1<<10)      /* Memory operand is absolute displacement */
+#define Mov         (1<<9)
+#define BitOp       (1<<10)
+#define MemAbs      (1<<11)      /* Memory operand is absolute displacement */
 #define String      (1<<12)     /* String instruction (rep capable) */
 #define Stack       (1<<13)     /* Stack instruction (push/pop) */
 #define Group       (1<<14)     /* Bits 3:5 of modrm byte extend opcode */
@@ -76,6 +77,7 @@
 #define Src2CL      (1<<29)
 #define Src2ImmByte (2<<29)
 #define Src2One     (3<<29)
+#define Src2Imm16   (4<<29)
 #define Src2Mask    (7<<29)
 
 enum {
@@ -135,11 +137,11 @@ static u32 opcode_table[256] = {
         SrcNone  | ByteOp  | ImplicitOps, SrcNone  | ImplicitOps, /* insb, insw/insd */
         SrcNone  | ByteOp  | ImplicitOps, SrcNone  | ImplicitOps, /* outsb, outsw/outsd */
         /* 0x70 - 0x77 */
-        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
-        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
+        SrcImmByte, SrcImmByte, SrcImmByte, SrcImmByte,
+        SrcImmByte, SrcImmByte, SrcImmByte, SrcImmByte,
         /* 0x78 - 0x7F */
-        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
-        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
+        SrcImmByte, SrcImmByte, SrcImmByte, SrcImmByte,
+        SrcImmByte, SrcImmByte, SrcImmByte, SrcImmByte,
         /* 0x80 - 0x87 */
         Group | Group1_80, Group | Group1_81,
         Group | Group1_82, Group | Group1_83,
@@ -153,7 +155,8 @@ static u32 opcode_table[256] = {
         /* 0x90 - 0x97 */
         DstReg, DstReg, DstReg, DstReg, DstReg, DstReg, DstReg, DstReg,
         /* 0x98 - 0x9F */
-        0, 0, 0, 0, ImplicitOps | Stack, ImplicitOps | Stack, 0, 0,
+        0, 0, SrcImm | Src2Imm16, 0,
+        ImplicitOps | Stack, ImplicitOps | Stack, 0, 0,
         /* 0xA0 - 0xA7 */
         ByteOp | DstReg | SrcMem | Mov | MemAbs, DstReg | SrcMem | Mov | MemAbs,
         ByteOp | DstMem | SrcReg | Mov | MemAbs, DstMem | SrcReg | Mov | MemAbs,
@@ -178,7 +181,8 @@ static u32 opcode_table[256] = {
         0, ImplicitOps | Stack, 0, 0,
         ByteOp | DstMem | SrcImm | ModRM | Mov, DstMem | SrcImm | ModRM | Mov,
         /* 0xC8 - 0xCF */
-        0, 0, 0, ImplicitOps | Stack, 0, 0, 0, 0,
+        0, 0, 0, ImplicitOps | Stack,
+        ImplicitOps, SrcImmByte, ImplicitOps, ImplicitOps,
         /* 0xD0 - 0xD7 */
         ByteOp | DstMem | SrcImplicit | ModRM, DstMem | SrcImplicit | ModRM,
         ByteOp | DstMem | SrcImplicit | ModRM, DstMem | SrcImplicit | ModRM,
@@ -187,11 +191,11 @@ static u32 opcode_table[256] = {
         0, 0, 0, 0, 0, 0, 0, 0,
         /* 0xE0 - 0xE7 */
         0, 0, 0, 0,
-        SrcNone | ByteOp | ImplicitOps, SrcNone | ImplicitOps,
-        SrcNone | ByteOp | ImplicitOps, SrcNone | ImplicitOps,
+        ByteOp | SrcImmUByte, SrcImmUByte,
+        ByteOp | SrcImmUByte, SrcImmUByte,
         /* 0xE8 - 0xEF */
-        ImplicitOps | Stack, SrcImm | ImplicitOps,
-        ImplicitOps, SrcImmByte | ImplicitOps,
+        SrcImm | Stack, SrcImm | ImplicitOps,
+        SrcImm | Src2Imm16, SrcImmByte | ImplicitOps,
         SrcNone | ByteOp | ImplicitOps, SrcNone | ImplicitOps,
         SrcNone | ByteOp | ImplicitOps, SrcNone | ImplicitOps,
         /* 0xF0 - 0xF7 */
@@ -230,10 +234,8 @@ static u32 twobyte_table[256] = {
         /* 0x70 - 0x7F */
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         /* 0x80 - 0x8F */
-        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
-        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
-        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
-        ImplicitOps, ImplicitOps, ImplicitOps, ImplicitOps,
+        SrcImm, SrcImm, SrcImm, SrcImm, SrcImm, SrcImm, SrcImm, SrcImm,
+        SrcImm, SrcImm, SrcImm, SrcImm, SrcImm, SrcImm, SrcImm, SrcImm,
         /* 0x90 - 0x9F */
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         /* 0xA0 - 0xA7 */
@@ -1044,10 +1046,14 @@ done_prefixes:
                 }
                 break;
         case SrcImmByte:
+        case SrcImmUByte:
                 c->src.type = OP_IMM;
                 c->src.ptr = (unsigned long *)c->eip;
                 c->src.bytes = 1;
-                c->src.val = insn_fetch(s8, 1, c->eip);
+                if ((c->d & SrcMask) == SrcImmByte)
+                        c->src.val = insn_fetch(s8, 1, c->eip);
+                else
+                        c->src.val = insn_fetch(u8, 1, c->eip);
                 break;
         case SrcOne:
                 c->src.bytes = 1;
@@ -1072,6 +1078,12 @@ done_prefixes:
                 c->src2.bytes = 1;
                 c->src2.val = insn_fetch(u8, 1, c->eip);
                 break;
+        case Src2Imm16:
+                c->src2.type = OP_IMM;
+                c->src2.ptr = (unsigned long *)c->eip;
+                c->src2.bytes = 2;
+                c->src2.val = insn_fetch(u16, 2, c->eip);
+                break;
         case Src2One:
                 c->src2.bytes = 1;
                 c->src2.val = 1;
@@ -1349,6 +1361,20 @@ static inline int writeback(struct x86_emulate_ctxt *ctxt,
         return 0;
 }
 
+void toggle_interruptibility(struct x86_emulate_ctxt *ctxt, u32 mask)
+{
+        u32 int_shadow = kvm_x86_ops->get_interrupt_shadow(ctxt->vcpu, mask);
+        /*
+         * an sti; sti; sequence only disable interrupts for the first
+         * instruction. So, if the last instruction, be it emulated or
+         * not, left the system with the INT_STI flag enabled, it
+         * means that the last instruction is an sti. We should not
+         * leave the flag on in this case. The same goes for mov ss
+         */
+        if (!(int_shadow & mask))
+                ctxt->interruptibility = mask;
+}
+
 int
 x86_emulate_insn(struct x86_emulate_ctxt *ctxt, struct x86_emulate_ops *ops)
 {
@@ -1360,6 +1386,8 @@ x86_emulate_insn(struct x86_emulate_ctxt *ctxt, struct x86_emulate_ops *ops)
         int io_dir_in;
         int rc = 0;
 
+        ctxt->interruptibility = 0;
+
         /* Shadow copy of register state. Committed on successful emulation.
          * NOTE: we can copy them from vcpu as x86_decode_insn() doesn't
          * modify them.
@@ -1531,13 +1559,10 @@ special_insn:
                         return -1;
                 }
                 return 0;
-        case 0x70 ... 0x7f: /* jcc (short) */ {
-                int rel = insn_fetch(s8, 1, c->eip);
-
+        case 0x70 ... 0x7f: /* jcc (short) */
                 if (test_cc(c->b, ctxt->eflags))
-                        jmp_rel(c, rel);
+                        jmp_rel(c, c->src.val);
                 break;
-        }
         case 0x80 ... 0x83:     /* Grp1 */
                 switch (c->modrm_reg) {
                 case 0:
@@ -1609,6 +1634,9 @@ special_insn:
                 int err;
 
                 sel = c->src.val;
+                if (c->modrm_reg == VCPU_SREG_SS)
+                        toggle_interruptibility(ctxt, X86_SHADOW_INT_MOV_SS);
+
                 if (c->modrm_reg <= 5) {
                         type_bits = (c->modrm_reg == 1) ? 9 : 1;
                         err = kvm_load_segment_descriptor(ctxt->vcpu, sel,
@@ -1769,59 +1797,32 @@ special_insn:
                 break;
         case 0xe4:      /* inb */
         case 0xe5:      /* in */
-                port = insn_fetch(u8, 1, c->eip);
+                port = c->src.val;
                 io_dir_in = 1;
                 goto do_io;
         case 0xe6: /* outb */
         case 0xe7: /* out */
-                port = insn_fetch(u8, 1, c->eip);
+                port = c->src.val;
                 io_dir_in = 0;
                 goto do_io;
         case 0xe8: /* call (near) */ {
-                long int rel;
-                switch (c->op_bytes) {
-                case 2:
-                        rel = insn_fetch(s16, 2, c->eip);
-                        break;
-                case 4:
-                        rel = insn_fetch(s32, 4, c->eip);
-                        break;
-                default:
-                        DPRINTF("Call: Invalid op_bytes\n");
-                        goto cannot_emulate;
-                }
+                long int rel = c->src.val;
                 c->src.val = (unsigned long) c->eip;
                 jmp_rel(c, rel);
-                c->op_bytes = c->ad_bytes;
                 emulate_push(ctxt);
                 break;
         }
         case 0xe9: /* jmp rel */
                 goto jmp;
-        case 0xea: /* jmp far */ {
-                uint32_t eip;
-                uint16_t sel;
-
-                switch (c->op_bytes) {
-                case 2:
-                        eip = insn_fetch(u16, 2, c->eip);
-                        break;
-                case 4:
-                        eip = insn_fetch(u32, 4, c->eip);
-                        break;
-                default:
-                        DPRINTF("jmp far: Invalid op_bytes\n");
-                        goto cannot_emulate;
-                }
-                sel = insn_fetch(u16, 2, c->eip);
-                if (kvm_load_segment_descriptor(ctxt->vcpu, sel, 9, VCPU_SREG_CS) < 0) {
+        case 0xea: /* jmp far */
+                if (kvm_load_segment_descriptor(ctxt->vcpu, c->src2.val, 9,
+                                        VCPU_SREG_CS) < 0) {
                         DPRINTF("jmp far: Failed to load CS descriptor\n");
                         goto cannot_emulate;
                 }
 
-                c->eip = eip;
+                c->eip = c->src.val;
                 break;
-        }
         case 0xeb:
               jmp:              /* jmp rel short */
                 jmp_rel(c, c->src.val);
@@ -1865,6 +1866,7 @@ special_insn:
                 c->dst.type = OP_NONE;  /* Disable writeback. */
                 break;
         case 0xfb: /* sti */
+                toggle_interruptibility(ctxt, X86_SHADOW_INT_STI);
                 ctxt->eflags |= X86_EFLAGS_IF;
                 c->dst.type = OP_NONE;  /* Disable writeback. */
                 break;
@@ -2039,28 +2041,11 @@ twobyte_insn:
                 if (!test_cc(c->b, ctxt->eflags))
                         c->dst.type = OP_NONE; /* no writeback */
                 break;
-        case 0x80 ... 0x8f: /* jnz rel, etc*/ {
-                long int rel;
-
-                switch (c->op_bytes) {
-                case 2:
-                        rel = insn_fetch(s16, 2, c->eip);
-                        break;
-                case 4:
-                        rel = insn_fetch(s32, 4, c->eip);
-                        break;
-                case 8:
-                        rel = insn_fetch(s64, 8, c->eip);
-                        break;
-                default:
-                        DPRINTF("jnz: Invalid op_bytes\n");
-                        goto cannot_emulate;
-                }
+        case 0x80 ... 0x8f: /* jnz rel, etc*/
                 if (test_cc(c->b, ctxt->eflags))
-                        jmp_rel(c, rel);
+                        jmp_rel(c, c->src.val);
                 c->dst.type = OP_NONE;
                 break;
-        }
         case 0xa3:
               bt:               /* bt */
                 c->dst.type = OP_NONE;
diff --git a/arch/x86/lib/Makefile b/arch/x86/lib/Makefile
index 55e11aa6d66c..f9d35632666b 100644
--- a/arch/x86/lib/Makefile
+++ b/arch/x86/lib/Makefile
@@ -2,7 +2,7 @@
 # Makefile for x86 specific library files.
 #
 
-obj-$(CONFIG_SMP) := msr-on-cpu.o
+obj-$(CONFIG_SMP) := msr.o
 
 lib-y := delay.o
 lib-y += thunk_$(BITS).o
diff --git a/arch/x86/lib/msr-on-cpu.c b/arch/x86/lib/msr-on-cpu.c
deleted file mode 100644
index 321cf720dbb6..000000000000
--- a/arch/x86/lib/msr-on-cpu.c
+++ /dev/null
@@ -1,97 +0,0 @@
-#include <linux/module.h>
-#include <linux/preempt.h>
-#include <linux/smp.h>
-#include <asm/msr.h>
-
-struct msr_info {
-        u32 msr_no;
-        u32 l, h;
-        int err;
-};
-
-static void __rdmsr_on_cpu(void *info)
-{
-        struct msr_info *rv = info;
-
-        rdmsr(rv->msr_no, rv->l, rv->h);
-}
-
-static void __wrmsr_on_cpu(void *info)
-{
-        struct msr_info *rv = info;
-
-        wrmsr(rv->msr_no, rv->l, rv->h);
-}
-
-int rdmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h)
-{
-        int err;
-        struct msr_info rv;
-
-        rv.msr_no = msr_no;
-        err = smp_call_function_single(cpu, __rdmsr_on_cpu, &rv, 1);
-        *l = rv.l;
-        *h = rv.h;
-
-        return err;
-}
-
-int wrmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h)
-{
-        int err;
-        struct msr_info rv;
-
-        rv.msr_no = msr_no;
-        rv.l = l;
-        rv.h = h;
-        err = smp_call_function_single(cpu, __wrmsr_on_cpu, &rv, 1);
-
-        return err;
-}
-
-/* These "safe" variants are slower and should be used when the target MSR
-   may not actually exist. */
-static void __rdmsr_safe_on_cpu(void *info)
-{
-        struct msr_info *rv = info;
-
-        rv->err = rdmsr_safe(rv->msr_no, &rv->l, &rv->h);
-}
-
-static void __wrmsr_safe_on_cpu(void *info)
-{
-        struct msr_info *rv = info;
-
-        rv->err = wrmsr_safe(rv->msr_no, rv->l, rv->h);
-}
-
-int rdmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h)
-{
-        int err;
-        struct msr_info rv;
-
-        rv.msr_no = msr_no;
-        err = smp_call_function_single(cpu, __rdmsr_safe_on_cpu, &rv, 1);
-        *l = rv.l;
-        *h = rv.h;
-
-        return err ? err : rv.err;
-}
-
-int wrmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h)
-{
-        int err;
-        struct msr_info rv;
-
-        rv.msr_no = msr_no;
-        rv.l = l;
-        rv.h = h;
-        err = smp_call_function_single(cpu, __wrmsr_safe_on_cpu, &rv, 1);
-
-        return err ? err : rv.err;
-}
-
-EXPORT_SYMBOL(rdmsr_on_cpu);
-EXPORT_SYMBOL(wrmsr_on_cpu);
-EXPORT_SYMBOL(rdmsr_safe_on_cpu);
-EXPORT_SYMBOL(wrmsr_safe_on_cpu);
diff --git a/arch/x86/lib/msr.c b/arch/x86/lib/msr.c
new file mode 100644
index 000000000000..1440b9c0547e
--- /dev/null
+++ b/arch/x86/lib/msr.c
@@ -0,0 +1,183 @@
+#include <linux/module.h>
+#include <linux/preempt.h>
+#include <linux/smp.h>
+#include <asm/msr.h>
+
+struct msr_info {
+        u32 msr_no;
+        struct msr reg;
+        struct msr *msrs;
+        int off;
+        int err;
+};
+
+static void __rdmsr_on_cpu(void *info)
+{
+        struct msr_info *rv = info;
+        struct msr *reg;
+        int this_cpu = raw_smp_processor_id();
+
+        if (rv->msrs)
+                reg = &rv->msrs[this_cpu - rv->off];
+        else
+                reg = &rv->reg;
+
+        rdmsr(rv->msr_no, reg->l, reg->h);
+}
+
+static void __wrmsr_on_cpu(void *info)
+{
+        struct msr_info *rv = info;
+        struct msr *reg;
+        int this_cpu = raw_smp_processor_id();
+
+        if (rv->msrs)
+                reg = &rv->msrs[this_cpu - rv->off];
+        else
+                reg = &rv->reg;
+
+        wrmsr(rv->msr_no, reg->l, reg->h);
+}
+
+int rdmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h)
+{
+        int err;
+        struct msr_info rv;
+
+        memset(&rv, 0, sizeof(rv));
+
+        rv.msr_no = msr_no;
+        err = smp_call_function_single(cpu, __rdmsr_on_cpu, &rv, 1);
+        *l = rv.reg.l;
+        *h = rv.reg.h;
+
+        return err;
+}
+EXPORT_SYMBOL(rdmsr_on_cpu);
+
+int wrmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h)
+{
+        int err;
+        struct msr_info rv;
+
+        memset(&rv, 0, sizeof(rv));
+
+        rv.msr_no = msr_no;
+        rv.reg.l = l;
+        rv.reg.h = h;
+        err = smp_call_function_single(cpu, __wrmsr_on_cpu, &rv, 1);
+
+        return err;
+}
+EXPORT_SYMBOL(wrmsr_on_cpu);
+
+/* rdmsr on a bunch of CPUs
+ *
+ * @mask:       which CPUs
+ * @msr_no:     which MSR
+ * @msrs:       array of MSR values
+ *
+ */
+void rdmsr_on_cpus(const cpumask_t *mask, u32 msr_no, struct msr *msrs)
+{
+        struct msr_info rv;
+        int this_cpu;
+
+        memset(&rv, 0, sizeof(rv));
+
+        rv.off    = cpumask_first(mask);
+        rv.msrs   = msrs;
+        rv.msr_no = msr_no;
+
+        preempt_disable();
+        /*
+         * FIXME: handle the CPU we're executing on separately for now until
+         * smp_call_function_many has been fixed to not skip it.
+         */
+        this_cpu = raw_smp_processor_id();
+        smp_call_function_single(this_cpu, __rdmsr_on_cpu, &rv, 1);
+
+        smp_call_function_many(mask, __rdmsr_on_cpu, &rv, 1);
+        preempt_enable();
+}
+EXPORT_SYMBOL(rdmsr_on_cpus);
+
+/*
+ * wrmsr on a bunch of CPUs
+ *
+ * @mask:       which CPUs
+ * @msr_no:     which MSR
+ * @msrs:       array of MSR values
+ *
+ */
+void wrmsr_on_cpus(const cpumask_t *mask, u32 msr_no, struct msr *msrs)
+{
+        struct msr_info rv;
+        int this_cpu;
+
+        memset(&rv, 0, sizeof(rv));
+
+        rv.off    = cpumask_first(mask);
+        rv.msrs   = msrs;
+        rv.msr_no = msr_no;
+
+        preempt_disable();
+        /*
+         * FIXME: handle the CPU we're executing on separately for now until
+         * smp_call_function_many has been fixed to not skip it.
+         */
+        this_cpu = raw_smp_processor_id();
+        smp_call_function_single(this_cpu, __wrmsr_on_cpu, &rv, 1);
+
+        smp_call_function_many(mask, __wrmsr_on_cpu, &rv, 1);
+        preempt_enable();
+}
+EXPORT_SYMBOL(wrmsr_on_cpus);
+
+/* These "safe" variants are slower and should be used when the target MSR
+   may not actually exist. */
+static void __rdmsr_safe_on_cpu(void *info)
+{
+        struct msr_info *rv = info;
+
+        rv->err = rdmsr_safe(rv->msr_no, &rv->reg.l, &rv->reg.h);
+}
+
+static void __wrmsr_safe_on_cpu(void *info)
+{
+        struct msr_info *rv = info;
+
+        rv->err = wrmsr_safe(rv->msr_no, rv->reg.l, rv->reg.h);
+}
+
+int rdmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h)
+{
+        int err;
+        struct msr_info rv;
+
+        memset(&rv, 0, sizeof(rv));
+
+        rv.msr_no = msr_no;
+        err = smp_call_function_single(cpu, __rdmsr_safe_on_cpu, &rv, 1);
+        *l = rv.reg.l;
+        *h = rv.reg.h;
+
+        return err ? err : rv.err;
+}
+EXPORT_SYMBOL(rdmsr_safe_on_cpu);
+
+int wrmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h)
+{
+        int err;
+        struct msr_info rv;
+
+        memset(&rv, 0, sizeof(rv));
+
+        rv.msr_no = msr_no;
+        rv.reg.l = l;
+        rv.reg.h = h;
+        err = smp_call_function_single(cpu, __wrmsr_safe_on_cpu, &rv, 1);
+
+        return err ? err : rv.err;
+}
+EXPORT_SYMBOL(wrmsr_safe_on_cpu);
diff --git a/block/Kconfig b/block/Kconfig
index e7d12782bcfb..2c39527aa7db 100644
--- a/block/Kconfig
+++ b/block/Kconfig
@@ -26,6 +26,7 @@ if BLOCK
 config LBD
         bool "Support for large block devices and files"
         depends on !64BIT
+        default y
         help
           Enable block devices or files of size 2TB and larger.
 
@@ -38,11 +39,13 @@ config LBD
 
           The ext4 filesystem requires that this feature be enabled in
           order to support filesystems that have the huge_file feature
-          enabled.    Otherwise, it will refuse to mount any filesystems
-          that use the huge_file feature, which is enabled by default
-          by mke2fs.ext4.   The GFS2 filesystem also requires this feature.
+          enabled.  Otherwise, it will refuse to mount in the read-write
+          mode any filesystems that use the huge_file feature, which is
+          enabled by default by mke2fs.ext4.
 
-          If unsure, say N.
+          The GFS2 filesystem also requires this feature.
+
+          If unsure, say Y.
 
 config BLK_DEV_BSG
         bool "Block layer SG support v4 (EXPERIMENTAL)"
diff --git a/block/as-iosched.c b/block/as-iosched.c
index c48fa670d221..7a12cf6ee1d3 100644
--- a/block/as-iosched.c
+++ b/block/as-iosched.c
@@ -306,8 +306,8 @@ as_choose_req(struct as_data *ad, struct request *rq1, struct request *rq2)
         data_dir = rq_is_sync(rq1);
 
         last = ad->last_sector[data_dir];
-        s1 = rq1->sector;
-        s2 = rq2->sector;
+        s1 = blk_rq_pos(rq1);
+        s2 = blk_rq_pos(rq2);
 
         BUG_ON(data_dir != rq_is_sync(rq2));
 
@@ -566,13 +566,15 @@ static void as_update_iohist(struct as_data *ad, struct as_io_context *aic,
                         as_update_thinktime(ad, aic, thinktime);
 
                         /* Calculate read -> read seek distance */
-                        if (aic->last_request_pos < rq->sector)
-                                seek_dist = rq->sector - aic->last_request_pos;
+                        if (aic->last_request_pos < blk_rq_pos(rq))
+                                seek_dist = blk_rq_pos(rq) -
+                                            aic->last_request_pos;
                         else
-                                seek_dist = aic->last_request_pos - rq->sector;
+                                seek_dist = aic->last_request_pos -
+                                            blk_rq_pos(rq);
                         as_update_seekdist(ad, aic, seek_dist);
                 }
-                aic->last_request_pos = rq->sector + rq->nr_sectors;
+                aic->last_request_pos = blk_rq_pos(rq) + blk_rq_sectors(rq);
                 set_bit(AS_TASK_IOSTARTED, &aic->state);
                 spin_unlock(&aic->lock);
         }
@@ -587,7 +589,7 @@ static int as_close_req(struct as_data *ad, struct as_io_context *aic,
 {
         unsigned long delay;    /* jiffies */
         sector_t last = ad->last_sector[ad->batch_data_dir];
-        sector_t next = rq->sector;
+        sector_t next = blk_rq_pos(rq);
         sector_t delta; /* acceptable close offset (in sectors) */
         sector_t s;
 
@@ -981,7 +983,7 @@ static void as_move_to_dispatch(struct as_data *ad, struct request *rq)
          * This has to be set in order to be correctly updated by
          * as_find_next_rq
          */
-        ad->last_sector[data_dir] = rq->sector + rq->nr_sectors;
+        ad->last_sector[data_dir] = blk_rq_pos(rq) + blk_rq_sectors(rq);
 
         if (data_dir == BLK_RW_SYNC) {
                 struct io_context *ioc = RQ_IOC(rq);
@@ -1312,12 +1314,8 @@ static void as_merged_requests(struct request_queue *q, struct request *req,
 static void as_work_handler(struct work_struct *work)
 {
         struct as_data *ad = container_of(work, struct as_data, antic_work);
-        struct request_queue *q = ad->q;
-        unsigned long flags;
 
-        spin_lock_irqsave(q->queue_lock, flags);
-        blk_start_queueing(q);
-        spin_unlock_irqrestore(q->queue_lock, flags);
+        blk_run_queue(ad->q);
 }
 
 static int as_may_queue(struct request_queue *q, int rw)
diff --git a/block/blk-barrier.c b/block/blk-barrier.c
index 20b4111fa050..30022b4e2f63 100644
--- a/block/blk-barrier.c
+++ b/block/blk-barrier.c
@@ -106,10 +106,7 @@ bool blk_ordered_complete_seq(struct request_queue *q, unsigned seq, int error)
          */
         q->ordseq = 0;
         rq = q->orig_bar_rq;
-
-        if (__blk_end_request(rq, q->orderr, blk_rq_bytes(rq)))
-                BUG();
-
+        __blk_end_request_all(rq, q->orderr);
         return true;
 }
 
@@ -166,7 +163,7 @@ static inline bool start_ordered(struct request_queue *q, struct request **rqp)
          * For an empty barrier, there's no actual BAR request, which
          * in turn makes POSTFLUSH unnecessary.  Mask them off.
          */
-        if (!rq->hard_nr_sectors) {
+        if (!blk_rq_sectors(rq)) {
                 q->ordered &= ~(QUEUE_ORDERED_DO_BAR |
                                 QUEUE_ORDERED_DO_POSTFLUSH);
                 /*
@@ -183,7 +180,7 @@ static inline bool start_ordered(struct request_queue *q, struct request **rqp)
         }
 
         /* stash away the original request */
-        elv_dequeue_request(q, rq);
+        blk_dequeue_request(rq);
         q->orig_bar_rq = rq;
         rq = NULL;
 
@@ -221,7 +218,7 @@ static inline bool start_ordered(struct request_queue *q, struct request **rqp)
         } else
                 skip |= QUEUE_ORDSEQ_PREFLUSH;
 
-        if ((q->ordered & QUEUE_ORDERED_BY_DRAIN) && q->in_flight)
+        if ((q->ordered & QUEUE_ORDERED_BY_DRAIN) && queue_in_flight(q))
                 rq = NULL;
         else
                 skip |= QUEUE_ORDSEQ_DRAIN;
@@ -251,10 +248,8 @@ bool blk_do_ordered(struct request_queue *q, struct request **rqp)
                          * Queue ordering not supported.  Terminate
                          * with prejudice.
                          */
-                        elv_dequeue_request(q, rq);
-                        if (__blk_end_request(rq, -EOPNOTSUPP,
-                                              blk_rq_bytes(rq)))
-                                BUG();
+                        blk_dequeue_request(rq);
+                        __blk_end_request_all(rq, -EOPNOTSUPP);
                         *rqp = NULL;
                         return false;
                 }
@@ -329,7 +324,7 @@ int blkdev_issue_flush(struct block_device *bdev, sector_t *error_sector)
         /*
          * The driver must store the error location in ->bi_sector, if
          * it supports it. For non-stacked drivers, this should be copied
-         * from rq->sector.
+         * from blk_rq_pos(rq).
          */
         if (error_sector)
                 *error_sector = bio->bi_sector;
@@ -393,10 +388,10 @@ int blkdev_issue_discard(struct block_device *bdev,
 
                 bio->bi_sector = sector;
 
-                if (nr_sects > q->max_hw_sectors) {
-                        bio->bi_size = q->max_hw_sectors << 9;
-                        nr_sects -= q->max_hw_sectors;
-                        sector += q->max_hw_sectors;
+                if (nr_sects > queue_max_hw_sectors(q)) {
+                        bio->bi_size = queue_max_hw_sectors(q) << 9;
+                        nr_sects -= queue_max_hw_sectors(q);
+                        sector += queue_max_hw_sectors(q);
                 } else {
                         bio->bi_size = nr_sects << 9;
                         nr_sects = 0;
diff --git a/block/blk-core.c b/block/blk-core.c
index 9475bf99b891..d17d71c71d4f 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -60,11 +60,11 @@ static void drive_stat_acct(struct request *rq, int new_io)
         int rw = rq_data_dir(rq);
         int cpu;
 
-        if (!blk_fs_request(rq) || !blk_do_io_stat(rq))
+        if (!blk_do_io_stat(rq))
                 return;
 
         cpu = part_stat_lock();
-        part = disk_map_sector_rcu(rq->rq_disk, rq->sector);
+        part = disk_map_sector_rcu(rq->rq_disk, blk_rq_pos(rq));
 
         if (!new_io)
                 part_stat_inc(cpu, part, merges[rw]);
@@ -119,13 +119,14 @@ void blk_rq_init(struct request_queue *q, struct request *rq)
         INIT_LIST_HEAD(&rq->timeout_list);
         rq->cpu = -1;
         rq->q = q;
-        rq->sector = rq->hard_sector = (sector_t) -1;
+        rq->__sector = (sector_t) -1;
         INIT_HLIST_NODE(&rq->hash);
         RB_CLEAR_NODE(&rq->rb_node);
         rq->cmd = rq->__cmd;
         rq->cmd_len = BLK_MAX_CDB;
         rq->tag = -1;
         rq->ref_count = 1;
+        rq->start_time = jiffies;
 }
 EXPORT_SYMBOL(blk_rq_init);
 
@@ -176,14 +177,11 @@ void blk_dump_rq_flags(struct request *rq, char *msg)
                 rq->rq_disk ? rq->rq_disk->disk_name : "?", rq->cmd_type,
                 rq->cmd_flags);
 
-        printk(KERN_INFO "  sector %llu, nr/cnr %lu/%u\n",
-                                                (unsigned long long)rq->sector,
-                                                rq->nr_sectors,
-                                                rq->current_nr_sectors);
-        printk(KERN_INFO "  bio %p, biotail %p, buffer %p, data %p, len %u\n",
-                                                rq->bio, rq->biotail,
-                                                rq->buffer, rq->data,
-                                                rq->data_len);
+        printk(KERN_INFO "  sector %llu, nr/cnr %u/%u\n",
+               (unsigned long long)blk_rq_pos(rq),
+               blk_rq_sectors(rq), blk_rq_cur_sectors(rq));
+        printk(KERN_INFO "  bio %p, biotail %p, buffer %p, len %u\n",
+               rq->bio, rq->biotail, rq->buffer, blk_rq_bytes(rq));
 
         if (blk_pc_request(rq)) {
                 printk(KERN_INFO "  cdb: ");
@@ -325,24 +323,6 @@ void blk_unplug(struct request_queue *q)
 }
 EXPORT_SYMBOL(blk_unplug);
 
-static void blk_invoke_request_fn(struct request_queue *q)
-{
-        if (unlikely(blk_queue_stopped(q)))
-                return;
-
-        /*
-         * one level of recursion is ok and is much faster than kicking
-         * the unplug handling
-         */
-        if (!queue_flag_test_and_set(QUEUE_FLAG_REENTER, q)) {
-                q->request_fn(q);
-                queue_flag_clear(QUEUE_FLAG_REENTER, q);
-        } else {
-                queue_flag_set(QUEUE_FLAG_PLUGGED, q);
-                kblockd_schedule_work(q, &q->unplug_work);
-        }
-}
-
 /**
  * blk_start_queue - restart a previously stopped queue
  * @q:    The &struct request_queue in question
@@ -357,7 +337,7 @@ void blk_start_queue(struct request_queue *q)
         WARN_ON(!irqs_disabled());
 
         queue_flag_clear(QUEUE_FLAG_STOPPED, q);
-        blk_invoke_request_fn(q);
+        __blk_run_queue(q);
 }
 EXPORT_SYMBOL(blk_start_queue);
 
@@ -417,12 +397,23 @@ void __blk_run_queue(struct request_queue *q)
 {
         blk_remove_plug(q);
 
+        if (unlikely(blk_queue_stopped(q)))
+                return;
+
+        if (elv_queue_empty(q))
+                return;
+
         /*
          * Only recurse once to avoid overrunning the stack, let the unplug
          * handling reinvoke the handler shortly if we already got there.
          */
-        if (!elv_queue_empty(q))
-                blk_invoke_request_fn(q);
+        if (!queue_flag_test_and_set(QUEUE_FLAG_REENTER, q)) {
+                q->request_fn(q);
+                queue_flag_clear(QUEUE_FLAG_REENTER, q);
+        } else {
+                queue_flag_set(QUEUE_FLAG_PLUGGED, q);
+                kblockd_schedule_work(q, &q->unplug_work);
+        }
 }
 EXPORT_SYMBOL(__blk_run_queue);
 
@@ -432,9 +423,7 @@ EXPORT_SYMBOL(__blk_run_queue);
  *
  * Description:
  *    Invoke request handling on this queue, if it has pending work to do.
- *    May be used to restart queueing when a request has completed. Also
- *    See @blk_start_queueing.
- *
+ *    May be used to restart queueing when a request has completed.
  */
 void blk_run_queue(struct request_queue *q)
 {
@@ -894,26 +883,58 @@ struct request *blk_get_request(struct request_queue *q, int rw, gfp_t gfp_mask)
 EXPORT_SYMBOL(blk_get_request);
 
 /**
- * blk_start_queueing - initiate dispatch of requests to device
- * @q:          request queue to kick into gear
+ * blk_make_request - given a bio, allocate a corresponding struct request.
+ *
+ * @bio:  The bio describing the memory mappings that will be submitted for IO.
+ *        It may be a chained-bio properly constructed by block/bio layer.
  *
- * This is basically a helper to remove the need to know whether a queue
- * is plugged or not if someone just wants to initiate dispatch of requests
- * for this queue. Should be used to start queueing on a device outside
- * of ->request_fn() context. Also see @blk_run_queue.
+ * blk_make_request is the parallel of generic_make_request for BLOCK_PC
+ * type commands. Where the struct request needs to be farther initialized by
+ * the caller. It is passed a &struct bio, which describes the memory info of
+ * the I/O transfer.
  *
- * The queue lock must be held with interrupts disabled.
+ * The caller of blk_make_request must make sure that bi_io_vec
+ * are set to describe the memory buffers. That bio_data_dir() will return
+ * the needed direction of the request. (And all bio's in the passed bio-chain
+ * are properly set accordingly)
+ *
+ * If called under none-sleepable conditions, mapped bio buffers must not
+ * need bouncing, by calling the appropriate masked or flagged allocator,
+ * suitable for the target device. Otherwise the call to blk_queue_bounce will
+ * BUG.
+ *
+ * WARNING: When allocating/cloning a bio-chain, careful consideration should be
+ * given to how you allocate bios. In particular, you cannot use __GFP_WAIT for
+ * anything but the first bio in the chain. Otherwise you risk waiting for IO
+ * completion of a bio that hasn't been submitted yet, thus resulting in a
+ * deadlock. Alternatively bios should be allocated using bio_kmalloc() instead
+ * of bio_alloc(), as that avoids the mempool deadlock.
+ * If possible a big IO should be split into smaller parts when allocation
+ * fails. Partial allocation should not be an error, or you risk a live-lock.
  */
-void blk_start_queueing(struct request_queue *q)
+struct request *blk_make_request(struct request_queue *q, struct bio *bio,
+                                 gfp_t gfp_mask)
 {
-        if (!blk_queue_plugged(q)) {
-                if (unlikely(blk_queue_stopped(q)))
-                        return;
-                q->request_fn(q);
-        } else
-                __generic_unplug_device(q);
+        struct request *rq = blk_get_request(q, bio_data_dir(bio), gfp_mask);
+
+        if (unlikely(!rq))
+                return ERR_PTR(-ENOMEM);
+
+        for_each_bio(bio) {
+                struct bio *bounce_bio = bio;
+                int ret;
+
+                blk_queue_bounce(q, &bounce_bio);
+                ret = blk_rq_append_bio(q, rq, bounce_bio);
+                if (unlikely(ret)) {
+                        blk_put_request(rq);
+                        return ERR_PTR(ret);
+                }
+        }
+
+        return rq;
 }
-EXPORT_SYMBOL(blk_start_queueing);
+EXPORT_SYMBOL(blk_make_request);
 
 /**
  * blk_requeue_request - put a request back on queue
@@ -934,6 +955,8 @@ void blk_requeue_request(struct request_queue *q, struct request *rq)
         if (blk_rq_tagged(rq))
                 blk_queue_end_tag(q, rq);
 
+        BUG_ON(blk_queued_rq(rq));
+
         elv_requeue_request(q, rq);
 }
 EXPORT_SYMBOL(blk_requeue_request);
@@ -969,7 +992,6 @@ void blk_insert_request(struct request_queue *q, struct request *rq,
          * barrier
          */
         rq->cmd_type = REQ_TYPE_SPECIAL;
-        rq->cmd_flags |= REQ_SOFTBARRIER;
 
         rq->special = data;
 
@@ -983,7 +1005,7 @@ void blk_insert_request(struct request_queue *q, struct request *rq,
 
         drive_stat_acct(rq, 1);
         __elv_add_request(q, rq, where, 0);
-        blk_start_queueing(q);
+        __blk_run_queue(q);
         spin_unlock_irqrestore(q->queue_lock, flags);
 }
 EXPORT_SYMBOL(blk_insert_request);
@@ -1105,16 +1127,13 @@ void init_request_from_bio(struct request *req, struct bio *bio)
         if (bio_failfast_driver(bio))
                 req->cmd_flags |= REQ_FAILFAST_DRIVER;
 
-        /*
-         * REQ_BARRIER implies no merging, but lets make it explicit
-         */
         if (unlikely(bio_discard(bio))) {
                 req->cmd_flags |= REQ_DISCARD;
                 if (bio_barrier(bio))
                         req->cmd_flags |= REQ_SOFTBARRIER;
                 req->q->prepare_discard_fn(req->q, req);
         } else if (unlikely(bio_barrier(bio)))
-                req->cmd_flags |= (REQ_HARDBARRIER | REQ_NOMERGE);
+                req->cmd_flags |= REQ_HARDBARRIER;
 
         if (bio_sync(bio))
                 req->cmd_flags |= REQ_RW_SYNC;
@@ -1124,9 +1143,8 @@ void init_request_from_bio(struct request *req, struct bio *bio)
                 req->cmd_flags |= REQ_NOIDLE;
 
         req->errors = 0;
-        req->hard_sector = req->sector = bio->bi_sector;
+        req->__sector = bio->bi_sector;
         req->ioprio = bio_prio(bio);
-        req->start_time = jiffies;
         blk_rq_bio_prep(req->q, req, bio);
 }
 
@@ -1142,14 +1160,13 @@ static inline bool queue_should_plug(struct request_queue *q)
 static int __make_request(struct request_queue *q, struct bio *bio)
 {
         struct request *req;
-        int el_ret, nr_sectors;
+        int el_ret;
+        unsigned int bytes = bio->bi_size;
         const unsigned short prio = bio_prio(bio);
         const int sync = bio_sync(bio);
         const int unplug = bio_unplug(bio);
         int rw_flags;
 
-        nr_sectors = bio_sectors(bio);
-
         /*
          * low level driver can indicate that it wants pages above a
          * certain limit bounced to low memory (ie for highmem, or even
@@ -1174,7 +1191,7 @@ static int __make_request(struct request_queue *q, struct bio *bio)
 
                 req->biotail->bi_next = bio;
                 req->biotail = bio;
-                req->nr_sectors = req->hard_nr_sectors += nr_sectors;
+                req->__data_len += bytes;
                 req->ioprio = ioprio_best(req->ioprio, prio);
                 if (!blk_rq_cpu_valid(req))
                         req->cpu = bio->bi_comp_cpu;
@@ -1200,10 +1217,8 @@ static int __make_request(struct request_queue *q, struct bio *bio)
                  * not touch req->buffer either...
                  */
                 req->buffer = bio_data(bio);
-                req->current_nr_sectors = bio_cur_sectors(bio);
-                req->hard_cur_sectors = req->current_nr_sectors;
-                req->sector = req->hard_sector = bio->bi_sector;
-                req->nr_sectors = req->hard_nr_sectors += nr_sectors;
+                req->__sector = bio->bi_sector;
+                req->__data_len += bytes;
                 req->ioprio = ioprio_best(req->ioprio, prio);
                 if (!blk_rq_cpu_valid(req))
                         req->cpu = bio->bi_comp_cpu;
@@ -1414,11 +1429,11 @@ static inline void __generic_make_request(struct bio *bio)
                         goto end_io;
                 }
 
-                if (unlikely(nr_sectors > q->max_hw_sectors)) {
+                if (unlikely(nr_sectors > queue_max_hw_sectors(q))) {
                         printk(KERN_ERR "bio too big device %s (%u > %u)\n",
-                                bdevname(bio->bi_bdev, b),
-                                bio_sectors(bio),
-                                q->max_hw_sectors);
+                               bdevname(bio->bi_bdev, b),
+                               bio_sectors(bio),
+                               queue_max_hw_sectors(q));
                         goto end_io;
                 }
 
@@ -1584,8 +1599,8 @@ EXPORT_SYMBOL(submit_bio);
  */
 int blk_rq_check_limits(struct request_queue *q, struct request *rq)
 {
-        if (rq->nr_sectors > q->max_sectors ||
-            rq->data_len > q->max_hw_sectors << 9) {
+        if (blk_rq_sectors(rq) > queue_max_sectors(q) ||
+            blk_rq_bytes(rq) > queue_max_hw_sectors(q) << 9) {
                 printk(KERN_ERR "%s: over max size limit.\n", __func__);
                 return -EIO;
         }
@@ -1597,8 +1612,8 @@ int blk_rq_check_limits(struct request_queue *q, struct request *rq)
          * limitation.
          */
         blk_recalc_rq_segments(rq);
-        if (rq->nr_phys_segments > q->max_phys_segments ||
-            rq->nr_phys_segments > q->max_hw_segments) {
+        if (rq->nr_phys_segments > queue_max_phys_segments(q) ||
+            rq->nr_phys_segments > queue_max_hw_segments(q)) {
                 printk(KERN_ERR "%s: over max segments limit.\n", __func__);
                 return -EIO;
         }
@@ -1642,40 +1657,15 @@ int blk_insert_cloned_request(struct request_queue *q, struct request *rq)
 }
 EXPORT_SYMBOL_GPL(blk_insert_cloned_request);
 
-/**
- * blkdev_dequeue_request - dequeue request and start timeout timer
- * @req: request to dequeue
- *
- * Dequeue @req and start timeout timer on it.  This hands off the
- * request to the driver.
- *
- * Block internal functions which don't want to start timer should
- * call elv_dequeue_request().
- */
-void blkdev_dequeue_request(struct request *req)
-{
-        elv_dequeue_request(req->q, req);
-
-        /*
-         * We are now handing the request to the hardware, add the
-         * timeout handler.
-         */
-        blk_add_timer(req);
-}
-EXPORT_SYMBOL(blkdev_dequeue_request);
-
 static void blk_account_io_completion(struct request *req, unsigned int bytes)
 {
-        if (!blk_do_io_stat(req))
-                return;
-
-        if (blk_fs_request(req)) {
+        if (blk_do_io_stat(req)) {
                 const int rw = rq_data_dir(req);
                 struct hd_struct *part;
                 int cpu;
 
                 cpu = part_stat_lock();
-                part = disk_map_sector_rcu(req->rq_disk, req->sector);
+                part = disk_map_sector_rcu(req->rq_disk, blk_rq_pos(req));
                 part_stat_add(cpu, part, sectors[rw], bytes >> 9);
                 part_stat_unlock();
         }
@@ -1683,22 +1673,19 @@ static void blk_account_io_completion(struct request *req, unsigned int bytes)
 
 static void blk_account_io_done(struct request *req)
 {
-        if (!blk_do_io_stat(req))
-                return;
-
         /*
          * Account IO completion.  bar_rq isn't accounted as a normal
          * IO on queueing nor completion.  Accounting the containing
          * request is enough.
          */
-        if (blk_fs_request(req) && req != &req->q->bar_rq) {
+        if (blk_do_io_stat(req) && req != &req->q->bar_rq) {
                 unsigned long duration = jiffies - req->start_time;
                 const int rw = rq_data_dir(req);
                 struct hd_struct *part;
                 int cpu;
 
                 cpu = part_stat_lock();
-                part = disk_map_sector_rcu(req->rq_disk, req->sector);
+                part = disk_map_sector_rcu(req->rq_disk, blk_rq_pos(req));
 
                 part_stat_inc(cpu, part, ios[rw]);
                 part_stat_add(cpu, part, ticks[rw], duration);
@@ -1710,38 +1697,226 @@ static void blk_account_io_done(struct request *req)
 }
 
 /**
- * __end_that_request_first - end I/O on a request
- * @req:      the request being processed
+ * blk_peek_request - peek at the top of a request queue
+ * @q: request queue to peek at
+ *
+ * Description:
+ *     Return the request at the top of @q.  The returned request
+ *     should be started using blk_start_request() before LLD starts
+ *     processing it.
+ *
+ * Return:
+ *     Pointer to the request at the top of @q if available.  Null
+ *     otherwise.
+ *
+ * Context:
+ *     queue_lock must be held.
+ */
+struct request *blk_peek_request(struct request_queue *q)
+{
+        struct request *rq;
+        int ret;
+
+        while ((rq = __elv_next_request(q)) != NULL) {
+                if (!(rq->cmd_flags & REQ_STARTED)) {
+                        /*
+                         * This is the first time the device driver
+                         * sees this request (possibly after
+                         * requeueing).  Notify IO scheduler.
+                         */
+                        if (blk_sorted_rq(rq))
+                                elv_activate_rq(q, rq);
+
+                        /*
+                         * just mark as started even if we don't start
+                         * it, a request that has been delayed should
+                         * not be passed by new incoming requests
+                         */
+                        rq->cmd_flags |= REQ_STARTED;
+                        trace_block_rq_issue(q, rq);
+                }
+
+                if (!q->boundary_rq || q->boundary_rq == rq) {
+                        q->end_sector = rq_end_sector(rq);
+                        q->boundary_rq = NULL;
+                }
+
+                if (rq->cmd_flags & REQ_DONTPREP)
+                        break;
+
+                if (q->dma_drain_size && blk_rq_bytes(rq)) {
+                        /*
+                         * make sure space for the drain appears we
+                         * know we can do this because max_hw_segments
+                         * has been adjusted to be one fewer than the
+                         * device can handle
+                         */
+                        rq->nr_phys_segments++;
+                }
+
+                if (!q->prep_rq_fn)
+                        break;
+
+                ret = q->prep_rq_fn(q, rq);
+                if (ret == BLKPREP_OK) {
+                        break;
+                } else if (ret == BLKPREP_DEFER) {
+                        /*
+                         * the request may have been (partially) prepped.
+                         * we need to keep this request in the front to
+                         * avoid resource deadlock.  REQ_STARTED will
+                         * prevent other fs requests from passing this one.
+                         */
+                        if (q->dma_drain_size && blk_rq_bytes(rq) &&
+                            !(rq->cmd_flags & REQ_DONTPREP)) {
+                                /*
+                                 * remove the space for the drain we added
+                                 * so that we don't add it again
+                                 */
+                                --rq->nr_phys_segments;
+                        }
+
+                        rq = NULL;
+                        break;
+                } else if (ret == BLKPREP_KILL) {
+                        rq->cmd_flags |= REQ_QUIET;
+                        /*
+                         * Mark this request as started so we don't trigger
+                         * any debug logic in the end I/O path.
+                         */
+                        blk_start_request(rq);
+                        __blk_end_request_all(rq, -EIO);
+                } else {
+                        printk(KERN_ERR "%s: bad return=%d\n", __func__, ret);
+                        break;
+                }
+        }
+
+        return rq;
+}
+EXPORT_SYMBOL(blk_peek_request);
+
+void blk_dequeue_request(struct request *rq)
+{
+        struct request_queue *q = rq->q;
+
+        BUG_ON(list_empty(&rq->queuelist));
+        BUG_ON(ELV_ON_HASH(rq));
+
+        list_del_init(&rq->queuelist);
+
+        /*
+         * the time frame between a request being removed from the lists
+         * and to it is freed is accounted as io that is in progress at
+         * the driver side.
+         */
+        if (blk_account_rq(rq))
+                q->in_flight[rq_is_sync(rq)]++;
+}
+
+/**
+ * blk_start_request - start request processing on the driver
+ * @req: request to dequeue
+ *
+ * Description:
+ *     Dequeue @req and start timeout timer on it.  This hands off the
+ *     request to the driver.
+ *
+ *     Block internal functions which don't want to start timer should
+ *     call blk_dequeue_request().
+ *
+ * Context:
+ *     queue_lock must be held.
+ */
+void blk_start_request(struct request *req)
+{
+        blk_dequeue_request(req);
+
+        /*
+         * We are now handing the request to the hardware, initialize
+         * resid_len to full count and add the timeout handler.
+         */
+        req->resid_len = blk_rq_bytes(req);
+        if (unlikely(blk_bidi_rq(req)))
+                req->next_rq->resid_len = blk_rq_bytes(req->next_rq);
+
+        blk_add_timer(req);
+}
+EXPORT_SYMBOL(blk_start_request);
+
+/**
+ * blk_fetch_request - fetch a request from a request queue
+ * @q: request queue to fetch a request from
+ *
+ * Description:
+ *     Return the request at the top of @q.  The request is started on
+ *     return and LLD can start processing it immediately.
+ *
+ * Return:
+ *     Pointer to the request at the top of @q if available.  Null
+ *     otherwise.
+ *
+ * Context:
+ *     queue_lock must be held.
+ */
+struct request *blk_fetch_request(struct request_queue *q)
+{
+        struct request *rq;
+
+        rq = blk_peek_request(q);
+        if (rq)
+                blk_start_request(rq);
+        return rq;
+}
+EXPORT_SYMBOL(blk_fetch_request);
+
+/**
+ * blk_update_request - Special helper function for request stacking drivers
+ * @rq:       the request being processed
  * @error:    %0 for success, < %0 for error
- * @nr_bytes: number of bytes to complete
+ * @nr_bytes: number of bytes to complete @rq
  *
  * Description:
- *     Ends I/O on a number of bytes attached to @req, and sets it up
- *     for the next range of segments (if any) in the cluster.
+ *     Ends I/O on a number of bytes attached to @rq, but doesn't complete
+ *     the request structure even if @rq doesn't have leftover.
+ *     If @rq has leftover, sets it up for the next range of segments.
+ *
+ *     This special helper function is only for request stacking drivers
+ *     (e.g. request-based dm) so that they can handle partial completion.
+ *     Actual device drivers should use blk_end_request instead.
+ *
+ *     Passing the result of blk_rq_bytes() as @nr_bytes guarantees
+ *     %false return from this function.
  *
  * Return:
- *     %0 - we are done with this request, call end_that_request_last()
- *     %1 - still buffers pending for this request
+ *     %false - this request doesn't have any more data
+ *     %true  - this request has more data
  **/
-static int __end_that_request_first(struct request *req, int error,
-                                    int nr_bytes)
+bool blk_update_request(struct request *req, int error, unsigned int nr_bytes)
 {
         int total_bytes, bio_nbytes, next_idx = 0;
         struct bio *bio;
 
+        if (!req->bio)
+                return false;
+
         trace_block_rq_complete(req->q, req);
 
         /*
-         * for a REQ_TYPE_BLOCK_PC request, we want to carry any eventual
-         * sense key with us all the way through
+         * For fs requests, rq is just carrier of independent bio's
+         * and each partial completion should be handled separately.
+         * Reset per-request error on each partial completion.
+         *
+         * TODO: tj: This is too subtle.  It would be better to let
+         * low level drivers do what they see fit.
          */
-        if (!blk_pc_request(req))
+        if (blk_fs_request(req))
                 req->errors = 0;
 
         if (error && (blk_fs_request(req) && !(req->cmd_flags & REQ_QUIET))) {
                 printk(KERN_ERR "end_request: I/O error, dev %s, sector %llu\n",
                                 req->rq_disk ? req->rq_disk->disk_name : "?",
-                                (unsigned long long)req->sector);
+                                (unsigned long long)blk_rq_pos(req));
         }
 
         blk_account_io_completion(req, nr_bytes);
@@ -1801,8 +1976,15 @@ static int __end_that_request_first(struct request *req, int error,
         /*
          * completely done
          */
-        if (!req->bio)
-                return 0;
+        if (!req->bio) {
+                /*
+                 * Reset counters so that the request stacking driver
+                 * can find how many bytes remain in the request
+                 * later.
+                 */
+                req->__data_len = 0;
+                return false;
+        }
 
         /*
          * if the request wasn't completed, update state
@@ -1814,21 +1996,55 @@ static int __end_that_request_first(struct request *req, int error,
                 bio_iovec(bio)->bv_len -= nr_bytes;
         }
 
-        blk_recalc_rq_sectors(req, total_bytes >> 9);
+        req->__data_len -= total_bytes;
+        req->buffer = bio_data(req->bio);
+
+        /* update sector only for requests with clear definition of sector */
+        if (blk_fs_request(req) || blk_discard_rq(req))
+                req->__sector += total_bytes >> 9;
+
+        /*
+         * If total number of sectors is less than the first segment
+         * size, something has gone terribly wrong.
+         */
+        if (blk_rq_bytes(req) < blk_rq_cur_bytes(req)) {
+                printk(KERN_ERR "blk: request botched\n");
+                req->__data_len = blk_rq_cur_bytes(req);
+        }
+
+        /* recalculate the number of segments */
         blk_recalc_rq_segments(req);
-        return 1;
+
+        return true;
+}
+EXPORT_SYMBOL_GPL(blk_update_request);
+
+static bool blk_update_bidi_request(struct request *rq, int error,
+                                    unsigned int nr_bytes,
+                                    unsigned int bidi_bytes)
+{
+        if (blk_update_request(rq, error, nr_bytes))
+                return true;
+
+        /* Bidi request must be completed as a whole */
+        if (unlikely(blk_bidi_rq(rq)) &&
+            blk_update_request(rq->next_rq, error, bidi_bytes))
+                return true;
+
+        add_disk_randomness(rq->rq_disk);
+
+        return false;
 }
 
 /*
  * queue lock must be held
  */
-static void end_that_request_last(struct request *req, int error)
+static void blk_finish_request(struct request *req, int error)
 {
         if (blk_rq_tagged(req))
                 blk_queue_end_tag(req->q, req);
 
-        if (blk_queued_rq(req))
-                elv_dequeue_request(req->q, req);
+        BUG_ON(blk_queued_rq(req));
 
         if (unlikely(laptop_mode) && blk_fs_request(req))
                 laptop_io_completion();
@@ -1848,117 +2064,62 @@ static void end_that_request_last(struct request *req, int error)
 }
 
 /**
- * blk_rq_bytes - Returns bytes left to complete in the entire request
- * @rq: the request being processed
- **/
-unsigned int blk_rq_bytes(struct request *rq)
-{
-        if (blk_fs_request(rq))
-                return rq->hard_nr_sectors << 9;
-
-        return rq->data_len;
-}
-EXPORT_SYMBOL_GPL(blk_rq_bytes);
-
-/**
- * blk_rq_cur_bytes - Returns bytes left to complete in the current segment
- * @rq: the request being processed
- **/
-unsigned int blk_rq_cur_bytes(struct request *rq)
-{
-        if (blk_fs_request(rq))
-                return rq->current_nr_sectors << 9;
-
-        if (rq->bio)
-                return rq->bio->bi_size;
-
-        return rq->data_len;
-}
-EXPORT_SYMBOL_GPL(blk_rq_cur_bytes);
-
-/**
- * end_request - end I/O on the current segment of the request
- * @req:        the request being processed
- * @uptodate:   error value or %0/%1 uptodate flag
+ * blk_end_bidi_request - Complete a bidi request
+ * @rq:         the request to complete
+ * @error:      %0 for success, < %0 for error
+ * @nr_bytes:   number of bytes to complete @rq
+ * @bidi_bytes: number of bytes to complete @rq->next_rq
  *
  * Description:
- *     Ends I/O on the current segment of a request. If that is the only
- *     remaining segment, the request is also completed and freed.
- *
- *     This is a remnant of how older block drivers handled I/O completions.
- *     Modern drivers typically end I/O on the full request in one go, unless
- *     they have a residual value to account for. For that case this function
- *     isn't really useful, unless the residual just happens to be the
- *     full current segment. In other words, don't use this function in new
- *     code. Use blk_end_request() or __blk_end_request() to end a request.
+ *     Ends I/O on a number of bytes attached to @rq and @rq->next_rq.
+ *     Drivers that supports bidi can safely call this member for any
+ *     type of request, bidi or uni.  In the later case @bidi_bytes is
+ *     just ignored.
+ *
+ * Return:
+ *     %false - we are done with this request
+ *     %true  - still buffers pending for this request
  **/
-void end_request(struct request *req, int uptodate)
-{
-        int error = 0;
-
-        if (uptodate <= 0)
-                error = uptodate ? uptodate : -EIO;
-
-        __blk_end_request(req, error, req->hard_cur_sectors << 9);
-}
-EXPORT_SYMBOL(end_request);
-
-static int end_that_request_data(struct request *rq, int error,
+static bool blk_end_bidi_request(struct request *rq, int error,
                                  unsigned int nr_bytes, unsigned int bidi_bytes)
 {
-        if (rq->bio) {
-                if (__end_that_request_first(rq, error, nr_bytes))
-                        return 1;
+        struct request_queue *q = rq->q;
+        unsigned long flags;
 
-                /* Bidi request must be completed as a whole */
-                if (blk_bidi_rq(rq) &&
-                    __end_that_request_first(rq->next_rq, error, bidi_bytes))
-                        return 1;
-        }
+        if (blk_update_bidi_request(rq, error, nr_bytes, bidi_bytes))
+                return true;
 
-        return 0;
+        spin_lock_irqsave(q->queue_lock, flags);
+        blk_finish_request(rq, error);
+        spin_unlock_irqrestore(q->queue_lock, flags);
+
+        return false;
 }
 
 /**
- * blk_end_io - Generic end_io function to complete a request.
- * @rq:           the request being processed
- * @error:        %0 for success, < %0 for error
- * @nr_bytes:     number of bytes to complete @rq
- * @bidi_bytes:   number of bytes to complete @rq->next_rq
- * @drv_callback: function called between completion of bios in the request
- *                and completion of the request.
- *                If the callback returns non %0, this helper returns without
- *                completion of the request.
+ * __blk_end_bidi_request - Complete a bidi request with queue lock held
+ * @rq:         the request to complete
+ * @error:      %0 for success, < %0 for error
+ * @nr_bytes:   number of bytes to complete @rq
+ * @bidi_bytes: number of bytes to complete @rq->next_rq
  *
  * Description:
- *     Ends I/O on a number of bytes attached to @rq and @rq->next_rq.
- *     If @rq has leftover, sets it up for the next range of segments.
+ *     Identical to blk_end_bidi_request() except that queue lock is
+ *     assumed to be locked on entry and remains so on return.
  *
  * Return:
- *     %0 - we are done with this request
- *     %1 - this request is not freed yet, it still has pending buffers.
+ *     %false - we are done with this request
+ *     %true  - still buffers pending for this request
  **/
-static int blk_end_io(struct request *rq, int error, unsigned int nr_bytes,
-                      unsigned int bidi_bytes,
-                      int (drv_callback)(struct request *))
+static bool __blk_end_bidi_request(struct request *rq, int error,
+                                   unsigned int nr_bytes, unsigned int bidi_bytes)
 {
-        struct request_queue *q = rq->q;
-        unsigned long flags = 0UL;
-
-        if (end_that_request_data(rq, error, nr_bytes, bidi_bytes))
-                return 1;
-
-        /* Special feature for tricky drivers */
-        if (drv_callback && drv_callback(rq))
-                return 1;
-
-        add_disk_randomness(rq->rq_disk);
+        if (blk_update_bidi_request(rq, error, nr_bytes, bidi_bytes))
+                return true;
 
-        spin_lock_irqsave(q->queue_lock, flags);
-        end_that_request_last(rq, error);
-        spin_unlock_irqrestore(q->queue_lock, flags);
+        blk_finish_request(rq, error);
 
-        return 0;
+        return false;
 }
 
 /**
@@ -1972,124 +2133,112 @@ static int blk_end_io(struct request *rq, int error, unsigned int nr_bytes,
  *     If @rq has leftover, sets it up for the next range of segments.
  *
  * Return:
- *     %0 - we are done with this request
- *     %1 - still buffers pending for this request
+ *     %false - we are done with this request
+ *     %true  - still buffers pending for this request
  **/
-int blk_end_request(struct request *rq, int error, unsigned int nr_bytes)
+bool blk_end_request(struct request *rq, int error, unsigned int nr_bytes)
 {
-        return blk_end_io(rq, error, nr_bytes, 0, NULL);
+        return blk_end_bidi_request(rq, error, nr_bytes, 0);
 }
 EXPORT_SYMBOL_GPL(blk_end_request);
 
 /**
- * __blk_end_request - Helper function for drivers to complete the request.
- * @rq:       the request being processed
- * @error:    %0 for success, < %0 for error
- * @nr_bytes: number of bytes to complete
+ * blk_end_request_all - Helper function for drives to finish the request.
+ * @rq: the request to finish
+ * @err: %0 for success, < %0 for error
  *
  * Description:
- *     Must be called with queue lock held unlike blk_end_request().
- *
- * Return:
- *     %0 - we are done with this request
- *     %1 - still buffers pending for this request
- **/
-int __blk_end_request(struct request *rq, int error, unsigned int nr_bytes)
+ *     Completely finish @rq.
+ */
+void blk_end_request_all(struct request *rq, int error)
 {
-        if (rq->bio && __end_that_request_first(rq, error, nr_bytes))
-                return 1;
+        bool pending;
+        unsigned int bidi_bytes = 0;
 
-        add_disk_randomness(rq->rq_disk);
+        if (unlikely(blk_bidi_rq(rq)))
+                bidi_bytes = blk_rq_bytes(rq->next_rq);
 
-        end_that_request_last(rq, error);
+        pending = blk_end_bidi_request(rq, error, blk_rq_bytes(rq), bidi_bytes);
+        BUG_ON(pending);
+}
+EXPORT_SYMBOL_GPL(blk_end_request_all);
 
-        return 0;
+/**
+ * blk_end_request_cur - Helper function to finish the current request chunk.
+ * @rq: the request to finish the current chunk for
+ * @err: %0 for success, < %0 for error
+ *
+ * Description:
+ *     Complete the current consecutively mapped chunk from @rq.
+ *
+ * Return:
+ *     %false - we are done with this request
+ *     %true  - still buffers pending for this request
+ */
+bool blk_end_request_cur(struct request *rq, int error)
+{
+        return blk_end_request(rq, error, blk_rq_cur_bytes(rq));
 }
-EXPORT_SYMBOL_GPL(__blk_end_request);
+EXPORT_SYMBOL_GPL(blk_end_request_cur);
 
 /**
- * blk_end_bidi_request - Helper function for drivers to complete bidi request.
- * @rq:         the bidi request being processed
- * @error:      %0 for success, < %0 for error
- * @nr_bytes:   number of bytes to complete @rq
- * @bidi_bytes: number of bytes to complete @rq->next_rq
+ * __blk_end_request - Helper function for drivers to complete the request.
+ * @rq:       the request being processed
+ * @error:    %0 for success, < %0 for error
+ * @nr_bytes: number of bytes to complete
  *
  * Description:
- *     Ends I/O on a number of bytes attached to @rq and @rq->next_rq.
+ *     Must be called with queue lock held unlike blk_end_request().
  *
  * Return:
- *     %0 - we are done with this request
- *     %1 - still buffers pending for this request
+ *     %false - we are done with this request
+ *     %true  - still buffers pending for this request
  **/
-int blk_end_bidi_request(struct request *rq, int error, unsigned int nr_bytes,
-                         unsigned int bidi_bytes)
+bool __blk_end_request(struct request *rq, int error, unsigned int nr_bytes)
 {
-        return blk_end_io(rq, error, nr_bytes, bidi_bytes, NULL);
+        return __blk_end_bidi_request(rq, error, nr_bytes, 0);
 }
-EXPORT_SYMBOL_GPL(blk_end_bidi_request);
+EXPORT_SYMBOL_GPL(__blk_end_request);
 
 /**
- * blk_update_request - Special helper function for request stacking drivers
- * @rq:           the request being processed
- * @error:        %0 for success, < %0 for error
- * @nr_bytes:     number of bytes to complete @rq
+ * __blk_end_request_all - Helper function for drives to finish the request.
+ * @rq: the request to finish
+ * @err: %0 for success, < %0 for error
  *
  * Description:
- *     Ends I/O on a number of bytes attached to @rq, but doesn't complete
- *     the request structure even if @rq doesn't have leftover.
- *     If @rq has leftover, sets it up for the next range of segments.
- *
- *     This special helper function is only for request stacking drivers
- *     (e.g. request-based dm) so that they can handle partial completion.
- *     Actual device drivers should use blk_end_request instead.
+ *     Completely finish @rq.  Must be called with queue lock held.
  */
-void blk_update_request(struct request *rq, int error, unsigned int nr_bytes)
+void __blk_end_request_all(struct request *rq, int error)
 {
-        if (!end_that_request_data(rq, error, nr_bytes, 0)) {
-                /*
-                 * These members are not updated in end_that_request_data()
-                 * when all bios are completed.
-                 * Update them so that the request stacking driver can find
-                 * how many bytes remain in the request later.
-                 */
-                rq->nr_sectors = rq->hard_nr_sectors = 0;
-                rq->current_nr_sectors = rq->hard_cur_sectors = 0;
-        }
+        bool pending;
+        unsigned int bidi_bytes = 0;
+
+        if (unlikely(blk_bidi_rq(rq)))
+                bidi_bytes = blk_rq_bytes(rq->next_rq);
+
+        pending = __blk_end_bidi_request(rq, error, blk_rq_bytes(rq), bidi_bytes);
+        BUG_ON(pending);
 }
-EXPORT_SYMBOL_GPL(blk_update_request);
+EXPORT_SYMBOL_GPL(__blk_end_request_all);
 
 /**
- * blk_end_request_callback - Special helper function for tricky drivers
- * @rq:           the request being processed
- * @error:        %0 for success, < %0 for error
- * @nr_bytes:     number of bytes to complete
- * @drv_callback: function called between completion of bios in the request
- *                and completion of the request.
- *                If the callback returns non %0, this helper returns without
- *                completion of the request.
+ * __blk_end_request_cur - Helper function to finish the current request chunk.
+ * @rq: the request to finish the current chunk for
+ * @err: %0 for success, < %0 for error
  *
  * Description:
- *     Ends I/O on a number of bytes attached to @rq.
- *     If @rq has leftover, sets it up for the next range of segments.
- *
- *     This special helper function is used only for existing tricky drivers.
- *     (e.g. cdrom_newpc_intr() of ide-cd)
- *     This interface will be removed when such drivers are rewritten.
- *     Don't use this interface in other places anymore.
+ *     Complete the current consecutively mapped chunk from @rq.  Must
+ *     be called with queue lock held.
  *
  * Return:
- *     %0 - we are done with this request
- *     %1 - this request is not freed yet.
- *          this request still has pending buffers or
- *          the driver doesn't want to finish this request yet.
- **/
-int blk_end_request_callback(struct request *rq, int error,
-                             unsigned int nr_bytes,
-                             int (drv_callback)(struct request *))
+ *     %false - we are done with this request
+ *     %true  - still buffers pending for this request
+ */
+bool __blk_end_request_cur(struct request *rq, int error)
 {
-        return blk_end_io(rq, error, nr_bytes, 0, drv_callback);
+        return __blk_end_request(rq, error, blk_rq_cur_bytes(rq));
 }
-EXPORT_SYMBOL_GPL(blk_end_request_callback);
+EXPORT_SYMBOL_GPL(__blk_end_request_cur);
 
 void blk_rq_bio_prep(struct request_queue *q, struct request *rq,
                      struct bio *bio)
@@ -2102,11 +2251,7 @@ void blk_rq_bio_prep(struct request_queue *q, struct request *rq,
                 rq->nr_phys_segments = bio_phys_segments(q, bio);
                 rq->buffer = bio_data(bio);
         }
-        rq->current_nr_sectors = bio_cur_sectors(bio);
-        rq->hard_cur_sectors = rq->current_nr_sectors;
-        rq->hard_nr_sectors = rq->nr_sectors = bio_sectors(bio);
-        rq->data_len = bio->bi_size;
-
+        rq->__data_len = bio->bi_size;
         rq->bio = rq->biotail = bio;
 
         if (bio->bi_bdev)
@@ -2141,6 +2286,106 @@ int blk_lld_busy(struct request_queue *q)
 }
 EXPORT_SYMBOL_GPL(blk_lld_busy);
 
+/**
+ * blk_rq_unprep_clone - Helper function to free all bios in a cloned request
+ * @rq: the clone request to be cleaned up
+ *
+ * Description:
+ *     Free all bios in @rq for a cloned request.
+ */
+void blk_rq_unprep_clone(struct request *rq)
+{
+        struct bio *bio;
+
+        while ((bio = rq->bio) != NULL) {
+                rq->bio = bio->bi_next;
+
+                bio_put(bio);
+        }
+}
+EXPORT_SYMBOL_GPL(blk_rq_unprep_clone);
+
+/*
+ * Copy attributes of the original request to the clone request.
+ * The actual data parts (e.g. ->cmd, ->buffer, ->sense) are not copied.
+ */
+static void __blk_rq_prep_clone(struct request *dst, struct request *src)
+{
+        dst->cpu = src->cpu;
+        dst->cmd_flags = (rq_data_dir(src) | REQ_NOMERGE);
+        dst->cmd_type = src->cmd_type;
+        dst->__sector = blk_rq_pos(src);
+        dst->__data_len = blk_rq_bytes(src);
+        dst->nr_phys_segments = src->nr_phys_segments;
+        dst->ioprio = src->ioprio;
+        dst->extra_len = src->extra_len;
+}
+
+/**
+ * blk_rq_prep_clone - Helper function to setup clone request
+ * @rq: the request to be setup
+ * @rq_src: original request to be cloned
+ * @bs: bio_set that bios for clone are allocated from
+ * @gfp_mask: memory allocation mask for bio
+ * @bio_ctr: setup function to be called for each clone bio.
+ *           Returns %0 for success, non %0 for failure.
+ * @data: private data to be passed to @bio_ctr
+ *
+ * Description:
+ *     Clones bios in @rq_src to @rq, and copies attributes of @rq_src to @rq.
+ *     The actual data parts of @rq_src (e.g. ->cmd, ->buffer, ->sense)
+ *     are not copied, and copying such parts is the caller's responsibility.
+ *     Also, pages which the original bios are pointing to are not copied
+ *     and the cloned bios just point same pages.
+ *     So cloned bios must be completed before original bios, which means
+ *     the caller must complete @rq before @rq_src.
+ */
+int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
+                      struct bio_set *bs, gfp_t gfp_mask,
+                      int (*bio_ctr)(struct bio *, struct bio *, void *),
+                      void *data)
+{
+        struct bio *bio, *bio_src;
+
+        if (!bs)
+                bs = fs_bio_set;
+
+        blk_rq_init(NULL, rq);
+
+        __rq_for_each_bio(bio_src, rq_src) {
+                bio = bio_alloc_bioset(gfp_mask, bio_src->bi_max_vecs, bs);
+                if (!bio)
+                        goto free_and_out;
+
+                __bio_clone(bio, bio_src);
+
+                if (bio_integrity(bio_src) &&
+                    bio_integrity_clone(bio, bio_src, gfp_mask))
+                        goto free_and_out;
+
+                if (bio_ctr && bio_ctr(bio, bio_src, data))
+                        goto free_and_out;
+
+                if (rq->bio) {
+                        rq->biotail->bi_next = bio;
+                        rq->biotail = bio;
+                } else
+                        rq->bio = rq->biotail = bio;
+        }
+
+        __blk_rq_prep_clone(rq, rq_src);
+
+        return 0;
+
+free_and_out:
+        if (bio)
+                bio_free(bio, bs);
+        blk_rq_unprep_clone(rq);
+
+        return -ENOMEM;
+}
+EXPORT_SYMBOL_GPL(blk_rq_prep_clone);
+
 int kblockd_schedule_work(struct request_queue *q, struct work_struct *work)
 {
         return queue_work(kblockd_workqueue, work);
@@ -2149,6 +2394,9 @@ EXPORT_SYMBOL(kblockd_schedule_work);
 
 int __init blk_dev_init(void)
 {
+        BUILD_BUG_ON(__REQ_NR_BITS > 8 *
+                        sizeof(((struct request *)0)->cmd_flags));
+
         kblockd_workqueue = create_workqueue("kblockd");
         if (!kblockd_workqueue)
                 panic("Failed to create kblockd\n");
diff --git a/block/blk-exec.c b/block/blk-exec.c
index 6af716d1e54e..49557e91f0da 100644
--- a/block/blk-exec.c
+++ b/block/blk-exec.c
@@ -51,7 +51,6 @@ void blk_execute_rq_nowait(struct request_queue *q, struct gendisk *bd_disk,
         int where = at_head ? ELEVATOR_INSERT_FRONT : ELEVATOR_INSERT_BACK;
 
         rq->rq_disk = bd_disk;
-        rq->cmd_flags |= REQ_NOMERGE;
         rq->end_io = done;
         WARN_ON(irqs_disabled());
         spin_lock_irq(q->queue_lock);
diff --git a/block/blk-integrity.c b/block/blk-integrity.c
index 91fa8e06b6a5..73e28d355688 100644
--- a/block/blk-integrity.c
+++ b/block/blk-integrity.c
@@ -340,7 +340,7 @@ int blk_integrity_register(struct gendisk *disk, struct blk_integrity *template)
                 kobject_uevent(&bi->kobj, KOBJ_ADD);
 
                 bi->flags |= INTEGRITY_FLAG_READ | INTEGRITY_FLAG_WRITE;
-                bi->sector_size = disk->queue->hardsect_size;
+                bi->sector_size = queue_logical_block_size(disk->queue);
                 disk->integrity = bi;
         } else
                 bi = disk->integrity;
diff --git a/block/blk-ioc.c b/block/blk-ioc.c
index 012f065ac8e2..d4ed6000147d 100644
--- a/block/blk-ioc.c
+++ b/block/blk-ioc.c
@@ -35,9 +35,9 @@ int put_io_context(struct io_context *ioc)
         if (ioc == NULL)
                 return 1;
 
-        BUG_ON(atomic_read(&ioc->refcount) == 0);
+        BUG_ON(atomic_long_read(&ioc->refcount) == 0);
 
-        if (atomic_dec_and_test(&ioc->refcount)) {
+        if (atomic_long_dec_and_test(&ioc->refcount)) {
                 rcu_read_lock();
                 if (ioc->aic && ioc->aic->dtor)
                         ioc->aic->dtor(ioc->aic);
@@ -90,7 +90,7 @@ struct io_context *alloc_io_context(gfp_t gfp_flags, int node)
 
         ret = kmem_cache_alloc_node(iocontext_cachep, gfp_flags, node);
         if (ret) {
-                atomic_set(&ret->refcount, 1);
+                atomic_long_set(&ret->refcount, 1);
                 atomic_set(&ret->nr_tasks, 1);
                 spin_lock_init(&ret->lock);
                 ret->ioprio_changed = 0;
@@ -151,7 +151,7 @@ struct io_context *get_io_context(gfp_t gfp_flags, int node)
                 ret = current_io_context(gfp_flags, node);
                 if (unlikely(!ret))
                         break;
-        } while (!atomic_inc_not_zero(&ret->refcount));
+        } while (!atomic_long_inc_not_zero(&ret->refcount));
 
         return ret;
 }
@@ -163,8 +163,8 @@ void copy_io_context(struct io_context **pdst, struct io_context **psrc)
         struct io_context *dst = *pdst;
 
         if (src) {
-                BUG_ON(atomic_read(&src->refcount) == 0);
-                atomic_inc(&src->refcount);
+                BUG_ON(atomic_long_read(&src->refcount) == 0);
+                atomic_long_inc(&src->refcount);
                 put_io_context(dst);
                 *pdst = src;
         }
diff --git a/block/blk-map.c b/block/blk-map.c
index f103729b462f..9083cf0180cc 100644
--- a/block/blk-map.c
+++ b/block/blk-map.c
@@ -20,11 +20,10 @@ int blk_rq_append_bio(struct request_queue *q, struct request *rq,
                 rq->biotail->bi_next = bio;
                 rq->biotail = bio;
 
-                rq->data_len += bio->bi_size;
+                rq->__data_len += bio->bi_size;
         }
         return 0;
 }
-EXPORT_SYMBOL(blk_rq_append_bio);
 
 static int __blk_rq_unmap_user(struct bio *bio)
 {
@@ -116,7 +115,7 @@ int blk_rq_map_user(struct request_queue *q, struct request *rq,
         struct bio *bio = NULL;
         int ret;
 
-        if (len > (q->max_hw_sectors << 9))
+        if (len > (queue_max_hw_sectors(q) << 9))
                 return -EINVAL;
         if (!len)
                 return -EINVAL;
@@ -156,7 +155,7 @@ int blk_rq_map_user(struct request_queue *q, struct request *rq,
         if (!bio_flagged(bio, BIO_USER_MAPPED))
                 rq->cmd_flags |= REQ_COPY_USER;
 
-        rq->buffer = rq->data = NULL;
+        rq->buffer = NULL;
         return 0;
 unmap_rq:
         blk_rq_unmap_user(bio);
@@ -235,7 +234,7 @@ int blk_rq_map_user_iov(struct request_queue *q, struct request *rq,
         blk_queue_bounce(q, &bio);
         bio_get(bio);
         blk_rq_bio_prep(q, rq, bio);
-        rq->buffer = rq->data = NULL;
+        rq->buffer = NULL;
         return 0;
 }
 EXPORT_SYMBOL(blk_rq_map_user_iov);
@@ -282,7 +281,8 @@ EXPORT_SYMBOL(blk_rq_unmap_user);
  *
  * Description:
  *    Data will be mapped directly if possible. Otherwise a bounce
- *    buffer is used.
+ *    buffer is used. Can be called multple times to append multple
+ *    buffers.
  */
 int blk_rq_map_kern(struct request_queue *q, struct request *rq, void *kbuf,
                     unsigned int len, gfp_t gfp_mask)
@@ -290,8 +290,9 @@ int blk_rq_map_kern(struct request_queue *q, struct request *rq, void *kbuf,
         int reading = rq_data_dir(rq) == READ;
         int do_copy = 0;
         struct bio *bio;
+        int ret;
 
-        if (len > (q->max_hw_sectors << 9))
+        if (len > (queue_max_hw_sectors(q) << 9))
                 return -EINVAL;
         if (!len || !kbuf)
                 return -EINVAL;
@@ -311,9 +312,15 @@ int blk_rq_map_kern(struct request_queue *q, struct request *rq, void *kbuf,
         if (do_copy)
                 rq->cmd_flags |= REQ_COPY_USER;
 
-        blk_rq_bio_prep(q, rq, bio);
+        ret = blk_rq_append_bio(q, rq, bio);
+        if (unlikely(ret)) {
+                /* request is too big */
+                bio_put(bio);
+                return ret;
+        }
+
         blk_queue_bounce(q, &rq->bio);
-        rq->buffer = rq->data = NULL;
+        rq->buffer = NULL;
         return 0;
 }
 EXPORT_SYMBOL(blk_rq_map_kern);
diff --git a/block/blk-merge.c b/block/blk-merge.c
index 23d2a6fe34a3..39ce64432ba6 100644
--- a/block/blk-merge.c
+++ b/block/blk-merge.c
@@ -9,35 +9,6 @@
 
 #include "blk.h"
 
-void blk_recalc_rq_sectors(struct request *rq, int nsect)
-{
-        if (blk_fs_request(rq) || blk_discard_rq(rq)) {
-                rq->hard_sector += nsect;
-                rq->hard_nr_sectors -= nsect;
-
-                /*
-                 * Move the I/O submission pointers ahead if required.
-                 */
-                if ((rq->nr_sectors >= rq->hard_nr_sectors) &&
-                    (rq->sector <= rq->hard_sector)) {
-                        rq->sector = rq->hard_sector;
-                        rq->nr_sectors = rq->hard_nr_sectors;
-                        rq->hard_cur_sectors = bio_cur_sectors(rq->bio);
-                        rq->current_nr_sectors = rq->hard_cur_sectors;
-                        rq->buffer = bio_data(rq->bio);
-                }
-
-                /*
-                 * if total number of sectors is less than the first segment
-                 * size, something has gone terribly wrong
-                 */
-                if (rq->nr_sectors < rq->current_nr_sectors) {
-                        printk(KERN_ERR "blk: request botched\n");
-                        rq->nr_sectors = rq->current_nr_sectors;
-                }
-        }
-}
-
 static unsigned int __blk_recalc_rq_segments(struct request_queue *q,
                                              struct bio *bio)
 {
@@ -61,11 +32,12 @@ static unsigned int __blk_recalc_rq_segments(struct request_queue *q,
                          * never considered part of another segment, since that
                          * might change with the bounce page.
                          */
-                        high = page_to_pfn(bv->bv_page) > q->bounce_pfn;
+                        high = page_to_pfn(bv->bv_page) > queue_bounce_pfn(q);
                         if (high || highprv)
                                 goto new_segment;
                         if (cluster) {
-                                if (seg_size + bv->bv_len > q->max_segment_size)
+                                if (seg_size + bv->bv_len
+                                    > queue_max_segment_size(q))
                                         goto new_segment;
                                 if (!BIOVEC_PHYS_MERGEABLE(bvprv, bv))
                                         goto new_segment;
@@ -120,7 +92,7 @@ static int blk_phys_contig_segment(struct request_queue *q, struct bio *bio,
                 return 0;
 
         if (bio->bi_seg_back_size + nxt->bi_seg_front_size >
-            q->max_segment_size)
+            queue_max_segment_size(q))
                 return 0;
 
         if (!bio_has_data(bio))
@@ -163,7 +135,7 @@ int blk_rq_map_sg(struct request_queue *q, struct request *rq,
                 int nbytes = bvec->bv_len;
 
                 if (bvprv && cluster) {
-                        if (sg->length + nbytes > q->max_segment_size)
+                        if (sg->length + nbytes > queue_max_segment_size(q))
                                 goto new_segment;
 
                         if (!BIOVEC_PHYS_MERGEABLE(bvprv, bvec))
@@ -199,8 +171,9 @@ new_segment:
 
 
         if (unlikely(rq->cmd_flags & REQ_COPY_USER) &&
-            (rq->data_len & q->dma_pad_mask)) {
-                unsigned int pad_len = (q->dma_pad_mask & ~rq->data_len) + 1;
+            (blk_rq_bytes(rq) & q->dma_pad_mask)) {
+                unsigned int pad_len =
+                        (q->dma_pad_mask & ~blk_rq_bytes(rq)) + 1;
 
                 sg->length += pad_len;
                 rq->extra_len += pad_len;
@@ -233,8 +206,8 @@ static inline int ll_new_hw_segment(struct request_queue *q,
 {
         int nr_phys_segs = bio_phys_segments(q, bio);
 
-        if (req->nr_phys_segments + nr_phys_segs > q->max_hw_segments
-            || req->nr_phys_segments + nr_phys_segs > q->max_phys_segments) {
+        if (req->nr_phys_segments + nr_phys_segs > queue_max_hw_segments(q) ||
+            req->nr_phys_segments + nr_phys_segs > queue_max_phys_segments(q)) {
                 req->cmd_flags |= REQ_NOMERGE;
                 if (req == q->last_merge)
                         q->last_merge = NULL;
@@ -255,11 +228,11 @@ int ll_back_merge_fn(struct request_queue *q, struct request *req,
         unsigned short max_sectors;
 
         if (unlikely(blk_pc_request(req)))
-                max_sectors = q->max_hw_sectors;
+                max_sectors = queue_max_hw_sectors(q);
         else
-                max_sectors = q->max_sectors;
+                max_sectors = queue_max_sectors(q);
 
-        if (req->nr_sectors + bio_sectors(bio) > max_sectors) {
+        if (blk_rq_sectors(req) + bio_sectors(bio) > max_sectors) {
                 req->cmd_flags |= REQ_NOMERGE;
                 if (req == q->last_merge)
                         q->last_merge = NULL;
@@ -279,12 +252,12 @@ int ll_front_merge_fn(struct request_queue *q, struct request *req,
         unsigned short max_sectors;
 
         if (unlikely(blk_pc_request(req)))
-                max_sectors = q->max_hw_sectors;
+                max_sectors = queue_max_hw_sectors(q);
         else
-                max_sectors = q->max_sectors;
+                max_sectors = queue_max_sectors(q);
 
 
-        if (req->nr_sectors + bio_sectors(bio) > max_sectors) {
+        if (blk_rq_sectors(req) + bio_sectors(bio) > max_sectors) {
                 req->cmd_flags |= REQ_NOMERGE;
                 if (req == q->last_merge)
                         q->last_merge = NULL;
@@ -315,7 +288,7 @@ static int ll_merge_requests_fn(struct request_queue *q, struct request *req,
         /*
          * Will it become too large?
          */
-        if ((req->nr_sectors + next->nr_sectors) > q->max_sectors)
+        if ((blk_rq_sectors(req) + blk_rq_sectors(next)) > queue_max_sectors(q))
                 return 0;
 
         total_phys_segments = req->nr_phys_segments + next->nr_phys_segments;
@@ -327,10 +300,10 @@ static int ll_merge_requests_fn(struct request_queue *q, struct request *req,
                 total_phys_segments--;
         }
 
-        if (total_phys_segments > q->max_phys_segments)
+        if (total_phys_segments > queue_max_phys_segments(q))
                 return 0;
 
-        if (total_phys_segments > q->max_hw_segments)
+        if (total_phys_segments > queue_max_hw_segments(q))
                 return 0;
 
         /* Merge is OK... */
@@ -345,7 +318,7 @@ static void blk_account_io_merge(struct request *req)
                 int cpu;
 
                 cpu = part_stat_lock();
-                part = disk_map_sector_rcu(req->rq_disk, req->sector);
+                part = disk_map_sector_rcu(req->rq_disk, blk_rq_pos(req));
 
                 part_round_stats(cpu, part);
                 part_dec_in_flight(part);
@@ -366,7 +339,7 @@ static int attempt_merge(struct request_queue *q, struct request *req,
         /*
          * not contiguous
          */
-        if (req->sector + req->nr_sectors != next->sector)
+        if (blk_rq_pos(req) + blk_rq_sectors(req) != blk_rq_pos(next))
                 return 0;
 
         if (rq_data_dir(req) != rq_data_dir(next)
@@ -398,7 +371,7 @@ static int attempt_merge(struct request_queue *q, struct request *req,
         req->biotail->bi_next = next->bio;
         req->biotail = next->biotail;
 
-        req->nr_sectors = req->hard_nr_sectors += next->hard_nr_sectors;
+        req->__data_len += blk_rq_bytes(next);
 
         elv_merge_requests(q, req, next);
 
diff --git a/block/blk-settings.c b/block/blk-settings.c
index 57af728d94bb..1c4df9bf6813 100644
--- a/block/blk-settings.c
+++ b/block/blk-settings.c
@@ -134,7 +134,7 @@ void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn)
         q->backing_dev_info.state = 0;
         q->backing_dev_info.capabilities = BDI_CAP_MAP_COPY;
         blk_queue_max_sectors(q, SAFE_MAX_SECTORS);
-        blk_queue_hardsect_size(q, 512);
+        blk_queue_logical_block_size(q, 512);
         blk_queue_dma_alignment(q, 511);
         blk_queue_congestion_threshold(q);
         q->nr_batching = BLK_BATCH_REQ;
@@ -179,16 +179,16 @@ void blk_queue_bounce_limit(struct request_queue *q, u64 dma_mask)
          */
         if (b_pfn < (min_t(u64, 0xffffffffUL, BLK_BOUNCE_HIGH) >> PAGE_SHIFT))
                 dma = 1;
-        q->bounce_pfn = max_low_pfn;
+        q->limits.bounce_pfn = max_low_pfn;
 #else
         if (b_pfn < blk_max_low_pfn)
                 dma = 1;
-        q->bounce_pfn = b_pfn;
+        q->limits.bounce_pfn = b_pfn;
 #endif
         if (dma) {
                 init_emergency_isa_pool();
                 q->bounce_gfp = GFP_NOIO | GFP_DMA;
-                q->bounce_pfn = b_pfn;
+                q->limits.bounce_pfn = b_pfn;
         }
 }
 EXPORT_SYMBOL(blk_queue_bounce_limit);
@@ -211,14 +211,23 @@ void blk_queue_max_sectors(struct request_queue *q, unsigned int max_sectors)
         }
 
         if (BLK_DEF_MAX_SECTORS > max_sectors)
-                q->max_hw_sectors = q->max_sectors = max_sectors;
+                q->limits.max_hw_sectors = q->limits.max_sectors = max_sectors;
         else {
-                q->max_sectors = BLK_DEF_MAX_SECTORS;
-                q->max_hw_sectors = max_sectors;
+                q->limits.max_sectors = BLK_DEF_MAX_SECTORS;
+                q->limits.max_hw_sectors = max_sectors;
         }
 }
 EXPORT_SYMBOL(blk_queue_max_sectors);
 
+void blk_queue_max_hw_sectors(struct request_queue *q, unsigned int max_sectors)
+{
+        if (BLK_DEF_MAX_SECTORS > max_sectors)
+                q->limits.max_hw_sectors = BLK_DEF_MAX_SECTORS;
+        else
+                q->limits.max_hw_sectors = max_sectors;
+}
+EXPORT_SYMBOL(blk_queue_max_hw_sectors);
+
 /**
  * blk_queue_max_phys_segments - set max phys segments for a request for this queue
  * @q:  the request queue for the device
@@ -238,7 +247,7 @@ void blk_queue_max_phys_segments(struct request_queue *q,
                        __func__, max_segments);
         }
 
-        q->max_phys_segments = max_segments;
+        q->limits.max_phys_segments = max_segments;
 }
 EXPORT_SYMBOL(blk_queue_max_phys_segments);
 
@@ -262,7 +271,7 @@ void blk_queue_max_hw_segments(struct request_queue *q,
                        __func__, max_segments);
         }
 
-        q->max_hw_segments = max_segments;
+        q->limits.max_hw_segments = max_segments;
 }
 EXPORT_SYMBOL(blk_queue_max_hw_segments);
 
@@ -283,26 +292,110 @@ void blk_queue_max_segment_size(struct request_queue *q, unsigned int max_size)
                        __func__, max_size);
         }
 
-        q->max_segment_size = max_size;
+        q->limits.max_segment_size = max_size;
 }
 EXPORT_SYMBOL(blk_queue_max_segment_size);
 
 /**
- * blk_queue_hardsect_size - set hardware sector size for the queue
+ * blk_queue_logical_block_size - set logical block size for the queue
  * @q:  the request queue for the device
- * @size:  the hardware sector size, in bytes
+ * @size:  the logical block size, in bytes
  *
  * Description:
- *   This should typically be set to the lowest possible sector size
- *   that the hardware can operate on (possible without reverting to
- *   even internal read-modify-write operations). Usually the default
- *   of 512 covers most hardware.
+ *   This should be set to the lowest possible block size that the
+ *   storage device can address.  The default of 512 covers most
+ *   hardware.
  **/
-void blk_queue_hardsect_size(struct request_queue *q, unsigned short size)
+void blk_queue_logical_block_size(struct request_queue *q, unsigned short size)
+{
+        q->limits.logical_block_size = size;
+
+        if (q->limits.physical_block_size < size)
+                q->limits.physical_block_size = size;
+
+        if (q->limits.io_min < q->limits.physical_block_size)
+                q->limits.io_min = q->limits.physical_block_size;
+}
+EXPORT_SYMBOL(blk_queue_logical_block_size);
+
+/**
+ * blk_queue_physical_block_size - set physical block size for the queue
+ * @q:  the request queue for the device
+ * @size:  the physical block size, in bytes
+ *
+ * Description:
+ *   This should be set to the lowest possible sector size that the
+ *   hardware can operate on without reverting to read-modify-write
+ *   operations.
+ */
+void blk_queue_physical_block_size(struct request_queue *q, unsigned short size)
+{
+        q->limits.physical_block_size = size;
+
+        if (q->limits.physical_block_size < q->limits.logical_block_size)
+                q->limits.physical_block_size = q->limits.logical_block_size;
+
+        if (q->limits.io_min < q->limits.physical_block_size)
+                q->limits.io_min = q->limits.physical_block_size;
+}
+EXPORT_SYMBOL(blk_queue_physical_block_size);
+
+/**
+ * blk_queue_alignment_offset - set physical block alignment offset
+ * @q:  the request queue for the device
+ * @alignment:  alignment offset in bytes
+ *
+ * Description:
+ *   Some devices are naturally misaligned to compensate for things like
+ *   the legacy DOS partition table 63-sector offset.  Low-level drivers
+ *   should call this function for devices whose first sector is not
+ *   naturally aligned.
+ */
+void blk_queue_alignment_offset(struct request_queue *q, unsigned int offset)
 {
-        q->hardsect_size = size;
+        q->limits.alignment_offset =
+                offset & (q->limits.physical_block_size - 1);
+        q->limits.misaligned = 0;
 }
-EXPORT_SYMBOL(blk_queue_hardsect_size);
+EXPORT_SYMBOL(blk_queue_alignment_offset);
+
+/**
+ * blk_queue_io_min - set minimum request size for the queue
+ * @q:  the request queue for the device
+ * @io_min:  smallest I/O size in bytes
+ *
+ * Description:
+ *   Some devices have an internal block size bigger than the reported
+ *   hardware sector size.  This function can be used to signal the
+ *   smallest I/O the device can perform without incurring a performance
+ *   penalty.
+ */
+void blk_queue_io_min(struct request_queue *q, unsigned int min)
+{
+        q->limits.io_min = min;
+
+        if (q->limits.io_min < q->limits.logical_block_size)
+                q->limits.io_min = q->limits.logical_block_size;
+
+        if (q->limits.io_min < q->limits.physical_block_size)
+                q->limits.io_min = q->limits.physical_block_size;
+}
+EXPORT_SYMBOL(blk_queue_io_min);
+
+/**
+ * blk_queue_io_opt - set optimal request size for the queue
+ * @q:  the request queue for the device
+ * @io_opt:  optimal request size in bytes
+ *
+ * Description:
+ *   Drivers can call this function to set the preferred I/O request
+ *   size for devices that report such a value.
+ */
+void blk_queue_io_opt(struct request_queue *q, unsigned int opt)
+{
+        q->limits.io_opt = opt;
+}
+EXPORT_SYMBOL(blk_queue_io_opt);
 
 /*
  * Returns the minimum that is _not_ zero, unless both are zero.
@@ -317,14 +410,27 @@ EXPORT_SYMBOL(blk_queue_hardsect_size);
 void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b)
 {
         /* zero is "infinity" */
-        t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors);
-        t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors);
-        t->seg_boundary_mask = min_not_zero(t->seg_boundary_mask, b->seg_boundary_mask);
+        t->limits.max_sectors = min_not_zero(queue_max_sectors(t),
+                                             queue_max_sectors(b));
+
+        t->limits.max_hw_sectors = min_not_zero(queue_max_hw_sectors(t),
+                                                queue_max_hw_sectors(b));
+
+        t->limits.seg_boundary_mask = min_not_zero(queue_segment_boundary(t),
+                                                   queue_segment_boundary(b));
+
+        t->limits.max_phys_segments = min_not_zero(queue_max_phys_segments(t),
+                                                   queue_max_phys_segments(b));
+
+        t->limits.max_hw_segments = min_not_zero(queue_max_hw_segments(t),
+                                                 queue_max_hw_segments(b));
+
+        t->limits.max_segment_size = min_not_zero(queue_max_segment_size(t),
+                                                  queue_max_segment_size(b));
+
+        t->limits.logical_block_size = max(queue_logical_block_size(t),
+                                           queue_logical_block_size(b));
 
-        t->max_phys_segments = min_not_zero(t->max_phys_segments, b->max_phys_segments);
-        t->max_hw_segments = min_not_zero(t->max_hw_segments, b->max_hw_segments);
-        t->max_segment_size = min_not_zero(t->max_segment_size, b->max_segment_size);
-        t->hardsect_size = max(t->hardsect_size, b->hardsect_size);
         if (!t->queue_lock)
                 WARN_ON_ONCE(1);
         else if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags)) {
@@ -337,6 +443,109 @@ void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b)
 EXPORT_SYMBOL(blk_queue_stack_limits);
 
 /**
+ * blk_stack_limits - adjust queue_limits for stacked devices
+ * @t:  the stacking driver limits (top)
+ * @b:  the underlying queue limits (bottom)
+ * @offset:  offset to beginning of data within component device
+ *
+ * Description:
+ *    Merges two queue_limit structs.  Returns 0 if alignment didn't
+ *    change.  Returns -1 if adding the bottom device caused
+ *    misalignment.
+ */
+int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
+                     sector_t offset)
+{
+        t->max_sectors = min_not_zero(t->max_sectors, b->max_sectors);
+        t->max_hw_sectors = min_not_zero(t->max_hw_sectors, b->max_hw_sectors);
+        t->bounce_pfn = min_not_zero(t->bounce_pfn, b->bounce_pfn);
+
+        t->seg_boundary_mask = min_not_zero(t->seg_boundary_mask,
+                                            b->seg_boundary_mask);
+
+        t->max_phys_segments = min_not_zero(t->max_phys_segments,
+                                            b->max_phys_segments);
+
+        t->max_hw_segments = min_not_zero(t->max_hw_segments,
+                                          b->max_hw_segments);
+
+        t->max_segment_size = min_not_zero(t->max_segment_size,
+                                           b->max_segment_size);
+
+        t->logical_block_size = max(t->logical_block_size,
+                                    b->logical_block_size);
+
+        t->physical_block_size = max(t->physical_block_size,
+                                     b->physical_block_size);
+
+        t->io_min = max(t->io_min, b->io_min);
+        t->no_cluster |= b->no_cluster;
+
+        /* Bottom device offset aligned? */
+        if (offset &&
+            (offset & (b->physical_block_size - 1)) != b->alignment_offset) {
+                t->misaligned = 1;
+                return -1;
+        }
+
+        /* If top has no alignment offset, inherit from bottom */
+        if (!t->alignment_offset)
+                t->alignment_offset =
+                        b->alignment_offset & (b->physical_block_size - 1);
+
+        /* Top device aligned on logical block boundary? */
+        if (t->alignment_offset & (t->logical_block_size - 1)) {
+                t->misaligned = 1;
+                return -1;
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(blk_stack_limits);
+
+/**
+ * disk_stack_limits - adjust queue limits for stacked drivers
+ * @disk:  MD/DM gendisk (top)
+ * @bdev:  the underlying block device (bottom)
+ * @offset:  offset to beginning of data within component device
+ *
+ * Description:
+ *    Merges the limits for two queues.  Returns 0 if alignment
+ *    didn't change.  Returns -1 if adding the bottom device caused
+ *    misalignment.
+ */
+void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
+                       sector_t offset)
+{
+        struct request_queue *t = disk->queue;
+        struct request_queue *b = bdev_get_queue(bdev);
+
+        offset += get_start_sect(bdev) << 9;
+
+        if (blk_stack_limits(&t->limits, &b->limits, offset) < 0) {
+                char top[BDEVNAME_SIZE], bottom[BDEVNAME_SIZE];
+
+                disk_name(disk, 0, top);
+                bdevname(bdev, bottom);
+
+                printk(KERN_NOTICE "%s: Warning: Device %s is misaligned\n",
+                       top, bottom);
+        }
+
+        if (!t->queue_lock)
+                WARN_ON_ONCE(1);
+        else if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags)) {
+                unsigned long flags;
+
+                spin_lock_irqsave(t->queue_lock, flags);
+                if (!test_bit(QUEUE_FLAG_CLUSTER, &b->queue_flags))
+                        queue_flag_clear(QUEUE_FLAG_CLUSTER, t);
+                spin_unlock_irqrestore(t->queue_lock, flags);
+        }
+}
+EXPORT_SYMBOL(disk_stack_limits);
+
+/**
  * blk_queue_dma_pad - set pad mask
  * @q:     the request queue for the device
  * @mask:  pad mask
@@ -396,11 +605,11 @@ int blk_queue_dma_drain(struct request_queue *q,
                                dma_drain_needed_fn *dma_drain_needed,
                                void *buf, unsigned int size)
 {
-        if (q->max_hw_segments < 2 || q->max_phys_segments < 2)
+        if (queue_max_hw_segments(q) < 2 || queue_max_phys_segments(q) < 2)
                 return -EINVAL;
         /* make room for appending the drain */
-        --q->max_hw_segments;
-        --q->max_phys_segments;
+        blk_queue_max_hw_segments(q, queue_max_hw_segments(q) - 1);
+        blk_queue_max_phys_segments(q, queue_max_phys_segments(q) - 1);
         q->dma_drain_needed = dma_drain_needed;
         q->dma_drain_buffer = buf;
         q->dma_drain_size = size;
@@ -422,7 +631,7 @@ void blk_queue_segment_boundary(struct request_queue *q, unsigned long mask)
                        __func__, mask);
         }
 
-        q->seg_boundary_mask = mask;
+        q->limits.seg_boundary_mask = mask;
 }
 EXPORT_SYMBOL(blk_queue_segment_boundary);
 
diff --git a/block/blk-sysfs.c b/block/blk-sysfs.c
index 26f9ec28f56c..b1cd04087d6a 100644
--- a/block/blk-sysfs.c
+++ b/block/blk-sysfs.c
@@ -95,21 +95,36 @@ queue_ra_store(struct request_queue *q, const char *page, size_t count)
 
 static ssize_t queue_max_sectors_show(struct request_queue *q, char *page)
 {
-        int max_sectors_kb = q->max_sectors >> 1;
+        int max_sectors_kb = queue_max_sectors(q) >> 1;
 
         return queue_var_show(max_sectors_kb, (page));
 }
 
-static ssize_t queue_hw_sector_size_show(struct request_queue *q, char *page)
+static ssize_t queue_logical_block_size_show(struct request_queue *q, char *page)
 {
-        return queue_var_show(q->hardsect_size, page);
+        return queue_var_show(queue_logical_block_size(q), page);
+}
+
+static ssize_t queue_physical_block_size_show(struct request_queue *q, char *page)
+{
+        return queue_var_show(queue_physical_block_size(q), page);
+}
+
+static ssize_t queue_io_min_show(struct request_queue *q, char *page)
+{
+        return queue_var_show(queue_io_min(q), page);
+}
+
+static ssize_t queue_io_opt_show(struct request_queue *q, char *page)
+{
+        return queue_var_show(queue_io_opt(q), page);
 }
 
 static ssize_t
 queue_max_sectors_store(struct request_queue *q, const char *page, size_t count)
 {
         unsigned long max_sectors_kb,
-                        max_hw_sectors_kb = q->max_hw_sectors >> 1,
+                max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1,
                         page_kb = 1 << (PAGE_CACHE_SHIFT - 10);
         ssize_t ret = queue_var_store(&max_sectors_kb, page, count);
 
@@ -117,7 +132,7 @@ queue_max_sectors_store(struct request_queue *q, const char *page, size_t count)
                 return -EINVAL;
 
         spin_lock_irq(q->queue_lock);
-        q->max_sectors = max_sectors_kb << 1;
+        blk_queue_max_sectors(q, max_sectors_kb << 1);
         spin_unlock_irq(q->queue_lock);
 
         return ret;
@@ -125,7 +140,7 @@ queue_max_sectors_store(struct request_queue *q, const char *page, size_t count)
 
 static ssize_t queue_max_hw_sectors_show(struct request_queue *q, char *page)
 {
-        int max_hw_sectors_kb = q->max_hw_sectors >> 1;
+        int max_hw_sectors_kb = queue_max_hw_sectors(q) >> 1;
 
         return queue_var_show(max_hw_sectors_kb, (page));
 }
@@ -249,7 +264,27 @@ static struct queue_sysfs_entry queue_iosched_entry = {
 
 static struct queue_sysfs_entry queue_hw_sector_size_entry = {
         .attr = {.name = "hw_sector_size", .mode = S_IRUGO },
-        .show = queue_hw_sector_size_show,
+        .show = queue_logical_block_size_show,
+};
+
+static struct queue_sysfs_entry queue_logical_block_size_entry = {
+        .attr = {.name = "logical_block_size", .mode = S_IRUGO },
+        .show = queue_logical_block_size_show,
+};
+
+static struct queue_sysfs_entry queue_physical_block_size_entry = {
+        .attr = {.name = "physical_block_size", .mode = S_IRUGO },
+        .show = queue_physical_block_size_show,
+};
+
+static struct queue_sysfs_entry queue_io_min_entry = {
+        .attr = {.name = "minimum_io_size", .mode = S_IRUGO },
+        .show = queue_io_min_show,
+};
+
+static struct queue_sysfs_entry queue_io_opt_entry = {
+        .attr = {.name = "optimal_io_size", .mode = S_IRUGO },
+        .show = queue_io_opt_show,
 };
 
 static struct queue_sysfs_entry queue_nonrot_entry = {
@@ -283,6 +318,10 @@ static struct attribute *default_attrs[] = {
         &queue_max_sectors_entry.attr,
         &queue_iosched_entry.attr,
         &queue_hw_sector_size_entry.attr,
+        &queue_logical_block_size_entry.attr,
+        &queue_physical_block_size_entry.attr,
+        &queue_io_min_entry.attr,
+        &queue_io_opt_entry.attr,
         &queue_nonrot_entry.attr,
         &queue_nomerges_entry.attr,
         &queue_rq_affinity_entry.attr,
@@ -394,16 +433,15 @@ int blk_register_queue(struct gendisk *disk)
         if (ret)
                 return ret;
 
-        if (!q->request_fn)
-                return 0;
-
-        ret = kobject_add(&q->kobj, kobject_get(&dev->kobj),
-                          "%s", "queue");
+        ret = kobject_add(&q->kobj, kobject_get(&dev->kobj), "%s", "queue");
         if (ret < 0)
                 return ret;
 
         kobject_uevent(&q->kobj, KOBJ_ADD);
 
+        if (!q->request_fn)
+                return 0;
+
         ret = elv_register_queue(q);
         if (ret) {
                 kobject_uevent(&q->kobj, KOBJ_REMOVE);
diff --git a/block/blk-tag.c b/block/blk-tag.c
index 3c518e3303ae..2e5cfeb59333 100644
--- a/block/blk-tag.c
+++ b/block/blk-tag.c
@@ -336,7 +336,7 @@ EXPORT_SYMBOL(blk_queue_end_tag);
 int blk_queue_start_tag(struct request_queue *q, struct request *rq)
 {
         struct blk_queue_tag *bqt = q->queue_tags;
-        unsigned max_depth, offset;
+        unsigned max_depth;
         int tag;
 
         if (unlikely((rq->cmd_flags & REQ_QUEUED))) {
@@ -355,13 +355,16 @@ int blk_queue_start_tag(struct request_queue *q, struct request *rq)
          * to starve sync IO on behalf of flooding async IO.
          */
         max_depth = bqt->max_depth;
-        if (rq_is_sync(rq))
-                offset = 0;
-        else
-                offset = max_depth >> 2;
+        if (!rq_is_sync(rq) && max_depth > 1) {
+                max_depth -= 2;
+                if (!max_depth)
+                        max_depth = 1;
+                if (q->in_flight[0] > max_depth)
+                        return 1;
+        }
 
         do {
-                tag = find_next_zero_bit(bqt->tag_map, max_depth, offset);
+                tag = find_first_zero_bit(bqt->tag_map, max_depth);
                 if (tag >= max_depth)
                         return 1;
 
@@ -374,7 +377,7 @@ int blk_queue_start_tag(struct request_queue *q, struct request *rq)
         rq->cmd_flags |= REQ_QUEUED;
         rq->tag = tag;
         bqt->tag_index[tag] = rq;
-        blkdev_dequeue_request(rq);
+        blk_start_request(rq);
         list_add(&rq->queuelist, &q->tag_busy_list);
         return 0;
 }
diff --git a/block/blk-timeout.c b/block/blk-timeout.c
index 1ec0d503cacd..1ba7e0aca878 100644
--- a/block/blk-timeout.c
+++ b/block/blk-timeout.c
@@ -122,10 +122,8 @@ void blk_rq_timed_out_timer(unsigned long data)
                         if (blk_mark_rq_complete(rq))
                                 continue;
                         blk_rq_timed_out(rq);
-                } else {
-                        if (!next || time_after(next, rq->deadline))
-                                next = rq->deadline;
-                }
+                } else if (!next || time_after(next, rq->deadline))
+                        next = rq->deadline;
         }
 
         /*
@@ -176,16 +174,14 @@ void blk_add_timer(struct request *req)
         BUG_ON(!list_empty(&req->timeout_list));
         BUG_ON(test_bit(REQ_ATOM_COMPLETE, &req->atomic_flags));
 
-        if (req->timeout)
-                req->deadline = jiffies + req->timeout;
-        else {
-                req->deadline = jiffies + q->rq_timeout;
-                /*
-                 * Some LLDs, like scsi, peek at the timeout to prevent
-                 * a command from being retried forever.
-                 */
+        /*
+         * Some LLDs, like scsi, peek at the timeout to prevent a
+         * command from being retried forever.
+         */
+        if (!req->timeout)
                 req->timeout = q->rq_timeout;
-        }
+
+        req->deadline = jiffies + req->timeout;
         list_add_tail(&req->timeout_list, &q->timeout_list);
 
         /*
diff --git a/block/blk.h b/block/blk.h
index 79c85f7c9ff5..3fae6add5430 100644
--- a/block/blk.h
+++ b/block/blk.h
@@ -13,6 +13,9 @@ extern struct kobj_type blk_queue_ktype;
 void init_request_from_bio(struct request *req, struct bio *bio);
 void blk_rq_bio_prep(struct request_queue *q, struct request *rq,
                         struct bio *bio);
+int blk_rq_append_bio(struct request_queue *q, struct request *rq,
+                      struct bio *bio);
+void blk_dequeue_request(struct request *rq);
 void __blk_queue_free_tags(struct request_queue *q);
 
 void blk_unplug_work(struct work_struct *work);
@@ -43,6 +46,43 @@ static inline void blk_clear_rq_complete(struct request *rq)
         clear_bit(REQ_ATOM_COMPLETE, &rq->atomic_flags);
 }
 
+/*
+ * Internal elevator interface
+ */
+#define ELV_ON_HASH(rq)         (!hlist_unhashed(&(rq)->hash))
+
+static inline struct request *__elv_next_request(struct request_queue *q)
+{
+        struct request *rq;
+
+        while (1) {
+                while (!list_empty(&q->queue_head)) {
+                        rq = list_entry_rq(q->queue_head.next);
+                        if (blk_do_ordered(q, &rq))
+                                return rq;
+                }
+
+                if (!q->elevator->ops->elevator_dispatch_fn(q, 0))
+                        return NULL;
+        }
+}
+
+static inline void elv_activate_rq(struct request_queue *q, struct request *rq)
+{
+        struct elevator_queue *e = q->elevator;
+
+        if (e->ops->elevator_activate_req_fn)
+                e->ops->elevator_activate_req_fn(q, rq);
+}
+
+static inline void elv_deactivate_rq(struct request_queue *q, struct request *rq)
+{
+        struct elevator_queue *e = q->elevator;
+
+        if (e->ops->elevator_deactivate_req_fn)
+                e->ops->elevator_deactivate_req_fn(q, rq);
+}
+
 #ifdef CONFIG_FAIL_IO_TIMEOUT
 int blk_should_fake_timeout(struct request_queue *);
 ssize_t part_timeout_show(struct device *, struct device_attribute *, char *);
@@ -64,7 +104,6 @@ int ll_front_merge_fn(struct request_queue *q, struct request *req,
 int attempt_back_merge(struct request_queue *q, struct request *rq);
 int attempt_front_merge(struct request_queue *q, struct request *rq);
 void blk_recalc_rq_segments(struct request *rq);
-void blk_recalc_rq_sectors(struct request *rq, int nsect);
 
 void blk_queue_congestion_threshold(struct request_queue *q);
 
@@ -112,9 +151,17 @@ static inline int blk_cpu_to_group(int cpu)
 #endif
 }
 
+/*
+ * Contribute to IO statistics IFF:
+ *
+ *      a) it's attached to a gendisk, and
+ *      b) the queue had IO stats enabled when this request was started, and
+ *      c) it's a file system request or a discard request
+ */
 static inline int blk_do_io_stat(struct request *rq)
 {
-        return rq->rq_disk && blk_rq_io_stat(rq);
+        return rq->rq_disk && blk_rq_io_stat(rq) &&
+               (blk_fs_request(rq) || blk_discard_rq(rq));
 }
 
 #endif
diff --git a/block/bsg.c b/block/bsg.c
index dd81be455e00..5358f9ae13c1 100644
--- a/block/bsg.c
+++ b/block/bsg.c
@@ -446,15 +446,15 @@ static int blk_complete_sgv4_hdr_rq(struct request *rq, struct sg_io_v4 *hdr,
         }
 
         if (rq->next_rq) {
-                hdr->dout_resid = rq->data_len;
-                hdr->din_resid = rq->next_rq->data_len;
+                hdr->dout_resid = rq->resid_len;
+                hdr->din_resid = rq->next_rq->resid_len;
                 blk_rq_unmap_user(bidi_bio);
                 rq->next_rq->bio = NULL;
                 blk_put_request(rq->next_rq);
         } else if (rq_data_dir(rq) == READ)
-                hdr->din_resid = rq->data_len;
+                hdr->din_resid = rq->resid_len;
         else
-                hdr->dout_resid = rq->data_len;
+                hdr->dout_resid = rq->resid_len;
 
         /*
          * If the request generated a negative error number, return it
diff --git a/block/cfq-iosched.c b/block/cfq-iosched.c
index a55a9bd75bd1..ef2f72d42434 100644
--- a/block/cfq-iosched.c
+++ b/block/cfq-iosched.c
@@ -349,8 +349,8 @@ cfq_choose_req(struct cfq_data *cfqd, struct request *rq1, struct request *rq2)
         else if (rq_is_meta(rq2) && !rq_is_meta(rq1))
                 return rq2;
 
-        s1 = rq1->sector;
-        s2 = rq2->sector;
+        s1 = blk_rq_pos(rq1);
+        s2 = blk_rq_pos(rq2);
 
         last = cfqd->last_position;
 
@@ -579,9 +579,9 @@ cfq_prio_tree_lookup(struct cfq_data *cfqd, struct rb_root *root,
                  * Sort strictly based on sector.  Smallest to the left,
                  * largest to the right.
                  */
-                if (sector > cfqq->next_rq->sector)
+                if (sector > blk_rq_pos(cfqq->next_rq))
                         n = &(*p)->rb_right;
-                else if (sector < cfqq->next_rq->sector)
+                else if (sector < blk_rq_pos(cfqq->next_rq))
                         n = &(*p)->rb_left;
                 else
                         break;
@@ -611,8 +611,8 @@ static void cfq_prio_tree_add(struct cfq_data *cfqd, struct cfq_queue *cfqq)
                 return;
 
         cfqq->p_root = &cfqd->prio_trees[cfqq->org_ioprio];
-        __cfqq = cfq_prio_tree_lookup(cfqd, cfqq->p_root, cfqq->next_rq->sector,
-                                         &parent, &p);
+        __cfqq = cfq_prio_tree_lookup(cfqd, cfqq->p_root,
+                                      blk_rq_pos(cfqq->next_rq), &parent, &p);
         if (!__cfqq) {
                 rb_link_node(&cfqq->p_node, parent, p);
                 rb_insert_color(&cfqq->p_node, cfqq->p_root);
@@ -760,7 +760,7 @@ static void cfq_activate_request(struct request_queue *q, struct request *rq)
         cfq_log_cfqq(cfqd, RQ_CFQQ(rq), "activate rq, drv=%d",
                                                 cfqd->rq_in_driver);
 
-        cfqd->last_position = rq->hard_sector + rq->hard_nr_sectors;
+        cfqd->last_position = blk_rq_pos(rq) + blk_rq_sectors(rq);
 }
 
 static void cfq_deactivate_request(struct request_queue *q, struct request *rq)
@@ -949,10 +949,10 @@ static struct cfq_queue *cfq_set_active_queue(struct cfq_data *cfqd,
 static inline sector_t cfq_dist_from_last(struct cfq_data *cfqd,
                                           struct request *rq)
 {
-        if (rq->sector >= cfqd->last_position)
-                return rq->sector - cfqd->last_position;
+        if (blk_rq_pos(rq) >= cfqd->last_position)
+                return blk_rq_pos(rq) - cfqd->last_position;
         else
-                return cfqd->last_position - rq->sector;
+                return cfqd->last_position - blk_rq_pos(rq);
 }
 
 #define CIC_SEEK_THR    8 * 1024
@@ -996,7 +996,7 @@ static struct cfq_queue *cfqq_close(struct cfq_data *cfqd,
         if (cfq_rq_close(cfqd, __cfqq->next_rq))
                 return __cfqq;
 
-        if (__cfqq->next_rq->sector < sector)
+        if (blk_rq_pos(__cfqq->next_rq) < sector)
                 node = rb_next(&__cfqq->p_node);
         else
                 node = rb_prev(&__cfqq->p_node);
@@ -1282,7 +1282,7 @@ static void cfq_dispatch_request(struct cfq_data *cfqd, struct cfq_queue *cfqq)
         if (!cfqd->active_cic) {
                 struct cfq_io_context *cic = RQ_CIC(rq);
 
-                atomic_inc(&cic->ioc->refcount);
+                atomic_long_inc(&cic->ioc->refcount);
                 cfqd->active_cic = cic;
         }
 }
@@ -1918,10 +1918,10 @@ cfq_update_io_seektime(struct cfq_data *cfqd, struct cfq_io_context *cic,
 
         if (!cic->last_request_pos)
                 sdist = 0;
-        else if (cic->last_request_pos < rq->sector)
-                sdist = rq->sector - cic->last_request_pos;
+        else if (cic->last_request_pos < blk_rq_pos(rq))
+                sdist = blk_rq_pos(rq) - cic->last_request_pos;
         else
-                sdist = cic->last_request_pos - rq->sector;
+                sdist = cic->last_request_pos - blk_rq_pos(rq);
 
         /*
          * Don't allow the seek distance to get too large from the
@@ -2071,7 +2071,7 @@ cfq_rq_enqueued(struct cfq_data *cfqd, struct cfq_queue *cfqq,
         cfq_update_io_seektime(cfqd, cic, rq);
         cfq_update_idle_window(cfqd, cfqq, cic);
 
-        cic->last_request_pos = rq->sector + rq->nr_sectors;
+        cic->last_request_pos = blk_rq_pos(rq) + blk_rq_sectors(rq);
 
         if (cfqq == cfqd->active_queue) {
                 /*
@@ -2088,7 +2088,7 @@ cfq_rq_enqueued(struct cfq_data *cfqd, struct cfq_queue *cfqq,
                         if (blk_rq_bytes(rq) > PAGE_CACHE_SIZE ||
                             cfqd->busy_queues > 1) {
                                 del_timer(&cfqd->idle_slice_timer);
-                                blk_start_queueing(cfqd->queue);
+                        __blk_run_queue(cfqd->queue);
                         }
                         cfq_mark_cfqq_must_dispatch(cfqq);
                 }
@@ -2100,7 +2100,7 @@ cfq_rq_enqueued(struct cfq_data *cfqd, struct cfq_queue *cfqq,
                  * this new queue is RT and the current one is BE
                  */
                 cfq_preempt_queue(cfqd, cfqq);
-                blk_start_queueing(cfqd->queue);
+                __blk_run_queue(cfqd->queue);
         }
 }
 
@@ -2345,7 +2345,7 @@ static void cfq_kick_queue(struct work_struct *work)
         struct request_queue *q = cfqd->queue;
 
         spin_lock_irq(q->queue_lock);
-        blk_start_queueing(q);
+        __blk_run_queue(cfqd->queue);
         spin_unlock_irq(q->queue_lock);
 }
 
diff --git a/block/compat_ioctl.c b/block/compat_ioctl.c
index f8c218cd08e1..7865a34e0faa 100644
--- a/block/compat_ioctl.c
+++ b/block/compat_ioctl.c
@@ -763,10 +763,10 @@ long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)
         case BLKBSZGET_32: /* get the logical block size (cf. BLKSSZGET) */
                 return compat_put_int(arg, block_size(bdev));
         case BLKSSZGET: /* get block device hardware sector size */
-                return compat_put_int(arg, bdev_hardsect_size(bdev));
+                return compat_put_int(arg, bdev_logical_block_size(bdev));
         case BLKSECTGET:
                 return compat_put_ushort(arg,
-                                         bdev_get_queue(bdev)->max_sectors);
+                                         queue_max_sectors(bdev_get_queue(bdev)));
         case BLKRASET: /* compatible, but no compat_ptr (!) */
         case BLKFRASET:
                 if (!capable(CAP_SYS_ADMIN))
diff --git a/block/deadline-iosched.c b/block/deadline-iosched.c
index c4d991d4adef..b547cbca7b23 100644
--- a/block/deadline-iosched.c
+++ b/block/deadline-iosched.c
@@ -138,7 +138,7 @@ deadline_merge(struct request_queue *q, struct request **req, struct bio *bio)
 
                 __rq = elv_rb_find(&dd->sort_list[bio_data_dir(bio)], sector);
                 if (__rq) {
-                        BUG_ON(sector != __rq->sector);
+                        BUG_ON(sector != blk_rq_pos(__rq));
 
                         if (elv_rq_merge_ok(__rq, bio)) {
                                 ret = ELEVATOR_FRONT_MERGE;
diff --git a/block/elevator.c b/block/elevator.c
index e220f0c543e3..ca861927ba41 100644
--- a/block/elevator.c
+++ b/block/elevator.c
@@ -51,8 +51,7 @@ static const int elv_hash_shift = 6;
 #define ELV_HASH_FN(sec)        \
                 (hash_long(ELV_HASH_BLOCK((sec)), elv_hash_shift))
 #define ELV_HASH_ENTRIES        (1 << elv_hash_shift)
-#define rq_hash_key(rq)         ((rq)->sector + (rq)->nr_sectors)
-#define ELV_ON_HASH(rq)         (!hlist_unhashed(&(rq)->hash))
+#define rq_hash_key(rq)         (blk_rq_pos(rq) + blk_rq_sectors(rq))
 
 /*
  * Query io scheduler to see if the current process issuing bio may be
@@ -116,9 +115,9 @@ static inline int elv_try_merge(struct request *__rq, struct bio *bio)
          * we can merge and sequence is ok, check if it's possible
          */
         if (elv_rq_merge_ok(__rq, bio)) {
-                if (__rq->sector + __rq->nr_sectors == bio->bi_sector)
+                if (blk_rq_pos(__rq) + blk_rq_sectors(__rq) == bio->bi_sector)
                         ret = ELEVATOR_BACK_MERGE;
-                else if (__rq->sector - bio_sectors(bio) == bio->bi_sector)
+                else if (blk_rq_pos(__rq) - bio_sectors(bio) == bio->bi_sector)
                         ret = ELEVATOR_FRONT_MERGE;
         }
 
@@ -306,22 +305,6 @@ void elevator_exit(struct elevator_queue *e)
 }
 EXPORT_SYMBOL(elevator_exit);
 
-static void elv_activate_rq(struct request_queue *q, struct request *rq)
-{
-        struct elevator_queue *e = q->elevator;
-
-        if (e->ops->elevator_activate_req_fn)
-                e->ops->elevator_activate_req_fn(q, rq);
-}
-
-static void elv_deactivate_rq(struct request_queue *q, struct request *rq)
-{
-        struct elevator_queue *e = q->elevator;
-
-        if (e->ops->elevator_deactivate_req_fn)
-                e->ops->elevator_deactivate_req_fn(q, rq);
-}
-
 static inline void __elv_rqhash_del(struct request *rq)
 {
         hlist_del_init(&rq->hash);
@@ -383,9 +366,9 @@ struct request *elv_rb_add(struct rb_root *root, struct request *rq)
                 parent = *p;
                 __rq = rb_entry(parent, struct request, rb_node);
 
-                if (rq->sector < __rq->sector)
+                if (blk_rq_pos(rq) < blk_rq_pos(__rq))
                         p = &(*p)->rb_left;
-                else if (rq->sector > __rq->sector)
+                else if (blk_rq_pos(rq) > blk_rq_pos(__rq))
                         p = &(*p)->rb_right;
                 else
                         return __rq;
@@ -413,9 +396,9 @@ struct request *elv_rb_find(struct rb_root *root, sector_t sector)
         while (n) {
                 rq = rb_entry(n, struct request, rb_node);
 
-                if (sector < rq->sector)
+                if (sector < blk_rq_pos(rq))
                         n = n->rb_left;
-                else if (sector > rq->sector)
+                else if (sector > blk_rq_pos(rq))
                         n = n->rb_right;
                 else
                         return rq;
@@ -454,14 +437,14 @@ void elv_dispatch_sort(struct request_queue *q, struct request *rq)
                         break;
                 if (pos->cmd_flags & stop_flags)
                         break;
-                if (rq->sector >= boundary) {
-                        if (pos->sector < boundary)
+                if (blk_rq_pos(rq) >= boundary) {
+                        if (blk_rq_pos(pos) < boundary)
                                 continue;
                 } else {
-                        if (pos->sector >= boundary)
+                        if (blk_rq_pos(pos) >= boundary)
                                 break;
                 }
-                if (rq->sector >= pos->sector)
+                if (blk_rq_pos(rq) >= blk_rq_pos(pos))
                         break;
         }
 
@@ -559,7 +542,7 @@ void elv_requeue_request(struct request_queue *q, struct request *rq)
          * in_flight count again
          */
         if (blk_account_rq(rq)) {
-                q->in_flight--;
+                q->in_flight[rq_is_sync(rq)]--;
                 if (blk_sorted_rq(rq))
                         elv_deactivate_rq(q, rq);
         }
@@ -588,6 +571,9 @@ void elv_drain_elevator(struct request_queue *q)
  */
 void elv_quiesce_start(struct request_queue *q)
 {
+        if (!q->elevator)
+                return;
+
         queue_flag_set(QUEUE_FLAG_ELVSWITCH, q);
 
         /*
@@ -595,7 +581,7 @@ void elv_quiesce_start(struct request_queue *q)
          */
         elv_drain_elevator(q);
         while (q->rq.elvpriv) {
-                blk_start_queueing(q);
+                __blk_run_queue(q);
                 spin_unlock_irq(q->queue_lock);
                 msleep(10);
                 spin_lock_irq(q->queue_lock);
@@ -639,8 +625,7 @@ void elv_insert(struct request_queue *q, struct request *rq, int where)
                  *   with anything.  There's no point in delaying queue
                  *   processing.
                  */
-                blk_remove_plug(q);
-                blk_start_queueing(q);
+                __blk_run_queue(q);
                 break;
 
         case ELEVATOR_INSERT_SORT:
@@ -699,7 +684,7 @@ void elv_insert(struct request_queue *q, struct request *rq, int where)
 
         if (unplug_it && blk_queue_plugged(q)) {
                 int nrq = q->rq.count[BLK_RW_SYNC] + q->rq.count[BLK_RW_ASYNC]
-                        - q->in_flight;
+                                - queue_in_flight(q);
 
                 if (nrq >= q->unplug_thresh)
                         __generic_unplug_device(q);
@@ -755,117 +740,6 @@ void elv_add_request(struct request_queue *q, struct request *rq, int where,
 }
 EXPORT_SYMBOL(elv_add_request);
 
-static inline struct request *__elv_next_request(struct request_queue *q)
-{
-        struct request *rq;
-
-        while (1) {
-                while (!list_empty(&q->queue_head)) {
-                        rq = list_entry_rq(q->queue_head.next);
-                        if (blk_do_ordered(q, &rq))
-                                return rq;
-                }
-
-                if (!q->elevator->ops->elevator_dispatch_fn(q, 0))
-                        return NULL;
-        }
-}
-
-struct request *elv_next_request(struct request_queue *q)
-{
-        struct request *rq;
-        int ret;
-
-        while ((rq = __elv_next_request(q)) != NULL) {
-                if (!(rq->cmd_flags & REQ_STARTED)) {
-                        /*
-                         * This is the first time the device driver
-                         * sees this request (possibly after
-                         * requeueing).  Notify IO scheduler.
-                         */
-                        if (blk_sorted_rq(rq))
-                                elv_activate_rq(q, rq);
-
-                        /*
-                         * just mark as started even if we don't start
-                         * it, a request that has been delayed should
-                         * not be passed by new incoming requests
-                         */
-                        rq->cmd_flags |= REQ_STARTED;
-                        trace_block_rq_issue(q, rq);
-                }
-
-                if (!q->boundary_rq || q->boundary_rq == rq) {
-                        q->end_sector = rq_end_sector(rq);
-                        q->boundary_rq = NULL;
-                }
-
-                if (rq->cmd_flags & REQ_DONTPREP)
-                        break;
-
-                if (q->dma_drain_size && rq->data_len) {
-                        /*
-                         * make sure space for the drain appears we
-                         * know we can do this because max_hw_segments
-                         * has been adjusted to be one fewer than the
-                         * device can handle
-                         */
-                        rq->nr_phys_segments++;
-                }
-
-                if (!q->prep_rq_fn)
-                        break;
-
-                ret = q->prep_rq_fn(q, rq);
-                if (ret == BLKPREP_OK) {
-                        break;
-                } else if (ret == BLKPREP_DEFER) {
-                        /*
-                         * the request may have been (partially) prepped.
-                         * we need to keep this request in the front to
-                         * avoid resource deadlock.  REQ_STARTED will
-                         * prevent other fs requests from passing this one.
-                         */
-                        if (q->dma_drain_size && rq->data_len &&
-                            !(rq->cmd_flags & REQ_DONTPREP)) {
-                                /*
-                                 * remove the space for the drain we added
-                                 * so that we don't add it again
-                                 */
-                                --rq->nr_phys_segments;
-                        }
-
-                        rq = NULL;
-                        break;
-                } else if (ret == BLKPREP_KILL) {
-                        rq->cmd_flags |= REQ_QUIET;
-                        __blk_end_request(rq, -EIO, blk_rq_bytes(rq));
-                } else {
-                        printk(KERN_ERR "%s: bad return=%d\n", __func__, ret);
-                        break;
-                }
-        }
-
-        return rq;
-}
-EXPORT_SYMBOL(elv_next_request);
-
-void elv_dequeue_request(struct request_queue *q, struct request *rq)
-{
-        BUG_ON(list_empty(&rq->queuelist));
-        BUG_ON(ELV_ON_HASH(rq));
-
-        list_del_init(&rq->queuelist);
-
-        /*
-         * the time frame between a request being removed from the lists
-         * and to it is freed is accounted as io that is in progress at
-         * the driver side.
-         */
-        if (blk_account_rq(rq))
-                q->in_flight++;
-}
-
 int elv_queue_empty(struct request_queue *q)
 {
         struct elevator_queue *e = q->elevator;
@@ -935,7 +809,12 @@ void elv_abort_queue(struct request_queue *q)
                 rq = list_entry_rq(q->queue_head.next);
                 rq->cmd_flags |= REQ_QUIET;
                 trace_block_rq_abort(q, rq);
-                __blk_end_request(rq, -EIO, blk_rq_bytes(rq));
+                /*
+                 * Mark this request as started so we don't trigger
+                 * any debug logic in the end I/O path.
+                 */
+                blk_start_request(rq);
+                __blk_end_request_all(rq, -EIO);
         }
 }
 EXPORT_SYMBOL(elv_abort_queue);
@@ -948,7 +827,7 @@ void elv_completed_request(struct request_queue *q, struct request *rq)
          * request is released from the driver, io must be done
          */
         if (blk_account_rq(rq)) {
-                q->in_flight--;
+                q->in_flight[rq_is_sync(rq)]--;
                 if (blk_sorted_rq(rq) && e->ops->elevator_completed_req_fn)
                         e->ops->elevator_completed_req_fn(q, rq);
         }
@@ -963,11 +842,11 @@ void elv_completed_request(struct request_queue *q, struct request *rq)
                 if (!list_empty(&q->queue_head))
                         next = list_entry_rq(q->queue_head.next);
 
-                if (!q->in_flight &&
+                if (!queue_in_flight(q) &&
                     blk_ordered_cur_seq(q) == QUEUE_ORDSEQ_DRAIN &&
                     (!next || blk_ordered_req_seq(next) > QUEUE_ORDSEQ_DRAIN)) {
                         blk_ordered_complete_seq(q, QUEUE_ORDSEQ_DRAIN, 0);
-                        blk_start_queueing(q);
+                        __blk_run_queue(q);
                 }
         }
 }
@@ -1175,6 +1054,9 @@ ssize_t elv_iosched_store(struct request_queue *q, const char *name,
         char elevator_name[ELV_NAME_MAX];
         struct elevator_type *e;
 
+        if (!q->elevator)
+                return count;
+
         strlcpy(elevator_name, name, sizeof(elevator_name));
         strstrip(elevator_name);
 
@@ -1198,10 +1080,15 @@ ssize_t elv_iosched_store(struct request_queue *q, const char *name,
 ssize_t elv_iosched_show(struct request_queue *q, char *name)
 {
         struct elevator_queue *e = q->elevator;
-        struct elevator_type *elv = e->elevator_type;
+        struct elevator_type *elv;
         struct elevator_type *__e;
         int len = 0;
 
+        if (!q->elevator)
+                return sprintf(name, "none\n");
+
+        elv = e->elevator_type;
+
         spin_lock(&elv_list_lock);
         list_for_each_entry(__e, &elv_list, list) {
                 if (!strcmp(elv->elevator_name, __e->elevator_name))
diff --git a/block/genhd.c b/block/genhd.c
index 1a4916e01732..fe7ccc0a618f 100644
--- a/block/genhd.c
+++ b/block/genhd.c
@@ -852,11 +852,21 @@ static ssize_t disk_capability_show(struct device *dev,
         return sprintf(buf, "%x\n", disk->flags);
 }
 
+static ssize_t disk_alignment_offset_show(struct device *dev,
+                                          struct device_attribute *attr,
+                                          char *buf)
+{
+        struct gendisk *disk = dev_to_disk(dev);
+
+        return sprintf(buf, "%d\n", queue_alignment_offset(disk->queue));
+}
+
 static DEVICE_ATTR(range, S_IRUGO, disk_range_show, NULL);
 static DEVICE_ATTR(ext_range, S_IRUGO, disk_ext_range_show, NULL);
 static DEVICE_ATTR(removable, S_IRUGO, disk_removable_show, NULL);
 static DEVICE_ATTR(ro, S_IRUGO, disk_ro_show, NULL);
 static DEVICE_ATTR(size, S_IRUGO, part_size_show, NULL);
+static DEVICE_ATTR(alignment_offset, S_IRUGO, disk_alignment_offset_show, NULL);
 static DEVICE_ATTR(capability, S_IRUGO, disk_capability_show, NULL);
 static DEVICE_ATTR(stat, S_IRUGO, part_stat_show, NULL);
 #ifdef CONFIG_FAIL_MAKE_REQUEST
@@ -875,6 +885,7 @@ static struct attribute *disk_attrs[] = {
         &dev_attr_removable.attr,
         &dev_attr_ro.attr,
         &dev_attr_size.attr,
+        &dev_attr_alignment_offset.attr,
         &dev_attr_capability.attr,
         &dev_attr_stat.attr,
 #ifdef CONFIG_FAIL_MAKE_REQUEST
diff --git a/block/ioctl.c b/block/ioctl.c
index ad474d4bbcce..500e4c73cc52 100644
--- a/block/ioctl.c
+++ b/block/ioctl.c
@@ -152,10 +152,10 @@ static int blk_ioctl_discard(struct block_device *bdev, uint64_t start,
                 bio->bi_private = &wait;
                 bio->bi_sector = start;
 
-                if (len > q->max_hw_sectors) {
-                        bio->bi_size = q->max_hw_sectors << 9;
-                        len -= q->max_hw_sectors;
-                        start += q->max_hw_sectors;
+                if (len > queue_max_hw_sectors(q)) {
+                        bio->bi_size = queue_max_hw_sectors(q) << 9;
+                        len -= queue_max_hw_sectors(q);
+                        start += queue_max_hw_sectors(q);
                 } else {
                         bio->bi_size = len << 9;
                         len = 0;
@@ -311,9 +311,9 @@ int blkdev_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd,
         case BLKBSZGET: /* get the logical block size (cf. BLKSSZGET) */
                 return put_int(arg, block_size(bdev));
         case BLKSSZGET: /* get block device hardware sector size */
-                return put_int(arg, bdev_hardsect_size(bdev));
+                return put_int(arg, bdev_logical_block_size(bdev));
         case BLKSECTGET:
-                return put_ushort(arg, bdev_get_queue(bdev)->max_sectors);
+                return put_ushort(arg, queue_max_sectors(bdev_get_queue(bdev)));
         case BLKRASET:
         case BLKFRASET:
                 if(!capable(CAP_SYS_ADMIN))
diff --git a/block/scsi_ioctl.c b/block/scsi_ioctl.c
index 82a0ca2f6729..5f8e798ede4e 100644
--- a/block/scsi_ioctl.c
+++ b/block/scsi_ioctl.c
@@ -75,7 +75,7 @@ static int sg_set_timeout(struct request_queue *q, int __user *p)
 
 static int sg_get_reserved_size(struct request_queue *q, int __user *p)
 {
-        unsigned val = min(q->sg_reserved_size, q->max_sectors << 9);
+        unsigned val = min(q->sg_reserved_size, queue_max_sectors(q) << 9);
 
         return put_user(val, p);
 }
@@ -89,8 +89,8 @@ static int sg_set_reserved_size(struct request_queue *q, int __user *p)
 
         if (size < 0)
                 return -EINVAL;
-        if (size > (q->max_sectors << 9))
-                size = q->max_sectors << 9;
+        if (size > (queue_max_sectors(q) << 9))
+                size = queue_max_sectors(q) << 9;
 
         q->sg_reserved_size = size;
         return 0;
@@ -230,7 +230,7 @@ static int blk_complete_sghdr_rq(struct request *rq, struct sg_io_hdr *hdr,
         hdr->info = 0;
         if (hdr->masked_status || hdr->host_status || hdr->driver_status)
                 hdr->info |= SG_INFO_CHECK;
-        hdr->resid = rq->data_len;
+        hdr->resid = rq->resid_len;
         hdr->sb_len_wr = 0;
 
         if (rq->sense_len && hdr->sbp) {
@@ -264,7 +264,7 @@ static int sg_io(struct request_queue *q, struct gendisk *bd_disk,
         if (hdr->cmd_len > BLK_MAX_CDB)
                 return -EINVAL;
 
-        if (hdr->dxfer_len > (q->max_hw_sectors << 9))
+        if (hdr->dxfer_len > (queue_max_hw_sectors(q) << 9))
                 return -EIO;
 
         if (hdr->dxfer_len)
@@ -500,9 +500,6 @@ static int __blk_send_generic(struct request_queue *q, struct gendisk *bd_disk,
 
         rq = blk_get_request(q, WRITE, __GFP_WAIT);
         rq->cmd_type = REQ_TYPE_BLOCK_PC;
-        rq->data = NULL;
-        rq->data_len = 0;
-        rq->extra_len = 0;
         rq->timeout = BLK_DEFAULT_SG_TIMEOUT;
         rq->cmd[0] = cmd;
         rq->cmd[4] = data;
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index 6b91c26a4635..15a23031833f 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -77,8 +77,6 @@ static ssize_t ahci_led_store(struct ata_port *ap, const char *buf,
                               size_t size);
 static ssize_t ahci_transmit_led_message(struct ata_port *ap, u32 state,
                                         ssize_t size);
-#define MAX_SLOTS 8
-#define MAX_RETRY 15
 
 enum {
         AHCI_PCI_BAR            = 5,
@@ -231,6 +229,10 @@ enum {
 
         ICH_MAP                         = 0x90, /* ICH MAP register */
 
+        /* em constants */
+        EM_MAX_SLOTS                    = 8,
+        EM_MAX_RETRY                    = 5,
+
         /* em_ctl bits */
         EM_CTL_RST                      = (1 << 9), /* Reset */
         EM_CTL_TM                       = (1 << 8), /* Transmit Message */
@@ -282,8 +284,8 @@ struct ahci_port_priv {
         unsigned int            ncq_saw_dmas:1;
         unsigned int            ncq_saw_sdb:1;
         u32                     intr_mask;      /* interrupts to enable */
-        struct ahci_em_priv     em_priv[MAX_SLOTS];/* enclosure management info
-                                                 * per PM slot */
+        /* enclosure management info per PM slot */
+        struct ahci_em_priv     em_priv[EM_MAX_SLOTS];
 };
 
 static int ahci_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val);
@@ -313,7 +315,6 @@ static void ahci_error_handler(struct ata_port *ap);
 static void ahci_post_internal_cmd(struct ata_queued_cmd *qc);
 static int ahci_port_resume(struct ata_port *ap);
 static void ahci_dev_config(struct ata_device *dev);
-static unsigned int ahci_fill_sg(struct ata_queued_cmd *qc, void *cmd_tbl);
 static void ahci_fill_cmd_slot(struct ahci_port_priv *pp, unsigned int tag,
                                u32 opts);
 #ifdef CONFIG_PM
@@ -404,14 +405,14 @@ static struct ata_port_operations ahci_sb600_ops = {
 #define AHCI_HFLAGS(flags)      .private_data   = (void *)(flags)
 
 static const struct ata_port_info ahci_port_info[] = {
-        /* board_ahci */
+        [board_ahci] =
         {
                 .flags          = AHCI_FLAG_COMMON,
                 .pio_mask       = ATA_PIO4,
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_ops,
         },
-        /* board_ahci_vt8251 */
+        [board_ahci_vt8251] =
         {
                 AHCI_HFLAGS     (AHCI_HFLAG_NO_NCQ | AHCI_HFLAG_NO_PMP),
                 .flags          = AHCI_FLAG_COMMON,
@@ -419,7 +420,7 @@ static const struct ata_port_info ahci_port_info[] = {
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_vt8251_ops,
         },
-        /* board_ahci_ign_iferr */
+        [board_ahci_ign_iferr] =
         {
                 AHCI_HFLAGS     (AHCI_HFLAG_IGN_IRQ_IF_ERR),
                 .flags          = AHCI_FLAG_COMMON,
@@ -427,17 +428,16 @@ static const struct ata_port_info ahci_port_info[] = {
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_ops,
         },
-        /* board_ahci_sb600 */
+        [board_ahci_sb600] =
         {
                 AHCI_HFLAGS     (AHCI_HFLAG_IGN_SERR_INTERNAL |
-                                 AHCI_HFLAG_32BIT_ONLY | AHCI_HFLAG_NO_MSI |
-                                 AHCI_HFLAG_SECT255),
+                                 AHCI_HFLAG_NO_MSI | AHCI_HFLAG_SECT255),
                 .flags          = AHCI_FLAG_COMMON,
                 .pio_mask       = ATA_PIO4,
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_sb600_ops,
         },
-        /* board_ahci_mv */
+        [board_ahci_mv] =
         {
                 AHCI_HFLAGS     (AHCI_HFLAG_NO_NCQ | AHCI_HFLAG_NO_MSI |
                                  AHCI_HFLAG_MV_PATA | AHCI_HFLAG_NO_PMP),
@@ -447,7 +447,7 @@ static const struct ata_port_info ahci_port_info[] = {
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_ops,
         },
-        /* board_ahci_sb700, for SB700 and SB800 */
+        [board_ahci_sb700] =    /* for SB700 and SB800 */
         {
                 AHCI_HFLAGS     (AHCI_HFLAG_IGN_SERR_INTERNAL),
                 .flags          = AHCI_FLAG_COMMON,
@@ -455,7 +455,7 @@ static const struct ata_port_info ahci_port_info[] = {
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_sb600_ops,
         },
-        /* board_ahci_mcp65 */
+        [board_ahci_mcp65] =
         {
                 AHCI_HFLAGS     (AHCI_HFLAG_YES_NCQ),
                 .flags          = AHCI_FLAG_COMMON,
@@ -463,7 +463,7 @@ static const struct ata_port_info ahci_port_info[] = {
                 .udma_mask      = ATA_UDMA6,
                 .port_ops       = &ahci_ops,
         },
-        /* board_ahci_nopmp */
+        [board_ahci_nopmp] =
         {
                 AHCI_HFLAGS     (AHCI_HFLAG_NO_PMP),
                 .flags          = AHCI_FLAG_COMMON,
@@ -1141,12 +1141,12 @@ static void ahci_start_port(struct ata_port *ap)
                         emp = &pp->em_priv[link->pmp];
 
                         /* EM Transmit bit maybe busy during init */
-                        for (i = 0; i < MAX_RETRY; i++) {
+                        for (i = 0; i < EM_MAX_RETRY; i++) {
                                 rc = ahci_transmit_led_message(ap,
                                                                emp->led_state,
                                                                4);
                                 if (rc == -EBUSY)
-                                        udelay(100);
+                                        msleep(1);
                                 else
                                         break;
                         }
@@ -1340,7 +1340,7 @@ static ssize_t ahci_transmit_led_message(struct ata_port *ap, u32 state,
 
         /* get the slot number from the message */
         pmp = (state & EM_MSG_LED_PMP_SLOT) >> 8;
-        if (pmp < MAX_SLOTS)
+        if (pmp < EM_MAX_SLOTS)
                 emp = &pp->em_priv[pmp];
         else
                 return -EINVAL;
@@ -1408,7 +1408,7 @@ static ssize_t ahci_led_store(struct ata_port *ap, const char *buf,
 
         /* get the slot number from the message */
         pmp = (state & EM_MSG_LED_PMP_SLOT) >> 8;
-        if (pmp < MAX_SLOTS)
+        if (pmp < EM_MAX_SLOTS)
                 emp = &pp->em_priv[pmp];
         else
                 return -EINVAL;
@@ -2584,6 +2584,51 @@ static void ahci_p5wdh_workaround(struct ata_host *host)
         }
 }
 
+/*
+ * SB600 ahci controller on ASUS M2A-VM can't do 64bit DMA with older
+ * BIOS.  The oldest version known to be broken is 0901 and working is
+ * 1501 which was released on 2007-10-26.  Force 32bit DMA on anything
+ * older than 1501.  Please read bko#9412 for more info.
+ */
+static bool ahci_asus_m2a_vm_32bit_only(struct pci_dev *pdev)
+{
+        static const struct dmi_system_id sysids[] = {
+                {
+                        .ident = "ASUS M2A-VM",
+                        .matches = {
+                                DMI_MATCH(DMI_BOARD_VENDOR,
+                                          "ASUSTeK Computer INC."),
+                                DMI_MATCH(DMI_BOARD_NAME, "M2A-VM"),
+                        },
+                },
+                { }
+        };
+        const char *cutoff_mmdd = "10/26";
+        const char *date;
+        int year;
+
+        if (pdev->bus->number != 0 || pdev->devfn != PCI_DEVFN(0x12, 0) ||
+            !dmi_check_system(sysids))
+                return false;
+
+        /*
+         * Argh.... both version and date are free form strings.
+         * Let's hope they're using the same date format across
+         * different versions.
+         */
+        date = dmi_get_system_info(DMI_BIOS_DATE);
+        year = dmi_get_year(DMI_BIOS_DATE);
+        if (date && strlen(date) >= 10 && date[2] == '/' && date[5] == '/' &&
+            (year > 2007 ||
+             (year == 2007 && strncmp(date, cutoff_mmdd, 5) >= 0)))
+                return false;
+
+        dev_printk(KERN_WARNING, &pdev->dev, "ASUS M2A-VM: BIOS too old, "
+                   "forcing 32bit DMA, update BIOS\n");
+
+        return true;
+}
+
 static bool ahci_broken_system_poweroff(struct pci_dev *pdev)
 {
         static const struct dmi_system_id broken_systems[] = {
@@ -2744,6 +2789,10 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         if (board_id == board_ahci_sb700 && pdev->revision >= 0x40)
                 hpriv->flags &= ~AHCI_HFLAG_IGN_SERR_INTERNAL;
 
+        /* apply ASUS M2A_VM quirk */
+        if (ahci_asus_m2a_vm_32bit_only(pdev))
+                hpriv->flags |= AHCI_HFLAG_32BIT_ONLY;
+
         if (!(hpriv->flags & AHCI_HFLAG_NO_MSI))
                 pci_enable_msi(pdev);
 
diff --git a/drivers/ata/ata_piix.c b/drivers/ata/ata_piix.c
index 1aeb7082b0c4..d0a14cf2bd74 100644
--- a/drivers/ata/ata_piix.c
+++ b/drivers/ata/ata_piix.c
@@ -223,10 +223,8 @@ static const struct pci_device_id piix_pci_tbl[] = {
         /* ICH8 Mobile PATA Controller */
         { 0x8086, 0x2850, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich_pata_100 },
 
-        /* NOTE: The following PCI ids must be kept in sync with the
-         * list in drivers/pci/quirks.c.
-         */
-
+        /* SATA ports */
+        
         /* 82801EB (ICH5) */
         { 0x8086, 0x24d1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, ich5_sata },
         /* 82801EB (ICH5) */
@@ -1509,8 +1507,8 @@ static int __devinit piix_init_one(struct pci_dev *pdev,
                 dev_printk(KERN_DEBUG, &pdev->dev,
                            "version " DRV_VERSION "\n");
 
-        /* no hotplugging support (FIXME) */
-        if (!in_module_init)
+        /* no hotplugging support for later devices (FIXME) */
+        if (!in_module_init && ent->driver_data >= ich5_sata)
                 return -ENODEV;
 
         if (piix_broken_system_poweroff(pdev)) {
@@ -1591,6 +1589,7 @@ static int __devinit piix_init_one(struct pci_dev *pdev,
                 host->ports[1]->mwdma_mask = 0;
                 host->ports[1]->udma_mask = 0;
         }
+        host->flags |= ATA_HOST_PARALLEL_SCAN;
 
         pci_set_master(pdev);
         return ata_pci_sff_activate_host(host, ata_sff_interrupt, &piix_sht);
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index c9242301cfa1..ca4d208ddf3b 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -5031,7 +5031,6 @@ int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active)
 {
         int nr_done = 0;
         u32 done_mask;
-        int i;
 
         done_mask = ap->qc_active ^ qc_active;
 
@@ -5041,16 +5040,16 @@ int ata_qc_complete_multiple(struct ata_port *ap, u32 qc_active)
                 return -EINVAL;
         }
 
-        for (i = 0; i < ATA_MAX_QUEUE; i++) {
+        while (done_mask) {
                 struct ata_queued_cmd *qc;
+                unsigned int tag = __ffs(done_mask);
 
-                if (!(done_mask & (1 << i)))
-                        continue;
-
-                if ((qc = ata_qc_from_tag(ap, i))) {
+                qc = ata_qc_from_tag(ap, tag);
+                if (qc) {
                         ata_qc_complete(qc);
                         nr_done++;
                 }
+                done_mask &= ~(1 << tag);
         }
 
         return nr_done;
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index 342316064e9f..d0dfeef55db5 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -1084,7 +1084,7 @@ static int atapi_drain_needed(struct request *rq)
         if (likely(!blk_pc_request(rq)))
                 return 0;
 
-        if (!rq->data_len || (rq->cmd_flags & REQ_RW))
+        if (!blk_rq_bytes(rq) || (rq->cmd_flags & REQ_RW))
                 return 0;
 
         return atapi_cmd_type(rq->cmd[0]) == ATAPI_MISC;
diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index bb18415d3d63..bbbb1fab1755 100644
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -727,17 +727,23 @@ unsigned int ata_sff_data_xfer(struct ata_device *dev, unsigned char *buf,
         else
                 iowrite16_rep(data_addr, buf, words);
 
-        /* Transfer trailing 1 byte, if any. */
+        /* Transfer trailing byte, if any. */
         if (unlikely(buflen & 0x01)) {
-                __le16 align_buf[1] = { 0 };
-                unsigned char *trailing_buf = buf + buflen - 1;
+                unsigned char pad[2];
 
+                /* Point buf to the tail of buffer */
+                buf += buflen - 1;
+
+                /*
+                 * Use io*16_rep() accessors here as well to avoid pointlessly
+                 * swapping bytes to and fro on the big endian machines...
+                 */
                 if (rw == READ) {
-                        align_buf[0] = cpu_to_le16(ioread16(data_addr));
-                        memcpy(trailing_buf, align_buf, 1);
+                        ioread16_rep(data_addr, pad, 1);
+                        *buf = pad[0];
                 } else {
-                        memcpy(align_buf, trailing_buf, 1);
-                        iowrite16(le16_to_cpu(align_buf[0]), data_addr);
+                        pad[0] = *buf;
+                        iowrite16_rep(data_addr, pad, 1);
                 }
                 words++;
         }
diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index 6cda12ba8122..b2d11f300c39 100644
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -305,8 +305,8 @@ static irqreturn_t nv_ck804_interrupt(int irq, void *dev_instance);
 static int nv_scr_read(struct ata_link *link, unsigned int sc_reg, u32 *val);
 static int nv_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val);
 
-static int nv_noclassify_hardreset(struct ata_link *link, unsigned int *class,
-                                   unsigned long deadline);
+static int nv_hardreset(struct ata_link *link, unsigned int *class,
+                        unsigned long deadline);
 static void nv_nf2_freeze(struct ata_port *ap);
 static void nv_nf2_thaw(struct ata_port *ap);
 static void nv_ck804_freeze(struct ata_port *ap);
@@ -406,49 +406,82 @@ static struct scsi_host_template nv_swncq_sht = {
         .slave_configure        = nv_swncq_slave_config,
 };
 
-static struct ata_port_operations nv_common_ops = {
+/*
+ * NV SATA controllers have various different problems with hardreset
+ * protocol depending on the specific controller and device.
+ *
+ * GENERIC:
+ *
+ *  bko11195 reports that link doesn't come online after hardreset on
+ *  generic nv's and there have been several other similar reports on
+ *  linux-ide.
+ *
+ *  bko12351#c23 reports that warmplug on MCP61 doesn't work with
+ *  softreset.
+ *
+ * NF2/3:
+ *
+ *  bko3352 reports nf2/3 controllers can't determine device signature
+ *  reliably after hardreset.  The following thread reports detection
+ *  failure on cold boot with the standard debouncing timing.
+ *
+ *  http://thread.gmane.org/gmane.linux.ide/34098
+ *
+ *  bko12176 reports that hardreset fails to bring up the link during
+ *  boot on nf2.
+ *
+ * CK804:
+ *
+ *  For initial probing after boot and hot plugging, hardreset mostly
+ *  works fine on CK804 but curiously, reprobing on the initial port
+ *  by rescanning or rmmod/insmod fails to acquire the initial D2H Reg
+ *  FIS in somewhat undeterministic way.
+ *
+ * SWNCQ:
+ *
+ *  bko12351 reports that when SWNCQ is enabled, for hotplug to work,
+ *  hardreset should be used and hardreset can't report proper
+ *  signature, which suggests that mcp5x is closer to nf2 as long as
+ *  reset quirkiness is concerned.
+ *
+ *  bko12703 reports that boot probing fails for intel SSD with
+ *  hardreset.  Link fails to come online.  Softreset works fine.
+ *
+ * The failures are varied but the following patterns seem true for
+ * all flavors.
+ *
+ * - Softreset during boot always works.
+ *
+ * - Hardreset during boot sometimes fails to bring up the link on
+ *   certain comibnations and device signature acquisition is
+ *   unreliable.
+ *
+ * - Hardreset is often necessary after hotplug.
+ *
+ * So, preferring softreset for boot probing and error handling (as
+ * hardreset might bring down the link) but using hardreset for
+ * post-boot probing should work around the above issues in most
+ * cases.  Define nv_hardreset() which only kicks in for post-boot
+ * probing and use it for all variants.
+ */
+static struct ata_port_operations nv_generic_ops = {
         .inherits               = &ata_bmdma_port_ops,
         .lost_interrupt         = ATA_OP_NULL,
         .scr_read               = nv_scr_read,
         .scr_write              = nv_scr_write,
+        .hardreset              = nv_hardreset,
 };
 
-/* OSDL bz11195 reports that link doesn't come online after hardreset
- * on generic nv's and there have been several other similar reports
- * on linux-ide.  Disable hardreset for generic nv's.
- */
-static struct ata_port_operations nv_generic_ops = {
-        .inherits               = &nv_common_ops,
-        .hardreset              = ATA_OP_NULL,
-};
-
-/* nf2 is ripe with hardreset related problems.
- *
- * kernel bz#3352 reports nf2/3 controllers can't determine device
- * signature reliably.  The following thread reports detection failure
- * on cold boot with the standard debouncing timing.
- *
- * http://thread.gmane.org/gmane.linux.ide/34098
- *
- * And bz#12176 reports that hardreset simply doesn't work on nf2.
- * Give up on it and just don't do hardreset.
- */
 static struct ata_port_operations nv_nf2_ops = {
         .inherits               = &nv_generic_ops,
         .freeze                 = nv_nf2_freeze,
         .thaw                   = nv_nf2_thaw,
 };
 
-/* For initial probing after boot and hot plugging, hardreset mostly
- * works fine on CK804 but curiously, reprobing on the initial port by
- * rescanning or rmmod/insmod fails to acquire the initial D2H Reg FIS
- * in somewhat undeterministic way.  Use noclassify hardreset.
- */
 static struct ata_port_operations nv_ck804_ops = {
-        .inherits               = &nv_common_ops,
+        .inherits               = &nv_generic_ops,
         .freeze                 = nv_ck804_freeze,
         .thaw                   = nv_ck804_thaw,
-        .hardreset              = nv_noclassify_hardreset,
         .host_stop              = nv_ck804_host_stop,
 };
 
@@ -476,19 +509,8 @@ static struct ata_port_operations nv_adma_ops = {
         .host_stop              = nv_adma_host_stop,
 };
 
-/* Kernel bz#12351 reports that when SWNCQ is enabled, for hotplug to
- * work, hardreset should be used and hardreset can't report proper
- * signature, which suggests that mcp5x is closer to nf2 as long as
- * reset quirkiness is concerned.  Define separate ops for mcp5x with
- * nv_noclassify_hardreset().
- */
-static struct ata_port_operations nv_mcp5x_ops = {
-        .inherits               = &nv_common_ops,
-        .hardreset              = nv_noclassify_hardreset,
-};
-
 static struct ata_port_operations nv_swncq_ops = {
-        .inherits               = &nv_mcp5x_ops,
+        .inherits               = &nv_generic_ops,
 
         .qc_defer               = ata_std_qc_defer,
         .qc_prep                = nv_swncq_qc_prep,
@@ -557,7 +579,7 @@ static const struct ata_port_info nv_port_info[] = {
                 .pio_mask       = NV_PIO_MASK,
                 .mwdma_mask     = NV_MWDMA_MASK,
                 .udma_mask      = NV_UDMA_MASK,
-                .port_ops       = &nv_mcp5x_ops,
+                .port_ops       = &nv_generic_ops,
                 .private_data   = NV_PI_PRIV(nv_generic_interrupt, &nv_sht),
         },
         /* SWNCQ */
@@ -1559,15 +1581,24 @@ static int nv_scr_write(struct ata_link *link, unsigned int sc_reg, u32 val)
         return 0;
 }
 
-static int nv_noclassify_hardreset(struct ata_link *link, unsigned int *class,
-                                   unsigned long deadline)
+static int nv_hardreset(struct ata_link *link, unsigned int *class,
+                        unsigned long deadline)
 {
-        bool online;
-        int rc;
+        struct ata_eh_context *ehc = &link->eh_context;
 
-        rc = sata_link_hardreset(link, sata_deb_timing_hotplug, deadline,
-                                 &online, NULL);
-        return online ? -EAGAIN : rc;
+        /* Do hardreset iff it's post-boot probing, please read the
+         * comment above port ops for details.
+         */
+        if (!(link->ap->pflags & ATA_PFLAG_LOADING) &&
+            !ata_dev_enabled(link->device))
+                sata_link_hardreset(link, sata_deb_timing_hotplug, deadline,
+                                    NULL, NULL);
+        else if (!(ehc->i.flags & ATA_EHI_QUIET))
+                ata_link_printk(link, KERN_INFO,
+                                "nv: skipping hardreset on occupied port\n");
+
+        /* device signature acquisition is unreliable */
+        return -EAGAIN;
 }
 
 static void nv_nf2_freeze(struct ata_port *ap)
diff --git a/drivers/ata/sata_sil.c b/drivers/ata/sata_sil.c
index e67ce8e5caa5..030ec079b184 100644
--- a/drivers/ata/sata_sil.c
+++ b/drivers/ata/sata_sil.c
@@ -183,7 +183,7 @@ static struct scsi_host_template sil_sht = {
 };
 
 static struct ata_port_operations sil_ops = {
-        .inherits               = &ata_bmdma_port_ops,
+        .inherits               = &ata_bmdma32_port_ops,
         .dev_config             = sil_dev_config,
         .set_mode               = sil_set_mode,
         .bmdma_setup            = sil_bmdma_setup,
diff --git a/drivers/ata/sata_sx4.c b/drivers/ata/sata_sx4.c
index eb05a3c82a9e..bbcf970068ad 100644
--- a/drivers/ata/sata_sx4.c
+++ b/drivers/ata/sata_sx4.c
@@ -193,6 +193,7 @@ enum {
                                           PDC_TIMER_MASK_INT,
 };
 
+#define ECC_ERASE_BUF_SZ (128 * 1024)
 
 struct pdc_port_priv {
         u8                      dimm_buf[(ATA_PRD_SZ * ATA_MAX_PRD) + 512];
@@ -1280,7 +1281,6 @@ static unsigned int pdc20621_dimm_init(struct ata_host *host)
 {
         int speed, size, length;
         u32 addr, spd0, pci_status;
-        u32 tmp = 0;
         u32 time_period = 0;
         u32 tcount = 0;
         u32 ticks = 0;
@@ -1395,14 +1395,17 @@ static unsigned int pdc20621_dimm_init(struct ata_host *host)
         pdc20621_i2c_read(host, PDC_DIMM0_SPD_DEV_ADDRESS,
                           PDC_DIMM_SPD_TYPE, &spd0);
         if (spd0 == 0x02) {
+                void *buf;
                 VPRINTK("Start ECC initialization\n");
                 addr = 0;
                 length = size * 1024 * 1024;
+                buf = kzalloc(ECC_ERASE_BUF_SZ, GFP_KERNEL);
                 while (addr < length) {
-                        pdc20621_put_to_dimm(host, (void *) &tmp, addr,
-                                             sizeof(u32));
-                        addr += sizeof(u32);
+                        pdc20621_put_to_dimm(host, buf, addr,
+                                             ECC_ERASE_BUF_SZ);
+                        addr += ECC_ERASE_BUF_SZ;
                 }
+                kfree(buf);
                 VPRINTK("Finish ECC initialization\n");
         }
         return 0;
diff --git a/drivers/block/DAC960.c b/drivers/block/DAC960.c
index f22ed6cc69f2..668dc234b8e2 100644
--- a/drivers/block/DAC960.c
+++ b/drivers/block/DAC960.c
@@ -3321,7 +3321,7 @@ static int DAC960_process_queue(DAC960_Controller_T *Controller, struct request_
         DAC960_Command_T *Command;
 
    while(1) {
-        Request = elv_next_request(req_q);
+        Request = blk_peek_request(req_q);
         if (!Request)
                 return 1;
 
@@ -3338,10 +3338,10 @@ static int DAC960_process_queue(DAC960_Controller_T *Controller, struct request_
         }
         Command->Completion = Request->end_io_data;
         Command->LogicalDriveNumber = (long)Request->rq_disk->private_data;
-        Command->BlockNumber = Request->sector;
-        Command->BlockCount = Request->nr_sectors;
+        Command->BlockNumber = blk_rq_pos(Request);
+        Command->BlockCount = blk_rq_sectors(Request);
         Command->Request = Request;
-        blkdev_dequeue_request(Request);
+        blk_start_request(Request);
         Command->SegmentCount = blk_rq_map_sg(req_q,
                   Command->Request, Command->cmd_sglist);
         /* pci_map_sg MAY change the value of SegCount */
@@ -3431,7 +3431,7 @@ static void DAC960_queue_partial_rw(DAC960_Command_T *Command)
    * successfully as possible.
    */
   Command->SegmentCount = 1;
-  Command->BlockNumber = Request->sector;
+  Command->BlockNumber = blk_rq_pos(Request);
   Command->BlockCount = 1;
   DAC960_QueueReadWriteCommand(Command);
   return;
diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig
index ddea8e485cc9..f42fa50d3550 100644
--- a/drivers/block/Kconfig
+++ b/drivers/block/Kconfig
@@ -412,7 +412,7 @@ config ATA_OVER_ETH
 
 config MG_DISK
         tristate "mGine mflash, gflash support"
-        depends on ARM && ATA && GPIOLIB
+        depends on ARM && GPIOLIB
         help
           mGine mFlash(gFlash) block device driver
 
diff --git a/drivers/block/amiflop.c b/drivers/block/amiflop.c
index 8df436ff7068..9c6e5b0fe894 100644
--- a/drivers/block/amiflop.c
+++ b/drivers/block/amiflop.c
@@ -112,8 +112,6 @@ module_param(fd_def_df0, ulong, 0);
 MODULE_LICENSE("GPL");
 
 static struct request_queue *floppy_queue;
-#define QUEUE (floppy_queue)
-#define CURRENT elv_next_request(floppy_queue)
 
 /*
  *  Macros
@@ -1335,64 +1333,60 @@ static int get_track(int drive, int track)
 
 static void redo_fd_request(void)
 {
+        struct request *rq;
         unsigned int cnt, block, track, sector;
         int drive;
         struct amiga_floppy_struct *floppy;
         char *data;
         unsigned long flags;
+        int err;
 
- repeat:
-        if (!CURRENT) {
+next_req:
+        rq = blk_fetch_request(floppy_queue);
+        if (!rq) {
                 /* Nothing left to do */
                 return;
         }
 
-        floppy = CURRENT->rq_disk->private_data;
+        floppy = rq->rq_disk->private_data;
         drive = floppy - unit;
 
+next_segment:
         /* Here someone could investigate to be more efficient */
-        for (cnt = 0; cnt < CURRENT->current_nr_sectors; cnt++) { 
+        for (cnt = 0, err = 0; cnt < blk_rq_cur_sectors(rq); cnt++) {
 #ifdef DEBUG
                 printk("fd: sector %ld + %d requested for %s\n",
-                       CURRENT->sector,cnt,
-                       (rq_data_dir(CURRENT) == READ) ? "read" : "write");
+                       blk_rq_pos(rq), cnt,
+                       (rq_data_dir(rq) == READ) ? "read" : "write");
 #endif
-                block = CURRENT->sector + cnt;
+                block = blk_rq_pos(rq) + cnt;
                 if ((int)block > floppy->blocks) {
-                        end_request(CURRENT, 0);
-                        goto repeat;
+                        err = -EIO;
+                        break;
                 }
 
                 track = block / (floppy->dtype->sects * floppy->type->sect_mult);
                 sector = block % (floppy->dtype->sects * floppy->type->sect_mult);
-                data = CURRENT->buffer + 512 * cnt;
+                data = rq->buffer + 512 * cnt;
 #ifdef DEBUG
                 printk("access to track %d, sector %d, with buffer at "
                        "0x%08lx\n", track, sector, data);
 #endif
 
-                if ((rq_data_dir(CURRENT) != READ) && (rq_data_dir(CURRENT) != WRITE)) {
-                        printk(KERN_WARNING "do_fd_request: unknown command\n");
-                        end_request(CURRENT, 0);
-                        goto repeat;
-                }
                 if (get_track(drive, track) == -1) {
-                        end_request(CURRENT, 0);
-                        goto repeat;
+                        err = -EIO;
+                        break;
                 }
 
-                switch (rq_data_dir(CURRENT)) {
-                case READ:
+                if (rq_data_dir(rq) == READ) {
                         memcpy(data, floppy->trackbuf + sector * 512, 512);
-                        break;
-
-                case WRITE:
+                } else {
                         memcpy(floppy->trackbuf + sector * 512, data, 512);
 
                         /* keep the drive spinning while writes are scheduled */
                         if (!fd_motor_on(drive)) {
-                                end_request(CURRENT, 0);
-                                goto repeat;
+                                err = -EIO;
+                                break;
                         }
                         /*
                          * setup a callback to write the track buffer
@@ -1404,14 +1398,12 @@ static void redo_fd_request(void)
                         /* reset the timer */
                         mod_timer (flush_track_timer + drive, jiffies + 1);
                         local_irq_restore(flags);
-                        break;
                 }
         }
-        CURRENT->nr_sectors -= CURRENT->current_nr_sectors;
-        CURRENT->sector += CURRENT->current_nr_sectors;
 
-        end_request(CURRENT, 1);
-        goto repeat;
+        if (__blk_end_request_cur(rq, err))
+                goto next_segment;
+        goto next_req;
 }
 
 static void do_fd_request(struct request_queue * q)
diff --git a/drivers/block/ataflop.c b/drivers/block/ataflop.c
index 4234c11c1e4c..f5e7180d7f47 100644
--- a/drivers/block/ataflop.c
+++ b/drivers/block/ataflop.c
@@ -79,9 +79,7 @@
 #undef DEBUG
 
 static struct request_queue *floppy_queue;
-
-#define QUEUE (floppy_queue)
-#define CURRENT elv_next_request(floppy_queue)
+static struct request *fd_request;
 
 /* Disk types: DD, HD, ED */
 static struct atari_disk_type {
@@ -376,6 +374,12 @@ static DEFINE_TIMER(readtrack_timer, fd_readtrack_check, 0, 0);
 static DEFINE_TIMER(timeout_timer, fd_times_out, 0, 0);
 static DEFINE_TIMER(fd_timer, check_change, 0, 0);
         
+static void fd_end_request_cur(int err)
+{
+        if (!__blk_end_request_cur(fd_request, err))
+                fd_request = NULL;
+}
+
 static inline void start_motor_off_timer(void)
 {
         mod_timer(&motor_off_timer, jiffies + FD_MOTOR_OFF_DELAY);
@@ -606,15 +610,15 @@ static void fd_error( void )
                 return;
         }
 
-        if (!CURRENT)
+        if (!fd_request)
                 return;
 
-        CURRENT->errors++;
-        if (CURRENT->errors >= MAX_ERRORS) {
+        fd_request->errors++;
+        if (fd_request->errors >= MAX_ERRORS) {
                 printk(KERN_ERR "fd%d: too many errors.\n", SelectedDrive );
-                end_request(CURRENT, 0);
+                fd_end_request_cur(-EIO);
         }
-        else if (CURRENT->errors == RECALIBRATE_ERRORS) {
+        else if (fd_request->errors == RECALIBRATE_ERRORS) {
                 printk(KERN_WARNING "fd%d: recalibrating\n", SelectedDrive );
                 if (SelectedDrive != -1)
                         SUD.track = -1;
@@ -725,16 +729,14 @@ static void do_fd_action( int drive )
             if (IS_BUFFERED( drive, ReqSide, ReqTrack )) {
                 if (ReqCmd == READ) {
                     copy_buffer( SECTOR_BUFFER(ReqSector), ReqData );
-                    if (++ReqCnt < CURRENT->current_nr_sectors) {
+                    if (++ReqCnt < blk_rq_cur_sectors(fd_request)) {
                         /* read next sector */
                         setup_req_params( drive );
                         goto repeat;
                     }
                     else {
                         /* all sectors finished */
-                        CURRENT->nr_sectors -= CURRENT->current_nr_sectors;
-                        CURRENT->sector += CURRENT->current_nr_sectors;
-                        end_request(CURRENT, 1);
+                        fd_end_request_cur(0);
                         redo_fd_request();
                         return;
                     }
@@ -1132,16 +1134,14 @@ static void fd_rwsec_done1(int status)
                 }
         }
   
-        if (++ReqCnt < CURRENT->current_nr_sectors) {
+        if (++ReqCnt < blk_rq_cur_sectors(fd_request)) {
                 /* read next sector */
                 setup_req_params( SelectedDrive );
                 do_fd_action( SelectedDrive );
         }
         else {
                 /* all sectors finished */
-                CURRENT->nr_sectors -= CURRENT->current_nr_sectors;
-                CURRENT->sector += CURRENT->current_nr_sectors;
-                end_request(CURRENT, 1);
+                fd_end_request_cur(0);
                 redo_fd_request();
         }
         return;
@@ -1382,7 +1382,7 @@ static void setup_req_params( int drive )
         ReqData = ReqBuffer + 512 * ReqCnt;
 
         if (UseTrackbuffer)
-                read_track = (ReqCmd == READ && CURRENT->errors == 0);
+                read_track = (ReqCmd == READ && fd_request->errors == 0);
         else
                 read_track = 0;
 
@@ -1396,25 +1396,27 @@ static void redo_fd_request(void)
         int drive, type;
         struct atari_floppy_struct *floppy;
 
-        DPRINT(("redo_fd_request: CURRENT=%p dev=%s CURRENT->sector=%ld\n",
-                CURRENT, CURRENT ? CURRENT->rq_disk->disk_name : "",
-                CURRENT ? CURRENT->sector : 0 ));
+        DPRINT(("redo_fd_request: fd_request=%p dev=%s fd_request->sector=%ld\n",
+                fd_request, fd_request ? fd_request->rq_disk->disk_name : "",
+                fd_request ? blk_rq_pos(fd_request) : 0 ));
 
         IsFormatting = 0;
 
 repeat:
+        if (!fd_request) {
+                fd_request = blk_fetch_request(floppy_queue);
+                if (!fd_request)
+                        goto the_end;
+        }
 
-        if (!CURRENT)
-                goto the_end;
-
-        floppy = CURRENT->rq_disk->private_data;
+        floppy = fd_request->rq_disk->private_data;
         drive = floppy - unit;
         type = floppy->type;
         
         if (!UD.connected) {
                 /* drive not connected */
                 printk(KERN_ERR "Unknown Device: fd%d\n", drive );
-                end_request(CURRENT, 0);
+                fd_end_request_cur(-EIO);
                 goto repeat;
         }
                 
@@ -1430,12 +1432,12 @@ repeat:
                 /* user supplied disk type */
                 if (--type >= NUM_DISK_MINORS) {
                         printk(KERN_WARNING "fd%d: invalid disk format", drive );
-                        end_request(CURRENT, 0);
+                        fd_end_request_cur(-EIO);
                         goto repeat;
                 }
                 if (minor2disktype[type].drive_types > DriveType)  {
                         printk(KERN_WARNING "fd%d: unsupported disk format", drive );
-                        end_request(CURRENT, 0);
+                        fd_end_request_cur(-EIO);
                         goto repeat;
                 }
                 type = minor2disktype[type].index;
@@ -1444,8 +1446,8 @@ repeat:
                 UD.autoprobe = 0;
         }
         
-        if (CURRENT->sector + 1 > UDT->blocks) {
-                end_request(CURRENT, 0);
+        if (blk_rq_pos(fd_request) + 1 > UDT->blocks) {
+                fd_end_request_cur(-EIO);
                 goto repeat;
         }
 
@@ -1453,9 +1455,9 @@ repeat:
         del_timer( &motor_off_timer );
                 
         ReqCnt = 0;
-        ReqCmd = rq_data_dir(CURRENT);
-        ReqBlock = CURRENT->sector;
-        ReqBuffer = CURRENT->buffer;
+        ReqCmd = rq_data_dir(fd_request);
+        ReqBlock = blk_rq_pos(fd_request);
+        ReqBuffer = fd_request->buffer;
         setup_req_params( drive );
         do_fd_action( drive );
 
diff --git a/drivers/block/brd.c b/drivers/block/brd.c
index 5f7e64ba87e5..4bf8705b3ace 100644
--- a/drivers/block/brd.c
+++ b/drivers/block/brd.c
@@ -407,12 +407,7 @@ static int __init ramdisk_size(char *str)
         rd_size = simple_strtol(str, NULL, 0);
         return 1;
 }
-static int __init ramdisk_size2(char *str)
-{
-        return ramdisk_size(str);
-}
-__setup("ramdisk=", ramdisk_size);
-__setup("ramdisk_size=", ramdisk_size2);
+__setup("ramdisk_size=", ramdisk_size);
 #endif
 
 /*
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 4d4d5e0d3fa6..b22cec97ea19 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -180,11 +180,13 @@ 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);
+                        __u8 page_code, unsigned char scsi3addr[],
+                        int cmd_type);
+static int sendcmd_withirq_core(ctlr_info_t *h, CommandList_struct *c,
+        int attempt_retry);
+static int process_sendcmd_error(ctlr_info_t *h, CommandList_struct *c);
 
 static void fail_all_cmds(unsigned long ctlr);
 static int scan_thread(void *data);
@@ -437,6 +439,194 @@ static void __devinit cciss_procinit(int i)
 }
 #endif                          /* CONFIG_PROC_FS */
 
+#define MAX_PRODUCT_NAME_LEN 19
+
+#define to_hba(n) container_of(n, struct ctlr_info, dev)
+#define to_drv(n) container_of(n, drive_info_struct, dev)
+
+static struct device_type cciss_host_type = {
+        .name           = "cciss_host",
+};
+
+static ssize_t dev_show_unique_id(struct device *dev,
+                                 struct device_attribute *attr,
+                                 char *buf)
+{
+        drive_info_struct *drv = to_drv(dev);
+        struct ctlr_info *h = to_hba(drv->dev.parent);
+        __u8 sn[16];
+        unsigned long flags;
+        int ret = 0;
+
+        spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
+        if (h->busy_configuring)
+                ret = -EBUSY;
+        else
+                memcpy(sn, drv->serial_no, sizeof(sn));
+        spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
+
+        if (ret)
+                return ret;
+        else
+                return snprintf(buf, 16 * 2 + 2,
+                                "%02X%02X%02X%02X%02X%02X%02X%02X"
+                                "%02X%02X%02X%02X%02X%02X%02X%02X\n",
+                                sn[0], sn[1], sn[2], sn[3],
+                                sn[4], sn[5], sn[6], sn[7],
+                                sn[8], sn[9], sn[10], sn[11],
+                                sn[12], sn[13], sn[14], sn[15]);
+}
+DEVICE_ATTR(unique_id, S_IRUGO, dev_show_unique_id, NULL);
+
+static ssize_t dev_show_vendor(struct device *dev,
+                               struct device_attribute *attr,
+                               char *buf)
+{
+        drive_info_struct *drv = to_drv(dev);
+        struct ctlr_info *h = to_hba(drv->dev.parent);
+        char vendor[VENDOR_LEN + 1];
+        unsigned long flags;
+        int ret = 0;
+
+        spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
+        if (h->busy_configuring)
+                ret = -EBUSY;
+        else
+                memcpy(vendor, drv->vendor, VENDOR_LEN + 1);
+        spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
+
+        if (ret)
+                return ret;
+        else
+                return snprintf(buf, sizeof(vendor) + 1, "%s\n", drv->vendor);
+}
+DEVICE_ATTR(vendor, S_IRUGO, dev_show_vendor, NULL);
+
+static ssize_t dev_show_model(struct device *dev,
+                              struct device_attribute *attr,
+                              char *buf)
+{
+        drive_info_struct *drv = to_drv(dev);
+        struct ctlr_info *h = to_hba(drv->dev.parent);
+        char model[MODEL_LEN + 1];
+        unsigned long flags;
+        int ret = 0;
+
+        spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
+        if (h->busy_configuring)
+                ret = -EBUSY;
+        else
+                memcpy(model, drv->model, MODEL_LEN + 1);
+        spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
+
+        if (ret)
+                return ret;
+        else
+                return snprintf(buf, sizeof(model) + 1, "%s\n", drv->model);
+}
+DEVICE_ATTR(model, S_IRUGO, dev_show_model, NULL);
+
+static ssize_t dev_show_rev(struct device *dev,
+                            struct device_attribute *attr,
+                            char *buf)
+{
+        drive_info_struct *drv = to_drv(dev);
+        struct ctlr_info *h = to_hba(drv->dev.parent);
+        char rev[REV_LEN + 1];
+        unsigned long flags;
+        int ret = 0;
+
+        spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
+        if (h->busy_configuring)
+                ret = -EBUSY;
+        else
+                memcpy(rev, drv->rev, REV_LEN + 1);
+        spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
+
+        if (ret)
+                return ret;
+        else
+                return snprintf(buf, sizeof(rev) + 1, "%s\n", drv->rev);
+}
+DEVICE_ATTR(rev, S_IRUGO, dev_show_rev, NULL);
+
+static struct attribute *cciss_dev_attrs[] = {
+        &dev_attr_unique_id.attr,
+        &dev_attr_model.attr,
+        &dev_attr_vendor.attr,
+        &dev_attr_rev.attr,
+        NULL
+};
+
+static struct attribute_group cciss_dev_attr_group = {
+        .attrs = cciss_dev_attrs,
+};
+
+static struct attribute_group *cciss_dev_attr_groups[] = {
+        &cciss_dev_attr_group,
+        NULL
+};
+
+static struct device_type cciss_dev_type = {
+        .name           = "cciss_device",
+        .groups         = cciss_dev_attr_groups,
+};
+
+static struct bus_type cciss_bus_type = {
+        .name           = "cciss",
+};
+
+
+/*
+ * Initialize sysfs entry for each controller.  This sets up and registers
+ * the 'cciss#' directory for each individual controller under
+ * /sys/bus/pci/devices/<dev>/.
+ */
+static int cciss_create_hba_sysfs_entry(struct ctlr_info *h)
+{
+        device_initialize(&h->dev);
+        h->dev.type = &cciss_host_type;
+        h->dev.bus = &cciss_bus_type;
+        dev_set_name(&h->dev, "%s", h->devname);
+        h->dev.parent = &h->pdev->dev;
+
+        return device_add(&h->dev);
+}
+
+/*
+ * Remove sysfs entries for an hba.
+ */
+static void cciss_destroy_hba_sysfs_entry(struct ctlr_info *h)
+{
+        device_del(&h->dev);
+}
+
+/*
+ * Initialize sysfs for each logical drive.  This sets up and registers
+ * the 'c#d#' directory for each individual logical drive under
+ * /sys/bus/pci/devices/<dev/ccis#/. We also create a link from
+ * /sys/block/cciss!c#d# to this entry.
+ */
+static int cciss_create_ld_sysfs_entry(struct ctlr_info *h,
+                                       drive_info_struct *drv,
+                                       int drv_index)
+{
+        device_initialize(&drv->dev);
+        drv->dev.type = &cciss_dev_type;
+        drv->dev.bus = &cciss_bus_type;
+        dev_set_name(&drv->dev, "c%dd%d", h->ctlr, drv_index);
+        drv->dev.parent = &h->dev;
+        return device_add(&drv->dev);
+}
+
+/*
+ * Remove sysfs entries for a logical drive.
+ */
+static void cciss_destroy_ld_sysfs_entry(drive_info_struct *drv)
+{
+        device_del(&drv->dev);
+}
+
 /*
  * 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
@@ -1299,7 +1489,6 @@ static void cciss_softirq_done(struct request *rq)
 {
         CommandList_struct *cmd = rq->completion_data;
         ctlr_info_t *h = hba[cmd->ctlr];
-        unsigned int nr_bytes;
         unsigned long flags;
         u64bit temp64;
         int i, ddir;
@@ -1321,15 +1510,11 @@ static void cciss_softirq_done(struct request *rq)
         printk("Done with %p\n", rq);
 #endif                          /* CCISS_DEBUG */
 
-        /*
-         * Store the full size and set the residual count for pc requests
-         */
-        nr_bytes = blk_rq_bytes(rq);
+        /* set the residual count for pc requests */
         if (blk_pc_request(rq))
-                rq->data_len = cmd->err_info->ResidualCnt;
+                rq->resid_len = cmd->err_info->ResidualCnt;
 
-        if (blk_end_request(rq, (rq->errors == 0) ? 0 : -EIO, nr_bytes))
-                BUG();
+        blk_end_request_all(rq, (rq->errors == 0) ? 0 : -EIO);
 
         spin_lock_irqsave(&h->lock, flags);
         cmd_free(h, cmd, 1);
@@ -1337,6 +1522,56 @@ static void cciss_softirq_done(struct request *rq)
         spin_unlock_irqrestore(&h->lock, flags);
 }
 
+static void log_unit_to_scsi3addr(ctlr_info_t *h, unsigned char scsi3addr[],
+        uint32_t log_unit)
+{
+        log_unit = h->drv[log_unit].LunID & 0x03fff;
+        memset(&scsi3addr[4], 0, 4);
+        memcpy(&scsi3addr[0], &log_unit, 4);
+        scsi3addr[3] |= 0x40;
+}
+
+/* This function gets the SCSI vendor, model, and revision of a logical drive
+ * via the inquiry page 0.  Model, vendor, and rev are set to empty strings if
+ * they cannot be read.
+ */
+static void cciss_get_device_descr(int ctlr, int logvol, int withirq,
+                                   char *vendor, char *model, char *rev)
+{
+        int rc;
+        InquiryData_struct *inq_buf;
+        unsigned char scsi3addr[8];
+
+        *vendor = '\0';
+        *model = '\0';
+        *rev = '\0';
+
+        inq_buf = kzalloc(sizeof(InquiryData_struct), GFP_KERNEL);
+        if (!inq_buf)
+                return;
+
+        log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol);
+        if (withirq)
+                rc = sendcmd_withirq(CISS_INQUIRY, ctlr, inq_buf,
+                             sizeof(InquiryData_struct), 0,
+                                scsi3addr, TYPE_CMD);
+        else
+                rc = sendcmd(CISS_INQUIRY, ctlr, inq_buf,
+                             sizeof(InquiryData_struct), 0,
+                                scsi3addr, TYPE_CMD);
+        if (rc == IO_OK) {
+                memcpy(vendor, &inq_buf->data_byte[8], VENDOR_LEN);
+                vendor[VENDOR_LEN] = '\0';
+                memcpy(model, &inq_buf->data_byte[16], MODEL_LEN);
+                model[MODEL_LEN] = '\0';
+                memcpy(rev, &inq_buf->data_byte[32], REV_LEN);
+                rev[REV_LEN] = '\0';
+        }
+
+        kfree(inq_buf);
+        return;
+}
+
 /* This function gets the serial number of a logical drive via
  * inquiry page 0x83.  Serial no. is 16 bytes.  If the serial
  * number cannot be had, for whatever reason, 16 bytes of 0xff
@@ -1348,6 +1583,7 @@ static void cciss_get_serial_no(int ctlr, int logvol, int withirq,
 #define PAGE_83_INQ_BYTES 64
         int rc;
         unsigned char *buf;
+        unsigned char scsi3addr[8];
 
         if (buflen > 16)
                 buflen = 16;
@@ -1356,12 +1592,13 @@ static void cciss_get_serial_no(int ctlr, int logvol, int withirq,
         if (!buf)
                 return;
         memset(serial_no, 0, buflen);
+        log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol);
         if (withirq)
                 rc = sendcmd_withirq(CISS_INQUIRY, ctlr, buf,
-                        PAGE_83_INQ_BYTES, 1, logvol, 0x83, TYPE_CMD);
+                        PAGE_83_INQ_BYTES, 0x83, scsi3addr, TYPE_CMD);
         else
                 rc = sendcmd(CISS_INQUIRY, ctlr, buf,
-                        PAGE_83_INQ_BYTES, 1, logvol, 0x83, NULL, TYPE_CMD);
+                        PAGE_83_INQ_BYTES, 0x83, scsi3addr, TYPE_CMD);
         if (rc == IO_OK)
                 memcpy(serial_no, &buf[8], buflen);
         kfree(buf);
@@ -1377,7 +1614,7 @@ static void cciss_add_disk(ctlr_info_t *h, struct gendisk *disk,
         disk->first_minor = drv_index << NWD_SHIFT;
         disk->fops = &cciss_fops;
         disk->private_data = &h->drv[drv_index];
-        disk->driverfs_dev = &h->pdev->dev;
+        disk->driverfs_dev = &h->drv[drv_index].dev;
 
         /* Set up queue information */
         blk_queue_bounce_limit(disk->queue, h->pdev->dma_mask);
@@ -1394,8 +1631,8 @@ static void cciss_add_disk(ctlr_info_t *h, struct gendisk *disk,
 
         disk->queue->queuedata = h;
 
-        blk_queue_hardsect_size(disk->queue,
-                                h->drv[drv_index].block_size);
+        blk_queue_logical_block_size(disk->queue,
+                                     h->drv[drv_index].block_size);
 
         /* Make sure all queue data is written out before */
         /* setting h->drv[drv_index].queue, as setting this */
@@ -1468,6 +1705,8 @@ static void cciss_update_drive_info(int ctlr, int drv_index, int first_time)
         drvinfo->block_size = block_size;
         drvinfo->nr_blocks = total_size + 1;
 
+        cciss_get_device_descr(ctlr, drv_index, 1, drvinfo->vendor,
+                                drvinfo->model, drvinfo->rev);
         cciss_get_serial_no(ctlr, drv_index, 1, drvinfo->serial_no,
                         sizeof(drvinfo->serial_no));
 
@@ -1517,6 +1756,9 @@ static void cciss_update_drive_info(int ctlr, int drv_index, int first_time)
         h->drv[drv_index].cylinders = drvinfo->cylinders;
         h->drv[drv_index].raid_level = drvinfo->raid_level;
         memcpy(h->drv[drv_index].serial_no, drvinfo->serial_no, 16);
+        memcpy(h->drv[drv_index].vendor, drvinfo->vendor, VENDOR_LEN + 1);
+        memcpy(h->drv[drv_index].model, drvinfo->model, MODEL_LEN + 1);
+        memcpy(h->drv[drv_index].rev, drvinfo->rev, REV_LEN + 1);
 
         ++h->num_luns;
         disk = h->gendisk[drv_index];
@@ -1591,6 +1833,8 @@ static int cciss_add_gendisk(ctlr_info_t *h, __u32 lunid, int controller_node)
                 }
         }
         h->drv[drv_index].LunID = lunid;
+        if (cciss_create_ld_sysfs_entry(h, &h->drv[drv_index], drv_index))
+                goto err_free_disk;
 
         /* Don't need to mark this busy because nobody */
         /* else knows about this disk yet to contend */
@@ -1598,6 +1842,11 @@ static int cciss_add_gendisk(ctlr_info_t *h, __u32 lunid, int controller_node)
         h->drv[drv_index].busy_configuring = 0;
         wmb();
         return drv_index;
+
+err_free_disk:
+        put_disk(h->gendisk[drv_index]);
+        h->gendisk[drv_index] = NULL;
+        return -1;
 }
 
 /* This is for the special case of a controller which
@@ -1668,8 +1917,8 @@ static int rebuild_lun_table(ctlr_info_t *h, int first_time)
                 goto mem_msg;
 
         return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
-                                      sizeof(ReportLunData_struct), 0,
-                                      0, 0, TYPE_CMD);
+                                      sizeof(ReportLunData_struct),
+                                      0, CTLR_LUNID, TYPE_CMD);
 
         if (return_code == IO_OK)
                 listlength = be32_to_cpu(*(__be32 *) ld_buff->LUNListLength);
@@ -1718,6 +1967,7 @@ static int rebuild_lun_table(ctlr_info_t *h, int first_time)
                         h->drv[i].busy_configuring = 1;
                         spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
                         return_code = deregister_disk(h, i, 1);
+                        cciss_destroy_ld_sysfs_entry(&h->drv[i]);
                         h->drv[i].busy_configuring = 0;
                 }
         }
@@ -1877,11 +2127,9 @@ static int deregister_disk(ctlr_info_t *h, int drv_index,
         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, __u8 page_code, unsigned char *scsi3addr,
+                int cmd_type)
 {
         ctlr_info_t *h = hba[ctlr];
         u64bit buff_dma_handle;
@@ -1897,27 +2145,12 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_
                 c->Header.SGTotal = 0;
         }
         c->Header.Tag.lower = c->busaddr;
+        memcpy(c->Header.LUN.LunAddrBytes, scsi3addr, 8);
 
         c->Request.Type.Type = cmd_type;
         if (cmd_type == TYPE_CMD) {
                 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 */
-                        if (use_unit_num == 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);
-                                c->Header.LUN.LogDev.Mode = 0;
-                        }
                         /* are we trying to read a vital product page */
                         if (page_code != 0) {
                                 c->Request.CDB[1] = 0x01;
@@ -1947,8 +2180,6 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_
                         break;
 
                 case CCISS_READ_CAPACITY:
-                        c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
-                        c->Header.LUN.LogDev.Mode = 1;
                         c->Request.CDBLen = 10;
                         c->Request.Type.Attribute = ATTR_SIMPLE;
                         c->Request.Type.Direction = XFER_READ;
@@ -1956,8 +2187,6 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_
                         c->Request.CDB[0] = cmd;
                         break;
                 case CCISS_READ_CAPACITY_16:
-                        c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
-                        c->Header.LUN.LogDev.Mode = 1;
                         c->Request.CDBLen = 16;
                         c->Request.Type.Attribute = ATTR_SIMPLE;
                         c->Request.Type.Direction = XFER_READ;
@@ -1979,6 +2208,12 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_
                         c->Request.CDB[0] = BMIC_WRITE;
                         c->Request.CDB[6] = BMIC_CACHE_FLUSH;
                         break;
+                case TEST_UNIT_READY:
+                        c->Request.CDBLen = 6;
+                        c->Request.Type.Attribute = ATTR_SIMPLE;
+                        c->Request.Type.Direction = XFER_NONE;
+                        c->Request.Timeout = 0;
+                        break;
                 default:
                         printk(KERN_WARNING
                                "cciss%d:  Unknown Command 0x%c\n", ctlr, cmd);
@@ -1997,13 +2232,13 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_
                         memcpy(&c->Request.CDB[4], buff, 8);
                         break;
                 case 1: /* RESET message */
-                        c->Request.CDBLen = 12;
+                        c->Request.CDBLen = 16;
                         c->Request.Type.Attribute = ATTR_SIMPLE;
-                        c->Request.Type.Direction = XFER_WRITE;
+                        c->Request.Type.Direction = XFER_NONE;
                         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[1] = 0x03;       /* reset a target */
                         break;
                 case 3: /* No-Op message */
                         c->Request.CDBLen = 1;
@@ -2035,114 +2270,152 @@ static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff, size_
         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 check_target_status(ctlr_info_t *h, CommandList_struct *c)
 {
-        ctlr_info_t *h = hba[ctlr];
-        CommandList_struct *c;
+        switch (c->err_info->ScsiStatus) {
+        case SAM_STAT_GOOD:
+                return IO_OK;
+        case SAM_STAT_CHECK_CONDITION:
+                switch (0xf & c->err_info->SenseInfo[2]) {
+                case 0: return IO_OK; /* no sense */
+                case 1: return IO_OK; /* recovered error */
+                default:
+                        printk(KERN_WARNING "cciss%d: cmd 0x%02x "
+                                "check condition, sense key = 0x%02x\n",
+                                h->ctlr, c->Request.CDB[0],
+                                c->err_info->SenseInfo[2]);
+                }
+                break;
+        default:
+                printk(KERN_WARNING "cciss%d: cmd 0x%02x"
+                        "scsi status = 0x%02x\n", h->ctlr,
+                        c->Request.CDB[0], c->err_info->ScsiStatus);
+                break;
+        }
+        return IO_ERROR;
+}
+
+static int process_sendcmd_error(ctlr_info_t *h, CommandList_struct *c)
+{
+        int return_status = IO_OK;
+
+        if (c->err_info->CommandStatus == CMD_SUCCESS)
+                return IO_OK;
+
+        switch (c->err_info->CommandStatus) {
+        case CMD_TARGET_STATUS:
+                return_status = check_target_status(h, c);
+                break;
+        case CMD_DATA_UNDERRUN:
+        case CMD_DATA_OVERRUN:
+                /* expected for inquiry and report lun commands */
+                break;
+        case CMD_INVALID:
+                printk(KERN_WARNING "cciss: cmd 0x%02x is "
+                       "reported invalid\n", c->Request.CDB[0]);
+                return_status = IO_ERROR;
+                break;
+        case CMD_PROTOCOL_ERR:
+                printk(KERN_WARNING "cciss: cmd 0x%02x has "
+                       "protocol error \n", c->Request.CDB[0]);
+                return_status = IO_ERROR;
+                break;
+        case CMD_HARDWARE_ERR:
+                printk(KERN_WARNING "cciss: cmd 0x%02x had "
+                       " hardware error\n", c->Request.CDB[0]);
+                return_status = IO_ERROR;
+                break;
+        case CMD_CONNECTION_LOST:
+                printk(KERN_WARNING "cciss: cmd 0x%02x had "
+                       "connection lost\n", c->Request.CDB[0]);
+                return_status = IO_ERROR;
+                break;
+        case CMD_ABORTED:
+                printk(KERN_WARNING "cciss: cmd 0x%02x was "
+                       "aborted\n", c->Request.CDB[0]);
+                return_status = IO_ERROR;
+                break;
+        case CMD_ABORT_FAILED:
+                printk(KERN_WARNING "cciss: cmd 0x%02x reports "
+                       "abort failed\n", c->Request.CDB[0]);
+                return_status = IO_ERROR;
+                break;
+        case CMD_UNSOLICITED_ABORT:
+                printk(KERN_WARNING
+                       "cciss%d: unsolicited abort 0x%02x\n", h->ctlr,
+                        c->Request.CDB[0]);
+                return_status = IO_NEEDS_RETRY;
+                break;
+        default:
+                printk(KERN_WARNING "cciss: cmd 0x%02x returned "
+                       "unknown status %x\n", c->Request.CDB[0],
+                       c->err_info->CommandStatus);
+                return_status = IO_ERROR;
+        }
+        return return_status;
+}
+
+static int sendcmd_withirq_core(ctlr_info_t *h, CommandList_struct *c,
+        int attempt_retry)
+{
+        DECLARE_COMPLETION_ONSTACK(wait);
         u64bit buff_dma_handle;
         unsigned long flags;
-        int return_status;
-        DECLARE_COMPLETION_ONSTACK(wait);
+        int return_status = IO_OK;
 
-        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);
-        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);
+        spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
         addQ(&h->reqQ, c);
         h->Qdepth++;
         start_io(h);
-        spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
+        spin_unlock_irqrestore(CCISS_LOCK(h->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 || !attempt_retry)
+                goto command_done;
 
-                        break;
-                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;
-                        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;
-                        break;
-                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;
-                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;
-                }
+        return_status = process_sendcmd_error(h, c);
+
+        if (return_status == IO_NEEDS_RETRY &&
+                c->retry_count < MAX_CMD_RETRIES) {
+                printk(KERN_WARNING "cciss%d: retrying 0x%02x\n", h->ctlr,
+                        c->Request.CDB[0]);
+                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;
         }
+
+command_done:
         /* 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);
+        return return_status;
+}
+
+static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
+                           __u8 page_code, unsigned char scsi3addr[],
+                        int cmd_type)
+{
+        ctlr_info_t *h = hba[ctlr];
+        CommandList_struct *c;
+        int return_status;
+
+        c = cmd_alloc(h, 0);
+        if (!c)
+                return -ENOMEM;
+        return_status = fill_cmd(c, cmd, ctlr, buff, size, page_code,
+                scsi3addr, cmd_type);
+        if (return_status == IO_OK)
+                return_status = sendcmd_withirq_core(h, c, 1);
+
         cmd_free(h, c, 0);
         return return_status;
 }
@@ -2155,15 +2428,17 @@ static void cciss_geometry_inquiry(int ctlr, int logvol,
 {
         int return_code;
         unsigned long t;
+        unsigned char scsi3addr[8];
 
         memset(inq_buff, 0, sizeof(InquiryData_struct));
+        log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol);
         if (withirq)
                 return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
-                                              inq_buff, sizeof(*inq_buff), 1,
-                                              logvol, 0xC1, TYPE_CMD);
+                                              inq_buff, sizeof(*inq_buff),
+                                              0xC1, scsi3addr, TYPE_CMD);
         else
                 return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
-                                      sizeof(*inq_buff), 1, logvol, 0xC1, NULL,
+                                      sizeof(*inq_buff), 0xC1, scsi3addr,
                                       TYPE_CMD);
         if (return_code == IO_OK) {
                 if (inq_buff->data_byte[8] == 0xFF) {
@@ -2204,6 +2479,7 @@ cciss_read_capacity(int ctlr, int logvol, int withirq, sector_t *total_size,
 {
         ReadCapdata_struct *buf;
         int return_code;
+        unsigned char scsi3addr[8];
 
         buf = kzalloc(sizeof(ReadCapdata_struct), GFP_KERNEL);
         if (!buf) {
@@ -2211,14 +2487,15 @@ cciss_read_capacity(int ctlr, int logvol, int withirq, sector_t *total_size,
                 return;
         }
 
+        log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol);
         if (withirq)
                 return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
                                 ctlr, buf, sizeof(ReadCapdata_struct),
-                                        1, logvol, 0, TYPE_CMD);
+                                        0, scsi3addr, TYPE_CMD);
         else
                 return_code = sendcmd(CCISS_READ_CAPACITY,
                                 ctlr, buf, sizeof(ReadCapdata_struct),
-                                        1, logvol, 0, NULL, TYPE_CMD);
+                                        0, scsi3addr, TYPE_CMD);
         if (return_code == IO_OK) {
                 *total_size = be32_to_cpu(*(__be32 *) buf->total_size);
                 *block_size = be32_to_cpu(*(__be32 *) buf->block_size);
@@ -2238,6 +2515,7 @@ cciss_read_capacity_16(int ctlr, int logvol, int withirq, sector_t *total_size,
 {
         ReadCapdata_struct_16 *buf;
         int return_code;
+        unsigned char scsi3addr[8];
 
         buf = kzalloc(sizeof(ReadCapdata_struct_16), GFP_KERNEL);
         if (!buf) {
@@ -2245,15 +2523,16 @@ cciss_read_capacity_16(int ctlr, int logvol, int withirq, sector_t *total_size,
                 return;
         }
 
+        log_unit_to_scsi3addr(hba[ctlr], scsi3addr, logvol);
         if (withirq) {
                 return_code = sendcmd_withirq(CCISS_READ_CAPACITY_16,
                         ctlr, buf, sizeof(ReadCapdata_struct_16),
-                                1, logvol, 0, TYPE_CMD);
+                                0, scsi3addr, TYPE_CMD);
         }
         else {
                 return_code = sendcmd(CCISS_READ_CAPACITY_16,
                         ctlr, buf, sizeof(ReadCapdata_struct_16),
-                                1, logvol, 0, NULL, TYPE_CMD);
+                                0, scsi3addr, TYPE_CMD);
         }
         if (return_code == IO_OK) {
                 *total_size = be64_to_cpu(*(__be64 *) buf->total_size);
@@ -2303,7 +2582,7 @@ static int cciss_revalidate(struct gendisk *disk)
         cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size,
                                inq_buff, drv);
 
-        blk_queue_hardsect_size(drv->queue, drv->block_size);
+        blk_queue_logical_block_size(drv->queue, drv->block_size);
         set_capacity(disk, drv->nr_blocks);
 
         kfree(inq_buff);
@@ -2333,86 +2612,21 @@ static unsigned long pollcomplete(int ctlr)
         return 1;
 }
 
-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
-           the scsi tape stuff gets into error handling mode, 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.
-           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;
-
-        /* 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);
-                /* not much we can do. */
-#ifdef CONFIG_CISS_SCSI_TAPE
-                return 1;
-        }
-
-        /* We've sent down an abort or reset, but something else
-           has completed */
-        if (srl->ncompletions >= (hba[ctlr]->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);
-                return 1;
-        }
-        /* Save it for later */
-        srl->complete[srl->ncompletions] = complete;
-        srl->ncompletions++;
-#endif
-        return 0;
-}
-
-/*
- * Send a command to the controller, and wait for it to complete.
- * Only used at init time.
+/* Send command c to controller h and poll for it to complete.
+ * Turns interrupts off on the board.  Used at driver init time
+ * and during SCSI error recovery.
  */
-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_core(ctlr_info_t *h, CommandList_struct *c)
 {
-        CommandList_struct *c;
         int i;
         unsigned long complete;
-        ctlr_info_t *info_p = hba[ctlr];
+        int status = IO_ERROR;
         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;
-        }
-        status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
-                          log_unit, page_code, scsi3addr, cmd_type);
-        if (status != IO_OK) {
-                cmd_free(info_p, c, 1);
-                return status;
-        }
-      resend_cmd1:
-        /*
-         * 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);
+resend_cmd1:
+
+        /* Disable interrupt on the board. */
+        h->access.set_intr_mask(h, CCISS_INTR_OFF);
 
         /* Make sure there is room in the command FIFO */
         /* Actually it should be completely empty at this time */
@@ -2420,21 +2634,15 @@ static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use
         /* tape side of the driver. */
         for (i = 200000; i > 0; i--) {
                 /* if fifo isn't full go */
-                if (!(info_p->access.fifo_full(info_p))) {
-
+                if (!(h->access.fifo_full(h)))
                         break;
-                }
                 udelay(10);
                 printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
-                       " waiting!\n", ctlr);
+                       " waiting!\n", h->ctlr);
         }
-        /*
-         * Send the cmd
-         */
-        info_p->access.submit_command(info_p, c);
-        done = 0;
+        h->access.submit_command(h, c); /* Send the cmd */
         do {
-                complete = pollcomplete(ctlr);
+                complete = pollcomplete(h->ctlr);
 
 #ifdef CCISS_DEBUG
                 printk(KERN_DEBUG "cciss: command completed\n");
@@ -2443,97 +2651,102 @@ static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size, unsigned int use
                 if (complete == 1) {
                         printk(KERN_WARNING
                                "cciss cciss%d: SendCmd Timeout out, "
-                               "No command list address returned!\n", ctlr);
+                               "No command list address returned!\n", h->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 (((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)
-                            )) {
-                                complete = c->busaddr;
-                        } else {
-                                if (c->err_info->CommandStatus ==
-                                    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));
-                                                goto resend_cmd1;
-                                        } else {
-                                                printk(KERN_WARNING
-                                                       "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);
-                                        status = IO_ERROR;
-                                        goto cleanup1;
-                                }
-                                printk(KERN_WARNING "ciss ciss%d: sendcmd"
-                                       " 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);
-                                status = IO_ERROR;
-                                goto cleanup1;
-                        }
+                /* Make sure it's the command we're expecting. */
+                if ((complete & ~CISS_ERROR_BIT) != c->busaddr) {
+                        printk(KERN_WARNING "cciss%d: Unexpected command "
+                                "completion.\n", h->ctlr);
+                        continue;
+                }
+
+                /* It is our command.  If no error, we're done. */
+                if (!(complete & CISS_ERROR_BIT)) {
+                        status = IO_OK;
+                        break;
                 }
-                /* This will need changing for direct lookup completions */
-                if (complete != c->busaddr) {
-                        if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
-                                BUG();  /* we are pretty much hosed if we get here. */
+
+                /* There is an error... */
+
+                /* 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))) {
+                        complete = c->busaddr;
+                        status = IO_OK;
+                        break;
+                }
+
+                if (c->err_info->CommandStatus == CMD_UNSOLICITED_ABORT) {
+                        printk(KERN_WARNING "cciss%d: unsolicited abort %p\n",
+                                h->ctlr, c);
+                        if (c->retry_count < MAX_CMD_RETRIES) {
+                                printk(KERN_WARNING "cciss%d: retrying %p\n",
+                                   h->ctlr, c);
+                                c->retry_count++;
+                                /* erase the old error information */
+                                memset(c->err_info, 0, sizeof(c->err_info));
+                                goto resend_cmd1;
                         }
-                        continue;
-                } else
-                        done = 1;
-        } while (!done);
+                        printk(KERN_WARNING "cciss%d: retried %p too many "
+                                "times\n", h->ctlr, c);
+                        status = IO_ERROR;
+                        break;
+                }
+
+                if (c->err_info->CommandStatus == CMD_UNABORTABLE) {
+                        printk(KERN_WARNING "cciss%d: command could not be "
+                                "aborted.\n", h->ctlr);
+                        status = IO_ERROR;
+                        break;
+                }
+
+                if (c->err_info->CommandStatus == CMD_TARGET_STATUS) {
+                        status = check_target_status(h, c);
+                        break;
+                }
+
+                printk(KERN_WARNING "cciss%d: sendcmd error\n", h->ctlr);
+                printk(KERN_WARNING "cmd = 0x%02x, CommandStatus = 0x%02x\n",
+                        c->Request.CDB[0], c->err_info->CommandStatus);
+                status = IO_ERROR;
+                break;
+
+        } while (1);
 
-      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,
+        pci_unmap_single(h->pdev, (dma_addr_t) buff_dma_handle.val,
                          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);
-#endif
-        cmd_free(info_p, c, 1);
+        return status;
+}
+
+/*
+ * Send a command to the controller, and wait for it to complete.
+ * Used at init time, and during SCSI error recovery.
+ */
+static int sendcmd(__u8 cmd, int ctlr, void *buff, size_t size,
+        __u8 page_code, unsigned char *scsi3addr, int cmd_type)
+{
+        CommandList_struct *c;
+        int status;
+
+        c = cmd_alloc(hba[ctlr], 1);
+        if (!c) {
+                printk(KERN_WARNING "cciss: unable to get memory");
+                return IO_ERROR;
+        }
+        status = fill_cmd(c, cmd, ctlr, buff, size, page_code,
+                scsi3addr, cmd_type);
+        if (status == IO_OK)
+                status = sendcmd_core(hba[ctlr], c);
+        cmd_free(hba[ctlr], c, 1);
         return status;
 }
 
@@ -2691,7 +2904,7 @@ static inline void complete_command(ctlr_info_t *h, CommandList_struct *cmd,
                         printk(KERN_WARNING "cciss: cmd %p has"
                                " completed with data underrun "
                                "reported\n", cmd);
-                        cmd->rq->data_len = cmd->err_info->ResidualCnt;
+                        cmd->rq->resid_len = cmd->err_info->ResidualCnt;
                 }
                 break;
         case CMD_DATA_OVERRUN:
@@ -2806,7 +3019,7 @@ static void do_cciss_request(struct request_queue *q)
                 goto startio;
 
       queue:
-        creq = elv_next_request(q);
+        creq = blk_peek_request(q);
         if (!creq)
                 goto startio;
 
@@ -2815,7 +3028,7 @@ static void do_cciss_request(struct request_queue *q)
         if ((c = cmd_alloc(h, 1)) == NULL)
                 goto full;
 
-        blkdev_dequeue_request(creq);
+        blk_start_request(creq);
 
         spin_unlock_irq(q->queue_lock);
 
@@ -2840,10 +3053,10 @@ static void do_cciss_request(struct request_queue *q)
         c->Request.Timeout = 0; // Don't time out
         c->Request.CDB[0] =
             (rq_data_dir(creq) == READ) ? h->cciss_read : h->cciss_write;
-        start_blk = creq->sector;
+        start_blk = blk_rq_pos(creq);
 #ifdef CCISS_DEBUG
-        printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n", (int)creq->sector,
-               (int)creq->nr_sectors);
+        printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n",
+               (int)blk_rq_pos(creq), (int)blk_rq_sectors(creq));
 #endif                          /* CCISS_DEBUG */
 
         sg_init_table(tmp_sg, MAXSGENTRIES);
@@ -2869,8 +3082,8 @@ static void do_cciss_request(struct request_queue *q)
                 h->maxSG = seg;
 
 #ifdef CCISS_DEBUG
-        printk(KERN_DEBUG "cciss: Submitting %lu sectors in %d segments\n",
-               creq->nr_sectors, seg);
+        printk(KERN_DEBUG "cciss: Submitting %u sectors in %d segments\n",
+               blk_rq_sectors(creq), seg);
 #endif                          /* CCISS_DEBUG */
 
         c->Header.SGList = c->Header.SGTotal = seg;
@@ -2882,8 +3095,8 @@ static void do_cciss_request(struct request_queue *q)
                         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[7] = (blk_rq_sectors(creq) >> 8) & 0xff;
+                        c->Request.CDB[8] = blk_rq_sectors(creq) & 0xff;
                         c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
                 } else {
                         u32 upper32 = upper_32_bits(start_blk);
@@ -2898,10 +3111,10 @@ static void do_cciss_request(struct request_queue *q)
                         c->Request.CDB[7]= (start_blk >> 16) & 0xff;
                         c->Request.CDB[8]= (start_blk >>  8) & 0xff;
                         c->Request.CDB[9]= start_blk & 0xff;
-                        c->Request.CDB[10]= (creq->nr_sectors >>  24) & 0xff;
-                        c->Request.CDB[11]= (creq->nr_sectors >>  16) & 0xff;
-                        c->Request.CDB[12]= (creq->nr_sectors >>  8) & 0xff;
-                        c->Request.CDB[13]= creq->nr_sectors & 0xff;
+                        c->Request.CDB[10]= (blk_rq_sectors(creq) >> 24) & 0xff;
+                        c->Request.CDB[11]= (blk_rq_sectors(creq) >> 16) & 0xff;
+                        c->Request.CDB[12]= (blk_rq_sectors(creq) >>  8) & 0xff;
+                        c->Request.CDB[13]= blk_rq_sectors(creq) & 0xff;
                         c->Request.CDB[14] = c->Request.CDB[15] = 0;
                 }
         } else if (blk_pc_request(creq)) {
@@ -2931,44 +3144,18 @@ startio:
 
 static inline unsigned long get_next_completion(ctlr_info_t *h)
 {
-#ifdef CONFIG_CISS_SCSI_TAPE
-        /* Any rejects from sendcmd() lying around? Process them first */
-        if (h->scsi_rejects.ncompletions == 0)
-                return h->access.command_completed(h);
-        else {
-                struct sendcmd_reject_list *srl;
-                int n;
-                srl = &h->scsi_rejects;
-                n = --srl->ncompletions;
-                /* printk("cciss%d: processing saved reject\n", h->ctlr); */
-                printk("p");
-                return srl->complete[n];
-        }
-#else
         return h->access.command_completed(h);
-#endif
 }
 
 static inline int interrupt_pending(ctlr_info_t *h)
 {
-#ifdef CONFIG_CISS_SCSI_TAPE
-        return (h->access.intr_pending(h)
-                || (h->scsi_rejects.ncompletions > 0));
-#else
         return h->access.intr_pending(h);
-#endif
 }
 
 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));
-#else
         return (((h->access.intr_pending(h) == 0) ||
                  (h->interrupts_enabled == 0)));
-#endif
 }
 
 static irqreturn_t do_cciss_intr(int irq, void *dev_id)
@@ -3723,12 +3910,15 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
         INIT_HLIST_HEAD(&hba[i]->reqQ);
 
         if (cciss_pci_init(hba[i], pdev) != 0)
-                goto clean1;
+                goto clean0;
 
         sprintf(hba[i]->devname, "cciss%d", i);
         hba[i]->ctlr = i;
         hba[i]->pdev = pdev;
 
+        if (cciss_create_hba_sysfs_entry(hba[i]))
+                goto clean0;
+
         /* configure PCI DMA stuff */
         if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))
                 dac = 1;
@@ -3787,15 +3977,6 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
                 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]) *
-                    (hba[i]->nr_cmds + 5), GFP_KERNEL);
-        if (hba[i]->scsi_rejects.complete == NULL) {
-                printk(KERN_ERR "cciss: out of memory");
-                goto clean4;
-        }
-#endif
         spin_lock_init(&hba[i]->lock);
 
         /* Initialize the pdev driver private data.
@@ -3828,7 +4009,7 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
         }
 
         return_code = sendcmd_withirq(CISS_INQUIRY, i, inq_buff,
-                sizeof(InquiryData_struct), 0, 0 , 0, TYPE_CMD);
+                sizeof(InquiryData_struct), 0, CTLR_LUNID, TYPE_CMD);
         if (return_code == IO_OK) {
                 hba[i]->firm_ver[0] = inq_buff->data_byte[32];
                 hba[i]->firm_ver[1] = inq_buff->data_byte[33];
@@ -3855,9 +4036,6 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
 
 clean4:
         kfree(inq_buff);
-#ifdef CONFIG_CISS_SCSI_TAPE
-        kfree(hba[i]->scsi_rejects.complete);
-#endif
         kfree(hba[i]->cmd_pool_bits);
         if (hba[i]->cmd_pool)
                 pci_free_consistent(hba[i]->pdev,
@@ -3872,6 +4050,8 @@ clean4:
 clean2:
         unregister_blkdev(hba[i]->major, hba[i]->devname);
 clean1:
+        cciss_destroy_hba_sysfs_entry(hba[i]);
+clean0:
         hba[i]->busy_initializing = 0;
         /* cleanup any queues that may have been initialized */
         for (j=0; j <= hba[i]->highest_lun; j++){
@@ -3907,8 +4087,8 @@ static void cciss_shutdown(struct pci_dev *pdev)
         /* sendcmd will turn off interrupt, and send the flush...
          * 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);
+        return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0,
+                CTLR_LUNID, TYPE_CMD);
         if (return_code == IO_OK) {
                 printk(KERN_INFO "Completed flushing cache on controller %d\n", i);
         } else {
@@ -3973,15 +4153,13 @@ static void __devexit cciss_remove_one(struct pci_dev *pdev)
         pci_free_consistent(hba[i]->pdev, hba[i]->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
         /*
          * Deliberately omit pci_disable_device(): it does something nasty to
          * Smart Array controllers that pci_enable_device does not undo
          */
         pci_release_regions(pdev);
         pci_set_drvdata(pdev, NULL);
+        cciss_destroy_hba_sysfs_entry(hba[i]);
         free_hba(i);
 }
 
@@ -3999,6 +4177,8 @@ static struct pci_driver cciss_pci_driver = {
  */
 static int __init cciss_init(void)
 {
+        int err;
+
         /*
          * The hardware requires that commands are aligned on a 64-bit
          * boundary. Given that we use pci_alloc_consistent() to allocate an
@@ -4008,8 +4188,20 @@ static int __init cciss_init(void)
 
         printk(KERN_INFO DRIVER_NAME "\n");
 
+        err = bus_register(&cciss_bus_type);
+        if (err)
+                return err;
+
         /* Register for our PCI devices */
-        return pci_register_driver(&cciss_pci_driver);
+        err = pci_register_driver(&cciss_pci_driver);
+        if (err)
+                goto err_bus_register;
+
+        return 0;
+
+err_bus_register:
+        bus_unregister(&cciss_bus_type);
+        return err;
 }
 
 static void __exit cciss_cleanup(void)
@@ -4026,6 +4218,7 @@ static void __exit cciss_cleanup(void)
                 }
         }
         remove_proc_entry("driver/cciss", NULL);
+        bus_unregister(&cciss_bus_type);
 }
 
 static void fail_all_cmds(unsigned long ctlr)
diff --git a/drivers/block/cciss.h b/drivers/block/cciss.h
index 703e08038fb9..06a5db25b298 100644
--- a/drivers/block/cciss.h
+++ b/drivers/block/cciss.h
@@ -11,6 +11,11 @@
 
 #define IO_OK           0
 #define IO_ERROR        1
+#define IO_NEEDS_RETRY  3
+
+#define VENDOR_LEN      8
+#define MODEL_LEN       16
+#define REV_LEN         4
 
 struct ctlr_info;
 typedef struct ctlr_info ctlr_info_t;
@@ -34,23 +39,20 @@ typedef struct _drive_info_struct
         int     cylinders;
         int     raid_level; /* set to -1 to indicate that
                              * the drive is not in use/configured
-                            */
-        int     busy_configuring; /*This is set when the drive is being removed
-                                   *to prevent it from being opened or it's queue
-                                   *from being started.
-                                  */
-        __u8 serial_no[16]; /* from inquiry page 0x83, */
-                            /* not necc. null terminated. */
+                             */
+        int     busy_configuring; /* This is set when a drive is being removed
+                                   * to prevent it from being opened or it's
+                                   * queue from being started.
+                                   */
+        struct  device dev;
+        __u8 serial_no[16]; /* from inquiry page 0x83,
+                             * not necc. null terminated.
+                             */
+        char vendor[VENDOR_LEN + 1]; /* SCSI vendor string */
+        char model[MODEL_LEN + 1];   /* SCSI model string */
+        char rev[REV_LEN + 1];       /* SCSI revision string */
 } drive_info_struct;
 
-#ifdef CONFIG_CISS_SCSI_TAPE
-
-struct sendcmd_reject_list {
-        int ncompletions;
-        unsigned long *complete; /* array of NR_CMDS tags */
-};
-
-#endif
 struct ctlr_info 
 {
         int     ctlr;
@@ -118,11 +120,11 @@ struct ctlr_info
         void *scsi_ctlr; /* ptr to structure containing scsi related stuff */
         /* list of block side commands the scsi error handling sucked up */
         /* and saved for later processing */
-        struct sendcmd_reject_list scsi_rejects;
 #endif
         unsigned char alive;
         struct completion *rescan_wait;
         struct task_struct *cciss_scan_thread;
+        struct device dev;
 };
 
 /*  Defining the diffent access_menthods */
diff --git a/drivers/block/cciss_cmd.h b/drivers/block/cciss_cmd.h
index 40b1b92dae7f..cd665b00c7c5 100644
--- a/drivers/block/cciss_cmd.h
+++ b/drivers/block/cciss_cmd.h
@@ -217,6 +217,8 @@ typedef union _LUNAddr_struct {
   LogDevAddr_struct  LogDev;
 } LUNAddr_struct;
 
+#define CTLR_LUNID "\0\0\0\0\0\0\0\0"
+
 typedef struct _CommandListHeader_struct {
   BYTE              ReplyQueue;
   BYTE              SGList;
diff --git a/drivers/block/cciss_scsi.c b/drivers/block/cciss_scsi.c
index a3fd87b41444..3315268b4ec7 100644
--- a/drivers/block/cciss_scsi.c
+++ b/drivers/block/cciss_scsi.c
@@ -44,20 +44,13 @@
 #define CCISS_ABORT_MSG 0x00
 #define CCISS_RESET_MSG 0x01
 
-/* some prototypes... */ 
-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: address is in scsi3addr */
-        unsigned int log_unit,
-        __u8    page_code,
-        unsigned char *scsi3addr,
+static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
+        size_t size,
+        __u8 page_code, unsigned char *scsi3addr,
         int cmd_type);
 
+static CommandList_struct *cmd_alloc(ctlr_info_t *h, int get_from_pool);
+static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool);
 
 static int cciss_scsi_proc_info(
                 struct Scsi_Host *sh,
@@ -1575,6 +1568,75 @@ cciss_seq_tape_report(struct seq_file *seq, int ctlr)
         CPQ_TAPE_UNLOCK(ctlr, flags);
 }
 
+static int wait_for_device_to_become_ready(ctlr_info_t *h,
+        unsigned char lunaddr[])
+{
+        int rc;
+        int count = 0;
+        int waittime = HZ;
+        CommandList_struct *c;
+
+        c = cmd_alloc(h, 1);
+        if (!c) {
+                printk(KERN_WARNING "cciss%d: out of memory in "
+                        "wait_for_device_to_become_ready.\n", h->ctlr);
+                return IO_ERROR;
+        }
+
+        /* Send test unit ready until device ready, or give up. */
+        while (count < 20) {
+
+                /* Wait for a bit.  do this first, because if we send
+                 * the TUR right away, the reset will just abort it.
+                 */
+                schedule_timeout_uninterruptible(waittime);
+                count++;
+
+                /* Increase wait time with each try, up to a point. */
+                if (waittime < (HZ * 30))
+                        waittime = waittime * 2;
+
+                /* Send the Test Unit Ready */
+                rc = fill_cmd(c, TEST_UNIT_READY, h->ctlr, NULL, 0, 0,
+                        lunaddr, TYPE_CMD);
+                if (rc == 0)
+                        rc = sendcmd_withirq_core(h, c, 0);
+
+                (void) process_sendcmd_error(h, c);
+
+                if (rc != 0)
+                        goto retry_tur;
+
+                if (c->err_info->CommandStatus == CMD_SUCCESS)
+                        break;
+
+                if (c->err_info->CommandStatus == CMD_TARGET_STATUS &&
+                        c->err_info->ScsiStatus == SAM_STAT_CHECK_CONDITION) {
+                        if (c->err_info->SenseInfo[2] == NO_SENSE)
+                                break;
+                        if (c->err_info->SenseInfo[2] == UNIT_ATTENTION) {
+                                unsigned char asc;
+                                asc = c->err_info->SenseInfo[12];
+                                check_for_unit_attention(h, c);
+                                if (asc == POWER_OR_RESET)
+                                        break;
+                        }
+                }
+retry_tur:
+                printk(KERN_WARNING "cciss%d: Waiting %d secs "
+                        "for device to become ready.\n",
+                        h->ctlr, waittime / HZ);
+                rc = 1; /* device not ready. */
+        }
+
+        if (rc)
+                printk("cciss%d: giving up on device.\n", h->ctlr);
+        else
+                printk(KERN_WARNING "cciss%d: device is ready.\n", h->ctlr);
+
+        cmd_free(h, c, 1);
+        return rc;
+}
 
 /* Need at least one of these error handlers to keep ../scsi/hosts.c from 
  * complaining.  Doing a host- or bus-reset can't do anything good here. 
@@ -1591,6 +1653,7 @@ static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
 {
         int rc;
         CommandList_struct *cmd_in_trouble;
+        unsigned char lunaddr[8];
         ctlr_info_t **c;
         int ctlr;
 
@@ -1600,19 +1663,15 @@ static int cciss_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
                 return FAILED;
         ctlr = (*c)->ctlr;
         printk(KERN_WARNING "cciss%d: resetting tape drive or medium changer.\n", ctlr);
-
         /* find the command that's giving us trouble */
         cmd_in_trouble = (CommandList_struct *) scsicmd->host_scribble;
-        if (cmd_in_trouble == NULL) { /* paranoia */
+        if (cmd_in_trouble == NULL) /* paranoia */
                 return FAILED;
-        }
+        memcpy(lunaddr, &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 8);
         /* send a reset to the SCSI LUN which the command was sent to */
-        rc = sendcmd(CCISS_RESET_MSG, ctlr, NULL, 0, 2, 0, 0, 
-                (unsigned char *) &cmd_in_trouble->Header.LUN.LunAddrBytes[0], 
+        rc = sendcmd_withirq(CCISS_RESET_MSG, ctlr, NULL, 0, 0, lunaddr,
                 TYPE_MSG);
-        /* sendcmd turned off interrupts on the board, turn 'em back on. */
-        (*c)->access.set_intr_mask(*c, CCISS_INTR_ON);
-        if (rc == 0)
+        if (rc == 0 && wait_for_device_to_become_ready(*c, lunaddr) == 0)
                 return SUCCESS;
         printk(KERN_WARNING "cciss%d: resetting device failed.\n", ctlr);
         return FAILED;
@@ -1622,6 +1681,7 @@ static int  cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
 {
         int rc;
         CommandList_struct *cmd_to_abort;
+        unsigned char lunaddr[8];
         ctlr_info_t **c;
         int ctlr;
 
@@ -1636,12 +1696,9 @@ static int  cciss_eh_abort_handler(struct scsi_cmnd *scsicmd)
         cmd_to_abort = (CommandList_struct *) scsicmd->host_scribble;
         if (cmd_to_abort == NULL) /* paranoia */
                 return FAILED;
-        rc = sendcmd(CCISS_ABORT_MSG, ctlr, &cmd_to_abort->Header.Tag, 
-                0, 2, 0, 0, 
-                (unsigned char *) &cmd_to_abort->Header.LUN.LunAddrBytes[0], 
-                TYPE_MSG);
-        /* sendcmd turned off interrupts on the board, turn 'em back on. */
-        (*c)->access.set_intr_mask(*c, CCISS_INTR_ON);
+        memcpy(lunaddr, &cmd_to_abort->Header.LUN.LunAddrBytes[0], 8);
+        rc = sendcmd_withirq(CCISS_ABORT_MSG, ctlr, &cmd_to_abort->Header.Tag,
+                0, 0, lunaddr, TYPE_MSG);
         if (rc == 0)
                 return SUCCESS;
         return FAILED;
diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index ca268ca11159..44fa2018f6b0 100644
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -474,7 +474,7 @@ static int __init cpqarray_register_ctlr( int i, struct pci_dev *pdev)
                 disk->fops = &ida_fops;
                 if (j && !drv->nr_blks)
                         continue;
-                blk_queue_hardsect_size(hba[i]->queue, drv->blk_size);
+                blk_queue_logical_block_size(hba[i]->queue, drv->blk_size);
                 set_capacity(disk, drv->nr_blks);
                 disk->queue = hba[i]->queue;
                 disk->private_data = drv;
@@ -903,7 +903,7 @@ static void do_ida_request(struct request_queue *q)
                 goto startio;
 
 queue_next:
-        creq = elv_next_request(q);
+        creq = blk_peek_request(q);
         if (!creq)
                 goto startio;
 
@@ -912,17 +912,18 @@ queue_next:
         if ((c = cmd_alloc(h,1)) == NULL)
                 goto startio;
 
-        blkdev_dequeue_request(creq);
+        blk_start_request(creq);
 
         c->ctlr = h->ctlr;
         c->hdr.unit = (drv_info_t *)(creq->rq_disk->private_data) - h->drv;
         c->hdr.size = sizeof(rblk_t) >> 2;
         c->size += sizeof(rblk_t);
 
-        c->req.hdr.blk = creq->sector;
+        c->req.hdr.blk = blk_rq_pos(creq);
         c->rq = creq;
 DBGPX(
-        printk("sector=%d, nr_sectors=%d\n", creq->sector, creq->nr_sectors);
+        printk("sector=%d, nr_sectors=%u\n",
+               blk_rq_pos(creq), blk_rq_sectors(creq));
 );
         sg_init_table(tmp_sg, SG_MAX);
         seg = blk_rq_map_sg(q, creq, tmp_sg);
@@ -940,9 +941,9 @@ DBGPX(
                                                  tmp_sg[i].offset,
                                                  tmp_sg[i].length, dir);
         }
-DBGPX(  printk("Submitting %d sectors in %d segments\n", creq->nr_sectors, seg); );
+DBGPX(  printk("Submitting %u sectors in %d segments\n", blk_rq_sectors(creq), seg); );
         c->req.hdr.sg_cnt = seg;
-        c->req.hdr.blk_cnt = creq->nr_sectors;
+        c->req.hdr.blk_cnt = blk_rq_sectors(creq);
         c->req.hdr.cmd = (rq_data_dir(creq) == READ) ? IDA_READ : IDA_WRITE;
         c->type = CMD_RWREQ;
 
@@ -1024,8 +1025,7 @@ static inline void complete_command(cmdlist_t *cmd, int timeout)
                                 cmd->req.sg[i].size, ddir);
 
         DBGPX(printk("Done with %p\n", rq););
-        if (__blk_end_request(rq, error, blk_rq_bytes(rq)))
-                BUG();
+        __blk_end_request_all(rq, error);
 }
 
 /*
@@ -1546,7 +1546,7 @@ static int revalidate_allvol(ctlr_info_t *host)
                 drv_info_t *drv = &host->drv[i];
                 if (i && !drv->nr_blks)
                         continue;
-                blk_queue_hardsect_size(host->queue, drv->blk_size);
+                blk_queue_logical_block_size(host->queue, drv->blk_size);
                 set_capacity(disk, drv->nr_blks);
                 disk->queue = host->queue;
                 disk->private_data = drv;
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 1300df6f1642..862b40c90181 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -931,7 +931,7 @@ static inline void unlock_fdc(void)
         del_timer(&fd_timeout);
         cont = NULL;
         clear_bit(0, &fdc_busy);
-        if (elv_next_request(floppy_queue))
+        if (current_req || blk_peek_request(floppy_queue))
                 do_fd_request(floppy_queue);
         spin_unlock_irqrestore(&floppy_lock, flags);
         wake_up(&fdc_wait);
@@ -2303,7 +2303,7 @@ static void floppy_end_request(struct request *req, int error)
 
         /* current_count_sectors can be zero if transfer failed */
         if (error)
-                nr_sectors = req->current_nr_sectors;
+                nr_sectors = blk_rq_cur_sectors(req);
         if (__blk_end_request(req, error, nr_sectors << 9))
                 return;
 
@@ -2332,7 +2332,7 @@ static void request_done(int uptodate)
         if (uptodate) {
                 /* maintain values for invalidation on geometry
                  * change */
-                block = current_count_sectors + req->sector;
+                block = current_count_sectors + blk_rq_pos(req);
                 INFBOUND(DRS->maxblock, block);
                 if (block > _floppy->sect)
                         DRS->maxtrack = 1;
@@ -2346,10 +2346,10 @@ static void request_done(int uptodate)
                         /* record write error information */
                         DRWE->write_errors++;
                         if (DRWE->write_errors == 1) {
-                                DRWE->first_error_sector = req->sector;
+                                DRWE->first_error_sector = blk_rq_pos(req);
                                 DRWE->first_error_generation = DRS->generation;
                         }
-                        DRWE->last_error_sector = req->sector;
+                        DRWE->last_error_sector = blk_rq_pos(req);
                         DRWE->last_error_generation = DRS->generation;
                 }
                 spin_lock_irqsave(q->queue_lock, flags);
@@ -2503,24 +2503,23 @@ static void copy_buffer(int ssize, int max_sector, int max_sector_2)
 
         max_sector = transfer_size(ssize,
                                    min(max_sector, max_sector_2),
-                                   current_req->nr_sectors);
+                                   blk_rq_sectors(current_req));
 
         if (current_count_sectors <= 0 && CT(COMMAND) == FD_WRITE &&
-            buffer_max > fsector_t + current_req->nr_sectors)
+            buffer_max > fsector_t + blk_rq_sectors(current_req))
                 current_count_sectors = min_t(int, buffer_max - fsector_t,
-                                              current_req->nr_sectors);
+                                              blk_rq_sectors(current_req));
 
         remaining = current_count_sectors << 9;
 #ifdef FLOPPY_SANITY_CHECK
-        if ((remaining >> 9) > current_req->nr_sectors &&
-            CT(COMMAND) == FD_WRITE) {
+        if (remaining > blk_rq_bytes(current_req) && CT(COMMAND) == FD_WRITE) {
                 DPRINT("in copy buffer\n");
                 printk("current_count_sectors=%ld\n", current_count_sectors);
                 printk("remaining=%d\n", remaining >> 9);
-                printk("current_req->nr_sectors=%ld\n",
-                       current_req->nr_sectors);
+                printk("current_req->nr_sectors=%u\n",
+                       blk_rq_sectors(current_req));
                 printk("current_req->current_nr_sectors=%u\n",
-                       current_req->current_nr_sectors);
+                       blk_rq_cur_sectors(current_req));
                 printk("max_sector=%d\n", max_sector);
                 printk("ssize=%d\n", ssize);
         }
@@ -2530,7 +2529,7 @@ static void copy_buffer(int ssize, int max_sector, int max_sector_2)
 
         dma_buffer = floppy_track_buffer + ((fsector_t - buffer_min) << 9);
 
-        size = current_req->current_nr_sectors << 9;
+        size = blk_rq_cur_bytes(current_req);
 
         rq_for_each_segment(bv, current_req, iter) {
                 if (!remaining)
@@ -2648,10 +2647,10 @@ static int make_raw_rw_request(void)
 
         max_sector = _floppy->sect * _floppy->head;
 
-        TRACK = (int)current_req->sector / max_sector;
-        fsector_t = (int)current_req->sector % max_sector;
+        TRACK = (int)blk_rq_pos(current_req) / max_sector;
+        fsector_t = (int)blk_rq_pos(current_req) % max_sector;
         if (_floppy->track && TRACK >= _floppy->track) {
-                if (current_req->current_nr_sectors & 1) {
+                if (blk_rq_cur_sectors(current_req) & 1) {
                         current_count_sectors = 1;
                         return 1;
                 } else
@@ -2669,7 +2668,7 @@ static int make_raw_rw_request(void)
                 if (fsector_t >= max_sector) {
                         current_count_sectors =
                             min_t(int, _floppy->sect - fsector_t,
-                                  current_req->nr_sectors);
+                                  blk_rq_sectors(current_req));
                         return 1;
                 }
                 SIZECODE = 2;
@@ -2720,7 +2719,7 @@ static int make_raw_rw_request(void)
 
         in_sector_offset = (fsector_t % _floppy->sect) % ssize;
         aligned_sector_t = fsector_t - in_sector_offset;
-        max_size = current_req->nr_sectors;
+        max_size = blk_rq_sectors(current_req);
         if ((raw_cmd->track == buffer_track) &&
             (current_drive == buffer_drive) &&
             (fsector_t >= buffer_min) && (fsector_t < buffer_max)) {
@@ -2729,10 +2728,10 @@ static int make_raw_rw_request(void)
                         copy_buffer(1, max_sector, buffer_max);
                         return 1;
                 }
-        } else if (in_sector_offset || current_req->nr_sectors < ssize) {
+        } else if (in_sector_offset || blk_rq_sectors(current_req) < ssize) {
                 if (CT(COMMAND) == FD_WRITE) {
-                        if (fsector_t + current_req->nr_sectors > ssize &&
-                            fsector_t + current_req->nr_sectors < ssize + ssize)
+                        if (fsector_t + blk_rq_sectors(current_req) > ssize &&
+                            fsector_t + blk_rq_sectors(current_req) < ssize + ssize)
                                 max_size = ssize + ssize;
                         else
                                 max_size = ssize;
@@ -2776,7 +2775,7 @@ static int make_raw_rw_request(void)
                     (indirect * 2 > direct * 3 &&
                      *errors < DP->max_errors.read_track && ((!probing
                        || (DP->read_track & (1 << DRS->probed_format)))))) {
-                        max_size = current_req->nr_sectors;
+                        max_size = blk_rq_sectors(current_req);
                 } else {
                         raw_cmd->kernel_data = current_req->buffer;
                         raw_cmd->length = current_count_sectors << 9;
@@ -2801,7 +2800,7 @@ static int make_raw_rw_request(void)
             fsector_t > buffer_max ||
             fsector_t < buffer_min ||
             ((CT(COMMAND) == FD_READ ||
-              (!in_sector_offset && current_req->nr_sectors >= ssize)) &&
+              (!in_sector_offset && blk_rq_sectors(current_req) >= ssize)) &&
              max_sector > 2 * max_buffer_sectors + buffer_min &&
              max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)
             /* not enough space */
@@ -2879,8 +2878,8 @@ static int make_raw_rw_request(void)
                                 printk("write\n");
                         return 0;
                 }
-        } else if (raw_cmd->length > current_req->nr_sectors << 9 ||
-                   current_count_sectors > current_req->nr_sectors) {
+        } else if (raw_cmd->length > blk_rq_bytes(current_req) ||
+                   current_count_sectors > blk_rq_sectors(current_req)) {
                 DPRINT("buffer overrun in direct transfer\n");
                 return 0;
         } else if (raw_cmd->length < current_count_sectors << 9) {
@@ -2913,7 +2912,7 @@ static void redo_fd_request(void)
                         struct request *req;
 
                         spin_lock_irq(floppy_queue->queue_lock);
-                        req = elv_next_request(floppy_queue);
+                        req = blk_fetch_request(floppy_queue);
                         spin_unlock_irq(floppy_queue->queue_lock);
                         if (!req) {
                                 do_floppy = NULL;
@@ -2990,8 +2989,9 @@ static void do_fd_request(struct request_queue * q)
         if (usage_count == 0) {
                 printk("warning: usage count=0, current_req=%p exiting\n",
                        current_req);
-                printk("sect=%ld type=%x flags=%x\n", (long)current_req->sector,
-                       current_req->cmd_type, current_req->cmd_flags);
+                printk("sect=%ld type=%x flags=%x\n",
+                       (long)blk_rq_pos(current_req), current_req->cmd_type,
+                       current_req->cmd_flags);
                 return;
         }
         if (test_bit(0, &fdc_busy)) {
@@ -4148,6 +4148,24 @@ static void floppy_device_release(struct device *dev)
 {
 }
 
+static int floppy_resume(struct platform_device *dev)
+{
+        int fdc;
+
+        for (fdc = 0; fdc < N_FDC; fdc++)
+                if (FDCS->address != -1)
+                        user_reset_fdc(-1, FD_RESET_ALWAYS, 0);
+
+        return 0;
+}
+
+static struct platform_driver floppy_driver = {
+        .resume = floppy_resume,
+        .driver = {
+                .name = "floppy",
+        },
+};
+
 static struct platform_device floppy_device[N_DRIVE];
 
 static struct kobject *floppy_find(dev_t dev, int *part, void *data)
@@ -4196,10 +4214,14 @@ static int __init floppy_init(void)
         if (err)
                 goto out_put_disk;
 
+        err = platform_driver_register(&floppy_driver);
+        if (err)
+                goto out_unreg_blkdev;
+
         floppy_queue = blk_init_queue(do_fd_request, &floppy_lock);
         if (!floppy_queue) {
                 err = -ENOMEM;
-                goto out_unreg_blkdev;
+                goto out_unreg_driver;
         }
         blk_queue_max_sectors(floppy_queue, 64);
 
@@ -4346,6 +4368,8 @@ out_flush_work:
 out_unreg_region:
         blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
         blk_cleanup_queue(floppy_queue);
+out_unreg_driver:
+        platform_driver_unregister(&floppy_driver);
 out_unreg_blkdev:
         unregister_blkdev(FLOPPY_MAJOR, "fd");
 out_put_disk:
@@ -4566,6 +4590,7 @@ static void __exit floppy_module_exit(void)
 
         blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256);
         unregister_blkdev(FLOPPY_MAJOR, "fd");
+        platform_driver_unregister(&floppy_driver);
 
         for (drive = 0; drive < N_DRIVE; drive++) {
                 del_timer_sync(&motor_off_timer[drive]);
diff --git a/drivers/block/hd.c b/drivers/block/hd.c
index baaa9e486e50..f65b3f369eb0 100644
--- a/drivers/block/hd.c
+++ b/drivers/block/hd.c
@@ -98,10 +98,9 @@
 
 static DEFINE_SPINLOCK(hd_lock);
 static struct request_queue *hd_queue;
+static struct request *hd_req;
 
 #define MAJOR_NR HD_MAJOR
-#define QUEUE (hd_queue)
-#define CURRENT elv_next_request(hd_queue)
 
 #define TIMEOUT_VALUE   (6*HZ)
 #define HD_DELAY        0
@@ -195,11 +194,24 @@ static void __init hd_setup(char *str, int *ints)
         NR_HD = hdind+1;
 }
 
+static bool hd_end_request(int err, unsigned int bytes)
+{
+        if (__blk_end_request(hd_req, err, bytes))
+                return true;
+        hd_req = NULL;
+        return false;
+}
+
+static bool hd_end_request_cur(int err)
+{
+        return hd_end_request(err, blk_rq_cur_bytes(hd_req));
+}
+
 static void dump_status(const char *msg, unsigned int stat)
 {
         char *name = "hd?";
-        if (CURRENT)
-                name = CURRENT->rq_disk->disk_name;
+        if (hd_req)
+                name = hd_req->rq_disk->disk_name;
 
 #ifdef VERBOSE_ERRORS
         printk("%s: %s: status=0x%02x { ", name, msg, stat & 0xff);
@@ -227,8 +239,8 @@ static void dump_status(const char *msg, unsigned int stat)
                 if (hd_error & (BBD_ERR|ECC_ERR|ID_ERR|MARK_ERR)) {
                         printk(", CHS=%d/%d/%d", (inb(HD_HCYL)<<8) + inb(HD_LCYL),
                                 inb(HD_CURRENT) & 0xf, inb(HD_SECTOR));
-                        if (CURRENT)
-                                printk(", sector=%ld", CURRENT->sector);
+                        if (hd_req)
+                                printk(", sector=%ld", blk_rq_pos(hd_req));
                 }
                 printk("\n");
         }
@@ -406,11 +418,12 @@ static void unexpected_hd_interrupt(void)
  */
 static void bad_rw_intr(void)
 {
-        struct request *req = CURRENT;
+        struct request *req = hd_req;
+
         if (req != NULL) {
                 struct hd_i_struct *disk = req->rq_disk->private_data;
                 if (++req->errors >= MAX_ERRORS || (hd_error & BBD_ERR)) {
-                        end_request(req, 0);
+                        hd_end_request_cur(-EIO);
                         disk->special_op = disk->recalibrate = 1;
                 } else if (req->errors % RESET_FREQ == 0)
                         reset = 1;
@@ -452,37 +465,30 @@ static void read_intr(void)
         bad_rw_intr();
         hd_request();
         return;
+
 ok_to_read:
-        req = CURRENT;
+        req = hd_req;
         insw(HD_DATA, req->buffer, 256);
-        req->sector++;
-        req->buffer += 512;
-        req->errors = 0;
-        i = --req->nr_sectors;
-        --req->current_nr_sectors;
 #ifdef DEBUG
-        printk("%s: read: sector %ld, remaining = %ld, buffer=%p\n",
-                req->rq_disk->disk_name, req->sector, req->nr_sectors,
-                req->buffer+512);
+        printk("%s: read: sector %ld, remaining = %u, buffer=%p\n",
+               req->rq_disk->disk_name, blk_rq_pos(req) + 1,
+               blk_rq_sectors(req) - 1, req->buffer+512);
 #endif
-        if (req->current_nr_sectors <= 0)
-                end_request(req, 1);
-        if (i > 0) {
+        if (hd_end_request(0, 512)) {
                 SET_HANDLER(&read_intr);
                 return;
         }
+
         (void) inb_p(HD_STATUS);
 #if (HD_DELAY > 0)
         last_req = read_timer();
 #endif
-        if (elv_next_request(QUEUE))
-                hd_request();
-        return;
+        hd_request();
 }
 
 static void write_intr(void)
 {
-        struct request *req = CURRENT;
+        struct request *req = hd_req;
         int i;
         int retries = 100000;
 
@@ -492,30 +498,25 @@ static void write_intr(void)
                         continue;
                 if (!OK_STATUS(i))
                         break;
-                if ((req->nr_sectors <= 1) || (i & DRQ_STAT))
+                if ((blk_rq_sectors(req) <= 1) || (i & DRQ_STAT))
                         goto ok_to_write;
         } while (--retries > 0);
         dump_status("write_intr", i);
         bad_rw_intr();
         hd_request();
         return;
+
 ok_to_write:
-        req->sector++;
-        i = --req->nr_sectors;
-        --req->current_nr_sectors;
-        req->buffer += 512;
-        if (!i || (req->bio && req->current_nr_sectors <= 0))
-                end_request(req, 1);
-        if (i > 0) {
+        if (hd_end_request(0, 512)) {
                 SET_HANDLER(&write_intr);
                 outsw(HD_DATA, req->buffer, 256);
-        } else {
+                return;
+        }
+
 #if (HD_DELAY > 0)
-                last_req = read_timer();
+        last_req = read_timer();
 #endif
-                hd_request();
-        }
-        return;
+        hd_request();
 }
 
 static void recal_intr(void)
@@ -537,18 +538,18 @@ static void hd_times_out(unsigned long dummy)
 
         do_hd = NULL;
 
-        if (!CURRENT)
+        if (!hd_req)
                 return;
 
         spin_lock_irq(hd_queue->queue_lock);
         reset = 1;
-        name = CURRENT->rq_disk->disk_name;
+        name = hd_req->rq_disk->disk_name;
         printk("%s: timeout\n", name);
-        if (++CURRENT->errors >= MAX_ERRORS) {
+        if (++hd_req->errors >= MAX_ERRORS) {
 #ifdef DEBUG
                 printk("%s: too many errors\n", name);
 #endif
-                end_request(CURRENT, 0);
+                hd_end_request_cur(-EIO);
         }
         hd_request();
         spin_unlock_irq(hd_queue->queue_lock);
@@ -563,7 +564,7 @@ static int do_special_op(struct hd_i_struct *disk, struct request *req)
         }
         if (disk->head > 16) {
                 printk("%s: cannot handle device with more than 16 heads - giving up\n", req->rq_disk->disk_name);
-                end_request(req, 0);
+                hd_end_request_cur(-EIO);
         }
         disk->special_op = 0;
         return 1;
@@ -590,24 +591,27 @@ static void hd_request(void)
 repeat:
         del_timer(&device_timer);
 
-        req = CURRENT;
-        if (!req) {
-                do_hd = NULL;
-                return;
+        if (!hd_req) {
+                hd_req = blk_fetch_request(hd_queue);
+                if (!hd_req) {
+                        do_hd = NULL;
+                        return;
+                }
         }
+        req = hd_req;
 
         if (reset) {
                 reset_hd();
                 return;
         }
         disk = req->rq_disk->private_data;
-        block = req->sector;
-        nsect = req->nr_sectors;
+        block = blk_rq_pos(req);
+        nsect = blk_rq_sectors(req);
         if (block >= get_capacity(req->rq_disk) ||
             ((block+nsect) > get_capacity(req->rq_disk))) {
                 printk("%s: bad access: block=%d, count=%d\n",
                         req->rq_disk->disk_name, block, nsect);
-                end_request(req, 0);
+                hd_end_request_cur(-EIO);
                 goto repeat;
         }
 
@@ -647,7 +651,7 @@ repeat:
                         break;
                 default:
                         printk("unknown hd-command\n");
-                        end_request(req, 0);
+                        hd_end_request_cur(-EIO);
                         break;
                 }
         }
@@ -720,7 +724,7 @@ static int __init hd_init(void)
         blk_queue_max_sectors(hd_queue, 255);
         init_timer(&device_timer);
         device_timer.function = hd_times_out;
-        blk_queue_hardsect_size(hd_queue, 512);
+        blk_queue_logical_block_size(hd_queue, 512);
 
         if (!NR_HD) {
                 /*
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index ddae80825899..801f4ab83302 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -511,11 +511,7 @@ out:
  */
 static void loop_add_bio(struct loop_device *lo, struct bio *bio)
 {
-        if (lo->lo_biotail) {
-                lo->lo_biotail->bi_next = bio;
-                lo->lo_biotail = bio;
-        } else
-                lo->lo_bio = lo->lo_biotail = bio;
+        bio_list_add(&lo->lo_bio_list, bio);
 }
 
 /*
@@ -523,16 +519,7 @@ static void loop_add_bio(struct loop_device *lo, struct bio *bio)
  */
 static struct bio *loop_get_bio(struct loop_device *lo)
 {
-        struct bio *bio;
-
-        if ((bio = lo->lo_bio)) {
-                if (bio == lo->lo_biotail)
-                        lo->lo_biotail = NULL;
-                lo->lo_bio = bio->bi_next;
-                bio->bi_next = NULL;
-        }
-
-        return bio;
+        return bio_list_pop(&lo->lo_bio_list);
 }
 
 static int loop_make_request(struct request_queue *q, struct bio *old_bio)
@@ -609,12 +596,13 @@ static int loop_thread(void *data)
 
         set_user_nice(current, -20);
 
-        while (!kthread_should_stop() || lo->lo_bio) {
+        while (!kthread_should_stop() || !bio_list_empty(&lo->lo_bio_list)) {
 
                 wait_event_interruptible(lo->lo_event,
-                                lo->lo_bio || kthread_should_stop());
+                                !bio_list_empty(&lo->lo_bio_list) ||
+                                kthread_should_stop());
 
-                if (!lo->lo_bio)
+                if (bio_list_empty(&lo->lo_bio_list))
                         continue;
                 spin_lock_irq(&lo->lo_lock);
                 bio = loop_get_bio(lo);
@@ -721,10 +709,6 @@ static int loop_change_fd(struct loop_device *lo, struct block_device *bdev,
         if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))
                 goto out_putf;
 
-        /* new backing store needs to support loop (eg splice_read) */
-        if (!inode->i_fop->splice_read)
-                goto out_putf;
-
         /* size of the new backing store needs to be the same */
         if (get_loop_size(lo, file) != get_loop_size(lo, old_file))
                 goto out_putf;
@@ -800,12 +784,7 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
         error = -EINVAL;
         if (S_ISREG(inode->i_mode) || S_ISBLK(inode->i_mode)) {
                 const struct address_space_operations *aops = mapping->a_ops;
-                /*
-                 * If we can't read - sorry. If we only can't write - well,
-                 * it's going to be read-only.
-                 */
-                if (!file->f_op->splice_read)
-                        goto out_putf;
+
                 if (aops->write_begin)
                         lo_flags |= LO_FLAGS_USE_AOPS;
                 if (!(lo_flags & LO_FLAGS_USE_AOPS) && !file->f_op->write)
@@ -841,7 +820,7 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode,
         lo->old_gfp_mask = mapping_gfp_mask(mapping);
         mapping_set_gfp_mask(mapping, lo->old_gfp_mask & ~(__GFP_IO|__GFP_FS));
 
-        lo->lo_bio = lo->lo_biotail = NULL;
+        bio_list_init(&lo->lo_bio_list);
 
         /*
          * set queue make_request_fn, and add limits based on lower level
diff --git a/drivers/block/mg_disk.c b/drivers/block/mg_disk.c
index f3898353d0a8..60de5a01e71e 100644
--- a/drivers/block/mg_disk.c
+++ b/drivers/block/mg_disk.c
@@ -17,71 +17,220 @@
 #include <linux/fs.h>
 #include <linux/blkdev.h>
 #include <linux/hdreg.h>
-#include <linux/libata.h>
+#include <linux/ata.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/platform_device.h>
 #include <linux/gpio.h>
-#include <linux/mg_disk.h>
 
 #define MG_RES_SEC (CONFIG_MG_DISK_RES << 1)
 
+/* name for block device */
+#define MG_DISK_NAME "mgd"
+/* name for platform device */
+#define MG_DEV_NAME "mg_disk"
+
+#define MG_DISK_MAJ 0
+#define MG_DISK_MAX_PART 16
+#define MG_SECTOR_SIZE 512
+#define MG_MAX_SECTS 256
+
+/* Register offsets */
+#define MG_BUFF_OFFSET                  0x8000
+#define MG_STORAGE_BUFFER_SIZE          0x200
+#define MG_REG_OFFSET                   0xC000
+#define MG_REG_FEATURE                  (MG_REG_OFFSET + 2)     /* write case */
+#define MG_REG_ERROR                    (MG_REG_OFFSET + 2)     /* read case */
+#define MG_REG_SECT_CNT                 (MG_REG_OFFSET + 4)
+#define MG_REG_SECT_NUM                 (MG_REG_OFFSET + 6)
+#define MG_REG_CYL_LOW                  (MG_REG_OFFSET + 8)
+#define MG_REG_CYL_HIGH                 (MG_REG_OFFSET + 0xA)
+#define MG_REG_DRV_HEAD                 (MG_REG_OFFSET + 0xC)
+#define MG_REG_COMMAND                  (MG_REG_OFFSET + 0xE)   /* write case */
+#define MG_REG_STATUS                   (MG_REG_OFFSET + 0xE)   /* read  case */
+#define MG_REG_DRV_CTRL                 (MG_REG_OFFSET + 0x10)
+#define MG_REG_BURST_CTRL               (MG_REG_OFFSET + 0x12)
+
+/* handy status */
+#define MG_STAT_READY   (ATA_DRDY | ATA_DSC)
+#define MG_READY_OK(s)  (((s) & (MG_STAT_READY | (ATA_BUSY | ATA_DF | \
+                                 ATA_ERR))) == MG_STAT_READY)
+
+/* error code for others */
+#define MG_ERR_NONE             0
+#define MG_ERR_TIMEOUT          0x100
+#define MG_ERR_INIT_STAT        0x101
+#define MG_ERR_TRANSLATION      0x102
+#define MG_ERR_CTRL_RST         0x103
+#define MG_ERR_INV_STAT         0x104
+#define MG_ERR_RSTOUT           0x105
+
+#define MG_MAX_ERRORS   6       /* Max read/write errors */
+
+/* command */
+#define MG_CMD_RD 0x20
+#define MG_CMD_WR 0x30
+#define MG_CMD_SLEEP 0x99
+#define MG_CMD_WAKEUP 0xC3
+#define MG_CMD_ID 0xEC
+#define MG_CMD_WR_CONF 0x3C
+#define MG_CMD_RD_CONF 0x40
+
+/* operation mode */
+#define MG_OP_CASCADE (1 << 0)
+#define MG_OP_CASCADE_SYNC_RD (1 << 1)
+#define MG_OP_CASCADE_SYNC_WR (1 << 2)
+#define MG_OP_INTERLEAVE (1 << 3)
+
+/* synchronous */
+#define MG_BURST_LAT_4 (3 << 4)
+#define MG_BURST_LAT_5 (4 << 4)
+#define MG_BURST_LAT_6 (5 << 4)
+#define MG_BURST_LAT_7 (6 << 4)
+#define MG_BURST_LAT_8 (7 << 4)
+#define MG_BURST_LEN_4 (1 << 1)
+#define MG_BURST_LEN_8 (2 << 1)
+#define MG_BURST_LEN_16 (3 << 1)
+#define MG_BURST_LEN_32 (4 << 1)
+#define MG_BURST_LEN_CONT (0 << 1)
+
+/* timeout value (unit: ms) */
+#define MG_TMAX_CONF_TO_CMD     1
+#define MG_TMAX_WAIT_RD_DRQ     10
+#define MG_TMAX_WAIT_WR_DRQ     500
+#define MG_TMAX_RST_TO_BUSY     10
+#define MG_TMAX_HDRST_TO_RDY    500
+#define MG_TMAX_SWRST_TO_RDY    500
+#define MG_TMAX_RSTOUT          3000
+
+/* device attribution */
+/* use mflash as boot device */
+#define MG_BOOT_DEV             (1 << 0)
+/* use mflash as storage device */
+#define MG_STORAGE_DEV          (1 << 1)
+/* same as MG_STORAGE_DEV, but bootloader already done reset sequence */
+#define MG_STORAGE_DEV_SKIP_RST (1 << 2)
+
+#define MG_DEV_MASK (MG_BOOT_DEV | MG_STORAGE_DEV | MG_STORAGE_DEV_SKIP_RST)
+
+/* names of GPIO resource */
+#define MG_RST_PIN      "mg_rst"
+/* except MG_BOOT_DEV, reset-out pin should be assigned */
+#define MG_RSTOUT_PIN   "mg_rstout"
+
+/* private driver data */
+struct mg_drv_data {
+        /* disk resource */
+        u32 use_polling;
+
+        /* device attribution */
+        u32 dev_attr;
+
+        /* internally used */
+        struct mg_host *host;
+};
+
+/* main structure for mflash driver */
+struct mg_host {
+        struct device *dev;
+
+        struct request_queue *breq;
+        struct request *req;
+        spinlock_t lock;
+        struct gendisk *gd;
+
+        struct timer_list timer;
+        void (*mg_do_intr) (struct mg_host *);
+
+        u16 id[ATA_ID_WORDS];
+
+        u16 cyls;
+        u16 heads;
+        u16 sectors;
+        u32 n_sectors;
+        u32 nres_sectors;
+
+        void __iomem *dev_base;
+        unsigned int irq;
+        unsigned int rst;
+        unsigned int rstout;
+
+        u32 major;
+        u32 error;
+};
+
+/*
+ * Debugging macro and defines
+ */
+#undef DO_MG_DEBUG
+#ifdef DO_MG_DEBUG
+#  define MG_DBG(fmt, args...) \
+        printk(KERN_DEBUG "%s:%d "fmt, __func__, __LINE__, ##args)
+#else /* CONFIG_MG_DEBUG */
+#  define MG_DBG(fmt, args...) do { } while (0)
+#endif /* CONFIG_MG_DEBUG */
+
 static void mg_request(struct request_queue *);
 
+static bool mg_end_request(struct mg_host *host, int err, unsigned int nr_bytes)
+{
+        if (__blk_end_request(host->req, err, nr_bytes))
+                return true;
+
+        host->req = NULL;
+        return false;
+}
+
+static bool mg_end_request_cur(struct mg_host *host, int err)
+{
+        return mg_end_request(host, err, blk_rq_cur_bytes(host->req));
+}
+
 static void mg_dump_status(const char *msg, unsigned int stat,
                 struct mg_host *host)
 {
         char *name = MG_DISK_NAME;
-        struct request *req;
 
-        if (host->breq) {
-                req = elv_next_request(host->breq);
-                if (req)
-                        name = req->rq_disk->disk_name;
-        }
+        if (host->req)
+                name = host->req->rq_disk->disk_name;
 
         printk(KERN_ERR "%s: %s: status=0x%02x { ", name, msg, stat & 0xff);
-        if (stat & MG_REG_STATUS_BIT_BUSY)
+        if (stat & ATA_BUSY)
                 printk("Busy ");
-        if (stat & MG_REG_STATUS_BIT_READY)
+        if (stat & ATA_DRDY)
                 printk("DriveReady ");
-        if (stat & MG_REG_STATUS_BIT_WRITE_FAULT)
+        if (stat & ATA_DF)
                 printk("WriteFault ");
-        if (stat & MG_REG_STATUS_BIT_SEEK_DONE)
+        if (stat & ATA_DSC)
                 printk("SeekComplete ");
-        if (stat & MG_REG_STATUS_BIT_DATA_REQ)
+        if (stat & ATA_DRQ)
                 printk("DataRequest ");
-        if (stat & MG_REG_STATUS_BIT_CORRECTED_ERROR)
+        if (stat & ATA_CORR)
                 printk("CorrectedError ");
-        if (stat & MG_REG_STATUS_BIT_ERROR)
+        if (stat & ATA_ERR)
                 printk("Error ");
         printk("}\n");
-        if ((stat & MG_REG_STATUS_BIT_ERROR) == 0) {
+        if ((stat & ATA_ERR) == 0) {
                 host->error = 0;
         } else {
                 host->error = inb((unsigned long)host->dev_base + MG_REG_ERROR);
                 printk(KERN_ERR "%s: %s: error=0x%02x { ", name, msg,
                                 host->error & 0xff);
-                if (host->error & MG_REG_ERR_BBK)
+                if (host->error & ATA_BBK)
                         printk("BadSector ");
-                if (host->error & MG_REG_ERR_UNC)
+                if (host->error & ATA_UNC)
                         printk("UncorrectableError ");
-                if (host->error & MG_REG_ERR_IDNF)
+                if (host->error & ATA_IDNF)
                         printk("SectorIdNotFound ");
-                if (host->error & MG_REG_ERR_ABRT)
+                if (host->error & ATA_ABORTED)
                         printk("DriveStatusError ");
-                if (host->error & MG_REG_ERR_AMNF)
+                if (host->error & ATA_AMNF)
                         printk("AddrMarkNotFound ");
                 printk("}");
-                if (host->error &
-                                (MG_REG_ERR_BBK | MG_REG_ERR_UNC |
-                                 MG_REG_ERR_IDNF | MG_REG_ERR_AMNF)) {
-                        if (host->breq) {
-                                req = elv_next_request(host->breq);
-                                if (req)
-                                        printk(", sector=%u", (u32)req->sector);
-                        }
-
+                if (host->error & (ATA_BBK | ATA_UNC | ATA_IDNF | ATA_AMNF)) {
+                        if (host->req)
+                                printk(", sector=%u",
+                                       (unsigned int)blk_rq_pos(host->req));
                 }
                 printk("\n");
         }
@@ -100,12 +249,12 @@ static unsigned int mg_wait(struct mg_host *host, u32 expect, u32 msec)
 
         do {
                 cur_jiffies = jiffies;
-                if (status & MG_REG_STATUS_BIT_BUSY) {
-                        if (expect == MG_REG_STATUS_BIT_BUSY)
+                if (status & ATA_BUSY) {
+                        if (expect == ATA_BUSY)
                                 break;
                 } else {
                         /* Check the error condition! */
-                        if (status & MG_REG_STATUS_BIT_ERROR) {
+                        if (status & ATA_ERR) {
                                 mg_dump_status("mg_wait", status, host);
                                 break;
                         }
@@ -114,8 +263,8 @@ static unsigned int mg_wait(struct mg_host *host, u32 expect, u32 msec)
                                 if (MG_READY_OK(status))
                                         break;
 
-                        if (expect == MG_REG_STATUS_BIT_DATA_REQ)
-                                if (status & MG_REG_STATUS_BIT_DATA_REQ)
+                        if (expect == ATA_DRQ)
+                                if (status & ATA_DRQ)
                                         break;
                 }
                 if (!msec) {
@@ -173,6 +322,42 @@ static irqreturn_t mg_irq(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
+/* local copy of ata_id_string() */
+static void mg_id_string(const u16 *id, unsigned char *s,
+                         unsigned int ofs, unsigned int len)
+{
+        unsigned int c;
+
+        BUG_ON(len & 1);
+
+        while (len > 0) {
+                c = id[ofs] >> 8;
+                *s = c;
+                s++;
+
+                c = id[ofs] & 0xff;
+                *s = c;
+                s++;
+
+                ofs++;
+                len -= 2;
+        }
+}
+
+/* local copy of ata_id_c_string() */
+static void mg_id_c_string(const u16 *id, unsigned char *s,
+                           unsigned int ofs, unsigned int len)
+{
+        unsigned char *p;
+
+        mg_id_string(id, s, ofs, len - 1);
+
+        p = s + strnlen(s, len - 1);
+        while (p > s && p[-1] == ' ')
+                p--;
+        *p = '\0';
+}
+
 static int mg_get_disk_id(struct mg_host *host)
 {
         u32 i;
@@ -184,12 +369,10 @@ static int mg_get_disk_id(struct mg_host *host)
         char serial[ATA_ID_SERNO_LEN + 1];
 
         if (!prv_data->use_polling)
-                outb(MG_REG_CTRL_INTR_DISABLE,
-                                (unsigned long)host->dev_base +
-                                MG_REG_DRV_CTRL);
+                outb(ATA_NIEN, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
 
         outb(MG_CMD_ID, (unsigned long)host->dev_base + MG_REG_COMMAND);
-        err = mg_wait(host, MG_REG_STATUS_BIT_DATA_REQ, MG_TMAX_WAIT_RD_DRQ);
+        err = mg_wait(host, ATA_DRQ, MG_TMAX_WAIT_RD_DRQ);
         if (err)
                 return err;
 
@@ -219,9 +402,9 @@ static int mg_get_disk_id(struct mg_host *host)
                 host->n_sectors -= host->nres_sectors;
         }
 
-        ata_id_c_string(id, fwrev, ATA_ID_FW_REV, sizeof(fwrev));
-        ata_id_c_string(id, model, ATA_ID_PROD, sizeof(model));
-        ata_id_c_string(id, serial, ATA_ID_SERNO, sizeof(serial));
+        mg_id_c_string(id, fwrev, ATA_ID_FW_REV, sizeof(fwrev));
+        mg_id_c_string(id, model, ATA_ID_PROD, sizeof(model));
+        mg_id_c_string(id, serial, ATA_ID_SERNO, sizeof(serial));
         printk(KERN_INFO "mg_disk: model: %s\n", model);
         printk(KERN_INFO "mg_disk: firm: %.8s\n", fwrev);
         printk(KERN_INFO "mg_disk: serial: %s\n", serial);
@@ -229,8 +412,7 @@ static int mg_get_disk_id(struct mg_host *host)
                         host->n_sectors, host->nres_sectors);
 
         if (!prv_data->use_polling)
-                outb(MG_REG_CTRL_INTR_ENABLE, (unsigned long)host->dev_base +
-                                MG_REG_DRV_CTRL);
+                outb(0, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
 
         return err;
 }
@@ -244,7 +426,7 @@ static int mg_disk_init(struct mg_host *host)
 
         /* hdd rst low */
         gpio_set_value(host->rst, 0);
-        err = mg_wait(host, MG_REG_STATUS_BIT_BUSY, MG_TMAX_RST_TO_BUSY);
+        err = mg_wait(host, ATA_BUSY, MG_TMAX_RST_TO_BUSY);
         if (err)
                 return err;
 
@@ -255,17 +437,14 @@ static int mg_disk_init(struct mg_host *host)
                 return err;
 
         /* soft reset on */
-        outb(MG_REG_CTRL_RESET |
-                        (prv_data->use_polling ? MG_REG_CTRL_INTR_DISABLE :
-                         MG_REG_CTRL_INTR_ENABLE),
+        outb(ATA_SRST | (prv_data->use_polling ? ATA_NIEN : 0),
                         (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
-        err = mg_wait(host, MG_REG_STATUS_BIT_BUSY, MG_TMAX_RST_TO_BUSY);
+        err = mg_wait(host, ATA_BUSY, MG_TMAX_RST_TO_BUSY);
         if (err)
                 return err;
 
         /* soft reset off */
-        outb(prv_data->use_polling ? MG_REG_CTRL_INTR_DISABLE :
-                        MG_REG_CTRL_INTR_ENABLE,
+        outb(prv_data->use_polling ? ATA_NIEN : 0,
                         (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
         err = mg_wait(host, MG_STAT_READY, MG_TMAX_SWRST_TO_RDY);
         if (err)
@@ -281,11 +460,10 @@ static int mg_disk_init(struct mg_host *host)
 
 static void mg_bad_rw_intr(struct mg_host *host)
 {
-        struct request *req = elv_next_request(host->breq);
-        if (req != NULL)
-                if (++req->errors >= MG_MAX_ERRORS ||
-                                host->error == MG_ERR_TIMEOUT)
-                        end_request(req, 0);
+        if (host->req)
+                if (++host->req->errors >= MG_MAX_ERRORS ||
+                    host->error == MG_ERR_TIMEOUT)
+                        mg_end_request_cur(host, -EIO);
 }
 
 static unsigned int mg_out(struct mg_host *host,
@@ -311,7 +489,7 @@ static unsigned int mg_out(struct mg_host *host,
                         MG_REG_CYL_LOW);
         outb((u8)(sect_num >> 16), (unsigned long)host->dev_base +
                         MG_REG_CYL_HIGH);
-        outb((u8)((sect_num >> 24) | MG_REG_HEAD_LBA_MODE),
+        outb((u8)((sect_num >> 24) | ATA_LBA | ATA_DEVICE_OBS),
                         (unsigned long)host->dev_base + MG_REG_DRV_HEAD);
         outb(cmd, (unsigned long)host->dev_base + MG_REG_COMMAND);
         return MG_ERR_NONE;
@@ -319,105 +497,77 @@ static unsigned int mg_out(struct mg_host *host,
 
 static void mg_read(struct request *req)
 {
-        u32 remains, j;
+        u32 j;
         struct mg_host *host = req->rq_disk->private_data;
 
-        remains = req->nr_sectors;
-
-        if (mg_out(host, req->sector, req->nr_sectors, MG_CMD_RD, NULL) !=
-                        MG_ERR_NONE)
+        if (mg_out(host, blk_rq_pos(req), blk_rq_sectors(req),
+                   MG_CMD_RD, NULL) != MG_ERR_NONE)
                 mg_bad_rw_intr(host);
 
         MG_DBG("requested %d sects (from %ld), buffer=0x%p\n",
-                        remains, req->sector, req->buffer);
+               blk_rq_sectors(req), blk_rq_pos(req), req->buffer);
+
+        do {
+                u16 *buff = (u16 *)req->buffer;
 
-        while (remains) {
-                if (mg_wait(host, MG_REG_STATUS_BIT_DATA_REQ,
-                                        MG_TMAX_WAIT_RD_DRQ) != MG_ERR_NONE) {
+                if (mg_wait(host, ATA_DRQ,
+                            MG_TMAX_WAIT_RD_DRQ) != MG_ERR_NONE) {
                         mg_bad_rw_intr(host);
                         return;
                 }
-                for (j = 0; j < MG_SECTOR_SIZE >> 1; j++) {
-                        *(u16 *)req->buffer =
-                                inw((unsigned long)host->dev_base +
-                                                MG_BUFF_OFFSET + (j << 1));
-                        req->buffer += 2;
-                }
-
-                req->sector++;
-                req->errors = 0;
-                remains = --req->nr_sectors;
-                --req->current_nr_sectors;
-
-                if (req->current_nr_sectors <= 0) {
-                        MG_DBG("remain : %d sects\n", remains);
-                        end_request(req, 1);
-                        if (remains > 0)
-                                req = elv_next_request(host->breq);
-                }
+                for (j = 0; j < MG_SECTOR_SIZE >> 1; j++)
+                        *buff++ = inw((unsigned long)host->dev_base +
+                                      MG_BUFF_OFFSET + (j << 1));
 
                 outb(MG_CMD_RD_CONF, (unsigned long)host->dev_base +
                                 MG_REG_COMMAND);
-        }
+        } while (mg_end_request(host, 0, MG_SECTOR_SIZE));
 }
 
 static void mg_write(struct request *req)
 {
-        u32 remains, j;
+        u32 j;
         struct mg_host *host = req->rq_disk->private_data;
 
-        remains = req->nr_sectors;
-
-        if (mg_out(host, req->sector, req->nr_sectors, MG_CMD_WR, NULL) !=
-                        MG_ERR_NONE) {
+        if (mg_out(host, blk_rq_pos(req), blk_rq_sectors(req),
+                   MG_CMD_WR, NULL) != MG_ERR_NONE) {
                 mg_bad_rw_intr(host);
                 return;
         }
 
-
         MG_DBG("requested %d sects (from %ld), buffer=0x%p\n",
-                        remains, req->sector, req->buffer);
-        while (remains) {
-                if (mg_wait(host, MG_REG_STATUS_BIT_DATA_REQ,
-                                        MG_TMAX_WAIT_WR_DRQ) != MG_ERR_NONE) {
+               blk_rq_sectors(req), blk_rq_pos(req), req->buffer);
+
+        do {
+                u16 *buff = (u16 *)req->buffer;
+
+        if (mg_wait(host, ATA_DRQ, MG_TMAX_WAIT_WR_DRQ) != MG_ERR_NONE) {
                         mg_bad_rw_intr(host);
                         return;
                 }
-                for (j = 0; j < MG_SECTOR_SIZE >> 1; j++) {
-                        outw(*(u16 *)req->buffer,
-                                        (unsigned long)host->dev_base +
-                                        MG_BUFF_OFFSET + (j << 1));
-                        req->buffer += 2;
-                }
-                req->sector++;
-                remains = --req->nr_sectors;
-                --req->current_nr_sectors;
-
-                if (req->current_nr_sectors <= 0) {
-                        MG_DBG("remain : %d sects\n", remains);
-                        end_request(req, 1);
-                        if (remains > 0)
-                                req = elv_next_request(host->breq);
-                }
+                for (j = 0; j < MG_SECTOR_SIZE >> 1; j++)
+                        outw(*buff++, (unsigned long)host->dev_base +
+                                      MG_BUFF_OFFSET + (j << 1));
 
                 outb(MG_CMD_WR_CONF, (unsigned long)host->dev_base +
                                 MG_REG_COMMAND);
-        }
+        } while (mg_end_request(host, 0, MG_SECTOR_SIZE));
 }
 
 static void mg_read_intr(struct mg_host *host)
 {
+        struct request *req = host->req;
         u32 i;
-        struct request *req;
+        u16 *buff;
 
         /* check status */
         do {
                 i = inb((unsigned long)host->dev_base + MG_REG_STATUS);
-                if (i & MG_REG_STATUS_BIT_BUSY)
+                if (i & ATA_BUSY)
                         break;
                 if (!MG_READY_OK(i))
                         break;
-                if (i & MG_REG_STATUS_BIT_DATA_REQ)
+                if (i & ATA_DRQ)
                         goto ok_to_read;
         } while (0);
         mg_dump_status("mg_read_intr", i, host);
@@ -427,60 +577,42 @@ static void mg_read_intr(struct mg_host *host)
 
 ok_to_read:
         /* get current segment of request */
-        req = elv_next_request(host->breq);
+        buff = (u16 *)req->buffer;
 
         /* read 1 sector */
-        for (i = 0; i < MG_SECTOR_SIZE >> 1; i++) {
-                *(u16 *)req->buffer =
-                        inw((unsigned long)host->dev_base + MG_BUFF_OFFSET +
-                                        (i << 1));
-                req->buffer += 2;
-        }
+        for (i = 0; i < MG_SECTOR_SIZE >> 1; i++)
+                *buff++ = inw((unsigned long)host->dev_base + MG_BUFF_OFFSET +
+                              (i << 1));
 
-        /* manipulate request */
         MG_DBG("sector %ld, remaining=%ld, buffer=0x%p\n",
-                        req->sector, req->nr_sectors - 1, req->buffer);
-
-        req->sector++;
-        req->errors = 0;
-        i = --req->nr_sectors;
-        --req->current_nr_sectors;
-
-        /* let know if current segment done */
-        if (req->current_nr_sectors <= 0)
-                end_request(req, 1);
-
-        /* set handler if read remains */
-        if (i > 0) {
-                host->mg_do_intr = mg_read_intr;
-                mod_timer(&host->timer, jiffies + 3 * HZ);
-        }
+               blk_rq_pos(req), blk_rq_sectors(req) - 1, req->buffer);
 
         /* send read confirm */
         outb(MG_CMD_RD_CONF, (unsigned long)host->dev_base + MG_REG_COMMAND);
 
-        /* goto next request */
-        if (!i)
+        if (mg_end_request(host, 0, MG_SECTOR_SIZE)) {
+                /* set handler if read remains */
+                host->mg_do_intr = mg_read_intr;
+                mod_timer(&host->timer, jiffies + 3 * HZ);
+        } else /* goto next request */
                 mg_request(host->breq);
 }
 
 static void mg_write_intr(struct mg_host *host)
 {
+        struct request *req = host->req;
         u32 i, j;
         u16 *buff;
-        struct request *req;
-
-        /* get current segment of request */
-        req = elv_next_request(host->breq);
+        bool rem;
 
         /* check status */
         do {
                 i = inb((unsigned long)host->dev_base + MG_REG_STATUS);
-                if (i & MG_REG_STATUS_BIT_BUSY)
+                if (i & ATA_BUSY)
                         break;
                 if (!MG_READY_OK(i))
                         break;
-                if ((req->nr_sectors <= 1) || (i & MG_REG_STATUS_BIT_DATA_REQ))
+                if ((blk_rq_sectors(req) <= 1) || (i & ATA_DRQ))
                         goto ok_to_write;
         } while (0);
         mg_dump_status("mg_write_intr", i, host);
@@ -489,18 +621,8 @@ static void mg_write_intr(struct mg_host *host)
         return;
 
 ok_to_write:
-        /* manipulate request */
-        req->sector++;
-        i = --req->nr_sectors;
-        --req->current_nr_sectors;
-        req->buffer += MG_SECTOR_SIZE;
-
-        /* let know if current segment or all done */
-        if (!i || (req->bio && req->current_nr_sectors <= 0))
-                end_request(req, 1);
-
-        /* write 1 sector and set handler if remains */
-        if (i > 0) {
+        if ((rem = mg_end_request(host, 0, MG_SECTOR_SIZE))) {
+                /* write 1 sector and set handler if remains */
                 buff = (u16 *)req->buffer;
                 for (j = 0; j < MG_STORAGE_BUFFER_SIZE >> 1; j++) {
                         outw(*buff, (unsigned long)host->dev_base +
@@ -508,7 +630,7 @@ ok_to_write:
                         buff++;
                 }
                 MG_DBG("sector %ld, remaining=%ld, buffer=0x%p\n",
-                                req->sector, req->nr_sectors, req->buffer);
+                       blk_rq_pos(req), blk_rq_sectors(req), req->buffer);
                 host->mg_do_intr = mg_write_intr;
                 mod_timer(&host->timer, jiffies + 3 * HZ);
         }
@@ -516,7 +638,7 @@ ok_to_write:
         /* send write confirm */
         outb(MG_CMD_WR_CONF, (unsigned long)host->dev_base + MG_REG_COMMAND);
 
-        if (!i)
+        if (!rem)
                 mg_request(host->breq);
 }
 
@@ -524,49 +646,45 @@ void mg_times_out(unsigned long data)
 {
         struct mg_host *host = (struct mg_host *)data;
         char *name;
-        struct request *req;
 
         spin_lock_irq(&host->lock);
 
-        req = elv_next_request(host->breq);
-        if (!req)
+        if (!host->req)
                 goto out_unlock;
 
         host->mg_do_intr = NULL;
 
-        name = req->rq_disk->disk_name;
+        name = host->req->rq_disk->disk_name;
         printk(KERN_DEBUG "%s: timeout\n", name);
 
         host->error = MG_ERR_TIMEOUT;
         mg_bad_rw_intr(host);
 
-        mg_request(host->breq);
 out_unlock:
+        mg_request(host->breq);
         spin_unlock_irq(&host->lock);
 }
 
 static void mg_request_poll(struct request_queue *q)
 {
-        struct request *req;
-        struct mg_host *host;
+        struct mg_host *host = q->queuedata;
 
-        while ((req = elv_next_request(q)) != NULL) {
-                host = req->rq_disk->private_data;
-                if (blk_fs_request(req)) {
-                        switch (rq_data_dir(req)) {
-                        case READ:
-                                mg_read(req);
-                                break;
-                        case WRITE:
-                                mg_write(req);
-                                break;
-                        default:
-                                printk(KERN_WARNING "%s:%d unknown command\n",
-                                                __func__, __LINE__);
-                                end_request(req, 0);
+        while (1) {
+                if (!host->req) {
+                        host->req = blk_fetch_request(q);
+                        if (!host->req)
                                 break;
-                        }
                 }
+
+                if (unlikely(!blk_fs_request(host->req))) {
+                        mg_end_request_cur(host, -EIO);
+                        continue;
+                }
+
+                if (rq_data_dir(host->req) == READ)
+                        mg_read(host->req);
+                else
+                        mg_write(host->req);
         }
 }
 
@@ -588,18 +706,15 @@ static unsigned int mg_issue_req(struct request *req,
                 break;
         case WRITE:
                 /* TODO : handler */
-                outb(MG_REG_CTRL_INTR_DISABLE,
-                                (unsigned long)host->dev_base +
-                                MG_REG_DRV_CTRL);
+                outb(ATA_NIEN, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
                 if (mg_out(host, sect_num, sect_cnt, MG_CMD_WR, &mg_write_intr)
                                 != MG_ERR_NONE) {
                         mg_bad_rw_intr(host);
                         return host->error;
                 }
                 del_timer(&host->timer);
-                mg_wait(host, MG_REG_STATUS_BIT_DATA_REQ, MG_TMAX_WAIT_WR_DRQ);
-                outb(MG_REG_CTRL_INTR_ENABLE, (unsigned long)host->dev_base +
-                                MG_REG_DRV_CTRL);
+                mg_wait(host, ATA_DRQ, MG_TMAX_WAIT_WR_DRQ);
+                outb(0, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
                 if (host->error) {
                         mg_bad_rw_intr(host);
                         return host->error;
@@ -614,11 +729,6 @@ static unsigned int mg_issue_req(struct request *req,
                 outb(MG_CMD_WR_CONF, (unsigned long)host->dev_base +
                                 MG_REG_COMMAND);
                 break;
-        default:
-                printk(KERN_WARNING "%s:%d unknown command\n",
-                                __func__, __LINE__);
-                end_request(req, 0);
-                break;
         }
         return MG_ERR_NONE;
 }
@@ -626,16 +736,17 @@ static unsigned int mg_issue_req(struct request *req,
 /* This function also called from IRQ context */
 static void mg_request(struct request_queue *q)
 {
+        struct mg_host *host = q->queuedata;
         struct request *req;
-        struct mg_host *host;
         u32 sect_num, sect_cnt;
 
         while (1) {
-                req = elv_next_request(q);
-                if (!req)
-                        return;
-
-                host = req->rq_disk->private_data;
+                if (!host->req) {
+                        host->req = blk_fetch_request(q);
+                        if (!host->req)
+                                break;
+                }
+                req = host->req;
 
                 /* check unwanted request call */
                 if (host->mg_do_intr)
@@ -643,9 +754,9 @@ static void mg_request(struct request_queue *q)
 
                 del_timer(&host->timer);
 
-                sect_num = req->sector;
+                sect_num = blk_rq_pos(req);
                 /* deal whole segments */
-                sect_cnt = req->nr_sectors;
+                sect_cnt = blk_rq_sectors(req);
 
                 /* sanity check */
                 if (sect_num >= get_capacity(req->rq_disk) ||
@@ -655,12 +766,14 @@ static void mg_request(struct request_queue *q)
                                         "%s: bad access: sector=%d, count=%d\n",
                                         req->rq_disk->disk_name,
                                         sect_num, sect_cnt);
-                        end_request(req, 0);
+                        mg_end_request_cur(host, -EIO);
                         continue;
                 }
 
-                if (!blk_fs_request(req))
-                        return;
+                if (unlikely(!blk_fs_request(req))) {
+                        mg_end_request_cur(host, -EIO);
+                        continue;
+                }
 
                 if (!mg_issue_req(req, host, sect_num, sect_cnt))
                         return;
@@ -690,9 +803,7 @@ static int mg_suspend(struct platform_device *plat_dev, pm_message_t state)
                 return -EIO;
 
         if (!prv_data->use_polling)
-                outb(MG_REG_CTRL_INTR_DISABLE,
-                                (unsigned long)host->dev_base +
-                                MG_REG_DRV_CTRL);
+                outb(ATA_NIEN, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
 
         outb(MG_CMD_SLEEP, (unsigned long)host->dev_base + MG_REG_COMMAND);
         /* wait until mflash deep sleep */
@@ -700,9 +811,7 @@ static int mg_suspend(struct platform_device *plat_dev, pm_message_t state)
 
         if (mg_wait(host, MG_STAT_READY, MG_TMAX_CONF_TO_CMD)) {
                 if (!prv_data->use_polling)
-                        outb(MG_REG_CTRL_INTR_ENABLE,
-                                        (unsigned long)host->dev_base +
-                                        MG_REG_DRV_CTRL);
+                        outb(0, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
                 return -EIO;
         }
 
@@ -725,8 +834,7 @@ static int mg_resume(struct platform_device *plat_dev)
                 return -EIO;
 
         if (!prv_data->use_polling)
-                outb(MG_REG_CTRL_INTR_ENABLE, (unsigned long)host->dev_base +
-                                MG_REG_DRV_CTRL);
+                outb(0, (unsigned long)host->dev_base + MG_REG_DRV_CTRL);
 
         return 0;
 }
@@ -877,6 +985,7 @@ static int mg_probe(struct platform_device *plat_dev)
                                 __func__, __LINE__);
                 goto probe_err_5;
         }
+        host->breq->queuedata = host;
 
         /* mflash is random device, thanx for the noop */
         elevator_exit(host->breq->elevator);
@@ -887,7 +996,7 @@ static int mg_probe(struct platform_device *plat_dev)
                 goto probe_err_6;
         }
         blk_queue_max_sectors(host->breq, MG_MAX_SECTS);
-        blk_queue_hardsect_size(host->breq, MG_SECTOR_SIZE);
+        blk_queue_logical_block_size(host->breq, MG_SECTOR_SIZE);
 
         init_timer(&host->timer);
         host->timer.function = mg_times_out;
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 4d6de4f15ccb..5d23ffad7c77 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -110,7 +110,7 @@ static void nbd_end_request(struct request *req)
                         req, error ? "failed" : "done");
 
         spin_lock_irqsave(q->queue_lock, flags);
-        __blk_end_request(req, error, req->nr_sectors << 9);
+        __blk_end_request_all(req, error);
         spin_unlock_irqrestore(q->queue_lock, flags);
 }
 
@@ -231,19 +231,19 @@ static int nbd_send_req(struct nbd_device *lo, struct request *req)
 {
         int result, flags;
         struct nbd_request request;
-        unsigned long size = req->nr_sectors << 9;
+        unsigned long size = blk_rq_bytes(req);
 
         request.magic = htonl(NBD_REQUEST_MAGIC);
         request.type = htonl(nbd_cmd(req));
-        request.from = cpu_to_be64((u64) req->sector << 9);
+        request.from = cpu_to_be64((u64)blk_rq_pos(req) << 9);
         request.len = htonl(size);
         memcpy(request.handle, &req, sizeof(req));
 
-        dprintk(DBG_TX, "%s: request %p: sending control (%s@%llu,%luB)\n",
+        dprintk(DBG_TX, "%s: request %p: sending control (%s@%llu,%uB)\n",
                         lo->disk->disk_name, req,
                         nbdcmd_to_ascii(nbd_cmd(req)),
-                        (unsigned long long)req->sector << 9,
-                        req->nr_sectors << 9);
+                        (unsigned long long)blk_rq_pos(req) << 9,
+                        blk_rq_bytes(req));
         result = sock_xmit(lo, 1, &request, sizeof(request),
                         (nbd_cmd(req) == NBD_CMD_WRITE) ? MSG_MORE : 0);
         if (result <= 0) {
@@ -533,11 +533,9 @@ static void do_nbd_request(struct request_queue *q)
 {
         struct request *req;
         
-        while ((req = elv_next_request(q)) != NULL) {
+        while ((req = blk_fetch_request(q)) != NULL) {
                 struct nbd_device *lo;
 
-                blkdev_dequeue_request(req);
-
                 spin_unlock_irq(q->queue_lock);
 
                 dprintk(DBG_BLKDEV, "%s: request %p: dequeued (flags=%x)\n",
@@ -580,13 +578,6 @@ static int __nbd_ioctl(struct block_device *bdev, struct nbd_device *lo,
                 blk_rq_init(NULL, &sreq);
                 sreq.cmd_type = REQ_TYPE_SPECIAL;
                 nbd_cmd(&sreq) = NBD_CMD_DISC;
-                /*
-                 * Set these to sane values in case server implementation
-                 * fails to check the request type first and also to keep
-                 * debugging output cleaner.
-                 */
-                sreq.sector = 0;
-                sreq.nr_sectors = 0;
                 if (!lo->sock)
                         return -EINVAL;
                 nbd_send_req(lo, &sreq);
diff --git a/drivers/block/paride/pcd.c b/drivers/block/paride/pcd.c
index e91d4b4b014f..911dfd98d813 100644
--- a/drivers/block/paride/pcd.c
+++ b/drivers/block/paride/pcd.c
@@ -719,32 +719,37 @@ static void do_pcd_request(struct request_queue * q)
         if (pcd_busy)
                 return;
         while (1) {
-                pcd_req = elv_next_request(q);
-                if (!pcd_req)
-                        return;
+                if (!pcd_req) {
+                        pcd_req = blk_fetch_request(q);
+                        if (!pcd_req)
+                                return;
+                }
 
                 if (rq_data_dir(pcd_req) == READ) {
                         struct pcd_unit *cd = pcd_req->rq_disk->private_data;
                         if (cd != pcd_current)
                                 pcd_bufblk = -1;
                         pcd_current = cd;
-                        pcd_sector = pcd_req->sector;
-                        pcd_count = pcd_req->current_nr_sectors;
+                        pcd_sector = blk_rq_pos(pcd_req);
+                        pcd_count = blk_rq_cur_sectors(pcd_req);
                         pcd_buf = pcd_req->buffer;
                         pcd_busy = 1;
                         ps_set_intr(do_pcd_read, NULL, 0, nice);
                         return;
-                } else
-                        end_request(pcd_req, 0);
+                } else {
+                        __blk_end_request_all(pcd_req, -EIO);
+                        pcd_req = NULL;
+                }
         }
 }
 
-static inline void next_request(int success)
+static inline void next_request(int err)
 {
         unsigned long saved_flags;
 
         spin_lock_irqsave(&pcd_lock, saved_flags);
-        end_request(pcd_req, success);
+        if (!__blk_end_request_cur(pcd_req, err))
+                pcd_req = NULL;
         pcd_busy = 0;
         do_pcd_request(pcd_queue);
         spin_unlock_irqrestore(&pcd_lock, saved_flags);
@@ -781,7 +786,7 @@ static void pcd_start(void)
 
         if (pcd_command(pcd_current, rd_cmd, 2048, "read block")) {
                 pcd_bufblk = -1;
-                next_request(0);
+                next_request(-EIO);
                 return;
         }
 
@@ -796,7 +801,7 @@ static void do_pcd_read(void)
         pcd_retries = 0;
         pcd_transfer();
         if (!pcd_count) {
-                next_request(1);
+                next_request(0);
                 return;
         }
 
@@ -815,7 +820,7 @@ static void do_pcd_read_drq(void)
                         return;
                 }
                 pcd_bufblk = -1;
-                next_request(0);
+                next_request(-EIO);
                 return;
         }
 
diff --git a/drivers/block/paride/pd.c b/drivers/block/paride/pd.c
index 9299455b0af6..bf5955b3d873 100644
--- a/drivers/block/paride/pd.c
+++ b/drivers/block/paride/pd.c
@@ -410,10 +410,12 @@ static void run_fsm(void)
                                 pd_claimed = 0;
                                 phase = NULL;
                                 spin_lock_irqsave(&pd_lock, saved_flags);
-                                end_request(pd_req, res);
-                                pd_req = elv_next_request(pd_queue);
-                                if (!pd_req)
-                                        stop = 1;
+                                if (!__blk_end_request_cur(pd_req,
+                                                res == Ok ? 0 : -EIO)) {
+                                        pd_req = blk_fetch_request(pd_queue);
+                                        if (!pd_req)
+                                                stop = 1;
+                                }
                                 spin_unlock_irqrestore(&pd_lock, saved_flags);
                                 if (stop)
                                         return;
@@ -443,11 +445,11 @@ static enum action do_pd_io_start(void)
 
         pd_cmd = rq_data_dir(pd_req);
         if (pd_cmd == READ || pd_cmd == WRITE) {
-                pd_block = pd_req->sector;
-                pd_count = pd_req->current_nr_sectors;
+                pd_block = blk_rq_pos(pd_req);
+                pd_count = blk_rq_cur_sectors(pd_req);
                 if (pd_block + pd_count > get_capacity(pd_req->rq_disk))
                         return Fail;
-                pd_run = pd_req->nr_sectors;
+                pd_run = blk_rq_sectors(pd_req);
                 pd_buf = pd_req->buffer;
                 pd_retries = 0;
                 if (pd_cmd == READ)
@@ -477,8 +479,8 @@ static int pd_next_buf(void)
         if (pd_count)
                 return 0;
         spin_lock_irqsave(&pd_lock, saved_flags);
-        end_request(pd_req, 1);
-        pd_count = pd_req->current_nr_sectors;
+        __blk_end_request_cur(pd_req, 0);
+        pd_count = blk_rq_cur_sectors(pd_req);
         pd_buf = pd_req->buffer;
         spin_unlock_irqrestore(&pd_lock, saved_flags);
         return 0;
@@ -702,7 +704,7 @@ static void do_pd_request(struct request_queue * q)
 {
         if (pd_req)
                 return;
-        pd_req = elv_next_request(q);
+        pd_req = blk_fetch_request(q);
         if (!pd_req)
                 return;
 
diff --git a/drivers/block/paride/pf.c b/drivers/block/paride/pf.c
index bef3b997ba3e..68a90834e993 100644
--- a/drivers/block/paride/pf.c
+++ b/drivers/block/paride/pf.c
@@ -750,12 +750,10 @@ static int pf_ready(void)
 
 static struct request_queue *pf_queue;
 
-static void pf_end_request(int uptodate)
+static void pf_end_request(int err)
 {
-        if (pf_req) {
-                end_request(pf_req, uptodate);
+        if (pf_req && !__blk_end_request_cur(pf_req, err))
                 pf_req = NULL;
-        }
 }
 
 static void do_pf_request(struct request_queue * q)
@@ -763,17 +761,19 @@ static void do_pf_request(struct request_queue * q)
         if (pf_busy)
                 return;
 repeat:
-        pf_req = elv_next_request(q);
-        if (!pf_req)
-                return;
+        if (!pf_req) {
+                pf_req = blk_fetch_request(q);
+                if (!pf_req)
+                        return;
+        }
 
         pf_current = pf_req->rq_disk->private_data;
-        pf_block = pf_req->sector;
-        pf_run = pf_req->nr_sectors;
-        pf_count = pf_req->current_nr_sectors;
+        pf_block = blk_rq_pos(pf_req);
+        pf_run = blk_rq_sectors(pf_req);
+        pf_count = blk_rq_cur_sectors(pf_req);
 
         if (pf_block + pf_count > get_capacity(pf_req->rq_disk)) {
-                pf_end_request(0);
+                pf_end_request(-EIO);
                 goto repeat;
         }
 
@@ -788,7 +788,7 @@ repeat:
                 pi_do_claimed(pf_current->pi, do_pf_write);
         else {
                 pf_busy = 0;
-                pf_end_request(0);
+                pf_end_request(-EIO);
                 goto repeat;
         }
 }
@@ -805,23 +805,22 @@ static int pf_next_buf(void)
                 return 1;
         if (!pf_count) {
                 spin_lock_irqsave(&pf_spin_lock, saved_flags);
-                pf_end_request(1);
-                pf_req = elv_next_request(pf_queue);
+                pf_end_request(0);
                 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
                 if (!pf_req)
                         return 1;
-                pf_count = pf_req->current_nr_sectors;
+                pf_count = blk_rq_cur_sectors(pf_req);
                 pf_buf = pf_req->buffer;
         }
         return 0;
 }
 
-static inline void next_request(int success)
+static inline void next_request(int err)
 {
         unsigned long saved_flags;
 
         spin_lock_irqsave(&pf_spin_lock, saved_flags);
-        pf_end_request(success);
+        pf_end_request(err);
         pf_busy = 0;
         do_pf_request(pf_queue);
         spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
@@ -844,7 +843,7 @@ static void do_pf_read_start(void)
                         pi_do_claimed(pf_current->pi, do_pf_read_start);
                         return;
                 }
-                next_request(0);
+                next_request(-EIO);
                 return;
         }
         pf_mask = STAT_DRQ;
@@ -863,7 +862,7 @@ static void do_pf_read_drq(void)
                                 pi_do_claimed(pf_current->pi, do_pf_read_start);
                                 return;
                         }
-                        next_request(0);
+                        next_request(-EIO);
                         return;
                 }
                 pi_read_block(pf_current->pi, pf_buf, 512);
@@ -871,7 +870,7 @@ static void do_pf_read_drq(void)
                         break;
         }
         pi_disconnect(pf_current->pi);
-        next_request(1);
+        next_request(0);
 }
 
 static void do_pf_write(void)
@@ -890,7 +889,7 @@ static void do_pf_write_start(void)
                         pi_do_claimed(pf_current->pi, do_pf_write_start);
                         return;
                 }
-                next_request(0);
+                next_request(-EIO);
                 return;
         }
 
@@ -903,7 +902,7 @@ static void do_pf_write_start(void)
                                 pi_do_claimed(pf_current->pi, do_pf_write_start);
                                 return;
                         }
-                        next_request(0);
+                        next_request(-EIO);
                         return;
                 }
                 pi_write_block(pf_current->pi, pf_buf, 512);
@@ -923,11 +922,11 @@ static void do_pf_write_done(void)
                         pi_do_claimed(pf_current->pi, do_pf_write_start);
                         return;
                 }
-                next_request(0);
+                next_request(-EIO);
                 return;
         }
         pi_disconnect(pf_current->pi);
-        next_request(1);
+        next_request(0);
 }
 
 static int __init pf_init(void)
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index dc7a8c352da2..d57f11759480 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -991,13 +991,15 @@ static void pkt_iosched_process_queue(struct pktcdvd_device *pd)
  */
 static int pkt_set_segment_merging(struct pktcdvd_device *pd, struct request_queue *q)
 {
-        if ((pd->settings.size << 9) / CD_FRAMESIZE <= q->max_phys_segments) {
+        if ((pd->settings.size << 9) / CD_FRAMESIZE
+            <= queue_max_phys_segments(q)) {
                 /*
                  * The cdrom device can handle one segment/frame
                  */
                 clear_bit(PACKET_MERGE_SEGS, &pd->flags);
                 return 0;
-        } else if ((pd->settings.size << 9) / PAGE_SIZE <= q->max_phys_segments) {
+        } else if ((pd->settings.size << 9) / PAGE_SIZE
+                   <= queue_max_phys_segments(q)) {
                 /*
                  * We can handle this case at the expense of some extra memory
                  * copies during write operations
@@ -2657,7 +2659,7 @@ static void pkt_init_queue(struct pktcdvd_device *pd)
         struct request_queue *q = pd->disk->queue;
 
         blk_queue_make_request(q, pkt_make_request);
-        blk_queue_hardsect_size(q, CD_FRAMESIZE);
+        blk_queue_logical_block_size(q, CD_FRAMESIZE);
         blk_queue_max_sectors(q, PACKET_MAX_SECTORS);
         blk_queue_merge_bvec(q, pkt_merge_bvec);
         q->queuedata = pd;
diff --git a/drivers/block/ps3disk.c b/drivers/block/ps3disk.c
index bccc42bb9212..aaeeb544228a 100644
--- a/drivers/block/ps3disk.c
+++ b/drivers/block/ps3disk.c
@@ -134,13 +134,12 @@ static int ps3disk_submit_request_sg(struct ps3_storage_device *dev,
         rq_for_each_segment(bv, req, iter)
                 n++;
         dev_dbg(&dev->sbd.core,
-                "%s:%u: %s req has %u bvecs for %lu sectors %lu hard sectors\n",
-                __func__, __LINE__, op, n, req->nr_sectors,
-                req->hard_nr_sectors);
+                "%s:%u: %s req has %u bvecs for %u sectors\n",
+                __func__, __LINE__, op, n, blk_rq_sectors(req));
 #endif
 
-        start_sector = req->sector * priv->blocking_factor;
-        sectors = req->nr_sectors * priv->blocking_factor;
+        start_sector = blk_rq_pos(req) * priv->blocking_factor;
+        sectors = blk_rq_sectors(req) * priv->blocking_factor;
         dev_dbg(&dev->sbd.core, "%s:%u: %s %llu sectors starting at %llu\n",
                 __func__, __LINE__, op, sectors, start_sector);
 
@@ -158,7 +157,7 @@ static int ps3disk_submit_request_sg(struct ps3_storage_device *dev,
         if (res) {
                 dev_err(&dev->sbd.core, "%s:%u: %s failed %d\n", __func__,
                         __LINE__, op, res);
-                end_request(req, 0);
+                __blk_end_request_all(req, -EIO);
                 return 0;
         }
 
@@ -180,7 +179,7 @@ static int ps3disk_submit_flush_request(struct ps3_storage_device *dev,
         if (res) {
                 dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%llx\n",
                         __func__, __LINE__, res);
-                end_request(req, 0);
+                __blk_end_request_all(req, -EIO);
                 return 0;
         }
 
@@ -195,7 +194,7 @@ static void ps3disk_do_request(struct ps3_storage_device *dev,
 
         dev_dbg(&dev->sbd.core, "%s:%u\n", __func__, __LINE__);
 
-        while ((req = elv_next_request(q))) {
+        while ((req = blk_fetch_request(q))) {
                 if (blk_fs_request(req)) {
                         if (ps3disk_submit_request_sg(dev, req))
                                 break;
@@ -205,7 +204,7 @@ static void ps3disk_do_request(struct ps3_storage_device *dev,
                                 break;
                 } else {
                         blk_dump_rq_flags(req, DEVICE_NAME " bad request");
-                        end_request(req, 0);
+                        __blk_end_request_all(req, -EIO);
                         continue;
                 }
         }
@@ -231,7 +230,6 @@ static irqreturn_t ps3disk_interrupt(int irq, void *data)
         struct request *req;
         int res, read, error;
         u64 tag, status;
-        unsigned long num_sectors;
         const char *op;
 
         res = lv1_storage_get_async_status(dev->sbd.dev_id, &tag, &status);
@@ -261,11 +259,9 @@ static irqreturn_t ps3disk_interrupt(int irq, void *data)
         if (req->cmd_type == REQ_TYPE_LINUX_BLOCK &&
             req->cmd[0] == REQ_LB_OP_FLUSH) {
                 read = 0;
-                num_sectors = req->hard_cur_sectors;
                 op = "flush";
         } else {
                 read = !rq_data_dir(req);
-                num_sectors = req->nr_sectors;
                 op = read ? "read" : "write";
         }
         if (status) {
@@ -281,7 +277,7 @@ static irqreturn_t ps3disk_interrupt(int irq, void *data)
         }
 
         spin_lock(&priv->lock);
-        __blk_end_request(req, error, num_sectors << 9);
+        __blk_end_request_all(req, error);
         priv->req = NULL;
         ps3disk_do_request(dev, priv->queue);
         spin_unlock(&priv->lock);
@@ -481,7 +477,7 @@ static int __devinit ps3disk_probe(struct ps3_system_bus_device *_dev)
         blk_queue_max_sectors(queue, dev->bounce_size >> 9);
         blk_queue_segment_boundary(queue, -1UL);
         blk_queue_dma_alignment(queue, dev->blk_size-1);
-        blk_queue_hardsect_size(queue, dev->blk_size);
+        blk_queue_logical_block_size(queue, dev->blk_size);
 
         blk_queue_ordered(queue, QUEUE_ORDERED_DRAIN_FLUSH,
                           ps3disk_prepare_flush);
diff --git a/drivers/block/sunvdc.c b/drivers/block/sunvdc.c
index 5861e33efe63..cbfd9c0aef03 100644
--- a/drivers/block/sunvdc.c
+++ b/drivers/block/sunvdc.c
@@ -212,11 +212,6 @@ static void vdc_end_special(struct vdc_port *port, struct vio_disk_desc *desc)
         vdc_finish(&port->vio, -err, WAITING_FOR_GEN_CMD);
 }
 
-static void vdc_end_request(struct request *req, int error, int num_sectors)
-{
-        __blk_end_request(req, error, num_sectors << 9);
-}
-
 static void vdc_end_one(struct vdc_port *port, struct vio_dring_state *dr,
                         unsigned int index)
 {
@@ -239,7 +234,7 @@ static void vdc_end_one(struct vdc_port *port, struct vio_dring_state *dr,
 
         rqe->req = NULL;
 
-        vdc_end_request(req, (desc->status ? -EIO : 0), desc->size >> 9);
+        __blk_end_request(req, (desc->status ? -EIO : 0), desc->size);
 
         if (blk_queue_stopped(port->disk->queue))
                 blk_start_queue(port->disk->queue);
@@ -421,7 +416,7 @@ static int __send_request(struct request *req)
                 desc->slice = 0;
         }
         desc->status = ~0;
-        desc->offset = (req->sector << 9) / port->vdisk_block_size;
+        desc->offset = (blk_rq_pos(req) << 9) / port->vdisk_block_size;
         desc->size = len;
         desc->ncookies = err;
 
@@ -446,14 +441,13 @@ out:
 static void do_vdc_request(struct request_queue *q)
 {
         while (1) {
-                struct request *req = elv_next_request(q);
+                struct request *req = blk_fetch_request(q);
 
                 if (!req)
                         break;
 
-                blkdev_dequeue_request(req);
                 if (__send_request(req) < 0)
-                        vdc_end_request(req, -EIO, req->hard_nr_sectors);
+                        __blk_end_request_all(req, -EIO);
         }
 }
 
diff --git a/drivers/block/swim.c b/drivers/block/swim.c
index d22cc3856937..cf7877fb8a7d 100644
--- a/drivers/block/swim.c
+++ b/drivers/block/swim.c
@@ -514,7 +514,7 @@ static int floppy_read_sectors(struct floppy_state *fs,
                         ret = swim_read_sector(fs, side, track, sector,
                                                 buffer);
                         if (try-- == 0)
-                                return -1;
+                                return -EIO;
                 } while (ret != 512);
 
                 buffer += ret;
@@ -528,45 +528,31 @@ static void redo_fd_request(struct request_queue *q)
         struct request *req;
         struct floppy_state *fs;
 
-        while ((req = elv_next_request(q))) {
+        req = blk_fetch_request(q);
+        while (req) {
+                int err = -EIO;
 
                 fs = req->rq_disk->private_data;
-                if (req->sector < 0 || req->sector >= fs->total_secs) {
-                        end_request(req, 0);
-                        continue;
-                }
-                if (req->current_nr_sectors == 0) {
-                        end_request(req, 1);
-                        continue;
-                }
-                if (!fs->disk_in) {
-                        end_request(req, 0);
-                        continue;
-                }
-                if (rq_data_dir(req) == WRITE) {
-                        if (fs->write_protected) {
-                                end_request(req, 0);
-                                continue;
-                        }
-                }
+                if (blk_rq_pos(req) >= fs->total_secs)
+                        goto done;
+                if (!fs->disk_in)
+                        goto done;
+                if (rq_data_dir(req) == WRITE && fs->write_protected)
+                        goto done;
+
                 switch (rq_data_dir(req)) {
                 case WRITE:
                         /* NOT IMPLEMENTED */
-                        end_request(req, 0);
                         break;
                 case READ:
-                        if (floppy_read_sectors(fs, req->sector,
-                                                req->current_nr_sectors,
-                                                req->buffer)) {
-                                end_request(req, 0);
-                                continue;
-                        }
-                        req->nr_sectors -= req->current_nr_sectors;
-                        req->sector += req->current_nr_sectors;
-                        req->buffer += req->current_nr_sectors * 512;
-                        end_request(req, 1);
+                        err = floppy_read_sectors(fs, blk_rq_pos(req),
+                                                  blk_rq_cur_sectors(req),
+                                                  req->buffer);
                         break;
                 }
+        done:
+                if (!__blk_end_request_cur(req, err))
+                        req = blk_fetch_request(q);
         }
 }
 
diff --git a/drivers/block/swim3.c b/drivers/block/swim3.c
index 612965307ba0..80df93e3cdd0 100644
--- a/drivers/block/swim3.c
+++ b/drivers/block/swim3.c
@@ -251,6 +251,20 @@ static int floppy_release(struct gendisk *disk, fmode_t mode);
 static int floppy_check_change(struct gendisk *disk);
 static int floppy_revalidate(struct gendisk *disk);
 
+static bool swim3_end_request(int err, unsigned int nr_bytes)
+{
+        if (__blk_end_request(fd_req, err, nr_bytes))
+                return true;
+
+        fd_req = NULL;
+        return false;
+}
+
+static bool swim3_end_request_cur(int err)
+{
+        return swim3_end_request(err, blk_rq_cur_bytes(fd_req));
+}
+
 static void swim3_select(struct floppy_state *fs, int sel)
 {
         struct swim3 __iomem *sw = fs->swim3;
@@ -310,25 +324,27 @@ static void start_request(struct floppy_state *fs)
                 wake_up(&fs->wait);
                 return;
         }
-        while (fs->state == idle && (req = elv_next_request(swim3_queue))) {
+        while (fs->state == idle) {
+                if (!fd_req) {
+                        fd_req = blk_fetch_request(swim3_queue);
+                        if (!fd_req)
+                                break;
+                }
+                req = fd_req;
 #if 0
-                printk("do_fd_req: dev=%s cmd=%d sec=%ld nr_sec=%ld buf=%p\n",
+                printk("do_fd_req: dev=%s cmd=%d sec=%ld nr_sec=%u buf=%p\n",
                        req->rq_disk->disk_name, req->cmd,
-                       (long)req->sector, req->nr_sectors, req->buffer);
-                printk("           errors=%d current_nr_sectors=%ld\n",
-                       req->errors, req->current_nr_sectors);
+                       (long)blk_rq_pos(req), blk_rq_sectors(req), req->buffer);
+                printk("           errors=%d current_nr_sectors=%u\n",
+                       req->errors, blk_rq_cur_sectors(req));
 #endif
 
-                if (req->sector < 0 || req->sector >= fs->total_secs) {
-                        end_request(req, 0);
-                        continue;
-                }
-                if (req->current_nr_sectors == 0) {
-                        end_request(req, 1);
+                if (blk_rq_pos(req) >= fs->total_secs) {
+                        swim3_end_request_cur(-EIO);
                         continue;
                 }
                 if (fs->ejected) {
-                        end_request(req, 0);
+                        swim3_end_request_cur(-EIO);
                         continue;
                 }
 
@@ -336,18 +352,19 @@ static void start_request(struct floppy_state *fs)
                         if (fs->write_prot < 0)
                                 fs->write_prot = swim3_readbit(fs, WRITE_PROT);
                         if (fs->write_prot) {
-                                end_request(req, 0);
+                                swim3_end_request_cur(-EIO);
                                 continue;
                         }
                 }
 
-                /* Do not remove the cast. req->sector is now a sector_t and
-                 * can be 64 bits, but it will never go past 32 bits for this
-                 * driver anyway, so we can safely cast it down and not have
-                 * to do a 64/32 division
+                /* Do not remove the cast. blk_rq_pos(req) is now a
+                 * sector_t and can be 64 bits, but it will never go
+                 * past 32 bits for this driver anyway, so we can
+                 * safely cast it down and not have to do a 64/32
+                 * division
                  */
-                fs->req_cyl = ((long)req->sector) / fs->secpercyl;
-                x = ((long)req->sector) % fs->secpercyl;
+                fs->req_cyl = ((long)blk_rq_pos(req)) / fs->secpercyl;
+                x = ((long)blk_rq_pos(req)) % fs->secpercyl;
                 fs->head = x / fs->secpertrack;
                 fs->req_sector = x % fs->secpertrack + 1;
                 fd_req = req;
@@ -424,7 +441,7 @@ static inline void setup_transfer(struct floppy_state *fs)
         struct dbdma_cmd *cp = fs->dma_cmd;
         struct dbdma_regs __iomem *dr = fs->dma;
 
-        if (fd_req->current_nr_sectors <= 0) {
+        if (blk_rq_cur_sectors(fd_req) <= 0) {
                 printk(KERN_ERR "swim3: transfer 0 sectors?\n");
                 return;
         }
@@ -432,8 +449,8 @@ static inline void setup_transfer(struct floppy_state *fs)
                 n = 1;
         else {
                 n = fs->secpertrack - fs->req_sector + 1;
-                if (n > fd_req->current_nr_sectors)
-                        n = fd_req->current_nr_sectors;
+                if (n > blk_rq_cur_sectors(fd_req))
+                        n = blk_rq_cur_sectors(fd_req);
         }
         fs->scount = n;
         swim3_select(fs, fs->head? READ_DATA_1: READ_DATA_0);
@@ -508,7 +525,7 @@ static void act(struct floppy_state *fs)
                 case do_transfer:
                         if (fs->cur_cyl != fs->req_cyl) {
                                 if (fs->retries > 5) {
-                                        end_request(fd_req, 0);
+                                        swim3_end_request_cur(-EIO);
                                         fs->state = idle;
                                         return;
                                 }
@@ -540,7 +557,7 @@ static void scan_timeout(unsigned long data)
         out_8(&sw->intr_enable, 0);
         fs->cur_cyl = -1;
         if (fs->retries > 5) {
-                end_request(fd_req, 0);
+                swim3_end_request_cur(-EIO);
                 fs->state = idle;
                 start_request(fs);
         } else {
@@ -559,7 +576,7 @@ static void seek_timeout(unsigned long data)
         out_8(&sw->select, RELAX);
         out_8(&sw->intr_enable, 0);
         printk(KERN_ERR "swim3: seek timeout\n");
-        end_request(fd_req, 0);
+        swim3_end_request_cur(-EIO);
         fs->state = idle;
         start_request(fs);
 }
@@ -583,7 +600,7 @@ static void settle_timeout(unsigned long data)
                 return;
         }
         printk(KERN_ERR "swim3: seek settle timeout\n");
-        end_request(fd_req, 0);
+        swim3_end_request_cur(-EIO);
         fs->state = idle;
         start_request(fs);
 }
@@ -593,8 +610,6 @@ static void xfer_timeout(unsigned long data)
         struct floppy_state *fs = (struct floppy_state *) data;
         struct swim3 __iomem *sw = fs->swim3;
         struct dbdma_regs __iomem *dr = fs->dma;
-        struct dbdma_cmd *cp = fs->dma_cmd;
-        unsigned long s;
         int n;
 
         fs->timeout_pending = 0;
@@ -605,17 +620,10 @@ static void xfer_timeout(unsigned long data)
         out_8(&sw->intr_enable, 0);
         out_8(&sw->control_bic, WRITE_SECTORS | DO_ACTION);
         out_8(&sw->select, RELAX);
-        if (rq_data_dir(fd_req) == WRITE)
-                ++cp;
-        if (ld_le16(&cp->xfer_status) != 0)
-                s = fs->scount - ((ld_le16(&cp->res_count) + 511) >> 9);
-        else
-                s = 0;
-        fd_req->sector += s;
-        fd_req->current_nr_sectors -= s;
         printk(KERN_ERR "swim3: timeout %sing sector %ld\n",
-               (rq_data_dir(fd_req)==WRITE? "writ": "read"), (long)fd_req->sector);
-        end_request(fd_req, 0);
+               (rq_data_dir(fd_req)==WRITE? "writ": "read"),
+               (long)blk_rq_pos(fd_req));
+        swim3_end_request_cur(-EIO);
         fs->state = idle;
         start_request(fs);
 }
@@ -646,7 +654,7 @@ static irqreturn_t swim3_interrupt(int irq, void *dev_id)
                                 printk(KERN_ERR "swim3: seen sector but cyl=ff?\n");
                                 fs->cur_cyl = -1;
                                 if (fs->retries > 5) {
-                                        end_request(fd_req, 0);
+                                        swim3_end_request_cur(-EIO);
                                         fs->state = idle;
                                         start_request(fs);
                                 } else {
@@ -719,9 +727,7 @@ static irqreturn_t swim3_interrupt(int irq, void *dev_id)
                 if (intr & ERROR_INTR) {
                         n = fs->scount - 1 - resid / 512;
                         if (n > 0) {
-                                fd_req->sector += n;
-                                fd_req->current_nr_sectors -= n;
-                                fd_req->buffer += n * 512;
+                                blk_update_request(fd_req, 0, n << 9);
                                 fs->req_sector += n;
                         }
                         if (fs->retries < 5) {
@@ -730,8 +736,8 @@ static irqreturn_t swim3_interrupt(int irq, void *dev_id)
                         } else {
                                 printk("swim3: error %sing block %ld (err=%x)\n",
                                        rq_data_dir(fd_req) == WRITE? "writ": "read",
-                                       (long)fd_req->sector, err);
-                                end_request(fd_req, 0);
+                                       (long)blk_rq_pos(fd_req), err);
+                                swim3_end_request_cur(-EIO);
                                 fs->state = idle;
                         }
                 } else {
@@ -740,18 +746,12 @@ static irqreturn_t swim3_interrupt(int irq, void *dev_id)
                                 printk(KERN_ERR "swim3: fd dma: stat=%x resid=%d\n", stat, resid);
                                 printk(KERN_ERR "  state=%d, dir=%x, intr=%x, err=%x\n",
                                        fs->state, rq_data_dir(fd_req), intr, err);
-                                end_request(fd_req, 0);
+                                swim3_end_request_cur(-EIO);
                                 fs->state = idle;
                                 start_request(fs);
                                 break;
                         }
-                        fd_req->sector += fs->scount;
-                        fd_req->current_nr_sectors -= fs->scount;
-                        fd_req->buffer += fs->scount * 512;
-                        if (fd_req->current_nr_sectors <= 0) {
-                                end_request(fd_req, 1);
-                                fs->state = idle;
-                        } else {
+                        if (swim3_end_request(0, fs->scount << 9)) {
                                 fs->req_sector += fs->scount;
                                 if (fs->req_sector > fs->secpertrack) {
                                         fs->req_sector -= fs->secpertrack;
@@ -761,7 +761,8 @@ static irqreturn_t swim3_interrupt(int irq, void *dev_id)
                                         }
                                 }
                                 act(fs);
-                        }
+                        } else
+                                fs->state = idle;
                 }
                 if (fs->state == idle)
                         start_request(fs);
diff --git a/drivers/block/sx8.c b/drivers/block/sx8.c
index ff0448e4bf03..da403b6a7f43 100644
--- a/drivers/block/sx8.c
+++ b/drivers/block/sx8.c
@@ -749,8 +749,7 @@ static inline void carm_end_request_queued(struct carm_host *host,
         struct request *req = crq->rq;
         int rc;
 
-        rc = __blk_end_request(req, error, blk_rq_bytes(req));
-        assert(rc == 0);
+        __blk_end_request_all(req, error);
 
         rc = carm_put_request(host, crq);
         assert(rc == 0);
@@ -811,12 +810,10 @@ static void carm_oob_rq_fn(struct request_queue *q)
 
         while (1) {
                 DPRINTK("get req\n");
-                rq = elv_next_request(q);
+                rq = blk_fetch_request(q);
                 if (!rq)
                         break;
 
-                blkdev_dequeue_request(rq);
-
                 crq = rq->special;
                 assert(crq != NULL);
                 assert(crq->rq == rq);
@@ -847,7 +844,7 @@ static void carm_rq_fn(struct request_queue *q)
 
 queue_one_request:
         VPRINTK("get req\n");
-        rq = elv_next_request(q);
+        rq = blk_peek_request(q);
         if (!rq)
                 return;
 
@@ -858,7 +855,7 @@ queue_one_request:
         }
         crq->rq = rq;
 
-        blkdev_dequeue_request(rq);
+        blk_start_request(rq);
 
         if (rq_data_dir(rq) == WRITE) {
                 writing = 1;
@@ -904,10 +901,10 @@ queue_one_request:
         msg->sg_count   = n_elem;
         msg->sg_type    = SGT_32BIT;
         msg->handle     = cpu_to_le32(TAG_ENCODE(crq->tag));
-        msg->lba        = cpu_to_le32(rq->sector & 0xffffffff);
-        tmp             = (rq->sector >> 16) >> 16;
+        msg->lba        = cpu_to_le32(blk_rq_pos(rq) & 0xffffffff);
+        tmp             = (blk_rq_pos(rq) >> 16) >> 16;
         msg->lba_high   = cpu_to_le16( (u16) tmp );
-        msg->lba_count  = cpu_to_le16(rq->nr_sectors);
+        msg->lba_count  = cpu_to_le16(blk_rq_sectors(rq));
 
         msg_size = sizeof(struct carm_msg_rw) - sizeof(msg->sg);
         for (i = 0; i < n_elem; i++) {
diff --git a/drivers/block/ub.c b/drivers/block/ub.c
index 689cd27ac890..cc54473b8e77 100644
--- a/drivers/block/ub.c
+++ b/drivers/block/ub.c
@@ -360,8 +360,7 @@ static void ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun,
 static void ub_cmd_build_packet(struct ub_dev *sc, struct ub_lun *lun,
     struct ub_scsi_cmd *cmd, struct ub_request *urq);
 static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
-static void ub_end_rq(struct request *rq, unsigned int status,
-    unsigned int cmd_len);
+static void ub_end_rq(struct request *rq, unsigned int status);
 static int ub_rw_cmd_retry(struct ub_dev *sc, struct ub_lun *lun,
     struct ub_request *urq, struct ub_scsi_cmd *cmd);
 static int ub_submit_scsi(struct ub_dev *sc, struct ub_scsi_cmd *cmd);
@@ -627,7 +626,7 @@ static void ub_request_fn(struct request_queue *q)
         struct ub_lun *lun = q->queuedata;
         struct request *rq;
 
-        while ((rq = elv_next_request(q)) != NULL) {
+        while ((rq = blk_peek_request(q)) != NULL) {
                 if (ub_request_fn_1(lun, rq) != 0) {
                         blk_stop_queue(q);
                         break;
@@ -643,14 +642,14 @@ static int ub_request_fn_1(struct ub_lun *lun, struct request *rq)
         int n_elem;
 
         if (atomic_read(&sc->poison)) {
-                blkdev_dequeue_request(rq);
-                ub_end_rq(rq, DID_NO_CONNECT << 16, blk_rq_bytes(rq));
+                blk_start_request(rq);
+                ub_end_rq(rq, DID_NO_CONNECT << 16);
                 return 0;
         }
 
         if (lun->changed && !blk_pc_request(rq)) {
-                blkdev_dequeue_request(rq);
-                ub_end_rq(rq, SAM_STAT_CHECK_CONDITION, blk_rq_bytes(rq));
+                blk_start_request(rq);
+                ub_end_rq(rq, SAM_STAT_CHECK_CONDITION);
                 return 0;
         }
 
@@ -660,7 +659,7 @@ static int ub_request_fn_1(struct ub_lun *lun, struct request *rq)
                 return -1;
         memset(cmd, 0, sizeof(struct ub_scsi_cmd));
 
-        blkdev_dequeue_request(rq);
+        blk_start_request(rq);
 
         urq = &lun->urq;
         memset(urq, 0, sizeof(struct ub_request));
@@ -702,7 +701,7 @@ static int ub_request_fn_1(struct ub_lun *lun, struct request *rq)
 
 drop:
         ub_put_cmd(lun, cmd);
-        ub_end_rq(rq, DID_ERROR << 16, blk_rq_bytes(rq));
+        ub_end_rq(rq, DID_ERROR << 16);
         return 0;
 }
 
@@ -723,11 +722,11 @@ static void ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun,
         /*
          * build the command
          *
-         * The call to blk_queue_hardsect_size() guarantees that request
+         * The call to blk_queue_logical_block_size() guarantees that request
          * is aligned, but it is given in terms of 512 byte units, always.
          */
-        block = rq->sector >> lun->capacity.bshift;
-        nblks = rq->nr_sectors >> lun->capacity.bshift;
+        block = blk_rq_pos(rq) >> lun->capacity.bshift;
+        nblks = blk_rq_sectors(rq) >> lun->capacity.bshift;
 
         cmd->cdb[0] = (cmd->dir == UB_DIR_READ)? READ_10: WRITE_10;
         /* 10-byte uses 4 bytes of LBA: 2147483648KB, 2097152MB, 2048GB */
@@ -739,7 +738,7 @@ static void ub_cmd_build_block(struct ub_dev *sc, struct ub_lun *lun,
         cmd->cdb[8] = nblks;
         cmd->cdb_len = 10;
 
-        cmd->len = rq->nr_sectors * 512;
+        cmd->len = blk_rq_bytes(rq);
 }
 
 static void ub_cmd_build_packet(struct ub_dev *sc, struct ub_lun *lun,
@@ -747,7 +746,7 @@ static void ub_cmd_build_packet(struct ub_dev *sc, struct ub_lun *lun,
 {
         struct request *rq = urq->rq;
 
-        if (rq->data_len == 0) {
+        if (blk_rq_bytes(rq) == 0) {
                 cmd->dir = UB_DIR_NONE;
         } else {
                 if (rq_data_dir(rq) == WRITE)
@@ -762,7 +761,7 @@ static void ub_cmd_build_packet(struct ub_dev *sc, struct ub_lun *lun,
         memcpy(&cmd->cdb, rq->cmd, rq->cmd_len);
         cmd->cdb_len = rq->cmd_len;
 
-        cmd->len = rq->data_len;
+        cmd->len = blk_rq_bytes(rq);
 
         /*
          * To reapply this to every URB is not as incorrect as it looks.
@@ -777,16 +776,15 @@ static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
         struct ub_request *urq = cmd->back;
         struct request *rq;
         unsigned int scsi_status;
-        unsigned int cmd_len;
 
         rq = urq->rq;
 
         if (cmd->error == 0) {
                 if (blk_pc_request(rq)) {
-                        if (cmd->act_len >= rq->data_len)
-                                rq->data_len = 0;
+                        if (cmd->act_len >= rq->resid_len)
+                                rq->resid_len = 0;
                         else
-                                rq->data_len -= cmd->act_len;
+                                rq->resid_len -= cmd->act_len;
                         scsi_status = 0;
                 } else {
                         if (cmd->act_len != cmd->len) {
@@ -818,17 +816,14 @@ static void ub_rw_cmd_done(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
 
         urq->rq = NULL;
 
-        cmd_len = cmd->len;
         ub_put_cmd(lun, cmd);
-        ub_end_rq(rq, scsi_status, cmd_len);
+        ub_end_rq(rq, scsi_status);
         blk_start_queue(lun->disk->queue);
 }
 
-static void ub_end_rq(struct request *rq, unsigned int scsi_status,
-    unsigned int cmd_len)
+static void ub_end_rq(struct request *rq, unsigned int scsi_status)
 {
         int error;
-        long rqlen;
 
         if (scsi_status == 0) {
                 error = 0;
@@ -836,12 +831,7 @@ static void ub_end_rq(struct request *rq, unsigned int scsi_status,
                 error = -EIO;
                 rq->errors = scsi_status;
         }
-        rqlen = blk_rq_bytes(rq);    /* Oddly enough, this is the residue. */
-        if (__blk_end_request(rq, error, cmd_len)) {
-                printk(KERN_WARNING DRV_NAME
-                    ": __blk_end_request blew, %s-cmd total %u rqlen %ld\n",
-                    blk_pc_request(rq)? "pc": "fs", cmd_len, rqlen);
-        }
+        __blk_end_request_all(rq, error);
 }
 
 static int ub_rw_cmd_retry(struct ub_dev *sc, struct ub_lun *lun,
@@ -1759,7 +1749,7 @@ static int ub_bd_revalidate(struct gendisk *disk)
         ub_revalidate(lun->udev, lun);
 
         /* XXX Support sector size switching like in sr.c */
-        blk_queue_hardsect_size(disk->queue, lun->capacity.bsize);
+        blk_queue_logical_block_size(disk->queue, lun->capacity.bsize);
         set_capacity(disk, lun->capacity.nsec);
         // set_disk_ro(sdkp->disk, lun->readonly);
 
@@ -2334,7 +2324,7 @@ static int ub_probe_lun(struct ub_dev *sc, int lnum)
         blk_queue_max_phys_segments(q, UB_MAX_REQ_SG);
         blk_queue_segment_boundary(q, 0xffffffff);      /* Dubious. */
         blk_queue_max_sectors(q, UB_MAX_SECTORS);
-        blk_queue_hardsect_size(q, lun->capacity.bsize);
+        blk_queue_logical_block_size(q, lun->capacity.bsize);
 
         lun->disk = disk;
         q->queuedata = lun;
diff --git a/drivers/block/viodasd.c b/drivers/block/viodasd.c
index ecccf65dce2f..390d69bb7c48 100644
--- a/drivers/block/viodasd.c
+++ b/drivers/block/viodasd.c
@@ -252,7 +252,7 @@ static int send_request(struct request *req)
         struct viodasd_device *d;
         unsigned long flags;
 
-        start = (u64)req->sector << 9;
+        start = (u64)blk_rq_pos(req) << 9;
 
         if (rq_data_dir(req) == READ) {
                 direction = DMA_FROM_DEVICE;
@@ -361,19 +361,17 @@ static void do_viodasd_request(struct request_queue *q)
          * back later.
          */
         while (num_req_outstanding < VIOMAXREQ) {
-                req = elv_next_request(q);
+                req = blk_fetch_request(q);
                 if (req == NULL)
                         return;
-                /* dequeue the current request from the queue */
-                blkdev_dequeue_request(req);
                 /* check that request contains a valid command */
                 if (!blk_fs_request(req)) {
-                        viodasd_end_request(req, -EIO, req->hard_nr_sectors);
+                        viodasd_end_request(req, -EIO, blk_rq_sectors(req));
                         continue;
                 }
                 /* Try sending the request */
                 if (send_request(req) != 0)
-                        viodasd_end_request(req, -EIO, req->hard_nr_sectors);
+                        viodasd_end_request(req, -EIO, blk_rq_sectors(req));
         }
 }
 
@@ -590,7 +588,7 @@ static int viodasd_handle_read_write(struct vioblocklpevent *bevent)
                 err = vio_lookup_rc(viodasd_err_table, bevent->sub_result);
                 printk(VIOD_KERN_WARNING "read/write error %d:0x%04x (%s)\n",
                                 event->xRc, bevent->sub_result, err->msg);
-                num_sect = req->hard_nr_sectors;
+                num_sect = blk_rq_sectors(req);
         }
         qlock = req->q->queue_lock;
         spin_lock_irqsave(qlock, irq_flags);
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index 5d34764c8a87..c0facaa55cf4 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -37,6 +37,7 @@ struct virtblk_req
         struct list_head list;
         struct request *req;
         struct virtio_blk_outhdr out_hdr;
+        struct virtio_scsi_inhdr in_hdr;
         u8 status;
 };
 
@@ -50,6 +51,7 @@ static void blk_done(struct virtqueue *vq)
         spin_lock_irqsave(&vblk->lock, flags);
         while ((vbr = vblk->vq->vq_ops->get_buf(vblk->vq, &len)) != NULL) {
                 int error;
+
                 switch (vbr->status) {
                 case VIRTIO_BLK_S_OK:
                         error = 0;
@@ -62,7 +64,13 @@ static void blk_done(struct virtqueue *vq)
                         break;
                 }
 
-                __blk_end_request(vbr->req, error, blk_rq_bytes(vbr->req));
+                if (blk_pc_request(vbr->req)) {
+                        vbr->req->resid_len = vbr->in_hdr.residual;
+                        vbr->req->sense_len = vbr->in_hdr.sense_len;
+                        vbr->req->errors = vbr->in_hdr.errors;
+                }
+
+                __blk_end_request_all(vbr->req, error);
                 list_del(&vbr->list);
                 mempool_free(vbr, vblk->pool);
         }
@@ -74,7 +82,7 @@ static void blk_done(struct virtqueue *vq)
 static bool do_req(struct request_queue *q, struct virtio_blk *vblk,
                    struct request *req)
 {
-        unsigned long num, out, in;
+        unsigned long num, out = 0, in = 0;
         struct virtblk_req *vbr;
 
         vbr = mempool_alloc(vblk->pool, GFP_ATOMIC);
@@ -85,7 +93,7 @@ static bool do_req(struct request_queue *q, struct virtio_blk *vblk,
         vbr->req = req;
         if (blk_fs_request(vbr->req)) {
                 vbr->out_hdr.type = 0;
-                vbr->out_hdr.sector = vbr->req->sector;
+                vbr->out_hdr.sector = blk_rq_pos(vbr->req);
                 vbr->out_hdr.ioprio = req_get_ioprio(vbr->req);
         } else if (blk_pc_request(vbr->req)) {
                 vbr->out_hdr.type = VIRTIO_BLK_T_SCSI_CMD;
@@ -99,18 +107,36 @@ static bool do_req(struct request_queue *q, struct virtio_blk *vblk,
         if (blk_barrier_rq(vbr->req))
                 vbr->out_hdr.type |= VIRTIO_BLK_T_BARRIER;
 
-        sg_set_buf(&vblk->sg[0], &vbr->out_hdr, sizeof(vbr->out_hdr));
-        num = blk_rq_map_sg(q, vbr->req, vblk->sg+1);
-        sg_set_buf(&vblk->sg[num+1], &vbr->status, sizeof(vbr->status));
+        sg_set_buf(&vblk->sg[out++], &vbr->out_hdr, sizeof(vbr->out_hdr));
 
-        if (rq_data_dir(vbr->req) == WRITE) {
-                vbr->out_hdr.type |= VIRTIO_BLK_T_OUT;
-                out = 1 + num;
-                in = 1;
-        } else {
-                vbr->out_hdr.type |= VIRTIO_BLK_T_IN;
-                out = 1;
-                in = 1 + num;
+        /*
+         * If this is a packet command we need a couple of additional headers.
+         * Behind the normal outhdr we put a segment with the scsi command
+         * block, and before the normal inhdr we put the sense data and the
+         * inhdr with additional status information before the normal inhdr.
+         */
+        if (blk_pc_request(vbr->req))
+                sg_set_buf(&vblk->sg[out++], vbr->req->cmd, vbr->req->cmd_len);
+
+        num = blk_rq_map_sg(q, vbr->req, vblk->sg + out);
+
+        if (blk_pc_request(vbr->req)) {
+                sg_set_buf(&vblk->sg[num + out + in++], vbr->req->sense, 96);
+                sg_set_buf(&vblk->sg[num + out + in++], &vbr->in_hdr,
+                           sizeof(vbr->in_hdr));
+        }
+
+        sg_set_buf(&vblk->sg[num + out + in++], &vbr->status,
+                   sizeof(vbr->status));
+
+        if (num) {
+                if (rq_data_dir(vbr->req) == WRITE) {
+                        vbr->out_hdr.type |= VIRTIO_BLK_T_OUT;
+                        out += num;
+                } else {
+                        vbr->out_hdr.type |= VIRTIO_BLK_T_IN;
+                        in += num;
+                }
         }
 
         if (vblk->vq->vq_ops->add_buf(vblk->vq, vblk->sg, out, in, vbr)) {
@@ -124,12 +150,11 @@ static bool do_req(struct request_queue *q, struct virtio_blk *vblk,
 
 static void do_virtblk_request(struct request_queue *q)
 {
-        struct virtio_blk *vblk = NULL;
+        struct virtio_blk *vblk = q->queuedata;
         struct request *req;
         unsigned int issued = 0;
 
-        while ((req = elv_next_request(q)) != NULL) {
-                vblk = req->rq_disk->private_data;
+        while ((req = blk_peek_request(q)) != NULL) {
                 BUG_ON(req->nr_phys_segments + 2 > vblk->sg_elems);
 
                 /* If this request fails, stop queue and wait for something to
@@ -138,7 +163,7 @@ static void do_virtblk_request(struct request_queue *q)
                         blk_stop_queue(q);
                         break;
                 }
-                blkdev_dequeue_request(req);
+                blk_start_request(req);
                 issued++;
         }
 
@@ -146,12 +171,51 @@ static void do_virtblk_request(struct request_queue *q)
                 vblk->vq->vq_ops->kick(vblk->vq);
 }
 
+/* return ATA identify data
+ */
+static int virtblk_identify(struct gendisk *disk, void *argp)
+{
+        struct virtio_blk *vblk = disk->private_data;
+        void *opaque;
+        int err = -ENOMEM;
+
+        opaque = kmalloc(VIRTIO_BLK_ID_BYTES, GFP_KERNEL);
+        if (!opaque)
+                goto out;
+
+        err = virtio_config_buf(vblk->vdev, VIRTIO_BLK_F_IDENTIFY,
+                offsetof(struct virtio_blk_config, identify), opaque,
+                VIRTIO_BLK_ID_BYTES);
+
+        if (err)
+                goto out_kfree;
+
+        if (copy_to_user(argp, opaque, VIRTIO_BLK_ID_BYTES))
+                err = -EFAULT;
+
+out_kfree:
+        kfree(opaque);
+out:
+        return err;
+}
+
 static int virtblk_ioctl(struct block_device *bdev, fmode_t mode,
                          unsigned cmd, unsigned long data)
 {
-        return scsi_cmd_ioctl(bdev->bd_disk->queue,
-                              bdev->bd_disk, mode, cmd,
-                              (void __user *)data);
+        struct gendisk *disk = bdev->bd_disk;
+        struct virtio_blk *vblk = disk->private_data;
+        void __user *argp = (void __user *)data;
+
+        if (cmd == HDIO_GET_IDENTITY)
+                return virtblk_identify(disk, argp);
+
+        /*
+         * Only allow the generic SCSI ioctls if the host can support it.
+         */
+        if (!virtio_has_feature(vblk->vdev, VIRTIO_BLK_F_SCSI))
+                return -ENOIOCTLCMD;
+
+        return scsi_cmd_ioctl(disk->queue, disk, mode, cmd, argp);
 }
 
 /* We provide getgeo only to please some old bootloader/partitioning tools */
@@ -249,6 +313,7 @@ static int virtblk_probe(struct virtio_device *vdev)
                 goto out_put_disk;
         }
 
+        vblk->disk->queue->queuedata = vblk;
         queue_flag_set_unlocked(QUEUE_FLAG_VIRT, vblk->disk->queue);
 
         if (index < 26) {
@@ -313,7 +378,7 @@ static int virtblk_probe(struct virtio_device *vdev)
                                 offsetof(struct virtio_blk_config, blk_size),
                                 &blk_size);
         if (!err)
-                blk_queue_hardsect_size(vblk->disk->queue, blk_size);
+                blk_queue_logical_block_size(vblk->disk->queue, blk_size);
 
         add_disk(vblk->disk);
         return 0;
@@ -356,6 +421,7 @@ static struct virtio_device_id id_table[] = {
 static unsigned int features[] = {
         VIRTIO_BLK_F_BARRIER, VIRTIO_BLK_F_SEG_MAX, VIRTIO_BLK_F_SIZE_MAX,
         VIRTIO_BLK_F_GEOMETRY, VIRTIO_BLK_F_RO, VIRTIO_BLK_F_BLK_SIZE,
+        VIRTIO_BLK_F_SCSI, VIRTIO_BLK_F_IDENTIFY
 };
 
 static struct virtio_driver virtio_blk = {
diff --git a/drivers/block/xd.c b/drivers/block/xd.c
index 64b496fce98b..ce2429219925 100644
--- a/drivers/block/xd.c
+++ b/drivers/block/xd.c
@@ -305,30 +305,25 @@ static void do_xd_request (struct request_queue * q)
         if (xdc_busy)
                 return;
 
-        while ((req = elv_next_request(q)) != NULL) {
-                unsigned block = req->sector;
-                unsigned count = req->nr_sectors;
-                int rw = rq_data_dir(req);
+        req = blk_fetch_request(q);
+        while (req) {
+                unsigned block = blk_rq_pos(req);
+                unsigned count = blk_rq_cur_sectors(req);
                 XD_INFO *disk = req->rq_disk->private_data;
-                int res = 0;
+                int res = -EIO;
                 int retry;
 
-                if (!blk_fs_request(req)) {
-                        end_request(req, 0);
-                        continue;
-                }
-                if (block + count > get_capacity(req->rq_disk)) {
-                        end_request(req, 0);
-                        continue;
-                }
-                if (rw != READ && rw != WRITE) {
-                        printk("do_xd_request: unknown request\n");
-                        end_request(req, 0);
-                        continue;
-                }
+                if (!blk_fs_request(req))
+                        goto done;
+                if (block + count > get_capacity(req->rq_disk))
+                        goto done;
                 for (retry = 0; (retry < XD_RETRIES) && !res; retry++)
-                        res = xd_readwrite(rw, disk, req->buffer, block, count);
-                end_request(req, res);  /* wrap up, 0 = fail, 1 = success */
+                        res = xd_readwrite(rq_data_dir(req), disk, req->buffer,
+                                           block, count);
+        done:
+                /* wrap up, 0 = success, -errno = fail */
+                if (!__blk_end_request_cur(req, res))
+                        req = blk_fetch_request(q);
         }
 }
 
@@ -418,7 +413,7 @@ static int xd_readwrite (u_char operation,XD_INFO *p,char *buffer,u_int block,u_
                                 printk("xd%c: %s timeout, recalibrating drive\n",'a'+drive,(operation == READ ? "read" : "write"));
                                 xd_recalibrate(drive);
                                 spin_lock_irq(&xd_lock);
-                                return (0);
+                                return -EIO;
                         case 2:
                                 if (sense[0] & 0x30) {
                                         printk("xd%c: %s - ",'a'+drive,(operation == READ ? "reading" : "writing"));
@@ -439,7 +434,7 @@ static int xd_readwrite (u_char operation,XD_INFO *p,char *buffer,u_int block,u_
                                 else
                                         printk(" - no valid disk address\n");
                                 spin_lock_irq(&xd_lock);
-                                return (0);
+                                return -EIO;
                 }
                 if (xd_dma_buffer)
                         for (i=0; i < (temp * 0x200); i++)
@@ -448,7 +443,7 @@ static int xd_readwrite (u_char operation,XD_INFO *p,char *buffer,u_int block,u_
                 count -= temp, buffer += temp * 0x200, block += temp;
         }
         spin_lock_irq(&xd_lock);
-        return (1);
+        return 0;
 }
 
 /* xd_recalibrate: recalibrate a given drive and reset controller if necessary */
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index a6cbf7b808e6..c1996829d5ec 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -122,7 +122,7 @@ static DEFINE_SPINLOCK(blkif_io_lock);
 static int get_id_from_freelist(struct blkfront_info *info)
 {
         unsigned long free = info->shadow_free;
-        BUG_ON(free > BLK_RING_SIZE);
+        BUG_ON(free >= BLK_RING_SIZE);
         info->shadow_free = info->shadow[free].req.id;
         info->shadow[free].req.id = 0x0fffffee; /* debug */
         return free;
@@ -231,7 +231,7 @@ static int blkif_queue_request(struct request *req)
         info->shadow[id].request = (unsigned long)req;
 
         ring_req->id = id;
-        ring_req->sector_number = (blkif_sector_t)req->sector;
+        ring_req->sector_number = (blkif_sector_t)blk_rq_pos(req);
         ring_req->handle = info->handle;
 
         ring_req->operation = rq_data_dir(req) ?
@@ -299,25 +299,25 @@ static void do_blkif_request(struct request_queue *rq)
 
         queued = 0;
 
-        while ((req = elv_next_request(rq)) != NULL) {
+        while ((req = blk_peek_request(rq)) != NULL) {
                 info = req->rq_disk->private_data;
-                if (!blk_fs_request(req)) {
-                        end_request(req, 0);
-                        continue;
-                }
 
                 if (RING_FULL(&info->ring))
                         goto wait;
 
-                pr_debug("do_blk_req %p: cmd %p, sec %lx, "
-                         "(%u/%li) buffer:%p [%s]\n",
-                         req, req->cmd, (unsigned long)req->sector,
-                         req->current_nr_sectors,
-                         req->nr_sectors, req->buffer,
-                         rq_data_dir(req) ? "write" : "read");
+                blk_start_request(req);
 
+                if (!blk_fs_request(req)) {
+                        __blk_end_request_all(req, -EIO);
+                        continue;
+                }
+
+                pr_debug("do_blk_req %p: cmd %p, sec %lx, "
+                         "(%u/%u) buffer:%p [%s]\n",
+                         req, req->cmd, (unsigned long)blk_rq_pos(req),
+                         blk_rq_cur_sectors(req), blk_rq_sectors(req),
+                         req->buffer, rq_data_dir(req) ? "write" : "read");
 
-                blkdev_dequeue_request(req);
                 if (blkif_queue_request(req)) {
                         blk_requeue_request(rq, req);
 wait:
@@ -344,7 +344,7 @@ static int xlvbd_init_blk_queue(struct gendisk *gd, u16 sector_size)
         queue_flag_set_unlocked(QUEUE_FLAG_VIRT, rq);
 
         /* Hard sector size and max sectors impersonate the equiv. hardware. */
-        blk_queue_hardsect_size(rq, sector_size);
+        blk_queue_logical_block_size(rq, sector_size);
         blk_queue_max_sectors(rq, 512);
 
         /* Each segment in a request is up to an aligned page in size. */
@@ -551,7 +551,6 @@ static irqreturn_t blkif_interrupt(int irq, void *dev_id)
 
         for (i = info->ring.rsp_cons; i != rp; i++) {
                 unsigned long id;
-                int ret;
 
                 bret = RING_GET_RESPONSE(&info->ring, i);
                 id   = bret->id;
@@ -578,8 +577,7 @@ static irqreturn_t blkif_interrupt(int irq, void *dev_id)
                                 dev_dbg(&info->xbdev->dev, "Bad return from blkdev data "
                                         "request: %x\n", bret->status);
 
-                        ret = __blk_end_request(req, error, blk_rq_bytes(req));
-                        BUG_ON(ret);
+                        __blk_end_request_all(req, error);
                         break;
                 default:
                         BUG();
diff --git a/drivers/block/xsysace.c b/drivers/block/xsysace.c
index 4aecf5dc6a93..f08491a3a813 100644
--- a/drivers/block/xsysace.c
+++ b/drivers/block/xsysace.c
@@ -463,10 +463,11 @@ struct request *ace_get_next_request(struct request_queue * q)
 {
         struct request *req;
 
-        while ((req = elv_next_request(q)) != NULL) {
+        while ((req = blk_peek_request(q)) != NULL) {
                 if (blk_fs_request(req))
                         break;
-                end_request(req, 0);
+                blk_start_request(req);
+                __blk_end_request_all(req, -EIO);
         }
         return req;
 }
@@ -492,9 +493,13 @@ static void ace_fsm_dostate(struct ace_device *ace)
                 set_capacity(ace->gd, 0);
                 dev_info(ace->dev, "No CF in slot\n");
 
-                /* Drop all pending requests */
-                while ((req = elv_next_request(ace->queue)) != NULL)
-                        end_request(req, 0);
+                /* Drop all in-flight and pending requests */
+                if (ace->req) {
+                        __blk_end_request_all(ace->req, -EIO);
+                        ace->req = NULL;
+                }
+                while ((req = blk_fetch_request(ace->queue)) != NULL)
+                        __blk_end_request_all(req, -EIO);
 
                 /* Drop back to IDLE state and notify waiters */
                 ace->fsm_state = ACE_FSM_STATE_IDLE;
@@ -642,19 +647,21 @@ static void ace_fsm_dostate(struct ace_device *ace)
                         ace->fsm_state = ACE_FSM_STATE_IDLE;
                         break;
                 }
+                blk_start_request(req);
 
                 /* Okay, it's a data request, set it up for transfer */
                 dev_dbg(ace->dev,
-                        "request: sec=%llx hcnt=%lx, ccnt=%x, dir=%i\n",
-                        (unsigned long long) req->sector, req->hard_nr_sectors,
-                        req->current_nr_sectors, rq_data_dir(req));
+                        "request: sec=%llx hcnt=%x, ccnt=%x, dir=%i\n",
+                        (unsigned long long)blk_rq_pos(req),
+                        blk_rq_sectors(req), blk_rq_cur_sectors(req),
+                        rq_data_dir(req));
 
                 ace->req = req;
                 ace->data_ptr = req->buffer;
-                ace->data_count = req->current_nr_sectors * ACE_BUF_PER_SECTOR;
-                ace_out32(ace, ACE_MPULBA, req->sector & 0x0FFFFFFF);
+                ace->data_count = blk_rq_cur_sectors(req) * ACE_BUF_PER_SECTOR;
+                ace_out32(ace, ACE_MPULBA, blk_rq_pos(req) & 0x0FFFFFFF);
 
-                count = req->hard_nr_sectors;
+                count = blk_rq_sectors(req);
                 if (rq_data_dir(req)) {
                         /* Kick off write request */
                         dev_dbg(ace->dev, "write data\n");
@@ -688,7 +695,7 @@ static void ace_fsm_dostate(struct ace_device *ace)
                         dev_dbg(ace->dev,
                                 "CFBSY set; t=%i iter=%i c=%i dc=%i irq=%i\n",
                                 ace->fsm_task, ace->fsm_iter_num,
-                                ace->req->current_nr_sectors * 16,
+                                blk_rq_cur_sectors(ace->req) * 16,
                                 ace->data_count, ace->in_irq);
                         ace_fsm_yield(ace);     /* need to poll CFBSY bit */
                         break;
@@ -697,7 +704,7 @@ static void ace_fsm_dostate(struct ace_device *ace)
                         dev_dbg(ace->dev,
                                 "DATABUF not set; t=%i iter=%i c=%i dc=%i irq=%i\n",
                                 ace->fsm_task, ace->fsm_iter_num,
-                                ace->req->current_nr_sectors * 16,
+                                blk_rq_cur_sectors(ace->req) * 16,
                                 ace->data_count, ace->in_irq);
                         ace_fsm_yieldirq(ace);
                         break;
@@ -717,14 +724,13 @@ static void ace_fsm_dostate(struct ace_device *ace)
                 }
 
                 /* bio finished; is there another one? */
-                if (__blk_end_request(ace->req, 0,
-                                        blk_rq_cur_bytes(ace->req))) {
-                        /* dev_dbg(ace->dev, "next block; h=%li c=%i\n",
-                         *      ace->req->hard_nr_sectors,
-                         *      ace->req->current_nr_sectors);
+                if (__blk_end_request_cur(ace->req, 0)) {
+                        /* dev_dbg(ace->dev, "next block; h=%u c=%u\n",
+                         *      blk_rq_sectors(ace->req),
+                         *      blk_rq_cur_sectors(ace->req));
                          */
                         ace->data_ptr = ace->req->buffer;
-                        ace->data_count = ace->req->current_nr_sectors * 16;
+                        ace->data_count = blk_rq_cur_sectors(ace->req) * 16;
                         ace_fsm_yieldirq(ace);
                         break;
                 }
@@ -978,7 +984,7 @@ static int __devinit ace_setup(struct ace_device *ace)
         ace->queue = blk_init_queue(ace_request, &ace->lock);
         if (ace->queue == NULL)
                 goto err_blk_initq;
-        blk_queue_hardsect_size(ace->queue, 512);
+        blk_queue_logical_block_size(ace->queue, 512);
 
         /*
          * Allocate and initialize GD structure
diff --git a/drivers/block/z2ram.c b/drivers/block/z2ram.c
index 80754cdd3119..4575171e5beb 100644
--- a/drivers/block/z2ram.c
+++ b/drivers/block/z2ram.c
@@ -70,15 +70,18 @@ static struct gendisk *z2ram_gendisk;
 static void do_z2_request(struct request_queue *q)
 {
         struct request *req;
-        while ((req = elv_next_request(q)) != NULL) {
-                unsigned long start = req->sector << 9;
-                unsigned long len  = req->current_nr_sectors << 9;
+
+        req = blk_fetch_request(q);
+        while (req) {
+                unsigned long start = blk_rq_pos(req) << 9;
+                unsigned long len  = blk_rq_cur_bytes(req);
+                int err = 0;
 
                 if (start + len > z2ram_size) {
                         printk( KERN_ERR DEVICE_NAME ": bad access: block=%lu, count=%u\n",
-                                req->sector, req->current_nr_sectors);
-                        end_request(req, 0);
-                        continue;
+                                blk_rq_pos(req), blk_rq_cur_sectors(req));
+                        err = -EIO;
+                        goto done;
                 }
                 while (len) {
                         unsigned long addr = start & Z2RAM_CHUNKMASK;
@@ -93,7 +96,9 @@ static void do_z2_request(struct request_queue *q)
                         start += size;
                         len -= size;
                 }
-                end_request(req, 1);
+        done:
+                if (!__blk_end_request_cur(req, err))
+                        req = blk_fetch_request(q);
         }
 }
 
diff --git a/drivers/bluetooth/hci_ldisc.c b/drivers/bluetooth/hci_ldisc.c
index af761dc434f6..4895f0e05322 100644
--- a/drivers/bluetooth/hci_ldisc.c
+++ b/drivers/bluetooth/hci_ldisc.c
@@ -277,8 +277,8 @@ static int hci_uart_tty_open(struct tty_struct *tty)
         /* FIXME: why is this needed. Note don't use ldisc_ref here as the
            open path is before the ldisc is referencable */
 
-        if (tty->ldisc.ops->flush_buffer)
-                tty->ldisc.ops->flush_buffer(tty);
+        if (tty->ldisc->ops->flush_buffer)
+                tty->ldisc->ops->flush_buffer(tty);
         tty_driver_flush_buffer(tty);
 
         return 0;
@@ -463,7 +463,6 @@ static int hci_uart_tty_ioctl(struct tty_struct *tty, struct file * file,
                                 clear_bit(HCI_UART_PROTO_SET, &hu->flags);
                                 return err;
                         }
-                        tty->low_latency = 1;
                 } else
                         return -EBUSY;
                 break;
diff --git a/drivers/cdrom/cdrom.c b/drivers/cdrom/cdrom.c
index cceace61ef28..71d1b9bab70b 100644
--- a/drivers/cdrom/cdrom.c
+++ b/drivers/cdrom/cdrom.c
@@ -2101,8 +2101,8 @@ static int cdrom_read_cdda_bpc(struct cdrom_device_info *cdi, __u8 __user *ubuf,
                 nr = nframes;
                 if (cdi->cdda_method == CDDA_BPC_SINGLE)
                         nr = 1;
-                if (nr * CD_FRAMESIZE_RAW > (q->max_sectors << 9))
-                        nr = (q->max_sectors << 9) / CD_FRAMESIZE_RAW;
+                if (nr * CD_FRAMESIZE_RAW > (queue_max_sectors(q) << 9))
+                        nr = (queue_max_sectors(q) << 9) / CD_FRAMESIZE_RAW;
 
                 len = nr * CD_FRAMESIZE_RAW;
 
diff --git a/drivers/cdrom/gdrom.c b/drivers/cdrom/gdrom.c
index 2eecb779437b..b5621f27c4be 100644
--- a/drivers/cdrom/gdrom.c
+++ b/drivers/cdrom/gdrom.c
@@ -584,8 +584,8 @@ static void gdrom_readdisk_dma(struct work_struct *work)
         list_for_each_safe(elem, next, &gdrom_deferred) {
                 req = list_entry(elem, struct request, queuelist);
                 spin_unlock(&gdrom_lock);
-                block = req->sector/GD_TO_BLK + GD_SESSION_OFFSET;
-                block_cnt = req->nr_sectors/GD_TO_BLK;
+                block = blk_rq_pos(req)/GD_TO_BLK + GD_SESSION_OFFSET;
+                block_cnt = blk_rq_sectors(req)/GD_TO_BLK;
                 ctrl_outl(PHYSADDR(req->buffer), GDROM_DMA_STARTADDR_REG);
                 ctrl_outl(block_cnt * GDROM_HARD_SECTOR, GDROM_DMA_LENGTH_REG);
                 ctrl_outl(1, GDROM_DMA_DIRECTION_REG);
@@ -632,39 +632,35 @@ static void gdrom_readdisk_dma(struct work_struct *work)
                 * before handling ending the request */
                 spin_lock(&gdrom_lock);
                 list_del_init(&req->queuelist);
-                __blk_end_request(req, err, blk_rq_bytes(req));
+                __blk_end_request_all(req, err);
         }
         spin_unlock(&gdrom_lock);
         kfree(read_command);
 }
 
-static void gdrom_request_handler_dma(struct request *req)
-{
-        /* dequeue, add to list of deferred work
-        * and then schedule workqueue */
-        blkdev_dequeue_request(req);
-        list_add_tail(&req->queuelist, &gdrom_deferred);
-        schedule_work(&work);
-}
-
 static void gdrom_request(struct request_queue *rq)
 {
         struct request *req;
 
-        while ((req = elv_next_request(rq)) != NULL) {
+        while ((req = blk_fetch_request(rq)) != NULL) {
                 if (!blk_fs_request(req)) {
                         printk(KERN_DEBUG "GDROM: Non-fs request ignored\n");
-                        end_request(req, 0);
+                        __blk_end_request_all(req, -EIO);
+                        continue;
                 }
                 if (rq_data_dir(req) != READ) {
                         printk(KERN_NOTICE "GDROM: Read only device -");
                         printk(" write request ignored\n");
-                        end_request(req, 0);
+                        __blk_end_request_all(req, -EIO);
+                        continue;
                 }
-                if (req->nr_sectors)
-                        gdrom_request_handler_dma(req);
-                else
-                        end_request(req, 0);
+
+                /*
+                 * Add to list of deferred work and then schedule
+                 * workqueue.
+                 */
+                list_add_tail(&req->queuelist, &gdrom_deferred);
+                schedule_work(&work);
         }
 }
 
@@ -743,7 +739,7 @@ static void __devinit probe_gdrom_setupdisk(void)
 
 static int __devinit probe_gdrom_setupqueue(void)
 {
-        blk_queue_hardsect_size(gd.gdrom_rq, GDROM_HARD_SECTOR);
+        blk_queue_logical_block_size(gd.gdrom_rq, GDROM_HARD_SECTOR);
         /* using DMA so memory will need to be contiguous */
         blk_queue_max_hw_segments(gd.gdrom_rq, 1);
         /* set a large max size to get most from DMA */
diff --git a/drivers/cdrom/viocd.c b/drivers/cdrom/viocd.c
index 9b1624e0ddeb..0fff646cc2f0 100644
--- a/drivers/cdrom/viocd.c
+++ b/drivers/cdrom/viocd.c
@@ -282,7 +282,7 @@ static int send_request(struct request *req)
                         viopath_targetinst(viopath_hostLp),
                         (u64)req, VIOVERSION << 16,
                         ((u64)DEVICE_NR(diskinfo) << 48) | dmaaddr,
-                        (u64)req->sector * 512, len, 0);
+                        (u64)blk_rq_pos(req) * 512, len, 0);
         if (hvrc != HvLpEvent_Rc_Good) {
                 printk(VIOCD_KERN_WARNING "hv error on op %d\n", (int)hvrc);
                 return -1;
@@ -291,36 +291,19 @@ static int send_request(struct request *req)
         return 0;
 }
 
-static void viocd_end_request(struct request *req, int error)
-{
-        int nsectors = req->hard_nr_sectors;
-
-        /*
-         * Make sure it's fully ended, and ensure that we process
-         * at least one sector.
-         */
-        if (blk_pc_request(req))
-                nsectors = (req->data_len + 511) >> 9;
-        if (!nsectors)
-                nsectors = 1;
-
-        if (__blk_end_request(req, error, nsectors << 9))
-                BUG();
-}
-
 static int rwreq;
 
 static void do_viocd_request(struct request_queue *q)
 {
         struct request *req;
 
-        while ((rwreq == 0) && ((req = elv_next_request(q)) != NULL)) {
+        while ((rwreq == 0) && ((req = blk_fetch_request(q)) != NULL)) {
                 if (!blk_fs_request(req))
-                        viocd_end_request(req, -EIO);
+                        __blk_end_request_all(req, -EIO);
                 else if (send_request(req) < 0) {
                         printk(VIOCD_KERN_WARNING
                                         "unable to send message to OS/400!");
-                        viocd_end_request(req, -EIO);
+                        __blk_end_request_all(req, -EIO);
                 } else
                         rwreq++;
         }
@@ -486,8 +469,8 @@ static void vio_handle_cd_event(struct HvLpEvent *event)
         case viocdopen:
                 if (event->xRc == 0) {
                         di = &viocd_diskinfo[bevent->disk];
-                        blk_queue_hardsect_size(di->viocd_disk->queue,
-                                        bevent->block_size);
+                        blk_queue_logical_block_size(di->viocd_disk->queue,
+                                                     bevent->block_size);
                         set_capacity(di->viocd_disk,
                                         bevent->media_size *
                                         bevent->block_size / 512);
@@ -531,9 +514,9 @@ return_complete:
                                         "with rc %d:0x%04X: %s\n",
                                         req, event->xRc,
                                         bevent->sub_result, err->msg);
-                        viocd_end_request(req, -EIO);
+                        __blk_end_request_all(req, -EIO);
                 } else
-                        viocd_end_request(req, 0);
+                        __blk_end_request_all(req, 0);
 
                 /* restart handling of incoming requests */
                 spin_unlock_irqrestore(&viocd_reqlock, flags);
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 735bbe2be51a..02ecfd5fa61c 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -97,6 +97,19 @@ config DEVKMEM
           kind of kernel debugging operations.
           When in doubt, say "N".
 
+config BFIN_JTAG_COMM
+        tristate "Blackfin JTAG Communication"
+        depends on BLACKFIN
+        help
+          Add support for emulating a TTY device over the Blackfin JTAG.
+
+          To compile this driver as a module, choose M here: the
+          module will be called bfin_jtag_comm.
+
+config BFIN_JTAG_COMM_CONSOLE
+        bool "Console on Blackfin JTAG"
+        depends on BFIN_JTAG_COMM=y
+
 config SERIAL_NONSTANDARD
         bool "Non-standard serial port support"
         depends on HAS_IOMEM
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index 9caf5b5ad1c0..189efcff08ce 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -13,6 +13,7 @@ obj-$(CONFIG_LEGACY_PTYS)	+= pty.o
 obj-$(CONFIG_UNIX98_PTYS)       += pty.o
 obj-y                           += misc.o
 obj-$(CONFIG_VT)                += vt_ioctl.o vc_screen.o selection.o keyboard.o
+obj-$(CONFIG_BFIN_JTAG_COMM)    += bfin_jtag_comm.o
 obj-$(CONFIG_CONSOLE_TRANSLATIONS) += consolemap.o consolemap_deftbl.o
 obj-$(CONFIG_HW_CONSOLE)        += vt.o defkeymap.o
 obj-$(CONFIG_AUDIT)             += tty_audit.o
diff --git a/drivers/char/bfin_jtag_comm.c b/drivers/char/bfin_jtag_comm.c
new file mode 100644
index 000000000000..44c113d56045
--- /dev/null
+++ b/drivers/char/bfin_jtag_comm.c
@@ -0,0 +1,365 @@
+/*
+ * TTY over Blackfin JTAG Communication
+ *
+ * Copyright 2008-2009 Analog Devices Inc.
+ *
+ * Enter bugs at http://blackfin.uclinux.org/
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/circ_buf.h>
+#include <linux/console.h>
+#include <linux/delay.h>
+#include <linux/err.h>
+#include <linux/kernel.h>
+#include <linux/kthread.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/sched.h>
+#include <linux/tty.h>
+#include <linux/tty_driver.h>
+#include <linux/tty_flip.h>
+#include <asm/atomic.h>
+
+/* See the Debug/Emulation chapter in the HRM */
+#define EMUDOF   0x00000001     /* EMUDAT_OUT full & valid */
+#define EMUDIF   0x00000002     /* EMUDAT_IN full & valid */
+#define EMUDOOVF 0x00000004     /* EMUDAT_OUT overflow */
+#define EMUDIOVF 0x00000008     /* EMUDAT_IN overflow */
+
+#define DRV_NAME "bfin-jtag-comm"
+#define DEV_NAME "ttyBFJC"
+
+#define pr_init(fmt, args...) ({ static const __initdata char __fmt[] = fmt; printk(__fmt, ## args); })
+#define debug(fmt, args...) pr_debug(DRV_NAME ": " fmt, ## args)
+
+static inline uint32_t bfin_write_emudat(uint32_t emudat)
+{
+        __asm__ __volatile__("emudat = %0;" : : "d"(emudat));
+        return emudat;
+}
+
+static inline uint32_t bfin_read_emudat(void)
+{
+        uint32_t emudat;
+        __asm__ __volatile__("%0 = emudat;" : "=d"(emudat));
+        return emudat;
+}
+
+static inline uint32_t bfin_write_emudat_chars(char a, char b, char c, char d)
+{
+        return bfin_write_emudat((a << 0) | (b << 8) | (c << 16) | (d << 24));
+}
+
+#define CIRC_SIZE 2048  /* see comment in tty_io.c:do_tty_write() */
+#define CIRC_MASK (CIRC_SIZE - 1)
+#define circ_empty(circ)     ((circ)->head == (circ)->tail)
+#define circ_free(circ)      CIRC_SPACE((circ)->head, (circ)->tail, CIRC_SIZE)
+#define circ_cnt(circ)       CIRC_CNT((circ)->head, (circ)->tail, CIRC_SIZE)
+#define circ_byte(circ, idx) ((circ)->buf[(idx) & CIRC_MASK])
+
+static struct tty_driver *bfin_jc_driver;
+static struct task_struct *bfin_jc_kthread;
+static struct tty_struct * volatile bfin_jc_tty;
+static unsigned long bfin_jc_count;
+static DEFINE_MUTEX(bfin_jc_tty_mutex);
+static volatile struct circ_buf bfin_jc_write_buf;
+
+static int
+bfin_jc_emudat_manager(void *arg)
+{
+        uint32_t inbound_len = 0, outbound_len = 0;
+
+        while (!kthread_should_stop()) {
+                /* no one left to give data to, so sleep */
+                if (bfin_jc_tty == NULL && circ_empty(&bfin_jc_write_buf)) {
+                        debug("waiting for readers\n");
+                        __set_current_state(TASK_UNINTERRUPTIBLE);
+                        schedule();
+                        __set_current_state(TASK_RUNNING);
+                }
+
+                /* no data available, so just chill */
+                if (!(bfin_read_DBGSTAT() & EMUDIF) && circ_empty(&bfin_jc_write_buf)) {
+                        debug("waiting for data (in_len = %i) (circ: %i %i)\n",
+                                inbound_len, bfin_jc_write_buf.tail, bfin_jc_write_buf.head);
+                        if (inbound_len)
+                                schedule();
+                        else
+                                schedule_timeout_interruptible(HZ);
+                        continue;
+                }
+
+                /* if incoming data is ready, eat it */
+                if (bfin_read_DBGSTAT() & EMUDIF) {
+                        struct tty_struct *tty;
+                        mutex_lock(&bfin_jc_tty_mutex);
+                        tty = (struct tty_struct *)bfin_jc_tty;
+                        if (tty != NULL) {
+                                uint32_t emudat = bfin_read_emudat();
+                                if (inbound_len == 0) {
+                                        debug("incoming length: 0x%08x\n", emudat);
+                                        inbound_len = emudat;
+                                } else {
+                                        size_t num_chars = (4 <= inbound_len ? 4 : inbound_len);
+                                        debug("  incoming data: 0x%08x (pushing %zu)\n", emudat, num_chars);
+                                        inbound_len -= num_chars;
+                                        tty_insert_flip_string(tty, (unsigned char *)&emudat, num_chars);
+                                        tty_flip_buffer_push(tty);
+                                }
+                        }
+                        mutex_unlock(&bfin_jc_tty_mutex);
+                }
+
+                /* if outgoing data is ready, post it */
+                if (!(bfin_read_DBGSTAT() & EMUDOF) && !circ_empty(&bfin_jc_write_buf)) {
+                        if (outbound_len == 0) {
+                                outbound_len = circ_cnt(&bfin_jc_write_buf);
+                                bfin_write_emudat(outbound_len);
+                                debug("outgoing length: 0x%08x\n", outbound_len);
+                        } else {
+                                struct tty_struct *tty;
+                                int tail = bfin_jc_write_buf.tail;
+                                size_t ate = (4 <= outbound_len ? 4 : outbound_len);
+                                uint32_t emudat =
+                                bfin_write_emudat_chars(
+                                        circ_byte(&bfin_jc_write_buf, tail + 0),
+                                        circ_byte(&bfin_jc_write_buf, tail + 1),
+                                        circ_byte(&bfin_jc_write_buf, tail + 2),
+                                        circ_byte(&bfin_jc_write_buf, tail + 3)
+                                );
+                                bfin_jc_write_buf.tail += ate;
+                                outbound_len -= ate;
+                                mutex_lock(&bfin_jc_tty_mutex);
+                                tty = (struct tty_struct *)bfin_jc_tty;
+                                if (tty)
+                                        tty_wakeup(tty);
+                                mutex_unlock(&bfin_jc_tty_mutex);
+                                debug("  outgoing data: 0x%08x (pushing %zu)\n", emudat, ate);
+                        }
+                }
+        }
+
+        __set_current_state(TASK_RUNNING);
+        return 0;
+}
+
+static int
+bfin_jc_open(struct tty_struct *tty, struct file *filp)
+{
+        mutex_lock(&bfin_jc_tty_mutex);
+        debug("open %lu\n", bfin_jc_count);
+        ++bfin_jc_count;
+        bfin_jc_tty = tty;
+        wake_up_process(bfin_jc_kthread);
+        mutex_unlock(&bfin_jc_tty_mutex);
+        return 0;
+}
+
+static void
+bfin_jc_close(struct tty_struct *tty, struct file *filp)
+{
+        mutex_lock(&bfin_jc_tty_mutex);
+        debug("close %lu\n", bfin_jc_count);
+        if (--bfin_jc_count == 0)
+                bfin_jc_tty = NULL;
+        wake_up_process(bfin_jc_kthread);
+        mutex_unlock(&bfin_jc_tty_mutex);
+}
+
+/* XXX: we dont handle the put_char() case where we must handle count = 1 */
+static int
+bfin_jc_circ_write(const unsigned char *buf, int count)
+{
+        int i;
+        count = min(count, circ_free(&bfin_jc_write_buf));
+        debug("going to write chunk of %i bytes\n", count);
+        for (i = 0; i < count; ++i)
+                circ_byte(&bfin_jc_write_buf, bfin_jc_write_buf.head + i) = buf[i];
+        bfin_jc_write_buf.head += i;
+        return i;
+}
+
+#ifndef CONFIG_BFIN_JTAG_COMM_CONSOLE
+# define acquire_console_sem()
+# define release_console_sem()
+#endif
+static int
+bfin_jc_write(struct tty_struct *tty, const unsigned char *buf, int count)
+{
+        int i;
+        acquire_console_sem();
+        i = bfin_jc_circ_write(buf, count);
+        release_console_sem();
+        wake_up_process(bfin_jc_kthread);
+        return i;
+}
+
+static void
+bfin_jc_flush_chars(struct tty_struct *tty)
+{
+        wake_up_process(bfin_jc_kthread);
+}
+
+static int
+bfin_jc_write_room(struct tty_struct *tty)
+{
+        return circ_free(&bfin_jc_write_buf);
+}
+
+static int
+bfin_jc_chars_in_buffer(struct tty_struct *tty)
+{
+        return circ_cnt(&bfin_jc_write_buf);
+}
+
+static void
+bfin_jc_wait_until_sent(struct tty_struct *tty, int timeout)
+{
+        unsigned long expire = jiffies + timeout;
+        while (!circ_empty(&bfin_jc_write_buf)) {
+                if (signal_pending(current))
+                        break;
+                if (time_after(jiffies, expire))
+                        break;
+        }
+}
+
+static struct tty_operations bfin_jc_ops = {
+        .open            = bfin_jc_open,
+        .close           = bfin_jc_close,
+        .write           = bfin_jc_write,
+        /*.put_char        = bfin_jc_put_char,*/
+        .flush_chars     = bfin_jc_flush_chars,
+        .write_room      = bfin_jc_write_room,
+        .chars_in_buffer = bfin_jc_chars_in_buffer,
+        .wait_until_sent = bfin_jc_wait_until_sent,
+};
+
+static int __init bfin_jc_init(void)
+{
+        int ret;
+
+        bfin_jc_kthread = kthread_create(bfin_jc_emudat_manager, NULL, DRV_NAME);
+        if (IS_ERR(bfin_jc_kthread))
+                return PTR_ERR(bfin_jc_kthread);
+
+        ret = -ENOMEM;
+
+        bfin_jc_write_buf.head = bfin_jc_write_buf.tail = 0;
+        bfin_jc_write_buf.buf = kmalloc(CIRC_SIZE, GFP_KERNEL);
+        if (!bfin_jc_write_buf.buf)
+                goto err;
+
+        bfin_jc_driver = alloc_tty_driver(1);
+        if (!bfin_jc_driver)
+                goto err;
+
+        bfin_jc_driver->owner        = THIS_MODULE;
+        bfin_jc_driver->driver_name  = DRV_NAME;
+        bfin_jc_driver->name         = DEV_NAME;
+        bfin_jc_driver->type         = TTY_DRIVER_TYPE_SERIAL;
+        bfin_jc_driver->subtype      = SERIAL_TYPE_NORMAL;
+        bfin_jc_driver->init_termios = tty_std_termios;
+        tty_set_operations(bfin_jc_driver, &bfin_jc_ops);
+
+        ret = tty_register_driver(bfin_jc_driver);
+        if (ret)
+                goto err;
+
+        pr_init(KERN_INFO DRV_NAME ": initialized\n");
+
+        return 0;
+
+ err:
+        put_tty_driver(bfin_jc_driver);
+        kfree(bfin_jc_write_buf.buf);
+        kthread_stop(bfin_jc_kthread);
+        return ret;
+}
+module_init(bfin_jc_init);
+
+static void __exit bfin_jc_exit(void)
+{
+        kthread_stop(bfin_jc_kthread);
+        kfree(bfin_jc_write_buf.buf);
+        tty_unregister_driver(bfin_jc_driver);
+        put_tty_driver(bfin_jc_driver);
+}
+module_exit(bfin_jc_exit);
+
+#if defined(CONFIG_BFIN_JTAG_COMM_CONSOLE) || defined(CONFIG_EARLY_PRINTK)
+static void
+bfin_jc_straight_buffer_write(const char *buf, unsigned count)
+{
+        unsigned ate = 0;
+        while (bfin_read_DBGSTAT() & EMUDOF)
+                continue;
+        bfin_write_emudat(count);
+        while (ate < count) {
+                while (bfin_read_DBGSTAT() & EMUDOF)
+                        continue;
+                bfin_write_emudat_chars(buf[ate], buf[ate+1], buf[ate+2], buf[ate+3]);
+                ate += 4;
+        }
+}
+#endif
+
+#ifdef CONFIG_BFIN_JTAG_COMM_CONSOLE
+static void
+bfin_jc_console_write(struct console *co, const char *buf, unsigned count)
+{
+        if (bfin_jc_kthread == NULL)
+                bfin_jc_straight_buffer_write(buf, count);
+        else
+                bfin_jc_circ_write(buf, count);
+}
+
+static struct tty_driver *
+bfin_jc_console_device(struct console *co, int *index)
+{
+        *index = co->index;
+        return bfin_jc_driver;
+}
+
+static struct console bfin_jc_console = {
+        .name    = DEV_NAME,
+        .write   = bfin_jc_console_write,
+        .device  = bfin_jc_console_device,
+        .flags   = CON_ANYTIME | CON_PRINTBUFFER,
+        .index   = -1,
+};
+
+static int __init bfin_jc_console_init(void)
+{
+        register_console(&bfin_jc_console);
+        return 0;
+}
+console_initcall(bfin_jc_console_init);
+#endif
+
+#ifdef CONFIG_EARLY_PRINTK
+static void __init
+bfin_jc_early_write(struct console *co, const char *buf, unsigned int count)
+{
+        bfin_jc_straight_buffer_write(buf, count);
+}
+
+static struct __initdata console bfin_jc_early_console = {
+        .name   = "early_BFJC",
+        .write   = bfin_jc_early_write,
+        .flags   = CON_ANYTIME | CON_PRINTBUFFER,
+        .index   = -1,
+};
+
+struct console * __init
+bfin_jc_early_init(unsigned int port, unsigned int cflag)
+{
+        return &bfin_jc_early_console;
+}
+#endif
+
+MODULE_AUTHOR("Mike Frysinger <vapier@gentoo.org>");
+MODULE_DESCRIPTION("TTY over Blackfin JTAG Communication");
+MODULE_LICENSE("GPL");
diff --git a/drivers/char/cyclades.c b/drivers/char/cyclades.c
index 1fdb9f657d8f..f3366d3f06cf 100644
--- a/drivers/char/cyclades.c
+++ b/drivers/char/cyclades.c
@@ -604,7 +604,6 @@
 
 #define NR_PORTS        256
 
-#define ZE_V1_NPORTS    64
 #define ZO_V1   0
 #define ZO_V2   1
 #define ZE_V1   2
@@ -663,18 +662,6 @@
 static void cy_throttle(struct tty_struct *tty);
 static void cy_send_xchar(struct tty_struct *tty, char ch);
 
-#define IS_CYC_Z(card) ((card).num_chips == (unsigned int)-1)
-
-#define Z_FPGA_CHECK(card) \
-        ((readl(&((struct RUNTIME_9060 __iomem *) \
-                ((card).ctl_addr))->init_ctrl) & (1<<17)) != 0)
-
-#define ISZLOADED(card) (((ZO_V1 == readl(&((struct RUNTIME_9060 __iomem *) \
-                        ((card).ctl_addr))->mail_box_0)) || \
-                        Z_FPGA_CHECK(card)) && \
-                        (ZFIRM_ID == readl(&((struct FIRM_ID __iomem *) \
-                        ((card).base_addr+ID_ADDRESS))->signature)))
-
 #ifndef SERIAL_XMIT_SIZE
 #define SERIAL_XMIT_SIZE        (min(PAGE_SIZE, 4096))
 #endif
@@ -687,8 +674,6 @@ static void cy_send_xchar(struct tty_struct *tty, char ch);
 #define DRIVER_VERSION  0x02010203
 #define RAM_SIZE 0x80000
 
-#define Z_FPGA_LOADED(X)        ((readl(&(X)->init_ctrl) & (1<<17)) != 0)
-
 enum zblock_type {
         ZBLOCK_PRG = 0,
         ZBLOCK_FPGA = 1
@@ -883,6 +868,29 @@ static void cyz_rx_restart(unsigned long);
 static struct timer_list cyz_rx_full_timer[NR_PORTS];
 #endif                          /* CONFIG_CYZ_INTR */
 
+static inline bool cy_is_Z(struct cyclades_card *card)
+{
+        return card->num_chips == (unsigned int)-1;
+}
+
+static inline bool __cyz_fpga_loaded(struct RUNTIME_9060 __iomem *ctl_addr)
+{
+        return readl(&ctl_addr->init_ctrl) & (1 << 17);
+}
+
+static inline bool cyz_fpga_loaded(struct cyclades_card *card)
+{
+        return __cyz_fpga_loaded(card->ctl_addr.p9060);
+}
+
+static inline bool cyz_is_loaded(struct cyclades_card *card)
+{
+        struct FIRM_ID __iomem *fw_id = card->base_addr + ID_ADDRESS;
+
+        return (card->hw_ver == ZO_V1 || cyz_fpga_loaded(card)) &&
+                        readl(&fw_id->signature) == ZFIRM_ID;
+}
+
 static inline int serial_paranoia_check(struct cyclades_port *info,
                 char *name, const char *routine)
 {
@@ -1395,19 +1403,15 @@ cyz_fetch_msg(struct cyclades_card *cinfo,
         unsigned long loc_doorbell;
 
         firm_id = cinfo->base_addr + ID_ADDRESS;
-        if (!ISZLOADED(*cinfo))
-                return -1;
         zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
         board_ctrl = &zfw_ctrl->board_ctrl;
 
-        loc_doorbell = readl(&((struct RUNTIME_9060 __iomem *)
-                                  (cinfo->ctl_addr))->loc_doorbell);
+        loc_doorbell = readl(&cinfo->ctl_addr.p9060->loc_doorbell);
         if (loc_doorbell) {
                 *cmd = (char)(0xff & loc_doorbell);
                 *channel = readl(&board_ctrl->fwcmd_channel);
                 *param = (__u32) readl(&board_ctrl->fwcmd_param);
-                cy_writel(&((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->
-                          loc_doorbell, 0xffffffff);
+                cy_writel(&cinfo->ctl_addr.p9060->loc_doorbell, 0xffffffff);
                 return 1;
         }
         return 0;
@@ -1424,15 +1428,14 @@ cyz_issue_cmd(struct cyclades_card *cinfo,
         unsigned int index;
 
         firm_id = cinfo->base_addr + ID_ADDRESS;
-        if (!ISZLOADED(*cinfo))
+        if (!cyz_is_loaded(cinfo))
                 return -1;
 
         zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
         board_ctrl = &zfw_ctrl->board_ctrl;
 
         index = 0;
-        pci_doorbell =
-            &((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->pci_doorbell;
+        pci_doorbell = &cinfo->ctl_addr.p9060->pci_doorbell;
         while ((readl(pci_doorbell) & 0xff) != 0) {
                 if (index++ == 1000)
                         return (int)(readl(pci_doorbell) & 0xff);
@@ -1624,10 +1627,8 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
         static struct BOARD_CTRL __iomem *board_ctrl;
         static struct CH_CTRL __iomem *ch_ctrl;
         static struct BUF_CTRL __iomem *buf_ctrl;
-        __u32 channel;
+        __u32 channel, param, fw_ver;
         __u8 cmd;
-        __u32 param;
-        __u32 hw_ver, fw_ver;
         int special_count;
         int delta_count;
 
@@ -1635,8 +1636,6 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
         zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
         board_ctrl = &zfw_ctrl->board_ctrl;
         fw_ver = readl(&board_ctrl->fw_version);
-        hw_ver = readl(&((struct RUNTIME_9060 __iomem *)(cinfo->ctl_addr))->
-                        mail_box_0);
 
         while (cyz_fetch_msg(cinfo, &channel, &cmd, &param) == 1) {
                 special_count = 0;
@@ -1737,15 +1736,7 @@ static irqreturn_t cyz_interrupt(int irq, void *dev_id)
 {
         struct cyclades_card *cinfo = dev_id;
 
-        if (unlikely(cinfo == NULL)) {
-#ifdef CY_DEBUG_INTERRUPTS
-                printk(KERN_DEBUG "cyz_interrupt: spurious interrupt %d\n",
-                                                                        irq);
-#endif
-                return IRQ_NONE;        /* spurious interrupt */
-        }
-
-        if (unlikely(!ISZLOADED(*cinfo))) {
+        if (unlikely(!cyz_is_loaded(cinfo))) {
 #ifdef CY_DEBUG_INTERRUPTS
                 printk(KERN_DEBUG "cyz_interrupt: board not yet loaded "
                                 "(IRQ%d).\n", irq);
@@ -1785,7 +1776,6 @@ static void cyz_poll(unsigned long arg)
         struct tty_struct *tty;
         struct FIRM_ID __iomem *firm_id;
         struct ZFW_CTRL __iomem *zfw_ctrl;
-        struct BOARD_CTRL __iomem *board_ctrl;
         struct BUF_CTRL __iomem *buf_ctrl;
         unsigned long expires = jiffies + HZ;
         unsigned int port, card;
@@ -1793,19 +1783,17 @@ static void cyz_poll(unsigned long arg)
         for (card = 0; card < NR_CARDS; card++) {
                 cinfo = &cy_card[card];
 
-                if (!IS_CYC_Z(*cinfo))
+                if (!cy_is_Z(cinfo))
                         continue;
-                if (!ISZLOADED(*cinfo))
+                if (!cyz_is_loaded(cinfo))
                         continue;
 
                 firm_id = cinfo->base_addr + ID_ADDRESS;
                 zfw_ctrl = cinfo->base_addr +
                                 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
-                board_ctrl = &(zfw_ctrl->board_ctrl);
 
         /* Skip first polling cycle to avoid racing conditions with the FW */
                 if (!cinfo->intr_enabled) {
-                        cinfo->nports = (int)readl(&board_ctrl->n_channel);
                         cinfo->intr_enabled = 1;
                         continue;
                 }
@@ -1874,7 +1862,7 @@ static int startup(struct cyclades_port *info)
 
         set_line_char(info);
 
-        if (!IS_CYC_Z(*card)) {
+        if (!cy_is_Z(card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
                 index = card->bus_index;
@@ -1931,7 +1919,7 @@ static int startup(struct cyclades_port *info)
                 base_addr = card->base_addr;
 
                 firm_id = base_addr + ID_ADDRESS;
-                if (!ISZLOADED(*card))
+                if (!cyz_is_loaded(card))
                         return -ENODEV;
 
                 zfw_ctrl = card->base_addr +
@@ -2026,7 +2014,7 @@ static void start_xmit(struct cyclades_port *info)
 
         card = info->card;
         channel = info->line - card->first_line;
-        if (!IS_CYC_Z(*card)) {
+        if (!cy_is_Z(card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
                 index = card->bus_index;
@@ -2070,7 +2058,7 @@ static void shutdown(struct cyclades_port *info)
 
         card = info->card;
         channel = info->line - card->first_line;
-        if (!IS_CYC_Z(*card)) {
+        if (!cy_is_Z(card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
                 index = card->bus_index;
@@ -2126,7 +2114,7 @@ static void shutdown(struct cyclades_port *info)
 #endif
 
                 firm_id = base_addr + ID_ADDRESS;
-                if (!ISZLOADED(*card))
+                if (!cyz_is_loaded(card))
                         return;
 
                 zfw_ctrl = card->base_addr +
@@ -2233,7 +2221,7 @@ block_til_ready(struct tty_struct *tty, struct file *filp,
 #endif
         info->port.blocked_open++;
 
-        if (!IS_CYC_Z(*cinfo)) {
+        if (!cy_is_Z(cinfo)) {
                 chip = channel >> 2;
                 channel &= 0x03;
                 index = cinfo->bus_index;
@@ -2296,7 +2284,7 @@ block_til_ready(struct tty_struct *tty, struct file *filp,
 
                 base_addr = cinfo->base_addr;
                 firm_id = base_addr + ID_ADDRESS;
-                if (!ISZLOADED(*cinfo)) {
+                if (!cyz_is_loaded(cinfo)) {
                         __set_current_state(TASK_RUNNING);
                         remove_wait_queue(&info->port.open_wait, &wait);
                         return -EINVAL;
@@ -2397,16 +2385,14 @@ static int cy_open(struct tty_struct *tty, struct file *filp)
            treat it as absent from the system.  This
            will make the user pay attention.
          */
-        if (IS_CYC_Z(*info->card)) {
+        if (cy_is_Z(info->card)) {
                 struct cyclades_card *cinfo = info->card;
                 struct FIRM_ID __iomem *firm_id = cinfo->base_addr + ID_ADDRESS;
 
-                if (!ISZLOADED(*cinfo)) {
-                        if (((ZE_V1 == readl(&((struct RUNTIME_9060 __iomem *)
-                                         (cinfo->ctl_addr))->mail_box_0)) &&
-                                        Z_FPGA_CHECK(*cinfo)) &&
-                                        (ZFIRM_HLT == readl(
-                                                &firm_id->signature))) {
+                if (!cyz_is_loaded(cinfo)) {
+                        if (cinfo->hw_ver == ZE_V1 && cyz_fpga_loaded(cinfo) &&
+                                        readl(&firm_id->signature) ==
+                                        ZFIRM_HLT) {
                                 printk(KERN_ERR "cyc:Cyclades-Z Error: you "
                                         "need an external power supply for "
                                         "this number of ports.\nFirmware "
@@ -2423,18 +2409,13 @@ static int cy_open(struct tty_struct *tty, struct file *filp)
                    interrupts should be enabled as soon as the first open
                    happens to one of its ports. */
                         if (!cinfo->intr_enabled) {
-                                struct ZFW_CTRL __iomem *zfw_ctrl;
-                                struct BOARD_CTRL __iomem *board_ctrl;
-
-                                zfw_ctrl = cinfo->base_addr +
-                                        (readl(&firm_id->zfwctrl_addr) &
-                                         0xfffff);
-
-                                board_ctrl = &zfw_ctrl->board_ctrl;
+                                u16 intr;
 
                                 /* Enable interrupts on the PLX chip */
-                                cy_writew(cinfo->ctl_addr + 0x68,
-                                        readw(cinfo->ctl_addr + 0x68) | 0x0900);
+                                intr = readw(&cinfo->ctl_addr.p9060->
+                                                intr_ctrl_stat) | 0x0900;
+                                cy_writew(&cinfo->ctl_addr.p9060->
+                                                intr_ctrl_stat, intr);
                                 /* Enable interrupts on the FW */
                                 retval = cyz_issue_cmd(cinfo, 0,
                                                 C_CM_IRQ_ENBL, 0L);
@@ -2442,8 +2423,6 @@ static int cy_open(struct tty_struct *tty, struct file *filp)
                                         printk(KERN_ERR "cyc:IRQ enable retval "
                                                 "was %x\n", retval);
                                 }
-                                cinfo->nports =
-                                        (int)readl(&board_ctrl->n_channel);
                                 cinfo->intr_enabled = 1;
                         }
                 }
@@ -2556,7 +2535,7 @@ static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
 #endif
         card = info->card;
         channel = (info->line) - (card->first_line);
-        if (!IS_CYC_Z(*card)) {
+        if (!cy_is_Z(card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
                 index = card->bus_index;
@@ -2601,7 +2580,7 @@ static void cy_flush_buffer(struct tty_struct *tty)
         info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
         spin_unlock_irqrestore(&card->card_lock, flags);
 
-        if (IS_CYC_Z(*card)) {  /* If it is a Z card, flush the on-board
+        if (cy_is_Z(card)) {    /* If it is a Z card, flush the on-board
                                            buffers as well */
                 spin_lock_irqsave(&card->card_lock, flags);
                 retval = cyz_issue_cmd(card, channel, C_CM_FLUSH_TX, 0L);
@@ -2682,7 +2661,7 @@ static void cy_close(struct tty_struct *tty, struct file *filp)
 
         spin_lock_irqsave(&card->card_lock, flags);
 
-        if (!IS_CYC_Z(*card)) {
+        if (!cy_is_Z(card)) {
                 int channel = info->line - card->first_line;
                 int index = card->bus_index;
                 void __iomem *base_addr = card->base_addr +
@@ -2902,7 +2881,7 @@ static int cy_chars_in_buffer(struct tty_struct *tty)
         channel = (info->line) - (card->first_line);
 
 #ifdef Z_EXT_CHARS_IN_BUFFER
-        if (!IS_CYC_Z(cy_card[card])) {
+        if (!cy_is_Z(card)) {
 #endif                          /* Z_EXT_CHARS_IN_BUFFER */
 #ifdef CY_DEBUG_IO
                 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
@@ -2984,7 +2963,6 @@ static void set_line_char(struct cyclades_port *info)
         void __iomem *base_addr;
         int chip, channel, index;
         unsigned cflag, iflag;
-        unsigned short chip_number;
         int baud, baud_rate = 0;
         int i;
 
@@ -3013,9 +2991,8 @@ static void set_line_char(struct cyclades_port *info)
 
         card = info->card;
         channel = info->line - card->first_line;
-        chip_number = channel / 4;
 
-        if (!IS_CYC_Z(*card)) {
+        if (!cy_is_Z(card)) {
 
                 index = card->bus_index;
 
@@ -3233,21 +3210,17 @@ static void set_line_char(struct cyclades_port *info)
         } else {
                 struct FIRM_ID __iomem *firm_id;
                 struct ZFW_CTRL __iomem *zfw_ctrl;
-                struct BOARD_CTRL __iomem *board_ctrl;
                 struct CH_CTRL __iomem *ch_ctrl;
-                struct BUF_CTRL __iomem *buf_ctrl;
                 __u32 sw_flow;
                 int retval;
 
                 firm_id = card->base_addr + ID_ADDRESS;
-                if (!ISZLOADED(*card))
+                if (!cyz_is_loaded(card))
                         return;
 
                 zfw_ctrl = card->base_addr +
                         (readl(&firm_id->zfwctrl_addr) & 0xfffff);
-                board_ctrl = &zfw_ctrl->board_ctrl;
                 ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
-                buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
 
                 /* baud rate */
                 baud = tty_get_baud_rate(info->port.tty);
@@ -3457,7 +3430,7 @@ static int get_lsr_info(struct cyclades_port *info, unsigned int __user *value)
 
         card = info->card;
         channel = (info->line) - (card->first_line);
-        if (!IS_CYC_Z(*card)) {
+        if (!cy_is_Z(card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
                 index = card->bus_index;
@@ -3497,7 +3470,7 @@ static int cy_tiocmget(struct tty_struct *tty, struct file *file)
 
         card = info->card;
         channel = info->line - card->first_line;
-        if (!IS_CYC_Z(*card)) {
+        if (!cy_is_Z(card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
                 index = card->bus_index;
@@ -3523,7 +3496,7 @@ static int cy_tiocmget(struct tty_struct *tty, struct file *file)
         } else {
                 base_addr = card->base_addr;
                 firm_id = card->base_addr + ID_ADDRESS;
-                if (ISZLOADED(*card)) {
+                if (cyz_is_loaded(card)) {
                         zfw_ctrl = card->base_addr +
                                 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
                         board_ctrl = &zfw_ctrl->board_ctrl;
@@ -3566,7 +3539,7 @@ cy_tiocmset(struct tty_struct *tty, struct file *file,
 
         card = info->card;
         channel = (info->line) - (card->first_line);
-        if (!IS_CYC_Z(*card)) {
+        if (!cy_is_Z(card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
                 index = card->bus_index;
@@ -3641,7 +3614,7 @@ cy_tiocmset(struct tty_struct *tty, struct file *file,
                 base_addr = card->base_addr;
 
                 firm_id = card->base_addr + ID_ADDRESS;
-                if (ISZLOADED(*card)) {
+                if (cyz_is_loaded(card)) {
                         zfw_ctrl = card->base_addr +
                                 (readl(&firm_id->zfwctrl_addr) & 0xfffff);
                         board_ctrl = &zfw_ctrl->board_ctrl;
@@ -3713,7 +3686,7 @@ static int cy_break(struct tty_struct *tty, int break_state)
         card = info->card;
 
         spin_lock_irqsave(&card->card_lock, flags);
-        if (!IS_CYC_Z(*card)) {
+        if (!cy_is_Z(card)) {
                 /* Let the transmit ISR take care of this (since it
                    requires stuffing characters into the output stream).
                  */
@@ -3782,7 +3755,7 @@ static int set_threshold(struct cyclades_port *info, unsigned long value)
 
         card = info->card;
         channel = info->line - card->first_line;
-        if (!IS_CYC_Z(*card)) {
+        if (!cy_is_Z(card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
                 index = card->bus_index;
@@ -3810,7 +3783,7 @@ static int get_threshold(struct cyclades_port *info,
 
         card = info->card;
         channel = info->line - card->first_line;
-        if (!IS_CYC_Z(*card)) {
+        if (!cy_is_Z(card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
                 index = card->bus_index;
@@ -3844,7 +3817,7 @@ static int set_timeout(struct cyclades_port *info, unsigned long value)
 
         card = info->card;
         channel = info->line - card->first_line;
-        if (!IS_CYC_Z(*card)) {
+        if (!cy_is_Z(card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
                 index = card->bus_index;
@@ -3867,7 +3840,7 @@ static int get_timeout(struct cyclades_port *info,
 
         card = info->card;
         channel = info->line - card->first_line;
-        if (!IS_CYC_Z(*card)) {
+        if (!cy_is_Z(card)) {
                 chip = channel >> 2;
                 channel &= 0x03;
                 index = card->bus_index;
@@ -4121,7 +4094,7 @@ static void cy_send_xchar(struct tty_struct *tty, char ch)
         card = info->card;
         channel = info->line - card->first_line;
 
-        if (IS_CYC_Z(*card)) {
+        if (cy_is_Z(card)) {
                 if (ch == STOP_CHAR(tty))
                         cyz_issue_cmd(card, channel, C_CM_SENDXOFF, 0L);
                 else if (ch == START_CHAR(tty))
@@ -4154,7 +4127,7 @@ static void cy_throttle(struct tty_struct *tty)
         card = info->card;
 
         if (I_IXOFF(tty)) {
-                if (!IS_CYC_Z(*card))
+                if (!cy_is_Z(card))
                         cy_send_xchar(tty, STOP_CHAR(tty));
                 else
                         info->throttle = 1;
@@ -4162,7 +4135,7 @@ static void cy_throttle(struct tty_struct *tty)
 
         if (tty->termios->c_cflag & CRTSCTS) {
                 channel = info->line - card->first_line;
-                if (!IS_CYC_Z(*card)) {
+                if (!cy_is_Z(card)) {
                         chip = channel >> 2;
                         channel &= 0x03;
                         index = card->bus_index;
@@ -4219,7 +4192,7 @@ static void cy_unthrottle(struct tty_struct *tty)
         if (tty->termios->c_cflag & CRTSCTS) {
                 card = info->card;
                 channel = info->line - card->first_line;
-                if (!IS_CYC_Z(*card)) {
+                if (!cy_is_Z(card)) {
                         chip = channel >> 2;
                         channel &= 0x03;
                         index = card->bus_index;
@@ -4263,7 +4236,7 @@ static void cy_stop(struct tty_struct *tty)
 
         cinfo = info->card;
         channel = info->line - cinfo->first_line;
-        if (!IS_CYC_Z(*cinfo)) {
+        if (!cy_is_Z(cinfo)) {
                 index = cinfo->bus_index;
                 chip = channel >> 2;
                 channel &= 0x03;
@@ -4296,7 +4269,7 @@ static void cy_start(struct tty_struct *tty)
         cinfo = info->card;
         channel = info->line - cinfo->first_line;
         index = cinfo->bus_index;
-        if (!IS_CYC_Z(*cinfo)) {
+        if (!cy_is_Z(cinfo)) {
                 chip = channel >> 2;
                 channel &= 0x03;
                 base_addr = cinfo->base_addr + (cy_chip_offset[chip] << index);
@@ -4347,33 +4320,20 @@ static void cy_hangup(struct tty_struct *tty)
 static int __devinit cy_init_card(struct cyclades_card *cinfo)
 {
         struct cyclades_port *info;
-        u32 uninitialized_var(mailbox);
-        unsigned int nports, port;
+        unsigned int port;
         unsigned short chip_number;
-        int uninitialized_var(index);
 
         spin_lock_init(&cinfo->card_lock);
+        cinfo->intr_enabled = 0;
 
-        if (IS_CYC_Z(*cinfo)) { /* Cyclades-Z */
-                mailbox = readl(&((struct RUNTIME_9060 __iomem *)
-                                     cinfo->ctl_addr)->mail_box_0);
-                nports = (mailbox == ZE_V1) ? ZE_V1_NPORTS : 8;
-                cinfo->intr_enabled = 0;
-                cinfo->nports = 0;      /* Will be correctly set later, after
-                                           Z FW is loaded */
-        } else {
-                index = cinfo->bus_index;
-                nports = cinfo->nports = CyPORTS_PER_CHIP * cinfo->num_chips;
-        }
-
-        cinfo->ports = kzalloc(sizeof(*cinfo->ports) * nports, GFP_KERNEL);
+        cinfo->ports = kcalloc(cinfo->nports, sizeof(*cinfo->ports),
+                        GFP_KERNEL);
         if (cinfo->ports == NULL) {
                 printk(KERN_ERR "Cyclades: cannot allocate ports\n");
-                cinfo->nports = 0;
                 return -ENOMEM;
         }
 
-        for (port = cinfo->first_line; port < cinfo->first_line + nports;
+        for (port = cinfo->first_line; port < cinfo->first_line + cinfo->nports;
                         port++) {
                 info = &cinfo->ports[port - cinfo->first_line];
                 tty_port_init(&info->port);
@@ -4387,9 +4347,9 @@ static int __devinit cy_init_card(struct cyclades_card *cinfo)
                 init_completion(&info->shutdown_wait);
                 init_waitqueue_head(&info->delta_msr_wait);
 
-                if (IS_CYC_Z(*cinfo)) {
+                if (cy_is_Z(cinfo)) {
                         info->type = PORT_STARTECH;
-                        if (mailbox == ZO_V1)
+                        if (cinfo->hw_ver == ZO_V1)
                                 info->xmit_fifo_size = CYZ_FIFO_SIZE;
                         else
                                 info->xmit_fifo_size = 4 * CYZ_FIFO_SIZE;
@@ -4398,6 +4358,7 @@ static int __devinit cy_init_card(struct cyclades_card *cinfo)
                                 cyz_rx_restart, (unsigned long)info);
 #endif
                 } else {
+                        int index = cinfo->bus_index;
                         info->type = PORT_CIRRUS;
                         info->xmit_fifo_size = CyMAX_CHAR_FIFO;
                         info->cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
@@ -4430,7 +4391,7 @@ static int __devinit cy_init_card(struct cyclades_card *cinfo)
         }
 
 #ifndef CONFIG_CYZ_INTR
-        if (IS_CYC_Z(*cinfo) && !timer_pending(&cyz_timerlist)) {
+        if (cy_is_Z(cinfo) && !timer_pending(&cyz_timerlist)) {
                 mod_timer(&cyz_timerlist, jiffies + 1);
 #ifdef CY_PCI_DEBUG
                 printk(KERN_DEBUG "Cyclades-Z polling initialized\n");
@@ -4621,11 +4582,12 @@ static int __init cy_detect_isa(void)
 
                 /* set cy_card */
                 cy_card[j].base_addr = cy_isa_address;
-                cy_card[j].ctl_addr = NULL;
+                cy_card[j].ctl_addr.p9050 = NULL;
                 cy_card[j].irq = (int)cy_isa_irq;
                 cy_card[j].bus_index = 0;
                 cy_card[j].first_line = cy_next_channel;
-                cy_card[j].num_chips = cy_isa_nchan / 4;
+                cy_card[j].num_chips = cy_isa_nchan / CyPORTS_PER_CHIP;
+                cy_card[j].nports = cy_isa_nchan;
                 if (cy_init_card(&cy_card[j])) {
                         cy_card[j].base_addr = NULL;
                         free_irq(cy_isa_irq, &cy_card[j]);
@@ -4781,7 +4743,7 @@ static int __devinit cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
         struct CUSTOM_REG __iomem *cust = base_addr;
         struct ZFW_CTRL __iomem *pt_zfwctrl;
         void __iomem *tmp;
-        u32 mailbox, status;
+        u32 mailbox, status, nchan;
         unsigned int i;
         int retval;
 
@@ -4793,7 +4755,7 @@ static int __devinit cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
 
         /* Check whether the firmware is already loaded and running. If
            positive, skip this board */
-        if (Z_FPGA_LOADED(ctl_addr) && readl(&fid->signature) == ZFIRM_ID) {
+        if (__cyz_fpga_loaded(ctl_addr) && readl(&fid->signature) == ZFIRM_ID) {
                 u32 cntval = readl(base_addr + 0x190);
 
                 udelay(100);
@@ -4812,7 +4774,7 @@ static int __devinit cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
 
         mailbox = readl(&ctl_addr->mail_box_0);
 
-        if (mailbox == 0 || Z_FPGA_LOADED(ctl_addr)) {
+        if (mailbox == 0 || __cyz_fpga_loaded(ctl_addr)) {
                 /* stops CPU and set window to beginning of RAM */
                 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
                 cy_writel(&cust->cpu_stop, 0);
@@ -4828,7 +4790,7 @@ static int __devinit cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
                                 base_addr);
                 if (retval)
                         goto err_rel;
-                if (!Z_FPGA_LOADED(ctl_addr)) {
+                if (!__cyz_fpga_loaded(ctl_addr)) {
                         dev_err(&pdev->dev, "fw upload successful, but fw is "
                                         "not loaded\n");
                         goto err_rel;
@@ -4887,7 +4849,7 @@ static int __devinit cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
                                 "system before loading the new FW to the "
                                 "Cyclades-Z.\n");
 
-                        if (Z_FPGA_LOADED(ctl_addr))
+                        if (__cyz_fpga_loaded(ctl_addr))
                                 plx_init(pdev, irq, ctl_addr);
 
                         retval = -EIO;
@@ -4902,16 +4864,16 @@ static int __devinit cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
                         base_addr + ID_ADDRESS, readl(&fid->zfwctrl_addr),
                         base_addr + readl(&fid->zfwctrl_addr));
 
+        nchan = readl(&pt_zfwctrl->board_ctrl.n_channel);
         dev_info(&pdev->dev, "Cyclades-Z FW loaded: version = %x, ports = %u\n",
-                readl(&pt_zfwctrl->board_ctrl.fw_version),
-                readl(&pt_zfwctrl->board_ctrl.n_channel));
+                readl(&pt_zfwctrl->board_ctrl.fw_version), nchan);
 
-        if (readl(&pt_zfwctrl->board_ctrl.n_channel) == 0) {
+        if (nchan == 0) {
                 dev_warn(&pdev->dev, "no Cyclades-Z ports were found. Please "
                         "check the connection between the Z host card and the "
                         "serial expanders.\n");
 
-                if (Z_FPGA_LOADED(ctl_addr))
+                if (__cyz_fpga_loaded(ctl_addr))
                         plx_init(pdev, irq, ctl_addr);
 
                 dev_info(&pdev->dev, "Null number of ports detected. Board "
@@ -4932,9 +4894,7 @@ static int __devinit cyz_load_fw(struct pci_dev *pdev, void __iomem *base_addr,
         cy_writel(&ctl_addr->intr_ctrl_stat, readl(&ctl_addr->intr_ctrl_stat) |
                         0x00030800UL);
 
-        plx_init(pdev, irq, ctl_addr);
-
-        return 0;
+        return nchan;
 err_rel:
         release_firmware(fw);
 err:
@@ -4946,7 +4906,7 @@ static int __devinit cy_pci_probe(struct pci_dev *pdev,
 {
         void __iomem *addr0 = NULL, *addr2 = NULL;
         char *card_name = NULL;
-        u32 mailbox;
+        u32 uninitialized_var(mailbox);
         unsigned int device_id, nchan = 0, card_no, i;
         unsigned char plx_ver;
         int retval, irq;
@@ -5023,11 +4983,12 @@ static int __devinit cy_pci_probe(struct pci_dev *pdev,
                 }
 
                 /* Disable interrupts on the PLX before resetting it */
-                cy_writew(addr0 + 0x68, readw(addr0 + 0x68) & ~0x0900);
+                cy_writew(&ctl_addr->intr_ctrl_stat,
+                                readw(&ctl_addr->intr_ctrl_stat) & ~0x0900);
 
                 plx_init(pdev, irq, addr0);
 
-                mailbox = (u32)readl(&ctl_addr->mail_box_0);
+                mailbox = readl(&ctl_addr->mail_box_0);
 
                 addr2 = ioremap_nocache(pci_resource_start(pdev, 2),
                                 mailbox == ZE_V1 ? CyPCI_Ze_win : CyPCI_Zwin);
@@ -5038,12 +4999,8 @@ static int __devinit cy_pci_probe(struct pci_dev *pdev,
 
                 if (mailbox == ZE_V1) {
                         card_name = "Cyclades-Ze";
-
-                        readl(&ctl_addr->mail_box_0);
-                        nchan = ZE_V1_NPORTS;
                 } else {
                         card_name = "Cyclades-8Zo";
-
 #ifdef CY_PCI_DEBUG
                         if (mailbox == ZO_V1) {
                                 cy_writel(&ctl_addr->loc_addr_base, WIN_CREG);
@@ -5065,15 +5022,12 @@ static int __devinit cy_pci_probe(struct pci_dev *pdev,
                          */
                         if ((mailbox == ZO_V1) || (mailbox == ZO_V2))
                                 cy_writel(addr2 + ID_ADDRESS, 0L);
-
-                        retval = cyz_load_fw(pdev, addr2, addr0, irq);
-                        if (retval)
-                                goto err_unmap;
-                        /* This must be a Cyclades-8Zo/PCI.  The extendable
-                           version will have a different device_id and will
-                           be allocated its maximum number of ports. */
-                        nchan = 8;
                 }
+
+                retval = cyz_load_fw(pdev, addr2, addr0, irq);
+                if (retval <= 0)
+                        goto err_unmap;
+                nchan = retval;
         }
 
         if ((cy_next_channel + nchan) > NR_PORTS) {
@@ -5103,8 +5057,10 @@ static int __devinit cy_pci_probe(struct pci_dev *pdev,
                         dev_err(&pdev->dev, "could not allocate IRQ\n");
                         goto err_unmap;
                 }
-                cy_card[card_no].num_chips = nchan / 4;
+                cy_card[card_no].num_chips = nchan / CyPORTS_PER_CHIP;
         } else {
+                cy_card[card_no].hw_ver = mailbox;
+                cy_card[card_no].num_chips = (unsigned int)-1;
 #ifdef CONFIG_CYZ_INTR
                 /* allocate IRQ only if board has an IRQ */
                 if (irq != 0 && irq != 255) {
@@ -5117,15 +5073,15 @@ static int __devinit cy_pci_probe(struct pci_dev *pdev,
                         }
                 }
 #endif                          /* CONFIG_CYZ_INTR */
-                cy_card[card_no].num_chips = (unsigned int)-1;
         }
 
         /* set cy_card */
         cy_card[card_no].base_addr = addr2;
-        cy_card[card_no].ctl_addr = addr0;
+        cy_card[card_no].ctl_addr.p9050 = addr0;
         cy_card[card_no].irq = irq;
         cy_card[card_no].bus_index = 1;
         cy_card[card_no].first_line = cy_next_channel;
+        cy_card[card_no].nports = nchan;
         retval = cy_init_card(&cy_card[card_no]);
         if (retval)
                 goto err_null;
@@ -5138,17 +5094,20 @@ static int __devinit cy_pci_probe(struct pci_dev *pdev,
                 plx_ver = readb(addr2 + CyPLX_VER) & 0x0f;
                 switch (plx_ver) {
                 case PLX_9050:
-
                         cy_writeb(addr0 + 0x4c, 0x43);
                         break;
 
                 case PLX_9060:
                 case PLX_9080:
                 default:        /* Old boards, use PLX_9060 */
-                        plx_init(pdev, irq, addr0);
-                        cy_writew(addr0 + 0x68, readw(addr0 + 0x68) | 0x0900);
+                {
+                        struct RUNTIME_9060 __iomem *ctl_addr = addr0;
+                        plx_init(pdev, irq, ctl_addr);
+                        cy_writew(&ctl_addr->intr_ctrl_stat,
+                                readw(&ctl_addr->intr_ctrl_stat) | 0x0900);
                         break;
                 }
+                }
         }
 
         dev_info(&pdev->dev, "%s/PCI #%d found: %d channels starting from "
@@ -5179,22 +5138,23 @@ static void __devexit cy_pci_remove(struct pci_dev *pdev)
         unsigned int i;
 
         /* non-Z with old PLX */
-        if (!IS_CYC_Z(*cinfo) && (readb(cinfo->base_addr + CyPLX_VER) & 0x0f) ==
+        if (!cy_is_Z(cinfo) && (readb(cinfo->base_addr + CyPLX_VER) & 0x0f) ==
                         PLX_9050)
-                cy_writeb(cinfo->ctl_addr + 0x4c, 0);
+                cy_writeb(cinfo->ctl_addr.p9050 + 0x4c, 0);
         else
 #ifndef CONFIG_CYZ_INTR
-                if (!IS_CYC_Z(*cinfo))
+                if (!cy_is_Z(cinfo))
 #endif
-                cy_writew(cinfo->ctl_addr + 0x68,
-                                readw(cinfo->ctl_addr + 0x68) & ~0x0900);
+                cy_writew(&cinfo->ctl_addr.p9060->intr_ctrl_stat,
+                        readw(&cinfo->ctl_addr.p9060->intr_ctrl_stat) &
+                        ~0x0900);
 
         iounmap(cinfo->base_addr);
-        if (cinfo->ctl_addr)
-                iounmap(cinfo->ctl_addr);
+        if (cinfo->ctl_addr.p9050)
+                iounmap(cinfo->ctl_addr.p9050);
         if (cinfo->irq
 #ifndef CONFIG_CYZ_INTR
-                && !IS_CYC_Z(*cinfo)
+                && !cy_is_Z(cinfo)
 #endif /* CONFIG_CYZ_INTR */
                 )
                 free_irq(cinfo->irq, cinfo);
@@ -5240,7 +5200,7 @@ static int cyclades_proc_show(struct seq_file *m, void *v)
                                         (cur_jifs - info->idle_stats.recv_idle)/
                                         HZ, info->idle_stats.overruns,
                                         /* FIXME: double check locking */
-                                        (long)info->port.tty->ldisc.ops->num);
+                                        (long)info->port.tty->ldisc->ops->num);
                         else
                                 seq_printf(m, "%3d %8lu %10lu %8lu "
                                         "%10lu %8lu %9lu %6ld\n",
@@ -5386,11 +5346,11 @@ static void __exit cy_cleanup_module(void)
                         /* clear interrupt */
                         cy_writeb(card->base_addr + Cy_ClrIntr, 0);
                         iounmap(card->base_addr);
-                        if (card->ctl_addr)
-                                iounmap(card->ctl_addr);
+                        if (card->ctl_addr.p9050)
+                                iounmap(card->ctl_addr.p9050);
                         if (card->irq
 #ifndef CONFIG_CYZ_INTR
-                                && !IS_CYC_Z(*card)
+                                && !cy_is_Z(card)
 #endif /* CONFIG_CYZ_INTR */
                                 )
                                 free_irq(card->irq, card);
diff --git a/drivers/char/epca.c b/drivers/char/epca.c
index af7c13ca9493..abef1f7d84fe 100644
--- a/drivers/char/epca.c
+++ b/drivers/char/epca.c
@@ -745,7 +745,7 @@ static int epca_carrier_raised(struct tty_port *port)
         return 0;
 }
 
-static void epca_raise_dtr_rts(struct tty_port *port)
+static void epca_dtr_rts(struct tty_port *port, int onoff)
 {
 }
 
@@ -925,7 +925,7 @@ static const struct tty_operations pc_ops = {
 
 static const struct tty_port_operations epca_port_ops = {
         .carrier_raised = epca_carrier_raised,
-        .raise_dtr_rts = epca_raise_dtr_rts,
+        .dtr_rts = epca_dtr_rts,
 };
 
 static int info_open(struct tty_struct *tty, struct file *filp)
@@ -1518,7 +1518,7 @@ static void doevent(int crd)
                 if (event & MODEMCHG_IND) {
                         /* A modem signal change has been indicated */
                         ch->imodem = mstat;
-                        if (test_bit(ASYNC_CHECK_CD, &ch->port.flags)) {
+                        if (test_bit(ASYNCB_CHECK_CD, &ch->port.flags)) {
                                 /* We are now receiving dcd */
                                 if (mstat & ch->dcd)
                                         wake_up_interruptible(&ch->port.open_wait);
@@ -1765,9 +1765,9 @@ static void epcaparam(struct tty_struct *tty, struct channel *ch)
                  * that the driver will wait on carrier detect.
                  */
                 if (ts->c_cflag & CLOCAL)
-                        clear_bit(ASYNC_CHECK_CD, &ch->port.flags);
+                        clear_bit(ASYNCB_CHECK_CD, &ch->port.flags);
                 else
-                        set_bit(ASYNC_CHECK_CD, &ch->port.flags);
+                        set_bit(ASYNCB_CHECK_CD, &ch->port.flags);
                 mval = ch->m_dtr | ch->m_rts;
         } /* End CBAUD not detected */
         iflag = termios2digi_i(ch, ts->c_iflag);
@@ -2114,8 +2114,8 @@ static int pc_ioctl(struct tty_struct *tty, struct file *file,
                         tty_wait_until_sent(tty, 0);
                 } else {
                         /* ldisc lock already held in ioctl */
-                        if (tty->ldisc.ops->flush_buffer)
-                                tty->ldisc.ops->flush_buffer(tty);
+                        if (tty->ldisc->ops->flush_buffer)
+                                tty->ldisc->ops->flush_buffer(tty);
                 }
                 unlock_kernel();
                 /* Fall Thru */
@@ -2244,7 +2244,8 @@ static void do_softint(struct work_struct *work)
                         if (test_and_clear_bit(EPCA_EVENT_HANGUP, &ch->event)) {
                                 tty_hangup(tty);
                                 wake_up_interruptible(&ch->port.open_wait);
-                                clear_bit(ASYNC_NORMAL_ACTIVE, &ch->port.flags);
+                                clear_bit(ASYNCB_NORMAL_ACTIVE,
+                                                &ch->port.flags);
                         }
                 }
                 tty_kref_put(tty);
diff --git a/drivers/char/ip2/i2lib.c b/drivers/char/ip2/i2lib.c
index 0061e18aff60..0d10b89218ed 100644
--- a/drivers/char/ip2/i2lib.c
+++ b/drivers/char/ip2/i2lib.c
@@ -868,11 +868,11 @@ i2Input(i2ChanStrPtr pCh)
                 amountToMove = count;
         }
         // Move the first block
-        pCh->pTTY->ldisc.ops->receive_buf( pCh->pTTY,
+        pCh->pTTY->ldisc->ops->receive_buf( pCh->pTTY,
                  &(pCh->Ibuf[stripIndex]), NULL, amountToMove );
         // If we needed to wrap, do the second data move
         if (count > amountToMove) {
-                pCh->pTTY->ldisc.ops->receive_buf( pCh->pTTY,
+                pCh->pTTY->ldisc->ops->receive_buf( pCh->pTTY,
                  pCh->Ibuf, NULL, count - amountToMove );
         }
         // Bump and wrap the stripIndex all at once by the amount of data read. This
diff --git a/drivers/char/ip2/ip2main.c b/drivers/char/ip2/ip2main.c
index afd9247cf082..517271c762e6 100644
--- a/drivers/char/ip2/ip2main.c
+++ b/drivers/char/ip2/ip2main.c
@@ -1315,8 +1315,8 @@ static inline void  isig(int sig, struct tty_struct *tty, int flush)
         if (tty->pgrp)
                 kill_pgrp(tty->pgrp, sig, 1);
         if (flush || !L_NOFLSH(tty)) {
-                if ( tty->ldisc.ops->flush_buffer )  
-                        tty->ldisc.ops->flush_buffer(tty);
+                if ( tty->ldisc->ops->flush_buffer )  
+                        tty->ldisc->ops->flush_buffer(tty);
                 i2InputFlush( tty->driver_data );
         }
 }
diff --git a/drivers/char/isicom.c b/drivers/char/isicom.c
index a59eac584d16..4d745a89504f 100644
--- a/drivers/char/isicom.c
+++ b/drivers/char/isicom.c
@@ -329,7 +329,7 @@ static inline void drop_rts(struct isi_port *port)
 
 /* card->lock MUST NOT be held */
 
-static void isicom_raise_dtr_rts(struct tty_port *port)
+static void isicom_dtr_rts(struct tty_port *port, int on)
 {
         struct isi_port *ip = container_of(port, struct isi_port, port);
         struct isi_board *card = ip->card;
@@ -339,10 +339,17 @@ static void isicom_raise_dtr_rts(struct tty_port *port)
         if (!lock_card(card))
                 return;
 
-        outw(0x8000 | (channel << card->shift_count) | 0x02, base);
-        outw(0x0f04, base);
-        InterruptTheCard(base);
-        ip->status |= (ISI_DTR | ISI_RTS);
+        if (on) {
+                outw(0x8000 | (channel << card->shift_count) | 0x02, base);
+                outw(0x0f04, base);
+                InterruptTheCard(base);
+                ip->status |= (ISI_DTR | ISI_RTS);
+        } else {
+                outw(0x8000 | (channel << card->shift_count) | 0x02, base);
+                outw(0x0C04, base);
+                InterruptTheCard(base);
+                ip->status &= ~(ISI_DTR | ISI_RTS);
+        }
         unlock_card(card);
 }
 
@@ -1339,7 +1346,7 @@ static const struct tty_operations isicom_ops = {
 
 static const struct tty_port_operations isicom_port_ops = {
         .carrier_raised         = isicom_carrier_raised,
-        .raise_dtr_rts          = isicom_raise_dtr_rts,
+        .dtr_rts                = isicom_dtr_rts,
 };
 
 static int __devinit reset_card(struct pci_dev *pdev,
diff --git a/drivers/char/istallion.c b/drivers/char/istallion.c
index fff19f7e29d2..e18800c400b1 100644
--- a/drivers/char/istallion.c
+++ b/drivers/char/istallion.c
@@ -1140,14 +1140,14 @@ static int stli_carrier_raised(struct tty_port *port)
         return (portp->sigs & TIOCM_CD) ? 1 : 0;
 }
 
-static void stli_raise_dtr_rts(struct tty_port *port)
+static void stli_dtr_rts(struct tty_port *port, int on)
 {
         struct stliport *portp = container_of(port, struct stliport, port);
         struct stlibrd *brdp = stli_brds[portp->brdnr];
-        stli_mkasysigs(&portp->asig, 1, 1);
+        stli_mkasysigs(&portp->asig, on, on);
         if (stli_cmdwait(brdp, portp, A_SETSIGNALS, &portp->asig,
                 sizeof(asysigs_t), 0) < 0)
-                        printk(KERN_WARNING "istallion: dtr raise failed.\n");
+                        printk(KERN_WARNING "istallion: dtr set failed.\n");
 }
 
 
@@ -4417,7 +4417,7 @@ static const struct tty_operations stli_ops = {
 
 static const struct tty_port_operations stli_port_ops = {
         .carrier_raised = stli_carrier_raised,
-        .raise_dtr_rts = stli_raise_dtr_rts,
+        .dtr_rts = stli_dtr_rts,
 };
 
 /*****************************************************************************/
diff --git a/drivers/char/moxa.c b/drivers/char/moxa.c
index 4a4cab73d0be..65b6ff2442c6 100644
--- a/drivers/char/moxa.c
+++ b/drivers/char/moxa.c
@@ -1184,6 +1184,11 @@ static int moxa_open(struct tty_struct *tty, struct file *filp)
                 return -ENODEV;
         }
 
+        if (port % MAX_PORTS_PER_BOARD >= brd->numPorts) {
+                mutex_unlock(&moxa_openlock);
+                return -ENODEV;
+        }
+
         ch = &brd->ports[port % MAX_PORTS_PER_BOARD];
         ch->port.count++;
         tty->driver_data = ch;
diff --git a/drivers/char/mxser.c b/drivers/char/mxser.c
index 13f8871e5b21..9533f43a30bb 100644
--- a/drivers/char/mxser.c
+++ b/drivers/char/mxser.c
@@ -547,14 +547,18 @@ static int mxser_carrier_raised(struct tty_port *port)
         return (inb(mp->ioaddr + UART_MSR) & UART_MSR_DCD)?1:0;
 }
 
-static void mxser_raise_dtr_rts(struct tty_port *port)
+static void mxser_dtr_rts(struct tty_port *port, int on)
 {
         struct mxser_port *mp = container_of(port, struct mxser_port, port);
         unsigned long flags;
 
         spin_lock_irqsave(&mp->slock, flags);
-        outb(inb(mp->ioaddr + UART_MCR) |
-                UART_MCR_DTR | UART_MCR_RTS, mp->ioaddr + UART_MCR);
+        if (on)
+                outb(inb(mp->ioaddr + UART_MCR) |
+                        UART_MCR_DTR | UART_MCR_RTS, mp->ioaddr + UART_MCR);
+        else
+                outb(inb(mp->ioaddr + UART_MCR)&~(UART_MCR_DTR | UART_MCR_RTS),
+                        mp->ioaddr + UART_MCR);
         spin_unlock_irqrestore(&mp->slock, flags);
 }
 
@@ -2356,7 +2360,7 @@ static const struct tty_operations mxser_ops = {
 
 struct tty_port_operations mxser_port_ops = {
         .carrier_raised = mxser_carrier_raised,
-        .raise_dtr_rts = mxser_raise_dtr_rts,
+        .dtr_rts = mxser_dtr_rts,
 };
 
 /*
diff --git a/drivers/char/n_hdlc.c b/drivers/char/n_hdlc.c
index bacb3e2872ae..461ece591a5b 100644
--- a/drivers/char/n_hdlc.c
+++ b/drivers/char/n_hdlc.c
@@ -342,8 +342,8 @@ static int n_hdlc_tty_open (struct tty_struct *tty)
 #endif
         
         /* Flush any pending characters in the driver and discipline. */
-        if (tty->ldisc.ops->flush_buffer)
-                tty->ldisc.ops->flush_buffer(tty);
+        if (tty->ldisc->ops->flush_buffer)
+                tty->ldisc->ops->flush_buffer(tty);
 
         tty_driver_flush_buffer(tty);
                 
diff --git a/drivers/char/n_tty.c b/drivers/char/n_tty.c
index f6f0e4ec2b51..94a5d5020abc 100644
--- a/drivers/char/n_tty.c
+++ b/drivers/char/n_tty.c
@@ -73,24 +73,6 @@
 #define ECHO_OP_SET_CANON_COL 0x81
 #define ECHO_OP_ERASE_TAB 0x82
 
-static inline unsigned char *alloc_buf(void)
-{
-        gfp_t prio = in_interrupt() ? GFP_ATOMIC : GFP_KERNEL;
-
-        if (PAGE_SIZE != N_TTY_BUF_SIZE)
-                return kmalloc(N_TTY_BUF_SIZE, prio);
-        else
-                return (unsigned char *)__get_free_page(prio);
-}
-
-static inline void free_buf(unsigned char *buf)
-{
-        if (PAGE_SIZE != N_TTY_BUF_SIZE)
-                kfree(buf);
-        else
-                free_page((unsigned long) buf);
-}
-
 static inline int tty_put_user(struct tty_struct *tty, unsigned char x,
                                unsigned char __user *ptr)
 {
@@ -1558,11 +1540,11 @@ static void n_tty_close(struct tty_struct *tty)
 {
         n_tty_flush_buffer(tty);
         if (tty->read_buf) {
-                free_buf(tty->read_buf);
+                kfree(tty->read_buf);
                 tty->read_buf = NULL;
         }
         if (tty->echo_buf) {
-                free_buf(tty->echo_buf);
+                kfree(tty->echo_buf);
                 tty->echo_buf = NULL;
         }
 }
@@ -1584,17 +1566,16 @@ static int n_tty_open(struct tty_struct *tty)
 
         /* These are ugly. Currently a malloc failure here can panic */
         if (!tty->read_buf) {
-                tty->read_buf = alloc_buf();
+                tty->read_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL);
                 if (!tty->read_buf)
                         return -ENOMEM;
         }
         if (!tty->echo_buf) {
-                tty->echo_buf = alloc_buf();
+                tty->echo_buf = kzalloc(N_TTY_BUF_SIZE, GFP_KERNEL);
+
                 if (!tty->echo_buf)
                         return -ENOMEM;
         }
-        memset(tty->read_buf, 0, N_TTY_BUF_SIZE);
-        memset(tty->echo_buf, 0, N_TTY_BUF_SIZE);
         reset_buffer_flags(tty);
         tty->column = 0;
         n_tty_set_termios(tty, NULL);
diff --git a/drivers/char/pcmcia/synclink_cs.c b/drivers/char/pcmcia/synclink_cs.c
index 19d79fc54461..77b364889224 100644
--- a/drivers/char/pcmcia/synclink_cs.c
+++ b/drivers/char/pcmcia/synclink_cs.c
@@ -383,7 +383,7 @@ static void async_mode(MGSLPC_INFO *info);
 static void tx_timeout(unsigned long context);
 
 static int carrier_raised(struct tty_port *port);
-static void raise_dtr_rts(struct tty_port *port);
+static void dtr_rts(struct tty_port *port, int onoff);
 
 #if SYNCLINK_GENERIC_HDLC
 #define dev_to_port(D) (dev_to_hdlc(D)->priv)
@@ -513,7 +513,7 @@ static void ldisc_receive_buf(struct tty_struct *tty,
 
 static const struct tty_port_operations mgslpc_port_ops = {
         .carrier_raised = carrier_raised,
-        .raise_dtr_rts = raise_dtr_rts
+        .dtr_rts = dtr_rts
 };
 
 static int mgslpc_probe(struct pcmcia_device *link)
@@ -2528,13 +2528,16 @@ static int carrier_raised(struct tty_port *port)
         return 0;
 }
 
-static void raise_dtr_rts(struct tty_port *port)
+static void dtr_rts(struct tty_port *port, int onoff)
 {
         MGSLPC_INFO *info = container_of(port, MGSLPC_INFO, port);
         unsigned long flags;
 
         spin_lock_irqsave(&info->lock,flags);
-        info->serial_signals |= SerialSignal_RTS + SerialSignal_DTR;
+        if (onoff)
+                info->serial_signals |= SerialSignal_RTS + SerialSignal_DTR;
+        else
+                info->serial_signals &= ~SerialSignal_RTS + SerialSignal_DTR;
         set_signals(info);
         spin_unlock_irqrestore(&info->lock,flags);
 }
diff --git a/drivers/char/pty.c b/drivers/char/pty.c
index 31038a0052a2..5acd29e6e043 100644
--- a/drivers/char/pty.c
+++ b/drivers/char/pty.c
@@ -30,7 +30,6 @@
 
 #include <asm/system.h>
 
-/* These are global because they are accessed in tty_io.c */
 #ifdef CONFIG_UNIX98_PTYS
 static struct tty_driver *ptm_driver;
 static struct tty_driver *pts_driver;
@@ -111,7 +110,7 @@ static int pty_write(struct tty_struct *tty, const unsigned char *buf,
         c = to->receive_room;
         if (c > count)
                 c = count;
-        to->ldisc.ops->receive_buf(to, buf, NULL, c);
+        to->ldisc->ops->receive_buf(to, buf, NULL, c);
 
         return c;
 }
@@ -149,11 +148,11 @@ static int pty_chars_in_buffer(struct tty_struct *tty)
         int count;
 
         /* We should get the line discipline lock for "tty->link" */
-        if (!to || !to->ldisc.ops->chars_in_buffer)
+        if (!to || !to->ldisc->ops->chars_in_buffer)
                 return 0;
 
         /* The ldisc must report 0 if no characters available to be read */
-        count = to->ldisc.ops->chars_in_buffer(to);
+        count = to->ldisc->ops->chars_in_buffer(to);
 
         if (tty->driver->subtype == PTY_TYPE_SLAVE)
                 return count;
@@ -187,8 +186,8 @@ static void pty_flush_buffer(struct tty_struct *tty)
         if (!to)
                 return;
 
-        if (to->ldisc.ops->flush_buffer)
-                to->ldisc.ops->flush_buffer(to);
+        if (to->ldisc->ops->flush_buffer)
+                to->ldisc->ops->flush_buffer(to);
 
         if (to->packet) {
                 spin_lock_irqsave(&tty->ctrl_lock, flags);
diff --git a/drivers/char/raw.c b/drivers/char/raw.c
index 20d90e6a6e50..db32f0e4c7dd 100644
--- a/drivers/char/raw.c
+++ b/drivers/char/raw.c
@@ -71,7 +71,7 @@ static int raw_open(struct inode *inode, struct file *filp)
         err = bd_claim(bdev, raw_open);
         if (err)
                 goto out1;
-        err = set_blocksize(bdev, bdev_hardsect_size(bdev));
+        err = set_blocksize(bdev, bdev_logical_block_size(bdev));
         if (err)
                 goto out2;
         filp->f_flags |= O_DIRECT;
diff --git a/drivers/char/rocket.c b/drivers/char/rocket.c
index f59fc5cea067..63d5b628477a 100644
--- a/drivers/char/rocket.c
+++ b/drivers/char/rocket.c
@@ -872,11 +872,16 @@ static int carrier_raised(struct tty_port *port)
         return (sGetChanStatusLo(&info->channel) & CD_ACT) ? 1 : 0;
 }
 
-static void raise_dtr_rts(struct tty_port *port)
+static void dtr_rts(struct tty_port *port, int on)
 {
         struct r_port *info = container_of(port, struct r_port, port);
-        sSetDTR(&info->channel);
-        sSetRTS(&info->channel);
+        if (on) {
+                sSetDTR(&info->channel);
+                sSetRTS(&info->channel);
+        } else {
+                sClrDTR(&info->channel);
+                sClrRTS(&info->channel);
+        }
 }
 
 /*
@@ -934,7 +939,7 @@ static int rp_open(struct tty_struct *tty, struct file *filp)
         /*
          * Info->count is now 1; so it's safe to sleep now.
          */
-        if (!test_bit(ASYNC_INITIALIZED, &port->flags)) {
+        if (!test_bit(ASYNCB_INITIALIZED, &port->flags)) {
                 cp = &info->channel;
                 sSetRxTrigger(cp, TRIG_1);
                 if (sGetChanStatus(cp) & CD_ACT)
@@ -958,7 +963,7 @@ static int rp_open(struct tty_struct *tty, struct file *filp)
                 sEnRxFIFO(cp);
                 sEnTransmit(cp);
 
-                set_bit(ASYNC_INITIALIZED, &info->port.flags);
+                set_bit(ASYNCB_INITIALIZED, &info->port.flags);
 
                 /*
                  * Set up the tty->alt_speed kludge
@@ -1641,7 +1646,7 @@ static int rp_write(struct tty_struct *tty,
         /*  Write remaining data into the port's xmit_buf */
         while (1) {
                 /* Hung up ? */
-                if (!test_bit(ASYNC_NORMAL_ACTIVE, &info->port.flags))
+                if (!test_bit(ASYNCB_NORMAL_ACTIVE, &info->port.flags))
                         goto end;
                 c = min(count, XMIT_BUF_SIZE - info->xmit_cnt - 1);
                 c = min(c, XMIT_BUF_SIZE - info->xmit_head);
@@ -2250,7 +2255,7 @@ static const struct tty_operations rocket_ops = {
 
 static const struct tty_port_operations rocket_port_ops = {
         .carrier_raised = carrier_raised,
-        .raise_dtr_rts = raise_dtr_rts,
+        .dtr_rts = dtr_rts,
 };
 
 /*
diff --git a/drivers/char/selection.c b/drivers/char/selection.c
index cb8ca5698963..f97b9e848064 100644
--- a/drivers/char/selection.c
+++ b/drivers/char/selection.c
@@ -327,7 +327,7 @@ int paste_selection(struct tty_struct *tty)
                 }
                 count = sel_buffer_lth - pasted;
                 count = min(count, tty->receive_room);
-                tty->ldisc.ops->receive_buf(tty, sel_buffer + pasted,
+                tty->ldisc->ops->receive_buf(tty, sel_buffer + pasted,
                                                                 NULL, count);
                 pasted += count;
         }
diff --git a/drivers/char/stallion.c b/drivers/char/stallion.c
index 2ad813a801dc..53e504f41b20 100644
--- a/drivers/char/stallion.c
+++ b/drivers/char/stallion.c
@@ -772,11 +772,11 @@ static int stl_carrier_raised(struct tty_port *port)
         return (portp->sigs & TIOCM_CD) ? 1 : 0;
 }
 
-static void stl_raise_dtr_rts(struct tty_port *port)
+static void stl_dtr_rts(struct tty_port *port, int on)
 {
         struct stlport *portp = container_of(port, struct stlport, port);
         /* Takes brd_lock internally */
-        stl_setsignals(portp, 1, 1);
+        stl_setsignals(portp, on, on);
 }
 
 /*****************************************************************************/
@@ -2547,7 +2547,7 @@ static const struct tty_operations stl_ops = {
 
 static const struct tty_port_operations stl_port_ops = {
         .carrier_raised = stl_carrier_raised,
-        .raise_dtr_rts = stl_raise_dtr_rts,
+        .dtr_rts = stl_dtr_rts,
 };
 
 /*****************************************************************************/
diff --git a/drivers/char/synclink.c b/drivers/char/synclink.c
index afd0b26ca056..afded3a2379c 100644
--- a/drivers/char/synclink.c
+++ b/drivers/char/synclink.c
@@ -3247,13 +3247,16 @@ static int carrier_raised(struct tty_port *port)
         return (info->serial_signals & SerialSignal_DCD) ? 1 : 0;
 }
 
-static void raise_dtr_rts(struct tty_port *port)
+static void dtr_rts(struct tty_port *port, int on)
 {
         struct mgsl_struct *info = container_of(port, struct mgsl_struct, port);
         unsigned long flags;
 
         spin_lock_irqsave(&info->irq_spinlock,flags);
-        info->serial_signals |= SerialSignal_RTS + SerialSignal_DTR;
+        if (on)
+                info->serial_signals |= SerialSignal_RTS + SerialSignal_DTR;
+        else
+                info->serial_signals &= ~(SerialSignal_RTS + SerialSignal_DTR);
         usc_set_serial_signals(info);
         spin_unlock_irqrestore(&info->irq_spinlock,flags);
 }
@@ -4258,7 +4261,7 @@ static void mgsl_add_device( struct mgsl_struct *info )
 
 static const struct tty_port_operations mgsl_port_ops = {
         .carrier_raised = carrier_raised,
-        .raise_dtr_rts = raise_dtr_rts,
+        .dtr_rts = dtr_rts,
 };
 
 
diff --git a/drivers/char/synclink_gt.c b/drivers/char/synclink_gt.c
index 5e256494686a..1386625fc4ca 100644
--- a/drivers/char/synclink_gt.c
+++ b/drivers/char/synclink_gt.c
@@ -214,6 +214,7 @@ struct slgt_desc
 #define set_desc_next(a,b) (a).next   = cpu_to_le32((unsigned int)(b))
 #define set_desc_count(a,b)(a).count  = cpu_to_le16((unsigned short)(b))
 #define set_desc_eof(a,b)  (a).status = cpu_to_le16((b) ? (le16_to_cpu((a).status) | BIT0) : (le16_to_cpu((a).status) & ~BIT0))
+#define set_desc_status(a, b) (a).status = cpu_to_le16((unsigned short)(b))
 #define desc_count(a)      (le16_to_cpu((a).count))
 #define desc_status(a)     (le16_to_cpu((a).status))
 #define desc_complete(a)   (le16_to_cpu((a).status) & BIT15)
@@ -297,6 +298,7 @@ struct slgt_info {
         u32 max_frame_size;       /* as set by device config */
 
         unsigned int rbuf_fill_level;
+        unsigned int rx_pio;
         unsigned int if_mode;
         unsigned int base_clock;
 
@@ -331,6 +333,8 @@ struct slgt_info {
         struct slgt_desc *rbufs;
         unsigned int rbuf_current;
         unsigned int rbuf_index;
+        unsigned int rbuf_fill_index;
+        unsigned short rbuf_fill_count;
 
         unsigned int tbuf_count;
         struct slgt_desc *tbufs;
@@ -2110,6 +2114,40 @@ static void ri_change(struct slgt_info *info, unsigned short status)
         info->pending_bh |= BH_STATUS;
 }
 
+static void isr_rxdata(struct slgt_info *info)
+{
+        unsigned int count = info->rbuf_fill_count;
+        unsigned int i = info->rbuf_fill_index;
+        unsigned short reg;
+
+        while (rd_reg16(info, SSR) & IRQ_RXDATA) {
+                reg = rd_reg16(info, RDR);
+                DBGISR(("isr_rxdata %s RDR=%04X\n", info->device_name, reg));
+                if (desc_complete(info->rbufs[i])) {
+                        /* all buffers full */
+                        rx_stop(info);
+                        info->rx_restart = 1;
+                        continue;
+                }
+                info->rbufs[i].buf[count++] = (unsigned char)reg;
+                /* async mode saves status byte to buffer for each data byte */
+                if (info->params.mode == MGSL_MODE_ASYNC)
+                        info->rbufs[i].buf[count++] = (unsigned char)(reg >> 8);
+                if (count == info->rbuf_fill_level || (reg & BIT10)) {
+                        /* buffer full or end of frame */
+                        set_desc_count(info->rbufs[i], count);
+                        set_desc_status(info->rbufs[i], BIT15 | (reg >> 8));
+                        info->rbuf_fill_count = count = 0;
+                        if (++i == info->rbuf_count)
+                                i = 0;
+                        info->pending_bh |= BH_RECEIVE;
+                }
+        }
+
+        info->rbuf_fill_index = i;
+        info->rbuf_fill_count = count;
+}
+
 static void isr_serial(struct slgt_info *info)
 {
         unsigned short status = rd_reg16(info, SSR);
@@ -2125,6 +2163,8 @@ static void isr_serial(struct slgt_info *info)
                         if (info->tx_count)
                                 isr_txeom(info, status);
                 }
+                if (info->rx_pio && (status & IRQ_RXDATA))
+                        isr_rxdata(info);
                 if ((status & IRQ_RXBREAK) && (status & RXBREAK)) {
                         info->icount.brk++;
                         /* process break detection if tty control allows */
@@ -2141,7 +2181,8 @@ static void isr_serial(struct slgt_info *info)
         } else {
                 if (status & (IRQ_TXIDLE + IRQ_TXUNDER))
                         isr_txeom(info, status);
-
+                if (info->rx_pio && (status & IRQ_RXDATA))
+                        isr_rxdata(info);
                 if (status & IRQ_RXIDLE) {
                         if (status & RXIDLE)
                                 info->icount.rxidle++;
@@ -2642,6 +2683,10 @@ static int rx_enable(struct slgt_info *info, int enable)
                         return -EINVAL;
                 }
                 info->rbuf_fill_level = rbuf_fill_level;
+                if (rbuf_fill_level < 128)
+                        info->rx_pio = 1; /* PIO mode */
+                else
+                        info->rx_pio = 0; /* DMA mode */
                 rx_stop(info); /* restart receiver to use new fill level */
         }
 
@@ -3099,13 +3144,16 @@ static int carrier_raised(struct tty_port *port)
         return (info->signals & SerialSignal_DCD) ? 1 : 0;
 }
 
-static void raise_dtr_rts(struct tty_port *port)
+static void dtr_rts(struct tty_port *port, int on)
 {
         unsigned long flags;
         struct slgt_info *info = container_of(port, struct slgt_info, port);
 
         spin_lock_irqsave(&info->lock,flags);
-        info->signals |= SerialSignal_RTS + SerialSignal_DTR;
+        if (on)
+                info->signals |= SerialSignal_RTS + SerialSignal_DTR;
+        else
+                info->signals &= ~(SerialSignal_RTS + SerialSignal_DTR);
         set_signals(info);
         spin_unlock_irqrestore(&info->lock,flags);
 }
@@ -3419,7 +3467,7 @@ static void add_device(struct slgt_info *info)
 
 static const struct tty_port_operations slgt_port_ops = {
         .carrier_raised = carrier_raised,
-        .raise_dtr_rts = raise_dtr_rts,
+        .dtr_rts = dtr_rts,
 };
 
 /*
@@ -3841,15 +3889,27 @@ static void rx_start(struct slgt_info *info)
         rdma_reset(info);
         reset_rbufs(info);
 
-        /* set 1st descriptor address */
-        wr_reg32(info, RDDAR, info->rbufs[0].pdesc);
-
-        if (info->params.mode != MGSL_MODE_ASYNC) {
-                /* enable rx DMA and DMA interrupt */
-                wr_reg32(info, RDCSR, (BIT2 + BIT0));
+        if (info->rx_pio) {
+                /* rx request when rx FIFO not empty */
+                wr_reg16(info, SCR, (unsigned short)(rd_reg16(info, SCR) & ~BIT14));
+                slgt_irq_on(info, IRQ_RXDATA);
+                if (info->params.mode == MGSL_MODE_ASYNC) {
+                        /* enable saving of rx status */
+                        wr_reg32(info, RDCSR, BIT6);
+                }
         } else {
-                /* enable saving of rx status, rx DMA and DMA interrupt */
-                wr_reg32(info, RDCSR, (BIT6 + BIT2 + BIT0));
+                /* rx request when rx FIFO half full */
+                wr_reg16(info, SCR, (unsigned short)(rd_reg16(info, SCR) | BIT14));
+                /* set 1st descriptor address */
+                wr_reg32(info, RDDAR, info->rbufs[0].pdesc);
+
+                if (info->params.mode != MGSL_MODE_ASYNC) {
+                        /* enable rx DMA and DMA interrupt */
+                        wr_reg32(info, RDCSR, (BIT2 + BIT0));
+                } else {
+                        /* enable saving of rx status, rx DMA and DMA interrupt */
+                        wr_reg32(info, RDCSR, (BIT6 + BIT2 + BIT0));
+                }
         }
 
         slgt_irq_on(info, IRQ_RXOVER);
@@ -4467,6 +4527,8 @@ static void free_rbufs(struct slgt_info *info, unsigned int i, unsigned int last
 static void reset_rbufs(struct slgt_info *info)
 {
         free_rbufs(info, 0, info->rbuf_count - 1);
+        info->rbuf_fill_index = 0;
+        info->rbuf_fill_count = 0;
 }
 
 /*
diff --git a/drivers/char/synclinkmp.c b/drivers/char/synclinkmp.c
index 26de60efe4b2..6f727e3c53ad 100644
--- a/drivers/char/synclinkmp.c
+++ b/drivers/char/synclinkmp.c
@@ -3277,13 +3277,16 @@ static int carrier_raised(struct tty_port *port)
         return (info->serial_signals & SerialSignal_DCD) ? 1 : 0;
 }
 
-static void raise_dtr_rts(struct tty_port *port)
+static void dtr_rts(struct tty_port *port, int on)
 {
         SLMP_INFO *info = container_of(port, SLMP_INFO, port);
         unsigned long flags;
 
         spin_lock_irqsave(&info->lock,flags);
-        info->serial_signals |= SerialSignal_RTS + SerialSignal_DTR;
+        if (on)
+                info->serial_signals |= SerialSignal_RTS + SerialSignal_DTR;
+        else
+                info->serial_signals &= ~(SerialSignal_RTS + SerialSignal_DTR);
         set_signals(info);
         spin_unlock_irqrestore(&info->lock,flags);
 }
@@ -3746,7 +3749,7 @@ static void add_device(SLMP_INFO *info)
 
 static const struct tty_port_operations port_ops = {
         .carrier_raised = carrier_raised,
-        .raise_dtr_rts = raise_dtr_rts,
+        .dtr_rts = dtr_rts,
 };
 
 /* Allocate and initialize a device instance structure
diff --git a/drivers/char/tty_audit.c b/drivers/char/tty_audit.c
index 55ba6f142883..ac16fbec72d0 100644
--- a/drivers/char/tty_audit.c
+++ b/drivers/char/tty_audit.c
@@ -29,10 +29,7 @@ static struct tty_audit_buf *tty_audit_buf_alloc(int major, int minor,
         buf = kmalloc(sizeof(*buf), GFP_KERNEL);
         if (!buf)
                 goto err;
-        if (PAGE_SIZE != N_TTY_BUF_SIZE)
-                buf->data = kmalloc(N_TTY_BUF_SIZE, GFP_KERNEL);
-        else
-                buf->data = (unsigned char *)__get_free_page(GFP_KERNEL);
+        buf->data = kmalloc(N_TTY_BUF_SIZE, GFP_KERNEL);
         if (!buf->data)
                 goto err_buf;
         atomic_set(&buf->count, 1);
@@ -52,10 +49,7 @@ err:
 static void tty_audit_buf_free(struct tty_audit_buf *buf)
 {
         WARN_ON(buf->valid != 0);
-        if (PAGE_SIZE != N_TTY_BUF_SIZE)
-                kfree(buf->data);
-        else
-                free_page((unsigned long)buf->data);
+        kfree(buf->data);
         kfree(buf);
 }
 
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index 66b99a2049e3..939e198d7670 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -295,7 +295,7 @@ struct tty_driver *tty_find_polling_driver(char *name, int *line)
         struct tty_driver *p, *res = NULL;
         int tty_line = 0;
         int len;
-        char *str;
+        char *str, *stp;
 
         for (str = name; *str; str++)
                 if ((*str >= '0' && *str <= '9') || *str == ',')
@@ -311,13 +311,14 @@ struct tty_driver *tty_find_polling_driver(char *name, int *line)
         list_for_each_entry(p, &tty_drivers, tty_drivers) {
                 if (strncmp(name, p->name, len) != 0)
                         continue;
-                if (*str == ',')
-                        str++;
-                if (*str == '\0')
-                        str = NULL;
+                stp = str;
+                if (*stp == ',')
+                        stp++;
+                if (*stp == '\0')
+                        stp = NULL;
 
                 if (tty_line >= 0 && tty_line <= p->num && p->ops &&
-                    p->ops->poll_init && !p->ops->poll_init(p, tty_line, str)) {
+                    p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
                         res = tty_driver_kref_get(p);
                         *line = tty_line;
                         break;
@@ -470,43 +471,6 @@ void tty_wakeup(struct tty_struct *tty)
 EXPORT_SYMBOL_GPL(tty_wakeup);
 
 /**
- *      tty_ldisc_flush -       flush line discipline queue
- *      @tty: tty
- *
- *      Flush the line discipline queue (if any) for this tty. If there
- *      is no line discipline active this is a no-op.
- */
-
-void tty_ldisc_flush(struct tty_struct *tty)
-{
-        struct tty_ldisc *ld = tty_ldisc_ref(tty);
-        if (ld) {
-                if (ld->ops->flush_buffer)
-                        ld->ops->flush_buffer(tty);
-                tty_ldisc_deref(ld);
-        }
-        tty_buffer_flush(tty);
-}
-
-EXPORT_SYMBOL_GPL(tty_ldisc_flush);
-
-/**
- *      tty_reset_termios       -       reset terminal state
- *      @tty: tty to reset
- *
- *      Restore a terminal to the driver default state
- */
-
-static void tty_reset_termios(struct tty_struct *tty)
-{
-        mutex_lock(&tty->termios_mutex);
-        *tty->termios = tty->driver->init_termios;
-        tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
-        tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
-        mutex_unlock(&tty->termios_mutex);
-}
-
-/**
  *      do_tty_hangup           -       actual handler for hangup events
  *      @work: tty device
  *
@@ -535,7 +499,6 @@ static void do_tty_hangup(struct work_struct *work)
         struct file *cons_filp = NULL;
         struct file *filp, *f = NULL;
         struct task_struct *p;
-        struct tty_ldisc *ld;
         int    closecount = 0, n;
         unsigned long flags;
         int refs = 0;
@@ -566,40 +529,8 @@ static void do_tty_hangup(struct work_struct *work)
                 filp->f_op = &hung_up_tty_fops;
         }
         file_list_unlock();
-        /*
-         * FIXME! What are the locking issues here? This may me overdoing
-         * things... This question is especially important now that we've
-         * removed the irqlock.
-         */
-        ld = tty_ldisc_ref(tty);
-        if (ld != NULL) {
-                /* We may have no line discipline at this point */
-                if (ld->ops->flush_buffer)
-                        ld->ops->flush_buffer(tty);
-                tty_driver_flush_buffer(tty);
-                if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
-                    ld->ops->write_wakeup)
-                        ld->ops->write_wakeup(tty);
-                if (ld->ops->hangup)
-                        ld->ops->hangup(tty);
-        }
-        /*
-         * FIXME: Once we trust the LDISC code better we can wait here for
-         * ldisc completion and fix the driver call race
-         */
-        wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
-        wake_up_interruptible_poll(&tty->read_wait, POLLIN);
-        /*
-         * Shutdown the current line discipline, and reset it to
-         * N_TTY.
-         */
-        if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
-                tty_reset_termios(tty);
-        /* Defer ldisc switch */
-        /* tty_deferred_ldisc_switch(N_TTY);
 
-          This should get done automatically when the port closes and
-          tty_release is called */
+        tty_ldisc_hangup(tty);
 
         read_lock(&tasklist_lock);
         if (tty->session) {
@@ -628,12 +559,15 @@ static void do_tty_hangup(struct work_struct *work)
         read_unlock(&tasklist_lock);
 
         spin_lock_irqsave(&tty->ctrl_lock, flags);
-        tty->flags = 0;
+        clear_bit(TTY_THROTTLED, &tty->flags);
+        clear_bit(TTY_PUSH, &tty->flags);
+        clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
         put_pid(tty->session);
         put_pid(tty->pgrp);
         tty->session = NULL;
         tty->pgrp = NULL;
         tty->ctrl_status = 0;
+        set_bit(TTY_HUPPED, &tty->flags);
         spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 
         /* Account for the p->signal references we killed */
@@ -659,10 +593,7 @@ static void do_tty_hangup(struct work_struct *work)
          * can't yet guarantee all that.
          */
         set_bit(TTY_HUPPED, &tty->flags);
-        if (ld) {
-                tty_ldisc_enable(tty);
-                tty_ldisc_deref(ld);
-        }
+        tty_ldisc_enable(tty);
         unlock_kernel();
         if (f)
                 fput(f);
@@ -2480,6 +2411,24 @@ static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int
         return tty->ops->tiocmset(tty, file, set, clear);
 }
 
+struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
+{
+        if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
+            tty->driver->subtype == PTY_TYPE_MASTER)
+                tty = tty->link;
+        return tty;
+}
+EXPORT_SYMBOL(tty_pair_get_tty);
+
+struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)
+{
+        if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
+            tty->driver->subtype == PTY_TYPE_MASTER)
+            return tty;
+        return tty->link;
+}
+EXPORT_SYMBOL(tty_pair_get_pty);
+
 /*
  * Split this up, as gcc can choke on it otherwise..
  */
@@ -2495,11 +2444,7 @@ long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         if (tty_paranoia_check(tty, inode, "tty_ioctl"))
                 return -EINVAL;
 
-        real_tty = tty;
-        if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
-            tty->driver->subtype == PTY_TYPE_MASTER)
-                real_tty = tty->link;
-
+        real_tty = tty_pair_get_tty(tty);
 
         /*
          * Factor out some common prep work
@@ -2555,7 +2500,7 @@ long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         case TIOCGSID:
                 return tiocgsid(tty, real_tty, p);
         case TIOCGETD:
-                return put_user(tty->ldisc.ops->num, (int __user *)p);
+                return put_user(tty->ldisc->ops->num, (int __user *)p);
         case TIOCSETD:
                 return tiocsetd(tty, p);
         /*
@@ -2770,6 +2715,7 @@ void initialize_tty_struct(struct tty_struct *tty,
         tty->buf.head = tty->buf.tail = NULL;
         tty_buffer_init(tty);
         mutex_init(&tty->termios_mutex);
+        mutex_init(&tty->ldisc_mutex);
         init_waitqueue_head(&tty->write_wait);
         init_waitqueue_head(&tty->read_wait);
         INIT_WORK(&tty->hangup_work, do_tty_hangup);
diff --git a/drivers/char/tty_ioctl.c b/drivers/char/tty_ioctl.c
index 6f4c7d0a53bf..8116bb1c8f80 100644
--- a/drivers/char/tty_ioctl.c
+++ b/drivers/char/tty_ioctl.c
@@ -97,14 +97,19 @@ EXPORT_SYMBOL(tty_driver_flush_buffer);
  *      @tty: terminal
  *
  *      Indicate that a tty should stop transmitting data down the stack.
+ *      Takes the termios mutex to protect against parallel throttle/unthrottle
+ *      and also to ensure the driver can consistently reference its own
+ *      termios data at this point when implementing software flow control.
  */
 
 void tty_throttle(struct tty_struct *tty)
 {
+        mutex_lock(&tty->termios_mutex);
         /* check TTY_THROTTLED first so it indicates our state */
         if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&
             tty->ops->throttle)
                 tty->ops->throttle(tty);
+        mutex_unlock(&tty->termios_mutex);
 }
 EXPORT_SYMBOL(tty_throttle);
 
@@ -113,13 +118,21 @@ EXPORT_SYMBOL(tty_throttle);
  *      @tty: terminal
  *
  *      Indicate that a tty may continue transmitting data down the stack.
+ *      Takes the termios mutex to protect against parallel throttle/unthrottle
+ *      and also to ensure the driver can consistently reference its own
+ *      termios data at this point when implementing software flow control.
+ *
+ *      Drivers should however remember that the stack can issue a throttle,
+ *      then change flow control method, then unthrottle.
  */
 
 void tty_unthrottle(struct tty_struct *tty)
 {
+        mutex_lock(&tty->termios_mutex);
         if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
             tty->ops->unthrottle)
                 tty->ops->unthrottle(tty);
+        mutex_unlock(&tty->termios_mutex);
 }
 EXPORT_SYMBOL(tty_unthrottle);
 
@@ -613,9 +626,25 @@ static int set_termios(struct tty_struct *tty, void __user *arg, int opt)
         return 0;
 }
 
+static void copy_termios(struct tty_struct *tty, struct ktermios *kterm)
+{
+        mutex_lock(&tty->termios_mutex);
+        memcpy(kterm, tty->termios, sizeof(struct ktermios));
+        mutex_unlock(&tty->termios_mutex);
+}
+
+static void copy_termios_locked(struct tty_struct *tty, struct ktermios *kterm)
+{
+        mutex_lock(&tty->termios_mutex);
+        memcpy(kterm, tty->termios_locked, sizeof(struct ktermios));
+        mutex_unlock(&tty->termios_mutex);
+}
+
 static int get_termio(struct tty_struct *tty, struct termio __user *termio)
 {
-        if (kernel_termios_to_user_termio(termio, tty->termios))
+        struct ktermios kterm;
+        copy_termios(tty, &kterm);
+        if (kernel_termios_to_user_termio(termio, &kterm))
                 return -EFAULT;
         return 0;
 }
@@ -917,6 +946,8 @@ int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
         struct tty_struct *real_tty;
         void __user *p = (void __user *)arg;
         int ret = 0;
+        struct ktermios kterm;
+        struct termiox ktermx;
 
         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
             tty->driver->subtype == PTY_TYPE_MASTER)
@@ -952,23 +983,20 @@ int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
                 return set_termios(real_tty, p, TERMIOS_OLD);
 #ifndef TCGETS2
         case TCGETS:
-                mutex_lock(&real_tty->termios_mutex);
-                if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios))
+                copy_termios(real_tty, &kterm);
+                if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
                         ret = -EFAULT;
-                mutex_unlock(&real_tty->termios_mutex);
                 return ret;
 #else
         case TCGETS:
-                mutex_lock(&real_tty->termios_mutex);
-                if (kernel_termios_to_user_termios_1((struct termios __user *)arg, real_tty->termios))
+                copy_termios(real_tty, &kterm);
+                if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
                         ret = -EFAULT;
-                mutex_unlock(&real_tty->termios_mutex);
                 return ret;
         case TCGETS2:
-                mutex_lock(&real_tty->termios_mutex);
-                if (kernel_termios_to_user_termios((struct termios2 __user *)arg, real_tty->termios))
+                copy_termios(real_tty, &kterm);
+                if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
                         ret = -EFAULT;
-                mutex_unlock(&real_tty->termios_mutex);
                 return ret;
         case TCSETSF2:
                 return set_termios(real_tty, p,  TERMIOS_FLUSH | TERMIOS_WAIT);
@@ -987,34 +1015,36 @@ int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
                 return set_termios(real_tty, p, TERMIOS_TERMIO);
 #ifndef TCGETS2
         case TIOCGLCKTRMIOS:
-                mutex_lock(&real_tty->termios_mutex);
-                if (kernel_termios_to_user_termios((struct termios __user *)arg, real_tty->termios_locked))
+                copy_termios_locked(real_tty, &kterm);
+                if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
                         ret = -EFAULT;
-                mutex_unlock(&real_tty->termios_mutex);
                 return ret;
         case TIOCSLCKTRMIOS:
                 if (!capable(CAP_SYS_ADMIN))
                         return -EPERM;
-                mutex_lock(&real_tty->termios_mutex);
-                if (user_termios_to_kernel_termios(real_tty->termios_locked,
+                copy_termios_locked(real_tty, &kterm);
+                if (user_termios_to_kernel_termios(&kterm,
                                                (struct termios __user *) arg))
-                        ret = -EFAULT;
+                        return -EFAULT;
+                mutex_lock(&real_tty->termios_mutex);
+                memcpy(real_tty->termios_locked, &kterm, sizeof(struct ktermios));
                 mutex_unlock(&real_tty->termios_mutex);
-                return ret;
+                return 0;
 #else
         case TIOCGLCKTRMIOS:
-                mutex_lock(&real_tty->termios_mutex);
-                if (kernel_termios_to_user_termios_1((struct termios __user *)arg, real_tty->termios_locked))
+                copy_termios_locked(real_tty, &kterm);
+                if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
                         ret = -EFAULT;
-                mutex_unlock(&real_tty->termios_mutex);
                 return ret;
         case TIOCSLCKTRMIOS:
                 if (!capable(CAP_SYS_ADMIN))
-                        ret = -EPERM;
-                mutex_lock(&real_tty->termios_mutex);
-                if (user_termios_to_kernel_termios_1(real_tty->termios_locked,
+                        return -EPERM;
+                copy_termios_locked(real_tty, &kterm);
+                if (user_termios_to_kernel_termios_1(&kterm,
                                                (struct termios __user *) arg))
-                        ret = -EFAULT;
+                        return -EFAULT;
+                mutex_lock(&real_tty->termios_mutex);
+                memcpy(real_tty->termios_locked, &kterm, sizeof(struct ktermios));
                 mutex_unlock(&real_tty->termios_mutex);
                 return ret;
 #endif
@@ -1023,9 +1053,10 @@ int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
                 if (real_tty->termiox == NULL)
                         return -EINVAL;
                 mutex_lock(&real_tty->termios_mutex);
-                if (copy_to_user(p, real_tty->termiox, sizeof(struct termiox)))
-                        ret = -EFAULT;
+                memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
                 mutex_unlock(&real_tty->termios_mutex);
+                if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
+                        ret = -EFAULT;
                 return ret;
         case TCSETX:
                 return set_termiox(real_tty, p, 0);
@@ -1035,10 +1066,9 @@ int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
                 return set_termiox(real_tty, p, TERMIOS_FLUSH);
 #endif          
         case TIOCGSOFTCAR:
-                mutex_lock(&real_tty->termios_mutex);
-                ret = put_user(C_CLOCAL(real_tty) ? 1 : 0,
+                copy_termios(real_tty, &kterm);
+                ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
                                                 (int __user *)arg);
-                mutex_unlock(&real_tty->termios_mutex);
                 return ret;
         case TIOCSSOFTCAR:
                 if (get_user(arg, (unsigned int __user *) arg))
diff --git a/drivers/char/tty_ldisc.c b/drivers/char/tty_ldisc.c
index f78f5b0127a8..39c8f86dedd4 100644
--- a/drivers/char/tty_ldisc.c
+++ b/drivers/char/tty_ldisc.c
@@ -115,19 +115,22 @@ EXPORT_SYMBOL(tty_unregister_ldisc);
 /**
  *      tty_ldisc_try_get       -       try and reference an ldisc
  *      @disc: ldisc number
- *      @ld: tty ldisc structure to complete
  *
  *      Attempt to open and lock a line discipline into place. Return
- *      the line discipline refcounted and assigned in ld. On an error
- *      report the error code back
+ *      the line discipline refcounted or an error.
  */
 
-static int tty_ldisc_try_get(int disc, struct tty_ldisc *ld)
+static struct tty_ldisc *tty_ldisc_try_get(int disc)
 {
         unsigned long flags;
+        struct tty_ldisc *ld;
         struct tty_ldisc_ops *ldops;
         int err = -EINVAL;
-        
+
+        ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
+        if (ld == NULL)
+                return ERR_PTR(-ENOMEM);
+
         spin_lock_irqsave(&tty_ldisc_lock, flags);
         ld->ops = NULL;
         ldops = tty_ldiscs[disc];
@@ -140,17 +143,19 @@ static int tty_ldisc_try_get(int disc, struct tty_ldisc *ld)
                         /* lock it */
                         ldops->refcount++;
                         ld->ops = ldops;
+                        ld->refcount = 0;
                         err = 0;
                 }
         }
         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
-        return err;
+        if (err)
+                return ERR_PTR(err);
+        return ld;
 }
 
 /**
  *      tty_ldisc_get           -       take a reference to an ldisc
  *      @disc: ldisc number
- *      @ld: tty line discipline structure to use
  *
  *      Takes a reference to a line discipline. Deals with refcounts and
  *      module locking counts. Returns NULL if the discipline is not available.
@@ -161,52 +166,54 @@ static int tty_ldisc_try_get(int disc, struct tty_ldisc *ld)
  *              takes tty_ldisc_lock to guard against ldisc races
  */
 
-static int tty_ldisc_get(int disc, struct tty_ldisc *ld)
+static struct tty_ldisc *tty_ldisc_get(int disc)
 {
-        int err;
+        struct tty_ldisc *ld;
 
         if (disc < N_TTY || disc >= NR_LDISCS)
-                return -EINVAL;
-        err = tty_ldisc_try_get(disc, ld);
-        if (err < 0) {
+                return ERR_PTR(-EINVAL);
+        ld = tty_ldisc_try_get(disc);
+        if (IS_ERR(ld)) {
                 request_module("tty-ldisc-%d", disc);
-                err = tty_ldisc_try_get(disc, ld);
+                ld = tty_ldisc_try_get(disc);
         }
-        return err;
+        return ld;
 }
 
 /**
  *      tty_ldisc_put           -       drop ldisc reference
- *      @disc: ldisc number
+ *      @ld: ldisc
  *
  *      Drop a reference to a line discipline. Manage refcounts and
- *      module usage counts
+ *      module usage counts. Free the ldisc once the recount hits zero.
  *
  *      Locking:
  *              takes tty_ldisc_lock to guard against ldisc races
  */
 
-static void tty_ldisc_put(struct tty_ldisc_ops *ld)
+static void tty_ldisc_put(struct tty_ldisc *ld)
 {
         unsigned long flags;
-        int disc = ld->num;
+        int disc = ld->ops->num;
+        struct tty_ldisc_ops *ldo;
 
         BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
 
         spin_lock_irqsave(&tty_ldisc_lock, flags);
-        ld = tty_ldiscs[disc];
-        BUG_ON(ld->refcount == 0);
-        ld->refcount--;
-        module_put(ld->owner);
+        ldo = tty_ldiscs[disc];
+        BUG_ON(ldo->refcount == 0);
+        ldo->refcount--;
+        module_put(ldo->owner);
         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
+        kfree(ld);
 }
 
-static void * tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
+static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
 {
         return (*pos < NR_LDISCS) ? pos : NULL;
 }
 
-static void * tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
+static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
 {
         (*pos)++;
         return (*pos < NR_LDISCS) ? pos : NULL;
@@ -219,12 +226,13 @@ static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
 static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
 {
         int i = *(loff_t *)v;
-        struct tty_ldisc ld;
-        
-        if (tty_ldisc_get(i, &ld) < 0)
+        struct tty_ldisc *ld;
+
+        ld = tty_ldisc_try_get(i);
+        if (IS_ERR(ld))
                 return 0;
-        seq_printf(m, "%-10s %2d\n", ld.ops->name ? ld.ops->name : "???", i);
-        tty_ldisc_put(ld.ops);
+        seq_printf(m, "%-10s %2d\n", ld->ops->name ? ld->ops->name : "???", i);
+        tty_ldisc_put(ld);
         return 0;
 }
 
@@ -263,8 +271,7 @@ const struct file_operations tty_ldiscs_proc_fops = {
 
 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
 {
-        ld->refcount = 0;
-        tty->ldisc = *ld;
+        tty->ldisc = ld;
 }
 
 /**
@@ -286,7 +293,7 @@ static int tty_ldisc_try(struct tty_struct *tty)
         int ret = 0;
 
         spin_lock_irqsave(&tty_ldisc_lock, flags);
-        ld = &tty->ldisc;
+        ld = tty->ldisc;
         if (test_bit(TTY_LDISC, &tty->flags)) {
                 ld->refcount++;
                 ret = 1;
@@ -315,10 +322,9 @@ struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
 {
         /* wait_event is a macro */
         wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
-        WARN_ON(tty->ldisc.refcount == 0);
-        return &tty->ldisc;
+        WARN_ON(tty->ldisc->refcount == 0);
+        return tty->ldisc;
 }
-
 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
 
 /**
@@ -335,10 +341,9 @@ EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
 {
         if (tty_ldisc_try(tty))
-                return &tty->ldisc;
+                return tty->ldisc;
         return NULL;
 }
-
 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
 
 /**
@@ -366,7 +371,6 @@ void tty_ldisc_deref(struct tty_ldisc *ld)
                 wake_up(&tty_ldisc_wait);
         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 }
-
 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
 
 /**
@@ -389,6 +393,26 @@ void tty_ldisc_enable(struct tty_struct *tty)
 }
 
 /**
+ *      tty_ldisc_flush -       flush line discipline queue
+ *      @tty: tty
+ *
+ *      Flush the line discipline queue (if any) for this tty. If there
+ *      is no line discipline active this is a no-op.
+ */
+
+void tty_ldisc_flush(struct tty_struct *tty)
+{
+        struct tty_ldisc *ld = tty_ldisc_ref(tty);
+        if (ld) {
+                if (ld->ops->flush_buffer)
+                        ld->ops->flush_buffer(tty);
+                tty_ldisc_deref(ld);
+        }
+        tty_buffer_flush(tty);
+}
+EXPORT_SYMBOL_GPL(tty_ldisc_flush);
+
+/**
  *      tty_set_termios_ldisc           -       set ldisc field
  *      @tty: tty structure
  *      @num: line discipline number
@@ -407,6 +431,39 @@ static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
         mutex_unlock(&tty->termios_mutex);
 }
 
+/**
+ *      tty_ldisc_open          -       open a line discipline
+ *      @tty: tty we are opening the ldisc on
+ *      @ld: discipline to open
+ *
+ *      A helper opening method. Also a convenient debugging and check
+ *      point.
+ */
+
+static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
+{
+        WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
+        if (ld->ops->open)
+                return ld->ops->open(tty);
+        return 0;
+}
+
+/**
+ *      tty_ldisc_close         -       close a line discipline
+ *      @tty: tty we are opening the ldisc on
+ *      @ld: discipline to close
+ *
+ *      A helper close method. Also a convenient debugging and check
+ *      point.
+ */
+
+static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
+{
+        WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
+        clear_bit(TTY_LDISC_OPEN, &tty->flags);
+        if (ld->ops->close)
+                ld->ops->close(tty);
+}
 
 /**
  *      tty_ldisc_restore       -       helper for tty ldisc change
@@ -420,66 +477,136 @@ static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
 {
         char buf[64];
-        struct tty_ldisc new_ldisc;
+        struct tty_ldisc *new_ldisc;
+        int r;
 
         /* There is an outstanding reference here so this is safe */
-        tty_ldisc_get(old->ops->num, old);
+        old = tty_ldisc_get(old->ops->num);
+        WARN_ON(IS_ERR(old));
         tty_ldisc_assign(tty, old);
         tty_set_termios_ldisc(tty, old->ops->num);
-        if (old->ops->open && (old->ops->open(tty) < 0)) {
-                tty_ldisc_put(old->ops);
+        if (tty_ldisc_open(tty, old) < 0) {
+                tty_ldisc_put(old);
                 /* This driver is always present */
-                if (tty_ldisc_get(N_TTY, &new_ldisc) < 0)
+                new_ldisc = tty_ldisc_get(N_TTY);
+                if (IS_ERR(new_ldisc))
                         panic("n_tty: get");
-                tty_ldisc_assign(tty, &new_ldisc);
+                tty_ldisc_assign(tty, new_ldisc);
                 tty_set_termios_ldisc(tty, N_TTY);
-                if (new_ldisc.ops->open) {
-                        int r = new_ldisc.ops->open(tty);
-                                if (r < 0)
-                                panic("Couldn't open N_TTY ldisc for "
-                                      "%s --- error %d.",
-                                      tty_name(tty, buf), r);
-                }
+                r = tty_ldisc_open(tty, new_ldisc);
+                if (r < 0)
+                        panic("Couldn't open N_TTY ldisc for "
+                              "%s --- error %d.",
+                              tty_name(tty, buf), r);
         }
 }
 
 /**
+ *      tty_ldisc_halt          -       shut down the line discipline
+ *      @tty: tty device
+ *
+ *      Shut down the line discipline and work queue for this tty device.
+ *      The TTY_LDISC flag being cleared ensures no further references can
+ *      be obtained while the delayed work queue halt ensures that no more
+ *      data is fed to the ldisc.
+ *
+ *      In order to wait for any existing references to complete see
+ *      tty_ldisc_wait_idle.
+ */
+
+static int tty_ldisc_halt(struct tty_struct *tty)
+{
+        clear_bit(TTY_LDISC, &tty->flags);
+        return cancel_delayed_work(&tty->buf.work);
+}
+
+/**
+ *      tty_ldisc_wait_idle     -       wait for the ldisc to become idle
+ *      @tty: tty to wait for
+ *
+ *      Wait for the line discipline to become idle. The discipline must
+ *      have been halted for this to guarantee it remains idle.
+ *
+ *      tty_ldisc_lock protects the ref counts currently.
+ */
+
+static int tty_ldisc_wait_idle(struct tty_struct *tty)
+{
+        unsigned long flags;
+        spin_lock_irqsave(&tty_ldisc_lock, flags);
+        while (tty->ldisc->refcount) {
+                spin_unlock_irqrestore(&tty_ldisc_lock, flags);
+                if (wait_event_timeout(tty_ldisc_wait,
+                                tty->ldisc->refcount == 0, 5 * HZ) == 0)
+                        return -EBUSY;
+                spin_lock_irqsave(&tty_ldisc_lock, flags);
+        }
+        spin_unlock_irqrestore(&tty_ldisc_lock, flags);
+        return 0;
+}
+
+/**
  *      tty_set_ldisc           -       set line discipline
  *      @tty: the terminal to set
  *      @ldisc: the line discipline
  *
  *      Set the discipline of a tty line. Must be called from a process
- *      context.
+ *      context. The ldisc change logic has to protect itself against any
+ *      overlapping ldisc change (including on the other end of pty pairs),
+ *      the close of one side of a tty/pty pair, and eventually hangup.
  *
- *      Locking: takes tty_ldisc_lock.
- *               called functions take termios_mutex
+ *      Locking: takes tty_ldisc_lock, termios_mutex
  */
 
 int tty_set_ldisc(struct tty_struct *tty, int ldisc)
 {
         int retval;
-        struct tty_ldisc o_ldisc, new_ldisc;
-        int work;
-        unsigned long flags;
+        struct tty_ldisc *o_ldisc, *new_ldisc;
+        int work, o_work = 0;
         struct tty_struct *o_tty;
 
-restart:
-        /* This is a bit ugly for now but means we can break the 'ldisc
-           is part of the tty struct' assumption later */
-        retval = tty_ldisc_get(ldisc, &new_ldisc);
-        if (retval)
-                return retval;
+        new_ldisc = tty_ldisc_get(ldisc);
+        if (IS_ERR(new_ldisc))
+                return PTR_ERR(new_ldisc);
+
+        /*
+         *      We need to look at the tty locking here for pty/tty pairs
+         *      when both sides try to change in parallel.
+         */
+
+        o_tty = tty->link;      /* o_tty is the pty side or NULL */
+
+
+        /*
+         *      Check the no-op case
+         */
+
+        if (tty->ldisc->ops->num == ldisc) {
+                tty_ldisc_put(new_ldisc);
+                return 0;
+        }
 
         /*
          *      Problem: What do we do if this blocks ?
+         *      We could deadlock here
          */
 
         tty_wait_until_sent(tty, 0);
 
-        if (tty->ldisc.ops->num == ldisc) {
-                tty_ldisc_put(new_ldisc.ops);
-                return 0;
+        mutex_lock(&tty->ldisc_mutex);
+
+        /*
+         *      We could be midstream of another ldisc change which has
+         *      dropped the lock during processing. If so we need to wait.
+         */
+
+        while (test_bit(TTY_LDISC_CHANGING, &tty->flags)) {
+                mutex_unlock(&tty->ldisc_mutex);
+                wait_event(tty_ldisc_wait,
+                        test_bit(TTY_LDISC_CHANGING, &tty->flags) == 0);
+                mutex_lock(&tty->ldisc_mutex);
         }
+        set_bit(TTY_LDISC_CHANGING, &tty->flags);
 
         /*
          *      No more input please, we are switching. The new ldisc
@@ -489,8 +616,6 @@ restart:
         tty->receive_room = 0;
 
         o_ldisc = tty->ldisc;
-        o_tty = tty->link;
-
         /*
          *      Make sure we don't change while someone holds a
          *      reference to the line discipline. The TTY_LDISC bit
@@ -501,108 +626,181 @@ restart:
          *      with a userspace app continually trying to use the tty in
          *      parallel to the change and re-referencing the tty.
          */
-        clear_bit(TTY_LDISC, &tty->flags);
-        if (o_tty)
-                clear_bit(TTY_LDISC, &o_tty->flags);
 
-        spin_lock_irqsave(&tty_ldisc_lock, flags);
-        if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
-                if (tty->ldisc.refcount) {
-                        /* Free the new ldisc we grabbed. Must drop the lock
-                           first. */
-                        spin_unlock_irqrestore(&tty_ldisc_lock, flags);
-                        tty_ldisc_put(o_ldisc.ops);
-                        /*
-                         * There are several reasons we may be busy, including
-                         * random momentary I/O traffic. We must therefore
-                         * retry. We could distinguish between blocking ops
-                         * and retries if we made tty_ldisc_wait() smarter.
-                         * That is up for discussion.
-                         */
-                        if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
-                                return -ERESTARTSYS;
-                        goto restart;
-                }
-                if (o_tty && o_tty->ldisc.refcount) {
-                        spin_unlock_irqrestore(&tty_ldisc_lock, flags);
-                        tty_ldisc_put(o_tty->ldisc.ops);
-                        if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
-                                return -ERESTARTSYS;
-                        goto restart;
-                }
-        }
-        /*
-         *      If the TTY_LDISC bit is set, then we are racing against
-         *      another ldisc change
-         */
-        if (test_bit(TTY_LDISC_CHANGING, &tty->flags)) {
-                struct tty_ldisc *ld;
-                spin_unlock_irqrestore(&tty_ldisc_lock, flags);
-                tty_ldisc_put(new_ldisc.ops);
-                ld = tty_ldisc_ref_wait(tty);
-                tty_ldisc_deref(ld);
-                goto restart;
-        }
-        /*
-         *      This flag is used to avoid two parallel ldisc changes. Once
-         *      open and close are fine grained locked this may work better
-         *      as a mutex shared with the open/close/hup paths
-         */
-        set_bit(TTY_LDISC_CHANGING, &tty->flags);
+        work = tty_ldisc_halt(tty);
         if (o_tty)
-                set_bit(TTY_LDISC_CHANGING, &o_tty->flags);
-        spin_unlock_irqrestore(&tty_ldisc_lock, flags);
-        
-        /*
-         *      From this point on we know nobody has an ldisc
-         *      usage reference, nor can they obtain one until
-         *      we say so later on.
-         */
+                o_work = tty_ldisc_halt(o_tty);
 
-        work = cancel_delayed_work(&tty->buf.work);
         /*
-         * Wait for ->hangup_work and ->buf.work handlers to terminate
-         * MUST NOT hold locks here.
+         * Wait for ->hangup_work and ->buf.work handlers to terminate.
+         * We must drop the mutex here in case a hangup is also in process.
          */
+
+        mutex_unlock(&tty->ldisc_mutex);
+
         flush_scheduled_work();
+
+        /* Let any existing reference holders finish */
+        retval = tty_ldisc_wait_idle(tty);
+        if (retval < 0) {
+                clear_bit(TTY_LDISC_CHANGING, &tty->flags);
+                tty_ldisc_put(new_ldisc);
+                return retval;
+        }
+
+        mutex_lock(&tty->ldisc_mutex);
+        if (test_bit(TTY_HUPPED, &tty->flags)) {
+                /* We were raced by the hangup method. It will have stomped
+                   the ldisc data and closed the ldisc down */
+                clear_bit(TTY_LDISC_CHANGING, &tty->flags);
+                mutex_unlock(&tty->ldisc_mutex);
+                tty_ldisc_put(new_ldisc);
+                return -EIO;
+        }
+
         /* Shutdown the current discipline. */
-        if (o_ldisc.ops->close)
-                (o_ldisc.ops->close)(tty);
+        tty_ldisc_close(tty, o_ldisc);
 
         /* Now set up the new line discipline. */
-        tty_ldisc_assign(tty, &new_ldisc);
+        tty_ldisc_assign(tty, new_ldisc);
         tty_set_termios_ldisc(tty, ldisc);
-        if (new_ldisc.ops->open)
-                retval = (new_ldisc.ops->open)(tty);
+
+        retval = tty_ldisc_open(tty, new_ldisc);
         if (retval < 0) {
-                tty_ldisc_put(new_ldisc.ops);
-                tty_ldisc_restore(tty, &o_ldisc);
+                /* Back to the old one or N_TTY if we can't */
+                tty_ldisc_put(new_ldisc);
+                tty_ldisc_restore(tty, o_ldisc);
         }
+
         /* At this point we hold a reference to the new ldisc and a
            a reference to the old ldisc. If we ended up flipping back
            to the existing ldisc we have two references to it */
 
-        if (tty->ldisc.ops->num != o_ldisc.ops->num && tty->ops->set_ldisc)
+        if (tty->ldisc->ops->num != o_ldisc->ops->num && tty->ops->set_ldisc)
                 tty->ops->set_ldisc(tty);
 
-        tty_ldisc_put(o_ldisc.ops);
+        tty_ldisc_put(o_ldisc);
 
         /*
-         *      Allow ldisc referencing to occur as soon as the driver
-         *      ldisc callback completes.
+         *      Allow ldisc referencing to occur again
          */
 
         tty_ldisc_enable(tty);
         if (o_tty)
                 tty_ldisc_enable(o_tty);
 
-        /* Restart it in case no characters kick it off. Safe if
+        /* Restart the work queue in case no characters kick it off. Safe if
            already running */
         if (work)
                 schedule_delayed_work(&tty->buf.work, 1);
+        if (o_work)
+                schedule_delayed_work(&o_tty->buf.work, 1);
+        mutex_unlock(&tty->ldisc_mutex);
         return retval;
 }
 
+/**
+ *      tty_reset_termios       -       reset terminal state
+ *      @tty: tty to reset
+ *
+ *      Restore a terminal to the driver default state.
+ */
+
+static void tty_reset_termios(struct tty_struct *tty)
+{
+        mutex_lock(&tty->termios_mutex);
+        *tty->termios = tty->driver->init_termios;
+        tty->termios->c_ispeed = tty_termios_input_baud_rate(tty->termios);
+        tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
+        mutex_unlock(&tty->termios_mutex);
+}
+
+
+/**
+ *      tty_ldisc_reinit        -       reinitialise the tty ldisc
+ *      @tty: tty to reinit
+ *
+ *      Switch the tty back to N_TTY line discipline and leave the
+ *      ldisc state closed
+ */
+
+static void tty_ldisc_reinit(struct tty_struct *tty)
+{
+        struct tty_ldisc *ld;
+
+        tty_ldisc_close(tty, tty->ldisc);
+        tty_ldisc_put(tty->ldisc);
+        tty->ldisc = NULL;
+        /*
+         *      Switch the line discipline back
+         */
+        ld = tty_ldisc_get(N_TTY);
+        BUG_ON(IS_ERR(ld));
+        tty_ldisc_assign(tty, ld);
+        tty_set_termios_ldisc(tty, N_TTY);
+}
+
+/**
+ *      tty_ldisc_hangup                -       hangup ldisc reset
+ *      @tty: tty being hung up
+ *
+ *      Some tty devices reset their termios when they receive a hangup
+ *      event. In that situation we must also switch back to N_TTY properly
+ *      before we reset the termios data.
+ *
+ *      Locking: We can take the ldisc mutex as the rest of the code is
+ *      careful to allow for this.
+ *
+ *      In the pty pair case this occurs in the close() path of the
+ *      tty itself so we must be careful about locking rules.
+ */
+
+void tty_ldisc_hangup(struct tty_struct *tty)
+{
+        struct tty_ldisc *ld;
+
+        /*
+         * FIXME! What are the locking issues here? This may me overdoing
+         * things... This question is especially important now that we've
+         * removed the irqlock.
+         */
+        ld = tty_ldisc_ref(tty);
+        if (ld != NULL) {
+                /* We may have no line discipline at this point */
+                if (ld->ops->flush_buffer)
+                        ld->ops->flush_buffer(tty);
+                tty_driver_flush_buffer(tty);
+                if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
+                    ld->ops->write_wakeup)
+                        ld->ops->write_wakeup(tty);
+                if (ld->ops->hangup)
+                        ld->ops->hangup(tty);
+                tty_ldisc_deref(ld);
+        }
+        /*
+         * FIXME: Once we trust the LDISC code better we can wait here for
+         * ldisc completion and fix the driver call race
+         */
+        wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
+        wake_up_interruptible_poll(&tty->read_wait, POLLIN);
+        /*
+         * Shutdown the current line discipline, and reset it to
+         * N_TTY.
+         */
+        if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
+                /* Avoid racing set_ldisc */
+                mutex_lock(&tty->ldisc_mutex);
+                /* Switch back to N_TTY */
+                tty_ldisc_reinit(tty);
+                /* At this point we have a closed ldisc and we want to
+                   reopen it. We could defer this to the next open but
+                   it means auditing a lot of other paths so this is a FIXME */
+                WARN_ON(tty_ldisc_open(tty, tty->ldisc));
+                tty_ldisc_enable(tty);
+                mutex_unlock(&tty->ldisc_mutex);
+                tty_reset_termios(tty);
+        }
+}
 
 /**
  *      tty_ldisc_setup                 -       open line discipline
@@ -610,24 +808,23 @@ restart:
  *      @o_tty: pair tty for pty/tty pairs
  *
  *      Called during the initial open of a tty/pty pair in order to set up the
- *      line discplines and bind them to the tty.
+ *      line disciplines and bind them to the tty. This has no locking issues
+ *      as the device isn't yet active.
  */
 
 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
 {
-        struct tty_ldisc *ld = &tty->ldisc;
+        struct tty_ldisc *ld = tty->ldisc;
         int retval;
 
-        if (ld->ops->open) {
-                retval = (ld->ops->open)(tty);
-                if (retval)
-                        return retval;
-        }
-        if (o_tty && o_tty->ldisc.ops->open) {
-                retval = (o_tty->ldisc.ops->open)(o_tty);
+        retval = tty_ldisc_open(tty, ld);
+        if (retval)
+                return retval;
+
+        if (o_tty) {
+                retval = tty_ldisc_open(o_tty, o_tty->ldisc);
                 if (retval) {
-                        if (ld->ops->close)
-                                (ld->ops->close)(tty);
+                        tty_ldisc_close(tty, ld);
                         return retval;
                 }
                 tty_ldisc_enable(o_tty);
@@ -635,32 +832,25 @@ int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
         tty_ldisc_enable(tty);
         return 0;
 }
-
 /**
  *      tty_ldisc_release               -       release line discipline
  *      @tty: tty being shut down
  *      @o_tty: pair tty for pty/tty pairs
  *
- *      Called during the final close of a tty/pty pair in order to shut down the
- *      line discpline layer.
+ *      Called during the final close of a tty/pty pair in order to shut down
+ *      the line discpline layer. On exit the ldisc assigned is N_TTY and the
+ *      ldisc has not been opened.
  */
 
 void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty)
 {
-        unsigned long flags;
-        struct tty_ldisc ld;
         /*
          * Prevent flush_to_ldisc() from rescheduling the work for later.  Then
          * kill any delayed work. As this is the final close it does not
          * race with the set_ldisc code path.
          */
-        clear_bit(TTY_LDISC, &tty->flags);
-        cancel_delayed_work(&tty->buf.work);
-
-        /*
-         * Wait for ->hangup_work and ->buf.work handlers to terminate
-         */
 
+        tty_ldisc_halt(tty);
         flush_scheduled_work();
 
         /*
@@ -668,38 +858,19 @@ void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty)
          * side waiters as the file is closing so user count on the file
          * side is zero.
          */
-        spin_lock_irqsave(&tty_ldisc_lock, flags);
-        while (tty->ldisc.refcount) {
-                spin_unlock_irqrestore(&tty_ldisc_lock, flags);
-                wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
-                spin_lock_irqsave(&tty_ldisc_lock, flags);
-        }
-        spin_unlock_irqrestore(&tty_ldisc_lock, flags);
+
+        tty_ldisc_wait_idle(tty);
+
         /*
          * Shutdown the current line discipline, and reset it to N_TTY.
          *
          * FIXME: this MUST get fixed for the new reflocking
          */
-        if (tty->ldisc.ops->close)
-                (tty->ldisc.ops->close)(tty);
-        tty_ldisc_put(tty->ldisc.ops);
 
-        /*
-         *      Switch the line discipline back
-         */
-        WARN_ON(tty_ldisc_get(N_TTY, &ld));
-        tty_ldisc_assign(tty, &ld);
-        tty_set_termios_ldisc(tty, N_TTY);
-        if (o_tty) {
-                /* FIXME: could o_tty be in setldisc here ? */
-                clear_bit(TTY_LDISC, &o_tty->flags);
-                if (o_tty->ldisc.ops->close)
-                        (o_tty->ldisc.ops->close)(o_tty);
-                tty_ldisc_put(o_tty->ldisc.ops);
-                WARN_ON(tty_ldisc_get(N_TTY, &ld));
-                tty_ldisc_assign(o_tty, &ld);
-                tty_set_termios_ldisc(o_tty, N_TTY);
-        }
+        tty_ldisc_reinit(tty);
+        /* This will need doing differently if we need to lock */
+        if (o_tty)
+                tty_ldisc_release(o_tty, NULL);
 }
 
 /**
@@ -712,10 +883,10 @@ void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty)
 
 void tty_ldisc_init(struct tty_struct *tty)
 {
-        struct tty_ldisc ld;
-        if (tty_ldisc_get(N_TTY, &ld) < 0)
+        struct tty_ldisc *ld = tty_ldisc_get(N_TTY);
+        if (IS_ERR(ld))
                 panic("n_tty: init_tty");
-        tty_ldisc_assign(tty, &ld);
+        tty_ldisc_assign(tty, ld);
 }
 
 void tty_ldisc_begin(void)
diff --git a/drivers/char/tty_port.c b/drivers/char/tty_port.c
index 9b8004c72686..62dadfc95e34 100644
--- a/drivers/char/tty_port.c
+++ b/drivers/char/tty_port.c
@@ -137,7 +137,7 @@ int tty_port_carrier_raised(struct tty_port *port)
 EXPORT_SYMBOL(tty_port_carrier_raised);
 
 /**
- *      tty_port_raise_dtr_rts  -       Riase DTR/RTS
+ *      tty_port_raise_dtr_rts  -       Raise DTR/RTS
  *      @port: tty port
  *
  *      Wrapper for the DTR/RTS raise logic. For the moment this is used
@@ -147,12 +147,28 @@ EXPORT_SYMBOL(tty_port_carrier_raised);
 
 void tty_port_raise_dtr_rts(struct tty_port *port)
 {
-        if (port->ops->raise_dtr_rts)
-                port->ops->raise_dtr_rts(port);
+        if (port->ops->dtr_rts)
+                port->ops->dtr_rts(port, 1);
 }
 EXPORT_SYMBOL(tty_port_raise_dtr_rts);
 
 /**
+ *      tty_port_lower_dtr_rts  -       Lower DTR/RTS
+ *      @port: tty port
+ *
+ *      Wrapper for the DTR/RTS raise logic. For the moment this is used
+ *      to hide some internal details. This will eventually become entirely
+ *      internal to the tty port.
+ */
+
+void tty_port_lower_dtr_rts(struct tty_port *port)
+{
+        if (port->ops->dtr_rts)
+                port->ops->dtr_rts(port, 0);
+}
+EXPORT_SYMBOL(tty_port_lower_dtr_rts);
+
+/**
  *      tty_port_block_til_ready        -       Waiting logic for tty open
  *      @port: the tty port being opened
  *      @tty: the tty device being bound
@@ -167,7 +183,7 @@ EXPORT_SYMBOL(tty_port_raise_dtr_rts);
  *              - port flags and counts
  *
  *      The passed tty_port must implement the carrier_raised method if it can
- *      do carrier detect and the raise_dtr_rts method if it supports software
+ *      do carrier detect and the dtr_rts method if it supports software
  *      management of these lines. Note that the dtr/rts raise is done each
  *      iteration as a hangup may have previously dropped them while we wait.
  */
@@ -182,7 +198,8 @@ int tty_port_block_til_ready(struct tty_port *port,
 
         /* block if port is in the process of being closed */
         if (tty_hung_up_p(filp) || port->flags & ASYNC_CLOSING) {
-                interruptible_sleep_on(&port->close_wait);
+                wait_event_interruptible(port->close_wait,
+                                !(port->flags & ASYNC_CLOSING));
                 if (port->flags & ASYNC_HUP_NOTIFY)
                         return -EAGAIN;
                 else
@@ -205,7 +222,6 @@ int tty_port_block_til_ready(struct tty_port *port,
            before the next open may complete */
 
         retval = 0;
-        add_wait_queue(&port->open_wait, &wait);
 
         /* The port lock protects the port counts */
         spin_lock_irqsave(&port->lock, flags);
@@ -219,7 +235,7 @@ int tty_port_block_til_ready(struct tty_port *port,
                 if (tty->termios->c_cflag & CBAUD)
                         tty_port_raise_dtr_rts(port);
 
-                set_current_state(TASK_INTERRUPTIBLE);
+                prepare_to_wait(&port->open_wait, &wait, TASK_INTERRUPTIBLE);
                 /* Check for a hangup or uninitialised port. Return accordingly */
                 if (tty_hung_up_p(filp) || !(port->flags & ASYNC_INITIALIZED)) {
                         if (port->flags & ASYNC_HUP_NOTIFY)
@@ -240,8 +256,7 @@ int tty_port_block_til_ready(struct tty_port *port,
                 }
                 schedule();
         }
-        set_current_state(TASK_RUNNING);
-        remove_wait_queue(&port->open_wait, &wait);
+        finish_wait(&port->open_wait, &wait);
 
         /* Update counts. A parallel hangup will have set count to zero and
            we must not mess that up further */
@@ -292,6 +307,17 @@ int tty_port_close_start(struct tty_port *port, struct tty_struct *tty, struct f
         if (port->flags & ASYNC_INITIALIZED &&
                         port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
                 tty_wait_until_sent(tty, port->closing_wait);
+        if (port->drain_delay) {
+                unsigned int bps = tty_get_baud_rate(tty);
+                long timeout;
+
+                if (bps > 1200)
+                        timeout = max_t(long, (HZ * 10 * port->drain_delay) / bps,
+                                                                HZ / 10);
+                else
+                        timeout = 2 * HZ;
+                schedule_timeout_interruptible(timeout);
+        }
         return 1;
 }
 EXPORT_SYMBOL(tty_port_close_start);
@@ -302,6 +328,9 @@ void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
 
         tty_ldisc_flush(tty);
 
+        if (tty->termios->c_cflag & HUPCL)
+                tty_port_lower_dtr_rts(port);
+
         spin_lock_irqsave(&port->lock, flags);
         tty->closing = 0;
 
diff --git a/drivers/clocksource/Makefile b/drivers/clocksource/Makefile
index 1efb2879a94f..eef216f7f61d 100644
--- a/drivers/clocksource/Makefile
+++ b/drivers/clocksource/Makefile
@@ -3,3 +3,5 @@ obj-$(CONFIG_X86_CYCLONE_TIMER)	+= cyclone.o
 obj-$(CONFIG_X86_PM_TIMER)      += acpi_pm.o
 obj-$(CONFIG_SCx200HR_TIMER)    += scx200_hrt.o
 obj-$(CONFIG_SH_TIMER_CMT)      += sh_cmt.o
+obj-$(CONFIG_SH_TIMER_MTU2)     += sh_mtu2.o
+obj-$(CONFIG_SH_TIMER_TMU)      += sh_tmu.o
diff --git a/drivers/clocksource/sh_cmt.c b/drivers/clocksource/sh_cmt.c
index 1c92c39a53aa..cf56a2af5fe1 100644
--- a/drivers/clocksource/sh_cmt.c
+++ b/drivers/clocksource/sh_cmt.c
@@ -18,7 +18,6 @@
  */
 
 #include <linux/init.h>
-#include <linux/bootmem.h>
 #include <linux/platform_device.h>
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
@@ -29,7 +28,7 @@
 #include <linux/err.h>
 #include <linux/clocksource.h>
 #include <linux/clockchips.h>
-#include <linux/sh_cmt.h>
+#include <linux/sh_timer.h>
 
 struct sh_cmt_priv {
         void __iomem *mapbase;
@@ -47,6 +46,7 @@ struct sh_cmt_priv {
         unsigned long rate;
         spinlock_t lock;
         struct clock_event_device ced;
+        struct clocksource cs;
         unsigned long total_cycles;
 };
 
@@ -59,7 +59,7 @@ static DEFINE_SPINLOCK(sh_cmt_lock);
 
 static inline unsigned long sh_cmt_read(struct sh_cmt_priv *p, int reg_nr)
 {
-        struct sh_cmt_config *cfg = p->pdev->dev.platform_data;
+        struct sh_timer_config *cfg = p->pdev->dev.platform_data;
         void __iomem *base = p->mapbase;
         unsigned long offs;
 
@@ -83,7 +83,7 @@ static inline unsigned long sh_cmt_read(struct sh_cmt_priv *p, int reg_nr)
 static inline void sh_cmt_write(struct sh_cmt_priv *p, int reg_nr,
                                 unsigned long value)
 {
-        struct sh_cmt_config *cfg = p->pdev->dev.platform_data;
+        struct sh_timer_config *cfg = p->pdev->dev.platform_data;
         void __iomem *base = p->mapbase;
         unsigned long offs;
 
@@ -110,23 +110,28 @@ static unsigned long sh_cmt_get_counter(struct sh_cmt_priv *p,
                                         int *has_wrapped)
 {
         unsigned long v1, v2, v3;
+        int o1, o2;
+
+        o1 = sh_cmt_read(p, CMCSR) & p->overflow_bit;
 
         /* Make sure the timer value is stable. Stolen from acpi_pm.c */
         do {
+                o2 = o1;
                 v1 = sh_cmt_read(p, CMCNT);
                 v2 = sh_cmt_read(p, CMCNT);
                 v3 = sh_cmt_read(p, CMCNT);
-        } while (unlikely((v1 > v2 && v1 < v3) || (v2 > v3 && v2 < v1)
-                          || (v3 > v1 && v3 < v2)));
+                o1 = sh_cmt_read(p, CMCSR) & p->overflow_bit;
+        } while (unlikely((o1 != o2) || (v1 > v2 && v1 < v3)
+                          || (v2 > v3 && v2 < v1) || (v3 > v1 && v3 < v2)));
 
-        *has_wrapped = sh_cmt_read(p, CMCSR) & p->overflow_bit;
+        *has_wrapped = o1;
         return v2;
 }
 
 
 static void sh_cmt_start_stop_ch(struct sh_cmt_priv *p, int start)
 {
-        struct sh_cmt_config *cfg = p->pdev->dev.platform_data;
+        struct sh_timer_config *cfg = p->pdev->dev.platform_data;
         unsigned long flags, value;
 
         /* start stop register shared by multiple timer channels */
@@ -144,7 +149,7 @@ static void sh_cmt_start_stop_ch(struct sh_cmt_priv *p, int start)
 
 static int sh_cmt_enable(struct sh_cmt_priv *p, unsigned long *rate)
 {
-        struct sh_cmt_config *cfg = p->pdev->dev.platform_data;
+        struct sh_timer_config *cfg = p->pdev->dev.platform_data;
         int ret;
 
         /* enable clock */
@@ -153,16 +158,18 @@ static int sh_cmt_enable(struct sh_cmt_priv *p, unsigned long *rate)
                 pr_err("sh_cmt: cannot enable clock \"%s\"\n", cfg->clk);
                 return ret;
         }
-        *rate = clk_get_rate(p->clk) / 8;
 
         /* make sure channel is disabled */
         sh_cmt_start_stop_ch(p, 0);
 
         /* configure channel, periodic mode and maximum timeout */
-        if (p->width == 16)
-                sh_cmt_write(p, CMCSR, 0);
-        else
+        if (p->width == 16) {
+                *rate = clk_get_rate(p->clk) / 512;
+                sh_cmt_write(p, CMCSR, 0x43);
+        } else {
+                *rate = clk_get_rate(p->clk) / 8;
                 sh_cmt_write(p, CMCSR, 0x01a4);
+        }
 
         sh_cmt_write(p, CMCOR, 0xffffffff);
         sh_cmt_write(p, CMCNT, 0);
@@ -376,6 +383,68 @@ static void sh_cmt_stop(struct sh_cmt_priv *p, unsigned long flag)
         spin_unlock_irqrestore(&p->lock, flags);
 }
 
+static struct sh_cmt_priv *cs_to_sh_cmt(struct clocksource *cs)
+{
+        return container_of(cs, struct sh_cmt_priv, cs);
+}
+
+static cycle_t sh_cmt_clocksource_read(struct clocksource *cs)
+{
+        struct sh_cmt_priv *p = cs_to_sh_cmt(cs);
+        unsigned long flags, raw;
+        unsigned long value;
+        int has_wrapped;
+
+        spin_lock_irqsave(&p->lock, flags);
+        value = p->total_cycles;
+        raw = sh_cmt_get_counter(p, &has_wrapped);
+
+        if (unlikely(has_wrapped))
+                raw += p->match_value;
+        spin_unlock_irqrestore(&p->lock, flags);
+
+        return value + raw;
+}
+
+static int sh_cmt_clocksource_enable(struct clocksource *cs)
+{
+        struct sh_cmt_priv *p = cs_to_sh_cmt(cs);
+        int ret;
+
+        p->total_cycles = 0;
+
+        ret = sh_cmt_start(p, FLAG_CLOCKSOURCE);
+        if (ret)
+                return ret;
+
+        /* TODO: calculate good shift from rate and counter bit width */
+        cs->shift = 0;
+        cs->mult = clocksource_hz2mult(p->rate, cs->shift);
+        return 0;
+}
+
+static void sh_cmt_clocksource_disable(struct clocksource *cs)
+{
+        sh_cmt_stop(cs_to_sh_cmt(cs), FLAG_CLOCKSOURCE);
+}
+
+static int sh_cmt_register_clocksource(struct sh_cmt_priv *p,
+                                       char *name, unsigned long rating)
+{
+        struct clocksource *cs = &p->cs;
+
+        cs->name = name;
+        cs->rating = rating;
+        cs->read = sh_cmt_clocksource_read;
+        cs->enable = sh_cmt_clocksource_enable;
+        cs->disable = sh_cmt_clocksource_disable;
+        cs->mask = CLOCKSOURCE_MASK(sizeof(unsigned long) * 8);
+        cs->flags = CLOCK_SOURCE_IS_CONTINUOUS;
+        pr_info("sh_cmt: %s used as clock source\n", cs->name);
+        clocksource_register(cs);
+        return 0;
+}
+
 static struct sh_cmt_priv *ced_to_sh_cmt(struct clock_event_device *ced)
 {
         return container_of(ced, struct sh_cmt_priv, ced);
@@ -468,9 +537,9 @@ static void sh_cmt_register_clockevent(struct sh_cmt_priv *p,
         clockevents_register_device(ced);
 }
 
-int sh_cmt_register(struct sh_cmt_priv *p, char *name,
-                    unsigned long clockevent_rating,
-                    unsigned long clocksource_rating)
+static int sh_cmt_register(struct sh_cmt_priv *p, char *name,
+                           unsigned long clockevent_rating,
+                           unsigned long clocksource_rating)
 {
         if (p->width == (sizeof(p->max_match_value) * 8))
                 p->max_match_value = ~0;
@@ -483,12 +552,15 @@ int sh_cmt_register(struct sh_cmt_priv *p, char *name,
         if (clockevent_rating)
                 sh_cmt_register_clockevent(p, name, clockevent_rating);
 
+        if (clocksource_rating)
+                sh_cmt_register_clocksource(p, name, clocksource_rating);
+
         return 0;
 }
 
 static int sh_cmt_setup(struct sh_cmt_priv *p, struct platform_device *pdev)
 {
-        struct sh_cmt_config *cfg = pdev->dev.platform_data;
+        struct sh_timer_config *cfg = pdev->dev.platform_data;
         struct resource *res;
         int irq, ret;
         ret = -ENXIO;
@@ -545,7 +617,7 @@ static int sh_cmt_setup(struct sh_cmt_priv *p, struct platform_device *pdev)
         if (resource_size(res) == 6) {
                 p->width = 16;
                 p->overflow_bit = 0x80;
-                p->clear_bits = ~0xc0;
+                p->clear_bits = ~0x80;
         } else {
                 p->width = 32;
                 p->overflow_bit = 0x8000;
@@ -566,8 +638,14 @@ static int sh_cmt_setup(struct sh_cmt_priv *p, struct platform_device *pdev)
 static int __devinit sh_cmt_probe(struct platform_device *pdev)
 {
         struct sh_cmt_priv *p = platform_get_drvdata(pdev);
+        struct sh_timer_config *cfg = pdev->dev.platform_data;
         int ret;
 
+        if (p) {
+                pr_info("sh_cmt: %s kept as earlytimer\n", cfg->name);
+                return 0;
+        }
+
         p = kmalloc(sizeof(*p), GFP_KERNEL);
         if (p == NULL) {
                 dev_err(&pdev->dev, "failed to allocate driver data\n");
@@ -577,7 +655,6 @@ static int __devinit sh_cmt_probe(struct platform_device *pdev)
         ret = sh_cmt_setup(p, pdev);
         if (ret) {
                 kfree(p);
-
                 platform_set_drvdata(pdev, NULL);
         }
         return ret;
@@ -606,6 +683,7 @@ static void __exit sh_cmt_exit(void)
         platform_driver_unregister(&sh_cmt_device_driver);
 }
 
+early_platform_init("earlytimer", &sh_cmt_device_driver);
 module_init(sh_cmt_init);
 module_exit(sh_cmt_exit);
 
diff --git a/drivers/clocksource/sh_mtu2.c b/drivers/clocksource/sh_mtu2.c
new file mode 100644
index 000000000000..d1ae75454d10
--- /dev/null
+++ b/drivers/clocksource/sh_mtu2.c
@@ -0,0 +1,357 @@
+/*
+ * SuperH Timer Support - MTU2
+ *
+ *  Copyright (C) 2009 Magnus Damm
+ *
+ * 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
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+#include <linux/interrupt.h>
+#include <linux/ioport.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/irq.h>
+#include <linux/err.h>
+#include <linux/clockchips.h>
+#include <linux/sh_timer.h>
+
+struct sh_mtu2_priv {
+        void __iomem *mapbase;
+        struct clk *clk;
+        struct irqaction irqaction;
+        struct platform_device *pdev;
+        unsigned long rate;
+        unsigned long periodic;
+        struct clock_event_device ced;
+};
+
+static DEFINE_SPINLOCK(sh_mtu2_lock);
+
+#define TSTR -1 /* shared register */
+#define TCR  0 /* channel register */
+#define TMDR 1 /* channel register */
+#define TIOR 2 /* channel register */
+#define TIER 3 /* channel register */
+#define TSR  4 /* channel register */
+#define TCNT 5 /* channel register */
+#define TGR  6 /* channel register */
+
+static unsigned long mtu2_reg_offs[] = {
+        [TCR] = 0,
+        [TMDR] = 1,
+        [TIOR] = 2,
+        [TIER] = 4,
+        [TSR] = 5,
+        [TCNT] = 6,
+        [TGR] = 8,
+};
+
+static inline unsigned long sh_mtu2_read(struct sh_mtu2_priv *p, int reg_nr)
+{
+        struct sh_timer_config *cfg = p->pdev->dev.platform_data;
+        void __iomem *base = p->mapbase;
+        unsigned long offs;
+
+        if (reg_nr == TSTR)
+                return ioread8(base + cfg->channel_offset);
+
+        offs = mtu2_reg_offs[reg_nr];
+
+        if ((reg_nr == TCNT) || (reg_nr == TGR))
+                return ioread16(base + offs);
+        else
+                return ioread8(base + offs);
+}
+
+static inline void sh_mtu2_write(struct sh_mtu2_priv *p, int reg_nr,
+                                unsigned long value)
+{
+        struct sh_timer_config *cfg = p->pdev->dev.platform_data;
+        void __iomem *base = p->mapbase;
+        unsigned long offs;
+
+        if (reg_nr == TSTR) {
+                iowrite8(value, base + cfg->channel_offset);
+                return;
+        }
+
+        offs = mtu2_reg_offs[reg_nr];
+
+        if ((reg_nr == TCNT) || (reg_nr == TGR))
+                iowrite16(value, base + offs);
+        else
+                iowrite8(value, base + offs);
+}
+
+static void sh_mtu2_start_stop_ch(struct sh_mtu2_priv *p, int start)
+{
+        struct sh_timer_config *cfg = p->pdev->dev.platform_data;
+        unsigned long flags, value;
+
+        /* start stop register shared by multiple timer channels */
+        spin_lock_irqsave(&sh_mtu2_lock, flags);
+        value = sh_mtu2_read(p, TSTR);
+
+        if (start)
+                value |= 1 << cfg->timer_bit;
+        else
+                value &= ~(1 << cfg->timer_bit);
+
+        sh_mtu2_write(p, TSTR, value);
+        spin_unlock_irqrestore(&sh_mtu2_lock, flags);
+}
+
+static int sh_mtu2_enable(struct sh_mtu2_priv *p)
+{
+        struct sh_timer_config *cfg = p->pdev->dev.platform_data;
+        int ret;
+
+        /* enable clock */
+        ret = clk_enable(p->clk);
+        if (ret) {
+                pr_err("sh_mtu2: cannot enable clock \"%s\"\n", cfg->clk);
+                return ret;
+        }
+
+        /* make sure channel is disabled */
+        sh_mtu2_start_stop_ch(p, 0);
+
+        p->rate = clk_get_rate(p->clk) / 64;
+        p->periodic = (p->rate + HZ/2) / HZ;
+
+        /* "Periodic Counter Operation" */
+        sh_mtu2_write(p, TCR, 0x23); /* TGRA clear, divide clock by 64 */
+        sh_mtu2_write(p, TIOR, 0);
+        sh_mtu2_write(p, TGR, p->periodic);
+        sh_mtu2_write(p, TCNT, 0);
+        sh_mtu2_write(p, TMDR, 0);
+        sh_mtu2_write(p, TIER, 0x01);
+
+        /* enable channel */
+        sh_mtu2_start_stop_ch(p, 1);
+
+        return 0;
+}
+
+static void sh_mtu2_disable(struct sh_mtu2_priv *p)
+{
+        /* disable channel */
+        sh_mtu2_start_stop_ch(p, 0);
+
+        /* stop clock */
+        clk_disable(p->clk);
+}
+
+static irqreturn_t sh_mtu2_interrupt(int irq, void *dev_id)
+{
+        struct sh_mtu2_priv *p = dev_id;
+
+        /* acknowledge interrupt */
+        sh_mtu2_read(p, TSR);
+        sh_mtu2_write(p, TSR, 0xfe);
+
+        /* notify clockevent layer */
+        p->ced.event_handler(&p->ced);
+        return IRQ_HANDLED;
+}
+
+static struct sh_mtu2_priv *ced_to_sh_mtu2(struct clock_event_device *ced)
+{
+        return container_of(ced, struct sh_mtu2_priv, ced);
+}
+
+static void sh_mtu2_clock_event_mode(enum clock_event_mode mode,
+                                    struct clock_event_device *ced)
+{
+        struct sh_mtu2_priv *p = ced_to_sh_mtu2(ced);
+        int disabled = 0;
+
+        /* deal with old setting first */
+        switch (ced->mode) {
+        case CLOCK_EVT_MODE_PERIODIC:
+                sh_mtu2_disable(p);
+                disabled = 1;
+                break;
+        default:
+                break;
+        }
+
+        switch (mode) {
+        case CLOCK_EVT_MODE_PERIODIC:
+                pr_info("sh_mtu2: %s used for periodic clock events\n",
+                        ced->name);
+                sh_mtu2_enable(p);
+                break;
+        case CLOCK_EVT_MODE_UNUSED:
+                if (!disabled)
+                        sh_mtu2_disable(p);
+                break;
+        case CLOCK_EVT_MODE_SHUTDOWN:
+        default:
+                break;
+        }
+}
+
+static void sh_mtu2_register_clockevent(struct sh_mtu2_priv *p,
+                                       char *name, unsigned long rating)
+{
+        struct clock_event_device *ced = &p->ced;
+        int ret;
+
+        memset(ced, 0, sizeof(*ced));
+
+        ced->name = name;
+        ced->features = CLOCK_EVT_FEAT_PERIODIC;
+        ced->rating = rating;
+        ced->cpumask = cpumask_of(0);
+        ced->set_mode = sh_mtu2_clock_event_mode;
+
+        ret = setup_irq(p->irqaction.irq, &p->irqaction);
+        if (ret) {
+                pr_err("sh_mtu2: failed to request irq %d\n",
+                       p->irqaction.irq);
+                return;
+        }
+
+        pr_info("sh_mtu2: %s used for clock events\n", ced->name);
+        clockevents_register_device(ced);
+}
+
+static int sh_mtu2_register(struct sh_mtu2_priv *p, char *name,
+                            unsigned long clockevent_rating)
+{
+        if (clockevent_rating)
+                sh_mtu2_register_clockevent(p, name, clockevent_rating);
+
+        return 0;
+}
+
+static int sh_mtu2_setup(struct sh_mtu2_priv *p, struct platform_device *pdev)
+{
+        struct sh_timer_config *cfg = pdev->dev.platform_data;
+        struct resource *res;
+        int irq, ret;
+        ret = -ENXIO;
+
+        memset(p, 0, sizeof(*p));
+        p->pdev = pdev;
+
+        if (!cfg) {
+                dev_err(&p->pdev->dev, "missing platform data\n");
+                goto err0;
+        }
+
+        platform_set_drvdata(pdev, p);
+
+        res = platform_get_resource(p->pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&p->pdev->dev, "failed to get I/O memory\n");
+                goto err0;
+        }
+
+        irq = platform_get_irq(p->pdev, 0);
+        if (irq < 0) {
+                dev_err(&p->pdev->dev, "failed to get irq\n");
+                goto err0;
+        }
+
+        /* map memory, let mapbase point to our channel */
+        p->mapbase = ioremap_nocache(res->start, resource_size(res));
+        if (p->mapbase == NULL) {
+                pr_err("sh_mtu2: failed to remap I/O memory\n");
+                goto err0;
+        }
+
+        /* setup data for setup_irq() (too early for request_irq()) */
+        p->irqaction.name = cfg->name;
+        p->irqaction.handler = sh_mtu2_interrupt;
+        p->irqaction.dev_id = p;
+        p->irqaction.irq = irq;
+        p->irqaction.flags = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL;
+        p->irqaction.mask = CPU_MASK_NONE;
+
+        /* get hold of clock */
+        p->clk = clk_get(&p->pdev->dev, cfg->clk);
+        if (IS_ERR(p->clk)) {
+                pr_err("sh_mtu2: cannot get clock \"%s\"\n", cfg->clk);
+                ret = PTR_ERR(p->clk);
+                goto err1;
+        }
+
+        return sh_mtu2_register(p, cfg->name, cfg->clockevent_rating);
+ err1:
+        iounmap(p->mapbase);
+ err0:
+        return ret;
+}
+
+static int __devinit sh_mtu2_probe(struct platform_device *pdev)
+{
+        struct sh_mtu2_priv *p = platform_get_drvdata(pdev);
+        struct sh_timer_config *cfg = pdev->dev.platform_data;
+        int ret;
+
+        if (p) {
+                pr_info("sh_mtu2: %s kept as earlytimer\n", cfg->name);
+                return 0;
+        }
+
+        p = kmalloc(sizeof(*p), GFP_KERNEL);
+        if (p == NULL) {
+                dev_err(&pdev->dev, "failed to allocate driver data\n");
+                return -ENOMEM;
+        }
+
+        ret = sh_mtu2_setup(p, pdev);
+        if (ret) {
+                kfree(p);
+                platform_set_drvdata(pdev, NULL);
+        }
+        return ret;
+}
+
+static int __devexit sh_mtu2_remove(struct platform_device *pdev)
+{
+        return -EBUSY; /* cannot unregister clockevent */
+}
+
+static struct platform_driver sh_mtu2_device_driver = {
+        .probe          = sh_mtu2_probe,
+        .remove         = __devexit_p(sh_mtu2_remove),
+        .driver         = {
+                .name   = "sh_mtu2",
+        }
+};
+
+static int __init sh_mtu2_init(void)
+{
+        return platform_driver_register(&sh_mtu2_device_driver);
+}
+
+static void __exit sh_mtu2_exit(void)
+{
+        platform_driver_unregister(&sh_mtu2_device_driver);
+}
+
+early_platform_init("earlytimer", &sh_mtu2_device_driver);
+module_init(sh_mtu2_init);
+module_exit(sh_mtu2_exit);
+
+MODULE_AUTHOR("Magnus Damm");
+MODULE_DESCRIPTION("SuperH MTU2 Timer Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/clocksource/sh_tmu.c b/drivers/clocksource/sh_tmu.c
new file mode 100644
index 000000000000..d6ea4398bf62
--- /dev/null
+++ b/drivers/clocksource/sh_tmu.c
@@ -0,0 +1,461 @@
+/*
+ * SuperH Timer Support - TMU
+ *
+ *  Copyright (C) 2009 Magnus Damm
+ *
+ * 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
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+#include <linux/interrupt.h>
+#include <linux/ioport.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/irq.h>
+#include <linux/err.h>
+#include <linux/clocksource.h>
+#include <linux/clockchips.h>
+#include <linux/sh_timer.h>
+
+struct sh_tmu_priv {
+        void __iomem *mapbase;
+        struct clk *clk;
+        struct irqaction irqaction;
+        struct platform_device *pdev;
+        unsigned long rate;
+        unsigned long periodic;
+        struct clock_event_device ced;
+        struct clocksource cs;
+};
+
+static DEFINE_SPINLOCK(sh_tmu_lock);
+
+#define TSTR -1 /* shared register */
+#define TCOR  0 /* channel register */
+#define TCNT 1 /* channel register */
+#define TCR 2 /* channel register */
+
+static inline unsigned long sh_tmu_read(struct sh_tmu_priv *p, int reg_nr)
+{
+        struct sh_timer_config *cfg = p->pdev->dev.platform_data;
+        void __iomem *base = p->mapbase;
+        unsigned long offs;
+
+        if (reg_nr == TSTR)
+                return ioread8(base - cfg->channel_offset);
+
+        offs = reg_nr << 2;
+
+        if (reg_nr == TCR)
+                return ioread16(base + offs);
+        else
+                return ioread32(base + offs);
+}
+
+static inline void sh_tmu_write(struct sh_tmu_priv *p, int reg_nr,
+                                unsigned long value)
+{
+        struct sh_timer_config *cfg = p->pdev->dev.platform_data;
+        void __iomem *base = p->mapbase;
+        unsigned long offs;
+
+        if (reg_nr == TSTR) {
+                iowrite8(value, base - cfg->channel_offset);
+                return;
+        }
+
+        offs = reg_nr << 2;
+
+        if (reg_nr == TCR)
+                iowrite16(value, base + offs);
+        else
+                iowrite32(value, base + offs);
+}
+
+static void sh_tmu_start_stop_ch(struct sh_tmu_priv *p, int start)
+{
+        struct sh_timer_config *cfg = p->pdev->dev.platform_data;
+        unsigned long flags, value;
+
+        /* start stop register shared by multiple timer channels */
+        spin_lock_irqsave(&sh_tmu_lock, flags);
+        value = sh_tmu_read(p, TSTR);
+
+        if (start)
+                value |= 1 << cfg->timer_bit;
+        else
+                value &= ~(1 << cfg->timer_bit);
+
+        sh_tmu_write(p, TSTR, value);
+        spin_unlock_irqrestore(&sh_tmu_lock, flags);
+}
+
+static int sh_tmu_enable(struct sh_tmu_priv *p)
+{
+        struct sh_timer_config *cfg = p->pdev->dev.platform_data;
+        int ret;
+
+        /* enable clock */
+        ret = clk_enable(p->clk);
+        if (ret) {
+                pr_err("sh_tmu: cannot enable clock \"%s\"\n", cfg->clk);
+                return ret;
+        }
+
+        /* make sure channel is disabled */
+        sh_tmu_start_stop_ch(p, 0);
+
+        /* maximum timeout */
+        sh_tmu_write(p, TCOR, 0xffffffff);
+        sh_tmu_write(p, TCNT, 0xffffffff);
+
+        /* configure channel to parent clock / 4, irq off */
+        p->rate = clk_get_rate(p->clk) / 4;
+        sh_tmu_write(p, TCR, 0x0000);
+
+        /* enable channel */
+        sh_tmu_start_stop_ch(p, 1);
+
+        return 0;
+}
+
+static void sh_tmu_disable(struct sh_tmu_priv *p)
+{
+        /* disable channel */
+        sh_tmu_start_stop_ch(p, 0);
+
+        /* stop clock */
+        clk_disable(p->clk);
+}
+
+static void sh_tmu_set_next(struct sh_tmu_priv *p, unsigned long delta,
+                            int periodic)
+{
+        /* stop timer */
+        sh_tmu_start_stop_ch(p, 0);
+
+        /* acknowledge interrupt */
+        sh_tmu_read(p, TCR);
+
+        /* enable interrupt */
+        sh_tmu_write(p, TCR, 0x0020);
+
+        /* reload delta value in case of periodic timer */
+        if (periodic)
+                sh_tmu_write(p, TCOR, delta);
+        else
+                sh_tmu_write(p, TCOR, 0);
+
+        sh_tmu_write(p, TCNT, delta);
+
+        /* start timer */
+        sh_tmu_start_stop_ch(p, 1);
+}
+
+static irqreturn_t sh_tmu_interrupt(int irq, void *dev_id)
+{
+        struct sh_tmu_priv *p = dev_id;
+
+        /* disable or acknowledge interrupt */
+        if (p->ced.mode == CLOCK_EVT_MODE_ONESHOT)
+                sh_tmu_write(p, TCR, 0x0000);
+        else
+                sh_tmu_write(p, TCR, 0x0020);
+
+        /* notify clockevent layer */
+        p->ced.event_handler(&p->ced);
+        return IRQ_HANDLED;
+}
+
+static struct sh_tmu_priv *cs_to_sh_tmu(struct clocksource *cs)
+{
+        return container_of(cs, struct sh_tmu_priv, cs);
+}
+
+static cycle_t sh_tmu_clocksource_read(struct clocksource *cs)
+{
+        struct sh_tmu_priv *p = cs_to_sh_tmu(cs);
+
+        return sh_tmu_read(p, TCNT) ^ 0xffffffff;
+}
+
+static int sh_tmu_clocksource_enable(struct clocksource *cs)
+{
+        struct sh_tmu_priv *p = cs_to_sh_tmu(cs);
+        int ret;
+
+        ret = sh_tmu_enable(p);
+        if (ret)
+                return ret;
+
+        /* TODO: calculate good shift from rate and counter bit width */
+        cs->shift = 10;
+        cs->mult = clocksource_hz2mult(p->rate, cs->shift);
+        return 0;
+}
+
+static void sh_tmu_clocksource_disable(struct clocksource *cs)
+{
+        sh_tmu_disable(cs_to_sh_tmu(cs));
+}
+
+static int sh_tmu_register_clocksource(struct sh_tmu_priv *p,
+                                       char *name, unsigned long rating)
+{
+        struct clocksource *cs = &p->cs;
+
+        cs->name = name;
+        cs->rating = rating;
+        cs->read = sh_tmu_clocksource_read;
+        cs->enable = sh_tmu_clocksource_enable;
+        cs->disable = sh_tmu_clocksource_disable;
+        cs->mask = CLOCKSOURCE_MASK(32);
+        cs->flags = CLOCK_SOURCE_IS_CONTINUOUS;
+        pr_info("sh_tmu: %s used as clock source\n", cs->name);
+        clocksource_register(cs);
+        return 0;
+}
+
+static struct sh_tmu_priv *ced_to_sh_tmu(struct clock_event_device *ced)
+{
+        return container_of(ced, struct sh_tmu_priv, ced);
+}
+
+static void sh_tmu_clock_event_start(struct sh_tmu_priv *p, int periodic)
+{
+        struct clock_event_device *ced = &p->ced;
+
+        sh_tmu_enable(p);
+
+        /* TODO: calculate good shift from rate and counter bit width */
+
+        ced->shift = 32;
+        ced->mult = div_sc(p->rate, NSEC_PER_SEC, ced->shift);
+        ced->max_delta_ns = clockevent_delta2ns(0xffffffff, ced);
+        ced->min_delta_ns = 5000;
+
+        if (periodic) {
+                p->periodic = (p->rate + HZ/2) / HZ;
+                sh_tmu_set_next(p, p->periodic, 1);
+        }
+}
+
+static void sh_tmu_clock_event_mode(enum clock_event_mode mode,
+                                    struct clock_event_device *ced)
+{
+        struct sh_tmu_priv *p = ced_to_sh_tmu(ced);
+        int disabled = 0;
+
+        /* deal with old setting first */
+        switch (ced->mode) {
+        case CLOCK_EVT_MODE_PERIODIC:
+        case CLOCK_EVT_MODE_ONESHOT:
+                sh_tmu_disable(p);
+                disabled = 1;
+                break;
+        default:
+                break;
+        }
+
+        switch (mode) {
+        case CLOCK_EVT_MODE_PERIODIC:
+                pr_info("sh_tmu: %s used for periodic clock events\n",
+                        ced->name);
+                sh_tmu_clock_event_start(p, 1);
+                break;
+        case CLOCK_EVT_MODE_ONESHOT:
+                pr_info("sh_tmu: %s used for oneshot clock events\n",
+                        ced->name);
+                sh_tmu_clock_event_start(p, 0);
+                break;
+        case CLOCK_EVT_MODE_UNUSED:
+                if (!disabled)
+                        sh_tmu_disable(p);
+                break;
+        case CLOCK_EVT_MODE_SHUTDOWN:
+        default:
+                break;
+        }
+}
+
+static int sh_tmu_clock_event_next(unsigned long delta,
+                                   struct clock_event_device *ced)
+{
+        struct sh_tmu_priv *p = ced_to_sh_tmu(ced);
+
+        BUG_ON(ced->mode != CLOCK_EVT_MODE_ONESHOT);
+
+        /* program new delta value */
+        sh_tmu_set_next(p, delta, 0);
+        return 0;
+}
+
+static void sh_tmu_register_clockevent(struct sh_tmu_priv *p,
+                                       char *name, unsigned long rating)
+{
+        struct clock_event_device *ced = &p->ced;
+        int ret;
+
+        memset(ced, 0, sizeof(*ced));
+
+        ced->name = name;
+        ced->features = CLOCK_EVT_FEAT_PERIODIC;
+        ced->features |= CLOCK_EVT_FEAT_ONESHOT;
+        ced->rating = rating;
+        ced->cpumask = cpumask_of(0);
+        ced->set_next_event = sh_tmu_clock_event_next;
+        ced->set_mode = sh_tmu_clock_event_mode;
+
+        ret = setup_irq(p->irqaction.irq, &p->irqaction);
+        if (ret) {
+                pr_err("sh_tmu: failed to request irq %d\n",
+                       p->irqaction.irq);
+                return;
+        }
+
+        pr_info("sh_tmu: %s used for clock events\n", ced->name);
+        clockevents_register_device(ced);
+}
+
+static int sh_tmu_register(struct sh_tmu_priv *p, char *name,
+                    unsigned long clockevent_rating,
+                    unsigned long clocksource_rating)
+{
+        if (clockevent_rating)
+                sh_tmu_register_clockevent(p, name, clockevent_rating);
+        else if (clocksource_rating)
+                sh_tmu_register_clocksource(p, name, clocksource_rating);
+
+        return 0;
+}
+
+static int sh_tmu_setup(struct sh_tmu_priv *p, struct platform_device *pdev)
+{
+        struct sh_timer_config *cfg = pdev->dev.platform_data;
+        struct resource *res;
+        int irq, ret;
+        ret = -ENXIO;
+
+        memset(p, 0, sizeof(*p));
+        p->pdev = pdev;
+
+        if (!cfg) {
+                dev_err(&p->pdev->dev, "missing platform data\n");
+                goto err0;
+        }
+
+        platform_set_drvdata(pdev, p);
+
+        res = platform_get_resource(p->pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(&p->pdev->dev, "failed to get I/O memory\n");
+                goto err0;
+        }
+
+        irq = platform_get_irq(p->pdev, 0);
+        if (irq < 0) {
+                dev_err(&p->pdev->dev, "failed to get irq\n");
+                goto err0;
+        }
+
+        /* map memory, let mapbase point to our channel */
+        p->mapbase = ioremap_nocache(res->start, resource_size(res));
+        if (p->mapbase == NULL) {
+                pr_err("sh_tmu: failed to remap I/O memory\n");
+                goto err0;
+        }
+
+        /* setup data for setup_irq() (too early for request_irq()) */
+        p->irqaction.name = cfg->name;
+        p->irqaction.handler = sh_tmu_interrupt;
+        p->irqaction.dev_id = p;
+        p->irqaction.irq = irq;
+        p->irqaction.flags = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL;
+        p->irqaction.mask = CPU_MASK_NONE;
+
+        /* get hold of clock */
+        p->clk = clk_get(&p->pdev->dev, cfg->clk);
+        if (IS_ERR(p->clk)) {
+                pr_err("sh_tmu: cannot get clock \"%s\"\n", cfg->clk);
+                ret = PTR_ERR(p->clk);
+                goto err1;
+        }
+
+        return sh_tmu_register(p, cfg->name,
+                               cfg->clockevent_rating,
+                               cfg->clocksource_rating);
+ err1:
+        iounmap(p->mapbase);
+ err0:
+        return ret;
+}
+
+static int __devinit sh_tmu_probe(struct platform_device *pdev)
+{
+        struct sh_tmu_priv *p = platform_get_drvdata(pdev);
+        struct sh_timer_config *cfg = pdev->dev.platform_data;
+        int ret;
+
+        if (p) {
+                pr_info("sh_tmu: %s kept as earlytimer\n", cfg->name);
+                return 0;
+        }
+
+        p = kmalloc(sizeof(*p), GFP_KERNEL);
+        if (p == NULL) {
+                dev_err(&pdev->dev, "failed to allocate driver data\n");
+                return -ENOMEM;
+        }
+
+        ret = sh_tmu_setup(p, pdev);
+        if (ret) {
+                kfree(p);
+                platform_set_drvdata(pdev, NULL);
+        }
+        return ret;
+}
+
+static int __devexit sh_tmu_remove(struct platform_device *pdev)
+{
+        return -EBUSY; /* cannot unregister clockevent and clocksource */
+}
+
+static struct platform_driver sh_tmu_device_driver = {
+        .probe          = sh_tmu_probe,
+        .remove         = __devexit_p(sh_tmu_remove),
+        .driver         = {
+                .name   = "sh_tmu",
+        }
+};
+
+static int __init sh_tmu_init(void)
+{
+        return platform_driver_register(&sh_tmu_device_driver);
+}
+
+static void __exit sh_tmu_exit(void)
+{
+        platform_driver_unregister(&sh_tmu_device_driver);
+}
+
+early_platform_init("earlytimer", &sh_tmu_device_driver);
+module_init(sh_tmu_init);
+module_exit(sh_tmu_exit);
+
+MODULE_AUTHOR("Magnus Damm");
+MODULE_DESCRIPTION("SuperH TMU Timer Driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/edac/Kconfig b/drivers/edac/Kconfig
index 956982f8739b..ab4f3592a11c 100644
--- a/drivers/edac/Kconfig
+++ b/drivers/edac/Kconfig
@@ -49,7 +49,6 @@ config EDAC_DEBUG_VERBOSE
 
 config EDAC_MM_EDAC
         tristate "Main Memory EDAC (Error Detection And Correction) reporting"
-        default y
         help
           Some systems are able to detect and correct errors in main
           memory.  EDAC can report statistics on memory error
@@ -58,6 +57,31 @@ config EDAC_MM_EDAC
           occurred so that a particular failing memory module can be
           replaced.  If unsure, select 'Y'.
 
+config EDAC_AMD64
+        tristate "AMD64 (Opteron, Athlon64) K8, F10h, F11h"
+        depends on EDAC_MM_EDAC && K8_NB && X86_64 && PCI
+        help
+          Support for error detection and correction on the AMD 64
+          Families of Memory Controllers (K8, F10h and F11h)
+
+config EDAC_AMD64_ERROR_INJECTION
+        bool "Sysfs Error Injection facilities"
+        depends on EDAC_AMD64
+        help
+          Recent Opterons (Family 10h and later) provide for Memory Error
+          Injection into the ECC detection circuits. The amd64_edac module
+          allows the operator/user to inject Uncorrectable and Correctable
+          errors into DRAM.
+
+          When enabled, in each of the respective memory controller directories
+          (/sys/devices/system/edac/mc/mcX), there are 3 input files:
+
+          - inject_section (0..3, 16-byte section of 64-byte cacheline),
+          - inject_word (0..8, 16-bit word of 16-byte section),
+          - inject_ecc_vector (hex ecc vector: select bits of inject word)
+
+          In addition, there are two control files, inject_read and inject_write,
+          which trigger the DRAM ECC Read and Write respectively.
 
 config EDAC_AMD76X
         tristate "AMD 76x (760, 762, 768)"
diff --git a/drivers/edac/Makefile b/drivers/edac/Makefile
index 59076819135d..633dc5604ee3 100644
--- a/drivers/edac/Makefile
+++ b/drivers/edac/Makefile
@@ -30,6 +30,13 @@ obj-$(CONFIG_EDAC_I3000)		+= i3000_edac.o
 obj-$(CONFIG_EDAC_X38)                  += x38_edac.o
 obj-$(CONFIG_EDAC_I82860)               += i82860_edac.o
 obj-$(CONFIG_EDAC_R82600)               += r82600_edac.o
+
+amd64_edac_mod-y :=  amd64_edac_err_types.o amd64_edac.o
+amd64_edac_mod-$(CONFIG_EDAC_DEBUG) += amd64_edac_dbg.o
+amd64_edac_mod-$(CONFIG_EDAC_AMD64_ERROR_INJECTION) += amd64_edac_inj.o
+
+obj-$(CONFIG_EDAC_AMD64)                += amd64_edac_mod.o
+
 obj-$(CONFIG_EDAC_PASEMI)               += pasemi_edac.o
 obj-$(CONFIG_EDAC_MPC85XX)              += mpc85xx_edac.o
 obj-$(CONFIG_EDAC_MV64X60)              += mv64x60_edac.o
diff --git a/drivers/edac/amd64_edac.c b/drivers/edac/amd64_edac.c
new file mode 100644
index 000000000000..c36bf40568cf
--- /dev/null
+++ b/drivers/edac/amd64_edac.c
@@ -0,0 +1,3354 @@
+#include "amd64_edac.h"
+#include <asm/k8.h>
+
+static struct edac_pci_ctl_info *amd64_ctl_pci;
+
+static int report_gart_errors;
+module_param(report_gart_errors, int, 0644);
+
+/*
+ * Set by command line parameter. If BIOS has enabled the ECC, this override is
+ * cleared to prevent re-enabling the hardware by this driver.
+ */
+static int ecc_enable_override;
+module_param(ecc_enable_override, int, 0644);
+
+/* Lookup table for all possible MC control instances */
+struct amd64_pvt;
+static struct mem_ctl_info *mci_lookup[MAX_NUMNODES];
+static struct amd64_pvt *pvt_lookup[MAX_NUMNODES];
+
+/*
+ * Memory scrubber control interface. For K8, memory scrubbing is handled by
+ * hardware and can involve L2 cache, dcache as well as the main memory. With
+ * F10, this is extended to L3 cache scrubbing on CPU models sporting that
+ * functionality.
+ *
+ * This causes the "units" for the scrubbing speed to vary from 64 byte blocks
+ * (dram) over to cache lines. This is nasty, so we will use bandwidth in
+ * bytes/sec for the setting.
+ *
+ * Currently, we only do dram scrubbing. If the scrubbing is done in software on
+ * other archs, we might not have access to the caches directly.
+ */
+
+/*
+ * scan the scrub rate mapping table for a close or matching bandwidth value to
+ * issue. If requested is too big, then use last maximum value found.
+ */
+static int amd64_search_set_scrub_rate(struct pci_dev *ctl, u32 new_bw,
+                                       u32 min_scrubrate)
+{
+        u32 scrubval;
+        int i;
+
+        /*
+         * map the configured rate (new_bw) to a value specific to the AMD64
+         * memory controller and apply to register. Search for the first
+         * bandwidth entry that is greater or equal than the setting requested
+         * and program that. If at last entry, turn off DRAM scrubbing.
+         */
+        for (i = 0; i < ARRAY_SIZE(scrubrates); i++) {
+                /*
+                 * skip scrub rates which aren't recommended
+                 * (see F10 BKDG, F3x58)
+                 */
+                if (scrubrates[i].scrubval < min_scrubrate)
+                        continue;
+
+                if (scrubrates[i].bandwidth <= new_bw)
+                        break;
+
+                /*
+                 * if no suitable bandwidth found, turn off DRAM scrubbing
+                 * entirely by falling back to the last element in the
+                 * scrubrates array.
+                 */
+        }
+
+        scrubval = scrubrates[i].scrubval;
+        if (scrubval)
+                edac_printk(KERN_DEBUG, EDAC_MC,
+                            "Setting scrub rate bandwidth: %u\n",
+                            scrubrates[i].bandwidth);
+        else
+                edac_printk(KERN_DEBUG, EDAC_MC, "Turning scrubbing off.\n");
+
+        pci_write_bits32(ctl, K8_SCRCTRL, scrubval, 0x001F);
+
+        return 0;
+}
+
+static int amd64_set_scrub_rate(struct mem_ctl_info *mci, u32 *bandwidth)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        u32 min_scrubrate = 0x0;
+
+        switch (boot_cpu_data.x86) {
+        case 0xf:
+                min_scrubrate = K8_MIN_SCRUB_RATE_BITS;
+                break;
+        case 0x10:
+                min_scrubrate = F10_MIN_SCRUB_RATE_BITS;
+                break;
+        case 0x11:
+                min_scrubrate = F11_MIN_SCRUB_RATE_BITS;
+                break;
+
+        default:
+                amd64_printk(KERN_ERR, "Unsupported family!\n");
+                break;
+        }
+        return amd64_search_set_scrub_rate(pvt->misc_f3_ctl, *bandwidth,
+                        min_scrubrate);
+}
+
+static int amd64_get_scrub_rate(struct mem_ctl_info *mci, u32 *bw)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        u32 scrubval = 0;
+        int status = -1, i, ret = 0;
+
+        ret = pci_read_config_dword(pvt->misc_f3_ctl, K8_SCRCTRL, &scrubval);
+        if (ret)
+                debugf0("Reading K8_SCRCTRL failed\n");
+
+        scrubval = scrubval & 0x001F;
+
+        edac_printk(KERN_DEBUG, EDAC_MC,
+                    "pci-read, sdram scrub control value: %d \n", scrubval);
+
+        for (i = 0; ARRAY_SIZE(scrubrates); i++) {
+                if (scrubrates[i].scrubval == scrubval) {
+                        *bw = scrubrates[i].bandwidth;
+                        status = 0;
+                        break;
+                }
+        }
+
+        return status;
+}
+
+/* Map from a CSROW entry to the mask entry that operates on it */
+static inline u32 amd64_map_to_dcs_mask(struct amd64_pvt *pvt, int csrow)
+{
+        return csrow >> (pvt->num_dcsm >> 3);
+}
+
+/* return the 'base' address the i'th CS entry of the 'dct' DRAM controller */
+static u32 amd64_get_dct_base(struct amd64_pvt *pvt, int dct, int csrow)
+{
+        if (dct == 0)
+                return pvt->dcsb0[csrow];
+        else
+                return pvt->dcsb1[csrow];
+}
+
+/*
+ * Return the 'mask' address the i'th CS entry. This function is needed because
+ * there number of DCSM registers on Rev E and prior vs Rev F and later is
+ * different.
+ */
+static u32 amd64_get_dct_mask(struct amd64_pvt *pvt, int dct, int csrow)
+{
+        if (dct == 0)
+                return pvt->dcsm0[amd64_map_to_dcs_mask(pvt, csrow)];
+        else
+                return pvt->dcsm1[amd64_map_to_dcs_mask(pvt, csrow)];
+}
+
+
+/*
+ * In *base and *limit, pass back the full 40-bit base and limit physical
+ * addresses for the node given by node_id.  This information is obtained from
+ * DRAM Base (section 3.4.4.1) and DRAM Limit (section 3.4.4.2) registers. The
+ * base and limit addresses are of type SysAddr, as defined at the start of
+ * section 3.4.4 (p. 70).  They are the lowest and highest physical addresses
+ * in the address range they represent.
+ */
+static void amd64_get_base_and_limit(struct amd64_pvt *pvt, int node_id,
+                               u64 *base, u64 *limit)
+{
+        *base = pvt->dram_base[node_id];
+        *limit = pvt->dram_limit[node_id];
+}
+
+/*
+ * Return 1 if the SysAddr given by sys_addr matches the base/limit associated
+ * with node_id
+ */
+static int amd64_base_limit_match(struct amd64_pvt *pvt,
+                                        u64 sys_addr, int node_id)
+{
+        u64 base, limit, addr;
+
+        amd64_get_base_and_limit(pvt, node_id, &base, &limit);
+
+        /* The K8 treats this as a 40-bit value.  However, bits 63-40 will be
+         * all ones if the most significant implemented address bit is 1.
+         * Here we discard bits 63-40.  See section 3.4.2 of AMD publication
+         * 24592: AMD x86-64 Architecture Programmer's Manual Volume 1
+         * Application Programming.
+         */
+        addr = sys_addr & 0x000000ffffffffffull;
+
+        return (addr >= base) && (addr <= limit);
+}
+
+/*
+ * Attempt to map a SysAddr to a node. On success, return a pointer to the
+ * mem_ctl_info structure for the node that the SysAddr maps to.
+ *
+ * On failure, return NULL.
+ */
+static struct mem_ctl_info *find_mc_by_sys_addr(struct mem_ctl_info *mci,
+                                                u64 sys_addr)
+{
+        struct amd64_pvt *pvt;
+        int node_id;
+        u32 intlv_en, bits;
+
+        /*
+         * Here we use the DRAM Base (section 3.4.4.1) and DRAM Limit (section
+         * 3.4.4.2) registers to map the SysAddr to a node ID.
+         */
+        pvt = mci->pvt_info;
+
+        /*
+         * The value of this field should be the same for all DRAM Base
+         * registers.  Therefore we arbitrarily choose to read it from the
+         * register for node 0.
+         */
+        intlv_en = pvt->dram_IntlvEn[0];
+
+        if (intlv_en == 0) {
+                for (node_id = 0; ; ) {
+                        if (amd64_base_limit_match(pvt, sys_addr, node_id))
+                                break;
+
+                        if (++node_id >= DRAM_REG_COUNT)
+                                goto err_no_match;
+                }
+                goto found;
+        }
+
+        if (unlikely((intlv_en != (0x01 << 8)) &&
+                     (intlv_en != (0x03 << 8)) &&
+                     (intlv_en != (0x07 << 8)))) {
+                amd64_printk(KERN_WARNING, "junk value of 0x%x extracted from "
+                             "IntlvEn field of DRAM Base Register for node 0: "
+                             "This probably indicates a BIOS bug.\n", intlv_en);
+                return NULL;
+        }
+
+        bits = (((u32) sys_addr) >> 12) & intlv_en;
+
+        for (node_id = 0; ; ) {
+                if ((pvt->dram_limit[node_id] & intlv_en) == bits)
+                        break;  /* intlv_sel field matches */
+
+                if (++node_id >= DRAM_REG_COUNT)
+                        goto err_no_match;
+        }
+
+        /* sanity test for sys_addr */
+        if (unlikely(!amd64_base_limit_match(pvt, sys_addr, node_id))) {
+                amd64_printk(KERN_WARNING,
+                          "%s(): sys_addr 0x%lx falls outside base/limit "
+                          "address range for node %d with node interleaving "
+                          "enabled.\n", __func__, (unsigned long)sys_addr,
+                          node_id);
+                return NULL;
+        }
+
+found:
+        return edac_mc_find(node_id);
+
+err_no_match:
+        debugf2("sys_addr 0x%lx doesn't match any node\n",
+                (unsigned long)sys_addr);
+
+        return NULL;
+}
+
+/*
+ * Extract the DRAM CS base address from selected csrow register.
+ */
+static u64 base_from_dct_base(struct amd64_pvt *pvt, int csrow)
+{
+        return ((u64) (amd64_get_dct_base(pvt, 0, csrow) & pvt->dcsb_base)) <<
+                                pvt->dcs_shift;
+}
+
+/*
+ * Extract the mask from the dcsb0[csrow] entry in a CPU revision-specific way.
+ */
+static u64 mask_from_dct_mask(struct amd64_pvt *pvt, int csrow)
+{
+        u64 dcsm_bits, other_bits;
+        u64 mask;
+
+        /* Extract bits from DRAM CS Mask. */
+        dcsm_bits = amd64_get_dct_mask(pvt, 0, csrow) & pvt->dcsm_mask;
+
+        other_bits = pvt->dcsm_mask;
+        other_bits = ~(other_bits << pvt->dcs_shift);
+
+        /*
+         * The extracted bits from DCSM belong in the spaces represented by
+         * the cleared bits in other_bits.
+         */
+        mask = (dcsm_bits << pvt->dcs_shift) | other_bits;
+
+        return mask;
+}
+
+/*
+ * @input_addr is an InputAddr associated with the node given by mci. Return the
+ * csrow that input_addr maps to, or -1 on failure (no csrow claims input_addr).
+ */
+static int input_addr_to_csrow(struct mem_ctl_info *mci, u64 input_addr)
+{
+        struct amd64_pvt *pvt;
+        int csrow;
+        u64 base, mask;
+
+        pvt = mci->pvt_info;
+
+        /*
+         * Here we use the DRAM CS Base and DRAM CS Mask registers. For each CS
+         * base/mask register pair, test the condition shown near the start of
+         * section 3.5.4 (p. 84, BKDG #26094, K8, revA-E).
+         */
+        for (csrow = 0; csrow < CHIPSELECT_COUNT; csrow++) {
+
+                /* This DRAM chip select is disabled on this node */
+                if ((pvt->dcsb0[csrow] & K8_DCSB_CS_ENABLE) == 0)
+                        continue;
+
+                base = base_from_dct_base(pvt, csrow);
+                mask = ~mask_from_dct_mask(pvt, csrow);
+
+                if ((input_addr & mask) == (base & mask)) {
+                        debugf2("InputAddr 0x%lx matches csrow %d (node %d)\n",
+                                (unsigned long)input_addr, csrow,
+                                pvt->mc_node_id);
+
+                        return csrow;
+                }
+        }
+
+        debugf2("no matching csrow for InputAddr 0x%lx (MC node %d)\n",
+                (unsigned long)input_addr, pvt->mc_node_id);
+
+        return -1;
+}
+
+/*
+ * Return the base value defined by the DRAM Base register for the node
+ * represented by mci.  This function returns the full 40-bit value despite the
+ * fact that the register only stores bits 39-24 of the value. See section
+ * 3.4.4.1 (BKDG #26094, K8, revA-E)
+ */
+static inline u64 get_dram_base(struct mem_ctl_info *mci)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+
+        return pvt->dram_base[pvt->mc_node_id];
+}
+
+/*
+ * Obtain info from the DRAM Hole Address Register (section 3.4.8, pub #26094)
+ * for the node represented by mci. Info is passed back in *hole_base,
+ * *hole_offset, and *hole_size.  Function returns 0 if info is valid or 1 if
+ * info is invalid. Info may be invalid for either of the following reasons:
+ *
+ * - The revision of the node is not E or greater.  In this case, the DRAM Hole
+ *   Address Register does not exist.
+ *
+ * - The DramHoleValid bit is cleared in the DRAM Hole Address Register,
+ *   indicating that its contents are not valid.
+ *
+ * The values passed back in *hole_base, *hole_offset, and *hole_size are
+ * complete 32-bit values despite the fact that the bitfields in the DHAR
+ * only represent bits 31-24 of the base and offset values.
+ */
+int amd64_get_dram_hole_info(struct mem_ctl_info *mci, u64 *hole_base,
+                             u64 *hole_offset, u64 *hole_size)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        u64 base;
+
+        /* only revE and later have the DRAM Hole Address Register */
+        if (boot_cpu_data.x86 == 0xf && pvt->ext_model < OPTERON_CPU_REV_E) {
+                debugf1("  revision %d for node %d does not support DHAR\n",
+                        pvt->ext_model, pvt->mc_node_id);
+                return 1;
+        }
+
+        /* only valid for Fam10h */
+        if (boot_cpu_data.x86 == 0x10 &&
+            (pvt->dhar & F10_DRAM_MEM_HOIST_VALID) == 0) {
+                debugf1("  Dram Memory Hoisting is DISABLED on this system\n");
+                return 1;
+        }
+
+        if ((pvt->dhar & DHAR_VALID) == 0) {
+                debugf1("  Dram Memory Hoisting is DISABLED on this node %d\n",
+                        pvt->mc_node_id);
+                return 1;
+        }
+
+        /* This node has Memory Hoisting */
+
+        /* +------------------+--------------------+--------------------+-----
+         * | memory           | DRAM hole          | relocated          |
+         * | [0, (x - 1)]     | [x, 0xffffffff]    | addresses from     |
+         * |                  |                    | DRAM hole          |
+         * |                  |                    | [0x100000000,      |
+         * |                  |                    |  (0x100000000+     |
+         * |                  |                    |   (0xffffffff-x))] |
+         * +------------------+--------------------+--------------------+-----
+         *
+         * Above is a diagram of physical memory showing the DRAM hole and the
+         * relocated addresses from the DRAM hole.  As shown, the DRAM hole
+         * starts at address x (the base address) and extends through address
+         * 0xffffffff.  The DRAM Hole Address Register (DHAR) relocates the
+         * addresses in the hole so that they start at 0x100000000.
+         */
+
+        base = dhar_base(pvt->dhar);
+
+        *hole_base = base;
+        *hole_size = (0x1ull << 32) - base;
+
+        if (boot_cpu_data.x86 > 0xf)
+                *hole_offset = f10_dhar_offset(pvt->dhar);
+        else
+                *hole_offset = k8_dhar_offset(pvt->dhar);
+
+        debugf1("  DHAR info for node %d base 0x%lx offset 0x%lx size 0x%lx\n",
+                pvt->mc_node_id, (unsigned long)*hole_base,
+                (unsigned long)*hole_offset, (unsigned long)*hole_size);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(amd64_get_dram_hole_info);
+
+/*
+ * Return the DramAddr that the SysAddr given by @sys_addr maps to.  It is
+ * assumed that sys_addr maps to the node given by mci.
+ *
+ * The first part of section 3.4.4 (p. 70) shows how the DRAM Base (section
+ * 3.4.4.1) and DRAM Limit (section 3.4.4.2) registers are used to translate a
+ * SysAddr to a DramAddr. If the DRAM Hole Address Register (DHAR) is enabled,
+ * then it is also involved in translating a SysAddr to a DramAddr. Sections
+ * 3.4.8 and 3.5.8.2 describe the DHAR and how it is used for memory hoisting.
+ * These parts of the documentation are unclear. I interpret them as follows:
+ *
+ * When node n receives a SysAddr, it processes the SysAddr as follows:
+ *
+ * 1. It extracts the DRAMBase and DRAMLimit values from the DRAM Base and DRAM
+ *    Limit registers for node n. If the SysAddr is not within the range
+ *    specified by the base and limit values, then node n ignores the Sysaddr
+ *    (since it does not map to node n). Otherwise continue to step 2 below.
+ *
+ * 2. If the DramHoleValid bit of the DHAR for node n is clear, the DHAR is
+ *    disabled so skip to step 3 below. Otherwise see if the SysAddr is within
+ *    the range of relocated addresses (starting at 0x100000000) from the DRAM
+ *    hole. If not, skip to step 3 below. Else get the value of the
+ *    DramHoleOffset field from the DHAR. To obtain the DramAddr, subtract the
+ *    offset defined by this value from the SysAddr.
+ *
+ * 3. Obtain the base address for node n from the DRAMBase field of the DRAM
+ *    Base register for node n. To obtain the DramAddr, subtract the base
+ *    address from the SysAddr, as shown near the start of section 3.4.4 (p.70).
+ */
+static u64 sys_addr_to_dram_addr(struct mem_ctl_info *mci, u64 sys_addr)
+{
+        u64 dram_base, hole_base, hole_offset, hole_size, dram_addr;
+        int ret = 0;
+
+        dram_base = get_dram_base(mci);
+
+        ret = amd64_get_dram_hole_info(mci, &hole_base, &hole_offset,
+                                      &hole_size);
+        if (!ret) {
+                if ((sys_addr >= (1ull << 32)) &&
+                    (sys_addr < ((1ull << 32) + hole_size))) {
+                        /* use DHAR to translate SysAddr to DramAddr */
+                        dram_addr = sys_addr - hole_offset;
+
+                        debugf2("using DHAR to translate SysAddr 0x%lx to "
+                                "DramAddr 0x%lx\n",
+                                (unsigned long)sys_addr,
+                                (unsigned long)dram_addr);
+
+                        return dram_addr;
+                }
+        }
+
+        /*
+         * Translate the SysAddr to a DramAddr as shown near the start of
+         * section 3.4.4 (p. 70).  Although sys_addr is a 64-bit value, the k8
+         * only deals with 40-bit values.  Therefore we discard bits 63-40 of
+         * sys_addr below.  If bit 39 of sys_addr is 1 then the bits we
+         * discard are all 1s.  Otherwise the bits we discard are all 0s.  See
+         * section 3.4.2 of AMD publication 24592: AMD x86-64 Architecture
+         * Programmer's Manual Volume 1 Application Programming.
+         */
+        dram_addr = (sys_addr & 0xffffffffffull) - dram_base;
+
+        debugf2("using DRAM Base register to translate SysAddr 0x%lx to "
+                "DramAddr 0x%lx\n", (unsigned long)sys_addr,
+                (unsigned long)dram_addr);
+        return dram_addr;
+}
+
+/*
+ * @intlv_en is the value of the IntlvEn field from a DRAM Base register
+ * (section 3.4.4.1).  Return the number of bits from a SysAddr that are used
+ * for node interleaving.
+ */
+static int num_node_interleave_bits(unsigned intlv_en)
+{
+        static const int intlv_shift_table[] = { 0, 1, 0, 2, 0, 0, 0, 3 };
+        int n;
+
+        BUG_ON(intlv_en > 7);
+        n = intlv_shift_table[intlv_en];
+        return n;
+}
+
+/* Translate the DramAddr given by @dram_addr to an InputAddr. */
+static u64 dram_addr_to_input_addr(struct mem_ctl_info *mci, u64 dram_addr)
+{
+        struct amd64_pvt *pvt;
+        int intlv_shift;
+        u64 input_addr;
+
+        pvt = mci->pvt_info;
+
+        /*
+         * See the start of section 3.4.4 (p. 70, BKDG #26094, K8, revA-E)
+         * concerning translating a DramAddr to an InputAddr.
+         */
+        intlv_shift = num_node_interleave_bits(pvt->dram_IntlvEn[0]);
+        input_addr = ((dram_addr >> intlv_shift) & 0xffffff000ull) +
+            (dram_addr & 0xfff);
+
+        debugf2("  Intlv Shift=%d DramAddr=0x%lx maps to InputAddr=0x%lx\n",
+                intlv_shift, (unsigned long)dram_addr,
+                (unsigned long)input_addr);
+
+        return input_addr;
+}
+
+/*
+ * Translate the SysAddr represented by @sys_addr to an InputAddr.  It is
+ * assumed that @sys_addr maps to the node given by mci.
+ */
+static u64 sys_addr_to_input_addr(struct mem_ctl_info *mci, u64 sys_addr)
+{
+        u64 input_addr;
+
+        input_addr =
+            dram_addr_to_input_addr(mci, sys_addr_to_dram_addr(mci, sys_addr));
+
+        debugf2("SysAdddr 0x%lx translates to InputAddr 0x%lx\n",
+                (unsigned long)sys_addr, (unsigned long)input_addr);
+
+        return input_addr;
+}
+
+
+/*
+ * @input_addr is an InputAddr associated with the node represented by mci.
+ * Translate @input_addr to a DramAddr and return the result.
+ */
+static u64 input_addr_to_dram_addr(struct mem_ctl_info *mci, u64 input_addr)
+{
+        struct amd64_pvt *pvt;
+        int node_id, intlv_shift;
+        u64 bits, dram_addr;
+        u32 intlv_sel;
+
+        /*
+         * Near the start of section 3.4.4 (p. 70, BKDG #26094, K8, revA-E)
+         * shows how to translate a DramAddr to an InputAddr. Here we reverse
+         * this procedure. When translating from a DramAddr to an InputAddr, the
+         * bits used for node interleaving are discarded.  Here we recover these
+         * bits from the IntlvSel field of the DRAM Limit register (section
+         * 3.4.4.2) for the node that input_addr is associated with.
+         */
+        pvt = mci->pvt_info;
+        node_id = pvt->mc_node_id;
+        BUG_ON((node_id < 0) || (node_id > 7));
+
+        intlv_shift = num_node_interleave_bits(pvt->dram_IntlvEn[0]);
+
+        if (intlv_shift == 0) {
+                debugf1("    InputAddr 0x%lx translates to DramAddr of "
+                        "same value\n", (unsigned long)input_addr);
+
+                return input_addr;
+        }
+
+        bits = ((input_addr & 0xffffff000ull) << intlv_shift) +
+            (input_addr & 0xfff);
+
+        intlv_sel = pvt->dram_IntlvSel[node_id] & ((1 << intlv_shift) - 1);
+        dram_addr = bits + (intlv_sel << 12);
+
+        debugf1("InputAddr 0x%lx translates to DramAddr 0x%lx "
+                "(%d node interleave bits)\n", (unsigned long)input_addr,
+                (unsigned long)dram_addr, intlv_shift);
+
+        return dram_addr;
+}
+
+/*
+ * @dram_addr is a DramAddr that maps to the node represented by mci. Convert
+ * @dram_addr to a SysAddr.
+ */
+static u64 dram_addr_to_sys_addr(struct mem_ctl_info *mci, u64 dram_addr)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        u64 hole_base, hole_offset, hole_size, base, limit, sys_addr;
+        int ret = 0;
+
+        ret = amd64_get_dram_hole_info(mci, &hole_base, &hole_offset,
+                                      &hole_size);
+        if (!ret) {
+                if ((dram_addr >= hole_base) &&
+                    (dram_addr < (hole_base + hole_size))) {
+                        sys_addr = dram_addr + hole_offset;
+
+                        debugf1("using DHAR to translate DramAddr 0x%lx to "
+                                "SysAddr 0x%lx\n", (unsigned long)dram_addr,
+                                (unsigned long)sys_addr);
+
+                        return sys_addr;
+                }
+        }
+
+        amd64_get_base_and_limit(pvt, pvt->mc_node_id, &base, &limit);
+        sys_addr = dram_addr + base;
+
+        /*
+         * The sys_addr we have computed up to this point is a 40-bit value
+         * because the k8 deals with 40-bit values.  However, the value we are
+         * supposed to return is a full 64-bit physical address.  The AMD
+         * x86-64 architecture specifies that the most significant implemented
+         * address bit through bit 63 of a physical address must be either all
+         * 0s or all 1s.  Therefore we sign-extend the 40-bit sys_addr to a
+         * 64-bit value below.  See section 3.4.2 of AMD publication 24592:
+         * AMD x86-64 Architecture Programmer's Manual Volume 1 Application
+         * Programming.
+         */
+        sys_addr |= ~((sys_addr & (1ull << 39)) - 1);
+
+        debugf1("    Node %d, DramAddr 0x%lx to SysAddr 0x%lx\n",
+                pvt->mc_node_id, (unsigned long)dram_addr,
+                (unsigned long)sys_addr);
+
+        return sys_addr;
+}
+
+/*
+ * @input_addr is an InputAddr associated with the node given by mci. Translate
+ * @input_addr to a SysAddr.
+ */
+static inline u64 input_addr_to_sys_addr(struct mem_ctl_info *mci,
+                                         u64 input_addr)
+{
+        return dram_addr_to_sys_addr(mci,
+                                     input_addr_to_dram_addr(mci, input_addr));
+}
+
+/*
+ * Find the minimum and maximum InputAddr values that map to the given @csrow.
+ * Pass back these values in *input_addr_min and *input_addr_max.
+ */
+static void find_csrow_limits(struct mem_ctl_info *mci, int csrow,
+                              u64 *input_addr_min, u64 *input_addr_max)
+{
+        struct amd64_pvt *pvt;
+        u64 base, mask;
+
+        pvt = mci->pvt_info;
+        BUG_ON((csrow < 0) || (csrow >= CHIPSELECT_COUNT));
+
+        base = base_from_dct_base(pvt, csrow);
+        mask = mask_from_dct_mask(pvt, csrow);
+
+        *input_addr_min = base & ~mask;
+        *input_addr_max = base | mask | pvt->dcs_mask_notused;
+}
+
+/*
+ * Extract error address from MCA NB Address Low (section 3.6.4.5) and MCA NB
+ * Address High (section 3.6.4.6) register values and return the result. Address
+ * is located in the info structure (nbeah and nbeal), the encoding is device
+ * specific.
+ */
+static u64 extract_error_address(struct mem_ctl_info *mci,
+                                 struct amd64_error_info_regs *info)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+
+        return pvt->ops->get_error_address(mci, info);
+}
+
+
+/* Map the Error address to a PAGE and PAGE OFFSET. */
+static inline void error_address_to_page_and_offset(u64 error_address,
+                                                    u32 *page, u32 *offset)
+{
+        *page = (u32) (error_address >> PAGE_SHIFT);
+        *offset = ((u32) error_address) & ~PAGE_MASK;
+}
+
+/*
+ * @sys_addr is an error address (a SysAddr) extracted from the MCA NB Address
+ * Low (section 3.6.4.5) and MCA NB Address High (section 3.6.4.6) registers
+ * of a node that detected an ECC memory error.  mci represents the node that
+ * the error address maps to (possibly different from the node that detected
+ * the error).  Return the number of the csrow that sys_addr maps to, or -1 on
+ * error.
+ */
+static int sys_addr_to_csrow(struct mem_ctl_info *mci, u64 sys_addr)
+{
+        int csrow;
+
+        csrow = input_addr_to_csrow(mci, sys_addr_to_input_addr(mci, sys_addr));
+
+        if (csrow == -1)
+                amd64_mc_printk(mci, KERN_ERR,
+                             "Failed to translate InputAddr to csrow for "
+                             "address 0x%lx\n", (unsigned long)sys_addr);
+        return csrow;
+}
+
+static int get_channel_from_ecc_syndrome(unsigned short syndrome);
+
+static void amd64_cpu_display_info(struct amd64_pvt *pvt)
+{
+        if (boot_cpu_data.x86 == 0x11)
+                edac_printk(KERN_DEBUG, EDAC_MC, "F11h CPU detected\n");
+        else if (boot_cpu_data.x86 == 0x10)
+                edac_printk(KERN_DEBUG, EDAC_MC, "F10h CPU detected\n");
+        else if (boot_cpu_data.x86 == 0xf)
+                edac_printk(KERN_DEBUG, EDAC_MC, "%s detected\n",
+                        (pvt->ext_model >= OPTERON_CPU_REV_F) ?
+                        "Rev F or later" : "Rev E or earlier");
+        else
+                /* we'll hardly ever ever get here */
+                edac_printk(KERN_ERR, EDAC_MC, "Unknown cpu!\n");
+}
+
+/*
+ * Determine if the DIMMs have ECC enabled. ECC is enabled ONLY if all the DIMMs
+ * are ECC capable.
+ */
+static enum edac_type amd64_determine_edac_cap(struct amd64_pvt *pvt)
+{
+        int bit;
+        enum dev_type edac_cap = EDAC_NONE;
+
+        bit = (boot_cpu_data.x86 > 0xf || pvt->ext_model >= OPTERON_CPU_REV_F)
+                ? 19
+                : 17;
+
+        if (pvt->dclr0 >> BIT(bit))
+                edac_cap = EDAC_FLAG_SECDED;
+
+        return edac_cap;
+}
+
+
+static void f10_debug_display_dimm_sizes(int ctrl, struct amd64_pvt *pvt,
+                                         int ganged);
+
+/* Display and decode various NB registers for debug purposes. */
+static void amd64_dump_misc_regs(struct amd64_pvt *pvt)
+{
+        int ganged;
+
+        debugf1("  nbcap:0x%8.08x DctDualCap=%s DualNode=%s 8-Node=%s\n",
+                pvt->nbcap,
+                (pvt->nbcap & K8_NBCAP_DCT_DUAL) ? "True" : "False",
+                (pvt->nbcap & K8_NBCAP_DUAL_NODE) ? "True" : "False",
+                (pvt->nbcap & K8_NBCAP_8_NODE) ? "True" : "False");
+        debugf1("    ECC Capable=%s   ChipKill Capable=%s\n",
+                (pvt->nbcap & K8_NBCAP_SECDED) ? "True" : "False",
+                (pvt->nbcap & K8_NBCAP_CHIPKILL) ? "True" : "False");
+        debugf1("  DramCfg0-low=0x%08x DIMM-ECC=%s Parity=%s Width=%s\n",
+                pvt->dclr0,
+                (pvt->dclr0 & BIT(19)) ?  "Enabled" : "Disabled",
+                (pvt->dclr0 & BIT(8)) ?  "Enabled" : "Disabled",
+                (pvt->dclr0 & BIT(11)) ?  "128b" : "64b");
+        debugf1("    DIMM x4 Present: L0=%s L1=%s L2=%s L3=%s  DIMM Type=%s\n",
+                (pvt->dclr0 & BIT(12)) ?  "Y" : "N",
+                (pvt->dclr0 & BIT(13)) ?  "Y" : "N",
+                (pvt->dclr0 & BIT(14)) ?  "Y" : "N",
+                (pvt->dclr0 & BIT(15)) ?  "Y" : "N",
+                (pvt->dclr0 & BIT(16)) ?  "UN-Buffered" : "Buffered");
+
+
+        debugf1("  online-spare: 0x%8.08x\n", pvt->online_spare);
+
+        if (boot_cpu_data.x86 == 0xf) {
+                debugf1("  dhar: 0x%8.08x Base=0x%08x Offset=0x%08x\n",
+                        pvt->dhar, dhar_base(pvt->dhar),
+                        k8_dhar_offset(pvt->dhar));
+                debugf1("      DramHoleValid=%s\n",
+                        (pvt->dhar & DHAR_VALID) ?  "True" : "False");
+
+                debugf1("  dbam-dkt: 0x%8.08x\n", pvt->dbam0);
+
+                /* everything below this point is Fam10h and above */
+                return;
+
+        } else {
+                debugf1("  dhar: 0x%8.08x Base=0x%08x Offset=0x%08x\n",
+                        pvt->dhar, dhar_base(pvt->dhar),
+                        f10_dhar_offset(pvt->dhar));
+                debugf1("    DramMemHoistValid=%s DramHoleValid=%s\n",
+                        (pvt->dhar & F10_DRAM_MEM_HOIST_VALID) ?
+                        "True" : "False",
+                        (pvt->dhar & DHAR_VALID) ?
+                        "True" : "False");
+        }
+
+        /* Only if NOT ganged does dcl1 have valid info */
+        if (!dct_ganging_enabled(pvt)) {
+                debugf1("  DramCfg1-low=0x%08x DIMM-ECC=%s Parity=%s "
+                        "Width=%s\n", pvt->dclr1,
+                        (pvt->dclr1 & BIT(19)) ?  "Enabled" : "Disabled",
+                        (pvt->dclr1 & BIT(8)) ?  "Enabled" : "Disabled",
+                        (pvt->dclr1 & BIT(11)) ?  "128b" : "64b");
+                debugf1("    DIMM x4 Present: L0=%s L1=%s L2=%s L3=%s  "
+                        "DIMM Type=%s\n",
+                        (pvt->dclr1 & BIT(12)) ?  "Y" : "N",
+                        (pvt->dclr1 & BIT(13)) ?  "Y" : "N",
+                        (pvt->dclr1 & BIT(14)) ?  "Y" : "N",
+                        (pvt->dclr1 & BIT(15)) ?  "Y" : "N",
+                        (pvt->dclr1 & BIT(16)) ?  "UN-Buffered" : "Buffered");
+        }
+
+        /*
+         * Determine if ganged and then dump memory sizes for first controller,
+         * and if NOT ganged dump info for 2nd controller.
+         */
+        ganged = dct_ganging_enabled(pvt);
+
+        f10_debug_display_dimm_sizes(0, pvt, ganged);
+
+        if (!ganged)
+                f10_debug_display_dimm_sizes(1, pvt, ganged);
+}
+
+/* Read in both of DBAM registers */
+static void amd64_read_dbam_reg(struct amd64_pvt *pvt)
+{
+        int err = 0;
+        unsigned int reg;
+
+        reg = DBAM0;
+        err = pci_read_config_dword(pvt->dram_f2_ctl, reg, &pvt->dbam0);
+        if (err)
+                goto err_reg;
+
+        if (boot_cpu_data.x86 >= 0x10) {
+                reg = DBAM1;
+                err = pci_read_config_dword(pvt->dram_f2_ctl, reg, &pvt->dbam1);
+
+                if (err)
+                        goto err_reg;
+        }
+
+err_reg:
+        debugf0("Error reading F2x%03x.\n", reg);
+}
+
+/*
+ * NOTE: CPU Revision Dependent code: Rev E and Rev F
+ *
+ * Set the DCSB and DCSM mask values depending on the CPU revision value. Also
+ * set the shift factor for the DCSB and DCSM values.
+ *
+ * ->dcs_mask_notused, RevE:
+ *
+ * To find the max InputAddr for the csrow, start with the base address and set
+ * all bits that are "don't care" bits in the test at the start of section
+ * 3.5.4 (p. 84).
+ *
+ * The "don't care" bits are all set bits in the mask and all bits in the gaps
+ * between bit ranges [35:25] and [19:13]. The value REV_E_DCS_NOTUSED_BITS
+ * represents bits [24:20] and [12:0], which are all bits in the above-mentioned
+ * gaps.
+ *
+ * ->dcs_mask_notused, RevF and later:
+ *
+ * To find the max InputAddr for the csrow, start with the base address and set
+ * all bits that are "don't care" bits in the test at the start of NPT section
+ * 4.5.4 (p. 87).
+ *
+ * The "don't care" bits are all set bits in the mask and all bits in the gaps
+ * between bit ranges [36:27] and [21:13].
+ *
+ * The value REV_F_F1Xh_DCS_NOTUSED_BITS represents bits [26:22] and [12:0],
+ * which are all bits in the above-mentioned gaps.
+ */
+static void amd64_set_dct_base_and_mask(struct amd64_pvt *pvt)
+{
+        if (pvt->ext_model >= OPTERON_CPU_REV_F) {
+                pvt->dcsb_base          = REV_F_F1Xh_DCSB_BASE_BITS;
+                pvt->dcsm_mask          = REV_F_F1Xh_DCSM_MASK_BITS;
+                pvt->dcs_mask_notused   = REV_F_F1Xh_DCS_NOTUSED_BITS;
+                pvt->dcs_shift          = REV_F_F1Xh_DCS_SHIFT;
+
+                switch (boot_cpu_data.x86) {
+                case 0xf:
+                        pvt->num_dcsm = REV_F_DCSM_COUNT;
+                        break;
+
+                case 0x10:
+                        pvt->num_dcsm = F10_DCSM_COUNT;
+                        break;
+
+                case 0x11:
+                        pvt->num_dcsm = F11_DCSM_COUNT;
+                        break;
+
+                default:
+                        amd64_printk(KERN_ERR, "Unsupported family!\n");
+                        break;
+                }
+        } else {
+                pvt->dcsb_base          = REV_E_DCSB_BASE_BITS;
+                pvt->dcsm_mask          = REV_E_DCSM_MASK_BITS;
+                pvt->dcs_mask_notused   = REV_E_DCS_NOTUSED_BITS;
+                pvt->dcs_shift          = REV_E_DCS_SHIFT;
+                pvt->num_dcsm           = REV_E_DCSM_COUNT;
+        }
+}
+
+/*
+ * Function 2 Offset F10_DCSB0; read in the DCS Base and DCS Mask hw registers
+ */
+static void amd64_read_dct_base_mask(struct amd64_pvt *pvt)
+{
+        int cs, reg, err = 0;
+
+        amd64_set_dct_base_and_mask(pvt);
+
+        for (cs = 0; cs < CHIPSELECT_COUNT; cs++) {
+                reg = K8_DCSB0 + (cs * 4);
+                err = pci_read_config_dword(pvt->dram_f2_ctl, reg,
+                                                &pvt->dcsb0[cs]);
+                if (unlikely(err))
+                        debugf0("Reading K8_DCSB0[%d] failed\n", cs);
+                else
+                        debugf0("  DCSB0[%d]=0x%08x reg: F2x%x\n",
+                                cs, pvt->dcsb0[cs], reg);
+
+                /* If DCT are NOT ganged, then read in DCT1's base */
+                if (boot_cpu_data.x86 >= 0x10 && !dct_ganging_enabled(pvt)) {
+                        reg = F10_DCSB1 + (cs * 4);
+                        err = pci_read_config_dword(pvt->dram_f2_ctl, reg,
+                                                        &pvt->dcsb1[cs]);
+                        if (unlikely(err))
+                                debugf0("Reading F10_DCSB1[%d] failed\n", cs);
+                        else
+                                debugf0("  DCSB1[%d]=0x%08x reg: F2x%x\n",
+                                        cs, pvt->dcsb1[cs], reg);
+                } else {
+                        pvt->dcsb1[cs] = 0;
+                }
+        }
+
+        for (cs = 0; cs < pvt->num_dcsm; cs++) {
+                reg = K8_DCSB0 + (cs * 4);
+                err = pci_read_config_dword(pvt->dram_f2_ctl, reg,
+                                        &pvt->dcsm0[cs]);
+                if (unlikely(err))
+                        debugf0("Reading K8_DCSM0 failed\n");
+                else
+                        debugf0("    DCSM0[%d]=0x%08x reg: F2x%x\n",
+                                cs, pvt->dcsm0[cs], reg);
+
+                /* If DCT are NOT ganged, then read in DCT1's mask */
+                if (boot_cpu_data.x86 >= 0x10 && !dct_ganging_enabled(pvt)) {
+                        reg = F10_DCSM1 + (cs * 4);
+                        err = pci_read_config_dword(pvt->dram_f2_ctl, reg,
+                                        &pvt->dcsm1[cs]);
+                        if (unlikely(err))
+                                debugf0("Reading F10_DCSM1[%d] failed\n", cs);
+                        else
+                                debugf0("    DCSM1[%d]=0x%08x reg: F2x%x\n",
+                                        cs, pvt->dcsm1[cs], reg);
+                } else
+                        pvt->dcsm1[cs] = 0;
+        }
+}
+
+static enum mem_type amd64_determine_memory_type(struct amd64_pvt *pvt)
+{
+        enum mem_type type;
+
+        if (boot_cpu_data.x86 >= 0x10 || pvt->ext_model >= OPTERON_CPU_REV_F) {
+                /* Rev F and later */
+                type = (pvt->dclr0 & BIT(16)) ? MEM_DDR2 : MEM_RDDR2;
+        } else {
+                /* Rev E and earlier */
+                type = (pvt->dclr0 & BIT(18)) ? MEM_DDR : MEM_RDDR;
+        }
+
+        debugf1("  Memory type is: %s\n",
+                (type == MEM_DDR2) ? "MEM_DDR2" :
+                (type == MEM_RDDR2) ? "MEM_RDDR2" :
+                (type == MEM_DDR) ? "MEM_DDR" : "MEM_RDDR");
+
+        return type;
+}
+
+/*
+ * Read the DRAM Configuration Low register. It differs between CG, D & E revs
+ * and the later RevF memory controllers (DDR vs DDR2)
+ *
+ * Return:
+ *      number of memory channels in operation
+ * Pass back:
+ *      contents of the DCL0_LOW register
+ */
+static int k8_early_channel_count(struct amd64_pvt *pvt)
+{
+        int flag, err = 0;
+
+        err = pci_read_config_dword(pvt->dram_f2_ctl, F10_DCLR_0, &pvt->dclr0);
+        if (err)
+                return err;
+
+        if ((boot_cpu_data.x86_model >> 4) >= OPTERON_CPU_REV_F) {
+                /* RevF (NPT) and later */
+                flag = pvt->dclr0 & F10_WIDTH_128;
+        } else {
+                /* RevE and earlier */
+                flag = pvt->dclr0 & REVE_WIDTH_128;
+        }
+
+        /* not used */
+        pvt->dclr1 = 0;
+
+        return (flag) ? 2 : 1;
+}
+
+/* extract the ERROR ADDRESS for the K8 CPUs */
+static u64 k8_get_error_address(struct mem_ctl_info *mci,
+                                struct amd64_error_info_regs *info)
+{
+        return (((u64) (info->nbeah & 0xff)) << 32) +
+                        (info->nbeal & ~0x03);
+}
+
+/*
+ * Read the Base and Limit registers for K8 based Memory controllers; extract
+ * fields from the 'raw' reg into separate data fields
+ *
+ * Isolates: BASE, LIMIT, IntlvEn, IntlvSel, RW_EN
+ */
+static void k8_read_dram_base_limit(struct amd64_pvt *pvt, int dram)
+{
+        u32 low;
+        u32 off = dram << 3;    /* 8 bytes between DRAM entries */
+        int err;
+
+        err = pci_read_config_dword(pvt->addr_f1_ctl,
+                                    K8_DRAM_BASE_LOW + off, &low);
+        if (err)
+                debugf0("Reading K8_DRAM_BASE_LOW failed\n");
+
+        /* Extract parts into separate data entries */
+        pvt->dram_base[dram] = ((u64) low & 0xFFFF0000) << 8;
+        pvt->dram_IntlvEn[dram] = (low >> 8) & 0x7;
+        pvt->dram_rw_en[dram] = (low & 0x3);
+
+        err = pci_read_config_dword(pvt->addr_f1_ctl,
+                                    K8_DRAM_LIMIT_LOW + off, &low);
+        if (err)
+                debugf0("Reading K8_DRAM_LIMIT_LOW failed\n");
+
+        /*
+         * Extract parts into separate data entries. Limit is the HIGHEST memory
+         * location of the region, so lower 24 bits need to be all ones
+         */
+        pvt->dram_limit[dram] = (((u64) low & 0xFFFF0000) << 8) | 0x00FFFFFF;
+        pvt->dram_IntlvSel[dram] = (low >> 8) & 0x7;
+        pvt->dram_DstNode[dram] = (low & 0x7);
+}
+
+static void k8_map_sysaddr_to_csrow(struct mem_ctl_info *mci,
+                                        struct amd64_error_info_regs *info,
+                                        u64 SystemAddress)
+{
+        struct mem_ctl_info *src_mci;
+        unsigned short syndrome;
+        int channel, csrow;
+        u32 page, offset;
+
+        /* Extract the syndrome parts and form a 16-bit syndrome */
+        syndrome = EXTRACT_HIGH_SYNDROME(info->nbsl) << 8;
+        syndrome |= EXTRACT_LOW_SYNDROME(info->nbsh);
+
+        /* CHIPKILL enabled */
+        if (info->nbcfg & K8_NBCFG_CHIPKILL) {
+                channel = get_channel_from_ecc_syndrome(syndrome);
+                if (channel < 0) {
+                        /*
+                         * Syndrome didn't map, so we don't know which of the
+                         * 2 DIMMs is in error. So we need to ID 'both' of them
+                         * as suspect.
+                         */
+                        amd64_mc_printk(mci, KERN_WARNING,
+                                       "unknown syndrome 0x%x - possible error "
+                                       "reporting race\n", syndrome);
+                        edac_mc_handle_ce_no_info(mci, EDAC_MOD_STR);
+                        return;
+                }
+        } else {
+                /*
+                 * non-chipkill ecc mode
+                 *
+                 * The k8 documentation is unclear about how to determine the
+                 * channel number when using non-chipkill memory.  This method
+                 * was obtained from email communication with someone at AMD.
+                 * (Wish the email was placed in this comment - norsk)
+                 */
+                channel = ((SystemAddress & BIT(3)) != 0);
+        }
+
+        /*
+         * Find out which node the error address belongs to. This may be
+         * different from the node that detected the error.
+         */
+        src_mci = find_mc_by_sys_addr(mci, SystemAddress);
+        if (src_mci) {
+                amd64_mc_printk(mci, KERN_ERR,
+                             "failed to map error address 0x%lx to a node\n",
+                             (unsigned long)SystemAddress);
+                edac_mc_handle_ce_no_info(mci, EDAC_MOD_STR);
+                return;
+        }
+
+        /* Now map the SystemAddress to a CSROW */
+        csrow = sys_addr_to_csrow(src_mci, SystemAddress);
+        if (csrow < 0) {
+                edac_mc_handle_ce_no_info(src_mci, EDAC_MOD_STR);
+        } else {
+                error_address_to_page_and_offset(SystemAddress, &page, &offset);
+
+                edac_mc_handle_ce(src_mci, page, offset, syndrome, csrow,
+                                  channel, EDAC_MOD_STR);
+        }
+}
+
+/*
+ * determrine the number of PAGES in for this DIMM's size based on its DRAM
+ * Address Mapping.
+ *
+ * First step is to calc the number of bits to shift a value of 1 left to
+ * indicate show many pages. Start with the DBAM value as the starting bits,
+ * then proceed to adjust those shift bits, based on CPU rev and the table.
+ * See BKDG on the DBAM
+ */
+static int k8_dbam_map_to_pages(struct amd64_pvt *pvt, int dram_map)
+{
+        int nr_pages;
+
+        if (pvt->ext_model >= OPTERON_CPU_REV_F) {
+                nr_pages = 1 << (revf_quad_ddr2_shift[dram_map] - PAGE_SHIFT);
+        } else {
+                /*
+                 * RevE and less section; this line is tricky. It collapses the
+                 * table used by RevD and later to one that matches revisions CG
+                 * and earlier.
+                 */
+                dram_map -= (pvt->ext_model >= OPTERON_CPU_REV_D) ?
+                                (dram_map > 8 ? 4 : (dram_map > 5 ?
+                                3 : (dram_map > 2 ? 1 : 0))) : 0;
+
+                /* 25 shift is 32MiB minimum DIMM size in RevE and prior */
+                nr_pages = 1 << (dram_map + 25 - PAGE_SHIFT);
+        }
+
+        return nr_pages;
+}
+
+/*
+ * Get the number of DCT channels in use.
+ *
+ * Return:
+ *      number of Memory Channels in operation
+ * Pass back:
+ *      contents of the DCL0_LOW register
+ */
+static int f10_early_channel_count(struct amd64_pvt *pvt)
+{
+        int err = 0, channels = 0;
+        u32 dbam;
+
+        err = pci_read_config_dword(pvt->dram_f2_ctl, F10_DCLR_0, &pvt->dclr0);
+        if (err)
+                goto err_reg;
+
+        err = pci_read_config_dword(pvt->dram_f2_ctl, F10_DCLR_1, &pvt->dclr1);
+        if (err)
+                goto err_reg;
+
+        /* If we are in 128 bit mode, then we are using 2 channels */
+        if (pvt->dclr0 & F10_WIDTH_128) {
+                debugf0("Data WIDTH is 128 bits - 2 channels\n");
+                channels = 2;
+                return channels;
+        }
+
+        /*
+         * Need to check if in UN-ganged mode: In such, there are 2 channels,
+         * but they are NOT in 128 bit mode and thus the above 'dcl0' status bit
+         * will be OFF.
+         *
+         * Need to check DCT0[0] and DCT1[0] to see if only one of them has
+         * their CSEnable bit on. If so, then SINGLE DIMM case.
+         */
+        debugf0("Data WIDTH is NOT 128 bits - need more decoding\n");
+
+        /*
+         * Check DRAM Bank Address Mapping values for each DIMM to see if there
+         * is more than just one DIMM present in unganged mode. Need to check
+         * both controllers since DIMMs can be placed in either one.
+         */
+        channels = 0;
+        err = pci_read_config_dword(pvt->dram_f2_ctl, DBAM0, &dbam);
+        if (err)
+                goto err_reg;
+
+        if (DBAM_DIMM(0, dbam) > 0)
+                channels++;
+        if (DBAM_DIMM(1, dbam) > 0)
+                channels++;
+        if (DBAM_DIMM(2, dbam) > 0)
+                channels++;
+        if (DBAM_DIMM(3, dbam) > 0)
+                channels++;
+
+        /* If more than 2 DIMMs are present, then we have 2 channels */
+        if (channels > 2)
+                channels = 2;
+        else if (channels == 0) {
+                /* No DIMMs on DCT0, so look at DCT1 */
+                err = pci_read_config_dword(pvt->dram_f2_ctl, DBAM1, &dbam);
+                if (err)
+                        goto err_reg;
+
+                if (DBAM_DIMM(0, dbam) > 0)
+                        channels++;
+                if (DBAM_DIMM(1, dbam) > 0)
+                        channels++;
+                if (DBAM_DIMM(2, dbam) > 0)
+                        channels++;
+                if (DBAM_DIMM(3, dbam) > 0)
+                        channels++;
+
+                if (channels > 2)
+                        channels = 2;
+        }
+
+        /* If we found ALL 0 values, then assume just ONE DIMM-ONE Channel */
+        if (channels == 0)
+                channels = 1;
+
+        debugf0("DIMM count= %d\n", channels);
+
+        return channels;
+
+err_reg:
+        return -1;
+
+}
+
+static int f10_dbam_map_to_pages(struct amd64_pvt *pvt, int dram_map)
+{
+        return 1 << (revf_quad_ddr2_shift[dram_map] - PAGE_SHIFT);
+}
+
+/* Enable extended configuration access via 0xCF8 feature */
+static void amd64_setup(struct amd64_pvt *pvt)
+{
+        u32 reg;
+
+        pci_read_config_dword(pvt->misc_f3_ctl, F10_NB_CFG_HIGH, &reg);
+
+        pvt->flags.cf8_extcfg = !!(reg & F10_NB_CFG_LOW_ENABLE_EXT_CFG);
+        reg |= F10_NB_CFG_LOW_ENABLE_EXT_CFG;
+        pci_write_config_dword(pvt->misc_f3_ctl, F10_NB_CFG_HIGH, reg);
+}
+
+/* Restore the extended configuration access via 0xCF8 feature */
+static void amd64_teardown(struct amd64_pvt *pvt)
+{
+        u32 reg;
+
+        pci_read_config_dword(pvt->misc_f3_ctl, F10_NB_CFG_HIGH, &reg);
+
+        reg &= ~F10_NB_CFG_LOW_ENABLE_EXT_CFG;
+        if (pvt->flags.cf8_extcfg)
+                reg |= F10_NB_CFG_LOW_ENABLE_EXT_CFG;
+        pci_write_config_dword(pvt->misc_f3_ctl, F10_NB_CFG_HIGH, reg);
+}
+
+static u64 f10_get_error_address(struct mem_ctl_info *mci,
+                        struct amd64_error_info_regs *info)
+{
+        return (((u64) (info->nbeah & 0xffff)) << 32) +
+                        (info->nbeal & ~0x01);
+}
+
+/*
+ * Read the Base and Limit registers for F10 based Memory controllers. Extract
+ * fields from the 'raw' reg into separate data fields.
+ *
+ * Isolates: BASE, LIMIT, IntlvEn, IntlvSel, RW_EN.
+ */
+static void f10_read_dram_base_limit(struct amd64_pvt *pvt, int dram)
+{
+        u32 high_offset, low_offset, high_base, low_base, high_limit, low_limit;
+
+        low_offset = K8_DRAM_BASE_LOW + (dram << 3);
+        high_offset = F10_DRAM_BASE_HIGH + (dram << 3);
+
+        /* read the 'raw' DRAM BASE Address register */
+        pci_read_config_dword(pvt->addr_f1_ctl, low_offset, &low_base);
+
+        /* Read from the ECS data register */
+        pci_read_config_dword(pvt->addr_f1_ctl, high_offset, &high_base);
+
+        /* Extract parts into separate data entries */
+        pvt->dram_rw_en[dram] = (low_base & 0x3);
+
+        if (pvt->dram_rw_en[dram] == 0)
+                return;
+
+        pvt->dram_IntlvEn[dram] = (low_base >> 8) & 0x7;
+
+        pvt->dram_base[dram] = (((((u64) high_base & 0x000000FF) << 32) |
+                                ((u64) low_base & 0xFFFF0000))) << 8;
+
+        low_offset = K8_DRAM_LIMIT_LOW + (dram << 3);
+        high_offset = F10_DRAM_LIMIT_HIGH + (dram << 3);
+
+        /* read the 'raw' LIMIT registers */
+        pci_read_config_dword(pvt->addr_f1_ctl, low_offset, &low_limit);
+
+        /* Read from the ECS data register for the HIGH portion */
+        pci_read_config_dword(pvt->addr_f1_ctl, high_offset, &high_limit);
+
+        debugf0("  HW Regs: BASE=0x%08x-%08x      LIMIT=  0x%08x-%08x\n",
+                high_base, low_base, high_limit, low_limit);
+
+        pvt->dram_DstNode[dram] = (low_limit & 0x7);
+        pvt->dram_IntlvSel[dram] = (low_limit >> 8) & 0x7;
+
+        /*
+         * Extract address values and form a LIMIT address. Limit is the HIGHEST
+         * memory location of the region, so low 24 bits need to be all ones.
+         */
+        low_limit |= 0x0000FFFF;
+        pvt->dram_limit[dram] =
+                ((((u64) high_limit << 32) + (u64) low_limit) << 8) | (0xFF);
+}
+
+static void f10_read_dram_ctl_register(struct amd64_pvt *pvt)
+{
+        int err = 0;
+
+        err = pci_read_config_dword(pvt->dram_f2_ctl, F10_DCTL_SEL_LOW,
+                                    &pvt->dram_ctl_select_low);
+        if (err) {
+                debugf0("Reading F10_DCTL_SEL_LOW failed\n");
+        } else {
+                debugf0("DRAM_DCTL_SEL_LOW=0x%x  DctSelBaseAddr=0x%x\n",
+                        pvt->dram_ctl_select_low, dct_sel_baseaddr(pvt));
+
+                debugf0("  DRAM DCTs are=%s DRAM Is=%s DRAM-Ctl-"
+                                "sel-hi-range=%s\n",
+                        (dct_ganging_enabled(pvt) ? "GANGED" : "NOT GANGED"),
+                        (dct_dram_enabled(pvt) ? "Enabled"   : "Disabled"),
+                        (dct_high_range_enabled(pvt) ? "Enabled" : "Disabled"));
+
+                debugf0("  DctDatIntLv=%s MemCleared=%s DctSelIntLvAddr=0x%x\n",
+                        (dct_data_intlv_enabled(pvt) ? "Enabled" : "Disabled"),
+                        (dct_memory_cleared(pvt) ? "True " : "False "),
+                        dct_sel_interleave_addr(pvt));
+        }
+
+        err = pci_read_config_dword(pvt->dram_f2_ctl, F10_DCTL_SEL_HIGH,
+                                    &pvt->dram_ctl_select_high);
+        if (err)
+                debugf0("Reading F10_DCTL_SEL_HIGH failed\n");
+}
+
+/*
+ * determine channel based on the interleaving mode: F10h BKDG, 2.8.9 Memory
+ * Interleaving Modes.
+ */
+static u32 f10_determine_channel(struct amd64_pvt *pvt, u64 sys_addr,
+                                int hi_range_sel, u32 intlv_en)
+{
+        u32 cs, temp, dct_sel_high = (pvt->dram_ctl_select_low >> 1) & 1;
+
+        if (dct_ganging_enabled(pvt))
+                cs = 0;
+        else if (hi_range_sel)
+                cs = dct_sel_high;
+        else if (dct_interleave_enabled(pvt)) {
+                /*
+                 * see F2x110[DctSelIntLvAddr] - channel interleave mode
+                 */
+                if (dct_sel_interleave_addr(pvt) == 0)
+                        cs = sys_addr >> 6 & 1;
+                else if ((dct_sel_interleave_addr(pvt) >> 1) & 1) {
+                        temp = hweight_long((u32) ((sys_addr >> 16) & 0x1F)) % 2;
+
+                        if (dct_sel_interleave_addr(pvt) & 1)
+                                cs = (sys_addr >> 9 & 1) ^ temp;
+                        else
+                                cs = (sys_addr >> 6 & 1) ^ temp;
+                } else if (intlv_en & 4)
+                        cs = sys_addr >> 15 & 1;
+                else if (intlv_en & 2)
+                        cs = sys_addr >> 14 & 1;
+                else if (intlv_en & 1)
+                        cs = sys_addr >> 13 & 1;
+                else
+                        cs = sys_addr >> 12 & 1;
+        } else if (dct_high_range_enabled(pvt) && !dct_ganging_enabled(pvt))
+                cs = ~dct_sel_high & 1;
+        else
+                cs = 0;
+
+        return cs;
+}
+
+static inline u32 f10_map_intlv_en_to_shift(u32 intlv_en)
+{
+        if (intlv_en == 1)
+                return 1;
+        else if (intlv_en == 3)
+                return 2;
+        else if (intlv_en == 7)
+                return 3;
+
+        return 0;
+}
+
+/* See F10h BKDG, 2.8.10.2 DctSelBaseOffset Programming */
+static inline u64 f10_get_base_addr_offset(u64 sys_addr, int hi_range_sel,
+                                                 u32 dct_sel_base_addr,
+                                                 u64 dct_sel_base_off,
+                                                 u32 hole_valid, u32 hole_off,
+                                                 u64 dram_base)
+{
+        u64 chan_off;
+
+        if (hi_range_sel) {
+                if (!(dct_sel_base_addr & 0xFFFFF800) &&
+                   hole_valid && (sys_addr >= 0x100000000ULL))
+                        chan_off = hole_off << 16;
+                else
+                        chan_off = dct_sel_base_off;
+        } else {
+                if (hole_valid && (sys_addr >= 0x100000000ULL))
+                        chan_off = hole_off << 16;
+                else
+                        chan_off = dram_base & 0xFFFFF8000000ULL;
+        }
+
+        return (sys_addr & 0x0000FFFFFFFFFFC0ULL) -
+                        (chan_off & 0x0000FFFFFF800000ULL);
+}
+
+/* Hack for the time being - Can we get this from BIOS?? */
+#define CH0SPARE_RANK   0
+#define CH1SPARE_RANK   1
+
+/*
+ * checks if the csrow passed in is marked as SPARED, if so returns the new
+ * spare row
+ */
+static inline int f10_process_possible_spare(int csrow,
+                                u32 cs, struct amd64_pvt *pvt)
+{
+        u32 swap_done;
+        u32 bad_dram_cs;
+
+        /* Depending on channel, isolate respective SPARING info */
+        if (cs) {
+                swap_done = F10_ONLINE_SPARE_SWAPDONE1(pvt->online_spare);
+                bad_dram_cs = F10_ONLINE_SPARE_BADDRAM_CS1(pvt->online_spare);
+                if (swap_done && (csrow == bad_dram_cs))
+                        csrow = CH1SPARE_RANK;
+        } else {
+                swap_done = F10_ONLINE_SPARE_SWAPDONE0(pvt->online_spare);
+                bad_dram_cs = F10_ONLINE_SPARE_BADDRAM_CS0(pvt->online_spare);
+                if (swap_done && (csrow == bad_dram_cs))
+                        csrow = CH0SPARE_RANK;
+        }
+        return csrow;
+}
+
+/*
+ * Iterate over the DRAM DCT "base" and "mask" registers looking for a
+ * SystemAddr match on the specified 'ChannelSelect' and 'NodeID'
+ *
+ * Return:
+ *      -EINVAL:  NOT FOUND
+ *      0..csrow = Chip-Select Row
+ */
+static int f10_lookup_addr_in_dct(u32 in_addr, u32 nid, u32 cs)
+{
+        struct mem_ctl_info *mci;
+        struct amd64_pvt *pvt;
+        u32 cs_base, cs_mask;
+        int cs_found = -EINVAL;
+        int csrow;
+
+        mci = mci_lookup[nid];
+        if (!mci)
+                return cs_found;
+
+        pvt = mci->pvt_info;
+
+        debugf1("InputAddr=0x%x  channelselect=%d\n", in_addr, cs);
+
+        for (csrow = 0; csrow < CHIPSELECT_COUNT; csrow++) {
+
+                cs_base = amd64_get_dct_base(pvt, cs, csrow);
+                if (!(cs_base & K8_DCSB_CS_ENABLE))
+                        continue;
+
+                /*
+                 * We have an ENABLED CSROW, Isolate just the MASK bits of the
+                 * target: [28:19] and [13:5], which map to [36:27] and [21:13]
+                 * of the actual address.
+                 */
+                cs_base &= REV_F_F1Xh_DCSB_BASE_BITS;
+
+                /*
+                 * Get the DCT Mask, and ENABLE the reserved bits: [18:16] and
+                 * [4:0] to become ON. Then mask off bits [28:0] ([36:8])
+                 */
+                cs_mask = amd64_get_dct_mask(pvt, cs, csrow);
+
+                debugf1("    CSROW=%d CSBase=0x%x RAW CSMask=0x%x\n",
+                                csrow, cs_base, cs_mask);
+
+                cs_mask = (cs_mask | 0x0007C01F) & 0x1FFFFFFF;
+
+                debugf1("              Final CSMask=0x%x\n", cs_mask);
+                debugf1("    (InputAddr & ~CSMask)=0x%x "
+                                "(CSBase & ~CSMask)=0x%x\n",
+                                (in_addr & ~cs_mask), (cs_base & ~cs_mask));
+
+                if ((in_addr & ~cs_mask) == (cs_base & ~cs_mask)) {
+                        cs_found = f10_process_possible_spare(csrow, cs, pvt);
+
+                        debugf1(" MATCH csrow=%d\n", cs_found);
+                        break;
+                }
+        }
+        return cs_found;
+}
+
+/* For a given @dram_range, check if @sys_addr falls within it. */
+static int f10_match_to_this_node(struct amd64_pvt *pvt, int dram_range,
+                                  u64 sys_addr, int *nid, int *chan_sel)
+{
+        int node_id, cs_found = -EINVAL, high_range = 0;
+        u32 intlv_en, intlv_sel, intlv_shift, hole_off;
+        u32 hole_valid, tmp, dct_sel_base, channel;
+        u64 dram_base, chan_addr, dct_sel_base_off;
+
+        dram_base = pvt->dram_base[dram_range];
+        intlv_en = pvt->dram_IntlvEn[dram_range];
+
+        node_id = pvt->dram_DstNode[dram_range];
+        intlv_sel = pvt->dram_IntlvSel[dram_range];
+
+        debugf1("(dram=%d) Base=0x%llx SystemAddr= 0x%llx Limit=0x%llx\n",
+                dram_range, dram_base, sys_addr, pvt->dram_limit[dram_range]);
+
+        /*
+         * This assumes that one node's DHAR is the same as all the other
+         * nodes' DHAR.
+         */
+        hole_off = (pvt->dhar & 0x0000FF80);
+        hole_valid = (pvt->dhar & 0x1);
+        dct_sel_base_off = (pvt->dram_ctl_select_high & 0xFFFFFC00) << 16;
+
+        debugf1("   HoleOffset=0x%x  HoleValid=0x%x IntlvSel=0x%x\n",
+                        hole_off, hole_valid, intlv_sel);
+
+        if (intlv_en ||
+            (intlv_sel != ((sys_addr >> 12) & intlv_en)))
+                return -EINVAL;
+
+        dct_sel_base = dct_sel_baseaddr(pvt);
+
+        /*
+         * check whether addresses >= DctSelBaseAddr[47:27] are to be used to
+         * select between DCT0 and DCT1.
+         */
+        if (dct_high_range_enabled(pvt) &&
+           !dct_ganging_enabled(pvt) &&
+           ((sys_addr >> 27) >= (dct_sel_base >> 11)))
+                high_range = 1;
+
+        channel = f10_determine_channel(pvt, sys_addr, high_range, intlv_en);
+
+        chan_addr = f10_get_base_addr_offset(sys_addr, high_range, dct_sel_base,
+                                             dct_sel_base_off, hole_valid,
+                                             hole_off, dram_base);
+
+        intlv_shift = f10_map_intlv_en_to_shift(intlv_en);
+
+        /* remove Node ID (in case of memory interleaving) */
+        tmp = chan_addr & 0xFC0;
+
+        chan_addr = ((chan_addr >> intlv_shift) & 0xFFFFFFFFF000ULL) | tmp;
+
+        /* remove channel interleave and hash */
+        if (dct_interleave_enabled(pvt) &&
+           !dct_high_range_enabled(pvt) &&
+           !dct_ganging_enabled(pvt)) {
+                if (dct_sel_interleave_addr(pvt) != 1)
+                        chan_addr = (chan_addr >> 1) & 0xFFFFFFFFFFFFFFC0ULL;
+                else {
+                        tmp = chan_addr & 0xFC0;
+                        chan_addr = ((chan_addr & 0xFFFFFFFFFFFFC000ULL) >> 1)
+                                        | tmp;
+                }
+        }
+
+        debugf1("   (ChannelAddrLong=0x%llx) >> 8 becomes InputAddr=0x%x\n",
+                chan_addr, (u32)(chan_addr >> 8));
+
+        cs_found = f10_lookup_addr_in_dct(chan_addr >> 8, node_id, channel);
+
+        if (cs_found >= 0) {
+                *nid = node_id;
+                *chan_sel = channel;
+        }
+        return cs_found;
+}
+
+static int f10_translate_sysaddr_to_cs(struct amd64_pvt *pvt, u64 sys_addr,
+                                       int *node, int *chan_sel)
+{
+        int dram_range, cs_found = -EINVAL;
+        u64 dram_base, dram_limit;
+
+        for (dram_range = 0; dram_range < DRAM_REG_COUNT; dram_range++) {
+
+                if (!pvt->dram_rw_en[dram_range])
+                        continue;
+
+                dram_base = pvt->dram_base[dram_range];
+                dram_limit = pvt->dram_limit[dram_range];
+
+                if ((dram_base <= sys_addr) && (sys_addr <= dram_limit)) {
+
+                        cs_found = f10_match_to_this_node(pvt, dram_range,
+                                                          sys_addr, node,
+                                                          chan_sel);
+                        if (cs_found >= 0)
+                                break;
+                }
+        }
+        return cs_found;
+}
+
+/*
+ * This the F10h reference code from AMD to map a @sys_addr to NodeID,
+ * CSROW, Channel.
+ *
+ * The @sys_addr is usually an error address received from the hardware.
+ */
+static void f10_map_sysaddr_to_csrow(struct mem_ctl_info *mci,
+                                     struct amd64_error_info_regs *info,
+                                     u64 sys_addr)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        u32 page, offset;
+        unsigned short syndrome;
+        int nid, csrow, chan = 0;
+
+        csrow = f10_translate_sysaddr_to_cs(pvt, sys_addr, &nid, &chan);
+
+        if (csrow >= 0) {
+                error_address_to_page_and_offset(sys_addr, &page, &offset);
+
+                syndrome = EXTRACT_HIGH_SYNDROME(info->nbsl) << 8;
+                syndrome |= EXTRACT_LOW_SYNDROME(info->nbsh);
+
+                /*
+                 * Is CHIPKILL on? If so, then we can attempt to use the
+                 * syndrome to isolate which channel the error was on.
+                 */
+                if (pvt->nbcfg & K8_NBCFG_CHIPKILL)
+                        chan = get_channel_from_ecc_syndrome(syndrome);
+
+                if (chan >= 0) {
+                        edac_mc_handle_ce(mci, page, offset, syndrome,
+                                        csrow, chan, EDAC_MOD_STR);
+                } else {
+                        /*
+                         * Channel unknown, report all channels on this
+                         * CSROW as failed.
+                         */
+                        for (chan = 0; chan < mci->csrows[csrow].nr_channels;
+                                                                chan++) {
+                                        edac_mc_handle_ce(mci, page, offset,
+                                                        syndrome,
+                                                        csrow, chan,
+                                                        EDAC_MOD_STR);
+                        }
+                }
+
+        } else {
+                edac_mc_handle_ce_no_info(mci, EDAC_MOD_STR);
+        }
+}
+
+/*
+ * Input (@index) is the DBAM DIMM value (1 of 4) used as an index into a shift
+ * table (revf_quad_ddr2_shift) which starts at 128MB DIMM size. Index of 0
+ * indicates an empty DIMM slot, as reported by Hardware on empty slots.
+ *
+ * Normalize to 128MB by subracting 27 bit shift.
+ */
+static int map_dbam_to_csrow_size(int index)
+{
+        int mega_bytes = 0;
+
+        if (index > 0 && index <= DBAM_MAX_VALUE)
+                mega_bytes = ((128 << (revf_quad_ddr2_shift[index]-27)));
+
+        return mega_bytes;
+}
+
+/*
+ * debug routine to display the memory sizes of a DIMM (ganged or not) and it
+ * CSROWs as well
+ */
+static void f10_debug_display_dimm_sizes(int ctrl, struct amd64_pvt *pvt,
+                                         int ganged)
+{
+        int dimm, size0, size1;
+        u32 dbam;
+        u32 *dcsb;
+
+        debugf1("  dbam%d: 0x%8.08x  CSROW is %s\n", ctrl,
+                        ctrl ? pvt->dbam1 : pvt->dbam0,
+                        ganged ? "GANGED - dbam1 not used" : "NON-GANGED");
+
+        dbam = ctrl ? pvt->dbam1 : pvt->dbam0;
+        dcsb = ctrl ? pvt->dcsb1 : pvt->dcsb0;
+
+        /* Dump memory sizes for DIMM and its CSROWs */
+        for (dimm = 0; dimm < 4; dimm++) {
+
+                size0 = 0;
+                if (dcsb[dimm*2] & K8_DCSB_CS_ENABLE)
+                        size0 = map_dbam_to_csrow_size(DBAM_DIMM(dimm, dbam));
+
+                size1 = 0;
+                if (dcsb[dimm*2 + 1] & K8_DCSB_CS_ENABLE)
+                        size1 = map_dbam_to_csrow_size(DBAM_DIMM(dimm, dbam));
+
+                debugf1("     CTRL-%d DIMM-%d=%5dMB   CSROW-%d=%5dMB "
+                                "CSROW-%d=%5dMB\n",
+                                ctrl,
+                                dimm,
+                                size0 + size1,
+                                dimm * 2,
+                                size0,
+                                dimm * 2 + 1,
+                                size1);
+        }
+}
+
+/*
+ * Very early hardware probe on pci_probe thread to determine if this module
+ * supports the hardware.
+ *
+ * Return:
+ *      0 for OK
+ *      1 for error
+ */
+static int f10_probe_valid_hardware(struct amd64_pvt *pvt)
+{
+        int ret = 0;
+
+        /*
+         * If we are on a DDR3 machine, we don't know yet if
+         * we support that properly at this time
+         */
+        if ((pvt->dchr0 & F10_DCHR_Ddr3Mode) ||
+            (pvt->dchr1 & F10_DCHR_Ddr3Mode)) {
+
+                amd64_printk(KERN_WARNING,
+                        "%s() This machine is running with DDR3 memory. "
+                        "This is not currently supported. "
+                        "DCHR0=0x%x DCHR1=0x%x\n",
+                        __func__, pvt->dchr0, pvt->dchr1);
+
+                amd64_printk(KERN_WARNING,
+                        "   Contact '%s' module MAINTAINER to help add"
+                        " support.\n",
+                        EDAC_MOD_STR);
+
+                ret = 1;
+
+        }
+        return ret;
+}
+
+/*
+ * There currently are 3 types type of MC devices for AMD Athlon/Opterons
+ * (as per PCI DEVICE_IDs):
+ *
+ * Family K8: That is the Athlon64 and Opteron CPUs. They all have the same PCI
+ * DEVICE ID, even though there is differences between the different Revisions
+ * (CG,D,E,F).
+ *
+ * Family F10h and F11h.
+ *
+ */
+static struct amd64_family_type amd64_family_types[] = {
+        [K8_CPUS] = {
+                .ctl_name = "RevF",
+                .addr_f1_ctl = PCI_DEVICE_ID_AMD_K8_NB_ADDRMAP,
+                .misc_f3_ctl = PCI_DEVICE_ID_AMD_K8_NB_MISC,
+                .ops = {
+                        .early_channel_count = k8_early_channel_count,
+                        .get_error_address = k8_get_error_address,
+                        .read_dram_base_limit = k8_read_dram_base_limit,
+                        .map_sysaddr_to_csrow = k8_map_sysaddr_to_csrow,
+                        .dbam_map_to_pages = k8_dbam_map_to_pages,
+                }
+        },
+        [F10_CPUS] = {
+                .ctl_name = "Family 10h",
+                .addr_f1_ctl = PCI_DEVICE_ID_AMD_10H_NB_MAP,
+                .misc_f3_ctl = PCI_DEVICE_ID_AMD_10H_NB_MISC,
+                .ops = {
+                        .probe_valid_hardware = f10_probe_valid_hardware,
+                        .early_channel_count = f10_early_channel_count,
+                        .get_error_address = f10_get_error_address,
+                        .read_dram_base_limit = f10_read_dram_base_limit,
+                        .read_dram_ctl_register = f10_read_dram_ctl_register,
+                        .map_sysaddr_to_csrow = f10_map_sysaddr_to_csrow,
+                        .dbam_map_to_pages = f10_dbam_map_to_pages,
+                }
+        },
+        [F11_CPUS] = {
+                .ctl_name = "Family 11h",
+                .addr_f1_ctl = PCI_DEVICE_ID_AMD_11H_NB_MAP,
+                .misc_f3_ctl = PCI_DEVICE_ID_AMD_11H_NB_MISC,
+                .ops = {
+                        .probe_valid_hardware = f10_probe_valid_hardware,
+                        .early_channel_count = f10_early_channel_count,
+                        .get_error_address = f10_get_error_address,
+                        .read_dram_base_limit = f10_read_dram_base_limit,
+                        .read_dram_ctl_register = f10_read_dram_ctl_register,
+                        .map_sysaddr_to_csrow = f10_map_sysaddr_to_csrow,
+                        .dbam_map_to_pages = f10_dbam_map_to_pages,
+                }
+        },
+};
+
+static struct pci_dev *pci_get_related_function(unsigned int vendor,
+                                                unsigned int device,
+                                                struct pci_dev *related)
+{
+        struct pci_dev *dev = NULL;
+
+        dev = pci_get_device(vendor, device, dev);
+        while (dev) {
+                if ((dev->bus->number == related->bus->number) &&
+                    (PCI_SLOT(dev->devfn) == PCI_SLOT(related->devfn)))
+                        break;
+                dev = pci_get_device(vendor, device, dev);
+        }
+
+        return dev;
+}
+
+/*
+ * syndrome mapping table for ECC ChipKill devices
+ *
+ * The comment in each row is the token (nibble) number that is in error.
+ * The least significant nibble of the syndrome is the mask for the bits
+ * that are in error (need to be toggled) for the particular nibble.
+ *
+ * Each row contains 16 entries.
+ * The first entry (0th) is the channel number for that row of syndromes.
+ * The remaining 15 entries are the syndromes for the respective Error
+ * bit mask index.
+ *
+ * 1st index entry is 0x0001 mask, indicating that the rightmost bit is the
+ * bit in error.
+ * The 2nd index entry is 0x0010 that the second bit is damaged.
+ * The 3rd index entry is 0x0011 indicating that the rightmost 2 bits
+ * are damaged.
+ * Thus so on until index 15, 0x1111, whose entry has the syndrome
+ * indicating that all 4 bits are damaged.
+ *
+ * A search is performed on this table looking for a given syndrome.
+ *
+ * See the AMD documentation for ECC syndromes. This ECC table is valid
+ * across all the versions of the AMD64 processors.
+ *
+ * A fast lookup is to use the LAST four bits of the 16-bit syndrome as a
+ * COLUMN index, then search all ROWS of that column, looking for a match
+ * with the input syndrome. The ROW value will be the token number.
+ *
+ * The 0'th entry on that row, can be returned as the CHANNEL (0 or 1) of this
+ * error.
+ */
+#define NUMBER_ECC_ROWS  36
+static const unsigned short ecc_chipkill_syndromes[NUMBER_ECC_ROWS][16] = {
+        /* Channel 0 syndromes */
+        {/*0*/  0, 0xe821, 0x7c32, 0x9413, 0xbb44, 0x5365, 0xc776, 0x2f57,
+           0xdd88, 0x35a9, 0xa1ba, 0x499b, 0x66cc, 0x8eed, 0x1afe, 0xf2df },
+        {/*1*/  0, 0x5d31, 0xa612, 0xfb23, 0x9584, 0xc8b5, 0x3396, 0x6ea7,
+           0xeac8, 0xb7f9, 0x4cda, 0x11eb, 0x7f4c, 0x227d, 0xd95e, 0x846f },
+        {/*2*/  0, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
+           0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f },
+        {/*3*/  0, 0x2021, 0x3032, 0x1013, 0x4044, 0x6065, 0x7076, 0x5057,
+           0x8088, 0xa0a9, 0xb0ba, 0x909b, 0xc0cc, 0xe0ed, 0xf0fe, 0xd0df },
+        {/*4*/  0, 0x5041, 0xa082, 0xf0c3, 0x9054, 0xc015, 0x30d6, 0x6097,
+           0xe0a8, 0xb0e9, 0x402a, 0x106b, 0x70fc, 0x20bd, 0xd07e, 0x803f },
+        {/*5*/  0, 0xbe21, 0xd732, 0x6913, 0x2144, 0x9f65, 0xf676, 0x4857,
+           0x3288, 0x8ca9, 0xe5ba, 0x5b9b, 0x13cc, 0xaded, 0xc4fe, 0x7adf },
+        {/*6*/  0, 0x4951, 0x8ea2, 0xc7f3, 0x5394, 0x1ac5, 0xdd36, 0x9467,
+           0xa1e8, 0xe8b9, 0x2f4a, 0x661b, 0xf27c, 0xbb2d, 0x7cde, 0x358f },
+        {/*7*/  0, 0x74e1, 0x9872, 0xec93, 0xd6b4, 0xa255, 0x4ec6, 0x3a27,
+           0x6bd8, 0x1f39, 0xf3aa, 0x874b, 0xbd6c, 0xc98d, 0x251e, 0x51ff },
+        {/*8*/  0, 0x15c1, 0x2a42, 0x3f83, 0xcef4, 0xdb35, 0xe4b6, 0xf177,
+           0x4758, 0x5299, 0x6d1a, 0x78db, 0x89ac, 0x9c6d, 0xa3ee, 0xb62f },
+        {/*9*/  0, 0x3d01, 0x1602, 0x2b03, 0x8504, 0xb805, 0x9306, 0xae07,
+           0xca08, 0xf709, 0xdc0a, 0xe10b, 0x4f0c, 0x720d, 0x590e, 0x640f },
+        {/*a*/  0, 0x9801, 0xec02, 0x7403, 0x6b04, 0xf305, 0x8706, 0x1f07,
+           0xbd08, 0x2509, 0x510a, 0xc90b, 0xd60c, 0x4e0d, 0x3a0e, 0xa20f },
+        {/*b*/  0, 0xd131, 0x6212, 0xb323, 0x3884, 0xe9b5, 0x5a96, 0x8ba7,
+           0x1cc8, 0xcdf9, 0x7eda, 0xafeb, 0x244c, 0xf57d, 0x465e, 0x976f },
+        {/*c*/  0, 0xe1d1, 0x7262, 0x93b3, 0xb834, 0x59e5, 0xca56, 0x2b87,
+           0xdc18, 0x3dc9, 0xae7a, 0x4fab, 0x542c, 0x85fd, 0x164e, 0xf79f },
+        {/*d*/  0, 0x6051, 0xb0a2, 0xd0f3, 0x1094, 0x70c5, 0xa036, 0xc067,
+           0x20e8, 0x40b9, 0x904a, 0x601b, 0x307c, 0x502d, 0x80de, 0xe08f },
+        {/*e*/  0, 0xa4c1, 0xf842, 0x5c83, 0xe6f4, 0x4235, 0x1eb6, 0xba77,
+           0x7b58, 0xdf99, 0x831a, 0x27db, 0x9dac, 0x396d, 0x65ee, 0xc12f },
+        {/*f*/  0, 0x11c1, 0x2242, 0x3383, 0xc8f4, 0xd935, 0xeab6, 0xfb77,
+           0x4c58, 0x5d99, 0x6e1a, 0x7fdb, 0x84ac, 0x956d, 0xa6ee, 0xb72f },
+
+        /* Channel 1 syndromes */
+        {/*10*/ 1, 0x45d1, 0x8a62, 0xcfb3, 0x5e34, 0x1be5, 0xd456, 0x9187,
+           0xa718, 0xe2c9, 0x2d7a, 0x68ab, 0xf92c, 0xbcfd, 0x734e, 0x369f },
+        {/*11*/ 1, 0x63e1, 0xb172, 0xd293, 0x14b4, 0x7755, 0xa5c6, 0xc627,
+           0x28d8, 0x4b39, 0x99aa, 0xfa4b, 0x3c6c, 0x5f8d, 0x8d1e, 0xeeff },
+        {/*12*/ 1, 0xb741, 0xd982, 0x6ec3, 0x2254, 0x9515, 0xfbd6, 0x4c97,
+           0x33a8, 0x84e9, 0xea2a, 0x5d6b, 0x11fc, 0xa6bd, 0xc87e, 0x7f3f },
+        {/*13*/ 1, 0xdd41, 0x6682, 0xbbc3, 0x3554, 0xe815, 0x53d6, 0xce97,
+           0x1aa8, 0xc7e9, 0x7c2a, 0xa1fb, 0x2ffc, 0xf2bd, 0x497e, 0x943f },
+        {/*14*/ 1, 0x2bd1, 0x3d62, 0x16b3, 0x4f34, 0x64e5, 0x7256, 0x5987,
+           0x8518, 0xaec9, 0xb87a, 0x93ab, 0xca2c, 0xe1fd, 0xf74e, 0xdc9f },
+        {/*15*/ 1, 0x83c1, 0xc142, 0x4283, 0xa4f4, 0x2735, 0x65b6, 0xe677,
+           0xf858, 0x7b99, 0x391a, 0xbadb, 0x5cac, 0xdf6d, 0x9dee, 0x1e2f },
+        {/*16*/ 1, 0x8fd1, 0xc562, 0x4ab3, 0xa934, 0x26e5, 0x6c56, 0xe387,
+           0xfe18, 0x71c9, 0x3b7a, 0xb4ab, 0x572c, 0xd8fd, 0x924e, 0x1d9f },
+        {/*17*/ 1, 0x4791, 0x89e2, 0xce73, 0x5264, 0x15f5, 0xdb86, 0x9c17,
+           0xa3b8, 0xe429, 0x2a5a, 0x6dcb, 0xf1dc, 0xb64d, 0x783e, 0x3faf },
+        {/*18*/ 1, 0x5781, 0xa9c2, 0xfe43, 0x92a4, 0xc525, 0x3b66, 0x6ce7,
+           0xe3f8, 0xb479, 0x4a3a, 0x1dbb, 0x715c, 0x26dd, 0xd89e, 0x8f1f },
+        {/*19*/ 1, 0xbf41, 0xd582, 0x6ac3, 0x2954, 0x9615, 0xfcd6, 0x4397,
+           0x3ea8, 0x81e9, 0xeb2a, 0x546b, 0x17fc, 0xa8bd, 0xc27e, 0x7d3f },
+        {/*1a*/ 1, 0x9891, 0xe1e2, 0x7273, 0x6464, 0xf7f5, 0x8586, 0x1617,
+           0xb8b8, 0x2b29, 0x595a, 0xcacb, 0xdcdc, 0x4f4d, 0x3d3e, 0xaeaf },
+        {/*1b*/ 1, 0xcce1, 0x4472, 0x8893, 0xfdb4, 0x3f55, 0xb9c6, 0x7527,
+           0x56d8, 0x9a39, 0x12aa, 0xde4b, 0xab6c, 0x678d, 0xef1e, 0x23ff },
+        {/*1c*/ 1, 0xa761, 0xf9b2, 0x5ed3, 0xe214, 0x4575, 0x1ba6, 0xbcc7,
+           0x7328, 0xd449, 0x8a9a, 0x2dfb, 0x913c, 0x365d, 0x688e, 0xcfef },
+        {/*1d*/ 1, 0xff61, 0x55b2, 0xaad3, 0x7914, 0x8675, 0x2ca6, 0xd3c7,
+           0x9e28, 0x6149, 0xcb9a, 0x34fb, 0xe73c, 0x185d, 0xb28e, 0x4def },
+        {/*1e*/ 1, 0x5451, 0xa8a2, 0xfcf3, 0x9694, 0xc2c5, 0x3e36, 0x6a67,
+           0xebe8, 0xbfb9, 0x434a, 0x171b, 0x7d7c, 0x292d, 0xd5de, 0x818f },
+        {/*1f*/ 1, 0x6fc1, 0xb542, 0xda83, 0x19f4, 0x7635, 0xacb6, 0xc377,
+           0x2e58, 0x4199, 0x9b1a, 0xf4db, 0x37ac, 0x586d, 0x82ee, 0xed2f },
+
+        /* ECC bits are also in the set of tokens and they too can go bad
+         * first 2 cover channel 0, while the second 2 cover channel 1
+         */
+        {/*20*/ 0, 0xbe01, 0xd702, 0x6903, 0x2104, 0x9f05, 0xf606, 0x4807,
+           0x3208, 0x8c09, 0xe50a, 0x5b0b, 0x130c, 0xad0d, 0xc40e, 0x7a0f },
+        {/*21*/ 0, 0x4101, 0x8202, 0xc303, 0x5804, 0x1905, 0xda06, 0x9b07,
+           0xac08, 0xed09, 0x2e0a, 0x6f0b, 0x640c, 0xb50d, 0x760e, 0x370f },
+        {/*22*/ 1, 0xc441, 0x4882, 0x8cc3, 0xf654, 0x3215, 0xbed6, 0x7a97,
+           0x5ba8, 0x9fe9, 0x132a, 0xd76b, 0xadfc, 0x69bd, 0xe57e, 0x213f },
+        {/*23*/ 1, 0x7621, 0x9b32, 0xed13, 0xda44, 0xac65, 0x4176, 0x3757,
+           0x6f88, 0x19a9, 0xf4ba, 0x829b, 0xb5cc, 0xc3ed, 0x2efe, 0x58df }
+};
+
+/*
+ * Given the syndrome argument, scan each of the channel tables for a syndrome
+ * match. Depending on which table it is found, return the channel number.
+ */
+static int get_channel_from_ecc_syndrome(unsigned short syndrome)
+{
+        int row;
+        int column;
+
+        /* Determine column to scan */
+        column = syndrome & 0xF;
+
+        /* Scan all rows, looking for syndrome, or end of table */
+        for (row = 0; row < NUMBER_ECC_ROWS; row++) {
+                if (ecc_chipkill_syndromes[row][column] == syndrome)
+                        return ecc_chipkill_syndromes[row][0];
+        }
+
+        debugf0("syndrome(%x) not found\n", syndrome);
+        return -1;
+}
+
+/*
+ * Check for valid error in the NB Status High register. If so, proceed to read
+ * NB Status Low, NB Address Low and NB Address High registers and store data
+ * into error structure.
+ *
+ * Returns:
+ *      - 1: if hardware regs contains valid error info
+ *      - 0: if no valid error is indicated
+ */
+static int amd64_get_error_info_regs(struct mem_ctl_info *mci,
+                                     struct amd64_error_info_regs *regs)
+{
+        struct amd64_pvt *pvt;
+        struct pci_dev *misc_f3_ctl;
+        int err = 0;
+
+        pvt = mci->pvt_info;
+        misc_f3_ctl = pvt->misc_f3_ctl;
+
+        err = pci_read_config_dword(misc_f3_ctl, K8_NBSH, &regs->nbsh);
+        if (err)
+                goto err_reg;
+
+        if (!(regs->nbsh & K8_NBSH_VALID_BIT))
+                return 0;
+
+        /* valid error, read remaining error information registers */
+        err = pci_read_config_dword(misc_f3_ctl, K8_NBSL, &regs->nbsl);
+        if (err)
+                goto err_reg;
+
+        err = pci_read_config_dword(misc_f3_ctl, K8_NBEAL, &regs->nbeal);
+        if (err)
+                goto err_reg;
+
+        err = pci_read_config_dword(misc_f3_ctl, K8_NBEAH, &regs->nbeah);
+        if (err)
+                goto err_reg;
+
+        err = pci_read_config_dword(misc_f3_ctl, K8_NBCFG, &regs->nbcfg);
+        if (err)
+                goto err_reg;
+
+        return 1;
+
+err_reg:
+        debugf0("Reading error info register failed\n");
+        return 0;
+}
+
+/*
+ * This function is called to retrieve the error data from hardware and store it
+ * in the info structure.
+ *
+ * Returns:
+ *      - 1: if a valid error is found
+ *      - 0: if no error is found
+ */
+static int amd64_get_error_info(struct mem_ctl_info *mci,
+                                struct amd64_error_info_regs *info)
+{
+        struct amd64_pvt *pvt;
+        struct amd64_error_info_regs regs;
+
+        pvt = mci->pvt_info;
+
+        if (!amd64_get_error_info_regs(mci, info))
+                return 0;
+
+        /*
+         * Here's the problem with the K8's EDAC reporting: There are four
+         * registers which report pieces of error information. They are shared
+         * between CEs and UEs. Furthermore, contrary to what is stated in the
+         * BKDG, the overflow bit is never used! Every error always updates the
+         * reporting registers.
+         *
+         * Can you see the race condition? All four error reporting registers
+         * must be read before a new error updates them! There is no way to read
+         * all four registers atomically. The best than can be done is to detect
+         * that a race has occured and then report the error without any kind of
+         * precision.
+         *
+         * What is still positive is that errors are still reported and thus
+         * problems can still be detected - just not localized because the
+         * syndrome and address are spread out across registers.
+         *
+         * Grrrrr!!!!!  Here's hoping that AMD fixes this in some future K8 rev.
+         * UEs and CEs should have separate register sets with proper overflow
+         * bits that are used! At very least the problem can be fixed by
+         * honoring the ErrValid bit in 'nbsh' and not updating registers - just
+         * set the overflow bit - unless the current error is CE and the new
+         * error is UE which would be the only situation for overwriting the
+         * current values.
+         */
+
+        regs = *info;
+
+        /* Use info from the second read - most current */
+        if (unlikely(!amd64_get_error_info_regs(mci, info)))
+                return 0;
+
+        /* clear the error bits in hardware */
+        pci_write_bits32(pvt->misc_f3_ctl, K8_NBSH, 0, K8_NBSH_VALID_BIT);
+
+        /* Check for the possible race condition */
+        if ((regs.nbsh != info->nbsh) ||
+             (regs.nbsl != info->nbsl) ||
+             (regs.nbeah != info->nbeah) ||
+             (regs.nbeal != info->nbeal)) {
+                amd64_mc_printk(mci, KERN_WARNING,
+                                "hardware STATUS read access race condition "
+                                "detected!\n");
+                return 0;
+        }
+        return 1;
+}
+
+static inline void amd64_decode_gart_tlb_error(struct mem_ctl_info *mci,
+                                         struct amd64_error_info_regs *info)
+{
+        u32 err_code;
+        u32 ec_tt;              /* error code transaction type (2b) */
+        u32 ec_ll;              /* error code cache level (2b) */
+
+        err_code = EXTRACT_ERROR_CODE(info->nbsl);
+        ec_ll = EXTRACT_LL_CODE(err_code);
+        ec_tt = EXTRACT_TT_CODE(err_code);
+
+        amd64_mc_printk(mci, KERN_ERR,
+                     "GART TLB event: transaction type(%s), "
+                     "cache level(%s)\n", tt_msgs[ec_tt], ll_msgs[ec_ll]);
+}
+
+static inline void amd64_decode_mem_cache_error(struct mem_ctl_info *mci,
+                                      struct amd64_error_info_regs *info)
+{
+        u32 err_code;
+        u32 ec_rrrr;            /* error code memory transaction (4b) */
+        u32 ec_tt;              /* error code transaction type (2b) */
+        u32 ec_ll;              /* error code cache level (2b) */
+
+        err_code = EXTRACT_ERROR_CODE(info->nbsl);
+        ec_ll = EXTRACT_LL_CODE(err_code);
+        ec_tt = EXTRACT_TT_CODE(err_code);
+        ec_rrrr = EXTRACT_RRRR_CODE(err_code);
+
+        amd64_mc_printk(mci, KERN_ERR,
+                     "cache hierarchy error: memory transaction type(%s), "
+                     "transaction type(%s), cache level(%s)\n",
+                     rrrr_msgs[ec_rrrr], tt_msgs[ec_tt], ll_msgs[ec_ll]);
+}
+
+
+/*
+ * Handle any Correctable Errors (CEs) that have occurred. Check for valid ERROR
+ * ADDRESS and process.
+ */
+static void amd64_handle_ce(struct mem_ctl_info *mci,
+                            struct amd64_error_info_regs *info)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        u64 SystemAddress;
+
+        /* Ensure that the Error Address is VALID */
+        if ((info->nbsh & K8_NBSH_VALID_ERROR_ADDR) == 0) {
+                amd64_mc_printk(mci, KERN_ERR,
+                        "HW has no ERROR_ADDRESS available\n");
+                edac_mc_handle_ce_no_info(mci, EDAC_MOD_STR);
+                return;
+        }
+
+        SystemAddress = extract_error_address(mci, info);
+
+        amd64_mc_printk(mci, KERN_ERR,
+                "CE ERROR_ADDRESS= 0x%llx\n", SystemAddress);
+
+        pvt->ops->map_sysaddr_to_csrow(mci, info, SystemAddress);
+}
+
+/* Handle any Un-correctable Errors (UEs) */
+static void amd64_handle_ue(struct mem_ctl_info *mci,
+                            struct amd64_error_info_regs *info)
+{
+        int csrow;
+        u64 SystemAddress;
+        u32 page, offset;
+        struct mem_ctl_info *log_mci, *src_mci = NULL;
+
+        log_mci = mci;
+
+        if ((info->nbsh & K8_NBSH_VALID_ERROR_ADDR) == 0) {
+                amd64_mc_printk(mci, KERN_CRIT,
+                        "HW has no ERROR_ADDRESS available\n");
+                edac_mc_handle_ue_no_info(log_mci, EDAC_MOD_STR);
+                return;
+        }
+
+        SystemAddress = extract_error_address(mci, info);
+
+        /*
+         * Find out which node the error address belongs to. This may be
+         * different from the node that detected the error.
+         */
+        src_mci = find_mc_by_sys_addr(mci, SystemAddress);
+        if (!src_mci) {
+                amd64_mc_printk(mci, KERN_CRIT,
+                        "ERROR ADDRESS (0x%lx) value NOT mapped to a MC\n",
+                        (unsigned long)SystemAddress);
+                edac_mc_handle_ue_no_info(log_mci, EDAC_MOD_STR);
+                return;
+        }
+
+        log_mci = src_mci;
+
+        csrow = sys_addr_to_csrow(log_mci, SystemAddress);
+        if (csrow < 0) {
+                amd64_mc_printk(mci, KERN_CRIT,
+                        "ERROR_ADDRESS (0x%lx) value NOT mapped to 'csrow'\n",
+                        (unsigned long)SystemAddress);
+                edac_mc_handle_ue_no_info(log_mci, EDAC_MOD_STR);
+        } else {
+                error_address_to_page_and_offset(SystemAddress, &page, &offset);
+                edac_mc_handle_ue(log_mci, page, offset, csrow, EDAC_MOD_STR);
+        }
+}
+
+static void amd64_decode_bus_error(struct mem_ctl_info *mci,
+                                   struct amd64_error_info_regs *info)
+{
+        u32 err_code, ext_ec;
+        u32 ec_pp;              /* error code participating processor (2p) */
+        u32 ec_to;              /* error code timed out (1b) */
+        u32 ec_rrrr;            /* error code memory transaction (4b) */
+        u32 ec_ii;              /* error code memory or I/O (2b) */
+        u32 ec_ll;              /* error code cache level (2b) */
+
+        ext_ec = EXTRACT_EXT_ERROR_CODE(info->nbsl);
+        err_code = EXTRACT_ERROR_CODE(info->nbsl);
+
+        ec_ll = EXTRACT_LL_CODE(err_code);
+        ec_ii = EXTRACT_II_CODE(err_code);
+        ec_rrrr = EXTRACT_RRRR_CODE(err_code);
+        ec_to = EXTRACT_TO_CODE(err_code);
+        ec_pp = EXTRACT_PP_CODE(err_code);
+
+        amd64_mc_printk(mci, KERN_ERR,
+                "BUS ERROR:\n"
+                "  time-out(%s) mem or i/o(%s)\n"
+                "  participating processor(%s)\n"
+                "  memory transaction type(%s)\n"
+                "  cache level(%s) Error Found by: %s\n",
+                to_msgs[ec_to],
+                ii_msgs[ec_ii],
+                pp_msgs[ec_pp],
+                rrrr_msgs[ec_rrrr],
+                ll_msgs[ec_ll],
+                (info->nbsh & K8_NBSH_ERR_SCRUBER) ?
+                        "Scrubber" : "Normal Operation");
+
+        /* If this was an 'observed' error, early out */
+        if (ec_pp == K8_NBSL_PP_OBS)
+                return;         /* We aren't the node involved */
+
+        /* Parse out the extended error code for ECC events */
+        switch (ext_ec) {
+        /* F10 changed to one Extended ECC error code */
+        case F10_NBSL_EXT_ERR_RES:              /* Reserved field */
+        case F10_NBSL_EXT_ERR_ECC:              /* F10 ECC ext err code */
+                break;
+
+        default:
+                amd64_mc_printk(mci, KERN_ERR, "NOT ECC: no special error "
+                                               "handling for this error\n");
+                return;
+        }
+
+        if (info->nbsh & K8_NBSH_CECC)
+                amd64_handle_ce(mci, info);
+        else if (info->nbsh & K8_NBSH_UECC)
+                amd64_handle_ue(mci, info);
+
+        /*
+         * If main error is CE then overflow must be CE.  If main error is UE
+         * then overflow is unknown.  We'll call the overflow a CE - if
+         * panic_on_ue is set then we're already panic'ed and won't arrive
+         * here. Else, then apparently someone doesn't think that UE's are
+         * catastrophic.
+         */
+        if (info->nbsh & K8_NBSH_OVERFLOW)
+                edac_mc_handle_ce_no_info(mci, EDAC_MOD_STR
+                                          "Error Overflow set");
+}
+
+int amd64_process_error_info(struct mem_ctl_info *mci,
+                             struct amd64_error_info_regs *info,
+                             int handle_errors)
+{
+        struct amd64_pvt *pvt;
+        struct amd64_error_info_regs *regs;
+        u32 err_code, ext_ec;
+        int gart_tlb_error = 0;
+
+        pvt = mci->pvt_info;
+
+        /* If caller doesn't want us to process the error, return */
+        if (!handle_errors)
+                return 1;
+
+        regs = info;
+
+        debugf1("NorthBridge ERROR: mci(0x%p)\n", mci);
+        debugf1("  MC node(%d) Error-Address(0x%.8x-%.8x)\n",
+                pvt->mc_node_id, regs->nbeah, regs->nbeal);
+        debugf1("  nbsh(0x%.8x) nbsl(0x%.8x)\n",
+                regs->nbsh, regs->nbsl);
+        debugf1("  Valid Error=%s Overflow=%s\n",
+                (regs->nbsh & K8_NBSH_VALID_BIT) ? "True" : "False",
+                (regs->nbsh & K8_NBSH_OVERFLOW) ? "True" : "False");
+        debugf1("  Err Uncorrected=%s MCA Error Reporting=%s\n",
+                (regs->nbsh & K8_NBSH_UNCORRECTED_ERR) ?
+                        "True" : "False",
+                (regs->nbsh & K8_NBSH_ERR_ENABLE) ?
+                        "True" : "False");
+        debugf1("  MiscErr Valid=%s ErrAddr Valid=%s PCC=%s\n",
+                (regs->nbsh & K8_NBSH_MISC_ERR_VALID) ?
+                        "True" : "False",
+                (regs->nbsh & K8_NBSH_VALID_ERROR_ADDR) ?
+                        "True" : "False",
+                (regs->nbsh & K8_NBSH_PCC) ?
+                        "True" : "False");
+        debugf1("  CECC=%s UECC=%s Found by Scruber=%s\n",
+                (regs->nbsh & K8_NBSH_CECC) ?
+                        "True" : "False",
+                (regs->nbsh & K8_NBSH_UECC) ?
+                        "True" : "False",
+                (regs->nbsh & K8_NBSH_ERR_SCRUBER) ?
+                        "True" : "False");
+        debugf1("  CORE0=%s CORE1=%s CORE2=%s CORE3=%s\n",
+                (regs->nbsh & K8_NBSH_CORE0) ? "True" : "False",
+                (regs->nbsh & K8_NBSH_CORE1) ? "True" : "False",
+                (regs->nbsh & K8_NBSH_CORE2) ? "True" : "False",
+                (regs->nbsh & K8_NBSH_CORE3) ? "True" : "False");
+
+
+        err_code = EXTRACT_ERROR_CODE(regs->nbsl);
+
+        /* Determine which error type:
+         *      1) GART errors - non-fatal, developmental events
+         *      2) MEMORY errors
+         *      3) BUS errors
+         *      4) Unknown error
+         */
+        if (TEST_TLB_ERROR(err_code)) {
+                /*
+                 * GART errors are intended to help graphics driver developers
+                 * to detect bad GART PTEs. It is recommended by AMD to disable
+                 * GART table walk error reporting by default[1] (currently
+                 * being disabled in mce_cpu_quirks()) and according to the
+                 * comment in mce_cpu_quirks(), such GART errors can be
+                 * incorrectly triggered. We may see these errors anyway and
+                 * unless requested by the user, they won't be reported.
+                 *
+                 * [1] section 13.10.1 on BIOS and Kernel Developers Guide for
+                 *     AMD NPT family 0Fh processors
+                 */
+                if (report_gart_errors == 0)
+                        return 1;
+
+                /*
+                 * Only if GART error reporting is requested should we generate
+                 * any logs.
+                 */
+                gart_tlb_error = 1;
+
+                debugf1("GART TLB error\n");
+                amd64_decode_gart_tlb_error(mci, info);
+        } else if (TEST_MEM_ERROR(err_code)) {
+                debugf1("Memory/Cache error\n");
+                amd64_decode_mem_cache_error(mci, info);
+        } else if (TEST_BUS_ERROR(err_code)) {
+                debugf1("Bus (Link/DRAM) error\n");
+                amd64_decode_bus_error(mci, info);
+        } else {
+                /* shouldn't reach here! */
+                amd64_mc_printk(mci, KERN_WARNING,
+                             "%s(): unknown MCE error 0x%x\n", __func__,
+                             err_code);
+        }
+
+        ext_ec = EXTRACT_EXT_ERROR_CODE(regs->nbsl);
+        amd64_mc_printk(mci, KERN_ERR,
+                "ExtErr=(0x%x) %s\n", ext_ec, ext_msgs[ext_ec]);
+
+        if (((ext_ec >= F10_NBSL_EXT_ERR_CRC &&
+                        ext_ec <= F10_NBSL_EXT_ERR_TGT) ||
+                        (ext_ec == F10_NBSL_EXT_ERR_RMW)) &&
+                        EXTRACT_LDT_LINK(info->nbsh)) {
+
+                amd64_mc_printk(mci, KERN_ERR,
+                        "Error on hypertransport link: %s\n",
+                        htlink_msgs[
+                        EXTRACT_LDT_LINK(info->nbsh)]);
+        }
+
+        /*
+         * Check the UE bit of the NB status high register, if set generate some
+         * logs. If NOT a GART error, then process the event as a NO-INFO event.
+         * If it was a GART error, skip that process.
+         */
+        if (regs->nbsh & K8_NBSH_UNCORRECTED_ERR) {
+                amd64_mc_printk(mci, KERN_CRIT, "uncorrected error\n");
+                if (!gart_tlb_error)
+                        edac_mc_handle_ue_no_info(mci, "UE bit is set\n");
+        }
+
+        if (regs->nbsh & K8_NBSH_PCC)
+                amd64_mc_printk(mci, KERN_CRIT,
+                        "PCC (processor context corrupt) set\n");
+
+        return 1;
+}
+EXPORT_SYMBOL_GPL(amd64_process_error_info);
+
+/*
+ * The main polling 'check' function, called FROM the edac core to perform the
+ * error checking and if an error is encountered, error processing.
+ */
+static void amd64_check(struct mem_ctl_info *mci)
+{
+        struct amd64_error_info_regs info;
+
+        if (amd64_get_error_info(mci, &info))
+                amd64_process_error_info(mci, &info, 1);
+}
+
+/*
+ * Input:
+ *      1) struct amd64_pvt which contains pvt->dram_f2_ctl pointer
+ *      2) AMD Family index value
+ *
+ * Ouput:
+ *      Upon return of 0, the following filled in:
+ *
+ *              struct pvt->addr_f1_ctl
+ *              struct pvt->misc_f3_ctl
+ *
+ *      Filled in with related device funcitions of 'dram_f2_ctl'
+ *      These devices are "reserved" via the pci_get_device()
+ *
+ *      Upon return of 1 (error status):
+ *
+ *              Nothing reserved
+ */
+static int amd64_reserve_mc_sibling_devices(struct amd64_pvt *pvt, int mc_idx)
+{
+        const struct amd64_family_type *amd64_dev = &amd64_family_types[mc_idx];
+
+        /* Reserve the ADDRESS MAP Device */
+        pvt->addr_f1_ctl = pci_get_related_function(pvt->dram_f2_ctl->vendor,
+                                                    amd64_dev->addr_f1_ctl,
+                                                    pvt->dram_f2_ctl);
+
+        if (!pvt->addr_f1_ctl) {
+                amd64_printk(KERN_ERR, "error address map device not found: "
+                             "vendor %x device 0x%x (broken BIOS?)\n",
+                             PCI_VENDOR_ID_AMD, amd64_dev->addr_f1_ctl);
+                return 1;
+        }
+
+        /* Reserve the MISC Device */
+        pvt->misc_f3_ctl = pci_get_related_function(pvt->dram_f2_ctl->vendor,
+                                                    amd64_dev->misc_f3_ctl,
+                                                    pvt->dram_f2_ctl);
+
+        if (!pvt->misc_f3_ctl) {
+                pci_dev_put(pvt->addr_f1_ctl);
+                pvt->addr_f1_ctl = NULL;
+
+                amd64_printk(KERN_ERR, "error miscellaneous device not found: "
+                             "vendor %x device 0x%x (broken BIOS?)\n",
+                             PCI_VENDOR_ID_AMD, amd64_dev->misc_f3_ctl);
+                return 1;
+        }
+
+        debugf1("    Addr Map device PCI Bus ID:\t%s\n",
+                pci_name(pvt->addr_f1_ctl));
+        debugf1("    DRAM MEM-CTL PCI Bus ID:\t%s\n",
+                pci_name(pvt->dram_f2_ctl));
+        debugf1("    Misc device PCI Bus ID:\t%s\n",
+                pci_name(pvt->misc_f3_ctl));
+
+        return 0;
+}
+
+static void amd64_free_mc_sibling_devices(struct amd64_pvt *pvt)
+{
+        pci_dev_put(pvt->addr_f1_ctl);
+        pci_dev_put(pvt->misc_f3_ctl);
+}
+
+/*
+ * Retrieve the hardware registers of the memory controller (this includes the
+ * 'Address Map' and 'Misc' device regs)
+ */
+static void amd64_read_mc_registers(struct amd64_pvt *pvt)
+{
+        u64 msr_val;
+        int dram, err = 0;
+
+        /*
+         * Retrieve TOP_MEM and TOP_MEM2; no masking off of reserved bits since
+         * those are Read-As-Zero
+         */
+        rdmsrl(MSR_K8_TOP_MEM1, msr_val);
+        pvt->top_mem = msr_val >> 23;
+        debugf0("  TOP_MEM=0x%08llx\n", pvt->top_mem);
+
+        /* check first whether TOP_MEM2 is enabled */
+        rdmsrl(MSR_K8_SYSCFG, msr_val);
+        if (msr_val & (1U << 21)) {
+                rdmsrl(MSR_K8_TOP_MEM2, msr_val);
+                pvt->top_mem2 = msr_val >> 23;
+                debugf0("  TOP_MEM2=0x%08llx\n", pvt->top_mem2);
+        } else
+                debugf0("  TOP_MEM2 disabled.\n");
+
+        amd64_cpu_display_info(pvt);
+
+        err = pci_read_config_dword(pvt->misc_f3_ctl, K8_NBCAP, &pvt->nbcap);
+        if (err)
+                goto err_reg;
+
+        if (pvt->ops->read_dram_ctl_register)
+                pvt->ops->read_dram_ctl_register(pvt);
+
+        for (dram = 0; dram < DRAM_REG_COUNT; dram++) {
+                /*
+                 * Call CPU specific READ function to get the DRAM Base and
+                 * Limit values from the DCT.
+                 */
+                pvt->ops->read_dram_base_limit(pvt, dram);
+
+                /*
+                 * Only print out debug info on rows with both R and W Enabled.
+                 * Normal processing, compiler should optimize this whole 'if'
+                 * debug output block away.
+                 */
+                if (pvt->dram_rw_en[dram] != 0) {
+                        debugf1("  DRAM_BASE[%d]: 0x%8.08x-%8.08x "
+                                "DRAM_LIMIT:  0x%8.08x-%8.08x\n",
+                                dram,
+                                (u32)(pvt->dram_base[dram] >> 32),
+                                (u32)(pvt->dram_base[dram] & 0xFFFFFFFF),
+                                (u32)(pvt->dram_limit[dram] >> 32),
+                                (u32)(pvt->dram_limit[dram] & 0xFFFFFFFF));
+                        debugf1("        IntlvEn=%s %s %s "
+                                "IntlvSel=%d DstNode=%d\n",
+                                pvt->dram_IntlvEn[dram] ?
+                                        "Enabled" : "Disabled",
+                                (pvt->dram_rw_en[dram] & 0x2) ? "W" : "!W",
+                                (pvt->dram_rw_en[dram] & 0x1) ? "R" : "!R",
+                                pvt->dram_IntlvSel[dram],
+                                pvt->dram_DstNode[dram]);
+                }
+        }
+
+        amd64_read_dct_base_mask(pvt);
+
+        err = pci_read_config_dword(pvt->addr_f1_ctl, K8_DHAR, &pvt->dhar);
+        if (err)
+                goto err_reg;
+
+        amd64_read_dbam_reg(pvt);
+
+        err = pci_read_config_dword(pvt->misc_f3_ctl,
+                                F10_ONLINE_SPARE, &pvt->online_spare);
+        if (err)
+                goto err_reg;
+
+        err = pci_read_config_dword(pvt->dram_f2_ctl, F10_DCLR_0, &pvt->dclr0);
+        if (err)
+                goto err_reg;
+
+        err = pci_read_config_dword(pvt->dram_f2_ctl, F10_DCHR_0, &pvt->dchr0);
+        if (err)
+                goto err_reg;
+
+        if (!dct_ganging_enabled(pvt)) {
+                err = pci_read_config_dword(pvt->dram_f2_ctl, F10_DCLR_1,
+                                                &pvt->dclr1);
+                if (err)
+                        goto err_reg;
+
+                err = pci_read_config_dword(pvt->dram_f2_ctl, F10_DCHR_1,
+                                                &pvt->dchr1);
+                if (err)
+                        goto err_reg;
+        }
+
+        amd64_dump_misc_regs(pvt);
+
+err_reg:
+        debugf0("Reading an MC register failed\n");
+
+}
+
+/*
+ * NOTE: CPU Revision Dependent code
+ *
+ * Input:
+ *      @csrow_nr ChipSelect Row Number (0..CHIPSELECT_COUNT-1)
+ *      k8 private pointer to -->
+ *                      DRAM Bank Address mapping register
+ *                      node_id
+ *                      DCL register where dual_channel_active is
+ *
+ * The DBAM register consists of 4 sets of 4 bits each definitions:
+ *
+ * Bits:        CSROWs
+ * 0-3          CSROWs 0 and 1
+ * 4-7          CSROWs 2 and 3
+ * 8-11         CSROWs 4 and 5
+ * 12-15        CSROWs 6 and 7
+ *
+ * Values range from: 0 to 15
+ * The meaning of the values depends on CPU revision and dual-channel state,
+ * see relevant BKDG more info.
+ *
+ * The memory controller provides for total of only 8 CSROWs in its current
+ * architecture. Each "pair" of CSROWs normally represents just one DIMM in
+ * single channel or two (2) DIMMs in dual channel mode.
+ *
+ * The following code logic collapses the various tables for CSROW based on CPU
+ * revision.
+ *
+ * Returns:
+ *      The number of PAGE_SIZE pages on the specified CSROW number it
+ *      encompasses
+ *
+ */
+static u32 amd64_csrow_nr_pages(int csrow_nr, struct amd64_pvt *pvt)
+{
+        u32 dram_map, nr_pages;
+
+        /*
+         * The math on this doesn't look right on the surface because x/2*4 can
+         * be simplified to x*2 but this expression makes use of the fact that
+         * it is integral math where 1/2=0. This intermediate value becomes the
+         * number of bits to shift the DBAM register to extract the proper CSROW
+         * field.
+         */
+        dram_map = (pvt->dbam0 >> ((csrow_nr / 2) * 4)) & 0xF;
+
+        nr_pages = pvt->ops->dbam_map_to_pages(pvt, dram_map);
+
+        /*
+         * If dual channel then double the memory size of single channel.
+         * Channel count is 1 or 2
+         */
+        nr_pages <<= (pvt->channel_count - 1);
+
+        debugf0("  (csrow=%d) DBAM map index= %d\n", csrow_nr, dram_map);
+        debugf0("    nr_pages= %u  channel-count = %d\n",
+                nr_pages, pvt->channel_count);
+
+        return nr_pages;
+}
+
+/*
+ * Initialize the array of csrow attribute instances, based on the values
+ * from pci config hardware registers.
+ */
+static int amd64_init_csrows(struct mem_ctl_info *mci)
+{
+        struct csrow_info *csrow;
+        struct amd64_pvt *pvt;
+        u64 input_addr_min, input_addr_max, sys_addr;
+        int i, err = 0, empty = 1;
+
+        pvt = mci->pvt_info;
+
+        err = pci_read_config_dword(pvt->misc_f3_ctl, K8_NBCFG, &pvt->nbcfg);
+        if (err)
+                debugf0("Reading K8_NBCFG failed\n");
+
+        debugf0("NBCFG= 0x%x  CHIPKILL= %s DRAM ECC= %s\n", pvt->nbcfg,
+                (pvt->nbcfg & K8_NBCFG_CHIPKILL) ? "Enabled" : "Disabled",
+                (pvt->nbcfg & K8_NBCFG_ECC_ENABLE) ? "Enabled" : "Disabled"
+                );
+
+        for (i = 0; i < CHIPSELECT_COUNT; i++) {
+                csrow = &mci->csrows[i];
+
+                if ((pvt->dcsb0[i] & K8_DCSB_CS_ENABLE) == 0) {
+                        debugf1("----CSROW %d EMPTY for node %d\n", i,
+                                pvt->mc_node_id);
+                        continue;
+                }
+
+                debugf1("----CSROW %d VALID for MC node %d\n",
+                        i, pvt->mc_node_id);
+
+                empty = 0;
+                csrow->nr_pages = amd64_csrow_nr_pages(i, pvt);
+                find_csrow_limits(mci, i, &input_addr_min, &input_addr_max);
+                sys_addr = input_addr_to_sys_addr(mci, input_addr_min);
+                csrow->first_page = (u32) (sys_addr >> PAGE_SHIFT);
+                sys_addr = input_addr_to_sys_addr(mci, input_addr_max);
+                csrow->last_page = (u32) (sys_addr >> PAGE_SHIFT);
+                csrow->page_mask = ~mask_from_dct_mask(pvt, i);
+                /* 8 bytes of resolution */
+
+                csrow->mtype = amd64_determine_memory_type(pvt);
+
+                debugf1("  for MC node %d csrow %d:\n", pvt->mc_node_id, i);
+                debugf1("    input_addr_min: 0x%lx input_addr_max: 0x%lx\n",
+                        (unsigned long)input_addr_min,
+                        (unsigned long)input_addr_max);
+                debugf1("    sys_addr: 0x%lx  page_mask: 0x%lx\n",
+                        (unsigned long)sys_addr, csrow->page_mask);
+                debugf1("    nr_pages: %u  first_page: 0x%lx "
+                        "last_page: 0x%lx\n",
+                        (unsigned)csrow->nr_pages,
+                        csrow->first_page, csrow->last_page);
+
+                /*
+                 * determine whether CHIPKILL or JUST ECC or NO ECC is operating
+                 */
+                if (pvt->nbcfg & K8_NBCFG_ECC_ENABLE)
+                        csrow->edac_mode =
+                            (pvt->nbcfg & K8_NBCFG_CHIPKILL) ?
+                            EDAC_S4ECD4ED : EDAC_SECDED;
+                else
+                        csrow->edac_mode = EDAC_NONE;
+        }
+
+        return empty;
+}
+
+/*
+ * Only if 'ecc_enable_override' is set AND BIOS had ECC disabled, do "we"
+ * enable it.
+ */
+static void amd64_enable_ecc_error_reporting(struct mem_ctl_info *mci)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        const cpumask_t *cpumask = cpumask_of_node(pvt->mc_node_id);
+        int cpu, idx = 0, err = 0;
+        struct msr msrs[cpumask_weight(cpumask)];
+        u32 value;
+        u32 mask = K8_NBCTL_CECCEn | K8_NBCTL_UECCEn;
+
+        if (!ecc_enable_override)
+                return;
+
+        memset(msrs, 0, sizeof(msrs));
+
+        amd64_printk(KERN_WARNING,
+                "'ecc_enable_override' parameter is active, "
+                "Enabling AMD ECC hardware now: CAUTION\n");
+
+        err = pci_read_config_dword(pvt->misc_f3_ctl, K8_NBCTL, &value);
+        if (err)
+                debugf0("Reading K8_NBCTL failed\n");
+
+        /* turn on UECCn and CECCEn bits */
+        pvt->old_nbctl = value & mask;
+        pvt->nbctl_mcgctl_saved = 1;
+
+        value |= mask;
+        pci_write_config_dword(pvt->misc_f3_ctl, K8_NBCTL, value);
+
+        rdmsr_on_cpus(cpumask, K8_MSR_MCGCTL, msrs);
+
+        for_each_cpu(cpu, cpumask) {
+                if (msrs[idx].l & K8_MSR_MCGCTL_NBE)
+                        set_bit(idx, &pvt->old_mcgctl);
+
+                msrs[idx].l |= K8_MSR_MCGCTL_NBE;
+                idx++;
+        }
+        wrmsr_on_cpus(cpumask, K8_MSR_MCGCTL, msrs);
+
+        err = pci_read_config_dword(pvt->misc_f3_ctl, K8_NBCFG, &value);
+        if (err)
+                debugf0("Reading K8_NBCFG failed\n");
+
+        debugf0("NBCFG(1)= 0x%x  CHIPKILL= %s ECC_ENABLE= %s\n", value,
+                (value & K8_NBCFG_CHIPKILL) ? "Enabled" : "Disabled",
+                (value & K8_NBCFG_ECC_ENABLE) ? "Enabled" : "Disabled");
+
+        if (!(value & K8_NBCFG_ECC_ENABLE)) {
+                amd64_printk(KERN_WARNING,
+                        "This node reports that DRAM ECC is "
+                        "currently Disabled; ENABLING now\n");
+
+                /* Attempt to turn on DRAM ECC Enable */
+                value |= K8_NBCFG_ECC_ENABLE;
+                pci_write_config_dword(pvt->misc_f3_ctl, K8_NBCFG, value);
+
+                err = pci_read_config_dword(pvt->misc_f3_ctl, K8_NBCFG, &value);
+                if (err)
+                        debugf0("Reading K8_NBCFG failed\n");
+
+                if (!(value & K8_NBCFG_ECC_ENABLE)) {
+                        amd64_printk(KERN_WARNING,
+                                "Hardware rejects Enabling DRAM ECC checking\n"
+                                "Check memory DIMM configuration\n");
+                } else {
+                        amd64_printk(KERN_DEBUG,
+                                "Hardware accepted DRAM ECC Enable\n");
+                }
+        }
+        debugf0("NBCFG(2)= 0x%x  CHIPKILL= %s ECC_ENABLE= %s\n", value,
+                (value & K8_NBCFG_CHIPKILL) ? "Enabled" : "Disabled",
+                (value & K8_NBCFG_ECC_ENABLE) ? "Enabled" : "Disabled");
+
+        pvt->ctl_error_info.nbcfg = value;
+}
+
+static void amd64_restore_ecc_error_reporting(struct amd64_pvt *pvt)
+{
+        const cpumask_t *cpumask = cpumask_of_node(pvt->mc_node_id);
+        int cpu, idx = 0, err = 0;
+        struct msr msrs[cpumask_weight(cpumask)];
+        u32 value;
+        u32 mask = K8_NBCTL_CECCEn | K8_NBCTL_UECCEn;
+
+        if (!pvt->nbctl_mcgctl_saved)
+                return;
+
+        memset(msrs, 0, sizeof(msrs));
+
+        err = pci_read_config_dword(pvt->misc_f3_ctl, K8_NBCTL, &value);
+        if (err)
+                debugf0("Reading K8_NBCTL failed\n");
+        value &= ~mask;
+        value |= pvt->old_nbctl;
+
+        /* restore the NB Enable MCGCTL bit */
+        pci_write_config_dword(pvt->misc_f3_ctl, K8_NBCTL, value);
+
+        rdmsr_on_cpus(cpumask, K8_MSR_MCGCTL, msrs);
+
+        for_each_cpu(cpu, cpumask) {
+                msrs[idx].l &= ~K8_MSR_MCGCTL_NBE;
+                msrs[idx].l |=
+                        test_bit(idx, &pvt->old_mcgctl) << K8_MSR_MCGCTL_NBE;
+                idx++;
+        }
+
+        wrmsr_on_cpus(cpumask, K8_MSR_MCGCTL, msrs);
+}
+
+static void check_mcg_ctl(void *ret)
+{
+        u64 msr_val = 0;
+        u8 nbe;
+
+        rdmsrl(MSR_IA32_MCG_CTL, msr_val);
+        nbe = msr_val & K8_MSR_MCGCTL_NBE;
+
+        debugf0("core: %u, MCG_CTL: 0x%llx, NB MSR is %s\n",
+                raw_smp_processor_id(), msr_val,
+                (nbe ? "enabled" : "disabled"));
+
+        if (!nbe)
+                *(int *)ret = 0;
+}
+
+/* check MCG_CTL on all the cpus on this node */
+static int amd64_mcg_ctl_enabled_on_cpus(const cpumask_t *mask)
+{
+        int ret = 1;
+        preempt_disable();
+        smp_call_function_many(mask, check_mcg_ctl, &ret, 1);
+        preempt_enable();
+
+        return ret;
+}
+
+/*
+ * EDAC requires that the BIOS have ECC enabled before taking over the
+ * processing of ECC errors. This is because the BIOS can properly initialize
+ * the memory system completely. A command line option allows to force-enable
+ * hardware ECC later in amd64_enable_ecc_error_reporting().
+ */
+static int amd64_check_ecc_enabled(struct amd64_pvt *pvt)
+{
+        u32 value;
+        int err = 0, ret = 0;
+        u8 ecc_enabled = 0;
+
+        err = pci_read_config_dword(pvt->misc_f3_ctl, K8_NBCFG, &value);
+        if (err)
+                debugf0("Reading K8_NBCTL failed\n");
+
+        ecc_enabled = !!(value & K8_NBCFG_ECC_ENABLE);
+
+        ret = amd64_mcg_ctl_enabled_on_cpus(cpumask_of_node(pvt->mc_node_id));
+
+        debugf0("K8_NBCFG=0x%x,  DRAM ECC is %s\n", value,
+                        (value & K8_NBCFG_ECC_ENABLE ? "enabled" : "disabled"));
+
+        if (!ecc_enabled || !ret) {
+                if (!ecc_enabled) {
+                        amd64_printk(KERN_WARNING, "This node reports that "
+                                                   "Memory ECC is currently "
+                                                   "disabled.\n");
+
+                        amd64_printk(KERN_WARNING, "bit 0x%lx in register "
+                                "F3x%x of the MISC_CONTROL device (%s) "
+                                "should be enabled\n", K8_NBCFG_ECC_ENABLE,
+                                K8_NBCFG, pci_name(pvt->misc_f3_ctl));
+                }
+                if (!ret) {
+                        amd64_printk(KERN_WARNING, "bit 0x%016lx in MSR 0x%08x "
+                                        "of node %d should be enabled\n",
+                                        K8_MSR_MCGCTL_NBE, MSR_IA32_MCG_CTL,
+                                        pvt->mc_node_id);
+                }
+                if (!ecc_enable_override) {
+                        amd64_printk(KERN_WARNING, "WARNING: ECC is NOT "
+                                "currently enabled by the BIOS. Module "
+                                "will NOT be loaded.\n"
+                                "    Either Enable ECC in the BIOS, "
+                                "or use the 'ecc_enable_override' "
+                                "parameter.\n"
+                                "    Might be a BIOS bug, if BIOS says "
+                                "ECC is enabled\n"
+                                "    Use of the override can cause "
+                                "unknown side effects.\n");
+                        ret = -ENODEV;
+                }
+        } else {
+                amd64_printk(KERN_INFO,
+                        "ECC is enabled by BIOS, Proceeding "
+                        "with EDAC module initialization\n");
+
+                /* CLEAR the override, since BIOS controlled it */
+                ecc_enable_override = 0;
+        }
+
+        return ret;
+}
+
+struct mcidev_sysfs_attribute sysfs_attrs[ARRAY_SIZE(amd64_dbg_attrs) +
+                                          ARRAY_SIZE(amd64_inj_attrs) +
+                                          1];
+
+struct mcidev_sysfs_attribute terminator = { .attr = { .name = NULL } };
+
+static void amd64_set_mc_sysfs_attributes(struct mem_ctl_info *mci)
+{
+        unsigned int i = 0, j = 0;
+
+        for (; i < ARRAY_SIZE(amd64_dbg_attrs); i++)
+                sysfs_attrs[i] = amd64_dbg_attrs[i];
+
+        for (j = 0; j < ARRAY_SIZE(amd64_inj_attrs); j++, i++)
+                sysfs_attrs[i] = amd64_inj_attrs[j];
+
+        sysfs_attrs[i] = terminator;
+
+        mci->mc_driver_sysfs_attributes = sysfs_attrs;
+}
+
+static void amd64_setup_mci_misc_attributes(struct mem_ctl_info *mci)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+
+        mci->mtype_cap          = MEM_FLAG_DDR2 | MEM_FLAG_RDDR2;
+        mci->edac_ctl_cap       = EDAC_FLAG_NONE;
+        mci->edac_cap           = EDAC_FLAG_NONE;
+
+        if (pvt->nbcap & K8_NBCAP_SECDED)
+                mci->edac_ctl_cap |= EDAC_FLAG_SECDED;
+
+        if (pvt->nbcap & K8_NBCAP_CHIPKILL)
+                mci->edac_ctl_cap |= EDAC_FLAG_S4ECD4ED;
+
+        mci->edac_cap           = amd64_determine_edac_cap(pvt);
+        mci->mod_name           = EDAC_MOD_STR;
+        mci->mod_ver            = EDAC_AMD64_VERSION;
+        mci->ctl_name           = get_amd_family_name(pvt->mc_type_index);
+        mci->dev_name           = pci_name(pvt->dram_f2_ctl);
+        mci->ctl_page_to_phys   = NULL;
+
+        /* IMPORTANT: Set the polling 'check' function in this module */
+        mci->edac_check         = amd64_check;
+
+        /* memory scrubber interface */
+        mci->set_sdram_scrub_rate = amd64_set_scrub_rate;
+        mci->get_sdram_scrub_rate = amd64_get_scrub_rate;
+}
+
+/*
+ * Init stuff for this DRAM Controller device.
+ *
+ * Due to a hardware feature on Fam10h CPUs, the Enable Extended Configuration
+ * Space feature MUST be enabled on ALL Processors prior to actually reading
+ * from the ECS registers. Since the loading of the module can occur on any
+ * 'core', and cores don't 'see' all the other processors ECS data when the
+ * others are NOT enabled. Our solution is to first enable ECS access in this
+ * routine on all processors, gather some data in a amd64_pvt structure and
+ * later come back in a finish-setup function to perform that final
+ * initialization. See also amd64_init_2nd_stage() for that.
+ */
+static int amd64_probe_one_instance(struct pci_dev *dram_f2_ctl,
+                                    int mc_type_index)
+{
+        struct amd64_pvt *pvt = NULL;
+        int err = 0, ret;
+
+        ret = -ENOMEM;
+        pvt = kzalloc(sizeof(struct amd64_pvt), GFP_KERNEL);
+        if (!pvt)
+                goto err_exit;
+
+        pvt->mc_node_id = get_mc_node_id_from_pdev(dram_f2_ctl);
+
+        pvt->dram_f2_ctl        = dram_f2_ctl;
+        pvt->ext_model          = boot_cpu_data.x86_model >> 4;
+        pvt->mc_type_index      = mc_type_index;
+        pvt->ops                = family_ops(mc_type_index);
+        pvt->old_mcgctl         = 0;
+
+        /*
+         * We have the dram_f2_ctl device as an argument, now go reserve its
+         * sibling devices from the PCI system.
+         */
+        ret = -ENODEV;
+        err = amd64_reserve_mc_sibling_devices(pvt, mc_type_index);
+        if (err)
+                goto err_free;
+
+        ret = -EINVAL;
+        err = amd64_check_ecc_enabled(pvt);
+        if (err)
+                goto err_put;
+
+        /*
+         * Key operation here: setup of HW prior to performing ops on it. Some
+         * setup is required to access ECS data. After this is performed, the
+         * 'teardown' function must be called upon error and normal exit paths.
+         */
+        if (boot_cpu_data.x86 >= 0x10)
+                amd64_setup(pvt);
+
+        /*
+         * Save the pointer to the private data for use in 2nd initialization
+         * stage
+         */
+        pvt_lookup[pvt->mc_node_id] = pvt;
+
+        return 0;
+
+err_put:
+        amd64_free_mc_sibling_devices(pvt);
+
+err_free:
+        kfree(pvt);
+
+err_exit:
+        return ret;
+}
+
+/*
+ * This is the finishing stage of the init code. Needs to be performed after all
+ * MCs' hardware have been prepped for accessing extended config space.
+ */
+static int amd64_init_2nd_stage(struct amd64_pvt *pvt)
+{
+        int node_id = pvt->mc_node_id;
+        struct mem_ctl_info *mci;
+        int ret, err = 0;
+
+        amd64_read_mc_registers(pvt);
+
+        ret = -ENODEV;
+        if (pvt->ops->probe_valid_hardware) {
+                err = pvt->ops->probe_valid_hardware(pvt);
+                if (err)
+                        goto err_exit;
+        }
+
+        /*
+         * We need to determine how many memory channels there are. Then use
+         * that information for calculating the size of the dynamic instance
+         * tables in the 'mci' structure
+         */
+        pvt->channel_count = pvt->ops->early_channel_count(pvt);
+        if (pvt->channel_count < 0)
+                goto err_exit;
+
+        ret = -ENOMEM;
+        mci = edac_mc_alloc(0, CHIPSELECT_COUNT, pvt->channel_count, node_id);
+        if (!mci)
+                goto err_exit;
+
+        mci->pvt_info = pvt;
+
+        mci->dev = &pvt->dram_f2_ctl->dev;
+        amd64_setup_mci_misc_attributes(mci);
+
+        if (amd64_init_csrows(mci))
+                mci->edac_cap = EDAC_FLAG_NONE;
+
+        amd64_enable_ecc_error_reporting(mci);
+        amd64_set_mc_sysfs_attributes(mci);
+
+        ret = -ENODEV;
+        if (edac_mc_add_mc(mci)) {
+                debugf1("failed edac_mc_add_mc()\n");
+                goto err_add_mc;
+        }
+
+        mci_lookup[node_id] = mci;
+        pvt_lookup[node_id] = NULL;
+        return 0;
+
+err_add_mc:
+        edac_mc_free(mci);
+
+err_exit:
+        debugf0("failure to init 2nd stage: ret=%d\n", ret);
+
+        amd64_restore_ecc_error_reporting(pvt);
+
+        if (boot_cpu_data.x86 > 0xf)
+                amd64_teardown(pvt);
+
+        amd64_free_mc_sibling_devices(pvt);
+
+        kfree(pvt_lookup[pvt->mc_node_id]);
+        pvt_lookup[node_id] = NULL;
+
+        return ret;
+}
+
+
+static int __devinit amd64_init_one_instance(struct pci_dev *pdev,
+                                 const struct pci_device_id *mc_type)
+{
+        int ret = 0;
+
+        debugf0("(MC node=%d,mc_type='%s')\n",
+                get_mc_node_id_from_pdev(pdev),
+                get_amd_family_name(mc_type->driver_data));
+
+        ret = pci_enable_device(pdev);
+        if (ret < 0)
+                ret = -EIO;
+        else
+                ret = amd64_probe_one_instance(pdev, mc_type->driver_data);
+
+        if (ret < 0)
+                debugf0("ret=%d\n", ret);
+
+        return ret;
+}
+
+static void __devexit amd64_remove_one_instance(struct pci_dev *pdev)
+{
+        struct mem_ctl_info *mci;
+        struct amd64_pvt *pvt;
+
+        /* Remove from EDAC CORE tracking list */
+        mci = edac_mc_del_mc(&pdev->dev);
+        if (!mci)
+                return;
+
+        pvt = mci->pvt_info;
+
+        amd64_restore_ecc_error_reporting(pvt);
+
+        if (boot_cpu_data.x86 > 0xf)
+                amd64_teardown(pvt);
+
+        amd64_free_mc_sibling_devices(pvt);
+
+        kfree(pvt);
+        mci->pvt_info = NULL;
+
+        mci_lookup[pvt->mc_node_id] = NULL;
+
+        /* Free the EDAC CORE resources */
+        edac_mc_free(mci);
+}
+
+/*
+ * This table is part of the interface for loading drivers for PCI devices. The
+ * PCI core identifies what devices are on a system during boot, and then
+ * inquiry this table to see if this driver is for a given device found.
+ */
+static const struct pci_device_id amd64_pci_table[] __devinitdata = {
+        {
+                .vendor         = PCI_VENDOR_ID_AMD,
+                .device         = PCI_DEVICE_ID_AMD_K8_NB_MEMCTL,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .class          = 0,
+                .class_mask     = 0,
+                .driver_data    = K8_CPUS
+        },
+        {
+                .vendor         = PCI_VENDOR_ID_AMD,
+                .device         = PCI_DEVICE_ID_AMD_10H_NB_DRAM,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .class          = 0,
+                .class_mask     = 0,
+                .driver_data    = F10_CPUS
+        },
+        {
+                .vendor         = PCI_VENDOR_ID_AMD,
+                .device         = PCI_DEVICE_ID_AMD_11H_NB_DRAM,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .class          = 0,
+                .class_mask     = 0,
+                .driver_data    = F11_CPUS
+        },
+        {0, }
+};
+MODULE_DEVICE_TABLE(pci, amd64_pci_table);
+
+static struct pci_driver amd64_pci_driver = {
+        .name           = EDAC_MOD_STR,
+        .probe          = amd64_init_one_instance,
+        .remove         = __devexit_p(amd64_remove_one_instance),
+        .id_table       = amd64_pci_table,
+};
+
+static void amd64_setup_pci_device(void)
+{
+        struct mem_ctl_info *mci;
+        struct amd64_pvt *pvt;
+
+        if (amd64_ctl_pci)
+                return;
+
+        mci = mci_lookup[0];
+        if (mci) {
+
+                pvt = mci->pvt_info;
+                amd64_ctl_pci =
+                        edac_pci_create_generic_ctl(&pvt->dram_f2_ctl->dev,
+                                                    EDAC_MOD_STR);
+
+                if (!amd64_ctl_pci) {
+                        pr_warning("%s(): Unable to create PCI control\n",
+                                   __func__);
+
+                        pr_warning("%s(): PCI error report via EDAC not set\n",
+                                   __func__);
+                        }
+        }
+}
+
+static int __init amd64_edac_init(void)
+{
+        int nb, err = -ENODEV;
+
+        edac_printk(KERN_INFO, EDAC_MOD_STR, EDAC_AMD64_VERSION "\n");
+
+        opstate_init();
+
+        if (cache_k8_northbridges() < 0)
+                goto err_exit;
+
+        err = pci_register_driver(&amd64_pci_driver);
+        if (err)
+                return err;
+
+        /*
+         * At this point, the array 'pvt_lookup[]' contains pointers to alloc'd
+         * amd64_pvt structs. These will be used in the 2nd stage init function
+         * to finish initialization of the MC instances.
+         */
+        for (nb = 0; nb < num_k8_northbridges; nb++) {
+                if (!pvt_lookup[nb])
+                        continue;
+
+                err = amd64_init_2nd_stage(pvt_lookup[nb]);
+                if (err)
+                        goto err_exit;
+        }
+
+        amd64_setup_pci_device();
+
+        return 0;
+
+err_exit:
+        debugf0("'finish_setup' stage failed\n");
+        pci_unregister_driver(&amd64_pci_driver);
+
+        return err;
+}
+
+static void __exit amd64_edac_exit(void)
+{
+        if (amd64_ctl_pci)
+                edac_pci_release_generic_ctl(amd64_ctl_pci);
+
+        pci_unregister_driver(&amd64_pci_driver);
+}
+
+module_init(amd64_edac_init);
+module_exit(amd64_edac_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("SoftwareBitMaker: Doug Thompson, "
+                "Dave Peterson, Thayne Harbaugh");
+MODULE_DESCRIPTION("MC support for AMD64 memory controllers - "
+                EDAC_AMD64_VERSION);
+
+module_param(edac_op_state, int, 0444);
+MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI");
diff --git a/drivers/edac/amd64_edac.h b/drivers/edac/amd64_edac.h
new file mode 100644
index 000000000000..a159957e167b
--- /dev/null
+++ b/drivers/edac/amd64_edac.h
@@ -0,0 +1,644 @@
+/*
+ * AMD64 class Memory Controller kernel module
+ *
+ * Copyright (c) 2009 SoftwareBitMaker.
+ * Copyright (c) 2009 Advanced Micro Devices, Inc.
+ *
+ * This file may be distributed under the terms of the
+ * GNU General Public License.
+ *
+ *      Originally Written by Thayne Harbaugh
+ *
+ *      Changes by Douglas "norsk" Thompson  <dougthompson@xmission.com>:
+ *              - K8 CPU Revision D and greater support
+ *
+ *      Changes by Dave Peterson <dsp@llnl.gov> <dave_peterson@pobox.com>:
+ *              - Module largely rewritten, with new (and hopefully correct)
+ *              code for dealing with node and chip select interleaving,
+ *              various code cleanup, and bug fixes
+ *              - Added support for memory hoisting using DRAM hole address
+ *              register
+ *
+ *      Changes by Douglas "norsk" Thompson <dougthompson@xmission.com>:
+ *              -K8 Rev (1207) revision support added, required Revision
+ *              specific mini-driver code to support Rev F as well as
+ *              prior revisions
+ *
+ *      Changes by Douglas "norsk" Thompson <dougthompson@xmission.com>:
+ *              -Family 10h revision support added. New PCI Device IDs,
+ *              indicating new changes. Actual registers modified
+ *              were slight, less than the Rev E to Rev F transition
+ *              but changing the PCI Device ID was the proper thing to
+ *              do, as it provides for almost automactic family
+ *              detection. The mods to Rev F required more family
+ *              information detection.
+ *
+ *      Changes/Fixes by Borislav Petkov <borislav.petkov@amd.com>:
+ *              - misc fixes and code cleanups
+ *
+ * This module is based on the following documents
+ * (available from http://www.amd.com/):
+ *
+ *      Title:  BIOS and Kernel Developer's Guide for AMD Athlon 64 and AMD
+ *              Opteron Processors
+ *      AMD publication #: 26094
+ *`     Revision: 3.26
+ *
+ *      Title:  BIOS and Kernel Developer's Guide for AMD NPT Family 0Fh
+ *              Processors
+ *      AMD publication #: 32559
+ *      Revision: 3.00
+ *      Issue Date: May 2006
+ *
+ *      Title:  BIOS and Kernel Developer's Guide (BKDG) For AMD Family 10h
+ *              Processors
+ *      AMD publication #: 31116
+ *      Revision: 3.00
+ *      Issue Date: September 07, 2007
+ *
+ * Sections in the first 2 documents are no longer in sync with each other.
+ * The Family 10h BKDG was totally re-written from scratch with a new
+ * presentation model.
+ * Therefore, comments that refer to a Document section might be off.
+ */
+
+#include <linux/module.h>
+#include <linux/ctype.h>
+#include <linux/init.h>
+#include <linux/pci.h>
+#include <linux/pci_ids.h>
+#include <linux/slab.h>
+#include <linux/mmzone.h>
+#include <linux/edac.h>
+#include <asm/msr.h>
+#include "edac_core.h"
+
+#define amd64_printk(level, fmt, arg...) \
+        edac_printk(level, "amd64", fmt, ##arg)
+
+#define amd64_mc_printk(mci, level, fmt, arg...) \
+        edac_mc_chipset_printk(mci, level, "amd64", fmt, ##arg)
+
+/*
+ * Throughout the comments in this code, the following terms are used:
+ *
+ *      SysAddr, DramAddr, and InputAddr
+ *
+ *  These terms come directly from the amd64 documentation
+ * (AMD publication #26094).  They are defined as follows:
+ *
+ *     SysAddr:
+ *         This is a physical address generated by a CPU core or a device
+ *         doing DMA.  If generated by a CPU core, a SysAddr is the result of
+ *         a virtual to physical address translation by the CPU core's address
+ *         translation mechanism (MMU).
+ *
+ *     DramAddr:
+ *         A DramAddr is derived from a SysAddr by subtracting an offset that
+ *         depends on which node the SysAddr maps to and whether the SysAddr
+ *         is within a range affected by memory hoisting.  The DRAM Base
+ *         (section 3.4.4.1) and DRAM Limit (section 3.4.4.2) registers
+ *         determine which node a SysAddr maps to.
+ *
+ *         If the DRAM Hole Address Register (DHAR) is enabled and the SysAddr
+ *         is within the range of addresses specified by this register, then
+ *         a value x from the DHAR is subtracted from the SysAddr to produce a
+ *         DramAddr.  Here, x represents the base address for the node that
+ *         the SysAddr maps to plus an offset due to memory hoisting.  See
+ *         section 3.4.8 and the comments in amd64_get_dram_hole_info() and
+ *         sys_addr_to_dram_addr() below for more information.
+ *
+ *         If the SysAddr is not affected by the DHAR then a value y is
+ *         subtracted from the SysAddr to produce a DramAddr.  Here, y is the
+ *         base address for the node that the SysAddr maps to.  See section
+ *         3.4.4 and the comments in sys_addr_to_dram_addr() below for more
+ *         information.
+ *
+ *     InputAddr:
+ *         A DramAddr is translated to an InputAddr before being passed to the
+ *         memory controller for the node that the DramAddr is associated
+ *         with.  The memory controller then maps the InputAddr to a csrow.
+ *         If node interleaving is not in use, then the InputAddr has the same
+ *         value as the DramAddr.  Otherwise, the InputAddr is produced by
+ *         discarding the bits used for node interleaving from the DramAddr.
+ *         See section 3.4.4 for more information.
+ *
+ *         The memory controller for a given node uses its DRAM CS Base and
+ *         DRAM CS Mask registers to map an InputAddr to a csrow.  See
+ *         sections 3.5.4 and 3.5.5 for more information.
+ */
+
+#define EDAC_AMD64_VERSION              " Ver: 3.2.0 " __DATE__
+#define EDAC_MOD_STR                    "amd64_edac"
+
+/* Extended Model from CPUID, for CPU Revision numbers */
+#define OPTERON_CPU_LE_REV_C            0
+#define OPTERON_CPU_REV_D               1
+#define OPTERON_CPU_REV_E               2
+
+/* NPT processors have the following Extended Models */
+#define OPTERON_CPU_REV_F               4
+#define OPTERON_CPU_REV_FA              5
+
+/* Hardware limit on ChipSelect rows per MC and processors per system */
+#define CHIPSELECT_COUNT                8
+#define DRAM_REG_COUNT                  8
+
+
+/*
+ * PCI-defined configuration space registers
+ */
+
+
+/*
+ * Function 1 - Address Map
+ */
+#define K8_DRAM_BASE_LOW                0x40
+#define K8_DRAM_LIMIT_LOW               0x44
+#define K8_DHAR                         0xf0
+
+#define DHAR_VALID                      BIT(0)
+#define F10_DRAM_MEM_HOIST_VALID        BIT(1)
+
+#define DHAR_BASE_MASK                  0xff000000
+#define dhar_base(dhar)                 (dhar & DHAR_BASE_MASK)
+
+#define K8_DHAR_OFFSET_MASK             0x0000ff00
+#define k8_dhar_offset(dhar)            ((dhar & K8_DHAR_OFFSET_MASK) << 16)
+
+#define F10_DHAR_OFFSET_MASK            0x0000ff80
+                                        /* NOTE: Extra mask bit vs K8 */
+#define f10_dhar_offset(dhar)           ((dhar & F10_DHAR_OFFSET_MASK) << 16)
+
+
+/* F10 High BASE/LIMIT registers */
+#define F10_DRAM_BASE_HIGH              0x140
+#define F10_DRAM_LIMIT_HIGH             0x144
+
+
+/*
+ * Function 2 - DRAM controller
+ */
+#define K8_DCSB0                        0x40
+#define F10_DCSB1                       0x140
+
+#define K8_DCSB_CS_ENABLE               BIT(0)
+#define K8_DCSB_NPT_SPARE               BIT(1)
+#define K8_DCSB_NPT_TESTFAIL            BIT(2)
+
+/*
+ * REV E: select [31:21] and [15:9] from DCSB and the shift amount to form
+ * the address
+ */
+#define REV_E_DCSB_BASE_BITS            (0xFFE0FE00ULL)
+#define REV_E_DCS_SHIFT                 4
+#define REV_E_DCSM_COUNT                8
+
+#define REV_F_F1Xh_DCSB_BASE_BITS       (0x1FF83FE0ULL)
+#define REV_F_F1Xh_DCS_SHIFT            8
+
+/*
+ * REV F and later: selects [28:19] and [13:5] from DCSB and the shift amount
+ * to form the address
+ */
+#define REV_F_DCSB_BASE_BITS            (0x1FF83FE0ULL)
+#define REV_F_DCS_SHIFT                 8
+#define REV_F_DCSM_COUNT                4
+#define F10_DCSM_COUNT                  4
+#define F11_DCSM_COUNT                  2
+
+/* DRAM CS Mask Registers */
+#define K8_DCSM0                        0x60
+#define F10_DCSM1                       0x160
+
+/* REV E: select [29:21] and [15:9] from DCSM */
+#define REV_E_DCSM_MASK_BITS            0x3FE0FE00
+
+/* unused bits [24:20] and [12:0] */
+#define REV_E_DCS_NOTUSED_BITS          0x01F01FFF
+
+/* REV F and later: select [28:19] and [13:5] from DCSM */
+#define REV_F_F1Xh_DCSM_MASK_BITS       0x1FF83FE0
+
+/* unused bits [26:22] and [12:0] */
+#define REV_F_F1Xh_DCS_NOTUSED_BITS     0x07C01FFF
+
+#define DBAM0                           0x80
+#define DBAM1                           0x180
+
+/* Extract the DIMM 'type' on the i'th DIMM from the DBAM reg value passed */
+#define DBAM_DIMM(i, reg)               ((((reg) >> (4*i))) & 0xF)
+
+#define DBAM_MAX_VALUE                  11
+
+
+#define F10_DCLR_0                      0x90
+#define F10_DCLR_1                      0x190
+#define REVE_WIDTH_128                  BIT(16)
+#define F10_WIDTH_128                   BIT(11)
+
+
+#define F10_DCHR_0                      0x94
+#define F10_DCHR_1                      0x194
+
+#define F10_DCHR_FOUR_RANK_DIMM         BIT(18)
+#define F10_DCHR_Ddr3Mode               BIT(8)
+#define F10_DCHR_MblMode                BIT(6)
+
+
+#define F10_DCTL_SEL_LOW                0x110
+
+#define dct_sel_baseaddr(pvt)    \
+        ((pvt->dram_ctl_select_low) & 0xFFFFF800)
+
+#define dct_sel_interleave_addr(pvt)    \
+        (((pvt->dram_ctl_select_low) >> 6) & 0x3)
+
+enum {
+        F10_DCTL_SEL_LOW_DctSelHiRngEn  = BIT(0),
+        F10_DCTL_SEL_LOW_DctSelIntLvEn  = BIT(2),
+        F10_DCTL_SEL_LOW_DctGangEn      = BIT(4),
+        F10_DCTL_SEL_LOW_DctDatIntLv    = BIT(5),
+        F10_DCTL_SEL_LOW_DramEnable     = BIT(8),
+        F10_DCTL_SEL_LOW_MemCleared     = BIT(10),
+};
+
+#define    dct_high_range_enabled(pvt)    \
+        (pvt->dram_ctl_select_low & F10_DCTL_SEL_LOW_DctSelHiRngEn)
+
+#define dct_interleave_enabled(pvt)        \
+        (pvt->dram_ctl_select_low & F10_DCTL_SEL_LOW_DctSelIntLvEn)
+
+#define dct_ganging_enabled(pvt)        \
+        (pvt->dram_ctl_select_low & F10_DCTL_SEL_LOW_DctGangEn)
+
+#define dct_data_intlv_enabled(pvt)    \
+        (pvt->dram_ctl_select_low & F10_DCTL_SEL_LOW_DctDatIntLv)
+
+#define dct_dram_enabled(pvt)    \
+        (pvt->dram_ctl_select_low & F10_DCTL_SEL_LOW_DramEnable)
+
+#define dct_memory_cleared(pvt)    \
+        (pvt->dram_ctl_select_low & F10_DCTL_SEL_LOW_MemCleared)
+
+
+#define F10_DCTL_SEL_HIGH               0x114
+
+
+/*
+ * Function 3 - Misc Control
+ */
+#define K8_NBCTL                        0x40
+
+/* Correctable ECC error reporting enable */
+#define K8_NBCTL_CECCEn                 BIT(0)
+
+/* UnCorrectable ECC error reporting enable */
+#define K8_NBCTL_UECCEn                 BIT(1)
+
+#define K8_NBCFG                        0x44
+#define K8_NBCFG_CHIPKILL               BIT(23)
+#define K8_NBCFG_ECC_ENABLE             BIT(22)
+
+#define K8_NBSL                         0x48
+
+
+#define EXTRACT_HIGH_SYNDROME(x)        (((x) >> 24) & 0xff)
+#define EXTRACT_EXT_ERROR_CODE(x)       (((x) >> 16) & 0x1f)
+
+/* Family F10h: Normalized Extended Error Codes */
+#define F10_NBSL_EXT_ERR_RES            0x0
+#define F10_NBSL_EXT_ERR_CRC            0x1
+#define F10_NBSL_EXT_ERR_SYNC           0x2
+#define F10_NBSL_EXT_ERR_MST            0x3
+#define F10_NBSL_EXT_ERR_TGT            0x4
+#define F10_NBSL_EXT_ERR_GART           0x5
+#define F10_NBSL_EXT_ERR_RMW            0x6
+#define F10_NBSL_EXT_ERR_WDT            0x7
+#define F10_NBSL_EXT_ERR_ECC            0x8
+#define F10_NBSL_EXT_ERR_DEV            0x9
+#define F10_NBSL_EXT_ERR_LINK_DATA      0xA
+
+/* Next two are overloaded values */
+#define F10_NBSL_EXT_ERR_LINK_PROTO     0xB
+#define F10_NBSL_EXT_ERR_L3_PROTO       0xB
+
+#define F10_NBSL_EXT_ERR_NB_ARRAY       0xC
+#define F10_NBSL_EXT_ERR_DRAM_PARITY    0xD
+#define F10_NBSL_EXT_ERR_LINK_RETRY     0xE
+
+/* Next two are overloaded values */
+#define F10_NBSL_EXT_ERR_GART_WALK      0xF
+#define F10_NBSL_EXT_ERR_DEV_WALK       0xF
+
+/* 0x10 to 0x1B: Reserved */
+#define F10_NBSL_EXT_ERR_L3_DATA        0x1C
+#define F10_NBSL_EXT_ERR_L3_TAG         0x1D
+#define F10_NBSL_EXT_ERR_L3_LRU         0x1E
+
+/* K8: Normalized Extended Error Codes */
+#define K8_NBSL_EXT_ERR_ECC             0x0
+#define K8_NBSL_EXT_ERR_CRC             0x1
+#define K8_NBSL_EXT_ERR_SYNC            0x2
+#define K8_NBSL_EXT_ERR_MST             0x3
+#define K8_NBSL_EXT_ERR_TGT             0x4
+#define K8_NBSL_EXT_ERR_GART            0x5
+#define K8_NBSL_EXT_ERR_RMW             0x6
+#define K8_NBSL_EXT_ERR_WDT             0x7
+#define K8_NBSL_EXT_ERR_CHIPKILL_ECC    0x8
+#define K8_NBSL_EXT_ERR_DRAM_PARITY     0xD
+
+#define EXTRACT_ERROR_CODE(x)           ((x) & 0xffff)
+#define TEST_TLB_ERROR(x)               (((x) & 0xFFF0) == 0x0010)
+#define TEST_MEM_ERROR(x)               (((x) & 0xFF00) == 0x0100)
+#define TEST_BUS_ERROR(x)               (((x) & 0xF800) == 0x0800)
+#define EXTRACT_TT_CODE(x)              (((x) >> 2) & 0x3)
+#define EXTRACT_II_CODE(x)              (((x) >> 2) & 0x3)
+#define EXTRACT_LL_CODE(x)              (((x) >> 0) & 0x3)
+#define EXTRACT_RRRR_CODE(x)            (((x) >> 4) & 0xf)
+#define EXTRACT_TO_CODE(x)              (((x) >> 8) & 0x1)
+#define EXTRACT_PP_CODE(x)              (((x) >> 9) & 0x3)
+
+/*
+ * The following are for BUS type errors AFTER values have been normalized by
+ * shifting right
+ */
+#define K8_NBSL_PP_SRC                  0x0
+#define K8_NBSL_PP_RES                  0x1
+#define K8_NBSL_PP_OBS                  0x2
+#define K8_NBSL_PP_GENERIC              0x3
+
+
+#define K8_NBSH                         0x4C
+
+#define K8_NBSH_VALID_BIT               BIT(31)
+#define K8_NBSH_OVERFLOW                BIT(30)
+#define K8_NBSH_UNCORRECTED_ERR         BIT(29)
+#define K8_NBSH_ERR_ENABLE              BIT(28)
+#define K8_NBSH_MISC_ERR_VALID          BIT(27)
+#define K8_NBSH_VALID_ERROR_ADDR        BIT(26)
+#define K8_NBSH_PCC                     BIT(25)
+#define K8_NBSH_CECC                    BIT(14)
+#define K8_NBSH_UECC                    BIT(13)
+#define K8_NBSH_ERR_SCRUBER             BIT(8)
+#define K8_NBSH_CORE3                   BIT(3)
+#define K8_NBSH_CORE2                   BIT(2)
+#define K8_NBSH_CORE1                   BIT(1)
+#define K8_NBSH_CORE0                   BIT(0)
+
+#define EXTRACT_LDT_LINK(x)             (((x) >> 4) & 0x7)
+#define EXTRACT_ERR_CPU_MAP(x)          ((x) & 0xF)
+#define EXTRACT_LOW_SYNDROME(x)         (((x) >> 15) & 0xff)
+
+
+#define K8_NBEAL                        0x50
+#define K8_NBEAH                        0x54
+#define K8_SCRCTRL                      0x58
+
+#define F10_NB_CFG_LOW                  0x88
+#define F10_NB_CFG_LOW_ENABLE_EXT_CFG   BIT(14)
+
+#define F10_NB_CFG_HIGH                 0x8C
+
+#define F10_ONLINE_SPARE                0xB0
+#define F10_ONLINE_SPARE_SWAPDONE0(x)   ((x) & BIT(1))
+#define F10_ONLINE_SPARE_SWAPDONE1(x)   ((x) & BIT(3))
+#define F10_ONLINE_SPARE_BADDRAM_CS0(x) (((x) >> 4) & 0x00000007)
+#define F10_ONLINE_SPARE_BADDRAM_CS1(x) (((x) >> 8) & 0x00000007)
+
+#define F10_NB_ARRAY_ADDR               0xB8
+
+#define F10_NB_ARRAY_DRAM_ECC           0x80000000
+
+/* Bits [2:1] are used to select 16-byte section within a 64-byte cacheline  */
+#define SET_NB_ARRAY_ADDRESS(section)   (((section) & 0x3) << 1)
+
+#define F10_NB_ARRAY_DATA               0xBC
+
+#define SET_NB_DRAM_INJECTION_WRITE(word, bits)  \
+                                        (BIT(((word) & 0xF) + 20) | \
+                                        BIT(17) |  \
+                                        ((bits) & 0xF))
+
+#define SET_NB_DRAM_INJECTION_READ(word, bits)  \
+                                        (BIT(((word) & 0xF) + 20) | \
+                                        BIT(16) |  \
+                                        ((bits) & 0xF))
+
+#define K8_NBCAP                        0xE8
+#define K8_NBCAP_CORES                  (BIT(12)|BIT(13))
+#define K8_NBCAP_CHIPKILL               BIT(4)
+#define K8_NBCAP_SECDED                 BIT(3)
+#define K8_NBCAP_8_NODE                 BIT(2)
+#define K8_NBCAP_DUAL_NODE              BIT(1)
+#define K8_NBCAP_DCT_DUAL               BIT(0)
+
+/*
+ * MSR Regs
+ */
+#define K8_MSR_MCGCTL                   0x017b
+#define K8_MSR_MCGCTL_NBE               BIT(4)
+
+#define K8_MSR_MC4CTL                   0x0410
+#define K8_MSR_MC4STAT                  0x0411
+#define K8_MSR_MC4ADDR                  0x0412
+
+/* AMD sets the first MC device at device ID 0x18. */
+static inline int get_mc_node_id_from_pdev(struct pci_dev *pdev)
+{
+        return PCI_SLOT(pdev->devfn) - 0x18;
+}
+
+enum amd64_chipset_families {
+        K8_CPUS = 0,
+        F10_CPUS,
+        F11_CPUS,
+};
+
+/*
+ * Structure to hold:
+ *
+ * 1) dynamically read status and error address HW registers
+ * 2) sysfs entered values
+ * 3) MCE values
+ *
+ * Depends on entry into the modules
+ */
+struct amd64_error_info_regs {
+        u32 nbcfg;
+        u32 nbsh;
+        u32 nbsl;
+        u32 nbeah;
+        u32 nbeal;
+};
+
+/* Error injection control structure */
+struct error_injection {
+        u32     section;
+        u32     word;
+        u32     bit_map;
+};
+
+struct amd64_pvt {
+        /* pci_device handles which we utilize */
+        struct pci_dev *addr_f1_ctl;
+        struct pci_dev *dram_f2_ctl;
+        struct pci_dev *misc_f3_ctl;
+
+        int mc_node_id;         /* MC index of this MC node */
+        int ext_model;          /* extended model value of this node */
+
+        struct low_ops *ops;    /* pointer to per PCI Device ID func table */
+
+        int channel_count;
+
+        /* Raw registers */
+        u32 dclr0;              /* DRAM Configuration Low DCT0 reg */
+        u32 dclr1;              /* DRAM Configuration Low DCT1 reg */
+        u32 dchr0;              /* DRAM Configuration High DCT0 reg */
+        u32 dchr1;              /* DRAM Configuration High DCT1 reg */
+        u32 nbcap;              /* North Bridge Capabilities */
+        u32 nbcfg;              /* F10 North Bridge Configuration */
+        u32 ext_nbcfg;          /* Extended F10 North Bridge Configuration */
+        u32 dhar;               /* DRAM Hoist reg */
+        u32 dbam0;              /* DRAM Base Address Mapping reg for DCT0 */
+        u32 dbam1;              /* DRAM Base Address Mapping reg for DCT1 */
+
+        /* DRAM CS Base Address Registers F2x[1,0][5C:40] */
+        u32 dcsb0[CHIPSELECT_COUNT];
+        u32 dcsb1[CHIPSELECT_COUNT];
+
+        /* DRAM CS Mask Registers F2x[1,0][6C:60] */
+        u32 dcsm0[CHIPSELECT_COUNT];
+        u32 dcsm1[CHIPSELECT_COUNT];
+
+        /*
+         * Decoded parts of DRAM BASE and LIMIT Registers
+         * F1x[78,70,68,60,58,50,48,40]
+         */
+        u64 dram_base[DRAM_REG_COUNT];
+        u64 dram_limit[DRAM_REG_COUNT];
+        u8  dram_IntlvSel[DRAM_REG_COUNT];
+        u8  dram_IntlvEn[DRAM_REG_COUNT];
+        u8  dram_DstNode[DRAM_REG_COUNT];
+        u8  dram_rw_en[DRAM_REG_COUNT];
+
+        /*
+         * The following fields are set at (load) run time, after CPU revision
+         * has been determined, since the dct_base and dct_mask registers vary
+         * based on revision
+         */
+        u32 dcsb_base;          /* DCSB base bits */
+        u32 dcsm_mask;          /* DCSM mask bits */
+        u32 num_dcsm;           /* Number of DCSM registers */
+        u32 dcs_mask_notused;   /* DCSM notused mask bits */
+        u32 dcs_shift;          /* DCSB and DCSM shift value */
+
+        u64 top_mem;            /* top of memory below 4GB */
+        u64 top_mem2;           /* top of memory above 4GB */
+
+        u32 dram_ctl_select_low;        /* DRAM Controller Select Low Reg */
+        u32 dram_ctl_select_high;       /* DRAM Controller Select High Reg */
+        u32 online_spare;               /* On-Line spare Reg */
+
+        /* temp storage for when input is received from sysfs */
+        struct amd64_error_info_regs ctl_error_info;
+
+        /* place to store error injection parameters prior to issue */
+        struct error_injection injection;
+
+        /* Save old hw registers' values before we modified them */
+        u32 nbctl_mcgctl_saved;         /* When true, following 2 are valid */
+        u32 old_nbctl;
+        unsigned long old_mcgctl;       /* per core on this node */
+
+        /* MC Type Index value: socket F vs Family 10h */
+        u32 mc_type_index;
+
+        /* misc settings */
+        struct flags {
+                unsigned long cf8_extcfg:1;
+        } flags;
+};
+
+struct scrubrate {
+       u32 scrubval;           /* bit pattern for scrub rate */
+       u32 bandwidth;          /* bandwidth consumed (bytes/sec) */
+};
+
+extern struct scrubrate scrubrates[23];
+extern u32 revf_quad_ddr2_shift[16];
+extern const char *tt_msgs[4];
+extern const char *ll_msgs[4];
+extern const char *rrrr_msgs[16];
+extern const char *to_msgs[2];
+extern const char *pp_msgs[4];
+extern const char *ii_msgs[4];
+extern const char *ext_msgs[32];
+extern const char *htlink_msgs[8];
+
+#ifdef CONFIG_EDAC_DEBUG
+#define NUM_DBG_ATTRS 9
+#else
+#define NUM_DBG_ATTRS 0
+#endif
+
+#ifdef CONFIG_EDAC_AMD64_ERROR_INJECTION
+#define NUM_INJ_ATTRS 5
+#else
+#define NUM_INJ_ATTRS 0
+#endif
+
+extern struct mcidev_sysfs_attribute amd64_dbg_attrs[NUM_DBG_ATTRS],
+                                     amd64_inj_attrs[NUM_INJ_ATTRS];
+
+/*
+ * Each of the PCI Device IDs types have their own set of hardware accessor
+ * functions and per device encoding/decoding logic.
+ */
+struct low_ops {
+        int (*probe_valid_hardware)(struct amd64_pvt *pvt);
+        int (*early_channel_count)(struct amd64_pvt *pvt);
+
+        u64 (*get_error_address)(struct mem_ctl_info *mci,
+                        struct amd64_error_info_regs *info);
+        void (*read_dram_base_limit)(struct amd64_pvt *pvt, int dram);
+        void (*read_dram_ctl_register)(struct amd64_pvt *pvt);
+        void (*map_sysaddr_to_csrow)(struct mem_ctl_info *mci,
+                                        struct amd64_error_info_regs *info,
+                                        u64 SystemAddr);
+        int (*dbam_map_to_pages)(struct amd64_pvt *pvt, int dram_map);
+};
+
+struct amd64_family_type {
+        const char *ctl_name;
+        u16 addr_f1_ctl;
+        u16 misc_f3_ctl;
+        struct low_ops ops;
+};
+
+static struct amd64_family_type amd64_family_types[];
+
+static inline const char *get_amd_family_name(int index)
+{
+        return amd64_family_types[index].ctl_name;
+}
+
+static inline struct low_ops *family_ops(int index)
+{
+        return &amd64_family_types[index].ops;
+}
+
+/*
+ * For future CPU versions, verify the following as new 'slow' rates appear and
+ * modify the necessary skip values for the supported CPU.
+ */
+#define K8_MIN_SCRUB_RATE_BITS  0x0
+#define F10_MIN_SCRUB_RATE_BITS 0x5
+#define F11_MIN_SCRUB_RATE_BITS 0x6
+
+int amd64_process_error_info(struct mem_ctl_info *mci,
+                             struct amd64_error_info_regs *info,
+                             int handle_errors);
+int amd64_get_dram_hole_info(struct mem_ctl_info *mci, u64 *hole_base,
+                             u64 *hole_offset, u64 *hole_size);
diff --git a/drivers/edac/amd64_edac_dbg.c b/drivers/edac/amd64_edac_dbg.c
new file mode 100644
index 000000000000..0a41b248a4ad
--- /dev/null
+++ b/drivers/edac/amd64_edac_dbg.c
@@ -0,0 +1,255 @@
+#include "amd64_edac.h"
+
+/*
+ * accept a hex value and store it into the virtual error register file, field:
+ * nbeal and nbeah. Assume virtual error values have already been set for: NBSL,
+ * NBSH and NBCFG. Then proceed to map the error values to a MC, CSROW and
+ * CHANNEL
+ */
+static ssize_t amd64_nbea_store(struct mem_ctl_info *mci, const char *data,
+                                size_t count)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        unsigned long long value;
+        int ret = 0;
+
+        ret = strict_strtoull(data, 16, &value);
+        if (ret != -EINVAL) {
+                debugf0("received NBEA= 0x%llx\n", value);
+
+                /* place the value into the virtual error packet */
+                pvt->ctl_error_info.nbeal = (u32) value;
+                value >>= 32;
+                pvt->ctl_error_info.nbeah = (u32) value;
+
+                /* Process the Mapping request */
+                /* TODO: Add race prevention */
+                amd64_process_error_info(mci, &pvt->ctl_error_info, 1);
+
+                return count;
+        }
+        return ret;
+}
+
+/* display back what the last NBEA (MCA NB Address (MC4_ADDR)) was written */
+static ssize_t amd64_nbea_show(struct mem_ctl_info *mci, char *data)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        u64 value;
+
+        value = pvt->ctl_error_info.nbeah;
+        value <<= 32;
+        value |= pvt->ctl_error_info.nbeal;
+
+        return sprintf(data, "%llx\n", value);
+}
+
+/* store the NBSL (MCA NB Status Low (MC4_STATUS)) value user desires */
+static ssize_t amd64_nbsl_store(struct mem_ctl_info *mci, const char *data,
+                                size_t count)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        unsigned long value;
+        int ret = 0;
+
+        ret = strict_strtoul(data, 16, &value);
+        if (ret != -EINVAL) {
+                debugf0("received NBSL= 0x%lx\n", value);
+
+                pvt->ctl_error_info.nbsl = (u32) value;
+
+                return count;
+        }
+        return ret;
+}
+
+/* display back what the last NBSL value written */
+static ssize_t amd64_nbsl_show(struct mem_ctl_info *mci, char *data)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        u32 value;
+
+        value = pvt->ctl_error_info.nbsl;
+
+        return sprintf(data, "%x\n", value);
+}
+
+/* store the NBSH (MCA NB Status High) value user desires */
+static ssize_t amd64_nbsh_store(struct mem_ctl_info *mci, const char *data,
+                                size_t count)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        unsigned long value;
+        int ret = 0;
+
+        ret = strict_strtoul(data, 16, &value);
+        if (ret != -EINVAL) {
+                debugf0("received NBSH= 0x%lx\n", value);
+
+                pvt->ctl_error_info.nbsh = (u32) value;
+
+                return count;
+        }
+        return ret;
+}
+
+/* display back what the last NBSH value written */
+static ssize_t amd64_nbsh_show(struct mem_ctl_info *mci, char *data)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        u32 value;
+
+        value = pvt->ctl_error_info.nbsh;
+
+        return sprintf(data, "%x\n", value);
+}
+
+/* accept and store the NBCFG (MCA NB Configuration) value user desires */
+static ssize_t amd64_nbcfg_store(struct mem_ctl_info *mci,
+                                        const char *data, size_t count)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        unsigned long value;
+        int ret = 0;
+
+        ret = strict_strtoul(data, 16, &value);
+        if (ret != -EINVAL) {
+                debugf0("received NBCFG= 0x%lx\n", value);
+
+                pvt->ctl_error_info.nbcfg = (u32) value;
+
+                return count;
+        }
+        return ret;
+}
+
+/* various show routines for the controls of a MCI */
+static ssize_t amd64_nbcfg_show(struct mem_ctl_info *mci, char *data)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+
+        return sprintf(data, "%x\n", pvt->ctl_error_info.nbcfg);
+}
+
+
+static ssize_t amd64_dhar_show(struct mem_ctl_info *mci, char *data)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+
+        return sprintf(data, "%x\n", pvt->dhar);
+}
+
+
+static ssize_t amd64_dbam_show(struct mem_ctl_info *mci, char *data)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+
+        return sprintf(data, "%x\n", pvt->dbam0);
+}
+
+
+static ssize_t amd64_topmem_show(struct mem_ctl_info *mci, char *data)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+
+        return sprintf(data, "%llx\n", pvt->top_mem);
+}
+
+
+static ssize_t amd64_topmem2_show(struct mem_ctl_info *mci, char *data)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+
+        return sprintf(data, "%llx\n", pvt->top_mem2);
+}
+
+static ssize_t amd64_hole_show(struct mem_ctl_info *mci, char *data)
+{
+        u64 hole_base = 0;
+        u64 hole_offset = 0;
+        u64 hole_size = 0;
+
+        amd64_get_dram_hole_info(mci, &hole_base, &hole_offset, &hole_size);
+
+        return sprintf(data, "%llx %llx %llx\n", hole_base, hole_offset,
+                                                 hole_size);
+}
+
+/*
+ * update NUM_DBG_ATTRS in case you add new members
+ */
+struct mcidev_sysfs_attribute amd64_dbg_attrs[] = {
+
+        {
+                .attr = {
+                        .name = "nbea_ctl",
+                        .mode = (S_IRUGO | S_IWUSR)
+                },
+                .show = amd64_nbea_show,
+                .store = amd64_nbea_store,
+        },
+        {
+                .attr = {
+                        .name = "nbsl_ctl",
+                        .mode = (S_IRUGO | S_IWUSR)
+                },
+                .show = amd64_nbsl_show,
+                .store = amd64_nbsl_store,
+        },
+        {
+                .attr = {
+                        .name = "nbsh_ctl",
+                        .mode = (S_IRUGO | S_IWUSR)
+                },
+                .show = amd64_nbsh_show,
+                .store = amd64_nbsh_store,
+        },
+        {
+                .attr = {
+                        .name = "nbcfg_ctl",
+                        .mode = (S_IRUGO | S_IWUSR)
+                },
+                .show = amd64_nbcfg_show,
+                .store = amd64_nbcfg_store,
+        },
+        {
+                .attr = {
+                        .name = "dhar",
+                        .mode = (S_IRUGO)
+                },
+                .show = amd64_dhar_show,
+                .store = NULL,
+        },
+        {
+                .attr = {
+                        .name = "dbam",
+                        .mode = (S_IRUGO)
+                },
+                .show = amd64_dbam_show,
+                .store = NULL,
+        },
+        {
+                .attr = {
+                        .name = "topmem",
+                        .mode = (S_IRUGO)
+                },
+                .show = amd64_topmem_show,
+                .store = NULL,
+        },
+        {
+                .attr = {
+                        .name = "topmem2",
+                        .mode = (S_IRUGO)
+                },
+                .show = amd64_topmem2_show,
+                .store = NULL,
+        },
+        {
+                .attr = {
+                        .name = "dram_hole",
+                        .mode = (S_IRUGO)
+                },
+                .show = amd64_hole_show,
+                .store = NULL,
+        },
+};
diff --git a/drivers/edac/amd64_edac_err_types.c b/drivers/edac/amd64_edac_err_types.c
new file mode 100644
index 000000000000..f212ff12a9d8
--- /dev/null
+++ b/drivers/edac/amd64_edac_err_types.c
@@ -0,0 +1,161 @@
+#include "amd64_edac.h"
+
+/*
+ * See F2x80 for K8 and F2x[1,0]80 for Fam10 and later. The table below is only
+ * for DDR2 DRAM mapping.
+ */
+u32 revf_quad_ddr2_shift[] = {
+        0,      /* 0000b NULL DIMM (128mb) */
+        28,     /* 0001b 256mb */
+        29,     /* 0010b 512mb */
+        29,     /* 0011b 512mb */
+        29,     /* 0100b 512mb */
+        30,     /* 0101b 1gb */
+        30,     /* 0110b 1gb */
+        31,     /* 0111b 2gb */
+        31,     /* 1000b 2gb */
+        32,     /* 1001b 4gb */
+        32,     /* 1010b 4gb */
+        33,     /* 1011b 8gb */
+        0,      /* 1100b future */
+        0,      /* 1101b future */
+        0,      /* 1110b future */
+        0       /* 1111b future */
+};
+
+/*
+ * Valid scrub rates for the K8 hardware memory scrubber. We map the scrubbing
+ * bandwidth to a valid bit pattern. The 'set' operation finds the 'matching-
+ * or higher value'.
+ *
+ *FIXME: Produce a better mapping/linearisation.
+ */
+
+struct scrubrate scrubrates[] = {
+        { 0x01, 1600000000UL},
+        { 0x02, 800000000UL},
+        { 0x03, 400000000UL},
+        { 0x04, 200000000UL},
+        { 0x05, 100000000UL},
+        { 0x06, 50000000UL},
+        { 0x07, 25000000UL},
+        { 0x08, 12284069UL},
+        { 0x09, 6274509UL},
+        { 0x0A, 3121951UL},
+        { 0x0B, 1560975UL},
+        { 0x0C, 781440UL},
+        { 0x0D, 390720UL},
+        { 0x0E, 195300UL},
+        { 0x0F, 97650UL},
+        { 0x10, 48854UL},
+        { 0x11, 24427UL},
+        { 0x12, 12213UL},
+        { 0x13, 6101UL},
+        { 0x14, 3051UL},
+        { 0x15, 1523UL},
+        { 0x16, 761UL},
+        { 0x00, 0UL},        /* scrubbing off */
+};
+
+/*
+ * string representation for the different MCA reported error types, see F3x48
+ * or MSR0000_0411.
+ */
+const char *tt_msgs[] = {        /* transaction type */
+        "instruction",
+        "data",
+        "generic",
+        "reserved"
+};
+
+const char *ll_msgs[] = {       /* cache level */
+        "L0",
+        "L1",
+        "L2",
+        "L3/generic"
+};
+
+const char *rrrr_msgs[] = {
+        "generic",
+        "generic read",
+        "generic write",
+        "data read",
+        "data write",
+        "inst fetch",
+        "prefetch",
+        "evict",
+        "snoop",
+        "reserved RRRR= 9",
+        "reserved RRRR= 10",
+        "reserved RRRR= 11",
+        "reserved RRRR= 12",
+        "reserved RRRR= 13",
+        "reserved RRRR= 14",
+        "reserved RRRR= 15"
+};
+
+const char *pp_msgs[] = {       /* participating processor */
+        "local node originated (SRC)",
+        "local node responded to request (RES)",
+        "local node observed as 3rd party (OBS)",
+        "generic"
+};
+
+const char *to_msgs[] = {
+        "no timeout",
+        "timed out"
+};
+
+const char *ii_msgs[] = {       /* memory or i/o */
+        "mem access",
+        "reserved",
+        "i/o access",
+        "generic"
+};
+
+/* Map the 5 bits of Extended Error code to the string table. */
+const char *ext_msgs[] = {      /* extended error */
+        "K8 ECC error/F10 reserved",    /* 0_0000b */
+        "CRC error",                    /* 0_0001b */
+        "sync error",                   /* 0_0010b */
+        "mst abort",                    /* 0_0011b */
+        "tgt abort",                    /* 0_0100b */
+        "GART error",                   /* 0_0101b */
+        "RMW error",                    /* 0_0110b */
+        "Wdog timer error",             /* 0_0111b */
+        "F10-ECC/K8-Chipkill error",    /* 0_1000b */
+        "DEV Error",                    /* 0_1001b */
+        "Link Data error",              /* 0_1010b */
+        "Link or L3 Protocol error",    /* 0_1011b */
+        "NB Array error",               /* 0_1100b */
+        "DRAM Parity error",            /* 0_1101b */
+        "Link Retry/GART Table Walk/DEV Table Walk error", /* 0_1110b */
+        "Res 0x0ff error",              /* 0_1111b */
+        "Res 0x100 error",              /* 1_0000b */
+        "Res 0x101 error",              /* 1_0001b */
+        "Res 0x102 error",              /* 1_0010b */
+        "Res 0x103 error",              /* 1_0011b */
+        "Res 0x104 error",              /* 1_0100b */
+        "Res 0x105 error",              /* 1_0101b */
+        "Res 0x106 error",              /* 1_0110b */
+        "Res 0x107 error",              /* 1_0111b */
+        "Res 0x108 error",              /* 1_1000b */
+        "Res 0x109 error",              /* 1_1001b */
+        "Res 0x10A error",              /* 1_1010b */
+        "Res 0x10B error",              /* 1_1011b */
+        "L3 Cache Data error",          /* 1_1100b */
+        "L3 CacheTag error",            /* 1_1101b */
+        "L3 Cache LRU error",           /* 1_1110b */
+        "Res 0x1FF error"               /* 1_1111b */
+};
+
+const char *htlink_msgs[] = {
+        "none",
+        "1",
+        "2",
+        "1 2",
+        "3",
+        "1 3",
+        "2 3",
+        "1 2 3"
+};
diff --git a/drivers/edac/amd64_edac_inj.c b/drivers/edac/amd64_edac_inj.c
new file mode 100644
index 000000000000..d3675b76b3a7
--- /dev/null
+++ b/drivers/edac/amd64_edac_inj.c
@@ -0,0 +1,185 @@
+#include "amd64_edac.h"
+
+/*
+ * store error injection section value which refers to one of 4 16-byte sections
+ * within a 64-byte cacheline
+ *
+ * range: 0..3
+ */
+static ssize_t amd64_inject_section_store(struct mem_ctl_info *mci,
+                                          const char *data, size_t count)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        unsigned long value;
+        int ret = 0;
+
+        ret = strict_strtoul(data, 10, &value);
+        if (ret != -EINVAL) {
+                pvt->injection.section = (u32) value;
+                return count;
+        }
+        return ret;
+}
+
+/*
+ * store error injection word value which refers to one of 9 16-bit word of the
+ * 16-byte (128-bit + ECC bits) section
+ *
+ * range: 0..8
+ */
+static ssize_t amd64_inject_word_store(struct mem_ctl_info *mci,
+                                        const char *data, size_t count)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        unsigned long value;
+        int ret = 0;
+
+        ret = strict_strtoul(data, 10, &value);
+        if (ret != -EINVAL) {
+
+                value = (value <= 8) ? value : 0;
+                pvt->injection.word = (u32) value;
+
+                return count;
+        }
+        return ret;
+}
+
+/*
+ * store 16 bit error injection vector which enables injecting errors to the
+ * corresponding bit within the error injection word above. When used during a
+ * DRAM ECC read, it holds the contents of the of the DRAM ECC bits.
+ */
+static ssize_t amd64_inject_ecc_vector_store(struct mem_ctl_info *mci,
+                                             const char *data, size_t count)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        unsigned long value;
+        int ret = 0;
+
+        ret = strict_strtoul(data, 16, &value);
+        if (ret != -EINVAL) {
+
+                pvt->injection.bit_map = (u32) value & 0xFFFF;
+
+                return count;
+        }
+        return ret;
+}
+
+/*
+ * Do a DRAM ECC read. Assemble staged values in the pvt area, format into
+ * fields needed by the injection registers and read the NB Array Data Port.
+ */
+static ssize_t amd64_inject_read_store(struct mem_ctl_info *mci,
+                                        const char *data, size_t count)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        unsigned long value;
+        u32 section, word_bits;
+        int ret = 0;
+
+        ret = strict_strtoul(data, 10, &value);
+        if (ret != -EINVAL) {
+
+                /* Form value to choose 16-byte section of cacheline */
+                section = F10_NB_ARRAY_DRAM_ECC |
+                                SET_NB_ARRAY_ADDRESS(pvt->injection.section);
+                pci_write_config_dword(pvt->misc_f3_ctl,
+                                        F10_NB_ARRAY_ADDR, section);
+
+                word_bits = SET_NB_DRAM_INJECTION_READ(pvt->injection.word,
+                                                pvt->injection.bit_map);
+
+                /* Issue 'word' and 'bit' along with the READ request */
+                pci_write_config_dword(pvt->misc_f3_ctl,
+                                        F10_NB_ARRAY_DATA, word_bits);
+
+                debugf0("section=0x%x word_bits=0x%x\n", section, word_bits);
+
+                return count;
+        }
+        return ret;
+}
+
+/*
+ * Do a DRAM ECC write. Assemble staged values in the pvt area and format into
+ * fields needed by the injection registers.
+ */
+static ssize_t amd64_inject_write_store(struct mem_ctl_info *mci,
+                                        const char *data, size_t count)
+{
+        struct amd64_pvt *pvt = mci->pvt_info;
+        unsigned long value;
+        u32 section, word_bits;
+        int ret = 0;
+
+        ret = strict_strtoul(data, 10, &value);
+        if (ret != -EINVAL) {
+
+                /* Form value to choose 16-byte section of cacheline */
+                section = F10_NB_ARRAY_DRAM_ECC |
+                                SET_NB_ARRAY_ADDRESS(pvt->injection.section);
+                pci_write_config_dword(pvt->misc_f3_ctl,
+                                        F10_NB_ARRAY_ADDR, section);
+
+                word_bits = SET_NB_DRAM_INJECTION_WRITE(pvt->injection.word,
+                                                pvt->injection.bit_map);
+
+                /* Issue 'word' and 'bit' along with the READ request */
+                pci_write_config_dword(pvt->misc_f3_ctl,
+                                        F10_NB_ARRAY_DATA, word_bits);
+
+                debugf0("section=0x%x word_bits=0x%x\n", section, word_bits);
+
+                return count;
+        }
+        return ret;
+}
+
+/*
+ * update NUM_INJ_ATTRS in case you add new members
+ */
+struct mcidev_sysfs_attribute amd64_inj_attrs[] = {
+
+        {
+                .attr = {
+                        .name = "inject_section",
+                        .mode = (S_IRUGO | S_IWUSR)
+                },
+                .show = NULL,
+                .store = amd64_inject_section_store,
+        },
+        {
+                .attr = {
+                        .name = "inject_word",
+                        .mode = (S_IRUGO | S_IWUSR)
+                },
+                .show = NULL,
+                .store = amd64_inject_word_store,
+        },
+        {
+                .attr = {
+                        .name = "inject_ecc_vector",
+                        .mode = (S_IRUGO | S_IWUSR)
+                },
+                .show = NULL,
+                .store = amd64_inject_ecc_vector_store,
+        },
+        {
+                .attr = {
+                        .name = "inject_write",
+                        .mode = (S_IRUGO | S_IWUSR)
+                },
+                .show = NULL,
+                .store = amd64_inject_write_store,
+        },
+        {
+                .attr = {
+                        .name = "inject_read",
+                        .mode = (S_IRUGO | S_IWUSR)
+                },
+                .show = NULL,
+                .store = amd64_inject_read_store,
+        },
+};
diff --git a/drivers/edac/edac_core.h b/drivers/edac/edac_core.h
index 6ad95c8d6363..48d3b1409834 100644
--- a/drivers/edac/edac_core.h
+++ b/drivers/edac/edac_core.h
@@ -76,10 +76,11 @@
 extern int edac_debug_level;
 
 #ifndef CONFIG_EDAC_DEBUG_VERBOSE
-#define edac_debug_printk(level, fmt, arg...)                            \
-        do {                                                             \
-                if (level <= edac_debug_level)                           \
-                        edac_printk(KERN_DEBUG, EDAC_DEBUG, fmt, ##arg); \
+#define edac_debug_printk(level, fmt, arg...)                           \
+        do {                                                            \
+                if (level <= edac_debug_level)                          \
+                        edac_printk(KERN_DEBUG, EDAC_DEBUG,             \
+                                    "%s: " fmt, __func__, ##arg);       \
         } while (0)
 #else  /* CONFIG_EDAC_DEBUG_VERBOSE */
 #define edac_debug_printk(level, fmt, arg...)                            \
diff --git a/drivers/firmware/dmi_scan.c b/drivers/firmware/dmi_scan.c
index 5f1b5400d96a..24c84ae81527 100644
--- a/drivers/firmware/dmi_scan.c
+++ b/drivers/firmware/dmi_scan.c
@@ -596,6 +596,7 @@ int dmi_get_year(int field)
 
         return year;
 }
+EXPORT_SYMBOL(dmi_get_year);
 
 /**
  *      dmi_walk - Walk the DMI table and get called back for every record
diff --git a/drivers/i2c/busses/i2c-sh7760.c b/drivers/i2c/busses/i2c-sh7760.c
index baa28b73ae42..b9680f50f541 100644
--- a/drivers/i2c/busses/i2c-sh7760.c
+++ b/drivers/i2c/busses/i2c-sh7760.c
@@ -396,7 +396,7 @@ static int __devinit calc_CCR(unsigned long scl_hz)
         signed char cdf, cdfm;
         int scgd, scgdm, scgds;
 
-        mclk = clk_get(NULL, "module_clk");
+        mclk = clk_get(NULL, "peripheral_clk");
         if (IS_ERR(mclk)) {
                 return PTR_ERR(mclk);
         } else {
diff --git a/drivers/ide/alim15x3.c b/drivers/ide/alim15x3.c
index 537da1cde16d..e59b6dee9ae2 100644
--- a/drivers/ide/alim15x3.c
+++ b/drivers/ide/alim15x3.c
@@ -402,27 +402,23 @@ static u8 ali_cable_detect(ide_hwif_t *hwif)
         return cbl;
 }
 
-#if !defined(CONFIG_SPARC64) && !defined(CONFIG_PPC)
+#ifndef CONFIG_SPARC64
 /**
  *      init_hwif_ali15x3       -       Initialize the ALI IDE x86 stuff
  *      @hwif: interface to configure
  *
  *      Obtain the IRQ tables for an ALi based IDE solution on the PC
  *      class platforms. This part of the code isn't applicable to the
- *      Sparc and PowerPC systems.
+ *      Sparc systems.
  */
 
 static void __devinit init_hwif_ali15x3 (ide_hwif_t *hwif)
 {
-        struct pci_dev *dev = to_pci_dev(hwif->dev);
         u8 ideic, inmir;
         s8 irq_routing_table[] = { -1,  9, 3, 10, 4,  5, 7,  6,
                                       1, 11, 0, 12, 0, 14, 0, 15 };
         int irq = -1;
 
-        if (dev->device == PCI_DEVICE_ID_AL_M5229)
-                hwif->irq = hwif->channel ? 15 : 14;
-
         if (isa_dev) {
                 /*
                  * read IDE interface control
@@ -455,7 +451,7 @@ static void __devinit init_hwif_ali15x3 (ide_hwif_t *hwif)
 }
 #else
 #define init_hwif_ali15x3 NULL
-#endif /* !defined(CONFIG_SPARC64) && !defined(CONFIG_PPC) */
+#endif /* CONFIG_SPARC64 */
 
 /**
  *      init_dma_ali15x3        -       set up DMA on ALi15x3
diff --git a/drivers/ide/ide-atapi.c b/drivers/ide/ide-atapi.c
index 7201b176d75b..757e5956b132 100644
--- a/drivers/ide/ide-atapi.c
+++ b/drivers/ide/ide-atapi.c
@@ -80,34 +80,6 @@ void ide_init_pc(struct ide_atapi_pc *pc)
 EXPORT_SYMBOL_GPL(ide_init_pc);
 
 /*
- * Generate a new packet command request in front of the request queue, before
- * the current request, so that it will be processed immediately, on the next
- * pass through the driver.
- */
-static void ide_queue_pc_head(ide_drive_t *drive, struct gendisk *disk,
-                              struct ide_atapi_pc *pc, struct request *rq)
-{
-        blk_rq_init(NULL, rq);
-        rq->cmd_type = REQ_TYPE_SPECIAL;
-        rq->cmd_flags |= REQ_PREEMPT;
-        rq->buffer = (char *)pc;
-        rq->rq_disk = disk;
-
-        if (pc->req_xfer) {
-                rq->data = pc->buf;
-                rq->data_len = pc->req_xfer;
-        }
-
-        memcpy(rq->cmd, pc->c, 12);
-        if (drive->media == ide_tape)
-                rq->cmd[13] = REQ_IDETAPE_PC1;
-
-        drive->hwif->rq = NULL;
-
-        elv_add_request(drive->queue, rq, ELEVATOR_INSERT_FRONT, 0);
-}
-
-/*
  * Add a special packet command request to the tail of the request queue,
  * and wait for it to be serviced.
  */
@@ -119,19 +91,21 @@ int ide_queue_pc_tail(ide_drive_t *drive, struct gendisk *disk,
 
         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
         rq->cmd_type = REQ_TYPE_SPECIAL;
-        rq->buffer = (char *)pc;
+        rq->special = (char *)pc;
 
         if (pc->req_xfer) {
-                rq->data = pc->buf;
-                rq->data_len = pc->req_xfer;
+                error = blk_rq_map_kern(drive->queue, rq, pc->buf, pc->req_xfer,
+                                        GFP_NOIO);
+                if (error)
+                        goto put_req;
         }
 
         memcpy(rq->cmd, pc->c, 12);
         if (drive->media == ide_tape)
                 rq->cmd[13] = REQ_IDETAPE_PC1;
         error = blk_execute_rq(drive->queue, disk, rq, 0);
+put_req:
         blk_put_request(rq);
-
         return error;
 }
 EXPORT_SYMBOL_GPL(ide_queue_pc_tail);
@@ -191,20 +165,113 @@ void ide_create_request_sense_cmd(ide_drive_t *drive, struct ide_atapi_pc *pc)
 }
 EXPORT_SYMBOL_GPL(ide_create_request_sense_cmd);
 
+void ide_prep_sense(ide_drive_t *drive, struct request *rq)
+{
+        struct request_sense *sense = &drive->sense_data;
+        struct request *sense_rq = &drive->sense_rq;
+        unsigned int cmd_len, sense_len;
+        int err;
+
+        debug_log("%s: enter\n", __func__);
+
+        switch (drive->media) {
+        case ide_floppy:
+                cmd_len = 255;
+                sense_len = 18;
+                break;
+        case ide_tape:
+                cmd_len = 20;
+                sense_len = 20;
+                break;
+        default:
+                cmd_len = 18;
+                sense_len = 18;
+        }
+
+        BUG_ON(sense_len > sizeof(*sense));
+
+        if (blk_sense_request(rq) || drive->sense_rq_armed)
+                return;
+
+        memset(sense, 0, sizeof(*sense));
+
+        blk_rq_init(rq->q, sense_rq);
+
+        err = blk_rq_map_kern(drive->queue, sense_rq, sense, sense_len,
+                              GFP_NOIO);
+        if (unlikely(err)) {
+                if (printk_ratelimit())
+                        printk(KERN_WARNING "%s: failed to map sense buffer\n",
+                               drive->name);
+                return;
+        }
+
+        sense_rq->rq_disk = rq->rq_disk;
+        sense_rq->cmd[0] = GPCMD_REQUEST_SENSE;
+        sense_rq->cmd[4] = cmd_len;
+        sense_rq->cmd_type = REQ_TYPE_SENSE;
+        sense_rq->cmd_flags |= REQ_PREEMPT;
+
+        if (drive->media == ide_tape)
+                sense_rq->cmd[13] = REQ_IDETAPE_PC1;
+
+        drive->sense_rq_armed = true;
+}
+EXPORT_SYMBOL_GPL(ide_prep_sense);
+
+int ide_queue_sense_rq(ide_drive_t *drive, void *special)
+{
+        /* deferred failure from ide_prep_sense() */
+        if (!drive->sense_rq_armed) {
+                printk(KERN_WARNING "%s: failed queue sense request\n",
+                       drive->name);
+                return -ENOMEM;
+        }
+
+        drive->sense_rq.special = special;
+        drive->sense_rq_armed = false;
+
+        drive->hwif->rq = NULL;
+
+        elv_add_request(drive->queue, &drive->sense_rq,
+                        ELEVATOR_INSERT_FRONT, 0);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(ide_queue_sense_rq);
+
 /*
  * Called when an error was detected during the last packet command.
- * We queue a request sense packet command in the head of the request list.
+ * We queue a request sense packet command at the head of the request
+ * queue.
  */
-void ide_retry_pc(ide_drive_t *drive, struct gendisk *disk)
+void ide_retry_pc(ide_drive_t *drive)
 {
-        struct request *rq = &drive->request_sense_rq;
+        struct request *failed_rq = drive->hwif->rq;
+        struct request *sense_rq = &drive->sense_rq;
         struct ide_atapi_pc *pc = &drive->request_sense_pc;
 
         (void)ide_read_error(drive);
-        ide_create_request_sense_cmd(drive, pc);
+
+        /* init pc from sense_rq */
+        ide_init_pc(pc);
+        memcpy(pc->c, sense_rq->cmd, 12);
+        pc->buf = bio_data(sense_rq->bio);      /* pointer to mapped address */
+        pc->req_xfer = blk_rq_bytes(sense_rq);
+
         if (drive->media == ide_tape)
                 set_bit(IDE_AFLAG_IGNORE_DSC, &drive->atapi_flags);
-        ide_queue_pc_head(drive, disk, pc, rq);
+
+        /*
+         * Push back the failed request and put request sense on top
+         * of it.  The failed command will be retried after sense data
+         * is acquired.
+         */
+        blk_requeue_request(failed_rq->q, failed_rq);
+        drive->hwif->rq = NULL;
+        if (ide_queue_sense_rq(drive, pc)) {
+                blk_start_request(failed_rq);
+                ide_complete_rq(drive, -EIO, blk_rq_bytes(failed_rq));
+        }
 }
 EXPORT_SYMBOL_GPL(ide_retry_pc);
 
@@ -246,7 +313,7 @@ int ide_cd_get_xferlen(struct request *rq)
                 return 32768;
         else if (blk_sense_request(rq) || blk_pc_request(rq) ||
                          rq->cmd_type == REQ_TYPE_ATA_PC)
-                return rq->data_len;
+                return blk_rq_bytes(rq);
         else
                 return 0;
 }
@@ -276,7 +343,6 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
         struct ide_cmd *cmd = &hwif->cmd;
         struct request *rq = hwif->rq;
         const struct ide_tp_ops *tp_ops = hwif->tp_ops;
-        xfer_func_t *xferfunc;
         unsigned int timeout, done;
         u16 bcount;
         u8 stat, ireason, dsc = 0;
@@ -303,18 +369,14 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
                                         drive->name, rq_data_dir(pc->rq)
                                                      ? "write" : "read");
                         pc->flags |= PC_FLAG_DMA_ERROR;
-                } else {
+                } else
                         pc->xferred = pc->req_xfer;
-                        if (drive->pc_update_buffers)
-                                drive->pc_update_buffers(drive, pc);
-                }
                 debug_log("%s: DMA finished\n", drive->name);
         }
 
         /* No more interrupts */
         if ((stat & ATA_DRQ) == 0) {
                 int uptodate, error;
-                unsigned int done;
 
                 debug_log("Packet command completed, %d bytes transferred\n",
                           pc->xferred);
@@ -343,7 +405,7 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
                         debug_log("[cmd %x]: check condition\n", rq->cmd[0]);
 
                         /* Retry operation */
-                        ide_retry_pc(drive, rq->rq_disk);
+                        ide_retry_pc(drive);
 
                         /* queued, but not started */
                         return ide_stopped;
@@ -353,6 +415,12 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
                 if ((pc->flags & PC_FLAG_WAIT_FOR_DSC) && (stat & ATA_DSC) == 0)
                         dsc = 1;
 
+                /*
+                 * ->pc_callback() might change rq->data_len for
+                 * residual count, cache total length.
+                 */
+                done = blk_rq_bytes(rq);
+
                 /* Command finished - Call the callback function */
                 uptodate = drive->pc_callback(drive, dsc);
 
@@ -361,7 +429,6 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
 
                 if (blk_special_request(rq)) {
                         rq->errors = 0;
-                        done = blk_rq_bytes(rq);
                         error = 0;
                 } else {
 
@@ -370,15 +437,10 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
                                         rq->errors = -EIO;
                         }
 
-                        if (drive->media == ide_tape)
-                                done = ide_rq_bytes(rq); /* FIXME */
-                        else
-                                done = blk_rq_bytes(rq);
-
                         error = uptodate ? 0 : -EIO;
                 }
 
-                ide_complete_rq(drive, error, done);
+                ide_complete_rq(drive, error, blk_rq_bytes(rq));
                 return ide_stopped;
         }
 
@@ -407,21 +469,11 @@ static ide_startstop_t ide_pc_intr(ide_drive_t *drive)
                 return ide_do_reset(drive);
         }
 
-        xferfunc = write ? tp_ops->output_data : tp_ops->input_data;
-
-        if (drive->media == ide_floppy && pc->buf == NULL) {
-                done = min_t(unsigned int, bcount, cmd->nleft);
-                ide_pio_bytes(drive, cmd, write, done);
-        } else if (drive->media == ide_tape && pc->bh) {
-                done = drive->pc_io_buffers(drive, pc, bcount, write);
-        } else {
-                done = min_t(unsigned int, bcount, pc->req_xfer - pc->xferred);
-                xferfunc(drive, NULL, pc->cur_pos, done);
-        }
+        done = min_t(unsigned int, bcount, cmd->nleft);
+        ide_pio_bytes(drive, cmd, write, done);
 
-        /* Update the current position */
+        /* Update transferred byte count */
         pc->xferred += done;
-        pc->cur_pos += done;
 
         bcount -= done;
 
@@ -599,7 +651,6 @@ ide_startstop_t ide_issue_pc(ide_drive_t *drive, struct ide_cmd *cmd)
 
                 /* We haven't transferred any data yet */
                 pc->xferred = 0;
-                pc->cur_pos = pc->buf;
 
                 valid_tf = IDE_VALID_DEVICE;
                 bcount = ((drive->media == ide_tape) ?
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 925eb9e245d1..424140c6c400 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -182,7 +182,7 @@ static void cdrom_analyze_sense_data(ide_drive_t *drive,
                                  (sense->information[2] <<  8) |
                                  (sense->information[3]);
 
-                        if (drive->queue->hardsect_size == 2048)
+                        if (queue_logical_block_size(drive->queue) == 2048)
                                 /* device sector size is 2K */
                                 sector <<= 2;
 
@@ -206,54 +206,25 @@ static void cdrom_analyze_sense_data(ide_drive_t *drive,
         ide_cd_log_error(drive->name, failed_command, sense);
 }
 
-static void cdrom_queue_request_sense(ide_drive_t *drive, void *sense,
-                                      struct request *failed_command)
-{
-        struct cdrom_info *info         = drive->driver_data;
-        struct request *rq              = &drive->request_sense_rq;
-
-        ide_debug_log(IDE_DBG_SENSE, "enter");
-
-        if (sense == NULL)
-                sense = &info->sense_data;
-
-        /* stuff the sense request in front of our current request */
-        blk_rq_init(NULL, rq);
-        rq->cmd_type = REQ_TYPE_ATA_PC;
-        rq->rq_disk = info->disk;
-
-        rq->data = sense;
-        rq->cmd[0] = GPCMD_REQUEST_SENSE;
-        rq->cmd[4] = 18;
-        rq->data_len = 18;
-
-        rq->cmd_type = REQ_TYPE_SENSE;
-        rq->cmd_flags |= REQ_PREEMPT;
-
-        /* NOTE! Save the failed command in "rq->buffer" */
-        rq->buffer = (void *) failed_command;
-
-        if (failed_command)
-                ide_debug_log(IDE_DBG_SENSE, "failed_cmd: 0x%x",
-                                             failed_command->cmd[0]);
-
-        drive->hwif->rq = NULL;
-
-        elv_add_request(drive->queue, rq, ELEVATOR_INSERT_FRONT, 0);
-}
-
 static void ide_cd_complete_failed_rq(ide_drive_t *drive, struct request *rq)
 {
         /*
-         * For REQ_TYPE_SENSE, "rq->buffer" points to the original
-         * failed request
+         * For REQ_TYPE_SENSE, "rq->special" points to the original
+         * failed request.  Also, the sense data should be read
+         * directly from rq which might be different from the original
+         * sense buffer if it got copied during mapping.
          */
-        struct request *failed = (struct request *)rq->buffer;
-        struct cdrom_info *info = drive->driver_data;
-        void *sense = &info->sense_data;
+        struct request *failed = (struct request *)rq->special;
+        void *sense = bio_data(rq->bio);
 
         if (failed) {
                 if (failed->sense) {
+                        /*
+                         * Sense is always read into drive->sense_data.
+                         * Copy back if the failed request has its
+                         * sense pointer set.
+                         */
+                        memcpy(failed->sense, sense, 18);
                         sense = failed->sense;
                         failed->sense_len = rq->sense_len;
                 }
@@ -428,22 +399,13 @@ static int cdrom_decode_status(ide_drive_t *drive, u8 stat)
 
         /* if we got a CHECK_CONDITION status, queue a request sense command */
         if (stat & ATA_ERR)
-                cdrom_queue_request_sense(drive, NULL, NULL);
+                return ide_queue_sense_rq(drive, NULL) ? 2 : 1;
         return 1;
 
 end_request:
         if (stat & ATA_ERR) {
-                struct request_queue *q = drive->queue;
-                unsigned long flags;
-
-                spin_lock_irqsave(q->queue_lock, flags);
-                blkdev_dequeue_request(rq);
-                spin_unlock_irqrestore(q->queue_lock, flags);
-
                 hwif->rq = NULL;
-
-                cdrom_queue_request_sense(drive, rq->sense, rq);
-                return 1;
+                return ide_queue_sense_rq(drive, rq) ? 2 : 1;
         } else
                 return 2;
 }
@@ -503,14 +465,8 @@ static void ide_cd_request_sense_fixup(ide_drive_t *drive, struct ide_cmd *cmd)
          * and some drives don't send them.  Sigh.
          */
         if (rq->cmd[0] == GPCMD_REQUEST_SENSE &&
-            cmd->nleft > 0 && cmd->nleft <= 5) {
-                unsigned int ofs = cmd->nbytes - cmd->nleft;
-
-                while (cmd->nleft > 0) {
-                        *((u8 *)rq->data + ofs++) = 0;
-                        cmd->nleft--;
-                }
-        }
+            cmd->nleft > 0 && cmd->nleft <= 5)
+                cmd->nleft = 0;
 }
 
 int ide_cd_queue_pc(ide_drive_t *drive, const unsigned char *cmd,
@@ -543,14 +499,18 @@ int ide_cd_queue_pc(ide_drive_t *drive, const unsigned char *cmd,
                 rq->cmd_flags |= cmd_flags;
                 rq->timeout = timeout;
                 if (buffer) {
-                        rq->data = buffer;
-                        rq->data_len = *bufflen;
+                        error = blk_rq_map_kern(drive->queue, rq, buffer,
+                                                *bufflen, GFP_NOIO);
+                        if (error) {
+                                blk_put_request(rq);
+                                return error;
+                        }
                 }
 
                 error = blk_execute_rq(drive->queue, info->disk, rq, 0);
 
                 if (buffer)
-                        *bufflen = rq->data_len;
+                        *bufflen = rq->resid_len;
 
                 flags = rq->cmd_flags;
                 blk_put_request(rq);
@@ -608,7 +568,7 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
         struct request *rq = hwif->rq;
         ide_expiry_t *expiry = NULL;
         int dma_error = 0, dma, thislen, uptodate = 0;
-        int write = (rq_data_dir(rq) == WRITE) ? 1 : 0, rc = 0, nsectors;
+        int write = (rq_data_dir(rq) == WRITE) ? 1 : 0, rc = 0;
         int sense = blk_sense_request(rq);
         unsigned int timeout;
         u16 len;
@@ -738,13 +698,8 @@ static ide_startstop_t cdrom_newpc_intr(ide_drive_t *drive)
 
 out_end:
         if (blk_pc_request(rq) && rc == 0) {
-                unsigned int dlen = rq->data_len;
-
-                rq->data_len = 0;
-
-                if (blk_end_request(rq, 0, dlen))
-                        BUG();
-
+                rq->resid_len = 0;
+                blk_end_request_all(rq, 0);
                 hwif->rq = NULL;
         } else {
                 if (sense && uptodate)
@@ -762,21 +717,13 @@ out_end:
                         ide_cd_error_cmd(drive, cmd);
 
                 /* make sure it's fully ended */
-                if (blk_pc_request(rq))
-                        nsectors = (rq->data_len + 511) >> 9;
-                else
-                        nsectors = rq->hard_nr_sectors;
-
-                if (nsectors == 0)
-                        nsectors = 1;
-
                 if (blk_fs_request(rq) == 0) {
-                        rq->data_len -= (cmd->nbytes - cmd->nleft);
+                        rq->resid_len -= cmd->nbytes - cmd->nleft;
                         if (uptodate == 0 && (cmd->tf_flags & IDE_TFLAG_WRITE))
-                                rq->data_len += cmd->last_xfer_len;
+                                rq->resid_len += cmd->last_xfer_len;
                 }
 
-                ide_complete_rq(drive, uptodate ? 0 : -EIO, nsectors << 9);
+                ide_complete_rq(drive, uptodate ? 0 : -EIO, blk_rq_bytes(rq));
 
                 if (sense && rc == 2)
                         ide_error(drive, "request sense failure", stat);
@@ -790,7 +737,7 @@ static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
         struct request_queue *q = drive->queue;
         int write = rq_data_dir(rq) == WRITE;
         unsigned short sectors_per_frame =
-                queue_hardsect_size(q) >> SECTOR_BITS;
+                queue_logical_block_size(q) >> SECTOR_BITS;
 
         ide_debug_log(IDE_DBG_RQ, "rq->cmd[0]: 0x%x, rq->cmd_flags: 0x%x, "
                                   "secs_per_frame: %u",
@@ -809,8 +756,8 @@ static ide_startstop_t cdrom_start_rw(ide_drive_t *drive, struct request *rq)
         }
 
         /* fs requests *must* be hardware frame aligned */
-        if ((rq->nr_sectors & (sectors_per_frame - 1)) ||
-            (rq->sector & (sectors_per_frame - 1)))
+        if ((blk_rq_sectors(rq) & (sectors_per_frame - 1)) ||
+            (blk_rq_pos(rq) & (sectors_per_frame - 1)))
                 return ide_stopped;
 
         /* use DMA, if possible */
@@ -838,15 +785,10 @@ static void cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
         drive->dma = 0;
 
         /* sg request */
-        if (rq->bio || ((rq->cmd_type == REQ_TYPE_ATA_PC) && rq->data_len)) {
+        if (rq->bio) {
                 struct request_queue *q = drive->queue;
+                char *buf = bio_data(rq->bio);
                 unsigned int alignment;
-                char *buf;
-
-                if (rq->bio)
-                        buf = bio_data(rq->bio);
-                else
-                        buf = rq->data;
 
                 drive->dma = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
 
@@ -858,7 +800,7 @@ static void cdrom_do_block_pc(ide_drive_t *drive, struct request *rq)
                  */
                 alignment = queue_dma_alignment(q) | q->dma_pad_mask;
                 if ((unsigned long)buf & alignment
-                    || rq->data_len & q->dma_pad_mask
+                    || blk_rq_bytes(rq) & q->dma_pad_mask
                     || object_is_on_stack(buf))
                         drive->dma = 0;
         }
@@ -896,6 +838,9 @@ static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq,
                 goto out_end;
         }
 
+        /* prepare sense request for this command */
+        ide_prep_sense(drive, rq);
+
         memset(&cmd, 0, sizeof(cmd));
 
         if (rq_data_dir(rq))
@@ -903,15 +848,14 @@ static ide_startstop_t ide_cd_do_request(ide_drive_t *drive, struct request *rq,
 
         cmd.rq = rq;
 
-        if (blk_fs_request(rq) || rq->data_len) {
-                ide_init_sg_cmd(&cmd, blk_fs_request(rq) ? (rq->nr_sectors << 9)
-                                                         : rq->data_len);
+        if (blk_fs_request(rq) || blk_rq_bytes(rq)) {
+                ide_init_sg_cmd(&cmd, blk_rq_bytes(rq));
                 ide_map_sg(drive, &cmd);
         }
 
         return ide_issue_pc(drive, &cmd);
 out_end:
-        nsectors = rq->hard_nr_sectors;
+        nsectors = blk_rq_sectors(rq);
 
         if (nsectors == 0)
                 nsectors = 1;
@@ -1077,8 +1021,8 @@ int ide_cd_read_toc(ide_drive_t *drive, struct request_sense *sense)
         /* save a private copy of the TOC capacity for error handling */
         drive->probed_capacity = toc->capacity * sectors_per_frame;
 
-        blk_queue_hardsect_size(drive->queue,
-                                sectors_per_frame << SECTOR_BITS);
+        blk_queue_logical_block_size(drive->queue,
+                                     sectors_per_frame << SECTOR_BITS);
 
         /* first read just the header, so we know how long the TOC is */
         stat = cdrom_read_tocentry(drive, 0, 1, 0, (char *) &toc->hdr,
@@ -1394,9 +1338,9 @@ static int ide_cdrom_probe_capabilities(ide_drive_t *drive)
 /* standard prep_rq_fn that builds 10 byte cmds */
 static int ide_cdrom_prep_fs(struct request_queue *q, struct request *rq)
 {
-        int hard_sect = queue_hardsect_size(q);
-        long block = (long)rq->hard_sector / (hard_sect >> 9);
-        unsigned long blocks = rq->hard_nr_sectors / (hard_sect >> 9);
+        int hard_sect = queue_logical_block_size(q);
+        long block = (long)blk_rq_pos(rq) / (hard_sect >> 9);
+        unsigned long blocks = blk_rq_sectors(rq) / (hard_sect >> 9);
 
         memset(rq->cmd, 0, BLK_MAX_CDB);
 
@@ -1599,7 +1543,7 @@ static int ide_cdrom_setup(ide_drive_t *drive)
 
         nslots = ide_cdrom_probe_capabilities(drive);
 
-        blk_queue_hardsect_size(q, CD_FRAMESIZE);
+        blk_queue_logical_block_size(q, CD_FRAMESIZE);
 
         if (ide_cdrom_register(drive, nslots)) {
                 printk(KERN_ERR PFX "%s: %s failed to register device with the"
diff --git a/drivers/ide/ide-cd.h b/drivers/ide/ide-cd.h
index 1d97101099ce..93a3cf1b0f3f 100644
--- a/drivers/ide/ide-cd.h
+++ b/drivers/ide/ide-cd.h
@@ -87,10 +87,6 @@ struct cdrom_info {
 
         struct atapi_toc *toc;
 
-        /* The result of the last successful request sense command
-           on this device. */
-        struct request_sense sense_data;
-
         u8 max_speed;           /* Max speed of the drive. */
         u8 current_speed;       /* Current speed of the drive. */
 
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index a9fbe2c31210..c6f7fcfb9d67 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -82,7 +82,7 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
                                         sector_t block)
 {
         ide_hwif_t *hwif        = drive->hwif;
-        u16 nsectors            = (u16)rq->nr_sectors;
+        u16 nsectors            = (u16)blk_rq_sectors(rq);
         u8 lba48                = !!(drive->dev_flags & IDE_DFLAG_LBA48);
         u8 dma                  = !!(drive->dev_flags & IDE_DFLAG_USING_DMA);
         struct ide_cmd          cmd;
@@ -90,7 +90,7 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
         ide_startstop_t         rc;
 
         if ((hwif->host_flags & IDE_HFLAG_NO_LBA48_DMA) && lba48 && dma) {
-                if (block + rq->nr_sectors > 1ULL << 28)
+                if (block + blk_rq_sectors(rq) > 1ULL << 28)
                         dma = 0;
                 else
                         lba48 = 0;
@@ -195,9 +195,9 @@ static ide_startstop_t ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
 
         ledtrig_ide_activity();
 
-        pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
+        pr_debug("%s: %sing: block=%llu, sectors=%u, buffer=0x%08lx\n",
                  drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
-                 (unsigned long long)block, rq->nr_sectors,
+                 (unsigned long long)block, blk_rq_sectors(rq),
                  (unsigned long)rq->buffer);
 
         if (hwif->rw_disk)
@@ -411,7 +411,6 @@ static void idedisk_prepare_flush(struct request_queue *q, struct request *rq)
         cmd->protocol = ATA_PROT_NODATA;
 
         rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
-        rq->cmd_flags |= REQ_SOFTBARRIER;
         rq->special = cmd;
 }
 
@@ -640,7 +639,7 @@ static void ide_disk_setup(ide_drive_t *drive)
         }
 
         printk(KERN_INFO "%s: max request size: %dKiB\n", drive->name,
-                q->max_sectors / 2);
+               queue_max_sectors(q) / 2);
 
         if (ata_id_is_ssd(id))
                 queue_flag_set_unlocked(QUEUE_FLAG_NONROT, q);
diff --git a/drivers/ide/ide-dma.c b/drivers/ide/ide-dma.c
index a0b8cab1d9a6..001f68f0bb28 100644
--- a/drivers/ide/ide-dma.c
+++ b/drivers/ide/ide-dma.c
@@ -103,7 +103,7 @@ ide_startstop_t ide_dma_intr(ide_drive_t *drive)
                                 ide_finish_cmd(drive, cmd, stat);
                         else
                                 ide_complete_rq(drive, 0,
-                                                cmd->rq->nr_sectors << 9);
+                                                blk_rq_sectors(cmd->rq) << 9);
                         return ide_stopped;
                 }
                 printk(KERN_ERR "%s: %s: bad DMA status (0x%02x)\n",
@@ -510,23 +510,11 @@ ide_startstop_t ide_dma_timeout_retry(ide_drive_t *drive, int error)
         /*
          * un-busy drive etc and make sure request is sane
          */
-
         rq = hwif->rq;
-        if (!rq)
-                goto out;
-
-        hwif->rq = NULL;
-
-        rq->errors = 0;
-
-        if (!rq->bio)
-                goto out;
-
-        rq->sector = rq->bio->bi_sector;
-        rq->current_nr_sectors = bio_iovec(rq->bio)->bv_len >> 9;
-        rq->hard_cur_sectors = rq->current_nr_sectors;
-        rq->buffer = bio_data(rq->bio);
-out:
+        if (rq) {
+                hwif->rq = NULL;
+                rq->errors = 0;
+        }
         return ret;
 }
 
diff --git a/drivers/ide/ide-floppy.c b/drivers/ide/ide-floppy.c
index 2b4868d95f8b..650981758f15 100644
--- a/drivers/ide/ide-floppy.c
+++ b/drivers/ide/ide-floppy.c
@@ -134,13 +134,17 @@ static ide_startstop_t ide_floppy_issue_pc(ide_drive_t *drive,
         drive->pc = pc;
 
         if (pc->retries > IDEFLOPPY_MAX_PC_RETRIES) {
+                unsigned int done = blk_rq_bytes(drive->hwif->rq);
+
                 if (!(pc->flags & PC_FLAG_SUPPRESS_ERROR))
                         ide_floppy_report_error(floppy, pc);
+
                 /* Giving up */
                 pc->error = IDE_DRV_ERROR_GENERAL;
 
                 drive->failed_pc = NULL;
                 drive->pc_callback(drive, 0);
+                ide_complete_rq(drive, -EIO, done);
                 return ide_stopped;
         }
 
@@ -190,7 +194,7 @@ static void idefloppy_create_rw_cmd(ide_drive_t *drive,
 {
         struct ide_disk_obj *floppy = drive->driver_data;
         int block = sector / floppy->bs_factor;
-        int blocks = rq->nr_sectors / floppy->bs_factor;
+        int blocks = blk_rq_sectors(rq) / floppy->bs_factor;
         int cmd = rq_data_dir(rq);
 
         ide_debug_log(IDE_DBG_FUNC, "block: %d, blocks: %d", block, blocks);
@@ -216,16 +220,14 @@ static void idefloppy_blockpc_cmd(struct ide_disk_obj *floppy,
         ide_init_pc(pc);
         memcpy(pc->c, rq->cmd, sizeof(pc->c));
         pc->rq = rq;
-        if (rq->data_len && rq_data_dir(rq) == WRITE)
-                pc->flags |= PC_FLAG_WRITING;
-        pc->buf = rq->data;
-        if (rq->bio)
+        if (blk_rq_bytes(rq)) {
                 pc->flags |= PC_FLAG_DMA_OK;
-        /*
-         * possibly problematic, doesn't look like ide-floppy correctly
-         * handled scattered requests if dma fails...
-         */
-        pc->req_xfer = pc->buf_size = rq->data_len;
+                if (rq_data_dir(rq) == WRITE)
+                        pc->flags |= PC_FLAG_WRITING;
+        }
+        /* pio will be performed by ide_pio_bytes() which handles sg fine */
+        pc->buf = NULL;
+        pc->req_xfer = pc->buf_size = blk_rq_bytes(rq);
 }
 
 static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive,
@@ -257,16 +259,16 @@ static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive,
                         goto out_end;
         }
         if (blk_fs_request(rq)) {
-                if (((long)rq->sector % floppy->bs_factor) ||
-                    (rq->nr_sectors % floppy->bs_factor)) {
+                if (((long)blk_rq_pos(rq) % floppy->bs_factor) ||
+                    (blk_rq_sectors(rq) % floppy->bs_factor)) {
                         printk(KERN_ERR PFX "%s: unsupported r/w rq size\n",
                                 drive->name);
                         goto out_end;
                 }
                 pc = &floppy->queued_pc;
                 idefloppy_create_rw_cmd(drive, pc, rq, (unsigned long)block);
-        } else if (blk_special_request(rq)) {
-                pc = (struct ide_atapi_pc *) rq->buffer;
+        } else if (blk_special_request(rq) || blk_sense_request(rq)) {
+                pc = (struct ide_atapi_pc *)rq->special;
         } else if (blk_pc_request(rq)) {
                 pc = &floppy->queued_pc;
                 idefloppy_blockpc_cmd(floppy, pc, rq);
@@ -275,6 +277,8 @@ static ide_startstop_t ide_floppy_do_request(ide_drive_t *drive,
                 goto out_end;
         }
 
+        ide_prep_sense(drive, rq);
+
         memset(&cmd, 0, sizeof(cmd));
 
         if (rq_data_dir(rq))
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index 6415a2e2ba87..bba4297f2f03 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -116,9 +116,9 @@ void ide_complete_cmd(ide_drive_t *drive, struct ide_cmd *cmd, u8 stat, u8 err)
 unsigned int ide_rq_bytes(struct request *rq)
 {
         if (blk_pc_request(rq))
-                return rq->data_len;
+                return blk_rq_bytes(rq);
         else
-                return rq->hard_cur_sectors << 9;
+                return blk_rq_cur_sectors(rq) << 9;
 }
 EXPORT_SYMBOL_GPL(ide_rq_bytes);
 
@@ -133,7 +133,7 @@ int ide_complete_rq(ide_drive_t *drive, int error, unsigned int nr_bytes)
          * and complete the whole request right now
          */
         if (blk_noretry_request(rq) && error <= 0)
-                nr_bytes = rq->hard_nr_sectors << 9;
+                nr_bytes = blk_rq_sectors(rq) << 9;
 
         rc = ide_end_rq(drive, rq, error, nr_bytes);
         if (rc == 0)
@@ -248,14 +248,7 @@ void ide_map_sg(ide_drive_t *drive, struct ide_cmd *cmd)
         struct scatterlist *sg = hwif->sg_table;
         struct request *rq = cmd->rq;
 
-        if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE) {
-                sg_init_one(sg, rq->buffer, rq->nr_sectors * SECTOR_SIZE);
-                cmd->sg_nents = 1;
-        } else if (!rq->bio) {
-                sg_init_one(sg, rq->data, rq->data_len);
-                cmd->sg_nents = 1;
-        } else
-                cmd->sg_nents = blk_rq_map_sg(drive->queue, rq, sg);
+        cmd->sg_nents = blk_rq_map_sg(drive->queue, rq, sg);
 }
 EXPORT_SYMBOL_GPL(ide_map_sg);
 
@@ -286,7 +279,7 @@ static ide_startstop_t execute_drive_cmd (ide_drive_t *drive,
 
         if (cmd) {
                 if (cmd->protocol == ATA_PROT_PIO) {
-                        ide_init_sg_cmd(cmd, rq->nr_sectors << 9);
+                        ide_init_sg_cmd(cmd, blk_rq_sectors(rq) << 9);
                         ide_map_sg(drive, cmd);
                 }
 
@@ -371,7 +364,7 @@ static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq)
                 if (rq->cmd_type == REQ_TYPE_ATA_TASKFILE)
                         return execute_drive_cmd(drive, rq);
                 else if (blk_pm_request(rq)) {
-                        struct request_pm_state *pm = rq->data;
+                        struct request_pm_state *pm = rq->special;
 #ifdef DEBUG_PM
                         printk("%s: start_power_step(step: %d)\n",
                                 drive->name, pm->pm_step);
@@ -394,7 +387,7 @@ static ide_startstop_t start_request (ide_drive_t *drive, struct request *rq)
 
                 drv = *(struct ide_driver **)rq->rq_disk->private_data;
 
-                return drv->do_request(drive, rq, rq->sector);
+                return drv->do_request(drive, rq, blk_rq_pos(rq));
         }
         return do_special(drive);
 kill_rq:
@@ -484,6 +477,9 @@ void do_ide_request(struct request_queue *q)
 
         spin_unlock_irq(q->queue_lock);
 
+        /* HLD do_request() callback might sleep, make sure it's okay */
+        might_sleep();
+
         if (ide_lock_host(host, hwif))
                 goto plug_device_2;
 
@@ -491,10 +487,10 @@ void do_ide_request(struct request_queue *q)
 
         if (!ide_lock_port(hwif)) {
                 ide_hwif_t *prev_port;
+
+                WARN_ON_ONCE(hwif->rq);
 repeat:
                 prev_port = hwif->host->cur_port;
-                hwif->rq = NULL;
-
                 if (drive->dev_flags & IDE_DFLAG_SLEEPING &&
                     time_after(drive->sleep, jiffies)) {
                         ide_unlock_port(hwif);
@@ -523,7 +519,9 @@ repeat:
                  * we know that the queue isn't empty, but this can happen
                  * if the q->prep_rq_fn() decides to kill a request
                  */
-                rq = elv_next_request(drive->queue);
+                if (!rq)
+                        rq = blk_fetch_request(drive->queue);
+
                 spin_unlock_irq(q->queue_lock);
                 spin_lock_irq(&hwif->lock);
 
@@ -535,7 +533,7 @@ repeat:
                 /*
                  * Sanity: don't accept a request that isn't a PM request
                  * if we are currently power managed. This is very important as
-                 * blk_stop_queue() doesn't prevent the elv_next_request()
+                 * blk_stop_queue() doesn't prevent the blk_fetch_request()
                  * above to return us whatever is in the queue. Since we call
                  * ide_do_request() ourselves, we end up taking requests while
                  * the queue is blocked...
@@ -559,8 +557,11 @@ repeat:
                 startstop = start_request(drive, rq);
                 spin_lock_irq(&hwif->lock);
 
-                if (startstop == ide_stopped)
+                if (startstop == ide_stopped) {
+                        rq = hwif->rq;
+                        hwif->rq = NULL;
                         goto repeat;
+                }
         } else
                 goto plug_device;
 out:
@@ -576,18 +577,24 @@ plug_device:
 plug_device_2:
         spin_lock_irq(q->queue_lock);
 
+        if (rq)
+                blk_requeue_request(q, rq);
         if (!elv_queue_empty(q))
                 blk_plug_device(q);
 }
 
-static void ide_plug_device(ide_drive_t *drive)
+static void ide_requeue_and_plug(ide_drive_t *drive, struct request *rq)
 {
         struct request_queue *q = drive->queue;
         unsigned long flags;
 
         spin_lock_irqsave(q->queue_lock, flags);
+
+        if (rq)
+                blk_requeue_request(q, rq);
         if (!elv_queue_empty(q))
                 blk_plug_device(q);
+
         spin_unlock_irqrestore(q->queue_lock, flags);
 }
 
@@ -636,6 +643,7 @@ void ide_timer_expiry (unsigned long data)
         unsigned long   flags;
         int             wait = -1;
         int             plug_device = 0;
+        struct request  *uninitialized_var(rq_in_flight);
 
         spin_lock_irqsave(&hwif->lock, flags);
 
@@ -697,6 +705,8 @@ void ide_timer_expiry (unsigned long data)
                 spin_lock_irq(&hwif->lock);
                 enable_irq(hwif->irq);
                 if (startstop == ide_stopped && hwif->polling == 0) {
+                        rq_in_flight = hwif->rq;
+                        hwif->rq = NULL;
                         ide_unlock_port(hwif);
                         plug_device = 1;
                 }
@@ -705,7 +715,7 @@ void ide_timer_expiry (unsigned long data)
 
         if (plug_device) {
                 ide_unlock_host(hwif->host);
-                ide_plug_device(drive);
+                ide_requeue_and_plug(drive, rq_in_flight);
         }
 }
 
@@ -791,6 +801,7 @@ irqreturn_t ide_intr (int irq, void *dev_id)
         ide_startstop_t startstop;
         irqreturn_t irq_ret = IRQ_NONE;
         int plug_device = 0;
+        struct request *uninitialized_var(rq_in_flight);
 
         if (host->host_flags & IDE_HFLAG_SERIALIZE) {
                 if (hwif != host->cur_port)
@@ -870,6 +881,8 @@ irqreturn_t ide_intr (int irq, void *dev_id)
          */
         if (startstop == ide_stopped && hwif->polling == 0) {
                 BUG_ON(hwif->handler);
+                rq_in_flight = hwif->rq;
+                hwif->rq = NULL;
                 ide_unlock_port(hwif);
                 plug_device = 1;
         }
@@ -879,7 +892,7 @@ out:
 out_early:
         if (plug_device) {
                 ide_unlock_host(hwif->host);
-                ide_plug_device(drive);
+                ide_requeue_and_plug(drive, rq_in_flight);
         }
 
         return irq_ret;
diff --git a/drivers/ide/ide-ioctls.c b/drivers/ide/ide-ioctls.c
index c1c25ebbaa1f..5991b23793f2 100644
--- a/drivers/ide/ide-ioctls.c
+++ b/drivers/ide/ide-ioctls.c
@@ -231,7 +231,6 @@ static int generic_drive_reset(ide_drive_t *drive)
         rq->cmd_type = REQ_TYPE_SPECIAL;
         rq->cmd_len = 1;
         rq->cmd[0] = REQ_DRIVE_RESET;
-        rq->cmd_flags |= REQ_SOFTBARRIER;
         if (blk_execute_rq(drive->queue, NULL, rq, 1))
                 ret = rq->errors;
         blk_put_request(rq);
diff --git a/drivers/ide/ide-lib.c b/drivers/ide/ide-lib.c
index 2148df836ce7..e386a32dc9ba 100644
--- a/drivers/ide/ide-lib.c
+++ b/drivers/ide/ide-lib.c
@@ -96,7 +96,7 @@ static void ide_dump_ata_error(ide_drive_t *drive, u8 err)
 
                 if (rq)
                         printk(KERN_CONT ", sector=%llu",
-                               (unsigned long long)rq->sector);
+                               (unsigned long long)blk_rq_pos(rq));
         }
         printk(KERN_CONT "\n");
 }
diff --git a/drivers/ide/ide-park.c b/drivers/ide/ide-park.c
index 310d03f2b5b7..a914023d6d03 100644
--- a/drivers/ide/ide-park.c
+++ b/drivers/ide/ide-park.c
@@ -24,11 +24,8 @@ static void issue_park_cmd(ide_drive_t *drive, unsigned long timeout)
                         start_queue = 1;
                 spin_unlock_irq(&hwif->lock);
 
-                if (start_queue) {
-                        spin_lock_irq(q->queue_lock);
-                        blk_start_queueing(q);
-                        spin_unlock_irq(q->queue_lock);
-                }
+                if (start_queue)
+                        blk_run_queue(q);
                 return;
         }
         spin_unlock_irq(&hwif->lock);
diff --git a/drivers/ide/ide-pm.c b/drivers/ide/ide-pm.c
index 0d8a151c0a01..ba1488bd8430 100644
--- a/drivers/ide/ide-pm.c
+++ b/drivers/ide/ide-pm.c
@@ -7,7 +7,6 @@ int generic_ide_suspend(struct device *dev, pm_message_t mesg)
         ide_hwif_t *hwif = drive->hwif;
         struct request *rq;
         struct request_pm_state rqpm;
-        struct ide_cmd cmd;
         int ret;
 
         /* call ACPI _GTM only once */
@@ -15,11 +14,9 @@ int generic_ide_suspend(struct device *dev, pm_message_t mesg)
                 ide_acpi_get_timing(hwif);
 
         memset(&rqpm, 0, sizeof(rqpm));
-        memset(&cmd, 0, sizeof(cmd));
         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
         rq->cmd_type = REQ_TYPE_PM_SUSPEND;
-        rq->special = &cmd;
-        rq->data = &rqpm;
+        rq->special = &rqpm;
         rqpm.pm_step = IDE_PM_START_SUSPEND;
         if (mesg.event == PM_EVENT_PRETHAW)
                 mesg.event = PM_EVENT_FREEZE;
@@ -41,7 +38,6 @@ int generic_ide_resume(struct device *dev)
         ide_hwif_t *hwif = drive->hwif;
         struct request *rq;
         struct request_pm_state rqpm;
-        struct ide_cmd cmd;
         int err;
 
         /* call ACPI _PS0 / _STM only once */
@@ -53,12 +49,10 @@ int generic_ide_resume(struct device *dev)
         ide_acpi_exec_tfs(drive);
 
         memset(&rqpm, 0, sizeof(rqpm));
-        memset(&cmd, 0, sizeof(cmd));
         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
         rq->cmd_type = REQ_TYPE_PM_RESUME;
         rq->cmd_flags |= REQ_PREEMPT;
-        rq->special = &cmd;
-        rq->data = &rqpm;
+        rq->special = &rqpm;
         rqpm.pm_step = IDE_PM_START_RESUME;
         rqpm.pm_state = PM_EVENT_ON;
 
@@ -77,7 +71,7 @@ int generic_ide_resume(struct device *dev)
 
 void ide_complete_power_step(ide_drive_t *drive, struct request *rq)
 {
-        struct request_pm_state *pm = rq->data;
+        struct request_pm_state *pm = rq->special;
 
 #ifdef DEBUG_PM
         printk(KERN_INFO "%s: complete_power_step(step: %d)\n",
@@ -107,10 +101,8 @@ void ide_complete_power_step(ide_drive_t *drive, struct request *rq)
 
 ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *rq)
 {
-        struct request_pm_state *pm = rq->data;
-        struct ide_cmd *cmd = rq->special;
-
-        memset(cmd, 0, sizeof(*cmd));
+        struct request_pm_state *pm = rq->special;
+        struct ide_cmd cmd = { };
 
         switch (pm->pm_step) {
         case IDE_PM_FLUSH_CACHE:        /* Suspend step 1 (flush cache) */
@@ -123,12 +115,12 @@ ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *rq)
                         return ide_stopped;
                 }
                 if (ata_id_flush_ext_enabled(drive->id))
-                        cmd->tf.command = ATA_CMD_FLUSH_EXT;
+                        cmd.tf.command = ATA_CMD_FLUSH_EXT;
                 else
-                        cmd->tf.command = ATA_CMD_FLUSH;
+                        cmd.tf.command = ATA_CMD_FLUSH;
                 goto out_do_tf;
         case IDE_PM_STANDBY:            /* Suspend step 2 (standby) */
-                cmd->tf.command = ATA_CMD_STANDBYNOW1;
+                cmd.tf.command = ATA_CMD_STANDBYNOW1;
                 goto out_do_tf;
         case IDE_PM_RESTORE_PIO:        /* Resume step 1 (restore PIO) */
                 ide_set_max_pio(drive);
@@ -141,7 +133,7 @@ ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *rq)
                         ide_complete_power_step(drive, rq);
                 return ide_stopped;
         case IDE_PM_IDLE:               /* Resume step 2 (idle) */
-                cmd->tf.command = ATA_CMD_IDLEIMMEDIATE;
+                cmd.tf.command = ATA_CMD_IDLEIMMEDIATE;
                 goto out_do_tf;
         case IDE_PM_RESTORE_DMA:        /* Resume step 3 (restore DMA) */
                 /*
@@ -163,11 +155,11 @@ ide_startstop_t ide_start_power_step(ide_drive_t *drive, struct request *rq)
         return ide_stopped;
 
 out_do_tf:
-        cmd->valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
-        cmd->valid.in.tf  = IDE_VALID_IN_TF  | IDE_VALID_DEVICE;
-        cmd->protocol = ATA_PROT_NODATA;
+        cmd.valid.out.tf = IDE_VALID_OUT_TF | IDE_VALID_DEVICE;
+        cmd.valid.in.tf  = IDE_VALID_IN_TF  | IDE_VALID_DEVICE;
+        cmd.protocol = ATA_PROT_NODATA;
 
-        return do_rw_taskfile(drive, cmd);
+        return do_rw_taskfile(drive, &cmd);
 }
 
 /**
@@ -181,7 +173,7 @@ out_do_tf:
 void ide_complete_pm_rq(ide_drive_t *drive, struct request *rq)
 {
         struct request_queue *q = drive->queue;
-        struct request_pm_state *pm = rq->data;
+        struct request_pm_state *pm = rq->special;
         unsigned long flags;
 
         ide_complete_power_step(drive, rq);
@@ -207,7 +199,7 @@ void ide_complete_pm_rq(ide_drive_t *drive, struct request *rq)
 
 void ide_check_pm_state(ide_drive_t *drive, struct request *rq)
 {
-        struct request_pm_state *pm = rq->data;
+        struct request_pm_state *pm = rq->special;
 
         if (blk_pm_suspend_request(rq) &&
             pm->pm_step == IDE_PM_START_SUSPEND)
diff --git a/drivers/ide/ide-tape.c b/drivers/ide/ide-tape.c
index 3a53e0834cf7..d9764f0bc82f 100644
--- a/drivers/ide/ide-tape.c
+++ b/drivers/ide/ide-tape.c
@@ -131,13 +131,6 @@ enum {
         IDETAPE_DIR_WRITE = (1 << 2),
 };
 
-struct idetape_bh {
-        u32 b_size;
-        atomic_t b_count;
-        struct idetape_bh *b_reqnext;
-        char *b_data;
-};
-
 /* Tape door status */
 #define DOOR_UNLOCKED                   0
 #define DOOR_LOCKED                     1
@@ -219,18 +212,12 @@ typedef struct ide_tape_obj {
 
         /* Data buffer size chosen based on the tape's recommendation */
         int buffer_size;
-        /* merge buffer */
-        struct idetape_bh *merge_bh;
-        /* size of the merge buffer */
-        int merge_bh_size;
-        /* pointer to current buffer head within the merge buffer */
-        struct idetape_bh *bh;
-        char *b_data;
-        int b_count;
-
-        int pages_per_buffer;
-        /* Wasted space in each stage */
-        int excess_bh_size;
+        /* Staging buffer of buffer_size bytes */
+        void *buf;
+        /* The read/write cursor */
+        void *cur;
+        /* The number of valid bytes in buf */
+        size_t valid;
 
         /* Measures average tape speed */
         unsigned long avg_time;
@@ -297,84 +284,6 @@ static struct ide_tape_obj *ide_tape_chrdev_get(unsigned int i)
         return tape;
 }
 
-static int idetape_input_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc,
-                                  unsigned int bcount)
-{
-        struct idetape_bh *bh = pc->bh;
-        int count;
-
-        while (bcount) {
-                if (bh == NULL)
-                        break;
-                count = min(
-                        (unsigned int)(bh->b_size - atomic_read(&bh->b_count)),
-                        bcount);
-                drive->hwif->tp_ops->input_data(drive, NULL, bh->b_data +
-                                        atomic_read(&bh->b_count), count);
-                bcount -= count;
-                atomic_add(count, &bh->b_count);
-                if (atomic_read(&bh->b_count) == bh->b_size) {
-                        bh = bh->b_reqnext;
-                        if (bh)
-                                atomic_set(&bh->b_count, 0);
-                }
-        }
-
-        pc->bh = bh;
-
-        return bcount;
-}
-
-static int idetape_output_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc,
-                                   unsigned int bcount)
-{
-        struct idetape_bh *bh = pc->bh;
-        int count;
-
-        while (bcount) {
-                if (bh == NULL)
-                        break;
-                count = min((unsigned int)pc->b_count, (unsigned int)bcount);
-                drive->hwif->tp_ops->output_data(drive, NULL, pc->b_data, count);
-                bcount -= count;
-                pc->b_data += count;
-                pc->b_count -= count;
-                if (!pc->b_count) {
-                        bh = bh->b_reqnext;
-                        pc->bh = bh;
-                        if (bh) {
-                                pc->b_data = bh->b_data;
-                                pc->b_count = atomic_read(&bh->b_count);
-                        }
-                }
-        }
-
-        return bcount;
-}
-
-static void idetape_update_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc)
-{
-        struct idetape_bh *bh = pc->bh;
-        int count;
-        unsigned int bcount = pc->xferred;
-
-        if (pc->flags & PC_FLAG_WRITING)
-                return;
-        while (bcount) {
-                if (bh == NULL) {
-                        printk(KERN_ERR "ide-tape: bh == NULL in %s\n",
-                                        __func__);
-                        return;
-                }
-                count = min((unsigned int)bh->b_size, (unsigned int)bcount);
-                atomic_set(&bh->b_count, count);
-                if (atomic_read(&bh->b_count) == bh->b_size)
-                        bh = bh->b_reqnext;
-                bcount -= count;
-        }
-        pc->bh = bh;
-}
-
 /*
  * called on each failed packet command retry to analyze the request sense. We
  * currently do not utilize this information.
@@ -392,12 +301,10 @@ static void idetape_analyze_error(ide_drive_t *drive, u8 *sense)
                  pc->c[0], tape->sense_key, tape->asc, tape->ascq);
 
         /* Correct pc->xferred by asking the tape.       */
-        if (pc->flags & PC_FLAG_DMA_ERROR) {
+        if (pc->flags & PC_FLAG_DMA_ERROR)
                 pc->xferred = pc->req_xfer -
                         tape->blk_size *
                         get_unaligned_be32(&sense[3]);
-                idetape_update_buffers(drive, pc);
-        }
 
         /*
          * If error was the result of a zero-length read or write command,
@@ -436,29 +343,6 @@ static void idetape_analyze_error(ide_drive_t *drive, u8 *sense)
         }
 }
 
-/* Free data buffers completely. */
-static void ide_tape_kfree_buffer(idetape_tape_t *tape)
-{
-        struct idetape_bh *prev_bh, *bh = tape->merge_bh;
-
-        while (bh) {
-                u32 size = bh->b_size;
-
-                while (size) {
-                        unsigned int order = fls(size >> PAGE_SHIFT)-1;
-
-                        if (bh->b_data)
-                                free_pages((unsigned long)bh->b_data, order);
-
-                        size &= (order-1);
-                        bh->b_data += (1 << order) * PAGE_SIZE;
-                }
-                prev_bh = bh;
-                bh = bh->b_reqnext;
-                kfree(prev_bh);
-        }
-}
-
 static void ide_tape_handle_dsc(ide_drive_t *);
 
 static int ide_tape_callback(ide_drive_t *drive, int dsc)
@@ -496,7 +380,7 @@ static int ide_tape_callback(ide_drive_t *drive, int dsc)
                 }
 
                 tape->first_frame += blocks;
-                rq->current_nr_sectors -= blocks;
+                rq->resid_len -= blocks * tape->blk_size;
 
                 if (pc->error) {
                         uptodate = 0;
@@ -558,19 +442,6 @@ static void ide_tape_handle_dsc(ide_drive_t *drive)
         idetape_postpone_request(drive);
 }
 
-static int ide_tape_io_buffers(ide_drive_t *drive, struct ide_atapi_pc *pc,
-                                unsigned int bcount, int write)
-{
-        unsigned int bleft;
-
-        if (write)
-                bleft = idetape_output_buffers(drive, pc, bcount);
-        else
-                bleft = idetape_input_buffers(drive, pc, bcount);
-
-        return bcount - bleft;
-}
-
 /*
  * Packet Command Interface
  *
@@ -622,6 +493,8 @@ static ide_startstop_t ide_tape_issue_pc(ide_drive_t *drive,
 
         if (pc->retries > IDETAPE_MAX_PC_RETRIES ||
                 (pc->flags & PC_FLAG_ABORT)) {
+                unsigned int done = blk_rq_bytes(drive->hwif->rq);
+
                 /*
                  * We will "abort" retrying a packet command in case legitimate
                  * error code was received (crossing a filemark, or end of the
@@ -641,8 +514,10 @@ static ide_startstop_t ide_tape_issue_pc(ide_drive_t *drive,
                         /* Giving up */
                         pc->error = IDE_DRV_ERROR_GENERAL;
                 }
+
                 drive->failed_pc = NULL;
                 drive->pc_callback(drive, 0);
+                ide_complete_rq(drive, -EIO, done);
                 return ide_stopped;
         }
         debug_log(DBG_SENSE, "Retry #%d, cmd = %02X\n", pc->retries, pc->c[0]);
@@ -695,7 +570,7 @@ static ide_startstop_t idetape_media_access_finished(ide_drive_t *drive)
                                 printk(KERN_ERR "ide-tape: %s: I/O error, ",
                                                 tape->name);
                         /* Retry operation */
-                        ide_retry_pc(drive, tape->disk);
+                        ide_retry_pc(drive);
                         return ide_stopped;
                 }
                 pc->error = 0;
@@ -711,27 +586,22 @@ static void ide_tape_create_rw_cmd(idetape_tape_t *tape,
                                    struct ide_atapi_pc *pc, struct request *rq,
                                    u8 opcode)
 {
-        struct idetape_bh *bh = (struct idetape_bh *)rq->special;
-        unsigned int length = rq->current_nr_sectors;
+        unsigned int length = blk_rq_sectors(rq);
 
         ide_init_pc(pc);
         put_unaligned(cpu_to_be32(length), (unsigned int *) &pc->c[1]);
         pc->c[1] = 1;
-        pc->bh = bh;
         pc->buf = NULL;
         pc->buf_size = length * tape->blk_size;
         pc->req_xfer = pc->buf_size;
         if (pc->req_xfer == tape->buffer_size)
                 pc->flags |= PC_FLAG_DMA_OK;
 
-        if (opcode == READ_6) {
+        if (opcode == READ_6)
                 pc->c[0] = READ_6;
-                atomic_set(&bh->b_count, 0);
-        } else if (opcode == WRITE_6) {
+        else if (opcode == WRITE_6) {
                 pc->c[0] = WRITE_6;
                 pc->flags |= PC_FLAG_WRITING;
-                pc->b_data = bh->b_data;
-                pc->b_count = atomic_read(&bh->b_count);
         }
 
         memcpy(rq->cmd, pc->c, 12);
@@ -747,12 +617,10 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive,
         struct ide_cmd cmd;
         u8 stat;
 
-        debug_log(DBG_SENSE, "sector: %llu, nr_sectors: %lu,"
-                        " current_nr_sectors: %u\n",
-                        (unsigned long long)rq->sector, rq->nr_sectors,
-                        rq->current_nr_sectors);
+        debug_log(DBG_SENSE, "sector: %llu, nr_sectors: %u\n"
+                  (unsigned long long)blk_rq_pos(rq), blk_rq_sectors(rq));
 
-        if (!blk_special_request(rq)) {
+        if (!(blk_special_request(rq) || blk_sense_request(rq))) {
                 /* We do not support buffer cache originated requests. */
                 printk(KERN_NOTICE "ide-tape: %s: Unsupported request in "
                         "request queue (%d)\n", drive->name, rq->cmd_type);
@@ -828,7 +696,7 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive,
                 goto out;
         }
         if (rq->cmd[13] & REQ_IDETAPE_PC1) {
-                pc = (struct ide_atapi_pc *) rq->buffer;
+                pc = (struct ide_atapi_pc *)rq->special;
                 rq->cmd[13] &= ~(REQ_IDETAPE_PC1);
                 rq->cmd[13] |= REQ_IDETAPE_PC2;
                 goto out;
@@ -840,6 +708,9 @@ static ide_startstop_t idetape_do_request(ide_drive_t *drive,
         BUG();
 
 out:
+        /* prepare sense request for this command */
+        ide_prep_sense(drive, rq);
+
         memset(&cmd, 0, sizeof(cmd));
 
         if (rq_data_dir(rq))
@@ -847,167 +718,10 @@ out:
 
         cmd.rq = rq;
 
-        return ide_tape_issue_pc(drive, &cmd, pc);
-}
-
-/*
- * The function below uses __get_free_pages to allocate a data buffer of size
- * tape->buffer_size (or a bit more). We attempt to combine sequential pages as
- * much as possible.
- *
- * It returns a pointer to the newly allocated buffer, or NULL in case of
- * failure.
- */
-static struct idetape_bh *ide_tape_kmalloc_buffer(idetape_tape_t *tape,
-                                                  int full, int clear)
-{
-        struct idetape_bh *prev_bh, *bh, *merge_bh;
-        int pages = tape->pages_per_buffer;
-        unsigned int order, b_allocd;
-        char *b_data = NULL;
-
-        merge_bh = kmalloc(sizeof(struct idetape_bh), GFP_KERNEL);
-        bh = merge_bh;
-        if (bh == NULL)
-                goto abort;
-
-        order = fls(pages) - 1;
-        bh->b_data = (char *) __get_free_pages(GFP_KERNEL, order);
-        if (!bh->b_data)
-                goto abort;
-        b_allocd = (1 << order) * PAGE_SIZE;
-        pages &= (order-1);
-
-        if (clear)
-                memset(bh->b_data, 0, b_allocd);
-        bh->b_reqnext = NULL;
-        bh->b_size = b_allocd;
-        atomic_set(&bh->b_count, full ? bh->b_size : 0);
-
-        while (pages) {
-                order = fls(pages) - 1;
-                b_data = (char *) __get_free_pages(GFP_KERNEL, order);
-                if (!b_data)
-                        goto abort;
-                b_allocd = (1 << order) * PAGE_SIZE;
-
-                if (clear)
-                        memset(b_data, 0, b_allocd);
-
-                /* newly allocated page frames below buffer header or ...*/
-                if (bh->b_data == b_data + b_allocd) {
-                        bh->b_size += b_allocd;
-                        bh->b_data -= b_allocd;
-                        if (full)
-                                atomic_add(b_allocd, &bh->b_count);
-                        continue;
-                }
-                /* they are above the header */
-                if (b_data == bh->b_data + bh->b_size) {
-                        bh->b_size += b_allocd;
-                        if (full)
-                                atomic_add(b_allocd, &bh->b_count);
-                        continue;
-                }
-                prev_bh = bh;
-                bh = kmalloc(sizeof(struct idetape_bh), GFP_KERNEL);
-                if (!bh) {
-                        free_pages((unsigned long) b_data, order);
-                        goto abort;
-                }
-                bh->b_reqnext = NULL;
-                bh->b_data = b_data;
-                bh->b_size = b_allocd;
-                atomic_set(&bh->b_count, full ? bh->b_size : 0);
-                prev_bh->b_reqnext = bh;
-
-                pages &= (order-1);
-        }
-
-        bh->b_size -= tape->excess_bh_size;
-        if (full)
-                atomic_sub(tape->excess_bh_size, &bh->b_count);
-        return merge_bh;
-abort:
-        ide_tape_kfree_buffer(tape);
-        return NULL;
-}
+        ide_init_sg_cmd(&cmd, pc->req_xfer);
+        ide_map_sg(drive, &cmd);
 
-static int idetape_copy_stage_from_user(idetape_tape_t *tape,
-                                        const char __user *buf, int n)
-{
-        struct idetape_bh *bh = tape->bh;
-        int count;
-        int ret = 0;
-
-        while (n) {
-                if (bh == NULL) {
-                        printk(KERN_ERR "ide-tape: bh == NULL in %s\n",
-                                        __func__);
-                        return 1;
-                }
-                count = min((unsigned int)
-                                (bh->b_size - atomic_read(&bh->b_count)),
-                                (unsigned int)n);
-                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;
-                if (atomic_read(&bh->b_count) == bh->b_size) {
-                        bh = bh->b_reqnext;
-                        if (bh)
-                                atomic_set(&bh->b_count, 0);
-                }
-        }
-        tape->bh = bh;
-        return ret;
-}
-
-static int idetape_copy_stage_to_user(idetape_tape_t *tape, char __user *buf,
-                                      int n)
-{
-        struct idetape_bh *bh = tape->bh;
-        int count;
-        int ret = 0;
-
-        while (n) {
-                if (bh == NULL) {
-                        printk(KERN_ERR "ide-tape: bh == NULL in %s\n",
-                                        __func__);
-                        return 1;
-                }
-                count = min(tape->b_count, n);
-                if  (copy_to_user(buf, tape->b_data, count))
-                        ret = 1;
-                n -= count;
-                tape->b_data += count;
-                tape->b_count -= count;
-                buf += count;
-                if (!tape->b_count) {
-                        bh = bh->b_reqnext;
-                        tape->bh = bh;
-                        if (bh) {
-                                tape->b_data = bh->b_data;
-                                tape->b_count = atomic_read(&bh->b_count);
-                        }
-                }
-        }
-        return ret;
-}
-
-static void idetape_init_merge_buffer(idetape_tape_t *tape)
-{
-        struct idetape_bh *bh = tape->merge_bh;
-        tape->bh = tape->merge_bh;
-
-        if (tape->chrdev_dir == IDETAPE_DIR_WRITE)
-                atomic_set(&bh->b_count, 0);
-        else {
-                tape->b_data = bh->b_data;
-                tape->b_count = atomic_read(&bh->b_count);
-        }
+        return ide_tape_issue_pc(drive, &cmd, pc);
 }
 
 /*
@@ -1107,10 +821,10 @@ static void __ide_tape_discard_merge_buffer(ide_drive_t *drive)
                 return;
 
         clear_bit(IDE_AFLAG_FILEMARK, &drive->atapi_flags);
-        tape->merge_bh_size = 0;
-        if (tape->merge_bh != NULL) {
-                ide_tape_kfree_buffer(tape);
-                tape->merge_bh = NULL;
+        tape->valid = 0;
+        if (tape->buf != NULL) {
+                kfree(tape->buf);
+                tape->buf = NULL;
         }
 
         tape->chrdev_dir = IDETAPE_DIR_NONE;
@@ -1164,36 +878,44 @@ static void ide_tape_discard_merge_buffer(ide_drive_t *drive,
  * Generate a read/write request for the block device interface and wait for it
  * to be serviced.
  */
-static int idetape_queue_rw_tail(ide_drive_t *drive, int cmd, int blocks,
-                                 struct idetape_bh *bh)
+static int idetape_queue_rw_tail(ide_drive_t *drive, int cmd, int size)
 {
         idetape_tape_t *tape = drive->driver_data;
         struct request *rq;
-        int ret, errors;
+        int ret;
 
         debug_log(DBG_SENSE, "%s: cmd=%d\n", __func__, cmd);
+        BUG_ON(cmd != REQ_IDETAPE_READ && cmd != REQ_IDETAPE_WRITE);
+        BUG_ON(size < 0 || size % tape->blk_size);
 
         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
         rq->cmd_type = REQ_TYPE_SPECIAL;
         rq->cmd[13] = cmd;
         rq->rq_disk = tape->disk;
-        rq->special = (void *)bh;
-        rq->sector = tape->first_frame;
-        rq->nr_sectors = blocks;
-        rq->current_nr_sectors = blocks;
-        blk_execute_rq(drive->queue, tape->disk, rq, 0);
+        rq->__sector = tape->first_frame;
 
-        errors = rq->errors;
-        ret = tape->blk_size * (blocks - rq->current_nr_sectors);
-        blk_put_request(rq);
+        if (size) {
+                ret = blk_rq_map_kern(drive->queue, rq, tape->buf, size,
+                                      __GFP_WAIT);
+                if (ret)
+                        goto out_put;
+        }
 
-        if ((cmd & (REQ_IDETAPE_READ | REQ_IDETAPE_WRITE)) == 0)
-                return 0;
+        blk_execute_rq(drive->queue, tape->disk, rq, 0);
 
-        if (tape->merge_bh)
-                idetape_init_merge_buffer(tape);
-        if (errors == IDE_DRV_ERROR_GENERAL)
-                return -EIO;
+        /* calculate the number of transferred bytes and update buffer state */
+        size -= rq->resid_len;
+        tape->cur = tape->buf;
+        if (cmd == REQ_IDETAPE_READ)
+                tape->valid = size;
+        else
+                tape->valid = 0;
+
+        ret = size;
+        if (rq->errors == IDE_DRV_ERROR_GENERAL)
+                ret = -EIO;
+out_put:
+        blk_put_request(rq);
         return ret;
 }
 
@@ -1230,153 +952,87 @@ static void idetape_create_space_cmd(struct ide_atapi_pc *pc, int count, u8 cmd)
         pc->flags |= PC_FLAG_WAIT_FOR_DSC;
 }
 
-/* Queue up a character device originated write request. */
-static int idetape_add_chrdev_write_request(ide_drive_t *drive, int blocks)
-{
-        idetape_tape_t *tape = drive->driver_data;
-
-        debug_log(DBG_CHRDEV, "Enter %s\n", __func__);
-
-        return idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE,
-                                     blocks, tape->merge_bh);
-}
-
 static void ide_tape_flush_merge_buffer(ide_drive_t *drive)
 {
         idetape_tape_t *tape = drive->driver_data;
-        int blocks, min;
-        struct idetape_bh *bh;
 
         if (tape->chrdev_dir != IDETAPE_DIR_WRITE) {
                 printk(KERN_ERR "ide-tape: bug: Trying to empty merge buffer"
                                 " but we are not writing.\n");
                 return;
         }
-        if (tape->merge_bh_size > tape->buffer_size) {
-                printk(KERN_ERR "ide-tape: bug: merge_buffer too big\n");
-                tape->merge_bh_size = tape->buffer_size;
-        }
-        if (tape->merge_bh_size) {
-                blocks = tape->merge_bh_size / tape->blk_size;
-                if (tape->merge_bh_size % tape->blk_size) {
-                        unsigned int i;
-
-                        blocks++;
-                        i = tape->blk_size - tape->merge_bh_size %
-                                tape->blk_size;
-                        bh = tape->bh->b_reqnext;
-                        while (bh) {
-                                atomic_set(&bh->b_count, 0);
-                                bh = bh->b_reqnext;
-                        }
-                        bh = tape->bh;
-                        while (i) {
-                                if (bh == NULL) {
-                                        printk(KERN_INFO "ide-tape: bug,"
-                                                         " bh NULL\n");
-                                        break;
-                                }
-                                min = min(i, (unsigned int)(bh->b_size -
-                                                atomic_read(&bh->b_count)));
-                                memset(bh->b_data + atomic_read(&bh->b_count),
-                                                0, min);
-                                atomic_add(min, &bh->b_count);
-                                i -= min;
-                                bh = bh->b_reqnext;
-                        }
-                }
-                (void) idetape_add_chrdev_write_request(drive, blocks);
-                tape->merge_bh_size = 0;
-        }
-        if (tape->merge_bh != NULL) {
-                ide_tape_kfree_buffer(tape);
-                tape->merge_bh = NULL;
+        if (tape->buf) {
+                size_t aligned = roundup(tape->valid, tape->blk_size);
+
+                memset(tape->cur, 0, aligned - tape->valid);
+                idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, aligned);
+                kfree(tape->buf);
+                tape->buf = NULL;
         }
         tape->chrdev_dir = IDETAPE_DIR_NONE;
 }
 
-static int idetape_init_read(ide_drive_t *drive)
+static int idetape_init_rw(ide_drive_t *drive, int dir)
 {
         idetape_tape_t *tape = drive->driver_data;
-        int bytes_read;
+        int rc;
 
-        /* Initialize read operation */
-        if (tape->chrdev_dir != IDETAPE_DIR_READ) {
-                if (tape->chrdev_dir == IDETAPE_DIR_WRITE) {
-                        ide_tape_flush_merge_buffer(drive);
-                        idetape_flush_tape_buffers(drive);
-                }
-                if (tape->merge_bh || tape->merge_bh_size) {
-                        printk(KERN_ERR "ide-tape: merge_bh_size should be"
-                                         " 0 now\n");
-                        tape->merge_bh_size = 0;
-                }
-                tape->merge_bh = ide_tape_kmalloc_buffer(tape, 0, 0);
-                if (!tape->merge_bh)
-                        return -ENOMEM;
-                tape->chrdev_dir = IDETAPE_DIR_READ;
+        BUG_ON(dir != IDETAPE_DIR_READ && dir != IDETAPE_DIR_WRITE);
 
-                /*
-                 * Issue a read 0 command to ensure that DSC handshake is
-                 * switched from completion mode to buffer available mode.
-                 * No point in issuing this if DSC overlap isn't supported, some
-                 * drives (Seagate STT3401A) will return an error.
-                 */
-                if (drive->dev_flags & IDE_DFLAG_DSC_OVERLAP) {
-                        bytes_read = idetape_queue_rw_tail(drive,
-                                                        REQ_IDETAPE_READ, 0,
-                                                        tape->merge_bh);
-                        if (bytes_read < 0) {
-                                ide_tape_kfree_buffer(tape);
-                                tape->merge_bh = NULL;
-                                tape->chrdev_dir = IDETAPE_DIR_NONE;
-                                return bytes_read;
-                        }
-                }
-        }
+        if (tape->chrdev_dir == dir)
+                return 0;
 
-        return 0;
-}
+        if (tape->chrdev_dir == IDETAPE_DIR_READ)
+                ide_tape_discard_merge_buffer(drive, 1);
+        else if (tape->chrdev_dir == IDETAPE_DIR_WRITE) {
+                ide_tape_flush_merge_buffer(drive);
+                idetape_flush_tape_buffers(drive);
+        }
 
-/* called from idetape_chrdev_read() to service a chrdev read request. */
-static int idetape_add_chrdev_read_request(ide_drive_t *drive, int blocks)
-{
-        idetape_tape_t *tape = drive->driver_data;
+        if (tape->buf || tape->valid) {
+                printk(KERN_ERR "ide-tape: valid should be 0 now\n");
+                tape->valid = 0;
+        }
 
-        debug_log(DBG_PROCS, "Enter %s, %d blocks\n", __func__, blocks);
+        tape->buf = kmalloc(tape->buffer_size, GFP_KERNEL);
+        if (!tape->buf)
+                return -ENOMEM;
+        tape->chrdev_dir = dir;
+        tape->cur = tape->buf;
 
-        /* If we are at a filemark, return a read length of 0 */
-        if (test_bit(IDE_AFLAG_FILEMARK, &drive->atapi_flags))
-                return 0;
-
-        idetape_init_read(drive);
+        /*
+         * Issue a 0 rw command to ensure that DSC handshake is
+         * switched from completion mode to buffer available mode.  No
+         * point in issuing this if DSC overlap isn't supported, some
+         * drives (Seagate STT3401A) will return an error.
+         */
+        if (drive->dev_flags & IDE_DFLAG_DSC_OVERLAP) {
+                int cmd = dir == IDETAPE_DIR_READ ? REQ_IDETAPE_READ
+                                                  : REQ_IDETAPE_WRITE;
+
+                rc = idetape_queue_rw_tail(drive, cmd, 0);
+                if (rc < 0) {
+                        kfree(tape->buf);
+                        tape->buf = NULL;
+                        tape->chrdev_dir = IDETAPE_DIR_NONE;
+                        return rc;
+                }
+        }
 
-        return idetape_queue_rw_tail(drive, REQ_IDETAPE_READ, blocks,
-                                     tape->merge_bh);
+        return 0;
 }
 
 static void idetape_pad_zeros(ide_drive_t *drive, int bcount)
 {
         idetape_tape_t *tape = drive->driver_data;
-        struct idetape_bh *bh;
-        int blocks;
+
+        memset(tape->buf, 0, tape->buffer_size);
 
         while (bcount) {
-                unsigned int count;
+                unsigned int count = min(tape->buffer_size, bcount);
 
-                bh = tape->merge_bh;
-                count = min(tape->buffer_size, bcount);
+                idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, count);
                 bcount -= count;
-                blocks = count / tape->blk_size;
-                while (count) {
-                        atomic_set(&bh->b_count,
-                                   min(count, (unsigned int)bh->b_size));
-                        memset(bh->b_data, 0, atomic_read(&bh->b_count));
-                        count -= atomic_read(&bh->b_count);
-                        bh = bh->b_reqnext;
-                }
-                idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE, blocks,
-                                      tape->merge_bh);
         }
 }
 
@@ -1456,7 +1112,7 @@ static int idetape_space_over_filemarks(ide_drive_t *drive, short mt_op,
         }
 
         if (tape->chrdev_dir == IDETAPE_DIR_READ) {
-                tape->merge_bh_size = 0;
+                tape->valid = 0;
                 if (test_and_clear_bit(IDE_AFLAG_FILEMARK, &drive->atapi_flags))
                         ++count;
                 ide_tape_discard_merge_buffer(drive, 0);
@@ -1505,9 +1161,9 @@ static ssize_t idetape_chrdev_read(struct file *file, char __user *buf,
 {
         struct ide_tape_obj *tape = file->private_data;
         ide_drive_t *drive = tape->drive;
-        ssize_t bytes_read, temp, actually_read = 0, rc;
+        size_t done = 0;
         ssize_t ret = 0;
-        u16 ctl = *(u16 *)&tape->caps[12];
+        int rc;
 
         debug_log(DBG_CHRDEV, "Enter %s, count %Zd\n", __func__, count);
 
@@ -1517,49 +1173,43 @@ static ssize_t idetape_chrdev_read(struct file *file, char __user *buf,
                             (count % tape->blk_size) == 0)
                                 tape->user_bs_factor = count / tape->blk_size;
         }
-        rc = idetape_init_read(drive);
+
+        rc = idetape_init_rw(drive, IDETAPE_DIR_READ);
         if (rc < 0)
                 return rc;
-        if (count == 0)
-                return (0);
-        if (tape->merge_bh_size) {
-                actually_read = min((unsigned int)(tape->merge_bh_size),
-                                    (unsigned int)count);
-                if (idetape_copy_stage_to_user(tape, buf, actually_read))
-                        ret = -EFAULT;
-                buf += actually_read;
-                tape->merge_bh_size -= actually_read;
-                count -= actually_read;
-        }
-        while (count >= tape->buffer_size) {
-                bytes_read = idetape_add_chrdev_read_request(drive, ctl);
-                if (bytes_read <= 0)
-                        goto finish;
-                if (idetape_copy_stage_to_user(tape, buf, bytes_read))
-                        ret = -EFAULT;
-                buf += bytes_read;
-                count -= bytes_read;
-                actually_read += bytes_read;
-        }
-        if (count) {
-                bytes_read = idetape_add_chrdev_read_request(drive, ctl);
-                if (bytes_read <= 0)
-                        goto finish;
-                temp = min((unsigned long)count, (unsigned long)bytes_read);
-                if (idetape_copy_stage_to_user(tape, buf, temp))
+
+        while (done < count) {
+                size_t todo;
+
+                /* refill if staging buffer is empty */
+                if (!tape->valid) {
+                        /* If we are at a filemark, nothing more to read */
+                        if (test_bit(IDE_AFLAG_FILEMARK, &drive->atapi_flags))
+                                break;
+                        /* read */
+                        if (idetape_queue_rw_tail(drive, REQ_IDETAPE_READ,
+                                                  tape->buffer_size) <= 0)
+                                break;
+                }
+
+                /* copy out */
+                todo = min_t(size_t, count - done, tape->valid);
+                if (copy_to_user(buf + done, tape->cur, todo))
                         ret = -EFAULT;
-                actually_read += temp;
-                tape->merge_bh_size = bytes_read-temp;
+
+                tape->cur += todo;
+                tape->valid -= todo;
+                done += todo;
         }
-finish:
-        if (!actually_read && test_bit(IDE_AFLAG_FILEMARK, &drive->atapi_flags)) {
+
+        if (!done && test_bit(IDE_AFLAG_FILEMARK, &drive->atapi_flags)) {
                 debug_log(DBG_SENSE, "%s: spacing over filemark\n", tape->name);
 
                 idetape_space_over_filemarks(drive, MTFSF, 1);
                 return 0;
         }
 
-        return ret ? ret : actually_read;
+        return ret ? ret : done;
 }
 
 static ssize_t idetape_chrdev_write(struct file *file, const char __user *buf,
@@ -1567,9 +1217,9 @@ static ssize_t idetape_chrdev_write(struct file *file, const char __user *buf,
 {
         struct ide_tape_obj *tape = file->private_data;
         ide_drive_t *drive = tape->drive;
-        ssize_t actually_written = 0;
+        size_t done = 0;
         ssize_t ret = 0;
-        u16 ctl = *(u16 *)&tape->caps[12];
+        int rc;
 
         /* The drive is write protected. */
         if (tape->write_prot)
@@ -1578,80 +1228,31 @@ static ssize_t idetape_chrdev_write(struct file *file, const char __user *buf,
         debug_log(DBG_CHRDEV, "Enter %s, count %Zd\n", __func__, count);
 
         /* Initialize write operation */
-        if (tape->chrdev_dir != IDETAPE_DIR_WRITE) {
-                if (tape->chrdev_dir == IDETAPE_DIR_READ)
-                        ide_tape_discard_merge_buffer(drive, 1);
-                if (tape->merge_bh || tape->merge_bh_size) {
-                        printk(KERN_ERR "ide-tape: merge_bh_size "
-                                "should be 0 now\n");
-                        tape->merge_bh_size = 0;
-                }
-                tape->merge_bh = ide_tape_kmalloc_buffer(tape, 0, 0);
-                if (!tape->merge_bh)
-                        return -ENOMEM;
-                tape->chrdev_dir = IDETAPE_DIR_WRITE;
-                idetape_init_merge_buffer(tape);
+        rc = idetape_init_rw(drive, IDETAPE_DIR_WRITE);
+        if (rc < 0)
+                return rc;
 
-                /*
-                 * Issue a write 0 command to ensure that DSC handshake is
-                 * switched from completion mode to buffer available mode. No
-                 * point in issuing this if DSC overlap isn't supported, some
-                 * drives (Seagate STT3401A) will return an error.
-                 */
-                if (drive->dev_flags & IDE_DFLAG_DSC_OVERLAP) {
-                        ssize_t retval = idetape_queue_rw_tail(drive,
-                                                        REQ_IDETAPE_WRITE, 0,
-                                                        tape->merge_bh);
-                        if (retval < 0) {
-                                ide_tape_kfree_buffer(tape);
-                                tape->merge_bh = NULL;
-                                tape->chrdev_dir = IDETAPE_DIR_NONE;
-                                return retval;
-                        }
-                }
-        }
-        if (count == 0)
-                return (0);
-        if (tape->merge_bh_size) {
-                if (tape->merge_bh_size >= tape->buffer_size) {
-                        printk(KERN_ERR "ide-tape: bug: merge buf too big\n");
-                        tape->merge_bh_size = 0;
-                }
-                actually_written = min((unsigned int)
-                                (tape->buffer_size - tape->merge_bh_size),
-                                (unsigned int)count);
-                if (idetape_copy_stage_from_user(tape, buf, actually_written))
-                                ret = -EFAULT;
-                buf += actually_written;
-                tape->merge_bh_size += actually_written;
-                count -= actually_written;
-
-                if (tape->merge_bh_size == tape->buffer_size) {
-                        ssize_t retval;
-                        tape->merge_bh_size = 0;
-                        retval = idetape_add_chrdev_write_request(drive, ctl);
-                        if (retval <= 0)
-                                return (retval);
-                }
-        }
-        while (count >= tape->buffer_size) {
-                ssize_t retval;
-                if (idetape_copy_stage_from_user(tape, buf, tape->buffer_size))
-                        ret = -EFAULT;
-                buf += tape->buffer_size;
-                count -= tape->buffer_size;
-                retval = idetape_add_chrdev_write_request(drive, ctl);
-                actually_written += tape->buffer_size;
-                if (retval <= 0)
-                        return (retval);
-        }
-        if (count) {
-                actually_written += count;
-                if (idetape_copy_stage_from_user(tape, buf, count))
+        while (done < count) {
+                size_t todo;
+
+                /* flush if staging buffer is full */
+                if (tape->valid == tape->buffer_size &&
+                    idetape_queue_rw_tail(drive, REQ_IDETAPE_WRITE,
+                                          tape->buffer_size) <= 0)
+                        return rc;
+
+                /* copy in */
+                todo = min_t(size_t, count - done,
+                             tape->buffer_size - tape->valid);
+                if (copy_from_user(tape->cur, buf + done, todo))
                         ret = -EFAULT;
-                tape->merge_bh_size += count;
+
+                tape->cur += todo;
+                tape->valid += todo;
+                done += todo;
         }
-        return ret ? ret : actually_written;
+
+        return ret ? ret : done;
 }
 
 static int idetape_write_filemark(ide_drive_t *drive)
@@ -1812,7 +1413,7 @@ static int idetape_chrdev_ioctl(struct inode *inode, struct file *file,
                 idetape_flush_tape_buffers(drive);
         }
         if (cmd == MTIOCGET || cmd == MTIOCPOS) {
-                block_offset = tape->merge_bh_size /
+                block_offset = tape->valid /
                         (tape->blk_size * tape->user_bs_factor);
                 position = idetape_read_position(drive);
                 if (position < 0)
@@ -1960,12 +1561,12 @@ static void idetape_write_release(ide_drive_t *drive, unsigned int minor)
         idetape_tape_t *tape = drive->driver_data;
 
         ide_tape_flush_merge_buffer(drive);
-        tape->merge_bh = ide_tape_kmalloc_buffer(tape, 1, 0);
-        if (tape->merge_bh != NULL) {
+        tape->buf = kmalloc(tape->buffer_size, GFP_KERNEL);
+        if (tape->buf != NULL) {
                 idetape_pad_zeros(drive, tape->blk_size *
                                 (tape->user_bs_factor - 1));
-                ide_tape_kfree_buffer(tape);
-                tape->merge_bh = NULL;
+                kfree(tape->buf);
+                tape->buf = NULL;
         }
         idetape_write_filemark(drive);
         idetape_flush_tape_buffers(drive);
@@ -2159,8 +1760,6 @@ static void idetape_setup(ide_drive_t *drive, idetape_tape_t *tape, int minor)
         u16 *ctl = (u16 *)&tape->caps[12];
 
         drive->pc_callback       = ide_tape_callback;
-        drive->pc_update_buffers = idetape_update_buffers;
-        drive->pc_io_buffers     = ide_tape_io_buffers;
 
         drive->dev_flags |= IDE_DFLAG_DSC_OVERLAP;
 
@@ -2191,11 +1790,6 @@ static void idetape_setup(ide_drive_t *drive, idetape_tape_t *tape, int minor)
                 tape->buffer_size = *ctl * tape->blk_size;
         }
         buffer_size = tape->buffer_size;
-        tape->pages_per_buffer = buffer_size / PAGE_SIZE;
-        if (buffer_size % PAGE_SIZE) {
-                tape->pages_per_buffer++;
-                tape->excess_bh_size = PAGE_SIZE - buffer_size % PAGE_SIZE;
-        }
 
         /* select the "best" DSC read/write polling freq */
         speed = max(*(u16 *)&tape->caps[14], *(u16 *)&tape->caps[8]);
@@ -2238,7 +1832,7 @@ static void ide_tape_release(struct device *dev)
         ide_drive_t *drive = tape->drive;
         struct gendisk *g = tape->disk;
 
-        BUG_ON(tape->merge_bh_size);
+        BUG_ON(tape->valid);
 
         drive->dev_flags &= ~IDE_DFLAG_DSC_OVERLAP;
         drive->driver_data = NULL;
diff --git a/drivers/ide/ide-taskfile.c b/drivers/ide/ide-taskfile.c
index 4aa6223c11be..a0c3e1b2f73c 100644
--- a/drivers/ide/ide-taskfile.c
+++ b/drivers/ide/ide-taskfile.c
@@ -385,7 +385,7 @@ out_end:
         if ((cmd->tf_flags & IDE_TFLAG_FS) == 0)
                 ide_finish_cmd(drive, cmd, stat);
         else
-                ide_complete_rq(drive, 0, cmd->rq->nr_sectors << 9);
+                ide_complete_rq(drive, 0, blk_rq_sectors(cmd->rq) << 9);
         return ide_stopped;
 out_err:
         ide_error_cmd(drive, cmd);
@@ -424,7 +424,9 @@ int ide_raw_taskfile(ide_drive_t *drive, struct ide_cmd *cmd, u8 *buf,
 
         rq = blk_get_request(drive->queue, READ, __GFP_WAIT);
         rq->cmd_type = REQ_TYPE_ATA_TASKFILE;
-        rq->buffer = buf;
+
+        if (cmd->tf_flags & IDE_TFLAG_WRITE)
+                rq->cmd_flags |= REQ_RW;
 
         /*
          * (ks) We transfer currently only whole sectors.
@@ -432,18 +434,20 @@ int ide_raw_taskfile(ide_drive_t *drive, struct ide_cmd *cmd, u8 *buf,
          * if we would find a solution to transfer any size.
          * To support special commands like READ LONG.
          */
-        rq->hard_nr_sectors = rq->nr_sectors = nsect;
-        rq->hard_cur_sectors = rq->current_nr_sectors = nsect;
-
-        if (cmd->tf_flags & IDE_TFLAG_WRITE)
-                rq->cmd_flags |= REQ_RW;
+        if (nsect) {
+                error = blk_rq_map_kern(drive->queue, rq, buf,
+                                        nsect * SECTOR_SIZE, __GFP_WAIT);
+                if (error)
+                        goto put_req;
+        }
 
         rq->special = cmd;
         cmd->rq = rq;
 
         error = blk_execute_rq(drive->queue, NULL, rq, 0);
-        blk_put_request(rq);
 
+put_req:
+        blk_put_request(rq);
         return error;
 }
 
diff --git a/drivers/ide/pdc202xx_old.c b/drivers/ide/pdc202xx_old.c
index b3bc96f930a6..e24ecc87a9b1 100644
--- a/drivers/ide/pdc202xx_old.c
+++ b/drivers/ide/pdc202xx_old.c
@@ -177,7 +177,7 @@ static void pdc202xx_dma_start(ide_drive_t *drive)
                 u8 clock = inb(high_16 + 0x11);
 
                 outb(clock | (hwif->channel ? 0x08 : 0x02), high_16 + 0x11);
-                word_count = (rq->nr_sectors << 8);
+                word_count = (blk_rq_sectors(rq) << 8);
                 word_count = (rq_data_dir(rq) == READ) ?
                                         word_count | 0x05000000 :
                                         word_count | 0x06000000;
diff --git a/drivers/ide/tc86c001.c b/drivers/ide/tc86c001.c
index b4cf42dc8a6f..05a93d6baecc 100644
--- a/drivers/ide/tc86c001.c
+++ b/drivers/ide/tc86c001.c
@@ -112,7 +112,7 @@ static void tc86c001_dma_start(ide_drive_t *drive)
         ide_hwif_t *hwif        = drive->hwif;
         unsigned long sc_base   = hwif->config_data;
         unsigned long twcr_port = sc_base + (drive->dn ? 0x06 : 0x04);
-        unsigned long nsectors  = hwif->rq->nr_sectors;
+        unsigned long nsectors  = blk_rq_sectors(hwif->rq);
 
         /*
          * We have to manually load the sector count and size into
diff --git a/drivers/ide/tx4939ide.c b/drivers/ide/tx4939ide.c
index 564422d23976..5ca76224f6d1 100644
--- a/drivers/ide/tx4939ide.c
+++ b/drivers/ide/tx4939ide.c
@@ -307,7 +307,7 @@ static int tx4939ide_dma_setup(ide_drive_t *drive, struct ide_cmd *cmd)
         tx4939ide_writew(SECTOR_SIZE / 2, base, drive->dn ?
                          TX4939IDE_Xfer_Cnt_2 : TX4939IDE_Xfer_Cnt_1);
 
-        tx4939ide_writew(cmd->rq->nr_sectors, base, TX4939IDE_Sec_Cnt);
+        tx4939ide_writew(blk_rq_sectors(cmd->rq), base, TX4939IDE_Sec_Cnt);
 
         return 0;
 }
diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index 56df1cee8fb3..3319c2fec28e 100644
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -232,7 +232,7 @@ static struct page *read_sb_page(mddev_t *mddev, long offset,
                 target = rdev->sb_start + offset + index * (PAGE_SIZE/512);
 
                 if (sync_page_io(rdev->bdev, target,
-                                 roundup(size, bdev_hardsect_size(rdev->bdev)),
+                                 roundup(size, bdev_logical_block_size(rdev->bdev)),
                                  page, READ)) {
                         page->index = index;
                         attach_page_buffers(page, NULL); /* so that free_buffer will
@@ -287,7 +287,7 @@ static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
                         int size = PAGE_SIZE;
                         if (page->index == bitmap->file_pages-1)
                                 size = roundup(bitmap->last_page_size,
-                                               bdev_hardsect_size(rdev->bdev));
+                                               bdev_logical_block_size(rdev->bdev));
                         /* Just make sure we aren't corrupting data or
                          * metadata
                          */
diff --git a/drivers/md/dm-exception-store.c b/drivers/md/dm-exception-store.c
index a2e26c242141..75d8081a9041 100644
--- a/drivers/md/dm-exception-store.c
+++ b/drivers/md/dm-exception-store.c
@@ -178,7 +178,7 @@ static int set_chunk_size(struct dm_exception_store *store,
         }
 
         /* Validate the chunk size against the device block size */
-        if (chunk_size_ulong % (bdev_hardsect_size(store->cow->bdev) >> 9)) {
+        if (chunk_size_ulong % (bdev_logical_block_size(store->cow->bdev) >> 9)) {
                 *error = "Chunk size is not a multiple of device blocksize";
                 return -EINVAL;
         }
diff --git a/drivers/md/dm-log.c b/drivers/md/dm-log.c
index be233bc4d917..6fa8ccf91c70 100644
--- a/drivers/md/dm-log.c
+++ b/drivers/md/dm-log.c
@@ -413,7 +413,8 @@ static int create_log_context(struct dm_dirty_log *log, struct dm_target *ti,
                  * Buffer holds both header and bitset.
                  */
                 buf_size = dm_round_up((LOG_OFFSET << SECTOR_SHIFT) +
-                                       bitset_size, ti->limits.hardsect_size);
+                                       bitset_size,
+                                       ti->limits.logical_block_size);
 
                 if (buf_size > dev->bdev->bd_inode->i_size) {
                         DMWARN("log device %s too small: need %llu bytes",
diff --git a/drivers/md/dm-snap-persistent.c b/drivers/md/dm-snap-persistent.c
index e75c6dd76a9a..2662a41337e7 100644
--- a/drivers/md/dm-snap-persistent.c
+++ b/drivers/md/dm-snap-persistent.c
@@ -282,7 +282,7 @@ static int read_header(struct pstore *ps, int *new_snapshot)
          */
         if (!ps->store->chunk_size) {
                 ps->store->chunk_size = max(DM_CHUNK_SIZE_DEFAULT_SECTORS,
-                    bdev_hardsect_size(ps->store->cow->bdev) >> 9);
+                    bdev_logical_block_size(ps->store->cow->bdev) >> 9);
                 ps->store->chunk_mask = ps->store->chunk_size - 1;
                 ps->store->chunk_shift = ffs(ps->store->chunk_size) - 1;
                 chunk_size_supplied = 0;
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 429b50b975d5..e9a73bb242b0 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -108,7 +108,8 @@ static void combine_restrictions_low(struct io_restrictions *lhs,
         lhs->max_hw_segments =
                 min_not_zero(lhs->max_hw_segments, rhs->max_hw_segments);
 
-        lhs->hardsect_size = max(lhs->hardsect_size, rhs->hardsect_size);
+        lhs->logical_block_size = max(lhs->logical_block_size,
+                                      rhs->logical_block_size);
 
         lhs->max_segment_size =
                 min_not_zero(lhs->max_segment_size, rhs->max_segment_size);
@@ -509,7 +510,7 @@ void dm_set_device_limits(struct dm_target *ti, struct block_device *bdev)
          *        combine_restrictions_low()
          */
         rs->max_sectors =
-                min_not_zero(rs->max_sectors, q->max_sectors);
+                min_not_zero(rs->max_sectors, queue_max_sectors(q));
 
         /*
          * Check if merge fn is supported.
@@ -524,24 +525,25 @@ void dm_set_device_limits(struct dm_target *ti, struct block_device *bdev)
 
         rs->max_phys_segments =
                 min_not_zero(rs->max_phys_segments,
-                             q->max_phys_segments);
+                             queue_max_phys_segments(q));
 
         rs->max_hw_segments =
-                min_not_zero(rs->max_hw_segments, q->max_hw_segments);
+                min_not_zero(rs->max_hw_segments, queue_max_hw_segments(q));
 
-        rs->hardsect_size = max(rs->hardsect_size, q->hardsect_size);
+        rs->logical_block_size = max(rs->logical_block_size,
+                                     queue_logical_block_size(q));
 
         rs->max_segment_size =
-                min_not_zero(rs->max_segment_size, q->max_segment_size);
+                min_not_zero(rs->max_segment_size, queue_max_segment_size(q));
 
         rs->max_hw_sectors =
-                min_not_zero(rs->max_hw_sectors, q->max_hw_sectors);
+                min_not_zero(rs->max_hw_sectors, queue_max_hw_sectors(q));
 
         rs->seg_boundary_mask =
                 min_not_zero(rs->seg_boundary_mask,
-                             q->seg_boundary_mask);
+                             queue_segment_boundary(q));
 
-        rs->bounce_pfn = min_not_zero(rs->bounce_pfn, q->bounce_pfn);
+        rs->bounce_pfn = min_not_zero(rs->bounce_pfn, queue_bounce_pfn(q));
 
         rs->no_cluster |= !test_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags);
 }
@@ -683,8 +685,8 @@ static void check_for_valid_limits(struct io_restrictions *rs)
                 rs->max_phys_segments = MAX_PHYS_SEGMENTS;
         if (!rs->max_hw_segments)
                 rs->max_hw_segments = MAX_HW_SEGMENTS;
-        if (!rs->hardsect_size)
-                rs->hardsect_size = 1 << SECTOR_SHIFT;
+        if (!rs->logical_block_size)
+                rs->logical_block_size = 1 << SECTOR_SHIFT;
         if (!rs->max_segment_size)
                 rs->max_segment_size = MAX_SEGMENT_SIZE;
         if (!rs->seg_boundary_mask)
@@ -912,13 +914,13 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q)
          * restrictions.
          */
         blk_queue_max_sectors(q, t->limits.max_sectors);
-        q->max_phys_segments = t->limits.max_phys_segments;
-        q->max_hw_segments = t->limits.max_hw_segments;
-        q->hardsect_size = t->limits.hardsect_size;
-        q->max_segment_size = t->limits.max_segment_size;
-        q->max_hw_sectors = t->limits.max_hw_sectors;
-        q->seg_boundary_mask = t->limits.seg_boundary_mask;
-        q->bounce_pfn = t->limits.bounce_pfn;
+        blk_queue_max_phys_segments(q, t->limits.max_phys_segments);
+        blk_queue_max_hw_segments(q, t->limits.max_hw_segments);
+        blk_queue_logical_block_size(q, t->limits.logical_block_size);
+        blk_queue_max_segment_size(q, t->limits.max_segment_size);
+        blk_queue_max_hw_sectors(q, t->limits.max_hw_sectors);
+        blk_queue_segment_boundary(q, t->limits.seg_boundary_mask);
+        blk_queue_bounce_limit(q, t->limits.bounce_pfn);
 
         if (t->limits.no_cluster)
                 queue_flag_clear_unlocked(QUEUE_FLAG_CLUSTER, q);
diff --git a/drivers/md/linear.c b/drivers/md/linear.c
index 7a36e38393a1..64f1f3e046e0 100644
--- a/drivers/md/linear.c
+++ b/drivers/md/linear.c
@@ -146,7 +146,7 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
                  * a one page request is never in violation.
                  */
                 if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
-                    mddev->queue->max_sectors > (PAGE_SIZE>>9))
+                    queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
                         blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
 
                 disk->num_sectors = rdev->sectors;
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 641b211fe3fe..20f6ac338349 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -1202,7 +1202,7 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
         atomic_set(&rdev->corrected_errors, le32_to_cpu(sb->cnt_corrected_read));
 
         rdev->sb_size = le32_to_cpu(sb->max_dev) * 2 + 256;
-        bmask = queue_hardsect_size(rdev->bdev->bd_disk->queue)-1;
+        bmask = queue_logical_block_size(rdev->bdev->bd_disk->queue)-1;
         if (rdev->sb_size & bmask)
                 rdev->sb_size = (rdev->sb_size | bmask) + 1;
 
diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index 41ced0cbe823..4ee31aa13c40 100644
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -303,7 +303,7 @@ static int multipath_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
                  * merge_bvec_fn will be involved in multipath.)
                  */
                         if (q->merge_bvec_fn &&
-                            mddev->queue->max_sectors > (PAGE_SIZE>>9))
+                            queue_max_sectors(q) > (PAGE_SIZE>>9))
                                 blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
 
                         conf->working_disks++;
@@ -467,7 +467,7 @@ static int multipath_run (mddev_t *mddev)
                  * violating it, not that we ever expect a device with
                  * a merge_bvec_fn to be involved in multipath */
                 if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
-                    mddev->queue->max_sectors > (PAGE_SIZE>>9))
+                    queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
                         blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
 
                 if (!test_bit(Faulty, &rdev->flags))
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index c08d7559be55..925507e7d673 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -144,7 +144,7 @@ static int create_strip_zones (mddev_t *mddev)
                  */
 
                 if (rdev1->bdev->bd_disk->queue->merge_bvec_fn &&
-                    mddev->queue->max_sectors > (PAGE_SIZE>>9))
+                    queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
                         blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
 
                 if (!smallest || (rdev1->sectors < smallest->sectors))
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 36df9109cde1..e23758b4a34e 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1130,7 +1130,7 @@ static int raid1_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
                          * a one page request is never in violation.
                          */
                         if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
-                            mddev->queue->max_sectors > (PAGE_SIZE>>9))
+                            queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
                                 blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
 
                         p->head_position = 0;
@@ -1996,7 +1996,7 @@ static int run(mddev_t *mddev)
                  * a one page request is never in violation.
                  */
                 if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
-                    mddev->queue->max_sectors > (PAGE_SIZE>>9))
+                    queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
                         blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
 
                 disk->head_position = 0;
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 499620afb44b..750550c1166f 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1158,8 +1158,8 @@ static int raid10_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
                          * a one page request is never in violation.
                          */
                         if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
-                            mddev->queue->max_sectors > (PAGE_SIZE>>9))
-                                mddev->queue->max_sectors = (PAGE_SIZE>>9);
+                            queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
+                                blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
 
                         p->head_position = 0;
                         rdev->raid_disk = mirror;
@@ -2145,8 +2145,8 @@ static int run(mddev_t *mddev)
                  * a one page request is never in violation.
                  */
                 if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
-                    mddev->queue->max_sectors > (PAGE_SIZE>>9))
-                        mddev->queue->max_sectors = (PAGE_SIZE>>9);
+                    queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
+                        blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
 
                 disk->head_position = 0;
         }
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index bb37fb1b2d82..bef876698232 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -3463,10 +3463,10 @@ static int bio_fits_rdev(struct bio *bi)
 {
         struct request_queue *q = bdev_get_queue(bi->bi_bdev);
 
-        if ((bi->bi_size>>9) > q->max_sectors)
+        if ((bi->bi_size>>9) > queue_max_sectors(q))
                 return 0;
         blk_recount_segments(q, bi);
-        if (bi->bi_phys_segments > q->max_phys_segments)
+        if (bi->bi_phys_segments > queue_max_phys_segments(q))
                 return 0;
 
         if (q->merge_bvec_fn)
diff --git a/drivers/memstick/core/mspro_block.c b/drivers/memstick/core/mspro_block.c
index de143deb06f0..7847bbc1440d 100644
--- a/drivers/memstick/core/mspro_block.c
+++ b/drivers/memstick/core/mspro_block.c
@@ -672,15 +672,14 @@ try_again:
                                                msb->req_sg);
 
                 if (!msb->seg_count) {
-                        chunk = __blk_end_request(msb->block_req, -ENOMEM,
-                                        blk_rq_cur_bytes(msb->block_req));
+                        chunk = __blk_end_request_cur(msb->block_req, -ENOMEM);
                         continue;
                 }
 
-                t_sec = msb->block_req->sector << 9;
+                t_sec = blk_rq_pos(msb->block_req) << 9;
                 sector_div(t_sec, msb->page_size);
 
-                count = msb->block_req->nr_sectors << 9;
+                count = blk_rq_bytes(msb->block_req);
                 count /= msb->page_size;
 
                 param.system = msb->system;
@@ -705,8 +704,8 @@ try_again:
                 return 0;
         }
 
-        dev_dbg(&card->dev, "elv_next\n");
-        msb->block_req = elv_next_request(msb->queue);
+        dev_dbg(&card->dev, "blk_fetch\n");
+        msb->block_req = blk_fetch_request(msb->queue);
         if (!msb->block_req) {
                 dev_dbg(&card->dev, "issue end\n");
                 return -EAGAIN;
@@ -745,7 +744,7 @@ static int mspro_block_complete_req(struct memstick_dev *card, int error)
                                         t_len *= msb->page_size;
                         }
                 } else
-                        t_len = msb->block_req->nr_sectors << 9;
+                        t_len = blk_rq_bytes(msb->block_req);
 
                 dev_dbg(&card->dev, "transferred %x (%d)\n", t_len, error);
 
@@ -825,8 +824,8 @@ static void mspro_block_submit_req(struct request_queue *q)
                 return;
 
         if (msb->eject) {
-                while ((req = elv_next_request(q)) != NULL)
-                        __blk_end_request(req, -ENODEV, blk_rq_bytes(req));
+                while ((req = blk_fetch_request(q)) != NULL)
+                        __blk_end_request_all(req, -ENODEV);
 
                 return;
         }
@@ -1243,7 +1242,7 @@ static int mspro_block_init_disk(struct memstick_dev *card)
 
         sprintf(msb->disk->disk_name, "mspblk%d", disk_id);
 
-        blk_queue_hardsect_size(msb->queue, msb->page_size);
+        blk_queue_logical_block_size(msb->queue, msb->page_size);
 
         capacity = be16_to_cpu(sys_info->user_block_count);
         capacity *= be16_to_cpu(sys_info->block_size);
diff --git a/drivers/message/fusion/mptsas.c b/drivers/message/fusion/mptsas.c
index a9019f081b97..79f5433359f9 100644
--- a/drivers/message/fusion/mptsas.c
+++ b/drivers/message/fusion/mptsas.c
@@ -1277,8 +1277,8 @@ static int mptsas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
         /* do we need to support multiple segments? */
         if (req->bio->bi_vcnt > 1 || rsp->bio->bi_vcnt > 1) {
                 printk(MYIOC_s_ERR_FMT "%s: multiple segments req %u %u, rsp %u %u\n",
-                    ioc->name, __func__, req->bio->bi_vcnt, req->data_len,
-                    rsp->bio->bi_vcnt, rsp->data_len);
+                    ioc->name, __func__, req->bio->bi_vcnt, blk_rq_bytes(req),
+                    rsp->bio->bi_vcnt, blk_rq_bytes(rsp));
                 return -EINVAL;
         }
 
@@ -1295,7 +1295,7 @@ static int mptsas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
         smpreq = (SmpPassthroughRequest_t *)mf;
         memset(smpreq, 0, sizeof(*smpreq));
 
-        smpreq->RequestDataLength = cpu_to_le16(req->data_len - 4);
+        smpreq->RequestDataLength = cpu_to_le16(blk_rq_bytes(req) - 4);
         smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
 
         if (rphy)
@@ -1321,10 +1321,10 @@ static int mptsas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
                        MPI_SGE_FLAGS_END_OF_BUFFER |
                        MPI_SGE_FLAGS_DIRECTION |
                        mpt_addr_size()) << MPI_SGE_FLAGS_SHIFT;
-        flagsLength |= (req->data_len - 4);
+        flagsLength |= (blk_rq_bytes(req) - 4);
 
         dma_addr_out = pci_map_single(ioc->pcidev, bio_data(req->bio),
-                                      req->data_len, PCI_DMA_BIDIRECTIONAL);
+                                      blk_rq_bytes(req), PCI_DMA_BIDIRECTIONAL);
         if (!dma_addr_out)
                 goto put_mf;
         mpt_add_sge(psge, flagsLength, dma_addr_out);
@@ -1332,9 +1332,9 @@ static int mptsas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
 
         /* response */
         flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ;
-        flagsLength |= rsp->data_len + 4;
+        flagsLength |= blk_rq_bytes(rsp) + 4;
         dma_addr_in =  pci_map_single(ioc->pcidev, bio_data(rsp->bio),
-                                      rsp->data_len, PCI_DMA_BIDIRECTIONAL);
+                                      blk_rq_bytes(rsp), PCI_DMA_BIDIRECTIONAL);
         if (!dma_addr_in)
                 goto unmap;
         mpt_add_sge(psge, flagsLength, dma_addr_in);
@@ -1357,8 +1357,8 @@ static int mptsas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
                 smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply;
                 memcpy(req->sense, smprep, sizeof(*smprep));
                 req->sense_len = sizeof(*smprep);
-                req->data_len = 0;
-                rsp->data_len -= smprep->ResponseDataLength;
+                req->resid_len = 0;
+                rsp->resid_len -= smprep->ResponseDataLength;
         } else {
                 printk(MYIOC_s_ERR_FMT "%s: smp passthru reply failed to be returned\n",
                     ioc->name, __func__);
@@ -1366,10 +1366,10 @@ static int mptsas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
         }
 unmap:
         if (dma_addr_out)
-                pci_unmap_single(ioc->pcidev, dma_addr_out, req->data_len,
+                pci_unmap_single(ioc->pcidev, dma_addr_out, blk_rq_bytes(req),
                                  PCI_DMA_BIDIRECTIONAL);
         if (dma_addr_in)
-                pci_unmap_single(ioc->pcidev, dma_addr_in, rsp->data_len,
+                pci_unmap_single(ioc->pcidev, dma_addr_in, blk_rq_bytes(rsp),
                                  PCI_DMA_BIDIRECTIONAL);
 put_mf:
         if (mf)
diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index a443e136dc41..335d4c78a775 100644
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -426,15 +426,9 @@ static void i2o_block_end_request(struct request *req, int error,
         struct request_queue *q = req->q;
         unsigned long flags;
 
-        if (blk_end_request(req, error, nr_bytes)) {
-                int leftover = (req->hard_nr_sectors << KERNEL_SECTOR_SHIFT);
-
-                if (blk_pc_request(req))
-                        leftover = req->data_len;
-
+        if (blk_end_request(req, error, nr_bytes))
                 if (error)
-                        blk_end_request(req, -EIO, leftover);
-        }
+                        blk_end_request_all(req, -EIO);
 
         spin_lock_irqsave(q->queue_lock, flags);
 
@@ -761,7 +755,7 @@ static int i2o_block_transfer(struct request *req)
                         break;
 
                 case CACHE_SMARTFETCH:
-                        if (req->nr_sectors > 16)
+                        if (blk_rq_sectors(req) > 16)
                                 ctl_flags = 0x201F0008;
                         else
                                 ctl_flags = 0x001F0000;
@@ -781,13 +775,13 @@ static int i2o_block_transfer(struct request *req)
                         ctl_flags = 0x001F0010;
                         break;
                 case CACHE_SMARTBACK:
-                        if (req->nr_sectors > 16)
+                        if (blk_rq_sectors(req) > 16)
                                 ctl_flags = 0x001F0004;
                         else
                                 ctl_flags = 0x001F0010;
                         break;
                 case CACHE_SMARTTHROUGH:
-                        if (req->nr_sectors > 16)
+                        if (blk_rq_sectors(req) > 16)
                                 ctl_flags = 0x001F0004;
                         else
                                 ctl_flags = 0x001F0010;
@@ -800,8 +794,9 @@ static int i2o_block_transfer(struct request *req)
         if (c->adaptec) {
                 u8 cmd[10];
                 u32 scsi_flags;
-                u16 hwsec = queue_hardsect_size(req->q) >> KERNEL_SECTOR_SHIFT;
+                u16 hwsec;
 
+                hwsec = queue_logical_block_size(req->q) >> KERNEL_SECTOR_SHIFT;
                 memset(cmd, 0, 10);
 
                 sgl_offset = SGL_OFFSET_12;
@@ -827,22 +822,22 @@ static int i2o_block_transfer(struct request *req)
 
                 *mptr++ = cpu_to_le32(scsi_flags);
 
-                *((u32 *) & cmd[2]) = cpu_to_be32(req->sector * hwsec);
-                *((u16 *) & cmd[7]) = cpu_to_be16(req->nr_sectors * hwsec);
+                *((u32 *) & cmd[2]) = cpu_to_be32(blk_rq_pos(req) * hwsec);
+                *((u16 *) & cmd[7]) = cpu_to_be16(blk_rq_sectors(req) * hwsec);
 
                 memcpy(mptr, cmd, 10);
                 mptr += 4;
-                *mptr++ = cpu_to_le32(req->nr_sectors << KERNEL_SECTOR_SHIFT);
+                *mptr++ = cpu_to_le32(blk_rq_bytes(req));
         } else
 #endif
         {
                 msg->u.head[1] = cpu_to_le32(cmd | HOST_TID << 12 | tid);
                 *mptr++ = cpu_to_le32(ctl_flags);
-                *mptr++ = cpu_to_le32(req->nr_sectors << KERNEL_SECTOR_SHIFT);
+                *mptr++ = cpu_to_le32(blk_rq_bytes(req));
                 *mptr++ =
-                    cpu_to_le32((u32) (req->sector << KERNEL_SECTOR_SHIFT));
+                    cpu_to_le32((u32) (blk_rq_pos(req) << KERNEL_SECTOR_SHIFT));
                 *mptr++ =
-                    cpu_to_le32(req->sector >> (32 - KERNEL_SECTOR_SHIFT));
+                    cpu_to_le32(blk_rq_pos(req) >> (32 - KERNEL_SECTOR_SHIFT));
         }
 
         if (!i2o_block_sglist_alloc(c, ireq, &mptr)) {
@@ -883,7 +878,7 @@ static void i2o_block_request_fn(struct request_queue *q)
         struct request *req;
 
         while (!blk_queue_plugged(q)) {
-                req = elv_next_request(q);
+                req = blk_peek_request(q);
                 if (!req)
                         break;
 
@@ -896,7 +891,7 @@ static void i2o_block_request_fn(struct request_queue *q)
 
                         if (queue_depth < I2O_BLOCK_MAX_OPEN_REQUESTS) {
                                 if (!i2o_block_transfer(req)) {
-                                        blkdev_dequeue_request(req);
+                                        blk_start_request(req);
                                         continue;
                                 } else
                                         osm_info("transfer error\n");
@@ -922,8 +917,10 @@ static void i2o_block_request_fn(struct request_queue *q)
                                 blk_stop_queue(q);
                                 break;
                         }
-                } else
-                        end_request(req, 0);
+                } else {
+                        blk_start_request(req);
+                        __blk_end_request_all(req, -EIO);
+                }
         }
 };
 
@@ -1082,7 +1079,7 @@ static int i2o_block_probe(struct device *dev)
          */
         if (!i2o_parm_field_get(i2o_dev, 0x0004, 1, &blocksize, 4) ||
             !i2o_parm_field_get(i2o_dev, 0x0000, 3, &blocksize, 4)) {
-                blk_queue_hardsect_size(queue, le32_to_cpu(blocksize));
+                blk_queue_logical_block_size(queue, le32_to_cpu(blocksize));
         } else
                 osm_warn("unable to get blocksize of %s\n", gd->disk_name);
 
diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index b25e9b6516ae..98ffc41eaf2c 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -243,7 +243,7 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
                 brq.mrq.cmd = &brq.cmd;
                 brq.mrq.data = &brq.data;
 
-                brq.cmd.arg = req->sector;
+                brq.cmd.arg = blk_rq_pos(req);
                 if (!mmc_card_blockaddr(card))
                         brq.cmd.arg <<= 9;
                 brq.cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC;
@@ -251,7 +251,7 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
                 brq.stop.opcode = MMC_STOP_TRANSMISSION;
                 brq.stop.arg = 0;
                 brq.stop.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC;
-                brq.data.blocks = req->nr_sectors;
+                brq.data.blocks = blk_rq_sectors(req);
 
                 /*
                  * The block layer doesn't support all sector count
@@ -301,7 +301,7 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
                  * Adjust the sg list so it is the same size as the
                  * request.
                  */
-                if (brq.data.blocks != req->nr_sectors) {
+                if (brq.data.blocks != blk_rq_sectors(req)) {
                         int i, data_size = brq.data.blocks << 9;
                         struct scatterlist *sg;
 
@@ -352,8 +352,8 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
                         printk(KERN_ERR "%s: error %d transferring data,"
                                " sector %u, nr %u, card status %#x\n",
                                req->rq_disk->disk_name, brq.data.error,
-                               (unsigned)req->sector,
-                               (unsigned)req->nr_sectors, status);
+                               (unsigned)blk_rq_pos(req),
+                               (unsigned)blk_rq_sectors(req), status);
                 }
 
                 if (brq.stop.error) {
@@ -521,7 +521,7 @@ static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card)
 
         sprintf(md->disk->disk_name, "mmcblk%d", devidx);
 
-        blk_queue_hardsect_size(md->queue.queue, 512);
+        blk_queue_logical_block_size(md->queue.queue, 512);
 
         if (!mmc_card_sd(card) && mmc_card_blockaddr(card)) {
                 /*
diff --git a/drivers/mmc/card/queue.c b/drivers/mmc/card/queue.c
index 7a72e75d5c67..49e582356c65 100644
--- a/drivers/mmc/card/queue.c
+++ b/drivers/mmc/card/queue.c
@@ -55,7 +55,7 @@ static int mmc_queue_thread(void *d)
                 spin_lock_irq(q->queue_lock);
                 set_current_state(TASK_INTERRUPTIBLE);
                 if (!blk_queue_plugged(q))
-                        req = elv_next_request(q);
+                        req = blk_fetch_request(q);
                 mq->req = req;
                 spin_unlock_irq(q->queue_lock);
 
@@ -88,16 +88,11 @@ static void mmc_request(struct request_queue *q)
 {
         struct mmc_queue *mq = q->queuedata;
         struct request *req;
-        int ret;
 
         if (!mq) {
                 printk(KERN_ERR "MMC: killing requests for dead queue\n");
-                while ((req = elv_next_request(q)) != NULL) {
-                        do {
-                                ret = __blk_end_request(req, -EIO,
-                                                        blk_rq_cur_bytes(req));
-                        } while (ret);
-                }
+                while ((req = blk_fetch_request(q)) != NULL)
+                        __blk_end_request_all(req, -EIO);
                 return;
         }
 
diff --git a/drivers/mtd/mtd_blkdevs.c b/drivers/mtd/mtd_blkdevs.c
index a49a9c8f2cb1..aaac3b6800b7 100644
--- a/drivers/mtd/mtd_blkdevs.c
+++ b/drivers/mtd/mtd_blkdevs.c
@@ -47,40 +47,41 @@ static int do_blktrans_request(struct mtd_blktrans_ops *tr,
         unsigned long block, nsect;
         char *buf;
 
-        block = req->sector << 9 >> tr->blkshift;
-        nsect = req->current_nr_sectors << 9 >> tr->blkshift;
+        block = blk_rq_pos(req) << 9 >> tr->blkshift;
+        nsect = blk_rq_cur_bytes(req) >> tr->blkshift;
 
         buf = req->buffer;
 
         if (req->cmd_type == REQ_TYPE_LINUX_BLOCK &&
             req->cmd[0] == REQ_LB_OP_DISCARD)
-                return !tr->discard(dev, block, nsect);
+                return tr->discard(dev, block, nsect);
 
         if (!blk_fs_request(req))
-                return 0;
+                return -EIO;
 
-        if (req->sector + req->current_nr_sectors > get_capacity(req->rq_disk))
-                return 0;
+        if (blk_rq_pos(req) + blk_rq_cur_sectors(req) >
+            get_capacity(req->rq_disk))
+                return -EIO;
 
         switch(rq_data_dir(req)) {
         case READ:
                 for (; nsect > 0; nsect--, block++, buf += tr->blksize)
                         if (tr->readsect(dev, block, buf))
-                                return 0;
-                return 1;
+                                return -EIO;
+                return 0;
 
         case WRITE:
                 if (!tr->writesect)
-                        return 0;
+                        return -EIO;
 
                 for (; nsect > 0; nsect--, block++, buf += tr->blksize)
                         if (tr->writesect(dev, block, buf))
-                                return 0;
-                return 1;
+                                return -EIO;
+                return 0;
 
         default:
                 printk(KERN_NOTICE "Unknown request %u\n", rq_data_dir(req));
-                return 0;
+                return -EIO;
         }
 }
 
@@ -88,19 +89,18 @@ static int mtd_blktrans_thread(void *arg)
 {
         struct mtd_blktrans_ops *tr = arg;
         struct request_queue *rq = tr->blkcore_priv->rq;
+        struct request *req = NULL;
 
         /* we might get involved when memory gets low, so use PF_MEMALLOC */
         current->flags |= PF_MEMALLOC;
 
         spin_lock_irq(rq->queue_lock);
+
         while (!kthread_should_stop()) {
-                struct request *req;
                 struct mtd_blktrans_dev *dev;
-                int res = 0;
-
-                req = elv_next_request(rq);
+                int res;
 
-                if (!req) {
+                if (!req && !(req = blk_fetch_request(rq))) {
                         set_current_state(TASK_INTERRUPTIBLE);
                         spin_unlock_irq(rq->queue_lock);
                         schedule();
@@ -119,8 +119,13 @@ static int mtd_blktrans_thread(void *arg)
 
                 spin_lock_irq(rq->queue_lock);
 
-                end_request(req, res);
+                if (!__blk_end_request_cur(req, res))
+                        req = NULL;
         }
+
+        if (req)
+                __blk_end_request_all(req, -EIO);
+
         spin_unlock_irq(rq->queue_lock);
 
         return 0;
@@ -373,7 +378,7 @@ int register_mtd_blktrans(struct mtd_blktrans_ops *tr)
         }
 
         tr->blkcore_priv->rq->queuedata = tr;
-        blk_queue_hardsect_size(tr->blkcore_priv->rq, tr->blksize);
+        blk_queue_logical_block_size(tr->blkcore_priv->rq, tr->blksize);
         if (tr->discard)
                 blk_queue_set_discard(tr->blkcore_priv->rq,
                                       blktrans_discard_request);
diff --git a/drivers/parport/parport_pc.c b/drivers/parport/parport_pc.c
index 4e63cc9e2778..151bf5bc8afe 100644
--- a/drivers/parport/parport_pc.c
+++ b/drivers/parport/parport_pc.c
@@ -1,5 +1,5 @@
 /* Low-level parallel-port routines for 8255-based PC-style hardware.
- * 
+ *
  * Authors: Phil Blundell <philb@gnu.org>
  *          Tim Waugh <tim@cyberelk.demon.co.uk>
  *          Jose Renau <renau@acm.org>
@@ -11,7 +11,7 @@
  * Cleaned up include files - Russell King <linux@arm.uk.linux.org>
  * DMA support - Bert De Jonghe <bert@sophis.be>
  * Many ECP bugs fixed.  Fred Barnes & Jamie Lokier, 1999
- * More PCI support now conditional on CONFIG_PCI, 03/2001, Paul G. 
+ * More PCI support now conditional on CONFIG_PCI, 03/2001, Paul G.
  * Various hacks, Fred Barnes, 04/2001
  * Updated probing logic - Adam Belay <ambx1@neo.rr.com>
  */
@@ -56,10 +56,10 @@
 #include <linux/pnp.h>
 #include <linux/platform_device.h>
 #include <linux/sysctl.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 
-#include <asm/io.h>
 #include <asm/dma.h>
-#include <asm/uaccess.h>
 
 #include <linux/parport.h>
 #include <linux/parport_pc.h>
@@ -82,7 +82,7 @@
 #define ECR_TST 06
 #define ECR_CNF 07
 #define ECR_MODE_MASK 0xe0
-#define ECR_WRITE(p,v) frob_econtrol((p),0xff,(v))
+#define ECR_WRITE(p, v) frob_econtrol((p), 0xff, (v))
 
 #undef DEBUG
 
@@ -109,27 +109,27 @@ static int pci_registered_parport;
 static int pnp_registered_parport;
 
 /* frob_control, but for ECR */
-static void frob_econtrol (struct parport *pb, unsigned char m,
+static void frob_econtrol(struct parport *pb, unsigned char m,
                            unsigned char v)
 {
         unsigned char ectr = 0;
 
         if (m != 0xff)
-                ectr = inb (ECONTROL (pb));
+                ectr = inb(ECONTROL(pb));
 
-        DPRINTK (KERN_DEBUG "frob_econtrol(%02x,%02x): %02x -> %02x\n",
+        DPRINTK(KERN_DEBUG "frob_econtrol(%02x,%02x): %02x -> %02x\n",
                 m, v, ectr, (ectr & ~m) ^ v);
 
-        outb ((ectr & ~m) ^ v, ECONTROL (pb));
+        outb((ectr & ~m) ^ v, ECONTROL(pb));
 }
 
-static __inline__ void frob_set_mode (struct parport *p, int mode)
+static inline void frob_set_mode(struct parport *p, int mode)
 {
-        frob_econtrol (p, ECR_MODE_MASK, mode << 5);
+        frob_econtrol(p, ECR_MODE_MASK, mode << 5);
 }
 
 #ifdef CONFIG_PARPORT_PC_FIFO
-/* Safely change the mode bits in the ECR 
+/* Safely change the mode bits in the ECR
    Returns:
             0    : Success
            -EBUSY: Could not drain FIFO in some finite amount of time,
@@ -141,17 +141,18 @@ static int change_mode(struct parport *p, int m)
         unsigned char oecr;
         int mode;
 
-        DPRINTK(KERN_INFO "parport change_mode ECP-ISA to mode 0x%02x\n",m);
+        DPRINTK(KERN_INFO "parport change_mode ECP-ISA to mode 0x%02x\n", m);
 
         if (!priv->ecr) {
-                printk (KERN_DEBUG "change_mode: but there's no ECR!\n");
+                printk(KERN_DEBUG "change_mode: but there's no ECR!\n");
                 return 0;
         }
 
         /* Bits <7:5> contain the mode. */
-        oecr = inb (ECONTROL (p));
+        oecr = inb(ECONTROL(p));
         mode = (oecr >> 5) & 0x7;
-        if (mode == m) return 0;
+        if (mode == m)
+                return 0;
 
         if (mode >= 2 && !(priv->ctr & 0x20)) {
                 /* This mode resets the FIFO, so we may
@@ -163,19 +164,21 @@ static int change_mode(struct parport *p, int m)
                 case ECR_ECP: /* ECP Parallel Port mode */
                         /* Busy wait for 200us */
                         for (counter = 0; counter < 40; counter++) {
-                                if (inb (ECONTROL (p)) & 0x01)
+                                if (inb(ECONTROL(p)) & 0x01)
+                                        break;
+                                if (signal_pending(current))
                                         break;
-                                if (signal_pending (current)) break;
-                                udelay (5);
+                                udelay(5);
                         }
 
                         /* Poll slowly. */
-                        while (!(inb (ECONTROL (p)) & 0x01)) {
-                                if (time_after_eq (jiffies, expire))
+                        while (!(inb(ECONTROL(p)) & 0x01)) {
+                                if (time_after_eq(jiffies, expire))
                                         /* The FIFO is stuck. */
                                         return -EBUSY;
-                                schedule_timeout_interruptible(msecs_to_jiffies(10));
-                                if (signal_pending (current))
+                                schedule_timeout_interruptible(
+                                                        msecs_to_jiffies(10));
+                                if (signal_pending(current))
                                         break;
                         }
                 }
@@ -185,20 +188,20 @@ static int change_mode(struct parport *p, int m)
                 /* We have to go through mode 001 */
                 oecr &= ~(7 << 5);
                 oecr |= ECR_PS2 << 5;
-                ECR_WRITE (p, oecr);
+                ECR_WRITE(p, oecr);
         }
 
         /* Set the mode. */
         oecr &= ~(7 << 5);
         oecr |= m << 5;
-        ECR_WRITE (p, oecr);
+        ECR_WRITE(p, oecr);
         return 0;
 }
 
 #ifdef CONFIG_PARPORT_1284
 /* Find FIFO lossage; FIFO is reset */
 #if 0
-static int get_fifo_residue (struct parport *p)
+static int get_fifo_residue(struct parport *p)
 {
         int residue;
         int cnfga;
@@ -206,26 +209,26 @@ static int get_fifo_residue (struct parport *p)
 
         /* Adjust for the contents of the FIFO. */
         for (residue = priv->fifo_depth; ; residue--) {
-                if (inb (ECONTROL (p)) & 0x2)
+                if (inb(ECONTROL(p)) & 0x2)
                                 /* Full up. */
                         break;
 
-                outb (0, FIFO (p));
+                outb(0, FIFO(p));
         }
 
-        printk (KERN_DEBUG "%s: %d PWords were left in FIFO\n", p->name,
+        printk(KERN_DEBUG "%s: %d PWords were left in FIFO\n", p->name,
                 residue);
 
         /* Reset the FIFO. */
-        frob_set_mode (p, ECR_PS2);
+        frob_set_mode(p, ECR_PS2);
 
         /* Now change to config mode and clean up. FIXME */
-        frob_set_mode (p, ECR_CNF);
-        cnfga = inb (CONFIGA (p));
-        printk (KERN_DEBUG "%s: cnfgA contains 0x%02x\n", p->name, cnfga);
+        frob_set_mode(p, ECR_CNF);
+        cnfga = inb(CONFIGA(p));
+        printk(KERN_DEBUG "%s: cnfgA contains 0x%02x\n", p->name, cnfga);
 
         if (!(cnfga & (1<<2))) {
-                printk (KERN_DEBUG "%s: Accounting for extra byte\n", p->name);
+                printk(KERN_DEBUG "%s: Accounting for extra byte\n", p->name);
                 residue++;
         }
 
@@ -233,9 +236,11 @@ static int get_fifo_residue (struct parport *p)
          * PWord != 1 byte. */
 
         /* Back to PS2 mode. */
-        frob_set_mode (p, ECR_PS2);
+        frob_set_mode(p, ECR_PS2);
 
-        DPRINTK (KERN_DEBUG "*** get_fifo_residue: done residue collecting (ecr = 0x%2.2x)\n", inb (ECONTROL (p)));
+        DPRINTK(KERN_DEBUG
+             "*** get_fifo_residue: done residue collecting (ecr = 0x%2.2x)\n",
+                                                        inb(ECONTROL(p)));
         return residue;
 }
 #endif  /*  0 */
@@ -257,8 +262,8 @@ static int clear_epp_timeout(struct parport *pb)
         /* To clear timeout some chips require double read */
         parport_pc_read_status(pb);
         r = parport_pc_read_status(pb);
-        outb (r | 0x01, STATUS (pb)); /* Some reset by writing 1 */
-        outb (r & 0xfe, STATUS (pb)); /* Others by writing 0 */
+        outb(r | 0x01, STATUS(pb)); /* Some reset by writing 1 */
+        outb(r & 0xfe, STATUS(pb)); /* Others by writing 0 */
         r = parport_pc_read_status(pb);
 
         return !(r & 0x01);
@@ -272,7 +277,8 @@ static int clear_epp_timeout(struct parport *pb)
  * of these are in parport_pc.h.
  */
 
-static void parport_pc_init_state(struct pardevice *dev, struct parport_state *s)
+static void parport_pc_init_state(struct pardevice *dev,
+                                                struct parport_state *s)
 {
         s->u.pc.ctr = 0xc;
         if (dev->irq_func &&
@@ -289,22 +295,23 @@ static void parport_pc_save_state(struct parport *p, struct parport_state *s)
         const struct parport_pc_private *priv = p->physport->private_data;
         s->u.pc.ctr = priv->ctr;
         if (priv->ecr)
-                s->u.pc.ecr = inb (ECONTROL (p));
+                s->u.pc.ecr = inb(ECONTROL(p));
 }
 
-static void parport_pc_restore_state(struct parport *p, struct parport_state *s)
+static void parport_pc_restore_state(struct parport *p,
+                                                struct parport_state *s)
 {
         struct parport_pc_private *priv = p->physport->private_data;
         register unsigned char c = s->u.pc.ctr & priv->ctr_writable;
-        outb (c, CONTROL (p));
+        outb(c, CONTROL(p));
         priv->ctr = c;
         if (priv->ecr)
-                ECR_WRITE (p, s->u.pc.ecr);
+                ECR_WRITE(p, s->u.pc.ecr);
 }
 
 #ifdef CONFIG_PARPORT_1284
-static size_t parport_pc_epp_read_data (struct parport *port, void *buf,
-                                        size_t length, int flags)
+static size_t parport_pc_epp_read_data(struct parport *port, void *buf,
+                                       size_t length, int flags)
 {
         size_t got = 0;
 
@@ -316,54 +323,52 @@ static size_t parport_pc_epp_read_data (struct parport *port, void *buf,
                  *  nFault is 0 if there is at least 1 byte in the Warp's FIFO
                  *  pError is 1 if there are 16 bytes in the Warp's FIFO
                  */
-                status = inb (STATUS (port));
+                status = inb(STATUS(port));
 
-                while (!(status & 0x08) && (got < length)) {
-                        if ((left >= 16) && (status & 0x20) && !(status & 0x08)) {
+                while (!(status & 0x08) && got < length) {
+                        if (left >= 16 && (status & 0x20) && !(status & 0x08)) {
                                 /* can grab 16 bytes from warp fifo */
-                                if (!((long)buf & 0x03)) {
-                                        insl (EPPDATA (port), buf, 4);
-                                } else {
-                                        insb (EPPDATA (port), buf, 16);
-                                }
+                                if (!((long)buf & 0x03))
+                                        insl(EPPDATA(port), buf, 4);
+                                else
+                                        insb(EPPDATA(port), buf, 16);
                                 buf += 16;
                                 got += 16;
                                 left -= 16;
                         } else {
                                 /* grab single byte from the warp fifo */
-                                *((char *)buf) = inb (EPPDATA (port));
+                                *((char *)buf) = inb(EPPDATA(port));
                                 buf++;
                                 got++;
                                 left--;
                         }
-                        status = inb (STATUS (port));
+                        status = inb(STATUS(port));
                         if (status & 0x01) {
                                 /* EPP timeout should never occur... */
-                                printk (KERN_DEBUG "%s: EPP timeout occurred while talking to "
-                                        "w91284pic (should not have done)\n", port->name);
-                                clear_epp_timeout (port);
+                                printk(KERN_DEBUG
+"%s: EPP timeout occurred while talking to w91284pic (should not have done)\n", port->name);
+                                clear_epp_timeout(port);
                         }
                 }
                 return got;
         }
         if ((flags & PARPORT_EPP_FAST) && (length > 1)) {
-                if (!(((long)buf | length) & 0x03)) {
-                        insl (EPPDATA (port), buf, (length >> 2));
-                } else {
-                        insb (EPPDATA (port), buf, length);
-                }
-                if (inb (STATUS (port)) & 0x01) {
-                        clear_epp_timeout (port);
+                if (!(((long)buf | length) & 0x03))
+                        insl(EPPDATA(port), buf, (length >> 2));
+                else
+                        insb(EPPDATA(port), buf, length);
+                if (inb(STATUS(port)) & 0x01) {
+                        clear_epp_timeout(port);
                         return -EIO;
                 }
                 return length;
         }
         for (; got < length; got++) {
-                *((char*)buf) = inb (EPPDATA(port));
+                *((char *)buf) = inb(EPPDATA(port));
                 buf++;
-                if (inb (STATUS (port)) & 0x01) {
+                if (inb(STATUS(port)) & 0x01) {
                         /* EPP timeout */
-                        clear_epp_timeout (port);
+                        clear_epp_timeout(port);
                         break;
                 }
         }
@@ -371,28 +376,27 @@ static size_t parport_pc_epp_read_data (struct parport *port, void *buf,
         return got;
 }
 
-static size_t parport_pc_epp_write_data (struct parport *port, const void *buf,
-                                         size_t length, int flags)
+static size_t parport_pc_epp_write_data(struct parport *port, const void *buf,
+                                        size_t length, int flags)
 {
         size_t written = 0;
 
         if ((flags & PARPORT_EPP_FAST) && (length > 1)) {
-                if (!(((long)buf | length) & 0x03)) {
-                        outsl (EPPDATA (port), buf, (length >> 2));
-                } else {
-                        outsb (EPPDATA (port), buf, length);
-                }
-                if (inb (STATUS (port)) & 0x01) {
-                        clear_epp_timeout (port);
+                if (!(((long)buf | length) & 0x03))
+                        outsl(EPPDATA(port), buf, (length >> 2));
+                else
+                        outsb(EPPDATA(port), buf, length);
+                if (inb(STATUS(port)) & 0x01) {
+                        clear_epp_timeout(port);
                         return -EIO;
                 }
                 return length;
         }
         for (; written < length; written++) {
-                outb (*((char*)buf), EPPDATA(port));
+                outb(*((char *)buf), EPPDATA(port));
                 buf++;
-                if (inb (STATUS(port)) & 0x01) {
-                        clear_epp_timeout (port);
+                if (inb(STATUS(port)) & 0x01) {
+                        clear_epp_timeout(port);
                         break;
                 }
         }
@@ -400,24 +404,24 @@ static size_t parport_pc_epp_write_data (struct parport *port, const void *buf,
         return written;
 }
 
-static size_t parport_pc_epp_read_addr (struct parport *port, void *buf,
+static size_t parport_pc_epp_read_addr(struct parport *port, void *buf,
                                         size_t length, int flags)
 {
         size_t got = 0;
 
         if ((flags & PARPORT_EPP_FAST) && (length > 1)) {
-                insb (EPPADDR (port), buf, length);
-                if (inb (STATUS (port)) & 0x01) {
-                        clear_epp_timeout (port);
+                insb(EPPADDR(port), buf, length);
+                if (inb(STATUS(port)) & 0x01) {
+                        clear_epp_timeout(port);
                         return -EIO;
                 }
                 return length;
         }
         for (; got < length; got++) {
-                *((char*)buf) = inb (EPPADDR (port));
+                *((char *)buf) = inb(EPPADDR(port));
                 buf++;
-                if (inb (STATUS (port)) & 0x01) {
-                        clear_epp_timeout (port);
+                if (inb(STATUS(port)) & 0x01) {
+                        clear_epp_timeout(port);
                         break;
                 }
         }
@@ -425,25 +429,25 @@ static size_t parport_pc_epp_read_addr (struct parport *port, void *buf,
         return got;
 }
 
-static size_t parport_pc_epp_write_addr (struct parport *port,
+static size_t parport_pc_epp_write_addr(struct parport *port,
                                          const void *buf, size_t length,
                                          int flags)
 {
         size_t written = 0;
 
         if ((flags & PARPORT_EPP_FAST) && (length > 1)) {
-                outsb (EPPADDR (port), buf, length);
-                if (inb (STATUS (port)) & 0x01) {
-                        clear_epp_timeout (port);
+                outsb(EPPADDR(port), buf, length);
+                if (inb(STATUS(port)) & 0x01) {
+                        clear_epp_timeout(port);
                         return -EIO;
                 }
                 return length;
         }
         for (; written < length; written++) {
-                outb (*((char*)buf), EPPADDR (port));
+                outb(*((char *)buf), EPPADDR(port));
                 buf++;
-                if (inb (STATUS (port)) & 0x01) {
-                        clear_epp_timeout (port);
+                if (inb(STATUS(port)) & 0x01) {
+                        clear_epp_timeout(port);
                         break;
                 }
         }
@@ -451,74 +455,74 @@ static size_t parport_pc_epp_write_addr (struct parport *port,
         return written;
 }
 
-static size_t parport_pc_ecpepp_read_data (struct parport *port, void *buf,
-                                           size_t length, int flags)
+static size_t parport_pc_ecpepp_read_data(struct parport *port, void *buf,
+                                          size_t length, int flags)
 {
         size_t got;
 
-        frob_set_mode (port, ECR_EPP);
-        parport_pc_data_reverse (port);
-        parport_pc_write_control (port, 0x4);
-        got = parport_pc_epp_read_data (port, buf, length, flags);
-        frob_set_mode (port, ECR_PS2);
+        frob_set_mode(port, ECR_EPP);
+        parport_pc_data_reverse(port);
+        parport_pc_write_control(port, 0x4);
+        got = parport_pc_epp_read_data(port, buf, length, flags);
+        frob_set_mode(port, ECR_PS2);
 
         return got;
 }
 
-static size_t parport_pc_ecpepp_write_data (struct parport *port,
-                                            const void *buf, size_t length,
-                                            int flags)
+static size_t parport_pc_ecpepp_write_data(struct parport *port,
+                                           const void *buf, size_t length,
+                                           int flags)
 {
         size_t written;
 
-        frob_set_mode (port, ECR_EPP);
-        parport_pc_write_control (port, 0x4);
-        parport_pc_data_forward (port);
-        written = parport_pc_epp_write_data (port, buf, length, flags);
-        frob_set_mode (port, ECR_PS2);
+        frob_set_mode(port, ECR_EPP);
+        parport_pc_write_control(port, 0x4);
+        parport_pc_data_forward(port);
+        written = parport_pc_epp_write_data(port, buf, length, flags);
+        frob_set_mode(port, ECR_PS2);
 
         return written;
 }
 
-static size_t parport_pc_ecpepp_read_addr (struct parport *port, void *buf,
-                                           size_t length, int flags)
+static size_t parport_pc_ecpepp_read_addr(struct parport *port, void *buf,
+                                          size_t length, int flags)
 {
         size_t got;
 
-        frob_set_mode (port, ECR_EPP);
-        parport_pc_data_reverse (port);
-        parport_pc_write_control (port, 0x4);
-        got = parport_pc_epp_read_addr (port, buf, length, flags);
-        frob_set_mode (port, ECR_PS2);
+        frob_set_mode(port, ECR_EPP);
+        parport_pc_data_reverse(port);
+        parport_pc_write_control(port, 0x4);
+        got = parport_pc_epp_read_addr(port, buf, length, flags);
+        frob_set_mode(port, ECR_PS2);
 
         return got;
 }
 
-static size_t parport_pc_ecpepp_write_addr (struct parport *port,
+static size_t parport_pc_ecpepp_write_addr(struct parport *port,
                                             const void *buf, size_t length,
                                             int flags)
 {
         size_t written;
 
-        frob_set_mode (port, ECR_EPP);
-        parport_pc_write_control (port, 0x4);
-        parport_pc_data_forward (port);
-        written = parport_pc_epp_write_addr (port, buf, length, flags);
-        frob_set_mode (port, ECR_PS2);
+        frob_set_mode(port, ECR_EPP);
+        parport_pc_write_control(port, 0x4);
+        parport_pc_data_forward(port);
+        written = parport_pc_epp_write_addr(port, buf, length, flags);
+        frob_set_mode(port, ECR_PS2);
 
         return written;
 }
 #endif /* IEEE 1284 support */
 
 #ifdef CONFIG_PARPORT_PC_FIFO
-static size_t parport_pc_fifo_write_block_pio (struct parport *port,
+static size_t parport_pc_fifo_write_block_pio(struct parport *port,
                                                const void *buf, size_t length)
 {
         int ret = 0;
         const unsigned char *bufp = buf;
         size_t left = length;
         unsigned long expire = jiffies + port->physport->cad->timeout;
-        const int fifo = FIFO (port);
+        const int fifo = FIFO(port);
         int poll_for = 8; /* 80 usecs */
         const struct parport_pc_private *priv = port->physport->private_data;
         const int fifo_depth = priv->fifo_depth;
@@ -526,25 +530,25 @@ static size_t parport_pc_fifo_write_block_pio (struct parport *port,
         port = port->physport;
 
         /* We don't want to be interrupted every character. */
-        parport_pc_disable_irq (port);
+        parport_pc_disable_irq(port);
         /* set nErrIntrEn and serviceIntr */
-        frob_econtrol (port, (1<<4) | (1<<2), (1<<4) | (1<<2));
+        frob_econtrol(port, (1<<4) | (1<<2), (1<<4) | (1<<2));
 
         /* Forward mode. */
-        parport_pc_data_forward (port); /* Must be in PS2 mode */
+        parport_pc_data_forward(port); /* Must be in PS2 mode */
 
         while (left) {
                 unsigned char byte;
-                unsigned char ecrval = inb (ECONTROL (port));
+                unsigned char ecrval = inb(ECONTROL(port));
                 int i = 0;
 
-                if (need_resched() && time_before (jiffies, expire))
+                if (need_resched() && time_before(jiffies, expire))
                         /* Can't yield the port. */
-                        schedule ();
+                        schedule();
 
                 /* Anyone else waiting for the port? */
                 if (port->waithead) {
-                        printk (KERN_DEBUG "Somebody wants the port\n");
+                        printk(KERN_DEBUG "Somebody wants the port\n");
                         break;
                 }
 
@@ -552,21 +556,22 @@ static size_t parport_pc_fifo_write_block_pio (struct parport *port,
                         /* FIFO is full. Wait for interrupt. */
 
                         /* Clear serviceIntr */
-                        ECR_WRITE (port, ecrval & ~(1<<2));
-                false_alarm:
-                        ret = parport_wait_event (port, HZ);
-                        if (ret < 0) break;
+                        ECR_WRITE(port, ecrval & ~(1<<2));
+false_alarm:
+                        ret = parport_wait_event(port, HZ);
+                        if (ret < 0)
+                                break;
                         ret = 0;
-                        if (!time_before (jiffies, expire)) {
+                        if (!time_before(jiffies, expire)) {
                                 /* Timed out. */
-                                printk (KERN_DEBUG "FIFO write timed out\n");
+                                printk(KERN_DEBUG "FIFO write timed out\n");
                                 break;
                         }
-                        ecrval = inb (ECONTROL (port));
+                        ecrval = inb(ECONTROL(port));
                         if (!(ecrval & (1<<2))) {
                                 if (need_resched() &&
-                                    time_before (jiffies, expire))
-                                        schedule ();
+                                    time_before(jiffies, expire))
+                                        schedule();
 
                                 goto false_alarm;
                         }
@@ -577,38 +582,38 @@ static size_t parport_pc_fifo_write_block_pio (struct parport *port,
                 /* Can't fail now. */
                 expire = jiffies + port->cad->timeout;
 
-        poll:
-                if (signal_pending (current))
+poll:
+                if (signal_pending(current))
                         break;
 
                 if (ecrval & 0x01) {
                         /* FIFO is empty. Blast it full. */
                         const int n = left < fifo_depth ? left : fifo_depth;
-                        outsb (fifo, bufp, n);
+                        outsb(fifo, bufp, n);
                         bufp += n;
                         left -= n;
 
                         /* Adjust the poll time. */
-                        if (i < (poll_for - 2)) poll_for--;
+                        if (i < (poll_for - 2))
+                                poll_for--;
                         continue;
                 } else if (i++ < poll_for) {
-                        udelay (10);
-                        ecrval = inb (ECONTROL (port));
+                        udelay(10);
+                        ecrval = inb(ECONTROL(port));
                         goto poll;
                 }
 
-                /* Half-full (call me an optimist) */
+                /* Half-full(call me an optimist) */
                 byte = *bufp++;
-                outb (byte, fifo);
+                outb(byte, fifo);
                 left--;
-        }
-
-dump_parport_state ("leave fifo_write_block_pio", port);
+        }
+        dump_parport_state("leave fifo_write_block_pio", port);
         return length - left;
 }
 
 #ifdef HAS_DMA
-static size_t parport_pc_fifo_write_block_dma (struct parport *port,
+static size_t parport_pc_fifo_write_block_dma(struct parport *port,
                                                const void *buf, size_t length)
 {
         int ret = 0;
@@ -621,7 +626,7 @@ static size_t parport_pc_fifo_write_block_dma (struct parport *port,
         unsigned long start = (unsigned long) buf;
         unsigned long end = (unsigned long) buf + length - 1;
 
-dump_parport_state ("enter fifo_write_block_dma", port);
+        dump_parport_state("enter fifo_write_block_dma", port);
         if (end < MAX_DMA_ADDRESS) {
                 /* If it would cross a 64k boundary, cap it at the end. */
                 if ((start ^ end) & ~0xffffUL)
@@ -629,8 +634,9 @@ dump_parport_state ("enter fifo_write_block_dma", port);
 
                 dma_addr = dma_handle = dma_map_single(dev, (void *)buf, length,
                                                        DMA_TO_DEVICE);
-        } else {
-                /* above 16 MB we use a bounce buffer as ISA-DMA is not possible */
+        } else {
+                /* above 16 MB we use a bounce buffer as ISA-DMA
+                   is not possible */
                 maxlen   = PAGE_SIZE;          /* sizeof(priv->dma_buf) */
                 dma_addr = priv->dma_handle;
                 dma_handle = 0;
@@ -639,12 +645,12 @@ dump_parport_state ("enter fifo_write_block_dma", port);
         port = port->physport;
 
         /* We don't want to be interrupted every character. */
-        parport_pc_disable_irq (port);
+        parport_pc_disable_irq(port);
         /* set nErrIntrEn and serviceIntr */
-        frob_econtrol (port, (1<<4) | (1<<2), (1<<4) | (1<<2));
+        frob_econtrol(port, (1<<4) | (1<<2), (1<<4) | (1<<2));
 
         /* Forward mode. */
-        parport_pc_data_forward (port); /* Must be in PS2 mode */
+        parport_pc_data_forward(port); /* Must be in PS2 mode */
 
         while (left) {
                 unsigned long expire = jiffies + port->physport->cad->timeout;
@@ -665,10 +671,10 @@ dump_parport_state ("enter fifo_write_block_dma", port);
                 set_dma_count(port->dma, count);
 
                 /* Set DMA mode */
-                frob_econtrol (port, 1<<3, 1<<3);
+                frob_econtrol(port, 1<<3, 1<<3);
 
                 /* Clear serviceIntr */
-                frob_econtrol (port, 1<<2, 0);
+                frob_econtrol(port, 1<<2, 0);
 
                 enable_dma(port->dma);
                 release_dma_lock(dmaflag);
@@ -676,20 +682,22 @@ dump_parport_state ("enter fifo_write_block_dma", port);
                 /* assume DMA will be successful */
                 left -= count;
                 buf  += count;
-                if (dma_handle) dma_addr += count;
+                if (dma_handle)
+                        dma_addr += count;
 
                 /* Wait for interrupt. */
-        false_alarm:
-                ret = parport_wait_event (port, HZ);
-                if (ret < 0) break;
+false_alarm:
+                ret = parport_wait_event(port, HZ);
+                if (ret < 0)
+                        break;
                 ret = 0;
-                if (!time_before (jiffies, expire)) {
+                if (!time_before(jiffies, expire)) {
                         /* Timed out. */
-                        printk (KERN_DEBUG "DMA write timed out\n");
+                        printk(KERN_DEBUG "DMA write timed out\n");
                         break;
                 }
                 /* Is serviceIntr set? */
-                if (!(inb (ECONTROL (port)) & (1<<2))) {
+                if (!(inb(ECONTROL(port)) & (1<<2))) {
                         cond_resched();
 
                         goto false_alarm;
@@ -705,14 +713,15 @@ dump_parport_state ("enter fifo_write_block_dma", port);
 
                 /* Anyone else waiting for the port? */
                 if (port->waithead) {
-                        printk (KERN_DEBUG "Somebody wants the port\n");
+                        printk(KERN_DEBUG "Somebody wants the port\n");
                         break;
                 }
 
                 /* update for possible DMA residue ! */
                 buf  -= count;
                 left += count;
-                if (dma_handle) dma_addr -= count;
+                if (dma_handle)
+                        dma_addr -= count;
         }
 
         /* Maybe got here through break, so adjust for DMA residue! */
@@ -723,12 +732,12 @@ dump_parport_state ("enter fifo_write_block_dma", port);
         release_dma_lock(dmaflag);
 
         /* Turn off DMA mode */
-        frob_econtrol (port, 1<<3, 0);
+        frob_econtrol(port, 1<<3, 0);
 
         if (dma_handle)
                 dma_unmap_single(dev, dma_handle, length, DMA_TO_DEVICE);
 
-dump_parport_state ("leave fifo_write_block_dma", port);
+        dump_parport_state("leave fifo_write_block_dma", port);
         return length - left;
 }
 #endif
@@ -738,13 +747,13 @@ static inline size_t parport_pc_fifo_write_block(struct parport *port,
 {
 #ifdef HAS_DMA
         if (port->dma != PARPORT_DMA_NONE)
-                return parport_pc_fifo_write_block_dma (port, buf, length);
+                return parport_pc_fifo_write_block_dma(port, buf, length);
 #endif
-        return parport_pc_fifo_write_block_pio (port, buf, length);
+        return parport_pc_fifo_write_block_pio(port, buf, length);
 }
 
 /* Parallel Port FIFO mode (ECP chipsets) */
-static size_t parport_pc_compat_write_block_pio (struct parport *port,
+static size_t parport_pc_compat_write_block_pio(struct parport *port,
                                                  const void *buf, size_t length,
                                                  int flags)
 {
@@ -756,14 +765,16 @@ static size_t parport_pc_compat_write_block_pio (struct parport *port,
         /* Special case: a timeout of zero means we cannot call schedule().
          * Also if O_NONBLOCK is set then use the default implementation. */
         if (port->physport->cad->timeout <= PARPORT_INACTIVITY_O_NONBLOCK)
-                return parport_ieee1284_write_compat (port, buf,
+                return parport_ieee1284_write_compat(port, buf,
                                                       length, flags);
 
         /* Set up parallel port FIFO mode.*/
-        parport_pc_data_forward (port); /* Must be in PS2 mode */
-        parport_pc_frob_control (port, PARPORT_CONTROL_STROBE, 0);
-        r = change_mode (port, ECR_PPF); /* Parallel port FIFO */
-        if (r)  printk (KERN_DEBUG "%s: Warning change_mode ECR_PPF failed\n", port->name);
+        parport_pc_data_forward(port); /* Must be in PS2 mode */
+        parport_pc_frob_control(port, PARPORT_CONTROL_STROBE, 0);
+        r = change_mode(port, ECR_PPF); /* Parallel port FIFO */
+        if (r)
+                printk(KERN_DEBUG "%s: Warning change_mode ECR_PPF failed\n",
+                                                                port->name);
 
         port->physport->ieee1284.phase = IEEE1284_PH_FWD_DATA;
 
@@ -775,40 +786,39 @@ static size_t parport_pc_compat_write_block_pio (struct parport *port,
          * the FIFO is empty, so allow 4 seconds for each position
          * in the fifo.
          */
-        expire = jiffies + (priv->fifo_depth * HZ * 4);
+        expire = jiffies + (priv->fifo_depth * HZ * 4);
         do {
                 /* Wait for the FIFO to empty */
-                r = change_mode (port, ECR_PS2);
-                if (r != -EBUSY) {
+                r = change_mode(port, ECR_PS2);
+                if (r != -EBUSY)
                         break;
-                }
-        } while (time_before (jiffies, expire));
+        } while (time_before(jiffies, expire));
         if (r == -EBUSY) {
 
-                printk (KERN_DEBUG "%s: FIFO is stuck\n", port->name);
+                printk(KERN_DEBUG "%s: FIFO is stuck\n", port->name);
 
                 /* Prevent further data transfer. */
-                frob_set_mode (port, ECR_TST);
+                frob_set_mode(port, ECR_TST);
 
                 /* Adjust for the contents of the FIFO. */
                 for (written -= priv->fifo_depth; ; written++) {
-                        if (inb (ECONTROL (port)) & 0x2) {
+                        if (inb(ECONTROL(port)) & 0x2) {
                                 /* Full up. */
                                 break;
                         }
-                        outb (0, FIFO (port));
+                        outb(0, FIFO(port));
                 }
 
                 /* Reset the FIFO and return to PS2 mode. */
-                frob_set_mode (port, ECR_PS2);
+                frob_set_mode(port, ECR_PS2);
         }
 
-        r = parport_wait_peripheral (port,
+        r = parport_wait_peripheral(port,
                                      PARPORT_STATUS_BUSY,
                                      PARPORT_STATUS_BUSY);
         if (r)
-                printk (KERN_DEBUG
-                        "%s: BUSY timeout (%d) in compat_write_block_pio\n", 
+                printk(KERN_DEBUG
+                        "%s: BUSY timeout (%d) in compat_write_block_pio\n",
                         port->name, r);
 
         port->physport->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
@@ -818,7 +828,7 @@ static size_t parport_pc_compat_write_block_pio (struct parport *port,
 
 /* ECP */
 #ifdef CONFIG_PARPORT_1284
-static size_t parport_pc_ecp_write_block_pio (struct parport *port,
+static size_t parport_pc_ecp_write_block_pio(struct parport *port,
                                               const void *buf, size_t length,
                                               int flags)
 {
@@ -830,36 +840,38 @@ static size_t parport_pc_ecp_write_block_pio (struct parport *port,
         /* Special case: a timeout of zero means we cannot call schedule().
          * Also if O_NONBLOCK is set then use the default implementation. */
         if (port->physport->cad->timeout <= PARPORT_INACTIVITY_O_NONBLOCK)
-                return parport_ieee1284_ecp_write_data (port, buf,
+                return parport_ieee1284_ecp_write_data(port, buf,
                                                         length, flags);
 
         /* Switch to forward mode if necessary. */
         if (port->physport->ieee1284.phase != IEEE1284_PH_FWD_IDLE) {
                 /* Event 47: Set nInit high. */
-                parport_frob_control (port,
+                parport_frob_control(port,
                                       PARPORT_CONTROL_INIT
                                       | PARPORT_CONTROL_AUTOFD,
                                       PARPORT_CONTROL_INIT
                                       | PARPORT_CONTROL_AUTOFD);
 
                 /* Event 49: PError goes high. */
-                r = parport_wait_peripheral (port,
+                r = parport_wait_peripheral(port,
                                              PARPORT_STATUS_PAPEROUT,
                                              PARPORT_STATUS_PAPEROUT);
                 if (r) {
-                        printk (KERN_DEBUG "%s: PError timeout (%d) "
+                        printk(KERN_DEBUG "%s: PError timeout (%d) "
                                 "in ecp_write_block_pio\n", port->name, r);
                 }
         }
 
         /* Set up ECP parallel port mode.*/
-        parport_pc_data_forward (port); /* Must be in PS2 mode */
-        parport_pc_frob_control (port,
+        parport_pc_data_forward(port); /* Must be in PS2 mode */
+        parport_pc_frob_control(port,
                                  PARPORT_CONTROL_STROBE |
                                  PARPORT_CONTROL_AUTOFD,
                                  0);
-        r = change_mode (port, ECR_ECP); /* ECP FIFO */
-        if (r) printk (KERN_DEBUG "%s: Warning change_mode ECR_ECP failed\n", port->name);
+        r = change_mode(port, ECR_ECP); /* ECP FIFO */
+        if (r)
+                printk(KERN_DEBUG "%s: Warning change_mode ECR_ECP failed\n",
+                                                                port->name);
         port->physport->ieee1284.phase = IEEE1284_PH_FWD_DATA;
 
         /* Write the data to the FIFO. */
@@ -873,55 +885,54 @@ static size_t parport_pc_ecp_write_block_pio (struct parport *port,
         expire = jiffies + (priv->fifo_depth * (HZ * 4));
         do {
                 /* Wait for the FIFO to empty */
-                r = change_mode (port, ECR_PS2);
-                if (r != -EBUSY) {
+                r = change_mode(port, ECR_PS2);
+                if (r != -EBUSY)
                         break;
-                }
-        } while (time_before (jiffies, expire));
+        } while (time_before(jiffies, expire));
         if (r == -EBUSY) {
 
-                printk (KERN_DEBUG "%s: FIFO is stuck\n", port->name);
+                printk(KERN_DEBUG "%s: FIFO is stuck\n", port->name);
 
                 /* Prevent further data transfer. */
-                frob_set_mode (port, ECR_TST);
+                frob_set_mode(port, ECR_TST);
 
                 /* Adjust for the contents of the FIFO. */
                 for (written -= priv->fifo_depth; ; written++) {
-                        if (inb (ECONTROL (port)) & 0x2) {
+                        if (inb(ECONTROL(port)) & 0x2) {
                                 /* Full up. */
                                 break;
                         }
-                        outb (0, FIFO (port));
+                        outb(0, FIFO(port));
                 }
 
                 /* Reset the FIFO and return to PS2 mode. */
-                frob_set_mode (port, ECR_PS2);
+                frob_set_mode(port, ECR_PS2);
 
                 /* Host transfer recovery. */
-                parport_pc_data_reverse (port); /* Must be in PS2 mode */
-                udelay (5);
-                parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
-                r = parport_wait_peripheral (port, PARPORT_STATUS_PAPEROUT, 0);
+                parport_pc_data_reverse(port); /* Must be in PS2 mode */
+                udelay(5);
+                parport_frob_control(port, PARPORT_CONTROL_INIT, 0);
+                r = parport_wait_peripheral(port, PARPORT_STATUS_PAPEROUT, 0);
                 if (r)
-                        printk (KERN_DEBUG "%s: PE,1 timeout (%d) "
+                        printk(KERN_DEBUG "%s: PE,1 timeout (%d) "
                                 "in ecp_write_block_pio\n", port->name, r);
 
-                parport_frob_control (port,
+                parport_frob_control(port,
                                       PARPORT_CONTROL_INIT,
                                       PARPORT_CONTROL_INIT);
-                r = parport_wait_peripheral (port,
+                r = parport_wait_peripheral(port,
                                              PARPORT_STATUS_PAPEROUT,
                                              PARPORT_STATUS_PAPEROUT);
-                if (r)
-                        printk (KERN_DEBUG "%s: PE,2 timeout (%d) "
+                if (r)
+                        printk(KERN_DEBUG "%s: PE,2 timeout (%d) "
                                 "in ecp_write_block_pio\n", port->name, r);
         }
 
-        r = parport_wait_peripheral (port,
-                                     PARPORT_STATUS_BUSY, 
+        r = parport_wait_peripheral(port,
+                                     PARPORT_STATUS_BUSY,
                                      PARPORT_STATUS_BUSY);
-        if(r)
-                printk (KERN_DEBUG
+        if (r)
+                printk(KERN_DEBUG
                         "%s: BUSY timeout (%d) in ecp_write_block_pio\n",
                         port->name, r);
 
@@ -931,7 +942,7 @@ static size_t parport_pc_ecp_write_block_pio (struct parport *port,
 }
 
 #if 0
-static size_t parport_pc_ecp_read_block_pio (struct parport *port,
+static size_t parport_pc_ecp_read_block_pio(struct parport *port,
                                              void *buf, size_t length,
                                              int flags)
 {
@@ -944,13 +955,13 @@ static size_t parport_pc_ecp_read_block_pio (struct parport *port,
         char *bufp = buf;
 
         port = port->physport;
-DPRINTK (KERN_DEBUG "parport_pc: parport_pc_ecp_read_block_pio\n");
-dump_parport_state ("enter fcn", port);
+        DPRINTK(KERN_DEBUG "parport_pc: parport_pc_ecp_read_block_pio\n");
+        dump_parport_state("enter fcn", port);
 
         /* Special case: a timeout of zero means we cannot call schedule().
          * Also if O_NONBLOCK is set then use the default implementation. */
         if (port->cad->timeout <= PARPORT_INACTIVITY_O_NONBLOCK)
-                return parport_ieee1284_ecp_read_data (port, buf,
+                return parport_ieee1284_ecp_read_data(port, buf,
                                                        length, flags);
 
         if (port->ieee1284.mode == IEEE1284_MODE_ECPRLE) {
@@ -966,173 +977,178 @@ dump_parport_state ("enter fcn", port);
          * go through software emulation.  Otherwise we may have to throw
          * away data. */
         if (length < fifofull)
-                return parport_ieee1284_ecp_read_data (port, buf,
+                return parport_ieee1284_ecp_read_data(port, buf,
                                                        length, flags);
 
         if (port->ieee1284.phase != IEEE1284_PH_REV_IDLE) {
                 /* change to reverse-idle phase (must be in forward-idle) */
 
                 /* Event 38: Set nAutoFd low (also make sure nStrobe is high) */
-                parport_frob_control (port,
+                parport_frob_control(port,
                                       PARPORT_CONTROL_AUTOFD
                                       | PARPORT_CONTROL_STROBE,
                                       PARPORT_CONTROL_AUTOFD);
-                parport_pc_data_reverse (port); /* Must be in PS2 mode */
-                udelay (5);
+                parport_pc_data_reverse(port); /* Must be in PS2 mode */
+                udelay(5);
                 /* Event 39: Set nInit low to initiate bus reversal */
-                parport_frob_control (port,
+                parport_frob_control(port,
                                       PARPORT_CONTROL_INIT,
                                       0);
                 /* Event 40: Wait for  nAckReverse (PError) to go low */
-                r = parport_wait_peripheral (port, PARPORT_STATUS_PAPEROUT, 0);
-                if (r) {
-                        printk (KERN_DEBUG "%s: PE timeout Event 40 (%d) "
+                r = parport_wait_peripheral(port, PARPORT_STATUS_PAPEROUT, 0);
+                if (r) {
+                        printk(KERN_DEBUG "%s: PE timeout Event 40 (%d) "
                                 "in ecp_read_block_pio\n", port->name, r);
                         return 0;
                 }
         }
 
         /* Set up ECP FIFO mode.*/
-/*      parport_pc_frob_control (port,
+/*      parport_pc_frob_control(port,
                                  PARPORT_CONTROL_STROBE |
                                  PARPORT_CONTROL_AUTOFD,
                                  PARPORT_CONTROL_AUTOFD); */
-        r = change_mode (port, ECR_ECP); /* ECP FIFO */
-        if (r) printk (KERN_DEBUG "%s: Warning change_mode ECR_ECP failed\n", port->name);
+        r = change_mode(port, ECR_ECP); /* ECP FIFO */
+        if (r)
+                printk(KERN_DEBUG "%s: Warning change_mode ECR_ECP failed\n",
+                                                                port->name);
 
         port->ieee1284.phase = IEEE1284_PH_REV_DATA;
 
         /* the first byte must be collected manually */
-dump_parport_state ("pre 43", port);
+        dump_parport_state("pre 43", port);
         /* Event 43: Wait for nAck to go low */
-        r = parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0);
+        r = parport_wait_peripheral(port, PARPORT_STATUS_ACK, 0);
         if (r) {
                 /* timed out while reading -- no data */
-                printk (KERN_DEBUG "PIO read timed out (initial byte)\n");
+                printk(KERN_DEBUG "PIO read timed out (initial byte)\n");
                 goto out_no_data;
         }
         /* read byte */
-        *bufp++ = inb (DATA (port));
+        *bufp++ = inb(DATA(port));
         left--;
-dump_parport_state ("43-44", port);
+        dump_parport_state("43-44", port);
         /* Event 44: nAutoFd (HostAck) goes high to acknowledge */
-        parport_pc_frob_control (port,
+        parport_pc_frob_control(port,
                                  PARPORT_CONTROL_AUTOFD,
                                  0);
-dump_parport_state ("pre 45", port);
+        dump_parport_state("pre 45", port);
         /* Event 45: Wait for nAck to go high */
-/*      r = parport_wait_peripheral (port, PARPORT_STATUS_ACK, PARPORT_STATUS_ACK); */
-dump_parport_state ("post 45", port);
-r = 0;
+        /* r = parport_wait_peripheral(port, PARPORT_STATUS_ACK,
+                                                PARPORT_STATUS_ACK); */
+        dump_parport_state("post 45", port);
+        r = 0;
         if (r) {
                 /* timed out while waiting for peripheral to respond to ack */
-                printk (KERN_DEBUG "ECP PIO read timed out (waiting for nAck)\n");
+                printk(KERN_DEBUG "ECP PIO read timed out (waiting for nAck)\n");
 
                 /* keep hold of the byte we've got already */
                 goto out_no_data;
         }
         /* Event 46: nAutoFd (HostAck) goes low to accept more data */
-        parport_pc_frob_control (port,
+        parport_pc_frob_control(port,
                                  PARPORT_CONTROL_AUTOFD,
                                  PARPORT_CONTROL_AUTOFD);
 
 
-dump_parport_state ("rev idle", port);
+        dump_parport_state("rev idle", port);
         /* Do the transfer. */
         while (left > fifofull) {
                 int ret;
                 unsigned long expire = jiffies + port->cad->timeout;
-                unsigned char ecrval = inb (ECONTROL (port));
+                unsigned char ecrval = inb(ECONTROL(port));
 
-                if (need_resched() && time_before (jiffies, expire))
+                if (need_resched() && time_before(jiffies, expire))
                         /* Can't yield the port. */
-                        schedule ();
+                        schedule();
 
                 /* At this point, the FIFO may already be full. In
-                 * that case ECP is already holding back the
-                 * peripheral (assuming proper design) with a delayed
-                 * handshake.  Work fast to avoid a peripheral
-                 * timeout.  */
+                 * that case ECP is already holding back the
+                 * peripheral (assuming proper design) with a delayed
+                 * handshake.  Work fast to avoid a peripheral
+                 * timeout.  */
 
                 if (ecrval & 0x01) {
                         /* FIFO is empty. Wait for interrupt. */
-dump_parport_state ("FIFO empty", port);
+                        dump_parport_state("FIFO empty", port);
 
                         /* Anyone else waiting for the port? */
                         if (port->waithead) {
-                                printk (KERN_DEBUG "Somebody wants the port\n");
+                                printk(KERN_DEBUG "Somebody wants the port\n");
                                 break;
                         }
 
                         /* Clear serviceIntr */
-                        ECR_WRITE (port, ecrval & ~(1<<2));
-                false_alarm:
-dump_parport_state ("waiting", port);
-                        ret = parport_wait_event (port, HZ);
-DPRINTK (KERN_DEBUG "parport_wait_event returned %d\n", ret);
+                        ECR_WRITE(port, ecrval & ~(1<<2));
+false_alarm:
+                        dump_parport_state("waiting", port);
+                        ret = parport_wait_event(port, HZ);
+                        DPRINTK(KERN_DEBUG "parport_wait_event returned %d\n",
+                                                                        ret);
                         if (ret < 0)
                                 break;
                         ret = 0;
-                        if (!time_before (jiffies, expire)) {
+                        if (!time_before(jiffies, expire)) {
                                 /* Timed out. */
-dump_parport_state ("timeout", port);
-                                printk (KERN_DEBUG "PIO read timed out\n");
+                                dump_parport_state("timeout", port);
+                                printk(KERN_DEBUG "PIO read timed out\n");
                                 break;
                         }
-                        ecrval = inb (ECONTROL (port));
+                        ecrval = inb(ECONTROL(port));
                         if (!(ecrval & (1<<2))) {
                                 if (need_resched() &&
-                                    time_before (jiffies, expire)) {
-                                        schedule ();
+                                    time_before(jiffies, expire)) {
+                                        schedule();
                                 }
                                 goto false_alarm;
                         }
 
                         /* Depending on how the FIFO threshold was
-                         * set, how long interrupt service took, and
-                         * how fast the peripheral is, we might be
-                         * lucky and have a just filled FIFO. */
+                         * set, how long interrupt service took, and
+                         * how fast the peripheral is, we might be
+                         * lucky and have a just filled FIFO. */
                         continue;
                 }
 
                 if (ecrval & 0x02) {
                         /* FIFO is full. */
-dump_parport_state ("FIFO full", port);
-                        insb (fifo, bufp, fifo_depth);
+                        dump_parport_state("FIFO full", port);
+                        insb(fifo, bufp, fifo_depth);
                         bufp += fifo_depth;
                         left -= fifo_depth;
                         continue;
                 }
 
-DPRINTK (KERN_DEBUG "*** ecp_read_block_pio: reading one byte from the FIFO\n");
+                DPRINTK(KERN_DEBUG
+                  "*** ecp_read_block_pio: reading one byte from the FIFO\n");
 
                 /* FIFO not filled.  We will cycle this loop for a while
-                 * and either the peripheral will fill it faster,
-                 * tripping a fast empty with insb, or we empty it. */
-                *bufp++ = inb (fifo);
+                 * and either the peripheral will fill it faster,
+                 * tripping a fast empty with insb, or we empty it. */
+                *bufp++ = inb(fifo);
                 left--;
         }
 
         /* scoop up anything left in the FIFO */
-        while (left && !(inb (ECONTROL (port) & 0x01))) {
-                *bufp++ = inb (fifo);
+        while (left && !(inb(ECONTROL(port) & 0x01))) {
+                *bufp++ = inb(fifo);
                 left--;
         }
 
         port->ieee1284.phase = IEEE1284_PH_REV_IDLE;
-dump_parport_state ("rev idle2", port);
+        dump_parport_state("rev idle2", port);
 
 out_no_data:
 
         /* Go to forward idle mode to shut the peripheral up (event 47). */
-        parport_frob_control (port, PARPORT_CONTROL_INIT, PARPORT_CONTROL_INIT);
+        parport_frob_control(port, PARPORT_CONTROL_INIT, PARPORT_CONTROL_INIT);
 
         /* event 49: PError goes high */
-        r = parport_wait_peripheral (port,
+        r = parport_wait_peripheral(port,
                                      PARPORT_STATUS_PAPEROUT,
                                      PARPORT_STATUS_PAPEROUT);
         if (r) {
-                printk (KERN_DEBUG
+                printk(KERN_DEBUG
                         "%s: PE timeout FWDIDLE (%d) in ecp_read_block_pio\n",
                         port->name, r);
         }
@@ -1141,14 +1157,14 @@ out_no_data:
 
         /* Finish up. */
         {
-                int lost = get_fifo_residue (port);
+                int lost = get_fifo_residue(port);
                 if (lost)
                         /* Shouldn't happen with compliant peripherals. */
-                        printk (KERN_DEBUG "%s: DATA LOSS (%d bytes)!\n",
+                        printk(KERN_DEBUG "%s: DATA LOSS (%d bytes)!\n",
                                 port->name, lost);
         }
 
-dump_parport_state ("fwd idle", port);
+        dump_parport_state("fwd idle", port);
         return length - left;
 }
 #endif  /*  0  */
@@ -1164,8 +1180,7 @@ dump_parport_state ("fwd idle", port);
 
 /* GCC is not inlining extern inline function later overwriten to non-inline,
    so we use outlined_ variants here.  */
-static const struct parport_operations parport_pc_ops =
-{
+static const struct parport_operations parport_pc_ops = {
         .write_data     = parport_pc_write_data,
         .read_data      = parport_pc_read_data,
 
@@ -1202,88 +1217,107 @@ static const struct parport_operations parport_pc_ops =
 };
 
 #ifdef CONFIG_PARPORT_PC_SUPERIO
+
+static struct superio_struct *find_free_superio(void)
+{
+        int i;
+        for (i = 0; i < NR_SUPERIOS; i++)
+                if (superios[i].io == 0)
+                        return &superios[i];
+        return NULL;
+}
+
+
 /* Super-IO chipset detection, Winbond, SMSC */
 static void __devinit show_parconfig_smsc37c669(int io, int key)
 {
-        int cr1,cr4,cra,cr23,cr26,cr27,i=0;
-        static const char *const modes[]={
+        int cr1, cr4, cra, cr23, cr26, cr27;
+        struct superio_struct *s;
+
+        static const char *const modes[] = {
                 "SPP and Bidirectional (PS/2)",
                 "EPP and SPP",
                 "ECP",
                 "ECP and EPP" };
 
-        outb(key,io);
-        outb(key,io);
-        outb(1,io);
-        cr1=inb(io+1);
-        outb(4,io);
-        cr4=inb(io+1);
-        outb(0x0a,io);
-        cra=inb(io+1);
-        outb(0x23,io);
-        cr23=inb(io+1);
-        outb(0x26,io);
-        cr26=inb(io+1);
-        outb(0x27,io);
-        cr27=inb(io+1);
-        outb(0xaa,io);
+        outb(key, io);
+        outb(key, io);
+        outb(1, io);
+        cr1 = inb(io + 1);
+        outb(4, io);
+        cr4 = inb(io + 1);
+        outb(0x0a, io);
+        cra = inb(io + 1);
+        outb(0x23, io);
+        cr23 = inb(io + 1);
+        outb(0x26, io);
+        cr26 = inb(io + 1);
+        outb(0x27, io);
+        cr27 = inb(io + 1);
+        outb(0xaa, io);
 
         if (verbose_probing) {
-                printk (KERN_INFO "SMSC 37c669 LPT Config: cr_1=0x%02x, 4=0x%02x, "
+                printk(KERN_INFO
+                        "SMSC 37c669 LPT Config: cr_1=0x%02x, 4=0x%02x, "
                         "A=0x%2x, 23=0x%02x, 26=0x%02x, 27=0x%02x\n",
-                        cr1,cr4,cra,cr23,cr26,cr27);
-                
+                        cr1, cr4, cra, cr23, cr26, cr27);
+
                 /* The documentation calls DMA and IRQ-Lines by letters, so
                    the board maker can/will wire them
                    appropriately/randomly...  G=reserved H=IDE-irq, */
-                printk (KERN_INFO "SMSC LPT Config: io=0x%04x, irq=%c, dma=%c, "
-                        "fifo threshold=%d\n", cr23*4,
-                        (cr27 &0x0f) ? 'A'-1+(cr27 &0x0f): '-',
-                        (cr26 &0x0f) ? 'A'-1+(cr26 &0x0f): '-', cra & 0x0f);
+                printk(KERN_INFO
+        "SMSC LPT Config: io=0x%04x, irq=%c, dma=%c, fifo threshold=%d\n",
+                                cr23 * 4,
+                                (cr27 & 0x0f) ? 'A' - 1 + (cr27 & 0x0f) : '-',
+                                (cr26 & 0x0f) ? 'A' - 1 + (cr26 & 0x0f) : '-',
+                                cra & 0x0f);
                 printk(KERN_INFO "SMSC LPT Config: enabled=%s power=%s\n",
-                       (cr23*4 >=0x100) ?"yes":"no", (cr1 & 4) ? "yes" : "no");
-                printk(KERN_INFO "SMSC LPT Config: Port mode=%s, EPP version =%s\n",
-                       (cr1 & 0x08 ) ? "Standard mode only (SPP)" : modes[cr4 & 0x03], 
-                       (cr4 & 0x40) ? "1.7" : "1.9");
+                       (cr23 * 4 >= 0x100) ? "yes" : "no",
+                       (cr1 & 4) ? "yes" : "no");
+                printk(KERN_INFO
+                        "SMSC LPT Config: Port mode=%s, EPP version =%s\n",
+                                (cr1 & 0x08) ? "Standard mode only (SPP)"
+                                              : modes[cr4 & 0x03],
+                                (cr4 & 0x40) ? "1.7" : "1.9");
         }
-                
+
         /* Heuristics !  BIOS setup for this mainboard device limits
            the choices to standard settings, i.e. io-address and IRQ
            are related, however DMA can be 1 or 3, assume DMA_A=DMA1,
            DMA_C=DMA3 (this is true e.g. for TYAN 1564D Tomcat IV) */
-        if(cr23*4 >=0x100) { /* if active */
-                while((superios[i].io!= 0) && (i<NR_SUPERIOS))
-                        i++;
-                if(i==NR_SUPERIOS)
+        if (cr23 * 4 >= 0x100) { /* if active */
+                s = find_free_superio();
+                if (s == NULL)
                         printk(KERN_INFO "Super-IO: too many chips!\n");
                 else {
                         int d;
-                        switch (cr23*4) {
-                                case 0x3bc:
-                                        superios[i].io = 0x3bc;
-                                        superios[i].irq = 7;
-                                        break;
-                                case 0x378:
-                                        superios[i].io = 0x378;
-                                        superios[i].irq = 7;
-                                        break;
-                                case 0x278:
-                                        superios[i].io = 0x278;
-                                        superios[i].irq = 5;
+                        switch (cr23 * 4) {
+                        case 0x3bc:
+                                s->io = 0x3bc;
+                                s->irq = 7;
+                                break;
+                        case 0x378:
+                                s->io = 0x378;
+                                s->irq = 7;
+                                break;
+                        case 0x278:
+                                s->io = 0x278;
+                                s->irq = 5;
                         }
-                        d=(cr26 &0x0f);
-                        if((d==1) || (d==3)) 
-                                superios[i].dma= d;
+                        d = (cr26 & 0x0f);
+                        if (d == 1 || d == 3)
+                                s->dma = d;
                         else
-                                superios[i].dma= PARPORT_DMA_NONE;
+                                s->dma = PARPORT_DMA_NONE;
                 }
-        }
+        }
 }
 
 
 static void __devinit show_parconfig_winbond(int io, int key)
 {
-        int cr30,cr60,cr61,cr70,cr74,crf0,i=0;
+        int cr30, cr60, cr61, cr70, cr74, crf0;
+        struct superio_struct *s;
         static const char *const modes[] = {
                 "Standard (SPP) and Bidirectional(PS/2)", /* 0 */
                 "EPP-1.9 and SPP",
@@ -1296,110 +1330,134 @@ static void __devinit show_parconfig_winbond(int io, int key)
         static char *const irqtypes[] = {
                 "pulsed low, high-Z",
                 "follows nACK" };
-                
+
         /* The registers are called compatible-PnP because the
-           register layout is modelled after ISA-PnP, the access
-           method is just another ... */
-        outb(key,io);
-        outb(key,io);
-        outb(0x07,io);   /* Register 7: Select Logical Device */
-        outb(0x01,io+1); /* LD1 is Parallel Port */
-        outb(0x30,io);
-        cr30=inb(io+1);
-        outb(0x60,io);
-        cr60=inb(io+1);
-        outb(0x61,io);
-        cr61=inb(io+1);
-        outb(0x70,io);
-        cr70=inb(io+1);
-        outb(0x74,io);
-        cr74=inb(io+1);
-        outb(0xf0,io);
-        crf0=inb(io+1);
-        outb(0xaa,io);
+           register layout is modelled after ISA-PnP, the access
+           method is just another ... */
+        outb(key, io);
+        outb(key, io);
+        outb(0x07, io);   /* Register 7: Select Logical Device */
+        outb(0x01, io + 1); /* LD1 is Parallel Port */
+        outb(0x30, io);
+        cr30 = inb(io + 1);
+        outb(0x60, io);
+        cr60 = inb(io + 1);
+        outb(0x61, io);
+        cr61 = inb(io + 1);
+        outb(0x70, io);
+        cr70 = inb(io + 1);
+        outb(0x74, io);
+        cr74 = inb(io + 1);
+        outb(0xf0, io);
+        crf0 = inb(io + 1);
+        outb(0xaa, io);
 
         if (verbose_probing) {
-                printk(KERN_INFO "Winbond LPT Config: cr_30=%02x 60,61=%02x%02x "
-                       "70=%02x 74=%02x, f0=%02x\n", cr30,cr60,cr61,cr70,cr74,crf0);
-                printk(KERN_INFO "Winbond LPT Config: active=%s, io=0x%02x%02x irq=%d, ", 
-                       (cr30 & 0x01) ? "yes":"no", cr60,cr61,cr70&0x0f );
+                printk(KERN_INFO
+    "Winbond LPT Config: cr_30=%02x 60,61=%02x%02x 70=%02x 74=%02x, f0=%02x\n",
+                                        cr30, cr60, cr61, cr70, cr74, crf0);
+                printk(KERN_INFO "Winbond LPT Config: active=%s, io=0x%02x%02x irq=%d, ",
+                       (cr30 & 0x01) ? "yes" : "no", cr60, cr61, cr70 & 0x0f);
                 if ((cr74 & 0x07) > 3)
                         printk("dma=none\n");
                 else
-                        printk("dma=%d\n",cr74 & 0x07);
-                printk(KERN_INFO "Winbond LPT Config: irqtype=%s, ECP fifo threshold=%d\n",
-                       irqtypes[crf0>>7], (crf0>>3)&0x0f);
-                printk(KERN_INFO "Winbond LPT Config: Port mode=%s\n", modes[crf0 & 0x07]);
+                        printk("dma=%d\n", cr74 & 0x07);
+                printk(KERN_INFO
+                    "Winbond LPT Config: irqtype=%s, ECP fifo threshold=%d\n",
+                                        irqtypes[crf0>>7], (crf0>>3)&0x0f);
+                printk(KERN_INFO "Winbond LPT Config: Port mode=%s\n",
+                                        modes[crf0 & 0x07]);
         }
 
-        if(cr30 & 0x01) { /* the settings can be interrogated later ... */
-                while((superios[i].io!= 0) && (i<NR_SUPERIOS))
-                        i++;
-                if(i==NR_SUPERIOS) 
+        if (cr30 & 0x01) { /* the settings can be interrogated later ... */
+                s = find_free_superio();
+                if (s == NULL)
                         printk(KERN_INFO "Super-IO: too many chips!\n");
                 else {
-                        superios[i].io = (cr60<<8)|cr61;
-                        superios[i].irq = cr70&0x0f;
-                        superios[i].dma = (((cr74 & 0x07) > 3) ?
+                        s->io = (cr60 << 8) | cr61;
+                        s->irq = cr70 & 0x0f;
+                        s->dma = (((cr74 & 0x07) > 3) ?
                                            PARPORT_DMA_NONE : (cr74 & 0x07));
                 }
         }
 }
 
-static void __devinit decode_winbond(int efer, int key, int devid, int devrev, int oldid)
+static void __devinit decode_winbond(int efer, int key, int devid,
+                                                        int devrev, int oldid)
 {
         const char *type = "unknown";
-        int id,progif=2;
+        int id, progif = 2;
 
         if (devid == devrev)
                 /* simple heuristics, we happened to read some
-                   non-winbond register */
+                   non-winbond register */
                 return;
 
-        id=(devid<<8) | devrev;
+        id = (devid << 8) | devrev;
 
         /* Values are from public data sheets pdf files, I can just
-           confirm 83977TF is correct :-) */
-        if      (id == 0x9771) type="83977F/AF";
-        else if (id == 0x9773) type="83977TF / SMSC 97w33x/97w34x";
-        else if (id == 0x9774) type="83977ATF";
-        else if ((id & ~0x0f) == 0x5270) type="83977CTF / SMSC 97w36x";
-        else if ((id & ~0x0f) == 0x52f0) type="83977EF / SMSC 97w35x";
-        else if ((id & ~0x0f) == 0x5210) type="83627";
-        else if ((id & ~0x0f) == 0x6010) type="83697HF";
-        else if ((oldid &0x0f ) == 0x0a) { type="83877F"; progif=1;}
-        else if ((oldid &0x0f ) == 0x0b) { type="83877AF"; progif=1;}
-        else if ((oldid &0x0f ) == 0x0c) { type="83877TF"; progif=1;}
-        else if ((oldid &0x0f ) == 0x0d) { type="83877ATF"; progif=1;}
-        else progif=0;
+           confirm 83977TF is correct :-) */
+        if (id == 0x9771)
+                type = "83977F/AF";
+        else if (id == 0x9773)
+                type = "83977TF / SMSC 97w33x/97w34x";
+        else if (id == 0x9774)
+                type = "83977ATF";
+        else if ((id & ~0x0f) == 0x5270)
+                type = "83977CTF / SMSC 97w36x";
+        else if ((id & ~0x0f) == 0x52f0)
+                type = "83977EF / SMSC 97w35x";
+        else if ((id & ~0x0f) == 0x5210)
+                type = "83627";
+        else if ((id & ~0x0f) == 0x6010)
+                type = "83697HF";
+        else if ((oldid & 0x0f) == 0x0a) {
+                type = "83877F";
+                progif = 1;
+        } else if ((oldid & 0x0f) == 0x0b) {
+                type = "83877AF";
+                progif = 1;
+        } else if ((oldid & 0x0f) == 0x0c) {
+                type = "83877TF";
+                progif = 1;
+        } else if ((oldid & 0x0f) == 0x0d) {
+                type = "83877ATF";
+                progif = 1;
+        } else
+                progif = 0;
 
         if (verbose_probing)
                 printk(KERN_INFO "Winbond chip at EFER=0x%x key=0x%02x "
-                       "devid=%02x devrev=%02x oldid=%02x type=%s\n", 
+                       "devid=%02x devrev=%02x oldid=%02x type=%s\n",
                        efer, key, devid, devrev, oldid, type);
 
         if (progif == 2)
-                show_parconfig_winbond(efer,key);
+                show_parconfig_winbond(efer, key);
 }
 
 static void __devinit decode_smsc(int efer, int key, int devid, int devrev)
 {
-        const char *type = "unknown";
+        const char *type = "unknown";
         void (*func)(int io, int key);
-        int id;
+        int id;
 
-        if (devid == devrev)
+        if (devid == devrev)
                 /* simple heuristics, we happened to read some
-                   non-smsc register */
+                   non-smsc register */
                 return;
 
-        func=NULL;
-        id=(devid<<8) | devrev;
+        func = NULL;
+        id = (devid << 8) | devrev;
 
-        if      (id==0x0302) {type="37c669"; func=show_parconfig_smsc37c669;}
-        else if (id==0x6582) type="37c665IR";
-        else if (devid==0x65) type="37c665GT";
-        else if (devid==0x66) type="37c666GT";
+        if (id == 0x0302) {
+                type = "37c669";
+                func = show_parconfig_smsc37c669;
+        } else if (id == 0x6582)
+                type = "37c665IR";
+        else if (devid == 0x65)
+                type = "37c665GT";
+        else if (devid == 0x66)
+                type = "37c666GT";
 
         if (verbose_probing)
                 printk(KERN_INFO "SMSC chip at EFER=0x%x "
@@ -1407,138 +1465,138 @@ static void __devinit decode_smsc(int efer, int key, int devid, int devrev)
                        efer, key, devid, devrev, type);
 
         if (func)
-                func(efer,key);
+                func(efer, key);
 }
 
 
 static void __devinit winbond_check(int io, int key)
 {
-        int devid,devrev,oldid,x_devid,x_devrev,x_oldid;
+        int devid, devrev, oldid, x_devid, x_devrev, x_oldid;
 
         if (!request_region(io, 3, __func__))
                 return;
 
         /* First probe without key */
-        outb(0x20,io);
-        x_devid=inb(io+1);
-        outb(0x21,io);
-        x_devrev=inb(io+1);
-        outb(0x09,io);
-        x_oldid=inb(io+1);
-
-        outb(key,io);
-        outb(key,io);     /* Write Magic Sequence to EFER, extended
-                             funtion enable register */
-        outb(0x20,io);    /* Write EFIR, extended function index register */
-        devid=inb(io+1);  /* Read EFDR, extended function data register */
-        outb(0x21,io);
-        devrev=inb(io+1);
-        outb(0x09,io);
-        oldid=inb(io+1);
-        outb(0xaa,io);    /* Magic Seal */
+        outb(0x20, io);
+        x_devid = inb(io + 1);
+        outb(0x21, io);
+        x_devrev = inb(io + 1);
+        outb(0x09, io);
+        x_oldid = inb(io + 1);
+
+        outb(key, io);
+        outb(key, io);     /* Write Magic Sequence to EFER, extended
+                              funtion enable register */
+        outb(0x20, io);    /* Write EFIR, extended function index register */
+        devid = inb(io + 1);  /* Read EFDR, extended function data register */
+        outb(0x21, io);
+        devrev = inb(io + 1);
+        outb(0x09, io);
+        oldid = inb(io + 1);
+        outb(0xaa, io);    /* Magic Seal */
 
         if ((x_devid == devid) && (x_devrev == devrev) && (x_oldid == oldid))
                 goto out; /* protection against false positives */
 
-        decode_winbond(io,key,devid,devrev,oldid);
+        decode_winbond(io, key, devid, devrev, oldid);
 out:
         release_region(io, 3);
 }
 
-static void __devinit winbond_check2(int io,int key)
+static void __devinit winbond_check2(int io, int key)
 {
-        int devid,devrev,oldid,x_devid,x_devrev,x_oldid;
+        int devid, devrev, oldid, x_devid, x_devrev, x_oldid;
 
         if (!request_region(io, 3, __func__))
                 return;
 
         /* First probe without the key */
-        outb(0x20,io+2);
-        x_devid=inb(io+2);
-        outb(0x21,io+1);
-        x_devrev=inb(io+2);
-        outb(0x09,io+1);
-        x_oldid=inb(io+2);
-
-        outb(key,io);     /* Write Magic Byte to EFER, extended
-                             funtion enable register */
-        outb(0x20,io+2);  /* Write EFIR, extended function index register */
-        devid=inb(io+2);  /* Read EFDR, extended function data register */
-        outb(0x21,io+1);
-        devrev=inb(io+2);
-        outb(0x09,io+1);
-        oldid=inb(io+2);
-        outb(0xaa,io);    /* Magic Seal */
-
-        if ((x_devid == devid) && (x_devrev == devrev) && (x_oldid == oldid))
+        outb(0x20, io + 2);
+        x_devid = inb(io + 2);
+        outb(0x21, io + 1);
+        x_devrev = inb(io + 2);
+        outb(0x09, io + 1);
+        x_oldid = inb(io + 2);
+
+        outb(key, io);     /* Write Magic Byte to EFER, extended
+                              funtion enable register */
+        outb(0x20, io + 2);  /* Write EFIR, extended function index register */
+        devid = inb(io + 2);  /* Read EFDR, extended function data register */
+        outb(0x21, io + 1);
+        devrev = inb(io + 2);
+        outb(0x09, io + 1);
+        oldid = inb(io + 2);
+        outb(0xaa, io);    /* Magic Seal */
+
+        if (x_devid == devid && x_devrev == devrev && x_oldid == oldid)
                 goto out; /* protection against false positives */
 
-        decode_winbond(io,key,devid,devrev,oldid);
+        decode_winbond(io, key, devid, devrev, oldid);
 out:
         release_region(io, 3);
 }
 
 static void __devinit smsc_check(int io, int key)
 {
-        int id,rev,oldid,oldrev,x_id,x_rev,x_oldid,x_oldrev;
+        int id, rev, oldid, oldrev, x_id, x_rev, x_oldid, x_oldrev;
 
         if (!request_region(io, 3, __func__))
                 return;
 
         /* First probe without the key */
-        outb(0x0d,io);
-        x_oldid=inb(io+1);
-        outb(0x0e,io);
-        x_oldrev=inb(io+1);
-        outb(0x20,io);
-        x_id=inb(io+1);
-        outb(0x21,io);
-        x_rev=inb(io+1);
-
-        outb(key,io);
-        outb(key,io);     /* Write Magic Sequence to EFER, extended
-                             funtion enable register */
-        outb(0x0d,io);    /* Write EFIR, extended function index register */
-        oldid=inb(io+1);  /* Read EFDR, extended function data register */
-        outb(0x0e,io);
-        oldrev=inb(io+1);
-        outb(0x20,io);
-        id=inb(io+1);
-        outb(0x21,io);
-        rev=inb(io+1);
-        outb(0xaa,io);    /* Magic Seal */
-
-        if ((x_id == id) && (x_oldrev == oldrev) &&
-            (x_oldid == oldid) && (x_rev == rev))
+        outb(0x0d, io);
+        x_oldid = inb(io + 1);
+        outb(0x0e, io);
+        x_oldrev = inb(io + 1);
+        outb(0x20, io);
+        x_id = inb(io + 1);
+        outb(0x21, io);
+        x_rev = inb(io + 1);
+
+        outb(key, io);
+        outb(key, io);     /* Write Magic Sequence to EFER, extended
+                              funtion enable register */
+        outb(0x0d, io);    /* Write EFIR, extended function index register */
+        oldid = inb(io + 1);  /* Read EFDR, extended function data register */
+        outb(0x0e, io);
+        oldrev = inb(io + 1);
+        outb(0x20, io);
+        id = inb(io + 1);
+        outb(0x21, io);
+        rev = inb(io + 1);
+        outb(0xaa, io);    /* Magic Seal */
+
+        if (x_id == id && x_oldrev == oldrev &&
+            x_oldid == oldid && x_rev == rev)
                 goto out; /* protection against false positives */
 
-        decode_smsc(io,key,oldid,oldrev);
+        decode_smsc(io, key, oldid, oldrev);
 out:
         release_region(io, 3);
 }
 
 
-static void __devinit detect_and_report_winbond (void)
-{ 
+static void __devinit detect_and_report_winbond(void)
+{
         if (verbose_probing)
                 printk(KERN_DEBUG "Winbond Super-IO detection, now testing ports 3F0,370,250,4E,2E ...\n");
-        winbond_check(0x3f0,0x87);
-        winbond_check(0x370,0x87);
-        winbond_check(0x2e ,0x87);
-        winbond_check(0x4e ,0x87);
-        winbond_check(0x3f0,0x86);
-        winbond_check2(0x250,0x88); 
-        winbond_check2(0x250,0x89);
+        winbond_check(0x3f0, 0x87);
+        winbond_check(0x370, 0x87);
+        winbond_check(0x2e , 0x87);
+        winbond_check(0x4e , 0x87);
+        winbond_check(0x3f0, 0x86);
+        winbond_check2(0x250, 0x88);
+        winbond_check2(0x250, 0x89);
 }
 
-static void __devinit detect_and_report_smsc (void)
+static void __devinit detect_and_report_smsc(void)
 {
         if (verbose_probing)
                 printk(KERN_DEBUG "SMSC Super-IO detection, now testing Ports 2F0, 370 ...\n");
-        smsc_check(0x3f0,0x55);
-        smsc_check(0x370,0x55);
-        smsc_check(0x3f0,0x44);
-        smsc_check(0x370,0x44);
+        smsc_check(0x3f0, 0x55);
+        smsc_check(0x370, 0x55);
+        smsc_check(0x3f0, 0x44);
+        smsc_check(0x370, 0x44);
 }
 
 static void __devinit detect_and_report_it87(void)
@@ -1573,34 +1631,39 @@ static void __devinit detect_and_report_it87(void)
 }
 #endif /* CONFIG_PARPORT_PC_SUPERIO */
 
-static int get_superio_dma (struct parport *p)
+static struct superio_struct *find_superio(struct parport *p)
 {
-        int i=0;
-        while( (superios[i].io != p->base) && (i<NR_SUPERIOS))
-                i++;
-        if (i!=NR_SUPERIOS)
-                return superios[i].dma;
+        int i;
+        for (i = 0; i < NR_SUPERIOS; i++)
+                if (superios[i].io != p->base)
+                        return &superios[i];
+        return NULL;
+}
+
+static int get_superio_dma(struct parport *p)
+{
+        struct superio_struct *s = find_superio(p);
+        if (s)
+                return s->dma;
         return PARPORT_DMA_NONE;
 }
 
-static int get_superio_irq (struct parport *p)
+static int get_superio_irq(struct parport *p)
 {
-        int i=0;
-        while( (superios[i].io != p->base) && (i<NR_SUPERIOS))
-                i++;
-        if (i!=NR_SUPERIOS)
-                return superios[i].irq;
-        return PARPORT_IRQ_NONE;
+        struct superio_struct *s = find_superio(p);
+        if (s)
+                return s->irq;
+        return PARPORT_IRQ_NONE;
 }
-        
+
 
 /* --- Mode detection ------------------------------------- */
 
 /*
  * Checks for port existence, all ports support SPP MODE
- * Returns: 
+ * Returns:
  *         0           :  No parallel port at this address
- *  PARPORT_MODE_PCSPP :  SPP port detected 
+ *  PARPORT_MODE_PCSPP :  SPP port detected
  *                        (if the user specified an ioport himself,
  *                         this shall always be the case!)
  *
@@ -1610,7 +1673,7 @@ static int parport_SPP_supported(struct parport *pb)
         unsigned char r, w;
 
         /*
-         * first clear an eventually pending EPP timeout 
+         * first clear an eventually pending EPP timeout
          * I (sailer@ife.ee.ethz.ch) have an SMSC chipset
          * that does not even respond to SPP cycles if an EPP
          * timeout is pending
@@ -1619,19 +1682,19 @@ static int parport_SPP_supported(struct parport *pb)
 
         /* Do a simple read-write test to make sure the port exists. */
         w = 0xc;
-        outb (w, CONTROL (pb));
+        outb(w, CONTROL(pb));
 
         /* Is there a control register that we can read from?  Some
          * ports don't allow reads, so read_control just returns a
          * software copy. Some ports _do_ allow reads, so bypass the
          * software copy here.  In addition, some bits aren't
          * writable. */
-        r = inb (CONTROL (pb));
+        r = inb(CONTROL(pb));
         if ((r & 0xf) == w) {
                 w = 0xe;
-                outb (w, CONTROL (pb));
-                r = inb (CONTROL (pb));
-                outb (0xc, CONTROL (pb));
+                outb(w, CONTROL(pb));
+                r = inb(CONTROL(pb));
+                outb(0xc, CONTROL(pb));
                 if ((r & 0xf) == w)
                         return PARPORT_MODE_PCSPP;
         }
@@ -1639,18 +1702,18 @@ static int parport_SPP_supported(struct parport *pb)
         if (user_specified)
                 /* That didn't work, but the user thinks there's a
                  * port here. */
-                printk (KERN_INFO "parport 0x%lx (WARNING): CTR: "
+                printk(KERN_INFO "parport 0x%lx (WARNING): CTR: "
                         "wrote 0x%02x, read 0x%02x\n", pb->base, w, r);
 
         /* Try the data register.  The data lines aren't tri-stated at
          * this stage, so we expect back what we wrote. */
         w = 0xaa;
-        parport_pc_write_data (pb, w);
-        r = parport_pc_read_data (pb);
+        parport_pc_write_data(pb, w);
+        r = parport_pc_read_data(pb);
         if (r == w) {
                 w = 0x55;
-                parport_pc_write_data (pb, w);
-                r = parport_pc_read_data (pb);
+                parport_pc_write_data(pb, w);
+                r = parport_pc_read_data(pb);
                 if (r == w)
                         return PARPORT_MODE_PCSPP;
         }
@@ -1658,9 +1721,9 @@ static int parport_SPP_supported(struct parport *pb)
         if (user_specified) {
                 /* Didn't work, but the user is convinced this is the
                  * place. */
-                printk (KERN_INFO "parport 0x%lx (WARNING): DATA: "
+                printk(KERN_INFO "parport 0x%lx (WARNING): DATA: "
                         "wrote 0x%02x, read 0x%02x\n", pb->base, w, r);
-                printk (KERN_INFO "parport 0x%lx: You gave this address, "
+                printk(KERN_INFO "parport 0x%lx: You gave this address, "
                         "but there is probably no parallel port there!\n",
                         pb->base);
         }
@@ -1691,33 +1754,33 @@ static int parport_ECR_present(struct parport *pb)
         struct parport_pc_private *priv = pb->private_data;
         unsigned char r = 0xc;
 
-        outb (r, CONTROL (pb));
-        if ((inb (ECONTROL (pb)) & 0x3) == (r & 0x3)) {
-                outb (r ^ 0x2, CONTROL (pb)); /* Toggle bit 1 */
+        outb(r, CONTROL(pb));
+        if ((inb(ECONTROL(pb)) & 0x3) == (r & 0x3)) {
+                outb(r ^ 0x2, CONTROL(pb)); /* Toggle bit 1 */
 
-                r = inb (CONTROL (pb));
-                if ((inb (ECONTROL (pb)) & 0x2) == (r & 0x2))
+                r = inb(CONTROL(pb));
+                if ((inb(ECONTROL(pb)) & 0x2) == (r & 0x2))
                         goto no_reg; /* Sure that no ECR register exists */
         }
-        
-        if ((inb (ECONTROL (pb)) & 0x3 ) != 0x1)
+
+        if ((inb(ECONTROL(pb)) & 0x3) != 0x1)
                 goto no_reg;
 
-        ECR_WRITE (pb, 0x34);
-        if (inb (ECONTROL (pb)) != 0x35)
+        ECR_WRITE(pb, 0x34);
+        if (inb(ECONTROL(pb)) != 0x35)
                 goto no_reg;
 
         priv->ecr = 1;
-        outb (0xc, CONTROL (pb));
-        
+        outb(0xc, CONTROL(pb));
+
         /* Go to mode 000 */
-        frob_set_mode (pb, ECR_SPP);
+        frob_set_mode(pb, ECR_SPP);
 
         return 1;
 
  no_reg:
-        outb (0xc, CONTROL (pb));
-        return 0; 
+        outb(0xc, CONTROL(pb));
+        return 0;
 }
 
 #ifdef CONFIG_PARPORT_1284
@@ -1727,7 +1790,7 @@ static int parport_ECR_present(struct parport *pb)
  * allows us to read data from the data lines.  In theory we would get back
  * 0xff but any peripheral attached to the port may drag some or all of the
  * lines down to zero.  So if we get back anything that isn't the contents
- * of the data register we deem PS/2 support to be present. 
+ * of the data register we deem PS/2 support to be present.
  *
  * Some SPP ports have "half PS/2" ability - you can't turn off the line
  * drivers, but an external peripheral with sufficiently beefy drivers of
@@ -1735,26 +1798,28 @@ static int parport_ECR_present(struct parport *pb)
  * where they can then be read back as normal.  Ports with this property
  * and the right type of device attached are likely to fail the SPP test,
  * (as they will appear to have stuck bits) and so the fact that they might
- * be misdetected here is rather academic. 
+ * be misdetected here is rather academic.
  */
 
 static int parport_PS2_supported(struct parport *pb)
 {
         int ok = 0;
-  
+
         clear_epp_timeout(pb);
 
         /* try to tri-state the buffer */
-        parport_pc_data_reverse (pb);
-        
+        parport_pc_data_reverse(pb);
+
         parport_pc_write_data(pb, 0x55);
-        if (parport_pc_read_data(pb) != 0x55) ok++;
+        if (parport_pc_read_data(pb) != 0x55)
+                ok++;
 
         parport_pc_write_data(pb, 0xaa);
-        if (parport_pc_read_data(pb) != 0xaa) ok++;
+        if (parport_pc_read_data(pb) != 0xaa)
+                ok++;
 
         /* cancel input mode */
-        parport_pc_data_forward (pb);
+        parport_pc_data_forward(pb);
 
         if (ok) {
                 pb->modes |= PARPORT_MODE_TRISTATE;
@@ -1773,68 +1838,68 @@ static int parport_ECP_supported(struct parport *pb)
         int config, configb;
         int pword;
         struct parport_pc_private *priv = pb->private_data;
-        /* Translate ECP intrLine to ISA irq value */   
-        static const int intrline[]= { 0, 7, 9, 10, 11, 14, 15, 5 }; 
+        /* Translate ECP intrLine to ISA irq value */
+        static const int intrline[] = { 0, 7, 9, 10, 11, 14, 15, 5 };
 
         /* If there is no ECR, we have no hope of supporting ECP. */
         if (!priv->ecr)
                 return 0;
 
         /* Find out FIFO depth */
-        ECR_WRITE (pb, ECR_SPP << 5); /* Reset FIFO */
-        ECR_WRITE (pb, ECR_TST << 5); /* TEST FIFO */
-        for (i=0; i < 1024 && !(inb (ECONTROL (pb)) & 0x02); i++)
-                outb (0xaa, FIFO (pb));
+        ECR_WRITE(pb, ECR_SPP << 5); /* Reset FIFO */
+        ECR_WRITE(pb, ECR_TST << 5); /* TEST FIFO */
+        for (i = 0; i < 1024 && !(inb(ECONTROL(pb)) & 0x02); i++)
+                outb(0xaa, FIFO(pb));
 
         /*
          * Using LGS chipset it uses ECR register, but
          * it doesn't support ECP or FIFO MODE
          */
         if (i == 1024) {
-                ECR_WRITE (pb, ECR_SPP << 5);
+                ECR_WRITE(pb, ECR_SPP << 5);
                 return 0;
         }
 
         priv->fifo_depth = i;
         if (verbose_probing)
-                printk (KERN_DEBUG "0x%lx: FIFO is %d bytes\n", pb->base, i);
+                printk(KERN_DEBUG "0x%lx: FIFO is %d bytes\n", pb->base, i);
 
         /* Find out writeIntrThreshold */
-        frob_econtrol (pb, 1<<2, 1<<2);
-        frob_econtrol (pb, 1<<2, 0);
+        frob_econtrol(pb, 1<<2, 1<<2);
+        frob_econtrol(pb, 1<<2, 0);
         for (i = 1; i <= priv->fifo_depth; i++) {
-                inb (FIFO (pb));
-                udelay (50);
-                if (inb (ECONTROL (pb)) & (1<<2))
+                inb(FIFO(pb));
+                udelay(50);
+                if (inb(ECONTROL(pb)) & (1<<2))
                         break;
         }
 
         if (i <= priv->fifo_depth) {
                 if (verbose_probing)
-                        printk (KERN_DEBUG "0x%lx: writeIntrThreshold is %d\n",
+                        printk(KERN_DEBUG "0x%lx: writeIntrThreshold is %d\n",
                                 pb->base, i);
         } else
                 /* Number of bytes we know we can write if we get an
-                   interrupt. */
+                   interrupt. */
                 i = 0;
 
         priv->writeIntrThreshold = i;
 
         /* Find out readIntrThreshold */
-        frob_set_mode (pb, ECR_PS2); /* Reset FIFO and enable PS2 */
-        parport_pc_data_reverse (pb); /* Must be in PS2 mode */
-        frob_set_mode (pb, ECR_TST); /* Test FIFO */
-        frob_econtrol (pb, 1<<2, 1<<2);
-        frob_econtrol (pb, 1<<2, 0);
+        frob_set_mode(pb, ECR_PS2); /* Reset FIFO and enable PS2 */
+        parport_pc_data_reverse(pb); /* Must be in PS2 mode */
+        frob_set_mode(pb, ECR_TST); /* Test FIFO */
+        frob_econtrol(pb, 1<<2, 1<<2);
+        frob_econtrol(pb, 1<<2, 0);
         for (i = 1; i <= priv->fifo_depth; i++) {
-                outb (0xaa, FIFO (pb));
-                if (inb (ECONTROL (pb)) & (1<<2))
+                outb(0xaa, FIFO(pb));
+                if (inb(ECONTROL(pb)) & (1<<2))
                         break;
         }
 
         if (i <= priv->fifo_depth) {
                 if (verbose_probing)
-                        printk (KERN_INFO "0x%lx: readIntrThreshold is %d\n",
+                        printk(KERN_INFO "0x%lx: readIntrThreshold is %d\n",
                                 pb->base, i);
         } else
                 /* Number of bytes we can read if we get an interrupt. */
@@ -1842,23 +1907,23 @@ static int parport_ECP_supported(struct parport *pb)
 
         priv->readIntrThreshold = i;
 
-        ECR_WRITE (pb, ECR_SPP << 5); /* Reset FIFO */
-        ECR_WRITE (pb, 0xf4); /* Configuration mode */
-        config = inb (CONFIGA (pb));
+        ECR_WRITE(pb, ECR_SPP << 5); /* Reset FIFO */
+        ECR_WRITE(pb, 0xf4); /* Configuration mode */
+        config = inb(CONFIGA(pb));
         pword = (config >> 4) & 0x7;
         switch (pword) {
         case 0:
                 pword = 2;
-                printk (KERN_WARNING "0x%lx: Unsupported pword size!\n",
+                printk(KERN_WARNING "0x%lx: Unsupported pword size!\n",
                         pb->base);
                 break;
         case 2:
                 pword = 4;
-                printk (KERN_WARNING "0x%lx: Unsupported pword size!\n",
+                printk(KERN_WARNING "0x%lx: Unsupported pword size!\n",
                         pb->base);
                 break;
         default:
-                printk (KERN_WARNING "0x%lx: Unknown implementation ID\n",
+                printk(KERN_WARNING "0x%lx: Unknown implementation ID\n",
                         pb->base);
                 /* Assume 1 */
         case 1:
@@ -1867,28 +1932,29 @@ static int parport_ECP_supported(struct parport *pb)
         priv->pword = pword;
 
         if (verbose_probing) {
-                printk (KERN_DEBUG "0x%lx: PWord is %d bits\n", pb->base, 8 * pword);
-                
-                printk (KERN_DEBUG "0x%lx: Interrupts are ISA-%s\n", pb->base,
+                printk(KERN_DEBUG "0x%lx: PWord is %d bits\n",
+                        pb->base, 8 * pword);
+
+                printk(KERN_DEBUG "0x%lx: Interrupts are ISA-%s\n", pb->base,
                         config & 0x80 ? "Level" : "Pulses");
 
-                configb = inb (CONFIGB (pb));
-                printk (KERN_DEBUG "0x%lx: ECP port cfgA=0x%02x cfgB=0x%02x\n",
+                configb = inb(CONFIGB(pb));
+                printk(KERN_DEBUG "0x%lx: ECP port cfgA=0x%02x cfgB=0x%02x\n",
                         pb->base, config, configb);
-                printk (KERN_DEBUG "0x%lx: ECP settings irq=", pb->base);
-                if ((configb >>3) & 0x07)
-                        printk("%d",intrline[(configb >>3) & 0x07]);
+                printk(KERN_DEBUG "0x%lx: ECP settings irq=", pb->base);
+                if ((configb >> 3) & 0x07)
+                        printk("%d", intrline[(configb >> 3) & 0x07]);
                 else
                         printk("<none or set by other means>");
-                printk (" dma=");
-                if( (configb & 0x03 ) == 0x00)
+                printk(" dma=");
+                if ((configb & 0x03) == 0x00)
                         printk("<none or set by other means>\n");
                 else
-                        printk("%d\n",configb & 0x07);
+                        printk("%d\n", configb & 0x07);
         }
 
         /* Go back to mode 000 */
-        frob_set_mode (pb, ECR_SPP);
+        frob_set_mode(pb, ECR_SPP);
 
         return 1;
 }
@@ -1903,10 +1969,10 @@ static int parport_ECPPS2_supported(struct parport *pb)
         if (!priv->ecr)
                 return 0;
 
-        oecr = inb (ECONTROL (pb));
-        ECR_WRITE (pb, ECR_PS2 << 5);
+        oecr = inb(ECONTROL(pb));
+        ECR_WRITE(pb, ECR_PS2 << 5);
         result = parport_PS2_supported(pb);
-        ECR_WRITE (pb, oecr);
+        ECR_WRITE(pb, oecr);
         return result;
 }
 
@@ -1930,16 +1996,15 @@ static int parport_EPP_supported(struct parport *pb)
          */
 
         /* If EPP timeout bit clear then EPP available */
-        if (!clear_epp_timeout(pb)) {
+        if (!clear_epp_timeout(pb))
                 return 0;  /* No way to clear timeout */
-        }
 
         /* Check for Intel bug. */
         if (priv->ecr) {
                 unsigned char i;
                 for (i = 0x00; i < 0x80; i += 0x20) {
-                        ECR_WRITE (pb, i);
-                        if (clear_epp_timeout (pb)) {
+                        ECR_WRITE(pb, i);
+                        if (clear_epp_timeout(pb)) {
                                 /* Phony EPP in ECP. */
                                 return 0;
                         }
@@ -1963,17 +2028,16 @@ static int parport_ECPEPP_supported(struct parport *pb)
         int result;
         unsigned char oecr;
 
-        if (!priv->ecr) {
+        if (!priv->ecr)
                 return 0;
-        }
 
-        oecr = inb (ECONTROL (pb));
+        oecr = inb(ECONTROL(pb));
         /* Search for SMC style EPP+ECP mode */
-        ECR_WRITE (pb, 0x80);
-        outb (0x04, CONTROL (pb));
+        ECR_WRITE(pb, 0x80);
+        outb(0x04, CONTROL(pb));
         result = parport_EPP_supported(pb);
 
-        ECR_WRITE (pb, oecr);
+        ECR_WRITE(pb, oecr);
 
         if (result) {
                 /* Set up access functions to use ECP+EPP hardware. */
@@ -1991,11 +2055,25 @@ static int parport_ECPEPP_supported(struct parport *pb)
 /* Don't bother probing for modes we know we won't use. */
 static int __devinit parport_PS2_supported(struct parport *pb) { return 0; }
 #ifdef CONFIG_PARPORT_PC_FIFO
-static int parport_ECP_supported(struct parport *pb) { return 0; }
+static int parport_ECP_supported(struct parport *pb)
+{
+        return 0;
+}
 #endif
-static int __devinit parport_EPP_supported(struct parport *pb) { return 0; }
-static int __devinit parport_ECPEPP_supported(struct parport *pb){return 0;}
-static int __devinit parport_ECPPS2_supported(struct parport *pb){return 0;}
+static int __devinit parport_EPP_supported(struct parport *pb)
+{
+        return 0;
+}
+
+static int __devinit parport_ECPEPP_supported(struct parport *pb)
+{
+        return 0;
+}
+
+static int __devinit parport_ECPPS2_supported(struct parport *pb)
+{
+        return 0;
+}
 
 #endif /* No IEEE 1284 support */
 
@@ -2005,17 +2083,17 @@ static int __devinit parport_ECPPS2_supported(struct parport *pb){return 0;}
 static int programmable_irq_support(struct parport *pb)
 {
         int irq, intrLine;
-        unsigned char oecr = inb (ECONTROL (pb));
+        unsigned char oecr = inb(ECONTROL(pb));
         static const int lookup[8] = {
                 PARPORT_IRQ_NONE, 7, 9, 10, 11, 14, 15, 5
         };
 
-        ECR_WRITE (pb, ECR_CNF << 5); /* Configuration MODE */
+        ECR_WRITE(pb, ECR_CNF << 5); /* Configuration MODE */
 
-        intrLine = (inb (CONFIGB (pb)) >> 3) & 0x07;
+        intrLine = (inb(CONFIGB(pb)) >> 3) & 0x07;
         irq = lookup[intrLine];
 
-        ECR_WRITE (pb, oecr);
+        ECR_WRITE(pb, oecr);
         return irq;
 }
 
@@ -2025,17 +2103,17 @@ static int irq_probe_ECP(struct parport *pb)
         unsigned long irqs;
 
         irqs = probe_irq_on();
-                
-        ECR_WRITE (pb, ECR_SPP << 5); /* Reset FIFO */
-        ECR_WRITE (pb, (ECR_TST << 5) | 0x04);
-        ECR_WRITE (pb, ECR_TST << 5);
+
+        ECR_WRITE(pb, ECR_SPP << 5); /* Reset FIFO */
+        ECR_WRITE(pb, (ECR_TST << 5) | 0x04);
+        ECR_WRITE(pb, ECR_TST << 5);
 
         /* If Full FIFO sure that writeIntrThreshold is generated */
-        for (i=0; i < 1024 && !(inb (ECONTROL (pb)) & 0x02) ; i++) 
-                outb (0xaa, FIFO (pb));
-                
+        for (i = 0; i < 1024 && !(inb(ECONTROL(pb)) & 0x02) ; i++)
+                outb(0xaa, FIFO(pb));
+
         pb->irq = probe_irq_off(irqs);
-        ECR_WRITE (pb, ECR_SPP << 5);
+        ECR_WRITE(pb, ECR_SPP << 5);
 
         if (pb->irq <= 0)
                 pb->irq = PARPORT_IRQ_NONE;
@@ -2045,7 +2123,7 @@ static int irq_probe_ECP(struct parport *pb)
 
 /*
  * This detection seems that only works in National Semiconductors
- * This doesn't work in SMC, LGS, and Winbond 
+ * This doesn't work in SMC, LGS, and Winbond
  */
 static int irq_probe_EPP(struct parport *pb)
 {
@@ -2056,16 +2134,16 @@ static int irq_probe_EPP(struct parport *pb)
         unsigned char oecr;
 
         if (pb->modes & PARPORT_MODE_PCECR)
-                oecr = inb (ECONTROL (pb));
+                oecr = inb(ECONTROL(pb));
 
         irqs = probe_irq_on();
 
         if (pb->modes & PARPORT_MODE_PCECR)
-                frob_econtrol (pb, 0x10, 0x10);
-        
+                frob_econtrol(pb, 0x10, 0x10);
+
         clear_epp_timeout(pb);
-        parport_pc_frob_control (pb, 0x20, 0x20);
-        parport_pc_frob_control (pb, 0x10, 0x10);
+        parport_pc_frob_control(pb, 0x20, 0x20);
+        parport_pc_frob_control(pb, 0x10, 0x10);
         clear_epp_timeout(pb);
 
         /* Device isn't expecting an EPP read
@@ -2074,9 +2152,9 @@ static int irq_probe_EPP(struct parport *pb)
         parport_pc_read_epp(pb);
         udelay(20);
 
-        pb->irq = probe_irq_off (irqs);
+        pb->irq = probe_irq_off(irqs);
         if (pb->modes & PARPORT_MODE_PCECR)
-                ECR_WRITE (pb, oecr);
+                ECR_WRITE(pb, oecr);
         parport_pc_write_control(pb, 0xc);
 
         if (pb->irq <= 0)
@@ -2133,28 +2211,28 @@ static int parport_irq_probe(struct parport *pb)
 /* --- DMA detection -------------------------------------- */
 
 /* Only if chipset conforms to ECP ISA Interface Standard */
-static int programmable_dma_support (struct parport *p)
+static int programmable_dma_support(struct parport *p)
 {
-        unsigned char oecr = inb (ECONTROL (p));
+        unsigned char oecr = inb(ECONTROL(p));
         int dma;
 
-        frob_set_mode (p, ECR_CNF);
-        
-        dma = inb (CONFIGB(p)) & 0x07;
+        frob_set_mode(p, ECR_CNF);
+
+        dma = inb(CONFIGB(p)) & 0x07;
         /* 000: Indicates jumpered 8-bit DMA if read-only.
            100: Indicates jumpered 16-bit DMA if read-only. */
         if ((dma & 0x03) == 0)
                 dma = PARPORT_DMA_NONE;
 
-        ECR_WRITE (p, oecr);
+        ECR_WRITE(p, oecr);
         return dma;
 }
 
-static int parport_dma_probe (struct parport *p)
+static int parport_dma_probe(struct parport *p)
 {
         const struct parport_pc_private *priv = p->private_data;
-        if (priv->ecr)
-                p->dma = programmable_dma_support(p); /* ask ECP chipset first */
+        if (priv->ecr)          /* ask ECP chipset first */
+                p->dma = programmable_dma_support(p);
         if (p->dma == PARPORT_DMA_NONE) {
                 /* ask known Super-IO chips proper, although these
                    claim ECP compatible, some don't report their DMA
@@ -2212,7 +2290,7 @@ struct parport *parport_pc_probe_port(unsigned long int base,
         if (!base_res)
                 goto out4;
 
-        memcpy(ops, &parport_pc_ops, sizeof (struct parport_operations));
+        memcpy(ops, &parport_pc_ops, sizeof(struct parport_operations));
         priv->ctr = 0xc;
         priv->ctr_writable = ~0x10;
         priv->ecr = 0;
@@ -2239,7 +2317,7 @@ struct parport *parport_pc_probe_port(unsigned long int base,
                         if (!parport_EPP_supported(p))
                                 parport_ECPEPP_supported(p);
         }
-        if (!parport_SPP_supported (p))
+        if (!parport_SPP_supported(p))
                 /* No port. */
                 goto out5;
         if (priv->ecr)
@@ -2247,7 +2325,7 @@ struct parport *parport_pc_probe_port(unsigned long int base,
         else
                 parport_PS2_supported(p);
 
-        p->size = (p->modes & PARPORT_MODE_EPP)?8:3;
+        p->size = (p->modes & PARPORT_MODE_EPP) ? 8 : 3;
 
         printk(KERN_INFO "%s: PC-style at 0x%lx", p->name, p->base);
         if (p->base_hi && priv->ecr)
@@ -2271,7 +2349,7 @@ struct parport *parport_pc_probe_port(unsigned long int base,
                 }
         }
         if (p->dma == PARPORT_DMA_AUTO) /* To use DMA, giving the irq
-                                           is mandatory (see above) */
+                                           is mandatory (see above) */
                 p->dma = PARPORT_DMA_NONE;
 
 #ifdef CONFIG_PARPORT_PC_FIFO
@@ -2288,16 +2366,23 @@ struct parport *parport_pc_probe_port(unsigned long int base,
                 if (p->dma != PARPORT_DMA_NONE) {
                         printk(", dma %d", p->dma);
                         p->modes |= PARPORT_MODE_DMA;
-                }
-                else printk(", using FIFO");
-        }
-        else
+                } else
+                        printk(", using FIFO");
+        } else
                 /* We can't use the DMA channel after all. */
                 p->dma = PARPORT_DMA_NONE;
 #endif /* Allowed to use FIFO/DMA */
 
         printk(" [");
-#define printmode(x) {if(p->modes&PARPORT_MODE_##x){printk("%s%s",f?",":"",#x);f++;}}
+
+#define printmode(x) \
+        {\
+                if (p->modes & PARPORT_MODE_##x) {\
+                        printk("%s%s", f ? "," : "", #x);\
+                        f++;\
+                } \
+        }
+
         {
                 int f = 0;
                 printmode(PCSPP);
@@ -2309,10 +2394,10 @@ struct parport *parport_pc_probe_port(unsigned long int base,
         }
 #undef printmode
 #ifndef CONFIG_PARPORT_1284
-        printk ("(,...)");
+        printk("(,...)");
 #endif /* CONFIG_PARPORT_1284 */
         printk("]\n");
-        if (probedirq != PARPORT_IRQ_NONE) 
+        if (probedirq != PARPORT_IRQ_NONE)
                 printk(KERN_INFO "%s: irq %d detected\n", p->name, probedirq);
 
         /* If No ECP release the ports grabbed above. */
@@ -2328,7 +2413,7 @@ struct parport *parport_pc_probe_port(unsigned long int base,
         if (p->irq != PARPORT_IRQ_NONE) {
                 if (request_irq(p->irq, parport_irq_handler,
                                  irqflags, p->name, p)) {
-                        printk (KERN_WARNING "%s: irq %d in use, "
+                        printk(KERN_WARNING "%s: irq %d in use, "
                                 "resorting to polled operation\n",
                                 p->name, p->irq);
                         p->irq = PARPORT_IRQ_NONE;
@@ -2338,8 +2423,8 @@ struct parport *parport_pc_probe_port(unsigned long int base,
 #ifdef CONFIG_PARPORT_PC_FIFO
 #ifdef HAS_DMA
                 if (p->dma != PARPORT_DMA_NONE) {
-                        if (request_dma (p->dma, p->name)) {
-                                printk (KERN_WARNING "%s: dma %d in use, "
+                        if (request_dma(p->dma, p->name)) {
+                                printk(KERN_WARNING "%s: dma %d in use, "
                                         "resorting to PIO operation\n",
                                         p->name, p->dma);
                                 p->dma = PARPORT_DMA_NONE;
@@ -2349,8 +2434,8 @@ struct parport *parport_pc_probe_port(unsigned long int base,
                                                        PAGE_SIZE,
                                                        &priv->dma_handle,
                                                        GFP_KERNEL);
-                                if (! priv->dma_buf) {
-                                        printk (KERN_WARNING "%s: "
+                                if (!priv->dma_buf) {
+                                        printk(KERN_WARNING "%s: "
                                                 "cannot get buffer for DMA, "
                                                 "resorting to PIO operation\n",
                                                 p->name);
@@ -2369,10 +2454,10 @@ struct parport *parport_pc_probe_port(unsigned long int base,
                  * Put the ECP detected port in PS2 mode.
                  * Do this also for ports that have ECR but don't do ECP.
                  */
-                ECR_WRITE (p, 0x34);
+                ECR_WRITE(p, 0x34);
 
         parport_pc_write_data(p, 0);
-        parport_pc_data_forward (p);
+        parport_pc_data_forward(p);
 
         /* Now that we've told the sharing engine about the port, and
            found out its characteristics, let the high-level drivers
@@ -2380,7 +2465,7 @@ struct parport *parport_pc_probe_port(unsigned long int base,
         spin_lock(&ports_lock);
         list_add(&priv->list, &ports_list);
         spin_unlock(&ports_lock);
-        parport_announce_port (p);
+        parport_announce_port(p);
 
         return p;
 
@@ -2393,18 +2478,17 @@ out5:
 out4:
         parport_put_port(p);
 out3:
-        kfree (priv);
+        kfree(priv);
 out2:
-        kfree (ops);
+        kfree(ops);
 out1:
         if (pdev)
                 platform_device_unregister(pdev);
         return NULL;
 }
+EXPORT_SYMBOL(parport_pc_probe_port);
 
-EXPORT_SYMBOL (parport_pc_probe_port);
-
-void parport_pc_unregister_port (struct parport *p)
+void parport_pc_unregister_port(struct parport *p)
 {
         struct parport_pc_private *priv = p->private_data;
         struct parport_operations *ops = p->ops;
@@ -2430,17 +2514,16 @@ void parport_pc_unregister_port (struct parport *p)
                                     priv->dma_buf,
                                     priv->dma_handle);
 #endif
-        kfree (p->private_data);
+        kfree(p->private_data);
         parport_put_port(p);
-        kfree (ops); /* hope no-one cached it */
+        kfree(ops); /* hope no-one cached it */
 }
-
-EXPORT_SYMBOL (parport_pc_unregister_port);
+EXPORT_SYMBOL(parport_pc_unregister_port);
 
 #ifdef CONFIG_PCI
 
 /* ITE support maintained by Rich Liu <richliu@poorman.org> */
-static int __devinit sio_ite_8872_probe (struct pci_dev *pdev, int autoirq,
+static int __devinit sio_ite_8872_probe(struct pci_dev *pdev, int autoirq,
                                          int autodma,
                                          const struct parport_pc_via_data *via)
 {
@@ -2452,73 +2535,74 @@ static int __devinit sio_ite_8872_probe (struct pci_dev *pdev, int autoirq,
         int irq;
         int i;
 
-        DPRINTK (KERN_DEBUG "sio_ite_8872_probe()\n");
-        
-        // make sure which one chip
-        for(i = 0; i < 5; i++) {
+        DPRINTK(KERN_DEBUG "sio_ite_8872_probe()\n");
+
+        /* make sure which one chip */
+        for (i = 0; i < 5; i++) {
                 base_res = request_region(inta_addr[i], 32, "it887x");
                 if (base_res) {
                         int test;
-                        pci_write_config_dword (pdev, 0x60,
+                        pci_write_config_dword(pdev, 0x60,
                                                 0xe5000000 | inta_addr[i]);
-                        pci_write_config_dword (pdev, 0x78,
+                        pci_write_config_dword(pdev, 0x78,
                                                 0x00000000 | inta_addr[i]);
-                        test = inb (inta_addr[i]);
-                        if (test != 0xff) break;
+                        test = inb(inta_addr[i]);
+                        if (test != 0xff)
+                                break;
                         release_region(inta_addr[i], 0x8);
                 }
         }
-        if(i >= 5) {
-                printk (KERN_INFO "parport_pc: cannot find ITE8872 INTA\n");
+        if (i >= 5) {
+                printk(KERN_INFO "parport_pc: cannot find ITE8872 INTA\n");
                 return 0;
         }
 
-        type = inb (inta_addr[i] + 0x18);
+        type = inb(inta_addr[i] + 0x18);
         type &= 0x0f;
 
         switch (type) {
         case 0x2:
-                printk (KERN_INFO "parport_pc: ITE8871 found (1P)\n");
+                printk(KERN_INFO "parport_pc: ITE8871 found (1P)\n");
                 ite8872set = 0x64200000;
                 break;
         case 0xa:
-                printk (KERN_INFO "parport_pc: ITE8875 found (1P)\n");
+                printk(KERN_INFO "parport_pc: ITE8875 found (1P)\n");
                 ite8872set = 0x64200000;
                 break;
         case 0xe:
-                printk (KERN_INFO "parport_pc: ITE8872 found (2S1P)\n");
+                printk(KERN_INFO "parport_pc: ITE8872 found (2S1P)\n");
                 ite8872set = 0x64e00000;
                 break;
         case 0x6:
-                printk (KERN_INFO "parport_pc: ITE8873 found (1S)\n");
+                printk(KERN_INFO "parport_pc: ITE8873 found (1S)\n");
                 return 0;
         case 0x8:
-                DPRINTK (KERN_DEBUG "parport_pc: ITE8874 found (2S)\n");
+                DPRINTK(KERN_DEBUG "parport_pc: ITE8874 found (2S)\n");
                 return 0;
         default:
-                printk (KERN_INFO "parport_pc: unknown ITE887x\n");
-                printk (KERN_INFO "parport_pc: please mail 'lspci -nvv' "
+                printk(KERN_INFO "parport_pc: unknown ITE887x\n");
+                printk(KERN_INFO "parport_pc: please mail 'lspci -nvv' "
                         "output to Rich.Liu@ite.com.tw\n");
                 return 0;
         }
 
-        pci_read_config_byte (pdev, 0x3c, &ite8872_irq);
-        pci_read_config_dword (pdev, 0x1c, &ite8872_lpt);
+        pci_read_config_byte(pdev, 0x3c, &ite8872_irq);
+        pci_read_config_dword(pdev, 0x1c, &ite8872_lpt);
         ite8872_lpt &= 0x0000ff00;
-        pci_read_config_dword (pdev, 0x20, &ite8872_lpthi);
+        pci_read_config_dword(pdev, 0x20, &ite8872_lpthi);
         ite8872_lpthi &= 0x0000ff00;
-        pci_write_config_dword (pdev, 0x6c, 0xe3000000 | ite8872_lpt);
-        pci_write_config_dword (pdev, 0x70, 0xe3000000 | ite8872_lpthi);
-        pci_write_config_dword (pdev, 0x80, (ite8872_lpthi<<16) | ite8872_lpt);
-        // SET SPP&EPP , Parallel Port NO DMA , Enable All Function
-        // SET Parallel IRQ
-        pci_write_config_dword (pdev, 0x9c,
+        pci_write_config_dword(pdev, 0x6c, 0xe3000000 | ite8872_lpt);
+        pci_write_config_dword(pdev, 0x70, 0xe3000000 | ite8872_lpthi);
+        pci_write_config_dword(pdev, 0x80, (ite8872_lpthi<<16) | ite8872_lpt);
+        /* SET SPP&EPP , Parallel Port NO DMA , Enable All Function */
+        /* SET Parallel IRQ */
+        pci_write_config_dword(pdev, 0x9c,
                                 ite8872set | (ite8872_irq * 0x11111));
 
-        DPRINTK (KERN_DEBUG "ITE887x: The IRQ is %d.\n", ite8872_irq);
-        DPRINTK (KERN_DEBUG "ITE887x: The PARALLEL I/O port is 0x%x.\n",
+        DPRINTK(KERN_DEBUG "ITE887x: The IRQ is %d.\n", ite8872_irq);
+        DPRINTK(KERN_DEBUG "ITE887x: The PARALLEL I/O port is 0x%x.\n",
                  ite8872_lpt);
-        DPRINTK (KERN_DEBUG "ITE887x: The PARALLEL I/O porthi is 0x%x.\n",
+        DPRINTK(KERN_DEBUG "ITE887x: The PARALLEL I/O porthi is 0x%x.\n",
                  ite8872_lpthi);
 
         /* Let the user (or defaults) steer us away from interrupts */
@@ -2530,14 +2614,14 @@ static int __devinit sio_ite_8872_probe (struct pci_dev *pdev, int autoirq,
          * Release the resource so that parport_pc_probe_port can get it.
          */
         release_resource(base_res);
-        if (parport_pc_probe_port (ite8872_lpt, ite8872_lpthi,
+        if (parport_pc_probe_port(ite8872_lpt, ite8872_lpthi,
                                    irq, PARPORT_DMA_NONE, &pdev->dev, 0)) {
-                printk (KERN_INFO
+                printk(KERN_INFO
                         "parport_pc: ITE 8872 parallel port: io=0x%X",
-                        ite8872_lpt);
+                                                                ite8872_lpt);
                 if (irq != PARPORT_IRQ_NONE)
-                        printk (", irq=%d", irq);
-                printk ("\n");
+                        printk(", irq=%d", irq);
+                printk("\n");
                 return 1;
         }
 
@@ -2546,7 +2630,7 @@ static int __devinit sio_ite_8872_probe (struct pci_dev *pdev, int autoirq,
 
 /* VIA 8231 support by Pavel Fedin <sonic_amiga@rambler.ru>
    based on VIA 686a support code by Jeff Garzik <jgarzik@pobox.com> */
-static int __devinitdata parport_init_mode = 0;
+static int __devinitdata parport_init_mode;
 
 /* Data for two known VIA chips */
 static struct parport_pc_via_data via_686a_data __devinitdata = {
@@ -2568,7 +2652,7 @@ static struct parport_pc_via_data via_8231_data __devinitdata = {
         0xF6
 };
 
-static int __devinit sio_via_probe (struct pci_dev *pdev, int autoirq,
+static int __devinit sio_via_probe(struct pci_dev *pdev, int autoirq,
                                     int autodma,
                                     const struct parport_pc_via_data *via)
 {
@@ -2580,38 +2664,38 @@ static int __devinit sio_via_probe (struct pci_dev *pdev, int autoirq,
 
         printk(KERN_DEBUG "parport_pc: VIA 686A/8231 detected\n");
 
-        switch(parport_init_mode)
-        {
+        switch (parport_init_mode) {
         case 1:
-            printk(KERN_DEBUG "parport_pc: setting SPP mode\n");
-            siofunc = VIA_FUNCTION_PARPORT_SPP;
-            break;
+                printk(KERN_DEBUG "parport_pc: setting SPP mode\n");
+                siofunc = VIA_FUNCTION_PARPORT_SPP;
+                break;
         case 2:
-            printk(KERN_DEBUG "parport_pc: setting PS/2 mode\n");
-            siofunc = VIA_FUNCTION_PARPORT_SPP;
-            ppcontrol = VIA_PARPORT_BIDIR;
-            break;
+                printk(KERN_DEBUG "parport_pc: setting PS/2 mode\n");
+                siofunc = VIA_FUNCTION_PARPORT_SPP;
+                ppcontrol = VIA_PARPORT_BIDIR;
+                break;
         case 3:
-            printk(KERN_DEBUG "parport_pc: setting EPP mode\n");
-            siofunc = VIA_FUNCTION_PARPORT_EPP;
-            ppcontrol = VIA_PARPORT_BIDIR;
-            have_epp = 1;
-            break;
+                printk(KERN_DEBUG "parport_pc: setting EPP mode\n");
+                siofunc = VIA_FUNCTION_PARPORT_EPP;
+                ppcontrol = VIA_PARPORT_BIDIR;
+                have_epp = 1;
+                break;
         case 4:
-            printk(KERN_DEBUG "parport_pc: setting ECP mode\n");
-            siofunc = VIA_FUNCTION_PARPORT_ECP;
-            ppcontrol = VIA_PARPORT_BIDIR;
-            break;
+                printk(KERN_DEBUG "parport_pc: setting ECP mode\n");
+                siofunc = VIA_FUNCTION_PARPORT_ECP;
+                ppcontrol = VIA_PARPORT_BIDIR;
+                break;
         case 5:
-            printk(KERN_DEBUG "parport_pc: setting EPP+ECP mode\n");
-            siofunc = VIA_FUNCTION_PARPORT_ECP;
-            ppcontrol = VIA_PARPORT_BIDIR|VIA_PARPORT_ECPEPP;
-            have_epp = 1;
-            break;
-         default:
-            printk(KERN_DEBUG "parport_pc: probing current configuration\n");
-            siofunc = VIA_FUNCTION_PROBE;
-            break;
+                printk(KERN_DEBUG "parport_pc: setting EPP+ECP mode\n");
+                siofunc = VIA_FUNCTION_PARPORT_ECP;
+                ppcontrol = VIA_PARPORT_BIDIR|VIA_PARPORT_ECPEPP;
+                have_epp = 1;
+                break;
+        default:
+                printk(KERN_DEBUG
+                        "parport_pc: probing current configuration\n");
+                siofunc = VIA_FUNCTION_PROBE;
+                break;
         }
         /*
          * unlock super i/o configuration
@@ -2622,38 +2706,36 @@ static int __devinit sio_via_probe (struct pci_dev *pdev, int autoirq,
 
         /* Bits 1-0: Parallel Port Mode / Enable */
         outb(via->viacfg_function, VIA_CONFIG_INDEX);
-        tmp = inb (VIA_CONFIG_DATA);
+        tmp = inb(VIA_CONFIG_DATA);
         /* Bit 5: EPP+ECP enable; bit 7: PS/2 bidirectional port enable */
         outb(via->viacfg_parport_control, VIA_CONFIG_INDEX);
-        tmp2 = inb (VIA_CONFIG_DATA);
-        if (siofunc == VIA_FUNCTION_PROBE)
-        {
-            siofunc = tmp & VIA_FUNCTION_PARPORT_DISABLE;
-            ppcontrol = tmp2;
+        tmp2 = inb(VIA_CONFIG_DATA);
+        if (siofunc == VIA_FUNCTION_PROBE) {
+                siofunc = tmp & VIA_FUNCTION_PARPORT_DISABLE;
+                ppcontrol = tmp2;
+        } else {
+                tmp &= ~VIA_FUNCTION_PARPORT_DISABLE;
+                tmp |= siofunc;
+                outb(via->viacfg_function, VIA_CONFIG_INDEX);
+                outb(tmp, VIA_CONFIG_DATA);
+                tmp2 &= ~(VIA_PARPORT_BIDIR|VIA_PARPORT_ECPEPP);
+                tmp2 |= ppcontrol;
+                outb(via->viacfg_parport_control, VIA_CONFIG_INDEX);
+                outb(tmp2, VIA_CONFIG_DATA);
         }
-        else
-        {
-            tmp &= ~VIA_FUNCTION_PARPORT_DISABLE;
-            tmp |= siofunc;
-            outb(via->viacfg_function, VIA_CONFIG_INDEX);
-            outb(tmp, VIA_CONFIG_DATA);
-            tmp2 &= ~(VIA_PARPORT_BIDIR|VIA_PARPORT_ECPEPP);
-            tmp2 |= ppcontrol;
-            outb(via->viacfg_parport_control, VIA_CONFIG_INDEX);
-            outb(tmp2, VIA_CONFIG_DATA);
-        }
-        
+
         /* Parallel Port I/O Base Address, bits 9-2 */
         outb(via->viacfg_parport_base, VIA_CONFIG_INDEX);
         port1 = inb(VIA_CONFIG_DATA) << 2;
-        
-        printk (KERN_DEBUG "parport_pc: Current parallel port base: 0x%X\n",port1);
-        if ((port1 == 0x3BC) && have_epp)
-        {
-            outb(via->viacfg_parport_base, VIA_CONFIG_INDEX);
-            outb((0x378 >> 2), VIA_CONFIG_DATA);
-            printk(KERN_DEBUG "parport_pc: Parallel port base changed to 0x378\n");
-            port1 = 0x378;
+
+        printk(KERN_DEBUG "parport_pc: Current parallel port base: 0x%X\n",
+                                                                        port1);
+        if (port1 == 0x3BC && have_epp) {
+                outb(via->viacfg_parport_base, VIA_CONFIG_INDEX);
+                outb((0x378 >> 2), VIA_CONFIG_DATA);
+                printk(KERN_DEBUG
+                        "parport_pc: Parallel port base changed to 0x378\n");
+                port1 = 0x378;
         }
 
         /*
@@ -2667,36 +2749,39 @@ static int __devinit sio_via_probe (struct pci_dev *pdev, int autoirq,
                 printk(KERN_INFO "parport_pc: VIA parallel port disabled in BIOS\n");
                 return 0;
         }
-        
+
         /* Bits 7-4: PnP Routing for Parallel Port IRQ */
         pci_read_config_byte(pdev, via->via_pci_parport_irq_reg, &tmp);
         irq = ((tmp & VIA_IRQCONTROL_PARALLEL) >> 4);
 
-        if (siofunc == VIA_FUNCTION_PARPORT_ECP)
-        {
-            /* Bits 3-2: PnP Routing for Parallel Port DMA */
-            pci_read_config_byte(pdev, via->via_pci_parport_dma_reg, &tmp);
-            dma = ((tmp & VIA_DMACONTROL_PARALLEL) >> 2);
-        }
-        else
-            /* if ECP not enabled, DMA is not enabled, assumed bogus 'dma' value */
-            dma = PARPORT_DMA_NONE;
+        if (siofunc == VIA_FUNCTION_PARPORT_ECP) {
+                /* Bits 3-2: PnP Routing for Parallel Port DMA */
+                pci_read_config_byte(pdev, via->via_pci_parport_dma_reg, &tmp);
+                dma = ((tmp & VIA_DMACONTROL_PARALLEL) >> 2);
+        } else
+                /* if ECP not enabled, DMA is not enabled, assumed
+                   bogus 'dma' value */
+                dma = PARPORT_DMA_NONE;
 
         /* Let the user (or defaults) steer us away from interrupts and DMA */
         if (autoirq == PARPORT_IRQ_NONE) {
-            irq = PARPORT_IRQ_NONE;
-            dma = PARPORT_DMA_NONE;
+                irq = PARPORT_IRQ_NONE;
+                dma = PARPORT_DMA_NONE;
         }
         if (autodma == PARPORT_DMA_NONE)
-            dma = PARPORT_DMA_NONE;
+                dma = PARPORT_DMA_NONE;
 
         switch (port1) {
-        case 0x3bc: port2 = 0x7bc; break;
-        case 0x378: port2 = 0x778; break;
-        case 0x278: port2 = 0x678; break;
+        case 0x3bc:
+                port2 = 0x7bc; break;
+        case 0x378:
+                port2 = 0x778; break;
+        case 0x278:
+                port2 = 0x678; break;
         default:
-                printk(KERN_INFO "parport_pc: Weird VIA parport base 0x%X, ignoring\n",
-                        port1);
+                printk(KERN_INFO
+                        "parport_pc: Weird VIA parport base 0x%X, ignoring\n",
+                                                                        port1);
                 return 0;
         }
 
@@ -2714,17 +2799,17 @@ static int __devinit sio_via_probe (struct pci_dev *pdev, int autoirq,
         }
 
         /* finally, do the probe with values obtained */
-        if (parport_pc_probe_port (port1, port2, irq, dma, &pdev->dev, 0)) {
-                printk (KERN_INFO
+        if (parport_pc_probe_port(port1, port2, irq, dma, &pdev->dev, 0)) {
+                printk(KERN_INFO
                         "parport_pc: VIA parallel port: io=0x%X", port1);
                 if (irq != PARPORT_IRQ_NONE)
-                        printk (", irq=%d", irq);
+                        printk(", irq=%d", irq);
                 if (dma != PARPORT_DMA_NONE)
-                        printk (", dma=%d", dma);
-                printk ("\n");
+                        printk(", dma=%d", dma);
+                printk("\n");
                 return 1;
         }
-        
+
         printk(KERN_WARNING "parport_pc: Strange, can't probe VIA parallel port: io=0x%X, irq=%d, dma=%d\n",
                 port1, irq, dma);
         return 0;
@@ -2732,8 +2817,8 @@ static int __devinit sio_via_probe (struct pci_dev *pdev, int autoirq,
 
 
 enum parport_pc_sio_types {
-        sio_via_686a = 0,       /* Via VT82C686A motherboard Super I/O */
-        sio_via_8231,           /* Via VT8231 south bridge integrated Super IO */
+        sio_via_686a = 0,   /* Via VT82C686A motherboard Super I/O */
+        sio_via_8231,       /* Via VT8231 south bridge integrated Super IO */
         sio_ite_8872,
         last_sio
 };
@@ -2804,15 +2889,15 @@ enum parport_pc_pci_cards {
 };
 
 
-/* each element directly indexed from enum list, above 
+/* each element directly indexed from enum list, above
  * (but offset by last_sio) */
 static struct parport_pc_pci {
         int numports;
         struct { /* BAR (base address registers) numbers in the config
-                    space header */
+                    space header */
                 int lo;
-                int hi; /* -1 if not there, >6 for offset-method (max
-                           BAR is 6) */
+                int hi;
+                /* -1 if not there, >6 for offset-method (max BAR is 6) */
         } addr[4];
 
         /* If set, this is called immediately after pci_enable_device.
@@ -2857,7 +2942,7 @@ static struct parport_pc_pci {
         /* timedia_4018  */             { 2, { { 0, 1 }, { 2, 3 }, } },
         /* timedia_9018a */             { 2, { { 0, 1 }, { 2, 3 }, } },
                                         /* SYBA uses fixed offsets in
-                                           a 1K io window */
+                                           a 1K io window */
         /* syba_2p_epp AP138B */        { 2, { { 0, 0x078 }, { 0, 0x178 }, } },
         /* syba_1p_ecp W83787 */        { 1, { { 0, 0x078 }, } },
         /* titan_010l */                { 1, { { 3, -1 }, } },
@@ -2873,11 +2958,14 @@ static struct parport_pc_pci {
         /* oxsemi_pcie_pport */         { 1, { { 0, 1 }, } },
         /* aks_0100 */                  { 1, { { 0, -1 }, } },
         /* mobility_pp */               { 1, { { 0, 1 }, } },
-        /* netmos_9705 */               { 1, { { 0, -1 }, } }, /* untested */
-        /* netmos_9715 */               { 2, { { 0, 1 }, { 2, 3 },} }, /* untested */
-        /* netmos_9755 */               { 2, { { 0, 1 }, { 2, 3 },} }, /* untested */
-        /* netmos_9805 */               { 1, { { 0, -1 }, } }, /* untested */
-        /* netmos_9815 */               { 2, { { 0, -1 }, { 2, -1 }, } }, /* untested */
+
+        /* The netmos entries below are untested */
+        /* netmos_9705 */               { 1, { { 0, -1 }, } },
+        /* netmos_9715 */               { 2, { { 0, 1 }, { 2, 3 },} },
+        /* netmos_9755 */               { 2, { { 0, 1 }, { 2, 3 },} },
+        /* netmos_9805 */               { 1, { { 0, -1 }, } },
+        /* netmos_9815 */               { 2, { { 0, -1 }, { 2, -1 }, } },
+
         /* quatech_sppxp100 */          { 1, { { 0, 1 }, } },
 };
 
@@ -2906,7 +2994,7 @@ static const struct pci_device_id parport_pc_pci_tbl[] = {
         { PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_BOCA_IOPPAR,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, boca_ioppar },
         { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
-          PCI_SUBVENDOR_ID_EXSYS, PCI_SUBDEVICE_ID_EXSYS_4014, 0,0, plx_9050 },
+          PCI_SUBVENDOR_ID_EXSYS, PCI_SUBDEVICE_ID_EXSYS_4014, 0, 0, plx_9050 },
         /* PCI_VENDOR_ID_TIMEDIA/SUNIX has many differing cards ...*/
         { 0x1409, 0x7168, 0x1409, 0x4078, 0, 0, timedia_4078a },
         { 0x1409, 0x7168, 0x1409, 0x4079, 0, 0, timedia_4079h },
@@ -2940,7 +3028,8 @@ static const struct pci_device_id parport_pc_pci_tbl[] = {
         { 0x9710, 0x9805, 0x1000, 0x0010, 0, 0, titan_1284p1 },
         { 0x9710, 0x9815, 0x1000, 0x0020, 0, 0, titan_1284p2 },
         /* PCI_VENDOR_ID_AVLAB/Intek21 has another bunch of cards ...*/
-        { 0x14db, 0x2120, PCI_ANY_ID, PCI_ANY_ID, 0, 0, avlab_1p}, /* AFAVLAB_TK9902 */
+        /* AFAVLAB_TK9902 */
+        { 0x14db, 0x2120, PCI_ANY_ID, PCI_ANY_ID, 0, 0, avlab_1p},
         { 0x14db, 0x2121, PCI_ANY_ID, PCI_ANY_ID, 0, 0, avlab_2p},
         { PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI952PP,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, oxsemi_952 },
@@ -2983,14 +3072,14 @@ static const struct pci_device_id parport_pc_pci_tbl[] = {
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, quatech_sppxp100 },
         { 0, } /* terminate list */
 };
-MODULE_DEVICE_TABLE(pci,parport_pc_pci_tbl);
+MODULE_DEVICE_TABLE(pci, parport_pc_pci_tbl);
 
 struct pci_parport_data {
         int num;
         struct parport *ports[2];
 };
 
-static int parport_pc_pci_probe (struct pci_dev *dev,
+static int parport_pc_pci_probe(struct pci_dev *dev,
                                            const struct pci_device_id *id)
 {
         int err, count, n, i = id->driver_data;
@@ -3003,7 +3092,8 @@ static int parport_pc_pci_probe (struct pci_dev *dev,
         /* This is a PCI card */
         i -= last_sio;
         count = 0;
-        if ((err = pci_enable_device (dev)) != 0)
+        err = pci_enable_device(dev);
+        if (err)
                 return err;
 
         data = kmalloc(sizeof(struct pci_parport_data), GFP_KERNEL);
@@ -3011,7 +3101,7 @@ static int parport_pc_pci_probe (struct pci_dev *dev,
                 return -ENOMEM;
 
         if (cards[i].preinit_hook &&
-            cards[i].preinit_hook (dev, PARPORT_IRQ_NONE, PARPORT_DMA_NONE)) {
+            cards[i].preinit_hook(dev, PARPORT_IRQ_NONE, PARPORT_DMA_NONE)) {
                 kfree(data);
                 return -ENODEV;
         }
@@ -3021,25 +3111,25 @@ static int parport_pc_pci_probe (struct pci_dev *dev,
                 int hi = cards[i].addr[n].hi;
                 int irq;
                 unsigned long io_lo, io_hi;
-                io_lo = pci_resource_start (dev, lo);
+                io_lo = pci_resource_start(dev, lo);
                 io_hi = 0;
                 if ((hi >= 0) && (hi <= 6))
-                        io_hi = pci_resource_start (dev, hi);
+                        io_hi = pci_resource_start(dev, hi);
                 else if (hi > 6)
                         io_lo += hi; /* Reinterpret the meaning of
-                                        "hi" as an offset (see SYBA
-                                        def.) */
+                                        "hi" as an offset (see SYBA
+                                        def.) */
                 /* TODO: test if sharing interrupts works */
                 irq = dev->irq;
                 if (irq == IRQ_NONE) {
-                        printk (KERN_DEBUG
+                        printk(KERN_DEBUG
         "PCI parallel port detected: %04x:%04x, I/O at %#lx(%#lx)\n",
                                 parport_pc_pci_tbl[i + last_sio].vendor,
                                 parport_pc_pci_tbl[i + last_sio].device,
                                 io_lo, io_hi);
                         irq = PARPORT_IRQ_NONE;
                 } else {
-                        printk (KERN_DEBUG
+                        printk(KERN_DEBUG
         "PCI parallel port detected: %04x:%04x, I/O at %#lx(%#lx), IRQ %d\n",
                                 parport_pc_pci_tbl[i + last_sio].vendor,
                                 parport_pc_pci_tbl[i + last_sio].device,
@@ -3056,7 +3146,7 @@ static int parport_pc_pci_probe (struct pci_dev *dev,
         data->num = count;
 
         if (cards[i].postinit_hook)
-                cards[i].postinit_hook (dev, count == 0);
+                cards[i].postinit_hook(dev, count == 0);
 
         if (count) {
                 pci_set_drvdata(dev, data);
@@ -3090,7 +3180,7 @@ static struct pci_driver parport_pc_pci_driver = {
         .remove         = __devexit_p(parport_pc_pci_remove),
 };
 
-static int __init parport_pc_init_superio (int autoirq, int autodma)
+static int __init parport_pc_init_superio(int autoirq, int autodma)
 {
         const struct pci_device_id *id;
         struct pci_dev *pdev = NULL;
@@ -3101,8 +3191,9 @@ static int __init parport_pc_init_superio (int autoirq, int autodma)
                 if (id == NULL || id->driver_data >= last_sio)
                         continue;
 
-                if (parport_pc_superio_info[id->driver_data].probe
-                        (pdev, autoirq, autodma,parport_pc_superio_info[id->driver_data].via)) {
+                if (parport_pc_superio_info[id->driver_data].probe(
+                        pdev, autoirq, autodma,
+                        parport_pc_superio_info[id->driver_data].via)) {
                         ret++;
                 }
         }
@@ -3111,7 +3202,10 @@ static int __init parport_pc_init_superio (int autoirq, int autodma)
 }
 #else
 static struct pci_driver parport_pc_pci_driver;
-static int __init parport_pc_init_superio(int autoirq, int autodma) {return 0;}
+static int __init parport_pc_init_superio(int autoirq, int autodma)
+{
+        return 0;
+}
 #endif /* CONFIG_PCI */
 
 #ifdef CONFIG_PNP
@@ -3124,44 +3218,45 @@ static const struct pnp_device_id parport_pc_pnp_tbl[] = {
         { }
 };
 
-MODULE_DEVICE_TABLE(pnp,parport_pc_pnp_tbl);
+MODULE_DEVICE_TABLE(pnp, parport_pc_pnp_tbl);
 
-static int parport_pc_pnp_probe(struct pnp_dev *dev, const struct pnp_device_id *id)
+static int parport_pc_pnp_probe(struct pnp_dev *dev,
+                                                const struct pnp_device_id *id)
 {
         struct parport *pdata;
         unsigned long io_lo, io_hi;
         int dma, irq;
 
-        if (pnp_port_valid(dev,0) &&
-                !(pnp_port_flags(dev,0) & IORESOURCE_DISABLED)) {
-                io_lo = pnp_port_start(dev,0);
+        if (pnp_port_valid(dev, 0) &&
+                !(pnp_port_flags(dev, 0) & IORESOURCE_DISABLED)) {
+                io_lo = pnp_port_start(dev, 0);
         } else
                 return -EINVAL;
 
-        if (pnp_port_valid(dev,1) &&
-                !(pnp_port_flags(dev,1) & IORESOURCE_DISABLED)) {
-                io_hi = pnp_port_start(dev,1);
+        if (pnp_port_valid(dev, 1) &&
+                !(pnp_port_flags(dev, 1) & IORESOURCE_DISABLED)) {
+                io_hi = pnp_port_start(dev, 1);
         } else
                 io_hi = 0;
 
-        if (pnp_irq_valid(dev,0) &&
-                !(pnp_irq_flags(dev,0) & IORESOURCE_DISABLED)) {
-                irq = pnp_irq(dev,0);
+        if (pnp_irq_valid(dev, 0) &&
+                !(pnp_irq_flags(dev, 0) & IORESOURCE_DISABLED)) {
+                irq = pnp_irq(dev, 0);
         } else
                 irq = PARPORT_IRQ_NONE;
 
-        if (pnp_dma_valid(dev,0) &&
-                !(pnp_dma_flags(dev,0) & IORESOURCE_DISABLED)) {
-                dma = pnp_dma(dev,0);
+        if (pnp_dma_valid(dev, 0) &&
+                !(pnp_dma_flags(dev, 0) & IORESOURCE_DISABLED)) {
+                dma = pnp_dma(dev, 0);
         } else
                 dma = PARPORT_DMA_NONE;
 
         dev_info(&dev->dev, "reported by %s\n", dev->protocol->name);
-        if (!(pdata = parport_pc_probe_port(io_lo, io_hi,
-                                        irq, dma, &dev->dev, 0)))
+        pdata = parport_pc_probe_port(io_lo, io_hi, irq, dma, &dev->dev, 0);
+        if (pdata == NULL)
                 return -ENODEV;
 
-        pnp_set_drvdata(dev,pdata);
+        pnp_set_drvdata(dev, pdata);
         return 0;
 }
 
@@ -3203,7 +3298,7 @@ static struct platform_driver parport_pc_platform_driver = {
 
 /* This is called by parport_pc_find_nonpci_ports (in asm/parport.h) */
 static int __devinit __attribute__((unused))
-parport_pc_find_isa_ports (int autoirq, int autodma)
+parport_pc_find_isa_ports(int autoirq, int autodma)
 {
         int count = 0;
 
@@ -3227,7 +3322,7 @@ parport_pc_find_isa_ports (int autoirq, int autodma)
  * autoirq is PARPORT_IRQ_NONE, PARPORT_IRQ_AUTO, or PARPORT_IRQ_PROBEONLY
  * autodma is PARPORT_DMA_NONE or PARPORT_DMA_AUTO
  */
-static void __init parport_pc_find_ports (int autoirq, int autodma)
+static void __init parport_pc_find_ports(int autoirq, int autodma)
 {
         int count = 0, err;
 
@@ -3261,11 +3356,18 @@ static void __init parport_pc_find_ports (int autoirq, int autodma)
  *      syntax and keep in mind that code below is a cleaned up version.
  */
 
-static int __initdata io[PARPORT_PC_MAX_PORTS+1] = { [0 ... PARPORT_PC_MAX_PORTS] = 0 };
-static int __initdata io_hi[PARPORT_PC_MAX_PORTS+1] =
-        { [0 ... PARPORT_PC_MAX_PORTS] = PARPORT_IOHI_AUTO };
-static int __initdata dmaval[PARPORT_PC_MAX_PORTS] = { [0 ... PARPORT_PC_MAX_PORTS-1] = PARPORT_DMA_NONE };
-static int __initdata irqval[PARPORT_PC_MAX_PORTS] = { [0 ... PARPORT_PC_MAX_PORTS-1] = PARPORT_IRQ_PROBEONLY };
+static int __initdata io[PARPORT_PC_MAX_PORTS+1] = {
+        [0 ... PARPORT_PC_MAX_PORTS] = 0
+};
+static int __initdata io_hi[PARPORT_PC_MAX_PORTS+1] = {
+        [0 ... PARPORT_PC_MAX_PORTS] = PARPORT_IOHI_AUTO
+};
+static int __initdata dmaval[PARPORT_PC_MAX_PORTS] = {
+        [0 ... PARPORT_PC_MAX_PORTS-1] = PARPORT_DMA_NONE
+};
+static int __initdata irqval[PARPORT_PC_MAX_PORTS] = {
+        [0 ... PARPORT_PC_MAX_PORTS-1] = PARPORT_IRQ_PROBEONLY
+};
 
 static int __init parport_parse_param(const char *s, int *val,
                                 int automatic, int none, int nofifo)
@@ -3306,18 +3408,19 @@ static int __init parport_parse_dma(const char *dmastr, int *val)
 #ifdef CONFIG_PCI
 static int __init parport_init_mode_setup(char *str)
 {
-        printk(KERN_DEBUG "parport_pc.c: Specified parameter parport_init_mode=%s\n", str);
-
-        if (!strcmp (str, "spp"))
-                parport_init_mode=1;
-        if (!strcmp (str, "ps2"))
-                parport_init_mode=2;
-        if (!strcmp (str, "epp"))
-                parport_init_mode=3;
-        if (!strcmp (str, "ecp"))
-                parport_init_mode=4;
-        if (!strcmp (str, "ecpepp"))
-                parport_init_mode=5;
+        printk(KERN_DEBUG
+             "parport_pc.c: Specified parameter parport_init_mode=%s\n", str);
+
+        if (!strcmp(str, "spp"))
+                parport_init_mode = 1;
+        if (!strcmp(str, "ps2"))
+                parport_init_mode = 2;
+        if (!strcmp(str, "epp"))
+                parport_init_mode = 3;
+        if (!strcmp(str, "ecp"))
+                parport_init_mode = 4;
+        if (!strcmp(str, "ecpepp"))
+                parport_init_mode = 5;
         return 1;
 }
 #endif
@@ -3341,7 +3444,8 @@ module_param(verbose_probing, int, 0644);
 #endif
 #ifdef CONFIG_PCI
 static char *init_mode;
-MODULE_PARM_DESC(init_mode, "Initialise mode for VIA VT8231 port (spp, ps2, epp, ecp or ecpepp)");
+MODULE_PARM_DESC(init_mode,
+        "Initialise mode for VIA VT8231 port (spp, ps2, epp, ecp or ecpepp)");
 module_param(init_mode, charp, 0);
 #endif
 
@@ -3372,7 +3476,7 @@ static int __init parse_parport_params(void)
                                 irqval[0] = val;
                                 break;
                         default:
-                                printk (KERN_WARNING
+                                printk(KERN_WARNING
                                         "parport_pc: irq specified "
                                         "without base address.  Use 'io=' "
                                         "to specify one\n");
@@ -3385,7 +3489,7 @@ static int __init parse_parport_params(void)
                                 dmaval[0] = val;
                                 break;
                         default:
-                                printk (KERN_WARNING
+                                printk(KERN_WARNING
                                         "parport_pc: dma specified "
                                         "without base address.  Use 'io=' "
                                         "to specify one\n");
@@ -3396,7 +3500,7 @@ static int __init parse_parport_params(void)
 
 #else
 
-static int parport_setup_ptr __initdata = 0;
+static int parport_setup_ptr __initdata;
 
 /*
  * Acceptable parameters:
@@ -3407,7 +3511,7 @@ static int parport_setup_ptr __initdata = 0;
  *
  * IRQ/DMA may be numeric or 'auto' or 'none'
  */
-static int __init parport_setup (char *str)
+static int __init parport_setup(char *str)
 {
         char *endptr;
         char *sep;
@@ -3419,15 +3523,15 @@ static int __init parport_setup (char *str)
                 return 1;
         }
 
-        if (!strncmp (str, "auto", 4)) {
+        if (!strncmp(str, "auto", 4)) {
                 irqval[0] = PARPORT_IRQ_AUTO;
                 dmaval[0] = PARPORT_DMA_AUTO;
                 return 1;
         }
 
-        val = simple_strtoul (str, &endptr, 0);
+        val = simple_strtoul(str, &endptr, 0);
         if (endptr == str) {
-                printk (KERN_WARNING "parport=%s not understood\n", str);
+                printk(KERN_WARNING "parport=%s not understood\n", str);
                 return 1;
         }
 
@@ -3461,7 +3565,7 @@ static int __init parse_parport_params(void)
         return io[0] == PARPORT_DISABLE;
 }
 
-__setup ("parport=", parport_setup);
+__setup("parport=", parport_setup);
 
 /*
  * Acceptable parameters:
@@ -3469,7 +3573,7 @@ __setup ("parport=", parport_setup);
  * parport_init_mode=[spp|ps2|epp|ecp|ecpepp]
  */
 #ifdef CONFIG_PCI
-__setup("parport_init_mode=",parport_init_mode_setup);
+__setup("parport_init_mode=", parport_init_mode_setup);
 #endif
 #endif
 
@@ -3493,13 +3597,13 @@ static int __init parport_pc_init(void)
                 for (i = 0; i < PARPORT_PC_MAX_PORTS; i++) {
                         if (!io[i])
                                 break;
-                        if ((io_hi[i]) == PARPORT_IOHI_AUTO)
-                               io_hi[i] = 0x400 + io[i];
+                        if (io_hi[i] == PARPORT_IOHI_AUTO)
+                                io_hi[i] = 0x400 + io[i];
                         parport_pc_probe_port(io[i], io_hi[i],
-                                          irqval[i], dmaval[i], NULL, 0);
+                                        irqval[i], dmaval[i], NULL, 0);
                 }
         } else
-                parport_pc_find_ports (irqval[0], dmaval[0]);
+                parport_pc_find_ports(irqval[0], dmaval[0]);
 
         return 0;
 }
@@ -3507,9 +3611,9 @@ static int __init parport_pc_init(void)
 static void __exit parport_pc_exit(void)
 {
         if (pci_registered_parport)
-                pci_unregister_driver (&parport_pc_pci_driver);
+                pci_unregister_driver(&parport_pc_pci_driver);
         if (pnp_registered_parport)
-                pnp_unregister_driver (&parport_pc_pnp_driver);
+                pnp_unregister_driver(&parport_pc_pnp_driver);
         platform_driver_unregister(&parport_pc_platform_driver);
 
         while (!list_empty(&ports_list)) {
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 4e9851fc1746..277d35d232fa 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -692,7 +692,7 @@ config RTC_DRV_GENERIC
         tristate "Generic RTC support"
         # Please consider writing a new RTC driver instead of using the generic
         # RTC abstraction
-        depends on PARISC || M68K || PPC
+        depends on PARISC || M68K || PPC || SUPERH32
         help
           Say Y or M here to enable RTC support on systems using the generic
           RTC abstraction. If you do not know what you are doing, you should
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index d1815272c435..27a1be0cd4d4 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -603,7 +603,7 @@ static void dasd_profile_end(struct dasd_block *block,
         if (dasd_profile_level != DASD_PROFILE_ON)
                 return;
 
-        sectors = req->nr_sectors;
+        sectors = blk_rq_sectors(req);
         if (!cqr->buildclk || !cqr->startclk ||
             !cqr->stopclk || !cqr->endclk ||
             !sectors)
@@ -1614,15 +1614,6 @@ void dasd_block_clear_timer(struct dasd_block *block)
 }
 
 /*
- * posts the buffer_cache about a finalized request
- */
-static inline void dasd_end_request(struct request *req, int error)
-{
-        if (__blk_end_request(req, error, blk_rq_bytes(req)))
-                BUG();
-}
-
-/*
  * Process finished error recovery ccw.
  */
 static inline void __dasd_block_process_erp(struct dasd_block *block,
@@ -1665,18 +1656,14 @@ static void __dasd_process_request_queue(struct dasd_block *block)
         if (basedev->state < DASD_STATE_READY)
                 return;
         /* Now we try to fetch requests from the request queue */
-        while (!blk_queue_plugged(queue) &&
-               elv_next_request(queue)) {
-
-                req = elv_next_request(queue);
-
+        while (!blk_queue_plugged(queue) && (req = blk_peek_request(queue))) {
                 if (basedev->features & DASD_FEATURE_READONLY &&
                     rq_data_dir(req) == WRITE) {
                         DBF_DEV_EVENT(DBF_ERR, basedev,
                                       "Rejecting write request %p",
                                       req);
-                        blkdev_dequeue_request(req);
-                        dasd_end_request(req, -EIO);
+                        blk_start_request(req);
+                        __blk_end_request_all(req, -EIO);
                         continue;
                 }
                 cqr = basedev->discipline->build_cp(basedev, block, req);
@@ -1704,8 +1691,8 @@ static void __dasd_process_request_queue(struct dasd_block *block)
                                       "CCW creation failed (rc=%ld) "
                                       "on request %p",
                                       PTR_ERR(cqr), req);
-                        blkdev_dequeue_request(req);
-                        dasd_end_request(req, -EIO);
+                        blk_start_request(req);
+                        __blk_end_request_all(req, -EIO);
                         continue;
                 }
                 /*
@@ -1714,7 +1701,7 @@ static void __dasd_process_request_queue(struct dasd_block *block)
                  */
                 cqr->callback_data = (void *) req;
                 cqr->status = DASD_CQR_FILLED;
-                blkdev_dequeue_request(req);
+                blk_start_request(req);
                 list_add_tail(&cqr->blocklist, &block->ccw_queue);
                 dasd_profile_start(block, cqr, req);
         }
@@ -1731,7 +1718,7 @@ static void __dasd_cleanup_cqr(struct dasd_ccw_req *cqr)
         status = cqr->block->base->discipline->free_cp(cqr, req);
         if (status <= 0)
                 error = status ? status : -EIO;
-        dasd_end_request(req, error);
+        __blk_end_request_all(req, error);
 }
 
 /*
@@ -2003,7 +1990,7 @@ static void dasd_setup_queue(struct dasd_block *block)
 {
         int max;
 
-        blk_queue_hardsect_size(block->request_queue, block->bp_block);
+        blk_queue_logical_block_size(block->request_queue, block->bp_block);
         max = block->base->discipline->max_blocks << block->s2b_shift;
         blk_queue_max_sectors(block->request_queue, max);
         blk_queue_max_phys_segments(block->request_queue, -1L);
@@ -2038,10 +2025,8 @@ static void dasd_flush_request_queue(struct dasd_block *block)
                 return;
 
         spin_lock_irq(&block->request_queue_lock);
-        while ((req = elv_next_request(block->request_queue))) {
-                blkdev_dequeue_request(req);
-                dasd_end_request(req, -EIO);
-        }
+        while ((req = blk_fetch_request(block->request_queue)))
+                __blk_end_request_all(req, -EIO);
         spin_unlock_irq(&block->request_queue_lock);
 }
 
diff --git a/drivers/s390/block/dasd_diag.c b/drivers/s390/block/dasd_diag.c
index b9a7f7733446..2efaddfae560 100644
--- a/drivers/s390/block/dasd_diag.c
+++ b/drivers/s390/block/dasd_diag.c
@@ -505,8 +505,9 @@ static struct dasd_ccw_req *dasd_diag_build_cp(struct dasd_device *memdev,
                 return ERR_PTR(-EINVAL);
         blksize = block->bp_block;
         /* Calculate record id of first and last block. */
-        first_rec = req->sector >> block->s2b_shift;
-        last_rec = (req->sector + req->nr_sectors - 1) >> block->s2b_shift;
+        first_rec = blk_rq_pos(req) >> block->s2b_shift;
+        last_rec =
+                (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;
         /* Check struct bio and count the number of blocks for the request. */
         count = 0;
         rq_for_each_segment(bv, req, iter) {
diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
index cb52da033f06..a41c94053e64 100644
--- a/drivers/s390/block/dasd_eckd.c
+++ b/drivers/s390/block/dasd_eckd.c
@@ -2354,10 +2354,10 @@ static struct dasd_ccw_req *dasd_eckd_build_cp(struct dasd_device *startdev,
         blksize = block->bp_block;
         blk_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
         /* Calculate record id of first and last block. */
-        first_rec = first_trk = req->sector >> block->s2b_shift;
+        first_rec = first_trk = blk_rq_pos(req) >> block->s2b_shift;
         first_offs = sector_div(first_trk, blk_per_trk);
         last_rec = last_trk =
-                (req->sector + req->nr_sectors - 1) >> block->s2b_shift;
+                (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;
         last_offs = sector_div(last_trk, blk_per_trk);
         cdlspecial = (private->uses_cdl && first_rec < 2*blk_per_trk);
 
@@ -2420,7 +2420,7 @@ dasd_eckd_free_cp(struct dasd_ccw_req *cqr, struct request *req)
         private = (struct dasd_eckd_private *) cqr->block->base->private;
         blksize = cqr->block->bp_block;
         blk_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
-        recid = req->sector >> cqr->block->s2b_shift;
+        recid = blk_rq_pos(req) >> cqr->block->s2b_shift;
         ccw = cqr->cpaddr;
         /* Skip over define extent & locate record. */
         ccw++;
diff --git a/drivers/s390/block/dasd_fba.c b/drivers/s390/block/dasd_fba.c
index a3eb6fd14673..8912358daa2f 100644
--- a/drivers/s390/block/dasd_fba.c
+++ b/drivers/s390/block/dasd_fba.c
@@ -270,8 +270,9 @@ static struct dasd_ccw_req *dasd_fba_build_cp(struct dasd_device * memdev,
                 return ERR_PTR(-EINVAL);
         blksize = block->bp_block;
         /* Calculate record id of first and last block. */
-        first_rec = req->sector >> block->s2b_shift;
-        last_rec = (req->sector + req->nr_sectors - 1) >> block->s2b_shift;
+        first_rec = blk_rq_pos(req) >> block->s2b_shift;
+        last_rec =
+                (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;
         /* Check struct bio and count the number of blocks for the request. */
         count = 0;
         cidaw = 0;
@@ -309,7 +310,7 @@ static struct dasd_ccw_req *dasd_fba_build_cp(struct dasd_device * memdev,
         ccw = cqr->cpaddr;
         /* First ccw is define extent. */
         define_extent(ccw++, cqr->data, rq_data_dir(req),
-                      block->bp_block, req->sector, req->nr_sectors);
+                      block->bp_block, blk_rq_pos(req), blk_rq_sectors(req));
         /* Build locate_record + read/write ccws. */
         idaws = (unsigned long *) (cqr->data + sizeof(struct DE_fba_data));
         LO_data = (struct LO_fba_data *) (idaws + cidaw);
diff --git a/drivers/s390/block/dcssblk.c b/drivers/s390/block/dcssblk.c
index cfdcf1aed33c..a4c7ffcd9987 100644
--- a/drivers/s390/block/dcssblk.c
+++ b/drivers/s390/block/dcssblk.c
@@ -602,7 +602,7 @@ dcssblk_add_store(struct device *dev, struct device_attribute *attr, const char
         dev_info->gd->private_data = dev_info;
         dev_info->gd->driverfs_dev = &dev_info->dev;
         blk_queue_make_request(dev_info->dcssblk_queue, dcssblk_make_request);
-        blk_queue_hardsect_size(dev_info->dcssblk_queue, 4096);
+        blk_queue_logical_block_size(dev_info->dcssblk_queue, 4096);
 
         seg_byte_size = (dev_info->end - dev_info->start + 1);
         set_capacity(dev_info->gd, seg_byte_size >> 9); // size in sectors
diff --git a/drivers/s390/block/xpram.c b/drivers/s390/block/xpram.c
index 76814f3e898a..0ae0c83ef879 100644
--- a/drivers/s390/block/xpram.c
+++ b/drivers/s390/block/xpram.c
@@ -343,7 +343,7 @@ static int __init xpram_setup_blkdev(void)
                         goto out;
                 }
                 blk_queue_make_request(xpram_queues[i], xpram_make_request);
-                blk_queue_hardsect_size(xpram_queues[i], 4096);
+                blk_queue_logical_block_size(xpram_queues[i], 4096);
         }
 
         /*
diff --git a/drivers/s390/char/tape_34xx.c b/drivers/s390/char/tape_34xx.c
index 5f8e8ef43dd3..2d00a383a475 100644
--- a/drivers/s390/char/tape_34xx.c
+++ b/drivers/s390/char/tape_34xx.c
@@ -1134,7 +1134,7 @@ tape_34xx_bread(struct tape_device *device, struct request *req)
         /* Setup ccws. */
         request->op = TO_BLOCK;
         start_block = (struct tape_34xx_block_id *) request->cpdata;
-        start_block->block = req->sector >> TAPEBLOCK_HSEC_S2B;
+        start_block->block = blk_rq_pos(req) >> TAPEBLOCK_HSEC_S2B;
         DBF_EVENT(6, "start_block = %i\n", start_block->block);
 
         ccw = request->cpaddr;
diff --git a/drivers/s390/char/tape_3590.c b/drivers/s390/char/tape_3590.c
index 823b05bd0dd7..c453b2f3e9f4 100644
--- a/drivers/s390/char/tape_3590.c
+++ b/drivers/s390/char/tape_3590.c
@@ -633,7 +633,7 @@ tape_3590_bread(struct tape_device *device, struct request *req)
         struct req_iterator iter;
 
         DBF_EVENT(6, "xBREDid:");
-        start_block = req->sector >> TAPEBLOCK_HSEC_S2B;
+        start_block = blk_rq_pos(req) >> TAPEBLOCK_HSEC_S2B;
         DBF_EVENT(6, "start_block = %i\n", start_block);
 
         rq_for_each_segment(bv, req, iter)
diff --git a/drivers/s390/char/tape_block.c b/drivers/s390/char/tape_block.c
index f32e89e7c4f2..47ff695255ea 100644
--- a/drivers/s390/char/tape_block.c
+++ b/drivers/s390/char/tape_block.c
@@ -74,13 +74,6 @@ tapeblock_trigger_requeue(struct tape_device *device)
  * Post finished request.
  */
 static void
-tapeblock_end_request(struct request *req, int error)
-{
-        if (blk_end_request(req, error, blk_rq_bytes(req)))
-                BUG();
-}
-
-static void
 __tapeblock_end_request(struct tape_request *ccw_req, void *data)
 {
         struct tape_device *device;
@@ -90,17 +83,17 @@ __tapeblock_end_request(struct tape_request *ccw_req, void *data)
 
         device = ccw_req->device;
         req = (struct request *) data;
-        tapeblock_end_request(req, (ccw_req->rc == 0) ? 0 : -EIO);
+        blk_end_request_all(req, (ccw_req->rc == 0) ? 0 : -EIO);
         if (ccw_req->rc == 0)
                 /* Update position. */
                 device->blk_data.block_position =
-                        (req->sector + req->nr_sectors) >> TAPEBLOCK_HSEC_S2B;
+                  (blk_rq_pos(req) + blk_rq_sectors(req)) >> TAPEBLOCK_HSEC_S2B;
         else
                 /* We lost the position information due to an error. */
                 device->blk_data.block_position = -1;
         device->discipline->free_bread(ccw_req);
         if (!list_empty(&device->req_queue) ||
-            elv_next_request(device->blk_data.request_queue))
+            blk_peek_request(device->blk_data.request_queue))
                 tapeblock_trigger_requeue(device);
 }
 
@@ -118,7 +111,7 @@ tapeblock_start_request(struct tape_device *device, struct request *req)
         ccw_req = device->discipline->bread(device, req);
         if (IS_ERR(ccw_req)) {
                 DBF_EVENT(1, "TBLOCK: bread failed\n");
-                tapeblock_end_request(req, -EIO);
+                blk_end_request_all(req, -EIO);
                 return PTR_ERR(ccw_req);
         }
         ccw_req->callback = __tapeblock_end_request;
@@ -131,7 +124,7 @@ tapeblock_start_request(struct tape_device *device, struct request *req)
                  * Start/enqueueing failed. No retries in
                  * this case.
                  */
-                tapeblock_end_request(req, -EIO);
+                blk_end_request_all(req, -EIO);
                 device->discipline->free_bread(ccw_req);
         }
 
@@ -169,19 +162,16 @@ tapeblock_requeue(struct work_struct *work) {
         spin_lock_irq(&device->blk_data.request_queue_lock);
         while (
                 !blk_queue_plugged(queue) &&
-                elv_next_request(queue)   &&
+                (req = blk_fetch_request(queue)) &&
                 nr_queued < TAPEBLOCK_MIN_REQUEUE
         ) {
-                req = elv_next_request(queue);
                 if (rq_data_dir(req) == WRITE) {
                         DBF_EVENT(1, "TBLOCK: Rejecting write request\n");
-                        blkdev_dequeue_request(req);
                         spin_unlock_irq(&device->blk_data.request_queue_lock);
-                        tapeblock_end_request(req, -EIO);
+                        blk_end_request_all(req, -EIO);
                         spin_lock_irq(&device->blk_data.request_queue_lock);
                         continue;
                 }
-                blkdev_dequeue_request(req);
                 nr_queued++;
                 spin_unlock_irq(&device->blk_data.request_queue_lock);
                 rc = tapeblock_start_request(device, req);
@@ -232,7 +222,7 @@ tapeblock_setup_device(struct tape_device * device)
         if (rc)
                 goto cleanup_queue;
 
-        blk_queue_hardsect_size(blkdat->request_queue, TAPEBLOCK_HSEC_SIZE);
+        blk_queue_logical_block_size(blkdat->request_queue, TAPEBLOCK_HSEC_SIZE);
         blk_queue_max_sectors(blkdat->request_queue, TAPEBLOCK_MAX_SEC);
         blk_queue_max_phys_segments(blkdat->request_queue, -1L);
         blk_queue_max_hw_segments(blkdat->request_queue, -1L);
diff --git a/drivers/sbus/char/jsflash.c b/drivers/sbus/char/jsflash.c
index a85ad05e8548..6d4651684688 100644
--- a/drivers/sbus/char/jsflash.c
+++ b/drivers/sbus/char/jsflash.c
@@ -186,31 +186,31 @@ static void jsfd_do_request(struct request_queue *q)
 {
         struct request *req;
 
-        while ((req = elv_next_request(q)) != NULL) {
+        req = blk_fetch_request(q);
+        while (req) {
                 struct jsfd_part *jdp = req->rq_disk->private_data;
-                unsigned long offset = req->sector << 9;
-                size_t len = req->current_nr_sectors << 9;
+                unsigned long offset = blk_rq_pos(req) << 9;
+                size_t len = blk_rq_cur_bytes(req);
+                int err = -EIO;
 
-                if ((offset + len) > jdp->dsize) {
-                        end_request(req, 0);
-                        continue;
-                }
+                if ((offset + len) > jdp->dsize)
+                        goto end;
 
                 if (rq_data_dir(req) != READ) {
                         printk(KERN_ERR "jsfd: write\n");
-                        end_request(req, 0);
-                        continue;
+                        goto end;
                 }
 
                 if ((jdp->dbase & 0xff000000) != 0x20000000) {
                         printk(KERN_ERR "jsfd: bad base %x\n", (int)jdp->dbase);
-                        end_request(req, 0);
-                        continue;
+                        goto end;
                 }
 
                 jsfd_read(req->buffer, jdp->dbase + offset, len);
-
-                end_request(req, 1);
+                err = 0;
+        end:
+                if (!__blk_end_request_cur(req, err))
+                        req = blk_fetch_request(q);
         }
 }
 
diff --git a/drivers/scsi/eata.c b/drivers/scsi/eata.c
index be5099dd94b5..c7076ce25e21 100644
--- a/drivers/scsi/eata.c
+++ b/drivers/scsi/eata.c
@@ -1825,7 +1825,7 @@ static int eata2x_queuecommand(struct scsi_cmnd *SCpnt,
         if (linked_comm && SCpnt->device->queue_depth > 2
             && TLDEV(SCpnt->device->type)) {
                 ha->cp_stat[i] = READY;
-                flush_dev(SCpnt->device, SCpnt->request->sector, ha, 0);
+                flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), ha, 0);
                 return 0;
         }
 
@@ -2144,13 +2144,13 @@ static int reorder(struct hostdata *ha, unsigned long cursec,
                 if (!cpp->din)
                         input_only = 0;
 
-                if (SCpnt->request->sector < minsec)
-                        minsec = SCpnt->request->sector;
-                if (SCpnt->request->sector > maxsec)
-                        maxsec = SCpnt->request->sector;
+                if (blk_rq_pos(SCpnt->request) < minsec)
+                        minsec = blk_rq_pos(SCpnt->request);
+                if (blk_rq_pos(SCpnt->request) > maxsec)
+                        maxsec = blk_rq_pos(SCpnt->request);
 
-                sl[n] = SCpnt->request->sector;
-                ioseek += SCpnt->request->nr_sectors;
+                sl[n] = blk_rq_pos(SCpnt->request);
+                ioseek += blk_rq_sectors(SCpnt->request);
 
                 if (!n)
                         continue;
@@ -2190,7 +2190,7 @@ static int reorder(struct hostdata *ha, unsigned long cursec,
                         k = il[n];
                         cpp = &ha->cp[k];
                         SCpnt = cpp->SCpnt;
-                        ll[n] = SCpnt->request->nr_sectors;
+                        ll[n] = blk_rq_sectors(SCpnt->request);
                         pl[n] = SCpnt->serial_number;
 
                         if (!n)
@@ -2236,12 +2236,12 @@ static int reorder(struct hostdata *ha, unsigned long cursec,
                         cpp = &ha->cp[k];
                         SCpnt = cpp->SCpnt;
                         scmd_printk(KERN_INFO, SCpnt,
-                            "%s pid %ld mb %d fc %d nr %d sec %ld ns %ld"
+                            "%s pid %ld mb %d fc %d nr %d sec %ld ns %u"
                              " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
                              (ihdlr ? "ihdlr" : "qcomm"),
                              SCpnt->serial_number, k, flushcount,
-                             n_ready, SCpnt->request->sector,
-                             SCpnt->request->nr_sectors, cursec, YESNO(s),
+                             n_ready, blk_rq_pos(SCpnt->request),
+                             blk_rq_sectors(SCpnt->request), cursec, YESNO(s),
                              YESNO(r), YESNO(rev), YESNO(input_only),
                              YESNO(overlap), cpp->din);
                 }
@@ -2408,7 +2408,7 @@ static irqreturn_t ihdlr(struct Scsi_Host *shost)
 
         if (linked_comm && SCpnt->device->queue_depth > 2
             && TLDEV(SCpnt->device->type))
-                flush_dev(SCpnt->device, SCpnt->request->sector, ha, 1);
+                flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), ha, 1);
 
         tstatus = status_byte(spp->target_status);
 
diff --git a/drivers/scsi/libsas/sas_expander.c b/drivers/scsi/libsas/sas_expander.c
index 3da02e436788..54fa1e42dc4d 100644
--- a/drivers/scsi/libsas/sas_expander.c
+++ b/drivers/scsi/libsas/sas_expander.c
@@ -1927,21 +1927,21 @@ int sas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
         /* do we need to support multiple segments? */
         if (req->bio->bi_vcnt > 1 || rsp->bio->bi_vcnt > 1) {
                 printk("%s: multiple segments req %u %u, rsp %u %u\n",
-                       __func__, req->bio->bi_vcnt, req->data_len,
-                       rsp->bio->bi_vcnt, rsp->data_len);
+                       __func__, req->bio->bi_vcnt, blk_rq_bytes(req),
+                       rsp->bio->bi_vcnt, blk_rq_bytes(rsp));
                 return -EINVAL;
         }
 
-        ret = smp_execute_task(dev, bio_data(req->bio), req->data_len,
-                               bio_data(rsp->bio), rsp->data_len);
+        ret = smp_execute_task(dev, bio_data(req->bio), blk_rq_bytes(req),
+                               bio_data(rsp->bio), blk_rq_bytes(rsp));
         if (ret > 0) {
                 /* positive number is the untransferred residual */
-                rsp->data_len = ret;
-                req->data_len = 0;
+                rsp->resid_len = ret;
+                req->resid_len = 0;
                 ret = 0;
         } else if (ret == 0) {
-                rsp->data_len = 0;
-                req->data_len = 0;
+                rsp->resid_len = 0;
+                req->resid_len = 0;
         }
 
         return ret;
diff --git a/drivers/scsi/libsas/sas_host_smp.c b/drivers/scsi/libsas/sas_host_smp.c
index d110a366c48a..1bc3b7567994 100644
--- a/drivers/scsi/libsas/sas_host_smp.c
+++ b/drivers/scsi/libsas/sas_host_smp.c
@@ -134,24 +134,24 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
 {
         u8 *req_data = NULL, *resp_data = NULL, *buf;
         struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost);
-        int error = -EINVAL, resp_data_len = rsp->data_len;
+        int error = -EINVAL;
 
         /* eight is the minimum size for request and response frames */
-        if (req->data_len < 8 || rsp->data_len < 8)
+        if (blk_rq_bytes(req) < 8 || blk_rq_bytes(rsp) < 8)
                 goto out;
 
-        if (bio_offset(req->bio) + req->data_len > PAGE_SIZE ||
-            bio_offset(rsp->bio) + rsp->data_len > PAGE_SIZE) {
+        if (bio_offset(req->bio) + blk_rq_bytes(req) > PAGE_SIZE ||
+            bio_offset(rsp->bio) + blk_rq_bytes(rsp) > PAGE_SIZE) {
                 shost_printk(KERN_ERR, shost,
                         "SMP request/response frame crosses page boundary");
                 goto out;
         }
 
-        req_data = kzalloc(req->data_len, GFP_KERNEL);
+        req_data = kzalloc(blk_rq_bytes(req), GFP_KERNEL);
 
         /* make sure frame can always be built ... we copy
          * back only the requested length */
-        resp_data = kzalloc(max(rsp->data_len, 128U), GFP_KERNEL);
+        resp_data = kzalloc(max(blk_rq_bytes(rsp), 128U), GFP_KERNEL);
 
         if (!req_data || !resp_data) {
                 error = -ENOMEM;
@@ -160,7 +160,7 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
 
         local_irq_disable();
         buf = kmap_atomic(bio_page(req->bio), KM_USER0) + bio_offset(req->bio);
-        memcpy(req_data, buf, req->data_len);
+        memcpy(req_data, buf, blk_rq_bytes(req));
         kunmap_atomic(buf - bio_offset(req->bio), KM_USER0);
         local_irq_enable();
 
@@ -178,15 +178,15 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
 
         switch (req_data[1]) {
         case SMP_REPORT_GENERAL:
-                req->data_len -= 8;
-                resp_data_len -= 32;
+                req->resid_len -= 8;
+                rsp->resid_len -= 32;
                 resp_data[2] = SMP_RESP_FUNC_ACC;
                 resp_data[9] = sas_ha->num_phys;
                 break;
 
         case SMP_REPORT_MANUF_INFO:
-                req->data_len -= 8;
-                resp_data_len -= 64;
+                req->resid_len -= 8;
+                rsp->resid_len -= 64;
                 resp_data[2] = SMP_RESP_FUNC_ACC;
                 memcpy(resp_data + 12, shost->hostt->name,
                        SAS_EXPANDER_VENDOR_ID_LEN);
@@ -199,13 +199,13 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
                 break;
 
         case SMP_DISCOVER:
-                req->data_len -= 16;
-                if ((int)req->data_len < 0) {
-                        req->data_len = 0;
+                req->resid_len -= 16;
+                if ((int)req->resid_len < 0) {
+                        req->resid_len = 0;
                         error = -EINVAL;
                         goto out;
                 }
-                resp_data_len -= 56;
+                rsp->resid_len -= 56;
                 sas_host_smp_discover(sas_ha, resp_data, req_data[9]);
                 break;
 
@@ -215,13 +215,13 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
                 break;
 
         case SMP_REPORT_PHY_SATA:
-                req->data_len -= 16;
-                if ((int)req->data_len < 0) {
-                        req->data_len = 0;
+                req->resid_len -= 16;
+                if ((int)req->resid_len < 0) {
+                        req->resid_len = 0;
                         error = -EINVAL;
                         goto out;
                 }
-                resp_data_len -= 60;
+                rsp->resid_len -= 60;
                 sas_report_phy_sata(sas_ha, resp_data, req_data[9]);
                 break;
 
@@ -238,13 +238,13 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
                 break;
 
         case SMP_PHY_CONTROL:
-                req->data_len -= 44;
-                if ((int)req->data_len < 0) {
-                        req->data_len = 0;
+                req->resid_len -= 44;
+                if ((int)req->resid_len < 0) {
+                        req->resid_len = 0;
                         error = -EINVAL;
                         goto out;
                 }
-                resp_data_len -= 8;
+                rsp->resid_len -= 8;
                 sas_phy_control(sas_ha, req_data[9], req_data[10],
                                 req_data[32] >> 4, req_data[33] >> 4,
                                 resp_data);
@@ -261,11 +261,10 @@ int sas_smp_host_handler(struct Scsi_Host *shost, struct request *req,
 
         local_irq_disable();
         buf = kmap_atomic(bio_page(rsp->bio), KM_USER0) + bio_offset(rsp->bio);
-        memcpy(buf, resp_data, rsp->data_len);
+        memcpy(buf, resp_data, blk_rq_bytes(rsp));
         flush_kernel_dcache_page(bio_page(rsp->bio));
         kunmap_atomic(buf - bio_offset(rsp->bio), KM_USER0);
         local_irq_enable();
-        rsp->data_len = resp_data_len;
 
  out:
         kfree(req_data);
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index 167b66dd34c7..8032c5adb6a9 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -1312,10 +1312,10 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
         uint32_t bgstat = bgf->bgstat;
         uint64_t failing_sector = 0;
 
-        printk(KERN_ERR "BG ERROR in cmd 0x%x lba 0x%llx blk cnt 0x%lx "
+        printk(KERN_ERR "BG ERROR in cmd 0x%x lba 0x%llx blk cnt 0x%x "
                         "bgstat=0x%x bghm=0x%x\n",
                         cmd->cmnd[0], (unsigned long long)scsi_get_lba(cmd),
-                        cmd->request->nr_sectors, bgstat, bghm);
+                        blk_rq_sectors(cmd->request), bgstat, bghm);
 
         spin_lock(&_dump_buf_lock);
         if (!_dump_buf_done) {
@@ -2378,15 +2378,15 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
                 if (cmnd->cmnd[0] == READ_10)
                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
                                         "9035 BLKGRD: READ @ sector %llu, "
-                                         "count %lu\n",
-                                         (unsigned long long)scsi_get_lba(cmnd),
-                                        cmnd->request->nr_sectors);
+                                        "count %u\n",
+                                        (unsigned long long)scsi_get_lba(cmnd),
+                                        blk_rq_sectors(cmnd->request));
                 else if (cmnd->cmnd[0] == WRITE_10)
                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
                                         "9036 BLKGRD: WRITE @ sector %llu, "
-                                        "count %lu cmd=%p\n",
+                                        "count %u cmd=%p\n",
                                         (unsigned long long)scsi_get_lba(cmnd),
-                                        cmnd->request->nr_sectors,
+                                        blk_rq_sectors(cmnd->request),
                                         cmnd);
 
                 err = lpfc_bg_scsi_prep_dma_buf(phba, lpfc_cmd);
@@ -2406,15 +2406,15 @@ lpfc_queuecommand(struct scsi_cmnd *cmnd, void (*done) (struct scsi_cmnd *))
                 if (cmnd->cmnd[0] == READ_10)
                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
                                          "9040 dbg: READ @ sector %llu, "
-                                         "count %lu\n",
+                                         "count %u\n",
                                          (unsigned long long)scsi_get_lba(cmnd),
-                                         cmnd->request->nr_sectors);
+                                         blk_rq_sectors(cmnd->request));
                 else if (cmnd->cmnd[0] == WRITE_10)
                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
                                          "9041 dbg: WRITE @ sector %llu, "
-                                         "count %lu cmd=%p\n",
+                                         "count %u cmd=%p\n",
                                          (unsigned long long)scsi_get_lba(cmnd),
-                                         cmnd->request->nr_sectors, cmnd);
+                                         blk_rq_sectors(cmnd->request), cmnd);
                 else
                         lpfc_printf_vlog(vport, KERN_WARNING, LOG_BG,
                                          "9042 dbg: parser not implemented\n");
diff --git a/drivers/scsi/mpt2sas/mpt2sas_transport.c b/drivers/scsi/mpt2sas/mpt2sas_transport.c
index e03dc0b1e1a0..5c65da519e39 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_transport.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_transport.c
@@ -1041,7 +1041,7 @@ transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
         if (req->bio->bi_vcnt > 1 || rsp->bio->bi_vcnt > 1) {
                 printk(MPT2SAS_ERR_FMT "%s: multiple segments req %u %u, "
                     "rsp %u %u\n", ioc->name, __func__, req->bio->bi_vcnt,
-                    req->data_len, rsp->bio->bi_vcnt, rsp->data_len);
+                    blk_rq_bytes(req), rsp->bio->bi_vcnt, blk_rq_bytes(rsp));
                 return -EINVAL;
         }
 
@@ -1104,7 +1104,7 @@ transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
         *((u64 *)&mpi_request->SASAddress) = (rphy) ?
             cpu_to_le64(rphy->identify.sas_address) :
             cpu_to_le64(ioc->sas_hba.sas_address);
-        mpi_request->RequestDataLength = cpu_to_le16(req->data_len - 4);
+        mpi_request->RequestDataLength = cpu_to_le16(blk_rq_bytes(req) - 4);
         psge = &mpi_request->SGL;
 
         /* WRITE sgel first */
@@ -1112,13 +1112,13 @@ transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
             MPI2_SGE_FLAGS_END_OF_BUFFER | MPI2_SGE_FLAGS_HOST_TO_IOC);
         sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
         dma_addr_out = pci_map_single(ioc->pdev, bio_data(req->bio),
-              req->data_len, PCI_DMA_BIDIRECTIONAL);
+                blk_rq_bytes(req), PCI_DMA_BIDIRECTIONAL);
         if (!dma_addr_out) {
                 mpt2sas_base_free_smid(ioc, le16_to_cpu(smid));
                 goto unmap;
         }
 
-        ioc->base_add_sg_single(psge, sgl_flags | (req->data_len - 4),
+        ioc->base_add_sg_single(psge, sgl_flags | (blk_rq_bytes(req) - 4),
             dma_addr_out);
 
         /* incr sgel */
@@ -1129,14 +1129,14 @@ transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
             MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER |
             MPI2_SGE_FLAGS_END_OF_LIST);
         sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
-        dma_addr_in =  pci_map_single(ioc->pdev, bio_data(rsp->bio),
-              rsp->data_len, PCI_DMA_BIDIRECTIONAL);
+        dma_addr_in = pci_map_single(ioc->pdev, bio_data(rsp->bio),
+                                     blk_rq_bytes(rsp), PCI_DMA_BIDIRECTIONAL);
         if (!dma_addr_in) {
                 mpt2sas_base_free_smid(ioc, le16_to_cpu(smid));
                 goto unmap;
         }
 
-        ioc->base_add_sg_single(psge, sgl_flags | (rsp->data_len + 4),
+        ioc->base_add_sg_single(psge, sgl_flags | (blk_rq_bytes(rsp) + 4),
             dma_addr_in);
 
         dtransportprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s - "
@@ -1170,9 +1170,8 @@ transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
 
                 memcpy(req->sense, mpi_reply, sizeof(*mpi_reply));
                 req->sense_len = sizeof(*mpi_reply);
-                req->data_len = 0;
-                rsp->data_len -= mpi_reply->ResponseDataLength;
-
+                req->resid_len = 0;
+                rsp->resid_len -= mpi_reply->ResponseDataLength;
         } else {
                 dtransportprintk(ioc, printk(MPT2SAS_DEBUG_FMT
                     "%s - no reply\n", ioc->name, __func__));
@@ -1188,10 +1187,10 @@ transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
 
  unmap:
         if (dma_addr_out)
-                pci_unmap_single(ioc->pdev, dma_addr_out, req->data_len,
+                pci_unmap_single(ioc->pdev, dma_addr_out, blk_rq_bytes(req),
                     PCI_DMA_BIDIRECTIONAL);
         if (dma_addr_in)
-                pci_unmap_single(ioc->pdev, dma_addr_in, rsp->data_len,
+                pci_unmap_single(ioc->pdev, dma_addr_in, blk_rq_bytes(rsp),
                     PCI_DMA_BIDIRECTIONAL);
 
  out:
diff --git a/drivers/scsi/osd/osd_initiator.c b/drivers/scsi/osd/osd_initiator.c
index 1ce6b24abab2..5776b2ab6b12 100644
--- a/drivers/scsi/osd/osd_initiator.c
+++ b/drivers/scsi/osd/osd_initiator.c
@@ -889,26 +889,6 @@ int osd_req_add_set_attr_list(struct osd_request *or,
 }
 EXPORT_SYMBOL(osd_req_add_set_attr_list);
 
-static int _append_map_kern(struct request *req,
-        void *buff, unsigned len, gfp_t flags)
-{
-        struct bio *bio;
-        int ret;
-
-        bio = bio_map_kern(req->q, buff, len, flags);
-        if (IS_ERR(bio)) {
-                OSD_ERR("Failed bio_map_kern(%p, %d) => %ld\n", buff, len,
-                        PTR_ERR(bio));
-                return PTR_ERR(bio);
-        }
-        ret = blk_rq_append_bio(req->q, req, bio);
-        if (ret) {
-                OSD_ERR("Failed blk_rq_append_bio(%p) => %d\n", bio, ret);
-                bio_put(bio);
-        }
-        return ret;
-}
-
 static int _req_append_segment(struct osd_request *or,
         unsigned padding, struct _osd_req_data_segment *seg,
         struct _osd_req_data_segment *last_seg, struct _osd_io_info *io)
@@ -924,14 +904,14 @@ static int _req_append_segment(struct osd_request *or,
                 else
                         pad_buff = io->pad_buff;
 
-                ret = _append_map_kern(io->req, pad_buff, padding,
+                ret = blk_rq_map_kern(io->req->q, io->req, pad_buff, padding,
                                        or->alloc_flags);
                 if (ret)
                         return ret;
                 io->total_bytes += padding;
         }
 
-        ret = _append_map_kern(io->req, seg->buff, seg->total_bytes,
+        ret = blk_rq_map_kern(io->req->q, io->req, seg->buff, seg->total_bytes,
                                or->alloc_flags);
         if (ret)
                 return ret;
@@ -1293,6 +1273,21 @@ static int _osd_req_finalize_data_integrity(struct osd_request *or,
 /*
  * osd_finalize_request and helpers
  */
+static struct request *_make_request(struct request_queue *q, bool has_write,
+                              struct _osd_io_info *oii, gfp_t flags)
+{
+        if (oii->bio)
+                return blk_make_request(q, oii->bio, flags);
+        else {
+                struct request *req;
+
+                req = blk_get_request(q, has_write ? WRITE : READ, flags);
+                if (unlikely(!req))
+                        return ERR_PTR(-ENOMEM);
+
+                return req;
+        }
+}
 
 static int _init_blk_request(struct osd_request *or,
         bool has_in, bool has_out)
@@ -1301,11 +1296,13 @@ static int _init_blk_request(struct osd_request *or,
         struct scsi_device *scsi_device = or->osd_dev->scsi_device;
         struct request_queue *q = scsi_device->request_queue;
         struct request *req;
-        int ret = -ENOMEM;
+        int ret;
 
-        req = blk_get_request(q, has_out, flags);
-        if (!req)
+        req = _make_request(q, has_out, has_out ? &or->out : &or->in, flags);
+        if (IS_ERR(req)) {
+                ret = PTR_ERR(req);
                 goto out;
+        }
 
         or->request = req;
         req->cmd_type = REQ_TYPE_BLOCK_PC;
@@ -1318,9 +1315,10 @@ static int _init_blk_request(struct osd_request *or,
                 or->out.req = req;
                 if (has_in) {
                         /* allocate bidi request */
-                        req = blk_get_request(q, READ, flags);
-                        if (!req) {
+                        req = _make_request(q, false, &or->in, flags);
+                        if (IS_ERR(req)) {
                                 OSD_DEBUG("blk_get_request for bidi failed\n");
+                                ret = PTR_ERR(req);
                                 goto out;
                         }
                         req->cmd_type = REQ_TYPE_BLOCK_PC;
@@ -1364,26 +1362,6 @@ int osd_finalize_request(struct osd_request *or,
                 return ret;
         }
 
-        if (or->out.bio) {
-                ret = blk_rq_append_bio(or->request->q, or->out.req,
-                                        or->out.bio);
-                if (ret) {
-                        OSD_DEBUG("blk_rq_append_bio out failed\n");
-                        return ret;
-                }
-                OSD_DEBUG("out bytes=%llu (bytes_req=%u)\n",
-                        _LLU(or->out.total_bytes), or->out.req->data_len);
-        }
-        if (or->in.bio) {
-                ret = blk_rq_append_bio(or->request->q, or->in.req, or->in.bio);
-                if (ret) {
-                        OSD_DEBUG("blk_rq_append_bio in failed\n");
-                        return ret;
-                }
-                OSD_DEBUG("in bytes=%llu (bytes_req=%u)\n",
-                        _LLU(or->in.total_bytes), or->in.req->data_len);
-        }
-
         or->out.pad_buff = sg_out_pad_buffer;
         or->in.pad_buff = sg_in_pad_buffer;
 
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index bb218c8b6e98..dd3f9d2b99fd 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -240,11 +240,11 @@ int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
          * is invalid.  Prevent the garbage from being misinterpreted
          * and prevent security leaks by zeroing out the excess data.
          */
-        if (unlikely(req->data_len > 0 && req->data_len <= bufflen))
-                memset(buffer + (bufflen - req->data_len), 0, req->data_len);
+        if (unlikely(req->resid_len > 0 && req->resid_len <= bufflen))
+                memset(buffer + (bufflen - req->resid_len), 0, req->resid_len);
 
         if (resid)
-                *resid = req->data_len;
+                *resid = req->resid_len;
         ret = req->errors;
  out:
         blk_put_request(req);
@@ -546,14 +546,9 @@ static struct scsi_cmnd *scsi_end_request(struct scsi_cmnd *cmd, int error,
          * to queue the remainder of them.
          */
         if (blk_end_request(req, error, bytes)) {
-                int leftover = (req->hard_nr_sectors << 9);
-
-                if (blk_pc_request(req))
-                        leftover = req->data_len;
-
                 /* kill remainder if no retrys */
                 if (error && scsi_noretry_cmd(cmd))
-                        blk_end_request(req, error, leftover);
+                        blk_end_request_all(req, error);
                 else {
                         if (requeue) {
                                 /*
@@ -673,34 +668,6 @@ void scsi_release_buffers(struct scsi_cmnd *cmd)
 EXPORT_SYMBOL(scsi_release_buffers);
 
 /*
- * Bidi commands Must be complete as a whole, both sides at once.
- * If part of the bytes were written and lld returned
- * scsi_in()->resid and/or scsi_out()->resid this information will be left
- * in req->data_len and req->next_rq->data_len. The upper-layer driver can
- * decide what to do with this information.
- */
-static void scsi_end_bidi_request(struct scsi_cmnd *cmd)
-{
-        struct request *req = cmd->request;
-        unsigned int dlen = req->data_len;
-        unsigned int next_dlen = req->next_rq->data_len;
-
-        req->data_len = scsi_out(cmd)->resid;
-        req->next_rq->data_len = scsi_in(cmd)->resid;
-
-        /* The req and req->next_rq have not been completed */
-        BUG_ON(blk_end_bidi_request(req, 0, dlen, next_dlen));
-
-        scsi_release_buffers(cmd);
-
-        /*
-         * This will goose the queue request function at the end, so we don't
-         * need to worry about launching another command.
-         */
-        scsi_next_command(cmd);
-}
-
-/*
  * Function:    scsi_io_completion()
  *
  * Purpose:     Completion processing for block device I/O requests.
@@ -739,7 +706,6 @@ static void scsi_end_bidi_request(struct scsi_cmnd *cmd)
 void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
 {
         int result = cmd->result;
-        int this_count;
         struct request_queue *q = cmd->device->request_queue;
         struct request *req = cmd->request;
         int error = 0;
@@ -773,12 +739,22 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
                         if (!sense_deferred)
                                 error = -EIO;
                 }
+
+                req->resid_len = scsi_get_resid(cmd);
+
                 if (scsi_bidi_cmnd(cmd)) {
-                        /* will also release_buffers */
-                        scsi_end_bidi_request(cmd);
+                        /*
+                         * Bidi commands Must be complete as a whole,
+                         * both sides at once.
+                         */
+                        req->next_rq->resid_len = scsi_in(cmd)->resid;
+
+                        blk_end_request_all(req, 0);
+
+                        scsi_release_buffers(cmd);
+                        scsi_next_command(cmd);
                         return;
                 }
-                req->data_len = scsi_get_resid(cmd);
         }
 
         BUG_ON(blk_bidi_rq(req)); /* bidi not support for !blk_pc_request yet */
@@ -787,9 +763,9 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
          * Next deal with any sectors which we were able to correctly
          * handle.
          */
-        SCSI_LOG_HLCOMPLETE(1, printk("%ld sectors total, "
+        SCSI_LOG_HLCOMPLETE(1, printk("%u sectors total, "
                                       "%d bytes done.\n",
-                                      req->nr_sectors, good_bytes));
+                                      blk_rq_sectors(req), good_bytes));
 
         /*
          * Recovered errors need reporting, but they're always treated
@@ -812,7 +788,6 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
          */
         if (scsi_end_request(cmd, error, good_bytes, result == 0) == NULL)
                 return;
-        this_count = blk_rq_bytes(req);
 
         error = -EIO;
 
@@ -922,7 +897,7 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
                         if (driver_byte(result) & DRIVER_SENSE)
                                 scsi_print_sense("", cmd);
                 }
-                blk_end_request(req, -EIO, blk_rq_bytes(req));
+                blk_end_request_all(req, -EIO);
                 scsi_next_command(cmd);
                 break;
         case ACTION_REPREP:
@@ -965,10 +940,7 @@ static int scsi_init_sgtable(struct request *req, struct scsi_data_buffer *sdb,
         count = blk_rq_map_sg(req->q, req, sdb->table.sgl);
         BUG_ON(count > sdb->table.nents);
         sdb->table.nents = count;
-        if (blk_pc_request(req))
-                sdb->length = req->data_len;
-        else
-                sdb->length = req->nr_sectors << 9;
+        sdb->length = blk_rq_bytes(req);
         return BLKPREP_OK;
 }
 
@@ -1087,22 +1059,21 @@ int scsi_setup_blk_pc_cmnd(struct scsi_device *sdev, struct request *req)
                 if (unlikely(ret))
                         return ret;
         } else {
-                BUG_ON(req->data_len);
-                BUG_ON(req->data);
+                BUG_ON(blk_rq_bytes(req));
 
                 memset(&cmd->sdb, 0, sizeof(cmd->sdb));
                 req->buffer = NULL;
         }
 
         cmd->cmd_len = req->cmd_len;
-        if (!req->data_len)
+        if (!blk_rq_bytes(req))
                 cmd->sc_data_direction = DMA_NONE;
         else if (rq_data_dir(req) == WRITE)
                 cmd->sc_data_direction = DMA_TO_DEVICE;
         else
                 cmd->sc_data_direction = DMA_FROM_DEVICE;
         
-        cmd->transfersize = req->data_len;
+        cmd->transfersize = blk_rq_bytes(req);
         cmd->allowed = req->retries;
         return BLKPREP_OK;
 }
@@ -1212,7 +1183,7 @@ int scsi_prep_return(struct request_queue *q, struct request *req, int ret)
                 break;
         case BLKPREP_DEFER:
                 /*
-                 * If we defer, the elv_next_request() returns NULL, but the
+                 * If we defer, the blk_peek_request() returns NULL, but the
                  * queue must be restarted, so we plug here if no returning
                  * command will automatically do that.
                  */
@@ -1388,7 +1359,7 @@ static void scsi_kill_request(struct request *req, struct request_queue *q)
         struct scsi_target *starget = scsi_target(sdev);
         struct Scsi_Host *shost = sdev->host;
 
-        blkdev_dequeue_request(req);
+        blk_start_request(req);
 
         if (unlikely(cmd == NULL)) {
                 printk(KERN_CRIT "impossible request in %s.\n",
@@ -1480,7 +1451,7 @@ static void scsi_request_fn(struct request_queue *q)
 
         if (!sdev) {
                 printk("scsi: killing requests for dead queue\n");
-                while ((req = elv_next_request(q)) != NULL)
+                while ((req = blk_peek_request(q)) != NULL)
                         scsi_kill_request(req, q);
                 return;
         }
@@ -1501,7 +1472,7 @@ static void scsi_request_fn(struct request_queue *q)
                  * that the request is fully prepared even if we cannot 
                  * accept it.
                  */
-                req = elv_next_request(q);
+                req = blk_peek_request(q);
                 if (!req || !scsi_dev_queue_ready(q, sdev))
                         break;
 
@@ -1517,7 +1488,7 @@ static void scsi_request_fn(struct request_queue *q)
                  * Remove the request from the request list.
                  */
                 if (!(blk_queue_tagged(q) && !blk_queue_start_tag(q, req)))
-                        blkdev_dequeue_request(req);
+                        blk_start_request(req);
                 sdev->device_busy++;
 
                 spin_unlock(q->queue_lock);
diff --git a/drivers/scsi/scsi_tgt_lib.c b/drivers/scsi/scsi_tgt_lib.c
index 48ba413f7f6a..10303272ba45 100644
--- a/drivers/scsi/scsi_tgt_lib.c
+++ b/drivers/scsi/scsi_tgt_lib.c
@@ -387,7 +387,7 @@ static int scsi_map_user_pages(struct scsi_tgt_cmd *tcmd, struct scsi_cmnd *cmd,
          * we use REQ_TYPE_BLOCK_PC so scsi_init_io doesn't set the
          * length for us.
          */
-        cmd->sdb.length = rq->data_len;
+        cmd->sdb.length = blk_rq_bytes(rq);
 
         return 0;
 
diff --git a/drivers/scsi/scsi_transport_sas.c b/drivers/scsi/scsi_transport_sas.c
index 50988cbf7b2d..d606452297cf 100644
--- a/drivers/scsi/scsi_transport_sas.c
+++ b/drivers/scsi/scsi_transport_sas.c
@@ -163,12 +163,10 @@ static void sas_smp_request(struct request_queue *q, struct Scsi_Host *shost,
         int (*handler)(struct Scsi_Host *, struct sas_rphy *, struct request *);
 
         while (!blk_queue_plugged(q)) {
-                req = elv_next_request(q);
+                req = blk_fetch_request(q);
                 if (!req)
                         break;
 
-                blkdev_dequeue_request(req);
-
                 spin_unlock_irq(q->queue_lock);
 
                 handler = to_sas_internal(shost->transportt)->f->smp_handler;
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 84044233b637..bcf3bd40bbd5 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -384,9 +384,9 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
         struct scsi_device *sdp = q->queuedata;
         struct gendisk *disk = rq->rq_disk;
         struct scsi_disk *sdkp;
-        sector_t block = rq->sector;
+        sector_t block = blk_rq_pos(rq);
         sector_t threshold;
-        unsigned int this_count = rq->nr_sectors;
+        unsigned int this_count = blk_rq_sectors(rq);
         int ret, host_dif;
 
         if (rq->cmd_type == REQ_TYPE_BLOCK_PC) {
@@ -413,10 +413,10 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
                                         this_count));
 
         if (!sdp || !scsi_device_online(sdp) ||
-            block + rq->nr_sectors > get_capacity(disk)) {
+            block + blk_rq_sectors(rq) > get_capacity(disk)) {
                 SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
-                                                "Finishing %ld sectors\n",
-                                                rq->nr_sectors));
+                                                "Finishing %u sectors\n",
+                                                blk_rq_sectors(rq)));
                 SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
                                                 "Retry with 0x%p\n", SCpnt));
                 goto out;
@@ -463,7 +463,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
          * for this.
          */
         if (sdp->sector_size == 1024) {
-                if ((block & 1) || (rq->nr_sectors & 1)) {
+                if ((block & 1) || (blk_rq_sectors(rq) & 1)) {
                         scmd_printk(KERN_ERR, SCpnt,
                                     "Bad block number requested\n");
                         goto out;
@@ -473,7 +473,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
                 }
         }
         if (sdp->sector_size == 2048) {
-                if ((block & 3) || (rq->nr_sectors & 3)) {
+                if ((block & 3) || (blk_rq_sectors(rq) & 3)) {
                         scmd_printk(KERN_ERR, SCpnt,
                                     "Bad block number requested\n");
                         goto out;
@@ -483,7 +483,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
                 }
         }
         if (sdp->sector_size == 4096) {
-                if ((block & 7) || (rq->nr_sectors & 7)) {
+                if ((block & 7) || (blk_rq_sectors(rq) & 7)) {
                         scmd_printk(KERN_ERR, SCpnt,
                                     "Bad block number requested\n");
                         goto out;
@@ -512,10 +512,10 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
         }
 
         SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt,
-                                        "%s %d/%ld 512 byte blocks.\n",
+                                        "%s %d/%u 512 byte blocks.\n",
                                         (rq_data_dir(rq) == WRITE) ?
                                         "writing" : "reading", this_count,
-                                        rq->nr_sectors));
+                                        blk_rq_sectors(rq)));
 
         /* Set RDPROTECT/WRPROTECT if disk is formatted with DIF */
         host_dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type);
@@ -971,8 +971,8 @@ static struct block_device_operations sd_fops = {
 
 static unsigned int sd_completed_bytes(struct scsi_cmnd *scmd)
 {
-        u64 start_lba = scmd->request->sector;
-        u64 end_lba = scmd->request->sector + (scsi_bufflen(scmd) / 512);
+        u64 start_lba = blk_rq_pos(scmd->request);
+        u64 end_lba = blk_rq_pos(scmd->request) + (scsi_bufflen(scmd) / 512);
         u64 bad_lba;
         int info_valid;
 
@@ -1510,7 +1510,7 @@ got_data:
                  */
                 sector_size = 512;
         }
-        blk_queue_hardsect_size(sdp->request_queue, sector_size);
+        blk_queue_logical_block_size(sdp->request_queue, sector_size);
 
         {
                 char cap_str_2[10], cap_str_10[10];
diff --git a/drivers/scsi/sd_dif.c b/drivers/scsi/sd_dif.c
index 184dff492797..82f14a9482d0 100644
--- a/drivers/scsi/sd_dif.c
+++ b/drivers/scsi/sd_dif.c
@@ -507,7 +507,7 @@ void sd_dif_complete(struct scsi_cmnd *scmd, unsigned int good_bytes)
         sector_sz = scmd->device->sector_size;
         sectors = good_bytes / sector_sz;
 
-        phys = scmd->request->sector & 0xffffffff;
+        phys = blk_rq_pos(scmd->request) & 0xffffffff;
         if (sector_sz == 4096)
                 phys >>= 3;
 
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 91e316fe6522..8201387b4daa 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -289,8 +289,8 @@ sg_open(struct inode *inode, struct file *filp)
         if (list_empty(&sdp->sfds)) {   /* no existing opens on this device */
                 sdp->sgdebug = 0;
                 q = sdp->device->request_queue;
-                sdp->sg_tablesize = min(q->max_hw_segments,
-                                        q->max_phys_segments);
+                sdp->sg_tablesize = min(queue_max_hw_segments(q),
+                                        queue_max_phys_segments(q));
         }
         if ((sfp = sg_add_sfp(sdp, dev)))
                 filp->private_data = sfp;
@@ -909,7 +909,7 @@ sg_ioctl(struct inode *inode, struct file *filp,
                 if (val < 0)
                         return -EINVAL;
                 val = min_t(int, val,
-                                sdp->device->request_queue->max_sectors * 512);
+                            queue_max_sectors(sdp->device->request_queue) * 512);
                 if (val != sfp->reserve.bufflen) {
                         if (sg_res_in_use(sfp) || sfp->mmap_called)
                                 return -EBUSY;
@@ -919,7 +919,7 @@ sg_ioctl(struct inode *inode, struct file *filp,
                 return 0;
         case SG_GET_RESERVED_SIZE:
                 val = min_t(int, sfp->reserve.bufflen,
-                                sdp->device->request_queue->max_sectors * 512);
+                            queue_max_sectors(sdp->device->request_queue) * 512);
                 return put_user(val, ip);
         case SG_SET_COMMAND_Q:
                 result = get_user(val, ip);
@@ -1059,7 +1059,7 @@ sg_ioctl(struct inode *inode, struct file *filp,
                         return -ENODEV;
                 return scsi_ioctl(sdp->device, cmd_in, p);
         case BLKSECTGET:
-                return put_user(sdp->device->request_queue->max_sectors * 512,
+                return put_user(queue_max_sectors(sdp->device->request_queue) * 512,
                                 ip);
         case BLKTRACESETUP:
                 return blk_trace_setup(sdp->device->request_queue,
@@ -1261,7 +1261,7 @@ static void sg_rq_end_io(struct request *rq, int uptodate)
 
         sense = rq->sense;
         result = rq->errors;
-        resid = rq->data_len;
+        resid = rq->resid_len;
 
         SCSI_LOG_TIMEOUT(4, printk("sg_cmd_done: %s, pack_id=%d, res=0x%x\n",
                 sdp->disk->disk_name, srp->header.pack_id, result));
@@ -1378,7 +1378,8 @@ static Sg_device *sg_alloc(struct gendisk *disk, struct scsi_device *scsidp)
         sdp->device = scsidp;
         INIT_LIST_HEAD(&sdp->sfds);
         init_waitqueue_head(&sdp->o_excl_wait);
-        sdp->sg_tablesize = min(q->max_hw_segments, q->max_phys_segments);
+        sdp->sg_tablesize = min(queue_max_hw_segments(q),
+                                queue_max_phys_segments(q));
         sdp->index = k;
         kref_init(&sdp->d_ref);
 
@@ -2056,7 +2057,7 @@ sg_add_sfp(Sg_device * sdp, int dev)
                 sg_big_buff = def_reserved_size;
 
         bufflen = min_t(int, sg_big_buff,
-                        sdp->device->request_queue->max_sectors * 512);
+                        queue_max_sectors(sdp->device->request_queue) * 512);
         sg_build_reserve(sfp, bufflen);
         SCSI_LOG_TIMEOUT(3, printk("sg_add_sfp:   bufflen=%d, k_use_sg=%d\n",
                            sfp->reserve.bufflen, sfp->reserve.k_use_sg));
diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index 0e1a0f2d2ad5..cd350dfc1216 100644
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -292,7 +292,8 @@ static int sr_done(struct scsi_cmnd *SCpnt)
                         if (cd->device->sector_size == 2048)
                                 error_sector <<= 2;
                         error_sector &= ~(block_sectors - 1);
-                        good_bytes = (error_sector - SCpnt->request->sector) << 9;
+                        good_bytes = (error_sector -
+                                      blk_rq_pos(SCpnt->request)) << 9;
                         if (good_bytes < 0 || good_bytes >= this_count)
                                 good_bytes = 0;
                         /*
@@ -349,8 +350,8 @@ static int sr_prep_fn(struct request_queue *q, struct request *rq)
                                 cd->disk->disk_name, block));
 
         if (!cd->device || !scsi_device_online(cd->device)) {
-                SCSI_LOG_HLQUEUE(2, printk("Finishing %ld sectors\n",
-                                        rq->nr_sectors));
+                SCSI_LOG_HLQUEUE(2, printk("Finishing %u sectors\n",
+                                           blk_rq_sectors(rq)));
                 SCSI_LOG_HLQUEUE(2, printk("Retry with 0x%p\n", SCpnt));
                 goto out;
         }
@@ -413,7 +414,7 @@ static int sr_prep_fn(struct request_queue *q, struct request *rq)
         /*
          * request doesn't start on hw block boundary, add scatter pads
          */
-        if (((unsigned int)rq->sector % (s_size >> 9)) ||
+        if (((unsigned int)blk_rq_pos(rq) % (s_size >> 9)) ||
             (scsi_bufflen(SCpnt) % s_size)) {
                 scmd_printk(KERN_NOTICE, SCpnt, "unaligned transfer\n");
                 goto out;
@@ -422,14 +423,14 @@ static int sr_prep_fn(struct request_queue *q, struct request *rq)
         this_count = (scsi_bufflen(SCpnt) >> 9) / (s_size >> 9);
 
 
-        SCSI_LOG_HLQUEUE(2, printk("%s : %s %d/%ld 512 byte blocks.\n",
+        SCSI_LOG_HLQUEUE(2, printk("%s : %s %d/%u 512 byte blocks.\n",
                                 cd->cdi.name,
                                 (rq_data_dir(rq) == WRITE) ?
                                         "writing" : "reading",
-                                this_count, rq->nr_sectors));
+                                this_count, blk_rq_sectors(rq)));
 
         SCpnt->cmnd[1] = 0;
-        block = (unsigned int)rq->sector / (s_size >> 9);
+        block = (unsigned int)blk_rq_pos(rq) / (s_size >> 9);
 
         if (this_count > 0xffff) {
                 this_count = 0xffff;
@@ -726,7 +727,7 @@ static void get_sectorsize(struct scsi_cd *cd)
         }
 
         queue = cd->device->request_queue;
-        blk_queue_hardsect_size(queue, sector_size);
+        blk_queue_logical_block_size(queue, sector_size);
 
         return;
 }
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index eb24efea8f14..89bd438e1fe3 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -463,7 +463,7 @@ static void st_scsi_execute_end(struct request *req, int uptodate)
         struct scsi_tape *STp = SRpnt->stp;
 
         STp->buffer->cmdstat.midlevel_result = SRpnt->result = req->errors;
-        STp->buffer->cmdstat.residual = req->data_len;
+        STp->buffer->cmdstat.residual = req->resid_len;
 
         if (SRpnt->waiting)
                 complete(SRpnt->waiting);
@@ -3983,8 +3983,8 @@ static int st_probe(struct device *dev)
                 return -ENODEV;
         }
 
-        i = min(SDp->request_queue->max_hw_segments,
-                SDp->request_queue->max_phys_segments);
+        i = min(queue_max_hw_segments(SDp->request_queue),
+                queue_max_phys_segments(SDp->request_queue));
         if (st_max_sg_segs < i)
                 i = st_max_sg_segs;
         buffer = new_tape_buffer((SDp->host)->unchecked_isa_dma, i);
diff --git a/drivers/scsi/u14-34f.c b/drivers/scsi/u14-34f.c
index 601e95141cbe..54023d41fd15 100644
--- a/drivers/scsi/u14-34f.c
+++ b/drivers/scsi/u14-34f.c
@@ -1306,7 +1306,7 @@ static int u14_34f_queuecommand(struct scsi_cmnd *SCpnt, void (*done)(struct scs
    if (linked_comm && SCpnt->device->queue_depth > 2
                                      && TLDEV(SCpnt->device->type)) {
       HD(j)->cp_stat[i] = READY;
-      flush_dev(SCpnt->device, SCpnt->request->sector, j, FALSE);
+      flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), j, FALSE);
       return 0;
       }
 
@@ -1610,11 +1610,13 @@ static int reorder(unsigned int j, unsigned long cursec,
 
       if (!(cpp->xdir == DTD_IN)) input_only = FALSE;
 
-      if (SCpnt->request->sector < minsec) minsec = SCpnt->request->sector;
-      if (SCpnt->request->sector > maxsec) maxsec = SCpnt->request->sector;
+      if (blk_rq_pos(SCpnt->request) < minsec)
+         minsec = blk_rq_pos(SCpnt->request);
+      if (blk_rq_pos(SCpnt->request) > maxsec)
+         maxsec = blk_rq_pos(SCpnt->request);
 
-      sl[n] = SCpnt->request->sector;
-      ioseek += SCpnt->request->nr_sectors;
+      sl[n] = blk_rq_pos(SCpnt->request);
+      ioseek += blk_rq_sectors(SCpnt->request);
 
       if (!n) continue;
 
@@ -1642,7 +1644,7 @@ static int reorder(unsigned int j, unsigned long cursec,
 
    if (!input_only) for (n = 0; n < n_ready; n++) {
       k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
-      ll[n] = SCpnt->request->nr_sectors; pl[n] = SCpnt->serial_number;
+      ll[n] = blk_rq_sectors(SCpnt->request); pl[n] = SCpnt->serial_number;
 
       if (!n) continue;
 
@@ -1666,12 +1668,12 @@ static int reorder(unsigned int j, unsigned long cursec,
    if (link_statistics && (overlap || !(flushcount % link_statistics)))
       for (n = 0; n < n_ready; n++) {
          k = il[n]; cpp = &HD(j)->cp[k]; SCpnt = cpp->SCpnt;
-         printk("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %ld"\
+         printk("%s %d.%d:%d pid %ld mb %d fc %d nr %d sec %ld ns %u"\
                 " cur %ld s:%c r:%c rev:%c in:%c ov:%c xd %d.\n",
                 (ihdlr ? "ihdlr" : "qcomm"), SCpnt->channel, SCpnt->target,
                 SCpnt->lun, SCpnt->serial_number, k, flushcount, n_ready,
-                SCpnt->request->sector, SCpnt->request->nr_sectors, cursec,
-                YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only),
+                blk_rq_pos(SCpnt->request), blk_rq_sectors(SCpnt->request),
+                cursec, YESNO(s), YESNO(r), YESNO(rev), YESNO(input_only),
                 YESNO(overlap), cpp->xdir);
          }
 #endif
@@ -1799,7 +1801,7 @@ static irqreturn_t ihdlr(unsigned int j)
 
    if (linked_comm && SCpnt->device->queue_depth > 2
                                      && TLDEV(SCpnt->device->type))
-      flush_dev(SCpnt->device, SCpnt->request->sector, j, TRUE);
+      flush_dev(SCpnt->device, blk_rq_pos(SCpnt->request), j, TRUE);
 
    tstatus = status_byte(spp->target_status);
 
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index a0127e93ade0..fb867a9f55e9 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -287,6 +287,13 @@ static const struct serial8250_config uart_config[] = {
                 .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
                 .flags          = UART_CAP_FIFO,
         },
+        [PORT_AR7] = {
+                .name           = "AR7",
+                .fifo_size      = 16,
+                .tx_loadsz      = 16,
+                .fcr            = UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_00,
+                .flags          = UART_CAP_FIFO | UART_CAP_AFE,
+        },
 };
 
 #if defined (CONFIG_SERIAL_8250_AU1X00)
diff --git a/drivers/serial/8250_pci.c b/drivers/serial/8250_pci.c
index 938bc1b6c3fa..e371a9c15341 100644
--- a/drivers/serial/8250_pci.c
+++ b/drivers/serial/8250_pci.c
@@ -2776,6 +2776,9 @@ static struct pci_device_id serial_pci_tbl[] = {
         {       PCI_VENDOR_ID_OXSEMI, 0x950a,
                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
                 pbn_b0_2_1130000 },
+        {       PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_C950,
+                PCI_VENDOR_ID_OXSEMI, PCI_SUBDEVICE_ID_OXSEMI_C950, 0, 0,
+                pbn_b0_1_921600 },
         {       PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI954,
                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
                 pbn_b0_4_115200 },
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig
index 343e3a35b6a3..641e800ed693 100644
--- a/drivers/serial/Kconfig
+++ b/drivers/serial/Kconfig
@@ -833,6 +833,7 @@ config SERIAL_IMX
         bool "IMX serial port support"
         depends on ARM && (ARCH_IMX || ARCH_MXC)
         select SERIAL_CORE
+        select RATIONAL
         help
           If you have a machine based on a Motorola IMX CPU you
           can enable its onboard serial port by enabling this option.
@@ -1433,4 +1434,11 @@ config SPORT_BAUD_RATE
         default 19200 if (SERIAL_SPORT_BAUD_RATE_19200)
         default 9600 if (SERIAL_SPORT_BAUD_RATE_9600)
 
+config SERIAL_TIMBERDALE
+        tristate "Support for timberdale UART"
+        depends on MFD_TIMBERDALE
+        select SERIAL_CORE
+        ---help---
+        Add support for UART controller on timberdale.
+
 endmenu
diff --git a/drivers/serial/Makefile b/drivers/serial/Makefile
index d438eb2a73de..45a8658f54d5 100644
--- a/drivers/serial/Makefile
+++ b/drivers/serial/Makefile
@@ -77,3 +77,4 @@ obj-$(CONFIG_SERIAL_OF_PLATFORM_NWPSERIAL) += nwpserial.o
 obj-$(CONFIG_SERIAL_KS8695) += serial_ks8695.o
 obj-$(CONFIG_KGDB_SERIAL_CONSOLE) += kgdboc.o
 obj-$(CONFIG_SERIAL_QE) += ucc_uart.o
+obj-$(CONFIG_SERIAL_TIMBERDALE) += timbuart.o
diff --git a/drivers/serial/bfin_5xx.c b/drivers/serial/bfin_5xx.c
index d86123e03391..e2f6b1bfac98 100644
--- a/drivers/serial/bfin_5xx.c
+++ b/drivers/serial/bfin_5xx.c
@@ -330,6 +330,11 @@ static void bfin_serial_tx_chars(struct bfin_serial_port *uart)
                 /* Clear TFI bit */
                 UART_PUT_LSR(uart, TFI);
 #endif
+                /* Anomaly notes:
+                 *  05000215 -  we always clear ETBEI within last UART TX
+                 *              interrupt to end a string. It is always set
+                 *              when start a new tx.
+                 */
                 UART_CLEAR_IER(uart, ETBEI);
                 return;
         }
@@ -415,6 +420,7 @@ static void bfin_serial_dma_tx_chars(struct bfin_serial_port *uart)
         set_dma_start_addr(uart->tx_dma_channel, (unsigned long)(xmit->buf+xmit->tail));
         set_dma_x_count(uart->tx_dma_channel, uart->tx_count);
         set_dma_x_modify(uart->tx_dma_channel, 1);
+        SSYNC();
         enable_dma(uart->tx_dma_channel);
 
         UART_SET_IER(uart, ETBEI);
@@ -473,27 +479,41 @@ static void bfin_serial_dma_rx_chars(struct bfin_serial_port *uart)
 void bfin_serial_rx_dma_timeout(struct bfin_serial_port *uart)
 {
         int x_pos, pos;
-        unsigned long flags;
-
-        spin_lock_irqsave(&uart->port.lock, flags);
 
+        dma_disable_irq(uart->rx_dma_channel);
+        spin_lock_bh(&uart->port.lock);
+
+        /* 2D DMA RX buffer ring is used. Because curr_y_count and
+         * curr_x_count can't be read as an atomic operation,
+         * curr_y_count should be read before curr_x_count. When
+         * curr_x_count is read, curr_y_count may already indicate
+         * next buffer line. But, the position calculated here is
+         * still indicate the old line. The wrong position data may
+         * be smaller than current buffer tail, which cause garbages
+         * are received if it is not prohibit.
+         */
         uart->rx_dma_nrows = get_dma_curr_ycount(uart->rx_dma_channel);
         x_pos = get_dma_curr_xcount(uart->rx_dma_channel);
         uart->rx_dma_nrows = DMA_RX_YCOUNT - uart->rx_dma_nrows;
-        if (uart->rx_dma_nrows == DMA_RX_YCOUNT)
+        if (uart->rx_dma_nrows == DMA_RX_YCOUNT || x_pos == 0)
                 uart->rx_dma_nrows = 0;
         x_pos = DMA_RX_XCOUNT - x_pos;
         if (x_pos == DMA_RX_XCOUNT)
                 x_pos = 0;
 
         pos = uart->rx_dma_nrows * DMA_RX_XCOUNT + x_pos;
-        if (pos != uart->rx_dma_buf.tail) {
+        /* Ignore receiving data if new position is in the same line of
+         * current buffer tail and small.
+         */
+        if (pos > uart->rx_dma_buf.tail ||
+                uart->rx_dma_nrows < (uart->rx_dma_buf.tail/DMA_RX_XCOUNT)) {
                 uart->rx_dma_buf.head = pos;
                 bfin_serial_dma_rx_chars(uart);
                 uart->rx_dma_buf.tail = uart->rx_dma_buf.head;
         }
 
-        spin_unlock_irqrestore(&uart->port.lock, flags);
+        spin_unlock_bh(&uart->port.lock);
+        dma_enable_irq(uart->rx_dma_channel);
 
         mod_timer(&(uart->rx_dma_timer), jiffies + DMA_RX_FLUSH_JIFFIES);
 }
@@ -514,6 +534,11 @@ static irqreturn_t bfin_serial_dma_tx_int(int irq, void *dev_id)
         if (!(get_dma_curr_irqstat(uart->tx_dma_channel)&DMA_RUN)) {
                 disable_dma(uart->tx_dma_channel);
                 clear_dma_irqstat(uart->tx_dma_channel);
+                /* Anomaly notes:
+                 *  05000215 -  we always clear ETBEI within last UART TX
+                 *              interrupt to end a string. It is always set
+                 *              when start a new tx.
+                 */
                 UART_CLEAR_IER(uart, ETBEI);
                 xmit->tail = (xmit->tail + uart->tx_count) & (UART_XMIT_SIZE - 1);
                 uart->port.icount.tx += uart->tx_count;
@@ -532,11 +557,26 @@ static irqreturn_t bfin_serial_dma_rx_int(int irq, void *dev_id)
 {
         struct bfin_serial_port *uart = dev_id;
         unsigned short irqstat;
+        int x_pos, pos;
 
         spin_lock(&uart->port.lock);
         irqstat = get_dma_curr_irqstat(uart->rx_dma_channel);
         clear_dma_irqstat(uart->rx_dma_channel);
-        bfin_serial_dma_rx_chars(uart);
+
+        uart->rx_dma_nrows = get_dma_curr_ycount(uart->rx_dma_channel);
+        x_pos = get_dma_curr_xcount(uart->rx_dma_channel);
+        uart->rx_dma_nrows = DMA_RX_YCOUNT - uart->rx_dma_nrows;
+        if (uart->rx_dma_nrows == DMA_RX_YCOUNT || x_pos == 0)
+                uart->rx_dma_nrows = 0;
+
+        pos = uart->rx_dma_nrows * DMA_RX_XCOUNT;
+        if (pos > uart->rx_dma_buf.tail ||
+                uart->rx_dma_nrows < (uart->rx_dma_buf.tail/DMA_RX_XCOUNT)) {
+                uart->rx_dma_buf.head = pos;
+                bfin_serial_dma_rx_chars(uart);
+                uart->rx_dma_buf.tail = uart->rx_dma_buf.head;
+        }
+
         spin_unlock(&uart->port.lock);
 
         return IRQ_HANDLED;
@@ -789,8 +829,16 @@ bfin_serial_set_termios(struct uart_port *port, struct ktermios *termios,
                         __func__);
         }
 
-        if (termios->c_cflag & CSTOPB)
-                lcr |= STB;
+        /* Anomaly notes:
+         *  05000231 -  STOP bit is always set to 1 whatever the user is set.
+         */
+        if (termios->c_cflag & CSTOPB) {
+                if (ANOMALY_05000231)
+                        printk(KERN_WARNING "STOP bits other than 1 is not "
+                                "supported in case of anomaly 05000231.\n");
+                else
+                        lcr |= STB;
+        }
         if (termios->c_cflag & PARENB)
                 lcr |= PEN;
         if (!(termios->c_cflag & PARODD))
@@ -940,6 +988,10 @@ static void bfin_serial_reset_irda(struct uart_port *port)
 }
 
 #ifdef CONFIG_CONSOLE_POLL
+/* Anomaly notes:
+ *  05000099 -  Because we only use THRE in poll_put and DR in poll_get,
+ *              losing other bits of UART_LSR is not a problem here.
+ */
 static void bfin_serial_poll_put_char(struct uart_port *port, unsigned char chr)
 {
         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
@@ -1245,12 +1297,17 @@ static __init void early_serial_write(struct console *con, const char *s,
         }
 }
 
+/*
+ * This should have a .setup or .early_setup in it, but then things get called
+ * without the command line options, and the baud rate gets messed up - so
+ * don't let the common infrastructure play with things. (see calls to setup
+ * & earlysetup in ./kernel/printk.c:register_console()
+ */
 static struct __initdata console bfin_early_serial_console = {
         .name = "early_BFuart",
         .write = early_serial_write,
         .device = uart_console_device,
         .flags = CON_PRINTBUFFER,
-        .setup = bfin_serial_console_setup,
         .index = -1,
         .data  = &bfin_serial_reg,
 };
diff --git a/drivers/serial/bfin_sport_uart.c b/drivers/serial/bfin_sport_uart.c
index 529c0ff7952c..34b4ae0fe760 100644
--- a/drivers/serial/bfin_sport_uart.c
+++ b/drivers/serial/bfin_sport_uart.c
@@ -101,15 +101,16 @@ static inline void tx_one_byte(struct sport_uart_port *up, unsigned int value)
 {
         pr_debug("%s value:%x\n", __func__, value);
         /* Place a Start and Stop bit */
-        __asm__ volatile (
-                "R2 = b#01111111100;\n\t"
-                "R3 = b#10000000001;\n\t"
-                "%0 <<= 2;\n\t"
-                "%0 = %0 & R2;\n\t"
-                "%0 = %0 | R3;\n\t"
-                :"=r"(value)
-                :"0"(value)
-                :"R2", "R3");
+        __asm__ __volatile__ (
+                "R2 = b#01111111100;"
+                "R3 = b#10000000001;"
+                "%0 <<= 2;"
+                "%0 = %0 & R2;"
+                "%0 = %0 | R3;"
+                : "=d"(value)
+                : "d"(value)
+                : "ASTAT", "R2", "R3"
+        );
         pr_debug("%s value:%x\n", __func__, value);
 
         SPORT_PUT_TX(up, value);
@@ -118,27 +119,30 @@ static inline void tx_one_byte(struct sport_uart_port *up, unsigned int value)
 static inline unsigned int rx_one_byte(struct sport_uart_port *up)
 {
         unsigned int value, extract;
+        u32 tmp_mask1, tmp_mask2, tmp_shift, tmp;
 
         value = SPORT_GET_RX32(up);
         pr_debug("%s value:%x\n", __func__, value);
 
         /* Extract 8 bits data */
-        __asm__ volatile (
-                "R5 = 0;\n\t"
-                "P0 = 8;\n\t"
-                "R1 = 0x1801(Z);\n\t"
-                "R3 = 0x0300(Z);\n\t"
-                "R4 = 0;\n\t"
-                "LSETUP(loop_s, loop_e) LC0 = P0;\nloop_s:\t"
-                "R2 = extract(%1, R1.L)(Z);\n\t"
-                "R2 <<= R4;\n\t"
-                "R5 = R5 | R2;\n\t"
-                "R1 = R1 - R3;\nloop_e:\t"
-                "R4 += 1;\n\t"
-                "%0 = R5;\n\t"
-                :"=r"(extract)
-                :"r"(value)
-                :"P0", "R1", "R2","R3","R4", "R5");
+        __asm__ __volatile__ (
+                "%[extr] = 0;"
+                "%[mask1] = 0x1801(Z);"
+                "%[mask2] = 0x0300(Z);"
+                "%[shift] = 0;"
+                "LSETUP(.Lloop_s, .Lloop_e) LC0 = %[lc];"
+                ".Lloop_s:"
+                "%[tmp] = extract(%[val], %[mask1].L)(Z);"
+                "%[tmp] <<= %[shift];"
+                "%[extr] = %[extr] | %[tmp];"
+                "%[mask1] = %[mask1] - %[mask2];"
+                ".Lloop_e:"
+                "%[shift] += 1;"
+                : [val]"=d"(value), [extr]"=d"(extract), [shift]"=d"(tmp_shift), [tmp]"=d"(tmp),
+                  [mask1]"=d"(tmp_mask1), [mask2]"=d"(tmp_mask2)
+                : "d"(value), [lc]"a"(8)
+                : "ASTAT", "LB0", "LC0", "LT0"
+        );
 
         pr_debug("      extract:%x\n", extract);
         return extract;
@@ -149,7 +153,7 @@ static int sport_uart_setup(struct sport_uart_port *up, int sclk, int baud_rate)
         int tclkdiv, tfsdiv, rclkdiv;
 
         /* Set TCR1 and TCR2 */
-        SPORT_PUT_TCR1(up, (LTFS | ITFS | TFSR | TLSBIT | ITCLK));
+        SPORT_PUT_TCR1(up, (LATFS | ITFS | TFSR | TLSBIT | ITCLK));
         SPORT_PUT_TCR2(up, 10);
         pr_debug("%s TCR1:%x, TCR2:%x\n", __func__, SPORT_GET_TCR1(up), SPORT_GET_TCR2(up));
 
@@ -419,7 +423,7 @@ static void sport_shutdown(struct uart_port *port)
 }
 
 static void sport_set_termios(struct uart_port *port,
-                struct termios *termios, struct termios *old)
+                struct ktermios *termios, struct ktermios *old)
 {
         pr_debug("%s enter, c_cflag:%08x\n", __func__, termios->c_cflag);
         uart_update_timeout(port, CS8 ,port->uartclk);
diff --git a/drivers/serial/icom.c b/drivers/serial/icom.c
index a461b3b2c72d..9f2891c2c4a2 100644
--- a/drivers/serial/icom.c
+++ b/drivers/serial/icom.c
@@ -137,7 +137,12 @@ static LIST_HEAD(icom_adapter_head);
 static spinlock_t icom_lock;
 
 #ifdef ICOM_TRACE
-static inline void trace(struct icom_port *, char *, unsigned long) {};
+static inline void trace(struct icom_port *icom_port, char *trace_pt,
+                        unsigned long trace_data)
+{
+        dev_info(&icom_port->adapter->pci_dev->dev, ":%d:%s - %lx\n",
+        icom_port->port, trace_pt, trace_data);
+}
 #else
 static inline void trace(struct icom_port *icom_port, char *trace_pt, unsigned long trace_data) {};
 #endif
@@ -408,7 +413,7 @@ static void load_code(struct icom_port *icom_port)
         release_firmware(fw);
 
         /* Set Hardware level */
-        if ((icom_port->adapter->version | ADAPTER_V2) == ADAPTER_V2)
+        if (icom_port->adapter->version == ADAPTER_V2)
                 writeb(V2_HARDWARE, &(icom_port->dram->misc_flags));
 
         /* Start the processor in Adapter */
@@ -861,7 +866,7 @@ static irqreturn_t icom_interrupt(int irq, void *dev_id)
         /* find icom_port for this interrupt */
         icom_adapter = (struct icom_adapter *) dev_id;
 
-        if ((icom_adapter->version | ADAPTER_V2) == ADAPTER_V2) {
+        if (icom_adapter->version == ADAPTER_V2) {
                 int_reg = icom_adapter->base_addr + 0x8024;
 
                 adapter_interrupts = readl(int_reg);
@@ -1647,15 +1652,6 @@ static void __exit icom_exit(void)
 module_init(icom_init);
 module_exit(icom_exit);
 
-#ifdef ICOM_TRACE
-static inline void trace(struct icom_port *icom_port, char *trace_pt,
-                  unsigned long trace_data)
-{
-        dev_info(&icom_port->adapter->pci_dev->dev, ":%d:%s - %lx\n",
-                 icom_port->port, trace_pt, trace_data);
-}
-#endif
-
 MODULE_AUTHOR("Michael Anderson <mjanders@us.ibm.com>");
 MODULE_DESCRIPTION("IBM iSeries Serial IOA driver");
 MODULE_SUPPORTED_DEVICE
diff --git a/drivers/serial/imx.c b/drivers/serial/imx.c
index 5f0be40dfdab..7b5d1de9cfe3 100644
--- a/drivers/serial/imx.c
+++ b/drivers/serial/imx.c
@@ -8,6 +8,9 @@
  *  Author: Sascha Hauer <sascha@saschahauer.de>
  *  Copyright (C) 2004 Pengutronix
  *
+ *  Copyright (C) 2009 emlix GmbH
+ *  Author: Fabian Godehardt (added IrDA support for iMX)
+ *
  * 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
@@ -41,6 +44,8 @@
 #include <linux/serial_core.h>
 #include <linux/serial.h>
 #include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/rational.h>
 
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -148,6 +153,7 @@
 #define  UCR4_DREN       (1<<0)  /* Recv data ready interrupt enable */
 #define  UFCR_RXTL_SHF   0       /* Receiver trigger level shift */
 #define  UFCR_RFDIV      (7<<7)  /* Reference freq divider mask */
+#define  UFCR_RFDIV_REG(x)      (((x) < 7 ? 6 - (x) : 6) << 7)
 #define  UFCR_TXTL_SHF   10      /* Transmitter trigger level shift */
 #define  USR1_PARITYERR  (1<<15) /* Parity error interrupt flag */
 #define  USR1_RTSS       (1<<14) /* RTS pin status */
@@ -211,10 +217,20 @@ struct imx_port {
         struct timer_list       timer;
         unsigned int            old_status;
         int                     txirq,rxirq,rtsirq;
-        int                     have_rtscts:1;
+        unsigned int            have_rtscts:1;
+        unsigned int            use_irda:1;
+        unsigned int            irda_inv_rx:1;
+        unsigned int            irda_inv_tx:1;
+        unsigned short          trcv_delay; /* transceiver delay */
         struct clk              *clk;
 };
 
+#ifdef CONFIG_IRDA
+#define USE_IRDA(sport) ((sport)->use_irda)
+#else
+#define USE_IRDA(sport) (0)
+#endif
+
 /*
  * Handle any change of modem status signal since we were last called.
  */
@@ -268,6 +284,48 @@ static void imx_stop_tx(struct uart_port *port)
         struct imx_port *sport = (struct imx_port *)port;
         unsigned long temp;
 
+        if (USE_IRDA(sport)) {
+                /* half duplex - wait for end of transmission */
+                int n = 256;
+                while ((--n > 0) &&
+                      !(readl(sport->port.membase + USR2) & USR2_TXDC)) {
+                        udelay(5);
+                        barrier();
+                }
+                /*
+                 * irda transceiver - wait a bit more to avoid
+                 * cutoff, hardware dependent
+                 */
+                udelay(sport->trcv_delay);
+
+                /*
+                 * half duplex - reactivate receive mode,
+                 * flush receive pipe echo crap
+                 */
+                if (readl(sport->port.membase + USR2) & USR2_TXDC) {
+                        temp = readl(sport->port.membase + UCR1);
+                        temp &= ~(UCR1_TXMPTYEN | UCR1_TRDYEN);
+                        writel(temp, sport->port.membase + UCR1);
+
+                        temp = readl(sport->port.membase + UCR4);
+                        temp &= ~(UCR4_TCEN);
+                        writel(temp, sport->port.membase + UCR4);
+
+                        while (readl(sport->port.membase + URXD0) &
+                               URXD_CHARRDY)
+                                barrier();
+
+                        temp = readl(sport->port.membase + UCR1);
+                        temp |= UCR1_RRDYEN;
+                        writel(temp, sport->port.membase + UCR1);
+
+                        temp = readl(sport->port.membase + UCR4);
+                        temp |= UCR4_DREN;
+                        writel(temp, sport->port.membase + UCR4);
+                }
+                return;
+        }
+
         temp = readl(sport->port.membase + UCR1);
         writel(temp & ~UCR1_TXMPTYEN, sport->port.membase + UCR1);
 }
@@ -302,13 +360,15 @@ static inline void imx_transmit_buffer(struct imx_port *sport)
                 /* send xmit->buf[xmit->tail]
                  * out the port here */
                 writel(xmit->buf[xmit->tail], sport->port.membase + URTX0);
-                xmit->tail = (xmit->tail + 1) &
-                         (UART_XMIT_SIZE - 1);
+                xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
                 sport->port.icount.tx++;
                 if (uart_circ_empty(xmit))
                         break;
         }
 
+        if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
+                uart_write_wakeup(&sport->port);
+
         if (uart_circ_empty(xmit))
                 imx_stop_tx(&sport->port);
 }
@@ -321,9 +381,30 @@ static void imx_start_tx(struct uart_port *port)
         struct imx_port *sport = (struct imx_port *)port;
         unsigned long temp;
 
+        if (USE_IRDA(sport)) {
+                /* half duplex in IrDA mode; have to disable receive mode */
+                temp = readl(sport->port.membase + UCR4);
+                temp &= ~(UCR4_DREN);
+                writel(temp, sport->port.membase + UCR4);
+
+                temp = readl(sport->port.membase + UCR1);
+                temp &= ~(UCR1_RRDYEN);
+                writel(temp, sport->port.membase + UCR1);
+        }
+
         temp = readl(sport->port.membase + UCR1);
         writel(temp | UCR1_TXMPTYEN, sport->port.membase + UCR1);
 
+        if (USE_IRDA(sport)) {
+                temp = readl(sport->port.membase + UCR1);
+                temp |= UCR1_TRDYEN;
+                writel(temp, sport->port.membase + UCR1);
+
+                temp = readl(sport->port.membase + UCR4);
+                temp |= UCR4_TCEN;
+                writel(temp, sport->port.membase + UCR4);
+        }
+
         if (readl(sport->port.membase + UTS) & UTS_TXEMPTY)
                 imx_transmit_buffer(sport);
 }
@@ -395,8 +476,7 @@ static irqreturn_t imx_rxint(int irq, void *dev_id)
                                 continue;
                 }
 
-                if (uart_handle_sysrq_char
-                            (&sport->port, (unsigned char)rx))
+                if (uart_handle_sysrq_char(&sport->port, (unsigned char)rx))
                         continue;
 
                 if (rx & (URXD_PRERR | URXD_OVRRUN | URXD_FRMERR) ) {
@@ -471,26 +551,26 @@ static unsigned int imx_tx_empty(struct uart_port *port)
  */
 static unsigned int imx_get_mctrl(struct uart_port *port)
 {
-        struct imx_port *sport = (struct imx_port *)port;
-        unsigned int tmp = TIOCM_DSR | TIOCM_CAR;
+        struct imx_port *sport = (struct imx_port *)port;
+        unsigned int tmp = TIOCM_DSR | TIOCM_CAR;
 
-        if (readl(sport->port.membase + USR1) & USR1_RTSS)
-                tmp |= TIOCM_CTS;
+        if (readl(sport->port.membase + USR1) & USR1_RTSS)
+                tmp |= TIOCM_CTS;
 
-        if (readl(sport->port.membase + UCR2) & UCR2_CTS)
-                tmp |= TIOCM_RTS;
+        if (readl(sport->port.membase + UCR2) & UCR2_CTS)
+                tmp |= TIOCM_RTS;
 
-        return tmp;
+        return tmp;
 }
 
 static void imx_set_mctrl(struct uart_port *port, unsigned int mctrl)
 {
-        struct imx_port *sport = (struct imx_port *)port;
+        struct imx_port *sport = (struct imx_port *)port;
         unsigned long temp;
 
         temp = readl(sport->port.membase + UCR2) & ~UCR2_CTS;
 
-        if (mctrl & TIOCM_RTS)
+        if (mctrl & TIOCM_RTS)
                 temp |= UCR2_CTS;
 
         writel(temp, sport->port.membase + UCR2);
@@ -534,12 +614,7 @@ static int imx_setup_ufcr(struct imx_port *sport, unsigned int mode)
         if(!ufcr_rfdiv)
                 ufcr_rfdiv = 1;
 
-        if(ufcr_rfdiv >= 7)
-                ufcr_rfdiv = 6;
-        else
-                ufcr_rfdiv = 6 - ufcr_rfdiv;
-
-        val |= UFCR_RFDIV & (ufcr_rfdiv << 7);
+        val |= UFCR_RFDIV_REG(ufcr_rfdiv);
 
         writel(val, sport->port.membase + UFCR);
 
@@ -558,8 +633,24 @@ static int imx_startup(struct uart_port *port)
          * requesting IRQs
          */
         temp = readl(sport->port.membase + UCR4);
+
+        if (USE_IRDA(sport))
+                temp |= UCR4_IRSC;
+
         writel(temp & ~UCR4_DREN, sport->port.membase + UCR4);
 
+        if (USE_IRDA(sport)) {
+                /* reset fifo's and state machines */
+                int i = 100;
+                temp = readl(sport->port.membase + UCR2);
+                temp &= ~UCR2_SRST;
+                writel(temp, sport->port.membase + UCR2);
+                while (!(readl(sport->port.membase + UCR2) & UCR2_SRST) &&
+                    (--i > 0)) {
+                        udelay(1);
+                }
+        }
+
         /*
          * Allocate the IRQ(s) i.MX1 has three interrupts whereas later
          * chips only have one interrupt.
@@ -575,12 +666,16 @@ static int imx_startup(struct uart_port *port)
                 if (retval)
                         goto error_out2;
 
-                retval = request_irq(sport->rtsirq, imx_rtsint,
-                             (sport->rtsirq < MAX_INTERNAL_IRQ) ? 0 :
-                               IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
-                                DRIVER_NAME, sport);
-                if (retval)
-                        goto error_out3;
+                /* do not use RTS IRQ on IrDA */
+                if (!USE_IRDA(sport)) {
+                        retval = request_irq(sport->rtsirq, imx_rtsint,
+                                     (sport->rtsirq < MAX_INTERNAL_IRQ) ? 0 :
+                                       IRQF_TRIGGER_FALLING |
+                                       IRQF_TRIGGER_RISING,
+                                        DRIVER_NAME, sport);
+                        if (retval)
+                                goto error_out3;
+                }
         } else {
                 retval = request_irq(sport->port.irq, imx_int, 0,
                                 DRIVER_NAME, sport);
@@ -597,18 +692,49 @@ static int imx_startup(struct uart_port *port)
 
         temp = readl(sport->port.membase + UCR1);
         temp |= UCR1_RRDYEN | UCR1_RTSDEN | UCR1_UARTEN;
+
+        if (USE_IRDA(sport)) {
+                temp |= UCR1_IREN;
+                temp &= ~(UCR1_RTSDEN);
+        }
+
         writel(temp, sport->port.membase + UCR1);
 
         temp = readl(sport->port.membase + UCR2);
         temp |= (UCR2_RXEN | UCR2_TXEN);
         writel(temp, sport->port.membase + UCR2);
 
+        if (USE_IRDA(sport)) {
+                /* clear RX-FIFO */
+                int i = 64;
+                while ((--i > 0) &&
+                        (readl(sport->port.membase + URXD0) & URXD_CHARRDY)) {
+                        barrier();
+                }
+        }
+
 #if defined CONFIG_ARCH_MX2 || defined CONFIG_ARCH_MX3
         temp = readl(sport->port.membase + UCR3);
         temp |= UCR3_RXDMUXSEL;
         writel(temp, sport->port.membase + UCR3);
 #endif
 
+        if (USE_IRDA(sport)) {
+                temp = readl(sport->port.membase + UCR4);
+                if (sport->irda_inv_rx)
+                        temp |= UCR4_INVR;
+                else
+                        temp &= ~(UCR4_INVR);
+                writel(temp | UCR4_DREN, sport->port.membase + UCR4);
+
+                temp = readl(sport->port.membase + UCR3);
+                if (sport->irda_inv_tx)
+                        temp |= UCR3_INVT;
+                else
+                        temp &= ~(UCR3_INVT);
+                writel(temp, sport->port.membase + UCR3);
+        }
+
         /*
          * Enable modem status interrupts
          */
@@ -616,6 +742,16 @@ static int imx_startup(struct uart_port *port)
         imx_enable_ms(&sport->port);
         spin_unlock_irqrestore(&sport->port.lock,flags);
 
+        if (USE_IRDA(sport)) {
+                struct imxuart_platform_data *pdata;
+                pdata = sport->port.dev->platform_data;
+                sport->irda_inv_rx = pdata->irda_inv_rx;
+                sport->irda_inv_tx = pdata->irda_inv_tx;
+                sport->trcv_delay = pdata->transceiver_delay;
+                if (pdata->irda_enable)
+                        pdata->irda_enable(1);
+        }
+
         return 0;
 
 error_out3:
@@ -633,6 +769,17 @@ static void imx_shutdown(struct uart_port *port)
         struct imx_port *sport = (struct imx_port *)port;
         unsigned long temp;
 
+        temp = readl(sport->port.membase + UCR2);
+        temp &= ~(UCR2_TXEN);
+        writel(temp, sport->port.membase + UCR2);
+
+        if (USE_IRDA(sport)) {
+                struct imxuart_platform_data *pdata;
+                pdata = sport->port.dev->platform_data;
+                if (pdata->irda_enable)
+                        pdata->irda_enable(0);
+        }
+
         /*
          * Stop our timer.
          */
@@ -642,7 +789,8 @@ static void imx_shutdown(struct uart_port *port)
          * Free the interrupts
          */
         if (sport->txirq > 0) {
-                free_irq(sport->rtsirq, sport);
+                if (!USE_IRDA(sport))
+                        free_irq(sport->rtsirq, sport);
                 free_irq(sport->txirq, sport);
                 free_irq(sport->rxirq, sport);
         } else
@@ -654,6 +802,9 @@ static void imx_shutdown(struct uart_port *port)
 
         temp = readl(sport->port.membase + UCR1);
         temp &= ~(UCR1_TXMPTYEN | UCR1_RRDYEN | UCR1_RTSDEN | UCR1_UARTEN);
+        if (USE_IRDA(sport))
+                temp &= ~(UCR1_IREN);
+
         writel(temp, sport->port.membase + UCR1);
 }
 
@@ -665,7 +816,9 @@ imx_set_termios(struct uart_port *port, struct ktermios *termios,
         unsigned long flags;
         unsigned int ucr2, old_ucr1, old_txrxen, baud, quot;
         unsigned int old_csize = old ? old->c_cflag & CSIZE : CS8;
-        unsigned int div, num, denom, ufcr;
+        unsigned int div, ufcr;
+        unsigned long num, denom;
+        uint64_t tdiv64;
 
         /*
          * If we don't support modem control lines, don't allow
@@ -761,38 +914,39 @@ imx_set_termios(struct uart_port *port, struct ktermios *termios,
                         sport->port.membase + UCR2);
         old_txrxen &= (UCR2_TXEN | UCR2_RXEN);
 
-        div = sport->port.uartclk / (baud * 16);
-        if (div > 7)
-                div = 7;
-        if (!div)
+        if (USE_IRDA(sport)) {
+                /*
+                 * use maximum available submodule frequency to
+                 * avoid missing short pulses due to low sampling rate
+                 */
                 div = 1;
-
-        num = baud;
-        denom = port->uartclk / div / 16;
-
-        /* shift num and denom right until they fit into 16 bits */
-        while (num > 0x10000 || denom > 0x10000) {
-                num >>= 1;
-                denom >>= 1;
+        } else {
+                div = sport->port.uartclk / (baud * 16);
+                if (div > 7)
+                        div = 7;
+                if (!div)
+                        div = 1;
         }
-        if (num > 0)
-                num -= 1;
-        if (denom > 0)
-                denom -= 1;
 
-        writel(num, sport->port.membase + UBIR);
-        writel(denom, sport->port.membase + UBMR);
+        rational_best_approximation(16 * div * baud, sport->port.uartclk,
+                1 << 16, 1 << 16, &num, &denom);
 
-        if (div == 7)
-                div = 6; /* 6 in RFDIV means divide by 7 */
-        else
-                div = 6 - div;
+        tdiv64 = sport->port.uartclk;
+        tdiv64 *= num;
+        do_div(tdiv64, denom * 16 * div);
+        tty_encode_baud_rate(sport->port.info->port.tty,
+                (speed_t)tdiv64, (speed_t)tdiv64);
+
+        num -= 1;
+        denom -= 1;
 
         ufcr = readl(sport->port.membase + UFCR);
-        ufcr = (ufcr & (~UFCR_RFDIV)) |
-            (div << 7);
+        ufcr = (ufcr & (~UFCR_RFDIV)) | UFCR_RFDIV_REG(div);
         writel(ufcr, sport->port.membase + UFCR);
 
+        writel(num, sport->port.membase + UBIR);
+        writel(denom, sport->port.membase + UBMR);
+
 #ifdef ONEMS
         writel(sport->port.uartclk / div / 1000, sport->port.membase + ONEMS);
 #endif
@@ -1072,22 +1226,22 @@ static struct uart_driver imx_reg = {
 
 static int serial_imx_suspend(struct platform_device *dev, pm_message_t state)
 {
-        struct imx_port *sport = platform_get_drvdata(dev);
+        struct imx_port *sport = platform_get_drvdata(dev);
 
-        if (sport)
-                uart_suspend_port(&imx_reg, &sport->port);
+        if (sport)
+                uart_suspend_port(&imx_reg, &sport->port);
 
-        return 0;
+        return 0;
 }
 
 static int serial_imx_resume(struct platform_device *dev)
 {
-        struct imx_port *sport = platform_get_drvdata(dev);
+        struct imx_port *sport = platform_get_drvdata(dev);
 
-        if (sport)
-                uart_resume_port(&imx_reg, &sport->port);
+        if (sport)
+                uart_resume_port(&imx_reg, &sport->port);
 
-        return 0;
+        return 0;
 }
 
 static int serial_imx_probe(struct platform_device *pdev)
@@ -1143,19 +1297,29 @@ static int serial_imx_probe(struct platform_device *pdev)
         imx_ports[pdev->id] = sport;
 
         pdata = pdev->dev.platform_data;
-        if(pdata && (pdata->flags & IMXUART_HAVE_RTSCTS))
+        if (pdata && (pdata->flags & IMXUART_HAVE_RTSCTS))
                 sport->have_rtscts = 1;
 
+#ifdef CONFIG_IRDA
+        if (pdata && (pdata->flags & IMXUART_IRDA))
+                sport->use_irda = 1;
+#endif
+
         if (pdata->init) {
                 ret = pdata->init(pdev);
                 if (ret)
                         goto clkput;
         }
 
-        uart_add_one_port(&imx_reg, &sport->port);
+        ret = uart_add_one_port(&imx_reg, &sport->port);
+        if (ret)
+                goto deinit;
         platform_set_drvdata(pdev, &sport->port);
 
         return 0;
+deinit:
+        if (pdata->exit)
+                pdata->exit(pdev);
 clkput:
         clk_put(sport->clk);
         clk_disable(sport->clk);
@@ -1193,13 +1357,13 @@ static int serial_imx_remove(struct platform_device *pdev)
 }
 
 static struct platform_driver serial_imx_driver = {
-        .probe          = serial_imx_probe,
-        .remove         = serial_imx_remove,
+        .probe          = serial_imx_probe,
+        .remove         = serial_imx_remove,
 
         .suspend        = serial_imx_suspend,
         .resume         = serial_imx_resume,
         .driver         = {
-                .name   = "imx-uart",
+                .name   = "imx-uart",
                 .owner  = THIS_MODULE,
         },
 };
diff --git a/drivers/serial/jsm/jsm.h b/drivers/serial/jsm/jsm.h
index c0a3e2734e24..4e5f3bde0461 100644
--- a/drivers/serial/jsm/jsm.h
+++ b/drivers/serial/jsm/jsm.h
@@ -61,6 +61,7 @@ enum {
         if ((DBG_##nlevel & jsm_debug))                 \
         dev_printk(KERN_##klevel, pdev->dev, fmt, ## args)
 
+#define MAXLINES        256
 #define MAXPORTS        8
 #define MAX_STOPS_SENT  5
 
diff --git a/drivers/serial/jsm/jsm_tty.c b/drivers/serial/jsm/jsm_tty.c
index 31496dc0a0d1..107ce2e187b8 100644
--- a/drivers/serial/jsm/jsm_tty.c
+++ b/drivers/serial/jsm/jsm_tty.c
@@ -33,6 +33,8 @@
 
 #include "jsm.h"
 
+static DECLARE_BITMAP(linemap, MAXLINES);
+
 static void jsm_carrier(struct jsm_channel *ch);
 
 static inline int jsm_get_mstat(struct jsm_channel *ch)
@@ -433,6 +435,7 @@ int __devinit jsm_tty_init(struct jsm_board *brd)
 int __devinit jsm_uart_port_init(struct jsm_board *brd)
 {
         int i;
+        unsigned int line;
         struct jsm_channel *ch;
 
         if (!brd)
@@ -459,9 +462,15 @@ int __devinit jsm_uart_port_init(struct jsm_board *brd)
                 brd->channels[i]->uart_port.membase = brd->re_map_membase;
                 brd->channels[i]->uart_port.fifosize = 16;
                 brd->channels[i]->uart_port.ops = &jsm_ops;
-                brd->channels[i]->uart_port.line = brd->channels[i]->ch_portnum + brd->boardnum * 2;
+                line = find_first_zero_bit(linemap, MAXLINES);
+                if (line >= MAXLINES) {
+                        printk(KERN_INFO "jsm: linemap is full, added device failed\n");
+                        continue;
+                } else
+                        set_bit((int)line, linemap);
+                brd->channels[i]->uart_port.line = line;
                 if (uart_add_one_port (&jsm_uart_driver, &brd->channels[i]->uart_port))
-                        printk(KERN_INFO "Added device failed\n");
+                        printk(KERN_INFO "jsm: add device failed\n");
                 else
                         printk(KERN_INFO "Added device \n");
         }
@@ -494,6 +503,7 @@ int jsm_remove_uart_port(struct jsm_board *brd)
 
                 ch = brd->channels[i];
 
+                clear_bit((int)(ch->uart_port.line), linemap);
                 uart_remove_one_port(&jsm_uart_driver, &brd->channels[i]->uart_port);
         }
 
diff --git a/drivers/serial/sh-sci.c b/drivers/serial/sh-sci.c
index dbf5357a77b3..a4cf1079b312 100644
--- a/drivers/serial/sh-sci.c
+++ b/drivers/serial/sh-sci.c
@@ -47,12 +47,17 @@
 #include <linux/clk.h>
 #include <linux/ctype.h>
 #include <linux/err.h>
+#include <linux/list.h>
 
 #ifdef CONFIG_SUPERH
 #include <asm/clock.h>
 #include <asm/sh_bios.h>
 #endif
 
+#ifdef CONFIG_H8300
+#include <asm/gpio.h>
+#endif
+
 #include "sh-sci.h"
 
 struct sci_port {
@@ -75,14 +80,22 @@ struct sci_port {
         int                     break_flag;
 
 #ifdef CONFIG_HAVE_CLK
-        /* Port clock */
-        struct clk              *clk;
+        /* Interface clock */
+        struct clk              *iclk;
+        /* Data clock */
+        struct clk              *dclk;
 #endif
+        struct list_head        node;
 };
 
-#ifdef CONFIG_SERIAL_SH_SCI_CONSOLE
-static struct sci_port *serial_console_port;
+struct sh_sci_priv {
+        spinlock_t lock;
+        struct list_head ports;
+
+#ifdef CONFIG_HAVE_CLK
+        struct notifier_block clk_nb;
 #endif
+};
 
 /* Function prototypes */
 static void sci_stop_tx(struct uart_port *port);
@@ -138,9 +151,8 @@ static void sci_poll_put_char(struct uart_port *port, unsigned char c)
                 status = sci_in(port, SCxSR);
         } while (!(status & SCxSR_TDxE(port)));
 
-        sci_in(port, SCxSR);            /* Dummy read */
-        sci_out(port, SCxSR, SCxSR_TDxE_CLEAR(port) & ~SCxSR_TEND(port));
         sci_out(port, SCxTDR, c);
+        sci_out(port, SCxSR, SCxSR_TDxE_CLEAR(port) & ~SCxSR_TEND(port));
 }
 #endif /* CONFIG_CONSOLE_POLL || CONFIG_SERIAL_SH_SCI_CONSOLE */
 
@@ -159,12 +171,12 @@ static void h8300_sci_config(struct uart_port *port, unsigned int ctrl)
                 *mstpcrl &= ~mask;
 }
 
-static inline void h8300_sci_enable(struct uart_port *port)
+static void h8300_sci_enable(struct uart_port *port)
 {
         h8300_sci_config(port, sci_enable);
 }
 
-static inline void h8300_sci_disable(struct uart_port *port)
+static void h8300_sci_disable(struct uart_port *port)
 {
         h8300_sci_config(port, sci_disable);
 }
@@ -611,7 +623,7 @@ static inline int sci_handle_breaks(struct uart_port *port)
         int copied = 0;
         unsigned short status = sci_in(port, SCxSR);
         struct tty_struct *tty = port->info->port.tty;
-        struct sci_port *s = &sci_ports[port->line];
+        struct sci_port *s = to_sci_port(port);
 
         if (uart_handle_break(port))
                 return 0;
@@ -726,19 +738,43 @@ static irqreturn_t sci_mpxed_interrupt(int irq, void *ptr)
 static int sci_notifier(struct notifier_block *self,
                         unsigned long phase, void *p)
 {
-        int i;
+        struct sh_sci_priv *priv = container_of(self,
+                                                struct sh_sci_priv, clk_nb);
+        struct sci_port *sci_port;
+        unsigned long flags;
 
         if ((phase == CPUFREQ_POSTCHANGE) ||
-            (phase == CPUFREQ_RESUMECHANGE))
-                for (i = 0; i < SCI_NPORTS; i++) {
-                        struct sci_port *s = &sci_ports[i];
-                        s->port.uartclk = clk_get_rate(s->clk);
-                }
+            (phase == CPUFREQ_RESUMECHANGE)) {
+                spin_lock_irqsave(&priv->lock, flags);
+                list_for_each_entry(sci_port, &priv->ports, node)
+                        sci_port->port.uartclk = clk_get_rate(sci_port->dclk);
+
+                spin_unlock_irqrestore(&priv->lock, flags);
+        }
 
         return NOTIFY_OK;
 }
 
-static struct notifier_block sci_nb = { &sci_notifier, NULL, 0 };
+static void sci_clk_enable(struct uart_port *port)
+{
+        struct sci_port *sci_port = to_sci_port(port);
+
+        clk_enable(sci_port->dclk);
+        sci_port->port.uartclk = clk_get_rate(sci_port->dclk);
+
+        if (sci_port->iclk)
+                clk_enable(sci_port->iclk);
+}
+
+static void sci_clk_disable(struct uart_port *port)
+{
+        struct sci_port *sci_port = to_sci_port(port);
+
+        if (sci_port->iclk)
+                clk_disable(sci_port->iclk);
+
+        clk_disable(sci_port->dclk);
+}
 #endif
 
 static int sci_request_irq(struct sci_port *port)
@@ -865,15 +901,11 @@ static void sci_break_ctl(struct uart_port *port, int break_state)
 
 static int sci_startup(struct uart_port *port)
 {
-        struct sci_port *s = &sci_ports[port->line];
+        struct sci_port *s = to_sci_port(port);
 
         if (s->enable)
                 s->enable(port);
 
-#ifdef CONFIG_HAVE_CLK
-        s->clk = clk_get(NULL, "module_clk");
-#endif
-
         sci_request_irq(s);
         sci_start_tx(port);
         sci_start_rx(port, 1);
@@ -883,7 +915,7 @@ static int sci_startup(struct uart_port *port)
 
 static void sci_shutdown(struct uart_port *port)
 {
-        struct sci_port *s = &sci_ports[port->line];
+        struct sci_port *s = to_sci_port(port);
 
         sci_stop_rx(port);
         sci_stop_tx(port);
@@ -891,11 +923,6 @@ static void sci_shutdown(struct uart_port *port)
 
         if (s->disable)
                 s->disable(port);
-
-#ifdef CONFIG_HAVE_CLK
-        clk_put(s->clk);
-        s->clk = NULL;
-#endif
 }
 
 static void sci_set_termios(struct uart_port *port, struct ktermios *termios,
@@ -980,25 +1007,31 @@ static int sci_request_port(struct uart_port *port)
 
 static void sci_config_port(struct uart_port *port, int flags)
 {
-        struct sci_port *s = &sci_ports[port->line];
+        struct sci_port *s = to_sci_port(port);
 
         port->type = s->type;
 
-        if (port->flags & UPF_IOREMAP && !port->membase) {
-#if defined(CONFIG_SUPERH64)
-                port->mapbase = onchip_remap(SCIF_ADDR_SH5, 1024, "SCIF");
-                port->membase = (void __iomem *)port->mapbase;
-#else
+        if (port->membase)
+                return;
+
+        if (port->flags & UPF_IOREMAP) {
                 port->membase = ioremap_nocache(port->mapbase, 0x40);
-#endif
 
-                dev_err(port->dev, "can't remap port#%d\n", port->line);
+                if (IS_ERR(port->membase))
+                        dev_err(port->dev, "can't remap port#%d\n", port->line);
+        } else {
+                /*
+                 * For the simple (and majority of) cases where we don't
+                 * need to do any remapping, just cast the cookie
+                 * directly.
+                 */
+                port->membase = (void __iomem *)port->mapbase;
         }
 }
 
 static int sci_verify_port(struct uart_port *port, struct serial_struct *ser)
 {
-        struct sci_port *s = &sci_ports[port->line];
+        struct sci_port *s = to_sci_port(port);
 
         if (ser->irq != s->irqs[SCIx_TXI_IRQ] || ser->irq > nr_irqs)
                 return -EINVAL;
@@ -1032,63 +1065,60 @@ static struct uart_ops sci_uart_ops = {
 #endif
 };
 
-static void __init sci_init_ports(void)
+static void __devinit sci_init_single(struct platform_device *dev,
+                                      struct sci_port *sci_port,
+                                      unsigned int index,
+                                      struct plat_sci_port *p)
 {
-        static int first = 1;
-        int i;
-
-        if (!first)
-                return;
-
-        first = 0;
-
-        for (i = 0; i < SCI_NPORTS; i++) {
-                sci_ports[i].port.ops           = &sci_uart_ops;
-                sci_ports[i].port.iotype        = UPIO_MEM;
-                sci_ports[i].port.line          = i;
-                sci_ports[i].port.fifosize      = 1;
+        sci_port->port.ops      = &sci_uart_ops;
+        sci_port->port.iotype   = UPIO_MEM;
+        sci_port->port.line     = index;
+        sci_port->port.fifosize = 1;
 
 #if defined(__H8300H__) || defined(__H8300S__)
 #ifdef __H8300S__
-                sci_ports[i].enable     = h8300_sci_enable;
-                sci_ports[i].disable    = h8300_sci_disable;
+        sci_port->enable        = h8300_sci_enable;
+        sci_port->disable       = h8300_sci_disable;
 #endif
-                sci_ports[i].port.uartclk = CONFIG_CPU_CLOCK;
+        sci_port->port.uartclk  = CONFIG_CPU_CLOCK;
 #elif defined(CONFIG_HAVE_CLK)
-                /*
-                 * XXX: We should use a proper SCI/SCIF clock
-                 */
-                {
-                        struct clk *clk = clk_get(NULL, "module_clk");
-                        sci_ports[i].port.uartclk = clk_get_rate(clk);
-                        clk_put(clk);
-                }
+        sci_port->iclk          = p->clk ? clk_get(&dev->dev, p->clk) : NULL;
+        sci_port->dclk          = clk_get(&dev->dev, "peripheral_clk");
+        sci_port->enable        = sci_clk_enable;
+        sci_port->disable       = sci_clk_disable;
 #else
 #error "Need a valid uartclk"
 #endif
 
-                sci_ports[i].break_timer.data = (unsigned long)&sci_ports[i];
-                sci_ports[i].break_timer.function = sci_break_timer;
+        sci_port->break_timer.data = (unsigned long)sci_port;
+        sci_port->break_timer.function = sci_break_timer;
+        init_timer(&sci_port->break_timer);
 
-                init_timer(&sci_ports[i].break_timer);
-        }
-}
-
-int __init early_sci_setup(struct uart_port *port)
-{
-        if (unlikely(port->line > SCI_NPORTS))
-                return -ENODEV;
+        sci_port->port.mapbase  = p->mapbase;
+        sci_port->port.membase  = p->membase;
 
-        sci_init_ports();
+        sci_port->port.irq      = p->irqs[SCIx_TXI_IRQ];
+        sci_port->port.flags    = p->flags;
+        sci_port->port.dev      = &dev->dev;
+        sci_port->type          = sci_port->port.type = p->type;
 
-        sci_ports[port->line].port.membase      = port->membase;
-        sci_ports[port->line].port.mapbase      = port->mapbase;
-        sci_ports[port->line].port.type         = port->type;
+        memcpy(&sci_port->irqs, &p->irqs, sizeof(p->irqs));
 
-        return 0;
 }
 
 #ifdef CONFIG_SERIAL_SH_SCI_CONSOLE
+static struct tty_driver *serial_console_device(struct console *co, int *index)
+{
+        struct uart_driver *p = &sci_uart_driver;
+        *index = co->index;
+        return p->tty_driver;
+}
+
+static void serial_console_putchar(struct uart_port *port, int ch)
+{
+        sci_poll_put_char(port, ch);
+}
+
 /*
  *      Print a string to the serial port trying not to disturb
  *      any possible real use of the port...
@@ -1096,25 +1126,27 @@ int __init early_sci_setup(struct uart_port *port)
 static void serial_console_write(struct console *co, const char *s,
                                  unsigned count)
 {
-        struct uart_port *port = &serial_console_port->port;
+        struct uart_port *port = co->data;
+        struct sci_port *sci_port = to_sci_port(port);
         unsigned short bits;
-        int i;
 
-        for (i = 0; i < count; i++) {
-                if (*s == 10)
-                        sci_poll_put_char(port, '\r');
+        if (sci_port->enable)
+                sci_port->enable(port);
 
-                sci_poll_put_char(port, *s++);
-        }
+        uart_console_write(port, s, count, serial_console_putchar);
 
         /* wait until fifo is empty and last bit has been transmitted */
         bits = SCxSR_TDxE(port) | SCxSR_TEND(port);
         while ((sci_in(port, SCxSR) & bits) != bits)
                 cpu_relax();
+
+        if (sci_port->disable);
+                sci_port->disable(port);
 }
 
 static int __init serial_console_setup(struct console *co, char *options)
 {
+        struct sci_port *sci_port;
         struct uart_port *port;
         int baud = 115200;
         int bits = 8;
@@ -1130,8 +1162,9 @@ static int __init serial_console_setup(struct console *co, char *options)
         if (co->index >= SCI_NPORTS)
                 co->index = 0;
 
-        serial_console_port = &sci_ports[co->index];
-        port = &serial_console_port->port;
+        sci_port = &sci_ports[co->index];
+        port = &sci_port->port;
+        co->data = port;
 
         /*
          * Also need to check port->type, we don't actually have any
@@ -1141,21 +1174,11 @@ static int __init serial_console_setup(struct console *co, char *options)
          */
         if (!port->type)
                 return -ENODEV;
-        if (!port->membase || !port->mapbase)
-                return -ENODEV;
-
-        port->type = serial_console_port->type;
-
-#ifdef CONFIG_HAVE_CLK
-        if (!serial_console_port->clk)
-                serial_console_port->clk = clk_get(NULL, "module_clk");
-#endif
 
-        if (port->flags & UPF_IOREMAP)
-                sci_config_port(port, 0);
+        sci_config_port(port, 0);
 
-        if (serial_console_port->enable)
-                serial_console_port->enable(port);
+        if (sci_port->enable)
+                sci_port->enable(port);
 
         if (options)
                 uart_parse_options(options, &baud, &parity, &bits, &flow);
@@ -1166,22 +1189,21 @@ static int __init serial_console_setup(struct console *co, char *options)
         if (ret == 0)
                 sci_stop_rx(port);
 #endif
+        /* TODO: disable clock */
         return ret;
 }
 
 static struct console serial_console = {
         .name           = "ttySC",
-        .device         = uart_console_device,
+        .device         = serial_console_device,
         .write          = serial_console_write,
         .setup          = serial_console_setup,
         .flags          = CON_PRINTBUFFER,
         .index          = -1,
-        .data           = &sci_uart_driver,
 };
 
 static int __init sci_console_init(void)
 {
-        sci_init_ports();
         register_console(&serial_console);
         return 0;
 }
@@ -1207,6 +1229,61 @@ static struct uart_driver sci_uart_driver = {
         .cons           = SCI_CONSOLE,
 };
 
+
+static int sci_remove(struct platform_device *dev)
+{
+        struct sh_sci_priv *priv = platform_get_drvdata(dev);
+        struct sci_port *p;
+        unsigned long flags;
+
+#ifdef CONFIG_HAVE_CLK
+        cpufreq_unregister_notifier(&priv->clk_nb, CPUFREQ_TRANSITION_NOTIFIER);
+#endif
+
+        spin_lock_irqsave(&priv->lock, flags);
+        list_for_each_entry(p, &priv->ports, node)
+                uart_remove_one_port(&sci_uart_driver, &p->port);
+
+        spin_unlock_irqrestore(&priv->lock, flags);
+
+        kfree(priv);
+        return 0;
+}
+
+static int __devinit sci_probe_single(struct platform_device *dev,
+                                      unsigned int index,
+                                      struct plat_sci_port *p,
+                                      struct sci_port *sciport)
+{
+        struct sh_sci_priv *priv = platform_get_drvdata(dev);
+        unsigned long flags;
+        int ret;
+
+        /* Sanity check */
+        if (unlikely(index >= SCI_NPORTS)) {
+                dev_notice(&dev->dev, "Attempting to register port "
+                           "%d when only %d are available.\n",
+                           index+1, SCI_NPORTS);
+                dev_notice(&dev->dev, "Consider bumping "
+                           "CONFIG_SERIAL_SH_SCI_NR_UARTS!\n");
+                return 0;
+        }
+
+        sci_init_single(dev, sciport, index, p);
+
+        ret = uart_add_one_port(&sci_uart_driver, &sciport->port);
+        if (ret)
+                return ret;
+
+        INIT_LIST_HEAD(&sciport->node);
+
+        spin_lock_irqsave(&priv->lock, flags);
+        list_add(&sciport->node, &priv->ports);
+        spin_unlock_irqrestore(&priv->lock, flags);
+
+        return 0;
+}
+
 /*
  * Register a set of serial devices attached to a platform device.  The
  * list is terminated with a zero flags entry, which means we expect
@@ -1216,57 +1293,34 @@ static struct uart_driver sci_uart_driver = {
 static int __devinit sci_probe(struct platform_device *dev)
 {
         struct plat_sci_port *p = dev->dev.platform_data;
+        struct sh_sci_priv *priv;
         int i, ret = -EINVAL;
 
-        for (i = 0; p && p->flags != 0; p++, i++) {
-                struct sci_port *sciport = &sci_ports[i];
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
 
-                /* Sanity check */
-                if (unlikely(i == SCI_NPORTS)) {
-                        dev_notice(&dev->dev, "Attempting to register port "
-                                   "%d when only %d are available.\n",
-                                   i+1, SCI_NPORTS);
-                        dev_notice(&dev->dev, "Consider bumping "
-                                   "CONFIG_SERIAL_SH_SCI_NR_UARTS!\n");
-                        break;
-                }
+        INIT_LIST_HEAD(&priv->ports);
+        spin_lock_init(&priv->lock);
+        platform_set_drvdata(dev, priv);
 
-                sciport->port.mapbase   = p->mapbase;
+#ifdef CONFIG_HAVE_CLK
+        priv->clk_nb.notifier_call = sci_notifier;
+        cpufreq_register_notifier(&priv->clk_nb, CPUFREQ_TRANSITION_NOTIFIER);
+#endif
 
-                if (p->mapbase && !p->membase) {
-                        if (p->flags & UPF_IOREMAP) {
-                                p->membase = ioremap_nocache(p->mapbase, 0x40);
-                                if (IS_ERR(p->membase)) {
-                                        ret = PTR_ERR(p->membase);
-                                        goto err_unreg;
-                                }
-                        } else {
-                                /*
-                                 * For the simple (and majority of) cases
-                                 * where we don't need to do any remapping,
-                                 * just cast the cookie directly.
-                                 */
-                                p->membase = (void __iomem *)p->mapbase;
-                        }
+        if (dev->id != -1) {
+                ret = sci_probe_single(dev, dev->id, p, &sci_ports[dev->id]);
+                if (ret)
+                        goto err_unreg;
+        } else {
+                for (i = 0; p && p->flags != 0; p++, i++) {
+                        ret = sci_probe_single(dev, i, p, &sci_ports[i]);
+                        if (ret)
+                                goto err_unreg;
                 }
-
-                sciport->port.membase   = p->membase;
-
-                sciport->port.irq       = p->irqs[SCIx_TXI_IRQ];
-                sciport->port.flags     = p->flags;
-                sciport->port.dev       = &dev->dev;
-
-                sciport->type           = sciport->port.type = p->type;
-
-                memcpy(&sciport->irqs, &p->irqs, sizeof(p->irqs));
-
-                uart_add_one_port(&sci_uart_driver, &sciport->port);
         }
 
-#ifdef CONFIG_HAVE_CLK
-        cpufreq_register_notifier(&sci_nb, CPUFREQ_TRANSITION_NOTIFIER);
-#endif
-
 #ifdef CONFIG_SH_STANDARD_BIOS
         sh_bios_gdb_detach();
 #endif
@@ -1274,50 +1328,36 @@ static int __devinit sci_probe(struct platform_device *dev)
         return 0;
 
 err_unreg:
-        for (i = i - 1; i >= 0; i--)
-                uart_remove_one_port(&sci_uart_driver, &sci_ports[i].port);
-
+        sci_remove(dev);
         return ret;
 }
 
-static int __devexit sci_remove(struct platform_device *dev)
-{
-        int i;
-
-#ifdef CONFIG_HAVE_CLK
-        cpufreq_unregister_notifier(&sci_nb, CPUFREQ_TRANSITION_NOTIFIER);
-#endif
-
-        for (i = 0; i < SCI_NPORTS; i++)
-                uart_remove_one_port(&sci_uart_driver, &sci_ports[i].port);
-
-        return 0;
-}
-
 static int sci_suspend(struct platform_device *dev, pm_message_t state)
 {
-        int i;
+        struct sh_sci_priv *priv = platform_get_drvdata(dev);
+        struct sci_port *p;
+        unsigned long flags;
 
-        for (i = 0; i < SCI_NPORTS; i++) {
-                struct sci_port *p = &sci_ports[i];
+        spin_lock_irqsave(&priv->lock, flags);
+        list_for_each_entry(p, &priv->ports, node)
+                uart_suspend_port(&sci_uart_driver, &p->port);
 
-                if (p->type != PORT_UNKNOWN && p->port.dev == &dev->dev)
-                        uart_suspend_port(&sci_uart_driver, &p->port);
-        }
+        spin_unlock_irqrestore(&priv->lock, flags);
 
         return 0;
 }
 
 static int sci_resume(struct platform_device *dev)
 {
-        int i;
+        struct sh_sci_priv *priv = platform_get_drvdata(dev);
+        struct sci_port *p;
+        unsigned long flags;
 
-        for (i = 0; i < SCI_NPORTS; i++) {
-                struct sci_port *p = &sci_ports[i];
+        spin_lock_irqsave(&priv->lock, flags);
+        list_for_each_entry(p, &priv->ports, node)
+                uart_resume_port(&sci_uart_driver, &p->port);
 
-                if (p->type != PORT_UNKNOWN && p->port.dev == &dev->dev)
-                        uart_resume_port(&sci_uart_driver, &p->port);
-        }
+        spin_unlock_irqrestore(&priv->lock, flags);
 
         return 0;
 }
@@ -1339,8 +1379,6 @@ static int __init sci_init(void)
 
         printk(banner);
 
-        sci_init_ports();
-
         ret = uart_register_driver(&sci_uart_driver);
         if (likely(ret == 0)) {
                 ret = platform_driver_register(&sci_driver);
diff --git a/drivers/serial/sh-sci.h b/drivers/serial/sh-sci.h
index d0aa82d7fce0..38072c15b845 100644
--- a/drivers/serial/sh-sci.h
+++ b/drivers/serial/sh-sci.h
@@ -91,6 +91,9 @@
 # define SCSPTR5                0xa4050128
 # define SCIF_ORER              0x0001  /* overrun error bit */
 # define SCSCR_INIT(port)       0x0038  /* TIE=0,RIE=0,TE=1,RE=1,REIE=1 */
+#elif defined(CONFIG_CPU_SUBTYPE_SH7724)
+# define SCIF_ORER              0x0001  /* overrun error bit */
+# define SCSCR_INIT(port)       0x0038  /* TIE=0,RIE=0,TE=1,RE=1,REIE=1 */
 #elif defined(CONFIG_CPU_SUBTYPE_SH4_202)
 # define SCSPTR2 0xffe80020 /* 16 bit SCIF */
 # define SCIF_ORER 0x0001   /* overrun error bit */
@@ -314,7 +317,18 @@
     }                                                                   \
   }
 
-#define CPU_SCIF_FNS(name, scif_offset, scif_size)                              \
+#ifdef CONFIG_H8300
+/* h8300 don't have SCIF */
+#define CPU_SCIF_FNS(name)                                              \
+  static inline unsigned int sci_##name##_in(struct uart_port *port)    \
+  {                                                                     \
+    return 0;                                                           \
+  }                                                                     \
+  static inline void sci_##name##_out(struct uart_port *port, unsigned int value) \
+  {                                                                     \
+  }
+#else
+#define CPU_SCIF_FNS(name, scif_offset, scif_size)                      \
   static inline unsigned int sci_##name##_in(struct uart_port *port)    \
   {                                                                     \
     SCI_IN(scif_size, scif_offset);                                     \
@@ -323,6 +337,7 @@
   {                                                                     \
     SCI_OUT(scif_size, scif_offset, value);                             \
   }
+#endif
 
 #define CPU_SCI_FNS(name, sci_offset, sci_size)                         \
   static inline unsigned int sci_##name##_in(struct uart_port* port)    \
@@ -360,8 +375,10 @@
                  sh3_scif_offset, sh3_scif_size, sh4_scif_offset, sh4_scif_size, \
                  h8_sci_offset, h8_sci_size) \
   CPU_SCI_FNS(name, h8_sci_offset, h8_sci_size)
-#define SCIF_FNS(name, sh3_scif_offset, sh3_scif_size, sh4_scif_offset, sh4_scif_size)
-#elif defined(CONFIG_CPU_SUBTYPE_SH7723)
+#define SCIF_FNS(name, sh3_scif_offset, sh3_scif_size, sh4_scif_offset, sh4_scif_size) \
+  CPU_SCIF_FNS(name)
+#elif defined(CONFIG_CPU_SUBTYPE_SH7723) ||\
+      defined(CONFIG_CPU_SUBTYPE_SH7724)
         #define SCIx_FNS(name, sh4_scifa_offset, sh4_scifa_size, sh4_scif_offset, sh4_scif_size) \
                 CPU_SCIx_FNS(name, sh4_scifa_offset, sh4_scifa_size, sh4_scif_offset, sh4_scif_size)
         #define SCIF_FNS(name, sh4_scif_offset, sh4_scif_size) \
@@ -390,7 +407,8 @@ SCIF_FNS(SCFDR,  0x1c, 16)
 SCIF_FNS(SCxTDR, 0x20,  8)
 SCIF_FNS(SCxRDR, 0x24,  8)
 SCIF_FNS(SCLSR,  0x24, 16)
-#elif defined(CONFIG_CPU_SUBTYPE_SH7723)
+#elif defined(CONFIG_CPU_SUBTYPE_SH7723) ||\
+      defined(CONFIG_CPU_SUBTYPE_SH7724)
 SCIx_FNS(SCSMR,  0x00, 16, 0x00, 16)
 SCIx_FNS(SCBRR,  0x04,  8, 0x04,  8)
 SCIx_FNS(SCSCR,  0x08, 16, 0x08, 16)
@@ -604,10 +622,21 @@ static inline int sci_rxd_in(struct uart_port *port)
                 return ctrl_inb(SCSPTR5) & 0x0008 ? 1 : 0; /* SCIF5 */
         return 1;
 }
+#elif defined(CONFIG_CPU_SUBTYPE_SH7724)
+#  define SCFSR    0x0010
+#  define SCASSR   0x0014
+static inline int sci_rxd_in(struct uart_port *port)
+{
+        if (port->type == PORT_SCIF)
+                return ctrl_inw((port->mapbase + SCFSR))  & SCIF_BRK ? 1 : 0;
+        if (port->type == PORT_SCIFA)
+                return ctrl_inw((port->mapbase + SCASSR)) & SCIF_BRK ? 1 : 0;
+        return 1;
+}
 #elif defined(CONFIG_CPU_SUBTYPE_SH5_101) || defined(CONFIG_CPU_SUBTYPE_SH5_103)
 static inline int sci_rxd_in(struct uart_port *port)
 {
-         return sci_in(port, SCSPTR2)&0x0001 ? 1 : 0; /* SCIF */
+         return sci_in(port, SCSPTR)&0x0001 ? 1 : 0; /* SCIF */
 }
 #elif defined(__H8300H__) || defined(__H8300S__)
 static inline int sci_rxd_in(struct uart_port *port)
@@ -757,7 +786,8 @@ static inline int sci_rxd_in(struct uart_port *port)
       defined(CONFIG_CPU_SUBTYPE_SH7720) || \
       defined(CONFIG_CPU_SUBTYPE_SH7721)
 #define SCBRR_VALUE(bps, clk) (((clk*2)+16*bps)/(32*bps)-1)
-#elif defined(CONFIG_CPU_SUBTYPE_SH7723)
+#elif defined(CONFIG_CPU_SUBTYPE_SH7723) ||\
+      defined(CONFIG_CPU_SUBTYPE_SH7724)
 static inline int scbrr_calc(struct uart_port *port, int bps, int clk)
 {
         if (port->type == PORT_SCIF)
diff --git a/drivers/serial/timbuart.c b/drivers/serial/timbuart.c
new file mode 100644
index 000000000000..ac9e5d5f742e
--- /dev/null
+++ b/drivers/serial/timbuart.c
@@ -0,0 +1,526 @@
+/*
+ * timbuart.c timberdale FPGA UART driver
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * Timberdale FPGA UART
+ */
+
+#include <linux/pci.h>
+#include <linux/interrupt.h>
+#include <linux/serial_core.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/ioport.h>
+
+#include "timbuart.h"
+
+struct timbuart_port {
+        struct uart_port        port;
+        struct tasklet_struct   tasklet;
+        int                     usedma;
+        u8                      last_ier;
+        struct platform_device  *dev;
+};
+
+static int baudrates[] = {9600, 19200, 38400, 57600, 115200, 230400, 460800,
+        921600, 1843200, 3250000};
+
+static void timbuart_mctrl_check(struct uart_port *port, u8 isr, u8 *ier);
+
+static irqreturn_t timbuart_handleinterrupt(int irq, void *devid);
+
+static void timbuart_stop_rx(struct uart_port *port)
+{
+        /* spin lock held by upper layer, disable all RX interrupts */
+        u8 ier = ioread8(port->membase + TIMBUART_IER) & ~RXFLAGS;
+        iowrite8(ier, port->membase + TIMBUART_IER);
+}
+
+static void timbuart_stop_tx(struct uart_port *port)
+{
+        /* spinlock held by upper layer, disable TX interrupt */
+        u8 ier = ioread8(port->membase + TIMBUART_IER) & ~TXBAE;
+        iowrite8(ier, port->membase + TIMBUART_IER);
+}
+
+static void timbuart_start_tx(struct uart_port *port)
+{
+        struct timbuart_port *uart =
+                container_of(port, struct timbuart_port, port);
+
+        /* do not transfer anything here -> fire off the tasklet */
+        tasklet_schedule(&uart->tasklet);
+}
+
+static void timbuart_flush_buffer(struct uart_port *port)
+{
+        u8 ctl = ioread8(port->membase + TIMBUART_CTRL) | TIMBUART_CTRL_FLSHTX;
+
+        iowrite8(ctl, port->membase + TIMBUART_CTRL);
+        iowrite8(TXBF, port->membase + TIMBUART_ISR);
+}
+
+static void timbuart_rx_chars(struct uart_port *port)
+{
+        struct tty_struct *tty = port->info->port.tty;
+
+        while (ioread8(port->membase + TIMBUART_ISR) & RXDP) {
+                u8 ch = ioread8(port->membase + TIMBUART_RXFIFO);
+                port->icount.rx++;
+                tty_insert_flip_char(tty, ch, TTY_NORMAL);
+        }
+
+        spin_unlock(&port->lock);
+        tty_flip_buffer_push(port->info->port.tty);
+        spin_lock(&port->lock);
+
+        dev_dbg(port->dev, "%s - total read %d bytes\n",
+                __func__, port->icount.rx);
+}
+
+static void timbuart_tx_chars(struct uart_port *port)
+{
+        struct circ_buf *xmit = &port->info->xmit;
+
+        while (!(ioread8(port->membase + TIMBUART_ISR) & TXBF) &&
+                !uart_circ_empty(xmit)) {
+                iowrite8(xmit->buf[xmit->tail],
+                        port->membase + TIMBUART_TXFIFO);
+                xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
+                port->icount.tx++;
+        }
+
+        dev_dbg(port->dev,
+                "%s - total written %d bytes, CTL: %x, RTS: %x, baud: %x\n",
+                 __func__,
+                port->icount.tx,
+                ioread8(port->membase + TIMBUART_CTRL),
+                port->mctrl & TIOCM_RTS,
+                ioread8(port->membase + TIMBUART_BAUDRATE));
+}
+
+static void timbuart_handle_tx_port(struct uart_port *port, u8 isr, u8 *ier)
+{
+        struct timbuart_port *uart =
+                container_of(port, struct timbuart_port, port);
+        struct circ_buf *xmit = &port->info->xmit;
+
+        if (uart_circ_empty(xmit) || uart_tx_stopped(port))
+                return;
+
+        if (port->x_char)
+                return;
+
+        if (isr & TXFLAGS) {
+                timbuart_tx_chars(port);
+                /* clear all TX interrupts */
+                iowrite8(TXFLAGS, port->membase + TIMBUART_ISR);
+
+                if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
+                        uart_write_wakeup(port);
+        } else
+                /* Re-enable any tx interrupt */
+                *ier |= uart->last_ier & TXFLAGS;
+
+        /* enable interrupts if there are chars in the transmit buffer,
+         * Or if we delivered some bytes and want the almost empty interrupt
+         * we wake up the upper layer later when we got the interrupt
+         * to give it some time to go out...
+         */
+        if (!uart_circ_empty(xmit))
+                *ier |= TXBAE;
+
+        dev_dbg(port->dev, "%s - leaving\n", __func__);
+}
+
+void timbuart_handle_rx_port(struct uart_port *port, u8 isr, u8 *ier)
+{
+        if (isr & RXFLAGS) {
+                /* Some RX status is set */
+                if (isr & RXBF) {
+                        u8 ctl = ioread8(port->membase + TIMBUART_CTRL) |
+                                TIMBUART_CTRL_FLSHRX;
+                        iowrite8(ctl, port->membase + TIMBUART_CTRL);
+                        port->icount.overrun++;
+                } else if (isr & (RXDP))
+                        timbuart_rx_chars(port);
+
+                /* ack all RX interrupts */
+                iowrite8(RXFLAGS, port->membase + TIMBUART_ISR);
+        }
+
+        /* always have the RX interrupts enabled */
+        *ier |= RXBAF | RXBF | RXTT;
+
+        dev_dbg(port->dev, "%s - leaving\n", __func__);
+}
+
+void timbuart_tasklet(unsigned long arg)
+{
+        struct timbuart_port *uart = (struct timbuart_port *)arg;
+        u8 isr, ier = 0;
+
+        spin_lock(&uart->port.lock);
+
+        isr = ioread8(uart->port.membase + TIMBUART_ISR);
+        dev_dbg(uart->port.dev, "%s ISR: %x\n", __func__, isr);
+
+        if (!uart->usedma)
+                timbuart_handle_tx_port(&uart->port, isr, &ier);
+
+        timbuart_mctrl_check(&uart->port, isr, &ier);
+
+        if (!uart->usedma)
+                timbuart_handle_rx_port(&uart->port, isr, &ier);
+
+        iowrite8(ier, uart->port.membase + TIMBUART_IER);
+
+        spin_unlock(&uart->port.lock);
+        dev_dbg(uart->port.dev, "%s leaving\n", __func__);
+}
+
+static unsigned int timbuart_tx_empty(struct uart_port *port)
+{
+        u8 isr = ioread8(port->membase + TIMBUART_ISR);
+
+        return (isr & TXBAE) ? TIOCSER_TEMT : 0;
+}
+
+static unsigned int timbuart_get_mctrl(struct uart_port *port)
+{
+        u8 cts = ioread8(port->membase + TIMBUART_CTRL);
+        dev_dbg(port->dev, "%s - cts %x\n", __func__, cts);
+
+        if (cts & TIMBUART_CTRL_CTS)
+                return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
+        else
+                return TIOCM_DSR | TIOCM_CAR;
+}
+
+static void timbuart_set_mctrl(struct uart_port *port, unsigned int mctrl)
+{
+        dev_dbg(port->dev, "%s - %x\n", __func__, mctrl);
+
+        if (mctrl & TIOCM_RTS)
+                iowrite8(TIMBUART_CTRL_RTS, port->membase + TIMBUART_CTRL);
+        else
+                iowrite8(TIMBUART_CTRL_RTS, port->membase + TIMBUART_CTRL);
+}
+
+static void timbuart_mctrl_check(struct uart_port *port, u8 isr, u8 *ier)
+{
+        unsigned int cts;
+
+        if (isr & CTS_DELTA) {
+                /* ack */
+                iowrite8(CTS_DELTA, port->membase + TIMBUART_ISR);
+                cts = timbuart_get_mctrl(port);
+                uart_handle_cts_change(port, cts & TIOCM_CTS);
+                wake_up_interruptible(&port->info->delta_msr_wait);
+        }
+
+        *ier |= CTS_DELTA;
+}
+
+static void timbuart_enable_ms(struct uart_port *port)
+{
+        /* N/A */
+}
+
+static void timbuart_break_ctl(struct uart_port *port, int ctl)
+{
+        /* N/A */
+}
+
+static int timbuart_startup(struct uart_port *port)
+{
+        struct timbuart_port *uart =
+                container_of(port, struct timbuart_port, port);
+
+        dev_dbg(port->dev, "%s\n", __func__);
+
+        iowrite8(TIMBUART_CTRL_FLSHRX, port->membase + TIMBUART_CTRL);
+        iowrite8(0xff, port->membase + TIMBUART_ISR);
+        /* Enable all but TX interrupts */
+        iowrite8(RXBAF | RXBF | RXTT | CTS_DELTA,
+                port->membase + TIMBUART_IER);
+
+        return request_irq(port->irq, timbuart_handleinterrupt, IRQF_SHARED,
+                "timb-uart", uart);
+}
+
+static void timbuart_shutdown(struct uart_port *port)
+{
+        struct timbuart_port *uart =
+                container_of(port, struct timbuart_port, port);
+        dev_dbg(port->dev, "%s\n", __func__);
+        free_irq(port->irq, uart);
+        iowrite8(0, port->membase + TIMBUART_IER);
+}
+
+static int get_bindex(int baud)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(baudrates); i++)
+                if (baud <= baudrates[i])
+                        return i;
+
+        return -1;
+}
+
+static void timbuart_set_termios(struct uart_port *port,
+        struct ktermios *termios,
+        struct ktermios *old)
+{
+        unsigned int baud;
+        short bindex;
+        unsigned long flags;
+
+        baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk / 16);
+        bindex = get_bindex(baud);
+        dev_dbg(port->dev, "%s - bindex %d\n", __func__, bindex);
+
+        if (bindex < 0)
+                bindex = 0;
+        baud = baudrates[bindex];
+
+        /* The serial layer calls into this once with old = NULL when setting
+           up initially */
+        if (old)
+                tty_termios_copy_hw(termios, old);
+        tty_termios_encode_baud_rate(termios, baud, baud);
+
+        spin_lock_irqsave(&port->lock, flags);
+        iowrite8((u8)bindex, port->membase + TIMBUART_BAUDRATE);
+        uart_update_timeout(port, termios->c_cflag, baud);
+        spin_unlock_irqrestore(&port->lock, flags);
+}
+
+static const char *timbuart_type(struct uart_port *port)
+{
+        return port->type == PORT_UNKNOWN ? "timbuart" : NULL;
+}
+
+/* We do not request/release mappings of the registers here,
+ * currently it's done in the proble function.
+ */
+static void timbuart_release_port(struct uart_port *port)
+{
+        struct platform_device *pdev = to_platform_device(port->dev);
+        int size =
+                resource_size(platform_get_resource(pdev, IORESOURCE_MEM, 0));
+
+        if (port->flags & UPF_IOREMAP) {
+                iounmap(port->membase);
+                port->membase = NULL;
+        }
+
+        release_mem_region(port->mapbase, size);
+}
+
+static int timbuart_request_port(struct uart_port *port)
+{
+        struct platform_device *pdev = to_platform_device(port->dev);
+        int size =
+                resource_size(platform_get_resource(pdev, IORESOURCE_MEM, 0));
+
+        if (!request_mem_region(port->mapbase, size, "timb-uart"))
+                return -EBUSY;
+
+        if (port->flags & UPF_IOREMAP) {
+                port->membase = ioremap(port->mapbase, size);
+                if (port->membase == NULL) {
+                        release_mem_region(port->mapbase, size);
+                        return -ENOMEM;
+                }
+        }
+
+        return 0;
+}
+
+static irqreturn_t timbuart_handleinterrupt(int irq, void *devid)
+{
+        struct timbuart_port *uart = (struct timbuart_port *)devid;
+
+        if (ioread8(uart->port.membase + TIMBUART_IPR)) {
+                uart->last_ier = ioread8(uart->port.membase + TIMBUART_IER);
+
+                /* disable interrupts, the tasklet enables them again */
+                iowrite8(0, uart->port.membase + TIMBUART_IER);
+
+                /* fire off bottom half */
+                tasklet_schedule(&uart->tasklet);
+
+                return IRQ_HANDLED;
+        } else
+                return IRQ_NONE;
+}
+
+/*
+ * Configure/autoconfigure the port.
+ */
+static void timbuart_config_port(struct uart_port *port, int flags)
+{
+        if (flags & UART_CONFIG_TYPE) {
+                port->type = PORT_TIMBUART;
+                timbuart_request_port(port);
+        }
+}
+
+static int timbuart_verify_port(struct uart_port *port,
+        struct serial_struct *ser)
+{
+        /* we don't want the core code to modify any port params */
+        return -EINVAL;
+}
+
+static struct uart_ops timbuart_ops = {
+        .tx_empty = timbuart_tx_empty,
+        .set_mctrl = timbuart_set_mctrl,
+        .get_mctrl = timbuart_get_mctrl,
+        .stop_tx = timbuart_stop_tx,
+        .start_tx = timbuart_start_tx,
+        .flush_buffer = timbuart_flush_buffer,
+        .stop_rx = timbuart_stop_rx,
+        .enable_ms = timbuart_enable_ms,
+        .break_ctl = timbuart_break_ctl,
+        .startup = timbuart_startup,
+        .shutdown = timbuart_shutdown,
+        .set_termios = timbuart_set_termios,
+        .type = timbuart_type,
+        .release_port = timbuart_release_port,
+        .request_port = timbuart_request_port,
+        .config_port = timbuart_config_port,
+        .verify_port = timbuart_verify_port
+};
+
+static struct uart_driver timbuart_driver = {
+        .owner = THIS_MODULE,
+        .driver_name = "timberdale_uart",
+        .dev_name = "ttyTU",
+        .major = TIMBUART_MAJOR,
+        .minor = TIMBUART_MINOR,
+        .nr = 1
+};
+
+static int timbuart_probe(struct platform_device *dev)
+{
+        int err;
+        struct timbuart_port *uart;
+        struct resource *iomem;
+
+        dev_dbg(&dev->dev, "%s\n", __func__);
+
+        uart = kzalloc(sizeof(*uart), GFP_KERNEL);
+        if (!uart) {
+                err = -EINVAL;
+                goto err_mem;
+        }
+
+        uart->usedma = 0;
+
+        uart->port.uartclk = 3250000 * 16;
+        uart->port.fifosize  = TIMBUART_FIFO_SIZE;
+        uart->port.regshift  = 2;
+        uart->port.iotype  = UPIO_MEM;
+        uart->port.ops = &timbuart_ops;
+        uart->port.irq = 0;
+        uart->port.flags = UPF_BOOT_AUTOCONF | UPF_IOREMAP;
+        uart->port.line  = 0;
+        uart->port.dev  = &dev->dev;
+
+        iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
+        if (!iomem) {
+                err = -ENOMEM;
+                goto err_register;
+        }
+        uart->port.mapbase = iomem->start;
+        uart->port.membase = NULL;
+
+        uart->port.irq = platform_get_irq(dev, 0);
+        if (uart->port.irq < 0) {
+                err = -EINVAL;
+                goto err_register;
+        }
+
+        tasklet_init(&uart->tasklet, timbuart_tasklet, (unsigned long)uart);
+
+        err = uart_register_driver(&timbuart_driver);
+        if (err)
+                goto err_register;
+
+        err = uart_add_one_port(&timbuart_driver, &uart->port);
+        if (err)
+                goto err_add_port;
+
+        platform_set_drvdata(dev, uart);
+
+        return 0;
+
+err_add_port:
+        uart_unregister_driver(&timbuart_driver);
+err_register:
+        kfree(uart);
+err_mem:
+        printk(KERN_ERR "timberdale: Failed to register Timberdale UART: %d\n",
+                err);
+
+        return err;
+}
+
+static int timbuart_remove(struct platform_device *dev)
+{
+        struct timbuart_port *uart = platform_get_drvdata(dev);
+
+        tasklet_kill(&uart->tasklet);
+        uart_remove_one_port(&timbuart_driver, &uart->port);
+        uart_unregister_driver(&timbuart_driver);
+        kfree(uart);
+
+        return 0;
+}
+
+static struct platform_driver timbuart_platform_driver = {
+        .driver = {
+                .name   = "timb-uart",
+                .owner  = THIS_MODULE,
+        },
+        .probe          = timbuart_probe,
+        .remove         = timbuart_remove,
+};
+
+/*--------------------------------------------------------------------------*/
+
+static int __init timbuart_init(void)
+{
+        return platform_driver_register(&timbuart_platform_driver);
+}
+
+static void __exit timbuart_exit(void)
+{
+        platform_driver_unregister(&timbuart_platform_driver);
+}
+
+module_init(timbuart_init);
+module_exit(timbuart_exit);
+
+MODULE_DESCRIPTION("Timberdale UART driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:timb-uart");
+
diff --git a/drivers/serial/timbuart.h b/drivers/serial/timbuart.h
new file mode 100644
index 000000000000..7e566766bc43
--- /dev/null
+++ b/drivers/serial/timbuart.h
@@ -0,0 +1,58 @@
+/*
+ * timbuart.c timberdale FPGA GPIO driver
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * Timberdale FPGA UART
+ */
+
+#ifndef _TIMBUART_H
+#define _TIMBUART_H
+
+#define TIMBUART_FIFO_SIZE      2048
+
+#define TIMBUART_RXFIFO         0x08
+#define TIMBUART_TXFIFO         0x0c
+#define TIMBUART_IER            0x10
+#define TIMBUART_IPR            0x14
+#define TIMBUART_ISR            0x18
+#define TIMBUART_CTRL           0x1c
+#define TIMBUART_BAUDRATE       0x20
+
+#define TIMBUART_CTRL_RTS       0x01
+#define TIMBUART_CTRL_CTS       0x02
+#define TIMBUART_CTRL_FLSHTX    0x40
+#define TIMBUART_CTRL_FLSHRX    0x80
+
+#define TXBF            0x01
+#define TXBAE           0x02
+#define CTS_DELTA       0x04
+#define RXDP            0x08
+#define RXBAF           0x10
+#define RXBF            0x20
+#define RXTT            0x40
+#define RXBNAE          0x80
+#define TXBE            0x100
+
+#define RXFLAGS (RXDP | RXBAF | RXBF | RXTT | RXBNAE)
+#define TXFLAGS (TXBF | TXBAE)
+
+#define TIMBUART_MAJOR 204
+#define TIMBUART_MINOR 192
+
+#endif /* _TIMBUART_H */
+
diff --git a/drivers/sh/intc.c b/drivers/sh/intc.c
index 12d13d99b6f0..d687a9b93d03 100644
--- a/drivers/sh/intc.c
+++ b/drivers/sh/intc.c
@@ -24,6 +24,7 @@
 #include <linux/sh_intc.h>
 #include <linux/sysdev.h>
 #include <linux/list.h>
+#include <linux/topology.h>
 
 #define _INTC_MK(fn, mode, addr_e, addr_d, width, shift) \
         ((shift) | ((width) << 5) | ((fn) << 9) | ((mode) << 13) | \
@@ -770,11 +771,19 @@ void __init register_intc_controller(struct intc_desc *desc)
         /* register the vectors one by one */
         for (i = 0; i < desc->nr_vectors; i++) {
                 struct intc_vect *vect = desc->vectors + i;
+                unsigned int irq = evt2irq(vect->vect);
+                struct irq_desc *irq_desc;
 
                 if (!vect->enum_id)
                         continue;
 
-                intc_register_irq(desc, d, vect->enum_id, evt2irq(vect->vect));
+                irq_desc = irq_to_desc_alloc_node(irq, numa_node_id());
+                if (unlikely(!irq_desc)) {
+                        printk(KERN_INFO "can not get irq_desc for %d\n", irq);
+                        continue;
+                }
+
+                intc_register_irq(desc, d, vect->enum_id, irq);
         }
 }
 
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 7a1164dd1d37..ddeb69192537 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -16,7 +16,8 @@
  *      v0.9  - thorough cleaning, URBification, almost a rewrite
  *      v0.10 - some more cleanups
  *      v0.11 - fixed flow control, read error doesn't stop reads
- *      v0.12 - added TIOCM ioctls, added break handling, made struct acm kmalloced
+ *      v0.12 - added TIOCM ioctls, added break handling, made struct acm
+ *              kmalloced
  *      v0.13 - added termios, added hangup
  *      v0.14 - sized down struct acm
  *      v0.15 - fixed flow control again - characters could be lost
@@ -62,7 +63,7 @@
 #include <linux/tty_flip.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <linux/usb.h>
 #include <linux/usb/cdc.h>
 #include <asm/byteorder.h>
@@ -87,7 +88,10 @@ static struct acm *acm_table[ACM_TTY_MINORS];
 
 static DEFINE_MUTEX(open_mutex);
 
-#define ACM_READY(acm)  (acm && acm->dev && acm->used)
+#define ACM_READY(acm)  (acm && acm->dev && acm->port.count)
+
+static const struct tty_port_operations acm_port_ops = {
+};
 
 #ifdef VERBOSE_DEBUG
 #define verbose 1
@@ -99,13 +103,15 @@ static DEFINE_MUTEX(open_mutex);
  * Functions for ACM control messages.
  */
 
-static int acm_ctrl_msg(struct acm *acm, int request, int value, void *buf, int len)
+static int acm_ctrl_msg(struct acm *acm, int request, int value,
+                                                        void *buf, int len)
 {
         int retval = usb_control_msg(acm->dev, usb_sndctrlpipe(acm->dev, 0),
                 request, USB_RT_ACM, value,
                 acm->control->altsetting[0].desc.bInterfaceNumber,
                 buf, len, 5000);
-        dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d", request, value, len, retval);
+        dbg("acm_control_msg: rq: 0x%02x val: %#x len: %#x result: %d",
+                                                request, value, len, retval);
         return retval < 0 ? retval : 0;
 }
 
@@ -150,9 +156,8 @@ static int acm_wb_is_avail(struct acm *acm)
 
         n = ACM_NW;
         spin_lock_irqsave(&acm->write_lock, flags);
-        for (i = 0; i < ACM_NW; i++) {
+        for (i = 0; i < ACM_NW; i++)
                 n -= acm->wb[i].use;
-        }
         spin_unlock_irqrestore(&acm->write_lock, flags);
         return n;
 }
@@ -183,7 +188,8 @@ static int acm_start_wb(struct acm *acm, struct acm_wb *wb)
         wb->urb->transfer_buffer_length = wb->len;
         wb->urb->dev = acm->dev;
 
-        if ((rc = usb_submit_urb(wb->urb, GFP_ATOMIC)) < 0) {
+        rc = usb_submit_urb(wb->urb, GFP_ATOMIC);
+        if (rc < 0) {
                 dbg("usb_submit_urb(write bulk) failed: %d", rc);
                 acm_write_done(acm, wb);
         }
@@ -262,6 +268,7 @@ static void acm_ctrl_irq(struct urb *urb)
 {
         struct acm *acm = urb->context;
         struct usb_cdc_notification *dr = urb->transfer_buffer;
+        struct tty_struct *tty;
         unsigned char *data;
         int newctrl;
         int retval;
@@ -287,40 +294,45 @@ static void acm_ctrl_irq(struct urb *urb)
 
         data = (unsigned char *)(dr + 1);
         switch (dr->bNotificationType) {
+        case USB_CDC_NOTIFY_NETWORK_CONNECTION:
+                dbg("%s network", dr->wValue ?
+                                        "connected to" : "disconnected from");
+                break;
 
-                case USB_CDC_NOTIFY_NETWORK_CONNECTION:
-
-                        dbg("%s network", dr->wValue ? "connected to" : "disconnected from");
-                        break;
-
-                case USB_CDC_NOTIFY_SERIAL_STATE:
-
-                        newctrl = get_unaligned_le16(data);
+        case USB_CDC_NOTIFY_SERIAL_STATE:
+                tty = tty_port_tty_get(&acm->port);
+                newctrl = get_unaligned_le16(data);
 
-                        if (acm->tty && !acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
+                if (tty) {
+                        if (!acm->clocal &&
+                                (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
                                 dbg("calling hangup");
-                                tty_hangup(acm->tty);
+                                tty_hangup(tty);
                         }
+                        tty_kref_put(tty);
+                }
 
-                        acm->ctrlin = newctrl;
-
-                        dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
-                                acm->ctrlin & ACM_CTRL_DCD ? '+' : '-', acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
-                                acm->ctrlin & ACM_CTRL_BRK ? '+' : '-', acm->ctrlin & ACM_CTRL_RI  ? '+' : '-',
-                                acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',     acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
-                                acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
+                acm->ctrlin = newctrl;
 
+                dbg("input control lines: dcd%c dsr%c break%c ring%c framing%c parity%c overrun%c",
+                        acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
+                        acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
+                        acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
+                        acm->ctrlin & ACM_CTRL_RI  ? '+' : '-',
+                        acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
+                        acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
+                        acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
                         break;
 
-                default:
-                        dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
-                                dr->bNotificationType, dr->wIndex,
-                                dr->wLength, data[0], data[1]);
-                        break;
+        default:
+                dbg("unknown notification %d received: index %d len %d data0 %d data1 %d",
+                        dr->bNotificationType, dr->wIndex,
+                        dr->wLength, data[0], data[1]);
+                break;
         }
 exit:
         usb_mark_last_busy(acm->dev);
-        retval = usb_submit_urb (urb, GFP_ATOMIC);
+        retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval)
                 dev_err(&urb->dev->dev, "%s - usb_submit_urb failed with "
                         "result %d", __func__, retval);
@@ -371,15 +383,14 @@ static void acm_rx_tasklet(unsigned long _acm)
 {
         struct acm *acm = (void *)_acm;
         struct acm_rb *buf;
-        struct tty_struct *tty = acm->tty;
+        struct tty_struct *tty;
         struct acm_ru *rcv;
         unsigned long flags;
         unsigned char throttled;
 
         dbg("Entering acm_rx_tasklet");
 
-        if (!ACM_READY(acm))
-        {
+        if (!ACM_READY(acm)) {
                 dbg("acm_rx_tasklet: ACM not ready");
                 return;
         }
@@ -387,12 +398,13 @@ static void acm_rx_tasklet(unsigned long _acm)
         spin_lock_irqsave(&acm->throttle_lock, flags);
         throttled = acm->throttle;
         spin_unlock_irqrestore(&acm->throttle_lock, flags);
-        if (throttled)
-        {
+        if (throttled) {
                 dbg("acm_rx_tasklet: throttled");
                 return;
         }
 
+        tty = tty_port_tty_get(&acm->port);
+
 next_buffer:
         spin_lock_irqsave(&acm->read_lock, flags);
         if (list_empty(&acm->filled_read_bufs)) {
@@ -406,20 +418,22 @@ next_buffer:
 
         dbg("acm_rx_tasklet: procesing buf 0x%p, size = %d", buf, buf->size);
 
-        tty_buffer_request_room(tty, buf->size);
-        spin_lock_irqsave(&acm->throttle_lock, flags);
-        throttled = acm->throttle;
-        spin_unlock_irqrestore(&acm->throttle_lock, flags);
-        if (!throttled)
-                tty_insert_flip_string(tty, buf->base, buf->size);
-        tty_flip_buffer_push(tty);
-
-        if (throttled) {
-                dbg("Throttling noticed");
-                spin_lock_irqsave(&acm->read_lock, flags);
-                list_add(&buf->list, &acm->filled_read_bufs);
-                spin_unlock_irqrestore(&acm->read_lock, flags);
-                return;
+        if (tty) {
+                spin_lock_irqsave(&acm->throttle_lock, flags);
+                throttled = acm->throttle;
+                spin_unlock_irqrestore(&acm->throttle_lock, flags);
+                if (!throttled) {
+                        tty_buffer_request_room(tty, buf->size);
+                        tty_insert_flip_string(tty, buf->base, buf->size);
+                        tty_flip_buffer_push(tty);
+                } else {
+                        tty_kref_put(tty);
+                        dbg("Throttling noticed");
+                        spin_lock_irqsave(&acm->read_lock, flags);
+                        list_add(&buf->list, &acm->filled_read_bufs);
+                        spin_unlock_irqrestore(&acm->read_lock, flags);
+                        return;
+                }
         }
 
         spin_lock_irqsave(&acm->read_lock, flags);
@@ -428,6 +442,8 @@ next_buffer:
         goto next_buffer;
 
 urbs:
+        tty_kref_put(tty);
+
         while (!list_empty(&acm->spare_read_bufs)) {
                 spin_lock_irqsave(&acm->read_lock, flags);
                 if (list_empty(&acm->spare_read_urbs)) {
@@ -454,10 +470,11 @@ urbs:
                 rcv->urb->transfer_dma = buf->dma;
                 rcv->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 
-                /* This shouldn't kill the driver as unsuccessful URBs are returned to the
-                   free-urbs-pool and resubmited ASAP */
+                /* This shouldn't kill the driver as unsuccessful URBs are
+                   returned to the free-urbs-pool and resubmited ASAP */
                 spin_lock_irqsave(&acm->read_lock, flags);
-                if (acm->susp_count || usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
+                if (acm->susp_count ||
+                                usb_submit_urb(rcv->urb, GFP_ATOMIC) < 0) {
                         list_add(&buf->list, &acm->spare_read_bufs);
                         list_add(&rcv->list, &acm->spare_read_urbs);
                         acm->processing = 0;
@@ -499,11 +516,14 @@ static void acm_write_bulk(struct urb *urb)
 static void acm_softint(struct work_struct *work)
 {
         struct acm *acm = container_of(work, struct acm, work);
+        struct tty_struct *tty;
 
         dev_vdbg(&acm->data->dev, "tx work\n");
         if (!ACM_READY(acm))
                 return;
-        tty_wakeup(acm->tty);
+        tty = tty_port_tty_get(&acm->port);
+        tty_wakeup(tty);
+        tty_kref_put(tty);
 }
 
 static void acm_waker(struct work_struct *waker)
@@ -543,8 +563,9 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
                 rv = 0;
 
         set_bit(TTY_NO_WRITE_SPLIT, &tty->flags);
+
         tty->driver_data = acm;
-        acm->tty = tty;
+        tty_port_tty_set(&acm->port, tty);
 
         if (usb_autopm_get_interface(acm->control) < 0)
                 goto early_bail;
@@ -552,11 +573,10 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
                 acm->control->needs_remote_wakeup = 1;
 
         mutex_lock(&acm->mutex);
-        if (acm->used++) {
+        if (acm->port.count++) {
                 usb_autopm_put_interface(acm->control);
                 goto done;
-        }
-
+        }
 
         acm->ctrlurb->dev = acm->dev;
         if (usb_submit_urb(acm->ctrlurb, GFP_KERNEL)) {
@@ -567,22 +587,22 @@ static int acm_tty_open(struct tty_struct *tty, struct file *filp)
         if (0 > acm_set_control(acm, acm->ctrlout = ACM_CTRL_DTR | ACM_CTRL_RTS) &&
             (acm->ctrl_caps & USB_CDC_CAP_LINE))
                 goto full_bailout;
+
         usb_autopm_put_interface(acm->control);
 
         INIT_LIST_HEAD(&acm->spare_read_urbs);
         INIT_LIST_HEAD(&acm->spare_read_bufs);
         INIT_LIST_HEAD(&acm->filled_read_bufs);
-        for (i = 0; i < acm->rx_buflimit; i++) {
+
+        for (i = 0; i < acm->rx_buflimit; i++)
                 list_add(&(acm->ru[i].list), &acm->spare_read_urbs);
-        }
-        for (i = 0; i < acm->rx_buflimit; i++) {
+        for (i = 0; i < acm->rx_buflimit; i++)
                 list_add(&(acm->rb[i].list), &acm->spare_read_bufs);
-        }
 
         acm->throttle = 0;
 
         tasklet_schedule(&acm->urb_task);
-
+        rv = tty_port_block_til_ready(&acm->port, tty, filp);
 done:
         mutex_unlock(&acm->mutex);
 err_out:
@@ -593,16 +613,17 @@ full_bailout:
         usb_kill_urb(acm->ctrlurb);
 bail_out:
         usb_autopm_put_interface(acm->control);
-        acm->used--;
+        acm->port.count--;
         mutex_unlock(&acm->mutex);
 early_bail:
         mutex_unlock(&open_mutex);
+        tty_port_tty_set(&acm->port, NULL);
         return -EIO;
 }
 
 static void acm_tty_unregister(struct acm *acm)
 {
-        int i,nr;
+        int i, nr;
 
         nr = acm->rx_buflimit;
         tty_unregister_device(acm_tty_driver, acm->minor);
@@ -619,41 +640,56 @@ static void acm_tty_unregister(struct acm *acm)
 
 static int acm_tty_chars_in_buffer(struct tty_struct *tty);
 
+static void acm_port_down(struct acm *acm, int drain)
+{
+        int i, nr = acm->rx_buflimit;
+        mutex_lock(&open_mutex);
+        if (acm->dev) {
+                usb_autopm_get_interface(acm->control);
+                acm_set_control(acm, acm->ctrlout = 0);
+                /* try letting the last writes drain naturally */
+                if (drain) {
+                        wait_event_interruptible_timeout(acm->drain_wait,
+                                (ACM_NW == acm_wb_is_avail(acm)) || !acm->dev,
+                                        ACM_CLOSE_TIMEOUT * HZ);
+                }
+                usb_kill_urb(acm->ctrlurb);
+                for (i = 0; i < ACM_NW; i++)
+                        usb_kill_urb(acm->wb[i].urb);
+                for (i = 0; i < nr; i++)
+                        usb_kill_urb(acm->ru[i].urb);
+                acm->control->needs_remote_wakeup = 0;
+                usb_autopm_put_interface(acm->control);
+        }
+        mutex_unlock(&open_mutex);
+}
+
+static void acm_tty_hangup(struct tty_struct *tty)
+{
+        struct acm *acm = tty->driver_data;
+        tty_port_hangup(&acm->port);
+        acm_port_down(acm, 0);
+}
+
 static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 {
         struct acm *acm = tty->driver_data;
-        int i,nr;
 
-        if (!acm || !acm->used)
+        /* Perform the closing process and see if we need to do the hardware
+           shutdown */
+        if (tty_port_close_start(&acm->port, tty, filp) == 0)
                 return;
-
-        nr = acm->rx_buflimit;
+        acm_port_down(acm, 0);
+        tty_port_close_end(&acm->port, tty);
         mutex_lock(&open_mutex);
-        if (!--acm->used) {
-                if (acm->dev) {
-                        usb_autopm_get_interface(acm->control);
-                        acm_set_control(acm, acm->ctrlout = 0);
-
-                        /* try letting the last writes drain naturally */
-                        wait_event_interruptible_timeout(acm->drain_wait,
-                                        (ACM_NW == acm_wb_is_avail(acm))
-                                                || !acm->dev,
-                                        ACM_CLOSE_TIMEOUT * HZ);
-
-                        usb_kill_urb(acm->ctrlurb);
-                        for (i = 0; i < ACM_NW; i++)
-                                usb_kill_urb(acm->wb[i].urb);
-                        for (i = 0; i < nr; i++)
-                                usb_kill_urb(acm->ru[i].urb);
-                        acm->control->needs_remote_wakeup = 0;
-                        usb_autopm_put_interface(acm->control);
-                } else
-                        acm_tty_unregister(acm);
-        }
+        tty_port_tty_set(&acm->port, NULL);
+        if (!acm->dev)
+                acm_tty_unregister(acm);
         mutex_unlock(&open_mutex);
 }
 
-static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int count)
+static int acm_tty_write(struct tty_struct *tty,
+                                        const unsigned char *buf, int count)
 {
         struct acm *acm = tty->driver_data;
         int stat;
@@ -669,7 +705,8 @@ static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int c
                 return 0;
 
         spin_lock_irqsave(&acm->write_lock, flags);
-        if ((wbn = acm_wb_alloc(acm)) < 0) {
+        wbn = acm_wb_alloc(acm);
+        if (wbn < 0) {
                 spin_unlock_irqrestore(&acm->write_lock, flags);
                 return 0;
         }
@@ -681,7 +718,8 @@ static int acm_tty_write(struct tty_struct *tty, const unsigned char *buf, int c
         wb->len = count;
         spin_unlock_irqrestore(&acm->write_lock, flags);
 
-        if ((stat = acm_write_start(acm, wbn)) < 0)
+        stat = acm_write_start(acm, wbn);
+        if (stat < 0)
                 return stat;
         return count;
 }
@@ -767,8 +805,10 @@ static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
                 return -EINVAL;
 
         newctrl = acm->ctrlout;
-        set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
-        clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) | (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
+        set = (set & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
+                                        (set & TIOCM_RTS ? ACM_CTRL_RTS : 0);
+        clear = (clear & TIOCM_DTR ? ACM_CTRL_DTR : 0) |
+                                        (clear & TIOCM_RTS ? ACM_CTRL_RTS : 0);
 
         newctrl = (newctrl & ~clear) | set;
 
@@ -777,7 +817,8 @@ static int acm_tty_tiocmset(struct tty_struct *tty, struct file *file,
         return acm_set_control(acm, acm->ctrlout = newctrl);
 }
 
-static int acm_tty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
+static int acm_tty_ioctl(struct tty_struct *tty, struct file *file,
+                                        unsigned int cmd, unsigned long arg)
 {
         struct acm *acm = tty->driver_data;
 
@@ -799,7 +840,8 @@ static const __u8 acm_tty_size[] = {
         5, 6, 7, 8
 };
 
-static void acm_tty_set_termios(struct tty_struct *tty, struct ktermios *termios_old)
+static void acm_tty_set_termios(struct tty_struct *tty,
+                                                struct ktermios *termios_old)
 {
         struct acm *acm = tty->driver_data;
         struct ktermios *termios = tty->termios;
@@ -809,19 +851,23 @@ static void acm_tty_set_termios(struct tty_struct *tty, struct ktermios *termios
         if (!ACM_READY(acm))
                 return;
 
+        /* FIXME: Needs to support the tty_baud interface */
+        /* FIXME: Broken on sparc */
         newline.dwDTERate = cpu_to_le32p(acm_tty_speed +
                 (termios->c_cflag & CBAUD & ~CBAUDEX) + (termios->c_cflag & CBAUDEX ? 15 : 0));
         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
         newline.bParityType = termios->c_cflag & PARENB ?
-                (termios->c_cflag & PARODD ? 1 : 2) + (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
+                                (termios->c_cflag & PARODD ? 1 : 2) +
+                                (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
         newline.bDataBits = acm_tty_size[(termios->c_cflag & CSIZE) >> 4];
-
+        /* FIXME: Needs to clear unsupported bits in the termios */
         acm->clocal = ((termios->c_cflag & CLOCAL) != 0);
 
         if (!newline.dwDTERate) {
                 newline.dwDTERate = acm->line.dwDTERate;
                 newctrl &= ~ACM_CTRL_DTR;
-        } else  newctrl |=  ACM_CTRL_DTR;
+        } else
+                newctrl |=  ACM_CTRL_DTR;
 
         if (newctrl != acm->ctrlout)
                 acm_set_control(acm, acm->ctrlout = newctrl);
@@ -846,9 +892,8 @@ static void acm_write_buffers_free(struct acm *acm)
         struct acm_wb *wb;
         struct usb_device *usb_dev = interface_to_usbdev(acm->control);
 
-        for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) {
+        for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++)
                 usb_buffer_free(usb_dev, acm->writesize, wb->buf, wb->dmah);
-        }
 }
 
 static void acm_read_buffers_free(struct acm *acm)
@@ -857,7 +902,8 @@ static void acm_read_buffers_free(struct acm *acm)
         int i, n = acm->rx_buflimit;
 
         for (i = 0; i < n; i++)
-                usb_buffer_free(usb_dev, acm->readsize, acm->rb[i].base, acm->rb[i].dma);
+                usb_buffer_free(usb_dev, acm->readsize,
+                                        acm->rb[i].base, acm->rb[i].dma);
 }
 
 /* Little helper: write buffers allocate */
@@ -882,8 +928,8 @@ static int acm_write_buffers_alloc(struct acm *acm)
         return 0;
 }
 
-static int acm_probe (struct usb_interface *intf,
-                      const struct usb_device_id *id)
+static int acm_probe(struct usb_interface *intf,
+                     const struct usb_device_id *id)
 {
         struct usb_cdc_union_desc *union_header = NULL;
         struct usb_cdc_country_functional_desc *cfd = NULL;
@@ -897,7 +943,7 @@ static int acm_probe (struct usb_interface *intf,
         struct usb_device *usb_dev = interface_to_usbdev(intf);
         struct acm *acm;
         int minor;
-        int ctrlsize,readsize;
+        int ctrlsize, readsize;
         u8 *buf;
         u8 ac_management_function = 0;
         u8 call_management_function = 0;
@@ -917,7 +963,7 @@ static int acm_probe (struct usb_interface *intf,
                 control_interface = usb_ifnum_to_if(usb_dev, 0);
                 goto skip_normal_probe;
         }
-        
+
         /* normal probing*/
         if (!buffer) {
                 dev_err(&intf->dev, "Weird descriptor references\n");
@@ -925,8 +971,10 @@ static int acm_probe (struct usb_interface *intf,
         }
 
         if (!buflen) {
-                if (intf->cur_altsetting->endpoint->extralen && intf->cur_altsetting->endpoint->extra) {
-                        dev_dbg(&intf->dev,"Seeking extra descriptors on endpoint\n");
+                if (intf->cur_altsetting->endpoint->extralen &&
+                                intf->cur_altsetting->endpoint->extra) {
+                        dev_dbg(&intf->dev,
+                                "Seeking extra descriptors on endpoint\n");
                         buflen = intf->cur_altsetting->endpoint->extralen;
                         buffer = intf->cur_altsetting->endpoint->extra;
                 } else {
@@ -937,47 +985,43 @@ static int acm_probe (struct usb_interface *intf,
         }
 
         while (buflen > 0) {
-                if (buffer [1] != USB_DT_CS_INTERFACE) {
+                if (buffer[1] != USB_DT_CS_INTERFACE) {
                         dev_err(&intf->dev, "skipping garbage\n");
                         goto next_desc;
                 }
 
-                switch (buffer [2]) {
-                        case USB_CDC_UNION_TYPE: /* we've found it */
-                                if (union_header) {
-                                        dev_err(&intf->dev, "More than one "
-                                                "union descriptor, "
-                                                "skipping ...\n");
-                                        goto next_desc;
-                                }
-                                union_header = (struct usb_cdc_union_desc *)
-                                                        buffer;
-                                break;
-                        case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
-                                cfd = (struct usb_cdc_country_functional_desc *)buffer;
-                                break;
-                        case USB_CDC_HEADER_TYPE: /* maybe check version */ 
-                                break; /* for now we ignore it */ 
-                        case USB_CDC_ACM_TYPE:
-                                ac_management_function = buffer[3];
-                                break;
-                        case USB_CDC_CALL_MANAGEMENT_TYPE:
-                                call_management_function = buffer[3];
-                                call_interface_num = buffer[4];
-                                if ((call_management_function & 3) != 3)
-                                        dev_err(&intf->dev, "This device "
-                                                "cannot do calls on its own. "
-                                                "It is no modem.\n");
-                                break;
-                        default:
-                                /* there are LOTS more CDC descriptors that
-                                 * could legitimately be found here.
-                                 */
-                                dev_dbg(&intf->dev, "Ignoring descriptor: "
-                                                "type %02x, length %d\n",
-                                                buffer[2], buffer[0]);
-                                break;
+                switch (buffer[2]) {
+                case USB_CDC_UNION_TYPE: /* we've found it */
+                        if (union_header) {
+                                dev_err(&intf->dev, "More than one "
+                                        "union descriptor, skipping ...\n");
+                                goto next_desc;
                         }
+                        union_header = (struct usb_cdc_union_desc *)buffer;
+                        break;
+                case USB_CDC_COUNTRY_TYPE: /* export through sysfs*/
+                        cfd = (struct usb_cdc_country_functional_desc *)buffer;
+                        break;
+                case USB_CDC_HEADER_TYPE: /* maybe check version */
+                        break; /* for now we ignore it */
+                case USB_CDC_ACM_TYPE:
+                        ac_management_function = buffer[3];
+                        break;
+                case USB_CDC_CALL_MANAGEMENT_TYPE:
+                        call_management_function = buffer[3];
+                        call_interface_num = buffer[4];
+                        if ((call_management_function & 3) != 3)
+                                dev_err(&intf->dev, "This device cannot do calls on its own. It is not a modem.\n");
+                        break;
+                default:
+                        /* there are LOTS more CDC descriptors that
+                         * could legitimately be found here.
+                         */
+                        dev_dbg(&intf->dev, "Ignoring descriptor: "
+                                        "type %02x, length %d\n",
+                                        buffer[2], buffer[0]);
+                        break;
+                }
 next_desc:
                 buflen -= buffer[0];
                 buffer += buffer[0];
@@ -985,33 +1029,36 @@ next_desc:
 
         if (!union_header) {
                 if (call_interface_num > 0) {
-                        dev_dbg(&intf->dev,"No union descriptor, using call management descriptor\n");
+                        dev_dbg(&intf->dev, "No union descriptor, using call management descriptor\n");
                         data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = call_interface_num));
                         control_interface = intf;
                 } else {
-                        dev_dbg(&intf->dev,"No union descriptor, giving up\n");
+                        dev_dbg(&intf->dev,
+                                        "No union descriptor, giving up\n");
                         return -ENODEV;
                 }
         } else {
                 control_interface = usb_ifnum_to_if(usb_dev, union_header->bMasterInterface0);
                 data_interface = usb_ifnum_to_if(usb_dev, (data_interface_num = union_header->bSlaveInterface0));
                 if (!control_interface || !data_interface) {
-                        dev_dbg(&intf->dev,"no interfaces\n");
+                        dev_dbg(&intf->dev, "no interfaces\n");
                         return -ENODEV;
                 }
         }
-        
+
         if (data_interface_num != call_interface_num)
-                dev_dbg(&intf->dev,"Separate call control interface. That is not fully supported.\n");
+                dev_dbg(&intf->dev, "Separate call control interface. That is not fully supported.\n");
 
 skip_normal_probe:
 
         /*workaround for switched interfaces */
-        if (data_interface->cur_altsetting->desc.bInterfaceClass != CDC_DATA_INTERFACE_TYPE) {
-                if (control_interface->cur_altsetting->desc.bInterfaceClass == CDC_DATA_INTERFACE_TYPE) {
+        if (data_interface->cur_altsetting->desc.bInterfaceClass
+                                                != CDC_DATA_INTERFACE_TYPE) {
+                if (control_interface->cur_altsetting->desc.bInterfaceClass
+                                                == CDC_DATA_INTERFACE_TYPE) {
                         struct usb_interface *t;
-                        dev_dbg(&intf->dev,"Your device has switched interfaces.\n");
-
+                        dev_dbg(&intf->dev,
+                                "Your device has switched interfaces.\n");
                         t = control_interface;
                         control_interface = data_interface;
                         data_interface = t;
@@ -1023,9 +1070,9 @@ skip_normal_probe:
         /* Accept probe requests only for the control interface */
         if (intf != control_interface)
                 return -ENODEV;
-        
+
         if (usb_interface_claimed(data_interface)) { /* valid in this context */
-                dev_dbg(&intf->dev,"The data interface isn't available\n");
+                dev_dbg(&intf->dev, "The data interface isn't available\n");
                 return -EBUSY;
         }
 
@@ -1042,8 +1089,8 @@ skip_normal_probe:
         if (!usb_endpoint_dir_in(epread)) {
                 /* descriptors are swapped */
                 struct usb_endpoint_descriptor *t;
-                dev_dbg(&intf->dev,"The data interface has switched endpoints\n");
-                
+                dev_dbg(&intf->dev,
+                        "The data interface has switched endpoints\n");
                 t = epread;
                 epread = epwrite;
                 epwrite = t;
@@ -1056,13 +1103,15 @@ skip_normal_probe:
                 return -ENODEV;
         }
 
-        if (!(acm = kzalloc(sizeof(struct acm), GFP_KERNEL))) {
+        acm = kzalloc(sizeof(struct acm), GFP_KERNEL);
+        if (acm == NULL) {
                 dev_dbg(&intf->dev, "out of memory (acm kzalloc)\n");
                 goto alloc_fail;
         }
 
         ctrlsize = le16_to_cpu(epctrl->wMaxPacketSize);
-        readsize = le16_to_cpu(epread->wMaxPacketSize)* ( quirks == SINGLE_RX_URB ? 1 : 2);
+        readsize = le16_to_cpu(epread->wMaxPacketSize) *
+                                (quirks == SINGLE_RX_URB ? 1 : 2);
         acm->writesize = le16_to_cpu(epwrite->wMaxPacketSize) * 20;
         acm->control = control_interface;
         acm->data = data_interface;
@@ -1082,6 +1131,8 @@ skip_normal_probe:
         spin_lock_init(&acm->read_lock);
         mutex_init(&acm->mutex);
         acm->rx_endpoint = usb_rcvbulkpipe(usb_dev, epread->bEndpointAddress);
+        tty_port_init(&acm->port);
+        acm->port.ops = &acm_port_ops;
 
         buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma);
         if (!buf) {
@@ -1103,8 +1154,10 @@ skip_normal_probe:
         for (i = 0; i < num_rx_buf; i++) {
                 struct acm_ru *rcv = &(acm->ru[i]);
 
-                if (!(rcv->urb = usb_alloc_urb(0, GFP_KERNEL))) {
-                        dev_dbg(&intf->dev, "out of memory (read urbs usb_alloc_urb)\n");
+                rcv->urb = usb_alloc_urb(0, GFP_KERNEL);
+                if (rcv->urb == NULL) {
+                        dev_dbg(&intf->dev,
+                                "out of memory (read urbs usb_alloc_urb)\n");
                         goto alloc_fail7;
                 }
 
@@ -1117,26 +1170,29 @@ skip_normal_probe:
                 rb->base = usb_buffer_alloc(acm->dev, readsize,
                                 GFP_KERNEL, &rb->dma);
                 if (!rb->base) {
-                        dev_dbg(&intf->dev, "out of memory (read bufs usb_buffer_alloc)\n");
+                        dev_dbg(&intf->dev,
+                                "out of memory (read bufs usb_buffer_alloc)\n");
                         goto alloc_fail7;
                 }
         }
-        for(i = 0; i < ACM_NW; i++)
-        {
+        for (i = 0; i < ACM_NW; i++) {
                 struct acm_wb *snd = &(acm->wb[i]);
 
-                if (!(snd->urb = usb_alloc_urb(0, GFP_KERNEL))) {
-                        dev_dbg(&intf->dev, "out of memory (write urbs usb_alloc_urb)");
+                snd->urb = usb_alloc_urb(0, GFP_KERNEL);
+                if (snd->urb == NULL) {
+                        dev_dbg(&intf->dev,
+                                "out of memory (write urbs usb_alloc_urb)");
                         goto alloc_fail7;
                 }
 
-                usb_fill_bulk_urb(snd->urb, usb_dev, usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
-                                NULL, acm->writesize, acm_write_bulk, snd);
+                usb_fill_bulk_urb(snd->urb, usb_dev,
+                        usb_sndbulkpipe(usb_dev, epwrite->bEndpointAddress),
+                        NULL, acm->writesize, acm_write_bulk, snd);
                 snd->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
                 snd->instance = acm;
         }
 
-        usb_set_intfdata (intf, acm);
+        usb_set_intfdata(intf, acm);
 
         i = device_create_file(&intf->dev, &dev_attr_bmCapabilities);
         if (i < 0)
@@ -1147,7 +1203,8 @@ skip_normal_probe:
                 if (!acm->country_codes)
                         goto skip_countries;
                 acm->country_code_size = cfd->bLength - 4;
-                memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0, cfd->bLength - 4);
+                memcpy(acm->country_codes, (u8 *)&cfd->wCountyCode0,
+                                                        cfd->bLength - 4);
                 acm->country_rel_date = cfd->iCountryCodeRelDate;
 
                 i = device_create_file(&intf->dev, &dev_attr_wCountryCodes);
@@ -1156,7 +1213,8 @@ skip_normal_probe:
                         goto skip_countries;
                 }
 
-                i = device_create_file(&intf->dev, &dev_attr_iCountryCodeRelDate);
+                i = device_create_file(&intf->dev,
+                                                &dev_attr_iCountryCodeRelDate);
                 if (i < 0) {
                         kfree(acm->country_codes);
                         goto skip_countries;
@@ -1164,8 +1222,10 @@ skip_normal_probe:
         }
 
 skip_countries:
-        usb_fill_int_urb(acm->ctrlurb, usb_dev, usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
-                         acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm, epctrl->bInterval);
+        usb_fill_int_urb(acm->ctrlurb, usb_dev,
+                        usb_rcvintpipe(usb_dev, epctrl->bEndpointAddress),
+                        acm->ctrl_buffer, ctrlsize, acm_ctrl_irq, acm,
+                        epctrl->bInterval);
         acm->ctrlurb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
         acm->ctrlurb->transfer_dma = acm->ctrl_dma;
 
@@ -1212,7 +1272,7 @@ static void stop_data_traffic(struct acm *acm)
         tasklet_disable(&acm->urb_task);
 
         usb_kill_urb(acm->ctrlurb);
-        for(i = 0; i < ACM_NW; i++)
+        for (i = 0; i < ACM_NW; i++)
                 usb_kill_urb(acm->wb[i].urb);
         for (i = 0; i < acm->rx_buflimit; i++)
                 usb_kill_urb(acm->ru[i].urb);
@@ -1227,13 +1287,14 @@ static void acm_disconnect(struct usb_interface *intf)
 {
         struct acm *acm = usb_get_intfdata(intf);
         struct usb_device *usb_dev = interface_to_usbdev(intf);
+        struct tty_struct *tty;
 
         /* sibling interface is already cleaning up */
         if (!acm)
                 return;
 
         mutex_lock(&open_mutex);
-        if (acm->country_codes){
+        if (acm->country_codes) {
                 device_remove_file(&acm->control->dev,
                                 &dev_attr_wCountryCodes);
                 device_remove_file(&acm->control->dev,
@@ -1247,22 +1308,25 @@ static void acm_disconnect(struct usb_interface *intf)
         stop_data_traffic(acm);
 
         acm_write_buffers_free(acm);
-        usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, acm->ctrl_dma);
+        usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer,
+                                                                acm->ctrl_dma);
         acm_read_buffers_free(acm);
 
         usb_driver_release_interface(&acm_driver, intf == acm->control ?
                                         acm->data : acm->control);
 
-        if (!acm->used) {
+        if (acm->port.count == 0) {
                 acm_tty_unregister(acm);
                 mutex_unlock(&open_mutex);
                 return;
         }
 
         mutex_unlock(&open_mutex);
-
-        if (acm->tty)
-                tty_hangup(acm->tty);
+        tty = tty_port_tty_get(&acm->port);
+        if (tty) {
+                tty_hangup(tty);
+                tty_kref_put(tty);
+        }
 }
 
 #ifdef CONFIG_PM
@@ -1297,7 +1361,7 @@ static int acm_suspend(struct usb_interface *intf, pm_message_t message)
         */
         mutex_lock(&acm->mutex);
 
-        if (acm->used)
+        if (acm->port.count)
                 stop_data_traffic(acm);
 
         mutex_unlock(&acm->mutex);
@@ -1319,7 +1383,7 @@ static int acm_resume(struct usb_interface *intf)
                 return 0;
 
         mutex_lock(&acm->mutex);
-        if (acm->used) {
+        if (acm->port.count) {
                 rv = usb_submit_urb(acm->ctrlurb, GFP_NOIO);
                 if (rv < 0)
                         goto err_out;
@@ -1398,7 +1462,7 @@ static struct usb_device_id acm_ids[] = {
         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
                 USB_CDC_ACM_PROTO_AT_GSM) },
         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
-                USB_CDC_ACM_PROTO_AT_3G ) },
+                USB_CDC_ACM_PROTO_AT_3G) },
         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
                 USB_CDC_ACM_PROTO_AT_CDMA) },
 
@@ -1406,7 +1470,7 @@ static struct usb_device_id acm_ids[] = {
         { }
 };
 
-MODULE_DEVICE_TABLE (usb, acm_ids);
+MODULE_DEVICE_TABLE(usb, acm_ids);
 
 static struct usb_driver acm_driver = {
         .name =         "cdc_acm",
@@ -1429,6 +1493,7 @@ static struct usb_driver acm_driver = {
 static const struct tty_operations acm_ops = {
         .open =                 acm_tty_open,
         .close =                acm_tty_close,
+        .hangup =               acm_tty_hangup,
         .write =                acm_tty_write,
         .write_room =           acm_tty_write_room,
         .ioctl =                acm_tty_ioctl,
@@ -1460,7 +1525,8 @@ static int __init acm_init(void)
         acm_tty_driver->subtype = SERIAL_TYPE_NORMAL,
         acm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
         acm_tty_driver->init_termios = tty_std_termios;
-        acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+        acm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
+                                                                HUPCL | CLOCAL;
         tty_set_operations(acm_tty_driver, &acm_ops);
 
         retval = tty_register_driver(acm_tty_driver);
@@ -1492,7 +1558,7 @@ static void __exit acm_exit(void)
 module_init(acm_init);
 module_exit(acm_exit);
 
-MODULE_AUTHOR( DRIVER_AUTHOR );
-MODULE_DESCRIPTION( DRIVER_DESC );
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_CHARDEV_MAJOR(ACM_TTY_MAJOR);
diff --git a/drivers/usb/class/cdc-acm.h b/drivers/usb/class/cdc-acm.h
index 1f95e7aa1b66..4c3856420add 100644
--- a/drivers/usb/class/cdc-acm.h
+++ b/drivers/usb/class/cdc-acm.h
@@ -89,8 +89,8 @@ struct acm {
         struct usb_device *dev;                         /* the corresponding usb device */
         struct usb_interface *control;                  /* control interface */
         struct usb_interface *data;                     /* data interface */
-        struct tty_struct *tty;                         /* the corresponding tty */
-        struct urb *ctrlurb;                    /* urbs */
+        struct tty_port port;                           /* our tty port data */
+        struct urb *ctrlurb;                            /* urbs */
         u8 *ctrl_buffer;                                /* buffers of urbs */
         dma_addr_t ctrl_dma;                            /* dma handles of buffers */
         u8 *country_codes;                              /* country codes from device */
@@ -120,7 +120,6 @@ struct acm {
         unsigned int ctrlout;                           /* output control lines (DTR, RTS) */
         unsigned int writesize;                         /* max packet size for the output bulk endpoint */
         unsigned int readsize,ctrlsize;                 /* buffer sizes for freeing */
-        unsigned int used;                              /* someone has this acm's device open */
         unsigned int minor;                             /* acm minor number */
         unsigned char throttle;                         /* throttled by tty layer */
         unsigned char clocal;                           /* termios CLOCAL */
diff --git a/drivers/usb/serial/belkin_sa.c b/drivers/usb/serial/belkin_sa.c
index b7eacad4d48c..2bfd6dd85b5a 100644
--- a/drivers/usb/serial/belkin_sa.c
+++ b/drivers/usb/serial/belkin_sa.c
@@ -93,8 +93,7 @@ static int  belkin_sa_startup(struct usb_serial *serial);
 static void belkin_sa_shutdown(struct usb_serial *serial);
 static int  belkin_sa_open(struct tty_struct *tty,
                         struct usb_serial_port *port, struct file *filp);
-static void belkin_sa_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+static void belkin_sa_close(struct usb_serial_port *port);
 static void belkin_sa_read_int_callback(struct urb *urb);
 static void belkin_sa_set_termios(struct tty_struct *tty,
                         struct usb_serial_port *port, struct ktermios * old);
@@ -244,8 +243,7 @@ exit:
 } /* belkin_sa_open */
 
 
-static void belkin_sa_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void belkin_sa_close(struct usb_serial_port *port)
 {
         dbg("%s port %d", __func__, port->number);
 
diff --git a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c
index ab4cc277aa65..2830766f5b39 100644
--- a/drivers/usb/serial/ch341.c
+++ b/drivers/usb/serial/ch341.c
@@ -262,32 +262,40 @@ error:	kfree(priv);
         return r;
 }
 
-static void ch341_close(struct tty_struct *tty, struct usb_serial_port *port,
-                                struct file *filp)
+static int ch341_carrier_raised(struct usb_serial_port *port)
+{
+        struct ch341_private *priv = usb_get_serial_port_data(port);
+        if (priv->line_status & CH341_BIT_DCD)
+                return 1;
+        return 0;
+}
+
+static void ch341_dtr_rts(struct usb_serial_port *port, int on)
 {
         struct ch341_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
-        unsigned int c_cflag;
 
         dbg("%s - port %d", __func__, port->number);
+        /* drop DTR and RTS */
+        spin_lock_irqsave(&priv->lock, flags);
+        if (on)
+                priv->line_control |= CH341_BIT_RTS | CH341_BIT_DTR;
+        else
+                priv->line_control &= ~(CH341_BIT_RTS | CH341_BIT_DTR);
+        spin_unlock_irqrestore(&priv->lock, flags);
+        ch341_set_handshake(port->serial->dev, priv->line_control);
+        wake_up_interruptible(&priv->delta_msr_wait);
+}
+
+static void ch341_close(struct usb_serial_port *port)
+{
+        dbg("%s - port %d", __func__, port->number);
 
         /* shutdown our urbs */
         dbg("%s - shutting down urbs", __func__);
         usb_kill_urb(port->write_urb);
         usb_kill_urb(port->read_urb);
         usb_kill_urb(port->interrupt_in_urb);
-
-        if (tty) {
-                c_cflag = tty->termios->c_cflag;
-                if (c_cflag & HUPCL) {
-                        /* drop DTR and RTS */
-                        spin_lock_irqsave(&priv->lock, flags);
-                        priv->line_control = 0;
-                        spin_unlock_irqrestore(&priv->lock, flags);
-                        ch341_set_handshake(port->serial->dev, 0);
-                }
-        }
-        wake_up_interruptible(&priv->delta_msr_wait);
 }
 
 
@@ -302,7 +310,6 @@ static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port,
         dbg("ch341_open()");
 
         priv->baud_rate = DEFAULT_BAUD_RATE;
-        priv->line_control = CH341_BIT_RTS | CH341_BIT_DTR;
 
         r = ch341_configure(serial->dev, priv);
         if (r)
@@ -322,7 +329,7 @@ static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port,
         if (r) {
                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
                         " error %d\n", __func__, r);
-                ch341_close(tty, port, NULL);
+                ch341_close(port);
                 return -EPROTO;
         }
 
@@ -343,9 +350,6 @@ static void ch341_set_termios(struct tty_struct *tty,
 
         dbg("ch341_set_termios()");
 
-        if (!tty || !tty->termios)
-                return;
-
         baud_rate = tty_get_baud_rate(tty);
 
         priv->baud_rate = baud_rate;
@@ -568,6 +572,8 @@ static struct usb_serial_driver ch341_device = {
         .usb_driver        = &ch341_driver,
         .num_ports         = 1,
         .open              = ch341_open,
+        .dtr_rts           = ch341_dtr_rts,
+        .carrier_raised    = ch341_carrier_raised,
         .close             = ch341_close,
         .ioctl             = ch341_ioctl,
         .set_termios       = ch341_set_termios,
diff --git a/drivers/usb/serial/console.c b/drivers/usb/serial/console.c
index 19e24045b137..247b61bfb7f4 100644
--- a/drivers/usb/serial/console.c
+++ b/drivers/usb/serial/console.c
@@ -169,7 +169,9 @@ static int usb_console_setup(struct console *co, char *options)
                         kfree(tty);
                 }
         }
-
+        /* So we know not to kill the hardware on a hangup on this
+           port. We have also bumped the use count by one so it won't go
+           idle */
         port->console = 1;
         retval = 0;
 
@@ -182,7 +184,7 @@ free_tty:
         kfree(tty);
 reset_open_count:
         port->port.count = 0;
-goto out;
+        goto out;
 }
 
 static void usb_console_write(struct console *co,
diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c
index e8d5133ce9c8..16a154d3b2fe 100644
--- a/drivers/usb/serial/cp210x.c
+++ b/drivers/usb/serial/cp210x.c
@@ -1,5 +1,5 @@
 /*
- * Silicon Laboratories CP2101/CP2102 USB to RS232 serial adaptor driver
+ * Silicon Laboratories CP210x USB to RS232 serial adaptor driver
  *
  * Copyright (C) 2005 Craig Shelley (craig@microtron.org.uk)
  *
@@ -27,44 +27,46 @@
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v0.08"
-#define DRIVER_DESC "Silicon Labs CP2101/CP2102 RS232 serial adaptor driver"
+#define DRIVER_VERSION "v0.09"
+#define DRIVER_DESC "Silicon Labs CP210x RS232 serial adaptor driver"
 
 /*
  * Function Prototypes
  */
-static int cp2101_open(struct tty_struct *, struct usb_serial_port *,
+static int cp210x_open(struct tty_struct *, struct usb_serial_port *,
                                                         struct file *);
-static void cp2101_cleanup(struct usb_serial_port *);
-static void cp2101_close(struct tty_struct *, struct usb_serial_port *,
-                                                        struct file*);
-static void cp2101_get_termios(struct tty_struct *,
+static void cp210x_cleanup(struct usb_serial_port *);
+static void cp210x_close(struct usb_serial_port *);
+static void cp210x_get_termios(struct tty_struct *,
         struct usb_serial_port *port);
-static void cp2101_get_termios_port(struct usb_serial_port *port,
+static void cp210x_get_termios_port(struct usb_serial_port *port,
         unsigned int *cflagp, unsigned int *baudp);
-static void cp2101_set_termios(struct tty_struct *, struct usb_serial_port *,
+static void cp210x_set_termios(struct tty_struct *, struct usb_serial_port *,
                                                         struct ktermios*);
-static int cp2101_tiocmget(struct tty_struct *, struct file *);
-static int cp2101_tiocmset(struct tty_struct *, struct file *,
+static int cp210x_tiocmget(struct tty_struct *, struct file *);
+static int cp210x_tiocmset(struct tty_struct *, struct file *,
                 unsigned int, unsigned int);
-static int cp2101_tiocmset_port(struct usb_serial_port *port, struct file *,
+static int cp210x_tiocmset_port(struct usb_serial_port *port, struct file *,
                 unsigned int, unsigned int);
-static void cp2101_break_ctl(struct tty_struct *, int);
-static int cp2101_startup(struct usb_serial *);
-static void cp2101_shutdown(struct usb_serial *);
+static void cp210x_break_ctl(struct tty_struct *, int);
+static int cp210x_startup(struct usb_serial *);
+static void cp210x_shutdown(struct usb_serial *);
 
 static int debug;
 
 static struct usb_device_id id_table [] = {
         { USB_DEVICE(0x0471, 0x066A) }, /* AKTAKOM ACE-1001 cable */
         { USB_DEVICE(0x0489, 0xE000) }, /* Pirelli Broadband S.p.A, DP-L10 SIP/GSM Mobile */
+        { USB_DEVICE(0x0745, 0x1000) }, /* CipherLab USB CCD Barcode Scanner 1000 */
         { USB_DEVICE(0x08e6, 0x5501) }, /* Gemalto Prox-PU/CU contactless smartcard reader */
+        { USB_DEVICE(0x08FD, 0x000A) }, /* Digianswer A/S , ZigBee/802.15.4 MAC Device */
         { USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */
         { USB_DEVICE(0x0FCF, 0x1004) }, /* Dynastream ANT2USB */
         { USB_DEVICE(0x0FCF, 0x1006) }, /* Dynastream ANT development board */
         { USB_DEVICE(0x10A6, 0xAA26) }, /* Knock-off DCU-11 cable */
         { USB_DEVICE(0x10AB, 0x10C5) }, /* Siemens MC60 Cable */
         { USB_DEVICE(0x10B5, 0xAC70) }, /* Nokia CA-42 USB */
+        { USB_DEVICE(0x10C4, 0x0F91) }, /* Vstabi */
         { USB_DEVICE(0x10C4, 0x800A) }, /* SPORTident BSM7-D-USB main station */
         { USB_DEVICE(0x10C4, 0x803B) }, /* Pololu USB-serial converter */
         { USB_DEVICE(0x10C4, 0x8053) }, /* Enfora EDG1228 */
@@ -85,10 +87,12 @@ static struct usb_device_id id_table [] = {
         { USB_DEVICE(0x10C4, 0x81C8) }, /* Lipowsky Industrie Elektronik GmbH, Baby-JTAG */
         { USB_DEVICE(0x10C4, 0x81E2) }, /* Lipowsky Industrie Elektronik GmbH, Baby-LIN */
         { USB_DEVICE(0x10C4, 0x81E7) }, /* Aerocomm Radio */
+        { USB_DEVICE(0x10C4, 0x81F2) }, /* C1007 HF band RFID controller */
         { USB_DEVICE(0x10C4, 0x8218) }, /* Lipowsky Industrie Elektronik GmbH, HARP-1 */
         { USB_DEVICE(0x10C4, 0x822B) }, /* Modem EDGE(GSM) Comander 2 */
         { USB_DEVICE(0x10C4, 0x826B) }, /* Cygnal Integrated Products, Inc., Fasttrax GPS demostration module */
         { USB_DEVICE(0x10c4, 0x8293) }, /* Telegesys ETRX2USB */
+        { USB_DEVICE(0x10C4, 0x82F9) }, /* Procyon AVS */
         { USB_DEVICE(0x10C4, 0x8341) }, /* Siemens MC35PU GPRS Modem */
         { USB_DEVICE(0x10C4, 0x83A8) }, /* Amber Wireless AMB2560 */
         { USB_DEVICE(0x10C4, 0x846E) }, /* BEI USB Sensor Interface (VCP) */
@@ -99,7 +103,9 @@ static struct usb_device_id id_table [] = {
         { USB_DEVICE(0x10C4, 0xF003) }, /* Elan Digital Systems USBpulse100 */
         { USB_DEVICE(0x10C4, 0xF004) }, /* Elan Digital Systems USBcount50 */
         { USB_DEVICE(0x10C5, 0xEA61) }, /* Silicon Labs MobiData GPRS USB Modem */
+        { USB_DEVICE(0x10CE, 0xEA6A) }, /* Silicon Labs MobiData GPRS USB Modem 100EU */
         { USB_DEVICE(0x13AD, 0x9999) }, /* Baltech card reader */
+        { USB_DEVICE(0x1555, 0x0004) }, /* Owen AC4 USB-RS485 Converter */
         { USB_DEVICE(0x166A, 0x0303) }, /* Clipsal 5500PCU C-Bus USB interface */
         { USB_DEVICE(0x16D6, 0x0001) }, /* Jablotron serial interface */
         { USB_DEVICE(0x18EF, 0xE00F) }, /* ELV USB-I2C-Interface */
@@ -108,53 +114,70 @@ static struct usb_device_id id_table [] = {
 
 MODULE_DEVICE_TABLE(usb, id_table);
 
-static struct usb_driver cp2101_driver = {
-        .name           = "cp2101",
+static struct usb_driver cp210x_driver = {
+        .name           = "cp210x",
         .probe          = usb_serial_probe,
         .disconnect     = usb_serial_disconnect,
         .id_table       = id_table,
         .no_dynamic_id  =       1,
 };
 
-static struct usb_serial_driver cp2101_device = {
+static struct usb_serial_driver cp210x_device = {
         .driver = {
                 .owner =        THIS_MODULE,
-                .name =         "cp2101",
+                .name =         "cp210x",
         },
-        .usb_driver             = &cp2101_driver,
+        .usb_driver             = &cp210x_driver,
         .id_table               = id_table,
         .num_ports              = 1,
-        .open                   = cp2101_open,
-        .close                  = cp2101_close,
-        .break_ctl              = cp2101_break_ctl,
-        .set_termios            = cp2101_set_termios,
-        .tiocmget               = cp2101_tiocmget,
-        .tiocmset               = cp2101_tiocmset,
-        .attach                 = cp2101_startup,
-        .shutdown               = cp2101_shutdown,
+        .open                   = cp210x_open,
+        .close                  = cp210x_close,
+        .break_ctl              = cp210x_break_ctl,
+        .set_termios            = cp210x_set_termios,
+        .tiocmget               = cp210x_tiocmget,
+        .tiocmset               = cp210x_tiocmset,
+        .attach                 = cp210x_startup,
+        .shutdown               = cp210x_shutdown,
 };
 
 /* Config request types */
 #define REQTYPE_HOST_TO_DEVICE  0x41
 #define REQTYPE_DEVICE_TO_HOST  0xc1
 
-/* Config SET requests. To GET, add 1 to the request number */
-#define CP2101_UART             0x00    /* Enable / Disable */
-#define CP2101_BAUDRATE         0x01    /* (BAUD_RATE_GEN_FREQ / baudrate) */
-#define CP2101_BITS             0x03    /* 0x(0)(databits)(parity)(stopbits) */
-#define CP2101_BREAK            0x05    /* On / Off */
-#define CP2101_CONTROL          0x07    /* Flow control line states */
-#define CP2101_MODEMCTL         0x13    /* Modem controls */
-#define CP2101_CONFIG_6         0x19    /* 6 bytes of config data ??? */
-
-/* CP2101_UART */
+/* Config request codes */
+#define CP210X_IFC_ENABLE       0x00
+#define CP210X_SET_BAUDDIV      0x01
+#define CP210X_GET_BAUDDIV      0x02
+#define CP210X_SET_LINE_CTL     0x03
+#define CP210X_GET_LINE_CTL     0x04
+#define CP210X_SET_BREAK        0x05
+#define CP210X_IMM_CHAR         0x06
+#define CP210X_SET_MHS          0x07
+#define CP210X_GET_MDMSTS       0x08
+#define CP210X_SET_XON          0x09
+#define CP210X_SET_XOFF         0x0A
+#define CP210X_SET_EVENTMASK    0x0B
+#define CP210X_GET_EVENTMASK    0x0C
+#define CP210X_SET_CHAR         0x0D
+#define CP210X_GET_CHARS        0x0E
+#define CP210X_GET_PROPS        0x0F
+#define CP210X_GET_COMM_STATUS  0x10
+#define CP210X_RESET            0x11
+#define CP210X_PURGE            0x12
+#define CP210X_SET_FLOW         0x13
+#define CP210X_GET_FLOW         0x14
+#define CP210X_EMBED_EVENTS     0x15
+#define CP210X_GET_EVENTSTATE   0x16
+#define CP210X_SET_CHARS        0x19
+
+/* CP210X_IFC_ENABLE */
 #define UART_ENABLE             0x0001
 #define UART_DISABLE            0x0000
 
-/* CP2101_BAUDRATE */
+/* CP210X_(SET|GET)_BAUDDIV */
 #define BAUD_RATE_GEN_FREQ      0x384000
 
-/* CP2101_BITS */
+/* CP210X_(SET|GET)_LINE_CTL */
 #define BITS_DATA_MASK          0X0f00
 #define BITS_DATA_5             0X0500
 #define BITS_DATA_6             0X0600
@@ -174,11 +197,11 @@ static struct usb_serial_driver cp2101_device = {
 #define BITS_STOP_1_5           0x0001
 #define BITS_STOP_2             0x0002
 
-/* CP2101_BREAK */
+/* CP210X_SET_BREAK */
 #define BREAK_ON                0x0000
 #define BREAK_OFF               0x0001
 
-/* CP2101_CONTROL */
+/* CP210X_(SET_MHS|GET_MDMSTS) */
 #define CONTROL_DTR             0x0001
 #define CONTROL_RTS             0x0002
 #define CONTROL_CTS             0x0010
@@ -189,13 +212,13 @@ static struct usb_serial_driver cp2101_device = {
 #define CONTROL_WRITE_RTS       0x0200
 
 /*
- * cp2101_get_config
- * Reads from the CP2101 configuration registers
+ * cp210x_get_config
+ * Reads from the CP210x configuration registers
  * 'size' is specified in bytes.
  * 'data' is a pointer to a pre-allocated array of integers large
  * enough to hold 'size' bytes (with 4 bytes to each integer)
  */
-static int cp2101_get_config(struct usb_serial_port *port, u8 request,
+static int cp210x_get_config(struct usb_serial_port *port, u8 request,
                 unsigned int *data, int size)
 {
         struct usb_serial *serial = port->serial;
@@ -211,9 +234,6 @@ static int cp2101_get_config(struct usb_serial_port *port, u8 request,
                 return -ENOMEM;
         }
 
-        /* For get requests, the request number must be incremented */
-        request++;
-
         /* Issue the request, attempting to read 'size' bytes */
         result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
                                 request, REQTYPE_DEVICE_TO_HOST, 0x0000,
@@ -236,12 +256,12 @@ static int cp2101_get_config(struct usb_serial_port *port, u8 request,
 }
 
 /*
- * cp2101_set_config
- * Writes to the CP2101 configuration registers
+ * cp210x_set_config
+ * Writes to the CP210x configuration registers
  * Values less than 16 bits wide are sent directly
  * 'size' is specified in bytes.
  */
-static int cp2101_set_config(struct usb_serial_port *port, u8 request,
+static int cp210x_set_config(struct usb_serial_port *port, u8 request,
                 unsigned int *data, int size)
 {
         struct usb_serial *serial = port->serial;
@@ -292,21 +312,21 @@ static int cp2101_set_config(struct usb_serial_port *port, u8 request,
 }
 
 /*
- * cp2101_set_config_single
- * Convenience function for calling cp2101_set_config on single data values
+ * cp210x_set_config_single
+ * Convenience function for calling cp210x_set_config on single data values
  * without requiring an integer pointer
  */
-static inline int cp2101_set_config_single(struct usb_serial_port *port,
+static inline int cp210x_set_config_single(struct usb_serial_port *port,
                 u8 request, unsigned int data)
 {
-        return cp2101_set_config(port, request, &data, 2);
+        return cp210x_set_config(port, request, &data, 2);
 }
 
 /*
- * cp2101_quantise_baudrate
+ * cp210x_quantise_baudrate
  * Quantises the baud rate as per AN205 Table 1
  */
-static unsigned int cp2101_quantise_baudrate(unsigned int baud) {
+static unsigned int cp210x_quantise_baudrate(unsigned int baud) {
         if      (baud <= 56)       baud = 0;
         else if (baud <= 300)      baud = 300;
         else if (baud <= 600)      baud = 600;
@@ -343,7 +363,7 @@ static unsigned int cp2101_quantise_baudrate(unsigned int baud) {
         return baud;
 }
 
-static int cp2101_open(struct tty_struct *tty, struct usb_serial_port *port,
+static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *port,
                                 struct file *filp)
 {
         struct usb_serial *serial = port->serial;
@@ -351,7 +371,7 @@ static int cp2101_open(struct tty_struct *tty, struct usb_serial_port *port,
 
         dbg("%s - port %d", __func__, port->number);
 
-        if (cp2101_set_config_single(port, CP2101_UART, UART_ENABLE)) {
+        if (cp210x_set_config_single(port, CP210X_IFC_ENABLE, UART_ENABLE)) {
                 dev_err(&port->dev, "%s - Unable to enable UART\n",
                                 __func__);
                 return -EPROTO;
@@ -373,17 +393,17 @@ static int cp2101_open(struct tty_struct *tty, struct usb_serial_port *port,
         }
 
         /* Configure the termios structure */
-        cp2101_get_termios(tty, port);
+        cp210x_get_termios(tty, port);
 
         /* Set the DTR and RTS pins low */
-        cp2101_tiocmset_port(tty ? (struct usb_serial_port *) tty->driver_data
+        cp210x_tiocmset_port(tty ? (struct usb_serial_port *) tty->driver_data
                         : port,
                 NULL, TIOCM_DTR | TIOCM_RTS, 0);
 
         return 0;
 }
 
-static void cp2101_cleanup(struct usb_serial_port *port)
+static void cp210x_cleanup(struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
 
@@ -398,8 +418,7 @@ static void cp2101_cleanup(struct usb_serial_port *port)
         }
 }
 
-static void cp2101_close(struct tty_struct *tty, struct usb_serial_port *port,
-                                        struct file *filp)
+static void cp210x_close(struct usb_serial_port *port)
 {
         dbg("%s - port %d", __func__, port->number);
 
@@ -410,23 +429,23 @@ static void cp2101_close(struct tty_struct *tty, struct usb_serial_port *port,
 
         mutex_lock(&port->serial->disc_mutex);
         if (!port->serial->disconnected)
-                cp2101_set_config_single(port, CP2101_UART, UART_DISABLE);
+                cp210x_set_config_single(port, CP210X_IFC_ENABLE, UART_DISABLE);
         mutex_unlock(&port->serial->disc_mutex);
 }
 
 /*
- * cp2101_get_termios
+ * cp210x_get_termios
  * Reads the baud rate, data bits, parity, stop bits and flow control mode
  * from the device, corrects any unsupported values, and configures the
  * termios structure to reflect the state of the device
  */
-static void cp2101_get_termios(struct tty_struct *tty,
+static void cp210x_get_termios(struct tty_struct *tty,
         struct usb_serial_port *port)
 {
         unsigned int baud;
 
         if (tty) {
-                cp2101_get_termios_port(tty->driver_data,
+                cp210x_get_termios_port(tty->driver_data,
                         &tty->termios->c_cflag, &baud);
                 tty_encode_baud_rate(tty, baud, baud);
         }
@@ -434,15 +453,15 @@ static void cp2101_get_termios(struct tty_struct *tty,
         else {
                 unsigned int cflag;
                 cflag = 0;
-                cp2101_get_termios_port(port, &cflag, &baud);
+                cp210x_get_termios_port(port, &cflag, &baud);
         }
 }
 
 /*
- * cp2101_get_termios_port
- * This is the heart of cp2101_get_termios which always uses a &usb_serial_port.
+ * cp210x_get_termios_port
+ * This is the heart of cp210x_get_termios which always uses a &usb_serial_port.
  */
-static void cp2101_get_termios_port(struct usb_serial_port *port,
+static void cp210x_get_termios_port(struct usb_serial_port *port,
         unsigned int *cflagp, unsigned int *baudp)
 {
         unsigned int cflag, modem_ctl[4];
@@ -451,17 +470,17 @@ static void cp2101_get_termios_port(struct usb_serial_port *port,
 
         dbg("%s - port %d", __func__, port->number);
 
-        cp2101_get_config(port, CP2101_BAUDRATE, &baud, 2);
+        cp210x_get_config(port, CP210X_GET_BAUDDIV, &baud, 2);
         /* Convert to baudrate */
         if (baud)
-                baud = cp2101_quantise_baudrate((BAUD_RATE_GEN_FREQ + baud/2)/ baud);
+                baud = cp210x_quantise_baudrate((BAUD_RATE_GEN_FREQ + baud/2)/ baud);
 
         dbg("%s - baud rate = %d", __func__, baud);
         *baudp = baud;
 
         cflag = *cflagp;
 
-        cp2101_get_config(port, CP2101_BITS, &bits, 2);
+        cp210x_get_config(port, CP210X_GET_LINE_CTL, &bits, 2);
         cflag &= ~CSIZE;
         switch (bits & BITS_DATA_MASK) {
         case BITS_DATA_5:
@@ -486,14 +505,14 @@ static void cp2101_get_termios_port(struct usb_serial_port *port,
                 cflag |= CS8;
                 bits &= ~BITS_DATA_MASK;
                 bits |= BITS_DATA_8;
-                cp2101_set_config(port, CP2101_BITS, &bits, 2);
+                cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2);
                 break;
         default:
                 dbg("%s - Unknown number of data bits, using 8", __func__);
                 cflag |= CS8;
                 bits &= ~BITS_DATA_MASK;
                 bits |= BITS_DATA_8;
-                cp2101_set_config(port, CP2101_BITS, &bits, 2);
+                cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2);
                 break;
         }
 
@@ -516,20 +535,20 @@ static void cp2101_get_termios_port(struct usb_serial_port *port,
                                 __func__);
                 cflag &= ~PARENB;
                 bits &= ~BITS_PARITY_MASK;
-                cp2101_set_config(port, CP2101_BITS, &bits, 2);
+                cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2);
                 break;
         case BITS_PARITY_SPACE:
                 dbg("%s - parity = SPACE (not supported, disabling parity)",
                                 __func__);
                 cflag &= ~PARENB;
                 bits &= ~BITS_PARITY_MASK;
-                cp2101_set_config(port, CP2101_BITS, &bits, 2);
+                cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2);
                 break;
         default:
                 dbg("%s - Unknown parity mode, disabling parity", __func__);
                 cflag &= ~PARENB;
                 bits &= ~BITS_PARITY_MASK;
-                cp2101_set_config(port, CP2101_BITS, &bits, 2);
+                cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2);
                 break;
         }
 
@@ -542,7 +561,7 @@ static void cp2101_get_termios_port(struct usb_serial_port *port,
                 dbg("%s - stop bits = 1.5 (not supported, using 1 stop bit)",
                                                                 __func__);
                 bits &= ~BITS_STOP_MASK;
-                cp2101_set_config(port, CP2101_BITS, &bits, 2);
+                cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2);
                 break;
         case BITS_STOP_2:
                 dbg("%s - stop bits = 2", __func__);
@@ -552,11 +571,11 @@ static void cp2101_get_termios_port(struct usb_serial_port *port,
                 dbg("%s - Unknown number of stop bits, using 1 stop bit",
                                                                 __func__);
                 bits &= ~BITS_STOP_MASK;
-                cp2101_set_config(port, CP2101_BITS, &bits, 2);
+                cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2);
                 break;
         }
 
-        cp2101_get_config(port, CP2101_MODEMCTL, modem_ctl, 16);
+        cp210x_get_config(port, CP210X_GET_FLOW, modem_ctl, 16);
         if (modem_ctl[0] & 0x0008) {
                 dbg("%s - flow control = CRTSCTS", __func__);
                 cflag |= CRTSCTS;
@@ -568,7 +587,7 @@ static void cp2101_get_termios_port(struct usb_serial_port *port,
         *cflagp = cflag;
 }
 
-static void cp2101_set_termios(struct tty_struct *tty,
+static void cp210x_set_termios(struct tty_struct *tty,
                 struct usb_serial_port *port, struct ktermios *old_termios)
 {
         unsigned int cflag, old_cflag;
@@ -583,13 +602,13 @@ static void cp2101_set_termios(struct tty_struct *tty,
         tty->termios->c_cflag &= ~CMSPAR;
         cflag = tty->termios->c_cflag;
         old_cflag = old_termios->c_cflag;
-        baud = cp2101_quantise_baudrate(tty_get_baud_rate(tty));
+        baud = cp210x_quantise_baudrate(tty_get_baud_rate(tty));
 
         /* If the baud rate is to be updated*/
         if (baud != tty_termios_baud_rate(old_termios) && baud != 0) {
                 dbg("%s - Setting baud rate to %d baud", __func__,
                                 baud);
-                if (cp2101_set_config_single(port, CP2101_BAUDRATE,
+                if (cp210x_set_config_single(port, CP210X_SET_BAUDDIV,
                                         ((BAUD_RATE_GEN_FREQ + baud/2) / baud))) {
                         dbg("Baud rate requested not supported by device\n");
                         baud = tty_termios_baud_rate(old_termios);
@@ -600,7 +619,7 @@ static void cp2101_set_termios(struct tty_struct *tty,
 
         /* If the number of data bits is to be updated */
         if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
-                cp2101_get_config(port, CP2101_BITS, &bits, 2);
+                cp210x_get_config(port, CP210X_GET_LINE_CTL, &bits, 2);
                 bits &= ~BITS_DATA_MASK;
                 switch (cflag & CSIZE) {
                 case CS5:
@@ -624,19 +643,19 @@ static void cp2101_set_termios(struct tty_struct *tty,
                         dbg("%s - data bits = 9", __func__);
                         break;*/
                 default:
-                        dbg("cp2101 driver does not "
+                        dbg("cp210x driver does not "
                                         "support the number of bits requested,"
                                         " using 8 bit mode\n");
                                 bits |= BITS_DATA_8;
                                 break;
                 }
-                if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
+                if (cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2))
                         dbg("Number of data bits requested "
                                         "not supported by device\n");
         }
 
         if ((cflag & (PARENB|PARODD)) != (old_cflag & (PARENB|PARODD))) {
-                cp2101_get_config(port, CP2101_BITS, &bits, 2);
+                cp210x_get_config(port, CP210X_GET_LINE_CTL, &bits, 2);
                 bits &= ~BITS_PARITY_MASK;
                 if (cflag & PARENB) {
                         if (cflag & PARODD) {
@@ -647,13 +666,13 @@ static void cp2101_set_termios(struct tty_struct *tty,
                                 dbg("%s - parity = EVEN", __func__);
                         }
                 }
-                if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
+                if (cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2))
                         dbg("Parity mode not supported "
                                         "by device\n");
         }
 
         if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) {
-                cp2101_get_config(port, CP2101_BITS, &bits, 2);
+                cp210x_get_config(port, CP210X_GET_LINE_CTL, &bits, 2);
                 bits &= ~BITS_STOP_MASK;
                 if (cflag & CSTOPB) {
                         bits |= BITS_STOP_2;
@@ -662,13 +681,13 @@ static void cp2101_set_termios(struct tty_struct *tty,
                         bits |= BITS_STOP_1;
                         dbg("%s - stop bits = 1", __func__);
                 }
-                if (cp2101_set_config(port, CP2101_BITS, &bits, 2))
+                if (cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2))
                         dbg("Number of stop bits requested "
                                         "not supported by device\n");
         }
 
         if ((cflag & CRTSCTS) != (old_cflag & CRTSCTS)) {
-                cp2101_get_config(port, CP2101_MODEMCTL, modem_ctl, 16);
+                cp210x_get_config(port, CP210X_GET_FLOW, modem_ctl, 16);
                 dbg("%s - read modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x",
                                 __func__, modem_ctl[0], modem_ctl[1],
                                 modem_ctl[2], modem_ctl[3]);
@@ -688,19 +707,19 @@ static void cp2101_set_termios(struct tty_struct *tty,
                 dbg("%s - write modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x",
                                 __func__, modem_ctl[0], modem_ctl[1],
                                 modem_ctl[2], modem_ctl[3]);
-                cp2101_set_config(port, CP2101_MODEMCTL, modem_ctl, 16);
+                cp210x_set_config(port, CP210X_SET_FLOW, modem_ctl, 16);
         }
 
 }
 
-static int cp2101_tiocmset (struct tty_struct *tty, struct file *file,
+static int cp210x_tiocmset (struct tty_struct *tty, struct file *file,
                 unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
-        return cp2101_tiocmset_port(port, file, set, clear);
+        return cp210x_tiocmset_port(port, file, set, clear);
 }
 
-static int cp2101_tiocmset_port(struct usb_serial_port *port, struct file *file,
+static int cp210x_tiocmset_port(struct usb_serial_port *port, struct file *file,
                 unsigned int set, unsigned int clear)
 {
         unsigned int control = 0;
@@ -726,10 +745,10 @@ static int cp2101_tiocmset_port(struct usb_serial_port *port, struct file *file,
 
         dbg("%s - control = 0x%.4x", __func__, control);
 
-        return cp2101_set_config(port, CP2101_CONTROL, &control, 2);
+        return cp210x_set_config(port, CP210X_SET_MHS, &control, 2);
 }
 
-static int cp2101_tiocmget (struct tty_struct *tty, struct file *file)
+static int cp210x_tiocmget (struct tty_struct *tty, struct file *file)
 {
         struct usb_serial_port *port = tty->driver_data;
         unsigned int control;
@@ -737,7 +756,7 @@ static int cp2101_tiocmget (struct tty_struct *tty, struct file *file)
 
         dbg("%s - port %d", __func__, port->number);
 
-        cp2101_get_config(port, CP2101_CONTROL, &control, 1);
+        cp210x_get_config(port, CP210X_GET_MDMSTS, &control, 1);
 
         result = ((control & CONTROL_DTR) ? TIOCM_DTR : 0)
                 |((control & CONTROL_RTS) ? TIOCM_RTS : 0)
@@ -751,7 +770,7 @@ static int cp2101_tiocmget (struct tty_struct *tty, struct file *file)
         return result;
 }
 
-static void cp2101_break_ctl (struct tty_struct *tty, int break_state)
+static void cp210x_break_ctl (struct tty_struct *tty, int break_state)
 {
         struct usb_serial_port *port = tty->driver_data;
         unsigned int state;
@@ -763,17 +782,17 @@ static void cp2101_break_ctl (struct tty_struct *tty, int break_state)
                 state = BREAK_ON;
         dbg("%s - turning break %s", __func__,
                         state == BREAK_OFF ? "off" : "on");
-        cp2101_set_config(port, CP2101_BREAK, &state, 2);
+        cp210x_set_config(port, CP210X_SET_BREAK, &state, 2);
 }
 
-static int cp2101_startup(struct usb_serial *serial)
+static int cp210x_startup(struct usb_serial *serial)
 {
-        /* CP2101 buffers behave strangely unless device is reset */
+        /* cp210x buffers behave strangely unless device is reset */
         usb_reset_device(serial->dev);
         return 0;
 }
 
-static void cp2101_shutdown(struct usb_serial *serial)
+static void cp210x_shutdown(struct usb_serial *serial)
 {
         int i;
 
@@ -781,21 +800,21 @@ static void cp2101_shutdown(struct usb_serial *serial)
 
         /* Stop reads and writes on all ports */
         for (i = 0; i < serial->num_ports; ++i)
-                cp2101_cleanup(serial->port[i]);
+                cp210x_cleanup(serial->port[i]);
 }
 
-static int __init cp2101_init(void)
+static int __init cp210x_init(void)
 {
         int retval;
 
-        retval = usb_serial_register(&cp2101_device);
+        retval = usb_serial_register(&cp210x_device);
         if (retval)
                 return retval; /* Failed to register */
 
-        retval = usb_register(&cp2101_driver);
+        retval = usb_register(&cp210x_driver);
         if (retval) {
                 /* Failed to register */
-                usb_serial_deregister(&cp2101_device);
+                usb_serial_deregister(&cp210x_device);
                 return retval;
         }
 
@@ -805,14 +824,14 @@ static int __init cp2101_init(void)
         return 0;
 }
 
-static void __exit cp2101_exit(void)
+static void __exit cp210x_exit(void)
 {
-        usb_deregister(&cp2101_driver);
-        usb_serial_deregister(&cp2101_device);
+        usb_deregister(&cp210x_driver);
+        usb_serial_deregister(&cp210x_device);
 }
 
-module_init(cp2101_init);
-module_exit(cp2101_exit);
+module_init(cp210x_init);
+module_exit(cp210x_exit);
 
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_VERSION(DRIVER_VERSION);
diff --git a/drivers/usb/serial/cyberjack.c b/drivers/usb/serial/cyberjack.c
index dd501bb63ed6..933ba913e66c 100644
--- a/drivers/usb/serial/cyberjack.c
+++ b/drivers/usb/serial/cyberjack.c
@@ -61,8 +61,7 @@ static int cyberjack_startup(struct usb_serial *serial);
 static void cyberjack_shutdown(struct usb_serial *serial);
 static int  cyberjack_open(struct tty_struct *tty,
                         struct usb_serial_port *port, struct file *filp);
-static void cyberjack_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+static void cyberjack_close(struct usb_serial_port *port);
 static int cyberjack_write(struct tty_struct *tty,
         struct usb_serial_port *port, const unsigned char *buf, int count);
 static int cyberjack_write_room(struct tty_struct *tty);
@@ -185,8 +184,7 @@ static int  cyberjack_open(struct tty_struct *tty,
         return result;
 }
 
-static void cyberjack_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void cyberjack_close(struct usb_serial_port *port)
 {
         dbg("%s - port %d", __func__, port->number);
 
diff --git a/drivers/usb/serial/cypress_m8.c b/drivers/usb/serial/cypress_m8.c
index e568710b263f..669f93848539 100644
--- a/drivers/usb/serial/cypress_m8.c
+++ b/drivers/usb/serial/cypress_m8.c
@@ -174,8 +174,8 @@ static int  cypress_ca42v2_startup(struct usb_serial *serial);
 static void cypress_shutdown(struct usb_serial *serial);
 static int  cypress_open(struct tty_struct *tty,
                         struct usb_serial_port *port, struct file *filp);
-static void cypress_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+static void cypress_close(struct usb_serial_port *port);
+static void cypress_dtr_rts(struct usb_serial_port *port, int on);
 static int  cypress_write(struct tty_struct *tty, struct usb_serial_port *port,
                         const unsigned char *buf, int count);
 static void cypress_send(struct usb_serial_port *port);
@@ -218,6 +218,7 @@ static struct usb_serial_driver cypress_earthmate_device = {
         .shutdown =                     cypress_shutdown,
         .open =                         cypress_open,
         .close =                        cypress_close,
+        .dtr_rts =                      cypress_dtr_rts,
         .write =                        cypress_write,
         .write_room =                   cypress_write_room,
         .ioctl =                        cypress_ioctl,
@@ -244,6 +245,7 @@ static struct usb_serial_driver cypress_hidcom_device = {
         .shutdown =                     cypress_shutdown,
         .open =                         cypress_open,
         .close =                        cypress_close,
+        .dtr_rts =                      cypress_dtr_rts,
         .write =                        cypress_write,
         .write_room =                   cypress_write_room,
         .ioctl =                        cypress_ioctl,
@@ -270,6 +272,7 @@ static struct usb_serial_driver cypress_ca42v2_device = {
         .shutdown =                     cypress_shutdown,
         .open =                         cypress_open,
         .close =                        cypress_close,
+        .dtr_rts =                      cypress_dtr_rts,
         .write =                        cypress_write,
         .write_room =                   cypress_write_room,
         .ioctl =                        cypress_ioctl,
@@ -656,11 +659,7 @@ static int cypress_open(struct tty_struct *tty,
         priv->rx_flags = 0;
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        /* raise both lines and set termios */
-        spin_lock_irqsave(&priv->lock, flags);
-        priv->line_control = CONTROL_DTR | CONTROL_RTS;
-        priv->cmd_ctrl = 1;
-        spin_unlock_irqrestore(&priv->lock, flags);
+        /* Set termios */
         result = cypress_write(tty, port, NULL, 0);
 
         if (result) {
@@ -694,76 +693,42 @@ static int cypress_open(struct tty_struct *tty,
                                                         __func__, result);
                 cypress_set_dead(port);
         }
-
+        port->port.drain_delay = 256;
         return result;
 } /* cypress_open */
 
+static void cypress_dtr_rts(struct usb_serial_port *port, int on)
+{
+        struct cypress_private *priv = usb_get_serial_port_data(port);
+        /* drop dtr and rts */
+        priv = usb_get_serial_port_data(port);
+        spin_lock_irq(&priv->lock);
+        if (on == 0)
+                priv->line_control = 0;
+        else 
+                priv->line_control = CONTROL_DTR | CONTROL_RTS;
+        priv->cmd_ctrl = 1;
+        spin_unlock_irq(&priv->lock);
+        cypress_write(NULL, port, NULL, 0);
+}
 
-static void cypress_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void cypress_close(struct usb_serial_port *port)
 {
         struct cypress_private *priv = usb_get_serial_port_data(port);
-        unsigned int c_cflag;
-        int bps;
-        long timeout;
-        wait_queue_t wait;
 
         dbg("%s - port %d", __func__, port->number);
 
-        /* wait for data to drain from buffer */
-        spin_lock_irq(&priv->lock);
-        timeout = CYPRESS_CLOSING_WAIT;
-        init_waitqueue_entry(&wait, current);
-        add_wait_queue(&tty->write_wait, &wait);
-        for (;;) {
-                set_current_state(TASK_INTERRUPTIBLE);
-                if (cypress_buf_data_avail(priv->buf) == 0
-                || timeout == 0 || signal_pending(current)
-                /* without mutex, allowed due to harmless failure mode */
-                || port->serial->disconnected)
-                        break;
-                spin_unlock_irq(&priv->lock);
-                timeout = schedule_timeout(timeout);
-                spin_lock_irq(&priv->lock);
-        }
-        set_current_state(TASK_RUNNING);
-        remove_wait_queue(&tty->write_wait, &wait);
-        /* clear out any remaining data in the buffer */
-        cypress_buf_clear(priv->buf);
-        spin_unlock_irq(&priv->lock);
-
         /* writing is potentially harmful, lock must be taken */
         mutex_lock(&port->serial->disc_mutex);
         if (port->serial->disconnected) {
                 mutex_unlock(&port->serial->disc_mutex);
                 return;
         }
-        /* wait for characters to drain from device */
-        if (tty) {
-                bps = tty_get_baud_rate(tty);
-                if (bps > 1200)
-                        timeout = max((HZ * 2560) / bps, HZ / 10);
-                else
-                        timeout = 2 * HZ;
-                schedule_timeout_interruptible(timeout);
-        }
-
+        cypress_buf_clear(priv->buf);
         dbg("%s - stopping urbs", __func__);
         usb_kill_urb(port->interrupt_in_urb);
         usb_kill_urb(port->interrupt_out_urb);
 
-        if (tty) {
-                c_cflag = tty->termios->c_cflag;
-                if (c_cflag & HUPCL) {
-                        /* drop dtr and rts */
-                        priv = usb_get_serial_port_data(port);
-                        spin_lock_irq(&priv->lock);
-                        priv->line_control = 0;
-                        priv->cmd_ctrl = 1;
-                        spin_unlock_irq(&priv->lock);
-                        cypress_write(tty, port, NULL, 0);
-                }
-        }
 
         if (stats)
                 dev_info(&port->dev, "Statistics: %d Bytes In | %d Bytes Out | %d Commands Issued\n",
diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c
index 38ba4ea8b6bf..30f5140eff03 100644
--- a/drivers/usb/serial/digi_acceleport.c
+++ b/drivers/usb/serial/digi_acceleport.c
@@ -422,7 +422,6 @@ struct digi_port {
         int dp_throttled;
         int dp_throttle_restart;
         wait_queue_head_t dp_flush_wait;
-        int dp_in_close;                        /* close in progress */
         wait_queue_head_t dp_close_wait;        /* wait queue for close */
         struct work_struct dp_wakeup_work;
         struct usb_serial_port *dp_port;
@@ -456,8 +455,9 @@ static int digi_write_room(struct tty_struct *tty);
 static int digi_chars_in_buffer(struct tty_struct *tty);
 static int digi_open(struct tty_struct *tty, struct usb_serial_port *port,
         struct file *filp);
-static void digi_close(struct tty_struct *tty, struct usb_serial_port *port,
-        struct file *filp);
+static void digi_close(struct usb_serial_port *port);
+static int digi_carrier_raised(struct usb_serial_port *port);
+static void digi_dtr_rts(struct usb_serial_port *port, int on);
 static int digi_startup_device(struct usb_serial *serial);
 static int digi_startup(struct usb_serial *serial);
 static void digi_shutdown(struct usb_serial *serial);
@@ -510,6 +510,8 @@ static struct usb_serial_driver digi_acceleport_2_device = {
         .num_ports =                    3,
         .open =                         digi_open,
         .close =                        digi_close,
+        .dtr_rts =                      digi_dtr_rts,
+        .carrier_raised =               digi_carrier_raised,
         .write =                        digi_write,
         .write_room =                   digi_write_room,
         .write_bulk_callback =          digi_write_bulk_callback,
@@ -1328,6 +1330,19 @@ static int digi_chars_in_buffer(struct tty_struct *tty)
 
 }
 
+static void digi_dtr_rts(struct usb_serial_port *port, int on)
+{
+        /* Adjust DTR and RTS */
+        digi_set_modem_signals(port, on * (TIOCM_DTR|TIOCM_RTS), 1);
+}
+
+static int digi_carrier_raised(struct usb_serial_port *port)
+{
+        struct digi_port *priv = usb_get_serial_port_data(port);
+        if (priv->dp_modem_signals & TIOCM_CD)
+                return 1;
+        return 0;
+}
 
 static int digi_open(struct tty_struct *tty, struct usb_serial_port *port,
                                 struct file *filp)
@@ -1336,7 +1351,6 @@ static int digi_open(struct tty_struct *tty, struct usb_serial_port *port,
         unsigned char buf[32];
         struct digi_port *priv = usb_get_serial_port_data(port);
         struct ktermios not_termios;
-        unsigned long flags = 0;
 
         dbg("digi_open: TOP: port=%d, open_count=%d",
                 priv->dp_port_num, port->port.count);
@@ -1345,26 +1359,6 @@ static int digi_open(struct tty_struct *tty, struct usb_serial_port *port,
         if (digi_startup_device(port->serial) != 0)
                 return -ENXIO;
 
-        spin_lock_irqsave(&priv->dp_port_lock, flags);
-
-        /* don't wait on a close in progress for non-blocking opens */
-        if (priv->dp_in_close && (filp->f_flags&(O_NDELAY|O_NONBLOCK)) == 0) {
-                spin_unlock_irqrestore(&priv->dp_port_lock, flags);
-                return -EAGAIN;
-        }
-
-        /* wait for a close in progress to finish */
-        while (priv->dp_in_close) {
-                cond_wait_interruptible_timeout_irqrestore(
-                        &priv->dp_close_wait, DIGI_RETRY_TIMEOUT,
-                        &priv->dp_port_lock, flags);
-                if (signal_pending(current))
-                        return -EINTR;
-                spin_lock_irqsave(&priv->dp_port_lock, flags);
-        }
-
-        spin_unlock_irqrestore(&priv->dp_port_lock, flags);
-
         /* read modem signals automatically whenever they change */
         buf[0] = DIGI_CMD_READ_INPUT_SIGNALS;
         buf[1] = priv->dp_port_num;
@@ -1387,16 +1381,11 @@ static int digi_open(struct tty_struct *tty, struct usb_serial_port *port,
                 not_termios.c_iflag = ~tty->termios->c_iflag;
                 digi_set_termios(tty, port, &not_termios);
         }
-
-        /* set DTR and RTS */
-        digi_set_modem_signals(port, TIOCM_DTR|TIOCM_RTS, 1);
-
         return 0;
 }
 
 
-static void digi_close(struct tty_struct *tty, struct usb_serial_port *port,
-                                struct file *filp)
+static void digi_close(struct usb_serial_port *port)
 {
         DEFINE_WAIT(wait);
         int ret;
@@ -1411,28 +1400,9 @@ static void digi_close(struct tty_struct *tty, struct usb_serial_port *port,
         if (port->serial->disconnected)
                 goto exit;
 
-        /* do cleanup only after final close on this port */
-        spin_lock_irq(&priv->dp_port_lock);
-        priv->dp_in_close = 1;
-        spin_unlock_irq(&priv->dp_port_lock);
-
-        /* tell line discipline to process only XON/XOFF */
-        tty->closing = 1;
-
-        /* wait for output to drain */
-        if ((filp->f_flags&(O_NDELAY|O_NONBLOCK)) == 0)
-                tty_wait_until_sent(tty, DIGI_CLOSE_TIMEOUT);
-
-        /* flush driver and line discipline buffers */
-        tty_driver_flush_buffer(tty);
-        tty_ldisc_flush(tty);
-
         if (port->serial->dev) {
-                /* wait for transmit idle */
-                if ((filp->f_flags&(O_NDELAY|O_NONBLOCK)) == 0)
-                        digi_transmit_idle(port, DIGI_CLOSE_TIMEOUT);
-                /* drop DTR and RTS */
-                digi_set_modem_signals(port, 0, 0);
+                /* FIXME: Transmit idle belongs in the wait_unti_sent path */
+                digi_transmit_idle(port, DIGI_CLOSE_TIMEOUT);
 
                 /* disable input flow control */
                 buf[0] = DIGI_CMD_SET_INPUT_FLOW_CONTROL;
@@ -1477,11 +1447,9 @@ static void digi_close(struct tty_struct *tty, struct usb_serial_port *port,
                 /* shutdown any outstanding bulk writes */
                 usb_kill_urb(port->write_urb);
         }
-        tty->closing = 0;
 exit:
         spin_lock_irq(&priv->dp_port_lock);
         priv->dp_write_urb_in_use = 0;
-        priv->dp_in_close = 0;
         wake_up_interruptible(&priv->dp_close_wait);
         spin_unlock_irq(&priv->dp_port_lock);
         mutex_unlock(&port->serial->disc_mutex);
@@ -1560,7 +1528,6 @@ static int digi_startup(struct usb_serial *serial)
                 priv->dp_throttled = 0;
                 priv->dp_throttle_restart = 0;
                 init_waitqueue_head(&priv->dp_flush_wait);
-                priv->dp_in_close = 0;
                 init_waitqueue_head(&priv->dp_close_wait);
                 INIT_WORK(&priv->dp_wakeup_work, digi_wakeup_write_lock);
                 priv->dp_port = serial->port[i];
diff --git a/drivers/usb/serial/empeg.c b/drivers/usb/serial/empeg.c
index c709ec474a80..2b141ccb0cd9 100644
--- a/drivers/usb/serial/empeg.c
+++ b/drivers/usb/serial/empeg.c
@@ -81,8 +81,7 @@ static int debug;
 /* function prototypes for an empeg-car player */
 static int  empeg_open(struct tty_struct *tty, struct usb_serial_port *port,
                                                 struct file *filp);
-static void empeg_close(struct tty_struct *tty, struct usb_serial_port *port,
-                                                struct file *filp);
+static void empeg_close(struct usb_serial_port *port);
 static int  empeg_write(struct tty_struct *tty, struct usb_serial_port *port,
                                                 const unsigned char *buf,
                                                 int count);
@@ -181,8 +180,7 @@ static int empeg_open(struct tty_struct *tty, struct usb_serial_port *port,
 }
 
 
-static void empeg_close(struct tty_struct *tty, struct usb_serial_port *port,
-                                struct file *filp)
+static void empeg_close(struct usb_serial_port *port)
 {
         dbg("%s - port %d", __func__, port->number);
 
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index d9fcdaedf389..683304d60615 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -89,6 +89,7 @@ struct ftdi_private {
         int force_rtscts;       /* if non-zero, force RTS-CTS to always
                                    be enabled */
 
+        unsigned int latency;           /* latency setting in use */
         spinlock_t tx_lock;     /* spinlock for transmit state */
         unsigned long tx_bytes;
         unsigned long tx_outstanding_bytes;
@@ -719,8 +720,8 @@ static int  ftdi_sio_port_probe(struct usb_serial_port *port);
 static int  ftdi_sio_port_remove(struct usb_serial_port *port);
 static int  ftdi_open(struct tty_struct *tty,
                         struct usb_serial_port *port, struct file *filp);
-static void ftdi_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+static void ftdi_close(struct usb_serial_port *port);
+static void ftdi_dtr_rts(struct usb_serial_port *port, int on);
 static int  ftdi_write(struct tty_struct *tty, struct usb_serial_port *port,
                         const unsigned char *buf, int count);
 static int  ftdi_write_room(struct tty_struct *tty);
@@ -758,6 +759,7 @@ static struct usb_serial_driver ftdi_sio_device = {
         .port_remove =          ftdi_sio_port_remove,
         .open =                 ftdi_open,
         .close =                ftdi_close,
+        .dtr_rts =              ftdi_dtr_rts,
         .throttle =             ftdi_throttle,
         .unthrottle =           ftdi_unthrottle,
         .write =                ftdi_write,
@@ -1037,7 +1039,54 @@ static int change_speed(struct tty_struct *tty, struct usb_serial_port *port)
         return rv;
 }
 
+static int write_latency_timer(struct usb_serial_port *port)
+{
+        struct ftdi_private *priv = usb_get_serial_port_data(port);
+        struct usb_device *udev = port->serial->dev;
+        char buf[1];
+        int rv = 0;
+        int l = priv->latency;
+
+        if (priv->flags & ASYNC_LOW_LATENCY)
+                l = 1;
+
+        dbg("%s: setting latency timer = %i", __func__, l);
+
+        rv = usb_control_msg(udev,
+                             usb_sndctrlpipe(udev, 0),
+                             FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
+                             FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
+                             l, priv->interface,
+                             buf, 0, WDR_TIMEOUT);
+
+        if (rv < 0)
+                dev_err(&port->dev, "Unable to write latency timer: %i\n", rv);
+        return rv;
+}
+
+static int read_latency_timer(struct usb_serial_port *port)
+{
+        struct ftdi_private *priv = usb_get_serial_port_data(port);
+        struct usb_device *udev = port->serial->dev;
+        unsigned short latency = 0;
+        int rv = 0;
+
 
+        dbg("%s", __func__);
+
+        rv = usb_control_msg(udev,
+                             usb_rcvctrlpipe(udev, 0),
+                             FTDI_SIO_GET_LATENCY_TIMER_REQUEST,
+                             FTDI_SIO_GET_LATENCY_TIMER_REQUEST_TYPE,
+                             0, priv->interface,
+                             (char *) &latency, 1, WDR_TIMEOUT);
+
+        if (rv < 0) {
+                dev_err(&port->dev, "Unable to read latency timer: %i\n", rv);
+                return -EIO;
+        }
+        return latency;
+}
 
 static int get_serial_info(struct usb_serial_port *port,
                                 struct serial_struct __user *retinfo)
@@ -1097,6 +1146,7 @@ static int set_serial_info(struct tty_struct *tty,
         priv->custom_divisor = new_serial.custom_divisor;
 
         tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
+        write_latency_timer(port);
 
 check_and_exit:
         if ((old_priv.flags & ASYNC_SPD_MASK) !=
@@ -1192,27 +1242,13 @@ static ssize_t show_latency_timer(struct device *dev,
 {
         struct usb_serial_port *port = to_usb_serial_port(dev);
         struct ftdi_private *priv = usb_get_serial_port_data(port);
-        struct usb_device *udev = port->serial->dev;
-        unsigned short latency = 0;
-        int rv = 0;
-
-
-        dbg("%s", __func__);
-
-        rv = usb_control_msg(udev,
-                             usb_rcvctrlpipe(udev, 0),
-                             FTDI_SIO_GET_LATENCY_TIMER_REQUEST,
-                             FTDI_SIO_GET_LATENCY_TIMER_REQUEST_TYPE,
-                             0, priv->interface,
-                             (char *) &latency, 1, WDR_TIMEOUT);
-
-        if (rv < 0) {
-                dev_err(dev, "Unable to read latency timer: %i\n", rv);
-                return -EIO;
-        }
-        return sprintf(buf, "%i\n", latency);
+        if (priv->flags & ASYNC_LOW_LATENCY)
+                return sprintf(buf, "1\n");
+        else
+                return sprintf(buf, "%i\n", priv->latency);
 }
 
+
 /* Write a new value of the latency timer, in units of milliseconds. */
 static ssize_t store_latency_timer(struct device *dev,
                         struct device_attribute *attr, const char *valbuf,
@@ -1220,25 +1256,13 @@ static ssize_t store_latency_timer(struct device *dev,
 {
         struct usb_serial_port *port = to_usb_serial_port(dev);
         struct ftdi_private *priv = usb_get_serial_port_data(port);
-        struct usb_device *udev = port->serial->dev;
-        char buf[1];
         int v = simple_strtoul(valbuf, NULL, 10);
         int rv = 0;
 
-        dbg("%s: setting latency timer = %i", __func__, v);
-
-        rv = usb_control_msg(udev,
-                             usb_sndctrlpipe(udev, 0),
-                             FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
-                             FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
-                             v, priv->interface,
-                             buf, 0, WDR_TIMEOUT);
-
-        if (rv < 0) {
-                dev_err(dev, "Unable to write latency timer: %i\n", rv);
+        priv->latency = v;
+        rv = write_latency_timer(port);
+        if (rv < 0)
                 return -EIO;
-        }
-
         return count;
 }
 
@@ -1392,6 +1416,7 @@ static int ftdi_sio_port_probe(struct usb_serial_port *port)
         usb_set_serial_port_data(port, priv);
 
         ftdi_determine_type(port);
+        read_latency_timer(port);
         create_sysfs_attrs(port);
         return 0;
 }
@@ -1514,6 +1539,8 @@ static int ftdi_open(struct tty_struct *tty,
         if (tty)
                 tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 
+        write_latency_timer(port);
+
         /* No error checking for this (will get errors later anyway) */
         /* See ftdi_sio.h for description of what is reset */
         usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
@@ -1529,11 +1556,6 @@ static int ftdi_open(struct tty_struct *tty,
         if (tty)
                 ftdi_set_termios(tty, port, tty->termios);
 
-        /* FIXME: Flow control might be enabled, so it should be checked -
-           we have no control of defaults! */
-        /* Turn on RTS and DTR since we are not flow controlling by default */
-        set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
-
         /* Not throttled */
         spin_lock_irqsave(&priv->rx_lock, flags);
         priv->rx_flags &= ~(THROTTLED | ACTUALLY_THROTTLED);
@@ -1558,6 +1580,30 @@ static int ftdi_open(struct tty_struct *tty,
 } /* ftdi_open */
 
 
+static void ftdi_dtr_rts(struct usb_serial_port *port, int on)
+{
+        struct ftdi_private *priv = usb_get_serial_port_data(port);
+        char buf[1];
+
+        mutex_lock(&port->serial->disc_mutex);
+        if (!port->serial->disconnected) {
+                /* Disable flow control */
+                if (!on && usb_control_msg(port->serial->dev,
+                            usb_sndctrlpipe(port->serial->dev, 0),
+                            FTDI_SIO_SET_FLOW_CTRL_REQUEST,
+                            FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
+                            0, priv->interface, buf, 0,
+                            WDR_TIMEOUT) < 0) {
+                            dev_err(&port->dev, "error from flowcontrol urb\n");
+                }
+                /* drop RTS and DTR */
+                if (on)
+                        set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
+                else
+                        clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
+        }
+        mutex_unlock(&port->serial->disc_mutex);
+}
 
 /*
  * usbserial:__serial_close  only calls ftdi_close if the point is open
@@ -1567,31 +1613,12 @@ static int ftdi_open(struct tty_struct *tty,
  *
  */
 
-static void ftdi_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void ftdi_close(struct usb_serial_port *port)
 { /* ftdi_close */
-        unsigned int c_cflag = tty->termios->c_cflag;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
-        char buf[1];
 
         dbg("%s", __func__);
 
-        mutex_lock(&port->serial->disc_mutex);
-        if (c_cflag & HUPCL && !port->serial->disconnected) {
-                /* Disable flow control */
-                if (usb_control_msg(port->serial->dev,
-                                    usb_sndctrlpipe(port->serial->dev, 0),
-                                    FTDI_SIO_SET_FLOW_CTRL_REQUEST,
-                                    FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
-                                    0, priv->interface, buf, 0,
-                                    WDR_TIMEOUT) < 0) {
-                        dev_err(&port->dev, "error from flowcontrol urb\n");
-                }
-
-                /* drop RTS and DTR */
-                clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
-        } /* Note change no line if hupcl is off */
-        mutex_unlock(&port->serial->disc_mutex);
 
         /* cancel any scheduled reading */
         cancel_delayed_work_sync(&priv->rx_work);
diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c
index 586d30ff450b..ee25a3fe3b09 100644
--- a/drivers/usb/serial/garmin_gps.c
+++ b/drivers/usb/serial/garmin_gps.c
@@ -993,8 +993,7 @@ static int garmin_open(struct tty_struct *tty,
 }
 
 
-static void garmin_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void garmin_close(struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
         struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c
index 4cec9906ccf3..be82ea956720 100644
--- a/drivers/usb/serial/generic.c
+++ b/drivers/usb/serial/generic.c
@@ -184,8 +184,7 @@ int usb_serial_generic_resume(struct usb_serial *serial)
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_resume);
 
-void usb_serial_generic_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+void usb_serial_generic_close(struct usb_serial_port *port)
 {
         dbg("%s - port %d", __func__, port->number);
         generic_cleanup(port);
diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c
index fb4a73d090f6..53ef5996e33d 100644
--- a/drivers/usb/serial/io_edgeport.c
+++ b/drivers/usb/serial/io_edgeport.c
@@ -207,8 +207,7 @@ static void edge_bulk_out_cmd_callback(struct urb *urb);
 /* function prototypes for the usbserial callbacks */
 static int edge_open(struct tty_struct *tty, struct usb_serial_port *port,
                                         struct file *filp);
-static void edge_close(struct tty_struct *tty, struct usb_serial_port *port,
-                                        struct file *filp);
+static void edge_close(struct usb_serial_port *port);
 static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
                                         const unsigned char *buf, int count);
 static int edge_write_room(struct tty_struct *tty);
@@ -965,7 +964,7 @@ static int edge_open(struct tty_struct *tty,
 
         if (!edge_port->txfifo.fifo) {
                 dbg("%s - no memory", __func__);
-                edge_close(tty, port, filp);
+                edge_close(port);
                 return -ENOMEM;
         }
 
@@ -975,7 +974,7 @@ static int edge_open(struct tty_struct *tty,
 
         if (!edge_port->write_urb) {
                 dbg("%s - no memory", __func__);
-                edge_close(tty, port, filp);
+                edge_close(port);
                 return -ENOMEM;
         }
 
@@ -1099,8 +1098,7 @@ static void block_until_tx_empty(struct edgeport_port *edge_port)
  * edge_close
  *      this function is called by the tty driver when a port is closed
  *****************************************************************************/
-static void edge_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void edge_close(struct usb_serial_port *port)
 {
         struct edgeport_serial *edge_serial;
         struct edgeport_port *edge_port;
diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c
index 513b25e044c1..eabf20eeb370 100644
--- a/drivers/usb/serial/io_ti.c
+++ b/drivers/usb/serial/io_ti.c
@@ -2009,8 +2009,7 @@ release_es_lock:
         return status;
 }
 
-static void edge_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void edge_close(struct usb_serial_port *port)
 {
         struct edgeport_serial *edge_serial;
         struct edgeport_port *edge_port;
diff --git a/drivers/usb/serial/ipaq.c b/drivers/usb/serial/ipaq.c
index cd62825a9ac3..c610a99fa477 100644
--- a/drivers/usb/serial/ipaq.c
+++ b/drivers/usb/serial/ipaq.c
@@ -76,8 +76,7 @@ static int initial_wait;
 /* Function prototypes for an ipaq */
 static int  ipaq_open(struct tty_struct *tty,
                         struct usb_serial_port *port, struct file *filp);
-static void ipaq_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+static void ipaq_close(struct usb_serial_port *port);
 static int  ipaq_calc_num_ports(struct usb_serial *serial);
 static int  ipaq_startup(struct usb_serial *serial);
 static void ipaq_shutdown(struct usb_serial *serial);
@@ -714,8 +713,7 @@ error:
 }
 
 
-static void ipaq_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void ipaq_close(struct usb_serial_port *port)
 {
         struct ipaq_private     *priv = usb_get_serial_port_data(port);
 
diff --git a/drivers/usb/serial/ipw.c b/drivers/usb/serial/ipw.c
index da2a2b46644a..29ad038b9c8d 100644
--- a/drivers/usb/serial/ipw.c
+++ b/drivers/usb/serial/ipw.c
@@ -302,23 +302,17 @@ static int ipw_open(struct tty_struct *tty,
         return 0;
 }
 
-static void ipw_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void ipw_dtr_rts(struct usb_serial_port *port, int on)
 {
         struct usb_device *dev = port->serial->dev;
         int result;
 
-        if (tty_hung_up_p(filp)) {
-                dbg("%s: tty_hung_up_p ...", __func__);
-                return;
-        }
-
         /*--1: drop the dtr */
         dbg("%s:dropping dtr", __func__);
         result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
                          IPW_SIO_SET_PIN,
                          USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
-                         IPW_PIN_CLRDTR,
+                         on ? IPW_PIN_SETDTR : IPW_PIN_CLRDTR,
                          0,
                          NULL,
                          0,
@@ -332,7 +326,7 @@ static void ipw_close(struct tty_struct *tty,
         result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
                          IPW_SIO_SET_PIN, USB_TYPE_VENDOR |
                                         USB_RECIP_INTERFACE | USB_DIR_OUT,
-                         IPW_PIN_CLRRTS,
+                         on ? IPW_PIN_SETRTS : IPW_PIN_CLRRTS,
                          0,
                          NULL,
                          0,
@@ -340,7 +334,12 @@ static void ipw_close(struct tty_struct *tty,
         if (result < 0)
                 dev_err(&port->dev,
                                 "dropping rts failed (error = %d)\n", result);
+}
 
+static void ipw_close(struct usb_serial_port *port)
+{
+        struct usb_device *dev = port->serial->dev;
+        int result;
 
         /*--3: purge */
         dbg("%s:sending purge", __func__);
@@ -461,6 +460,7 @@ static struct usb_serial_driver ipw_device = {
         .num_ports =            1,
         .open =                 ipw_open,
         .close =                ipw_close,
+        .dtr_rts =              ipw_dtr_rts,
         .port_probe =           ipw_probe,
         .port_remove =          ipw_disconnect,
         .write =                ipw_write,
diff --git a/drivers/usb/serial/ir-usb.c b/drivers/usb/serial/ir-usb.c
index 4e2cda93da59..66009b6b763a 100644
--- a/drivers/usb/serial/ir-usb.c
+++ b/drivers/usb/serial/ir-usb.c
@@ -88,8 +88,7 @@ static int xbof = -1;
 static int  ir_startup (struct usb_serial *serial);
 static int  ir_open(struct tty_struct *tty, struct usb_serial_port *port,
                                         struct file *filep);
-static void ir_close(struct tty_struct *tty, struct usb_serial_port *port,
-                                        struct file *filep);
+static void ir_close(struct usb_serial_port *port);
 static int  ir_write(struct tty_struct *tty, struct usb_serial_port *port,
                                         const unsigned char *buf, int count);
 static void ir_write_bulk_callback (struct urb *urb);
@@ -346,8 +345,7 @@ static int ir_open(struct tty_struct *tty,
         return result;
 }
 
-static void ir_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file * filp)
+static void ir_close(struct usb_serial_port *port)
 {
         dbg("%s - port %d", __func__, port->number);
 
diff --git a/drivers/usb/serial/iuu_phoenix.c b/drivers/usb/serial/iuu_phoenix.c
index 4473d442b2aa..76a3cc327bb9 100644
--- a/drivers/usb/serial/iuu_phoenix.c
+++ b/drivers/usb/serial/iuu_phoenix.c
@@ -40,7 +40,7 @@ static int debug;
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v0.5"
+#define DRIVER_VERSION "v0.10"
 #define DRIVER_DESC "Infinity USB Unlimited Phoenix driver"
 
 static struct usb_device_id id_table[] = {
@@ -70,7 +70,6 @@ static void read_rxcmd_callback(struct urb *urb);
 struct iuu_private {
         spinlock_t lock;        /* store irq state */
         wait_queue_head_t delta_msr_wait;
-        u8 line_control;
         u8 line_status;
         u8 termios_initialized;
         int tiostatus;          /* store IUART SIGNAL for tiocmget call */
@@ -651,32 +650,33 @@ static int iuu_bulk_write(struct usb_serial_port *port)
         unsigned long flags;
         int result;
         int i;
+        int buf_len;
         char *buf_ptr = port->write_urb->transfer_buffer;
         dbg("%s - enter", __func__);
 
+        spin_lock_irqsave(&priv->lock, flags);
         *buf_ptr++ = IUU_UART_ESC;
         *buf_ptr++ = IUU_UART_TX;
         *buf_ptr++ = priv->writelen;
 
-        memcpy(buf_ptr, priv->writebuf,
-               priv->writelen);
+        memcpy(buf_ptr, priv->writebuf, priv->writelen);
+        buf_len = priv->writelen;
+        priv->writelen = 0;
+        spin_unlock_irqrestore(&priv->lock, flags);
         if (debug == 1) {
-                for (i = 0; i < priv->writelen; i++)
+                for (i = 0; i < buf_len; i++)
                         sprintf(priv->dbgbuf + i*2 ,
                                 "%02X", priv->writebuf[i]);
-                priv->dbgbuf[priv->writelen+i*2] = 0;
+                priv->dbgbuf[buf_len+i*2] = 0;
                 dbg("%s - writing %i chars : %s", __func__,
-                    priv->writelen, priv->dbgbuf);
+                    buf_len, priv->dbgbuf);
         }
         usb_fill_bulk_urb(port->write_urb, port->serial->dev,
                           usb_sndbulkpipe(port->serial->dev,
                                           port->bulk_out_endpointAddress),
-                          port->write_urb->transfer_buffer, priv->writelen + 3,
+                          port->write_urb->transfer_buffer, buf_len + 3,
                           iuu_rxcmd, port);
         result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
-        spin_lock_irqsave(&priv->lock, flags);
-        priv->writelen = 0;
-        spin_unlock_irqrestore(&priv->lock, flags);
         usb_serial_port_softint(port);
         return result;
 }
@@ -770,14 +770,10 @@ static int iuu_uart_write(struct tty_struct *tty, struct usb_serial_port *port,
                 return -ENOMEM;
 
         spin_lock_irqsave(&priv->lock, flags);
-        if (priv->writelen > 0) {
-                /* buffer already filled but not commited */
-                spin_unlock_irqrestore(&priv->lock, flags);
-                return 0;
-        }
+
         /* fill the buffer */
-        memcpy(priv->writebuf, buf, count);
-        priv->writelen = count;
+        memcpy(priv->writebuf + priv->writelen, buf, count);
+        priv->writelen += count;
         spin_unlock_irqrestore(&priv->lock, flags);
 
         return count;
@@ -819,7 +815,7 @@ static int iuu_uart_on(struct usb_serial_port *port)
         buf[0] = IUU_UART_ENABLE;
         buf[1] = (u8) ((IUU_BAUD_9600 >> 8) & 0x00FF);
         buf[2] = (u8) (0x00FF & IUU_BAUD_9600);
-        buf[3] = (u8) (0x0F0 & IUU_TWO_STOP_BITS) | (0x07 & IUU_PARITY_EVEN);
+        buf[3] = (u8) (0x0F0 & IUU_ONE_STOP_BIT) | (0x07 & IUU_PARITY_EVEN);
 
         status = bulk_immediate(port, buf, 4);
         if (status != IUU_OPERATION_OK) {
@@ -946,19 +942,59 @@ static int iuu_uart_baud(struct usb_serial_port *port, u32 baud,
         return status;
 }
 
-static int set_control_lines(struct usb_device *dev, u8 value)
+static void iuu_set_termios(struct tty_struct *tty,
+                struct usb_serial_port *port, struct ktermios *old_termios)
 {
-        return 0;
+        const u32 supported_mask = CMSPAR|PARENB|PARODD;
+
+        unsigned int cflag = tty->termios->c_cflag;
+        int status;
+        u32 actual;
+        u32 parity;
+        int csize = CS7;
+        int baud = 9600;        /* Fixed for the moment */
+        u32 newval = cflag & supported_mask;
+
+        /* compute the parity parameter */
+        parity = 0;
+        if (cflag & CMSPAR) {   /* Using mark space */
+                if (cflag & PARODD)
+                        parity |= IUU_PARITY_SPACE;
+                else
+                        parity |= IUU_PARITY_MARK;
+        } else if (!(cflag & PARENB)) {
+                parity |= IUU_PARITY_NONE;
+                csize = CS8;
+        } else if (cflag & PARODD)
+                parity |= IUU_PARITY_ODD;
+        else
+                parity |= IUU_PARITY_EVEN;
+
+        parity |= (cflag & CSTOPB ? IUU_TWO_STOP_BITS : IUU_ONE_STOP_BIT);
+
+        /* set it */
+        status = iuu_uart_baud(port,
+                        (clockmode == 2) ? 16457 : 9600 * boost / 100,
+                        &actual, parity);
+
+        /* set the termios value to the real one, so the user now what has
+         * changed. We support few fields so its easies to copy the old hw
+         * settings back over and then adjust them
+         */
+        if (old_termios)
+                tty_termios_copy_hw(tty->termios, old_termios);
+        if (status != 0)        /* Set failed - return old bits */
+                return;
+        /* Re-encode speed, parity and csize */
+        tty_encode_baud_rate(tty, baud, baud);
+        tty->termios->c_cflag &= ~(supported_mask|CSIZE);
+        tty->termios->c_cflag |= newval | csize;
 }
 
-static void iuu_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void iuu_close(struct usb_serial_port *port)
 {
         /* iuu_led (port,255,0,0,0); */
         struct usb_serial *serial;
-        struct iuu_private *priv = usb_get_serial_port_data(port);
-        unsigned long flags;
-        unsigned int c_cflag;
 
         serial = port->serial;
         if (!serial)
@@ -968,17 +1004,6 @@ static void iuu_close(struct tty_struct *tty,
 
         iuu_uart_off(port);
         if (serial->dev) {
-                if (tty) {
-                        c_cflag = tty->termios->c_cflag;
-                        if (c_cflag & HUPCL) {
-                                /* drop DTR and RTS */
-                                priv = usb_get_serial_port_data(port);
-                                spin_lock_irqsave(&priv->lock, flags);
-                                priv->line_control = 0;
-                                spin_unlock_irqrestore(&priv->lock, flags);
-                                set_control_lines(port->serial->dev, 0);
-                        }
-                }
                 /* free writebuf */
                 /* shutdown our urbs */
                 dbg("%s - shutting down urbs", __func__);
@@ -1154,7 +1179,7 @@ static int iuu_open(struct tty_struct *tty,
         if (result) {
                 dev_err(&port->dev, "%s - failed submitting read urb,"
                         " error %d\n", __func__, result);
-                iuu_close(tty, port, NULL);
+                iuu_close(port);
                 return -EPROTO;
         } else {
                 dbg("%s - rxcmd OK", __func__);
@@ -1175,6 +1200,7 @@ static struct usb_serial_driver iuu_device = {
         .read_bulk_callback = iuu_uart_read_callback,
         .tiocmget = iuu_tiocmget,
         .tiocmset = iuu_tiocmset,
+        .set_termios = iuu_set_termios,
         .attach = iuu_startup,
         .shutdown = iuu_shutdown,
 };
diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
index 00daa8f7759a..f1195a98f316 100644
--- a/drivers/usb/serial/keyspan.c
+++ b/drivers/usb/serial/keyspan.c
@@ -1298,8 +1298,16 @@ static inline void stop_urb(struct urb *urb)
                 usb_kill_urb(urb);
 }
 
-static void keyspan_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void keyspan_dtr_rts(struct usb_serial_port *port, int on)
+{
+        struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
+
+        p_priv->rts_state = on;
+        p_priv->dtr_state = on;
+        keyspan_send_setup(port, 0);
+}
+
+static void keyspan_close(struct usb_serial_port *port)
 {
         int                     i;
         struct usb_serial       *serial = port->serial;
@@ -1336,7 +1344,6 @@ static void keyspan_close(struct tty_struct *tty,
                         stop_urb(p_priv->out_urbs[i]);
                 }
         }
-        tty_port_tty_set(&port->port, NULL);
 }
 
 /* download the firmware to a pre-renumeration device */
diff --git a/drivers/usb/serial/keyspan.h b/drivers/usb/serial/keyspan.h
index 38b4582e0734..0d4569b60768 100644
--- a/drivers/usb/serial/keyspan.h
+++ b/drivers/usb/serial/keyspan.h
@@ -38,9 +38,8 @@
 static int  keyspan_open                (struct tty_struct *tty,
                                          struct usb_serial_port *port,
                                          struct file *filp);
-static void keyspan_close               (struct tty_struct *tty,
-                                         struct usb_serial_port *port,
-                                         struct file *filp);
+static void keyspan_close               (struct usb_serial_port *port);
+static void keyspan_dtr_rts             (struct usb_serial_port *port, int on);
 static int  keyspan_startup             (struct usb_serial *serial);
 static void keyspan_shutdown            (struct usb_serial *serial);
 static int  keyspan_write_room          (struct tty_struct *tty);
@@ -562,6 +561,7 @@ static struct usb_serial_driver keyspan_1port_device = {
         .num_ports              = 1,
         .open                   = keyspan_open,
         .close                  = keyspan_close,
+        .dtr_rts                = keyspan_dtr_rts,
         .write                  = keyspan_write,
         .write_room             = keyspan_write_room,
         .set_termios            = keyspan_set_termios,
@@ -582,6 +582,7 @@ static struct usb_serial_driver keyspan_2port_device = {
         .num_ports              = 2,
         .open                   = keyspan_open,
         .close                  = keyspan_close,
+        .dtr_rts                = keyspan_dtr_rts,
         .write                  = keyspan_write,
         .write_room             = keyspan_write_room,
         .set_termios            = keyspan_set_termios,
@@ -602,6 +603,7 @@ static struct usb_serial_driver keyspan_4port_device = {
         .num_ports              = 4,
         .open                   = keyspan_open,
         .close                  = keyspan_close,
+        .dtr_rts                = keyspan_dtr_rts,
         .write                  = keyspan_write,
         .write_room             = keyspan_write_room,
         .set_termios            = keyspan_set_termios,
diff --git a/drivers/usb/serial/keyspan_pda.c b/drivers/usb/serial/keyspan_pda.c
index bf1ae247da66..ab769dbea1b3 100644
--- a/drivers/usb/serial/keyspan_pda.c
+++ b/drivers/usb/serial/keyspan_pda.c
@@ -651,6 +651,35 @@ static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
 }
 
 
+static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
+{
+        struct usb_serial *serial = port->serial;
+
+        if (serial->dev) {
+                if (on)
+                        keyspan_pda_set_modem_info(serial, (1<<7) | (1<< 2));
+                else
+                        keyspan_pda_set_modem_info(serial, 0);
+        }
+}
+
+static int keyspan_pda_carrier_raised(struct usb_serial_port *port)
+{
+        struct usb_serial *serial = port->serial;
+        unsigned char modembits;
+
+        /* If we can read the modem status and the DCD is low then
+           carrier is not raised yet */
+        if (keyspan_pda_get_modem_info(serial, &modembits) >= 0) {
+                if (!(modembits & (1>>6)))
+                        return 0;
+        }
+        /* Carrier raised, or we failed (eg disconnected) so
+           progress accordingly */
+        return 1;
+}
+
+
 static int keyspan_pda_open(struct tty_struct *tty,
                         struct usb_serial_port *port, struct file *filp)
 {
@@ -682,13 +711,6 @@ static int keyspan_pda_open(struct tty_struct *tty,
         priv->tx_room = room;
         priv->tx_throttled = room ? 0 : 1;
 
-        /* the normal serial device seems to always turn on DTR and RTS here,
-           so do the same */
-        if (tty && (tty->termios->c_cflag & CBAUD))
-                keyspan_pda_set_modem_info(serial, (1<<7) | (1<<2));
-        else
-                keyspan_pda_set_modem_info(serial, 0);
-
         /*Start reading from the device*/
         port->interrupt_in_urb->dev = serial->dev;
         rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
@@ -700,19 +722,11 @@ static int keyspan_pda_open(struct tty_struct *tty,
 error:
         return rc;
 }
-
-
-static void keyspan_pda_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void keyspan_pda_close(struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
 
         if (serial->dev) {
-                /* the normal serial device seems to always shut
-                   off DTR and RTS now */
-                if (tty->termios->c_cflag & HUPCL)
-                        keyspan_pda_set_modem_info(serial, 0);
-
                 /* shutdown our bulk reads and writes */
                 usb_kill_urb(port->write_urb);
                 usb_kill_urb(port->interrupt_in_urb);
@@ -839,6 +853,8 @@ static struct usb_serial_driver keyspan_pda_device = {
         .usb_driver =           &keyspan_pda_driver,
         .id_table =             id_table_std,
         .num_ports =            1,
+        .dtr_rts =              keyspan_pda_dtr_rts,
+        .carrier_raised =       keyspan_pda_carrier_raised,
         .open =                 keyspan_pda_open,
         .close =                keyspan_pda_close,
         .write =                keyspan_pda_write,
diff --git a/drivers/usb/serial/kl5kusb105.c b/drivers/usb/serial/kl5kusb105.c
index fcd9082f3e7f..fa817c66b3e8 100644
--- a/drivers/usb/serial/kl5kusb105.c
+++ b/drivers/usb/serial/kl5kusb105.c
@@ -76,8 +76,7 @@ static int  klsi_105_startup(struct usb_serial *serial);
 static void klsi_105_shutdown(struct usb_serial *serial);
 static int  klsi_105_open(struct tty_struct *tty,
                         struct usb_serial_port *port, struct file *filp);
-static void klsi_105_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+static void klsi_105_close(struct usb_serial_port *port);
 static int  klsi_105_write(struct tty_struct *tty,
         struct usb_serial_port *port, const unsigned char *buf, int count);
 static void klsi_105_write_bulk_callback(struct urb *urb);
@@ -447,8 +446,7 @@ exit:
 } /* klsi_105_open */
 
 
-static void klsi_105_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void klsi_105_close(struct usb_serial_port *port)
 {
         struct klsi_105_private *priv = usb_get_serial_port_data(port);
         int rc;
diff --git a/drivers/usb/serial/kobil_sct.c b/drivers/usb/serial/kobil_sct.c
index c148544953b3..6b570498287f 100644
--- a/drivers/usb/serial/kobil_sct.c
+++ b/drivers/usb/serial/kobil_sct.c
@@ -72,8 +72,7 @@ static int  kobil_startup(struct usb_serial *serial);
 static void kobil_shutdown(struct usb_serial *serial);
 static int  kobil_open(struct tty_struct *tty,
                         struct usb_serial_port *port, struct file *filp);
-static void kobil_close(struct tty_struct *tty, struct usb_serial_port *port,
-                        struct file *filp);
+static void kobil_close(struct usb_serial_port *port);
 static int  kobil_write(struct tty_struct *tty, struct usb_serial_port *port,
                          const unsigned char *buf, int count);
 static int  kobil_write_room(struct tty_struct *tty);
@@ -209,7 +208,7 @@ static void kobil_shutdown(struct usb_serial *serial)
 
         for (i = 0; i < serial->num_ports; ++i) {
                 while (serial->port[i]->port.count > 0)
-                        kobil_close(NULL, serial->port[i], NULL);
+                        kobil_close(serial->port[i]);
                 kfree(usb_get_serial_port_data(serial->port[i]));
                 usb_set_serial_port_data(serial->port[i], NULL);
         }
@@ -346,11 +345,11 @@ static int kobil_open(struct tty_struct *tty,
 }
 
 
-static void kobil_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void kobil_close(struct usb_serial_port *port)
 {
         dbg("%s - port %d", __func__, port->number);
 
+        /* FIXME: Add rts/dtr methods */
         if (port->write_urb) {
                 usb_kill_urb(port->write_urb);
                 usb_free_urb(port->write_urb);
diff --git a/drivers/usb/serial/mct_u232.c b/drivers/usb/serial/mct_u232.c
index 82930a7d5093..873795548fc0 100644
--- a/drivers/usb/serial/mct_u232.c
+++ b/drivers/usb/serial/mct_u232.c
@@ -95,8 +95,8 @@ static int  mct_u232_startup(struct usb_serial *serial);
 static void mct_u232_shutdown(struct usb_serial *serial);
 static int  mct_u232_open(struct tty_struct *tty,
                         struct usb_serial_port *port, struct file *filp);
-static void mct_u232_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+static void mct_u232_close(struct usb_serial_port *port);
+static void mct_u232_dtr_rts(struct usb_serial_port *port, int on);
 static void mct_u232_read_int_callback(struct urb *urb);
 static void mct_u232_set_termios(struct tty_struct *tty,
                         struct usb_serial_port *port, struct ktermios *old);
@@ -140,6 +140,7 @@ static struct usb_serial_driver mct_u232_device = {
         .num_ports =         1,
         .open =              mct_u232_open,
         .close =             mct_u232_close,
+        .dtr_rts =           mct_u232_dtr_rts,
         .throttle =          mct_u232_throttle,
         .unthrottle =        mct_u232_unthrottle,
         .read_int_callback = mct_u232_read_int_callback,
@@ -496,29 +497,29 @@ error:
         return retval;
 } /* mct_u232_open */
 
-
-static void mct_u232_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void mct_u232_dtr_rts(struct usb_serial_port *port, int on)
 {
-        unsigned int c_cflag;
         unsigned int control_state;
         struct mct_u232_private *priv = usb_get_serial_port_data(port);
-        dbg("%s port %d", __func__, port->number);
 
-        if (tty) {
-                c_cflag = tty->termios->c_cflag;
-                mutex_lock(&port->serial->disc_mutex);
-                if (c_cflag & HUPCL && !port->serial->disconnected) {
-                        /* drop DTR and RTS */
-                        spin_lock_irq(&priv->lock);
+        mutex_lock(&port->serial->disc_mutex);
+        if (!port->serial->disconnected) {
+                /* drop DTR and RTS */
+                spin_lock_irq(&priv->lock);
+                if (on)
+                        priv->control_state |= TIOCM_DTR | TIOCM_RTS;
+                else
                         priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
-                        control_state = priv->control_state;
-                        spin_unlock_irq(&priv->lock);
-                        mct_u232_set_modem_ctrl(port->serial, control_state);
-                }
-                mutex_unlock(&port->serial->disc_mutex);
+                control_state = priv->control_state;
+                spin_unlock_irq(&priv->lock);
+                mct_u232_set_modem_ctrl(port->serial, control_state);
         }
+        mutex_unlock(&port->serial->disc_mutex);
+}
 
+static void mct_u232_close(struct usb_serial_port *port)
+{
+        dbg("%s port %d", __func__, port->number);
 
         if (port->serial->dev) {
                 /* shutdown our urbs */
diff --git a/drivers/usb/serial/mos7720.c b/drivers/usb/serial/mos7720.c
index 24e3b5d4b4d4..9e1a013ee7f6 100644
--- a/drivers/usb/serial/mos7720.c
+++ b/drivers/usb/serial/mos7720.c
@@ -533,8 +533,7 @@ static int mos7720_chars_in_buffer(struct tty_struct *tty)
         return chars;
 }
 
-static void mos7720_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void mos7720_close(struct usb_serial_port *port)
 {
         struct usb_serial *serial;
         struct moschip_port *mos7720_port;
diff --git a/drivers/usb/serial/mos7840.c b/drivers/usb/serial/mos7840.c
index 84fb1dcd30dc..10b78a37214f 100644
--- a/drivers/usb/serial/mos7840.c
+++ b/drivers/usb/serial/mos7840.c
@@ -1135,54 +1135,12 @@ static int mos7840_chars_in_buffer(struct tty_struct *tty)
 
 }
 
-/************************************************************************
- *
- * mos7840_block_until_tx_empty
- *
- *      This function will block the close until one of the following:
- *              1. TX count are 0
- *              2. The mos7840 has stopped
- *              3. A timeout of 3 seconds without activity has expired
- *
- ************************************************************************/
-static void mos7840_block_until_tx_empty(struct tty_struct *tty,
-                                struct moschip_port *mos7840_port)
-{
-        int timeout = HZ / 10;
-        int wait = 30;
-        int count;
-
-        while (1) {
-
-                count = mos7840_chars_in_buffer(tty);
-
-                /* Check for Buffer status */
-                if (count <= 0)
-                        return;
-
-                /* Block the thread for a while */
-                interruptible_sleep_on_timeout(&mos7840_port->wait_chase,
-                                               timeout);
-
-                /* No activity.. count down section */
-                wait--;
-                if (wait == 0) {
-                        dbg("%s - TIMEOUT", __func__);
-                        return;
-                } else {
-                        /* Reset timeout value back to seconds */
-                        wait = 30;
-                }
-        }
-}
-
 /*****************************************************************************
  * mos7840_close
  *      this function is called by the tty driver when a port is closed
  *****************************************************************************/
 
-static void mos7840_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void mos7840_close(struct usb_serial_port *port)
 {
         struct usb_serial *serial;
         struct moschip_port *mos7840_port;
@@ -1223,10 +1181,6 @@ static void mos7840_close(struct tty_struct *tty,
                 }
         }
 
-        if (serial->dev)
-                /* flush and block until tx is empty */
-                mos7840_block_until_tx_empty(tty, mos7840_port);
-
         /* While closing port, shutdown all bulk read, write  *
          * and interrupt read if they exists                  */
         if (serial->dev) {
diff --git a/drivers/usb/serial/navman.c b/drivers/usb/serial/navman.c
index bcdcbb822705..f5f3751a888c 100644
--- a/drivers/usb/serial/navman.c
+++ b/drivers/usb/serial/navman.c
@@ -98,8 +98,7 @@ static int navman_open(struct tty_struct *tty,
         return result;
 }
 
-static void navman_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void navman_close(struct usb_serial_port *port)
 {
         dbg("%s - port %d", __func__, port->number);
 
diff --git a/drivers/usb/serial/omninet.c b/drivers/usb/serial/omninet.c
index df6539712726..1104617334f5 100644
--- a/drivers/usb/serial/omninet.c
+++ b/drivers/usb/serial/omninet.c
@@ -66,8 +66,7 @@ static int debug;
 /* function prototypes */
 static int  omninet_open(struct tty_struct *tty, struct usb_serial_port *port,
                                                         struct file *filp);
-static void omninet_close(struct tty_struct *tty, struct usb_serial_port *port,
-                                                        struct file *filp);
+static void omninet_close(struct usb_serial_port *port);
 static void omninet_read_bulk_callback(struct urb *urb);
 static void omninet_write_bulk_callback(struct urb *urb);
 static int  omninet_write(struct tty_struct *tty, struct usb_serial_port *port,
@@ -189,8 +188,7 @@ static int omninet_open(struct tty_struct *tty,
         return result;
 }
 
-static void omninet_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void omninet_close(struct usb_serial_port *port)
 {
         dbg("%s - port %d", __func__, port->number);
         usb_kill_urb(port->read_urb);
diff --git a/drivers/usb/serial/opticon.c b/drivers/usb/serial/opticon.c
index b500ad10b758..c20480aa9755 100644
--- a/drivers/usb/serial/opticon.c
+++ b/drivers/usb/serial/opticon.c
@@ -173,8 +173,7 @@ static int opticon_open(struct tty_struct *tty, struct usb_serial_port *port,
         return result;
 }
 
-static void opticon_close(struct tty_struct *tty, struct usb_serial_port *port,
-                          struct file *filp)
+static void opticon_close(struct usb_serial_port *port)
 {
         struct opticon_private *priv = usb_get_serial_data(port->serial);
 
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 7817b82889ca..a16d69fadba1 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -45,8 +45,9 @@
 /* Function prototypes */
 static int  option_open(struct tty_struct *tty, struct usb_serial_port *port,
                                                         struct file *filp);
-static void option_close(struct tty_struct *tty, struct usb_serial_port *port,
-                                                        struct file *filp);
+static void option_close(struct usb_serial_port *port);
+static void option_dtr_rts(struct usb_serial_port *port, int on);
+
 static int  option_startup(struct usb_serial *serial);
 static void option_shutdown(struct usb_serial *serial);
 static int  option_write_room(struct tty_struct *tty);
@@ -61,7 +62,7 @@ static void option_set_termios(struct tty_struct *tty,
 static int  option_tiocmget(struct tty_struct *tty, struct file *file);
 static int  option_tiocmset(struct tty_struct *tty, struct file *file,
                                 unsigned int set, unsigned int clear);
-static int  option_send_setup(struct tty_struct *tty, struct usb_serial_port *port);
+static int  option_send_setup(struct usb_serial_port *port);
 static int  option_suspend(struct usb_serial *serial, pm_message_t message);
 static int  option_resume(struct usb_serial *serial);
 
@@ -551,6 +552,7 @@ static struct usb_serial_driver option_1port_device = {
         .num_ports         = 1,
         .open              = option_open,
         .close             = option_close,
+        .dtr_rts           = option_dtr_rts,
         .write             = option_write,
         .write_room        = option_write_room,
         .chars_in_buffer   = option_chars_in_buffer,
@@ -630,7 +632,7 @@ static void option_set_termios(struct tty_struct *tty,
         dbg("%s", __func__);
         /* Doesn't support option setting */
         tty_termios_copy_hw(tty->termios, old_termios);
-        option_send_setup(tty, port);
+        option_send_setup(port);
 }
 
 static int option_tiocmget(struct tty_struct *tty, struct file *file)
@@ -669,7 +671,7 @@ static int option_tiocmset(struct tty_struct *tty, struct file *file,
                 portdata->rts_state = 0;
         if (clear & TIOCM_DTR)
                 portdata->dtr_state = 0;
-        return option_send_setup(tty, port);
+        return option_send_setup(port);
 }
 
 /* Write */
@@ -897,10 +899,6 @@ static int option_open(struct tty_struct *tty,
 
         dbg("%s", __func__);
 
-        /* Set some sane defaults */
-        portdata->rts_state = 1;
-        portdata->dtr_state = 1;
-
         /* Reset low level data toggle and start reading from endpoints */
         for (i = 0; i < N_IN_URB; i++) {
                 urb = portdata->in_urbs[i];
@@ -936,37 +934,43 @@ static int option_open(struct tty_struct *tty,
                                 usb_pipeout(urb->pipe), 0); */
         }
 
-        option_send_setup(tty, port);
+        option_send_setup(port);
 
         return 0;
 }
 
-static void option_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void option_dtr_rts(struct usb_serial_port *port, int on)
 {
-        int i;
         struct usb_serial *serial = port->serial;
         struct option_port_private *portdata;
 
         dbg("%s", __func__);
         portdata = usb_get_serial_port_data(port);
+        mutex_lock(&serial->disc_mutex);
+        portdata->rts_state = on;
+        portdata->dtr_state = on;
+        if (serial->dev)
+                option_send_setup(port);
+        mutex_unlock(&serial->disc_mutex);
+}
 
-        portdata->rts_state = 0;
-        portdata->dtr_state = 0;
 
-        if (serial->dev) {
-                mutex_lock(&serial->disc_mutex);
-                if (!serial->disconnected)
-                        option_send_setup(tty, port);
-                mutex_unlock(&serial->disc_mutex);
+static void option_close(struct usb_serial_port *port)
+{
+        int i;
+        struct usb_serial *serial = port->serial;
+        struct option_port_private *portdata;
+
+        dbg("%s", __func__);
+        portdata = usb_get_serial_port_data(port);
 
+        if (serial->dev) {
                 /* Stop reading/writing urbs */
                 for (i = 0; i < N_IN_URB; i++)
                         usb_kill_urb(portdata->in_urbs[i]);
                 for (i = 0; i < N_OUT_URB; i++)
                         usb_kill_urb(portdata->out_urbs[i]);
         }
-        tty_port_tty_set(&port->port, NULL);
 }
 
 /* Helper functions used by option_setup_urbs */
@@ -1032,28 +1036,24 @@ static void option_setup_urbs(struct usb_serial *serial)
  * This is exactly the same as SET_CONTROL_LINE_STATE from the PSTN
  * CDC.
 */
-static int option_send_setup(struct tty_struct *tty,
-                                                struct usb_serial_port *port)
+static int option_send_setup(struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
         struct option_port_private *portdata;
         int ifNum = serial->interface->cur_altsetting->desc.bInterfaceNumber;
+        int val = 0;
         dbg("%s", __func__);
 
         portdata = usb_get_serial_port_data(port);
 
-        if (tty) {
-                int val = 0;
-                if (portdata->dtr_state)
-                        val |= 0x01;
-                if (portdata->rts_state)
-                        val |= 0x02;
+        if (portdata->dtr_state)
+                val |= 0x01;
+        if (portdata->rts_state)
+                val |= 0x02;
 
-                return usb_control_msg(serial->dev,
-                        usb_rcvctrlpipe(serial->dev, 0),
-                        0x22, 0x21, val, ifNum, NULL, 0, USB_CTRL_SET_TIMEOUT);
-        }
-        return 0;
+        return usb_control_msg(serial->dev,
+                usb_rcvctrlpipe(serial->dev, 0),
+                0x22, 0x21, val, ifNum, NULL, 0, USB_CTRL_SET_TIMEOUT);
 }
 
 static int option_startup(struct usb_serial *serial)
diff --git a/drivers/usb/serial/oti6858.c b/drivers/usb/serial/oti6858.c
index ba551f00f16f..7de54781fe61 100644
--- a/drivers/usb/serial/oti6858.c
+++ b/drivers/usb/serial/oti6858.c
@@ -143,8 +143,7 @@ struct oti6858_control_pkt {
 /* function prototypes */
 static int oti6858_open(struct tty_struct *tty,
                         struct usb_serial_port *port, struct file *filp);
-static void oti6858_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+static void oti6858_close(struct usb_serial_port *port);
 static void oti6858_set_termios(struct tty_struct *tty,
                         struct usb_serial_port *port, struct ktermios *old);
 static int oti6858_ioctl(struct tty_struct *tty, struct file *file,
@@ -622,67 +621,30 @@ static int oti6858_open(struct tty_struct *tty,
         if (result != 0) {
                 dev_err(&port->dev, "%s(): usb_submit_urb() failed"
                                " with error %d\n", __func__, result);
-                oti6858_close(tty, port, NULL);
+                oti6858_close(port);
                 return -EPROTO;
         }
 
         /* setup termios */
         if (tty)
                 oti6858_set_termios(tty, port, &tmp_termios);
-
+        port->port.drain_delay = 256;   /* FIXME: check the FIFO length */
         return 0;
 }
 
-static void oti6858_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void oti6858_close(struct usb_serial_port *port)
 {
         struct oti6858_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
-        long timeout;
-        wait_queue_t wait;
 
         dbg("%s(port = %d)", __func__, port->number);
 
-        /* wait for data to drain from the buffer */
         spin_lock_irqsave(&priv->lock, flags);
-        timeout = 30 * HZ;      /* PL2303_CLOSING_WAIT */
-        init_waitqueue_entry(&wait, current);
-        add_wait_queue(&tty->write_wait, &wait);
-        dbg("%s(): entering wait loop", __func__);
-        for (;;) {
-                set_current_state(TASK_INTERRUPTIBLE);
-                if (oti6858_buf_data_avail(priv->buf) == 0
-                || timeout == 0 || signal_pending(current)
-                || port->serial->disconnected)
-                        break;
-                spin_unlock_irqrestore(&priv->lock, flags);
-                timeout = schedule_timeout(timeout);
-                spin_lock_irqsave(&priv->lock, flags);
-        }
-        set_current_state(TASK_RUNNING);
-        remove_wait_queue(&tty->write_wait, &wait);
-        dbg("%s(): after wait loop", __func__);
-
         /* clear out any remaining data in the buffer */
         oti6858_buf_clear(priv->buf);
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        /* wait for characters to drain from the device */
-        /* (this is long enough for the entire 256 byte */
-        /* pl2303 hardware buffer to drain with no flow */
-        /* control for data rates of 1200 bps or more, */
-        /* for lower rates we should really know how much */
-        /* data is in the buffer to compute a delay */
-        /* that is not unnecessarily long) */
-        /* FIXME
-        bps = tty_get_baud_rate(tty);
-        if (bps > 1200)
-                timeout = max((HZ*2560)/bps,HZ/10);
-        else
-        */
-                timeout = 2*HZ;
-        schedule_timeout_interruptible(timeout);
-        dbg("%s(): after schedule_timeout_interruptible()", __func__);
+        dbg("%s(): after buf_clear()", __func__);
 
         /* cancel scheduled setup */
         cancel_delayed_work(&priv->delayed_setup_work);
@@ -694,15 +656,6 @@ static void oti6858_close(struct tty_struct *tty,
         usb_kill_urb(port->write_urb);
         usb_kill_urb(port->read_urb);
         usb_kill_urb(port->interrupt_in_urb);
-
-        /*
-        if (tty && (tty->termios->c_cflag) & HUPCL) {
-                // drop DTR and RTS
-                spin_lock_irqsave(&priv->lock, flags);
-                priv->pending_setup.control &= ~CONTROL_MASK;
-                spin_unlock_irqrestore(&priv->lock, flags);
-        }
-        */
 }
 
 static int oti6858_tiocmset(struct tty_struct *tty, struct file *file,
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index 751a533a4347..e02dc3d643c7 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -652,69 +652,41 @@ static void pl2303_set_termios(struct tty_struct *tty,
         kfree(buf);
 }
 
-static void pl2303_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
+{
+        struct pl2303_private *priv = usb_get_serial_port_data(port);
+        unsigned long flags;
+        u8 control;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        /* Change DTR and RTS */
+        if (on)
+                priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
+        else
+                priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
+        control = priv->line_control;
+        spin_unlock_irqrestore(&priv->lock, flags);
+        set_control_lines(port->serial->dev, control);
+}
+
+static void pl2303_close(struct usb_serial_port *port)
 {
         struct pl2303_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
-        unsigned int c_cflag;
-        int bps;
-        long timeout;
-        wait_queue_t wait;
 
         dbg("%s - port %d", __func__, port->number);
 
-        /* wait for data to drain from the buffer */
         spin_lock_irqsave(&priv->lock, flags);
-        timeout = PL2303_CLOSING_WAIT;
-        init_waitqueue_entry(&wait, current);
-        add_wait_queue(&tty->write_wait, &wait);
-        for (;;) {
-                set_current_state(TASK_INTERRUPTIBLE);
-                if (pl2303_buf_data_avail(priv->buf) == 0 ||
-                    timeout == 0 || signal_pending(current) ||
-                    port->serial->disconnected)
-                        break;
-                spin_unlock_irqrestore(&priv->lock, flags);
-                timeout = schedule_timeout(timeout);
-                spin_lock_irqsave(&priv->lock, flags);
-        }
-        set_current_state(TASK_RUNNING);
-        remove_wait_queue(&tty->write_wait, &wait);
         /* clear out any remaining data in the buffer */
         pl2303_buf_clear(priv->buf);
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        /* wait for characters to drain from the device */
-        /* (this is long enough for the entire 256 byte */
-        /* pl2303 hardware buffer to drain with no flow */
-        /* control for data rates of 1200 bps or more, */
-        /* for lower rates we should really know how much */
-        /* data is in the buffer to compute a delay */
-        /* that is not unnecessarily long) */
-        bps = tty_get_baud_rate(tty);
-        if (bps > 1200)
-                timeout = max((HZ*2560)/bps, HZ/10);
-        else
-                timeout = 2*HZ;
-        schedule_timeout_interruptible(timeout);
-
         /* shutdown our urbs */
         dbg("%s - shutting down urbs", __func__);
         usb_kill_urb(port->write_urb);
         usb_kill_urb(port->read_urb);
         usb_kill_urb(port->interrupt_in_urb);
 
-        if (tty) {
-                c_cflag = tty->termios->c_cflag;
-                if (c_cflag & HUPCL) {
-                        /* drop DTR and RTS */
-                        spin_lock_irqsave(&priv->lock, flags);
-                        priv->line_control = 0;
-                        spin_unlock_irqrestore(&priv->lock, flags);
-                        set_control_lines(port->serial->dev, 0);
-                }
-        }
 }
 
 static int pl2303_open(struct tty_struct *tty,
@@ -748,7 +720,7 @@ static int pl2303_open(struct tty_struct *tty,
         if (result) {
                 dev_err(&port->dev, "%s - failed submitting read urb,"
                         " error %d\n", __func__, result);
-                pl2303_close(tty, port, NULL);
+                pl2303_close(port);
                 return -EPROTO;
         }
 
@@ -758,9 +730,10 @@ static int pl2303_open(struct tty_struct *tty,
         if (result) {
                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
                         " error %d\n", __func__, result);
-                pl2303_close(tty, port, NULL);
+                pl2303_close(port);
                 return -EPROTO;
         }
+        port->port.drain_delay = 256;
         return 0;
 }
 
@@ -821,6 +794,14 @@ static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
         return result;
 }
 
+static int pl2303_carrier_raised(struct usb_serial_port *port)
+{
+        struct pl2303_private *priv = usb_get_serial_port_data(port);
+        if (priv->line_status & UART_DCD)
+                return 1;
+        return 0;
+}
+
 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
 {
         struct pl2303_private *priv = usb_get_serial_port_data(port);
@@ -1125,6 +1106,8 @@ static struct usb_serial_driver pl2303_device = {
         .num_ports =            1,
         .open =                 pl2303_open,
         .close =                pl2303_close,
+        .dtr_rts =              pl2303_dtr_rts,
+        .carrier_raised =       pl2303_carrier_raised,
         .write =                pl2303_write,
         .ioctl =                pl2303_ioctl,
         .break_ctl =            pl2303_break_ctl,
diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c
index 913225c61610..17ac34f4d668 100644
--- a/drivers/usb/serial/sierra.c
+++ b/drivers/usb/serial/sierra.c
@@ -26,12 +26,10 @@
 #include <linux/module.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
-#include <linux/usb/ch9.h>
 
 #define SWIMS_USB_REQUEST_SetPower      0x00
 #define SWIMS_USB_REQUEST_SetNmea       0x07
 
-/* per port private data */
 #define N_IN_URB        4
 #define N_OUT_URB       4
 #define IN_BUFLEN       4096
@@ -39,6 +37,12 @@
 static int debug;
 static int nmea;
 
+/* Used in interface blacklisting */
+struct sierra_iface_info {
+        const u32 infolen;      /* number of interface numbers on blacklist */
+        const u8  *ifaceinfo;   /* pointer to the array holding the numbers */
+};
+
 static int sierra_set_power_state(struct usb_device *udev, __u16 swiState)
 {
         int result;
@@ -85,6 +89,23 @@ static int sierra_calc_num_ports(struct usb_serial *serial)
         return result;
 }
 
+static int is_blacklisted(const u8 ifnum,
+                                const struct sierra_iface_info *blacklist)
+{
+        const u8  *info;
+        int i;
+
+        if (blacklist) {
+                info = blacklist->ifaceinfo;
+
+                for (i = 0; i < blacklist->infolen; i++) {
+                        if (info[i] == ifnum)
+                                return 1;
+                }
+        }
+        return 0;
+}
+
 static int sierra_calc_interface(struct usb_serial *serial)
 {
         int interface;
@@ -153,9 +174,25 @@ static int sierra_probe(struct usb_serial *serial,
          */
         usb_set_serial_data(serial, (void *)num_ports);
 
+        /* ifnum could have changed - by calling usb_set_interface */
+        ifnum = sierra_calc_interface(serial);
+
+        if (is_blacklisted(ifnum,
+                                (struct sierra_iface_info *)id->driver_info)) {
+                dev_dbg(&serial->dev->dev,
+                        "Ignoring blacklisted interface #%d\n", ifnum);
+                return -ENODEV;
+        }
+
         return result;
 }
 
+static const u8 direct_ip_non_serial_ifaces[] = { 7, 8, 9, 10, 11 };
+static const struct sierra_iface_info direct_ip_interface_blacklist = {
+        .infolen = ARRAY_SIZE(direct_ip_non_serial_ifaces),
+        .ifaceinfo = direct_ip_non_serial_ifaces,
+};
+
 static struct usb_device_id id_table [] = {
         { USB_DEVICE(0x1199, 0x0017) }, /* Sierra Wireless EM5625 */
         { USB_DEVICE(0x1199, 0x0018) }, /* Sierra Wireless MC5720 */
@@ -188,9 +225,11 @@ static struct usb_device_id id_table [] = {
         { USB_DEVICE(0x1199, 0x6833) }, /* Sierra Wireless MC8781 */
         { USB_DEVICE(0x1199, 0x683A) }, /* Sierra Wireless MC8785 */
         { USB_DEVICE(0x1199, 0x683B) }, /* Sierra Wireless MC8785 Composite */
-        { USB_DEVICE(0x1199, 0x683C) }, /* Sierra Wireless MC8790 */
-        { USB_DEVICE(0x1199, 0x683D) }, /* Sierra Wireless MC8790 */
-        { USB_DEVICE(0x1199, 0x683E) }, /* Sierra Wireless MC8790 */
+        /* Sierra Wireless MC8790, MC8791, MC8792 Composite */
+        { USB_DEVICE(0x1199, 0x683C) },
+        { USB_DEVICE(0x1199, 0x683D) }, /* Sierra Wireless MC8791 Composite */
+        /* Sierra Wireless MC8790, MC8791, MC8792 */
+        { USB_DEVICE(0x1199, 0x683E) },
         { USB_DEVICE(0x1199, 0x6850) }, /* Sierra Wireless AirCard 880 */
         { USB_DEVICE(0x1199, 0x6851) }, /* Sierra Wireless AirCard 881 */
         { USB_DEVICE(0x1199, 0x6852) }, /* Sierra Wireless AirCard 880 E */
@@ -211,6 +250,10 @@ static struct usb_device_id id_table [] = {
         { USB_DEVICE(0x1199, 0x0112) }, /* Sierra Wireless AirCard 580 */
         { USB_DEVICE(0x0F3D, 0x0112) }, /* Airprime/Sierra PC 5220 */
 
+        { USB_DEVICE(0x1199, 0x68A3),   /* Sierra Wireless Direct IP modems */
+          .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
+        },
+
         { }
 };
 MODULE_DEVICE_TABLE(usb, id_table);
@@ -229,7 +272,6 @@ struct sierra_port_private {
 
         /* Input endpoints and buffers for this port */
         struct urb *in_urbs[N_IN_URB];
-        char *in_buffer[N_IN_URB];
 
         /* Settings for the port */
         int rts_state;  /* Handshaking pins (outputs) */
@@ -240,57 +282,50 @@ struct sierra_port_private {
         int ri_state;
 };
 
-static int sierra_send_setup(struct tty_struct *tty,
-                                                struct usb_serial_port *port)
+static int sierra_send_setup(struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
         struct sierra_port_private *portdata;
         __u16 interface = 0;
+        int val = 0;
 
         dev_dbg(&port->dev, "%s", __func__);
 
         portdata = usb_get_serial_port_data(port);
 
-        if (tty) {
-                int val = 0;
-                if (portdata->dtr_state)
-                        val |= 0x01;
-                if (portdata->rts_state)
-                        val |= 0x02;
-
-                /* If composite device then properly report interface */
-                if (serial->num_ports == 1) {
-                        interface = sierra_calc_interface(serial);
-
-                        /* Control message is sent only to interfaces with
-                         * interrupt_in endpoints
-                         */
-                        if (port->interrupt_in_urb) {
-                                /* send control message */
-                                return usb_control_msg(serial->dev,
-                                        usb_rcvctrlpipe(serial->dev, 0),
-                                        0x22, 0x21, val, interface,
-                                        NULL, 0, USB_CTRL_SET_TIMEOUT);
-                        }
-                }
-
-                /* Otherwise the need to do non-composite mapping */
-                else {
-                        if (port->bulk_out_endpointAddress == 2)
-                                interface = 0;
-                        else if (port->bulk_out_endpointAddress == 4)
-                                interface = 1;
-                        else if (port->bulk_out_endpointAddress == 5)
-                                interface = 2;
+        if (portdata->dtr_state)
+                val |= 0x01;
+        if (portdata->rts_state)
+                val |= 0x02;
 
+        /* If composite device then properly report interface */
+        if (serial->num_ports == 1) {
+                interface = sierra_calc_interface(serial);
+                /* Control message is sent only to interfaces with
+                 * interrupt_in endpoints
+                 */
+                if (port->interrupt_in_urb) {
+                        /* send control message */
                         return usb_control_msg(serial->dev,
                                 usb_rcvctrlpipe(serial->dev, 0),
                                 0x22, 0x21, val, interface,
                                 NULL, 0, USB_CTRL_SET_TIMEOUT);
-
                 }
         }
 
+        /* Otherwise the need to do non-composite mapping */
+        else {
+                if (port->bulk_out_endpointAddress == 2)
+                        interface = 0;
+                else if (port->bulk_out_endpointAddress == 4)
+                        interface = 1;
+                else if (port->bulk_out_endpointAddress == 5)
+                        interface = 2;
+                return usb_control_msg(serial->dev,
+                        usb_rcvctrlpipe(serial->dev, 0),
+                        0x22, 0x21, val, interface,
+                        NULL, 0, USB_CTRL_SET_TIMEOUT);
+        }
         return 0;
 }
 
@@ -299,7 +334,7 @@ static void sierra_set_termios(struct tty_struct *tty,
 {
         dev_dbg(&port->dev, "%s", __func__);
         tty_termios_copy_hw(tty->termios, old_termios);
-        sierra_send_setup(tty, port);
+        sierra_send_setup(port);
 }
 
 static int sierra_tiocmget(struct tty_struct *tty, struct file *file)
@@ -338,7 +373,18 @@ static int sierra_tiocmset(struct tty_struct *tty, struct file *file,
                 portdata->rts_state = 0;
         if (clear & TIOCM_DTR)
                 portdata->dtr_state = 0;
-        return sierra_send_setup(tty, port);
+        return sierra_send_setup(port);
+}
+
+static void sierra_release_urb(struct urb *urb)
+{
+        struct usb_serial_port *port;
+        if (urb) {
+                port =  urb->context;
+                dev_dbg(&port->dev, "%s: %p\n", __func__, urb);
+                kfree(urb->transfer_buffer);
+                usb_free_urb(urb);
+        }
 }
 
 static void sierra_outdat_callback(struct urb *urb)
@@ -465,7 +511,7 @@ static void sierra_indat_callback(struct urb *urb)
                                 " received", __func__);
 
                 /* Resubmit urb so we continue receiving */
-                if (port->port.count && status != -ESHUTDOWN) {
+                if (port->port.count && status != -ESHUTDOWN && status != -EPERM) {
                         err = usb_submit_urb(urb, GFP_ATOMIC);
                         if (err)
                                 dev_err(&port->dev, "resubmit read urb failed."
@@ -557,67 +603,99 @@ static int sierra_write_room(struct tty_struct *tty)
         return 2048;
 }
 
-static int sierra_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void sierra_stop_rx_urbs(struct usb_serial_port *port)
 {
-        struct sierra_port_private *portdata;
-        struct usb_serial *serial = port->serial;
         int i;
-        struct urb *urb;
-        int result;
+        struct sierra_port_private *portdata = usb_get_serial_port_data(port);
 
-        portdata = usb_get_serial_port_data(port);
+        for (i = 0; i < ARRAY_SIZE(portdata->in_urbs); i++)
+                usb_kill_urb(portdata->in_urbs[i]);
 
-        dev_dbg(&port->dev, "%s", __func__);
+        usb_kill_urb(port->interrupt_in_urb);
+}
 
-        /* Set some sane defaults */
-        portdata->rts_state = 1;
-        portdata->dtr_state = 1;
+static int sierra_submit_rx_urbs(struct usb_serial_port *port, gfp_t mem_flags)
+{
+        int ok_cnt;
+        int err = -EINVAL;
+        int i;
+        struct urb *urb;
+        struct sierra_port_private *portdata = usb_get_serial_port_data(port);
 
-        /* Reset low level data toggle and start reading from endpoints */
-        for (i = 0; i < N_IN_URB; i++) {
+        ok_cnt = 0;
+        for (i = 0; i < ARRAY_SIZE(portdata->in_urbs); i++) {
                 urb = portdata->in_urbs[i];
                 if (!urb)
                         continue;
-                if (urb->dev != serial->dev) {
-                        dev_dbg(&port->dev, "%s: dev %p != %p",
-                                 __func__, urb->dev, serial->dev);
-                        continue;
+                err = usb_submit_urb(urb, mem_flags);
+                if (err) {
+                        dev_err(&port->dev, "%s: submit urb failed: %d\n",
+                                __func__, err);
+                } else {
+                        ok_cnt++;
                 }
+        }
 
-                /*
-                 * make sure endpoint data toggle is synchronized with the
-                 * device
-                 */
-                usb_clear_halt(urb->dev, urb->pipe);
-
-                result = usb_submit_urb(urb, GFP_KERNEL);
-                if (result) {
-                        dev_err(&port->dev, "submit urb %d failed (%d) %d\n",
-                                i, result, urb->transfer_buffer_length);
+        if (ok_cnt && port->interrupt_in_urb) {
+                err = usb_submit_urb(port->interrupt_in_urb, mem_flags);
+                if (err) {
+                        dev_err(&port->dev, "%s: submit intr urb failed: %d\n",
+                                __func__, err);
                 }
         }
 
-        sierra_send_setup(tty, port);
+        if (ok_cnt > 0) /* at least one rx urb submitted */
+                return 0;
+        else
+                return err;
+}
+
+static struct urb *sierra_setup_urb(struct usb_serial *serial, int endpoint,
+                                        int dir, void *ctx, int len,
+                                        gfp_t mem_flags,
+                                        usb_complete_t callback)
+{
+        struct urb      *urb;
+        u8              *buf;
+
+        if (endpoint == -1)
+                return NULL;
 
-        /* start up the interrupt endpoint if we have one */
-        if (port->interrupt_in_urb) {
-                result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
-                if (result)
-                        dev_err(&port->dev, "submit irq_in urb failed %d\n",
-                                result);
+        urb = usb_alloc_urb(0, mem_flags);
+        if (urb == NULL) {
+                dev_dbg(&serial->dev->dev, "%s: alloc for endpoint %d failed\n",
+                        __func__, endpoint);
+                return NULL;
         }
-        return 0;
+
+        buf = kmalloc(len, mem_flags);
+        if (buf) {
+                /* Fill URB using supplied data */
+                usb_fill_bulk_urb(urb, serial->dev,
+                        usb_sndbulkpipe(serial->dev, endpoint) | dir,
+                        buf, len, callback, ctx);
+
+                /* debug */
+                dev_dbg(&serial->dev->dev, "%s %c u : %p d:%p\n", __func__,
+                                dir == USB_DIR_IN ? 'i' : 'o', urb, buf);
+        } else {
+                dev_dbg(&serial->dev->dev, "%s %c u:%p d:%p\n", __func__,
+                                dir == USB_DIR_IN ? 'i' : 'o', urb, buf);
+
+                sierra_release_urb(urb);
+                urb = NULL;
+        }
+
+        return urb;
 }
 
-static void sierra_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void sierra_close(struct usb_serial_port *port)
 {
         int i;
         struct usb_serial *serial = port->serial;
         struct sierra_port_private *portdata;
 
-        dev_dbg(&port->dev, "%s", __func__);
+        dev_dbg(&port->dev, "%s\n", __func__);
         portdata = usb_get_serial_port_data(port);
 
         portdata->rts_state = 0;
@@ -626,25 +704,83 @@ static void sierra_close(struct tty_struct *tty,
         if (serial->dev) {
                 mutex_lock(&serial->disc_mutex);
                 if (!serial->disconnected)
-                        sierra_send_setup(tty, port);
+                        sierra_send_setup(port);
                 mutex_unlock(&serial->disc_mutex);
 
-                /* Stop reading/writing urbs */
-                for (i = 0; i < N_IN_URB; i++)
-                        usb_kill_urb(portdata->in_urbs[i]);
+                /* Stop reading urbs */
+                sierra_stop_rx_urbs(port);
+                /* .. and release them */
+                for (i = 0; i < N_IN_URB; i++) {
+                        sierra_release_urb(portdata->in_urbs[i]);
+                        portdata->in_urbs[i] = NULL;
+                }
         }
+}
 
-        usb_kill_urb(port->interrupt_in_urb);
-        tty_port_tty_set(&port->port, NULL);
+static int sierra_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
+{
+        struct sierra_port_private *portdata;
+        struct usb_serial *serial = port->serial;
+        int i;
+        int err;
+        int endpoint;
+        struct urb *urb;
+
+        portdata = usb_get_serial_port_data(port);
+
+        dev_dbg(&port->dev, "%s", __func__);
+
+        /* Set some sane defaults */
+        portdata->rts_state = 1;
+        portdata->dtr_state = 1;
+
+
+        endpoint = port->bulk_in_endpointAddress;
+        for (i = 0; i < ARRAY_SIZE(portdata->in_urbs); i++) {
+                urb = sierra_setup_urb(serial, endpoint, USB_DIR_IN, port,
+                                        IN_BUFLEN, GFP_KERNEL,
+                                        sierra_indat_callback);
+                portdata->in_urbs[i] = urb;
+        }
+        /* clear halt condition */
+        usb_clear_halt(serial->dev,
+                        usb_sndbulkpipe(serial->dev, endpoint) | USB_DIR_IN);
+
+        err = sierra_submit_rx_urbs(port, GFP_KERNEL);
+        if (err) {
+                /* get rid of everything as in close */
+                sierra_close(port);
+                return err;
+        }
+        sierra_send_setup(port);
+
+        return 0;
+}
+
+
+static void sierra_dtr_rts(struct usb_serial_port *port, int on)
+{
+        struct usb_serial *serial = port->serial;
+        struct sierra_port_private *portdata;
+
+        portdata = usb_get_serial_port_data(port);
+        portdata->rts_state = on;
+        portdata->dtr_state = on;
+
+        if (serial->dev) {
+                mutex_lock(&serial->disc_mutex);
+                if (!serial->disconnected)
+                        sierra_send_setup(port);
+                mutex_unlock(&serial->disc_mutex);
+        }
 }
 
 static int sierra_startup(struct usb_serial *serial)
 {
         struct usb_serial_port *port;
         struct sierra_port_private *portdata;
-        struct urb *urb;
         int i;
-        int j;
 
         dev_dbg(&serial->dev->dev, "%s", __func__);
 
@@ -666,34 +802,8 @@ static int sierra_startup(struct usb_serial *serial)
                         return -ENOMEM;
                 }
                 spin_lock_init(&portdata->lock);
-                for (j = 0; j < N_IN_URB; j++) {
-                        portdata->in_buffer[j] = kmalloc(IN_BUFLEN, GFP_KERNEL);
-                        if (!portdata->in_buffer[j]) {
-                                for (--j; j >= 0; j--)
-                                        kfree(portdata->in_buffer[j]);
-                                kfree(portdata);
-                                return -ENOMEM;
-                        }
-                }
-
+                /* Set the port private data pointer */
                 usb_set_serial_port_data(port, portdata);
-
-                /* initialize the in urbs */
-                for (j = 0; j < N_IN_URB; ++j) {
-                        urb = usb_alloc_urb(0, GFP_KERNEL);
-                        if (urb == NULL) {
-                                dev_dbg(&port->dev, "%s: alloc for in "
-                                        "port failed.", __func__);
-                                continue;
-                        }
-                        /* Fill URB using supplied data. */
-                        usb_fill_bulk_urb(urb, serial->dev,
-                                          usb_rcvbulkpipe(serial->dev,
-                                                port->bulk_in_endpointAddress),
-                                          portdata->in_buffer[j], IN_BUFLEN,
-                                          sierra_indat_callback, port);
-                        portdata->in_urbs[j] = urb;
-                }
         }
 
         return 0;
@@ -701,7 +811,7 @@ static int sierra_startup(struct usb_serial *serial)
 
 static void sierra_shutdown(struct usb_serial *serial)
 {
-        int i, j;
+        int i;
         struct usb_serial_port *port;
         struct sierra_port_private *portdata;
 
@@ -714,12 +824,6 @@ static void sierra_shutdown(struct usb_serial *serial)
                 portdata = usb_get_serial_port_data(port);
                 if (!portdata)
                         continue;
-
-                for (j = 0; j < N_IN_URB; j++) {
-                        usb_kill_urb(portdata->in_urbs[j]);
-                        usb_free_urb(portdata->in_urbs[j]);
-                        kfree(portdata->in_buffer[j]);
-                }
                 kfree(portdata);
                 usb_set_serial_port_data(port, NULL);
         }
@@ -737,6 +841,7 @@ static struct usb_serial_driver sierra_device = {
         .probe             = sierra_probe,
         .open              = sierra_open,
         .close             = sierra_close,
+        .dtr_rts           = sierra_dtr_rts,
         .write             = sierra_write,
         .write_room        = sierra_write_room,
         .set_termios       = sierra_set_termios,
diff --git a/drivers/usb/serial/spcp8x5.c b/drivers/usb/serial/spcp8x5.c
index 5e7528cc81a8..8f7ed8f13996 100644
--- a/drivers/usb/serial/spcp8x5.c
+++ b/drivers/usb/serial/spcp8x5.c
@@ -446,66 +446,47 @@ static void spcp8x5_set_workMode(struct usb_device *dev, u16 value,
                         "RTSCTS usb_control_msg(enable flowctrl) = %d\n", ret);
 }
 
+static int spcp8x5_carrier_raised(struct usb_serial_port *port)
+{
+        struct spcp8x5_private *priv = usb_get_serial_port_data(port);
+        if (priv->line_status & MSR_STATUS_LINE_DCD)
+                return 1;
+        return 0;
+}
+
+static void spcp8x5_dtr_rts(struct usb_serial_port *port, int on)
+{
+        struct spcp8x5_private *priv = usb_get_serial_port_data(port);
+        unsigned long flags;
+        u8 control;
+
+        spin_lock_irqsave(&priv->lock, flags);
+        if (on)
+                priv->line_control = MCR_CONTROL_LINE_DTR
+                                                | MCR_CONTROL_LINE_RTS;
+        else
+                priv->line_control &= ~ (MCR_CONTROL_LINE_DTR
+                                                | MCR_CONTROL_LINE_RTS);
+        control = priv->line_control;
+        spin_unlock_irqrestore(&priv->lock, flags);
+        spcp8x5_set_ctrlLine(port->serial->dev, control , priv->type);
+}
+
 /* close the serial port. We should wait for data sending to device 1st and
  * then kill all urb. */
-static void spcp8x5_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void spcp8x5_close(struct usb_serial_port *port)
 {
         struct spcp8x5_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
-        unsigned int c_cflag;
-        int bps;
-        long timeout;
-        wait_queue_t wait;
         int result;
 
         dbg("%s - port %d", __func__, port->number);
 
-        /* wait for data to drain from the buffer */
         spin_lock_irqsave(&priv->lock, flags);
-        timeout = SPCP8x5_CLOSING_WAIT;
-        init_waitqueue_entry(&wait, current);
-        add_wait_queue(&tty->write_wait, &wait);
-        for (;;) {
-                set_current_state(TASK_INTERRUPTIBLE);
-                if (ringbuf_avail_data(priv->buf) == 0 ||
-                    timeout == 0 || signal_pending(current))
-                        break;
-                spin_unlock_irqrestore(&priv->lock, flags);
-                timeout = schedule_timeout(timeout);
-                spin_lock_irqsave(&priv->lock, flags);
-        }
-        set_current_state(TASK_RUNNING);
-        remove_wait_queue(&tty->write_wait, &wait);
-
         /* clear out any remaining data in the buffer */
         clear_ringbuf(priv->buf);
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        /* wait for characters to drain from the device (this is long enough
-         * for the entire all byte spcp8x5 hardware buffer to drain with no
-         * flow control for data rates of 1200 bps or more, for lower rates we
-         * should really know how much data is in the buffer to compute a delay
-         * that is not unnecessarily long) */
-        bps = tty_get_baud_rate(tty);
-        if (bps > 1200)
-                timeout = max((HZ*2560) / bps, HZ/10);
-        else
-                timeout = 2*HZ;
-        set_current_state(TASK_INTERRUPTIBLE);
-        schedule_timeout(timeout);
-
-        /* clear control lines */
-        if (tty) {
-                c_cflag = tty->termios->c_cflag;
-                if (c_cflag & HUPCL) {
-                        spin_lock_irqsave(&priv->lock, flags);
-                        priv->line_control = 0;
-                        spin_unlock_irqrestore(&priv->lock, flags);
-                        spcp8x5_set_ctrlLine(port->serial->dev, 0 , priv->type);
-                }
-        }
-
         /* kill urb */
         if (port->write_urb != NULL) {
                 result = usb_unlink_urb(port->write_urb);
@@ -665,13 +646,6 @@ static int spcp8x5_open(struct tty_struct *tty,
         if (ret)
                 return ret;
 
-        spin_lock_irqsave(&priv->lock, flags);
-        if (tty && (tty->termios->c_cflag & CBAUD))
-                priv->line_control = MCR_DTR | MCR_RTS;
-        else
-                priv->line_control = 0;
-        spin_unlock_irqrestore(&priv->lock, flags);
-
         spcp8x5_set_ctrlLine(serial->dev, priv->line_control , priv->type);
 
         /* Setup termios */
@@ -691,9 +665,10 @@ static int spcp8x5_open(struct tty_struct *tty,
         port->read_urb->dev = serial->dev;
         ret = usb_submit_urb(port->read_urb, GFP_KERNEL);
         if (ret) {
-                spcp8x5_close(tty, port, NULL);
+                spcp8x5_close(port);
                 return -EPROTO;
         }
+        port->port.drain_delay = 256;
         return 0;
 }
 
@@ -1033,6 +1008,8 @@ static struct usb_serial_driver spcp8x5_device = {
         .num_ports              = 1,
         .open                   = spcp8x5_open,
         .close                  = spcp8x5_close,
+        .dtr_rts                = spcp8x5_dtr_rts,
+        .carrier_raised         = spcp8x5_carrier_raised,
         .write                  = spcp8x5_write,
         .set_termios            = spcp8x5_set_termios,
         .ioctl                  = spcp8x5_ioctl,
diff --git a/drivers/usb/serial/symbolserial.c b/drivers/usb/serial/symbolserial.c
index 69879e437940..8b07ebc6baeb 100644
--- a/drivers/usb/serial/symbolserial.c
+++ b/drivers/usb/serial/symbolserial.c
@@ -152,8 +152,7 @@ static int symbol_open(struct tty_struct *tty, struct usb_serial_port *port,
         return result;
 }
 
-static void symbol_close(struct tty_struct *tty, struct usb_serial_port *port,
-                          struct file *filp)
+static void symbol_close(struct usb_serial_port *port)
 {
         struct symbol_private *priv = usb_get_serial_data(port->serial);
 
diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c
index 0a64bac306ee..42cb04c403be 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.c
+++ b/drivers/usb/serial/ti_usb_3410_5052.c
@@ -100,8 +100,7 @@ static int ti_startup(struct usb_serial *serial);
 static void ti_shutdown(struct usb_serial *serial);
 static int ti_open(struct tty_struct *tty, struct usb_serial_port *port,
                 struct file *file);
-static void ti_close(struct tty_struct *tty, struct usb_serial_port *port,
-                struct file *file);
+static void ti_close(struct usb_serial_port *port);
 static int ti_write(struct tty_struct *tty, struct usb_serial_port *port,
                 const unsigned char *data, int count);
 static int ti_write_room(struct tty_struct *tty);
@@ -647,8 +646,7 @@ release_lock:
 }
 
 
-static void ti_close(struct tty_struct *tty, struct usb_serial_port *port,
-                                                        struct file *file)
+static void ti_close(struct usb_serial_port *port)
 {
         struct ti_device *tdev;
         struct ti_port *tport;
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index f331e2bde88a..1967a7edc10c 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -238,9 +238,11 @@ static int serial_open (struct tty_struct *tty, struct file *filp)
                         goto bailout_interface_put;
                 mutex_unlock(&serial->disc_mutex);
         }
-
         mutex_unlock(&port->mutex);
-        return 0;
+        /* Now do the correct tty layer semantics */
+        retval = tty_port_block_til_ready(&port->port, tty, filp);
+        if (retval == 0)
+                return 0;
 
 bailout_interface_put:
         usb_autopm_put_interface(serial->interface);
@@ -259,64 +261,89 @@ bailout_serial_put:
         return retval;
 }
 
-static void serial_close(struct tty_struct *tty, struct file *filp)
+/**
+ *      serial_do_down          -       shut down hardware
+ *      @port: port to shut down
+ *
+ *      Shut down a USB port unless it is the console. We never shut down the
+ *      console hardware as it will always be in use.
+ *
+ *      Don't free any resources at this point
+ */
+static void serial_do_down(struct usb_serial_port *port)
 {
-        struct usb_serial_port *port = tty->driver_data;
+        struct usb_serial_driver *drv = port->serial->type;
         struct usb_serial *serial;
         struct module *owner;
-        int count;
 
-        if (!port)
+        /* The console is magical, do not hang up the console hardware
+           or there will be tears */
+        if (port->console)
                 return;
 
-        dbg("%s - port %d", __func__, port->number);
-
         mutex_lock(&port->mutex);
         serial = port->serial;
         owner = serial->type->driver.owner;
 
-        if (port->port.count == 0) {
-                mutex_unlock(&port->mutex);
-                return;
-        }
-
-        if (port->port.count == 1)
-                /* only call the device specific close if this
-                 * port is being closed by the last owner. Ensure we do
-                 * this before we drop the port count. The call is protected
-                 * by the port mutex
-                 */
-                serial->type->close(tty, port, filp);
-
-        if (port->port.count == (port->console ? 2 : 1)) {
-                struct tty_struct *tty = tty_port_tty_get(&port->port);
-                if (tty) {
-                        /* We must do this before we drop the port count to
-                           zero. */
-                        if (tty->driver_data)
-                                tty->driver_data = NULL;
-                        tty_port_tty_set(&port->port, NULL);
-                        tty_kref_put(tty);
-                }
-        }
+        if (drv->close)
+                drv->close(port);
 
-        --port->port.count;
-        count = port->port.count;
         mutex_unlock(&port->mutex);
-        put_device(&port->dev);
+}
+
+/**
+ *      serial_do_free          -       free resources post close/hangup
+ *      @port: port to free up
+ *
+ *      Do the resource freeing and refcount dropping for the port. We must
+ *      be careful about ordering and we must avoid freeing up the console.
+ */
 
+static void serial_do_free(struct usb_serial_port *port)
+{
+        struct usb_serial *serial;
+        struct module *owner;
+
+        /* The console is magical, do not hang up the console hardware
+           or there will be tears */
+        if (port->console)
+                return;
+
+        serial = port->serial;
+        owner = serial->type->driver.owner;
+        put_device(&port->dev);
         /* Mustn't dereference port any more */
-        if (count == 0) {
-                mutex_lock(&serial->disc_mutex);
-                if (!serial->disconnected)
-                        usb_autopm_put_interface(serial->interface);
-                mutex_unlock(&serial->disc_mutex);
-        }
+        mutex_lock(&serial->disc_mutex);
+        if (!serial->disconnected)
+                usb_autopm_put_interface(serial->interface);
+        mutex_unlock(&serial->disc_mutex);
         usb_serial_put(serial);
-
         /* Mustn't dereference serial any more */
-        if (count == 0)
-                module_put(owner);
+        module_put(owner);
+}
+
+static void serial_close(struct tty_struct *tty, struct file *filp)
+{
+        struct usb_serial_port *port = tty->driver_data;
+
+        dbg("%s - port %d", __func__, port->number);
+
+
+        if (tty_port_close_start(&port->port, tty, filp) == 0)
+                return;
+
+        serial_do_down(port);           
+        tty_port_close_end(&port->port, tty);
+        tty_port_tty_set(&port->port, NULL);
+        serial_do_free(port);
+}
+
+static void serial_hangup(struct tty_struct *tty)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        serial_do_down(port);
+        tty_port_hangup(&port->port);
+        serial_do_free(port);
 }
 
 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
@@ -648,6 +675,29 @@ static struct usb_serial_driver *search_serial_device(
         return NULL;
 }
 
+static int serial_carrier_raised(struct tty_port *port)
+{
+        struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
+        struct usb_serial_driver *drv = p->serial->type;
+        if (drv->carrier_raised)
+                return drv->carrier_raised(p);
+        /* No carrier control - don't block */
+        return 1;       
+}
+
+static void serial_dtr_rts(struct tty_port *port, int on)
+{
+        struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
+        struct usb_serial_driver *drv = p->serial->type;
+        if (drv->dtr_rts)
+                drv->dtr_rts(p, on);
+}
+
+static const struct tty_port_operations serial_port_ops = {
+        .carrier_raised = serial_carrier_raised,
+        .dtr_rts = serial_dtr_rts,
+};
+
 int usb_serial_probe(struct usb_interface *interface,
                                const struct usb_device_id *id)
 {
@@ -841,6 +891,7 @@ int usb_serial_probe(struct usb_interface *interface,
                 if (!port)
                         goto probe_error;
                 tty_port_init(&port->port);
+                port->port.ops = &serial_port_ops;
                 port->serial = serial;
                 spin_lock_init(&port->lock);
                 mutex_init(&port->mutex);
@@ -1071,6 +1122,9 @@ void usb_serial_disconnect(struct usb_interface *interface)
                 if (port) {
                         struct tty_struct *tty = tty_port_tty_get(&port->port);
                         if (tty) {
+                                /* The hangup will occur asynchronously but
+                                   the object refcounts will sort out all the
+                                   cleanup */
                                 tty_hangup(tty);
                                 tty_kref_put(tty);
                         }
@@ -1135,6 +1189,7 @@ static const struct tty_operations serial_ops = {
         .open =                 serial_open,
         .close =                serial_close,
         .write =                serial_write,
+        .hangup =               serial_hangup,
         .write_room =           serial_write_room,
         .ioctl =                serial_ioctl,
         .set_termios =          serial_set_termios,
@@ -1147,6 +1202,7 @@ static const struct tty_operations serial_ops = {
         .proc_fops =            &serial_proc_fops,
 };
 
+
 struct tty_driver *usb_serial_tty_driver;
 
 static int __init usb_serial_init(void)
diff --git a/drivers/usb/serial/visor.c b/drivers/usb/serial/visor.c
index 5ac414bda718..b15f1c0e1d4a 100644
--- a/drivers/usb/serial/visor.c
+++ b/drivers/usb/serial/visor.c
@@ -38,8 +38,7 @@
 /* function prototypes for a handspring visor */
 static int  visor_open(struct tty_struct *tty, struct usb_serial_port *port,
                                         struct file *filp);
-static void visor_close(struct tty_struct *tty, struct usb_serial_port *port,
-                                        struct file *filp);
+static void visor_close(struct usb_serial_port *port);
 static int  visor_write(struct tty_struct *tty, struct usb_serial_port *port,
                                         const unsigned char *buf, int count);
 static int  visor_write_room(struct tty_struct *tty);
@@ -324,8 +323,7 @@ exit:
 }
 
 
-static void visor_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void visor_close(struct usb_serial_port *port)
 {
         struct visor_private *priv = usb_get_serial_port_data(port);
         unsigned char *transfer_buffer;
diff --git a/drivers/usb/serial/whiteheat.c b/drivers/usb/serial/whiteheat.c
index 5335d3211c07..7c7295d09f34 100644
--- a/drivers/usb/serial/whiteheat.c
+++ b/drivers/usb/serial/whiteheat.c
@@ -147,8 +147,7 @@ static int  whiteheat_attach(struct usb_serial *serial);
 static void whiteheat_shutdown(struct usb_serial *serial);
 static int  whiteheat_open(struct tty_struct *tty,
                         struct usb_serial_port *port, struct file *filp);
-static void whiteheat_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+static void whiteheat_close(struct usb_serial_port *port);
 static int  whiteheat_write(struct tty_struct *tty,
                         struct usb_serial_port *port,
                         const unsigned char *buf, int count);
@@ -712,8 +711,7 @@ exit:
 }
 
 
-static void whiteheat_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void whiteheat_close(struct usb_serial_port *port)
 {
         struct whiteheat_private *info = usb_get_serial_port_data(port);
         struct whiteheat_urb_wrap *wrap;
@@ -723,31 +721,7 @@ static void whiteheat_close(struct tty_struct *tty,
 
         dbg("%s - port %d", __func__, port->number);
 
-        mutex_lock(&port->serial->disc_mutex);
-        /* filp is NULL when called from usb_serial_disconnect */
-        if ((filp && (tty_hung_up_p(filp))) || port->serial->disconnected) {
-                mutex_unlock(&port->serial->disc_mutex);
-                return;
-        }
-        mutex_unlock(&port->serial->disc_mutex);
-
-        tty->closing = 1;
-
-/*
- * Not currently in use; tty_wait_until_sent() calls
- * serial_chars_in_buffer() which deadlocks on the second semaphore
- * acquisition. This should be fixed at some point. Greg's been
- * notified.
-        if ((filp->f_flags & (O_NDELAY | O_NONBLOCK)) == 0) {
-                tty_wait_until_sent(tty, CLOSING_DELAY);
-        }
-*/
-
-        tty_driver_flush_buffer(tty);
-        tty_ldisc_flush(tty);
-
         firm_report_tx_done(port);
-
         firm_close(port);
 
         /* shutdown our bulk reads and writes */
@@ -775,10 +749,7 @@ static void whiteheat_close(struct tty_struct *tty,
         }
         spin_unlock_irq(&info->lock);
         mutex_unlock(&info->deathwarrant);
-
         stop_command_port(port->serial);
-
-        tty->closing = 0;
 }
 
 
diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
index 4ca3b5860643..cfa26d56ce60 100644
--- a/drivers/usb/storage/scsiglue.c
+++ b/drivers/usb/storage/scsiglue.c
@@ -132,7 +132,7 @@ static int slave_configure(struct scsi_device *sdev)
 
                 if (us->fflags & US_FL_MAX_SECTORS_MIN)
                         max_sectors = PAGE_CACHE_SIZE >> 9;
-                if (sdev->request_queue->max_sectors > max_sectors)
+                if (queue_max_sectors(sdev->request_queue) > max_sectors)
                         blk_queue_max_sectors(sdev->request_queue,
                                               max_sectors);
         } else if (sdev->type == TYPE_TAPE) {
@@ -483,7 +483,7 @@ static ssize_t show_max_sectors(struct device *dev, struct device_attribute *att
 {
         struct scsi_device *sdev = to_scsi_device(dev);
 
-        return sprintf(buf, "%u\n", sdev->request_queue->max_sectors);
+        return sprintf(buf, "%u\n", queue_max_sectors(sdev->request_queue));
 }
 
 /* Input routine for the sysfs max_sectors file */
diff --git a/drivers/video/hitfb.c b/drivers/video/hitfb.c
index e6467cf9f19f..020db7fc9153 100644
--- a/drivers/video/hitfb.c
+++ b/drivers/video/hitfb.c
@@ -335,9 +335,9 @@ static int __init hitfb_probe(struct platform_device *dev)
         if (fb_get_options("hitfb", NULL))
                 return -ENODEV;
 
-        hitfb_fix.mmio_start = CONFIG_HD64461_IOBASE+0x1000;
+        hitfb_fix.mmio_start = HD64461_IO_OFFSET(0x1000);
         hitfb_fix.mmio_len = 0x1000;
-        hitfb_fix.smem_start = CONFIG_HD64461_IOBASE + 0x02000000;
+        hitfb_fix.smem_start = HD64461_IO_OFFSET(0x02000000);
         hitfb_fix.smem_len = 512 * 1024;
 
         lcdclor = fb_readw(HD64461_LCDCLOR);
diff --git a/fs/bio.c b/fs/bio.c
index 740699c4f90c..59000215e59b 100644
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -498,11 +498,11 @@ int bio_get_nr_vecs(struct block_device *bdev)
         struct request_queue *q = bdev_get_queue(bdev);
         int nr_pages;
 
-        nr_pages = ((q->max_sectors << 9) + PAGE_SIZE - 1) >> PAGE_SHIFT;
-        if (nr_pages > q->max_phys_segments)
-                nr_pages = q->max_phys_segments;
-        if (nr_pages > q->max_hw_segments)
-                nr_pages = q->max_hw_segments;
+        nr_pages = ((queue_max_sectors(q) << 9) + PAGE_SIZE - 1) >> PAGE_SHIFT;
+        if (nr_pages > queue_max_phys_segments(q))
+                nr_pages = queue_max_phys_segments(q);
+        if (nr_pages > queue_max_hw_segments(q))
+                nr_pages = queue_max_hw_segments(q);
 
         return nr_pages;
 }
@@ -561,8 +561,8 @@ static int __bio_add_page(struct request_queue *q, struct bio *bio, struct page
          * make this too complex.
          */
 
-        while (bio->bi_phys_segments >= q->max_phys_segments
-               || bio->bi_phys_segments >= q->max_hw_segments) {
+        while (bio->bi_phys_segments >= queue_max_phys_segments(q)
+               || bio->bi_phys_segments >= queue_max_hw_segments(q)) {
 
                 if (retried_segments)
                         return 0;
@@ -633,7 +633,8 @@ static int __bio_add_page(struct request_queue *q, struct bio *bio, struct page
 int bio_add_pc_page(struct request_queue *q, struct bio *bio, struct page *page,
                     unsigned int len, unsigned int offset)
 {
-        return __bio_add_page(q, bio, page, len, offset, q->max_hw_sectors);
+        return __bio_add_page(q, bio, page, len, offset,
+                              queue_max_hw_sectors(q));
 }
 
 /**
@@ -653,7 +654,7 @@ int bio_add_page(struct bio *bio, struct page *page, unsigned int len,
                  unsigned int offset)
 {
         struct request_queue *q = bdev_get_queue(bio->bi_bdev);
-        return __bio_add_page(q, bio, page, len, offset, q->max_sectors);
+        return __bio_add_page(q, bio, page, len, offset, queue_max_sectors(q));
 }
 
 struct bio_map_data {
@@ -720,7 +721,7 @@ static int __bio_copy_iov(struct bio *bio, struct bio_vec *iovecs,
 
                 while (bv_len && iov_idx < iov_count) {
                         unsigned int bytes;
-                        char *iov_addr;
+                        char __user *iov_addr;
 
                         bytes = min_t(unsigned int,
                                       iov[iov_idx].iov_len - iov_off, bv_len);
@@ -1200,7 +1201,7 @@ static void bio_copy_kern_endio(struct bio *bio, int err)
                 char *addr = page_address(bvec->bv_page);
                 int len = bmd->iovecs[i].bv_len;
 
-                if (read && !err)
+                if (read)
                         memcpy(p, addr, len);
 
                 __free_page(bvec->bv_page);
@@ -1489,11 +1490,12 @@ struct bio_pair *bio_split(struct bio *bi, int first_sectors)
 sector_t bio_sector_offset(struct bio *bio, unsigned short index,
                            unsigned int offset)
 {
-        unsigned int sector_sz = queue_hardsect_size(bio->bi_bdev->bd_disk->queue);
+        unsigned int sector_sz;
         struct bio_vec *bv;
         sector_t sectors;
         int i;
 
+        sector_sz = queue_logical_block_size(bio->bi_bdev->bd_disk->queue);
         sectors = 0;
 
         if (index >= bio->bi_idx)
diff --git a/fs/block_dev.c b/fs/block_dev.c
index f45dbc18dd17..2dfc6cdcebbe 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -76,7 +76,7 @@ int set_blocksize(struct block_device *bdev, int size)
                 return -EINVAL;
 
         /* Size cannot be smaller than the size supported by the device */
-        if (size < bdev_hardsect_size(bdev))
+        if (size < bdev_logical_block_size(bdev))
                 return -EINVAL;
 
         /* Don't change the size if it is same as current */
@@ -106,7 +106,7 @@ EXPORT_SYMBOL(sb_set_blocksize);
 
 int sb_min_blocksize(struct super_block *sb, int size)
 {
-        int minsize = bdev_hardsect_size(sb->s_bdev);
+        int minsize = bdev_logical_block_size(sb->s_bdev);
         if (size < minsize)
                 size = minsize;
         return sb_set_blocksize(sb, size);
@@ -1111,7 +1111,7 @@ EXPORT_SYMBOL(check_disk_change);
 
 void bd_set_size(struct block_device *bdev, loff_t size)
 {
-        unsigned bsize = bdev_hardsect_size(bdev);
+        unsigned bsize = bdev_logical_block_size(bdev);
 
         bdev->bd_inode->i_size = size;
         while (bsize < PAGE_CACHE_SIZE) {
diff --git a/fs/buffer.c b/fs/buffer.c
index 49106127a4aa..a3ef091a45bd 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -1085,12 +1085,12 @@ static struct buffer_head *
 __getblk_slow(struct block_device *bdev, sector_t block, int size)
 {
         /* Size must be multiple of hard sectorsize */
-        if (unlikely(size & (bdev_hardsect_size(bdev)-1) ||
+        if (unlikely(size & (bdev_logical_block_size(bdev)-1) ||
                         (size < 512 || size > PAGE_SIZE))) {
                 printk(KERN_ERR "getblk(): invalid block size %d requested\n",
                                         size);
-                printk(KERN_ERR "hardsect size: %d\n",
-                                        bdev_hardsect_size(bdev));
+                printk(KERN_ERR "logical block size: %d\n",
+                                        bdev_logical_block_size(bdev));
 
                 dump_stack();
                 return NULL;
@@ -2935,6 +2935,8 @@ int submit_bh(int rw, struct buffer_head * bh)
         BUG_ON(!buffer_locked(bh));
         BUG_ON(!buffer_mapped(bh));
         BUG_ON(!bh->b_end_io);
+        BUG_ON(buffer_delay(bh));
+        BUG_ON(buffer_unwritten(bh));
 
         /*
          * Mask in barrier bit for a write (could be either a WRITE or a
diff --git a/fs/cifs/CHANGES b/fs/cifs/CHANGES
index f20c4069c220..b48689839428 100644
--- a/fs/cifs/CHANGES
+++ b/fs/cifs/CHANGES
@@ -1,3 +1,12 @@
+Version 1.59
+------------
+Client uses server inode numbers (which are persistent) rather than
+client generated ones by default (mount option "serverino" turned
+on by default if server supports it).  Add forceuid and forcegid
+mount options (so that when negotiating unix extensions specifying
+which uid mounted does not immediately force the server's reported
+uids to be overridden).
+
 Version 1.58
 ------------
 Guard against buffer overruns in various UCS-2 to UTF-8 string conversions
@@ -10,6 +19,8 @@ we converted from).  Fix endianness of the vcnum field used during
 session setup to distinguish multiple mounts to same server from different
 userids. Raw NTLMSSP fixed (it requires /proc/fs/cifs/experimental
 flag to be set to 2, and mount must enable krb5 to turn on extended security).
+Performance of file create to Samba improved (posix create on lookup
+removes 1 of 2 network requests sent on file create)
  
 Version 1.57
 ------------
diff --git a/fs/cifs/README b/fs/cifs/README
index db208ddb9899..ad92921dbde4 100644
--- a/fs/cifs/README
+++ b/fs/cifs/README
@@ -262,7 +262,8 @@ A partial list of the supported mount options follows:
                 mount.  
   domain        Set the SMB/CIFS workgroup name prepended to the
                 username during CIFS session establishment
-  uid           Set the default uid for inodes. For mounts to servers
+  forceuid      Set the default uid for inodes based on the uid
+                passed in. For mounts to servers
                 which do support the CIFS Unix extensions, such as a
                 properly configured Samba server, the server provides
                 the uid, gid and mode so this parameter should  not be
@@ -292,6 +293,12 @@ A partial list of the supported mount options follows:
                 the client.  Note that the mount.cifs helper must be
                 at version 1.10 or higher to support specifying the uid
                 (or gid) in non-numeric form.
+  forcegid      (similar to above but for the groupid instead of uid)
+  uid           Set the default uid for inodes, and indicate to the
+                cifs kernel driver which local user mounted . If the server
+                supports the unix extensions the default uid is
+                not used to fill in the owner fields of inodes (files)
+                unless the "forceuid" parameter is specified.
   gid           Set the default gid for inodes (similar to above).
   file_mode     If CIFS Unix extensions are not supported by the server
                 this overrides the default mode for file inodes.
@@ -388,8 +395,13 @@ A partial list of the supported mount options follows:
                 or the CIFS Unix Extensions equivalent and for those
                 this mount option will have no effect.  Exporting cifs mounts
                 under nfsd requires this mount option on the cifs mount.
+                This is now the default if server supports the 
+                required network operation.
   noserverino   Client generates inode numbers (rather than using the actual one
-                from the server) by default.
+                from the server). These inode numbers will vary after
+                unmount or reboot which can confuse some applications,
+                but not all server filesystems support unique inode
+                numbers.
   setuids       If the CIFS Unix extensions are negotiated with the server
                 the client will attempt to set the effective uid and gid of
                 the local process on newly created files, directories, and
diff --git a/fs/cifs/cifs_spnego.c b/fs/cifs/cifs_spnego.c
index 67bf93a40d2e..4a4581cb2b5e 100644
--- a/fs/cifs/cifs_spnego.c
+++ b/fs/cifs/cifs_spnego.c
@@ -23,6 +23,7 @@
 #include <linux/string.h>
 #include <keys/user-type.h>
 #include <linux/key-type.h>
+#include <linux/inet.h>
 #include "cifsglob.h"
 #include "cifs_spnego.h"
 #include "cifs_debug.h"
@@ -73,9 +74,6 @@ struct key_type cifs_spnego_key_type = {
  * strlen(";sec=ntlmsspi") */
 #define MAX_MECH_STR_LEN        13
 
-/* max possible addr len eg FEDC:BA98:7654:3210:FEDC:BA98:7654:3210/128 */
-#define MAX_IPV6_ADDR_LEN       43
-
 /* strlen of "host=" */
 #define HOST_KEY_LEN            5
 
@@ -102,7 +100,7 @@ cifs_get_spnego_key(struct cifsSesInfo *sesInfo)
            host=hostname sec=mechanism uid=0xFF user=username */
         desc_len = MAX_VER_STR_LEN +
                    HOST_KEY_LEN + strlen(hostname) +
-                   IP_KEY_LEN + MAX_IPV6_ADDR_LEN +
+                   IP_KEY_LEN + INET6_ADDRSTRLEN +
                    MAX_MECH_STR_LEN +
                    UID_KEY_LEN + (sizeof(uid_t) * 2) +
                    USER_KEY_LEN + strlen(sesInfo->userName) + 1;
diff --git a/fs/cifs/cifsacl.c b/fs/cifs/cifsacl.c
index 57ecdc83c26f..1403b5d86a73 100644
--- a/fs/cifs/cifsacl.c
+++ b/fs/cifs/cifsacl.c
@@ -552,130 +552,138 @@ static int build_sec_desc(struct cifs_ntsd *pntsd, struct cifs_ntsd *pnntsd,
         return rc;
 }
 
-
-/* Retrieve an ACL from the server */
-static struct cifs_ntsd *get_cifs_acl(u32 *pacllen, struct inode *inode,
-                                       const char *path, const __u16 *pfid)
+static struct cifs_ntsd *get_cifs_acl_by_fid(struct cifs_sb_info *cifs_sb,
+                __u16 fid, u32 *pacllen)
 {
-        struct cifsFileInfo *open_file = NULL;
-        bool unlock_file = false;
-        int xid;
-        int rc = -EIO;
-        __u16 fid;
-        struct super_block *sb;
-        struct cifs_sb_info *cifs_sb;
         struct cifs_ntsd *pntsd = NULL;
+        int xid, rc;
+
+        xid = GetXid();
+        rc = CIFSSMBGetCIFSACL(xid, cifs_sb->tcon, fid, &pntsd, pacllen);
+        FreeXid(xid);
 
-        cFYI(1, ("get mode from ACL for %s", path));
 
-        if (inode == NULL)
-                return NULL;
+        cFYI(1, ("GetCIFSACL rc = %d ACL len %d", rc, *pacllen));
+        return pntsd;
+}
+
+static struct cifs_ntsd *get_cifs_acl_by_path(struct cifs_sb_info *cifs_sb,
+                const char *path, u32 *pacllen)
+{
+        struct cifs_ntsd *pntsd = NULL;
+        int oplock = 0;
+        int xid, rc;
+        __u16 fid;
 
         xid = GetXid();
-        if (pfid == NULL)
-                open_file = find_readable_file(CIFS_I(inode));
-        else
-                fid = *pfid;
 
-        sb = inode->i_sb;
-        if (sb == NULL) {
-                FreeXid(xid);
-                return NULL;
-        }
-        cifs_sb = CIFS_SB(sb);
-
-        if (open_file) {
-                unlock_file = true;
-                fid = open_file->netfid;
-        } else if (pfid == NULL) {
-                int oplock = 0;
-                /* open file */
-                rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN,
-                                READ_CONTROL, 0, &fid, &oplock, NULL,
-                                cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
-                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
-                if (rc != 0) {
-                        cERROR(1, ("Unable to open file to get ACL"));
-                        FreeXid(xid);
-                        return NULL;
-                }
+        rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN, READ_CONTROL, 0,
+                         &fid, &oplock, NULL, cifs_sb->local_nls,
+                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
+        if (rc) {
+                cERROR(1, ("Unable to open file to get ACL"));
+                goto out;
         }
 
         rc = CIFSSMBGetCIFSACL(xid, cifs_sb->tcon, fid, &pntsd, pacllen);
         cFYI(1, ("GetCIFSACL rc = %d ACL len %d", rc, *pacllen));
-        if (unlock_file == true) /* find_readable_file increments ref count */
-                atomic_dec(&open_file->wrtPending);
-        else if (pfid == NULL) /* if opened above we have to close the handle */
-                CIFSSMBClose(xid, cifs_sb->tcon, fid);
-        /* else handle was passed in by caller */
 
+        CIFSSMBClose(xid, cifs_sb->tcon, fid);
+ out:
         FreeXid(xid);
         return pntsd;
 }
 
-/* Set an ACL on the server */
-static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
-                                struct inode *inode, const char *path)
+/* Retrieve an ACL from the server */
+static struct cifs_ntsd *get_cifs_acl(struct cifs_sb_info *cifs_sb,
+                                      struct inode *inode, const char *path,
+                                      u32 *pacllen)
 {
-        struct cifsFileInfo *open_file;
-        bool unlock_file = false;
-        int xid;
-        int rc = -EIO;
-        __u16 fid;
-        struct super_block *sb;
-        struct cifs_sb_info *cifs_sb;
+        struct cifs_ntsd *pntsd = NULL;
+        struct cifsFileInfo *open_file = NULL;
 
-        cFYI(DBG2, ("set ACL for %s from mode 0x%x", path, inode->i_mode));
+        if (inode)
+                open_file = find_readable_file(CIFS_I(inode));
+        if (!open_file)
+                return get_cifs_acl_by_path(cifs_sb, path, pacllen);
 
-        if (!inode)
-                return rc;
+        pntsd = get_cifs_acl_by_fid(cifs_sb, open_file->netfid, pacllen);
+        atomic_dec(&open_file->wrtPending);
+        return pntsd;
+}
 
-        sb = inode->i_sb;
-        if (sb == NULL)
-                return rc;
+static int set_cifs_acl_by_fid(struct cifs_sb_info *cifs_sb, __u16 fid,
+                struct cifs_ntsd *pnntsd, u32 acllen)
+{
+        int xid, rc;
 
-        cifs_sb = CIFS_SB(sb);
         xid = GetXid();
+        rc = CIFSSMBSetCIFSACL(xid, cifs_sb->tcon, fid, pnntsd, acllen);
+        FreeXid(xid);
 
-        open_file = find_readable_file(CIFS_I(inode));
-        if (open_file) {
-                unlock_file = true;
-                fid = open_file->netfid;
-        } else {
-                int oplock = 0;
-                /* open file */
-                rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN,
-                                WRITE_DAC, 0, &fid, &oplock, NULL,
-                                cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
-                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
-                if (rc != 0) {
-                        cERROR(1, ("Unable to open file to set ACL"));
-                        FreeXid(xid);
-                        return rc;
-                }
+        cFYI(DBG2, ("SetCIFSACL rc = %d", rc));
+        return rc;
+}
+
+static int set_cifs_acl_by_path(struct cifs_sb_info *cifs_sb, const char *path,
+                struct cifs_ntsd *pnntsd, u32 acllen)
+{
+        int oplock = 0;
+        int xid, rc;
+        __u16 fid;
+
+        xid = GetXid();
+
+        rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN, WRITE_DAC, 0,
+                         &fid, &oplock, NULL, cifs_sb->local_nls,
+                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
+        if (rc) {
+                cERROR(1, ("Unable to open file to set ACL"));
+                goto out;
         }
 
         rc = CIFSSMBSetCIFSACL(xid, cifs_sb->tcon, fid, pnntsd, acllen);
         cFYI(DBG2, ("SetCIFSACL rc = %d", rc));
-        if (unlock_file)
-                atomic_dec(&open_file->wrtPending);
-        else
-                CIFSSMBClose(xid, cifs_sb->tcon, fid);
 
+        CIFSSMBClose(xid, cifs_sb->tcon, fid);
+ out:
         FreeXid(xid);
+        return rc;
+}
 
+/* Set an ACL on the server */
+static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
+                                struct inode *inode, const char *path)
+{
+        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
+        struct cifsFileInfo *open_file;
+        int rc;
+
+        cFYI(DBG2, ("set ACL for %s from mode 0x%x", path, inode->i_mode));
+
+        open_file = find_readable_file(CIFS_I(inode));
+        if (!open_file)
+                return set_cifs_acl_by_path(cifs_sb, path, pnntsd, acllen);
+
+        rc = set_cifs_acl_by_fid(cifs_sb, open_file->netfid, pnntsd, acllen);
+        atomic_dec(&open_file->wrtPending);
         return rc;
 }
 
 /* Translate the CIFS ACL (simlar to NTFS ACL) for a file into mode bits */
-void acl_to_uid_mode(struct inode *inode, const char *path, const __u16 *pfid)
+void acl_to_uid_mode(struct cifs_sb_info *cifs_sb, struct inode *inode,
+                     const char *path, const __u16 *pfid)
 {
         struct cifs_ntsd *pntsd = NULL;
         u32 acllen = 0;
         int rc = 0;
 
         cFYI(DBG2, ("converting ACL to mode for %s", path));
-        pntsd = get_cifs_acl(&acllen, inode, path, pfid);
+
+        if (pfid)
+                pntsd = get_cifs_acl_by_fid(cifs_sb, *pfid, &acllen);
+        else
+                pntsd = get_cifs_acl(cifs_sb, inode, path, &acllen);
 
         /* if we can retrieve the ACL, now parse Access Control Entries, ACEs */
         if (pntsd)
@@ -698,7 +706,7 @@ int mode_to_acl(struct inode *inode, const char *path, __u64 nmode)
         cFYI(DBG2, ("set ACL from mode for %s", path));
 
         /* Get the security descriptor */
-        pntsd = get_cifs_acl(&secdesclen, inode, path, NULL);
+        pntsd = get_cifs_acl(CIFS_SB(inode->i_sb), inode, path, &secdesclen);
 
         /* Add three ACEs for owner, group, everyone getting rid of
            other ACEs as chmod disables ACEs and set the security descriptor */
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 5e6d35804d73..0a10a59b6392 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -146,7 +146,7 @@ cifs_read_super(struct super_block *sb, void *data,
 #endif
         sb->s_blocksize = CIFS_MAX_MSGSIZE;
         sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
-        inode = cifs_iget(sb, ROOT_I);
+        inode = cifs_root_iget(sb, ROOT_I);
 
         if (IS_ERR(inode)) {
                 rc = PTR_ERR(inode);
diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
index 051b71cfdea9..9570a0e8023f 100644
--- a/fs/cifs/cifsfs.h
+++ b/fs/cifs/cifsfs.h
@@ -36,7 +36,7 @@ extern void cifs_read_inode(struct inode *);
 
 /* Functions related to inodes */
 extern const struct inode_operations cifs_dir_inode_ops;
-extern struct inode *cifs_iget(struct super_block *, unsigned long);
+extern struct inode *cifs_root_iget(struct super_block *, unsigned long);
 extern int cifs_create(struct inode *, struct dentry *, int,
                        struct nameidata *);
 extern struct dentry *cifs_lookup(struct inode *, struct dentry *,
@@ -100,5 +100,5 @@ extern long cifs_ioctl(struct file *filep, unsigned int cmd, unsigned long arg);
 extern const struct export_operations cifs_export_ops;
 #endif /* EXPERIMENTAL */
 
-#define CIFS_VERSION   "1.58"
+#define CIFS_VERSION   "1.59"
 #endif                          /* _CIFSFS_H */
diff --git a/fs/cifs/cifsproto.h b/fs/cifs/cifsproto.h
index fae083930eee..f9452329bcce 100644
--- a/fs/cifs/cifsproto.h
+++ b/fs/cifs/cifsproto.h
@@ -90,10 +90,10 @@ extern struct oplock_q_entry *AllocOplockQEntry(struct inode *, u16,
                                                  struct cifsTconInfo *);
 extern void DeleteOplockQEntry(struct oplock_q_entry *);
 extern void DeleteTconOplockQEntries(struct cifsTconInfo *);
-extern struct timespec cifs_NTtimeToUnix(u64 utc_nanoseconds_since_1601);
+extern struct timespec cifs_NTtimeToUnix(__le64 utc_nanoseconds_since_1601);
 extern u64 cifs_UnixTimeToNT(struct timespec);
-extern __le64 cnvrtDosCifsTm(__u16 date, __u16 time);
-extern struct timespec cnvrtDosUnixTm(__u16 date, __u16 time);
+extern struct timespec cnvrtDosUnixTm(__le16 le_date, __le16 le_time,
+                                      int offset);
 
 extern int cifs_posix_open(char *full_path, struct inode **pinode,
                            struct super_block *sb, int mode, int oflags,
@@ -108,8 +108,8 @@ extern int cifs_get_inode_info(struct inode **pinode,
 extern int cifs_get_inode_info_unix(struct inode **pinode,
                         const unsigned char *search_path,
                         struct super_block *sb, int xid);
-extern void acl_to_uid_mode(struct inode *inode, const char *path,
-                            const __u16 *pfid);
+extern void acl_to_uid_mode(struct cifs_sb_info *cifs_sb, struct inode *inode,
+                            const char *path, const __u16 *pfid);
 extern int mode_to_acl(struct inode *inode, const char *path, __u64);
 
 extern int cifs_mount(struct super_block *, struct cifs_sb_info *, char *,
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index d06260251c30..b84c61d5bca4 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -524,8 +524,8 @@ CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
                         int val, seconds, remain, result;
                         struct timespec ts, utc;
                         utc = CURRENT_TIME;
-                        ts = cnvrtDosUnixTm(le16_to_cpu(rsp->SrvTime.Date),
-                                                le16_to_cpu(rsp->SrvTime.Time));
+                        ts = cnvrtDosUnixTm(rsp->SrvTime.Date,
+                                            rsp->SrvTime.Time, 0);
                         cFYI(1, ("SrvTime %d sec since 1970 (utc: %d) diff: %d",
                                 (int)ts.tv_sec, (int)utc.tv_sec,
                                 (int)(utc.tv_sec - ts.tv_sec)));
@@ -2427,8 +2427,7 @@ querySymLinkRetry:
         params = 2 /* level */  + 4 /* rsrvd */  + name_len /* incl null */ ;
         pSMB->TotalDataCount = 0;
         pSMB->MaxParameterCount = cpu_to_le16(2);
-        /* BB find exact max data count below from sess structure BB */
-        pSMB->MaxDataCount = cpu_to_le16(4000);
+        pSMB->MaxDataCount = cpu_to_le16(CIFSMaxBufSize);
         pSMB->MaxSetupCount = 0;
         pSMB->Reserved = 0;
         pSMB->Flags = 0;
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 4aa81a507b74..97f4311b9a8e 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -35,6 +35,7 @@
 #include <linux/namei.h>
 #include <asm/uaccess.h>
 #include <asm/processor.h>
+#include <linux/inet.h>
 #include <net/ipv6.h>
 #include "cifspdu.h"
 #include "cifsglob.h"
@@ -61,7 +62,6 @@ struct smb_vol {
         char *domainname;
         char *UNC;
         char *UNCip;
-        char *in6_addr;   /* ipv6 address as human readable form of in6_addr */
         char *iocharset;  /* local code page for mapping to and from Unicode */
         char source_rfc1001_name[16]; /* netbios name of client */
         char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
@@ -827,14 +827,16 @@ cifs_parse_mount_options(char *options, const char *devname,
         vol->target_rfc1001_name[0] = 0;
         vol->linux_uid = current_uid();  /* use current_euid() instead? */
         vol->linux_gid = current_gid();
-        vol->dir_mode = S_IRWXUGO;
-        /* 2767 perms indicate mandatory locking support */
-        vol->file_mode = (S_IRWXUGO | S_ISGID) & (~S_IXGRP);
+
+        /* default to only allowing write access to owner of the mount */
+        vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
 
         /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
         vol->rw = true;
         /* default is always to request posix paths. */
         vol->posix_paths = 1;
+        /* default to using server inode numbers where available */
+        vol->server_ino = 1;
 
         if (!options)
                 return 1;
@@ -955,10 +957,12 @@ cifs_parse_mount_options(char *options, const char *devname,
                                 }
                                 strcpy(vol->password, value);
                         }
-                } else if (strnicmp(data, "ip", 2) == 0) {
+                } else if (!strnicmp(data, "ip", 2) ||
+                           !strnicmp(data, "addr", 4)) {
                         if (!value || !*value) {
                                 vol->UNCip = NULL;
-                        } else if (strnlen(value, 35) < 35) {
+                        } else if (strnlen(value, INET6_ADDRSTRLEN) <
+                                                        INET6_ADDRSTRLEN) {
                                 vol->UNCip = value;
                         } else {
                                 printk(KERN_WARNING "CIFS: ip address "
@@ -1092,17 +1096,17 @@ cifs_parse_mount_options(char *options, const char *devname,
                                 return 1;
                         }
                 } else if (strnicmp(data, "uid", 3) == 0) {
-                        if (value && *value) {
+                        if (value && *value)
                                 vol->linux_uid =
                                         simple_strtoul(value, &value, 0);
+                } else if (strnicmp(data, "forceuid", 8) == 0) {
                                 vol->override_uid = 1;
-                        }
                 } else if (strnicmp(data, "gid", 3) == 0) {
-                        if (value && *value) {
+                        if (value && *value)
                                 vol->linux_gid =
                                         simple_strtoul(value, &value, 0);
+                } else if (strnicmp(data, "forcegid", 8) == 0) {
                                 vol->override_gid = 1;
-                        }
                 } else if (strnicmp(data, "file_mode", 4) == 0) {
                         if (value && *value) {
                                 vol->file_mode =
@@ -1315,16 +1319,6 @@ cifs_parse_mount_options(char *options, const char *devname,
                         vol->direct_io = 1;
                 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
                         vol->direct_io = 1;
-                } else if (strnicmp(data, "in6_addr", 8) == 0) {
-                        if (!value || !*value) {
-                                vol->in6_addr = NULL;
-                        } else if (strnlen(value, 49) == 48) {
-                                vol->in6_addr = value;
-                        } else {
-                                printk(KERN_WARNING "CIFS: ip v6 address not "
-                                                    "48 characters long\n");
-                                return 1;
-                        }
                 } else if (strnicmp(data, "noac", 4) == 0) {
                         printk(KERN_WARNING "CIFS: Mount option noac not "
                                 "supported. Instead set "
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 302ea15f02e6..06866841b97f 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -241,7 +241,7 @@ static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
         /* BB need same check in cifs_create too? */
         /* if not oplocked, invalidate inode pages if mtime or file
            size changed */
-        temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
+        temp = cifs_NTtimeToUnix(buf->LastWriteTime);
         if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
                            (file->f_path.dentry->d_inode->i_size ==
                             (loff_t)le64_to_cpu(buf->EndOfFile))) {
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index 9c869a6dcba1..fad882b075ba 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -85,10 +85,10 @@ static void cifs_unix_info_to_inode(struct inode *inode,
         __u64 num_of_bytes = le64_to_cpu(info->NumOfBytes);
         __u64 end_of_file = le64_to_cpu(info->EndOfFile);
 
-        inode->i_atime = cifs_NTtimeToUnix(le64_to_cpu(info->LastAccessTime));
+        inode->i_atime = cifs_NTtimeToUnix(info->LastAccessTime);
         inode->i_mtime =
-                cifs_NTtimeToUnix(le64_to_cpu(info->LastModificationTime));
-        inode->i_ctime = cifs_NTtimeToUnix(le64_to_cpu(info->LastStatusChange));
+                cifs_NTtimeToUnix(info->LastModificationTime);
+        inode->i_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
         inode->i_mode = le64_to_cpu(info->Permissions);
 
         /*
@@ -554,14 +554,11 @@ int cifs_get_inode_info(struct inode **pinode,
 
         /* Linux can not store file creation time so ignore it */
         if (pfindData->LastAccessTime)
-                inode->i_atime = cifs_NTtimeToUnix
-                        (le64_to_cpu(pfindData->LastAccessTime));
+                inode->i_atime = cifs_NTtimeToUnix(pfindData->LastAccessTime);
         else /* do not need to use current_fs_time - time not stored */
                 inode->i_atime = CURRENT_TIME;
-        inode->i_mtime =
-                    cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastWriteTime));
-        inode->i_ctime =
-            cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
+        inode->i_mtime = cifs_NTtimeToUnix(pfindData->LastWriteTime);
+        inode->i_ctime = cifs_NTtimeToUnix(pfindData->ChangeTime);
         cFYI(DBG2, ("Attributes came in as 0x%x", attr));
         if (adjustTZ && (pTcon->ses) && (pTcon->ses->server)) {
                 inode->i_ctime.tv_sec += pTcon->ses->server->timeAdj;
@@ -629,7 +626,7 @@ int cifs_get_inode_info(struct inode **pinode,
         /* fill in 0777 bits from ACL */
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
                 cFYI(1, ("Getting mode bits from ACL"));
-                acl_to_uid_mode(inode, full_path, pfid);
+                acl_to_uid_mode(cifs_sb, inode, full_path, pfid);
         }
 #endif
         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
@@ -699,7 +696,7 @@ char *cifs_build_path_to_root(struct cifs_sb_info *cifs_sb)
 }
 
 /* gets root inode */
-struct inode *cifs_iget(struct super_block *sb, unsigned long ino)
+struct inode *cifs_root_iget(struct super_block *sb, unsigned long ino)
 {
         int xid;
         struct cifs_sb_info *cifs_sb;
diff --git a/fs/cifs/netmisc.c b/fs/cifs/netmisc.c
index e2fe998989a3..32d6baa0a54f 100644
--- a/fs/cifs/netmisc.c
+++ b/fs/cifs/netmisc.c
@@ -853,12 +853,12 @@ smbCalcSize_LE(struct smb_hdr *ptr)
 
 #define NTFS_TIME_OFFSET ((u64)(369*365 + 89) * 24 * 3600 * 10000000)
 
-    /*
-     * Convert the NT UTC (based 1601-01-01, in hundred nanosecond units)
-     * into Unix UTC (based 1970-01-01, in seconds).
-     */
+/*
+ * Convert the NT UTC (based 1601-01-01, in hundred nanosecond units)
+ * into Unix UTC (based 1970-01-01, in seconds).
+ */
 struct timespec
-cifs_NTtimeToUnix(u64 ntutc)
+cifs_NTtimeToUnix(__le64 ntutc)
 {
         struct timespec ts;
         /* BB what about the timezone? BB */
@@ -866,7 +866,7 @@ cifs_NTtimeToUnix(u64 ntutc)
         /* Subtract the NTFS time offset, then convert to 1s intervals. */
         u64 t;
 
-        t = ntutc - NTFS_TIME_OFFSET;
+        t = le64_to_cpu(ntutc) - NTFS_TIME_OFFSET;
         ts.tv_nsec = do_div(t, 10000000) * 100;
         ts.tv_sec = t;
         return ts;
@@ -883,16 +883,12 @@ cifs_UnixTimeToNT(struct timespec t)
 static int total_days_of_prev_months[] =
 {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
 
-
-__le64 cnvrtDosCifsTm(__u16 date, __u16 time)
-{
-        return cpu_to_le64(cifs_UnixTimeToNT(cnvrtDosUnixTm(date, time)));
-}
-
-struct timespec cnvrtDosUnixTm(__u16 date, __u16 time)
+struct timespec cnvrtDosUnixTm(__le16 le_date, __le16 le_time, int offset)
 {
         struct timespec ts;
         int sec, min, days, month, year;
+        u16 date = le16_to_cpu(le_date);
+        u16 time = le16_to_cpu(le_time);
         SMB_TIME *st = (SMB_TIME *)&time;
         SMB_DATE *sd = (SMB_DATE *)&date;
 
@@ -933,7 +929,7 @@ struct timespec cnvrtDosUnixTm(__u16 date, __u16 time)
                 days -= ((year & 0x03) == 0) && (month < 2 ? 1 : 0);
         sec += 24 * 60 * 60 * days;
 
-        ts.tv_sec = sec;
+        ts.tv_sec = sec + offset;
 
         /* cFYI(1,("sec after cnvrt dos to unix time %d",sec)); */
 
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index 964e097c8203..86d0055dc529 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -115,17 +115,6 @@ construct_dentry(struct qstr *qstring, struct file *file,
         return rc;
 }
 
-static void AdjustForTZ(struct cifsTconInfo *tcon, struct inode *inode)
-{
-        if ((tcon) && (tcon->ses) && (tcon->ses->server)) {
-                inode->i_ctime.tv_sec += tcon->ses->server->timeAdj;
-                inode->i_mtime.tv_sec += tcon->ses->server->timeAdj;
-                inode->i_atime.tv_sec += tcon->ses->server->timeAdj;
-        }
-        return;
-}
-
-
 static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
                           char *buf, unsigned int *pobject_type, int isNewInode)
 {
@@ -150,26 +139,25 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
                 allocation_size = le64_to_cpu(pfindData->AllocationSize);
                 end_of_file = le64_to_cpu(pfindData->EndOfFile);
                 tmp_inode->i_atime =
-                      cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastAccessTime));
+                        cifs_NTtimeToUnix(pfindData->LastAccessTime);
                 tmp_inode->i_mtime =
-                      cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastWriteTime));
+                        cifs_NTtimeToUnix(pfindData->LastWriteTime);
                 tmp_inode->i_ctime =
-                      cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
+                        cifs_NTtimeToUnix(pfindData->ChangeTime);
         } else { /* legacy, OS2 and DOS style */
-/*              struct timespec ts;*/
+                int offset = cifs_sb->tcon->ses->server->timeAdj;
                 FIND_FILE_STANDARD_INFO *pfindData =
                         (FIND_FILE_STANDARD_INFO *)buf;
 
-                tmp_inode->i_mtime = cnvrtDosUnixTm(
-                                le16_to_cpu(pfindData->LastWriteDate),
-                                le16_to_cpu(pfindData->LastWriteTime));
-                tmp_inode->i_atime = cnvrtDosUnixTm(
-                                le16_to_cpu(pfindData->LastAccessDate),
-                                le16_to_cpu(pfindData->LastAccessTime));
-                tmp_inode->i_ctime = cnvrtDosUnixTm(
-                                le16_to_cpu(pfindData->LastWriteDate),
-                                le16_to_cpu(pfindData->LastWriteTime));
-                AdjustForTZ(cifs_sb->tcon, tmp_inode);
+                tmp_inode->i_mtime = cnvrtDosUnixTm(pfindData->LastWriteDate,
+                                                    pfindData->LastWriteTime,
+                                                    offset);
+                tmp_inode->i_atime = cnvrtDosUnixTm(pfindData->LastAccessDate,
+                                                    pfindData->LastAccessTime,
+                                                    offset);
+                tmp_inode->i_ctime = cnvrtDosUnixTm(pfindData->LastWriteDate,
+                                                    pfindData->LastWriteTime,
+                                                    offset);
                 attr = le16_to_cpu(pfindData->Attributes);
                 allocation_size = le32_to_cpu(pfindData->AllocationSize);
                 end_of_file = le32_to_cpu(pfindData->DataSize);
@@ -331,11 +319,11 @@ static void unix_fill_in_inode(struct inode *tmp_inode,
         local_size  = tmp_inode->i_size;
 
         tmp_inode->i_atime =
-            cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastAccessTime));
+            cifs_NTtimeToUnix(pfindData->LastAccessTime);
         tmp_inode->i_mtime =
-            cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastModificationTime));
+            cifs_NTtimeToUnix(pfindData->LastModificationTime);
         tmp_inode->i_ctime =
-            cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastStatusChange));
+            cifs_NTtimeToUnix(pfindData->LastStatusChange);
 
         tmp_inode->i_mode = le64_to_cpu(pfindData->Permissions);
         /* since we set the inode type below we need to mask off type
diff --git a/fs/coda/file.c b/fs/coda/file.c
index 6a347fbc998a..ffd42815fda1 100644
--- a/fs/coda/file.c
+++ b/fs/coda/file.c
@@ -47,6 +47,8 @@ coda_file_splice_read(struct file *coda_file, loff_t *ppos,
                       struct pipe_inode_info *pipe, size_t count,
                       unsigned int flags)
 {
+        ssize_t (*splice_read)(struct file *, loff_t *,
+                               struct pipe_inode_info *, size_t, unsigned int);
         struct coda_file_info *cfi;
         struct file *host_file;
 
@@ -54,10 +56,11 @@ coda_file_splice_read(struct file *coda_file, loff_t *ppos,
         BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
         host_file = cfi->cfi_container;
 
-        if (!host_file->f_op || !host_file->f_op->splice_read)
-                return -EINVAL;
+        splice_read = host_file->f_op->splice_read;
+        if (!splice_read)
+                splice_read = default_file_splice_read;
 
-        return host_file->f_op->splice_read(host_file, ppos, pipe, count,flags);
+        return splice_read(host_file, ppos, pipe, count, flags);
 }
 
 static ssize_t
diff --git a/fs/compat.c b/fs/compat.c
index 681ed81e6be0..bb2a9b2e8173 100644
--- a/fs/compat.c
+++ b/fs/compat.c
@@ -1488,7 +1488,7 @@ int compat_do_execve(char * filename,
         if (!bprm)
                 goto out_files;
 
-        retval = mutex_lock_interruptible(&current->cred_exec_mutex);
+        retval = mutex_lock_interruptible(&current->cred_guard_mutex);
         if (retval < 0)
                 goto out_free;
         current->in_execve = 1;
@@ -1550,7 +1550,7 @@ int compat_do_execve(char * filename,
         /* execve succeeded */
         current->fs->in_exec = 0;
         current->in_execve = 0;
-        mutex_unlock(&current->cred_exec_mutex);
+        mutex_unlock(&current->cred_guard_mutex);
         acct_update_integrals(current);
         free_bprm(bprm);
         if (displaced)
@@ -1573,7 +1573,7 @@ out_unmark:
 
 out_unlock:
         current->in_execve = 0;
-        mutex_unlock(&current->cred_exec_mutex);
+        mutex_unlock(&current->cred_guard_mutex);
 
 out_free:
         free_bprm(bprm);
diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c
index c68edb969441..9b1d285f9fe6 100644
--- a/fs/devpts/inode.c
+++ b/fs/devpts/inode.c
@@ -557,8 +557,10 @@ static int __init init_devpts_fs(void)
         int err = register_filesystem(&devpts_fs_type);
         if (!err) {
                 devpts_mnt = kern_mount(&devpts_fs_type);
-                if (IS_ERR(devpts_mnt))
+                if (IS_ERR(devpts_mnt)) {
                         err = PTR_ERR(devpts_mnt);
+                        unregister_filesystem(&devpts_fs_type);
+                }
         }
         return err;
 }
diff --git a/fs/direct-io.c b/fs/direct-io.c
index 05763bbc2050..8b10b87dc01a 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -1127,7 +1127,7 @@ __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
                 rw = WRITE_ODIRECT;
 
         if (bdev)
-                bdev_blkbits = blksize_bits(bdev_hardsect_size(bdev));
+                bdev_blkbits = blksize_bits(bdev_logical_block_size(bdev));
 
         if (offset & blocksize_mask) {
                 if (bdev)
diff --git a/fs/exec.c b/fs/exec.c
index 895823d0149d..a7fcd975c6b2 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -1016,7 +1016,7 @@ void install_exec_creds(struct linux_binprm *bprm)
         commit_creds(bprm->cred);
         bprm->cred = NULL;
 
-        /* cred_exec_mutex must be held at least to this point to prevent
+        /* cred_guard_mutex must be held at least to this point to prevent
          * ptrace_attach() from altering our determination of the task's
          * credentials; any time after this it may be unlocked */
 
@@ -1026,7 +1026,7 @@ EXPORT_SYMBOL(install_exec_creds);
 
 /*
  * determine how safe it is to execute the proposed program
- * - the caller must hold current->cred_exec_mutex to protect against
+ * - the caller must hold current->cred_guard_mutex to protect against
  *   PTRACE_ATTACH
  */
 int check_unsafe_exec(struct linux_binprm *bprm)
@@ -1268,7 +1268,7 @@ int do_execve(char * filename,
         if (!bprm)
                 goto out_files;
 
-        retval = mutex_lock_interruptible(&current->cred_exec_mutex);
+        retval = mutex_lock_interruptible(&current->cred_guard_mutex);
         if (retval < 0)
                 goto out_free;
         current->in_execve = 1;
@@ -1331,7 +1331,7 @@ int do_execve(char * filename,
         /* execve succeeded */
         current->fs->in_exec = 0;
         current->in_execve = 0;
-        mutex_unlock(&current->cred_exec_mutex);
+        mutex_unlock(&current->cred_guard_mutex);
         acct_update_integrals(current);
         free_bprm(bprm);
         if (displaced)
@@ -1354,7 +1354,7 @@ out_unmark:
 
 out_unlock:
         current->in_execve = 0;
-        mutex_unlock(&current->cred_exec_mutex);
+        mutex_unlock(&current->cred_guard_mutex);
 
 out_free:
         free_bprm(bprm);
diff --git a/fs/exofs/osd.c b/fs/exofs/osd.c
index b249ae97fb15..06ca92672eb5 100644
--- a/fs/exofs/osd.c
+++ b/fs/exofs/osd.c
@@ -50,10 +50,10 @@ int exofs_check_ok_resid(struct osd_request *or, u64 *in_resid, u64 *out_resid)
 
         /* FIXME: should be include in osd_sense_info */
         if (in_resid)
-                *in_resid = or->in.req ? or->in.req->data_len : 0;
+                *in_resid = or->in.req ? or->in.req->resid_len : 0;
 
         if (out_resid)
-                *out_resid = or->out.req ? or->out.req->data_len : 0;
+                *out_resid = or->out.req ? or->out.req->resid_len : 0;
 
         return ret;
 }
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 5c4afe652245..e3c748faf2db 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -1093,6 +1093,7 @@ failed_mount:
         brelse(bh);
 failed_sbi:
         sb->s_fs_info = NULL;
+        kfree(sbi->s_blockgroup_lock);
         kfree(sbi);
         return ret;
 }
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 599dbfe504c3..3c70d52afb10 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -1696,7 +1696,7 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
                 goto failed_mount;
         }
 
-        hblock = bdev_hardsect_size(sb->s_bdev);
+        hblock = bdev_logical_block_size(sb->s_bdev);
         if (sb->s_blocksize != blocksize) {
                 /*
                  * Make sure the blocksize for the filesystem is larger
@@ -2021,6 +2021,7 @@ failed_mount:
         brelse(bh);
 out_fail:
         sb->s_fs_info = NULL;
+        kfree(sbi->s_blockgroup_lock);
         kfree(sbi);
         lock_kernel();
         return ret;
@@ -2119,7 +2120,7 @@ static journal_t *ext3_get_dev_journal(struct super_block *sb,
         }
 
         blocksize = sb->s_blocksize;
-        hblock = bdev_hardsect_size(bdev);
+        hblock = bdev_logical_block_size(bdev);
         if (blocksize < hblock) {
                 printk(KERN_ERR
                         "EXT3-fs: blocksize too small for journal device.\n");
diff --git a/fs/ext4/Makefile b/fs/ext4/Makefile
index a8ff003a00f7..8a34710ecf40 100644
--- a/fs/ext4/Makefile
+++ b/fs/ext4/Makefile
@@ -5,8 +5,8 @@
 obj-$(CONFIG_EXT4_FS) += ext4.o
 
 ext4-y  := balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o \
-                   ioctl.o namei.o super.o symlink.o hash.o resize.o extents.o \
-                   ext4_jbd2.o migrate.o mballoc.o
+                ioctl.o namei.o super.o symlink.o hash.o resize.o extents.o \
+                ext4_jbd2.o migrate.o mballoc.o block_validity.o
 
 ext4-$(CONFIG_EXT4_FS_XATTR)            += xattr.o xattr_user.o xattr_trusted.o
 ext4-$(CONFIG_EXT4_FS_POSIX_ACL)        += acl.o
diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
index 53c72ad85877..e2126d70dff5 100644
--- a/fs/ext4/balloc.c
+++ b/fs/ext4/balloc.c
@@ -19,7 +19,6 @@
 #include <linux/buffer_head.h>
 #include "ext4.h"
 #include "ext4_jbd2.h"
-#include "group.h"
 #include "mballoc.h"
 
 /*
@@ -88,6 +87,7 @@ unsigned ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,
                  ext4_group_t block_group, struct ext4_group_desc *gdp)
 {
         int bit, bit_max;
+        ext4_group_t ngroups = ext4_get_groups_count(sb);
         unsigned free_blocks, group_blocks;
         struct ext4_sb_info *sbi = EXT4_SB(sb);
 
@@ -123,7 +123,7 @@ unsigned ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,
                 bit_max += ext4_bg_num_gdb(sb, block_group);
         }
 
-        if (block_group == sbi->s_groups_count - 1) {
+        if (block_group == ngroups - 1) {
                 /*
                  * Even though mke2fs always initialize first and last group
                  * if some other tool enabled the EXT4_BG_BLOCK_UNINIT we need
@@ -131,7 +131,7 @@ unsigned ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,
                  */
                 group_blocks = ext4_blocks_count(sbi->s_es) -
                         le32_to_cpu(sbi->s_es->s_first_data_block) -
-                        (EXT4_BLOCKS_PER_GROUP(sb) * (sbi->s_groups_count - 1));
+                        (EXT4_BLOCKS_PER_GROUP(sb) * (ngroups - 1));
         } else {
                 group_blocks = EXT4_BLOCKS_PER_GROUP(sb);
         }
@@ -205,18 +205,18 @@ struct ext4_group_desc * ext4_get_group_desc(struct super_block *sb,
 {
         unsigned int group_desc;
         unsigned int offset;
+        ext4_group_t ngroups = ext4_get_groups_count(sb);
         struct ext4_group_desc *desc;
         struct ext4_sb_info *sbi = EXT4_SB(sb);
 
-        if (block_group >= sbi->s_groups_count) {
+        if (block_group >= ngroups) {
                 ext4_error(sb, "ext4_get_group_desc",
                            "block_group >= groups_count - "
                            "block_group = %u, groups_count = %u",
-                           block_group, sbi->s_groups_count);
+                           block_group, ngroups);
 
                 return NULL;
         }
-        smp_rmb();
 
         group_desc = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb);
         offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1);
@@ -326,16 +326,16 @@ ext4_read_block_bitmap(struct super_block *sb, ext4_group_t block_group)
                 unlock_buffer(bh);
                 return bh;
         }
-        spin_lock(sb_bgl_lock(EXT4_SB(sb), block_group));
+        ext4_lock_group(sb, block_group);
         if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
                 ext4_init_block_bitmap(sb, bh, block_group, desc);
                 set_bitmap_uptodate(bh);
                 set_buffer_uptodate(bh);
-                spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group));
+                ext4_unlock_group(sb, block_group);
                 unlock_buffer(bh);
                 return bh;
         }
-        spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group));
+        ext4_unlock_group(sb, block_group);
         if (buffer_uptodate(bh)) {
                 /*
                  * if not uninit if bh is uptodate,
@@ -451,7 +451,7 @@ void ext4_add_groupblocks(handle_t *handle, struct super_block *sb,
         down_write(&grp->alloc_sem);
         for (i = 0, blocks_freed = 0; i < count; i++) {
                 BUFFER_TRACE(bitmap_bh, "clear bit");
-                if (!ext4_clear_bit_atomic(sb_bgl_lock(sbi, block_group),
+                if (!ext4_clear_bit_atomic(ext4_group_lock_ptr(sb, block_group),
                                                 bit + i, bitmap_bh->b_data)) {
                         ext4_error(sb, __func__,
                                    "bit already cleared for block %llu",
@@ -461,11 +461,11 @@ void ext4_add_groupblocks(handle_t *handle, struct super_block *sb,
                         blocks_freed++;
                 }
         }
-        spin_lock(sb_bgl_lock(sbi, block_group));
+        ext4_lock_group(sb, block_group);
         blk_free_count = blocks_freed + ext4_free_blks_count(sb, desc);
         ext4_free_blks_set(sb, desc, blk_free_count);
         desc->bg_checksum = ext4_group_desc_csum(sbi, block_group, desc);
-        spin_unlock(sb_bgl_lock(sbi, block_group));
+        ext4_unlock_group(sb, block_group);
         percpu_counter_add(&sbi->s_freeblocks_counter, blocks_freed);
 
         if (sbi->s_log_groups_per_flex) {
@@ -665,7 +665,7 @@ ext4_fsblk_t ext4_count_free_blocks(struct super_block *sb)
         ext4_fsblk_t desc_count;
         struct ext4_group_desc *gdp;
         ext4_group_t i;
-        ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count;
+        ext4_group_t ngroups = ext4_get_groups_count(sb);
 #ifdef EXT4FS_DEBUG
         struct ext4_super_block *es;
         ext4_fsblk_t bitmap_count;
@@ -677,7 +677,6 @@ ext4_fsblk_t ext4_count_free_blocks(struct super_block *sb)
         bitmap_count = 0;
         gdp = NULL;
 
-        smp_rmb();
         for (i = 0; i < ngroups; i++) {
                 gdp = ext4_get_group_desc(sb, i, NULL);
                 if (!gdp)
@@ -700,7 +699,6 @@ ext4_fsblk_t ext4_count_free_blocks(struct super_block *sb)
         return bitmap_count;
 #else
         desc_count = 0;
-        smp_rmb();
         for (i = 0; i < ngroups; i++) {
                 gdp = ext4_get_group_desc(sb, i, NULL);
                 if (!gdp)
diff --git a/fs/ext4/block_validity.c b/fs/ext4/block_validity.c
new file mode 100644
index 000000000000..50784ef07563
--- /dev/null
+++ b/fs/ext4/block_validity.c
@@ -0,0 +1,244 @@
+/*
+ *  linux/fs/ext4/block_validity.c
+ *
+ * Copyright (C) 2009
+ * Theodore Ts'o (tytso@mit.edu)
+ *
+ * Track which blocks in the filesystem are metadata blocks that
+ * should never be used as data blocks by files or directories.
+ */
+
+#include <linux/time.h>
+#include <linux/fs.h>
+#include <linux/namei.h>
+#include <linux/quotaops.h>
+#include <linux/buffer_head.h>
+#include <linux/module.h>
+#include <linux/swap.h>
+#include <linux/pagemap.h>
+#include <linux/version.h>
+#include <linux/blkdev.h>
+#include <linux/mutex.h>
+#include "ext4.h"
+
+struct ext4_system_zone {
+        struct rb_node  node;
+        ext4_fsblk_t    start_blk;
+        unsigned int    count;
+};
+
+static struct kmem_cache *ext4_system_zone_cachep;
+
+int __init init_ext4_system_zone(void)
+{
+        ext4_system_zone_cachep = KMEM_CACHE(ext4_system_zone,
+                                             SLAB_RECLAIM_ACCOUNT);
+        if (ext4_system_zone_cachep == NULL)
+                return -ENOMEM;
+        return 0;
+}
+
+void exit_ext4_system_zone(void)
+{
+        kmem_cache_destroy(ext4_system_zone_cachep);
+}
+
+static inline int can_merge(struct ext4_system_zone *entry1,
+                     struct ext4_system_zone *entry2)
+{
+        if ((entry1->start_blk + entry1->count) == entry2->start_blk)
+                return 1;
+        return 0;
+}
+
+/*
+ * Mark a range of blocks as belonging to the "system zone" --- that
+ * is, filesystem metadata blocks which should never be used by
+ * inodes.
+ */
+static int add_system_zone(struct ext4_sb_info *sbi,
+                           ext4_fsblk_t start_blk,
+                           unsigned int count)
+{
+        struct ext4_system_zone *new_entry = NULL, *entry;
+        struct rb_node **n = &sbi->system_blks.rb_node, *node;
+        struct rb_node *parent = NULL, *new_node = NULL;
+
+        while (*n) {
+                parent = *n;
+                entry = rb_entry(parent, struct ext4_system_zone, node);
+                if (start_blk < entry->start_blk)
+                        n = &(*n)->rb_left;
+                else if (start_blk >= (entry->start_blk + entry->count))
+                        n = &(*n)->rb_right;
+                else {
+                        if (start_blk + count > (entry->start_blk + 
+                                                 entry->count))
+                                entry->count = (start_blk + count - 
+                                                entry->start_blk);
+                        new_node = *n;
+                        new_entry = rb_entry(new_node, struct ext4_system_zone,
+                                             node);
+                        break;
+                }
+        }
+
+        if (!new_entry) {
+                new_entry = kmem_cache_alloc(ext4_system_zone_cachep,
+                                             GFP_KERNEL);
+                if (!new_entry)
+                        return -ENOMEM;
+                new_entry->start_blk = start_blk;
+                new_entry->count = count;
+                new_node = &new_entry->node;
+
+                rb_link_node(new_node, parent, n);
+                rb_insert_color(new_node, &sbi->system_blks);
+        }
+
+        /* Can we merge to the left? */
+        node = rb_prev(new_node);
+        if (node) {
+                entry = rb_entry(node, struct ext4_system_zone, node);
+                if (can_merge(entry, new_entry)) {
+                        new_entry->start_blk = entry->start_blk;
+                        new_entry->count += entry->count;
+                        rb_erase(node, &sbi->system_blks);
+                        kmem_cache_free(ext4_system_zone_cachep, entry);
+                }
+        }
+
+        /* Can we merge to the right? */
+        node = rb_next(new_node);
+        if (node) {
+                entry = rb_entry(node, struct ext4_system_zone, node);
+                if (can_merge(new_entry, entry)) {
+                        new_entry->count += entry->count;
+                        rb_erase(node, &sbi->system_blks);
+                        kmem_cache_free(ext4_system_zone_cachep, entry);
+                }
+        }
+        return 0;
+}
+
+static void debug_print_tree(struct ext4_sb_info *sbi)
+{
+        struct rb_node *node;
+        struct ext4_system_zone *entry;
+        int first = 1;
+
+        printk(KERN_INFO "System zones: ");
+        node = rb_first(&sbi->system_blks);
+        while (node) {
+                entry = rb_entry(node, struct ext4_system_zone, node);
+                printk("%s%llu-%llu", first ? "" : ", ",
+                       entry->start_blk, entry->start_blk + entry->count - 1);
+                first = 0;
+                node = rb_next(node);
+        }
+        printk("\n");
+}
+
+int ext4_setup_system_zone(struct super_block *sb)
+{
+        ext4_group_t ngroups = ext4_get_groups_count(sb);
+        struct ext4_sb_info *sbi = EXT4_SB(sb);
+        struct ext4_group_desc *gdp;
+        ext4_group_t i;
+        int flex_size = ext4_flex_bg_size(sbi);
+        int ret;
+
+        if (!test_opt(sb, BLOCK_VALIDITY)) {
+                if (EXT4_SB(sb)->system_blks.rb_node)
+                        ext4_release_system_zone(sb);
+                return 0;
+        }
+        if (EXT4_SB(sb)->system_blks.rb_node)
+                return 0;
+
+        for (i=0; i < ngroups; i++) {
+                if (ext4_bg_has_super(sb, i) &&
+                    ((i < 5) || ((i % flex_size) == 0)))
+                        add_system_zone(sbi, ext4_group_first_block_no(sb, i),
+                                        sbi->s_gdb_count + 1);
+                gdp = ext4_get_group_desc(sb, i, NULL);
+                ret = add_system_zone(sbi, ext4_block_bitmap(sb, gdp), 1);
+                if (ret)
+                        return ret;
+                ret = add_system_zone(sbi, ext4_inode_bitmap(sb, gdp), 1);
+                if (ret)
+                        return ret;
+                ret = add_system_zone(sbi, ext4_inode_table(sb, gdp),
+                                sbi->s_itb_per_group);
+                if (ret)
+                        return ret;
+        }
+
+        if (test_opt(sb, DEBUG))
+                debug_print_tree(EXT4_SB(sb));
+        return 0;
+}
+
+/* Called when the filesystem is unmounted */
+void ext4_release_system_zone(struct super_block *sb)
+{
+        struct rb_node  *n = EXT4_SB(sb)->system_blks.rb_node;
+        struct rb_node  *parent;
+        struct ext4_system_zone *entry;
+
+        while (n) {
+                /* Do the node's children first */
+                if (n->rb_left) {
+                        n = n->rb_left;
+                        continue;
+                }
+                if (n->rb_right) {
+                        n = n->rb_right;
+                        continue;
+                }
+                /*
+                 * The node has no children; free it, and then zero
+                 * out parent's link to it.  Finally go to the
+                 * beginning of the loop and try to free the parent
+                 * node.
+                 */
+                parent = rb_parent(n);
+                entry = rb_entry(n, struct ext4_system_zone, node);
+                kmem_cache_free(ext4_system_zone_cachep, entry);
+                if (!parent)
+                        EXT4_SB(sb)->system_blks.rb_node = NULL;
+                else if (parent->rb_left == n)
+                        parent->rb_left = NULL;
+                else if (parent->rb_right == n)
+                        parent->rb_right = NULL;
+                n = parent;
+        }
+        EXT4_SB(sb)->system_blks.rb_node = NULL;
+}
+
+/*
+ * Returns 1 if the passed-in block region (start_blk,
+ * start_blk+count) is valid; 0 if some part of the block region
+ * overlaps with filesystem metadata blocks.
+ */
+int ext4_data_block_valid(struct ext4_sb_info *sbi, ext4_fsblk_t start_blk,
+                          unsigned int count)
+{
+        struct ext4_system_zone *entry;
+        struct rb_node *n = sbi->system_blks.rb_node;
+
+        if ((start_blk <= le32_to_cpu(sbi->s_es->s_first_data_block)) ||
+            (start_blk + count > ext4_blocks_count(sbi->s_es)))
+                return 0;
+        while (n) {
+                entry = rb_entry(n, struct ext4_system_zone, node);
+                if (start_blk + count - 1 < entry->start_blk)
+                        n = n->rb_left;
+                else if (start_blk >= (entry->start_blk + entry->count))
+                        n = n->rb_right;
+                else
+                        return 0;
+        }
+        return 1;
+}
+
diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c
index b64789929a65..9dc93168e262 100644
--- a/fs/ext4/dir.c
+++ b/fs/ext4/dir.c
@@ -131,8 +131,7 @@ static int ext4_readdir(struct file *filp,
                 struct buffer_head *bh = NULL;
 
                 map_bh.b_state = 0;
-                err = ext4_get_blocks_wrap(NULL, inode, blk, 1, &map_bh,
-                                                0, 0, 0);
+                err = ext4_get_blocks(NULL, inode, blk, 1, &map_bh, 0);
                 if (err > 0) {
                         pgoff_t index = map_bh.b_blocknr >>
                                         (PAGE_CACHE_SHIFT - inode->i_blkbits);
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index d0f15ef56de1..cc7d5edc38c9 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -21,7 +21,14 @@
 #include <linux/magic.h>
 #include <linux/jbd2.h>
 #include <linux/quota.h>
-#include "ext4_i.h"
+#include <linux/rwsem.h>
+#include <linux/rbtree.h>
+#include <linux/seqlock.h>
+#include <linux/mutex.h>
+#include <linux/timer.h>
+#include <linux/wait.h>
+#include <linux/blockgroup_lock.h>
+#include <linux/percpu_counter.h>
 
 /*
  * The fourth extended filesystem constants/structures
@@ -46,6 +53,19 @@
 #define ext4_debug(f, a...)     do {} while (0)
 #endif
 
+/* data type for block offset of block group */
+typedef int ext4_grpblk_t;
+
+/* data type for filesystem-wide blocks number */
+typedef unsigned long long ext4_fsblk_t;
+
+/* data type for file logical block number */
+typedef __u32 ext4_lblk_t;
+
+/* data type for block group number */
+typedef unsigned int ext4_group_t;
+
+
 /* prefer goal again. length */
 #define EXT4_MB_HINT_MERGE              1
 /* blocks already reserved */
@@ -179,9 +199,6 @@ struct flex_groups {
 #define EXT4_BG_BLOCK_UNINIT    0x0002 /* Block bitmap not in use */
 #define EXT4_BG_INODE_ZEROED    0x0004 /* On-disk itable initialized to zero */
 
-#ifdef __KERNEL__
-#include "ext4_sb.h"
-#endif
 /*
  * Macro-instructions used to manage group descriptors
  */
@@ -297,10 +314,23 @@ struct ext4_new_group_data {
 };
 
 /*
- * Following is used by preallocation code to tell get_blocks() that we
- * want uninitialzed extents.
+ * Flags used by ext4_get_blocks()
  */
-#define EXT4_CREATE_UNINITIALIZED_EXT           2
+        /* Allocate any needed blocks and/or convert an unitialized
+           extent to be an initialized ext4 */
+#define EXT4_GET_BLOCKS_CREATE                  0x0001
+        /* Request the creation of an unitialized extent */
+#define EXT4_GET_BLOCKS_UNINIT_EXT              0x0002
+#define EXT4_GET_BLOCKS_CREATE_UNINIT_EXT       (EXT4_GET_BLOCKS_UNINIT_EXT|\
+                                                 EXT4_GET_BLOCKS_CREATE)
+        /* Caller is from the delayed allocation writeout path,
+           so set the magic i_delalloc_reserve_flag after taking the 
+           inode allocation semaphore for */
+#define EXT4_GET_BLOCKS_DELALLOC_RESERVE        0x0004
+        /* Call ext4_da_update_reserve_space() after successfully 
+           allocating the blocks */
+#define EXT4_GET_BLOCKS_UPDATE_RESERVE_SPACE    0x0008
+
 
 /*
  * ioctl commands
@@ -516,6 +546,110 @@ do {									       \
 #endif /* defined(__KERNEL__) || defined(__linux__) */
 
 /*
+ * storage for cached extent
+ */
+struct ext4_ext_cache {
+        ext4_fsblk_t    ec_start;
+        ext4_lblk_t     ec_block;
+        __u32           ec_len; /* must be 32bit to return holes */
+        __u32           ec_type;
+};
+
+/*
+ * fourth extended file system inode data in memory
+ */
+struct ext4_inode_info {
+        __le32  i_data[15];     /* unconverted */
+        __u32   i_flags;
+        ext4_fsblk_t    i_file_acl;
+        __u32   i_dtime;
+
+        /*
+         * i_block_group is the number of the block group which contains
+         * this file's inode.  Constant across the lifetime of the inode,
+         * it is ued for making block allocation decisions - we try to
+         * place a file's data blocks near its inode block, and new inodes
+         * near to their parent directory's inode.
+         */
+        ext4_group_t    i_block_group;
+        __u32   i_state;                /* Dynamic state flags for ext4 */
+
+        ext4_lblk_t             i_dir_start_lookup;
+#ifdef CONFIG_EXT4_FS_XATTR
+        /*
+         * Extended attributes can be read independently of the main file
+         * data. Taking i_mutex even when reading would cause contention
+         * between readers of EAs and writers of regular file data, so
+         * instead we synchronize on xattr_sem when reading or changing
+         * EAs.
+         */
+        struct rw_semaphore xattr_sem;
+#endif
+#ifdef CONFIG_EXT4_FS_POSIX_ACL
+        struct posix_acl        *i_acl;
+        struct posix_acl        *i_default_acl;
+#endif
+
+        struct list_head i_orphan;      /* unlinked but open inodes */
+
+        /*
+         * i_disksize keeps track of what the inode size is ON DISK, not
+         * in memory.  During truncate, i_size is set to the new size by
+         * the VFS prior to calling ext4_truncate(), but the filesystem won't
+         * set i_disksize to 0 until the truncate is actually under way.
+         *
+         * The intent is that i_disksize always represents the blocks which
+         * are used by this file.  This allows recovery to restart truncate
+         * on orphans if we crash during truncate.  We actually write i_disksize
+         * into the on-disk inode when writing inodes out, instead of i_size.
+         *
+         * The only time when i_disksize and i_size may be different is when
+         * a truncate is in progress.  The only things which change i_disksize
+         * are ext4_get_block (growth) and ext4_truncate (shrinkth).
+         */
+        loff_t  i_disksize;
+
+        /*
+         * i_data_sem is for serialising ext4_truncate() against
+         * ext4_getblock().  In the 2.4 ext2 design, great chunks of inode's
+         * data tree are chopped off during truncate. We can't do that in
+         * ext4 because whenever we perform intermediate commits during
+         * truncate, the inode and all the metadata blocks *must* be in a
+         * consistent state which allows truncation of the orphans to restart
+         * during recovery.  Hence we must fix the get_block-vs-truncate race
+         * by other means, so we have i_data_sem.
+         */
+        struct rw_semaphore i_data_sem;
+        struct inode vfs_inode;
+        struct jbd2_inode jinode;
+
+        struct ext4_ext_cache i_cached_extent;
+        /*
+         * File creation time. Its function is same as that of
+         * struct timespec i_{a,c,m}time in the generic inode.
+         */
+        struct timespec i_crtime;
+
+        /* mballoc */
+        struct list_head i_prealloc_list;
+        spinlock_t i_prealloc_lock;
+
+        /* ialloc */
+        ext4_group_t    i_last_alloc_group;
+
+        /* allocation reservation info for delalloc */
+        unsigned int i_reserved_data_blocks;
+        unsigned int i_reserved_meta_blocks;
+        unsigned int i_allocated_meta_blocks;
+        unsigned short i_delalloc_reserved_flag;
+
+        /* on-disk additional length */
+        __u16 i_extra_isize;
+
+        spinlock_t i_block_reservation_lock;
+};
+
+/*
  * File system states
  */
 #define EXT4_VALID_FS                   0x0001  /* Unmounted cleanly */
@@ -560,6 +694,7 @@ do {									       \
 #define EXT4_MOUNT_I_VERSION            0x2000000 /* i_version support */
 #define EXT4_MOUNT_DELALLOC             0x8000000 /* Delalloc support */
 #define EXT4_MOUNT_DATA_ERR_ABORT       0x10000000 /* Abort on file data write */
+#define EXT4_MOUNT_BLOCK_VALIDITY       0x20000000 /* Block validity checking */
 
 /* Compatibility, for having both ext2_fs.h and ext4_fs.h included at once */
 #ifndef _LINUX_EXT2_FS_H
@@ -689,6 +824,137 @@ struct ext4_super_block {
 };
 
 #ifdef __KERNEL__
+/*
+ * fourth extended-fs super-block data in memory
+ */
+struct ext4_sb_info {
+        unsigned long s_desc_size;      /* Size of a group descriptor in bytes */
+        unsigned long s_inodes_per_block;/* Number of inodes per block */
+        unsigned long s_blocks_per_group;/* Number of blocks in a group */
+        unsigned long s_inodes_per_group;/* Number of inodes in a group */
+        unsigned long s_itb_per_group;  /* Number of inode table blocks per group */
+        unsigned long s_gdb_count;      /* Number of group descriptor blocks */
+        unsigned long s_desc_per_block; /* Number of group descriptors per block */
+        ext4_group_t s_groups_count;    /* Number of groups in the fs */
+        unsigned long s_overhead_last;  /* Last calculated overhead */
+        unsigned long s_blocks_last;    /* Last seen block count */
+        loff_t s_bitmap_maxbytes;       /* max bytes for bitmap files */
+        struct buffer_head * s_sbh;     /* Buffer containing the super block */
+        struct ext4_super_block *s_es;  /* Pointer to the super block in the buffer */
+        struct buffer_head **s_group_desc;
+        unsigned long  s_mount_opt;
+        ext4_fsblk_t s_sb_block;
+        uid_t s_resuid;
+        gid_t s_resgid;
+        unsigned short s_mount_state;
+        unsigned short s_pad;
+        int s_addr_per_block_bits;
+        int s_desc_per_block_bits;
+        int s_inode_size;
+        int s_first_ino;
+        unsigned int s_inode_readahead_blks;
+        spinlock_t s_next_gen_lock;
+        u32 s_next_generation;
+        u32 s_hash_seed[4];
+        int s_def_hash_version;
+        int s_hash_unsigned;    /* 3 if hash should be signed, 0 if not */
+        struct percpu_counter s_freeblocks_counter;
+        struct percpu_counter s_freeinodes_counter;
+        struct percpu_counter s_dirs_counter;
+        struct percpu_counter s_dirtyblocks_counter;
+        struct blockgroup_lock *s_blockgroup_lock;
+        struct proc_dir_entry *s_proc;
+        struct kobject s_kobj;
+        struct completion s_kobj_unregister;
+
+        /* Journaling */
+        struct inode *s_journal_inode;
+        struct journal_s *s_journal;
+        struct list_head s_orphan;
+        struct mutex s_orphan_lock;
+        struct mutex s_resize_lock;
+        unsigned long s_commit_interval;
+        u32 s_max_batch_time;
+        u32 s_min_batch_time;
+        struct block_device *journal_bdev;
+#ifdef CONFIG_JBD2_DEBUG
+        struct timer_list turn_ro_timer;        /* For turning read-only (crash simulation) */
+        wait_queue_head_t ro_wait_queue;        /* For people waiting for the fs to go read-only */
+#endif
+#ifdef CONFIG_QUOTA
+        char *s_qf_names[MAXQUOTAS];            /* Names of quota files with journalled quota */
+        int s_jquota_fmt;                       /* Format of quota to use */
+#endif
+        unsigned int s_want_extra_isize; /* New inodes should reserve # bytes */
+        struct rb_root system_blks;
+
+#ifdef EXTENTS_STATS
+        /* ext4 extents stats */
+        unsigned long s_ext_min;
+        unsigned long s_ext_max;
+        unsigned long s_depth_max;
+        spinlock_t s_ext_stats_lock;
+        unsigned long s_ext_blocks;
+        unsigned long s_ext_extents;
+#endif
+
+        /* for buddy allocator */
+        struct ext4_group_info ***s_group_info;
+        struct inode *s_buddy_cache;
+        long s_blocks_reserved;
+        spinlock_t s_reserve_lock;
+        spinlock_t s_md_lock;
+        tid_t s_last_transaction;
+        unsigned short *s_mb_offsets;
+        unsigned int *s_mb_maxs;
+
+        /* tunables */
+        unsigned long s_stripe;
+        unsigned int s_mb_stream_request;
+        unsigned int s_mb_max_to_scan;
+        unsigned int s_mb_min_to_scan;
+        unsigned int s_mb_stats;
+        unsigned int s_mb_order2_reqs;
+        unsigned int s_mb_group_prealloc;
+        /* where last allocation was done - for stream allocation */
+        unsigned long s_mb_last_group;
+        unsigned long s_mb_last_start;
+
+        /* history to debug policy */
+        struct ext4_mb_history *s_mb_history;
+        int s_mb_history_cur;
+        int s_mb_history_max;
+        int s_mb_history_num;
+        spinlock_t s_mb_history_lock;
+        int s_mb_history_filter;
+
+        /* stats for buddy allocator */
+        spinlock_t s_mb_pa_lock;
+        atomic_t s_bal_reqs;    /* number of reqs with len > 1 */
+        atomic_t s_bal_success; /* we found long enough chunks */
+        atomic_t s_bal_allocated;       /* in blocks */
+        atomic_t s_bal_ex_scanned;      /* total extents scanned */
+        atomic_t s_bal_goals;   /* goal hits */
+        atomic_t s_bal_breaks;  /* too long searches */
+        atomic_t s_bal_2orders; /* 2^order hits */
+        spinlock_t s_bal_lock;
+        unsigned long s_mb_buddies_generated;
+        unsigned long long s_mb_generation_time;
+        atomic_t s_mb_lost_chunks;
+        atomic_t s_mb_preallocated;
+        atomic_t s_mb_discarded;
+
+        /* locality groups */
+        struct ext4_locality_group *s_locality_groups;
+
+        /* for write statistics */
+        unsigned long s_sectors_written_start;
+        u64 s_kbytes_written;
+
+        unsigned int s_log_groups_per_flex;
+        struct flex_groups *s_flex_groups;
+};
+
 static inline struct ext4_sb_info *EXT4_SB(struct super_block *sb)
 {
         return sb->s_fs_info;
@@ -704,7 +970,6 @@ static inline struct timespec ext4_current_time(struct inode *inode)
                 current_fs_time(inode->i_sb) : CURRENT_TIME_SEC;
 }
 
-
 static inline int ext4_valid_inum(struct super_block *sb, unsigned long ino)
 {
         return ino == EXT4_ROOT_INO ||
@@ -1014,6 +1279,14 @@ extern struct ext4_group_desc * ext4_get_group_desc(struct super_block * sb,
                                                     ext4_group_t block_group,
                                                     struct buffer_head ** bh);
 extern int ext4_should_retry_alloc(struct super_block *sb, int *retries);
+struct buffer_head *ext4_read_block_bitmap(struct super_block *sb,
+                                      ext4_group_t block_group);
+extern unsigned ext4_init_block_bitmap(struct super_block *sb,
+                                       struct buffer_head *bh,
+                                       ext4_group_t group,
+                                       struct ext4_group_desc *desc);
+#define ext4_free_blocks_after_init(sb, group, desc)                    \
+                ext4_init_block_bitmap(sb, NULL, group, desc)
 
 /* dir.c */
 extern int ext4_check_dir_entry(const char *, struct inode *,
@@ -1038,6 +1311,11 @@ extern struct inode * ext4_orphan_get(struct super_block *, unsigned long);
 extern unsigned long ext4_count_free_inodes(struct super_block *);
 extern unsigned long ext4_count_dirs(struct super_block *);
 extern void ext4_check_inodes_bitmap(struct super_block *);
+extern unsigned ext4_init_inode_bitmap(struct super_block *sb,
+                                       struct buffer_head *bh,
+                                       ext4_group_t group,
+                                       struct ext4_group_desc *desc);
+extern void mark_bitmap_end(int start_bit, int end_bit, char *bitmap);
 
 /* mballoc.c */
 extern long ext4_mb_stats;
@@ -1123,6 +1401,8 @@ extern void ext4_abort(struct super_block *, const char *, const char *, ...)
         __attribute__ ((format (printf, 3, 4)));
 extern void ext4_warning(struct super_block *, const char *, const char *, ...)
         __attribute__ ((format (printf, 3, 4)));
+extern void ext4_msg(struct super_block *, const char *, const char *, ...)
+        __attribute__ ((format (printf, 3, 4)));
 extern void ext4_grp_locked_error(struct super_block *, ext4_group_t,
                                 const char *, const char *, ...)
         __attribute__ ((format (printf, 4, 5)));
@@ -1161,6 +1441,10 @@ extern void ext4_used_dirs_set(struct super_block *sb,
                                 struct ext4_group_desc *bg, __u32 count);
 extern void ext4_itable_unused_set(struct super_block *sb,
                                    struct ext4_group_desc *bg, __u32 count);
+extern __le16 ext4_group_desc_csum(struct ext4_sb_info *sbi, __u32 group,
+                                   struct ext4_group_desc *gdp);
+extern int ext4_group_desc_csum_verify(struct ext4_sb_info *sbi, __u32 group,
+                                       struct ext4_group_desc *gdp);
 
 static inline ext4_fsblk_t ext4_blocks_count(struct ext4_super_block *es)
 {
@@ -1228,6 +1512,18 @@ struct ext4_group_info *ext4_get_group_info(struct super_block *sb,
          return grp_info[indexv][indexh];
 }
 
+/*
+ * Reading s_groups_count requires using smp_rmb() afterwards.  See
+ * the locking protocol documented in the comments of ext4_group_add()
+ * in resize.c
+ */
+static inline ext4_group_t ext4_get_groups_count(struct super_block *sb)
+{
+        ext4_group_t    ngroups = EXT4_SB(sb)->s_groups_count;
+
+        smp_rmb();
+        return ngroups;
+}
 
 static inline ext4_group_t ext4_flex_group(struct ext4_sb_info *sbi,
                                              ext4_group_t block_group)
@@ -1283,33 +1579,25 @@ struct ext4_group_info {
 };
 
 #define EXT4_GROUP_INFO_NEED_INIT_BIT   0
-#define EXT4_GROUP_INFO_LOCKED_BIT      1
 
 #define EXT4_MB_GRP_NEED_INIT(grp)      \
         (test_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &((grp)->bb_state)))
 
-static inline void ext4_lock_group(struct super_block *sb, ext4_group_t group)
+static inline spinlock_t *ext4_group_lock_ptr(struct super_block *sb,
+                                              ext4_group_t group)
 {
-        struct ext4_group_info *grinfo = ext4_get_group_info(sb, group);
-
-        bit_spin_lock(EXT4_GROUP_INFO_LOCKED_BIT, &(grinfo->bb_state));
+        return bgl_lock_ptr(EXT4_SB(sb)->s_blockgroup_lock, group);
 }
 
-static inline void ext4_unlock_group(struct super_block *sb,
-                                        ext4_group_t group)
+static inline void ext4_lock_group(struct super_block *sb, ext4_group_t group)
 {
-        struct ext4_group_info *grinfo = ext4_get_group_info(sb, group);
-
-        bit_spin_unlock(EXT4_GROUP_INFO_LOCKED_BIT, &(grinfo->bb_state));
+        spin_lock(ext4_group_lock_ptr(sb, group));
 }
 
-static inline int ext4_is_group_locked(struct super_block *sb,
+static inline void ext4_unlock_group(struct super_block *sb,
                                         ext4_group_t group)
 {
-        struct ext4_group_info *grinfo = ext4_get_group_info(sb, group);
-
-        return bit_spin_is_locked(EXT4_GROUP_INFO_LOCKED_BIT,
-                                                &(grinfo->bb_state));
+        spin_unlock(ext4_group_lock_ptr(sb, group));
 }
 
 /*
@@ -1326,11 +1614,21 @@ extern const struct file_operations ext4_file_operations;
 /* namei.c */
 extern const struct inode_operations ext4_dir_inode_operations;
 extern const struct inode_operations ext4_special_inode_operations;
+extern struct dentry *ext4_get_parent(struct dentry *child);
 
 /* symlink.c */
 extern const struct inode_operations ext4_symlink_inode_operations;
 extern const struct inode_operations ext4_fast_symlink_inode_operations;
 
+/* block_validity */
+extern void ext4_release_system_zone(struct super_block *sb);
+extern int ext4_setup_system_zone(struct super_block *sb);
+extern int __init init_ext4_system_zone(void);
+extern void exit_ext4_system_zone(void);
+extern int ext4_data_block_valid(struct ext4_sb_info *sbi,
+                                 ext4_fsblk_t start_blk,
+                                 unsigned int count);
+
 /* extents.c */
 extern int ext4_ext_tree_init(handle_t *handle, struct inode *);
 extern int ext4_ext_writepage_trans_blocks(struct inode *, int);
@@ -1338,17 +1636,15 @@ extern int ext4_ext_index_trans_blocks(struct inode *inode, int nrblocks,
                                        int chunk);
 extern int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
                                ext4_lblk_t iblock, unsigned int max_blocks,
-                               struct buffer_head *bh_result,
-                               int create, int extend_disksize);
+                               struct buffer_head *bh_result, int flags);
 extern void ext4_ext_truncate(struct inode *);
 extern void ext4_ext_init(struct super_block *);
 extern void ext4_ext_release(struct super_block *);
 extern long ext4_fallocate(struct inode *inode, int mode, loff_t offset,
                           loff_t len);
-extern int ext4_get_blocks_wrap(handle_t *handle, struct inode *inode,
-                        sector_t block, unsigned int max_blocks,
-                        struct buffer_head *bh, int create,
-                        int extend_disksize, int flag);
+extern int ext4_get_blocks(handle_t *handle, struct inode *inode,
+                           sector_t block, unsigned int max_blocks,
+                           struct buffer_head *bh, int flags);
 extern int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                         __u64 start, __u64 len);
 
diff --git a/fs/ext4/ext4_i.h b/fs/ext4/ext4_i.h
deleted file mode 100644
index 4ce2187123aa..000000000000
--- a/fs/ext4/ext4_i.h
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- *  ext4_i.h
- *
- * Copyright (C) 1992, 1993, 1994, 1995
- * Remy Card (card@masi.ibp.fr)
- * Laboratoire MASI - Institut Blaise Pascal
- * Universite Pierre et Marie Curie (Paris VI)
- *
- *  from
- *
- *  linux/include/linux/minix_fs_i.h
- *
- *  Copyright (C) 1991, 1992  Linus Torvalds
- */
-
-#ifndef _EXT4_I
-#define _EXT4_I
-
-#include <linux/rwsem.h>
-#include <linux/rbtree.h>
-#include <linux/seqlock.h>
-#include <linux/mutex.h>
-
-/* data type for block offset of block group */
-typedef int ext4_grpblk_t;
-
-/* data type for filesystem-wide blocks number */
-typedef unsigned long long ext4_fsblk_t;
-
-/* data type for file logical block number */
-typedef __u32 ext4_lblk_t;
-
-/* data type for block group number */
-typedef unsigned int ext4_group_t;
-
-/*
- * storage for cached extent
- */
-struct ext4_ext_cache {
-        ext4_fsblk_t    ec_start;
-        ext4_lblk_t     ec_block;
-        __u32           ec_len; /* must be 32bit to return holes */
-        __u32           ec_type;
-};
-
-/*
- * fourth extended file system inode data in memory
- */
-struct ext4_inode_info {
-        __le32  i_data[15];     /* unconverted */
-        __u32   i_flags;
-        ext4_fsblk_t    i_file_acl;
-        __u32   i_dtime;
-
-        /*
-         * i_block_group is the number of the block group which contains
-         * this file's inode.  Constant across the lifetime of the inode,
-         * it is ued for making block allocation decisions - we try to
-         * place a file's data blocks near its inode block, and new inodes
-         * near to their parent directory's inode.
-         */
-        ext4_group_t    i_block_group;
-        __u32   i_state;                /* Dynamic state flags for ext4 */
-
-        ext4_lblk_t             i_dir_start_lookup;
-#ifdef CONFIG_EXT4_FS_XATTR
-        /*
-         * Extended attributes can be read independently of the main file
-         * data. Taking i_mutex even when reading would cause contention
-         * between readers of EAs and writers of regular file data, so
-         * instead we synchronize on xattr_sem when reading or changing
-         * EAs.
-         */
-        struct rw_semaphore xattr_sem;
-#endif
-#ifdef CONFIG_EXT4_FS_POSIX_ACL
-        struct posix_acl        *i_acl;
-        struct posix_acl        *i_default_acl;
-#endif
-
-        struct list_head i_orphan;      /* unlinked but open inodes */
-
-        /*
-         * i_disksize keeps track of what the inode size is ON DISK, not
-         * in memory.  During truncate, i_size is set to the new size by
-         * the VFS prior to calling ext4_truncate(), but the filesystem won't
-         * set i_disksize to 0 until the truncate is actually under way.
-         *
-         * The intent is that i_disksize always represents the blocks which
-         * are used by this file.  This allows recovery to restart truncate
-         * on orphans if we crash during truncate.  We actually write i_disksize
-         * into the on-disk inode when writing inodes out, instead of i_size.
-         *
-         * The only time when i_disksize and i_size may be different is when
-         * a truncate is in progress.  The only things which change i_disksize
-         * are ext4_get_block (growth) and ext4_truncate (shrinkth).
-         */
-        loff_t  i_disksize;
-
-        /*
-         * i_data_sem is for serialising ext4_truncate() against
-         * ext4_getblock().  In the 2.4 ext2 design, great chunks of inode's
-         * data tree are chopped off during truncate. We can't do that in
-         * ext4 because whenever we perform intermediate commits during
-         * truncate, the inode and all the metadata blocks *must* be in a
-         * consistent state which allows truncation of the orphans to restart
-         * during recovery.  Hence we must fix the get_block-vs-truncate race
-         * by other means, so we have i_data_sem.
-         */
-        struct rw_semaphore i_data_sem;
-        struct inode vfs_inode;
-        struct jbd2_inode jinode;
-
-        struct ext4_ext_cache i_cached_extent;
-        /*
-         * File creation time. Its function is same as that of
-         * struct timespec i_{a,c,m}time in the generic inode.
-         */
-        struct timespec i_crtime;
-
-        /* mballoc */
-        struct list_head i_prealloc_list;
-        spinlock_t i_prealloc_lock;
-
-        /* ialloc */
-        ext4_group_t    i_last_alloc_group;
-
-        /* allocation reservation info for delalloc */
-        unsigned int i_reserved_data_blocks;
-        unsigned int i_reserved_meta_blocks;
-        unsigned int i_allocated_meta_blocks;
-        unsigned short i_delalloc_reserved_flag;
-
-        /* on-disk additional length */
-        __u16 i_extra_isize;
-
-        spinlock_t i_block_reservation_lock;
-};
-
-#endif  /* _EXT4_I */
diff --git a/fs/ext4/ext4_sb.h b/fs/ext4/ext4_sb.h
deleted file mode 100644
index 57b71fefbccf..000000000000
--- a/fs/ext4/ext4_sb.h
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
- *  ext4_sb.h
- *
- * Copyright (C) 1992, 1993, 1994, 1995
- * Remy Card (card@masi.ibp.fr)
- * Laboratoire MASI - Institut Blaise Pascal
- * Universite Pierre et Marie Curie (Paris VI)
- *
- *  from
- *
- *  linux/include/linux/minix_fs_sb.h
- *
- *  Copyright (C) 1991, 1992  Linus Torvalds
- */
-
-#ifndef _EXT4_SB
-#define _EXT4_SB
-
-#ifdef __KERNEL__
-#include <linux/timer.h>
-#include <linux/wait.h>
-#include <linux/blockgroup_lock.h>
-#include <linux/percpu_counter.h>
-#endif
-#include <linux/rbtree.h>
-
-/*
- * fourth extended-fs super-block data in memory
- */
-struct ext4_sb_info {
-        unsigned long s_desc_size;      /* Size of a group descriptor in bytes */
-        unsigned long s_inodes_per_block;/* Number of inodes per block */
-        unsigned long s_blocks_per_group;/* Number of blocks in a group */
-        unsigned long s_inodes_per_group;/* Number of inodes in a group */
-        unsigned long s_itb_per_group;  /* Number of inode table blocks per group */
-        unsigned long s_gdb_count;      /* Number of group descriptor blocks */
-        unsigned long s_desc_per_block; /* Number of group descriptors per block */
-        ext4_group_t s_groups_count;    /* Number of groups in the fs */
-        unsigned long s_overhead_last;  /* Last calculated overhead */
-        unsigned long s_blocks_last;    /* Last seen block count */
-        loff_t s_bitmap_maxbytes;       /* max bytes for bitmap files */
-        struct buffer_head * s_sbh;     /* Buffer containing the super block */
-        struct ext4_super_block *s_es;  /* Pointer to the super block in the buffer */
-        struct buffer_head **s_group_desc;
-        unsigned long  s_mount_opt;
-        ext4_fsblk_t s_sb_block;
-        uid_t s_resuid;
-        gid_t s_resgid;
-        unsigned short s_mount_state;
-        unsigned short s_pad;
-        int s_addr_per_block_bits;
-        int s_desc_per_block_bits;
-        int s_inode_size;
-        int s_first_ino;
-        unsigned int s_inode_readahead_blks;
-        spinlock_t s_next_gen_lock;
-        u32 s_next_generation;
-        u32 s_hash_seed[4];
-        int s_def_hash_version;
-        int s_hash_unsigned;    /* 3 if hash should be signed, 0 if not */
-        struct percpu_counter s_freeblocks_counter;
-        struct percpu_counter s_freeinodes_counter;
-        struct percpu_counter s_dirs_counter;
-        struct percpu_counter s_dirtyblocks_counter;
-        struct blockgroup_lock *s_blockgroup_lock;
-        struct proc_dir_entry *s_proc;
-        struct kobject s_kobj;
-        struct completion s_kobj_unregister;
-
-        /* Journaling */
-        struct inode *s_journal_inode;
-        struct journal_s *s_journal;
-        struct list_head s_orphan;
-        unsigned long s_commit_interval;
-        u32 s_max_batch_time;
-        u32 s_min_batch_time;
-        struct block_device *journal_bdev;
-#ifdef CONFIG_JBD2_DEBUG
-        struct timer_list turn_ro_timer;        /* For turning read-only (crash simulation) */
-        wait_queue_head_t ro_wait_queue;        /* For people waiting for the fs to go read-only */
-#endif
-#ifdef CONFIG_QUOTA
-        char *s_qf_names[MAXQUOTAS];            /* Names of quota files with journalled quota */
-        int s_jquota_fmt;                       /* Format of quota to use */
-#endif
-        unsigned int s_want_extra_isize; /* New inodes should reserve # bytes */
-
-#ifdef EXTENTS_STATS
-        /* ext4 extents stats */
-        unsigned long s_ext_min;
-        unsigned long s_ext_max;
-        unsigned long s_depth_max;
-        spinlock_t s_ext_stats_lock;
-        unsigned long s_ext_blocks;
-        unsigned long s_ext_extents;
-#endif
-
-        /* for buddy allocator */
-        struct ext4_group_info ***s_group_info;
-        struct inode *s_buddy_cache;
-        long s_blocks_reserved;
-        spinlock_t s_reserve_lock;
-        spinlock_t s_md_lock;
-        tid_t s_last_transaction;
-        unsigned short *s_mb_offsets;
-        unsigned int *s_mb_maxs;
-
-        /* tunables */
-        unsigned long s_stripe;
-        unsigned int s_mb_stream_request;
-        unsigned int s_mb_max_to_scan;
-        unsigned int s_mb_min_to_scan;
-        unsigned int s_mb_stats;
-        unsigned int s_mb_order2_reqs;
-        unsigned int s_mb_group_prealloc;
-        /* where last allocation was done - for stream allocation */
-        unsigned long s_mb_last_group;
-        unsigned long s_mb_last_start;
-
-        /* history to debug policy */
-        struct ext4_mb_history *s_mb_history;
-        int s_mb_history_cur;
-        int s_mb_history_max;
-        int s_mb_history_num;
-        spinlock_t s_mb_history_lock;
-        int s_mb_history_filter;
-
-        /* stats for buddy allocator */
-        spinlock_t s_mb_pa_lock;
-        atomic_t s_bal_reqs;    /* number of reqs with len > 1 */
-        atomic_t s_bal_success; /* we found long enough chunks */
-        atomic_t s_bal_allocated;       /* in blocks */
-        atomic_t s_bal_ex_scanned;      /* total extents scanned */
-        atomic_t s_bal_goals;   /* goal hits */
-        atomic_t s_bal_breaks;  /* too long searches */
-        atomic_t s_bal_2orders; /* 2^order hits */
-        spinlock_t s_bal_lock;
-        unsigned long s_mb_buddies_generated;
-        unsigned long long s_mb_generation_time;
-        atomic_t s_mb_lost_chunks;
-        atomic_t s_mb_preallocated;
-        atomic_t s_mb_discarded;
-
-        /* locality groups */
-        struct ext4_locality_group *s_locality_groups;
-
-        /* for write statistics */
-        unsigned long s_sectors_written_start;
-        u64 s_kbytes_written;
-
-        unsigned int s_log_groups_per_flex;
-        struct flex_groups *s_flex_groups;
-};
-
-static inline spinlock_t *
-sb_bgl_lock(struct ext4_sb_info *sbi, unsigned int block_group)
-{
-        return bgl_lock_ptr(sbi->s_blockgroup_lock, block_group);
-}
-
-#endif  /* _EXT4_SB */
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index e3a55eb8b26a..2593f748c3a4 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -326,32 +326,18 @@ ext4_ext_max_entries(struct inode *inode, int depth)
 
 static int ext4_valid_extent(struct inode *inode, struct ext4_extent *ext)
 {
-        ext4_fsblk_t block = ext_pblock(ext), valid_block;
+        ext4_fsblk_t block = ext_pblock(ext);
         int len = ext4_ext_get_actual_len(ext);
-        struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
 
-        valid_block = le32_to_cpu(es->s_first_data_block) +
-                EXT4_SB(inode->i_sb)->s_gdb_count;
-        if (unlikely(block <= valid_block ||
-                     ((block + len) > ext4_blocks_count(es))))
-                return 0;
-        else
-                return 1;
+        return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, len);
 }
 
 static int ext4_valid_extent_idx(struct inode *inode,
                                 struct ext4_extent_idx *ext_idx)
 {
-        ext4_fsblk_t block = idx_pblock(ext_idx), valid_block;
-        struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
+        ext4_fsblk_t block = idx_pblock(ext_idx);
 
-        valid_block = le32_to_cpu(es->s_first_data_block) +
-                EXT4_SB(inode->i_sb)->s_gdb_count;
-        if (unlikely(block <= valid_block ||
-                     (block >= ext4_blocks_count(es))))
-                return 0;
-        else
-                return 1;
+        return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, 1);
 }
 
 static int ext4_valid_extent_entries(struct inode *inode,
@@ -2097,12 +2083,16 @@ ext4_ext_rm_leaf(handle_t *handle, struct inode *inode,
         ex = EXT_LAST_EXTENT(eh);
 
         ex_ee_block = le32_to_cpu(ex->ee_block);
-        if (ext4_ext_is_uninitialized(ex))
-                uninitialized = 1;
         ex_ee_len = ext4_ext_get_actual_len(ex);
 
         while (ex >= EXT_FIRST_EXTENT(eh) &&
                         ex_ee_block + ex_ee_len > start) {
+
+                if (ext4_ext_is_uninitialized(ex))
+                        uninitialized = 1;
+                else
+                        uninitialized = 0;
+
                 ext_debug("remove ext %lu:%u\n", ex_ee_block, ex_ee_len);
                 path[depth].p_ext = ex;
 
@@ -2784,7 +2774,7 @@ fix_extent_len:
 int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
                         ext4_lblk_t iblock,
                         unsigned int max_blocks, struct buffer_head *bh_result,
-                        int create, int extend_disksize)
+                        int flags)
 {
         struct ext4_ext_path *path = NULL;
         struct ext4_extent_header *eh;
@@ -2793,7 +2783,6 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
         int err = 0, depth, ret, cache_type;
         unsigned int allocated = 0;
         struct ext4_allocation_request ar;
-        loff_t disksize;
 
         __clear_bit(BH_New, &bh_result->b_state);
         ext_debug("blocks %u/%u requested for inode %u\n",
@@ -2803,7 +2792,7 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
         cache_type = ext4_ext_in_cache(inode, iblock, &newex);
         if (cache_type) {
                 if (cache_type == EXT4_EXT_CACHE_GAP) {
-                        if (!create) {
+                        if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) {
                                 /*
                                  * block isn't allocated yet and
                                  * user doesn't want to allocate it
@@ -2869,9 +2858,11 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
                                                         EXT4_EXT_CACHE_EXTENT);
                                 goto out;
                         }
-                        if (create == EXT4_CREATE_UNINITIALIZED_EXT)
+                        if (flags & EXT4_GET_BLOCKS_UNINIT_EXT)
                                 goto out;
-                        if (!create) {
+                        if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) {
+                                if (allocated > max_blocks)
+                                        allocated = max_blocks;
                                 /*
                                  * We have blocks reserved already.  We
                                  * return allocated blocks so that delalloc
@@ -2879,8 +2870,6 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
                                  * the buffer head will be unmapped so that
                                  * a read from the block returns 0s.
                                  */
-                                if (allocated > max_blocks)
-                                        allocated = max_blocks;
                                 set_buffer_unwritten(bh_result);
                                 bh_result->b_bdev = inode->i_sb->s_bdev;
                                 bh_result->b_blocknr = newblock;
@@ -2903,7 +2892,7 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
          * requested block isn't allocated yet;
          * we couldn't try to create block if create flag is zero
          */
-        if (!create) {
+        if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) {
                 /*
                  * put just found gap into cache to speed up
                  * subsequent requests
@@ -2932,10 +2921,10 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
          * EXT_UNINIT_MAX_LEN.
          */
         if (max_blocks > EXT_INIT_MAX_LEN &&
-            create != EXT4_CREATE_UNINITIALIZED_EXT)
+            !(flags & EXT4_GET_BLOCKS_UNINIT_EXT))
                 max_blocks = EXT_INIT_MAX_LEN;
         else if (max_blocks > EXT_UNINIT_MAX_LEN &&
-                 create == EXT4_CREATE_UNINITIALIZED_EXT)
+                 (flags & EXT4_GET_BLOCKS_UNINIT_EXT))
                 max_blocks = EXT_UNINIT_MAX_LEN;
 
         /* Check if we can really insert (iblock)::(iblock+max_blocks) extent */
@@ -2966,7 +2955,7 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
         /* try to insert new extent into found leaf and return */
         ext4_ext_store_pblock(&newex, newblock);
         newex.ee_len = cpu_to_le16(ar.len);
-        if (create == EXT4_CREATE_UNINITIALIZED_EXT)  /* Mark uninitialized */
+        if (flags & EXT4_GET_BLOCKS_UNINIT_EXT)  /* Mark uninitialized */
                 ext4_ext_mark_uninitialized(&newex);
         err = ext4_ext_insert_extent(handle, inode, path, &newex);
         if (err) {
@@ -2983,18 +2972,10 @@ int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
         newblock = ext_pblock(&newex);
         allocated = ext4_ext_get_actual_len(&newex);
 outnew:
-        if (extend_disksize) {
-                disksize = ((loff_t) iblock + ar.len) << inode->i_blkbits;
-                if (disksize > i_size_read(inode))
-                        disksize = i_size_read(inode);
-                if (disksize > EXT4_I(inode)->i_disksize)
-                        EXT4_I(inode)->i_disksize = disksize;
-        }
-
         set_buffer_new(bh_result);
 
         /* Cache only when it is _not_ an uninitialized extent */
-        if (create != EXT4_CREATE_UNINITIALIZED_EXT)
+        if ((flags & EXT4_GET_BLOCKS_UNINIT_EXT) == 0)
                 ext4_ext_put_in_cache(inode, iblock, allocated, newblock,
                                                 EXT4_EXT_CACHE_EXTENT);
 out:
@@ -3150,9 +3131,10 @@ retry:
                         ret = PTR_ERR(handle);
                         break;
                 }
-                ret = ext4_get_blocks_wrap(handle, inode, block,
-                                          max_blocks, &map_bh,
-                                          EXT4_CREATE_UNINITIALIZED_EXT, 0, 0);
+                map_bh.b_state = 0;
+                ret = ext4_get_blocks(handle, inode, block,
+                                      max_blocks, &map_bh,
+                                      EXT4_GET_BLOCKS_CREATE_UNINIT_EXT);
                 if (ret <= 0) {
 #ifdef EXT4FS_DEBUG
                         WARN_ON(ret <= 0);
@@ -3195,7 +3177,7 @@ static int ext4_ext_fiemap_cb(struct inode *inode, struct ext4_ext_path *path,
                        void *data)
 {
         struct fiemap_extent_info *fieinfo = data;
-        unsigned long blksize_bits = inode->i_sb->s_blocksize_bits;
+        unsigned char blksize_bits = inode->i_sb->s_blocksize_bits;
         __u64   logical;
         __u64   physical;
         __u64   length;
@@ -3242,9 +3224,16 @@ static int ext4_ext_fiemap_cb(struct inode *inode, struct ext4_ext_path *path,
          *
          * XXX this might miss a single-block extent at EXT_MAX_BLOCK
          */
-        if (logical + length - 1 == EXT_MAX_BLOCK ||
-            ext4_ext_next_allocated_block(path) == EXT_MAX_BLOCK)
+        if (ext4_ext_next_allocated_block(path) == EXT_MAX_BLOCK ||
+            newex->ec_block + newex->ec_len - 1 == EXT_MAX_BLOCK) {
+                loff_t size = i_size_read(inode);
+                loff_t bs = EXT4_BLOCK_SIZE(inode->i_sb);
+
                 flags |= FIEMAP_EXTENT_LAST;
+                if ((flags & FIEMAP_EXTENT_DELALLOC) &&
+                    logical+length > size)
+                        length = (size - logical + bs - 1) & ~(bs-1);
+        }
 
         error = fiemap_fill_next_extent(fieinfo, logical, physical,
                                         length, flags);
@@ -3318,10 +3307,10 @@ int ext4_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                  * Walk the extent tree gathering extent information.
                  * ext4_ext_fiemap_cb will push extents back to user.
                  */
-                down_write(&EXT4_I(inode)->i_data_sem);
+                down_read(&EXT4_I(inode)->i_data_sem);
                 error = ext4_ext_walk_space(inode, start_blk, len_blks,
                                           ext4_ext_fiemap_cb, fieinfo);
-                up_write(&EXT4_I(inode)->i_data_sem);
+                up_read(&EXT4_I(inode)->i_data_sem);
         }
 
         return error;
diff --git a/fs/ext4/group.h b/fs/ext4/group.h
deleted file mode 100644
index c2c0a8d06d0e..000000000000
--- a/fs/ext4/group.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- *  linux/fs/ext4/group.h
- *
- * Copyright (C) 2007 Cluster File Systems, Inc
- *
- * Author: Andreas Dilger <adilger@clusterfs.com>
- */
-
-#ifndef _LINUX_EXT4_GROUP_H
-#define _LINUX_EXT4_GROUP_H
-
-extern __le16 ext4_group_desc_csum(struct ext4_sb_info *sbi, __u32 group,
-                                   struct ext4_group_desc *gdp);
-extern int ext4_group_desc_csum_verify(struct ext4_sb_info *sbi, __u32 group,
-                                       struct ext4_group_desc *gdp);
-struct buffer_head *ext4_read_block_bitmap(struct super_block *sb,
-                                      ext4_group_t block_group);
-extern unsigned ext4_init_block_bitmap(struct super_block *sb,
-                                       struct buffer_head *bh,
-                                       ext4_group_t group,
-                                       struct ext4_group_desc *desc);
-#define ext4_free_blocks_after_init(sb, group, desc)                    \
-                ext4_init_block_bitmap(sb, NULL, group, desc)
-extern unsigned ext4_init_inode_bitmap(struct super_block *sb,
-                                       struct buffer_head *bh,
-                                       ext4_group_t group,
-                                       struct ext4_group_desc *desc);
-extern void mark_bitmap_end(int start_bit, int end_bit, char *bitmap);
-#endif /* _LINUX_EXT4_GROUP_H */
diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index f18e0a08a6b5..3743bd849bce 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -27,7 +27,6 @@
 #include "ext4_jbd2.h"
 #include "xattr.h"
 #include "acl.h"
-#include "group.h"
 
 /*
  * ialloc.c contains the inodes allocation and deallocation routines
@@ -123,16 +122,16 @@ ext4_read_inode_bitmap(struct super_block *sb, ext4_group_t block_group)
                 unlock_buffer(bh);
                 return bh;
         }
-        spin_lock(sb_bgl_lock(EXT4_SB(sb), block_group));
+        ext4_lock_group(sb, block_group);
         if (desc->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
                 ext4_init_inode_bitmap(sb, bh, block_group, desc);
                 set_bitmap_uptodate(bh);
                 set_buffer_uptodate(bh);
-                spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group));
+                ext4_unlock_group(sb, block_group);
                 unlock_buffer(bh);
                 return bh;
         }
-        spin_unlock(sb_bgl_lock(EXT4_SB(sb), block_group));
+        ext4_unlock_group(sb, block_group);
         if (buffer_uptodate(bh)) {
                 /*
                  * if not uninit if bh is uptodate,
@@ -247,9 +246,8 @@ void ext4_free_inode(handle_t *handle, struct inode *inode)
                 goto error_return;
 
         /* Ok, now we can actually update the inode bitmaps.. */
-        spin_lock(sb_bgl_lock(sbi, block_group));
-        cleared = ext4_clear_bit(bit, bitmap_bh->b_data);
-        spin_unlock(sb_bgl_lock(sbi, block_group));
+        cleared = ext4_clear_bit_atomic(ext4_group_lock_ptr(sb, block_group),
+                                        bit, bitmap_bh->b_data);
         if (!cleared)
                 ext4_error(sb, "ext4_free_inode",
                            "bit already cleared for inode %lu", ino);
@@ -261,7 +259,7 @@ void ext4_free_inode(handle_t *handle, struct inode *inode)
                 if (fatal) goto error_return;
 
                 if (gdp) {
-                        spin_lock(sb_bgl_lock(sbi, block_group));
+                        ext4_lock_group(sb, block_group);
                         count = ext4_free_inodes_count(sb, gdp) + 1;
                         ext4_free_inodes_set(sb, gdp, count);
                         if (is_directory) {
@@ -277,7 +275,7 @@ void ext4_free_inode(handle_t *handle, struct inode *inode)
                         }
                         gdp->bg_checksum = ext4_group_desc_csum(sbi,
                                                         block_group, gdp);
-                        spin_unlock(sb_bgl_lock(sbi, block_group));
+                        ext4_unlock_group(sb, block_group);
                         percpu_counter_inc(&sbi->s_freeinodes_counter);
                         if (is_directory)
                                 percpu_counter_dec(&sbi->s_dirs_counter);
@@ -316,7 +314,7 @@ error_return:
 static int find_group_dir(struct super_block *sb, struct inode *parent,
                                 ext4_group_t *best_group)
 {
-        ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count;
+        ext4_group_t ngroups = ext4_get_groups_count(sb);
         unsigned int freei, avefreei;
         struct ext4_group_desc *desc, *best_desc = NULL;
         ext4_group_t group;
@@ -349,11 +347,10 @@ static int find_group_flex(struct super_block *sb, struct inode *parent,
 {
         struct ext4_sb_info *sbi = EXT4_SB(sb);
         struct ext4_group_desc *desc;
-        struct buffer_head *bh;
         struct flex_groups *flex_group = sbi->s_flex_groups;
         ext4_group_t parent_group = EXT4_I(parent)->i_block_group;
         ext4_group_t parent_fbg_group = ext4_flex_group(sbi, parent_group);
-        ext4_group_t ngroups = sbi->s_groups_count;
+        ext4_group_t ngroups = ext4_get_groups_count(sb);
         int flex_size = ext4_flex_bg_size(sbi);
         ext4_group_t best_flex = parent_fbg_group;
         int blocks_per_flex = sbi->s_blocks_per_group * flex_size;
@@ -362,7 +359,7 @@ static int find_group_flex(struct super_block *sb, struct inode *parent,
         ext4_group_t n_fbg_groups;
         ext4_group_t i;
 
-        n_fbg_groups = (sbi->s_groups_count + flex_size - 1) >>
+        n_fbg_groups = (ngroups + flex_size - 1) >>
                 sbi->s_log_groups_per_flex;
 
 find_close_to_parent:
@@ -404,7 +401,7 @@ find_close_to_parent:
 found_flexbg:
         for (i = best_flex * flex_size; i < ngroups &&
                      i < (best_flex + 1) * flex_size; i++) {
-                desc = ext4_get_group_desc(sb, i, &bh);
+                desc = ext4_get_group_desc(sb, i, NULL);
                 if (ext4_free_inodes_count(sb, desc)) {
                         *best_group = i;
                         goto out;
@@ -478,20 +475,21 @@ static int find_group_orlov(struct super_block *sb, struct inode *parent,
 {
         ext4_group_t parent_group = EXT4_I(parent)->i_block_group;
         struct ext4_sb_info *sbi = EXT4_SB(sb);
-        ext4_group_t ngroups = sbi->s_groups_count;
+        ext4_group_t real_ngroups = ext4_get_groups_count(sb);
         int inodes_per_group = EXT4_INODES_PER_GROUP(sb);
         unsigned int freei, avefreei;
         ext4_fsblk_t freeb, avefreeb;
         unsigned int ndirs;
         int max_dirs, min_inodes;
         ext4_grpblk_t min_blocks;
-        ext4_group_t i, grp, g;
+        ext4_group_t i, grp, g, ngroups;
         struct ext4_group_desc *desc;
         struct orlov_stats stats;
         int flex_size = ext4_flex_bg_size(sbi);
 
+        ngroups = real_ngroups;
         if (flex_size > 1) {
-                ngroups = (ngroups + flex_size - 1) >>
+                ngroups = (real_ngroups + flex_size - 1) >>
                         sbi->s_log_groups_per_flex;
                 parent_group >>= sbi->s_log_groups_per_flex;
         }
@@ -543,7 +541,7 @@ static int find_group_orlov(struct super_block *sb, struct inode *parent,
                  */
                 grp *= flex_size;
                 for (i = 0; i < flex_size; i++) {
-                        if (grp+i >= sbi->s_groups_count)
+                        if (grp+i >= real_ngroups)
                                 break;
                         desc = ext4_get_group_desc(sb, grp+i, NULL);
                         if (desc && ext4_free_inodes_count(sb, desc)) {
@@ -583,7 +581,7 @@ static int find_group_orlov(struct super_block *sb, struct inode *parent,
         }
 
 fallback:
-        ngroups = sbi->s_groups_count;
+        ngroups = real_ngroups;
         avefreei = freei / ngroups;
 fallback_retry:
         parent_group = EXT4_I(parent)->i_block_group;
@@ -613,9 +611,8 @@ static int find_group_other(struct super_block *sb, struct inode *parent,
                             ext4_group_t *group, int mode)
 {
         ext4_group_t parent_group = EXT4_I(parent)->i_block_group;
-        ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count;
+        ext4_group_t i, last, ngroups = ext4_get_groups_count(sb);
         struct ext4_group_desc *desc;
-        ext4_group_t i, last;
         int flex_size = ext4_flex_bg_size(EXT4_SB(sb));
 
         /*
@@ -708,10 +705,10 @@ static int find_group_other(struct super_block *sb, struct inode *parent,
 
 /*
  * claim the inode from the inode bitmap. If the group
- * is uninit we need to take the groups's sb_bgl_lock
+ * is uninit we need to take the groups's ext4_group_lock
  * and clear the uninit flag. The inode bitmap update
  * and group desc uninit flag clear should be done
- * after holding sb_bgl_lock so that ext4_read_inode_bitmap
+ * after holding ext4_group_lock so that ext4_read_inode_bitmap
  * doesn't race with the ext4_claim_inode
  */
 static int ext4_claim_inode(struct super_block *sb,
@@ -722,7 +719,7 @@ static int ext4_claim_inode(struct super_block *sb,
         struct ext4_sb_info *sbi = EXT4_SB(sb);
         struct ext4_group_desc *gdp = ext4_get_group_desc(sb, group, NULL);
 
-        spin_lock(sb_bgl_lock(sbi, group));
+        ext4_lock_group(sb, group);
         if (ext4_set_bit(ino, inode_bitmap_bh->b_data)) {
                 /* not a free inode */
                 retval = 1;
@@ -731,7 +728,7 @@ static int ext4_claim_inode(struct super_block *sb,
         ino++;
         if ((group == 0 && ino < EXT4_FIRST_INO(sb)) ||
                         ino > EXT4_INODES_PER_GROUP(sb)) {
-                spin_unlock(sb_bgl_lock(sbi, group));
+                ext4_unlock_group(sb, group);
                 ext4_error(sb, __func__,
                            "reserved inode or inode > inodes count - "
                            "block_group = %u, inode=%lu", group,
@@ -780,7 +777,7 @@ static int ext4_claim_inode(struct super_block *sb,
         }
         gdp->bg_checksum = ext4_group_desc_csum(sbi, group, gdp);
 err_ret:
-        spin_unlock(sb_bgl_lock(sbi, group));
+        ext4_unlock_group(sb, group);
         return retval;
 }
 
@@ -799,11 +796,10 @@ struct inode *ext4_new_inode(handle_t *handle, struct inode *dir, int mode)
         struct super_block *sb;
         struct buffer_head *inode_bitmap_bh = NULL;
         struct buffer_head *group_desc_bh;
-        ext4_group_t group = 0;
+        ext4_group_t ngroups, group = 0;
         unsigned long ino = 0;
         struct inode *inode;
         struct ext4_group_desc *gdp = NULL;
-        struct ext4_super_block *es;
         struct ext4_inode_info *ei;
         struct ext4_sb_info *sbi;
         int ret2, err = 0;
@@ -818,15 +814,14 @@ struct inode *ext4_new_inode(handle_t *handle, struct inode *dir, int mode)
                 return ERR_PTR(-EPERM);
 
         sb = dir->i_sb;
+        ngroups = ext4_get_groups_count(sb);
         trace_mark(ext4_request_inode, "dev %s dir %lu mode %d", sb->s_id,
                    dir->i_ino, mode);
         inode = new_inode(sb);
         if (!inode)
                 return ERR_PTR(-ENOMEM);
         ei = EXT4_I(inode);
-
         sbi = EXT4_SB(sb);
-        es = sbi->s_es;
 
         if (sbi->s_log_groups_per_flex && test_opt(sb, OLDALLOC)) {
                 ret2 = find_group_flex(sb, dir, &group);
@@ -856,7 +851,7 @@ got_group:
         if (ret2 == -1)
                 goto out;
 
-        for (i = 0; i < sbi->s_groups_count; i++) {
+        for (i = 0; i < ngroups; i++) {
                 err = -EIO;
 
                 gdp = ext4_get_group_desc(sb, group, &group_desc_bh);
@@ -917,7 +912,7 @@ repeat_in_this_group:
                  * group descriptor metadata has not yet been updated.
                  * So we just go onto the next blockgroup.
                  */
-                if (++group == sbi->s_groups_count)
+                if (++group == ngroups)
                         group = 0;
         }
         err = -ENOSPC;
@@ -938,7 +933,7 @@ got:
                 }
 
                 free = 0;
-                spin_lock(sb_bgl_lock(sbi, group));
+                ext4_lock_group(sb, group);
                 /* recheck and clear flag under lock if we still need to */
                 if (gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
                         free = ext4_free_blocks_after_init(sb, group, gdp);
@@ -947,7 +942,7 @@ got:
                         gdp->bg_checksum = ext4_group_desc_csum(sbi, group,
                                                                 gdp);
                 }
-                spin_unlock(sb_bgl_lock(sbi, group));
+                ext4_unlock_group(sb, group);
 
                 /* Don't need to dirty bitmap block if we didn't change it */
                 if (free) {
@@ -1158,7 +1153,7 @@ unsigned long ext4_count_free_inodes(struct super_block *sb)
 {
         unsigned long desc_count;
         struct ext4_group_desc *gdp;
-        ext4_group_t i;
+        ext4_group_t i, ngroups = ext4_get_groups_count(sb);
 #ifdef EXT4FS_DEBUG
         struct ext4_super_block *es;
         unsigned long bitmap_count, x;
@@ -1168,7 +1163,7 @@ unsigned long ext4_count_free_inodes(struct super_block *sb)
         desc_count = 0;
         bitmap_count = 0;
         gdp = NULL;
-        for (i = 0; i < EXT4_SB(sb)->s_groups_count; i++) {
+        for (i = 0; i < ngroups; i++) {
                 gdp = ext4_get_group_desc(sb, i, NULL);
                 if (!gdp)
                         continue;
@@ -1190,7 +1185,7 @@ unsigned long ext4_count_free_inodes(struct super_block *sb)
         return desc_count;
 #else
         desc_count = 0;
-        for (i = 0; i < EXT4_SB(sb)->s_groups_count; i++) {
+        for (i = 0; i < ngroups; i++) {
                 gdp = ext4_get_group_desc(sb, i, NULL);
                 if (!gdp)
                         continue;
@@ -1205,9 +1200,9 @@ unsigned long ext4_count_free_inodes(struct super_block *sb)
 unsigned long ext4_count_dirs(struct super_block * sb)
 {
         unsigned long count = 0;
-        ext4_group_t i;
+        ext4_group_t i, ngroups = ext4_get_groups_count(sb);
 
-        for (i = 0; i < EXT4_SB(sb)->s_groups_count; i++) {
+        for (i = 0; i < ngroups; i++) {
                 struct ext4_group_desc *gdp = ext4_get_group_desc(sb, i, NULL);
                 if (!gdp)
                         continue;
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 2a9ffd528dd1..875db944b22f 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -372,20 +372,21 @@ static int ext4_block_to_path(struct inode *inode,
 }
 
 static int __ext4_check_blockref(const char *function, struct inode *inode,
-                                 __le32 *p, unsigned int max) {
-
-        unsigned int maxblocks = ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es);
+                                 __le32 *p, unsigned int max)
+{
         __le32 *bref = p;
+        unsigned int blk;
+
         while (bref < p+max) {
-                if (unlikely(le32_to_cpu(*bref) >= maxblocks)) {
+                blk = le32_to_cpu(*bref++);
+                if (blk && 
+                    unlikely(!ext4_data_block_valid(EXT4_SB(inode->i_sb), 
+                                                    blk, 1))) {
                         ext4_error(inode->i_sb, function,
-                                   "block reference %u >= max (%u) "
-                                   "in inode #%lu, offset=%d",
-                                   le32_to_cpu(*bref), maxblocks,
-                                   inode->i_ino, (int)(bref-p));
+                                   "invalid block reference %u "
+                                   "in inode #%lu", blk, inode->i_ino);
                         return -EIO;
                 }
-                bref++;
         }
         return 0;
 }
@@ -892,6 +893,10 @@ err_out:
 }
 
 /*
+ * The ext4_ind_get_blocks() function handles non-extents inodes
+ * (i.e., using the traditional indirect/double-indirect i_blocks
+ * scheme) for ext4_get_blocks().
+ *
  * Allocation strategy is simple: if we have to allocate something, we will
  * have to go the whole way to leaf. So let's do it before attaching anything
  * to tree, set linkage between the newborn blocks, write them if sync is
@@ -909,15 +914,16 @@ err_out:
  * return = 0, if plain lookup failed.
  * return < 0, error case.
  *
- *
- * Need to be called with
- * down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system block
- * (ie, create is zero). Otherwise down_write(&EXT4_I(inode)->i_data_sem)
+ * The ext4_ind_get_blocks() function should be called with
+ * down_write(&EXT4_I(inode)->i_data_sem) if allocating filesystem
+ * blocks (i.e., flags has EXT4_GET_BLOCKS_CREATE set) or
+ * down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system
+ * blocks.
  */
-static int ext4_get_blocks_handle(handle_t *handle, struct inode *inode,
+static int ext4_ind_get_blocks(handle_t *handle, struct inode *inode,
                                   ext4_lblk_t iblock, unsigned int maxblocks,
                                   struct buffer_head *bh_result,
-                                  int create, int extend_disksize)
+                                  int flags)
 {
         int err = -EIO;
         ext4_lblk_t offsets[4];
@@ -927,14 +933,11 @@ static int ext4_get_blocks_handle(handle_t *handle, struct inode *inode,
         int indirect_blks;
         int blocks_to_boundary = 0;
         int depth;
-        struct ext4_inode_info *ei = EXT4_I(inode);
         int count = 0;
         ext4_fsblk_t first_block = 0;
-        loff_t disksize;
-
 
         J_ASSERT(!(EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL));
-        J_ASSERT(handle != NULL || create == 0);
+        J_ASSERT(handle != NULL || (flags & EXT4_GET_BLOCKS_CREATE) == 0);
         depth = ext4_block_to_path(inode, iblock, offsets,
                                         &blocks_to_boundary);
 
@@ -963,7 +966,7 @@ static int ext4_get_blocks_handle(handle_t *handle, struct inode *inode,
         }
 
         /* Next simple case - plain lookup or failed read of indirect block */
-        if (!create || err == -EIO)
+        if ((flags & EXT4_GET_BLOCKS_CREATE) == 0 || err == -EIO)
                 goto cleanup;
 
         /*
@@ -997,19 +1000,7 @@ static int ext4_get_blocks_handle(handle_t *handle, struct inode *inode,
         if (!err)
                 err = ext4_splice_branch(handle, inode, iblock,
                                         partial, indirect_blks, count);
-        /*
-         * i_disksize growing is protected by i_data_sem.  Don't forget to
-         * protect it if you're about to implement concurrent
-         * ext4_get_block() -bzzz
-        */
-        if (!err && extend_disksize) {
-                disksize = ((loff_t) iblock + count) << inode->i_blkbits;
-                if (disksize > i_size_read(inode))
-                        disksize = i_size_read(inode);
-                if (disksize > ei->i_disksize)
-                        ei->i_disksize = disksize;
-        }
-        if (err)
+        else 
                 goto cleanup;
 
         set_buffer_new(bh_result);
@@ -1120,8 +1111,23 @@ static void ext4_da_update_reserve_space(struct inode *inode, int used)
                 ext4_discard_preallocations(inode);
 }
 
+static int check_block_validity(struct inode *inode, sector_t logical,
+                                sector_t phys, int len)
+{
+        if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), phys, len)) {
+                ext4_error(inode->i_sb, "check_block_validity",
+                           "inode #%lu logical block %llu mapped to %llu "
+                           "(size %d)", inode->i_ino,
+                           (unsigned long long) logical,
+                           (unsigned long long) phys, len);
+                WARN_ON(1);
+                return -EIO;
+        }
+        return 0;
+}
+
 /*
- * The ext4_get_blocks_wrap() function try to look up the requested blocks,
+ * The ext4_get_blocks() function tries to look up the requested blocks,
  * and returns if the blocks are already mapped.
  *
  * Otherwise it takes the write lock of the i_data_sem and allocate blocks
@@ -1129,7 +1135,7 @@ static void ext4_da_update_reserve_space(struct inode *inode, int used)
  * mapped.
  *
  * If file type is extents based, it will call ext4_ext_get_blocks(),
- * Otherwise, call with ext4_get_blocks_handle() to handle indirect mapping
+ * Otherwise, call with ext4_ind_get_blocks() to handle indirect mapping
  * based files
  *
  * On success, it returns the number of blocks being mapped or allocate.
@@ -1142,9 +1148,9 @@ static void ext4_da_update_reserve_space(struct inode *inode, int used)
  *
  * It returns the error in case of allocation failure.
  */
-int ext4_get_blocks_wrap(handle_t *handle, struct inode *inode, sector_t block,
-                        unsigned int max_blocks, struct buffer_head *bh,
-                        int create, int extend_disksize, int flag)
+int ext4_get_blocks(handle_t *handle, struct inode *inode, sector_t block,
+                    unsigned int max_blocks, struct buffer_head *bh,
+                    int flags)
 {
         int retval;
 
@@ -1152,21 +1158,28 @@ int ext4_get_blocks_wrap(handle_t *handle, struct inode *inode, sector_t block,
         clear_buffer_unwritten(bh);
 
         /*
-         * Try to see if we can get  the block without requesting
-         * for new file system block.
+         * Try to see if we can get the block without requesting a new
+         * file system block.
          */
         down_read((&EXT4_I(inode)->i_data_sem));
         if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL) {
                 retval =  ext4_ext_get_blocks(handle, inode, block, max_blocks,
-                                bh, 0, 0);
+                                bh, 0);
         } else {
-                retval = ext4_get_blocks_handle(handle,
-                                inode, block, max_blocks, bh, 0, 0);
+                retval = ext4_ind_get_blocks(handle, inode, block, max_blocks,
+                                             bh, 0);
         }
         up_read((&EXT4_I(inode)->i_data_sem));
 
+        if (retval > 0 && buffer_mapped(bh)) {
+                int ret = check_block_validity(inode, block, 
+                                               bh->b_blocknr, retval);
+                if (ret != 0)
+                        return ret;
+        }
+
         /* If it is only a block(s) look up */
-        if (!create)
+        if ((flags & EXT4_GET_BLOCKS_CREATE) == 0)
                 return retval;
 
         /*
@@ -1205,7 +1218,7 @@ int ext4_get_blocks_wrap(handle_t *handle, struct inode *inode, sector_t block,
          * let the underlying get_block() function know to
          * avoid double accounting
          */
-        if (flag)
+        if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
                 EXT4_I(inode)->i_delalloc_reserved_flag = 1;
         /*
          * We need to check for EXT4 here because migrate
@@ -1213,10 +1226,10 @@ int ext4_get_blocks_wrap(handle_t *handle, struct inode *inode, sector_t block,
          */
         if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL) {
                 retval =  ext4_ext_get_blocks(handle, inode, block, max_blocks,
-                                bh, create, extend_disksize);
+                                              bh, flags);
         } else {
-                retval = ext4_get_blocks_handle(handle, inode, block,
-                                max_blocks, bh, create, extend_disksize);
+                retval = ext4_ind_get_blocks(handle, inode, block,
+                                             max_blocks, bh, flags);
 
                 if (retval > 0 && buffer_new(bh)) {
                         /*
@@ -1229,18 +1242,23 @@ int ext4_get_blocks_wrap(handle_t *handle, struct inode *inode, sector_t block,
                 }
         }
 
-        if (flag) {
+        if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
                 EXT4_I(inode)->i_delalloc_reserved_flag = 0;
-                /*
-                 * Update reserved blocks/metadata blocks
-                 * after successful block allocation
-                 * which were deferred till now
-                 */
-                if ((retval > 0) && buffer_delay(bh))
-                        ext4_da_update_reserve_space(inode, retval);
-        }
+
+        /*
+         * Update reserved blocks/metadata blocks after successful
+         * block allocation which had been deferred till now.
+         */
+        if ((retval > 0) && (flags & EXT4_GET_BLOCKS_UPDATE_RESERVE_SPACE))
+                ext4_da_update_reserve_space(inode, retval);
 
         up_write((&EXT4_I(inode)->i_data_sem));
+        if (retval > 0 && buffer_mapped(bh)) {
+                int ret = check_block_validity(inode, block, 
+                                               bh->b_blocknr, retval);
+                if (ret != 0)
+                        return ret;
+        }
         return retval;
 }
 
@@ -1268,8 +1286,8 @@ int ext4_get_block(struct inode *inode, sector_t iblock,
                 started = 1;
         }
 
-        ret = ext4_get_blocks_wrap(handle, inode, iblock,
-                                        max_blocks, bh_result, create, 0, 0);
+        ret = ext4_get_blocks(handle, inode, iblock, max_blocks, bh_result,
+                              create ? EXT4_GET_BLOCKS_CREATE : 0);
         if (ret > 0) {
                 bh_result->b_size = (ret << inode->i_blkbits);
                 ret = 0;
@@ -1288,17 +1306,19 @@ struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode,
 {
         struct buffer_head dummy;
         int fatal = 0, err;
+        int flags = 0;
 
         J_ASSERT(handle != NULL || create == 0);
 
         dummy.b_state = 0;
         dummy.b_blocknr = -1000;
         buffer_trace_init(&dummy.b_history);
-        err = ext4_get_blocks_wrap(handle, inode, block, 1,
-                                        &dummy, create, 1, 0);
+        if (create)
+                flags |= EXT4_GET_BLOCKS_CREATE;
+        err = ext4_get_blocks(handle, inode, block, 1, &dummy, flags);
         /*
-         * ext4_get_blocks_handle() returns number of blocks
-         * mapped. 0 in case of a HOLE.
+         * ext4_get_blocks() returns number of blocks mapped. 0 in
+         * case of a HOLE.
          */
         if (err > 0) {
                 if (err > 1)
@@ -1439,7 +1459,7 @@ static int ext4_write_begin(struct file *file, struct address_space *mapping,
                                 struct page **pagep, void **fsdata)
 {
         struct inode *inode = mapping->host;
-        int ret, needed_blocks = ext4_writepage_trans_blocks(inode);
+        int ret, needed_blocks;
         handle_t *handle;
         int retries = 0;
         struct page *page;
@@ -1450,6 +1470,11 @@ static int ext4_write_begin(struct file *file, struct address_space *mapping,
                    "dev %s ino %lu pos %llu len %u flags %u",
                    inode->i_sb->s_id, inode->i_ino,
                    (unsigned long long) pos, len, flags);
+        /*
+         * Reserve one block more for addition to orphan list in case
+         * we allocate blocks but write fails for some reason
+         */
+        needed_blocks = ext4_writepage_trans_blocks(inode) + 1;
         index = pos >> PAGE_CACHE_SHIFT;
         from = pos & (PAGE_CACHE_SIZE - 1);
         to = from + len;
@@ -1483,15 +1508,30 @@ retry:
 
         if (ret) {
                 unlock_page(page);
-                ext4_journal_stop(handle);
                 page_cache_release(page);
                 /*
                  * block_write_begin may have instantiated a few blocks
                  * outside i_size.  Trim these off again. Don't need
                  * i_size_read because we hold i_mutex.
+                 *
+                 * Add inode to orphan list in case we crash before
+                 * truncate finishes
                  */
                 if (pos + len > inode->i_size)
+                        ext4_orphan_add(handle, inode);
+
+                ext4_journal_stop(handle);
+                if (pos + len > inode->i_size) {
                         vmtruncate(inode, inode->i_size);
+                        /* 
+                         * If vmtruncate failed early the inode might
+                         * still be on the orphan list; we need to
+                         * make sure the inode is removed from the
+                         * orphan list in that case.
+                         */
+                        if (inode->i_nlink)
+                                ext4_orphan_del(NULL, inode);
+                }
         }
 
         if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
@@ -1509,6 +1549,52 @@ static int write_end_fn(handle_t *handle, struct buffer_head *bh)
         return ext4_handle_dirty_metadata(handle, NULL, bh);
 }
 
+static int ext4_generic_write_end(struct file *file,
+                                struct address_space *mapping,
+                                loff_t pos, unsigned len, unsigned copied,
+                                struct page *page, void *fsdata)
+{
+        int i_size_changed = 0;
+        struct inode *inode = mapping->host;
+        handle_t *handle = ext4_journal_current_handle();
+
+        copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);
+
+        /*
+         * No need to use i_size_read() here, the i_size
+         * cannot change under us because we hold i_mutex.
+         *
+         * But it's important to update i_size while still holding page lock:
+         * page writeout could otherwise come in and zero beyond i_size.
+         */
+        if (pos + copied > inode->i_size) {
+                i_size_write(inode, pos + copied);
+                i_size_changed = 1;
+        }
+
+        if (pos + copied >  EXT4_I(inode)->i_disksize) {
+                /* We need to mark inode dirty even if
+                 * new_i_size is less that inode->i_size
+                 * bu greater than i_disksize.(hint delalloc)
+                 */
+                ext4_update_i_disksize(inode, (pos + copied));
+                i_size_changed = 1;
+        }
+        unlock_page(page);
+        page_cache_release(page);
+
+        /*
+         * Don't mark the inode dirty under page lock. First, it unnecessarily
+         * makes the holding time of page lock longer. Second, it forces lock
+         * ordering of page lock and transaction start for journaling
+         * filesystems.
+         */
+        if (i_size_changed)
+                ext4_mark_inode_dirty(handle, inode);
+
+        return copied;
+}
+
 /*
  * We need to pick up the new inode size which generic_commit_write gave us
  * `file' can be NULL - eg, when called from page_symlink().
@@ -1532,21 +1618,15 @@ static int ext4_ordered_write_end(struct file *file,
         ret = ext4_jbd2_file_inode(handle, inode);
 
         if (ret == 0) {
-                loff_t new_i_size;
-
-                new_i_size = pos + copied;
-                if (new_i_size > EXT4_I(inode)->i_disksize) {
-                        ext4_update_i_disksize(inode, new_i_size);
-                        /* We need to mark inode dirty even if
-                         * new_i_size is less that inode->i_size
-                         * bu greater than i_disksize.(hint delalloc)
-                         */
-                        ext4_mark_inode_dirty(handle, inode);
-                }
-
-                ret2 = generic_write_end(file, mapping, pos, len, copied,
+                ret2 = ext4_generic_write_end(file, mapping, pos, len, copied,
                                                         page, fsdata);
                 copied = ret2;
+                if (pos + len > inode->i_size)
+                        /* if we have allocated more blocks and copied
+                         * less. We will have blocks allocated outside
+                         * inode->i_size. So truncate them
+                         */
+                        ext4_orphan_add(handle, inode);
                 if (ret2 < 0)
                         ret = ret2;
         }
@@ -1554,6 +1634,18 @@ static int ext4_ordered_write_end(struct file *file,
         if (!ret)
                 ret = ret2;
 
+        if (pos + len > inode->i_size) {
+                vmtruncate(inode, inode->i_size);
+                /* 
+                 * If vmtruncate failed early the inode might still be
+                 * on the orphan list; we need to make sure the inode
+                 * is removed from the orphan list in that case.
+                 */
+                if (inode->i_nlink)
+                        ext4_orphan_del(NULL, inode);
+        }
+
+
         return ret ? ret : copied;
 }
 
@@ -1565,25 +1657,21 @@ static int ext4_writeback_write_end(struct file *file,
         handle_t *handle = ext4_journal_current_handle();
         struct inode *inode = mapping->host;
         int ret = 0, ret2;
-        loff_t new_i_size;
 
         trace_mark(ext4_writeback_write_end,
                    "dev %s ino %lu pos %llu len %u copied %u",
                    inode->i_sb->s_id, inode->i_ino,
                    (unsigned long long) pos, len, copied);
-        new_i_size = pos + copied;
-        if (new_i_size > EXT4_I(inode)->i_disksize) {
-                ext4_update_i_disksize(inode, new_i_size);
-                /* We need to mark inode dirty even if
-                 * new_i_size is less that inode->i_size
-                 * bu greater than i_disksize.(hint delalloc)
-                 */
-                ext4_mark_inode_dirty(handle, inode);
-        }
-
-        ret2 = generic_write_end(file, mapping, pos, len, copied,
+        ret2 = ext4_generic_write_end(file, mapping, pos, len, copied,
                                                         page, fsdata);
         copied = ret2;
+        if (pos + len > inode->i_size)
+                /* if we have allocated more blocks and copied
+                 * less. We will have blocks allocated outside
+                 * inode->i_size. So truncate them
+                 */
+                ext4_orphan_add(handle, inode);
+
         if (ret2 < 0)
                 ret = ret2;
 
@@ -1591,6 +1679,17 @@ static int ext4_writeback_write_end(struct file *file,
         if (!ret)
                 ret = ret2;
 
+        if (pos + len > inode->i_size) {
+                vmtruncate(inode, inode->i_size);
+                /* 
+                 * If vmtruncate failed early the inode might still be
+                 * on the orphan list; we need to make sure the inode
+                 * is removed from the orphan list in that case.
+                 */
+                if (inode->i_nlink)
+                        ext4_orphan_del(NULL, inode);
+        }
+
         return ret ? ret : copied;
 }
 
@@ -1635,10 +1734,27 @@ static int ext4_journalled_write_end(struct file *file,
         }
 
         unlock_page(page);
+        page_cache_release(page);
+        if (pos + len > inode->i_size)
+                /* if we have allocated more blocks and copied
+                 * less. We will have blocks allocated outside
+                 * inode->i_size. So truncate them
+                 */
+                ext4_orphan_add(handle, inode);
+
         ret2 = ext4_journal_stop(handle);
         if (!ret)
                 ret = ret2;
-        page_cache_release(page);
+        if (pos + len > inode->i_size) {
+                vmtruncate(inode, inode->i_size);
+                /* 
+                 * If vmtruncate failed early the inode might still be
+                 * on the orphan list; we need to make sure the inode
+                 * is removed from the orphan list in that case.
+                 */
+                if (inode->i_nlink)
+                        ext4_orphan_del(NULL, inode);
+        }
 
         return ret ? ret : copied;
 }
@@ -1852,7 +1968,7 @@ static int mpage_da_submit_io(struct mpage_da_data *mpd)
  * @logical - first logical block to start assignment with
  *
  * the function goes through all passed space and put actual disk
- * block numbers into buffer heads, dropping BH_Delay
+ * block numbers into buffer heads, dropping BH_Delay and BH_Unwritten
  */
 static void mpage_put_bnr_to_bhs(struct mpage_da_data *mpd, sector_t logical,
                                  struct buffer_head *exbh)
@@ -1902,16 +2018,24 @@ static void mpage_put_bnr_to_bhs(struct mpage_da_data *mpd, sector_t logical,
                         do {
                                 if (cur_logical >= logical + blocks)
                                         break;
-                                if (buffer_delay(bh)) {
-                                        bh->b_blocknr = pblock;
-                                        clear_buffer_delay(bh);
-                                        bh->b_bdev = inode->i_sb->s_bdev;
-                                } else if (buffer_unwritten(bh)) {
-                                        bh->b_blocknr = pblock;
-                                        clear_buffer_unwritten(bh);
-                                        set_buffer_mapped(bh);
-                                        set_buffer_new(bh);
-                                        bh->b_bdev = inode->i_sb->s_bdev;
+
+                                if (buffer_delay(bh) ||
+                                                buffer_unwritten(bh)) {
+
+                                        BUG_ON(bh->b_bdev != inode->i_sb->s_bdev);
+
+                                        if (buffer_delay(bh)) {
+                                                clear_buffer_delay(bh);
+                                                bh->b_blocknr = pblock;
+                                        } else {
+                                                /*
+                                                 * unwritten already should have
+                                                 * blocknr assigned. Verify that
+                                                 */
+                                                clear_buffer_unwritten(bh);
+                                                BUG_ON(bh->b_blocknr != pblock);
+                                        }
+
                                 } else if (buffer_mapped(bh))
                                         BUG_ON(bh->b_blocknr != pblock);
 
@@ -1990,51 +2114,6 @@ static void ext4_print_free_blocks(struct inode *inode)
         return;
 }
 
-#define         EXT4_DELALLOC_RSVED     1
-static int ext4_da_get_block_write(struct inode *inode, sector_t iblock,
-                                   struct buffer_head *bh_result, int create)
-{
-        int ret;
-        unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
-        loff_t disksize = EXT4_I(inode)->i_disksize;
-        handle_t *handle = NULL;
-
-        handle = ext4_journal_current_handle();
-        BUG_ON(!handle);
-        ret = ext4_get_blocks_wrap(handle, inode, iblock, max_blocks,
-                                   bh_result, create, 0, EXT4_DELALLOC_RSVED);
-        if (ret <= 0)
-                return ret;
-
-        bh_result->b_size = (ret << inode->i_blkbits);
-
-        if (ext4_should_order_data(inode)) {
-                int retval;
-                retval = ext4_jbd2_file_inode(handle, inode);
-                if (retval)
-                        /*
-                         * Failed to add inode for ordered mode. Don't
-                         * update file size
-                         */
-                        return retval;
-        }
-
-        /*
-         * Update on-disk size along with block allocation we don't
-         * use 'extend_disksize' as size may change within already
-         * allocated block -bzzz
-         */
-        disksize = ((loff_t) iblock + ret) << inode->i_blkbits;
-        if (disksize > i_size_read(inode))
-                disksize = i_size_read(inode);
-        if (disksize > EXT4_I(inode)->i_disksize) {
-                ext4_update_i_disksize(inode, disksize);
-                ret = ext4_mark_inode_dirty(handle, inode);
-                return ret;
-        }
-        return 0;
-}
-
 /*
  * mpage_da_map_blocks - go through given space
  *
@@ -2045,29 +2124,57 @@ static int ext4_da_get_block_write(struct inode *inode, sector_t iblock,
  */
 static int mpage_da_map_blocks(struct mpage_da_data *mpd)
 {
-        int err = 0;
+        int err, blks, get_blocks_flags;
         struct buffer_head new;
-        sector_t next;
+        sector_t next = mpd->b_blocknr;
+        unsigned max_blocks = mpd->b_size >> mpd->inode->i_blkbits;
+        loff_t disksize = EXT4_I(mpd->inode)->i_disksize;
+        handle_t *handle = NULL;
 
         /*
          * We consider only non-mapped and non-allocated blocks
          */
         if ((mpd->b_state  & (1 << BH_Mapped)) &&
-            !(mpd->b_state & (1 << BH_Delay)))
+                !(mpd->b_state & (1 << BH_Delay)) &&
+                !(mpd->b_state & (1 << BH_Unwritten)))
                 return 0;
-        new.b_state = mpd->b_state;
-        new.b_blocknr = 0;
-        new.b_size = mpd->b_size;
-        next = mpd->b_blocknr;
+
         /*
-         * If we didn't accumulate anything
-         * to write simply return
+         * If we didn't accumulate anything to write simply return
          */
-        if (!new.b_size)
+        if (!mpd->b_size)
                 return 0;
 
-        err = ext4_da_get_block_write(mpd->inode, next, &new, 1);
-        if (err) {
+        handle = ext4_journal_current_handle();
+        BUG_ON(!handle);
+
+        /*
+         * Call ext4_get_blocks() to allocate any delayed allocation
+         * blocks, or to convert an uninitialized extent to be
+         * initialized (in the case where we have written into
+         * one or more preallocated blocks).
+         *
+         * We pass in the magic EXT4_GET_BLOCKS_DELALLOC_RESERVE to
+         * indicate that we are on the delayed allocation path.  This
+         * affects functions in many different parts of the allocation
+         * call path.  This flag exists primarily because we don't
+         * want to change *many* call functions, so ext4_get_blocks()
+         * will set the magic i_delalloc_reserved_flag once the
+         * inode's allocation semaphore is taken.
+         *
+         * If the blocks in questions were delalloc blocks, set
+         * EXT4_GET_BLOCKS_DELALLOC_RESERVE so the delalloc accounting
+         * variables are updated after the blocks have been allocated.
+         */
+        new.b_state = 0;
+        get_blocks_flags = (EXT4_GET_BLOCKS_CREATE |
+                            EXT4_GET_BLOCKS_DELALLOC_RESERVE);
+        if (mpd->b_state & (1 << BH_Delay))
+                get_blocks_flags |= EXT4_GET_BLOCKS_UPDATE_RESERVE_SPACE;
+        blks = ext4_get_blocks(handle, mpd->inode, next, max_blocks,
+                               &new, get_blocks_flags);
+        if (blks < 0) {
+                err = blks;
                 /*
                  * If get block returns with error we simply
                  * return. Later writepage will redirty the page and
@@ -2100,12 +2207,14 @@ static int mpage_da_map_blocks(struct mpage_da_data *mpd)
                 if (err == -ENOSPC) {
                         ext4_print_free_blocks(mpd->inode);
                 }
-                /* invlaidate all the pages */
+                /* invalidate all the pages */
                 ext4_da_block_invalidatepages(mpd, next,
                                 mpd->b_size >> mpd->inode->i_blkbits);
                 return err;
         }
-        BUG_ON(new.b_size == 0);
+        BUG_ON(blks == 0);
+
+        new.b_size = (blks << mpd->inode->i_blkbits);
 
         if (buffer_new(&new))
                 __unmap_underlying_blocks(mpd->inode, &new);
@@ -2118,6 +2227,23 @@ static int mpage_da_map_blocks(struct mpage_da_data *mpd)
             (mpd->b_state & (1 << BH_Unwritten)))
                 mpage_put_bnr_to_bhs(mpd, next, &new);
 
+        if (ext4_should_order_data(mpd->inode)) {
+                err = ext4_jbd2_file_inode(handle, mpd->inode);
+                if (err)
+                        return err;
+        }
+
+        /*
+         * Update on-disk size along with block allocation.
+         */
+        disksize = ((loff_t) next + blks) << mpd->inode->i_blkbits;
+        if (disksize > i_size_read(mpd->inode))
+                disksize = i_size_read(mpd->inode);
+        if (disksize > EXT4_I(mpd->inode)->i_disksize) {
+                ext4_update_i_disksize(mpd->inode, disksize);
+                return ext4_mark_inode_dirty(handle, mpd->inode);
+        }
+
         return 0;
 }
 
@@ -2192,6 +2318,17 @@ flush_it:
         return;
 }
 
+static int ext4_bh_unmapped_or_delay(handle_t *handle, struct buffer_head *bh)
+{
+        /*
+         * unmapped buffer is possible for holes.
+         * delay buffer is possible with delayed allocation.
+         * We also need to consider unwritten buffer as unmapped.
+         */
+        return (!buffer_mapped(bh) || buffer_delay(bh) ||
+                                buffer_unwritten(bh)) && buffer_dirty(bh);
+}
+
 /*
  * __mpage_da_writepage - finds extent of pages and blocks
  *
@@ -2276,8 +2413,7 @@ static int __mpage_da_writepage(struct page *page,
                          * Otherwise we won't make progress
                          * with the page in ext4_da_writepage
                          */
-                        if (buffer_dirty(bh) &&
-                            (!buffer_mapped(bh) || buffer_delay(bh))) {
+                        if (ext4_bh_unmapped_or_delay(NULL, bh)) {
                                 mpage_add_bh_to_extent(mpd, logical,
                                                        bh->b_size,
                                                        bh->b_state);
@@ -2303,8 +2439,16 @@ static int __mpage_da_writepage(struct page *page,
 }
 
 /*
- * this is a special callback for ->write_begin() only
- * it's intention is to return mapped block or reserve space
+ * This is a special get_blocks_t callback which is used by
+ * ext4_da_write_begin().  It will either return mapped block or
+ * reserve space for a single block.
+ *
+ * For delayed buffer_head we have BH_Mapped, BH_New, BH_Delay set.
+ * We also have b_blocknr = -1 and b_bdev initialized properly
+ *
+ * For unwritten buffer_head we have BH_Mapped, BH_New, BH_Unwritten set.
+ * We also have b_blocknr = physicalblock mapping unwritten extent and b_bdev
+ * initialized properly.
  */
 static int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
                                   struct buffer_head *bh_result, int create)
@@ -2323,7 +2467,7 @@ static int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
          * preallocated blocks are unmapped but should treated
          * the same as allocated blocks.
          */
-        ret = ext4_get_blocks_wrap(NULL, inode, iblock, 1,  bh_result, 0, 0, 0);
+        ret = ext4_get_blocks(NULL, inode, iblock, 1,  bh_result, 0);
         if ((ret == 0) && !buffer_delay(bh_result)) {
                 /* the block isn't (pre)allocated yet, let's reserve space */
                 /*
@@ -2340,40 +2484,53 @@ static int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
                 set_buffer_delay(bh_result);
         } else if (ret > 0) {
                 bh_result->b_size = (ret << inode->i_blkbits);
-                /*
-                 * With sub-block writes into unwritten extents
-                 * we also need to mark the buffer as new so that
-                 * the unwritten parts of the buffer gets correctly zeroed.
-                 */
-                if (buffer_unwritten(bh_result))
+                if (buffer_unwritten(bh_result)) {
+                        /* A delayed write to unwritten bh should
+                         * be marked new and mapped.  Mapped ensures
+                         * that we don't do get_block multiple times
+                         * when we write to the same offset and new
+                         * ensures that we do proper zero out for
+                         * partial write.
+                         */
                         set_buffer_new(bh_result);
+                        set_buffer_mapped(bh_result);
+                }
                 ret = 0;
         }
 
         return ret;
 }
 
-static int ext4_bh_unmapped_or_delay(handle_t *handle, struct buffer_head *bh)
-{
-        /*
-         * unmapped buffer is possible for holes.
-         * delay buffer is possible with delayed allocation
-         */
-        return ((!buffer_mapped(bh) || buffer_delay(bh)) && buffer_dirty(bh));
-}
-
-static int ext4_normal_get_block_write(struct inode *inode, sector_t iblock,
+/*
+ * This function is used as a standard get_block_t calback function
+ * when there is no desire to allocate any blocks.  It is used as a
+ * callback function for block_prepare_write(), nobh_writepage(), and
+ * block_write_full_page().  These functions should only try to map a
+ * single block at a time.
+ *
+ * Since this function doesn't do block allocations even if the caller
+ * requests it by passing in create=1, it is critically important that
+ * any caller checks to make sure that any buffer heads are returned
+ * by this function are either all already mapped or marked for
+ * delayed allocation before calling nobh_writepage() or
+ * block_write_full_page().  Otherwise, b_blocknr could be left
+ * unitialized, and the page write functions will be taken by
+ * surprise.
+ */
+static int noalloc_get_block_write(struct inode *inode, sector_t iblock,
                                    struct buffer_head *bh_result, int create)
 {
         int ret = 0;
         unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
 
+        BUG_ON(bh_result->b_size != inode->i_sb->s_blocksize);
+
         /*
          * we don't want to do block allocation in writepage
          * so call get_block_wrap with create = 0
          */
-        ret = ext4_get_blocks_wrap(NULL, inode, iblock, max_blocks,
-                                   bh_result, 0, 0, 0);
+        ret = ext4_get_blocks(NULL, inode, iblock, max_blocks, bh_result, 0);
+        BUG_ON(create && ret == 0);
         if (ret > 0) {
                 bh_result->b_size = (ret << inode->i_blkbits);
                 ret = 0;
@@ -2382,10 +2539,11 @@ static int ext4_normal_get_block_write(struct inode *inode, sector_t iblock,
 }
 
 /*
- * get called vi ext4_da_writepages after taking page lock (have journal handle)
- * get called via journal_submit_inode_data_buffers (no journal handle)
- * get called via shrink_page_list via pdflush (no journal handle)
- * or grab_page_cache when doing write_begin (have journal handle)
+ * This function can get called via...
+ *   - ext4_da_writepages after taking page lock (have journal handle)
+ *   - journal_submit_inode_data_buffers (no journal handle)
+ *   - shrink_page_list via pdflush (no journal handle)
+ *   - grab_page_cache when doing write_begin (have journal handle)
  */
 static int ext4_da_writepage(struct page *page,
                                 struct writeback_control *wbc)
@@ -2436,7 +2594,7 @@ static int ext4_da_writepage(struct page *page,
                  * do block allocation here.
                  */
                 ret = block_prepare_write(page, 0, PAGE_CACHE_SIZE,
-                                                ext4_normal_get_block_write);
+                                          noalloc_get_block_write);
                 if (!ret) {
                         page_bufs = page_buffers(page);
                         /* check whether all are mapped and non delay */
@@ -2461,11 +2619,10 @@ static int ext4_da_writepage(struct page *page,
         }
 
         if (test_opt(inode->i_sb, NOBH) && ext4_should_writeback_data(inode))
-                ret = nobh_writepage(page, ext4_normal_get_block_write, wbc);
+                ret = nobh_writepage(page, noalloc_get_block_write, wbc);
         else
-                ret = block_write_full_page(page,
-                                                ext4_normal_get_block_write,
-                                                wbc);
+                ret = block_write_full_page(page, noalloc_get_block_write,
+                                            wbc);
 
         return ret;
 }
@@ -2777,7 +2934,7 @@ retry:
         *pagep = page;
 
         ret = block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
-                                                        ext4_da_get_block_prep);
+                                ext4_da_get_block_prep);
         if (ret < 0) {
                 unlock_page(page);
                 ext4_journal_stop(handle);
@@ -2815,7 +2972,7 @@ static int ext4_da_should_update_i_disksize(struct page *page,
         for (i = 0; i < idx; i++)
                 bh = bh->b_this_page;
 
-        if (!buffer_mapped(bh) || (buffer_delay(bh)))
+        if (!buffer_mapped(bh) || (buffer_delay(bh)) || buffer_unwritten(bh))
                 return 0;
         return 1;
 }
@@ -3085,12 +3242,10 @@ static int __ext4_normal_writepage(struct page *page,
         struct inode *inode = page->mapping->host;
 
         if (test_opt(inode->i_sb, NOBH))
-                return nobh_writepage(page,
-                                        ext4_normal_get_block_write, wbc);
+                return nobh_writepage(page, noalloc_get_block_write, wbc);
         else
-                return block_write_full_page(page,
-                                                ext4_normal_get_block_write,
-                                                wbc);
+                return block_write_full_page(page, noalloc_get_block_write,
+                                             wbc);
 }
 
 static int ext4_normal_writepage(struct page *page,
@@ -3142,7 +3297,7 @@ static int __ext4_journalled_writepage(struct page *page,
         int err;
 
         ret = block_prepare_write(page, 0, PAGE_CACHE_SIZE,
-                                        ext4_normal_get_block_write);
+                                  noalloc_get_block_write);
         if (ret != 0)
                 goto out_unlock;
 
@@ -3227,9 +3382,8 @@ static int ext4_journalled_writepage(struct page *page,
                  * really know unless we go poke around in the buffer_heads.
                  * But block_write_full_page will do the right thing.
                  */
-                return block_write_full_page(page,
-                                                ext4_normal_get_block_write,
-                                                wbc);
+                return block_write_full_page(page, noalloc_get_block_write,
+                                             wbc);
         }
 no_write:
         redirty_page_for_writepage(wbc, page);
@@ -3973,7 +4127,8 @@ void ext4_truncate(struct inode *inode)
         if (!ext4_can_truncate(inode))
                 return;
 
-        if (inode->i_size == 0 && !test_opt(inode->i_sb, NO_AUTO_DA_ALLOC))
+        if (ei->i_disksize && inode->i_size == 0 &&
+            !test_opt(inode->i_sb, NO_AUTO_DA_ALLOC))
                 ei->i_state |= EXT4_STATE_DA_ALLOC_CLOSE;
 
         if (EXT4_I(inode)->i_flags & EXT4_EXTENTS_FL) {
@@ -4715,25 +4870,6 @@ int ext4_write_inode(struct inode *inode, int wait)
         return ext4_force_commit(inode->i_sb);
 }
 
-int __ext4_write_dirty_metadata(struct inode *inode, struct buffer_head *bh)
-{
-        int err = 0;
-
-        mark_buffer_dirty(bh);
-        if (inode && inode_needs_sync(inode)) {
-                sync_dirty_buffer(bh);
-                if (buffer_req(bh) && !buffer_uptodate(bh)) {
-                        ext4_error(inode->i_sb, __func__,
-                                   "IO error syncing inode, "
-                                   "inode=%lu, block=%llu",
-                                   inode->i_ino,
-                                   (unsigned long long)bh->b_blocknr);
-                        err = -EIO;
-                }
-        }
-        return err;
-}
-
 /*
  * ext4_setattr()
  *
@@ -4930,7 +5066,8 @@ static int ext4_index_trans_blocks(struct inode *inode, int nrblocks, int chunk)
  */
 int ext4_meta_trans_blocks(struct inode *inode, int nrblocks, int chunk)
 {
-        int groups, gdpblocks;
+        ext4_group_t groups, ngroups = ext4_get_groups_count(inode->i_sb);
+        int gdpblocks;
         int idxblocks;
         int ret = 0;
 
@@ -4957,8 +5094,8 @@ int ext4_meta_trans_blocks(struct inode *inode, int nrblocks, int chunk)
                 groups += nrblocks;
 
         gdpblocks = groups;
-        if (groups > EXT4_SB(inode->i_sb)->s_groups_count)
-                groups = EXT4_SB(inode->i_sb)->s_groups_count;
+        if (groups > ngroups)
+                groups = ngroups;
         if (groups > EXT4_SB(inode->i_sb)->s_gdb_count)
                 gdpblocks = EXT4_SB(inode->i_sb)->s_gdb_count;
 
@@ -4998,7 +5135,7 @@ int ext4_writepage_trans_blocks(struct inode *inode)
  * Calculate the journal credits for a chunk of data modification.
  *
  * This is called from DIO, fallocate or whoever calling
- * ext4_get_blocks_wrap() to map/allocate a chunk of contigous disk blocks.
+ * ext4_get_blocks() to map/allocate a chunk of contigous disk blocks.
  *
  * journal buffers for data blocks are not included here, as DIO
  * and fallocate do no need to journal data buffers.
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index f871677a7984..ed8482e22c0e 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -372,24 +372,12 @@ static inline void mb_set_bit(int bit, void *addr)
         ext4_set_bit(bit, addr);
 }
 
-static inline void mb_set_bit_atomic(spinlock_t *lock, int bit, void *addr)
-{
-        addr = mb_correct_addr_and_bit(&bit, addr);
-        ext4_set_bit_atomic(lock, bit, addr);
-}
-
 static inline void mb_clear_bit(int bit, void *addr)
 {
         addr = mb_correct_addr_and_bit(&bit, addr);
         ext4_clear_bit(bit, addr);
 }
 
-static inline void mb_clear_bit_atomic(spinlock_t *lock, int bit, void *addr)
-{
-        addr = mb_correct_addr_and_bit(&bit, addr);
-        ext4_clear_bit_atomic(lock, bit, addr);
-}
-
 static inline int mb_find_next_zero_bit(void *addr, int max, int start)
 {
         int fix = 0, ret, tmpmax;
@@ -448,7 +436,7 @@ static void mb_free_blocks_double(struct inode *inode, struct ext4_buddy *e4b,
 
         if (unlikely(e4b->bd_info->bb_bitmap == NULL))
                 return;
-        BUG_ON(!ext4_is_group_locked(sb, e4b->bd_group));
+        assert_spin_locked(ext4_group_lock_ptr(sb, e4b->bd_group));
         for (i = 0; i < count; i++) {
                 if (!mb_test_bit(first + i, e4b->bd_info->bb_bitmap)) {
                         ext4_fsblk_t blocknr;
@@ -472,7 +460,7 @@ static void mb_mark_used_double(struct ext4_buddy *e4b, int first, int count)
 
         if (unlikely(e4b->bd_info->bb_bitmap == NULL))
                 return;
-        BUG_ON(!ext4_is_group_locked(e4b->bd_sb, e4b->bd_group));
+        assert_spin_locked(ext4_group_lock_ptr(e4b->bd_sb, e4b->bd_group));
         for (i = 0; i < count; i++) {
                 BUG_ON(mb_test_bit(first + i, e4b->bd_info->bb_bitmap));
                 mb_set_bit(first + i, e4b->bd_info->bb_bitmap);
@@ -739,6 +727,7 @@ static void ext4_mb_generate_buddy(struct super_block *sb,
 
 static int ext4_mb_init_cache(struct page *page, char *incore)
 {
+        ext4_group_t ngroups;
         int blocksize;
         int blocks_per_page;
         int groups_per_page;
@@ -757,6 +746,7 @@ static int ext4_mb_init_cache(struct page *page, char *incore)
 
         inode = page->mapping->host;
         sb = inode->i_sb;
+        ngroups = ext4_get_groups_count(sb);
         blocksize = 1 << inode->i_blkbits;
         blocks_per_page = PAGE_CACHE_SIZE / blocksize;
 
@@ -780,7 +770,7 @@ static int ext4_mb_init_cache(struct page *page, char *incore)
         for (i = 0; i < groups_per_page; i++) {
                 struct ext4_group_desc *desc;
 
-                if (first_group + i >= EXT4_SB(sb)->s_groups_count)
+                if (first_group + i >= ngroups)
                         break;
 
                 err = -EIO;
@@ -801,17 +791,17 @@ static int ext4_mb_init_cache(struct page *page, char *incore)
                         unlock_buffer(bh[i]);
                         continue;
                 }
-                spin_lock(sb_bgl_lock(EXT4_SB(sb), first_group + i));
+                ext4_lock_group(sb, first_group + i);
                 if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
                         ext4_init_block_bitmap(sb, bh[i],
                                                 first_group + i, desc);
                         set_bitmap_uptodate(bh[i]);
                         set_buffer_uptodate(bh[i]);
-                        spin_unlock(sb_bgl_lock(EXT4_SB(sb), first_group + i));
+                        ext4_unlock_group(sb, first_group + i);
                         unlock_buffer(bh[i]);
                         continue;
                 }
-                spin_unlock(sb_bgl_lock(EXT4_SB(sb), first_group + i));
+                ext4_unlock_group(sb, first_group + i);
                 if (buffer_uptodate(bh[i])) {
                         /*
                          * if not uninit if bh is uptodate,
@@ -852,7 +842,7 @@ static int ext4_mb_init_cache(struct page *page, char *incore)
                 struct ext4_group_info *grinfo;
 
                 group = (first_block + i) >> 1;
-                if (group >= EXT4_SB(sb)->s_groups_count)
+                if (group >= ngroups)
                         break;
 
                 /*
@@ -1078,7 +1068,7 @@ static int mb_find_order_for_block(struct ext4_buddy *e4b, int block)
         return 0;
 }
 
-static void mb_clear_bits(spinlock_t *lock, void *bm, int cur, int len)
+static void mb_clear_bits(void *bm, int cur, int len)
 {
         __u32 *addr;
 
@@ -1091,15 +1081,12 @@ static void mb_clear_bits(spinlock_t *lock, void *bm, int cur, int len)
                         cur += 32;
                         continue;
                 }
-                if (lock)
-                        mb_clear_bit_atomic(lock, cur, bm);
-                else
-                        mb_clear_bit(cur, bm);
+                mb_clear_bit(cur, bm);
                 cur++;
         }
 }
 
-static void mb_set_bits(spinlock_t *lock, void *bm, int cur, int len)
+static void mb_set_bits(void *bm, int cur, int len)
 {
         __u32 *addr;
 
@@ -1112,10 +1099,7 @@ static void mb_set_bits(spinlock_t *lock, void *bm, int cur, int len)
                         cur += 32;
                         continue;
                 }
-                if (lock)
-                        mb_set_bit_atomic(lock, cur, bm);
-                else
-                        mb_set_bit(cur, bm);
+                mb_set_bit(cur, bm);
                 cur++;
         }
 }
@@ -1131,7 +1115,7 @@ static void mb_free_blocks(struct inode *inode, struct ext4_buddy *e4b,
         struct super_block *sb = e4b->bd_sb;
 
         BUG_ON(first + count > (sb->s_blocksize << 3));
-        BUG_ON(!ext4_is_group_locked(sb, e4b->bd_group));
+        assert_spin_locked(ext4_group_lock_ptr(sb, e4b->bd_group));
         mb_check_buddy(e4b);
         mb_free_blocks_double(inode, e4b, first, count);
 
@@ -1212,7 +1196,7 @@ static int mb_find_extent(struct ext4_buddy *e4b, int order, int block,
         int ord;
         void *buddy;
 
-        BUG_ON(!ext4_is_group_locked(e4b->bd_sb, e4b->bd_group));
+        assert_spin_locked(ext4_group_lock_ptr(e4b->bd_sb, e4b->bd_group));
         BUG_ON(ex == NULL);
 
         buddy = mb_find_buddy(e4b, order, &max);
@@ -1276,7 +1260,7 @@ static int mb_mark_used(struct ext4_buddy *e4b, struct ext4_free_extent *ex)
 
         BUG_ON(start + len > (e4b->bd_sb->s_blocksize << 3));
         BUG_ON(e4b->bd_group != ex->fe_group);
-        BUG_ON(!ext4_is_group_locked(e4b->bd_sb, e4b->bd_group));
+        assert_spin_locked(ext4_group_lock_ptr(e4b->bd_sb, e4b->bd_group));
         mb_check_buddy(e4b);
         mb_mark_used_double(e4b, start, len);
 
@@ -1330,8 +1314,7 @@ static int mb_mark_used(struct ext4_buddy *e4b, struct ext4_free_extent *ex)
                 e4b->bd_info->bb_counters[ord]++;
         }
 
-        mb_set_bits(sb_bgl_lock(EXT4_SB(e4b->bd_sb), ex->fe_group),
-                        EXT4_MB_BITMAP(e4b), ex->fe_start, len0);
+        mb_set_bits(EXT4_MB_BITMAP(e4b), ex->fe_start, len0);
         mb_check_buddy(e4b);
 
         return ret;
@@ -1726,7 +1709,6 @@ static int ext4_mb_good_group(struct ext4_allocation_context *ac,
         unsigned free, fragments;
         unsigned i, bits;
         int flex_size = ext4_flex_bg_size(EXT4_SB(ac->ac_sb));
-        struct ext4_group_desc *desc;
         struct ext4_group_info *grp = ext4_get_group_info(ac->ac_sb, group);
 
         BUG_ON(cr < 0 || cr >= 4);
@@ -1742,10 +1724,6 @@ static int ext4_mb_good_group(struct ext4_allocation_context *ac,
         switch (cr) {
         case 0:
                 BUG_ON(ac->ac_2order == 0);
-                /* If this group is uninitialized, skip it initially */
-                desc = ext4_get_group_desc(ac->ac_sb, group, NULL);
-                if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT))
-                        return 0;
 
                 /* Avoid using the first bg of a flexgroup for data files */
                 if ((ac->ac_flags & EXT4_MB_HINT_DATA) &&
@@ -1788,6 +1766,7 @@ int ext4_mb_get_buddy_cache_lock(struct super_block *sb, ext4_group_t group)
         int block, pnum;
         int blocks_per_page;
         int groups_per_page;
+        ext4_group_t ngroups = ext4_get_groups_count(sb);
         ext4_group_t first_group;
         struct ext4_group_info *grp;
 
@@ -1807,7 +1786,7 @@ int ext4_mb_get_buddy_cache_lock(struct super_block *sb, ext4_group_t group)
         /* read all groups the page covers into the cache */
         for (i = 0; i < groups_per_page; i++) {
 
-                if ((first_group + i) >= EXT4_SB(sb)->s_groups_count)
+                if ((first_group + i) >= ngroups)
                         break;
                 grp = ext4_get_group_info(sb, first_group + i);
                 /* take all groups write allocation
@@ -1945,8 +1924,7 @@ err:
 static noinline_for_stack int
 ext4_mb_regular_allocator(struct ext4_allocation_context *ac)
 {
-        ext4_group_t group;
-        ext4_group_t i;
+        ext4_group_t ngroups, group, i;
         int cr;
         int err = 0;
         int bsbits;
@@ -1957,6 +1935,7 @@ ext4_mb_regular_allocator(struct ext4_allocation_context *ac)
 
         sb = ac->ac_sb;
         sbi = EXT4_SB(sb);
+        ngroups = ext4_get_groups_count(sb);
         BUG_ON(ac->ac_status == AC_STATUS_FOUND);
 
         /* first, try the goal */
@@ -2017,11 +1996,11 @@ repeat:
                  */
                 group = ac->ac_g_ex.fe_group;
 
-                for (i = 0; i < EXT4_SB(sb)->s_groups_count; group++, i++) {
+                for (i = 0; i < ngroups; group++, i++) {
                         struct ext4_group_info *grp;
                         struct ext4_group_desc *desc;
 
-                        if (group == EXT4_SB(sb)->s_groups_count)
+                        if (group == ngroups)
                                 group = 0;
 
                         /* quick check to skip empty groups */
@@ -2064,9 +2043,7 @@ repeat:
 
                         ac->ac_groups_scanned++;
                         desc = ext4_get_group_desc(sb, group, NULL);
-                        if (cr == 0 || (desc->bg_flags &
-                                        cpu_to_le16(EXT4_BG_BLOCK_UNINIT) &&
-                                        ac->ac_2order != 0))
+                        if (cr == 0)
                                 ext4_mb_simple_scan_group(ac, &e4b);
                         else if (cr == 1 &&
                                         ac->ac_g_ex.fe_len == sbi->s_stripe)
@@ -2315,12 +2292,10 @@ static struct file_operations ext4_mb_seq_history_fops = {
 static void *ext4_mb_seq_groups_start(struct seq_file *seq, loff_t *pos)
 {
         struct super_block *sb = seq->private;
-        struct ext4_sb_info *sbi = EXT4_SB(sb);
         ext4_group_t group;
 
-        if (*pos < 0 || *pos >= sbi->s_groups_count)
+        if (*pos < 0 || *pos >= ext4_get_groups_count(sb))
                 return NULL;
-
         group = *pos + 1;
         return (void *) ((unsigned long) group);
 }
@@ -2328,11 +2303,10 @@ static void *ext4_mb_seq_groups_start(struct seq_file *seq, loff_t *pos)
 static void *ext4_mb_seq_groups_next(struct seq_file *seq, void *v, loff_t *pos)
 {
         struct super_block *sb = seq->private;
-        struct ext4_sb_info *sbi = EXT4_SB(sb);
         ext4_group_t group;
 
         ++*pos;
-        if (*pos < 0 || *pos >= sbi->s_groups_count)
+        if (*pos < 0 || *pos >= ext4_get_groups_count(sb))
                 return NULL;
         group = *pos + 1;
         return (void *) ((unsigned long) group);
@@ -2420,7 +2394,8 @@ static void ext4_mb_history_release(struct super_block *sb)
 
         if (sbi->s_proc != NULL) {
                 remove_proc_entry("mb_groups", sbi->s_proc);
-                remove_proc_entry("mb_history", sbi->s_proc);
+                if (sbi->s_mb_history_max)
+                        remove_proc_entry("mb_history", sbi->s_proc);
         }
         kfree(sbi->s_mb_history);
 }
@@ -2431,17 +2406,17 @@ static void ext4_mb_history_init(struct super_block *sb)
         int i;
 
         if (sbi->s_proc != NULL) {
-                proc_create_data("mb_history", S_IRUGO, sbi->s_proc,
-                                 &ext4_mb_seq_history_fops, sb);
+                if (sbi->s_mb_history_max)
+                        proc_create_data("mb_history", S_IRUGO, sbi->s_proc,
+                                         &ext4_mb_seq_history_fops, sb);
                 proc_create_data("mb_groups", S_IRUGO, sbi->s_proc,
                                  &ext4_mb_seq_groups_fops, sb);
         }
 
-        sbi->s_mb_history_max = 1000;
         sbi->s_mb_history_cur = 0;
         spin_lock_init(&sbi->s_mb_history_lock);
         i = sbi->s_mb_history_max * sizeof(struct ext4_mb_history);
-        sbi->s_mb_history = kzalloc(i, GFP_KERNEL);
+        sbi->s_mb_history = i ? kzalloc(i, GFP_KERNEL) : NULL;
         /* if we can't allocate history, then we simple won't use it */
 }
 
@@ -2451,7 +2426,7 @@ ext4_mb_store_history(struct ext4_allocation_context *ac)
         struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
         struct ext4_mb_history h;
 
-        if (unlikely(sbi->s_mb_history == NULL))
+        if (sbi->s_mb_history == NULL)
                 return;
 
         if (!(ac->ac_op & sbi->s_mb_history_filter))
@@ -2587,6 +2562,7 @@ void ext4_mb_update_group_info(struct ext4_group_info *grp, ext4_grpblk_t add)
 
 static int ext4_mb_init_backend(struct super_block *sb)
 {
+        ext4_group_t ngroups = ext4_get_groups_count(sb);
         ext4_group_t i;
         int metalen;
         struct ext4_sb_info *sbi = EXT4_SB(sb);
@@ -2598,7 +2574,7 @@ static int ext4_mb_init_backend(struct super_block *sb)
         struct ext4_group_desc *desc;
 
         /* This is the number of blocks used by GDT */
-        num_meta_group_infos = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) -
+        num_meta_group_infos = (ngroups + EXT4_DESC_PER_BLOCK(sb) -
                                 1) >> EXT4_DESC_PER_BLOCK_BITS(sb);
 
         /*
@@ -2644,7 +2620,7 @@ static int ext4_mb_init_backend(struct super_block *sb)
         for (i = 0; i < num_meta_group_infos; i++) {
                 if ((i + 1) == num_meta_group_infos)
                         metalen = sizeof(*meta_group_info) *
-                                (sbi->s_groups_count -
+                                (ngroups -
                                         (i << EXT4_DESC_PER_BLOCK_BITS(sb)));
                 meta_group_info = kmalloc(metalen, GFP_KERNEL);
                 if (meta_group_info == NULL) {
@@ -2655,7 +2631,7 @@ static int ext4_mb_init_backend(struct super_block *sb)
                 sbi->s_group_info[i] = meta_group_info;
         }
 
-        for (i = 0; i < sbi->s_groups_count; i++) {
+        for (i = 0; i < ngroups; i++) {
                 desc = ext4_get_group_desc(sb, i, NULL);
                 if (desc == NULL) {
                         printk(KERN_ERR
@@ -2761,7 +2737,7 @@ int ext4_mb_init(struct super_block *sb, int needs_recovery)
         return 0;
 }
 
-/* need to called with ext4 group lock (ext4_lock_group) */
+/* need to called with the ext4 group lock held */
 static void ext4_mb_cleanup_pa(struct ext4_group_info *grp)
 {
         struct ext4_prealloc_space *pa;
@@ -2781,13 +2757,14 @@ static void ext4_mb_cleanup_pa(struct ext4_group_info *grp)
 
 int ext4_mb_release(struct super_block *sb)
 {
+        ext4_group_t ngroups = ext4_get_groups_count(sb);
         ext4_group_t i;
         int num_meta_group_infos;
         struct ext4_group_info *grinfo;
         struct ext4_sb_info *sbi = EXT4_SB(sb);
 
         if (sbi->s_group_info) {
-                for (i = 0; i < sbi->s_groups_count; i++) {
+                for (i = 0; i < ngroups; i++) {
                         grinfo = ext4_get_group_info(sb, i);
 #ifdef DOUBLE_CHECK
                         kfree(grinfo->bb_bitmap);
@@ -2797,7 +2774,7 @@ int ext4_mb_release(struct super_block *sb)
                         ext4_unlock_group(sb, i);
                         kfree(grinfo);
                 }
-                num_meta_group_infos = (sbi->s_groups_count +
+                num_meta_group_infos = (ngroups +
                                 EXT4_DESC_PER_BLOCK(sb) - 1) >>
                         EXT4_DESC_PER_BLOCK_BITS(sb);
                 for (i = 0; i < num_meta_group_infos; i++)
@@ -2984,27 +2961,25 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
                 + le32_to_cpu(es->s_first_data_block);
 
         len = ac->ac_b_ex.fe_len;
-        if (in_range(ext4_block_bitmap(sb, gdp), block, len) ||
-            in_range(ext4_inode_bitmap(sb, gdp), block, len) ||
-            in_range(block, ext4_inode_table(sb, gdp),
-                     EXT4_SB(sb)->s_itb_per_group) ||
-            in_range(block + len - 1, ext4_inode_table(sb, gdp),
-                     EXT4_SB(sb)->s_itb_per_group)) {
+        if (!ext4_data_block_valid(sbi, block, len)) {
                 ext4_error(sb, __func__,
-                           "Allocating block %llu in system zone of %d group\n",
-                           block, ac->ac_b_ex.fe_group);
+                           "Allocating blocks %llu-%llu which overlap "
+                           "fs metadata\n", block, block+len);
                 /* File system mounted not to panic on error
                  * Fix the bitmap and repeat the block allocation
                  * We leak some of the blocks here.
                  */
-                mb_set_bits(sb_bgl_lock(sbi, ac->ac_b_ex.fe_group),
-                                bitmap_bh->b_data, ac->ac_b_ex.fe_start,
-                                ac->ac_b_ex.fe_len);
+                ext4_lock_group(sb, ac->ac_b_ex.fe_group);
+                mb_set_bits(bitmap_bh->b_data, ac->ac_b_ex.fe_start,
+                            ac->ac_b_ex.fe_len);
+                ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
                 err = ext4_handle_dirty_metadata(handle, NULL, bitmap_bh);
                 if (!err)
                         err = -EAGAIN;
                 goto out_err;
         }
+
+        ext4_lock_group(sb, ac->ac_b_ex.fe_group);
 #ifdef AGGRESSIVE_CHECK
         {
                 int i;
@@ -3014,9 +2989,7 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
                 }
         }
 #endif
-        spin_lock(sb_bgl_lock(sbi, ac->ac_b_ex.fe_group));
-        mb_set_bits(NULL, bitmap_bh->b_data,
-                                ac->ac_b_ex.fe_start, ac->ac_b_ex.fe_len);
+        mb_set_bits(bitmap_bh->b_data, ac->ac_b_ex.fe_start,ac->ac_b_ex.fe_len);
         if (gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
                 gdp->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT);
                 ext4_free_blks_set(sb, gdp,
@@ -3026,7 +2999,8 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
         len = ext4_free_blks_count(sb, gdp) - ac->ac_b_ex.fe_len;
         ext4_free_blks_set(sb, gdp, len);
         gdp->bg_checksum = ext4_group_desc_csum(sbi, ac->ac_b_ex.fe_group, gdp);
-        spin_unlock(sb_bgl_lock(sbi, ac->ac_b_ex.fe_group));
+
+        ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
         percpu_counter_sub(&sbi->s_freeblocks_counter, ac->ac_b_ex.fe_len);
         /*
          * Now reduce the dirty block count also. Should not go negative
@@ -3459,7 +3433,7 @@ ext4_mb_use_preallocated(struct ext4_allocation_context *ac)
  * the function goes through all block freed in the group
  * but not yet committed and marks them used in in-core bitmap.
  * buddy must be generated from this bitmap
- * Need to be called with ext4 group lock (ext4_lock_group)
+ * Need to be called with the ext4 group lock held
  */
 static void ext4_mb_generate_from_freelist(struct super_block *sb, void *bitmap,
                                                 ext4_group_t group)
@@ -3473,9 +3447,7 @@ static void ext4_mb_generate_from_freelist(struct super_block *sb, void *bitmap,
 
         while (n) {
                 entry = rb_entry(n, struct ext4_free_data, node);
-                mb_set_bits(sb_bgl_lock(EXT4_SB(sb), group),
-                                bitmap, entry->start_blk,
-                                entry->count);
+                mb_set_bits(bitmap, entry->start_blk, entry->count);
                 n = rb_next(n);
         }
         return;
@@ -3484,7 +3456,7 @@ static void ext4_mb_generate_from_freelist(struct super_block *sb, void *bitmap,
 /*
  * the function goes through all preallocation in this group and marks them
  * used in in-core bitmap. buddy must be generated from this bitmap
- * Need to be called with ext4 group lock (ext4_lock_group)
+ * Need to be called with ext4 group lock held
  */
 static void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap,
                                         ext4_group_t group)
@@ -3516,8 +3488,7 @@ static void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap,
                 if (unlikely(len == 0))
                         continue;
                 BUG_ON(groupnr != group);
-                mb_set_bits(sb_bgl_lock(EXT4_SB(sb), group),
-                                                bitmap, start, len);
+                mb_set_bits(bitmap, start, len);
                 preallocated += len;
                 count++;
         }
@@ -4121,7 +4092,7 @@ static void ext4_mb_return_to_preallocation(struct inode *inode,
 static void ext4_mb_show_ac(struct ext4_allocation_context *ac)
 {
         struct super_block *sb = ac->ac_sb;
-        ext4_group_t i;
+        ext4_group_t ngroups, i;
 
         printk(KERN_ERR "EXT4-fs: Can't allocate:"
                         " Allocation context details:\n");
@@ -4145,7 +4116,8 @@ static void ext4_mb_show_ac(struct ext4_allocation_context *ac)
         printk(KERN_ERR "EXT4-fs: %lu scanned, %d found\n", ac->ac_ex_scanned,
                 ac->ac_found);
         printk(KERN_ERR "EXT4-fs: groups: \n");
-        for (i = 0; i < EXT4_SB(sb)->s_groups_count; i++) {
+        ngroups = ext4_get_groups_count(sb);
+        for (i = 0; i < ngroups; i++) {
                 struct ext4_group_info *grp = ext4_get_group_info(sb, i);
                 struct ext4_prealloc_space *pa;
                 ext4_grpblk_t start;
@@ -4469,13 +4441,13 @@ static int ext4_mb_release_context(struct ext4_allocation_context *ac)
 
 static int ext4_mb_discard_preallocations(struct super_block *sb, int needed)
 {
-        ext4_group_t i;
+        ext4_group_t i, ngroups = ext4_get_groups_count(sb);
         int ret;
         int freed = 0;
 
         trace_mark(ext4_mb_discard_preallocations, "dev %s needed %d",
                    sb->s_id, needed);
-        for (i = 0; i < EXT4_SB(sb)->s_groups_count && needed > 0; i++) {
+        for (i = 0; i < ngroups && needed > 0; i++) {
                 ret = ext4_mb_discard_group_preallocations(sb, i, needed);
                 freed += ret;
                 needed -= ret;
@@ -4859,29 +4831,25 @@ do_more:
                 new_entry->group  = block_group;
                 new_entry->count = count;
                 new_entry->t_tid = handle->h_transaction->t_tid;
+
                 ext4_lock_group(sb, block_group);
-                mb_clear_bits(sb_bgl_lock(sbi, block_group), bitmap_bh->b_data,
-                                bit, count);
+                mb_clear_bits(bitmap_bh->b_data, bit, count);
                 ext4_mb_free_metadata(handle, &e4b, new_entry);
-                ext4_unlock_group(sb, block_group);
         } else {
-                ext4_lock_group(sb, block_group);
                 /* need to update group_info->bb_free and bitmap
                  * with group lock held. generate_buddy look at
                  * them with group lock_held
                  */
-                mb_clear_bits(sb_bgl_lock(sbi, block_group), bitmap_bh->b_data,
-                                bit, count);
+                ext4_lock_group(sb, block_group);
+                mb_clear_bits(bitmap_bh->b_data, bit, count);
                 mb_free_blocks(inode, &e4b, bit, count);
                 ext4_mb_return_to_preallocation(inode, &e4b, block, count);
-                ext4_unlock_group(sb, block_group);
         }
 
-        spin_lock(sb_bgl_lock(sbi, block_group));
         ret = ext4_free_blks_count(sb, gdp) + count;
         ext4_free_blks_set(sb, gdp, ret);
         gdp->bg_checksum = ext4_group_desc_csum(sbi, block_group, gdp);
-        spin_unlock(sb_bgl_lock(sbi, block_group));
+        ext4_unlock_group(sb, block_group);
         percpu_counter_add(&sbi->s_freeblocks_counter, count);
 
         if (sbi->s_log_groups_per_flex) {
diff --git a/fs/ext4/mballoc.h b/fs/ext4/mballoc.h
index dd9e6cd5f6cf..75e34f69215b 100644
--- a/fs/ext4/mballoc.h
+++ b/fs/ext4/mballoc.h
@@ -23,7 +23,6 @@
 #include <linux/mutex.h>
 #include "ext4_jbd2.h"
 #include "ext4.h"
-#include "group.h"
 
 /*
  * with AGGRESSIVE_CHECK allocator runs consistency checks over
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 22098e1cd085..07eb6649e4fa 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -37,7 +37,6 @@
 #include "ext4.h"
 #include "ext4_jbd2.h"
 
-#include "namei.h"
 #include "xattr.h"
 #include "acl.h"
 
@@ -750,7 +749,7 @@ static int dx_make_map(struct ext4_dir_entry_2 *de, unsigned blocksize,
                         ext4fs_dirhash(de->name, de->name_len, &h);
                         map_tail--;
                         map_tail->hash = h.hash;
-                        map_tail->offs = (u16) ((char *) de - base);
+                        map_tail->offs = ((char *) de - base)>>2;
                         map_tail->size = le16_to_cpu(de->rec_len);
                         count++;
                         cond_resched();
@@ -1148,7 +1147,8 @@ dx_move_dirents(char *from, char *to, struct dx_map_entry *map, int count,
         unsigned rec_len = 0;
 
         while (count--) {
-                struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *) (from + map->offs);
+                struct ext4_dir_entry_2 *de = (struct ext4_dir_entry_2 *) 
+                                                (from + (map->offs<<2));
                 rec_len = EXT4_DIR_REC_LEN(de->name_len);
                 memcpy (to, de, rec_len);
                 ((struct ext4_dir_entry_2 *) to)->rec_len =
@@ -1997,7 +1997,7 @@ int ext4_orphan_add(handle_t *handle, struct inode *inode)
         if (!ext4_handle_valid(handle))
                 return 0;
 
-        lock_super(sb);
+        mutex_lock(&EXT4_SB(sb)->s_orphan_lock);
         if (!list_empty(&EXT4_I(inode)->i_orphan))
                 goto out_unlock;
 
@@ -2006,9 +2006,13 @@ int ext4_orphan_add(handle_t *handle, struct inode *inode)
 
         /* @@@ FIXME: Observation from aviro:
          * I think I can trigger J_ASSERT in ext4_orphan_add().  We block
-         * here (on lock_super()), so race with ext4_link() which might bump
+         * here (on s_orphan_lock), so race with ext4_link() which might bump
          * ->i_nlink. For, say it, character device. Not a regular file,
          * not a directory, not a symlink and ->i_nlink > 0.
+         *
+         * tytso, 4/25/2009: I'm not sure how that could happen;
+         * shouldn't the fs core protect us from these sort of
+         * unlink()/link() races?
          */
         J_ASSERT((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
                   S_ISLNK(inode->i_mode)) || inode->i_nlink == 0);
@@ -2045,7 +2049,7 @@ int ext4_orphan_add(handle_t *handle, struct inode *inode)
         jbd_debug(4, "orphan inode %lu will point to %d\n",
                         inode->i_ino, NEXT_ORPHAN(inode));
 out_unlock:
-        unlock_super(sb);
+        mutex_unlock(&EXT4_SB(sb)->s_orphan_lock);
         ext4_std_error(inode->i_sb, err);
         return err;
 }
@@ -2066,11 +2070,9 @@ int ext4_orphan_del(handle_t *handle, struct inode *inode)
         if (!ext4_handle_valid(handle))
                 return 0;
 
-        lock_super(inode->i_sb);
-        if (list_empty(&ei->i_orphan)) {
-                unlock_super(inode->i_sb);
-                return 0;
-        }
+        mutex_lock(&EXT4_SB(inode->i_sb)->s_orphan_lock);
+        if (list_empty(&ei->i_orphan))
+                goto out;
 
         ino_next = NEXT_ORPHAN(inode);
         prev = ei->i_orphan.prev;
@@ -2120,7 +2122,7 @@ int ext4_orphan_del(handle_t *handle, struct inode *inode)
 out_err:
         ext4_std_error(inode->i_sb, err);
 out:
-        unlock_super(inode->i_sb);
+        mutex_unlock(&EXT4_SB(inode->i_sb)->s_orphan_lock);
         return err;
 
 out_brelse:
@@ -2533,6 +2535,7 @@ const struct inode_operations ext4_dir_inode_operations = {
         .removexattr    = generic_removexattr,
 #endif
         .permission     = ext4_permission,
+        .fiemap         = ext4_fiemap,
 };
 
 const struct inode_operations ext4_special_inode_operations = {
diff --git a/fs/ext4/namei.h b/fs/ext4/namei.h
deleted file mode 100644
index 5e4dfff36a00..000000000000
--- a/fs/ext4/namei.h
+++ /dev/null
@@ -1,8 +0,0 @@
-/*  linux/fs/ext4/namei.h
- *
- * Copyright (C) 2005 Simtec Electronics
- *      Ben Dooks <ben@simtec.co.uk>
- *
-*/
-
-extern struct dentry *ext4_get_parent(struct dentry *child);
diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 546c7dd869e1..27eb289eea37 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -15,7 +15,6 @@
 #include <linux/slab.h>
 
 #include "ext4_jbd2.h"
-#include "group.h"
 
 #define outside(b, first, last) ((b) < (first) || (b) >= (last))
 #define inside(b, first, last)  ((b) >= (first) && (b) < (last))
@@ -193,7 +192,7 @@ static int setup_new_group_blocks(struct super_block *sb,
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
 
-        lock_super(sb);
+        mutex_lock(&sbi->s_resize_lock);
         if (input->group != sbi->s_groups_count) {
                 err = -EBUSY;
                 goto exit_journal;
@@ -302,7 +301,7 @@ exit_bh:
         brelse(bh);
 
 exit_journal:
-        unlock_super(sb);
+        mutex_unlock(&sbi->s_resize_lock);
         if ((err2 = ext4_journal_stop(handle)) && !err)
                 err = err2;
 
@@ -643,11 +642,12 @@ exit_free:
  * important part is that the new block and inode counts are in the backup
  * superblocks, and the location of the new group metadata in the GDT backups.
  *
- * We do not need lock_super() for this, because these blocks are not
- * otherwise touched by the filesystem code when it is mounted.  We don't
- * need to worry about last changing from sbi->s_groups_count, because the
- * worst that can happen is that we do not copy the full number of backups
- * at this time.  The resize which changed s_groups_count will backup again.
+ * We do not need take the s_resize_lock for this, because these
+ * blocks are not otherwise touched by the filesystem code when it is
+ * mounted.  We don't need to worry about last changing from
+ * sbi->s_groups_count, because the worst that can happen is that we
+ * do not copy the full number of backups at this time.  The resize
+ * which changed s_groups_count will backup again.
  */
 static void update_backups(struct super_block *sb,
                            int blk_off, char *data, int size)
@@ -809,7 +809,7 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
                 goto exit_put;
         }
 
-        lock_super(sb);
+        mutex_lock(&sbi->s_resize_lock);
         if (input->group != sbi->s_groups_count) {
                 ext4_warning(sb, __func__,
                              "multiple resizers run on filesystem!");
@@ -840,7 +840,7 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
         /*
          * OK, now we've set up the new group.  Time to make it active.
          *
-         * Current kernels don't lock all allocations via lock_super(),
+         * We do not lock all allocations via s_resize_lock
          * so we have to be safe wrt. concurrent accesses the group
          * data.  So we need to be careful to set all of the relevant
          * group descriptor data etc. *before* we enable the group.
@@ -900,12 +900,12 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
          *
          * The precise rules we use are:
          *
-         * * Writers of s_groups_count *must* hold lock_super
+         * * Writers of s_groups_count *must* hold s_resize_lock
          * AND
          * * Writers must perform a smp_wmb() after updating all dependent
          *   data and before modifying the groups count
          *
-         * * Readers must hold lock_super() over the access
+         * * Readers must hold s_resize_lock over the access
          * OR
          * * Readers must perform an smp_rmb() after reading the groups count
          *   and before reading any dependent data.
@@ -948,7 +948,7 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
         sb->s_dirt = 1;
 
 exit_journal:
-        unlock_super(sb);
+        mutex_unlock(&sbi->s_resize_lock);
         if ((err2 = ext4_journal_stop(handle)) && !err)
                 err = err2;
         if (!err) {
@@ -986,7 +986,7 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
 
         /* We don't need to worry about locking wrt other resizers just
          * yet: we're going to revalidate es->s_blocks_count after
-         * taking lock_super() below. */
+         * taking the s_resize_lock below. */
         o_blocks_count = ext4_blocks_count(es);
         o_groups_count = EXT4_SB(sb)->s_groups_count;
 
@@ -1056,11 +1056,11 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
                 goto exit_put;
         }
 
-        lock_super(sb);
+        mutex_lock(&EXT4_SB(sb)->s_resize_lock);
         if (o_blocks_count != ext4_blocks_count(es)) {
                 ext4_warning(sb, __func__,
                              "multiple resizers run on filesystem!");
-                unlock_super(sb);
+                mutex_unlock(&EXT4_SB(sb)->s_resize_lock);
                 ext4_journal_stop(handle);
                 err = -EBUSY;
                 goto exit_put;
@@ -1070,14 +1070,14 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
                                                  EXT4_SB(sb)->s_sbh))) {
                 ext4_warning(sb, __func__,
                              "error %d on journal write access", err);
-                unlock_super(sb);
+                mutex_unlock(&EXT4_SB(sb)->s_resize_lock);
                 ext4_journal_stop(handle);
                 goto exit_put;
         }
         ext4_blocks_count_set(es, o_blocks_count + add);
         ext4_handle_dirty_metadata(handle, NULL, EXT4_SB(sb)->s_sbh);
         sb->s_dirt = 1;
-        unlock_super(sb);
+        mutex_unlock(&EXT4_SB(sb)->s_resize_lock);
         ext4_debug("freeing blocks %llu through %llu\n", o_blocks_count,
                    o_blocks_count + add);
         /* We add the blocks to the bitmap and set the group need init bit */
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 2958f4e6f222..f016707597a7 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -20,6 +20,7 @@
 #include <linux/string.h>
 #include <linux/fs.h>
 #include <linux/time.h>
+#include <linux/vmalloc.h>
 #include <linux/jbd2.h>
 #include <linux/slab.h>
 #include <linux/init.h>
@@ -45,16 +46,20 @@
 #include "ext4_jbd2.h"
 #include "xattr.h"
 #include "acl.h"
-#include "namei.h"
-#include "group.h"
+
+static int default_mb_history_length = 1000;
+
+module_param_named(default_mb_history_length, default_mb_history_length,
+                   int, 0644);
+MODULE_PARM_DESC(default_mb_history_length,
+                 "Default number of entries saved for mb_history");
 
 struct proc_dir_entry *ext4_proc_root;
 static struct kset *ext4_kset;
 
 static int ext4_load_journal(struct super_block *, struct ext4_super_block *,
                              unsigned long journal_devnum);
-static int ext4_commit_super(struct super_block *sb,
-                              struct ext4_super_block *es, int sync);
+static int ext4_commit_super(struct super_block *sb, int sync);
 static void ext4_mark_recovery_complete(struct super_block *sb,
                                         struct ext4_super_block *es);
 static void ext4_clear_journal_err(struct super_block *sb,
@@ -74,7 +79,7 @@ ext4_fsblk_t ext4_block_bitmap(struct super_block *sb,
 {
         return le32_to_cpu(bg->bg_block_bitmap_lo) |
                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
-                (ext4_fsblk_t)le32_to_cpu(bg->bg_block_bitmap_hi) << 32 : 0);
+                 (ext4_fsblk_t)le32_to_cpu(bg->bg_block_bitmap_hi) << 32 : 0);
 }
 
 ext4_fsblk_t ext4_inode_bitmap(struct super_block *sb,
@@ -82,7 +87,7 @@ ext4_fsblk_t ext4_inode_bitmap(struct super_block *sb,
 {
         return le32_to_cpu(bg->bg_inode_bitmap_lo) |
                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
-                (ext4_fsblk_t)le32_to_cpu(bg->bg_inode_bitmap_hi) << 32 : 0);
+                 (ext4_fsblk_t)le32_to_cpu(bg->bg_inode_bitmap_hi) << 32 : 0);
 }
 
 ext4_fsblk_t ext4_inode_table(struct super_block *sb,
@@ -90,7 +95,7 @@ ext4_fsblk_t ext4_inode_table(struct super_block *sb,
 {
         return le32_to_cpu(bg->bg_inode_table_lo) |
                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
-                (ext4_fsblk_t)le32_to_cpu(bg->bg_inode_table_hi) << 32 : 0);
+                 (ext4_fsblk_t)le32_to_cpu(bg->bg_inode_table_hi) << 32 : 0);
 }
 
 __u32 ext4_free_blks_count(struct super_block *sb,
@@ -98,7 +103,7 @@ __u32 ext4_free_blks_count(struct super_block *sb,
 {
         return le16_to_cpu(bg->bg_free_blocks_count_lo) |
                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
-                (__u32)le16_to_cpu(bg->bg_free_blocks_count_hi) << 16 : 0);
+                 (__u32)le16_to_cpu(bg->bg_free_blocks_count_hi) << 16 : 0);
 }
 
 __u32 ext4_free_inodes_count(struct super_block *sb,
@@ -106,7 +111,7 @@ __u32 ext4_free_inodes_count(struct super_block *sb,
 {
         return le16_to_cpu(bg->bg_free_inodes_count_lo) |
                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
-                (__u32)le16_to_cpu(bg->bg_free_inodes_count_hi) << 16 : 0);
+                 (__u32)le16_to_cpu(bg->bg_free_inodes_count_hi) << 16 : 0);
 }
 
 __u32 ext4_used_dirs_count(struct super_block *sb,
@@ -114,7 +119,7 @@ __u32 ext4_used_dirs_count(struct super_block *sb,
 {
         return le16_to_cpu(bg->bg_used_dirs_count_lo) |
                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
-                (__u32)le16_to_cpu(bg->bg_used_dirs_count_hi) << 16 : 0);
+                 (__u32)le16_to_cpu(bg->bg_used_dirs_count_hi) << 16 : 0);
 }
 
 __u32 ext4_itable_unused_count(struct super_block *sb,
@@ -122,7 +127,7 @@ __u32 ext4_itable_unused_count(struct super_block *sb,
 {
         return le16_to_cpu(bg->bg_itable_unused_lo) |
                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
-                (__u32)le16_to_cpu(bg->bg_itable_unused_hi) << 16 : 0);
+                 (__u32)le16_to_cpu(bg->bg_itable_unused_hi) << 16 : 0);
 }
 
 void ext4_block_bitmap_set(struct super_block *sb,
@@ -202,8 +207,7 @@ handle_t *ext4_journal_start_sb(struct super_block *sb, int nblocks)
         journal = EXT4_SB(sb)->s_journal;
         if (journal) {
                 if (is_journal_aborted(journal)) {
-                        ext4_abort(sb, __func__,
-                                   "Detected aborted journal");
+                        ext4_abort(sb, __func__, "Detected aborted journal");
                         return ERR_PTR(-EROFS);
                 }
                 return jbd2_journal_start(journal, nblocks);
@@ -302,10 +306,10 @@ static void ext4_handle_error(struct super_block *sb)
                         jbd2_journal_abort(journal, -EIO);
         }
         if (test_opt(sb, ERRORS_RO)) {
-                printk(KERN_CRIT "Remounting filesystem read-only\n");
+                ext4_msg(sb, KERN_CRIT, "Remounting filesystem read-only");
                 sb->s_flags |= MS_RDONLY;
         }
-        ext4_commit_super(sb, es, 1);
+        ext4_commit_super(sb, 1);
         if (test_opt(sb, ERRORS_PANIC))
                 panic("EXT4-fs (device %s): panic forced after error\n",
                         sb->s_id);
@@ -395,8 +399,6 @@ void ext4_abort(struct super_block *sb, const char *function,
 {
         va_list args;
 
-        printk(KERN_CRIT "ext4_abort called.\n");
-
         va_start(args, fmt);
         printk(KERN_CRIT "EXT4-fs error (device %s): %s: ", sb->s_id, function);
         vprintk(fmt, args);
@@ -409,7 +411,7 @@ void ext4_abort(struct super_block *sb, const char *function,
         if (sb->s_flags & MS_RDONLY)
                 return;
 
-        printk(KERN_CRIT "Remounting filesystem read-only\n");
+        ext4_msg(sb, KERN_CRIT, "Remounting filesystem read-only");
         EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
         sb->s_flags |= MS_RDONLY;
         EXT4_SB(sb)->s_mount_opt |= EXT4_MOUNT_ABORT;
@@ -417,6 +419,18 @@ void ext4_abort(struct super_block *sb, const char *function,
                 jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO);
 }
 
+void ext4_msg (struct super_block * sb, const char *prefix,
+                   const char *fmt, ...)
+{
+        va_list args;
+
+        va_start(args, fmt);
+        printk("%sEXT4-fs (%s): ", prefix, sb->s_id);
+        vprintk(fmt, args);
+        printk("\n");
+        va_end(args);
+}
+
 void ext4_warning(struct super_block *sb, const char *function,
                   const char *fmt, ...)
 {
@@ -431,7 +445,7 @@ void ext4_warning(struct super_block *sb, const char *function,
 }
 
 void ext4_grp_locked_error(struct super_block *sb, ext4_group_t grp,
-                                const char *function, const char *fmt, ...)
+                           const char *function, const char *fmt, ...)
 __releases(bitlock)
 __acquires(bitlock)
 {
@@ -447,7 +461,7 @@ __acquires(bitlock)
         if (test_opt(sb, ERRORS_CONT)) {
                 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
                 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
-                ext4_commit_super(sb, es, 0);
+                ext4_commit_super(sb, 0);
                 return;
         }
         ext4_unlock_group(sb, grp);
@@ -467,7 +481,6 @@ __acquires(bitlock)
         return;
 }
 
-
 void ext4_update_dynamic_rev(struct super_block *sb)
 {
         struct ext4_super_block *es = EXT4_SB(sb)->s_es;
@@ -496,7 +509,7 @@ void ext4_update_dynamic_rev(struct super_block *sb)
 /*
  * Open the external journal device
  */
-static struct block_device *ext4_blkdev_get(dev_t dev)
+static struct block_device *ext4_blkdev_get(dev_t dev, struct super_block *sb)
 {
         struct block_device *bdev;
         char b[BDEVNAME_SIZE];
@@ -507,7 +520,7 @@ static struct block_device *ext4_blkdev_get(dev_t dev)
         return bdev;
 
 fail:
-        printk(KERN_ERR "EXT4-fs: failed to open journal device %s: %ld\n",
+        ext4_msg(sb, KERN_ERR, "failed to open journal device %s: %ld",
                         __bdevname(dev, b), PTR_ERR(bdev));
         return NULL;
 }
@@ -543,8 +556,8 @@ static void dump_orphan_list(struct super_block *sb, struct ext4_sb_info *sbi)
 {
         struct list_head *l;
 
-        printk(KERN_ERR "sb orphan head is %d\n",
-               le32_to_cpu(sbi->s_es->s_last_orphan));
+        ext4_msg(sb, KERN_ERR, "sb orphan head is %d",
+                 le32_to_cpu(sbi->s_es->s_last_orphan));
 
         printk(KERN_ERR "sb_info orphan list:\n");
         list_for_each(l, &sbi->s_orphan) {
@@ -563,6 +576,7 @@ static void ext4_put_super(struct super_block *sb)
         struct ext4_super_block *es = sbi->s_es;
         int i, err;
 
+        ext4_release_system_zone(sb);
         ext4_mb_release(sb);
         ext4_ext_release(sb);
         ext4_xattr_put_super(sb);
@@ -576,7 +590,7 @@ static void ext4_put_super(struct super_block *sb)
         if (!(sb->s_flags & MS_RDONLY)) {
                 EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
                 es->s_state = cpu_to_le16(sbi->s_mount_state);
-                ext4_commit_super(sb, es, 1);
+                ext4_commit_super(sb, 1);
         }
         if (sbi->s_proc) {
                 remove_proc_entry(sb->s_id, ext4_proc_root);
@@ -586,7 +600,10 @@ static void ext4_put_super(struct super_block *sb)
         for (i = 0; i < sbi->s_gdb_count; i++)
                 brelse(sbi->s_group_desc[i]);
         kfree(sbi->s_group_desc);
-        kfree(sbi->s_flex_groups);
+        if (is_vmalloc_addr(sbi->s_flex_groups))
+                vfree(sbi->s_flex_groups);
+        else
+                kfree(sbi->s_flex_groups);
         percpu_counter_destroy(&sbi->s_freeblocks_counter);
         percpu_counter_destroy(&sbi->s_freeinodes_counter);
         percpu_counter_destroy(&sbi->s_dirs_counter);
@@ -629,7 +646,6 @@ static void ext4_put_super(struct super_block *sb)
         lock_kernel();
         kfree(sbi->s_blockgroup_lock);
         kfree(sbi);
-        return;
 }
 
 static struct kmem_cache *ext4_inode_cachep;
@@ -644,6 +660,7 @@ static struct inode *ext4_alloc_inode(struct super_block *sb)
         ei = kmem_cache_alloc(ext4_inode_cachep, GFP_NOFS);
         if (!ei)
                 return NULL;
+
 #ifdef CONFIG_EXT4_FS_POSIX_ACL
         ei->i_acl = EXT4_ACL_NOT_CACHED;
         ei->i_default_acl = EXT4_ACL_NOT_CACHED;
@@ -664,14 +681,16 @@ static struct inode *ext4_alloc_inode(struct super_block *sb)
         ei->i_allocated_meta_blocks = 0;
         ei->i_delalloc_reserved_flag = 0;
         spin_lock_init(&(ei->i_block_reservation_lock));
+
         return &ei->vfs_inode;
 }
 
 static void ext4_destroy_inode(struct inode *inode)
 {
         if (!list_empty(&(EXT4_I(inode)->i_orphan))) {
-                printk("EXT4 Inode %p: orphan list check failed!\n",
-                        EXT4_I(inode));
+                ext4_msg(inode->i_sb, KERN_ERR,
+                         "Inode %lu (%p): orphan list check failed!",
+                         inode->i_ino, EXT4_I(inode));
                 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4,
                                 EXT4_I(inode), sizeof(struct ext4_inode_info),
                                 true);
@@ -870,12 +889,12 @@ static int ext4_show_options(struct seq_file *seq, struct vfsmount *vfs)
                 seq_puts(seq, ",noauto_da_alloc");
 
         ext4_show_quota_options(seq, sb);
+
         return 0;
 }
 
-
 static struct inode *ext4_nfs_get_inode(struct super_block *sb,
-                u64 ino, u32 generation)
+                                        u64 ino, u32 generation)
 {
         struct inode *inode;
 
@@ -904,14 +923,14 @@ static struct inode *ext4_nfs_get_inode(struct super_block *sb,
 }
 
 static struct dentry *ext4_fh_to_dentry(struct super_block *sb, struct fid *fid,
-                int fh_len, int fh_type)
+                                        int fh_len, int fh_type)
 {
         return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
                                     ext4_nfs_get_inode);
 }
 
 static struct dentry *ext4_fh_to_parent(struct super_block *sb, struct fid *fid,
-                int fh_len, int fh_type)
+                                        int fh_len, int fh_type)
 {
         return generic_fh_to_parent(sb, fid, fh_len, fh_type,
                                     ext4_nfs_get_inode);
@@ -923,7 +942,8 @@ static struct dentry *ext4_fh_to_parent(struct super_block *sb, struct fid *fid,
  * which would prevent try_to_free_buffers() from freeing them, we must use
  * jbd2 layer's try_to_free_buffers() function to release them.
  */
-static int bdev_try_to_free_page(struct super_block *sb, struct page *page, gfp_t wait)
+static int bdev_try_to_free_page(struct super_block *sb, struct page *page,
+                                 gfp_t wait)
 {
         journal_t *journal = EXT4_SB(sb)->s_journal;
 
@@ -992,7 +1012,6 @@ static const struct super_operations ext4_sops = {
         .dirty_inode    = ext4_dirty_inode,
         .delete_inode   = ext4_delete_inode,
         .put_super      = ext4_put_super,
-        .write_super    = ext4_write_super,
         .sync_fs        = ext4_sync_fs,
         .freeze_fs      = ext4_freeze,
         .unfreeze_fs    = ext4_unfreeze,
@@ -1007,6 +1026,25 @@ static const struct super_operations ext4_sops = {
         .bdev_try_to_free_page = bdev_try_to_free_page,
 };
 
+static const struct super_operations ext4_nojournal_sops = {
+        .alloc_inode    = ext4_alloc_inode,
+        .destroy_inode  = ext4_destroy_inode,
+        .write_inode    = ext4_write_inode,
+        .dirty_inode    = ext4_dirty_inode,
+        .delete_inode   = ext4_delete_inode,
+        .write_super    = ext4_write_super,
+        .put_super      = ext4_put_super,
+        .statfs         = ext4_statfs,
+        .remount_fs     = ext4_remount,
+        .clear_inode    = ext4_clear_inode,
+        .show_options   = ext4_show_options,
+#ifdef CONFIG_QUOTA
+        .quota_read     = ext4_quota_read,
+        .quota_write    = ext4_quota_write,
+#endif
+        .bdev_try_to_free_page = bdev_try_to_free_page,
+};
+
 static const struct export_operations ext4_export_ops = {
         .fh_to_dentry = ext4_fh_to_dentry,
         .fh_to_parent = ext4_fh_to_parent,
@@ -1023,12 +1061,13 @@ enum {
         Opt_journal_update, Opt_journal_dev,
         Opt_journal_checksum, Opt_journal_async_commit,
         Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
-        Opt_data_err_abort, Opt_data_err_ignore,
+        Opt_data_err_abort, Opt_data_err_ignore, Opt_mb_history_length,
         Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
         Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_quota, Opt_noquota,
         Opt_ignore, Opt_barrier, Opt_nobarrier, Opt_err, Opt_resize,
         Opt_usrquota, Opt_grpquota, Opt_i_version,
         Opt_stripe, Opt_delalloc, Opt_nodelalloc,
+        Opt_block_validity, Opt_noblock_validity,
         Opt_inode_readahead_blks, Opt_journal_ioprio
 };
 
@@ -1069,6 +1108,7 @@ static const match_table_t tokens = {
         {Opt_data_writeback, "data=writeback"},
         {Opt_data_err_abort, "data_err=abort"},
         {Opt_data_err_ignore, "data_err=ignore"},
+        {Opt_mb_history_length, "mb_history_length=%u"},
         {Opt_offusrjquota, "usrjquota="},
         {Opt_usrjquota, "usrjquota=%s"},
         {Opt_offgrpjquota, "grpjquota="},
@@ -1087,6 +1127,8 @@ static const match_table_t tokens = {
         {Opt_resize, "resize"},
         {Opt_delalloc, "delalloc"},
         {Opt_nodelalloc, "nodelalloc"},
+        {Opt_block_validity, "block_validity"},
+        {Opt_noblock_validity, "noblock_validity"},
         {Opt_inode_readahead_blks, "inode_readahead_blks=%u"},
         {Opt_journal_ioprio, "journal_ioprio=%u"},
         {Opt_auto_da_alloc, "auto_da_alloc=%u"},
@@ -1102,8 +1144,9 @@ static ext4_fsblk_t get_sb_block(void **data)
 
         if (!options || strncmp(options, "sb=", 3) != 0)
                 return 1;       /* Default location */
+
         options += 3;
-        /*todo: use simple_strtoll with >32bit ext4 */
+        /* TODO: use simple_strtoll with >32bit ext4 */
         sb_block = simple_strtoul(options, &options, 0);
         if (*options && *options != ',') {
                 printk(KERN_ERR "EXT4-fs: Invalid sb specification: %s\n",
@@ -1113,6 +1156,7 @@ static ext4_fsblk_t get_sb_block(void **data)
         if (*options == ',')
                 options++;
         *data = (void *) options;
+
         return sb_block;
 }
 
@@ -1206,8 +1250,7 @@ static int parse_options(char *options, struct super_block *sb,
 #else
                 case Opt_user_xattr:
                 case Opt_nouser_xattr:
-                        printk(KERN_ERR "EXT4 (no)user_xattr options "
-                               "not supported\n");
+                        ext4_msg(sb, KERN_ERR, "(no)user_xattr options not supported");
                         break;
 #endif
 #ifdef CONFIG_EXT4_FS_POSIX_ACL
@@ -1220,8 +1263,7 @@ static int parse_options(char *options, struct super_block *sb,
 #else
                 case Opt_acl:
                 case Opt_noacl:
-                        printk(KERN_ERR "EXT4 (no)acl options "
-                               "not supported\n");
+                        ext4_msg(sb, KERN_ERR, "(no)acl options not supported");
                         break;
 #endif
                 case Opt_journal_update:
@@ -1231,16 +1273,16 @@ static int parse_options(char *options, struct super_block *sb,
                            user to specify an existing inode to be the
                            journal file. */
                         if (is_remount) {
-                                printk(KERN_ERR "EXT4-fs: cannot specify "
-                                       "journal on remount\n");
+                                ext4_msg(sb, KERN_ERR,
+                                         "Cannot specify journal on remount");
                                 return 0;
                         }
                         set_opt(sbi->s_mount_opt, UPDATE_JOURNAL);
                         break;
                 case Opt_journal_dev:
                         if (is_remount) {
-                                printk(KERN_ERR "EXT4-fs: cannot specify "
-                                       "journal on remount\n");
+                                ext4_msg(sb, KERN_ERR,
+                                        "Cannot specify journal on remount");
                                 return 0;
                         }
                         if (match_int(&args[0], &option))
@@ -1294,9 +1336,8 @@ static int parse_options(char *options, struct super_block *sb,
                         if (is_remount) {
                                 if ((sbi->s_mount_opt & EXT4_MOUNT_DATA_FLAGS)
                                                 != data_opt) {
-                                        printk(KERN_ERR
-                                                "EXT4-fs: cannot change data "
-                                                "mode on remount\n");
+                                        ext4_msg(sb, KERN_ERR,
+                                                "Cannot change data mode on remount");
                                         return 0;
                                 }
                         } else {
@@ -1310,6 +1351,13 @@ static int parse_options(char *options, struct super_block *sb,
                 case Opt_data_err_ignore:
                         clear_opt(sbi->s_mount_opt, DATA_ERR_ABORT);
                         break;
+                case Opt_mb_history_length:
+                        if (match_int(&args[0], &option))
+                                return 0;
+                        if (option < 0)
+                                return 0;
+                        sbi->s_mb_history_max = option;
+                        break;
 #ifdef CONFIG_QUOTA
                 case Opt_usrjquota:
                         qtype = USRQUOTA;
@@ -1319,31 +1367,31 @@ static int parse_options(char *options, struct super_block *sb,
 set_qf_name:
                         if (sb_any_quota_loaded(sb) &&
                             !sbi->s_qf_names[qtype]) {
-                                printk(KERN_ERR
-                                       "EXT4-fs: Cannot change journaled "
-                                       "quota options when quota turned on.\n");
+                                ext4_msg(sb, KERN_ERR,
+                                       "Cannot change journaled "
+                                       "quota options when quota turned on");
                                 return 0;
                         }
                         qname = match_strdup(&args[0]);
                         if (!qname) {
-                                printk(KERN_ERR
-                                        "EXT4-fs: not enough memory for "
-                                        "storing quotafile name.\n");
+                                ext4_msg(sb, KERN_ERR,
+                                        "Not enough memory for "
+                                        "storing quotafile name");
                                 return 0;
                         }
                         if (sbi->s_qf_names[qtype] &&
                             strcmp(sbi->s_qf_names[qtype], qname)) {
-                                printk(KERN_ERR
-                                        "EXT4-fs: %s quota file already "
-                                        "specified.\n", QTYPE2NAME(qtype));
+                                ext4_msg(sb, KERN_ERR,
+                                        "%s quota file already "
+                                        "specified", QTYPE2NAME(qtype));
                                 kfree(qname);
                                 return 0;
                         }
                         sbi->s_qf_names[qtype] = qname;
                         if (strchr(sbi->s_qf_names[qtype], '/')) {
-                                printk(KERN_ERR
-                                        "EXT4-fs: quotafile must be on "
-                                        "filesystem root.\n");
+                                ext4_msg(sb, KERN_ERR,
+                                        "quotafile must be on "
+                                        "filesystem root");
                                 kfree(sbi->s_qf_names[qtype]);
                                 sbi->s_qf_names[qtype] = NULL;
                                 return 0;
@@ -1358,9 +1406,9 @@ set_qf_name:
 clear_qf_name:
                         if (sb_any_quota_loaded(sb) &&
                             sbi->s_qf_names[qtype]) {
-                                printk(KERN_ERR "EXT4-fs: Cannot change "
+                                ext4_msg(sb, KERN_ERR, "Cannot change "
                                         "journaled quota options when "
-                                        "quota turned on.\n");
+                                        "quota turned on");
                                 return 0;
                         }
                         /*
@@ -1377,9 +1425,9 @@ clear_qf_name:
 set_qf_format:
                         if (sb_any_quota_loaded(sb) &&
                             sbi->s_jquota_fmt != qfmt) {
-                                printk(KERN_ERR "EXT4-fs: Cannot change "
+                                ext4_msg(sb, KERN_ERR, "Cannot change "
                                         "journaled quota options when "
-                                        "quota turned on.\n");
+                                        "quota turned on");
                                 return 0;
                         }
                         sbi->s_jquota_fmt = qfmt;
@@ -1395,8 +1443,8 @@ set_qf_format:
                         break;
                 case Opt_noquota:
                         if (sb_any_quota_loaded(sb)) {
-                                printk(KERN_ERR "EXT4-fs: Cannot change quota "
-                                        "options when quota turned on.\n");
+                                ext4_msg(sb, KERN_ERR, "Cannot change quota "
+                                        "options when quota turned on");
                                 return 0;
                         }
                         clear_opt(sbi->s_mount_opt, QUOTA);
@@ -1407,8 +1455,8 @@ set_qf_format:
                 case Opt_quota:
                 case Opt_usrquota:
                 case Opt_grpquota:
-                        printk(KERN_ERR
-                                "EXT4-fs: quota options not supported.\n");
+                        ext4_msg(sb, KERN_ERR,
+                                "quota options not supported");
                         break;
                 case Opt_usrjquota:
                 case Opt_grpjquota:
@@ -1416,9 +1464,8 @@ set_qf_format:
                 case Opt_offgrpjquota:
                 case Opt_jqfmt_vfsold:
                 case Opt_jqfmt_vfsv0:
-                        printk(KERN_ERR
-                                "EXT4-fs: journaled quota options not "
-                                "supported.\n");
+                        ext4_msg(sb, KERN_ERR,
+                                "journaled quota options not supported");
                         break;
                 case Opt_noquota:
                         break;
@@ -1443,8 +1490,9 @@ set_qf_format:
                         break;
                 case Opt_resize:
                         if (!is_remount) {
-                                printk("EXT4-fs: resize option only available "
-                                        "for remount\n");
+                                ext4_msg(sb, KERN_ERR,
+                                        "resize option only available "
+                                        "for remount");
                                 return 0;
                         }
                         if (match_int(&args[0], &option) != 0)
@@ -1474,14 +1522,21 @@ set_qf_format:
                 case Opt_delalloc:
                         set_opt(sbi->s_mount_opt, DELALLOC);
                         break;
+                case Opt_block_validity:
+                        set_opt(sbi->s_mount_opt, BLOCK_VALIDITY);
+                        break;
+                case Opt_noblock_validity:
+                        clear_opt(sbi->s_mount_opt, BLOCK_VALIDITY);
+                        break;
                 case Opt_inode_readahead_blks:
                         if (match_int(&args[0], &option))
                                 return 0;
                         if (option < 0 || option > (1 << 30))
                                 return 0;
-                        if (option & (option - 1)) {
-                                printk(KERN_ERR "EXT4-fs: inode_readahead_blks"
-                                       " must be a power of 2\n");
+                        if (!is_power_of_2(option)) {
+                                ext4_msg(sb, KERN_ERR,
+                                         "EXT4-fs: inode_readahead_blks"
+                                         " must be a power of 2");
                                 return 0;
                         }
                         sbi->s_inode_readahead_blks = option;
@@ -1508,9 +1563,9 @@ set_qf_format:
                                 set_opt(sbi->s_mount_opt,NO_AUTO_DA_ALLOC);
                         break;
                 default:
-                        printk(KERN_ERR
-                               "EXT4-fs: Unrecognized mount option \"%s\" "
-                               "or missing value\n", p);
+                        ext4_msg(sb, KERN_ERR,
+                               "Unrecognized mount option \"%s\" "
+                               "or missing value", p);
                         return 0;
                 }
         }
@@ -1528,21 +1583,21 @@ set_qf_format:
                                 (sbi->s_mount_opt & EXT4_MOUNT_GRPQUOTA)) ||
                     (sbi->s_qf_names[GRPQUOTA] &&
                                 (sbi->s_mount_opt & EXT4_MOUNT_USRQUOTA))) {
-                        printk(KERN_ERR "EXT4-fs: old and new quota "
-                                        "format mixing.\n");
+                        ext4_msg(sb, KERN_ERR, "old and new quota "
+                                        "format mixing");
                         return 0;
                 }
 
                 if (!sbi->s_jquota_fmt) {
-                        printk(KERN_ERR "EXT4-fs: journaled quota format "
-                                        "not specified.\n");
+                        ext4_msg(sb, KERN_ERR, "journaled quota format "
+                                        "not specified");
                         return 0;
                 }
         } else {
                 if (sbi->s_jquota_fmt) {
-                        printk(KERN_ERR "EXT4-fs: journaled quota format "
+                        ext4_msg(sb, KERN_ERR, "journaled quota format "
                                         "specified with no journaling "
-                                        "enabled.\n");
+                                        "enabled");
                         return 0;
                 }
         }
@@ -1557,32 +1612,32 @@ static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
         int res = 0;
 
         if (le32_to_cpu(es->s_rev_level) > EXT4_MAX_SUPP_REV) {
-                printk(KERN_ERR "EXT4-fs warning: revision level too high, "
-                       "forcing read-only mode\n");
+                ext4_msg(sb, KERN_ERR, "revision level too high, "
+                         "forcing read-only mode");
                 res = MS_RDONLY;
         }
         if (read_only)
                 return res;
         if (!(sbi->s_mount_state & EXT4_VALID_FS))
-                printk(KERN_WARNING "EXT4-fs warning: mounting unchecked fs, "
-                       "running e2fsck is recommended\n");
+                ext4_msg(sb, KERN_WARNING, "warning: mounting unchecked fs, "
+                         "running e2fsck is recommended");
         else if ((sbi->s_mount_state & EXT4_ERROR_FS))
-                printk(KERN_WARNING
-                       "EXT4-fs warning: mounting fs with errors, "
-                       "running e2fsck is recommended\n");
+                ext4_msg(sb, KERN_WARNING,
+                         "warning: mounting fs with errors, "
+                         "running e2fsck is recommended");
         else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&
                  le16_to_cpu(es->s_mnt_count) >=
                  (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
-                printk(KERN_WARNING
-                       "EXT4-fs warning: maximal mount count reached, "
-                       "running e2fsck is recommended\n");
+                ext4_msg(sb, KERN_WARNING,
+                         "warning: maximal mount count reached, "
+                         "running e2fsck is recommended");
         else if (le32_to_cpu(es->s_checkinterval) &&
                 (le32_to_cpu(es->s_lastcheck) +
                         le32_to_cpu(es->s_checkinterval) <= get_seconds()))
-                printk(KERN_WARNING
-                       "EXT4-fs warning: checktime reached, "
-                       "running e2fsck is recommended\n");
-        if (!sbi->s_journal) 
+                ext4_msg(sb, KERN_WARNING,
+                         "warning: checktime reached, "
+                         "running e2fsck is recommended");
+        if (!sbi->s_journal)
                 es->s_state &= cpu_to_le16(~EXT4_VALID_FS);
         if (!(__s16) le16_to_cpu(es->s_max_mnt_count))
                 es->s_max_mnt_count = cpu_to_le16(EXT4_DFL_MAX_MNT_COUNT);
@@ -1592,7 +1647,7 @@ static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
         if (sbi->s_journal)
                 EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
 
-        ext4_commit_super(sb, es, 1);
+        ext4_commit_super(sb, 1);
         if (test_opt(sb, DEBUG))
                 printk(KERN_INFO "[EXT4 FS bs=%lu, gc=%u, "
                                 "bpg=%lu, ipg=%lu, mo=%04lx]\n",
@@ -1603,11 +1658,11 @@ static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
                         sbi->s_mount_opt);
 
         if (EXT4_SB(sb)->s_journal) {
-                printk(KERN_INFO "EXT4 FS on %s, %s journal on %s\n",
-                       sb->s_id, EXT4_SB(sb)->s_journal->j_inode ? "internal" :
+                ext4_msg(sb, KERN_INFO, "%s journal on %s",
+                       EXT4_SB(sb)->s_journal->j_inode ? "internal" :
                        "external", EXT4_SB(sb)->s_journal->j_devname);
         } else {
-                printk(KERN_INFO "EXT4 FS on %s, no journal\n", sb->s_id);
+                ext4_msg(sb, KERN_INFO, "no journal");
         }
         return res;
 }
@@ -1616,10 +1671,10 @@ static int ext4_fill_flex_info(struct super_block *sb)
 {
         struct ext4_sb_info *sbi = EXT4_SB(sb);
         struct ext4_group_desc *gdp = NULL;
-        struct buffer_head *bh;
         ext4_group_t flex_group_count;
         ext4_group_t flex_group;
         int groups_per_flex = 0;
+        size_t size;
         int i;
 
         if (!sbi->s_es->s_log_groups_per_flex) {
@@ -1634,16 +1689,21 @@ static int ext4_fill_flex_info(struct super_block *sb)
         flex_group_count = ((sbi->s_groups_count + groups_per_flex - 1) +
                         ((le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) + 1) <<
                               EXT4_DESC_PER_BLOCK_BITS(sb))) / groups_per_flex;
-        sbi->s_flex_groups = kzalloc(flex_group_count *
-                                     sizeof(struct flex_groups), GFP_KERNEL);
+        size = flex_group_count * sizeof(struct flex_groups);
+        sbi->s_flex_groups = kzalloc(size, GFP_KERNEL);
+        if (sbi->s_flex_groups == NULL) {
+                sbi->s_flex_groups = vmalloc(size);
+                if (sbi->s_flex_groups)
+                        memset(sbi->s_flex_groups, 0, size);
+        }
         if (sbi->s_flex_groups == NULL) {
-                printk(KERN_ERR "EXT4-fs: not enough memory for "
-                                "%u flex groups\n", flex_group_count);
+                ext4_msg(sb, KERN_ERR, "not enough memory for "
+                                "%u flex groups", flex_group_count);
                 goto failed;
         }
 
         for (i = 0; i < sbi->s_groups_count; i++) {
-                gdp = ext4_get_group_desc(sb, i, &bh);
+                gdp = ext4_get_group_desc(sb, i, NULL);
 
                 flex_group = ext4_flex_group(sbi, i);
                 atomic_set(&sbi->s_flex_groups[flex_group].free_inodes,
@@ -1724,44 +1784,44 @@ static int ext4_check_descriptors(struct super_block *sb)
 
                 block_bitmap = ext4_block_bitmap(sb, gdp);
                 if (block_bitmap < first_block || block_bitmap > last_block) {
-                        printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: "
+                        ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
                                "Block bitmap for group %u not in group "
-                               "(block %llu)!\n", i, block_bitmap);
+                               "(block %llu)!", i, block_bitmap);
                         return 0;
                 }
                 inode_bitmap = ext4_inode_bitmap(sb, gdp);
                 if (inode_bitmap < first_block || inode_bitmap > last_block) {
-                        printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: "
+                        ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
                                "Inode bitmap for group %u not in group "
-                               "(block %llu)!\n", i, inode_bitmap);
+                               "(block %llu)!", i, inode_bitmap);
                         return 0;
                 }
                 inode_table = ext4_inode_table(sb, gdp);
                 if (inode_table < first_block ||
                     inode_table + sbi->s_itb_per_group - 1 > last_block) {
-                        printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: "
+                        ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
                                "Inode table for group %u not in group "
-                               "(block %llu)!\n", i, inode_table);
+                               "(block %llu)!", i, inode_table);
                         return 0;
                 }
-                spin_lock(sb_bgl_lock(sbi, i));
+                ext4_lock_group(sb, i);
                 if (!ext4_group_desc_csum_verify(sbi, i, gdp)) {
-                        printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: "
-                               "Checksum for group %u failed (%u!=%u)\n",
-                               i, le16_to_cpu(ext4_group_desc_csum(sbi, i,
-                               gdp)), le16_to_cpu(gdp->bg_checksum));
+                        ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
+                                 "Checksum for group %u failed (%u!=%u)",
+                                 i, le16_to_cpu(ext4_group_desc_csum(sbi, i,
+                                     gdp)), le16_to_cpu(gdp->bg_checksum));
                         if (!(sb->s_flags & MS_RDONLY)) {
-                                spin_unlock(sb_bgl_lock(sbi, i));
+                                ext4_unlock_group(sb, i);
                                 return 0;
                         }
                 }
-                spin_unlock(sb_bgl_lock(sbi, i));
+                ext4_unlock_group(sb, i);
                 if (!flexbg_flag)
                         first_block += EXT4_BLOCKS_PER_GROUP(sb);
         }
 
         ext4_free_blocks_count_set(sbi->s_es, ext4_count_free_blocks(sb));
-        sbi->s_es->s_free_inodes_count = cpu_to_le32(ext4_count_free_inodes(sb));
+        sbi->s_es->s_free_inodes_count =cpu_to_le32(ext4_count_free_inodes(sb));
         return 1;
 }
 
@@ -1796,8 +1856,8 @@ static void ext4_orphan_cleanup(struct super_block *sb,
         }
 
         if (bdev_read_only(sb->s_bdev)) {
-                printk(KERN_ERR "EXT4-fs: write access "
-                        "unavailable, skipping orphan cleanup.\n");
+                ext4_msg(sb, KERN_ERR, "write access "
+                        "unavailable, skipping orphan cleanup");
                 return;
         }
 
@@ -1811,8 +1871,7 @@ static void ext4_orphan_cleanup(struct super_block *sb,
         }
 
         if (s_flags & MS_RDONLY) {
-                printk(KERN_INFO "EXT4-fs: %s: orphan cleanup on readonly fs\n",
-                       sb->s_id);
+                ext4_msg(sb, KERN_INFO, "orphan cleanup on readonly fs");
                 sb->s_flags &= ~MS_RDONLY;
         }
 #ifdef CONFIG_QUOTA
@@ -1823,9 +1882,9 @@ static void ext4_orphan_cleanup(struct super_block *sb,
                 if (EXT4_SB(sb)->s_qf_names[i]) {
                         int ret = ext4_quota_on_mount(sb, i);
                         if (ret < 0)
-                                printk(KERN_ERR
-                                        "EXT4-fs: Cannot turn on journaled "
-                                        "quota: error %d\n", ret);
+                                ext4_msg(sb, KERN_ERR,
+                                        "Cannot turn on journaled "
+                                        "quota: error %d", ret);
                 }
         }
 #endif
@@ -1842,16 +1901,16 @@ static void ext4_orphan_cleanup(struct super_block *sb,
                 list_add(&EXT4_I(inode)->i_orphan, &EXT4_SB(sb)->s_orphan);
                 vfs_dq_init(inode);
                 if (inode->i_nlink) {
-                        printk(KERN_DEBUG
-                                "%s: truncating inode %lu to %lld bytes\n",
+                        ext4_msg(sb, KERN_DEBUG,
+                                "%s: truncating inode %lu to %lld bytes",
                                 __func__, inode->i_ino, inode->i_size);
                         jbd_debug(2, "truncating inode %lu to %lld bytes\n",
                                   inode->i_ino, inode->i_size);
                         ext4_truncate(inode);
                         nr_truncates++;
                 } else {
-                        printk(KERN_DEBUG
-                                "%s: deleting unreferenced inode %lu\n",
+                        ext4_msg(sb, KERN_DEBUG,
+                                "%s: deleting unreferenced inode %lu",
                                 __func__, inode->i_ino);
                         jbd_debug(2, "deleting unreferenced inode %lu\n",
                                   inode->i_ino);
@@ -1863,11 +1922,11 @@ static void ext4_orphan_cleanup(struct super_block *sb,
 #define PLURAL(x) (x), ((x) == 1) ? "" : "s"
 
         if (nr_orphans)
-                printk(KERN_INFO "EXT4-fs: %s: %d orphan inode%s deleted\n",
-                       sb->s_id, PLURAL(nr_orphans));
+                ext4_msg(sb, KERN_INFO, "%d orphan inode%s deleted",
+                       PLURAL(nr_orphans));
         if (nr_truncates)
-                printk(KERN_INFO "EXT4-fs: %s: %d truncate%s cleaned up\n",
-                       sb->s_id, PLURAL(nr_truncates));
+                ext4_msg(sb, KERN_INFO, "%d truncate%s cleaned up",
+                       PLURAL(nr_truncates));
 #ifdef CONFIG_QUOTA
         /* Turn quotas off */
         for (i = 0; i < MAXQUOTAS; i++) {
@@ -1877,6 +1936,7 @@ static void ext4_orphan_cleanup(struct super_block *sb,
 #endif
         sb->s_flags = s_flags; /* Restore MS_RDONLY status */
 }
+
 /*
  * Maximal extent format file size.
  * Resulting logical blkno at s_maxbytes must fit in our on-disk
@@ -1927,19 +1987,19 @@ static loff_t ext4_max_bitmap_size(int bits, int has_huge_files)
         loff_t res = EXT4_NDIR_BLOCKS;
         int meta_blocks;
         loff_t upper_limit;
-        /* This is calculated to be the largest file size for a
-         * dense, bitmapped file such that the total number of
-         * sectors in the file, including data and all indirect blocks,
-         * does not exceed 2^48 -1
-         * __u32 i_blocks_lo and _u16 i_blocks_high representing the
-         * total number of  512 bytes blocks of the file
+        /* This is calculated to be the largest file size for a dense, block
+         * mapped file such that the file's total number of 512-byte sectors,
+         * including data and all indirect blocks, does not exceed (2^48 - 1).
+         *
+         * __u32 i_blocks_lo and _u16 i_blocks_high represent the total
+         * number of 512-byte sectors of the file.
          */
 
         if (!has_huge_files || sizeof(blkcnt_t) < sizeof(u64)) {
                 /*
-                 * !has_huge_files or CONFIG_LBD is not enabled
-                 * implies the inode i_block represent total blocks in
-                 * 512 bytes 32 == size of vfs inode i_blocks * 8
+                 * !has_huge_files or CONFIG_LBD not enabled implies that
+                 * the inode i_block field represents total file blocks in
+                 * 2^32 512-byte sectors == size of vfs inode i_blocks * 8
                  */
                 upper_limit = (1LL << 32) - 1;
 
@@ -1981,7 +2041,7 @@ static loff_t ext4_max_bitmap_size(int bits, int has_huge_files)
 }
 
 static ext4_fsblk_t descriptor_loc(struct super_block *sb,
-                                ext4_fsblk_t logical_sb_block, int nr)
+                                   ext4_fsblk_t logical_sb_block, int nr)
 {
         struct ext4_sb_info *sbi = EXT4_SB(sb);
         ext4_group_t bg, first_meta_bg;
@@ -1995,6 +2055,7 @@ static ext4_fsblk_t descriptor_loc(struct super_block *sb,
         bg = sbi->s_desc_per_block * nr;
         if (ext4_bg_has_super(sb, bg))
                 has_super = 1;
+
         return (has_super + ext4_group_first_block_no(sb, bg));
 }
 
@@ -2091,8 +2152,7 @@ static ssize_t inode_readahead_blks_store(struct ext4_attr *a,
         if (parse_strtoul(buf, 0x40000000, &t))
                 return -EINVAL;
 
-        /* inode_readahead_blks must be a power of 2 */
-        if (t & (t-1))
+        if (!is_power_of_2(t))
                 return -EINVAL;
 
         sbi->s_inode_readahead_blks = t;
@@ -2100,7 +2160,7 @@ static ssize_t inode_readahead_blks_store(struct ext4_attr *a,
 }
 
 static ssize_t sbi_ui_show(struct ext4_attr *a,
-                                struct ext4_sb_info *sbi, char *buf)
+                           struct ext4_sb_info *sbi, char *buf)
 {
         unsigned int *ui = (unsigned int *) (((char *) sbi) + a->offset);
 
@@ -2205,7 +2265,6 @@ static struct kobj_type ext4_ktype = {
 static int ext4_fill_super(struct super_block *sb, void *data, int silent)
                                 __releases(kernel_lock)
                                 __acquires(kernel_lock)
-
 {
         struct buffer_head *bh;
         struct ext4_super_block *es = NULL;
@@ -2256,7 +2315,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
 
         blocksize = sb_min_blocksize(sb, EXT4_MIN_BLOCK_SIZE);
         if (!blocksize) {
-                printk(KERN_ERR "EXT4-fs: unable to set blocksize\n");
+                ext4_msg(sb, KERN_ERR, "unable to set blocksize");
                 goto out_fail;
         }
 
@@ -2272,7 +2331,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
         }
 
         if (!(bh = sb_bread(sb, logical_sb_block))) {
-                printk(KERN_ERR "EXT4-fs: unable to read superblock\n");
+                ext4_msg(sb, KERN_ERR, "unable to read superblock");
                 goto out_fail;
         }
         /*
@@ -2321,6 +2380,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
         sbi->s_commit_interval = JBD2_DEFAULT_MAX_COMMIT_AGE * HZ;
         sbi->s_min_batch_time = EXT4_DEF_MIN_BATCH_TIME;
         sbi->s_max_batch_time = EXT4_DEF_MAX_BATCH_TIME;
+        sbi->s_mb_history_max = default_mb_history_length;
 
         set_opt(sbi->s_mount_opt, BARRIER);
 
@@ -2330,7 +2390,6 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
          */
         set_opt(sbi->s_mount_opt, DELALLOC);
 
-
         if (!parse_options((char *) data, sb, &journal_devnum,
                            &journal_ioprio, NULL, 0))
                 goto failed_mount;
@@ -2342,9 +2401,9 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
             (EXT4_HAS_COMPAT_FEATURE(sb, ~0U) ||
              EXT4_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||
              EXT4_HAS_INCOMPAT_FEATURE(sb, ~0U)))
-                printk(KERN_WARNING
-                       "EXT4-fs warning: feature flags set on rev 0 fs, "
-                       "running e2fsck is recommended\n");
+                ext4_msg(sb, KERN_WARNING,
+                       "feature flags set on rev 0 fs, "
+                       "running e2fsck is recommended");
 
         /*
          * Check feature flags regardless of the revision level, since we
@@ -2353,16 +2412,18 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
          */
         features = EXT4_HAS_INCOMPAT_FEATURE(sb, ~EXT4_FEATURE_INCOMPAT_SUPP);
         if (features) {
-                printk(KERN_ERR "EXT4-fs: %s: couldn't mount because of "
-                       "unsupported optional features (%x).\n", sb->s_id,
+                ext4_msg(sb, KERN_ERR,
+                        "Couldn't mount because of "
+                        "unsupported optional features (%x)",
                         (le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_incompat) &
                         ~EXT4_FEATURE_INCOMPAT_SUPP));
                 goto failed_mount;
         }
         features = EXT4_HAS_RO_COMPAT_FEATURE(sb, ~EXT4_FEATURE_RO_COMPAT_SUPP);
         if (!(sb->s_flags & MS_RDONLY) && features) {
-                printk(KERN_ERR "EXT4-fs: %s: couldn't mount RDWR because of "
-                       "unsupported optional features (%x).\n", sb->s_id,
+                ext4_msg(sb, KERN_ERR,
+                        "Couldn't mount RDWR because of "
+                        "unsupported optional features (%x)",
                         (le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_ro_compat) &
                         ~EXT4_FEATURE_RO_COMPAT_SUPP));
                 goto failed_mount;
@@ -2376,9 +2437,9 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
                  */
                 if (sizeof(root->i_blocks) < sizeof(u64) &&
                                 !(sb->s_flags & MS_RDONLY)) {
-                        printk(KERN_ERR "EXT4-fs: %s: Filesystem with huge "
+                        ext4_msg(sb, KERN_ERR, "Filesystem with huge "
                                         "files cannot be mounted read-write "
-                                        "without CONFIG_LBD.\n", sb->s_id);
+                                        "without CONFIG_LBD");
                         goto failed_mount;
                 }
         }
@@ -2386,17 +2447,15 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
 
         if (blocksize < EXT4_MIN_BLOCK_SIZE ||
             blocksize > EXT4_MAX_BLOCK_SIZE) {
-                printk(KERN_ERR
-                       "EXT4-fs: Unsupported filesystem blocksize %d on %s.\n",
-                       blocksize, sb->s_id);
+                ext4_msg(sb, KERN_ERR,
+                       "Unsupported filesystem blocksize %d", blocksize);
                 goto failed_mount;
         }
 
         if (sb->s_blocksize != blocksize) {
-
                 /* Validate the filesystem blocksize */
                 if (!sb_set_blocksize(sb, blocksize)) {
-                        printk(KERN_ERR "EXT4-fs: bad block size %d.\n",
+                        ext4_msg(sb, KERN_ERR, "bad block size %d",
                                         blocksize);
                         goto failed_mount;
                 }
@@ -2406,15 +2465,15 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
                 offset = do_div(logical_sb_block, blocksize);
                 bh = sb_bread(sb, logical_sb_block);
                 if (!bh) {
-                        printk(KERN_ERR
-                               "EXT4-fs: Can't read superblock on 2nd try.\n");
+                        ext4_msg(sb, KERN_ERR,
+                               "Can't read superblock on 2nd try");
                         goto failed_mount;
                 }
                 es = (struct ext4_super_block *)(((char *)bh->b_data) + offset);
                 sbi->s_es = es;
                 if (es->s_magic != cpu_to_le16(EXT4_SUPER_MAGIC)) {
-                        printk(KERN_ERR
-                               "EXT4-fs: Magic mismatch, very weird !\n");
+                        ext4_msg(sb, KERN_ERR,
+                               "Magic mismatch, very weird!");
                         goto failed_mount;
                 }
         }
@@ -2432,30 +2491,33 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
                 if ((sbi->s_inode_size < EXT4_GOOD_OLD_INODE_SIZE) ||
                     (!is_power_of_2(sbi->s_inode_size)) ||
                     (sbi->s_inode_size > blocksize)) {
-                        printk(KERN_ERR
-                               "EXT4-fs: unsupported inode size: %d\n",
+                        ext4_msg(sb, KERN_ERR,
+                               "unsupported inode size: %d",
                                sbi->s_inode_size);
                         goto failed_mount;
                 }
                 if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE)
                         sb->s_time_gran = 1 << (EXT4_EPOCH_BITS - 2);
         }
+
         sbi->s_desc_size = le16_to_cpu(es->s_desc_size);
         if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT)) {
                 if (sbi->s_desc_size < EXT4_MIN_DESC_SIZE_64BIT ||
                     sbi->s_desc_size > EXT4_MAX_DESC_SIZE ||
                     !is_power_of_2(sbi->s_desc_size)) {
-                        printk(KERN_ERR
-                               "EXT4-fs: unsupported descriptor size %lu\n",
+                        ext4_msg(sb, KERN_ERR,
+                               "unsupported descriptor size %lu",
                                sbi->s_desc_size);
                         goto failed_mount;
                 }
         } else
                 sbi->s_desc_size = EXT4_MIN_DESC_SIZE;
+
         sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
         sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
         if (EXT4_INODE_SIZE(sb) == 0 || EXT4_INODES_PER_GROUP(sb) == 0)
                 goto cantfind_ext4;
+
         sbi->s_inodes_per_block = blocksize / EXT4_INODE_SIZE(sb);
         if (sbi->s_inodes_per_block == 0)
                 goto cantfind_ext4;
@@ -2466,6 +2528,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
         sbi->s_mount_state = le16_to_cpu(es->s_state);
         sbi->s_addr_per_block_bits = ilog2(EXT4_ADDR_PER_BLOCK(sb));
         sbi->s_desc_per_block_bits = ilog2(EXT4_DESC_PER_BLOCK(sb));
+
         for (i = 0; i < 4; i++)
                 sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
         sbi->s_def_hash_version = es->s_def_hash_version;
@@ -2483,25 +2546,24 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
         }
 
         if (sbi->s_blocks_per_group > blocksize * 8) {
-                printk(KERN_ERR
-                       "EXT4-fs: #blocks per group too big: %lu\n",
+                ext4_msg(sb, KERN_ERR,
+                       "#blocks per group too big: %lu",
                        sbi->s_blocks_per_group);
                 goto failed_mount;
         }
         if (sbi->s_inodes_per_group > blocksize * 8) {
-                printk(KERN_ERR
-                       "EXT4-fs: #inodes per group too big: %lu\n",
+                ext4_msg(sb, KERN_ERR,
+                       "#inodes per group too big: %lu",
                        sbi->s_inodes_per_group);
                 goto failed_mount;
         }
 
         if (ext4_blocks_count(es) >
                     (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) {
-                printk(KERN_ERR "EXT4-fs: filesystem on %s:"
-                        " too large to mount safely\n", sb->s_id);
+                ext4_msg(sb, KERN_ERR, "filesystem"
+                        " too large to mount safely");
                 if (sizeof(sector_t) < 8)
-                        printk(KERN_WARNING "EXT4-fs: CONFIG_LBD not "
-                                        "enabled\n");
+                        ext4_msg(sb, KERN_WARNING, "CONFIG_LBD not enabled");
                 goto failed_mount;
         }
 
@@ -2511,21 +2573,21 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
         /* check blocks count against device size */
         blocks_count = sb->s_bdev->bd_inode->i_size >> sb->s_blocksize_bits;
         if (blocks_count && ext4_blocks_count(es) > blocks_count) {
-                printk(KERN_WARNING "EXT4-fs: bad geometry: block count %llu "
-                       "exceeds size of device (%llu blocks)\n",
+                ext4_msg(sb, KERN_WARNING, "bad geometry: block count %llu "
+                       "exceeds size of device (%llu blocks)",
                        ext4_blocks_count(es), blocks_count);
                 goto failed_mount;
         }
 
-        /*
-         * It makes no sense for the first data block to be beyond the end
-         * of the filesystem.
-         */
-        if (le32_to_cpu(es->s_first_data_block) >= ext4_blocks_count(es)) {
-                printk(KERN_WARNING "EXT4-fs: bad geometry: first data"
-                       "block %u is beyond end of filesystem (%llu)\n",
-                       le32_to_cpu(es->s_first_data_block),
-                       ext4_blocks_count(es));
+        /*
+         * It makes no sense for the first data block to be beyond the end
+         * of the filesystem.
+         */
+        if (le32_to_cpu(es->s_first_data_block) >= ext4_blocks_count(es)) {
+                ext4_msg(sb, KERN_WARNING, "bad geometry: first data"
+                         "block %u is beyond end of filesystem (%llu)",
+                         le32_to_cpu(es->s_first_data_block),
+                         ext4_blocks_count(es));
                 goto failed_mount;
         }
         blocks_count = (ext4_blocks_count(es) -
@@ -2533,9 +2595,9 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
                         EXT4_BLOCKS_PER_GROUP(sb) - 1);
         do_div(blocks_count, EXT4_BLOCKS_PER_GROUP(sb));
         if (blocks_count > ((uint64_t)1<<32) - EXT4_DESC_PER_BLOCK(sb)) {
-                printk(KERN_WARNING "EXT4-fs: groups count too large: %u "
+                ext4_msg(sb, KERN_WARNING, "groups count too large: %u "
                        "(block count %llu, first data block %u, "
-                       "blocks per group %lu)\n", sbi->s_groups_count,
+                       "blocks per group %lu)", sbi->s_groups_count,
                        ext4_blocks_count(es),
                        le32_to_cpu(es->s_first_data_block),
                        EXT4_BLOCKS_PER_GROUP(sb));
@@ -2547,7 +2609,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
         sbi->s_group_desc = kmalloc(db_count * sizeof(struct buffer_head *),
                                     GFP_KERNEL);
         if (sbi->s_group_desc == NULL) {
-                printk(KERN_ERR "EXT4-fs: not enough memory\n");
+                ext4_msg(sb, KERN_ERR, "not enough memory");
                 goto failed_mount;
         }
 
@@ -2562,21 +2624,21 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
                 block = descriptor_loc(sb, logical_sb_block, i);
                 sbi->s_group_desc[i] = sb_bread(sb, block);
                 if (!sbi->s_group_desc[i]) {
-                        printk(KERN_ERR "EXT4-fs: "
-                               "can't read group descriptor %d\n", i);
+                        ext4_msg(sb, KERN_ERR,
+                               "can't read group descriptor %d", i);
                         db_count = i;
                         goto failed_mount2;
                 }
         }
         if (!ext4_check_descriptors(sb)) {
-                printk(KERN_ERR "EXT4-fs: group descriptors corrupted!\n");
+                ext4_msg(sb, KERN_ERR, "group descriptors corrupted!");
                 goto failed_mount2;
         }
         if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG))
                 if (!ext4_fill_flex_info(sb)) {
-                        printk(KERN_ERR
-                               "EXT4-fs: unable to initialize "
-                               "flex_bg meta info!\n");
+                        ext4_msg(sb, KERN_ERR,
+                               "unable to initialize "
+                               "flex_bg meta info!");
                         goto failed_mount2;
                 }
 
@@ -2598,7 +2660,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
                 err = percpu_counter_init(&sbi->s_dirtyblocks_counter, 0);
         }
         if (err) {
-                printk(KERN_ERR "EXT4-fs: insufficient memory\n");
+                ext4_msg(sb, KERN_ERR, "insufficient memory");
                 goto failed_mount3;
         }
 
@@ -2607,7 +2669,11 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
         /*
          * set up enough so that it can read an inode
          */
-        sb->s_op = &ext4_sops;
+        if (!test_opt(sb, NOLOAD) &&
+            EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL))
+                sb->s_op = &ext4_sops;
+        else
+                sb->s_op = &ext4_nojournal_sops;
         sb->s_export_op = &ext4_export_ops;
         sb->s_xattr = ext4_xattr_handlers;
 #ifdef CONFIG_QUOTA
@@ -2615,6 +2681,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
         sb->dq_op = &ext4_quota_operations;
 #endif
         INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
+        mutex_init(&sbi->s_orphan_lock);
+        mutex_init(&sbi->s_resize_lock);
 
         sb->s_root = NULL;
 
@@ -2632,13 +2700,13 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
                         goto failed_mount3;
                 if (!(sb->s_flags & MS_RDONLY) &&
                     EXT4_SB(sb)->s_journal->j_failed_commit) {
-                        printk(KERN_CRIT "EXT4-fs error (device %s): "
+                        ext4_msg(sb, KERN_CRIT, "error: "
                                "ext4_fill_super: Journal transaction "
-                               "%u is corrupt\n", sb->s_id,
+                               "%u is corrupt",
                                EXT4_SB(sb)->s_journal->j_failed_commit);
                         if (test_opt(sb, ERRORS_RO)) {
-                                printk(KERN_CRIT
-                                       "Mounting filesystem read-only\n");
+                                ext4_msg(sb, KERN_CRIT,
+                                       "Mounting filesystem read-only");
                                 sb->s_flags |= MS_RDONLY;
                                 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
                                 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
@@ -2646,14 +2714,14 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
                         if (test_opt(sb, ERRORS_PANIC)) {
                                 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
                                 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
-                                ext4_commit_super(sb, es, 1);
+                                ext4_commit_super(sb, 1);
                                 goto failed_mount4;
                         }
                 }
         } else if (test_opt(sb, NOLOAD) && !(sb->s_flags & MS_RDONLY) &&
               EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER)) {
-                printk(KERN_ERR "EXT4-fs: required journal recovery "
-                       "suppressed and not mounted read-only\n");
+                ext4_msg(sb, KERN_ERR, "required journal recovery "
+                       "suppressed and not mounted read-only");
                 goto failed_mount4;
         } else {
                 clear_opt(sbi->s_mount_opt, DATA_FLAGS);
@@ -2666,7 +2734,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
         if (ext4_blocks_count(es) > 0xffffffffULL &&
             !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
                                        JBD2_FEATURE_INCOMPAT_64BIT)) {
-                printk(KERN_ERR "EXT4-fs: Failed to set 64-bit journal feature\n");
+                ext4_msg(sb, KERN_ERR, "Failed to set 64-bit journal feature");
                 goto failed_mount4;
         }
 
@@ -2704,8 +2772,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
         case EXT4_MOUNT_WRITEBACK_DATA:
                 if (!jbd2_journal_check_available_features
                     (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) {
-                        printk(KERN_ERR "EXT4-fs: Journal does not support "
-                               "requested data journaling mode\n");
+                        ext4_msg(sb, KERN_ERR, "Journal does not support "
+                               "requested data journaling mode");
                         goto failed_mount4;
                 }
         default:
@@ -2717,8 +2785,8 @@ no_journal:
 
         if (test_opt(sb, NOBH)) {
                 if (!(test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA)) {
-                        printk(KERN_WARNING "EXT4-fs: Ignoring nobh option - "
-                                "its supported only with writeback mode\n");
+                        ext4_msg(sb, KERN_WARNING, "Ignoring nobh option - "
+                                "its supported only with writeback mode");
                         clear_opt(sbi->s_mount_opt, NOBH);
                 }
         }
@@ -2729,18 +2797,18 @@ no_journal:
 
         root = ext4_iget(sb, EXT4_ROOT_INO);
         if (IS_ERR(root)) {
-                printk(KERN_ERR "EXT4-fs: get root inode failed\n");
+                ext4_msg(sb, KERN_ERR, "get root inode failed");
                 ret = PTR_ERR(root);
                 goto failed_mount4;
         }
         if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
                 iput(root);
-                printk(KERN_ERR "EXT4-fs: corrupt root inode, run e2fsck\n");
+                ext4_msg(sb, KERN_ERR, "corrupt root inode, run e2fsck");
                 goto failed_mount4;
         }
         sb->s_root = d_alloc_root(root);
         if (!sb->s_root) {
-                printk(KERN_ERR "EXT4-fs: get root dentry failed\n");
+                ext4_msg(sb, KERN_ERR, "get root dentry failed");
                 iput(root);
                 ret = -ENOMEM;
                 goto failed_mount4;
@@ -2769,22 +2837,29 @@ no_journal:
                                                         sbi->s_inode_size) {
                 sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
                                                        EXT4_GOOD_OLD_INODE_SIZE;
-                printk(KERN_INFO "EXT4-fs: required extra inode space not"
-                        "available.\n");
+                ext4_msg(sb, KERN_INFO, "required extra inode space not"
+                         "available");
         }
 
         if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) {
-                printk(KERN_WARNING "EXT4-fs: Ignoring delalloc option - "
-                                "requested data journaling mode\n");
+                ext4_msg(sb, KERN_WARNING, "Ignoring delalloc option - "
+                         "requested data journaling mode");
                 clear_opt(sbi->s_mount_opt, DELALLOC);
         } else if (test_opt(sb, DELALLOC))
-                printk(KERN_INFO "EXT4-fs: delayed allocation enabled\n");
+                ext4_msg(sb, KERN_INFO, "delayed allocation enabled");
+
+        err = ext4_setup_system_zone(sb);
+        if (err) {
+                ext4_msg(sb, KERN_ERR, "failed to initialize system "
+                         "zone (%d)\n", err);
+                goto failed_mount4;
+        }
 
         ext4_ext_init(sb);
         err = ext4_mb_init(sb, needs_recovery);
         if (err) {
-                printk(KERN_ERR "EXT4-fs: failed to initalize mballoc (%d)\n",
-                       err);
+                ext4_msg(sb, KERN_ERR, "failed to initalize mballoc (%d)",
+                         err);
                 goto failed_mount4;
         }
 
@@ -2798,19 +2873,11 @@ no_journal:
                 goto failed_mount4;
         };
 
-        /*
-         * akpm: core read_super() calls in here with the superblock locked.
-         * That deadlocks, because orphan cleanup needs to lock the superblock
-         * in numerous places.  Here we just pop the lock - it's relatively
-         * harmless, because we are now ready to accept write_super() requests,
-         * and aviro says that's the only reason for hanging onto the
-         * superblock lock.
-         */
         EXT4_SB(sb)->s_mount_state |= EXT4_ORPHAN_FS;
         ext4_orphan_cleanup(sb, es);
         EXT4_SB(sb)->s_mount_state &= ~EXT4_ORPHAN_FS;
         if (needs_recovery) {
-                printk(KERN_INFO "EXT4-fs: recovery complete.\n");
+                ext4_msg(sb, KERN_INFO, "recovery complete");
                 ext4_mark_recovery_complete(sb, es);
         }
         if (EXT4_SB(sb)->s_journal) {
@@ -2823,25 +2890,30 @@ no_journal:
         } else
                 descr = "out journal";
 
-        printk(KERN_INFO "EXT4-fs: mounted filesystem %s with%s\n",
-               sb->s_id, descr);
+        ext4_msg(sb, KERN_INFO, "mounted filesystem with%s", descr);
 
         lock_kernel();
         return 0;
 
 cantfind_ext4:
         if (!silent)
-                printk(KERN_ERR "VFS: Can't find ext4 filesystem on dev %s.\n",
-                       sb->s_id);
+                ext4_msg(sb, KERN_ERR, "VFS: Can't find ext4 filesystem");
         goto failed_mount;
 
 failed_mount4:
-        printk(KERN_ERR "EXT4-fs (device %s): mount failed\n", sb->s_id);
+        ext4_msg(sb, KERN_ERR, "mount failed");
+        ext4_release_system_zone(sb);
         if (sbi->s_journal) {
                 jbd2_journal_destroy(sbi->s_journal);
                 sbi->s_journal = NULL;
         }
 failed_mount3:
+        if (sbi->s_flex_groups) {
+                if (is_vmalloc_addr(sbi->s_flex_groups))
+                        vfree(sbi->s_flex_groups);
+                else
+                        kfree(sbi->s_flex_groups);
+        }
         percpu_counter_destroy(&sbi->s_freeblocks_counter);
         percpu_counter_destroy(&sbi->s_freeinodes_counter);
         percpu_counter_destroy(&sbi->s_dirs_counter);
@@ -2862,6 +2934,7 @@ failed_mount:
         brelse(bh);
 out_fail:
         sb->s_fs_info = NULL;
+        kfree(sbi->s_blockgroup_lock);
         kfree(sbi);
         lock_kernel();
         return ret;
@@ -2906,27 +2979,27 @@ static journal_t *ext4_get_journal(struct super_block *sb,
 
         journal_inode = ext4_iget(sb, journal_inum);
         if (IS_ERR(journal_inode)) {
-                printk(KERN_ERR "EXT4-fs: no journal found.\n");
+                ext4_msg(sb, KERN_ERR, "no journal found");
                 return NULL;
         }
         if (!journal_inode->i_nlink) {
                 make_bad_inode(journal_inode);
                 iput(journal_inode);
-                printk(KERN_ERR "EXT4-fs: journal inode is deleted.\n");
+                ext4_msg(sb, KERN_ERR, "journal inode is deleted");
                 return NULL;
         }
 
         jbd_debug(2, "Journal inode found at %p: %lld bytes\n",
                   journal_inode, journal_inode->i_size);
         if (!S_ISREG(journal_inode->i_mode)) {
-                printk(KERN_ERR "EXT4-fs: invalid journal inode.\n");
+                ext4_msg(sb, KERN_ERR, "invalid journal inode");
                 iput(journal_inode);
                 return NULL;
         }
 
         journal = jbd2_journal_init_inode(journal_inode);
         if (!journal) {
-                printk(KERN_ERR "EXT4-fs: Could not load journal inode\n");
+                ext4_msg(sb, KERN_ERR, "Could not load journal inode");
                 iput(journal_inode);
                 return NULL;
         }
@@ -2950,22 +3023,22 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb,
 
         BUG_ON(!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL));
 
-        bdev = ext4_blkdev_get(j_dev);
+        bdev = ext4_blkdev_get(j_dev, sb);
         if (bdev == NULL)
                 return NULL;
 
         if (bd_claim(bdev, sb)) {
-                printk(KERN_ERR
-                        "EXT4-fs: failed to claim external journal device.\n");
+                ext4_msg(sb, KERN_ERR,
+                        "failed to claim external journal device");
                 blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
                 return NULL;
         }
 
         blocksize = sb->s_blocksize;
-        hblock = bdev_hardsect_size(bdev);
+        hblock = bdev_logical_block_size(bdev);
         if (blocksize < hblock) {
-                printk(KERN_ERR
-                        "EXT4-fs: blocksize too small for journal device.\n");
+                ext4_msg(sb, KERN_ERR,
+                        "blocksize too small for journal device");
                 goto out_bdev;
         }
 
@@ -2973,8 +3046,8 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb,
         offset = EXT4_MIN_BLOCK_SIZE % blocksize;
         set_blocksize(bdev, blocksize);
         if (!(bh = __bread(bdev, sb_block, blocksize))) {
-                printk(KERN_ERR "EXT4-fs: couldn't read superblock of "
-                       "external journal\n");
+                ext4_msg(sb, KERN_ERR, "couldn't read superblock of "
+                       "external journal");
                 goto out_bdev;
         }
 
@@ -2982,14 +3055,14 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb,
         if ((le16_to_cpu(es->s_magic) != EXT4_SUPER_MAGIC) ||
             !(le32_to_cpu(es->s_feature_incompat) &
               EXT4_FEATURE_INCOMPAT_JOURNAL_DEV)) {
-                printk(KERN_ERR "EXT4-fs: external journal has "
-                                        "bad superblock\n");
+                ext4_msg(sb, KERN_ERR, "external journal has "
+                                        "bad superblock");
                 brelse(bh);
                 goto out_bdev;
         }
 
         if (memcmp(EXT4_SB(sb)->s_es->s_journal_uuid, es->s_uuid, 16)) {
-                printk(KERN_ERR "EXT4-fs: journal UUID does not match\n");
+                ext4_msg(sb, KERN_ERR, "journal UUID does not match");
                 brelse(bh);
                 goto out_bdev;
         }
@@ -3001,25 +3074,26 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb,
         journal = jbd2_journal_init_dev(bdev, sb->s_bdev,
                                         start, len, blocksize);
         if (!journal) {
-                printk(KERN_ERR "EXT4-fs: failed to create device journal\n");
+                ext4_msg(sb, KERN_ERR, "failed to create device journal");
                 goto out_bdev;
         }
         journal->j_private = sb;
         ll_rw_block(READ, 1, &journal->j_sb_buffer);
         wait_on_buffer(journal->j_sb_buffer);
         if (!buffer_uptodate(journal->j_sb_buffer)) {
-                printk(KERN_ERR "EXT4-fs: I/O error on journal device\n");
+                ext4_msg(sb, KERN_ERR, "I/O error on journal device");
                 goto out_journal;
         }
         if (be32_to_cpu(journal->j_superblock->s_nr_users) != 1) {
-                printk(KERN_ERR "EXT4-fs: External journal has more than one "
-                                        "user (unsupported) - %d\n",
+                ext4_msg(sb, KERN_ERR, "External journal has more than one "
+                                        "user (unsupported) - %d",
                         be32_to_cpu(journal->j_superblock->s_nr_users));
                 goto out_journal;
         }
         EXT4_SB(sb)->journal_bdev = bdev;
         ext4_init_journal_params(sb, journal);
         return journal;
+
 out_journal:
         jbd2_journal_destroy(journal);
 out_bdev:
@@ -3041,8 +3115,8 @@ static int ext4_load_journal(struct super_block *sb,
 
         if (journal_devnum &&
             journal_devnum != le32_to_cpu(es->s_journal_dev)) {
-                printk(KERN_INFO "EXT4-fs: external journal device major/minor "
-                        "numbers have changed\n");
+                ext4_msg(sb, KERN_INFO, "external journal device major/minor "
+                        "numbers have changed");
                 journal_dev = new_decode_dev(journal_devnum);
         } else
                 journal_dev = new_decode_dev(le32_to_cpu(es->s_journal_dev));
@@ -3054,24 +3128,23 @@ static int ext4_load_journal(struct super_block *sb,
          * crash?  For recovery, we need to check in advance whether we
          * can get read-write access to the device.
          */
-
         if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER)) {
                 if (sb->s_flags & MS_RDONLY) {
-                        printk(KERN_INFO "EXT4-fs: INFO: recovery "
-                                        "required on readonly filesystem.\n");
+                        ext4_msg(sb, KERN_INFO, "INFO: recovery "
+                                        "required on readonly filesystem");
                         if (really_read_only) {
-                                printk(KERN_ERR "EXT4-fs: write access "
-                                        "unavailable, cannot proceed.\n");
+                                ext4_msg(sb, KERN_ERR, "write access "
+                                        "unavailable, cannot proceed");
                                 return -EROFS;
                         }
-                        printk(KERN_INFO "EXT4-fs: write access will "
-                               "be enabled during recovery.\n");
+                        ext4_msg(sb, KERN_INFO, "write access will "
+                               "be enabled during recovery");
                 }
         }
 
         if (journal_inum && journal_dev) {
-                printk(KERN_ERR "EXT4-fs: filesystem has both journal "
-                       "and inode journals!\n");
+                ext4_msg(sb, KERN_ERR, "filesystem has both journal "
+                       "and inode journals!");
                 return -EINVAL;
         }
 
@@ -3084,14 +3157,14 @@ static int ext4_load_journal(struct super_block *sb,
         }
 
         if (journal->j_flags & JBD2_BARRIER)
-                printk(KERN_INFO "EXT4-fs: barriers enabled\n");
+                ext4_msg(sb, KERN_INFO, "barriers enabled");
         else
-                printk(KERN_INFO "EXT4-fs: barriers disabled\n");
+                ext4_msg(sb, KERN_INFO, "barriers disabled");
 
         if (!really_read_only && test_opt(sb, UPDATE_JOURNAL)) {
                 err = jbd2_journal_update_format(journal);
                 if (err)  {
-                        printk(KERN_ERR "EXT4-fs: error updating journal.\n");
+                        ext4_msg(sb, KERN_ERR, "error updating journal");
                         jbd2_journal_destroy(journal);
                         return err;
                 }
@@ -3103,7 +3176,7 @@ static int ext4_load_journal(struct super_block *sb,
                 err = jbd2_journal_load(journal);
 
         if (err) {
-                printk(KERN_ERR "EXT4-fs: error loading journal.\n");
+                ext4_msg(sb, KERN_ERR, "error loading journal");
                 jbd2_journal_destroy(journal);
                 return err;
         }
@@ -3114,18 +3187,17 @@ static int ext4_load_journal(struct super_block *sb,
         if (journal_devnum &&
             journal_devnum != le32_to_cpu(es->s_journal_dev)) {
                 es->s_journal_dev = cpu_to_le32(journal_devnum);
-                sb->s_dirt = 1;
 
                 /* Make sure we flush the recovery flag to disk. */
-                ext4_commit_super(sb, es, 1);
+                ext4_commit_super(sb, 1);
         }
 
         return 0;
 }
 
-static int ext4_commit_super(struct super_block *sb,
-                              struct ext4_super_block *es, int sync)
+static int ext4_commit_super(struct super_block *sb, int sync)
 {
+        struct ext4_super_block *es = EXT4_SB(sb)->s_es;
         struct buffer_head *sbh = EXT4_SB(sb)->s_sbh;
         int error = 0;
 
@@ -3140,8 +3212,8 @@ static int ext4_commit_super(struct super_block *sb,
                  * be remapped.  Nothing we can do but to retry the
                  * write and hope for the best.
                  */
-                printk(KERN_ERR "EXT4-fs: previous I/O error to "
-                       "superblock detected for %s.\n", sb->s_id);
+                ext4_msg(sb, KERN_ERR, "previous I/O error to "
+                       "superblock detected");
                 clear_buffer_write_io_error(sbh);
                 set_buffer_uptodate(sbh);
         }
@@ -3154,7 +3226,7 @@ static int ext4_commit_super(struct super_block *sb,
                                         &EXT4_SB(sb)->s_freeblocks_counter));
         es->s_free_inodes_count = cpu_to_le32(percpu_counter_sum_positive(
                                         &EXT4_SB(sb)->s_freeinodes_counter));
-
+        sb->s_dirt = 0;
         BUFFER_TRACE(sbh, "marking dirty");
         mark_buffer_dirty(sbh);
         if (sync) {
@@ -3164,8 +3236,8 @@ static int ext4_commit_super(struct super_block *sb,
 
                 error = buffer_write_io_error(sbh);
                 if (error) {
-                        printk(KERN_ERR "EXT4-fs: I/O error while writing "
-                               "superblock for %s.\n", sb->s_id);
+                        ext4_msg(sb, KERN_ERR, "I/O error while writing "
+                               "superblock");
                         clear_buffer_write_io_error(sbh);
                         set_buffer_uptodate(sbh);
                 }
@@ -3173,7 +3245,6 @@ static int ext4_commit_super(struct super_block *sb,
         return error;
 }
 
-
 /*
  * Have we just finished recovery?  If so, and if we are mounting (or
  * remounting) the filesystem readonly, then we will end up with a
@@ -3192,14 +3263,11 @@ static void ext4_mark_recovery_complete(struct super_block *sb,
         if (jbd2_journal_flush(journal) < 0)
                 goto out;
 
-        lock_super(sb);
         if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER) &&
             sb->s_flags & MS_RDONLY) {
                 EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
-                sb->s_dirt = 0;
-                ext4_commit_super(sb, es, 1);
+                ext4_commit_super(sb, 1);
         }
-        unlock_super(sb);
 
 out:
         jbd2_journal_unlock_updates(journal);
@@ -3238,7 +3306,7 @@ static void ext4_clear_journal_err(struct super_block *sb,
 
                 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
                 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
-                ext4_commit_super(sb, es, 1);
+                ext4_commit_super(sb, 1);
 
                 jbd2_journal_clear_err(journal);
         }
@@ -3257,29 +3325,15 @@ int ext4_force_commit(struct super_block *sb)
                 return 0;
 
         journal = EXT4_SB(sb)->s_journal;
-        if (journal) {
-                sb->s_dirt = 0;
+        if (journal)
                 ret = ext4_journal_force_commit(journal);
-        }
 
         return ret;
 }
 
-/*
- * Ext4 always journals updates to the superblock itself, so we don't
- * have to propagate any other updates to the superblock on disk at this
- * point.  (We can probably nuke this function altogether, and remove
- * any mention to sb->s_dirt in all of fs/ext4; eventual cleanup...)
- */
 static void ext4_write_super(struct super_block *sb)
 {
-        if (EXT4_SB(sb)->s_journal) {
-                if (mutex_trylock(&sb->s_lock) != 0)
-                        BUG();
-                sb->s_dirt = 0;
-        } else {
-                ext4_commit_super(sb, EXT4_SB(sb)->s_es, 1);
-        }
+        ext4_commit_super(sb, 1);
 }
 
 static int ext4_sync_fs(struct super_block *sb, int wait)
@@ -3288,16 +3342,9 @@ static int ext4_sync_fs(struct super_block *sb, int wait)
         tid_t target;
 
         trace_mark(ext4_sync_fs, "dev %s wait %d", sb->s_id, wait);
-        sb->s_dirt = 0;
-        if (EXT4_SB(sb)->s_journal) {
-                if (jbd2_journal_start_commit(EXT4_SB(sb)->s_journal,
-                                              &target)) {
-                        if (wait)
-                                jbd2_log_wait_commit(EXT4_SB(sb)->s_journal,
-                                                     target);
-                }
-        } else {
-                ext4_commit_super(sb, EXT4_SB(sb)->s_es, wait);
+        if (jbd2_journal_start_commit(EXT4_SB(sb)->s_journal, &target)) {
+                if (wait)
+                        jbd2_log_wait_commit(EXT4_SB(sb)->s_journal, target);
         }
         return ret;
 }
@@ -3310,34 +3357,32 @@ static int ext4_freeze(struct super_block *sb)
 {
         int error = 0;
         journal_t *journal;
-        sb->s_dirt = 0;
 
-        if (!(sb->s_flags & MS_RDONLY)) {
-                journal = EXT4_SB(sb)->s_journal;
+        if (sb->s_flags & MS_RDONLY)
+                return 0;
 
-                if (journal) {
-                        /* Now we set up the journal barrier. */
-                        jbd2_journal_lock_updates(journal);
+        journal = EXT4_SB(sb)->s_journal;
 
-                        /*
-                         * We don't want to clear needs_recovery flag when we
-                         * failed to flush the journal.
-                         */
-                        error = jbd2_journal_flush(journal);
-                        if (error < 0)
-                                goto out;
-                }
+        /* Now we set up the journal barrier. */
+        jbd2_journal_lock_updates(journal);
 
-                /* Journal blocked and flushed, clear needs_recovery flag. */
-                EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
-                error = ext4_commit_super(sb, EXT4_SB(sb)->s_es, 1);
-                if (error)
-                        goto out;
+        /*
+         * Don't clear the needs_recovery flag if we failed to flush
+         * the journal.
+         */
+        error = jbd2_journal_flush(journal);
+        if (error < 0) {
+        out:
+                jbd2_journal_unlock_updates(journal);
+                return error;
         }
+
+        /* Journal blocked and flushed, clear needs_recovery flag. */
+        EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
+        error = ext4_commit_super(sb, 1);
+        if (error)
+                goto out;
         return 0;
-out:
-        jbd2_journal_unlock_updates(journal);
-        return error;
 }
 
 /*
@@ -3346,14 +3391,15 @@ out:
  */
 static int ext4_unfreeze(struct super_block *sb)
 {
-        if (EXT4_SB(sb)->s_journal && !(sb->s_flags & MS_RDONLY)) {
-                lock_super(sb);
-                /* Reser the needs_recovery flag before the fs is unlocked. */
-                EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
-                ext4_commit_super(sb, EXT4_SB(sb)->s_es, 1);
-                unlock_super(sb);
-                jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
-        }
+        if (sb->s_flags & MS_RDONLY)
+                return 0;
+
+        lock_super(sb);
+        /* Reset the needs_recovery flag before the fs is unlocked. */
+        EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
+        ext4_commit_super(sb, 1);
+        unlock_super(sb);
+        jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
         return 0;
 }
 
@@ -3432,22 +3478,15 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
                             (sbi->s_mount_state & EXT4_VALID_FS))
                                 es->s_state = cpu_to_le16(sbi->s_mount_state);
 
-                        /*
-                         * We have to unlock super so that we can wait for
-                         * transactions.
-                         */
-                        if (sbi->s_journal) {
-                                unlock_super(sb);
+                        if (sbi->s_journal)
                                 ext4_mark_recovery_complete(sb, es);
-                                lock_super(sb);
-                        }
                 } else {
                         int ret;
                         if ((ret = EXT4_HAS_RO_COMPAT_FEATURE(sb,
                                         ~EXT4_FEATURE_RO_COMPAT_SUPP))) {
-                                printk(KERN_WARNING "EXT4-fs: %s: couldn't "
+                                ext4_msg(sb, KERN_WARNING, "couldn't "
                                        "remount RDWR because of unsupported "
-                                       "optional features (%x).\n", sb->s_id,
+                                       "optional features (%x)",
                                 (le32_to_cpu(sbi->s_es->s_feature_ro_compat) &
                                         ~EXT4_FEATURE_RO_COMPAT_SUPP));
                                 err = -EROFS;
@@ -3456,17 +3495,15 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
 
                         /*
                          * Make sure the group descriptor checksums
-                         * are sane.  If they aren't, refuse to
-                         * remount r/w.
+                         * are sane.  If they aren't, refuse to remount r/w.
                          */
                         for (g = 0; g < sbi->s_groups_count; g++) {
                                 struct ext4_group_desc *gdp =
                                         ext4_get_group_desc(sb, g, NULL);
 
                                 if (!ext4_group_desc_csum_verify(sbi, g, gdp)) {
-                                        printk(KERN_ERR
-               "EXT4-fs: ext4_remount: "
-                "Checksum for group %u failed (%u!=%u)\n",
+                                        ext4_msg(sb, KERN_ERR,
+               "ext4_remount: Checksum for group %u failed (%u!=%u)",
                 g, le16_to_cpu(ext4_group_desc_csum(sbi, g, gdp)),
                                                le16_to_cpu(gdp->bg_checksum));
                                         err = -EINVAL;
@@ -3480,11 +3517,10 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
                          * require a full umount/remount for now.
                          */
                         if (es->s_last_orphan) {
-                                printk(KERN_WARNING "EXT4-fs: %s: couldn't "
+                                ext4_msg(sb, KERN_WARNING, "Couldn't "
                                        "remount RDWR because of unprocessed "
                                        "orphan inode list.  Please "
-                                       "umount/remount instead.\n",
-                                       sb->s_id);
+                                       "umount/remount instead");
                                 err = -EINVAL;
                                 goto restore_opts;
                         }
@@ -3504,8 +3540,9 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
                                 sb->s_flags &= ~MS_RDONLY;
                 }
         }
+        ext4_setup_system_zone(sb);
         if (sbi->s_journal == NULL)
-                ext4_commit_super(sb, es, 1);
+                ext4_commit_super(sb, 1);
 
 #ifdef CONFIG_QUOTA
         /* Release old quota file names */
@@ -3515,6 +3552,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
                         kfree(old_opts.s_qf_names[i]);
 #endif
         return 0;
+
 restore_opts:
         sb->s_flags = old_sb_flags;
         sbi->s_mount_opt = old_opts.s_mount_opt;
@@ -3545,9 +3583,8 @@ static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf)
         if (test_opt(sb, MINIX_DF)) {
                 sbi->s_overhead_last = 0;
         } else if (sbi->s_blocks_last != ext4_blocks_count(es)) {
-                ext4_group_t ngroups = sbi->s_groups_count, i;
+                ext4_group_t i, ngroups = ext4_get_groups_count(sb);
                 ext4_fsblk_t overhead = 0;
-                smp_rmb();
 
                 /*
                  * Compute the overhead (FS structures).  This is constant
@@ -3599,11 +3636,12 @@ static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf)
                le64_to_cpup((void *)es->s_uuid + sizeof(u64));
         buf->f_fsid.val[0] = fsid & 0xFFFFFFFFUL;
         buf->f_fsid.val[1] = (fsid >> 32) & 0xFFFFFFFFUL;
+
         return 0;
 }
 
-/* Helper function for writing quotas on sync - we need to start transaction before quota file
- * is locked for write. Otherwise the are possible deadlocks:
+/* Helper function for writing quotas on sync - we need to start transaction
+ * before quota file is locked for write. Otherwise the are possible deadlocks:
  * Process 1                         Process 2
  * ext4_create()                     quota_sync()
  *   jbd2_journal_start()                  write_dquot()
@@ -3627,7 +3665,7 @@ static int ext4_write_dquot(struct dquot *dquot)
 
         inode = dquot_to_inode(dquot);
         handle = ext4_journal_start(inode,
-                                        EXT4_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
+                                    EXT4_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
         ret = dquot_commit(dquot);
@@ -3643,7 +3681,7 @@ static int ext4_acquire_dquot(struct dquot *dquot)
         handle_t *handle;
 
         handle = ext4_journal_start(dquot_to_inode(dquot),
-                                        EXT4_QUOTA_INIT_BLOCKS(dquot->dq_sb));
+                                    EXT4_QUOTA_INIT_BLOCKS(dquot->dq_sb));
         if (IS_ERR(handle))
                 return PTR_ERR(handle);
         ret = dquot_acquire(dquot);
@@ -3659,7 +3697,7 @@ static int ext4_release_dquot(struct dquot *dquot)
         handle_t *handle;
 
         handle = ext4_journal_start(dquot_to_inode(dquot),
-                                        EXT4_QUOTA_DEL_BLOCKS(dquot->dq_sb));
+                                    EXT4_QUOTA_DEL_BLOCKS(dquot->dq_sb));
         if (IS_ERR(handle)) {
                 /* Release dquot anyway to avoid endless cycle in dqput() */
                 dquot_release(dquot);
@@ -3707,7 +3745,7 @@ static int ext4_write_info(struct super_block *sb, int type)
 static int ext4_quota_on_mount(struct super_block *sb, int type)
 {
         return vfs_quota_on_mount(sb, EXT4_SB(sb)->s_qf_names[type],
-                        EXT4_SB(sb)->s_jquota_fmt, type);
+                                  EXT4_SB(sb)->s_jquota_fmt, type);
 }
 
 /*
@@ -3738,9 +3776,9 @@ static int ext4_quota_on(struct super_block *sb, int type, int format_id,
         if (EXT4_SB(sb)->s_qf_names[type]) {
                 /* Quotafile not in fs root? */
                 if (path.dentry->d_parent != sb->s_root)
-                        printk(KERN_WARNING
-                                "EXT4-fs: Quota file not on filesystem root. "
-                                "Journaled quota will not work.\n");
+                        ext4_msg(sb, KERN_WARNING,
+                                "Quota file not on filesystem root. "
+                                "Journaled quota will not work");
         }
 
         /*
@@ -3823,8 +3861,8 @@ static ssize_t ext4_quota_write(struct super_block *sb, int type,
         handle_t *handle = journal_current_handle();
 
         if (EXT4_SB(sb)->s_journal && !handle) {
-                printk(KERN_WARNING "EXT4-fs: Quota write (off=%llu, len=%llu)"
-                        " cancelled because transaction is not started.\n",
+                ext4_msg(sb, KERN_WARNING, "Quota write (off=%llu, len=%llu)"
+                        " cancelled because transaction is not started",
                         (unsigned long long)off, (unsigned long long)len);
                 return -EIO;
         }
@@ -3878,10 +3916,10 @@ out:
 
 #endif
 
-static int ext4_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
+static int ext4_get_sb(struct file_system_type *fs_type, int flags,
+                       const char *dev_name, void *data, struct vfsmount *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, ext4_fill_super, mnt);
+        return get_sb_bdev(fs_type, flags, dev_name, data, ext4_fill_super,mnt);
 }
 
 static struct file_system_type ext4_fs_type = {
@@ -3893,14 +3931,14 @@ static struct file_system_type ext4_fs_type = {
 };
 
 #ifdef CONFIG_EXT4DEV_COMPAT
-static int ext4dev_get_sb(struct file_system_type *fs_type,
-        int flags, const char *dev_name, void *data, struct vfsmount *mnt)
+static int ext4dev_get_sb(struct file_system_type *fs_type, int flags,
+                          const char *dev_name, void *data,struct vfsmount *mnt)
 {
-        printk(KERN_WARNING "EXT4-fs: Update your userspace programs "
-               "to mount using ext4\n");
-        printk(KERN_WARNING "EXT4-fs: ext4dev backwards compatibility "
-               "will go away by 2.6.31\n");
-        return get_sb_bdev(fs_type, flags, dev_name, data, ext4_fill_super, mnt);
+        printk(KERN_WARNING "EXT4-fs (%s): Update your userspace programs "
+               "to mount using ext4\n", dev_name);
+        printk(KERN_WARNING "EXT4-fs (%s): ext4dev backwards compatibility "
+               "will go away by 2.6.31\n", dev_name);
+        return get_sb_bdev(fs_type, flags, dev_name, data, ext4_fill_super,mnt);
 }
 
 static struct file_system_type ext4dev_fs_type = {
@@ -3917,13 +3955,16 @@ static int __init init_ext4_fs(void)
 {
         int err;
 
+        err = init_ext4_system_zone();
+        if (err)
+                return err;
         ext4_kset = kset_create_and_add("ext4", NULL, fs_kobj);
         if (!ext4_kset)
-                return -ENOMEM;
+                goto out4;
         ext4_proc_root = proc_mkdir("fs/ext4", NULL);
         err = init_ext4_mballoc();
         if (err)
-                return err;
+                goto out3;
 
         err = init_ext4_xattr();
         if (err)
@@ -3948,6 +3989,11 @@ out1:
         exit_ext4_xattr();
 out2:
         exit_ext4_mballoc();
+out3:
+        remove_proc_entry("fs/ext4", NULL);
+        kset_unregister(ext4_kset);
+out4:
+        exit_ext4_system_zone();
         return err;
 }
 
@@ -3962,6 +4008,7 @@ static void __exit exit_ext4_fs(void)
         exit_ext4_mballoc();
         remove_proc_entry("fs/ext4", NULL);
         kset_unregister(ext4_kset);
+        exit_ext4_system_zone();
 }
 
 MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
diff --git a/fs/gfs2/Kconfig b/fs/gfs2/Kconfig
index 3a981b7f64ca..cad957cdb1e5 100644
--- a/fs/gfs2/Kconfig
+++ b/fs/gfs2/Kconfig
@@ -7,6 +7,7 @@ config GFS2_FS
         select IP_SCTP if DLM_SCTP
         select FS_POSIX_ACL
         select CRC32
+        select SLOW_WORK
         help
           A cluster filesystem.
 
diff --git a/fs/gfs2/Makefile b/fs/gfs2/Makefile
index a851ea4bdf70..d53a9bea1c2f 100644
--- a/fs/gfs2/Makefile
+++ b/fs/gfs2/Makefile
@@ -1,8 +1,8 @@
 obj-$(CONFIG_GFS2_FS) += gfs2.o
 gfs2-y := acl.o bmap.o dir.o eaops.o eattr.o glock.o \
         glops.o inode.o log.o lops.o main.o meta_io.o \
-        mount.o ops_address.o ops_dentry.o ops_export.o ops_file.o \
-        ops_fstype.o ops_inode.o ops_super.o quota.o \
+        aops.o dentry.o export.o file.o \
+        ops_fstype.o ops_inode.o quota.o \
         recovery.o rgrp.o super.o sys.o trans.o util.o
 
 gfs2-$(CONFIG_GFS2_FS_LOCKING_DLM) += lock_dlm.o
diff --git a/fs/gfs2/ops_address.c b/fs/gfs2/aops.c
index a6dde1751e17..03ebb439ace0 100644
--- a/fs/gfs2/ops_address.c
+++ b/fs/gfs2/aops.c
@@ -28,7 +28,6 @@
 #include "inode.h"
 #include "log.h"
 #include "meta_io.h"
-#include "ops_address.h"
 #include "quota.h"
 #include "trans.h"
 #include "rgrp.h"
@@ -781,10 +780,12 @@ static int gfs2_stuffed_write_end(struct inode *inode, struct buffer_head *dibh,
         unlock_page(page);
         page_cache_release(page);
 
-        if (inode->i_size < to) {
-                i_size_write(inode, to);
-                ip->i_disksize = inode->i_size;
-                di->di_size = cpu_to_be64(inode->i_size);
+        if (copied) {
+                if (inode->i_size < to) {
+                        i_size_write(inode, to);
+                        ip->i_disksize = inode->i_size;
+                }
+                gfs2_dinode_out(ip, di);
                 mark_inode_dirty(inode);
         }
 
@@ -824,7 +825,6 @@ static int gfs2_write_end(struct file *file, struct address_space *mapping,
         struct gfs2_sbd *sdp = GFS2_SB(inode);
         struct buffer_head *dibh;
         struct gfs2_alloc *al = ip->i_alloc;
-        struct gfs2_dinode *di;
         unsigned int from = pos & (PAGE_CACHE_SIZE - 1);
         unsigned int to = from + len;
         int ret;
@@ -847,11 +847,10 @@ static int gfs2_write_end(struct file *file, struct address_space *mapping,
                 gfs2_page_add_databufs(ip, page, from, to);
 
         ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);
-
-        if (likely(ret >= 0) && (inode->i_size > ip->i_disksize)) {
-                di = (struct gfs2_dinode *)dibh->b_data;
-                ip->i_disksize = inode->i_size;
-                di->di_size = cpu_to_be64(inode->i_size);
+        if (ret > 0) {
+                if (inode->i_size > ip->i_disksize)
+                        ip->i_disksize = inode->i_size;
+                gfs2_dinode_out(ip, dibh->b_data);
                 mark_inode_dirty(inode);
         }
 
diff --git a/fs/gfs2/bmap.c b/fs/gfs2/bmap.c
index 3a5d3f883e10..329763530dc0 100644
--- a/fs/gfs2/bmap.c
+++ b/fs/gfs2/bmap.c
@@ -25,7 +25,6 @@
 #include "trans.h"
 #include "dir.h"
 #include "util.h"
-#include "ops_address.h"
 
 /* This doesn't need to be that large as max 64 bit pointers in a 4k
  * block is 512, so __u16 is fine for that. It saves stack space to
@@ -136,7 +135,9 @@ int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page)
                    and write it out to disk */
 
                 unsigned int n = 1;
-                block = gfs2_alloc_block(ip, &n);
+                error = gfs2_alloc_block(ip, &block, &n);
+                if (error)
+                        goto out_brelse;
                 if (isdir) {
                         gfs2_trans_add_unrevoke(GFS2_SB(&ip->i_inode), block, 1);
                         error = gfs2_dir_get_new_buffer(ip, block, &bh);
@@ -476,8 +477,11 @@ static int gfs2_bmap_alloc(struct inode *inode, const sector_t lblock,
         blks = dblks + iblks;
         i = sheight;
         do {
+                int error;
                 n = blks - alloced;
-                bn = gfs2_alloc_block(ip, &n);
+                error = gfs2_alloc_block(ip, &bn, &n);
+                if (error)
+                        return error;
                 alloced += n;
                 if (state != ALLOC_DATA || gfs2_is_jdata(ip))
                         gfs2_trans_add_unrevoke(sdp, bn, n);
@@ -1008,7 +1012,7 @@ static int gfs2_block_truncate_page(struct address_space *mapping)
                 gfs2_trans_add_bh(ip->i_gl, bh, 0);
 
         zero_user(page, offset, length);
-
+        mark_buffer_dirty(bh);
 unlock:
         unlock_page(page);
         page_cache_release(page);
diff --git a/fs/gfs2/ops_dentry.c b/fs/gfs2/dentry.c
index 022c66cd5606..022c66cd5606 100644
--- a/fs/gfs2/ops_dentry.c
+++ b/fs/gfs2/dentry.c
diff --git a/fs/gfs2/dir.c b/fs/gfs2/dir.c
index aef4d0c06748..297d7e5cebad 100644
--- a/fs/gfs2/dir.c
+++ b/fs/gfs2/dir.c
@@ -803,13 +803,20 @@ static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh,
 {
         struct gfs2_inode *ip = GFS2_I(inode);
         unsigned int n = 1;
-        u64 bn = gfs2_alloc_block(ip, &n);
-        struct buffer_head *bh = gfs2_meta_new(ip->i_gl, bn);
+        u64 bn;
+        int error;
+        struct buffer_head *bh;
         struct gfs2_leaf *leaf;
         struct gfs2_dirent *dent;
         struct qstr name = { .name = "", .len = 0, .hash = 0 };
+
+        error = gfs2_alloc_block(ip, &bn, &n);
+        if (error)
+                return NULL;
+        bh = gfs2_meta_new(ip->i_gl, bn);
         if (!bh)
                 return NULL;
+
         gfs2_trans_add_unrevoke(GFS2_SB(inode), bn, 1);
         gfs2_trans_add_bh(ip->i_gl, bh, 1);
         gfs2_metatype_set(bh, GFS2_METATYPE_LF, GFS2_FORMAT_LF);
diff --git a/fs/gfs2/eattr.c b/fs/gfs2/eattr.c
index 899763aed217..07ea9529adda 100644
--- a/fs/gfs2/eattr.c
+++ b/fs/gfs2/eattr.c
@@ -582,8 +582,11 @@ static int ea_alloc_blk(struct gfs2_inode *ip, struct buffer_head **bhp)
         struct gfs2_ea_header *ea;
         unsigned int n = 1;
         u64 block;
+        int error;
 
-        block = gfs2_alloc_block(ip, &n);
+        error = gfs2_alloc_block(ip, &block, &n);
+        if (error)
+                return error;
         gfs2_trans_add_unrevoke(sdp, block, 1);
         *bhp = gfs2_meta_new(ip->i_gl, block);
         gfs2_trans_add_bh(ip->i_gl, *bhp, 1);
@@ -617,6 +620,7 @@ static int ea_write(struct gfs2_inode *ip, struct gfs2_ea_header *ea,
                     struct gfs2_ea_request *er)
 {
         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
+        int error;
 
         ea->ea_data_len = cpu_to_be32(er->er_data_len);
         ea->ea_name_len = er->er_name_len;
@@ -642,7 +646,9 @@ static int ea_write(struct gfs2_inode *ip, struct gfs2_ea_header *ea,
                         int mh_size = sizeof(struct gfs2_meta_header);
                         unsigned int n = 1;
 
-                        block = gfs2_alloc_block(ip, &n);
+                        error = gfs2_alloc_block(ip, &block, &n);
+                        if (error)
+                                return error;
                         gfs2_trans_add_unrevoke(sdp, block, 1);
                         bh = gfs2_meta_new(ip->i_gl, block);
                         gfs2_trans_add_bh(ip->i_gl, bh, 1);
@@ -963,7 +969,9 @@ static int ea_set_block(struct gfs2_inode *ip, struct gfs2_ea_request *er,
         } else {
                 u64 blk;
                 unsigned int n = 1;
-                blk = gfs2_alloc_block(ip, &n);
+                error = gfs2_alloc_block(ip, &blk, &n);
+                if (error)
+                        return error;
                 gfs2_trans_add_unrevoke(sdp, blk, 1);
                 indbh = gfs2_meta_new(ip->i_gl, blk);
                 gfs2_trans_add_bh(ip->i_gl, indbh, 1);
diff --git a/fs/gfs2/ops_export.c b/fs/gfs2/export.c
index 9200ef221716..9200ef221716 100644
--- a/fs/gfs2/ops_export.c
+++ b/fs/gfs2/export.c
diff --git a/fs/gfs2/ops_file.c b/fs/gfs2/file.c
index 5d82e91887e3..73318a3ce6f1 100644
--- a/fs/gfs2/ops_file.c
+++ b/fs/gfs2/file.c
@@ -39,7 +39,6 @@
 #include "trans.h"
 #include "util.h"
 #include "eaops.h"
-#include "ops_address.h"
 
 /**
  * gfs2_llseek - seek to a location in a file
@@ -425,33 +424,36 @@ static struct vm_operations_struct gfs2_vm_ops = {
         .page_mkwrite = gfs2_page_mkwrite,
 };
 
-
 /**
  * gfs2_mmap -
  * @file: The file to map
  * @vma: The VMA which described the mapping
  *
- * Returns: 0 or error code
+ * There is no need to get a lock here unless we should be updating
+ * atime. We ignore any locking errors since the only consequence is
+ * a missed atime update (which will just be deferred until later).
+ *
+ * Returns: 0
  */
 
 static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
 {
         struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
-        struct gfs2_holder i_gh;
-        int error;
 
-        gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
-        error = gfs2_glock_nq(&i_gh);
-        if (error) {
-                gfs2_holder_uninit(&i_gh);
-                return error;
-        }
+        if (!(file->f_flags & O_NOATIME)) {
+                struct gfs2_holder i_gh;
+                int error;
 
+                gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
+                error = gfs2_glock_nq(&i_gh);
+                file_accessed(file);
+                if (error == 0)
+                        gfs2_glock_dq_uninit(&i_gh);
+        }
         vma->vm_ops = &gfs2_vm_ops;
+        vma->vm_flags |= VM_CAN_NONLINEAR;
 
-        gfs2_glock_dq_uninit(&i_gh);
-
-        return error;
+        return 0;
 }
 
 /**
@@ -692,12 +694,10 @@ static void do_unflock(struct file *file, struct file_lock *fl)
 
 static int gfs2_flock(struct file *file, int cmd, struct file_lock *fl)
 {
-        struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
-
         if (!(fl->fl_flags & FL_FLOCK))
                 return -ENOLCK;
-        if (__mandatory_lock(&ip->i_inode))
-                return -ENOLCK;
+        if (fl->fl_type & LOCK_MAND)
+                return -EOPNOTSUPP;
 
         if (fl->fl_type == F_UNLCK) {
                 do_unflock(file, fl);
diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c
index ff4981090489..2bf62bcc5181 100644
--- a/fs/gfs2/glock.c
+++ b/fs/gfs2/glock.c
@@ -796,22 +796,37 @@ void gfs2_holder_uninit(struct gfs2_holder *gh)
         gh->gh_ip = 0;
 }
 
-static int just_schedule(void *word)
+/**
+ * gfs2_glock_holder_wait
+ * @word: unused
+ *
+ * This function and gfs2_glock_demote_wait both show up in the WCHAN
+ * field. Thus I've separated these otherwise identical functions in
+ * order to be more informative to the user.
+ */
+
+static int gfs2_glock_holder_wait(void *word)
 {
         schedule();
         return 0;
 }
 
+static int gfs2_glock_demote_wait(void *word)
+{
+        schedule();
+        return 0;
+}
+
 static void wait_on_holder(struct gfs2_holder *gh)
 {
         might_sleep();
-        wait_on_bit(&gh->gh_iflags, HIF_WAIT, just_schedule, TASK_UNINTERRUPTIBLE);
+        wait_on_bit(&gh->gh_iflags, HIF_WAIT, gfs2_glock_holder_wait, TASK_UNINTERRUPTIBLE);
 }
 
 static void wait_on_demote(struct gfs2_glock *gl)
 {
         might_sleep();
-        wait_on_bit(&gl->gl_flags, GLF_DEMOTE, just_schedule, TASK_UNINTERRUPTIBLE);
+        wait_on_bit(&gl->gl_flags, GLF_DEMOTE, gfs2_glock_demote_wait, TASK_UNINTERRUPTIBLE);
 }
 
 /**
diff --git a/fs/gfs2/glops.c b/fs/gfs2/glops.c
index 70f87f43afa2..d5e4ab155ca0 100644
--- a/fs/gfs2/glops.c
+++ b/fs/gfs2/glops.c
@@ -310,24 +310,6 @@ static void rgrp_go_unlock(struct gfs2_holder *gh)
 }
 
 /**
- * rgrp_go_dump - print out an rgrp
- * @seq: The iterator
- * @gl: The glock in question
- *
- */
-
-static int rgrp_go_dump(struct seq_file *seq, const struct gfs2_glock *gl)
-{
-        const struct gfs2_rgrpd *rgd = gl->gl_object;
-        if (rgd == NULL)
-                return 0;
-        gfs2_print_dbg(seq, " R: n:%llu f:%02x b:%u/%u i:%u\n",
-                       (unsigned long long)rgd->rd_addr, rgd->rd_flags,
-                       rgd->rd_free, rgd->rd_free_clone, rgd->rd_dinodes);
-        return 0;
-}
-
-/**
  * trans_go_sync - promote/demote the transaction glock
  * @gl: the glock
  * @state: the requested state
@@ -410,7 +392,7 @@ const struct gfs2_glock_operations gfs2_rgrp_glops = {
         .go_demote_ok = rgrp_go_demote_ok,
         .go_lock = rgrp_go_lock,
         .go_unlock = rgrp_go_unlock,
-        .go_dump = rgrp_go_dump,
+        .go_dump = gfs2_rgrp_dump,
         .go_type = LM_TYPE_RGRP,
         .go_min_hold_time = HZ / 5,
 };
diff --git a/fs/gfs2/incore.h b/fs/gfs2/incore.h
index 399d1b978049..225347fbff3c 100644
--- a/fs/gfs2/incore.h
+++ b/fs/gfs2/incore.h
@@ -12,6 +12,7 @@
 
 #include <linux/fs.h>
 #include <linux/workqueue.h>
+#include <linux/slow-work.h>
 #include <linux/dlm.h>
 #include <linux/buffer_head.h>
 
@@ -63,9 +64,12 @@ struct gfs2_log_element {
         const struct gfs2_log_operations *le_ops;
 };
 
+#define GBF_FULL 1
+
 struct gfs2_bitmap {
         struct buffer_head *bi_bh;
         char *bi_clone;
+        unsigned long bi_flags;
         u32 bi_offset;
         u32 bi_start;
         u32 bi_len;
@@ -90,10 +94,11 @@ struct gfs2_rgrpd {
         struct gfs2_sbd *rd_sbd;
         unsigned int rd_bh_count;
         u32 rd_last_alloc;
-        unsigned char rd_flags;
-#define GFS2_RDF_CHECK        0x01      /* Need to check for unlinked inodes */
-#define GFS2_RDF_NOALLOC      0x02      /* rg prohibits allocation */
-#define GFS2_RDF_UPTODATE     0x04      /* rg is up to date */
+        u32 rd_flags;
+#define GFS2_RDF_CHECK          0x10000000 /* check for unlinked inodes */
+#define GFS2_RDF_UPTODATE       0x20000000 /* rg is up to date */
+#define GFS2_RDF_ERROR          0x40000000 /* error in rg */
+#define GFS2_RDF_MASK           0xf0000000 /* mask for internal flags */
 };
 
 enum gfs2_state_bits {
@@ -376,11 +381,11 @@ struct gfs2_journal_extent {
 struct gfs2_jdesc {
         struct list_head jd_list;
         struct list_head extent_list;
-
+        struct slow_work jd_work;
         struct inode *jd_inode;
+        unsigned long jd_flags;
+#define JDF_RECOVERY 1
         unsigned int jd_jid;
-        int jd_dirty;
-
         unsigned int jd_blocks;
 };
 
@@ -390,9 +395,6 @@ struct gfs2_statfs_change_host {
         s64 sc_dinodes;
 };
 
-#define GFS2_GLOCKD_DEFAULT     1
-#define GFS2_GLOCKD_MAX         16
-
 #define GFS2_QUOTA_DEFAULT      GFS2_QUOTA_OFF
 #define GFS2_QUOTA_OFF          0
 #define GFS2_QUOTA_ACCOUNT      1
@@ -418,6 +420,7 @@ struct gfs2_args {
         unsigned int ar_data:2;                 /* ordered/writeback */
         unsigned int ar_meta:1;                 /* mount metafs */
         unsigned int ar_discard:1;              /* discard requests */
+        int ar_commit;                          /* Commit interval */
 };
 
 struct gfs2_tune {
@@ -426,7 +429,6 @@ struct gfs2_tune {
         unsigned int gt_incore_log_blocks;
         unsigned int gt_log_flush_secs;
 
-        unsigned int gt_recoverd_secs;
         unsigned int gt_logd_secs;
 
         unsigned int gt_quota_simul_sync; /* Max quotavals to sync at once */
@@ -447,6 +449,7 @@ enum {
         SDF_JOURNAL_LIVE        = 1,
         SDF_SHUTDOWN            = 2,
         SDF_NOBARRIERS          = 3,
+        SDF_NORECOVERY          = 4,
 };
 
 #define GFS2_FSNAME_LEN         256
@@ -493,7 +496,6 @@ struct lm_lockstruct {
         unsigned long ls_flags;
         dlm_lockspace_t *ls_dlm;
 
-        int ls_recover_jid;
         int ls_recover_jid_done;
         int ls_recover_jid_status;
 };
@@ -582,7 +584,6 @@ struct gfs2_sbd {
 
         /* Daemon stuff */
 
-        struct task_struct *sd_recoverd_process;
         struct task_struct *sd_logd_process;
         struct task_struct *sd_quotad_process;
 
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index 5a31d426116f..2f94bd723698 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -30,7 +30,6 @@
 #include "inode.h"
 #include "log.h"
 #include "meta_io.h"
-#include "ops_address.h"
 #include "quota.h"
 #include "rgrp.h"
 #include "trans.h"
@@ -1047,154 +1046,7 @@ fail:
         return ERR_PTR(error);
 }
 
-/**
- * gfs2_rmdiri - Remove a directory
- * @dip: The parent directory of the directory to be removed
- * @name: The name of the directory to be removed
- * @ip: The GFS2 inode of the directory to be removed
- *
- * Assumes Glocks on dip and ip are held
- *
- * Returns: errno
- */
-
-int gfs2_rmdiri(struct gfs2_inode *dip, const struct qstr *name,
-                struct gfs2_inode *ip)
-{
-        struct qstr dotname;
-        int error;
-
-        if (ip->i_entries != 2) {
-                if (gfs2_consist_inode(ip))
-                        gfs2_dinode_print(ip);
-                return -EIO;
-        }
-
-        error = gfs2_dir_del(dip, name);
-        if (error)
-                return error;
-
-        error = gfs2_change_nlink(dip, -1);
-        if (error)
-                return error;
-
-        gfs2_str2qstr(&dotname, ".");
-        error = gfs2_dir_del(ip, &dotname);
-        if (error)
-                return error;
-
-        gfs2_str2qstr(&dotname, "..");
-        error = gfs2_dir_del(ip, &dotname);
-        if (error)
-                return error;
-
-        /* It looks odd, but it really should be done twice */
-        error = gfs2_change_nlink(ip, -1);
-        if (error)
-                return error;
-
-        error = gfs2_change_nlink(ip, -1);
-        if (error)
-                return error;
-
-        return error;
-}
-
-/*
- * gfs2_unlink_ok - check to see that a inode is still in a directory
- * @dip: the directory
- * @name: the name of the file
- * @ip: the inode
- *
- * Assumes that the lock on (at least) @dip is held.
- *
- * Returns: 0 if the parent/child relationship is correct, errno if it isn't
- */
-
-int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
-                   const struct gfs2_inode *ip)
-{
-        int error;
-
-        if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
-                return -EPERM;
-
-        if ((dip->i_inode.i_mode & S_ISVTX) &&
-            dip->i_inode.i_uid != current_fsuid() &&
-            ip->i_inode.i_uid != current_fsuid() && !capable(CAP_FOWNER))
-                return -EPERM;
-
-        if (IS_APPEND(&dip->i_inode))
-                return -EPERM;
-
-        error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
-        if (error)
-                return error;
-
-        error = gfs2_dir_check(&dip->i_inode, name, ip);
-        if (error)
-                return error;
-
-        return 0;
-}
-
-/**
- * gfs2_readlinki - return the contents of a symlink
- * @ip: the symlink's inode
- * @buf: a pointer to the buffer to be filled
- * @len: a pointer to the length of @buf
- *
- * If @buf is too small, a piece of memory is kmalloc()ed and needs
- * to be freed by the caller.
- *
- * Returns: errno
- */
-
-int gfs2_readlinki(struct gfs2_inode *ip, char **buf, unsigned int *len)
-{
-        struct gfs2_holder i_gh;
-        struct buffer_head *dibh;
-        unsigned int x;
-        int error;
-
-        gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
-        error = gfs2_glock_nq(&i_gh);
-        if (error) {
-                gfs2_holder_uninit(&i_gh);
-                return error;
-        }
-
-        if (!ip->i_disksize) {
-                gfs2_consist_inode(ip);
-                error = -EIO;
-                goto out;
-        }
-
-        error = gfs2_meta_inode_buffer(ip, &dibh);
-        if (error)
-                goto out;
-
-        x = ip->i_disksize + 1;
-        if (x > *len) {
-                *buf = kmalloc(x, GFP_NOFS);
-                if (!*buf) {
-                        error = -ENOMEM;
-                        goto out_brelse;
-                }
-        }
-
-        memcpy(*buf, dibh->b_data + sizeof(struct gfs2_dinode), x);
-        *len = x;
-
-out_brelse:
-        brelse(dibh);
-out:
-        gfs2_glock_dq_uninit(&i_gh);
-        return error;
-}
-
-static int
-__gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
+static int __gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr)
 {
         struct buffer_head *dibh;
         int error;
diff --git a/fs/gfs2/inode.h b/fs/gfs2/inode.h
index c30be2b66580..c341aaf67adb 100644
--- a/fs/gfs2/inode.h
+++ b/fs/gfs2/inode.h
@@ -11,8 +11,16 @@
 #define __INODE_DOT_H__
 
 #include <linux/fs.h>
+#include <linux/buffer_head.h>
+#include <linux/mm.h>
 #include "util.h"
 
+extern int gfs2_releasepage(struct page *page, gfp_t gfp_mask);
+extern int gfs2_internal_read(struct gfs2_inode *ip,
+                              struct file_ra_state *ra_state,
+                              char *buf, loff_t *pos, unsigned size);
+extern void gfs2_set_aops(struct inode *inode);
+
 static inline int gfs2_is_stuffed(const struct gfs2_inode *ip)
 {
         return !ip->i_height;
@@ -73,30 +81,26 @@ static inline void gfs2_inum_out(const struct gfs2_inode *ip,
 }
 
 
-void gfs2_set_iop(struct inode *inode);
-struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned type, 
-                                u64 no_addr, u64 no_formal_ino,
-                                int skip_freeing);
-struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr);
-
-int gfs2_inode_refresh(struct gfs2_inode *ip);
-
-int gfs2_dinode_dealloc(struct gfs2_inode *inode);
-int gfs2_change_nlink(struct gfs2_inode *ip, int diff);
-struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
-                           int is_root);
-struct inode *gfs2_createi(struct gfs2_holder *ghs, const struct qstr *name,
-                           unsigned int mode, dev_t dev);
-int gfs2_rmdiri(struct gfs2_inode *dip, const struct qstr *name,
-                struct gfs2_inode *ip);
-int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
-                   const struct gfs2_inode *ip);
-int gfs2_permission(struct inode *inode, int mask);
-int gfs2_readlinki(struct gfs2_inode *ip, char **buf, unsigned int *len);
-int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr);
-struct inode *gfs2_lookup_simple(struct inode *dip, const char *name);
-void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf);
-void gfs2_dinode_print(const struct gfs2_inode *ip);
+extern void gfs2_set_iop(struct inode *inode);
+extern struct inode *gfs2_inode_lookup(struct super_block *sb, unsigned type, 
+                                       u64 no_addr, u64 no_formal_ino,
+                                       int skip_freeing);
+extern struct inode *gfs2_ilookup(struct super_block *sb, u64 no_addr);
+
+extern int gfs2_inode_refresh(struct gfs2_inode *ip);
+
+extern int gfs2_dinode_dealloc(struct gfs2_inode *inode);
+extern int gfs2_change_nlink(struct gfs2_inode *ip, int diff);
+extern struct inode *gfs2_lookupi(struct inode *dir, const struct qstr *name,
+                                  int is_root);
+extern struct inode *gfs2_createi(struct gfs2_holder *ghs,
+                                  const struct qstr *name,
+                                  unsigned int mode, dev_t dev);
+extern int gfs2_permission(struct inode *inode, int mask);
+extern int gfs2_setattr_simple(struct gfs2_inode *ip, struct iattr *attr);
+extern struct inode *gfs2_lookup_simple(struct inode *dip, const char *name);
+extern void gfs2_dinode_out(const struct gfs2_inode *ip, void *buf);
+extern void gfs2_dinode_print(const struct gfs2_inode *ip);
 
 extern const struct inode_operations gfs2_file_iops;
 extern const struct inode_operations gfs2_dir_iops;
diff --git a/fs/gfs2/log.c b/fs/gfs2/log.c
index 98918a756410..aa62cf5976e8 100644
--- a/fs/gfs2/log.c
+++ b/fs/gfs2/log.c
@@ -120,7 +120,7 @@ __acquires(&sdp->sd_log_lock)
                         lock_buffer(bh);
                         if (test_clear_buffer_dirty(bh)) {
                                 bh->b_end_io = end_buffer_write_sync;
-                                submit_bh(WRITE, bh);
+                                submit_bh(WRITE_SYNC_PLUG, bh);
                         } else {
                                 unlock_buffer(bh);
                                 brelse(bh);
@@ -604,7 +604,7 @@ static void log_write_header(struct gfs2_sbd *sdp, u32 flags, int pull)
         if (test_bit(SDF_NOBARRIERS, &sdp->sd_flags))
                 goto skip_barrier;
         get_bh(bh);
-        submit_bh(WRITE_BARRIER | (1 << BIO_RW_META), bh);
+        submit_bh(WRITE_SYNC | (1 << BIO_RW_BARRIER) | (1 << BIO_RW_META), bh);
         wait_on_buffer(bh);
         if (buffer_eopnotsupp(bh)) {
                 clear_buffer_eopnotsupp(bh);
@@ -664,7 +664,7 @@ static void gfs2_ordered_write(struct gfs2_sbd *sdp)
                 lock_buffer(bh);
                 if (buffer_mapped(bh) && test_clear_buffer_dirty(bh)) {
                         bh->b_end_io = end_buffer_write_sync;
-                        submit_bh(WRITE, bh);
+                        submit_bh(WRITE_SYNC_PLUG, bh);
                 } else {
                         unlock_buffer(bh);
                         brelse(bh);
diff --git a/fs/gfs2/lops.c b/fs/gfs2/lops.c
index 80e4f5f898bb..00315f50fa46 100644
--- a/fs/gfs2/lops.c
+++ b/fs/gfs2/lops.c
@@ -13,6 +13,8 @@
 #include <linux/completion.h>
 #include <linux/buffer_head.h>
 #include <linux/gfs2_ondisk.h>
+#include <linux/bio.h>
+#include <linux/fs.h>
 
 #include "gfs2.h"
 #include "incore.h"
@@ -189,7 +191,7 @@ static void buf_lo_before_commit(struct gfs2_sbd *sdp)
                 }
 
                 gfs2_log_unlock(sdp);
-                submit_bh(WRITE, bh);
+                submit_bh(WRITE_SYNC_PLUG, bh);
                 gfs2_log_lock(sdp);
 
                 n = 0;
@@ -199,7 +201,7 @@ static void buf_lo_before_commit(struct gfs2_sbd *sdp)
                         gfs2_log_unlock(sdp);
                         lock_buffer(bd2->bd_bh);
                         bh = gfs2_log_fake_buf(sdp, bd2->bd_bh);
-                        submit_bh(WRITE, bh);
+                        submit_bh(WRITE_SYNC_PLUG, bh);
                         gfs2_log_lock(sdp);
                         if (++n >= num)
                                 break;
@@ -341,7 +343,7 @@ static void revoke_lo_before_commit(struct gfs2_sbd *sdp)
                 sdp->sd_log_num_revoke--;
 
                 if (offset + sizeof(u64) > sdp->sd_sb.sb_bsize) {
-                        submit_bh(WRITE, bh);
+                        submit_bh(WRITE_SYNC_PLUG, bh);
 
                         bh = gfs2_log_get_buf(sdp);
                         mh = (struct gfs2_meta_header *)bh->b_data;
@@ -358,7 +360,7 @@ static void revoke_lo_before_commit(struct gfs2_sbd *sdp)
         }
         gfs2_assert_withdraw(sdp, !sdp->sd_log_num_revoke);
 
-        submit_bh(WRITE, bh);
+        submit_bh(WRITE_SYNC_PLUG, bh);
 }
 
 static void revoke_lo_before_scan(struct gfs2_jdesc *jd,
@@ -560,7 +562,7 @@ static void gfs2_write_blocks(struct gfs2_sbd *sdp, struct buffer_head *bh,
         ptr = bh_log_ptr(bh);
         
         get_bh(bh);
-        submit_bh(WRITE, bh);
+        submit_bh(WRITE_SYNC_PLUG, bh);
         gfs2_log_lock(sdp);
         while(!list_empty(list)) {
                 bd = list_entry(list->next, struct gfs2_bufdata, bd_le.le_list);
@@ -586,7 +588,7 @@ static void gfs2_write_blocks(struct gfs2_sbd *sdp, struct buffer_head *bh,
                 } else {
                         bh1 = gfs2_log_fake_buf(sdp, bd->bd_bh);
                 }
-                submit_bh(WRITE, bh1);
+                submit_bh(WRITE_SYNC_PLUG, bh1);
                 gfs2_log_lock(sdp);
                 ptr += 2;
         }
diff --git a/fs/gfs2/main.c b/fs/gfs2/main.c
index a6892ed0840a..eacd78a5d082 100644
--- a/fs/gfs2/main.c
+++ b/fs/gfs2/main.c
@@ -15,6 +15,7 @@
 #include <linux/init.h>
 #include <linux/gfs2_ondisk.h>
 #include <asm/atomic.h>
+#include <linux/slow-work.h>
 
 #include "gfs2.h"
 #include "incore.h"
@@ -113,12 +114,18 @@ static int __init init_gfs2_fs(void)
         if (error)
                 goto fail_unregister;
 
+        error = slow_work_register_user();
+        if (error)
+                goto fail_slow;
+
         gfs2_register_debugfs();
 
         printk("GFS2 (built %s %s) installed\n", __DATE__, __TIME__);
 
         return 0;
 
+fail_slow:
+        unregister_filesystem(&gfs2meta_fs_type);
 fail_unregister:
         unregister_filesystem(&gfs2_fs_type);
 fail:
@@ -156,6 +163,7 @@ static void __exit exit_gfs2_fs(void)
         gfs2_unregister_debugfs();
         unregister_filesystem(&gfs2_fs_type);
         unregister_filesystem(&gfs2meta_fs_type);
+        slow_work_unregister_user();
 
         kmem_cache_destroy(gfs2_quotad_cachep);
         kmem_cache_destroy(gfs2_rgrpd_cachep);
diff --git a/fs/gfs2/meta_io.c b/fs/gfs2/meta_io.c
index 8d6f13256b26..cb8d7a93d5ec 100644
--- a/fs/gfs2/meta_io.c
+++ b/fs/gfs2/meta_io.c
@@ -31,19 +31,66 @@
 #include "rgrp.h"
 #include "trans.h"
 #include "util.h"
-#include "ops_address.h"
 
-static int aspace_get_block(struct inode *inode, sector_t lblock,
-                            struct buffer_head *bh_result, int create)
+static int gfs2_aspace_writepage(struct page *page, struct writeback_control *wbc)
 {
-        gfs2_assert_warn(inode->i_sb->s_fs_info, 0);
-        return -EOPNOTSUPP;
-}
+        int err;
+        struct buffer_head *bh, *head;
+        int nr_underway = 0;
+        int write_op = (1 << BIO_RW_META) | ((wbc->sync_mode == WB_SYNC_ALL ?
+                        WRITE_SYNC_PLUG : WRITE));
+
+        BUG_ON(!PageLocked(page));
+        BUG_ON(!page_has_buffers(page));
+
+        head = page_buffers(page);
+        bh = head;
+
+        do {
+                if (!buffer_mapped(bh))
+                        continue;
+                /*
+                 * If it's a fully non-blocking write attempt and we cannot
+                 * lock the buffer then redirty the page.  Note that this can
+                 * potentially cause a busy-wait loop from pdflush and kswapd
+                 * activity, but those code paths have their own higher-level
+                 * throttling.
+                 */
+                if (wbc->sync_mode != WB_SYNC_NONE || !wbc->nonblocking) {
+                        lock_buffer(bh);
+                } else if (!trylock_buffer(bh)) {
+                        redirty_page_for_writepage(wbc, page);
+                        continue;
+                }
+                if (test_clear_buffer_dirty(bh)) {
+                        mark_buffer_async_write(bh);
+                } else {
+                        unlock_buffer(bh);
+                }
+        } while ((bh = bh->b_this_page) != head);
+
+        /*
+         * The page and its buffers are protected by PageWriteback(), so we can
+         * drop the bh refcounts early.
+         */
+        BUG_ON(PageWriteback(page));
+        set_page_writeback(page);
+
+        do {
+                struct buffer_head *next = bh->b_this_page;
+                if (buffer_async_write(bh)) {
+                        submit_bh(write_op, bh);
+                        nr_underway++;
+                }
+                bh = next;
+        } while (bh != head);
+        unlock_page(page);
 
-static int gfs2_aspace_writepage(struct page *page,
-                                 struct writeback_control *wbc)
-{
-        return block_write_full_page(page, aspace_get_block, wbc);
+        err = 0;
+        if (nr_underway == 0)
+                end_page_writeback(page);
+
+        return err;
 }
 
 static const struct address_space_operations aspace_aops = {
@@ -201,16 +248,32 @@ struct buffer_head *gfs2_meta_new(struct gfs2_glock *gl, u64 blkno)
 int gfs2_meta_read(struct gfs2_glock *gl, u64 blkno, int flags,
                    struct buffer_head **bhp)
 {
-        *bhp = gfs2_getbuf(gl, blkno, CREATE);
-        if (!buffer_uptodate(*bhp)) {
-                ll_rw_block(READ_META, 1, bhp);
-                if (flags & DIO_WAIT) {
-                        int error = gfs2_meta_wait(gl->gl_sbd, *bhp);
-                        if (error) {
-                                brelse(*bhp);
-                                return error;
-                        }
-                }
+        struct gfs2_sbd *sdp = gl->gl_sbd;
+        struct buffer_head *bh;
+
+        if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags)))
+                return -EIO;
+
+        *bhp = bh = gfs2_getbuf(gl, blkno, CREATE);
+
+        lock_buffer(bh);
+        if (buffer_uptodate(bh)) {
+                unlock_buffer(bh);
+                return 0;
+        }
+        bh->b_end_io = end_buffer_read_sync;
+        get_bh(bh);
+        submit_bh(READ_SYNC | (1 << BIO_RW_META), bh);
+        if (!(flags & DIO_WAIT))
+                return 0;
+
+        wait_on_buffer(bh);
+        if (unlikely(!buffer_uptodate(bh))) {
+                struct gfs2_trans *tr = current->journal_info;
+                if (tr && tr->tr_touched)
+                        gfs2_io_error_bh(sdp, bh);
+                brelse(bh);
+                return -EIO;
         }
 
         return 0;
@@ -404,7 +467,7 @@ struct buffer_head *gfs2_meta_ra(struct gfs2_glock *gl, u64 dblock, u32 extlen)
         if (buffer_uptodate(first_bh))
                 goto out;
         if (!buffer_locked(first_bh))
-                ll_rw_block(READ_META, 1, &first_bh);
+                ll_rw_block(READ_SYNC | (1 << BIO_RW_META), 1, &first_bh);
 
         dblock++;
         extlen--;
diff --git a/fs/gfs2/mount.c b/fs/gfs2/mount.c
deleted file mode 100644
index f7e8527a21e0..000000000000
--- a/fs/gfs2/mount.c
+++ /dev/null
@@ -1,185 +0,0 @@
-/*
- * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
- * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
- *
- * This copyrighted material is made available to anyone wishing to use,
- * modify, copy, or redistribute it subject to the terms and conditions
- * of the GNU General Public License version 2.
- */
-
-#include <linux/slab.h>
-#include <linux/spinlock.h>
-#include <linux/completion.h>
-#include <linux/buffer_head.h>
-#include <linux/gfs2_ondisk.h>
-#include <linux/parser.h>
-
-#include "gfs2.h"
-#include "incore.h"
-#include "super.h"
-#include "sys.h"
-#include "util.h"
-
-enum {
-        Opt_lockproto,
-        Opt_locktable,
-        Opt_hostdata,
-        Opt_spectator,
-        Opt_ignore_local_fs,
-        Opt_localflocks,
-        Opt_localcaching,
-        Opt_debug,
-        Opt_nodebug,
-        Opt_upgrade,
-        Opt_acl,
-        Opt_noacl,
-        Opt_quota_off,
-        Opt_quota_account,
-        Opt_quota_on,
-        Opt_quota,
-        Opt_noquota,
-        Opt_suiddir,
-        Opt_nosuiddir,
-        Opt_data_writeback,
-        Opt_data_ordered,
-        Opt_meta,
-        Opt_discard,
-        Opt_nodiscard,
-        Opt_err,
-};
-
-static const match_table_t tokens = {
-        {Opt_lockproto, "lockproto=%s"},
-        {Opt_locktable, "locktable=%s"},
-        {Opt_hostdata, "hostdata=%s"},
-        {Opt_spectator, "spectator"},
-        {Opt_ignore_local_fs, "ignore_local_fs"},
-        {Opt_localflocks, "localflocks"},
-        {Opt_localcaching, "localcaching"},
-        {Opt_debug, "debug"},
-        {Opt_nodebug, "nodebug"},
-        {Opt_upgrade, "upgrade"},
-        {Opt_acl, "acl"},
-        {Opt_noacl, "noacl"},
-        {Opt_quota_off, "quota=off"},
-        {Opt_quota_account, "quota=account"},
-        {Opt_quota_on, "quota=on"},
-        {Opt_quota, "quota"},
-        {Opt_noquota, "noquota"},
-        {Opt_suiddir, "suiddir"},
-        {Opt_nosuiddir, "nosuiddir"},
-        {Opt_data_writeback, "data=writeback"},
-        {Opt_data_ordered, "data=ordered"},
-        {Opt_meta, "meta"},
-        {Opt_discard, "discard"},
-        {Opt_nodiscard, "nodiscard"},
-        {Opt_err, NULL}
-};
-
-/**
- * gfs2_mount_args - Parse mount options
- * @sdp:
- * @data:
- *
- * Return: errno
- */
-
-int gfs2_mount_args(struct gfs2_sbd *sdp, struct gfs2_args *args, char *options)
-{
-        char *o;
-        int token;
-        substring_t tmp[MAX_OPT_ARGS];
-
-        /* Split the options into tokens with the "," character and
-           process them */
-
-        while (1) {
-                o = strsep(&options, ",");
-                if (o == NULL)
-                        break;
-                if (*o == '\0')
-                        continue;
-
-                token = match_token(o, tokens, tmp);
-                switch (token) {
-                case Opt_lockproto:
-                        match_strlcpy(args->ar_lockproto, &tmp[0],
-                                      GFS2_LOCKNAME_LEN);
-                        break;
-                case Opt_locktable:
-                        match_strlcpy(args->ar_locktable, &tmp[0],
-                                      GFS2_LOCKNAME_LEN);
-                        break;
-                case Opt_hostdata:
-                        match_strlcpy(args->ar_hostdata, &tmp[0],
-                                      GFS2_LOCKNAME_LEN);
-                        break;
-                case Opt_spectator:
-                        args->ar_spectator = 1;
-                        break;
-                case Opt_ignore_local_fs:
-                        args->ar_ignore_local_fs = 1;
-                        break;
-                case Opt_localflocks:
-                        args->ar_localflocks = 1;
-                        break;
-                case Opt_localcaching:
-                        args->ar_localcaching = 1;
-                        break;
-                case Opt_debug:
-                        args->ar_debug = 1;
-                        break;
-                case Opt_nodebug:
-                        args->ar_debug = 0;
-                        break;
-                case Opt_upgrade:
-                        args->ar_upgrade = 1;
-                        break;
-                case Opt_acl:
-                        args->ar_posix_acl = 1;
-                        break;
-                case Opt_noacl:
-                        args->ar_posix_acl = 0;
-                        break;
-                case Opt_quota_off:
-                case Opt_noquota:
-                        args->ar_quota = GFS2_QUOTA_OFF;
-                        break;
-                case Opt_quota_account:
-                        args->ar_quota = GFS2_QUOTA_ACCOUNT;
-                        break;
-                case Opt_quota_on:
-                case Opt_quota:
-                        args->ar_quota = GFS2_QUOTA_ON;
-                        break;
-                case Opt_suiddir:
-                        args->ar_suiddir = 1;
-                        break;
-                case Opt_nosuiddir:
-                        args->ar_suiddir = 0;
-                        break;
-                case Opt_data_writeback:
-                        args->ar_data = GFS2_DATA_WRITEBACK;
-                        break;
-                case Opt_data_ordered:
-                        args->ar_data = GFS2_DATA_ORDERED;
-                        break;
-                case Opt_meta:
-                        args->ar_meta = 1;
-                        break;
-                case Opt_discard:
-                        args->ar_discard = 1;
-                        break;
-                case Opt_nodiscard:
-                        args->ar_discard = 0;
-                        break;
-                case Opt_err:
-                default:
-                        fs_info(sdp, "invalid mount option: %s\n", o);
-                        return -EINVAL;
-                }
-        }
-
-        return 0;
-}
-
diff --git a/fs/gfs2/ops_address.h b/fs/gfs2/ops_address.h
deleted file mode 100644
index 5da21285bba4..000000000000
--- a/fs/gfs2/ops_address.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
- * Copyright (C) 2004-2007 Red Hat, Inc.  All rights reserved.
- *
- * This copyrighted material is made available to anyone wishing to use,
- * modify, copy, or redistribute it subject to the terms and conditions
- * of the GNU General Public License version 2.
- */
-
-#ifndef __OPS_ADDRESS_DOT_H__
-#define __OPS_ADDRESS_DOT_H__
-
-#include <linux/fs.h>
-#include <linux/buffer_head.h>
-#include <linux/mm.h>
-
-extern int gfs2_releasepage(struct page *page, gfp_t gfp_mask);
-extern int gfs2_internal_read(struct gfs2_inode *ip,
-                              struct file_ra_state *ra_state,
-                              char *buf, loff_t *pos, unsigned size);
-extern void gfs2_set_aops(struct inode *inode);
-
-#endif /* __OPS_ADDRESS_DOT_H__ */
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index 1ff9473ea753..cc34f271b3e7 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -17,6 +17,7 @@
 #include <linux/namei.h>
 #include <linux/mount.h>
 #include <linux/gfs2_ondisk.h>
+#include <linux/slow-work.h>
 
 #include "gfs2.h"
 #include "incore.h"
@@ -55,8 +56,6 @@ static void gfs2_tune_init(struct gfs2_tune *gt)
         spin_lock_init(&gt->gt_spin);
 
         gt->gt_incore_log_blocks = 1024;
-        gt->gt_log_flush_secs = 60;
-        gt->gt_recoverd_secs = 60;
         gt->gt_logd_secs = 1;
         gt->gt_quota_simul_sync = 64;
         gt->gt_quota_warn_period = 10;
@@ -526,11 +525,11 @@ static int init_sb(struct gfs2_sbd *sdp, int silent)
         }
 
         /* Set up the buffer cache and SB for real */
-        if (sdp->sd_sb.sb_bsize < bdev_hardsect_size(sb->s_bdev)) {
+        if (sdp->sd_sb.sb_bsize < bdev_logical_block_size(sb->s_bdev)) {
                 ret = -EINVAL;
                 fs_err(sdp, "FS block size (%u) is too small for device "
                        "block size (%u)\n",
-                       sdp->sd_sb.sb_bsize, bdev_hardsect_size(sb->s_bdev));
+                       sdp->sd_sb.sb_bsize, bdev_logical_block_size(sb->s_bdev));
                 goto out;
         }
         if (sdp->sd_sb.sb_bsize > PAGE_SIZE) {
@@ -676,6 +675,7 @@ static int gfs2_jindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ji_gh)
                         break;
 
                 INIT_LIST_HEAD(&jd->extent_list);
+                slow_work_init(&jd->jd_work, &gfs2_recover_ops);
                 jd->jd_inode = gfs2_lookupi(sdp->sd_jindex, &name, 1);
                 if (!jd->jd_inode || IS_ERR(jd->jd_inode)) {
                         if (!jd->jd_inode)
@@ -701,14 +701,13 @@ static int init_journal(struct gfs2_sbd *sdp, int undo)
 {
         struct inode *master = sdp->sd_master_dir->d_inode;
         struct gfs2_holder ji_gh;
-        struct task_struct *p;
         struct gfs2_inode *ip;
         int jindex = 1;
         int error = 0;
 
         if (undo) {
                 jindex = 0;
-                goto fail_recoverd;
+                goto fail_jinode_gh;
         }
 
         sdp->sd_jindex = gfs2_lookup_simple(master, "jindex");
@@ -801,18 +800,8 @@ static int init_journal(struct gfs2_sbd *sdp, int undo)
         gfs2_glock_dq_uninit(&ji_gh);
         jindex = 0;
 
-        p = kthread_run(gfs2_recoverd, sdp, "gfs2_recoverd");
-        error = IS_ERR(p);
-        if (error) {
-                fs_err(sdp, "can't start recoverd thread: %d\n", error);
-                goto fail_jinode_gh;
-        }
-        sdp->sd_recoverd_process = p;
-
         return 0;
 
-fail_recoverd:
-        kthread_stop(sdp->sd_recoverd_process);
 fail_jinode_gh:
         if (!sdp->sd_args.ar_spectator)
                 gfs2_glock_dq_uninit(&sdp->sd_jinode_gh);
@@ -1165,6 +1154,7 @@ static int fill_super(struct super_block *sb, void *data, int silent)
 
         sdp->sd_args.ar_quota = GFS2_QUOTA_DEFAULT;
         sdp->sd_args.ar_data = GFS2_DATA_DEFAULT;
+        sdp->sd_args.ar_commit = 60;
 
         error = gfs2_mount_args(sdp, &sdp->sd_args, data);
         if (error) {
@@ -1172,8 +1162,10 @@ static int fill_super(struct super_block *sb, void *data, int silent)
                 goto fail;
         }
 
-        if (sdp->sd_args.ar_spectator)
+        if (sdp->sd_args.ar_spectator) {
                 sb->s_flags |= MS_RDONLY;
+                set_bit(SDF_NORECOVERY, &sdp->sd_flags);
+        }
         if (sdp->sd_args.ar_posix_acl)
                 sb->s_flags |= MS_POSIXACL;
 
@@ -1191,6 +1183,8 @@ static int fill_super(struct super_block *sb, void *data, int silent)
                                GFS2_BASIC_BLOCK_SHIFT;
         sdp->sd_fsb2bb = 1 << sdp->sd_fsb2bb_shift;
 
+        sdp->sd_tune.gt_log_flush_secs = sdp->sd_args.ar_commit;
+
         error = init_names(sdp, silent);
         if (error)
                 goto fail;
@@ -1279,9 +1273,22 @@ static int gfs2_get_sb(struct file_system_type *fs_type, int flags,
         return get_sb_bdev(fs_type, flags, dev_name, data, fill_super, mnt);
 }
 
-static struct super_block *get_gfs2_sb(const char *dev_name)
+static int test_meta_super(struct super_block *s, void *ptr)
+{
+        struct block_device *bdev = ptr;
+        return (bdev == s->s_bdev);
+}
+
+static int set_meta_super(struct super_block *s, void *ptr)
 {
-        struct super_block *sb;
+        return -EINVAL;
+}
+
+static int gfs2_get_sb_meta(struct file_system_type *fs_type, int flags,
+                            const char *dev_name, void *data, struct vfsmount *mnt)
+{
+        struct super_block *s;
+        struct gfs2_sbd *sdp;
         struct path path;
         int error;
 
@@ -1289,30 +1296,17 @@ static struct super_block *get_gfs2_sb(const char *dev_name)
         if (error) {
                 printk(KERN_WARNING "GFS2: path_lookup on %s returned error %d\n",
                        dev_name, error);
-                return NULL;
+                return error;
         }
-        sb = path.dentry->d_inode->i_sb;
-        if (sb && (sb->s_type == &gfs2_fs_type))
-                atomic_inc(&sb->s_active);
-        else
-                sb = NULL;
+        s = sget(&gfs2_fs_type, test_meta_super, set_meta_super,
+                 path.dentry->d_inode->i_sb->s_bdev);
         path_put(&path);
-        return sb;
-}
-
-static int gfs2_get_sb_meta(struct file_system_type *fs_type, int flags,
-                            const char *dev_name, void *data, struct vfsmount *mnt)
-{
-        struct super_block *sb = NULL;
-        struct gfs2_sbd *sdp;
-
-        sb = get_gfs2_sb(dev_name);
-        if (!sb) {
+        if (IS_ERR(s)) {
                 printk(KERN_WARNING "GFS2: gfs2 mount does not exist\n");
-                return -ENOENT;
+                return PTR_ERR(s);
         }
-        sdp = sb->s_fs_info;
-        mnt->mnt_sb = sb;
+        sdp = s->s_fs_info;
+        mnt->mnt_sb = s;
         mnt->mnt_root = dget(sdp->sd_master_dir);
         return 0;
 }
diff --git a/fs/gfs2/ops_inode.c b/fs/gfs2/ops_inode.c
index 1c70fa5168d6..f8bd20baf99c 100644
--- a/fs/gfs2/ops_inode.c
+++ b/fs/gfs2/ops_inode.c
@@ -262,6 +262,44 @@ out_parent:
         return error;
 }
 
+/*
+ * gfs2_unlink_ok - check to see that a inode is still in a directory
+ * @dip: the directory
+ * @name: the name of the file
+ * @ip: the inode
+ *
+ * Assumes that the lock on (at least) @dip is held.
+ *
+ * Returns: 0 if the parent/child relationship is correct, errno if it isn't
+ */
+
+static int gfs2_unlink_ok(struct gfs2_inode *dip, const struct qstr *name,
+                          const struct gfs2_inode *ip)
+{
+        int error;
+
+        if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
+                return -EPERM;
+
+        if ((dip->i_inode.i_mode & S_ISVTX) &&
+            dip->i_inode.i_uid != current_fsuid() &&
+            ip->i_inode.i_uid != current_fsuid() && !capable(CAP_FOWNER))
+                return -EPERM;
+
+        if (IS_APPEND(&dip->i_inode))
+                return -EPERM;
+
+        error = gfs2_permission(&dip->i_inode, MAY_WRITE | MAY_EXEC);
+        if (error)
+                return error;
+
+        error = gfs2_dir_check(&dip->i_inode, name, ip);
+        if (error)
+                return error;
+
+        return 0;
+}
+
 /**
  * gfs2_unlink - Unlink a file
  * @dir: The inode of the directory containing the file to unlink
@@ -473,6 +511,59 @@ static int gfs2_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 }
 
 /**
+ * gfs2_rmdiri - Remove a directory
+ * @dip: The parent directory of the directory to be removed
+ * @name: The name of the directory to be removed
+ * @ip: The GFS2 inode of the directory to be removed
+ *
+ * Assumes Glocks on dip and ip are held
+ *
+ * Returns: errno
+ */
+
+static int gfs2_rmdiri(struct gfs2_inode *dip, const struct qstr *name,
+                       struct gfs2_inode *ip)
+{
+        struct qstr dotname;
+        int error;
+
+        if (ip->i_entries != 2) {
+                if (gfs2_consist_inode(ip))
+                        gfs2_dinode_print(ip);
+                return -EIO;
+        }
+
+        error = gfs2_dir_del(dip, name);
+        if (error)
+                return error;
+
+        error = gfs2_change_nlink(dip, -1);
+        if (error)
+                return error;
+
+        gfs2_str2qstr(&dotname, ".");
+        error = gfs2_dir_del(ip, &dotname);
+        if (error)
+                return error;
+
+        gfs2_str2qstr(&dotname, "..");
+        error = gfs2_dir_del(ip, &dotname);
+        if (error)
+                return error;
+
+        /* It looks odd, but it really should be done twice */
+        error = gfs2_change_nlink(ip, -1);
+        if (error)
+                return error;
+
+        error = gfs2_change_nlink(ip, -1);
+        if (error)
+                return error;
+
+        return error;
+}
+
+/**
  * gfs2_rmdir - Remove a directory
  * @dir: The parent directory of the directory to be removed
  * @dentry: The dentry of the directory to remove
@@ -885,6 +976,61 @@ out:
 }
 
 /**
+ * gfs2_readlinki - return the contents of a symlink
+ * @ip: the symlink's inode
+ * @buf: a pointer to the buffer to be filled
+ * @len: a pointer to the length of @buf
+ *
+ * If @buf is too small, a piece of memory is kmalloc()ed and needs
+ * to be freed by the caller.
+ *
+ * Returns: errno
+ */
+
+static int gfs2_readlinki(struct gfs2_inode *ip, char **buf, unsigned int *len)
+{
+        struct gfs2_holder i_gh;
+        struct buffer_head *dibh;
+        unsigned int x;
+        int error;
+
+        gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
+        error = gfs2_glock_nq(&i_gh);
+        if (error) {
+                gfs2_holder_uninit(&i_gh);
+                return error;
+        }
+
+        if (!ip->i_disksize) {
+                gfs2_consist_inode(ip);
+                error = -EIO;
+                goto out;
+        }
+
+        error = gfs2_meta_inode_buffer(ip, &dibh);
+        if (error)
+                goto out;
+
+        x = ip->i_disksize + 1;
+        if (x > *len) {
+                *buf = kmalloc(x, GFP_NOFS);
+                if (!*buf) {
+                        error = -ENOMEM;
+                        goto out_brelse;
+                }
+        }
+
+        memcpy(*buf, dibh->b_data + sizeof(struct gfs2_dinode), x);
+        *len = x;
+
+out_brelse:
+        brelse(dibh);
+out:
+        gfs2_glock_dq_uninit(&i_gh);
+        return error;
+}
+
+/**
  * gfs2_readlink - Read the value of a symlink
  * @dentry: the symlink
  * @buf: the buffer to read the symlink data into
diff --git a/fs/gfs2/ops_super.c b/fs/gfs2/ops_super.c
deleted file mode 100644
index 458019569dcb..000000000000
--- a/fs/gfs2/ops_super.c
+++ /dev/null
@@ -1,723 +0,0 @@
-/*
- * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
- * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
- *
- * This copyrighted material is made available to anyone wishing to use,
- * modify, copy, or redistribute it subject to the terms and conditions
- * of the GNU General Public License version 2.
- */
-
-#include <linux/sched.h>
-#include <linux/slab.h>
-#include <linux/spinlock.h>
-#include <linux/completion.h>
-#include <linux/buffer_head.h>
-#include <linux/statfs.h>
-#include <linux/seq_file.h>
-#include <linux/mount.h>
-#include <linux/kthread.h>
-#include <linux/delay.h>
-#include <linux/gfs2_ondisk.h>
-#include <linux/crc32.h>
-#include <linux/time.h>
-
-#include "gfs2.h"
-#include "incore.h"
-#include "glock.h"
-#include "inode.h"
-#include "log.h"
-#include "quota.h"
-#include "recovery.h"
-#include "rgrp.h"
-#include "super.h"
-#include "sys.h"
-#include "util.h"
-#include "trans.h"
-#include "dir.h"
-#include "eattr.h"
-#include "bmap.h"
-#include "meta_io.h"
-
-#define args_neq(a1, a2, x) ((a1)->ar_##x != (a2)->ar_##x)
-
-/**
- * gfs2_write_inode - Make sure the inode is stable on the disk
- * @inode: The inode
- * @sync: synchronous write flag
- *
- * Returns: errno
- */
-
-static int gfs2_write_inode(struct inode *inode, int sync)
-{
-        struct gfs2_inode *ip = GFS2_I(inode);
-        struct gfs2_sbd *sdp = GFS2_SB(inode);
-        struct gfs2_holder gh;
-        struct buffer_head *bh;
-        struct timespec atime;
-        struct gfs2_dinode *di;
-        int ret = 0;
-
-        /* Check this is a "normal" inode, etc */
-        if (!test_bit(GIF_USER, &ip->i_flags) ||
-            (current->flags & PF_MEMALLOC))
-                return 0;
-        ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
-        if (ret)
-                goto do_flush;
-        ret = gfs2_trans_begin(sdp, RES_DINODE, 0);
-        if (ret)
-                goto do_unlock;
-        ret = gfs2_meta_inode_buffer(ip, &bh);
-        if (ret == 0) {
-                di = (struct gfs2_dinode *)bh->b_data;
-                atime.tv_sec = be64_to_cpu(di->di_atime);
-                atime.tv_nsec = be32_to_cpu(di->di_atime_nsec);
-                if (timespec_compare(&inode->i_atime, &atime) > 0) {
-                        gfs2_trans_add_bh(ip->i_gl, bh, 1);
-                        gfs2_dinode_out(ip, bh->b_data);
-                }
-                brelse(bh);
-        }
-        gfs2_trans_end(sdp);
-do_unlock:
-        gfs2_glock_dq_uninit(&gh);
-do_flush:
-        if (sync != 0)
-                gfs2_log_flush(GFS2_SB(inode), ip->i_gl);
-        return ret;
-}
-
-/**
- * gfs2_make_fs_ro - Turn a Read-Write FS into a Read-Only one
- * @sdp: the filesystem
- *
- * Returns: errno
- */
-
-static int gfs2_make_fs_ro(struct gfs2_sbd *sdp)
-{
-        struct gfs2_holder t_gh;
-        int error;
-
-        gfs2_quota_sync(sdp);
-        gfs2_statfs_sync(sdp);
-
-        error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED, GL_NOCACHE,
-                                   &t_gh);
-        if (error && !test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
-                return error;
-
-        gfs2_meta_syncfs(sdp);
-        gfs2_log_shutdown(sdp);
-
-        clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
-
-        if (t_gh.gh_gl)
-                gfs2_glock_dq_uninit(&t_gh);
-
-        gfs2_quota_cleanup(sdp);
-
-        return error;
-}
-
-/**
- * gfs2_put_super - Unmount the filesystem
- * @sb: The VFS superblock
- *
- */
-
-static void gfs2_put_super(struct super_block *sb)
-{
-        struct gfs2_sbd *sdp = sb->s_fs_info;
-        int error;
-
-        /*  Unfreeze the filesystem, if we need to  */
-
-        mutex_lock(&sdp->sd_freeze_lock);
-        if (sdp->sd_freeze_count)
-                gfs2_glock_dq_uninit(&sdp->sd_freeze_gh);
-        mutex_unlock(&sdp->sd_freeze_lock);
-
-        kthread_stop(sdp->sd_quotad_process);
-        kthread_stop(sdp->sd_logd_process);
-        kthread_stop(sdp->sd_recoverd_process);
-
-        if (!(sb->s_flags & MS_RDONLY)) {
-                error = gfs2_make_fs_ro(sdp);
-                if (error)
-                        gfs2_io_error(sdp);
-        }
-        /*  At this point, we're through modifying the disk  */
-
-        /*  Release stuff  */
-
-        iput(sdp->sd_jindex);
-        iput(sdp->sd_inum_inode);
-        iput(sdp->sd_statfs_inode);
-        iput(sdp->sd_rindex);
-        iput(sdp->sd_quota_inode);
-
-        gfs2_glock_put(sdp->sd_rename_gl);
-        gfs2_glock_put(sdp->sd_trans_gl);
-
-        if (!sdp->sd_args.ar_spectator) {
-                gfs2_glock_dq_uninit(&sdp->sd_journal_gh);
-                gfs2_glock_dq_uninit(&sdp->sd_jinode_gh);
-                gfs2_glock_dq_uninit(&sdp->sd_ir_gh);
-                gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
-                gfs2_glock_dq_uninit(&sdp->sd_qc_gh);
-                iput(sdp->sd_ir_inode);
-                iput(sdp->sd_sc_inode);
-                iput(sdp->sd_qc_inode);
-        }
-
-        gfs2_glock_dq_uninit(&sdp->sd_live_gh);
-        gfs2_clear_rgrpd(sdp);
-        gfs2_jindex_free(sdp);
-        /*  Take apart glock structures and buffer lists  */
-        gfs2_gl_hash_clear(sdp);
-        /*  Unmount the locking protocol  */
-        gfs2_lm_unmount(sdp);
-
-        /*  At this point, we're through participating in the lockspace  */
-        gfs2_sys_fs_del(sdp);
-}
-
-/**
- * gfs2_write_super
- * @sb: the superblock
- *
- */
-
-static void gfs2_write_super(struct super_block *sb)
-{
-        sb->s_dirt = 0;
-}
-
-/**
- * gfs2_sync_fs - sync the filesystem
- * @sb: the superblock
- *
- * Flushes the log to disk.
- */
-
-static int gfs2_sync_fs(struct super_block *sb, int wait)
-{
-        sb->s_dirt = 0;
-        if (wait && sb->s_fs_info)
-                gfs2_log_flush(sb->s_fs_info, NULL);
-        return 0;
-}
-
-/**
- * gfs2_freeze - prevent further writes to the filesystem
- * @sb: the VFS structure for the filesystem
- *
- */
-
-static int gfs2_freeze(struct super_block *sb)
-{
-        struct gfs2_sbd *sdp = sb->s_fs_info;
-        int error;
-
-        if (test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
-                return -EINVAL;
-
-        for (;;) {
-                error = gfs2_freeze_fs(sdp);
-                if (!error)
-                        break;
-
-                switch (error) {
-                case -EBUSY:
-                        fs_err(sdp, "waiting for recovery before freeze\n");
-                        break;
-
-                default:
-                        fs_err(sdp, "error freezing FS: %d\n", error);
-                        break;
-                }
-
-                fs_err(sdp, "retrying...\n");
-                msleep(1000);
-        }
-        return 0;
-}
-
-/**
- * gfs2_unfreeze - reallow writes to the filesystem
- * @sb: the VFS structure for the filesystem
- *
- */
-
-static int gfs2_unfreeze(struct super_block *sb)
-{
-        gfs2_unfreeze_fs(sb->s_fs_info);
-        return 0;
-}
-
-/**
- * statfs_fill - fill in the sg for a given RG
- * @rgd: the RG
- * @sc: the sc structure
- *
- * Returns: 0 on success, -ESTALE if the LVB is invalid
- */
-
-static int statfs_slow_fill(struct gfs2_rgrpd *rgd,
-                            struct gfs2_statfs_change_host *sc)
-{
-        gfs2_rgrp_verify(rgd);
-        sc->sc_total += rgd->rd_data;
-        sc->sc_free += rgd->rd_free;
-        sc->sc_dinodes += rgd->rd_dinodes;
-        return 0;
-}
-
-/**
- * gfs2_statfs_slow - Stat a filesystem using asynchronous locking
- * @sdp: the filesystem
- * @sc: the sc info that will be returned
- *
- * Any error (other than a signal) will cause this routine to fall back
- * to the synchronous version.
- *
- * FIXME: This really shouldn't busy wait like this.
- *
- * Returns: errno
- */
-
-static int gfs2_statfs_slow(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *sc)
-{
-        struct gfs2_holder ri_gh;
-        struct gfs2_rgrpd *rgd_next;
-        struct gfs2_holder *gha, *gh;
-        unsigned int slots = 64;
-        unsigned int x;
-        int done;
-        int error = 0, err;
-
-        memset(sc, 0, sizeof(struct gfs2_statfs_change_host));
-        gha = kcalloc(slots, sizeof(struct gfs2_holder), GFP_KERNEL);
-        if (!gha)
-                return -ENOMEM;
-
-        error = gfs2_rindex_hold(sdp, &ri_gh);
-        if (error)
-                goto out;
-
-        rgd_next = gfs2_rgrpd_get_first(sdp);
-
-        for (;;) {
-                done = 1;
-
-                for (x = 0; x < slots; x++) {
-                        gh = gha + x;
-
-                        if (gh->gh_gl && gfs2_glock_poll(gh)) {
-                                err = gfs2_glock_wait(gh);
-                                if (err) {
-                                        gfs2_holder_uninit(gh);
-                                        error = err;
-                                } else {
-                                        if (!error)
-                                                error = statfs_slow_fill(
-                                                        gh->gh_gl->gl_object, sc);
-                                        gfs2_glock_dq_uninit(gh);
-                                }
-                        }
-
-                        if (gh->gh_gl)
-                                done = 0;
-                        else if (rgd_next && !error) {
-                                error = gfs2_glock_nq_init(rgd_next->rd_gl,
-                                                           LM_ST_SHARED,
-                                                           GL_ASYNC,
-                                                           gh);
-                                rgd_next = gfs2_rgrpd_get_next(rgd_next);
-                                done = 0;
-                        }
-
-                        if (signal_pending(current))
-                                error = -ERESTARTSYS;
-                }
-
-                if (done)
-                        break;
-
-                yield();
-        }
-
-        gfs2_glock_dq_uninit(&ri_gh);
-
-out:
-        kfree(gha);
-        return error;
-}
-
-/**
- * gfs2_statfs_i - Do a statfs
- * @sdp: the filesystem
- * @sg: the sg structure
- *
- * Returns: errno
- */
-
-static int gfs2_statfs_i(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *sc)
-{
-        struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
-        struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
-
-        spin_lock(&sdp->sd_statfs_spin);
-
-        *sc = *m_sc;
-        sc->sc_total += l_sc->sc_total;
-        sc->sc_free += l_sc->sc_free;
-        sc->sc_dinodes += l_sc->sc_dinodes;
-
-        spin_unlock(&sdp->sd_statfs_spin);
-
-        if (sc->sc_free < 0)
-                sc->sc_free = 0;
-        if (sc->sc_free > sc->sc_total)
-                sc->sc_free = sc->sc_total;
-        if (sc->sc_dinodes < 0)
-                sc->sc_dinodes = 0;
-
-        return 0;
-}
-
-/**
- * gfs2_statfs - Gather and return stats about the filesystem
- * @sb: The superblock
- * @statfsbuf: The buffer
- *
- * Returns: 0 on success or error code
- */
-
-static int gfs2_statfs(struct dentry *dentry, struct kstatfs *buf)
-{
-        struct super_block *sb = dentry->d_inode->i_sb;
-        struct gfs2_sbd *sdp = sb->s_fs_info;
-        struct gfs2_statfs_change_host sc;
-        int error;
-
-        if (gfs2_tune_get(sdp, gt_statfs_slow))
-                error = gfs2_statfs_slow(sdp, &sc);
-        else
-                error = gfs2_statfs_i(sdp, &sc);
-
-        if (error)
-                return error;
-
-        buf->f_type = GFS2_MAGIC;
-        buf->f_bsize = sdp->sd_sb.sb_bsize;
-        buf->f_blocks = sc.sc_total;
-        buf->f_bfree = sc.sc_free;
-        buf->f_bavail = sc.sc_free;
-        buf->f_files = sc.sc_dinodes + sc.sc_free;
-        buf->f_ffree = sc.sc_free;
-        buf->f_namelen = GFS2_FNAMESIZE;
-
-        return 0;
-}
-
-/**
- * gfs2_remount_fs - called when the FS is remounted
- * @sb:  the filesystem
- * @flags:  the remount flags
- * @data:  extra data passed in (not used right now)
- *
- * Returns: errno
- */
-
-static int gfs2_remount_fs(struct super_block *sb, int *flags, char *data)
-{
-        struct gfs2_sbd *sdp = sb->s_fs_info;
-        struct gfs2_args args = sdp->sd_args; /* Default to current settings */
-        int error;
-
-        error = gfs2_mount_args(sdp, &args, data);
-        if (error)
-                return error;
-
-        /* Not allowed to change locking details */
-        if (strcmp(args.ar_lockproto, sdp->sd_args.ar_lockproto) ||
-            strcmp(args.ar_locktable, sdp->sd_args.ar_locktable) ||
-            strcmp(args.ar_hostdata, sdp->sd_args.ar_hostdata))
-                return -EINVAL;
-
-        /* Some flags must not be changed */
-        if (args_neq(&args, &sdp->sd_args, spectator) ||
-            args_neq(&args, &sdp->sd_args, ignore_local_fs) ||
-            args_neq(&args, &sdp->sd_args, localflocks) ||
-            args_neq(&args, &sdp->sd_args, localcaching) ||
-            args_neq(&args, &sdp->sd_args, meta))
-                return -EINVAL;
-
-        if (sdp->sd_args.ar_spectator)
-                *flags |= MS_RDONLY;
-
-        if ((sb->s_flags ^ *flags) & MS_RDONLY) {
-                if (*flags & MS_RDONLY)
-                        error = gfs2_make_fs_ro(sdp);
-                else
-                        error = gfs2_make_fs_rw(sdp);
-                if (error)
-                        return error;
-        }
-
-        sdp->sd_args = args;
-        if (sdp->sd_args.ar_posix_acl)
-                sb->s_flags |= MS_POSIXACL;
-        else
-                sb->s_flags &= ~MS_POSIXACL;
-        return 0;
-}
-
-/**
- * gfs2_drop_inode - Drop an inode (test for remote unlink)
- * @inode: The inode to drop
- *
- * If we've received a callback on an iopen lock then its because a
- * remote node tried to deallocate the inode but failed due to this node
- * still having the inode open. Here we mark the link count zero
- * since we know that it must have reached zero if the GLF_DEMOTE flag
- * is set on the iopen glock. If we didn't do a disk read since the
- * remote node removed the final link then we might otherwise miss
- * this event. This check ensures that this node will deallocate the
- * inode's blocks, or alternatively pass the baton on to another
- * node for later deallocation.
- */
-
-static void gfs2_drop_inode(struct inode *inode)
-{
-        struct gfs2_inode *ip = GFS2_I(inode);
-
-        if (test_bit(GIF_USER, &ip->i_flags) && inode->i_nlink) {
-                struct gfs2_glock *gl = ip->i_iopen_gh.gh_gl;
-                if (gl && test_bit(GLF_DEMOTE, &gl->gl_flags))
-                        clear_nlink(inode);
-        }
-        generic_drop_inode(inode);
-}
-
-/**
- * gfs2_clear_inode - Deallocate an inode when VFS is done with it
- * @inode: The VFS inode
- *
- */
-
-static void gfs2_clear_inode(struct inode *inode)
-{
-        struct gfs2_inode *ip = GFS2_I(inode);
-
-        /* This tells us its a "real" inode and not one which only
-         * serves to contain an address space (see rgrp.c, meta_io.c)
-         * which therefore doesn't have its own glocks.
-         */
-        if (test_bit(GIF_USER, &ip->i_flags)) {
-                ip->i_gl->gl_object = NULL;
-                gfs2_glock_put(ip->i_gl);
-                ip->i_gl = NULL;
-                if (ip->i_iopen_gh.gh_gl) {
-                        ip->i_iopen_gh.gh_gl->gl_object = NULL;
-                        gfs2_glock_dq_uninit(&ip->i_iopen_gh);
-                }
-        }
-}
-
-static int is_ancestor(const struct dentry *d1, const struct dentry *d2)
-{
-        do {
-                if (d1 == d2)
-                        return 1;
-                d1 = d1->d_parent;
-        } while (!IS_ROOT(d1));
-        return 0;
-}
-
-/**
- * gfs2_show_options - Show mount options for /proc/mounts
- * @s: seq_file structure
- * @mnt: vfsmount
- *
- * Returns: 0 on success or error code
- */
-
-static int gfs2_show_options(struct seq_file *s, struct vfsmount *mnt)
-{
-        struct gfs2_sbd *sdp = mnt->mnt_sb->s_fs_info;
-        struct gfs2_args *args = &sdp->sd_args;
-
-        if (is_ancestor(mnt->mnt_root, sdp->sd_master_dir))
-                seq_printf(s, ",meta");
-        if (args->ar_lockproto[0])
-                seq_printf(s, ",lockproto=%s", args->ar_lockproto);
-        if (args->ar_locktable[0])
-                seq_printf(s, ",locktable=%s", args->ar_locktable);
-        if (args->ar_hostdata[0])
-                seq_printf(s, ",hostdata=%s", args->ar_hostdata);
-        if (args->ar_spectator)
-                seq_printf(s, ",spectator");
-        if (args->ar_ignore_local_fs)
-                seq_printf(s, ",ignore_local_fs");
-        if (args->ar_localflocks)
-                seq_printf(s, ",localflocks");
-        if (args->ar_localcaching)
-                seq_printf(s, ",localcaching");
-        if (args->ar_debug)
-                seq_printf(s, ",debug");
-        if (args->ar_upgrade)
-                seq_printf(s, ",upgrade");
-        if (args->ar_posix_acl)
-                seq_printf(s, ",acl");
-        if (args->ar_quota != GFS2_QUOTA_DEFAULT) {
-                char *state;
-                switch (args->ar_quota) {
-                case GFS2_QUOTA_OFF:
-                        state = "off";
-                        break;
-                case GFS2_QUOTA_ACCOUNT:
-                        state = "account";
-                        break;
-                case GFS2_QUOTA_ON:
-                        state = "on";
-                        break;
-                default:
-                        state = "unknown";
-                        break;
-                }
-                seq_printf(s, ",quota=%s", state);
-        }
-        if (args->ar_suiddir)
-                seq_printf(s, ",suiddir");
-        if (args->ar_data != GFS2_DATA_DEFAULT) {
-                char *state;
-                switch (args->ar_data) {
-                case GFS2_DATA_WRITEBACK:
-                        state = "writeback";
-                        break;
-                case GFS2_DATA_ORDERED:
-                        state = "ordered";
-                        break;
-                default:
-                        state = "unknown";
-                        break;
-                }
-                seq_printf(s, ",data=%s", state);
-        }
-        if (args->ar_discard)
-                seq_printf(s, ",discard");
-
-        return 0;
-}
-
-/*
- * We have to (at the moment) hold the inodes main lock to cover
- * the gap between unlocking the shared lock on the iopen lock and
- * taking the exclusive lock. I'd rather do a shared -> exclusive
- * conversion on the iopen lock, but we can change that later. This
- * is safe, just less efficient.
- */
-
-static void gfs2_delete_inode(struct inode *inode)
-{
-        struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
-        struct gfs2_inode *ip = GFS2_I(inode);
-        struct gfs2_holder gh;
-        int error;
-
-        if (!test_bit(GIF_USER, &ip->i_flags))
-                goto out;
-
-        error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
-        if (unlikely(error)) {
-                gfs2_glock_dq_uninit(&ip->i_iopen_gh);
-                goto out;
-        }
-
-        gfs2_glock_dq_wait(&ip->i_iopen_gh);
-        gfs2_holder_reinit(LM_ST_EXCLUSIVE, LM_FLAG_TRY_1CB | GL_NOCACHE, &ip->i_iopen_gh);
-        error = gfs2_glock_nq(&ip->i_iopen_gh);
-        if (error)
-                goto out_truncate;
-
-        if (S_ISDIR(inode->i_mode) &&
-            (ip->i_diskflags & GFS2_DIF_EXHASH)) {
-                error = gfs2_dir_exhash_dealloc(ip);
-                if (error)
-                        goto out_unlock;
-        }
-
-        if (ip->i_eattr) {
-                error = gfs2_ea_dealloc(ip);
-                if (error)
-                        goto out_unlock;
-        }
-
-        if (!gfs2_is_stuffed(ip)) {
-                error = gfs2_file_dealloc(ip);
-                if (error)
-                        goto out_unlock;
-        }
-
-        error = gfs2_dinode_dealloc(ip);
-        if (error)
-                goto out_unlock;
-
-out_truncate:
-        error = gfs2_trans_begin(sdp, 0, sdp->sd_jdesc->jd_blocks);
-        if (error)
-                goto out_unlock;
-        /* Needs to be done before glock release & also in a transaction */
-        truncate_inode_pages(&inode->i_data, 0);
-        gfs2_trans_end(sdp);
-
-out_unlock:
-        if (test_bit(HIF_HOLDER, &ip->i_iopen_gh.gh_iflags))
-                gfs2_glock_dq(&ip->i_iopen_gh);
-        gfs2_holder_uninit(&ip->i_iopen_gh);
-        gfs2_glock_dq_uninit(&gh);
-        if (error && error != GLR_TRYFAILED)
-                fs_warn(sdp, "gfs2_delete_inode: %d\n", error);
-out:
-        truncate_inode_pages(&inode->i_data, 0);
-        clear_inode(inode);
-}
-
-static struct inode *gfs2_alloc_inode(struct super_block *sb)
-{
-        struct gfs2_inode *ip;
-
-        ip = kmem_cache_alloc(gfs2_inode_cachep, GFP_KERNEL);
-        if (ip) {
-                ip->i_flags = 0;
-                ip->i_gl = NULL;
-        }
-        return &ip->i_inode;
-}
-
-static void gfs2_destroy_inode(struct inode *inode)
-{
-        kmem_cache_free(gfs2_inode_cachep, inode);
-}
-
-const struct super_operations gfs2_super_ops = {
-        .alloc_inode            = gfs2_alloc_inode,
-        .destroy_inode          = gfs2_destroy_inode,
-        .write_inode            = gfs2_write_inode,
-        .delete_inode           = gfs2_delete_inode,
-        .put_super              = gfs2_put_super,
-        .write_super            = gfs2_write_super,
-        .sync_fs                = gfs2_sync_fs,
-        .freeze_fs              = gfs2_freeze,
-        .unfreeze_fs            = gfs2_unfreeze,
-        .statfs                 = gfs2_statfs,
-        .remount_fs             = gfs2_remount_fs,
-        .clear_inode            = gfs2_clear_inode,
-        .drop_inode             = gfs2_drop_inode,
-        .show_options           = gfs2_show_options,
-};
-
diff --git a/fs/gfs2/quota.c b/fs/gfs2/quota.c
index 152e6c4a0dca..2e9b9326bfc9 100644
--- a/fs/gfs2/quota.c
+++ b/fs/gfs2/quota.c
@@ -60,7 +60,6 @@
 #include "super.h"
 #include "trans.h"
 #include "inode.h"
-#include "ops_address.h"
 #include "util.h"
 
 #define QUOTA_USER 1
diff --git a/fs/gfs2/recovery.c b/fs/gfs2/recovery.c
index 247e8f7d6b3d..59d2695509d3 100644
--- a/fs/gfs2/recovery.c
+++ b/fs/gfs2/recovery.c
@@ -13,8 +13,7 @@
 #include <linux/buffer_head.h>
 #include <linux/gfs2_ondisk.h>
 #include <linux/crc32.h>
-#include <linux/kthread.h>
-#include <linux/freezer.h>
+#include <linux/slow-work.h>
 
 #include "gfs2.h"
 #include "incore.h"
@@ -441,18 +440,25 @@ static void gfs2_recovery_done(struct gfs2_sbd *sdp, unsigned int jid,
         kobject_uevent_env(&sdp->sd_kobj, KOBJ_CHANGE, envp);
 }
 
-/**
- * gfs2_recover_journal - recover a given journal
- * @jd: the struct gfs2_jdesc describing the journal
- *
- * Acquire the journal's lock, check to see if the journal is clean, and
- * do recovery if necessary.
- *
- * Returns: errno
- */
+static int gfs2_recover_get_ref(struct slow_work *work)
+{
+        struct gfs2_jdesc *jd = container_of(work, struct gfs2_jdesc, jd_work);
+        if (test_and_set_bit(JDF_RECOVERY, &jd->jd_flags))
+                return -EBUSY;
+        return 0;
+}
 
-int gfs2_recover_journal(struct gfs2_jdesc *jd)
+static void gfs2_recover_put_ref(struct slow_work *work)
+{
+        struct gfs2_jdesc *jd = container_of(work, struct gfs2_jdesc, jd_work);
+        clear_bit(JDF_RECOVERY, &jd->jd_flags);
+        smp_mb__after_clear_bit();
+        wake_up_bit(&jd->jd_flags, JDF_RECOVERY);
+}
+
+static void gfs2_recover_work(struct slow_work *work)
 {
+        struct gfs2_jdesc *jd = container_of(work, struct gfs2_jdesc, jd_work);
         struct gfs2_inode *ip = GFS2_I(jd->jd_inode);
         struct gfs2_sbd *sdp = GFS2_SB(jd->jd_inode);
         struct gfs2_log_header_host head;
@@ -569,7 +575,7 @@ int gfs2_recover_journal(struct gfs2_jdesc *jd)
                 gfs2_glock_dq_uninit(&j_gh);
 
         fs_info(sdp, "jid=%u: Done\n", jd->jd_jid);
-        return 0;
+        return;
 
 fail_gunlock_tr:
         gfs2_glock_dq_uninit(&t_gh);
@@ -584,70 +590,28 @@ fail_gunlock_j:
 
 fail:
         gfs2_recovery_done(sdp, jd->jd_jid, LM_RD_GAVEUP);
-        return error;
 }
 
-static struct gfs2_jdesc *gfs2_jdesc_find_dirty(struct gfs2_sbd *sdp)
-{
-        struct gfs2_jdesc *jd;
-        int found = 0;
-
-        spin_lock(&sdp->sd_jindex_spin);
+struct slow_work_ops gfs2_recover_ops = {
+        .get_ref = gfs2_recover_get_ref,
+        .put_ref = gfs2_recover_put_ref,
+        .execute = gfs2_recover_work,
+};
 
-        list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
-                if (jd->jd_dirty) {
-                        jd->jd_dirty = 0;
-                        found = 1;
-                        break;
-                }
-        }
-        spin_unlock(&sdp->sd_jindex_spin);
-
-        if (!found)
-                jd = NULL;
 
-        return jd;
-}
-
-/**
- * gfs2_check_journals - Recover any dirty journals
- * @sdp: the filesystem
- *
- */
-
-static void gfs2_check_journals(struct gfs2_sbd *sdp)
+static int gfs2_recovery_wait(void *word)
 {
-        struct gfs2_jdesc *jd;
-
-        for (;;) {
-                jd = gfs2_jdesc_find_dirty(sdp);
-                if (!jd)
-                        break;
-
-                if (jd != sdp->sd_jdesc)
-                        gfs2_recover_journal(jd);
-        }
+        schedule();
+        return 0;
 }
 
-/**
- * gfs2_recoverd - Recover dead machine's journals
- * @sdp: Pointer to GFS2 superblock
- *
- */
-
-int gfs2_recoverd(void *data)
+int gfs2_recover_journal(struct gfs2_jdesc *jd)
 {
-        struct gfs2_sbd *sdp = data;
-        unsigned long t;
-
-        while (!kthread_should_stop()) {
-                gfs2_check_journals(sdp);
-                t = gfs2_tune_get(sdp,  gt_recoverd_secs) * HZ;
-                if (freezing(current))
-                        refrigerator();
-                schedule_timeout_interruptible(t);
-        }
-
+        int rv;
+        rv = slow_work_enqueue(&jd->jd_work);
+        if (rv)
+                return rv;
+        wait_on_bit(&jd->jd_flags, JDF_RECOVERY, gfs2_recovery_wait, TASK_UNINTERRUPTIBLE);
         return 0;
 }
 
diff --git a/fs/gfs2/recovery.h b/fs/gfs2/recovery.h
index a8218ea15b57..1616ac22569a 100644
--- a/fs/gfs2/recovery.h
+++ b/fs/gfs2/recovery.h
@@ -28,7 +28,7 @@ extern void gfs2_revoke_clean(struct gfs2_sbd *sdp);
 extern int gfs2_find_jhead(struct gfs2_jdesc *jd,
                     struct gfs2_log_header_host *head);
 extern int gfs2_recover_journal(struct gfs2_jdesc *gfs2_jd);
-extern int gfs2_recoverd(void *data);
+extern struct slow_work_ops gfs2_recover_ops;
 
 #endif /* __RECOVERY_DOT_H__ */
 
diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c
index 565038243fa2..de3239731db8 100644
--- a/fs/gfs2/rgrp.c
+++ b/fs/gfs2/rgrp.c
@@ -29,7 +29,6 @@
 #include "util.h"
 #include "log.h"
 #include "inode.h"
-#include "ops_address.h"
 
 #define BFITNOENT ((u32)~0)
 #define NO_BLOCK ((u64)~0)
@@ -442,6 +441,7 @@ static int compute_bitstructs(struct gfs2_rgrpd *rgd)
         for (x = 0; x < length; x++) {
                 bi = rgd->rd_bits + x;
 
+                bi->bi_flags = 0;
                 /* small rgrp; bitmap stored completely in header block */
                 if (length == 1) {
                         bytes = bytes_left;
@@ -580,7 +580,6 @@ static int read_rindex_entry(struct gfs2_inode *ip,
 
         rgd->rd_gl->gl_object = rgd;
         rgd->rd_flags &= ~GFS2_RDF_UPTODATE;
-        rgd->rd_flags |= GFS2_RDF_CHECK;
         return error;
 }
 
@@ -701,10 +700,9 @@ static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
         u32 rg_flags;
 
         rg_flags = be32_to_cpu(str->rg_flags);
-        if (rg_flags & GFS2_RGF_NOALLOC)
-                rgd->rd_flags |= GFS2_RDF_NOALLOC;
-        else
-                rgd->rd_flags &= ~GFS2_RDF_NOALLOC;
+        rg_flags &= ~GFS2_RDF_MASK;
+        rgd->rd_flags &= GFS2_RDF_MASK;
+        rgd->rd_flags |= rg_flags;
         rgd->rd_free = be32_to_cpu(str->rg_free);
         rgd->rd_dinodes = be32_to_cpu(str->rg_dinodes);
         rgd->rd_igeneration = be64_to_cpu(str->rg_igeneration);
@@ -713,11 +711,8 @@ static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
 static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
 {
         struct gfs2_rgrp *str = buf;
-        u32 rg_flags = 0;
 
-        if (rgd->rd_flags & GFS2_RDF_NOALLOC)
-                rg_flags |= GFS2_RGF_NOALLOC;
-        str->rg_flags = cpu_to_be32(rg_flags);
+        str->rg_flags = cpu_to_be32(rgd->rd_flags & ~GFS2_RDF_MASK);
         str->rg_free = cpu_to_be32(rgd->rd_free);
         str->rg_dinodes = cpu_to_be32(rgd->rd_dinodes);
         str->__pad = cpu_to_be32(0);
@@ -775,8 +770,10 @@ int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
         }
 
         if (!(rgd->rd_flags & GFS2_RDF_UPTODATE)) {
+                for (x = 0; x < length; x++)
+                        clear_bit(GBF_FULL, &rgd->rd_bits[x].bi_flags);
                 gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
-                rgd->rd_flags |= GFS2_RDF_UPTODATE;
+                rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
         }
 
         spin_lock(&sdp->sd_rindex_spin);
@@ -845,7 +842,7 @@ static void gfs2_rgrp_send_discards(struct gfs2_sbd *sdp, u64 offset,
         struct super_block *sb = sdp->sd_vfs;
         struct block_device *bdev = sb->s_bdev;
         const unsigned int sects_per_blk = sdp->sd_sb.sb_bsize /
-                                           bdev_hardsect_size(sb->s_bdev);
+                                           bdev_logical_block_size(sb->s_bdev);
         u64 blk;
         sector_t start = 0;
         sector_t nr_sects = 0;
@@ -903,6 +900,7 @@ void gfs2_rgrp_repolish_clones(struct gfs2_rgrpd *rgd)
                         continue;
                 if (sdp->sd_args.ar_discard)
                         gfs2_rgrp_send_discards(sdp, rgd->rd_data0, bi);
+                clear_bit(GBF_FULL, &bi->bi_flags);
                 memcpy(bi->bi_clone + bi->bi_offset,
                        bi->bi_bh->b_data + bi->bi_offset, bi->bi_len);
         }
@@ -942,7 +940,7 @@ static int try_rgrp_fit(struct gfs2_rgrpd *rgd, struct gfs2_alloc *al)
         struct gfs2_sbd *sdp = rgd->rd_sbd;
         int ret = 0;
 
-        if (rgd->rd_flags & GFS2_RDF_NOALLOC)
+        if (rgd->rd_flags & (GFS2_RGF_NOALLOC | GFS2_RDF_ERROR))
                 return 0;
 
         spin_lock(&sdp->sd_rindex_spin);
@@ -1315,30 +1313,37 @@ static u32 rgblk_search(struct gfs2_rgrpd *rgd, u32 goal,
 {
         struct gfs2_bitmap *bi = NULL;
         const u32 length = rgd->rd_length;
-        u32 blk = 0;
+        u32 blk = BFITNOENT;
         unsigned int buf, x;
         const unsigned int elen = *n;
-        const u8 *buffer;
+        const u8 *buffer = NULL;
 
         *n = 0;
         /* Find bitmap block that contains bits for goal block */
         for (buf = 0; buf < length; buf++) {
                 bi = rgd->rd_bits + buf;
-                if (goal < (bi->bi_start + bi->bi_len) * GFS2_NBBY)
-                        break;
+                /* Convert scope of "goal" from rgrp-wide to within found bit block */
+                if (goal < (bi->bi_start + bi->bi_len) * GFS2_NBBY) {
+                        goal -= bi->bi_start * GFS2_NBBY;
+                        goto do_search;
+                }
         }
+        buf = 0;
+        goal = 0;
 
-        gfs2_assert(rgd->rd_sbd, buf < length);
-
-        /* Convert scope of "goal" from rgrp-wide to within found bit block */
-        goal -= bi->bi_start * GFS2_NBBY;
-
+do_search:
         /* Search (up to entire) bitmap in this rgrp for allocatable block.
            "x <= length", instead of "x < length", because we typically start
            the search in the middle of a bit block, but if we can't find an
            allocatable block anywhere else, we want to be able wrap around and
            search in the first part of our first-searched bit block.  */
         for (x = 0; x <= length; x++) {
+                bi = rgd->rd_bits + buf;
+
+                if (test_bit(GBF_FULL, &bi->bi_flags) &&
+                    (old_state == GFS2_BLKST_FREE))
+                        goto skip;
+
                 /* The GFS2_BLKST_UNLINKED state doesn't apply to the clone
                    bitmaps, so we must search the originals for that. */
                 buffer = bi->bi_bh->b_data + bi->bi_offset;
@@ -1349,33 +1354,39 @@ static u32 rgblk_search(struct gfs2_rgrpd *rgd, u32 goal,
                 if (blk != BFITNOENT)
                         break;
 
+                if ((goal == 0) && (old_state == GFS2_BLKST_FREE))
+                        set_bit(GBF_FULL, &bi->bi_flags);
+
                 /* Try next bitmap block (wrap back to rgrp header if at end) */
-                buf = (buf + 1) % length;
-                bi = rgd->rd_bits + buf;
+skip:
+                buf++;
+                buf %= length;
                 goal = 0;
         }
 
-        if (blk != BFITNOENT && old_state != new_state) {
-                *n = 1;
-                gfs2_trans_add_bh(rgd->rd_gl, bi->bi_bh, 1);
+        if (blk == BFITNOENT)
+                return blk;
+        *n = 1;
+        if (old_state == new_state)
+                goto out;
+
+        gfs2_trans_add_bh(rgd->rd_gl, bi->bi_bh, 1);
+        gfs2_setbit(rgd, bi->bi_bh->b_data, bi->bi_clone, bi->bi_offset,
+                    bi->bi_len, blk, new_state);
+        goal = blk;
+        while (*n < elen) {
+                goal++;
+                if (goal >= (bi->bi_len * GFS2_NBBY))
+                        break;
+                if (gfs2_testbit(rgd, buffer, bi->bi_len, goal) !=
+                    GFS2_BLKST_FREE)
+                        break;
                 gfs2_setbit(rgd, bi->bi_bh->b_data, bi->bi_clone, bi->bi_offset,
-                            bi->bi_len, blk, new_state);
-                goal = blk;
-                while (*n < elen) {
-                        goal++;
-                        if (goal >= (bi->bi_len * GFS2_NBBY))
-                                break;
-                        if (gfs2_testbit(rgd, buffer, bi->bi_len, goal) !=
-                            GFS2_BLKST_FREE)
-                                break;
-                        gfs2_setbit(rgd, bi->bi_bh->b_data, bi->bi_clone,
-                                    bi->bi_offset, bi->bi_len, goal,
-                                    new_state);
-                        (*n)++;
-                }
+                            bi->bi_len, goal, new_state);
+                (*n)++;
         }
-
-        return (blk == BFITNOENT) ? blk : (bi->bi_start * GFS2_NBBY) + blk;
+out:
+        return (bi->bi_start * GFS2_NBBY) + blk;
 }
 
 /**
@@ -1435,13 +1446,33 @@ static struct gfs2_rgrpd *rgblk_free(struct gfs2_sbd *sdp, u64 bstart,
 }
 
 /**
- * gfs2_alloc_block - Allocate a block
+ * gfs2_rgrp_dump - print out an rgrp
+ * @seq: The iterator
+ * @gl: The glock in question
+ *
+ */
+
+int gfs2_rgrp_dump(struct seq_file *seq, const struct gfs2_glock *gl)
+{
+        const struct gfs2_rgrpd *rgd = gl->gl_object;
+        if (rgd == NULL)
+                return 0;
+        gfs2_print_dbg(seq, " R: n:%llu f:%02x b:%u/%u i:%u\n",
+                       (unsigned long long)rgd->rd_addr, rgd->rd_flags,
+                       rgd->rd_free, rgd->rd_free_clone, rgd->rd_dinodes);
+        return 0;
+}
+
+/**
+ * gfs2_alloc_block - Allocate one or more blocks
  * @ip: the inode to allocate the block for
+ * @bn: Used to return the starting block number
+ * @n: requested number of blocks/extent length (value/result)
  *
- * Returns: the allocated block
+ * Returns: 0 or error
  */
 
-u64 gfs2_alloc_block(struct gfs2_inode *ip, unsigned int *n)
+int gfs2_alloc_block(struct gfs2_inode *ip, u64 *bn, unsigned int *n)
 {
         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
         struct buffer_head *dibh;
@@ -1457,7 +1488,10 @@ u64 gfs2_alloc_block(struct gfs2_inode *ip, unsigned int *n)
                 goal = rgd->rd_last_alloc;
 
         blk = rgblk_search(rgd, goal, GFS2_BLKST_FREE, GFS2_BLKST_USED, n);
-        BUG_ON(blk == BFITNOENT);
+
+        /* Since all blocks are reserved in advance, this shouldn't happen */
+        if (blk == BFITNOENT)
+                goto rgrp_error;
 
         rgd->rd_last_alloc = blk;
         block = rgd->rd_data0 + blk;
@@ -1469,7 +1503,9 @@ u64 gfs2_alloc_block(struct gfs2_inode *ip, unsigned int *n)
                 di->di_goal_meta = di->di_goal_data = cpu_to_be64(ip->i_goal);
                 brelse(dibh);
         }
-        gfs2_assert_withdraw(sdp, rgd->rd_free >= *n);
+        if (rgd->rd_free < *n)
+                goto rgrp_error;
+
         rgd->rd_free -= *n;
 
         gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
@@ -1484,7 +1520,16 @@ u64 gfs2_alloc_block(struct gfs2_inode *ip, unsigned int *n)
         rgd->rd_free_clone -= *n;
         spin_unlock(&sdp->sd_rindex_spin);
 
-        return block;
+        *bn = block;
+        return 0;
+
+rgrp_error:
+        fs_warn(sdp, "rgrp %llu has an error, marking it readonly until umount\n",
+                (unsigned long long)rgd->rd_addr);
+        fs_warn(sdp, "umount on all nodes and run fsck.gfs2 to fix the error\n");
+        gfs2_rgrp_dump(NULL, rgd->rd_gl);
+        rgd->rd_flags |= GFS2_RDF_ERROR;
+        return -EIO;
 }
 
 /**
diff --git a/fs/gfs2/rgrp.h b/fs/gfs2/rgrp.h
index 3181c7e624bf..1e76ff0f3e00 100644
--- a/fs/gfs2/rgrp.h
+++ b/fs/gfs2/rgrp.h
@@ -14,22 +14,22 @@ struct gfs2_rgrpd;
 struct gfs2_sbd;
 struct gfs2_holder;
 
-void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd);
+extern void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd);
 
 struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk);
 struct gfs2_rgrpd *gfs2_rgrpd_get_first(struct gfs2_sbd *sdp);
 struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd);
 
-void gfs2_clear_rgrpd(struct gfs2_sbd *sdp);
-int gfs2_rindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ri_gh);
+extern void gfs2_clear_rgrpd(struct gfs2_sbd *sdp);
+extern int gfs2_rindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ri_gh);
 
-int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd);
-void gfs2_rgrp_bh_hold(struct gfs2_rgrpd *rgd);
-void gfs2_rgrp_bh_put(struct gfs2_rgrpd *rgd);
+extern int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd);
+extern void gfs2_rgrp_bh_hold(struct gfs2_rgrpd *rgd);
+extern void gfs2_rgrp_bh_put(struct gfs2_rgrpd *rgd);
 
-void gfs2_rgrp_repolish_clones(struct gfs2_rgrpd *rgd);
+extern void gfs2_rgrp_repolish_clones(struct gfs2_rgrpd *rgd);
 
-struct gfs2_alloc *gfs2_alloc_get(struct gfs2_inode *ip);
+extern struct gfs2_alloc *gfs2_alloc_get(struct gfs2_inode *ip);
 static inline void gfs2_alloc_put(struct gfs2_inode *ip)
 {
         BUG_ON(ip->i_alloc == NULL);
@@ -37,22 +37,22 @@ static inline void gfs2_alloc_put(struct gfs2_inode *ip)
         ip->i_alloc = NULL;
 }
 
-int gfs2_inplace_reserve_i(struct gfs2_inode *ip,
-                         char *file, unsigned int line);
+extern int gfs2_inplace_reserve_i(struct gfs2_inode *ip, char *file,
+                                  unsigned int line);
 #define gfs2_inplace_reserve(ip) \
 gfs2_inplace_reserve_i((ip), __FILE__, __LINE__)
 
-void gfs2_inplace_release(struct gfs2_inode *ip);
+extern void gfs2_inplace_release(struct gfs2_inode *ip);
 
-unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block);
+extern unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block);
 
-u64 gfs2_alloc_block(struct gfs2_inode *ip, unsigned int *n);
-u64 gfs2_alloc_di(struct gfs2_inode *ip, u64 *generation);
+extern int gfs2_alloc_block(struct gfs2_inode *ip, u64 *bn, unsigned int *n);
+extern u64 gfs2_alloc_di(struct gfs2_inode *ip, u64 *generation);
 
-void gfs2_free_data(struct gfs2_inode *ip, u64 bstart, u32 blen);
-void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen);
-void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip);
-void gfs2_unlink_di(struct inode *inode);
+extern void gfs2_free_data(struct gfs2_inode *ip, u64 bstart, u32 blen);
+extern void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen);
+extern void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip);
+extern void gfs2_unlink_di(struct inode *inode);
 
 struct gfs2_rgrp_list {
         unsigned int rl_rgrps;
@@ -61,10 +61,11 @@ struct gfs2_rgrp_list {
         struct gfs2_holder *rl_ghs;
 };
 
-void gfs2_rlist_add(struct gfs2_sbd *sdp, struct gfs2_rgrp_list *rlist,
-                    u64 block);
-void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state);
-void gfs2_rlist_free(struct gfs2_rgrp_list *rlist);
-u64 gfs2_ri_total(struct gfs2_sbd *sdp);
+extern void gfs2_rlist_add(struct gfs2_sbd *sdp, struct gfs2_rgrp_list *rlist,
+                           u64 block);
+extern void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state);
+extern void gfs2_rlist_free(struct gfs2_rgrp_list *rlist);
+extern u64 gfs2_ri_total(struct gfs2_sbd *sdp);
+extern int gfs2_rgrp_dump(struct seq_file *seq, const struct gfs2_glock *gl);
 
 #endif /* __RGRP_DOT_H__ */
diff --git a/fs/gfs2/super.c b/fs/gfs2/super.c
index 601913e0a482..40bcc37e5a70 100644
--- a/fs/gfs2/super.c
+++ b/fs/gfs2/super.c
@@ -7,14 +7,20 @@
  * of the GNU General Public License version 2.
  */
 
+#include <linux/bio.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/completion.h>
 #include <linux/buffer_head.h>
-#include <linux/crc32.h>
+#include <linux/statfs.h>
+#include <linux/seq_file.h>
+#include <linux/mount.h>
+#include <linux/kthread.h>
+#include <linux/delay.h>
 #include <linux/gfs2_ondisk.h>
-#include <linux/bio.h>
+#include <linux/crc32.h>
+#include <linux/time.h>
 
 #include "gfs2.h"
 #include "incore.h"
@@ -31,6 +37,183 @@
 #include "super.h"
 #include "trans.h"
 #include "util.h"
+#include "sys.h"
+#include "eattr.h"
+
+#define args_neq(a1, a2, x) ((a1)->ar_##x != (a2)->ar_##x)
+
+enum {
+        Opt_lockproto,
+        Opt_locktable,
+        Opt_hostdata,
+        Opt_spectator,
+        Opt_ignore_local_fs,
+        Opt_localflocks,
+        Opt_localcaching,
+        Opt_debug,
+        Opt_nodebug,
+        Opt_upgrade,
+        Opt_acl,
+        Opt_noacl,
+        Opt_quota_off,
+        Opt_quota_account,
+        Opt_quota_on,
+        Opt_quota,
+        Opt_noquota,
+        Opt_suiddir,
+        Opt_nosuiddir,
+        Opt_data_writeback,
+        Opt_data_ordered,
+        Opt_meta,
+        Opt_discard,
+        Opt_nodiscard,
+        Opt_commit,
+        Opt_error,
+};
+
+static const match_table_t tokens = {
+        {Opt_lockproto, "lockproto=%s"},
+        {Opt_locktable, "locktable=%s"},
+        {Opt_hostdata, "hostdata=%s"},
+        {Opt_spectator, "spectator"},
+        {Opt_ignore_local_fs, "ignore_local_fs"},
+        {Opt_localflocks, "localflocks"},
+        {Opt_localcaching, "localcaching"},
+        {Opt_debug, "debug"},
+        {Opt_nodebug, "nodebug"},
+        {Opt_upgrade, "upgrade"},
+        {Opt_acl, "acl"},
+        {Opt_noacl, "noacl"},
+        {Opt_quota_off, "quota=off"},
+        {Opt_quota_account, "quota=account"},
+        {Opt_quota_on, "quota=on"},
+        {Opt_quota, "quota"},
+        {Opt_noquota, "noquota"},
+        {Opt_suiddir, "suiddir"},
+        {Opt_nosuiddir, "nosuiddir"},
+        {Opt_data_writeback, "data=writeback"},
+        {Opt_data_ordered, "data=ordered"},
+        {Opt_meta, "meta"},
+        {Opt_discard, "discard"},
+        {Opt_nodiscard, "nodiscard"},
+        {Opt_commit, "commit=%d"},
+        {Opt_error, NULL}
+};
+
+/**
+ * gfs2_mount_args - Parse mount options
+ * @sdp:
+ * @data:
+ *
+ * Return: errno
+ */
+
+int gfs2_mount_args(struct gfs2_sbd *sdp, struct gfs2_args *args, char *options)
+{
+        char *o;
+        int token;
+        substring_t tmp[MAX_OPT_ARGS];
+        int rv;
+
+        /* Split the options into tokens with the "," character and
+           process them */
+
+        while (1) {
+                o = strsep(&options, ",");
+                if (o == NULL)
+                        break;
+                if (*o == '\0')
+                        continue;
+
+                token = match_token(o, tokens, tmp);
+                switch (token) {
+                case Opt_lockproto:
+                        match_strlcpy(args->ar_lockproto, &tmp[0],
+                                      GFS2_LOCKNAME_LEN);
+                        break;
+                case Opt_locktable:
+                        match_strlcpy(args->ar_locktable, &tmp[0],
+                                      GFS2_LOCKNAME_LEN);
+                        break;
+                case Opt_hostdata:
+                        match_strlcpy(args->ar_hostdata, &tmp[0],
+                                      GFS2_LOCKNAME_LEN);
+                        break;
+                case Opt_spectator:
+                        args->ar_spectator = 1;
+                        break;
+                case Opt_ignore_local_fs:
+                        args->ar_ignore_local_fs = 1;
+                        break;
+                case Opt_localflocks:
+                        args->ar_localflocks = 1;
+                        break;
+                case Opt_localcaching:
+                        args->ar_localcaching = 1;
+                        break;
+                case Opt_debug:
+                        args->ar_debug = 1;
+                        break;
+                case Opt_nodebug:
+                        args->ar_debug = 0;
+                        break;
+                case Opt_upgrade:
+                        args->ar_upgrade = 1;
+                        break;
+                case Opt_acl:
+                        args->ar_posix_acl = 1;
+                        break;
+                case Opt_noacl:
+                        args->ar_posix_acl = 0;
+                        break;
+                case Opt_quota_off:
+                case Opt_noquota:
+                        args->ar_quota = GFS2_QUOTA_OFF;
+                        break;
+                case Opt_quota_account:
+                        args->ar_quota = GFS2_QUOTA_ACCOUNT;
+                        break;
+                case Opt_quota_on:
+                case Opt_quota:
+                        args->ar_quota = GFS2_QUOTA_ON;
+                        break;
+                case Opt_suiddir:
+                        args->ar_suiddir = 1;
+                        break;
+                case Opt_nosuiddir:
+                        args->ar_suiddir = 0;
+                        break;
+                case Opt_data_writeback:
+                        args->ar_data = GFS2_DATA_WRITEBACK;
+                        break;
+                case Opt_data_ordered:
+                        args->ar_data = GFS2_DATA_ORDERED;
+                        break;
+                case Opt_meta:
+                        args->ar_meta = 1;
+                        break;
+                case Opt_discard:
+                        args->ar_discard = 1;
+                        break;
+                case Opt_nodiscard:
+                        args->ar_discard = 0;
+                        break;
+                case Opt_commit:
+                        rv = match_int(&tmp[0], &args->ar_commit);
+                        if (rv || args->ar_commit <= 0) {
+                                fs_info(sdp, "commit mount option requires a positive numeric argument\n");
+                                return rv ? rv : -EINVAL;
+                        }
+                        break;
+                case Opt_error:
+                default:
+                        fs_info(sdp, "invalid mount option: %s\n", o);
+                        return -EINVAL;
+                }
+        }
+
+        return 0;
+}
 
 /**
  * gfs2_jindex_free - Clear all the journal index information
@@ -436,3 +619,719 @@ void gfs2_unfreeze_fs(struct gfs2_sbd *sdp)
         mutex_unlock(&sdp->sd_freeze_lock);
 }
 
+
+/**
+ * gfs2_write_inode - Make sure the inode is stable on the disk
+ * @inode: The inode
+ * @sync: synchronous write flag
+ *
+ * Returns: errno
+ */
+
+static int gfs2_write_inode(struct inode *inode, int sync)
+{
+        struct gfs2_inode *ip = GFS2_I(inode);
+        struct gfs2_sbd *sdp = GFS2_SB(inode);
+        struct gfs2_holder gh;
+        struct buffer_head *bh;
+        struct timespec atime;
+        struct gfs2_dinode *di;
+        int ret = 0;
+
+        /* Check this is a "normal" inode, etc */
+        if (!test_bit(GIF_USER, &ip->i_flags) ||
+            (current->flags & PF_MEMALLOC))
+                return 0;
+        ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
+        if (ret)
+                goto do_flush;
+        ret = gfs2_trans_begin(sdp, RES_DINODE, 0);
+        if (ret)
+                goto do_unlock;
+        ret = gfs2_meta_inode_buffer(ip, &bh);
+        if (ret == 0) {
+                di = (struct gfs2_dinode *)bh->b_data;
+                atime.tv_sec = be64_to_cpu(di->di_atime);
+                atime.tv_nsec = be32_to_cpu(di->di_atime_nsec);
+                if (timespec_compare(&inode->i_atime, &atime) > 0) {
+                        gfs2_trans_add_bh(ip->i_gl, bh, 1);
+                        gfs2_dinode_out(ip, bh->b_data);
+                }
+                brelse(bh);
+        }
+        gfs2_trans_end(sdp);
+do_unlock:
+        gfs2_glock_dq_uninit(&gh);
+do_flush:
+        if (sync != 0)
+                gfs2_log_flush(GFS2_SB(inode), ip->i_gl);
+        return ret;
+}
+
+/**
+ * gfs2_make_fs_ro - Turn a Read-Write FS into a Read-Only one
+ * @sdp: the filesystem
+ *
+ * Returns: errno
+ */
+
+static int gfs2_make_fs_ro(struct gfs2_sbd *sdp)
+{
+        struct gfs2_holder t_gh;
+        int error;
+
+        gfs2_quota_sync(sdp);
+        gfs2_statfs_sync(sdp);
+
+        error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED, GL_NOCACHE,
+                                   &t_gh);
+        if (error && !test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
+                return error;
+
+        gfs2_meta_syncfs(sdp);
+        gfs2_log_shutdown(sdp);
+
+        clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
+
+        if (t_gh.gh_gl)
+                gfs2_glock_dq_uninit(&t_gh);
+
+        gfs2_quota_cleanup(sdp);
+
+        return error;
+}
+
+static int gfs2_umount_recovery_wait(void *word)
+{
+        schedule();
+        return 0;
+}
+
+/**
+ * gfs2_put_super - Unmount the filesystem
+ * @sb: The VFS superblock
+ *
+ */
+
+static void gfs2_put_super(struct super_block *sb)
+{
+        struct gfs2_sbd *sdp = sb->s_fs_info;
+        int error;
+        struct gfs2_jdesc *jd;
+
+        /*  Unfreeze the filesystem, if we need to  */
+
+        mutex_lock(&sdp->sd_freeze_lock);
+        if (sdp->sd_freeze_count)
+                gfs2_glock_dq_uninit(&sdp->sd_freeze_gh);
+        mutex_unlock(&sdp->sd_freeze_lock);
+
+        /* No more recovery requests */
+        set_bit(SDF_NORECOVERY, &sdp->sd_flags);
+        smp_mb();
+
+        /* Wait on outstanding recovery */
+restart:
+        spin_lock(&sdp->sd_jindex_spin);
+        list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
+                if (!test_bit(JDF_RECOVERY, &jd->jd_flags))
+                        continue;
+                spin_unlock(&sdp->sd_jindex_spin);
+                wait_on_bit(&jd->jd_flags, JDF_RECOVERY,
+                            gfs2_umount_recovery_wait, TASK_UNINTERRUPTIBLE);
+                goto restart;
+        }
+        spin_unlock(&sdp->sd_jindex_spin);
+
+        kthread_stop(sdp->sd_quotad_process);
+        kthread_stop(sdp->sd_logd_process);
+
+        if (!(sb->s_flags & MS_RDONLY)) {
+                error = gfs2_make_fs_ro(sdp);
+                if (error)
+                        gfs2_io_error(sdp);
+        }
+        /*  At this point, we're through modifying the disk  */
+
+        /*  Release stuff  */
+
+        iput(sdp->sd_jindex);
+        iput(sdp->sd_inum_inode);
+        iput(sdp->sd_statfs_inode);
+        iput(sdp->sd_rindex);
+        iput(sdp->sd_quota_inode);
+
+        gfs2_glock_put(sdp->sd_rename_gl);
+        gfs2_glock_put(sdp->sd_trans_gl);
+
+        if (!sdp->sd_args.ar_spectator) {
+                gfs2_glock_dq_uninit(&sdp->sd_journal_gh);
+                gfs2_glock_dq_uninit(&sdp->sd_jinode_gh);
+                gfs2_glock_dq_uninit(&sdp->sd_ir_gh);
+                gfs2_glock_dq_uninit(&sdp->sd_sc_gh);
+                gfs2_glock_dq_uninit(&sdp->sd_qc_gh);
+                iput(sdp->sd_ir_inode);
+                iput(sdp->sd_sc_inode);
+                iput(sdp->sd_qc_inode);
+        }
+
+        gfs2_glock_dq_uninit(&sdp->sd_live_gh);
+        gfs2_clear_rgrpd(sdp);
+        gfs2_jindex_free(sdp);
+        /*  Take apart glock structures and buffer lists  */
+        gfs2_gl_hash_clear(sdp);
+        /*  Unmount the locking protocol  */
+        gfs2_lm_unmount(sdp);
+
+        /*  At this point, we're through participating in the lockspace  */
+        gfs2_sys_fs_del(sdp);
+}
+
+/**
+ * gfs2_write_super
+ * @sb: the superblock
+ *
+ */
+
+static void gfs2_write_super(struct super_block *sb)
+{
+        sb->s_dirt = 0;
+}
+
+/**
+ * gfs2_sync_fs - sync the filesystem
+ * @sb: the superblock
+ *
+ * Flushes the log to disk.
+ */
+
+static int gfs2_sync_fs(struct super_block *sb, int wait)
+{
+        sb->s_dirt = 0;
+        if (wait && sb->s_fs_info)
+                gfs2_log_flush(sb->s_fs_info, NULL);
+        return 0;
+}
+
+/**
+ * gfs2_freeze - prevent further writes to the filesystem
+ * @sb: the VFS structure for the filesystem
+ *
+ */
+
+static int gfs2_freeze(struct super_block *sb)
+{
+        struct gfs2_sbd *sdp = sb->s_fs_info;
+        int error;
+
+        if (test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
+                return -EINVAL;
+
+        for (;;) {
+                error = gfs2_freeze_fs(sdp);
+                if (!error)
+                        break;
+
+                switch (error) {
+                case -EBUSY:
+                        fs_err(sdp, "waiting for recovery before freeze\n");
+                        break;
+
+                default:
+                        fs_err(sdp, "error freezing FS: %d\n", error);
+                        break;
+                }
+
+                fs_err(sdp, "retrying...\n");
+                msleep(1000);
+        }
+        return 0;
+}
+
+/**
+ * gfs2_unfreeze - reallow writes to the filesystem
+ * @sb: the VFS structure for the filesystem
+ *
+ */
+
+static int gfs2_unfreeze(struct super_block *sb)
+{
+        gfs2_unfreeze_fs(sb->s_fs_info);
+        return 0;
+}
+
+/**
+ * statfs_fill - fill in the sg for a given RG
+ * @rgd: the RG
+ * @sc: the sc structure
+ *
+ * Returns: 0 on success, -ESTALE if the LVB is invalid
+ */
+
+static int statfs_slow_fill(struct gfs2_rgrpd *rgd,
+                            struct gfs2_statfs_change_host *sc)
+{
+        gfs2_rgrp_verify(rgd);
+        sc->sc_total += rgd->rd_data;
+        sc->sc_free += rgd->rd_free;
+        sc->sc_dinodes += rgd->rd_dinodes;
+        return 0;
+}
+
+/**
+ * gfs2_statfs_slow - Stat a filesystem using asynchronous locking
+ * @sdp: the filesystem
+ * @sc: the sc info that will be returned
+ *
+ * Any error (other than a signal) will cause this routine to fall back
+ * to the synchronous version.
+ *
+ * FIXME: This really shouldn't busy wait like this.
+ *
+ * Returns: errno
+ */
+
+static int gfs2_statfs_slow(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *sc)
+{
+        struct gfs2_holder ri_gh;
+        struct gfs2_rgrpd *rgd_next;
+        struct gfs2_holder *gha, *gh;
+        unsigned int slots = 64;
+        unsigned int x;
+        int done;
+        int error = 0, err;
+
+        memset(sc, 0, sizeof(struct gfs2_statfs_change_host));
+        gha = kcalloc(slots, sizeof(struct gfs2_holder), GFP_KERNEL);
+        if (!gha)
+                return -ENOMEM;
+
+        error = gfs2_rindex_hold(sdp, &ri_gh);
+        if (error)
+                goto out;
+
+        rgd_next = gfs2_rgrpd_get_first(sdp);
+
+        for (;;) {
+                done = 1;
+
+                for (x = 0; x < slots; x++) {
+                        gh = gha + x;
+
+                        if (gh->gh_gl && gfs2_glock_poll(gh)) {
+                                err = gfs2_glock_wait(gh);
+                                if (err) {
+                                        gfs2_holder_uninit(gh);
+                                        error = err;
+                                } else {
+                                        if (!error)
+                                                error = statfs_slow_fill(
+                                                        gh->gh_gl->gl_object, sc);
+                                        gfs2_glock_dq_uninit(gh);
+                                }
+                        }
+
+                        if (gh->gh_gl)
+                                done = 0;
+                        else if (rgd_next && !error) {
+                                error = gfs2_glock_nq_init(rgd_next->rd_gl,
+                                                           LM_ST_SHARED,
+                                                           GL_ASYNC,
+                                                           gh);
+                                rgd_next = gfs2_rgrpd_get_next(rgd_next);
+                                done = 0;
+                        }
+
+                        if (signal_pending(current))
+                                error = -ERESTARTSYS;
+                }
+
+                if (done)
+                        break;
+
+                yield();
+        }
+
+        gfs2_glock_dq_uninit(&ri_gh);
+
+out:
+        kfree(gha);
+        return error;
+}
+
+/**
+ * gfs2_statfs_i - Do a statfs
+ * @sdp: the filesystem
+ * @sg: the sg structure
+ *
+ * Returns: errno
+ */
+
+static int gfs2_statfs_i(struct gfs2_sbd *sdp, struct gfs2_statfs_change_host *sc)
+{
+        struct gfs2_statfs_change_host *m_sc = &sdp->sd_statfs_master;
+        struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
+
+        spin_lock(&sdp->sd_statfs_spin);
+
+        *sc = *m_sc;
+        sc->sc_total += l_sc->sc_total;
+        sc->sc_free += l_sc->sc_free;
+        sc->sc_dinodes += l_sc->sc_dinodes;
+
+        spin_unlock(&sdp->sd_statfs_spin);
+
+        if (sc->sc_free < 0)
+                sc->sc_free = 0;
+        if (sc->sc_free > sc->sc_total)
+                sc->sc_free = sc->sc_total;
+        if (sc->sc_dinodes < 0)
+                sc->sc_dinodes = 0;
+
+        return 0;
+}
+
+/**
+ * gfs2_statfs - Gather and return stats about the filesystem
+ * @sb: The superblock
+ * @statfsbuf: The buffer
+ *
+ * Returns: 0 on success or error code
+ */
+
+static int gfs2_statfs(struct dentry *dentry, struct kstatfs *buf)
+{
+        struct super_block *sb = dentry->d_inode->i_sb;
+        struct gfs2_sbd *sdp = sb->s_fs_info;
+        struct gfs2_statfs_change_host sc;
+        int error;
+
+        if (gfs2_tune_get(sdp, gt_statfs_slow))
+                error = gfs2_statfs_slow(sdp, &sc);
+        else
+                error = gfs2_statfs_i(sdp, &sc);
+
+        if (error)
+                return error;
+
+        buf->f_type = GFS2_MAGIC;
+        buf->f_bsize = sdp->sd_sb.sb_bsize;
+        buf->f_blocks = sc.sc_total;
+        buf->f_bfree = sc.sc_free;
+        buf->f_bavail = sc.sc_free;
+        buf->f_files = sc.sc_dinodes + sc.sc_free;
+        buf->f_ffree = sc.sc_free;
+        buf->f_namelen = GFS2_FNAMESIZE;
+
+        return 0;
+}
+
+/**
+ * gfs2_remount_fs - called when the FS is remounted
+ * @sb:  the filesystem
+ * @flags:  the remount flags
+ * @data:  extra data passed in (not used right now)
+ *
+ * Returns: errno
+ */
+
+static int gfs2_remount_fs(struct super_block *sb, int *flags, char *data)
+{
+        struct gfs2_sbd *sdp = sb->s_fs_info;
+        struct gfs2_args args = sdp->sd_args; /* Default to current settings */
+        struct gfs2_tune *gt = &sdp->sd_tune;
+        int error;
+
+        spin_lock(&gt->gt_spin);
+        args.ar_commit = gt->gt_log_flush_secs;
+        spin_unlock(&gt->gt_spin);
+        error = gfs2_mount_args(sdp, &args, data);
+        if (error)
+                return error;
+
+        /* Not allowed to change locking details */
+        if (strcmp(args.ar_lockproto, sdp->sd_args.ar_lockproto) ||
+            strcmp(args.ar_locktable, sdp->sd_args.ar_locktable) ||
+            strcmp(args.ar_hostdata, sdp->sd_args.ar_hostdata))
+                return -EINVAL;
+
+        /* Some flags must not be changed */
+        if (args_neq(&args, &sdp->sd_args, spectator) ||
+            args_neq(&args, &sdp->sd_args, ignore_local_fs) ||
+            args_neq(&args, &sdp->sd_args, localflocks) ||
+            args_neq(&args, &sdp->sd_args, localcaching) ||
+            args_neq(&args, &sdp->sd_args, meta))
+                return -EINVAL;
+
+        if (sdp->sd_args.ar_spectator)
+                *flags |= MS_RDONLY;
+
+        if ((sb->s_flags ^ *flags) & MS_RDONLY) {
+                if (*flags & MS_RDONLY)
+                        error = gfs2_make_fs_ro(sdp);
+                else
+                        error = gfs2_make_fs_rw(sdp);
+                if (error)
+                        return error;
+        }
+
+        sdp->sd_args = args;
+        if (sdp->sd_args.ar_posix_acl)
+                sb->s_flags |= MS_POSIXACL;
+        else
+                sb->s_flags &= ~MS_POSIXACL;
+        spin_lock(&gt->gt_spin);
+        gt->gt_log_flush_secs = args.ar_commit;
+        spin_unlock(&gt->gt_spin);
+
+        return 0;
+}
+
+/**
+ * gfs2_drop_inode - Drop an inode (test for remote unlink)
+ * @inode: The inode to drop
+ *
+ * If we've received a callback on an iopen lock then its because a
+ * remote node tried to deallocate the inode but failed due to this node
+ * still having the inode open. Here we mark the link count zero
+ * since we know that it must have reached zero if the GLF_DEMOTE flag
+ * is set on the iopen glock. If we didn't do a disk read since the
+ * remote node removed the final link then we might otherwise miss
+ * this event. This check ensures that this node will deallocate the
+ * inode's blocks, or alternatively pass the baton on to another
+ * node for later deallocation.
+ */
+
+static void gfs2_drop_inode(struct inode *inode)
+{
+        struct gfs2_inode *ip = GFS2_I(inode);
+
+        if (test_bit(GIF_USER, &ip->i_flags) && inode->i_nlink) {
+                struct gfs2_glock *gl = ip->i_iopen_gh.gh_gl;
+                if (gl && test_bit(GLF_DEMOTE, &gl->gl_flags))
+                        clear_nlink(inode);
+        }
+        generic_drop_inode(inode);
+}
+
+/**
+ * gfs2_clear_inode - Deallocate an inode when VFS is done with it
+ * @inode: The VFS inode
+ *
+ */
+
+static void gfs2_clear_inode(struct inode *inode)
+{
+        struct gfs2_inode *ip = GFS2_I(inode);
+
+        /* This tells us its a "real" inode and not one which only
+         * serves to contain an address space (see rgrp.c, meta_io.c)
+         * which therefore doesn't have its own glocks.
+         */
+        if (test_bit(GIF_USER, &ip->i_flags)) {
+                ip->i_gl->gl_object = NULL;
+                gfs2_glock_put(ip->i_gl);
+                ip->i_gl = NULL;
+                if (ip->i_iopen_gh.gh_gl) {
+                        ip->i_iopen_gh.gh_gl->gl_object = NULL;
+                        gfs2_glock_dq_uninit(&ip->i_iopen_gh);
+                }
+        }
+}
+
+static int is_ancestor(const struct dentry *d1, const struct dentry *d2)
+{
+        do {
+                if (d1 == d2)
+                        return 1;
+                d1 = d1->d_parent;
+        } while (!IS_ROOT(d1));
+        return 0;
+}
+
+/**
+ * gfs2_show_options - Show mount options for /proc/mounts
+ * @s: seq_file structure
+ * @mnt: vfsmount
+ *
+ * Returns: 0 on success or error code
+ */
+
+static int gfs2_show_options(struct seq_file *s, struct vfsmount *mnt)
+{
+        struct gfs2_sbd *sdp = mnt->mnt_sb->s_fs_info;
+        struct gfs2_args *args = &sdp->sd_args;
+        int lfsecs;
+
+        if (is_ancestor(mnt->mnt_root, sdp->sd_master_dir))
+                seq_printf(s, ",meta");
+        if (args->ar_lockproto[0])
+                seq_printf(s, ",lockproto=%s", args->ar_lockproto);
+        if (args->ar_locktable[0])
+                seq_printf(s, ",locktable=%s", args->ar_locktable);
+        if (args->ar_hostdata[0])
+                seq_printf(s, ",hostdata=%s", args->ar_hostdata);
+        if (args->ar_spectator)
+                seq_printf(s, ",spectator");
+        if (args->ar_ignore_local_fs)
+                seq_printf(s, ",ignore_local_fs");
+        if (args->ar_localflocks)
+                seq_printf(s, ",localflocks");
+        if (args->ar_localcaching)
+                seq_printf(s, ",localcaching");
+        if (args->ar_debug)
+                seq_printf(s, ",debug");
+        if (args->ar_upgrade)
+                seq_printf(s, ",upgrade");
+        if (args->ar_posix_acl)
+                seq_printf(s, ",acl");
+        if (args->ar_quota != GFS2_QUOTA_DEFAULT) {
+                char *state;
+                switch (args->ar_quota) {
+                case GFS2_QUOTA_OFF:
+                        state = "off";
+                        break;
+                case GFS2_QUOTA_ACCOUNT:
+                        state = "account";
+                        break;
+                case GFS2_QUOTA_ON:
+                        state = "on";
+                        break;
+                default:
+                        state = "unknown";
+                        break;
+                }
+                seq_printf(s, ",quota=%s", state);
+        }
+        if (args->ar_suiddir)
+                seq_printf(s, ",suiddir");
+        if (args->ar_data != GFS2_DATA_DEFAULT) {
+                char *state;
+                switch (args->ar_data) {
+                case GFS2_DATA_WRITEBACK:
+                        state = "writeback";
+                        break;
+                case GFS2_DATA_ORDERED:
+                        state = "ordered";
+                        break;
+                default:
+                        state = "unknown";
+                        break;
+                }
+                seq_printf(s, ",data=%s", state);
+        }
+        if (args->ar_discard)
+                seq_printf(s, ",discard");
+        lfsecs = sdp->sd_tune.gt_log_flush_secs;
+        if (lfsecs != 60)
+                seq_printf(s, ",commit=%d", lfsecs);
+        return 0;
+}
+
+/*
+ * We have to (at the moment) hold the inodes main lock to cover
+ * the gap between unlocking the shared lock on the iopen lock and
+ * taking the exclusive lock. I'd rather do a shared -> exclusive
+ * conversion on the iopen lock, but we can change that later. This
+ * is safe, just less efficient.
+ */
+
+static void gfs2_delete_inode(struct inode *inode)
+{
+        struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
+        struct gfs2_inode *ip = GFS2_I(inode);
+        struct gfs2_holder gh;
+        int error;
+
+        if (!test_bit(GIF_USER, &ip->i_flags))
+                goto out;
+
+        error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
+        if (unlikely(error)) {
+                gfs2_glock_dq_uninit(&ip->i_iopen_gh);
+                goto out;
+        }
+
+        gfs2_glock_dq_wait(&ip->i_iopen_gh);
+        gfs2_holder_reinit(LM_ST_EXCLUSIVE, LM_FLAG_TRY_1CB | GL_NOCACHE, &ip->i_iopen_gh);
+        error = gfs2_glock_nq(&ip->i_iopen_gh);
+        if (error)
+                goto out_truncate;
+
+        if (S_ISDIR(inode->i_mode) &&
+            (ip->i_diskflags & GFS2_DIF_EXHASH)) {
+                error = gfs2_dir_exhash_dealloc(ip);
+                if (error)
+                        goto out_unlock;
+        }
+
+        if (ip->i_eattr) {
+                error = gfs2_ea_dealloc(ip);
+                if (error)
+                        goto out_unlock;
+        }
+
+        if (!gfs2_is_stuffed(ip)) {
+                error = gfs2_file_dealloc(ip);
+                if (error)
+                        goto out_unlock;
+        }
+
+        error = gfs2_dinode_dealloc(ip);
+        if (error)
+                goto out_unlock;
+
+out_truncate:
+        error = gfs2_trans_begin(sdp, 0, sdp->sd_jdesc->jd_blocks);
+        if (error)
+                goto out_unlock;
+        /* Needs to be done before glock release & also in a transaction */
+        truncate_inode_pages(&inode->i_data, 0);
+        gfs2_trans_end(sdp);
+
+out_unlock:
+        if (test_bit(HIF_HOLDER, &ip->i_iopen_gh.gh_iflags))
+                gfs2_glock_dq(&ip->i_iopen_gh);
+        gfs2_holder_uninit(&ip->i_iopen_gh);
+        gfs2_glock_dq_uninit(&gh);
+        if (error && error != GLR_TRYFAILED && error != -EROFS)
+                fs_warn(sdp, "gfs2_delete_inode: %d\n", error);
+out:
+        truncate_inode_pages(&inode->i_data, 0);
+        clear_inode(inode);
+}
+
+static struct inode *gfs2_alloc_inode(struct super_block *sb)
+{
+        struct gfs2_inode *ip;
+
+        ip = kmem_cache_alloc(gfs2_inode_cachep, GFP_KERNEL);
+        if (ip) {
+                ip->i_flags = 0;
+                ip->i_gl = NULL;
+        }
+        return &ip->i_inode;
+}
+
+static void gfs2_destroy_inode(struct inode *inode)
+{
+        kmem_cache_free(gfs2_inode_cachep, inode);
+}
+
+const struct super_operations gfs2_super_ops = {
+        .alloc_inode            = gfs2_alloc_inode,
+        .destroy_inode          = gfs2_destroy_inode,
+        .write_inode            = gfs2_write_inode,
+        .delete_inode           = gfs2_delete_inode,
+        .put_super              = gfs2_put_super,
+        .write_super            = gfs2_write_super,
+        .sync_fs                = gfs2_sync_fs,
+        .freeze_fs              = gfs2_freeze,
+        .unfreeze_fs            = gfs2_unfreeze,
+        .statfs                 = gfs2_statfs,
+        .remount_fs             = gfs2_remount_fs,
+        .clear_inode            = gfs2_clear_inode,
+        .drop_inode             = gfs2_drop_inode,
+        .show_options           = gfs2_show_options,
+};
+
diff --git a/fs/gfs2/sys.c b/fs/gfs2/sys.c
index 7655f5025fec..23419dc3027b 100644
--- a/fs/gfs2/sys.c
+++ b/fs/gfs2/sys.c
@@ -26,6 +26,36 @@
 #include "util.h"
 #include "glops.h"
 
+struct gfs2_attr {
+        struct attribute attr;
+        ssize_t (*show)(struct gfs2_sbd *, char *);
+        ssize_t (*store)(struct gfs2_sbd *, const char *, size_t);
+};
+
+static ssize_t gfs2_attr_show(struct kobject *kobj, struct attribute *attr,
+                              char *buf)
+{
+        struct gfs2_sbd *sdp = container_of(kobj, struct gfs2_sbd, sd_kobj);
+        struct gfs2_attr *a = container_of(attr, struct gfs2_attr, attr);
+        return a->show ? a->show(sdp, buf) : 0;
+}
+
+static ssize_t gfs2_attr_store(struct kobject *kobj, struct attribute *attr,
+                               const char *buf, size_t len)
+{
+        struct gfs2_sbd *sdp = container_of(kobj, struct gfs2_sbd, sd_kobj);
+        struct gfs2_attr *a = container_of(attr, struct gfs2_attr, attr);
+        return a->store ? a->store(sdp, buf, len) : len;
+}
+
+static struct sysfs_ops gfs2_attr_ops = {
+        .show  = gfs2_attr_show,
+        .store = gfs2_attr_store,
+};
+
+
+static struct kset *gfs2_kset;
+
 static ssize_t id_show(struct gfs2_sbd *sdp, char *buf)
 {
         return snprintf(buf, PAGE_SIZE, "%u:%u\n",
@@ -212,11 +242,6 @@ static ssize_t demote_rq_store(struct gfs2_sbd *sdp, const char *buf, size_t len
         return len;
 }
 
-struct gfs2_attr {
-        struct attribute attr;
-        ssize_t (*show)(struct gfs2_sbd *, char *);
-        ssize_t (*store)(struct gfs2_sbd *, const char *, size_t);
-};
 
 #define GFS2_ATTR(name, mode, show, store) \
 static struct gfs2_attr gfs2_attr_##name = __ATTR(name, mode, show, store)
@@ -246,58 +271,11 @@ static struct attribute *gfs2_attrs[] = {
         NULL,
 };
 
-static ssize_t gfs2_attr_show(struct kobject *kobj, struct attribute *attr,
-                              char *buf)
-{
-        struct gfs2_sbd *sdp = container_of(kobj, struct gfs2_sbd, sd_kobj);
-        struct gfs2_attr *a = container_of(attr, struct gfs2_attr, attr);
-        return a->show ? a->show(sdp, buf) : 0;
-}
-
-static ssize_t gfs2_attr_store(struct kobject *kobj, struct attribute *attr,
-                               const char *buf, size_t len)
-{
-        struct gfs2_sbd *sdp = container_of(kobj, struct gfs2_sbd, sd_kobj);
-        struct gfs2_attr *a = container_of(attr, struct gfs2_attr, attr);
-        return a->store ? a->store(sdp, buf, len) : len;
-}
-
-static struct sysfs_ops gfs2_attr_ops = {
-        .show  = gfs2_attr_show,
-        .store = gfs2_attr_store,
-};
-
 static struct kobj_type gfs2_ktype = {
         .default_attrs = gfs2_attrs,
         .sysfs_ops     = &gfs2_attr_ops,
 };
 
-static struct kset *gfs2_kset;
-
-/*
- * display struct lm_lockstruct fields
- */
-
-struct lockstruct_attr {
-        struct attribute attr;
-        ssize_t (*show)(struct gfs2_sbd *, char *);
-};
-
-#define LOCKSTRUCT_ATTR(name, fmt)                                          \
-static ssize_t name##_show(struct gfs2_sbd *sdp, char *buf)                 \
-{                                                                           \
-        return snprintf(buf, PAGE_SIZE, fmt, sdp->sd_lockstruct.ls_##name); \
-}                                                                           \
-static struct lockstruct_attr lockstruct_attr_##name = __ATTR_RO(name)
-
-LOCKSTRUCT_ATTR(jid,      "%u\n");
-LOCKSTRUCT_ATTR(first,    "%u\n");
-
-static struct attribute *lockstruct_attrs[] = {
-        &lockstruct_attr_jid.attr,
-        &lockstruct_attr_first.attr,
-        NULL,
-};
 
 /*
  * lock_module. Originally from lock_dlm
@@ -359,34 +337,33 @@ static ssize_t first_done_show(struct gfs2_sbd *sdp, char *buf)
         return sprintf(buf, "%d\n", ls->ls_first_done);
 }
 
-static ssize_t recover_show(struct gfs2_sbd *sdp, char *buf)
-{
-        struct lm_lockstruct *ls = &sdp->sd_lockstruct;
-        return sprintf(buf, "%d\n", ls->ls_recover_jid);
-}
-
-static void gfs2_jdesc_make_dirty(struct gfs2_sbd *sdp, unsigned int jid)
+static ssize_t recover_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
 {
+        unsigned jid;
         struct gfs2_jdesc *jd;
+        int rv;
+
+        rv = sscanf(buf, "%u", &jid);
+        if (rv != 1)
+                return -EINVAL;
 
+        rv = -ESHUTDOWN;
         spin_lock(&sdp->sd_jindex_spin);
+        if (test_bit(SDF_NORECOVERY, &sdp->sd_flags))
+                goto out;
+        rv = -EBUSY;
+        if (sdp->sd_jdesc->jd_jid == jid)
+                goto out;
+        rv = -ENOENT;
         list_for_each_entry(jd, &sdp->sd_jindex_list, jd_list) {
                 if (jd->jd_jid != jid)
                         continue;
-                jd->jd_dirty = 1;
+                rv = slow_work_enqueue(&jd->jd_work);
                 break;
         }
+out:
         spin_unlock(&sdp->sd_jindex_spin);
-}
-
-static ssize_t recover_store(struct gfs2_sbd *sdp, const char *buf, size_t len)
-{
-        struct lm_lockstruct *ls = &sdp->sd_lockstruct;
-        ls->ls_recover_jid = simple_strtol(buf, NULL, 0);
-        gfs2_jdesc_make_dirty(sdp, ls->ls_recover_jid);
-        if (sdp->sd_recoverd_process)
-                wake_up_process(sdp->sd_recoverd_process);
-        return len;
+        return rv ? rv : len;
 }
 
 static ssize_t recover_done_show(struct gfs2_sbd *sdp, char *buf)
@@ -401,31 +378,31 @@ static ssize_t recover_status_show(struct gfs2_sbd *sdp, char *buf)
         return sprintf(buf, "%d\n", ls->ls_recover_jid_status);
 }
 
-struct gdlm_attr {
-        struct attribute attr;
-        ssize_t (*show)(struct gfs2_sbd *sdp, char *);
-        ssize_t (*store)(struct gfs2_sbd *sdp, const char *, size_t);
-};
+static ssize_t jid_show(struct gfs2_sbd *sdp, char *buf)
+{
+        return sprintf(buf, "%u\n", sdp->sd_lockstruct.ls_jid);
+}
 
 #define GDLM_ATTR(_name,_mode,_show,_store) \
-static struct gdlm_attr gdlm_attr_##_name = __ATTR(_name,_mode,_show,_store)
-
-GDLM_ATTR(proto_name,     0444, proto_name_show,     NULL);
-GDLM_ATTR(block,          0644, block_show,          block_store);
-GDLM_ATTR(withdraw,       0644, withdraw_show,       withdraw_store);
-GDLM_ATTR(id,             0444, lkid_show,           NULL);
-GDLM_ATTR(first,          0444, lkfirst_show,        NULL);
-GDLM_ATTR(first_done,     0444, first_done_show,     NULL);
-GDLM_ATTR(recover,        0644, recover_show,        recover_store);
-GDLM_ATTR(recover_done,   0444, recover_done_show,   NULL);
-GDLM_ATTR(recover_status, 0444, recover_status_show, NULL);
+static struct gfs2_attr gdlm_attr_##_name = __ATTR(_name,_mode,_show,_store)
+
+GDLM_ATTR(proto_name,     0444, proto_name_show,        NULL);
+GDLM_ATTR(block,          0644, block_show,             block_store);
+GDLM_ATTR(withdraw,       0644, withdraw_show,          withdraw_store);
+GDLM_ATTR(id,             0444, lkid_show,              NULL);
+GDLM_ATTR(jid,            0444, jid_show,               NULL);
+GDLM_ATTR(first,          0444, lkfirst_show,           NULL);
+GDLM_ATTR(first_done,     0444, first_done_show,        NULL);
+GDLM_ATTR(recover,        0200, NULL,                   recover_store);
+GDLM_ATTR(recover_done,   0444, recover_done_show,      NULL);
+GDLM_ATTR(recover_status, 0444, recover_status_show,    NULL);
 
 static struct attribute *lock_module_attrs[] = {
         &gdlm_attr_proto_name.attr,
         &gdlm_attr_block.attr,
         &gdlm_attr_withdraw.attr,
         &gdlm_attr_id.attr,
-        &lockstruct_attr_jid.attr,
+        &gdlm_attr_jid.attr,
         &gdlm_attr_first.attr,
         &gdlm_attr_first_done.attr,
         &gdlm_attr_recover.attr,
@@ -435,53 +412,6 @@ static struct attribute *lock_module_attrs[] = {
 };
 
 /*
- * display struct gfs2_args fields
- */
-
-struct args_attr {
-        struct attribute attr;
-        ssize_t (*show)(struct gfs2_sbd *, char *);
-};
-
-#define ARGS_ATTR(name, fmt)                                                \
-static ssize_t name##_show(struct gfs2_sbd *sdp, char *buf)                 \
-{                                                                           \
-        return snprintf(buf, PAGE_SIZE, fmt, sdp->sd_args.ar_##name);       \
-}                                                                           \
-static struct args_attr args_attr_##name = __ATTR_RO(name)
-
-ARGS_ATTR(lockproto,       "%s\n");
-ARGS_ATTR(locktable,       "%s\n");
-ARGS_ATTR(hostdata,        "%s\n");
-ARGS_ATTR(spectator,       "%d\n");
-ARGS_ATTR(ignore_local_fs, "%d\n");
-ARGS_ATTR(localcaching,    "%d\n");
-ARGS_ATTR(localflocks,     "%d\n");
-ARGS_ATTR(debug,           "%d\n");
-ARGS_ATTR(upgrade,         "%d\n");
-ARGS_ATTR(posix_acl,       "%d\n");
-ARGS_ATTR(quota,           "%u\n");
-ARGS_ATTR(suiddir,         "%d\n");
-ARGS_ATTR(data,            "%d\n");
-
-static struct attribute *args_attrs[] = {
-        &args_attr_lockproto.attr,
-        &args_attr_locktable.attr,
-        &args_attr_hostdata.attr,
-        &args_attr_spectator.attr,
-        &args_attr_ignore_local_fs.attr,
-        &args_attr_localcaching.attr,
-        &args_attr_localflocks.attr,
-        &args_attr_debug.attr,
-        &args_attr_upgrade.attr,
-        &args_attr_posix_acl.attr,
-        &args_attr_quota.attr,
-        &args_attr_suiddir.attr,
-        &args_attr_data.attr,
-        NULL,
-};
-
-/*
  * get and set struct gfs2_tune fields
  */
 
@@ -531,14 +461,8 @@ static ssize_t tune_set(struct gfs2_sbd *sdp, unsigned int *field,
         return len;
 }
 
-struct tune_attr {
-        struct attribute attr;
-        ssize_t (*show)(struct gfs2_sbd *, char *);
-        ssize_t (*store)(struct gfs2_sbd *, const char *, size_t);
-};
-
 #define TUNE_ATTR_3(name, show, store)                                        \
-static struct tune_attr tune_attr_##name = __ATTR(name, 0644, show, store)
+static struct gfs2_attr tune_attr_##name = __ATTR(name, 0644, show, store)
 
 #define TUNE_ATTR_2(name, store)                                              \
 static ssize_t name##_show(struct gfs2_sbd *sdp, char *buf)                   \
@@ -554,15 +478,6 @@ static ssize_t name##_store(struct gfs2_sbd *sdp, const char *buf, size_t len)\
 }                                                                             \
 TUNE_ATTR_2(name, name##_store)
 
-#define TUNE_ATTR_DAEMON(name, process)                                       \
-static ssize_t name##_store(struct gfs2_sbd *sdp, const char *buf, size_t len)\
-{                                                                             \
-        ssize_t r = tune_set(sdp, &sdp->sd_tune.gt_##name, 1, buf, len);      \
-        wake_up_process(sdp->sd_##process);                                   \
-        return r;                                                             \
-}                                                                             \
-TUNE_ATTR_2(name, name##_store)
-
 TUNE_ATTR(incore_log_blocks, 0);
 TUNE_ATTR(log_flush_secs, 0);
 TUNE_ATTR(quota_warn_period, 0);
@@ -574,8 +489,6 @@ TUNE_ATTR(new_files_jdata, 0);
 TUNE_ATTR(quota_simul_sync, 1);
 TUNE_ATTR(stall_secs, 1);
 TUNE_ATTR(statfs_quantum, 1);
-TUNE_ATTR_DAEMON(recoverd_secs, recoverd_process);
-TUNE_ATTR_DAEMON(logd_secs, logd_process);
 TUNE_ATTR_3(quota_scale, quota_scale_show, quota_scale_store);
 
 static struct attribute *tune_attrs[] = {
@@ -589,23 +502,11 @@ static struct attribute *tune_attrs[] = {
         &tune_attr_quota_simul_sync.attr,
         &tune_attr_stall_secs.attr,
         &tune_attr_statfs_quantum.attr,
-        &tune_attr_recoverd_secs.attr,
-        &tune_attr_logd_secs.attr,
         &tune_attr_quota_scale.attr,
         &tune_attr_new_files_jdata.attr,
         NULL,
 };
 
-static struct attribute_group lockstruct_group = {
-        .name = "lockstruct",
-        .attrs = lockstruct_attrs,
-};
-
-static struct attribute_group args_group = {
-        .name = "args",
-        .attrs = args_attrs,
-};
-
 static struct attribute_group tune_group = {
         .name = "tune",
         .attrs = tune_attrs,
@@ -626,17 +527,9 @@ int gfs2_sys_fs_add(struct gfs2_sbd *sdp)
         if (error)
                 goto fail;
 
-        error = sysfs_create_group(&sdp->sd_kobj, &lockstruct_group);
-        if (error)
-                goto fail_reg;
-
-        error = sysfs_create_group(&sdp->sd_kobj, &args_group);
-        if (error)
-                goto fail_lockstruct;
-
         error = sysfs_create_group(&sdp->sd_kobj, &tune_group);
         if (error)
-                goto fail_args;
+                goto fail_reg;
 
         error = sysfs_create_group(&sdp->sd_kobj, &lock_module_group);
         if (error)
@@ -647,10 +540,6 @@ int gfs2_sys_fs_add(struct gfs2_sbd *sdp)
 
 fail_tune:
         sysfs_remove_group(&sdp->sd_kobj, &tune_group);
-fail_args:
-        sysfs_remove_group(&sdp->sd_kobj, &args_group);
-fail_lockstruct:
-        sysfs_remove_group(&sdp->sd_kobj, &lockstruct_group);
 fail_reg:
         kobject_put(&sdp->sd_kobj);
 fail:
@@ -661,8 +550,6 @@ fail:
 void gfs2_sys_fs_del(struct gfs2_sbd *sdp)
 {
         sysfs_remove_group(&sdp->sd_kobj, &tune_group);
-        sysfs_remove_group(&sdp->sd_kobj, &args_group);
-        sysfs_remove_group(&sdp->sd_kobj, &lockstruct_group);
         sysfs_remove_group(&sdp->sd_kobj, &lock_module_group);
         kobject_put(&sdp->sd_kobj);
 }
diff --git a/fs/gfs2/trans.c b/fs/gfs2/trans.c
index 053752d4b27f..4ef0e9fa3549 100644
--- a/fs/gfs2/trans.c
+++ b/fs/gfs2/trans.c
@@ -33,6 +33,9 @@ int gfs2_trans_begin(struct gfs2_sbd *sdp, unsigned int blocks,
         BUG_ON(current->journal_info);
         BUG_ON(blocks == 0 && revokes == 0);
 
+        if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
+                return -EROFS;
+
         tr = kzalloc(sizeof(struct gfs2_trans), GFP_NOFS);
         if (!tr)
                 return -ENOMEM;
@@ -54,12 +57,6 @@ int gfs2_trans_begin(struct gfs2_sbd *sdp, unsigned int blocks,
         if (error)
                 goto fail_holder_uninit;
 
-        if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags)) {
-                tr->tr_t_gh.gh_flags |= GL_NOCACHE;
-                error = -EROFS;
-                goto fail_gunlock;
-        }
-
         error = gfs2_log_reserve(sdp, tr->tr_reserved);
         if (error)
                 goto fail_gunlock;
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index c1462d43e721..941c8425c10b 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -30,6 +30,7 @@
 #include <linux/dnotify.h>
 #include <linux/statfs.h>
 #include <linux/security.h>
+#include <linux/ima.h>
 
 #include <asm/uaccess.h>
 
@@ -986,6 +987,7 @@ struct file *hugetlb_file_setup(const char *name, size_t size, int acctflag)
                         &hugetlbfs_file_operations);
         if (!file)
                 goto out_dentry; /* inode is already attached */
+        ima_counts_get(file);
 
         return file;
 
diff --git a/fs/ioctl.c b/fs/ioctl.c
index 82d9c42b8bac..286f38dfc6c0 100644
--- a/fs/ioctl.c
+++ b/fs/ioctl.c
@@ -414,10 +414,6 @@ static int file_ioctl(struct file *filp, unsigned int cmd,
         switch (cmd) {
         case FIBMAP:
                 return ioctl_fibmap(filp, p);
-        case FS_IOC_FIEMAP:
-                return ioctl_fiemap(filp, arg);
-        case FIGETBSZ:
-                return put_user(inode->i_sb->s_blocksize, p);
         case FIONREAD:
                 return put_user(i_size_read(inode) - filp->f_pos, p);
         }
@@ -557,6 +553,16 @@ int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
                 error = ioctl_fsthaw(filp);
                 break;
 
+        case FS_IOC_FIEMAP:
+                return ioctl_fiemap(filp, arg);
+
+        case FIGETBSZ:
+        {
+                struct inode *inode = filp->f_path.dentry->d_inode;
+                int __user *p = (int __user *)arg;
+                return put_user(inode->i_sb->s_blocksize, p);
+        }
+
         default:
                 if (S_ISREG(filp->f_path.dentry->d_inode->i_mode))
                         error = file_ioctl(filp, cmd, arg);
diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
index 58144102bf25..62be7d294ec2 100644
--- a/fs/jbd2/journal.c
+++ b/fs/jbd2/journal.c
@@ -1781,7 +1781,7 @@ int jbd2_journal_wipe(journal_t *journal, int write)
  * Journal abort has very specific semantics, which we describe
  * for journal abort.
  *
- * Two internal function, which provide abort to te jbd layer
+ * Two internal functions, which provide abort to the jbd layer
  * itself are here.
  */
 
@@ -1879,7 +1879,7 @@ void jbd2_journal_abort(journal_t *journal, int errno)
  * int jbd2_journal_errno () - returns the journal's error state.
  * @journal: journal to examine.
  *
- * This is the errno numbet set with jbd2_journal_abort(), the last
+ * This is the errno number set with jbd2_journal_abort(), the last
  * time the journal was mounted - if the journal was stopped
  * without calling abort this will be 0.
  *
@@ -1903,7 +1903,7 @@ int jbd2_journal_errno(journal_t *journal)
  * int jbd2_journal_clear_err () - clears the journal's error state
  * @journal: journal to act on.
  *
- * An error must be cleared or Acked to take a FS out of readonly
+ * An error must be cleared or acked to take a FS out of readonly
  * mode.
  */
 int jbd2_journal_clear_err(journal_t *journal)
@@ -1923,7 +1923,7 @@ int jbd2_journal_clear_err(journal_t *journal)
  * void jbd2_journal_ack_err() - Ack journal err.
  * @journal: journal to act on.
  *
- * An error must be cleared or Acked to take a FS out of readonly
+ * An error must be cleared or acked to take a FS out of readonly
  * mode.
  */
 void jbd2_journal_ack_err(journal_t *journal)
diff --git a/fs/mpage.c b/fs/mpage.c
index 680ba60863ff..42381bd6543b 100644
--- a/fs/mpage.c
+++ b/fs/mpage.c
@@ -379,7 +379,8 @@ mpage_readpages(struct address_space *mapping, struct list_head *pages,
         struct buffer_head map_bh;
         unsigned long first_logical_block = 0;
 
-        clear_buffer_mapped(&map_bh);
+        map_bh.b_state = 0;
+        map_bh.b_size = 0;
         for (page_idx = 0; page_idx < nr_pages; page_idx++) {
                 struct page *page = list_entry(pages->prev, struct page, lru);
 
@@ -412,7 +413,8 @@ int mpage_readpage(struct page *page, get_block_t get_block)
         struct buffer_head map_bh;
         unsigned long first_logical_block = 0;
 
-        clear_buffer_mapped(&map_bh);
+        map_bh.b_state = 0;
+        map_bh.b_size = 0;
         bio = do_mpage_readpage(bio, page, 1, &last_block_in_bio,
                         &map_bh, &first_logical_block, get_block);
         if (bio)
diff --git a/fs/namei.c b/fs/namei.c
index 967c3db92724..c82805d088e1 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -853,7 +853,8 @@ static int __link_path_walk(const char *name, struct nameidata *nd)
                         err = inode_permission(nd->path.dentry->d_inode,
                                                MAY_EXEC);
                 if (!err)
-                        err = ima_path_check(&nd->path, MAY_EXEC);
+                        err = ima_path_check(&nd->path, MAY_EXEC,
+                                             IMA_COUNT_UPDATE);
                 if (err)
                         break;
 
@@ -1515,7 +1516,8 @@ int may_open(struct path *path, int acc_mode, int flag)
                 return error;
 
         error = ima_path_check(path,
-                               acc_mode & (MAY_READ | MAY_WRITE | MAY_EXEC));
+                               acc_mode & (MAY_READ | MAY_WRITE | MAY_EXEC),
+                               IMA_COUNT_UPDATE);
         if (error)
                 return error;
         /*
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index b660435978d2..bd584bcf1d9f 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -55,6 +55,7 @@
 #include <linux/security.h>
 #endif /* CONFIG_NFSD_V4 */
 #include <linux/jhash.h>
+#include <linux/ima.h>
 
 #include <asm/uaccess.h>
 
@@ -735,6 +736,8 @@ nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
                             flags, cred);
         if (IS_ERR(*filp))
                 host_err = PTR_ERR(*filp);
+        else
+                ima_counts_get(*filp);
 out_nfserr:
         err = nfserrno(host_err);
 out:
@@ -2024,6 +2027,7 @@ nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp,
                                         struct dentry *dentry, int acc)
 {
         struct inode    *inode = dentry->d_inode;
+        struct path     path;
         int             err;
 
         if (acc == NFSD_MAY_NOP)
@@ -2096,7 +2100,17 @@ nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp,
         if (err == -EACCES && S_ISREG(inode->i_mode) &&
             acc == (NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE))
                 err = inode_permission(inode, MAY_EXEC);
+        if (err)
+                goto nfsd_out;
 
+        /* Do integrity (permission) checking now, but defer incrementing
+         * IMA counts to the actual file open.
+         */
+        path.mnt = exp->ex_path.mnt;
+        path.dentry = dentry;
+        err = ima_path_check(&path, acc & (MAY_READ | MAY_WRITE | MAY_EXEC),
+                             IMA_COUNT_LEAVE);
+nfsd_out:
         return err? nfserrno(err) : 0;
 }
 
diff --git a/fs/nilfs2/the_nilfs.c b/fs/nilfs2/the_nilfs.c
index 7f65b3be4aa9..a91f15b8673c 100644
--- a/fs/nilfs2/the_nilfs.c
+++ b/fs/nilfs2/the_nilfs.c
@@ -515,7 +515,7 @@ int init_nilfs(struct the_nilfs *nilfs, struct nilfs_sb_info *sbi, char *data)
 
         blocksize = BLOCK_SIZE << le32_to_cpu(sbp->s_log_block_size);
         if (sb->s_blocksize != blocksize) {
-                int hw_blocksize = bdev_hardsect_size(sb->s_bdev);
+                int hw_blocksize = bdev_logical_block_size(sb->s_bdev);
 
                 if (blocksize < hw_blocksize) {
                         printk(KERN_ERR
diff --git a/fs/ntfs/super.c b/fs/ntfs/super.c
index f76951dcd4a6..6aa7c4713536 100644
--- a/fs/ntfs/super.c
+++ b/fs/ntfs/super.c
@@ -25,7 +25,7 @@
 #include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/spinlock.h>
-#include <linux/blkdev.h>       /* For bdev_hardsect_size(). */
+#include <linux/blkdev.h>       /* For bdev_logical_block_size(). */
 #include <linux/backing-dev.h>
 #include <linux/buffer_head.h>
 #include <linux/vfs.h>
@@ -2785,13 +2785,13 @@ static int ntfs_fill_super(struct super_block *sb, void *opt, const int silent)
                 goto err_out_now;
 
         /* We support sector sizes up to the PAGE_CACHE_SIZE. */
-        if (bdev_hardsect_size(sb->s_bdev) > PAGE_CACHE_SIZE) {
+        if (bdev_logical_block_size(sb->s_bdev) > PAGE_CACHE_SIZE) {
                 if (!silent)
                         ntfs_error(sb, "Device has unsupported sector size "
                                         "(%i).  The maximum supported sector "
                                         "size on this architecture is %lu "
                                         "bytes.",
-                                        bdev_hardsect_size(sb->s_bdev),
+                                        bdev_logical_block_size(sb->s_bdev),
                                         PAGE_CACHE_SIZE);
                 goto err_out_now;
         }
diff --git a/fs/ocfs2/cluster/heartbeat.c b/fs/ocfs2/cluster/heartbeat.c
index 4f85eceab376..09cc25d04611 100644
--- a/fs/ocfs2/cluster/heartbeat.c
+++ b/fs/ocfs2/cluster/heartbeat.c
@@ -1371,7 +1371,7 @@ static ssize_t o2hb_region_dev_write(struct o2hb_region *reg,
 
         bdevname(reg->hr_bdev, reg->hr_dev_name);
 
-        sectsize = bdev_hardsect_size(reg->hr_bdev);
+        sectsize = bdev_logical_block_size(reg->hr_bdev);
         if (sectsize != reg->hr_block_bytes) {
                 mlog(ML_ERROR,
                      "blocksize %u incorrect for device, expected %d",
diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index 79ff8d9d37e0..5c6163f55039 100644
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -713,7 +713,7 @@ static int ocfs2_sb_probe(struct super_block *sb,
         *bh = NULL;
 
         /* may be > 512 */
-        *sector_size = bdev_hardsect_size(sb->s_bdev);
+        *sector_size = bdev_logical_block_size(sb->s_bdev);
         if (*sector_size > OCFS2_MAX_BLOCKSIZE) {
                 mlog(ML_ERROR, "Hardware sector size too large: %d (max=%d)\n",
                      *sector_size, OCFS2_MAX_BLOCKSIZE);
diff --git a/fs/partitions/check.c b/fs/partitions/check.c
index 99e33ef40be4..0af36085eb28 100644
--- a/fs/partitions/check.c
+++ b/fs/partitions/check.c
@@ -219,6 +219,13 @@ ssize_t part_size_show(struct device *dev,
         return sprintf(buf, "%llu\n",(unsigned long long)p->nr_sects);
 }
 
+ssize_t part_alignment_offset_show(struct device *dev,
+                                   struct device_attribute *attr, char *buf)
+{
+        struct hd_struct *p = dev_to_part(dev);
+        return sprintf(buf, "%llu\n", (unsigned long long)p->alignment_offset);
+}
+
 ssize_t part_stat_show(struct device *dev,
                        struct device_attribute *attr, char *buf)
 {
@@ -272,6 +279,7 @@ ssize_t part_fail_store(struct device *dev,
 static DEVICE_ATTR(partition, S_IRUGO, part_partition_show, NULL);
 static DEVICE_ATTR(start, S_IRUGO, part_start_show, NULL);
 static DEVICE_ATTR(size, S_IRUGO, part_size_show, NULL);
+static DEVICE_ATTR(alignment_offset, S_IRUGO, part_alignment_offset_show, NULL);
 static DEVICE_ATTR(stat, S_IRUGO, part_stat_show, NULL);
 #ifdef CONFIG_FAIL_MAKE_REQUEST
 static struct device_attribute dev_attr_fail =
@@ -282,6 +290,7 @@ static struct attribute *part_attrs[] = {
         &dev_attr_partition.attr,
         &dev_attr_start.attr,
         &dev_attr_size.attr,
+        &dev_attr_alignment_offset.attr,
         &dev_attr_stat.attr,
 #ifdef CONFIG_FAIL_MAKE_REQUEST
         &dev_attr_fail.attr,
@@ -383,6 +392,7 @@ struct hd_struct *add_partition(struct gendisk *disk, int partno,
         pdev = part_to_dev(p);
 
         p->start_sect = start;
+        p->alignment_offset = queue_sector_alignment_offset(disk->queue, start);
         p->nr_sects = len;
         p->partno = partno;
         p->policy = get_disk_ro(disk);
diff --git a/fs/partitions/ibm.c b/fs/partitions/ibm.c
index 46297683cd34..fc71aab08460 100644
--- a/fs/partitions/ibm.c
+++ b/fs/partitions/ibm.c
@@ -76,7 +76,7 @@ ibm_partition(struct parsed_partitions *state, struct block_device *bdev)
         Sector sect;
 
         res = 0;
-        blocksize = bdev_hardsect_size(bdev);
+        blocksize = bdev_logical_block_size(bdev);
         if (blocksize <= 0)
                 goto out_exit;
         i_size = i_size_read(bdev->bd_inode);
diff --git a/fs/partitions/msdos.c b/fs/partitions/msdos.c
index 796511886f28..0028d2ef0662 100644
--- a/fs/partitions/msdos.c
+++ b/fs/partitions/msdos.c
@@ -110,7 +110,7 @@ parse_extended(struct parsed_partitions *state, struct block_device *bdev,
         Sector sect;
         unsigned char *data;
         u32 this_sector, this_size;
-        int sector_size = bdev_hardsect_size(bdev) / 512;
+        int sector_size = bdev_logical_block_size(bdev) / 512;
         int loopct = 0;         /* number of links followed
                                    without finding a data partition */
         int i;
@@ -415,7 +415,7 @@ static struct {
  
 int msdos_partition(struct parsed_partitions *state, struct block_device *bdev)
 {
-        int sector_size = bdev_hardsect_size(bdev) / 512;
+        int sector_size = bdev_logical_block_size(bdev) / 512;
         Sector sect;
         unsigned char *data;
         struct partition *p;
diff --git a/fs/pipe.c b/fs/pipe.c
index 13414ec45b8d..f7dd21ad85a6 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -302,6 +302,20 @@ int generic_pipe_buf_confirm(struct pipe_inode_info *info,
         return 0;
 }
 
+/**
+ * generic_pipe_buf_release - put a reference to a &struct pipe_buffer
+ * @pipe:       the pipe that the buffer belongs to
+ * @buf:        the buffer to put a reference to
+ *
+ * Description:
+ *      This function releases a reference to @buf.
+ */
+void generic_pipe_buf_release(struct pipe_inode_info *pipe,
+                              struct pipe_buffer *buf)
+{
+        page_cache_release(buf->page);
+}
+
 static const struct pipe_buf_operations anon_pipe_buf_ops = {
         .can_merge = 1,
         .map = generic_pipe_buf_map,
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 3326bbf9ab95..1539e630c47d 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -2128,9 +2128,15 @@ static ssize_t proc_pid_attr_write(struct file * file, const char __user * buf,
         if (copy_from_user(page, buf, count))
                 goto out_free;
 
+        /* Guard against adverse ptrace interaction */
+        length = mutex_lock_interruptible(&task->cred_guard_mutex);
+        if (length < 0)
+                goto out_free;
+
         length = security_setprocattr(task,
                                       (char*)file->f_path.dentry->d_name.name,
                                       (void*)page, count);
+        mutex_unlock(&task->cred_guard_mutex);
 out_free:
         free_page((unsigned long) page);
 out:
diff --git a/fs/read_write.c b/fs/read_write.c
index 9d1e76bb9ee1..6c8c55dec2bc 100644
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -805,12 +805,6 @@ static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos,
                 goto out;
         if (!(in_file->f_mode & FMODE_READ))
                 goto fput_in;
-        retval = -EINVAL;
-        in_inode = in_file->f_path.dentry->d_inode;
-        if (!in_inode)
-                goto fput_in;
-        if (!in_file->f_op || !in_file->f_op->splice_read)
-                goto fput_in;
         retval = -ESPIPE;
         if (!ppos)
                 ppos = &in_file->f_pos;
@@ -834,6 +828,7 @@ static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos,
         retval = -EINVAL;
         if (!out_file->f_op || !out_file->f_op->sendpage)
                 goto fput_out;
+        in_inode = in_file->f_path.dentry->d_inode;
         out_inode = out_file->f_path.dentry->d_inode;
         retval = rw_verify_area(WRITE, out_file, &out_file->f_pos, count);
         if (retval < 0)
diff --git a/fs/splice.c b/fs/splice.c
index 666953d59a35..73766d24f97b 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -507,9 +507,131 @@ ssize_t generic_file_splice_read(struct file *in, loff_t *ppos,
 
         return ret;
 }
-
 EXPORT_SYMBOL(generic_file_splice_read);
 
+static const struct pipe_buf_operations default_pipe_buf_ops = {
+        .can_merge = 0,
+        .map = generic_pipe_buf_map,
+        .unmap = generic_pipe_buf_unmap,
+        .confirm = generic_pipe_buf_confirm,
+        .release = generic_pipe_buf_release,
+        .steal = generic_pipe_buf_steal,
+        .get = generic_pipe_buf_get,
+};
+
+static ssize_t kernel_readv(struct file *file, const struct iovec *vec,
+                            unsigned long vlen, loff_t offset)
+{
+        mm_segment_t old_fs;
+        loff_t pos = offset;
+        ssize_t res;
+
+        old_fs = get_fs();
+        set_fs(get_ds());
+        /* The cast to a user pointer is valid due to the set_fs() */
+        res = vfs_readv(file, (const struct iovec __user *)vec, vlen, &pos);
+        set_fs(old_fs);
+
+        return res;
+}
+
+static ssize_t kernel_write(struct file *file, const char *buf, size_t count,
+                            loff_t pos)
+{
+        mm_segment_t old_fs;
+        ssize_t res;
+
+        old_fs = get_fs();
+        set_fs(get_ds());
+        /* The cast to a user pointer is valid due to the set_fs() */
+        res = vfs_write(file, (const char __user *)buf, count, &pos);
+        set_fs(old_fs);
+
+        return res;
+}
+
+ssize_t default_file_splice_read(struct file *in, loff_t *ppos,
+                                 struct pipe_inode_info *pipe, size_t len,
+                                 unsigned int flags)
+{
+        unsigned int nr_pages;
+        unsigned int nr_freed;
+        size_t offset;
+        struct page *pages[PIPE_BUFFERS];
+        struct partial_page partial[PIPE_BUFFERS];
+        struct iovec vec[PIPE_BUFFERS];
+        pgoff_t index;
+        ssize_t res;
+        size_t this_len;
+        int error;
+        int i;
+        struct splice_pipe_desc spd = {
+                .pages = pages,
+                .partial = partial,
+                .flags = flags,
+                .ops = &default_pipe_buf_ops,
+                .spd_release = spd_release_page,
+        };
+
+        index = *ppos >> PAGE_CACHE_SHIFT;
+        offset = *ppos & ~PAGE_CACHE_MASK;
+        nr_pages = (len + offset + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+
+        for (i = 0; i < nr_pages && i < PIPE_BUFFERS && len; i++) {
+                struct page *page;
+
+                page = alloc_page(GFP_USER);
+                error = -ENOMEM;
+                if (!page)
+                        goto err;
+
+                this_len = min_t(size_t, len, PAGE_CACHE_SIZE - offset);
+                vec[i].iov_base = (void __user *) page_address(page);
+                vec[i].iov_len = this_len;
+                pages[i] = page;
+                spd.nr_pages++;
+                len -= this_len;
+                offset = 0;
+        }
+
+        res = kernel_readv(in, vec, spd.nr_pages, *ppos);
+        if (res < 0) {
+                error = res;
+                goto err;
+        }
+
+        error = 0;
+        if (!res)
+                goto err;
+
+        nr_freed = 0;
+        for (i = 0; i < spd.nr_pages; i++) {
+                this_len = min_t(size_t, vec[i].iov_len, res);
+                partial[i].offset = 0;
+                partial[i].len = this_len;
+                if (!this_len) {
+                        __free_page(pages[i]);
+                        pages[i] = NULL;
+                        nr_freed++;
+                }
+                res -= this_len;
+        }
+        spd.nr_pages -= nr_freed;
+
+        res = splice_to_pipe(pipe, &spd);
+        if (res > 0)
+                *ppos += res;
+
+        return res;
+
+err:
+        for (i = 0; i < spd.nr_pages; i++)
+                __free_page(pages[i]);
+
+        return error;
+}
+EXPORT_SYMBOL(default_file_splice_read);
+
 /*
  * Send 'sd->len' bytes to socket from 'sd->file' at position 'sd->pos'
  * using sendpage(). Return the number of bytes sent.
@@ -881,6 +1003,36 @@ generic_file_splice_write(struct pipe_inode_info *pipe, struct file *out,
 
 EXPORT_SYMBOL(generic_file_splice_write);
 
+static int write_pipe_buf(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
+                          struct splice_desc *sd)
+{
+        int ret;
+        void *data;
+
+        ret = buf->ops->confirm(pipe, buf);
+        if (ret)
+                return ret;
+
+        data = buf->ops->map(pipe, buf, 0);
+        ret = kernel_write(sd->u.file, data + buf->offset, sd->len, sd->pos);
+        buf->ops->unmap(pipe, buf, data);
+
+        return ret;
+}
+
+static ssize_t default_file_splice_write(struct pipe_inode_info *pipe,
+                                         struct file *out, loff_t *ppos,
+                                         size_t len, unsigned int flags)
+{
+        ssize_t ret;
+
+        ret = splice_from_pipe(pipe, out, ppos, len, flags, write_pipe_buf);
+        if (ret > 0)
+                *ppos += ret;
+
+        return ret;
+}
+
 /**
  * generic_splice_sendpage - splice data from a pipe to a socket
  * @pipe:       pipe to splice from
@@ -908,11 +1060,10 @@ EXPORT_SYMBOL(generic_splice_sendpage);
 static long do_splice_from(struct pipe_inode_info *pipe, struct file *out,
                            loff_t *ppos, size_t len, unsigned int flags)
 {
+        ssize_t (*splice_write)(struct pipe_inode_info *, struct file *,
+                                loff_t *, size_t, unsigned int);
         int ret;
 
-        if (unlikely(!out->f_op || !out->f_op->splice_write))
-                return -EINVAL;
-
         if (unlikely(!(out->f_mode & FMODE_WRITE)))
                 return -EBADF;
 
@@ -923,7 +1074,11 @@ static long do_splice_from(struct pipe_inode_info *pipe, struct file *out,
         if (unlikely(ret < 0))
                 return ret;
 
-        return out->f_op->splice_write(pipe, out, ppos, len, flags);
+        splice_write = out->f_op->splice_write;
+        if (!splice_write)
+                splice_write = default_file_splice_write;
+
+        return splice_write(pipe, out, ppos, len, flags);
 }
 
 /*
@@ -933,11 +1088,10 @@ static long do_splice_to(struct file *in, loff_t *ppos,
                          struct pipe_inode_info *pipe, size_t len,
                          unsigned int flags)
 {
+        ssize_t (*splice_read)(struct file *, loff_t *,
+                               struct pipe_inode_info *, size_t, unsigned int);
         int ret;
 
-        if (unlikely(!in->f_op || !in->f_op->splice_read))
-                return -EINVAL;
-
         if (unlikely(!(in->f_mode & FMODE_READ)))
                 return -EBADF;
 
@@ -945,7 +1099,11 @@ static long do_splice_to(struct file *in, loff_t *ppos,
         if (unlikely(ret < 0))
                 return ret;
 
-        return in->f_op->splice_read(in, ppos, pipe, len, flags);
+        splice_read = in->f_op->splice_read;
+        if (!splice_read)
+                splice_read = default_file_splice_read;
+
+        return splice_read(in, ppos, pipe, len, flags);
 }
 
 /**
@@ -1112,6 +1270,9 @@ long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
         return ret;
 }
 
+static int splice_pipe_to_pipe(struct pipe_inode_info *ipipe,
+                               struct pipe_inode_info *opipe,
+                               size_t len, unsigned int flags);
 /*
  * After the inode slimming patch, i_pipe/i_bdev/i_cdev share the same
  * location, so checking ->i_pipe is not enough to verify that this is a
@@ -1132,12 +1293,32 @@ static long do_splice(struct file *in, loff_t __user *off_in,
                       struct file *out, loff_t __user *off_out,
                       size_t len, unsigned int flags)
 {
-        struct pipe_inode_info *pipe;
+        struct pipe_inode_info *ipipe;
+        struct pipe_inode_info *opipe;
         loff_t offset, *off;
         long ret;
 
-        pipe = pipe_info(in->f_path.dentry->d_inode);
-        if (pipe) {
+        ipipe = pipe_info(in->f_path.dentry->d_inode);
+        opipe = pipe_info(out->f_path.dentry->d_inode);
+
+        if (ipipe && opipe) {
+                if (off_in || off_out)
+                        return -ESPIPE;
+
+                if (!(in->f_mode & FMODE_READ))
+                        return -EBADF;
+
+                if (!(out->f_mode & FMODE_WRITE))
+                        return -EBADF;
+
+                /* Splicing to self would be fun, but... */
+                if (ipipe == opipe)
+                        return -EINVAL;
+
+                return splice_pipe_to_pipe(ipipe, opipe, len, flags);
+        }
+
+        if (ipipe) {
                 if (off_in)
                         return -ESPIPE;
                 if (off_out) {
@@ -1149,7 +1330,7 @@ static long do_splice(struct file *in, loff_t __user *off_in,
                 } else
                         off = &out->f_pos;
 
-                ret = do_splice_from(pipe, out, off, len, flags);
+                ret = do_splice_from(ipipe, out, off, len, flags);
 
                 if (off_out && copy_to_user(off_out, off, sizeof(loff_t)))
                         ret = -EFAULT;
@@ -1157,8 +1338,7 @@ static long do_splice(struct file *in, loff_t __user *off_in,
                 return ret;
         }
 
-        pipe = pipe_info(out->f_path.dentry->d_inode);
-        if (pipe) {
+        if (opipe) {
                 if (off_out)
                         return -ESPIPE;
                 if (off_in) {
@@ -1170,7 +1350,7 @@ static long do_splice(struct file *in, loff_t __user *off_in,
                 } else
                         off = &in->f_pos;
 
-                ret = do_splice_to(in, off, pipe, len, flags);
+                ret = do_splice_to(in, off, opipe, len, flags);
 
                 if (off_in && copy_to_user(off_in, off, sizeof(loff_t)))
                         ret = -EFAULT;
@@ -1511,7 +1691,7 @@ SYSCALL_DEFINE6(splice, int, fd_in, loff_t __user *, off_in,
  * Make sure there's data to read. Wait for input if we can, otherwise
  * return an appropriate error.
  */
-static int link_ipipe_prep(struct pipe_inode_info *pipe, unsigned int flags)
+static int ipipe_prep(struct pipe_inode_info *pipe, unsigned int flags)
 {
         int ret;
 
@@ -1549,7 +1729,7 @@ static int link_ipipe_prep(struct pipe_inode_info *pipe, unsigned int flags)
  * Make sure there's writeable room. Wait for room if we can, otherwise
  * return an appropriate error.
  */
-static int link_opipe_prep(struct pipe_inode_info *pipe, unsigned int flags)
+static int opipe_prep(struct pipe_inode_info *pipe, unsigned int flags)
 {
         int ret;
 
@@ -1587,6 +1767,124 @@ static int link_opipe_prep(struct pipe_inode_info *pipe, unsigned int flags)
 }
 
 /*
+ * Splice contents of ipipe to opipe.
+ */
+static int splice_pipe_to_pipe(struct pipe_inode_info *ipipe,
+                               struct pipe_inode_info *opipe,
+                               size_t len, unsigned int flags)
+{
+        struct pipe_buffer *ibuf, *obuf;
+        int ret = 0, nbuf;
+        bool input_wakeup = false;
+
+
+retry:
+        ret = ipipe_prep(ipipe, flags);
+        if (ret)
+                return ret;
+
+        ret = opipe_prep(opipe, flags);
+        if (ret)
+                return ret;
+
+        /*
+         * Potential ABBA deadlock, work around it by ordering lock
+         * grabbing by pipe info address. Otherwise two different processes
+         * could deadlock (one doing tee from A -> B, the other from B -> A).
+         */
+        pipe_double_lock(ipipe, opipe);
+
+        do {
+                if (!opipe->readers) {
+                        send_sig(SIGPIPE, current, 0);
+                        if (!ret)
+                                ret = -EPIPE;
+                        break;
+                }
+
+                if (!ipipe->nrbufs && !ipipe->writers)
+                        break;
+
+                /*
+                 * Cannot make any progress, because either the input
+                 * pipe is empty or the output pipe is full.
+                 */
+                if (!ipipe->nrbufs || opipe->nrbufs >= PIPE_BUFFERS) {
+                        /* Already processed some buffers, break */
+                        if (ret)
+                                break;
+
+                        if (flags & SPLICE_F_NONBLOCK) {
+                                ret = -EAGAIN;
+                                break;
+                        }
+
+                        /*
+                         * We raced with another reader/writer and haven't
+                         * managed to process any buffers.  A zero return
+                         * value means EOF, so retry instead.
+                         */
+                        pipe_unlock(ipipe);
+                        pipe_unlock(opipe);
+                        goto retry;
+                }
+
+                ibuf = ipipe->bufs + ipipe->curbuf;
+                nbuf = (opipe->curbuf + opipe->nrbufs) % PIPE_BUFFERS;
+                obuf = opipe->bufs + nbuf;
+
+                if (len >= ibuf->len) {
+                        /*
+                         * Simply move the whole buffer from ipipe to opipe
+                         */
+                        *obuf = *ibuf;
+                        ibuf->ops = NULL;
+                        opipe->nrbufs++;
+                        ipipe->curbuf = (ipipe->curbuf + 1) % PIPE_BUFFERS;
+                        ipipe->nrbufs--;
+                        input_wakeup = true;
+                } else {
+                        /*
+                         * Get a reference to this pipe buffer,
+                         * so we can copy the contents over.
+                         */
+                        ibuf->ops->get(ipipe, ibuf);
+                        *obuf = *ibuf;
+
+                        /*
+                         * Don't inherit the gift flag, we need to
+                         * prevent multiple steals of this page.
+                         */
+                        obuf->flags &= ~PIPE_BUF_FLAG_GIFT;
+
+                        obuf->len = len;
+                        opipe->nrbufs++;
+                        ibuf->offset += obuf->len;
+                        ibuf->len -= obuf->len;
+                }
+                ret += obuf->len;
+                len -= obuf->len;
+        } while (len);
+
+        pipe_unlock(ipipe);
+        pipe_unlock(opipe);
+
+        /*
+         * If we put data in the output pipe, wakeup any potential readers.
+         */
+        if (ret > 0) {
+                smp_mb();
+                if (waitqueue_active(&opipe->wait))
+                        wake_up_interruptible(&opipe->wait);
+                kill_fasync(&opipe->fasync_readers, SIGIO, POLL_IN);
+        }
+        if (input_wakeup)
+                wakeup_pipe_writers(ipipe);
+
+        return ret;
+}
+
+/*
  * Link contents of ipipe to opipe.
  */
 static int link_pipe(struct pipe_inode_info *ipipe,
@@ -1690,9 +1988,9 @@ static long do_tee(struct file *in, struct file *out, size_t len,
                  * Keep going, unless we encounter an error. The ipipe/opipe
                  * ordering doesn't really matter.
                  */
-                ret = link_ipipe_prep(ipipe, flags);
+                ret = ipipe_prep(ipipe, flags);
                 if (!ret) {
-                        ret = link_opipe_prep(opipe, flags);
+                        ret = opipe_prep(opipe, flags);
                         if (!ret)
                                 ret = link_pipe(ipipe, opipe, len, flags);
                 }
diff --git a/fs/udf/super.c b/fs/udf/super.c
index 72348cc855a4..0ba44107d8f1 100644
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -1915,7 +1915,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
         if (uopt.flags & (1 << UDF_FLAG_BLOCKSIZE_SET)) {
                 ret = udf_load_vrs(sb, &uopt, silent, &fileset);
         } else {
-                uopt.blocksize = bdev_hardsect_size(sb->s_bdev);
+                uopt.blocksize = bdev_logical_block_size(sb->s_bdev);
                 ret = udf_load_vrs(sb, &uopt, silent, &fileset);
                 if (!ret && uopt.blocksize != UDF_DEFAULT_BLOCKSIZE) {
                         if (!silent)
diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
index e28800a9f2b5..1418b916fc27 100644
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -1501,7 +1501,7 @@ xfs_setsize_buftarg_early(
         struct block_device     *bdev)
 {
         return xfs_setsize_buftarg_flags(btp,
-                        PAGE_CACHE_SIZE, bdev_hardsect_size(bdev), 0);
+                        PAGE_CACHE_SIZE, bdev_logical_block_size(bdev), 0);
 }
 
 int
diff --git a/include/linux/bio.h b/include/linux/bio.h
index 7b214fd672a2..12737be58601 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -218,12 +218,12 @@ struct bio {
 #define bio_sectors(bio)        ((bio)->bi_size >> 9)
 #define bio_empty_barrier(bio)  (bio_barrier(bio) && !bio_has_data(bio) && !bio_discard(bio))
 
-static inline unsigned int bio_cur_sectors(struct bio *bio)
+static inline unsigned int bio_cur_bytes(struct bio *bio)
 {
         if (bio->bi_vcnt)
-                return bio_iovec(bio)->bv_len >> 9;
+                return bio_iovec(bio)->bv_len;
         else /* dataless requests such as discard */
-                return bio->bi_size >> 9;
+                return bio->bi_size;
 }
 
 static inline void *bio_data(struct bio *bio)
@@ -279,7 +279,7 @@ static inline int bio_has_allocated_vec(struct bio *bio)
 #define __BIO_SEG_BOUNDARY(addr1, addr2, mask) \
         (((addr1) | (mask)) == (((addr2) - 1) | (mask)))
 #define BIOVEC_SEG_BOUNDARY(q, b1, b2) \
-        __BIO_SEG_BOUNDARY(bvec_to_phys((b1)), bvec_to_phys((b2)) + (b2)->bv_len, (q)->seg_boundary_mask)
+        __BIO_SEG_BOUNDARY(bvec_to_phys((b1)), bvec_to_phys((b2)) + (b2)->bv_len, queue_segment_boundary((q)))
 #define BIO_SEG_BOUNDARY(q, b1, b2) \
         BIOVEC_SEG_BOUNDARY((q), __BVEC_END((b1)), __BVEC_START((b2)))
 
@@ -506,7 +506,7 @@ static inline int bio_has_data(struct bio *bio)
 }
 
 /*
- * BIO list managment for use by remapping drivers (e.g. DM or MD).
+ * BIO list management for use by remapping drivers (e.g. DM or MD) and loop.
  *
  * A bio_list anchors a singly-linked list of bios chained through the bi_next
  * member of the bio.  The bio_list also caches the last list member to allow
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index b4f71f1a4af7..ebdfde8fe556 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -166,19 +166,9 @@ struct request {
         enum rq_cmd_type_bits cmd_type;
         unsigned long atomic_flags;
 
-        /* Maintain bio traversal state for part by part I/O submission.
-         * hard_* are block layer internals, no driver should touch them!
-         */
-
-        sector_t sector;                /* next sector to submit */
-        sector_t hard_sector;           /* next sector to complete */
-        unsigned long nr_sectors;       /* no. of sectors left to submit */
-        unsigned long hard_nr_sectors;  /* no. of sectors left to complete */
-        /* no. of sectors left to submit in the current segment */
-        unsigned int current_nr_sectors;
-
-        /* no. of sectors left to complete in the current segment */
-        unsigned int hard_cur_sectors;
+        /* the following two fields are internal, NEVER access directly */
+        sector_t __sector;              /* sector cursor */
+        unsigned int __data_len;        /* total data len */
 
         struct bio *bio;
         struct bio *biotail;
@@ -211,8 +201,8 @@ struct request {
 
         unsigned short ioprio;
 
-        void *special;
-        char *buffer;
+        void *special;          /* opaque pointer available for LLD use */
+        char *buffer;           /* kaddr of the current segment if available */
 
         int tag;
         int errors;
@@ -226,10 +216,9 @@ struct request {
         unsigned char __cmd[BLK_MAX_CDB];
         unsigned char *cmd;
 
-        unsigned int data_len;
         unsigned int extra_len; /* length of alignment and padding */
         unsigned int sense_len;
-        void *data;
+        unsigned int resid_len; /* residual count */
         void *sense;
 
         unsigned long deadline;
@@ -318,6 +307,26 @@ struct blk_cmd_filter {
         struct kobject kobj;
 };
 
+struct queue_limits {
+        unsigned long           bounce_pfn;
+        unsigned long           seg_boundary_mask;
+
+        unsigned int            max_hw_sectors;
+        unsigned int            max_sectors;
+        unsigned int            max_segment_size;
+        unsigned int            physical_block_size;
+        unsigned int            alignment_offset;
+        unsigned int            io_min;
+        unsigned int            io_opt;
+
+        unsigned short          logical_block_size;
+        unsigned short          max_hw_segments;
+        unsigned short          max_phys_segments;
+
+        unsigned char           misaligned;
+        unsigned char           no_cluster;
+};
+
 struct request_queue
 {
         /*
@@ -369,7 +378,6 @@ struct request_queue
         /*
          * queue needs bounce pages for pages above this limit
          */
-        unsigned long           bounce_pfn;
         gfp_t                   bounce_gfp;
 
         /*
@@ -398,14 +406,6 @@ struct request_queue
         unsigned int            nr_congestion_off;
         unsigned int            nr_batching;
 
-        unsigned int            max_sectors;
-        unsigned int            max_hw_sectors;
-        unsigned short          max_phys_segments;
-        unsigned short          max_hw_segments;
-        unsigned short          hardsect_size;
-        unsigned int            max_segment_size;
-
-        unsigned long           seg_boundary_mask;
         void                    *dma_drain_buffer;
         unsigned int            dma_drain_size;
         unsigned int            dma_pad_mask;
@@ -415,12 +415,14 @@ struct request_queue
         struct list_head        tag_busy_list;
 
         unsigned int            nr_sorted;
-        unsigned int            in_flight;
+        unsigned int            in_flight[2];
 
         unsigned int            rq_timeout;
         struct timer_list       timeout;
         struct list_head        timeout_list;
 
+        struct queue_limits     limits;
+
         /*
          * sg stuff
          */
@@ -522,6 +524,11 @@ static inline void queue_flag_clear_unlocked(unsigned int flag,
         __clear_bit(flag, &q->queue_flags);
 }
 
+static inline int queue_in_flight(struct request_queue *q)
+{
+        return q->in_flight[0] + q->in_flight[1];
+}
+
 static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
 {
         WARN_ON_ONCE(!queue_is_locked(q));
@@ -752,10 +759,17 @@ extern void blk_rq_init(struct request_queue *q, struct request *rq);
 extern void blk_put_request(struct request *);
 extern void __blk_put_request(struct request_queue *, struct request *);
 extern struct request *blk_get_request(struct request_queue *, int, gfp_t);
+extern struct request *blk_make_request(struct request_queue *, struct bio *,
+                                        gfp_t);
 extern void blk_insert_request(struct request_queue *, struct request *, int, void *);
 extern void blk_requeue_request(struct request_queue *, struct request *);
 extern int blk_rq_check_limits(struct request_queue *q, struct request *rq);
 extern int blk_lld_busy(struct request_queue *q);
+extern int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
+                             struct bio_set *bs, gfp_t gfp_mask,
+                             int (*bio_ctr)(struct bio *, struct bio *, void *),
+                             void *data);
+extern void blk_rq_unprep_clone(struct request *rq);
 extern int blk_insert_cloned_request(struct request_queue *q,
                                      struct request *rq);
 extern void blk_plug_device(struct request_queue *);
@@ -768,12 +782,6 @@ extern int sg_scsi_ioctl(struct request_queue *, struct gendisk *, fmode_t,
                          struct scsi_ioctl_command __user *);
 
 /*
- * Temporary export, until SCSI gets fixed up.
- */
-extern int blk_rq_append_bio(struct request_queue *q, struct request *rq,
-                             struct bio *bio);
-
-/*
  * A queue has just exitted congestion.  Note this in the global counter of
  * congested queues, and wake up anyone who was waiting for requests to be
  * put back.
@@ -798,7 +806,6 @@ extern void blk_sync_queue(struct request_queue *q);
 extern void __blk_stop_queue(struct request_queue *q);
 extern void __blk_run_queue(struct request_queue *);
 extern void blk_run_queue(struct request_queue *);
-extern void blk_start_queueing(struct request_queue *);
 extern int blk_rq_map_user(struct request_queue *, struct request *,
                            struct rq_map_data *, void __user *, unsigned long,
                            gfp_t);
@@ -831,41 +838,73 @@ static inline void blk_run_address_space(struct address_space *mapping)
                 blk_run_backing_dev(mapping->backing_dev_info, NULL);
 }
 
-extern void blkdev_dequeue_request(struct request *req);
+/*
+ * blk_rq_pos()         : the current sector
+ * blk_rq_bytes()       : bytes left in the entire request
+ * blk_rq_cur_bytes()   : bytes left in the current segment
+ * blk_rq_sectors()     : sectors left in the entire request
+ * blk_rq_cur_sectors() : sectors left in the current segment
+ */
+static inline sector_t blk_rq_pos(const struct request *rq)
+{
+        return rq->__sector;
+}
+
+static inline unsigned int blk_rq_bytes(const struct request *rq)
+{
+        return rq->__data_len;
+}
+
+static inline int blk_rq_cur_bytes(const struct request *rq)
+{
+        return rq->bio ? bio_cur_bytes(rq->bio) : 0;
+}
+
+static inline unsigned int blk_rq_sectors(const struct request *rq)
+{
+        return blk_rq_bytes(rq) >> 9;
+}
+
+static inline unsigned int blk_rq_cur_sectors(const struct request *rq)
+{
+        return blk_rq_cur_bytes(rq) >> 9;
+}
+
+/*
+ * Request issue related functions.
+ */
+extern struct request *blk_peek_request(struct request_queue *q);
+extern void blk_start_request(struct request *rq);
+extern struct request *blk_fetch_request(struct request_queue *q);
 
 /*
- * blk_end_request() and friends.
- * __blk_end_request() and end_request() must be called with
- * the request queue spinlock acquired.
+ * Request completion related functions.
+ *
+ * blk_update_request() completes given number of bytes and updates
+ * the request without completing it.
+ *
+ * blk_end_request() and friends.  __blk_end_request() must be called
+ * with the request queue spinlock acquired.
  *
  * Several drivers define their own end_request and call
  * blk_end_request() for parts of the original function.
  * This prevents code duplication in drivers.
  */
-extern int blk_end_request(struct request *rq, int error,
-                                unsigned int nr_bytes);
-extern int __blk_end_request(struct request *rq, int error,
-                                unsigned int nr_bytes);
-extern int blk_end_bidi_request(struct request *rq, int error,
-                                unsigned int nr_bytes, unsigned int bidi_bytes);
-extern void end_request(struct request *, int);
-extern int blk_end_request_callback(struct request *rq, int error,
-                                unsigned int nr_bytes,
-                                int (drv_callback)(struct request *));
+extern bool blk_update_request(struct request *rq, int error,
+                               unsigned int nr_bytes);
+extern bool blk_end_request(struct request *rq, int error,
+                            unsigned int nr_bytes);
+extern void blk_end_request_all(struct request *rq, int error);
+extern bool blk_end_request_cur(struct request *rq, int error);
+extern bool __blk_end_request(struct request *rq, int error,
+                              unsigned int nr_bytes);
+extern void __blk_end_request_all(struct request *rq, int error);
+extern bool __blk_end_request_cur(struct request *rq, int error);
+
 extern void blk_complete_request(struct request *);
 extern void __blk_complete_request(struct request *);
 extern void blk_abort_request(struct request *);
 extern void blk_abort_queue(struct request_queue *);
-extern void blk_update_request(struct request *rq, int error,
-                               unsigned int nr_bytes);
-
-/*
- * blk_end_request() takes bytes instead of sectors as a complete size.
- * blk_rq_bytes() returns bytes left to complete in the entire request.
- * blk_rq_cur_bytes() returns bytes left to complete in the current segment.
- */
-extern unsigned int blk_rq_bytes(struct request *rq);
-extern unsigned int blk_rq_cur_bytes(struct request *rq);
 
 /*
  * Access functions for manipulating queue properties
@@ -877,10 +916,20 @@ extern void blk_cleanup_queue(struct request_queue *);
 extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
 extern void blk_queue_bounce_limit(struct request_queue *, u64);
 extern void blk_queue_max_sectors(struct request_queue *, unsigned int);
+extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
 extern void blk_queue_max_phys_segments(struct request_queue *, unsigned short);
 extern void blk_queue_max_hw_segments(struct request_queue *, unsigned short);
 extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
-extern void blk_queue_hardsect_size(struct request_queue *, unsigned short);
+extern void blk_queue_logical_block_size(struct request_queue *, unsigned short);
+extern void blk_queue_physical_block_size(struct request_queue *, unsigned short);
+extern void blk_queue_alignment_offset(struct request_queue *q,
+                                       unsigned int alignment);
+extern void blk_queue_io_min(struct request_queue *q, unsigned int min);
+extern void blk_queue_io_opt(struct request_queue *q, unsigned int opt);
+extern int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
+                            sector_t offset);
+extern void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
+                              sector_t offset);
 extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
 extern void blk_queue_dma_pad(struct request_queue *, unsigned int);
 extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int);
@@ -967,19 +1016,87 @@ extern void blk_set_cmd_filter_defaults(struct blk_cmd_filter *filter);
 
 #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
 
-static inline int queue_hardsect_size(struct request_queue *q)
+static inline unsigned long queue_bounce_pfn(struct request_queue *q)
+{
+        return q->limits.bounce_pfn;
+}
+
+static inline unsigned long queue_segment_boundary(struct request_queue *q)
+{
+        return q->limits.seg_boundary_mask;
+}
+
+static inline unsigned int queue_max_sectors(struct request_queue *q)
+{
+        return q->limits.max_sectors;
+}
+
+static inline unsigned int queue_max_hw_sectors(struct request_queue *q)
+{
+        return q->limits.max_hw_sectors;
+}
+
+static inline unsigned short queue_max_hw_segments(struct request_queue *q)
+{
+        return q->limits.max_hw_segments;
+}
+
+static inline unsigned short queue_max_phys_segments(struct request_queue *q)
+{
+        return q->limits.max_phys_segments;
+}
+
+static inline unsigned int queue_max_segment_size(struct request_queue *q)
+{
+        return q->limits.max_segment_size;
+}
+
+static inline unsigned short queue_logical_block_size(struct request_queue *q)
 {
         int retval = 512;
 
-        if (q && q->hardsect_size)
-                retval = q->hardsect_size;
+        if (q && q->limits.logical_block_size)
+                retval = q->limits.logical_block_size;
 
         return retval;
 }
 
-static inline int bdev_hardsect_size(struct block_device *bdev)
+static inline unsigned short bdev_logical_block_size(struct block_device *bdev)
+{
+        return queue_logical_block_size(bdev_get_queue(bdev));
+}
+
+static inline unsigned int queue_physical_block_size(struct request_queue *q)
+{
+        return q->limits.physical_block_size;
+}
+
+static inline unsigned int queue_io_min(struct request_queue *q)
+{
+        return q->limits.io_min;
+}
+
+static inline unsigned int queue_io_opt(struct request_queue *q)
+{
+        return q->limits.io_opt;
+}
+
+static inline int queue_alignment_offset(struct request_queue *q)
+{
+        if (q && q->limits.misaligned)
+                return -1;
+
+        if (q && q->limits.alignment_offset)
+                return q->limits.alignment_offset;
+
+        return 0;
+}
+
+static inline int queue_sector_alignment_offset(struct request_queue *q,
+                                                sector_t sector)
 {
-        return queue_hardsect_size(bdev_get_queue(bdev));
+        return ((sector << 9) - q->limits.alignment_offset)
+                & (q->limits.io_min - 1);
 }
 
 static inline int queue_dma_alignment(struct request_queue *q)
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index 5a40d14daa9f..c56457c8334e 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -288,7 +288,15 @@ static inline cycle_t clocksource_read(struct clocksource *cs)
  */
 static inline int clocksource_enable(struct clocksource *cs)
 {
-        return cs->enable ? cs->enable(cs) : 0;
+        int ret = 0;
+
+        if (cs->enable)
+                ret = cs->enable(cs);
+
+        /* save mult_orig on enable */
+        cs->mult_orig = cs->mult;
+
+        return ret;
 }
 
 /**
diff --git a/include/linux/cyclades.h b/include/linux/cyclades.h
index 788850ba4e75..1fbdea4f08eb 100644
--- a/include/linux/cyclades.h
+++ b/include/linux/cyclades.h
@@ -142,19 +142,6 @@ struct CYZ_BOOT_CTRL {
 
 
 #ifndef DP_WINDOW_SIZE
-/* #include "cyclomz.h" */
-/****************** ****************** *******************/
-/*
- *      The data types defined below are used in all ZFIRM interface
- *      data structures. They accomodate differences between HW
- *      architectures and compilers.
- */
-
-typedef __u64  ucdouble;                /* 64 bits, unsigned */
-typedef __u32  uclong;                  /* 32 bits, unsigned */
-typedef __u16  ucshort;         /* 16 bits, unsigned */
-typedef __u8   ucchar;                  /* 8 bits, unsigned */
-
 /*
  *      Memory Window Sizes
  */
@@ -507,16 +494,20 @@ struct ZFW_CTRL {
 
 /* Per card data structure */
 struct cyclades_card {
-    void __iomem *base_addr;
-    void __iomem *ctl_addr;
-    int irq;
-    unsigned int num_chips;     /* 0 if card absent, -1 if Z/PCI, else Y */
-    unsigned int first_line;    /* minor number of first channel on card */
-    unsigned int nports;        /* Number of ports in the card */
-    int bus_index;              /* address shift - 0 for ISA, 1 for PCI */
-    int intr_enabled;           /* FW Interrupt flag - 0 disabled, 1 enabled */
-    spinlock_t card_lock;
-    struct cyclades_port *ports;
+        void __iomem *base_addr;
+        union {
+                void __iomem *p9050;
+                struct RUNTIME_9060 __iomem *p9060;
+        } ctl_addr;
+        int irq;
+        unsigned int num_chips; /* 0 if card absent, -1 if Z/PCI, else Y */
+        unsigned int first_line;        /* minor number of first channel on card */
+        unsigned int nports;    /* Number of ports in the card */
+        int bus_index;          /* address shift - 0 for ISA, 1 for PCI */
+        int intr_enabled;               /* FW Interrupt flag - 0 disabled, 1 enabled */
+        u32 hw_ver;
+        spinlock_t card_lock;
+        struct cyclades_port *ports;
 };
 
 /***************************************
diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
index ded2d7c42668..49c2362977fd 100644
--- a/include/linux/device-mapper.h
+++ b/include/linux/device-mapper.h
@@ -149,7 +149,7 @@ struct io_restrictions {
         unsigned max_hw_sectors;
         unsigned max_sectors;
         unsigned max_segment_size;
-        unsigned short hardsect_size;
+        unsigned short logical_block_size;
         unsigned short max_hw_segments;
         unsigned short max_phys_segments;
         unsigned char no_cluster; /* inverted so that 0 is default */
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index c59b769f62b0..1cb3372e65d8 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -103,10 +103,8 @@ extern int elv_merge(struct request_queue *, struct request **, struct bio *);
 extern void elv_merge_requests(struct request_queue *, struct request *,
                                struct request *);
 extern void elv_merged_request(struct request_queue *, struct request *, int);
-extern void elv_dequeue_request(struct request_queue *, struct request *);
 extern void elv_requeue_request(struct request_queue *, struct request *);
 extern int elv_queue_empty(struct request_queue *);
-extern struct request *elv_next_request(struct request_queue *q);
 extern struct request *elv_former_request(struct request_queue *, struct request *);
 extern struct request *elv_latter_request(struct request_queue *, struct request *);
 extern int elv_register_queue(struct request_queue *q);
@@ -171,7 +169,7 @@ enum {
         ELV_MQUEUE_MUST,
 };
 
-#define rq_end_sector(rq)       ((rq)->sector + (rq)->nr_sectors)
+#define rq_end_sector(rq)       (blk_rq_pos(rq) + blk_rq_sectors(rq))
 #define rb_entry_rq(node)       rb_entry((node), struct request, rb_node)
 
 /*
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 3b534e527e09..83d6b4397245 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2205,6 +2205,8 @@ extern int generic_segment_checks(const struct iovec *iov,
 /* fs/splice.c */
 extern ssize_t generic_file_splice_read(struct file *, loff_t *,
                 struct pipe_inode_info *, size_t, unsigned int);
+extern ssize_t default_file_splice_read(struct file *, loff_t *,
+                struct pipe_inode_info *, size_t, unsigned int);
 extern ssize_t generic_file_splice_write(struct pipe_inode_info *,
                 struct file *, loff_t *, size_t, unsigned int);
 extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index a1a28caed23d..149fda264c86 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -90,6 +90,7 @@ struct disk_stats {
 struct hd_struct {
         sector_t start_sect;
         sector_t nr_sects;
+        sector_t alignment_offset;
         struct device __dev;
         struct kobject *holder_dir;
         int policy, partno;
diff --git a/include/linux/ide.h b/include/linux/ide.h
index 9fed365a598b..867cb68d8461 100644
--- a/include/linux/ide.h
+++ b/include/linux/ide.h
@@ -26,6 +26,9 @@
 #include <asm/io.h>
 #include <asm/mutex.h>
 
+/* for request_sense */
+#include <linux/cdrom.h>
+
 #if defined(CONFIG_CRIS) || defined(CONFIG_FRV) || defined(CONFIG_MN10300)
 # define SUPPORT_VLB_SYNC 0
 #else
@@ -324,7 +327,6 @@ struct ide_cmd {
         unsigned int            cursg_ofs;
 
         struct request          *rq;            /* copy of request */
-        void                    *special;       /* valid_t generally */
 };
 
 /* ATAPI packet command flags */
@@ -360,11 +362,7 @@ struct ide_atapi_pc {
 
         /* data buffer */
         u8 *buf;
-        /* current buffer position */
-        u8 *cur_pos;
         int buf_size;
-        /* missing/available data on the current buffer */
-        int b_count;
 
         /* the corresponding request */
         struct request *rq;
@@ -377,10 +375,6 @@ struct ide_atapi_pc {
          */
         u8 pc_buf[IDE_PC_BUFFER_SIZE];
 
-        /* idetape only */
-        struct idetape_bh *bh;
-        char *b_data;
-
         unsigned long timeout;
 };
 
@@ -593,16 +587,16 @@ struct ide_drive_s {
         /* callback for packet commands */
         int  (*pc_callback)(struct ide_drive_s *, int);
 
-        void (*pc_update_buffers)(struct ide_drive_s *, struct ide_atapi_pc *);
-        int  (*pc_io_buffers)(struct ide_drive_s *, struct ide_atapi_pc *,
-                              unsigned int, int);
-
         ide_startstop_t (*irq_handler)(struct ide_drive_s *);
 
         unsigned long atapi_flags;
 
         struct ide_atapi_pc request_sense_pc;
-        struct request request_sense_rq;
+
+        /* current sense rq and buffer */
+        bool sense_rq_armed;
+        struct request sense_rq;
+        struct request_sense sense_data;
 };
 
 typedef struct ide_drive_s ide_drive_t;
@@ -1174,7 +1168,10 @@ int ide_do_test_unit_ready(ide_drive_t *, struct gendisk *);
 int ide_do_start_stop(ide_drive_t *, struct gendisk *, int);
 int ide_set_media_lock(ide_drive_t *, struct gendisk *, int);
 void ide_create_request_sense_cmd(ide_drive_t *, struct ide_atapi_pc *);
-void ide_retry_pc(ide_drive_t *, struct gendisk *);
+void ide_retry_pc(ide_drive_t *drive);
+
+void ide_prep_sense(ide_drive_t *drive, struct request *rq);
+int ide_queue_sense_rq(ide_drive_t *drive, void *special);
 
 int ide_cd_expiry(ide_drive_t *);
 
diff --git a/include/linux/ima.h b/include/linux/ima.h
index 0e2aa45cb0ce..b1b827d091a9 100644
--- a/include/linux/ima.h
+++ b/include/linux/ima.h
@@ -13,14 +13,17 @@
 #include <linux/fs.h>
 struct linux_binprm;
 
+#define IMA_COUNT_UPDATE 1
+#define IMA_COUNT_LEAVE 0
+
 #ifdef CONFIG_IMA
 extern int ima_bprm_check(struct linux_binprm *bprm);
 extern int ima_inode_alloc(struct inode *inode);
 extern void ima_inode_free(struct inode *inode);
-extern int ima_path_check(struct path *path, int mask);
+extern int ima_path_check(struct path *path, int mask, int update_counts);
 extern void ima_file_free(struct file *file);
 extern int ima_file_mmap(struct file *file, unsigned long prot);
-extern void ima_shm_check(struct file *file);
+extern void ima_counts_get(struct file *file);
 
 #else
 static inline int ima_bprm_check(struct linux_binprm *bprm)
@@ -38,7 +41,7 @@ static inline void ima_inode_free(struct inode *inode)
         return;
 }
 
-static inline int ima_path_check(struct path *path, int mask)
+static inline int ima_path_check(struct path *path, int mask, int update_counts)
 {
         return 0;
 }
@@ -53,7 +56,7 @@ static inline int ima_file_mmap(struct file *file, unsigned long prot)
         return 0;
 }
 
-static inline void ima_shm_check(struct file *file)
+static inline void ima_counts_get(struct file *file)
 {
         return;
 }
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index 889bf99eca6d..6646bfc7b892 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -145,8 +145,8 @@ extern struct cred init_cred;
         .group_leader   = &tsk,                                         \
         .real_cred      = &init_cred,                                   \
         .cred           = &init_cred,                                   \
-        .cred_exec_mutex =                                              \
-                 __MUTEX_INITIALIZER(tsk.cred_exec_mutex),              \
+        .cred_guard_mutex =                                             \
+                 __MUTEX_INITIALIZER(tsk.cred_guard_mutex),             \
         .comm           = "swapper",                                    \
         .thread         = INIT_THREAD,                                  \
         .fs             = &init_fs,                                     \
diff --git a/include/linux/iocontext.h b/include/linux/iocontext.h
index 08b987bccf89..dd05434fa45f 100644
--- a/include/linux/iocontext.h
+++ b/include/linux/iocontext.h
@@ -64,7 +64,7 @@ struct cfq_io_context {
  * and kmalloc'ed. These could be shared between processes.
  */
 struct io_context {
-        atomic_t refcount;
+        atomic_long_t refcount;
         atomic_t nr_tasks;
 
         /* all the fields below are protected by this lock */
@@ -91,8 +91,8 @@ static inline struct io_context *ioc_task_link(struct io_context *ioc)
          * if ref count is zero, don't allow sharing (ioc is going away, it's
          * a race).
          */
-        if (ioc && atomic_inc_not_zero(&ioc->refcount)) {
-                atomic_inc(&ioc->nr_tasks);
+        if (ioc && atomic_long_inc_not_zero(&ioc->refcount)) {
+                atomic_long_inc(&ioc->refcount);
                 return ioc;
         }
 
diff --git a/include/linux/kvm.h b/include/linux/kvm.h
index 8cc137911b34..3db5d8d37485 100644
--- a/include/linux/kvm.h
+++ b/include/linux/kvm.h
@@ -119,7 +119,7 @@ struct kvm_run {
                         __u32 error_code;
                 } ex;
                 /* KVM_EXIT_IO */
-                struct kvm_io {
+                struct {
 #define KVM_EXIT_IO_IN  0
 #define KVM_EXIT_IO_OUT 1
                         __u8 direction;
@@ -224,10 +224,10 @@ struct kvm_interrupt {
 /* for KVM_GET_DIRTY_LOG */
 struct kvm_dirty_log {
         __u32 slot;
-        __u32 padding;
+        __u32 padding1;
         union {
                 void __user *dirty_bitmap; /* one bit per page */
-                __u64 padding;
+                __u64 padding2;
         };
 };
 
@@ -409,6 +409,10 @@ struct kvm_trace_rec {
 #ifdef __KVM_HAVE_DEVICE_ASSIGNMENT
 #define KVM_CAP_DEVICE_DEASSIGNMENT 27
 #endif
+#ifdef __KVM_HAVE_MSIX
+#define KVM_CAP_DEVICE_MSIX 28
+#endif
+#define KVM_CAP_ASSIGN_DEV_IRQ 29
 /* Another bug in KVM_SET_USER_MEMORY_REGION fixed: */
 #define KVM_CAP_JOIN_MEMORY_REGIONS_WORKS 30
 
@@ -482,11 +486,18 @@ struct kvm_irq_routing {
 #define KVM_ASSIGN_PCI_DEVICE _IOR(KVMIO, 0x69, \
                                    struct kvm_assigned_pci_dev)
 #define KVM_SET_GSI_ROUTING       _IOW(KVMIO, 0x6a, struct kvm_irq_routing)
+/* deprecated, replaced by KVM_ASSIGN_DEV_IRQ */
 #define KVM_ASSIGN_IRQ _IOR(KVMIO, 0x70, \
                             struct kvm_assigned_irq)
+#define KVM_ASSIGN_DEV_IRQ        _IOW(KVMIO, 0x70, struct kvm_assigned_irq)
 #define KVM_REINJECT_CONTROL      _IO(KVMIO, 0x71)
 #define KVM_DEASSIGN_PCI_DEVICE _IOW(KVMIO, 0x72, \
                                      struct kvm_assigned_pci_dev)
+#define KVM_ASSIGN_SET_MSIX_NR \
+                        _IOW(KVMIO, 0x73, struct kvm_assigned_msix_nr)
+#define KVM_ASSIGN_SET_MSIX_ENTRY \
+                        _IOW(KVMIO, 0x74, struct kvm_assigned_msix_entry)
+#define KVM_DEASSIGN_DEV_IRQ       _IOW(KVMIO, 0x75, struct kvm_assigned_irq)
 
 /*
  * ioctls for vcpu fds
@@ -577,6 +588,8 @@ struct kvm_debug_guest {
 #define KVM_TRC_STLB_INVAL       (KVM_TRC_HANDLER + 0x18)
 #define KVM_TRC_PPC_INSTR        (KVM_TRC_HANDLER + 0x19)
 
+#define KVM_DEV_ASSIGN_ENABLE_IOMMU     (1 << 0)
+
 struct kvm_assigned_pci_dev {
         __u32 assigned_dev_id;
         __u32 busnr;
@@ -587,6 +600,17 @@ struct kvm_assigned_pci_dev {
         };
 };
 
+#define KVM_DEV_IRQ_HOST_INTX    (1 << 0)
+#define KVM_DEV_IRQ_HOST_MSI     (1 << 1)
+#define KVM_DEV_IRQ_HOST_MSIX    (1 << 2)
+
+#define KVM_DEV_IRQ_GUEST_INTX   (1 << 8)
+#define KVM_DEV_IRQ_GUEST_MSI    (1 << 9)
+#define KVM_DEV_IRQ_GUEST_MSIX   (1 << 10)
+
+#define KVM_DEV_IRQ_HOST_MASK    0x00ff
+#define KVM_DEV_IRQ_GUEST_MASK   0xff00
+
 struct kvm_assigned_irq {
         __u32 assigned_dev_id;
         __u32 host_irq;
@@ -602,9 +626,19 @@ struct kvm_assigned_irq {
         };
 };
 
-#define KVM_DEV_ASSIGN_ENABLE_IOMMU     (1 << 0)
 
-#define KVM_DEV_IRQ_ASSIGN_MSI_ACTION   KVM_DEV_IRQ_ASSIGN_ENABLE_MSI
-#define KVM_DEV_IRQ_ASSIGN_ENABLE_MSI   (1 << 0)
+struct kvm_assigned_msix_nr {
+        __u32 assigned_dev_id;
+        __u16 entry_nr;
+        __u16 padding;
+};
+
+#define KVM_MAX_MSIX_PER_DEV            512
+struct kvm_assigned_msix_entry {
+        __u32 assigned_dev_id;
+        __u32 gsi;
+        __u16 entry; /* The index of entry in the MSI-X table */
+        __u16 padding[3];
+};
 
 #endif
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index 894a56e365e8..aacc5449f586 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -38,6 +38,7 @@
 #define KVM_REQ_UNHALT             6
 #define KVM_REQ_MMU_SYNC           7
 #define KVM_REQ_KVMCLOCK_UPDATE    8
+#define KVM_REQ_KICK               9
 
 #define KVM_USERSPACE_IRQ_SOURCE_ID     0
 
@@ -72,7 +73,6 @@ struct kvm_vcpu {
         struct mutex mutex;
         int   cpu;
         struct kvm_run *run;
-        int guest_mode;
         unsigned long requests;
         unsigned long guest_debug;
         int fpu_active;
@@ -298,6 +298,7 @@ int kvm_arch_hardware_setup(void);
 void kvm_arch_hardware_unsetup(void);
 void kvm_arch_check_processor_compat(void *rtn);
 int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu);
+int kvm_arch_interrupt_allowed(struct kvm_vcpu *vcpu);
 
 void kvm_free_physmem(struct kvm *kvm);
 
@@ -319,6 +320,13 @@ struct kvm_irq_ack_notifier {
         void (*irq_acked)(struct kvm_irq_ack_notifier *kian);
 };
 
+#define KVM_ASSIGNED_MSIX_PENDING               0x1
+struct kvm_guest_msix_entry {
+        u32 vector;
+        u16 entry;
+        u16 flags;
+};
+
 struct kvm_assigned_dev_kernel {
         struct kvm_irq_ack_notifier ack_notifier;
         struct work_struct interrupt_work;
@@ -326,18 +334,18 @@ struct kvm_assigned_dev_kernel {
         int assigned_dev_id;
         int host_busnr;
         int host_devfn;
+        unsigned int entries_nr;
         int host_irq;
         bool host_irq_disabled;
+        struct msix_entry *host_msix_entries;
         int guest_irq;
-#define KVM_ASSIGNED_DEV_GUEST_INTX     (1 << 0)
-#define KVM_ASSIGNED_DEV_GUEST_MSI      (1 << 1)
-#define KVM_ASSIGNED_DEV_HOST_INTX      (1 << 8)
-#define KVM_ASSIGNED_DEV_HOST_MSI       (1 << 9)
+        struct kvm_guest_msix_entry *guest_msix_entries;
         unsigned long irq_requested_type;
         int irq_source_id;
         int flags;
         struct pci_dev *dev;
         struct kvm *kvm;
+        spinlock_t assigned_dev_lock;
 };
 
 struct kvm_irq_mask_notifier {
@@ -360,6 +368,9 @@ void kvm_unregister_irq_ack_notifier(struct kvm_irq_ack_notifier *kian);
 int kvm_request_irq_source_id(struct kvm *kvm);
 void kvm_free_irq_source_id(struct kvm *kvm, int irq_source_id);
 
+/* For vcpu->arch.iommu_flags */
+#define KVM_IOMMU_CACHE_COHERENCY       0x1
+
 #ifdef CONFIG_IOMMU_API
 int kvm_iommu_map_pages(struct kvm *kvm, gfn_t base_gfn,
                         unsigned long npages);
diff --git a/include/linux/kvm_types.h b/include/linux/kvm_types.h
index 2b8318c83e53..fb46efbeabec 100644
--- a/include/linux/kvm_types.h
+++ b/include/linux/kvm_types.h
@@ -40,4 +40,31 @@ typedef unsigned long  hfn_t;
 
 typedef hfn_t pfn_t;
 
+union kvm_ioapic_redirect_entry {
+        u64 bits;
+        struct {
+                u8 vector;
+                u8 delivery_mode:3;
+                u8 dest_mode:1;
+                u8 delivery_status:1;
+                u8 polarity:1;
+                u8 remote_irr:1;
+                u8 trig_mode:1;
+                u8 mask:1;
+                u8 reserve:7;
+                u8 reserved[4];
+                u8 dest_id;
+        } fields;
+};
+
+struct kvm_lapic_irq {
+        u32 vector;
+        u32 delivery_mode;
+        u32 dest_mode;
+        u32 level;
+        u32 trig_mode;
+        u32 shorthand;
+        u32 dest_id;
+};
+
 #endif /* __KVM_TYPES_H__ */
diff --git a/include/linux/loop.h b/include/linux/loop.h
index 40725447f5e0..66c194e2d9b9 100644
--- a/include/linux/loop.h
+++ b/include/linux/loop.h
@@ -56,8 +56,7 @@ struct loop_device {
         gfp_t           old_gfp_mask;
 
         spinlock_t              lo_lock;
-        struct bio              *lo_bio;
-        struct bio              *lo_biotail;
+        struct bio_list         lo_bio_list;
         int                     lo_state;
         struct mutex            lo_ctl_mutex;
         struct task_struct      *lo_thread;
diff --git a/include/linux/lsm_audit.h b/include/linux/lsm_audit.h
new file mode 100644
index 000000000000..e461b2c3d711
--- /dev/null
+++ b/include/linux/lsm_audit.h
@@ -0,0 +1,111 @@
+/*
+ * Common LSM logging functions
+ * Heavily borrowed from selinux/avc.h
+ *
+ * Author : Etienne BASSET  <etienne.basset@ensta.org>
+ *
+ * All credits to : Stephen Smalley, <sds@epoch.ncsc.mil>
+ * All BUGS to : Etienne BASSET  <etienne.basset@ensta.org>
+ */
+#ifndef _LSM_COMMON_LOGGING_
+#define _LSM_COMMON_LOGGING_
+
+#include <linux/stddef.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/kdev_t.h>
+#include <linux/spinlock.h>
+#include <linux/init.h>
+#include <linux/audit.h>
+#include <linux/in6.h>
+#include <linux/path.h>
+#include <linux/key.h>
+#include <linux/skbuff.h>
+#include <asm/system.h>
+
+
+/* Auxiliary data to use in generating the audit record. */
+struct common_audit_data {
+        char    type;
+#define LSM_AUDIT_DATA_FS      1
+#define LSM_AUDIT_DATA_NET     2
+#define LSM_AUDIT_DATA_CAP     3
+#define LSM_AUDIT_DATA_IPC     4
+#define LSM_AUDIT_DATA_TASK    5
+#define LSM_AUDIT_DATA_KEY     6
+        struct task_struct *tsk;
+        union   {
+                struct {
+                        struct path path;
+                        struct inode *inode;
+                } fs;
+                struct {
+                        int netif;
+                        struct sock *sk;
+                        u16 family;
+                        __be16 dport;
+                        __be16 sport;
+                        union {
+                                struct {
+                                        __be32 daddr;
+                                        __be32 saddr;
+                                } v4;
+                                struct {
+                                        struct in6_addr daddr;
+                                        struct in6_addr saddr;
+                                } v6;
+                        } fam;
+                } net;
+                int cap;
+                int ipc_id;
+                struct task_struct *tsk;
+#ifdef CONFIG_KEYS
+                struct {
+                        key_serial_t key;
+                        char *key_desc;
+                } key_struct;
+#endif
+        } u;
+        const char *function;
+        /* this union contains LSM specific data */
+        union {
+                /* SMACK data */
+                struct smack_audit_data {
+                        char *subject;
+                        char *object;
+                        char *request;
+                        int result;
+                } smack_audit_data;
+                /* SELinux data */
+                struct {
+                        u32 ssid;
+                        u32 tsid;
+                        u16 tclass;
+                        u32 requested;
+                        u32 audited;
+                        struct av_decision *avd;
+                        int result;
+                } selinux_audit_data;
+        } lsm_priv;
+        /* these callback will be implemented by a specific LSM */
+        void (*lsm_pre_audit)(struct audit_buffer *, void *);
+        void (*lsm_post_audit)(struct audit_buffer *, void *);
+};
+
+#define v4info fam.v4
+#define v6info fam.v6
+
+int ipv4_skb_to_auditdata(struct sk_buff *skb,
+                struct common_audit_data *ad, u8 *proto);
+
+int ipv6_skb_to_auditdata(struct sk_buff *skb,
+                struct common_audit_data *ad, u8 *proto);
+
+/* Initialize an LSM audit data structure. */
+#define COMMON_AUDIT_DATA_INIT(_d, _t) \
+        { memset((_d), 0, sizeof(struct common_audit_data)); \
+         (_d)->type = LSM_AUDIT_DATA_##_t; (_d)->function = __func__; }
+
+void common_lsm_audit(struct common_audit_data *a);
+
+#endif
diff --git a/include/linux/magic.h b/include/linux/magic.h
index 5b4e28bcb788..927138cf3050 100644
--- a/include/linux/magic.h
+++ b/include/linux/magic.h
@@ -9,6 +9,7 @@
 #define DEBUGFS_MAGIC          0x64626720
 #define SYSFS_MAGIC             0x62656572
 #define SECURITYFS_MAGIC        0x73636673
+#define SELINUX_MAGIC           0xf97cff8c
 #define TMPFS_MAGIC             0x01021994
 #define SQUASHFS_MAGIC          0x73717368
 #define EFS_SUPER_MAGIC         0x414A53
diff --git a/include/linux/mg_disk.h b/include/linux/mg_disk.h
deleted file mode 100644
index 1f76b1ebf627..000000000000
--- a/include/linux/mg_disk.h
+++ /dev/null
@@ -1,206 +0,0 @@
-/*
- *  include/linux/mg_disk.c
- *
- *  Support for the mGine m[g]flash IO mode.
- *  Based on legacy hd.c
- *
- * (c) 2008 mGine Co.,LTD
- * (c) 2008 unsik Kim <donari75@gmail.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2 as
- *  published by the Free Software Foundation.
- */
-
-#ifndef __MG_DISK_H__
-#define __MG_DISK_H__
-
-#include <linux/blkdev.h>
-#include <linux/ata.h>
-
-/* name for block device */
-#define MG_DISK_NAME "mgd"
-/* name for platform device */
-#define MG_DEV_NAME "mg_disk"
-
-#define MG_DISK_MAJ 0
-#define MG_DISK_MAX_PART 16
-#define MG_SECTOR_SIZE 512
-#define MG_MAX_SECTS 256
-
-/* Register offsets */
-#define MG_BUFF_OFFSET                  0x8000
-#define MG_STORAGE_BUFFER_SIZE          0x200
-#define MG_REG_OFFSET                   0xC000
-#define MG_REG_FEATURE                  (MG_REG_OFFSET + 2)     /* write case */
-#define MG_REG_ERROR                    (MG_REG_OFFSET + 2)     /* read case */
-#define MG_REG_SECT_CNT                 (MG_REG_OFFSET + 4)
-#define MG_REG_SECT_NUM                 (MG_REG_OFFSET + 6)
-#define MG_REG_CYL_LOW                  (MG_REG_OFFSET + 8)
-#define MG_REG_CYL_HIGH                 (MG_REG_OFFSET + 0xA)
-#define MG_REG_DRV_HEAD                 (MG_REG_OFFSET + 0xC)
-#define MG_REG_COMMAND                  (MG_REG_OFFSET + 0xE)   /* write case */
-#define MG_REG_STATUS                   (MG_REG_OFFSET + 0xE)   /* read  case */
-#define MG_REG_DRV_CTRL                 (MG_REG_OFFSET + 0x10)
-#define MG_REG_BURST_CTRL               (MG_REG_OFFSET + 0x12)
-
-/* "Drive Select/Head Register" bit values */
-#define MG_REG_HEAD_MUST_BE_ON          0xA0 /* These 2 bits are always on */
-#define MG_REG_HEAD_DRIVE_MASTER        (0x00 | MG_REG_HEAD_MUST_BE_ON)
-#define MG_REG_HEAD_DRIVE_SLAVE         (0x10 | MG_REG_HEAD_MUST_BE_ON)
-#define MG_REG_HEAD_LBA_MODE            (0x40 | MG_REG_HEAD_MUST_BE_ON)
-
-
-/* "Device Control Register" bit values */
-#define MG_REG_CTRL_INTR_ENABLE                 0x0
-#define MG_REG_CTRL_INTR_DISABLE                (0x1<<1)
-#define MG_REG_CTRL_RESET                       (0x1<<2)
-#define MG_REG_CTRL_INTR_POLA_ACTIVE_HIGH       0x0
-#define MG_REG_CTRL_INTR_POLA_ACTIVE_LOW        (0x1<<4)
-#define MG_REG_CTRL_DPD_POLA_ACTIVE_LOW         0x0
-#define MG_REG_CTRL_DPD_POLA_ACTIVE_HIGH        (0x1<<5)
-#define MG_REG_CTRL_DPD_DISABLE                 0x0
-#define MG_REG_CTRL_DPD_ENABLE                  (0x1<<6)
-
-/* Status register bit */
-/* error bit in status register */
-#define MG_REG_STATUS_BIT_ERROR                 0x01
-/* corrected error in status register */
-#define MG_REG_STATUS_BIT_CORRECTED_ERROR       0x04
-/* data request bit in status register */
-#define MG_REG_STATUS_BIT_DATA_REQ              0x08
-/* DSC - Drive Seek Complete */
-#define MG_REG_STATUS_BIT_SEEK_DONE             0x10
-/* DWF - Drive Write Fault */
-#define MG_REG_STATUS_BIT_WRITE_FAULT           0x20
-#define MG_REG_STATUS_BIT_READY                 0x40
-#define MG_REG_STATUS_BIT_BUSY                  0x80
-
-/* handy status */
-#define MG_STAT_READY   (MG_REG_STATUS_BIT_READY | MG_REG_STATUS_BIT_SEEK_DONE)
-#define MG_READY_OK(s)  (((s) & (MG_STAT_READY | \
-                                (MG_REG_STATUS_BIT_BUSY | \
-                                 MG_REG_STATUS_BIT_WRITE_FAULT | \
-                                 MG_REG_STATUS_BIT_ERROR))) == MG_STAT_READY)
-
-/* Error register */
-#define MG_REG_ERR_AMNF         0x01
-#define MG_REG_ERR_ABRT         0x04
-#define MG_REG_ERR_IDNF         0x10
-#define MG_REG_ERR_UNC          0x40
-#define MG_REG_ERR_BBK          0x80
-
-/* error code for others */
-#define MG_ERR_NONE             0
-#define MG_ERR_TIMEOUT          0x100
-#define MG_ERR_INIT_STAT        0x101
-#define MG_ERR_TRANSLATION      0x102
-#define MG_ERR_CTRL_RST         0x103
-#define MG_ERR_INV_STAT         0x104
-#define MG_ERR_RSTOUT           0x105
-
-#define MG_MAX_ERRORS   6       /* Max read/write errors */
-
-/* command */
-#define MG_CMD_RD 0x20
-#define MG_CMD_WR 0x30
-#define MG_CMD_SLEEP 0x99
-#define MG_CMD_WAKEUP 0xC3
-#define MG_CMD_ID 0xEC
-#define MG_CMD_WR_CONF 0x3C
-#define MG_CMD_RD_CONF 0x40
-
-/* operation mode */
-#define MG_OP_CASCADE (1 << 0)
-#define MG_OP_CASCADE_SYNC_RD (1 << 1)
-#define MG_OP_CASCADE_SYNC_WR (1 << 2)
-#define MG_OP_INTERLEAVE (1 << 3)
-
-/* synchronous */
-#define MG_BURST_LAT_4 (3 << 4)
-#define MG_BURST_LAT_5 (4 << 4)
-#define MG_BURST_LAT_6 (5 << 4)
-#define MG_BURST_LAT_7 (6 << 4)
-#define MG_BURST_LAT_8 (7 << 4)
-#define MG_BURST_LEN_4 (1 << 1)
-#define MG_BURST_LEN_8 (2 << 1)
-#define MG_BURST_LEN_16 (3 << 1)
-#define MG_BURST_LEN_32 (4 << 1)
-#define MG_BURST_LEN_CONT (0 << 1)
-
-/* timeout value (unit: ms) */
-#define MG_TMAX_CONF_TO_CMD     1
-#define MG_TMAX_WAIT_RD_DRQ     10
-#define MG_TMAX_WAIT_WR_DRQ     500
-#define MG_TMAX_RST_TO_BUSY     10
-#define MG_TMAX_HDRST_TO_RDY    500
-#define MG_TMAX_SWRST_TO_RDY    500
-#define MG_TMAX_RSTOUT          3000
-
-/* device attribution */
-/* use mflash as boot device */
-#define MG_BOOT_DEV             (1 << 0)
-/* use mflash as storage device */
-#define MG_STORAGE_DEV          (1 << 1)
-/* same as MG_STORAGE_DEV, but bootloader already done reset sequence */
-#define MG_STORAGE_DEV_SKIP_RST (1 << 2)
-
-#define MG_DEV_MASK (MG_BOOT_DEV | MG_STORAGE_DEV | MG_STORAGE_DEV_SKIP_RST)
-
-/* names of GPIO resource */
-#define MG_RST_PIN      "mg_rst"
-/* except MG_BOOT_DEV, reset-out pin should be assigned */
-#define MG_RSTOUT_PIN   "mg_rstout"
-
-/* private driver data */
-struct mg_drv_data {
-        /* disk resource */
-        u32 use_polling;
-
-        /* device attribution */
-        u32 dev_attr;
-
-        /* internally used */
-        struct mg_host *host;
-};
-
-/* main structure for mflash driver */
-struct mg_host {
-        struct device *dev;
-
-        struct request_queue *breq;
-        spinlock_t lock;
-        struct gendisk *gd;
-
-        struct timer_list timer;
-        void (*mg_do_intr) (struct mg_host *);
-
-        u16 id[ATA_ID_WORDS];
-
-        u16 cyls;
-        u16 heads;
-        u16 sectors;
-        u32 n_sectors;
-        u32 nres_sectors;
-
-        void __iomem *dev_base;
-        unsigned int irq;
-        unsigned int rst;
-        unsigned int rstout;
-
-        u32 major;
-        u32 error;
-};
-
-/*
- * Debugging macro and defines
- */
-#undef DO_MG_DEBUG
-#ifdef DO_MG_DEBUG
-#  define MG_DBG(fmt, args...) \
-        printk(KERN_DEBUG "%s:%d "fmt, __func__, __LINE__, ##args)
-#else /* CONFIG_MG_DEBUG */
-#  define MG_DBG(fmt, args...) do { } while (0)
-#endif /* CONFIG_MG_DEBUG */
-
-#endif
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 9772d6cbfc82..ad613ed66ab0 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -581,12 +581,10 @@ static inline void set_page_links(struct page *page, enum zone_type zone,
  */
 static inline unsigned long round_hint_to_min(unsigned long hint)
 {
-#ifdef CONFIG_SECURITY
         hint &= PAGE_MASK;
         if (((void *)hint != NULL) &&
             (hint < mmap_min_addr))
                 return PAGE_ALIGN(mmap_min_addr);
-#endif
         return hint;
 }
 
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 0f71812d67d3..d7d1c41a0b17 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -1996,10 +1996,12 @@
 #define PCI_DEVICE_ID_OXSEMI_PCIe952_1_U        0xC118
 #define PCI_DEVICE_ID_OXSEMI_PCIe952_1_GU       0xC11C
 #define PCI_DEVICE_ID_OXSEMI_16PCI954   0x9501
+#define PCI_DEVICE_ID_OXSEMI_C950       0x950B
 #define PCI_DEVICE_ID_OXSEMI_16PCI95N   0x9511
 #define PCI_DEVICE_ID_OXSEMI_16PCI954PP 0x9513
 #define PCI_DEVICE_ID_OXSEMI_16PCI952   0x9521
 #define PCI_DEVICE_ID_OXSEMI_16PCI952PP 0x9523
+#define PCI_SUBDEVICE_ID_OXSEMI_C950    0x0001
 
 #define PCI_VENDOR_ID_CHELSIO           0x1425
 
diff --git a/include/linux/pipe_fs_i.h b/include/linux/pipe_fs_i.h
index c8f038554e80..b43a9e039059 100644
--- a/include/linux/pipe_fs_i.h
+++ b/include/linux/pipe_fs_i.h
@@ -152,5 +152,6 @@ void generic_pipe_buf_unmap(struct pipe_inode_info *, struct pipe_buffer *, void
 void generic_pipe_buf_get(struct pipe_inode_info *, struct pipe_buffer *);
 int generic_pipe_buf_confirm(struct pipe_inode_info *, struct pipe_buffer *);
 int generic_pipe_buf_steal(struct pipe_inode_info *, struct pipe_buffer *);
+void generic_pipe_buf_release(struct pipe_inode_info *, struct pipe_buffer *);
 
 #endif
diff --git a/include/linux/rational.h b/include/linux/rational.h
new file mode 100644
index 000000000000..4f532fcd9eea
--- /dev/null
+++ b/include/linux/rational.h
@@ -0,0 +1,19 @@
+/*
+ * rational fractions
+ *
+ * Copyright (C) 2009 emlix GmbH, Oskar Schirmer <os@emlix.com>
+ *
+ * helper functions when coping with rational numbers,
+ * e.g. when calculating optimum numerator/denominator pairs for
+ * pll configuration taking into account restricted register size
+ */
+
+#ifndef _LINUX_RATIONAL_H
+#define _LINUX_RATIONAL_H
+
+void rational_best_approximation(
+        unsigned long given_numerator, unsigned long given_denominator,
+        unsigned long max_numerator, unsigned long max_denominator,
+        unsigned long *best_numerator, unsigned long *best_denominator);
+
+#endif /* _LINUX_RATIONAL_H */
diff --git a/include/linux/sched.h b/include/linux/sched.h
index d1399660b776..42bf2766111e 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -1261,7 +1261,9 @@ struct task_struct {
                                          * credentials (COW) */
         const struct cred *cred;        /* effective (overridable) subjective task
                                          * credentials (COW) */
-        struct mutex cred_exec_mutex;   /* execve vs ptrace cred calculation mutex */
+        struct mutex cred_guard_mutex;  /* guard against foreign influences on
+                                         * credential calculations
+                                         * (notably. ptrace) */
 
         char comm[TASK_COMM_LEN]; /* executable name excluding path
                                      - access with [gs]et_task_comm (which lock
@@ -1901,6 +1903,7 @@ extern void sched_dead(struct task_struct *p);
 
 extern void proc_caches_init(void);
 extern void flush_signals(struct task_struct *);
+extern void __flush_signals(struct task_struct *);
 extern void ignore_signals(struct task_struct *);
 extern void flush_signal_handlers(struct task_struct *, int force_default);
 extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
diff --git a/include/linux/security.h b/include/linux/security.h
index d5fd6163606f..5eff459b3833 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -2197,6 +2197,8 @@ static inline int security_file_mmap(struct file *file, unsigned long reqprot,
                                      unsigned long addr,
                                      unsigned long addr_only)
 {
+        if ((addr < mmap_min_addr) && !capable(CAP_SYS_RAWIO))
+                return -EACCES;
         return 0;
 }
 
diff --git a/include/linux/serial.h b/include/linux/serial.h
index 9136cc5608c3..e5bb75a63802 100644
--- a/include/linux/serial.h
+++ b/include/linux/serial.h
@@ -96,54 +96,76 @@ struct serial_uart_config {
 
 /*
  * Definitions for async_struct (and serial_struct) flags field
+ *
+ * Define ASYNCB_* for convenient use with {test,set,clear}_bit.
  */
-#define ASYNC_HUP_NOTIFY 0x0001 /* Notify getty on hangups and closes 
-                                   on the callout port */
-#define ASYNC_FOURPORT  0x0002  /* Set OU1, OUT2 per AST Fourport settings */
-#define ASYNC_SAK       0x0004  /* Secure Attention Key (Orange book) */
-#define ASYNC_SPLIT_TERMIOS 0x0008 /* Separate termios for dialin/callout */
-
-#define ASYNC_SPD_MASK  0x1030
-#define ASYNC_SPD_HI    0x0010  /* Use 56000 instead of 38400 bps */
-
-#define ASYNC_SPD_VHI   0x0020  /* Use 115200 instead of 38400 bps */
-#define ASYNC_SPD_CUST  0x0030  /* Use user-specified divisor */
-
-#define ASYNC_SKIP_TEST 0x0040 /* Skip UART test during autoconfiguration */
-#define ASYNC_AUTO_IRQ  0x0080 /* Do automatic IRQ during autoconfiguration */
-#define ASYNC_SESSION_LOCKOUT 0x0100 /* Lock out cua opens based on session */
-#define ASYNC_PGRP_LOCKOUT    0x0200 /* Lock out cua opens based on pgrp */
-#define ASYNC_CALLOUT_NOHUP   0x0400 /* Don't do hangups for cua device */
-
-#define ASYNC_HARDPPS_CD        0x0800  /* Call hardpps when CD goes high  */
-
-#define ASYNC_SPD_SHI   0x1000  /* Use 230400 instead of 38400 bps */
-#define ASYNC_SPD_WARP  0x1010  /* Use 460800 instead of 38400 bps */
-
-#define ASYNC_LOW_LATENCY 0x2000 /* Request low latency behaviour */
-
-#define ASYNC_BUGGY_UART  0x4000 /* This is a buggy UART, skip some safety
-                                  * checks.  Note: can be dangerous! */
-
-#define ASYNC_AUTOPROBE  0x8000 /* Port was autoprobed by PCI or PNP code */
-
-#define ASYNC_FLAGS     0x7FFF  /* Possible legal async flags */
-#define ASYNC_USR_MASK  0x3430  /* Legal flags that non-privileged
-                                 * users can set or reset */
-
-/* Internal flags used only by kernel/chr_drv/serial.c */
-#define ASYNC_INITIALIZED       0x80000000 /* Serial port was initialized */
-#define ASYNC_NORMAL_ACTIVE     0x20000000 /* Normal device is active */
-#define ASYNC_BOOT_AUTOCONF     0x10000000 /* Autoconfigure port on bootup */
-#define ASYNC_CLOSING           0x08000000 /* Serial port is closing */
-#define ASYNC_CTS_FLOW          0x04000000 /* Do CTS flow control */
-#define ASYNC_CHECK_CD          0x02000000 /* i.e., CLOCAL */
-#define ASYNC_SHARE_IRQ         0x01000000 /* for multifunction cards
-                                             --- no longer used */
-#define ASYNC_CONS_FLOW         0x00800000 /* flow control for console  */
-
-#define ASYNC_BOOT_ONLYMCA      0x00400000 /* Probe only if MCA bus */
-#define ASYNC_INTERNAL_FLAGS    0xFFC00000 /* Internal flags */
+#define ASYNCB_HUP_NOTIFY        0 /* Notify getty on hangups and closes
+                                    * on the callout port */
+#define ASYNCB_FOURPORT          1 /* Set OU1, OUT2 per AST Fourport settings */
+#define ASYNCB_SAK               2 /* Secure Attention Key (Orange book) */
+#define ASYNCB_SPLIT_TERMIOS     3 /* Separate termios for dialin/callout */
+#define ASYNCB_SPD_HI            4 /* Use 56000 instead of 38400 bps */
+#define ASYNCB_SPD_VHI           5 /* Use 115200 instead of 38400 bps */
+#define ASYNCB_SKIP_TEST         6 /* Skip UART test during autoconfiguration */
+#define ASYNCB_AUTO_IRQ          7 /* Do automatic IRQ during
+                                    * autoconfiguration */
+#define ASYNCB_SESSION_LOCKOUT   8 /* Lock out cua opens based on session */
+#define ASYNCB_PGRP_LOCKOUT      9 /* Lock out cua opens based on pgrp */
+#define ASYNCB_CALLOUT_NOHUP    10 /* Don't do hangups for cua device */
+#define ASYNCB_HARDPPS_CD       11 /* Call hardpps when CD goes high  */
+#define ASYNCB_SPD_SHI          12 /* Use 230400 instead of 38400 bps */
+#define ASYNCB_LOW_LATENCY      13 /* Request low latency behaviour */
+#define ASYNCB_BUGGY_UART       14 /* This is a buggy UART, skip some safety
+                                    * checks.  Note: can be dangerous! */
+#define ASYNCB_AUTOPROBE        15 /* Port was autoprobed by PCI or PNP code */
+#define ASYNCB_LAST_USER        15
+
+/* Internal flags used only by kernel */
+#define ASYNCB_INITIALIZED      31 /* Serial port was initialized */
+#define ASYNCB_NORMAL_ACTIVE    29 /* Normal device is active */
+#define ASYNCB_BOOT_AUTOCONF    28 /* Autoconfigure port on bootup */
+#define ASYNCB_CLOSING          27 /* Serial port is closing */
+#define ASYNCB_CTS_FLOW         26 /* Do CTS flow control */
+#define ASYNCB_CHECK_CD         25 /* i.e., CLOCAL */
+#define ASYNCB_SHARE_IRQ        24 /* for multifunction cards, no longer used */
+#define ASYNCB_CONS_FLOW        23 /* flow control for console  */
+#define ASYNCB_BOOT_ONLYMCA     22 /* Probe only if MCA bus */
+#define ASYNCB_FIRST_KERNEL     22
+
+#define ASYNC_HUP_NOTIFY        (1U << ASYNCB_HUP_NOTIFY)
+#define ASYNC_FOURPORT          (1U << ASYNCB_FOURPORT)
+#define ASYNC_SAK               (1U << ASYNCB_SAK)
+#define ASYNC_SPLIT_TERMIOS     (1U << ASYNCB_SPLIT_TERMIOS)
+#define ASYNC_SPD_HI            (1U << ASYNCB_SPD_HI)
+#define ASYNC_SPD_VHI           (1U << ASYNCB_SPD_VHI)
+#define ASYNC_SKIP_TEST         (1U << ASYNCB_SKIP_TEST)
+#define ASYNC_AUTO_IRQ          (1U << ASYNCB_AUTO_IRQ)
+#define ASYNC_SESSION_LOCKOUT   (1U << ASYNCB_SESSION_LOCKOUT)
+#define ASYNC_PGRP_LOCKOUT      (1U << ASYNCB_PGRP_LOCKOUT)
+#define ASYNC_CALLOUT_NOHUP     (1U << ASYNCB_CALLOUT_NOHUP)
+#define ASYNC_HARDPPS_CD        (1U << ASYNCB_HARDPPS_CD)
+#define ASYNC_SPD_SHI           (1U << ASYNCB_SPD_SHI)
+#define ASYNC_LOW_LATENCY       (1U << ASYNCB_LOW_LATENCY)
+#define ASYNC_BUGGY_UART        (1U << ASYNCB_BUGGY_UART)
+#define ASYNC_AUTOPROBE         (1U << ASYNCB_AUTOPROBE)
+
+#define ASYNC_FLAGS             ((1U << ASYNCB_LAST_USER) - 1)
+#define ASYNC_USR_MASK          (ASYNC_SPD_HI|ASYNC_SPD_VHI| \
+                ASYNC_CALLOUT_NOHUP|ASYNC_SPD_SHI|ASYNC_LOW_LATENCY)
+#define ASYNC_SPD_CUST          (ASYNC_SPD_HI|ASYNC_SPD_VHI)
+#define ASYNC_SPD_WARP          (ASYNC_SPD_HI|ASYNC_SPD_SHI)
+#define ASYNC_SPD_MASK          (ASYNC_SPD_HI|ASYNC_SPD_VHI|ASYNC_SPD_SHI)
+
+#define ASYNC_INITIALIZED       (1U << ASYNCB_INITIALIZED)
+#define ASYNC_NORMAL_ACTIVE     (1U << ASYNCB_NORMAL_ACTIVE)
+#define ASYNC_BOOT_AUTOCONF     (1U << ASYNCB_BOOT_AUTOCONF)
+#define ASYNC_CLOSING           (1U << ASYNCB_CLOSING)
+#define ASYNC_CTS_FLOW          (1U << ASYNCB_CTS_FLOW)
+#define ASYNC_CHECK_CD          (1U << ASYNCB_CHECK_CD)
+#define ASYNC_SHARE_IRQ         (1U << ASYNCB_SHARE_IRQ)
+#define ASYNC_CONS_FLOW         (1U << ASYNCB_CONS_FLOW)
+#define ASYNC_BOOT_ONLYMCA      (1U << ASYNCB_BOOT_ONLYMCA)
+#define ASYNC_INTERNAL_FLAGS    (~((1U << ASYNCB_FIRST_KERNEL) - 1))
 
 /*
  * Multiport serial configuration structure --- external structure
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 57a97e52e58d..6fd80c4243f1 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -41,7 +41,8 @@
 #define PORT_XSCALE     15
 #define PORT_RM9000     16      /* PMC-Sierra RM9xxx internal UART */
 #define PORT_OCTEON     17      /* Cavium OCTEON internal UART */
-#define PORT_MAX_8250   17      /* max port ID */
+#define PORT_AR7        18      /* Texas Instruments AR7 internal UART */
+#define PORT_MAX_8250   18      /* max port ID */
 
 /*
  * ARM specific type numbers.  These are not currently guaranteed
@@ -167,6 +168,9 @@
 /* MAX3100 */
 #define PORT_MAX3100    86
 
+/* Timberdale UART */
+#define PORT_TIMBUART   87
+
 #ifdef __KERNEL__
 
 #include <linux/compiler.h>
diff --git a/include/linux/serial_sci.h b/include/linux/serial_sci.h
index 893cc53486bc..1c297ddc9d5a 100644
--- a/include/linux/serial_sci.h
+++ b/include/linux/serial_sci.h
@@ -25,8 +25,7 @@ struct plat_sci_port {
         unsigned int    irqs[SCIx_NR_IRQS];     /* ERI, RXI, TXI, BRI */
         unsigned int    type;                   /* SCI / SCIF / IRDA */
         upf_t           flags;                  /* UPF_* flags */
+        char            *clk;                   /* clock string */
 };
 
-int early_sci_setup(struct uart_port *port);
-
 #endif /* __LINUX_SERIAL_SCI_H */
diff --git a/include/linux/sh_cmt.h b/include/linux/sh_cmt.h
deleted file mode 100644
index 68cacde5954f..000000000000
--- a/include/linux/sh_cmt.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef __SH_CMT_H__
-#define __SH_CMT_H__
-
-struct sh_cmt_config {
-        char *name;
-        unsigned long channel_offset;
-        int timer_bit;
-        char *clk;
-        unsigned long clockevent_rating;
-        unsigned long clocksource_rating;
-};
-
-#endif /* __SH_CMT_H__ */
diff --git a/include/linux/sh_timer.h b/include/linux/sh_timer.h
new file mode 100644
index 000000000000..864bd56bd3b0
--- /dev/null
+++ b/include/linux/sh_timer.h
@@ -0,0 +1,13 @@
+#ifndef __SH_TIMER_H__
+#define __SH_TIMER_H__
+
+struct sh_timer_config {
+        char *name;
+        long channel_offset;
+        int timer_bit;
+        char *clk;
+        unsigned long clockevent_rating;
+        unsigned long clocksource_rating;
+};
+
+#endif /* __SH_TIMER_H__ */
diff --git a/include/linux/splice.h b/include/linux/splice.h
index 5f3faa9d15ae..18e7c7c0cae6 100644
--- a/include/linux/splice.h
+++ b/include/linux/splice.h
@@ -11,8 +11,7 @@
 #include <linux/pipe_fs_i.h>
 
 /*
- * splice is tied to pipes as a transport (at least for now), so we'll just
- * add the splice flags here.
+ * Flags passed in from splice/tee/vmsplice
  */
 #define SPLICE_F_MOVE   (0x01)  /* move pages instead of copying */
 #define SPLICE_F_NONBLOCK (0x02) /* don't block on the pipe splicing (but */
diff --git a/include/linux/time.h b/include/linux/time.h
index 242f62499bb7..ea16c1a01d51 100644
--- a/include/linux/time.h
+++ b/include/linux/time.h
@@ -113,6 +113,21 @@ struct timespec current_kernel_time(void);
 #define CURRENT_TIME            (current_kernel_time())
 #define CURRENT_TIME_SEC        ((struct timespec) { get_seconds(), 0 })
 
+/* Some architectures do not supply their own clocksource.
+ * This is mainly the case in architectures that get their
+ * inter-tick times by reading the counter on their interval
+ * timer. Since these timers wrap every tick, they're not really
+ * useful as clocksources. Wrapping them to act like one is possible
+ * but not very efficient. So we provide a callout these arches
+ * can implement for use with the jiffies clocksource to provide
+ * finer then tick granular time.
+ */
+#ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
+extern u32 arch_gettimeoffset(void);
+#else
+static inline u32 arch_gettimeoffset(void) { return 0; }
+#endif
+
 extern void do_gettimeofday(struct timeval *tv);
 extern int do_settimeofday(struct timespec *tv);
 extern int do_sys_settimeofday(struct timespec *tv, struct timezone *tz);
diff --git a/include/linux/tty.h b/include/linux/tty.h
index fc39db95499f..1488d8c81aac 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -185,7 +185,7 @@ struct tty_port;
 struct tty_port_operations {
         /* Return 1 if the carrier is raised */
         int (*carrier_raised)(struct tty_port *port);
-        void (*raise_dtr_rts)(struct tty_port *port);
+        void (*dtr_rts)(struct tty_port *port, int raise);
 };
         
 struct tty_port {
@@ -201,6 +201,9 @@ struct tty_port {
         unsigned char           *xmit_buf;      /* Optional buffer */
         int                     close_delay;    /* Close port delay */
         int                     closing_wait;   /* Delay for output */
+        int                     drain_delay;    /* Set to zero if no pure time
+                                                   based drain is needed else
+                                                   set to size of fifo */
 };
 
 /*
@@ -223,8 +226,11 @@ struct tty_struct {
         struct tty_driver *driver;
         const struct tty_operations *ops;
         int index;
-        /* The ldisc objects are protected by tty_ldisc_lock at the moment */
-        struct tty_ldisc ldisc;
+
+        /* Protects ldisc changes: Lock tty not pty */
+        struct mutex ldisc_mutex;
+        struct tty_ldisc *ldisc;
+
         struct mutex termios_mutex;
         spinlock_t ctrl_lock;
         /* Termios values are protected by the termios mutex */
@@ -311,6 +317,7 @@ struct tty_struct {
 #define TTY_CLOSING             7       /* ->close() in progress */
 #define TTY_LDISC               9       /* Line discipline attached */
 #define TTY_LDISC_CHANGING      10      /* Line discipline changing */
+#define TTY_LDISC_OPEN          11      /* Line discipline is open */
 #define TTY_HW_COOK_OUT         14      /* Hardware can do output cooking */
 #define TTY_HW_COOK_IN          15      /* Hardware can do input cooking */
 #define TTY_PTY_LOCK            16      /* pty private */
@@ -403,6 +410,7 @@ extern int tty_termios_hw_change(struct ktermios *a, struct ktermios *b);
 extern struct tty_ldisc *tty_ldisc_ref(struct tty_struct *);
 extern void tty_ldisc_deref(struct tty_ldisc *);
 extern struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *);
+extern void tty_ldisc_hangup(struct tty_struct *tty);
 extern const struct file_operations tty_ldiscs_proc_fops;
 
 extern void tty_wakeup(struct tty_struct *tty);
@@ -425,6 +433,9 @@ extern struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx,
 extern void tty_release_dev(struct file *filp);
 extern int tty_init_termios(struct tty_struct *tty);
 
+extern struct tty_struct *tty_pair_get_tty(struct tty_struct *tty);
+extern struct tty_struct *tty_pair_get_pty(struct tty_struct *tty);
+
 extern struct mutex tty_mutex;
 
 extern void tty_write_unlock(struct tty_struct *tty);
@@ -438,6 +449,7 @@ extern struct tty_struct *tty_port_tty_get(struct tty_port *port);
 extern void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty);
 extern int tty_port_carrier_raised(struct tty_port *port);
 extern void tty_port_raise_dtr_rts(struct tty_port *port);
+extern void tty_port_lower_dtr_rts(struct tty_port *port);
 extern void tty_port_hangup(struct tty_port *port);
 extern int tty_port_block_til_ready(struct tty_port *port,
                                 struct tty_struct *tty, struct file *filp);
diff --git a/include/linux/tty_driver.h b/include/linux/tty_driver.h
index bcba84ea2d86..3566129384a4 100644
--- a/include/linux/tty_driver.h
+++ b/include/linux/tty_driver.h
@@ -127,7 +127,8 @@
  *      the line discipline are close to full, and it should somehow
  *      signal that no more characters should be sent to the tty.
  *
- *      Optional: Always invoke via tty_throttle();
+ *      Optional: Always invoke via tty_throttle(), called under the
+ *      termios lock.
  * 
  * void (*unthrottle)(struct tty_struct * tty);
  *
@@ -135,7 +136,8 @@
  *      that characters can now be sent to the tty without fear of
  *      overrunning the input buffers of the line disciplines.
  * 
- *      Optional: Always invoke via tty_unthrottle();
+ *      Optional: Always invoke via tty_unthrottle(), called under the
+ *      termios lock.
  *
  * void (*stop)(struct tty_struct *tty);
  *
diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h
index 625e9e4639c6..8cdfed738fe4 100644
--- a/include/linux/usb/serial.h
+++ b/include/linux/usb/serial.h
@@ -224,8 +224,7 @@ struct usb_serial_driver {
         /* Called by console with tty = NULL and by tty */
         int  (*open)(struct tty_struct *tty,
                         struct usb_serial_port *port, struct file *filp);
-        void (*close)(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+        void (*close)(struct usb_serial_port *port);
         int  (*write)(struct tty_struct *tty, struct usb_serial_port *port,
                         const unsigned char *buf, int count);
         /* Called only by the tty layer */
@@ -241,6 +240,10 @@ struct usb_serial_driver {
         int  (*tiocmget)(struct tty_struct *tty, struct file *file);
         int  (*tiocmset)(struct tty_struct *tty, struct file *file,
                          unsigned int set, unsigned int clear);
+        /* Called by the tty layer for port level work. There may or may not
+           be an attached tty at this point */
+        void (*dtr_rts)(struct usb_serial_port *port, int on);
+        int  (*carrier_raised)(struct usb_serial_port *port);
         /* USB events */
         void (*read_int_callback)(struct urb *urb);
         void (*write_int_callback)(struct urb *urb);
@@ -283,8 +286,7 @@ extern int usb_serial_generic_open(struct tty_struct *tty,
                 struct usb_serial_port *port, struct file *filp);
 extern int usb_serial_generic_write(struct tty_struct *tty,
         struct usb_serial_port *port, const unsigned char *buf, int count);
-extern void usb_serial_generic_close(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+extern void usb_serial_generic_close(struct usb_serial_port *port);
 extern int usb_serial_generic_resume(struct usb_serial *serial);
 extern int usb_serial_generic_write_room(struct tty_struct *tty);
 extern int usb_serial_generic_chars_in_buffer(struct tty_struct *tty);
diff --git a/include/linux/virtio_blk.h b/include/linux/virtio_blk.h
index 94c56d29869d..be7d255fc7cf 100644
--- a/include/linux/virtio_blk.h
+++ b/include/linux/virtio_blk.h
@@ -15,6 +15,10 @@
 #define VIRTIO_BLK_F_GEOMETRY   4       /* Legacy geometry available  */
 #define VIRTIO_BLK_F_RO         5       /* Disk is read-only */
 #define VIRTIO_BLK_F_BLK_SIZE   6       /* Block size of disk is available*/
+#define VIRTIO_BLK_F_SCSI       7       /* Supports scsi command passthru */
+#define VIRTIO_BLK_F_IDENTIFY   8       /* ATA IDENTIFY supported */
+
+#define VIRTIO_BLK_ID_BYTES     (sizeof(__u16[256]))    /* IDENTIFY DATA */
 
 struct virtio_blk_config
 {
@@ -32,6 +36,7 @@ struct virtio_blk_config
         } geometry;
         /* block size of device (if VIRTIO_BLK_F_BLK_SIZE) */
         __u32 blk_size;
+        __u8 identify[VIRTIO_BLK_ID_BYTES];
 } __attribute__((packed));
 
 /* These two define direction. */
@@ -55,6 +60,13 @@ struct virtio_blk_outhdr
         __u64 sector;
 };
 
+struct virtio_scsi_inhdr {
+        __u32 errors;
+        __u32 data_len;
+        __u32 sense_len;
+        __u32 residual;
+};
+
 /* And this is the final byte of the write scatter-gather list. */
 #define VIRTIO_BLK_S_OK         0
 #define VIRTIO_BLK_S_IOERR      1
diff --git a/include/scsi/scsi_cmnd.h b/include/scsi/scsi_cmnd.h
index 43b50d36925c..3878d1dc7f59 100644
--- a/include/scsi/scsi_cmnd.h
+++ b/include/scsi/scsi_cmnd.h
@@ -270,7 +270,7 @@ static inline unsigned char scsi_get_prot_type(struct scsi_cmnd *scmd)
 
 static inline sector_t scsi_get_lba(struct scsi_cmnd *scmd)
 {
-        return scmd->request->sector;
+        return blk_rq_pos(scmd->request);
 }
 
 static inline unsigned scsi_prot_sg_count(struct scsi_cmnd *cmd)
diff --git a/include/trace/events/block.h b/include/trace/events/block.h
index 53effd496a50..d6b05f42dd44 100644
--- a/include/trace/events/block.h
+++ b/include/trace/events/block.h
@@ -25,9 +25,8 @@ TRACE_EVENT(block_rq_abort,
 
         TP_fast_assign(
                 __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
-                __entry->sector    = blk_pc_request(rq) ? 0 : rq->hard_sector;
-                __entry->nr_sector = blk_pc_request(rq) ?
-                                                0 : rq->hard_nr_sectors;
+                __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
+                __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
                 __entry->errors    = rq->errors;
 
                 blk_fill_rwbs_rq(__entry->rwbs, rq);
@@ -59,10 +58,9 @@ TRACE_EVENT(block_rq_insert,
 
         TP_fast_assign(
                 __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
-                __entry->sector    = blk_pc_request(rq) ? 0 : rq->hard_sector;
-                __entry->nr_sector = blk_pc_request(rq) ?
-                                                0 : rq->hard_nr_sectors;
-                __entry->bytes     = blk_pc_request(rq) ? rq->data_len : 0;
+                __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
+                __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
+                __entry->bytes     = blk_pc_request(rq) ? blk_rq_bytes(rq) : 0;
 
                 blk_fill_rwbs_rq(__entry->rwbs, rq);
                 blk_dump_cmd(__get_str(cmd), rq);
@@ -94,10 +92,9 @@ TRACE_EVENT(block_rq_issue,
 
         TP_fast_assign(
                 __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
-                __entry->sector    = blk_pc_request(rq) ? 0 : rq->hard_sector;
-                __entry->nr_sector = blk_pc_request(rq) ?
-                                                0 : rq->hard_nr_sectors;
-                __entry->bytes     = blk_pc_request(rq) ? rq->data_len : 0;
+                __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
+                __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
+                __entry->bytes     = blk_pc_request(rq) ? blk_rq_bytes(rq) : 0;
 
                 blk_fill_rwbs_rq(__entry->rwbs, rq);
                 blk_dump_cmd(__get_str(cmd), rq);
@@ -128,9 +125,8 @@ TRACE_EVENT(block_rq_requeue,
 
         TP_fast_assign(
                 __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
-                __entry->sector    = blk_pc_request(rq) ? 0 : rq->hard_sector;
-                __entry->nr_sector = blk_pc_request(rq) ?
-                                                0 : rq->hard_nr_sectors;
+                __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
+                __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
                 __entry->errors    = rq->errors;
 
                 blk_fill_rwbs_rq(__entry->rwbs, rq);
@@ -161,9 +157,8 @@ TRACE_EVENT(block_rq_complete,
 
         TP_fast_assign(
                 __entry->dev       = rq->rq_disk ? disk_devt(rq->rq_disk) : 0;
-                __entry->sector    = blk_pc_request(rq) ? 0 : rq->hard_sector;
-                __entry->nr_sector = blk_pc_request(rq) ?
-                                                0 : rq->hard_nr_sectors;
+                __entry->sector    = blk_pc_request(rq) ? 0 : blk_rq_pos(rq);
+                __entry->nr_sector = blk_pc_request(rq) ? 0 : blk_rq_sectors(rq);
                 __entry->errors    = rq->errors;
 
                 blk_fill_rwbs_rq(__entry->rwbs, rq);
diff --git a/ipc/shm.c b/ipc/shm.c
index 425971600485..15dd238e5338 100644
--- a/ipc/shm.c
+++ b/ipc/shm.c
@@ -384,7 +384,6 @@ static int newseg(struct ipc_namespace *ns, struct ipc_params *params)
         error = PTR_ERR(file);
         if (IS_ERR(file))
                 goto no_file;
-        ima_shm_check(file);
 
         id = ipc_addid(&shm_ids(ns), &shp->shm_perm, ns->shm_ctlmni);
         if (id < 0) {
@@ -891,7 +890,7 @@ long do_shmat(int shmid, char __user *shmaddr, int shmflg, ulong *raddr)
         file = alloc_file(path.mnt, path.dentry, f_mode, &shm_file_operations);
         if (!file)
                 goto out_free;
-        ima_shm_check(file);
+        ima_counts_get(file);
 
         file->private_data = sfd;
         file->f_mapping = shp->shm_file->f_mapping;
diff --git a/kernel/cred.c b/kernel/cred.c
index 3a039189d707..1bb4d7e5d616 100644
--- a/kernel/cred.c
+++ b/kernel/cred.c
@@ -167,7 +167,7 @@ EXPORT_SYMBOL(prepare_creds);
 
 /*
  * Prepare credentials for current to perform an execve()
- * - The caller must hold current->cred_exec_mutex
+ * - The caller must hold current->cred_guard_mutex
  */
 struct cred *prepare_exec_creds(void)
 {
@@ -276,7 +276,7 @@ int copy_creds(struct task_struct *p, unsigned long clone_flags)
         struct cred *new;
         int ret;
 
-        mutex_init(&p->cred_exec_mutex);
+        mutex_init(&p->cred_guard_mutex);
 
         if (
 #ifdef CONFIG_KEYS
diff --git a/kernel/exit.c b/kernel/exit.c
index cab535c427b8..51d1fe3fb7ad 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -1472,6 +1472,7 @@ static int wait_consider_task(struct task_struct *parent, int ptrace,
                  */
                 if (*notask_error)
                         *notask_error = ret;
+                return 0;
         }
 
         if (likely(!ptrace) && unlikely(p->ptrace)) {
diff --git a/kernel/module.c b/kernel/module.c
index 2383e60fcf3f..278e9b6762bb 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -73,6 +73,9 @@ DEFINE_MUTEX(module_mutex);
 EXPORT_SYMBOL_GPL(module_mutex);
 static LIST_HEAD(modules);
 
+/* Block module loading/unloading? */
+int modules_disabled = 0;
+
 /* Waiting for a module to finish initializing? */
 static DECLARE_WAIT_QUEUE_HEAD(module_wq);
 
@@ -778,7 +781,7 @@ SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
         char name[MODULE_NAME_LEN];
         int ret, forced = 0;
 
-        if (!capable(CAP_SYS_MODULE))
+        if (!capable(CAP_SYS_MODULE) || modules_disabled)
                 return -EPERM;
 
         if (strncpy_from_user(name, name_user, MODULE_NAME_LEN-1) < 0)
@@ -2338,7 +2341,7 @@ SYSCALL_DEFINE3(init_module, void __user *, umod,
         int ret = 0;
 
         /* Must have permission */
-        if (!capable(CAP_SYS_MODULE))
+        if (!capable(CAP_SYS_MODULE) || modules_disabled)
                 return -EPERM;
 
         /* Only one module load at a time, please */
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index 2442d140bd9a..f6d8b8cb5e34 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
@@ -175,10 +175,11 @@ int ptrace_attach(struct task_struct *task)
         if (same_thread_group(task, current))
                 goto out;
 
-        /* Protect exec's credential calculations against our interference;
-         * SUID, SGID and LSM creds get determined differently under ptrace.
+        /* Protect the target's credential calculations against our
+         * interference; SUID, SGID and LSM creds get determined differently
+         * under ptrace.
          */
-        retval = mutex_lock_interruptible(&task->cred_exec_mutex);
+        retval = mutex_lock_interruptible(&task->cred_guard_mutex);
         if (retval  < 0)
                 goto out;
 
@@ -222,7 +223,7 @@ repeat:
 bad:
         write_unlock_irqrestore(&tasklist_lock, flags);
         task_unlock(task);
-        mutex_unlock(&task->cred_exec_mutex);
+        mutex_unlock(&task->cred_guard_mutex);
 out:
         return retval;
 }
diff --git a/kernel/signal.c b/kernel/signal.c
index dba6ae99978a..809a228019ad 100644
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -247,14 +247,19 @@ void flush_sigqueue(struct sigpending *queue)
 /*
  * Flush all pending signals for a task.
  */
+void __flush_signals(struct task_struct *t)
+{
+        clear_tsk_thread_flag(t, TIF_SIGPENDING);
+        flush_sigqueue(&t->pending);
+        flush_sigqueue(&t->signal->shared_pending);
+}
+
 void flush_signals(struct task_struct *t)
 {
         unsigned long flags;
 
         spin_lock_irqsave(&t->sighand->siglock, flags);
-        clear_tsk_thread_flag(t, TIF_SIGPENDING);
-        flush_sigqueue(&t->pending);
-        flush_sigqueue(&t->signal->shared_pending);
+        __flush_signals(t);
         spin_unlock_irqrestore(&t->sighand->siglock, flags);
 }
 
diff --git a/kernel/slow-work.c b/kernel/slow-work.c
index b28d19135f43..521ed2004d63 100644
--- a/kernel/slow-work.c
+++ b/kernel/slow-work.c
@@ -372,8 +372,8 @@ static int slow_work_thread(void *_data)
                 vsmax *= atomic_read(&slow_work_thread_count);
                 vsmax /= 100;
 
-                prepare_to_wait(&slow_work_thread_wq, &wait,
-                                TASK_INTERRUPTIBLE);
+                prepare_to_wait_exclusive(&slow_work_thread_wq, &wait,
+                                          TASK_INTERRUPTIBLE);
                 if (!freezing(current) &&
                     !slow_work_threads_should_exit &&
                     !slow_work_available(vsmax) &&
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 6a463716ecbf..944ba03cae19 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -114,6 +114,7 @@ static int ngroups_max = NGROUPS_MAX;
 
 #ifdef CONFIG_MODULES
 extern char modprobe_path[];
+extern int modules_disabled;
 #endif
 #ifdef CONFIG_CHR_DEV_SG
 extern int sg_big_buff;
@@ -534,6 +535,17 @@ static struct ctl_table kern_table[] = {
                 .proc_handler   = &proc_dostring,
                 .strategy       = &sysctl_string,
         },
+        {
+                .ctl_name       = CTL_UNNUMBERED,
+                .procname       = "modules_disabled",
+                .data           = &modules_disabled,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                /* only handle a transition from default "0" to "1" */
+                .proc_handler   = &proc_dointvec_minmax,
+                .extra1         = &one,
+                .extra2         = &one,
+        },
 #endif
 #if defined(CONFIG_HOTPLUG) && defined(CONFIG_NET)
         {
@@ -1233,7 +1245,6 @@ static struct ctl_table vm_table[] = {
                 .strategy       = &sysctl_jiffies,
         },
 #endif
-#ifdef CONFIG_SECURITY
         {
                 .ctl_name       = CTL_UNNUMBERED,
                 .procname       = "mmap_min_addr",
@@ -1242,7 +1253,6 @@ static struct ctl_table vm_table[] = {
                 .mode           = 0644,
                 .proc_handler   = &proc_doulongvec_minmax,
         },
-#endif
 #ifdef CONFIG_NUMA
         {
                 .ctl_name       = CTL_UNNUMBERED,
diff --git a/kernel/time/clocksource.c b/kernel/time/clocksource.c
index ecfd7b5187e0..80189f6f1c5a 100644
--- a/kernel/time/clocksource.c
+++ b/kernel/time/clocksource.c
@@ -402,9 +402,6 @@ int clocksource_register(struct clocksource *c)
         unsigned long flags;
         int ret;
 
-        /* save mult_orig on registration */
-        c->mult_orig = c->mult;
-
         spin_lock_irqsave(&clocksource_lock, flags);
         ret = clocksource_enqueue(c);
         if (!ret)
diff --git a/kernel/time/timekeeping.c b/kernel/time/timekeeping.c
index 52a8bf8931f3..e8c77d9c633a 100644
--- a/kernel/time/timekeeping.c
+++ b/kernel/time/timekeeping.c
@@ -77,6 +77,10 @@ static void clocksource_forward_now(void)
         clock->cycle_last = cycle_now;
 
         nsec = cyc2ns(clock, cycle_delta);
+
+        /* If arch requires, add in gettimeoffset() */
+        nsec += arch_gettimeoffset();
+
         timespec_add_ns(&xtime, nsec);
 
         nsec = ((s64)cycle_delta * clock->mult_orig) >> clock->shift;
@@ -111,6 +115,9 @@ void getnstimeofday(struct timespec *ts)
                 /* convert to nanoseconds: */
                 nsecs = cyc2ns(clock, cycle_delta);
 
+                /* If arch requires, add in gettimeoffset() */
+                nsecs += arch_gettimeoffset();
+
         } while (read_seqretry(&xtime_lock, seq));
 
         timespec_add_ns(ts, nsecs);
diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
index 7bd6a9893c24..39af8af6fc30 100644
--- a/kernel/trace/blktrace.c
+++ b/kernel/trace/blktrace.c
@@ -669,12 +669,12 @@ static void blk_add_trace_rq(struct request_queue *q, struct request *rq,
 
         if (blk_pc_request(rq)) {
                 what |= BLK_TC_ACT(BLK_TC_PC);
-                __blk_add_trace(bt, 0, rq->data_len, rw, what, rq->errors,
-                                rq->cmd_len, rq->cmd);
+                __blk_add_trace(bt, 0, blk_rq_bytes(rq), rw,
+                                what, rq->errors, rq->cmd_len, rq->cmd);
         } else  {
                 what |= BLK_TC_ACT(BLK_TC_FS);
-                __blk_add_trace(bt, rq->hard_sector, rq->hard_nr_sectors << 9,
-                                rw, what, rq->errors, 0, NULL);
+                __blk_add_trace(bt, blk_rq_pos(rq), blk_rq_bytes(rq), rw,
+                                what, rq->errors, 0, NULL);
         }
 }
 
@@ -881,11 +881,11 @@ void blk_add_driver_data(struct request_queue *q,
                 return;
 
         if (blk_pc_request(rq))
-                __blk_add_trace(bt, 0, rq->data_len, 0, BLK_TA_DRV_DATA,
-                                rq->errors, len, data);
+                __blk_add_trace(bt, 0, blk_rq_bytes(rq), 0,
+                                BLK_TA_DRV_DATA, rq->errors, len, data);
         else
-                __blk_add_trace(bt, rq->hard_sector, rq->hard_nr_sectors << 9,
-                                0, BLK_TA_DRV_DATA, rq->errors, len, data);
+                __blk_add_trace(bt, blk_rq_pos(rq), blk_rq_bytes(rq), 0,
+                                BLK_TA_DRV_DATA, rq->errors, len, data);
 }
 EXPORT_SYMBOL_GPL(blk_add_driver_data);
 
@@ -1724,10 +1724,7 @@ void blk_fill_rwbs_rq(char *rwbs, struct request *rq)
         if (blk_discard_rq(rq))
                 rw |= (1 << BIO_RW_DISCARD);
 
-        if (blk_pc_request(rq))
-                bytes = rq->data_len;
-        else
-                bytes = rq->hard_nr_sectors << 9;
+        bytes = blk_rq_bytes(rq);
 
         blk_fill_rwbs(rwbs, rw, bytes);
 }
diff --git a/lib/Kconfig b/lib/Kconfig
index 8ade0a7a91e0..9960be04cbbe 100644
--- a/lib/Kconfig
+++ b/lib/Kconfig
@@ -10,6 +10,9 @@ menu "Library routines"
 config BITREVERSE
         tristate
 
+config RATIONAL
+        boolean
+
 config GENERIC_FIND_FIRST_BIT
         bool
 
diff --git a/lib/Makefile b/lib/Makefile
index 33a40e40e3ee..1f6edefebffe 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -50,6 +50,7 @@ ifneq ($(CONFIG_HAVE_DEC_LOCK),y)
 endif
 
 obj-$(CONFIG_BITREVERSE) += bitrev.o
+obj-$(CONFIG_RATIONAL)  += rational.o
 obj-$(CONFIG_CRC_CCITT) += crc-ccitt.o
 obj-$(CONFIG_CRC16)     += crc16.o
 obj-$(CONFIG_CRC_T10DIF)+= crc-t10dif.o
diff --git a/lib/rational.c b/lib/rational.c
new file mode 100644
index 000000000000..b3c099b5478e
--- /dev/null
+++ b/lib/rational.c
@@ -0,0 +1,62 @@
+/*
+ * rational fractions
+ *
+ * Copyright (C) 2009 emlix GmbH, Oskar Schirmer <os@emlix.com>
+ *
+ * helper functions when coping with rational numbers
+ */
+
+#include <linux/rational.h>
+
+/*
+ * calculate best rational approximation for a given fraction
+ * taking into account restricted register size, e.g. to find
+ * appropriate values for a pll with 5 bit denominator and
+ * 8 bit numerator register fields, trying to set up with a
+ * frequency ratio of 3.1415, one would say:
+ *
+ * rational_best_approximation(31415, 10000,
+ *              (1 << 8) - 1, (1 << 5) - 1, &n, &d);
+ *
+ * you may look at given_numerator as a fixed point number,
+ * with the fractional part size described in given_denominator.
+ *
+ * for theoretical background, see:
+ * http://en.wikipedia.org/wiki/Continued_fraction
+ */
+
+void rational_best_approximation(
+        unsigned long given_numerator, unsigned long given_denominator,
+        unsigned long max_numerator, unsigned long max_denominator,
+        unsigned long *best_numerator, unsigned long *best_denominator)
+{
+        unsigned long n, d, n0, d0, n1, d1;
+        n = given_numerator;
+        d = given_denominator;
+        n0 = d1 = 0;
+        n1 = d0 = 1;
+        for (;;) {
+                unsigned long t, a;
+                if ((n1 > max_numerator) || (d1 > max_denominator)) {
+                        n1 = n0;
+                        d1 = d0;
+                        break;
+                }
+                if (d == 0)
+                        break;
+                t = d;
+                a = n / d;
+                d = n % d;
+                n = t;
+                t = n0 + a * n1;
+                n0 = n1;
+                n1 = t;
+                t = d0 + a * d1;
+                d0 = d1;
+                d1 = t;
+        }
+        *best_numerator = n1;
+        *best_denominator = d1;
+}
+
+EXPORT_SYMBOL(rational_best_approximation);
diff --git a/mm/Kconfig b/mm/Kconfig
index c2b57d81e153..71830ba7b986 100644
--- a/mm/Kconfig
+++ b/mm/Kconfig
@@ -226,6 +226,25 @@ config HAVE_MLOCKED_PAGE_BIT
 config MMU_NOTIFIER
         bool
 
+config DEFAULT_MMAP_MIN_ADDR
+        int "Low address space to protect from user allocation"
+        default 4096
+        help
+          This is the portion of low virtual memory which should be protected
+          from userspace allocation.  Keeping a user from writing to low pages
+          can help reduce the impact of kernel NULL pointer bugs.
+
+          For most ia64, ppc64 and x86 users with lots of address space
+          a value of 65536 is reasonable and should cause no problems.
+          On arm and other archs it should not be higher than 32768.
+          Programs which use vm86 functionality would either need additional
+          permissions from either the LSM or the capabilities module or have
+          this protection disabled.
+
+          This value can be changed after boot using the
+          /proc/sys/vm/mmap_min_addr tunable.
+
+
 config NOMMU_INITIAL_TRIM_EXCESS
         int "Turn on mmap() excess space trimming before booting"
         depends on !MMU
diff --git a/mm/bounce.c b/mm/bounce.c
index 65f5e17e411a..4ebe3ea83795 100644
--- a/mm/bounce.c
+++ b/mm/bounce.c
@@ -191,7 +191,7 @@ static void __blk_queue_bounce(struct request_queue *q, struct bio **bio_orig,
                 /*
                  * is destination page below bounce pfn?
                  */
-                if (page_to_pfn(page) <= q->bounce_pfn)
+                if (page_to_pfn(page) <= queue_bounce_pfn(q))
                         continue;
 
                 /*
@@ -283,7 +283,7 @@ void blk_queue_bounce(struct request_queue *q, struct bio **bio_orig)
          * don't waste time iterating over bio segments
          */
         if (!(q->bounce_gfp & GFP_DMA)) {
-                if (q->bounce_pfn >= blk_max_pfn)
+                if (queue_bounce_pfn(q) >= blk_max_pfn)
                         return;
                 pool = page_pool;
         } else {
diff --git a/mm/mmap.c b/mm/mmap.c
index 6b7b1a95944b..2b43fa1aa3c8 100644
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -87,6 +87,9 @@ int sysctl_overcommit_ratio = 50;	/* default is 50% */
 int sysctl_max_map_count __read_mostly = DEFAULT_MAX_MAP_COUNT;
 struct percpu_counter vm_committed_as;
 
+/* amount of vm to protect from userspace access */
+unsigned long mmap_min_addr = CONFIG_DEFAULT_MMAP_MIN_ADDR;
+
 /*
  * Check that a process has enough memory to allocate a new virtual
  * mapping. 0 means there is enough memory for the allocation to
diff --git a/mm/nommu.c b/mm/nommu.c
index b571ef707428..2fd2ad5da98e 100644
--- a/mm/nommu.c
+++ b/mm/nommu.c
@@ -69,6 +69,9 @@ int sysctl_max_map_count = DEFAULT_MAX_MAP_COUNT;
 int sysctl_nr_trim_pages = CONFIG_NOMMU_INITIAL_TRIM_EXCESS;
 int heap_stack_gap = 0;
 
+/* amount of vm to protect from userspace access */
+unsigned long mmap_min_addr = CONFIG_DEFAULT_MMAP_MIN_ADDR;
+
 atomic_long_t mmap_pages_allocated;
 
 EXPORT_SYMBOL(mem_map);
diff --git a/mm/shmem.c b/mm/shmem.c
index b25f95ce3db7..0132fbd45a23 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -2659,6 +2659,7 @@ struct file *shmem_file_setup(char *name, loff_t size, unsigned long flags)
         if (error)
                 goto close_file;
 #endif
+        ima_counts_get(file);
         return file;
 
 close_file:
@@ -2684,7 +2685,6 @@ int shmem_zero_setup(struct vm_area_struct *vma)
         if (IS_ERR(file))
                 return PTR_ERR(file);
 
-        ima_shm_check(file);
         if (vma->vm_file)
                 fput(vma->vm_file);
         vma->vm_file = file;
diff --git a/security/Kconfig b/security/Kconfig
index bb244774e9d7..d23c839038f0 100644
--- a/security/Kconfig
+++ b/security/Kconfig
@@ -110,28 +110,8 @@ config SECURITY_ROOTPLUG
 
           See <http://www.linuxjournal.com/article.php?sid=6279> for
           more information about this module.
-          
-          If you are unsure how to answer this question, answer N.
-
-config SECURITY_DEFAULT_MMAP_MIN_ADDR
-        int "Low address space to protect from user allocation"
-        depends on SECURITY
-        default 0
-        help
-          This is the portion of low virtual memory which should be protected
-          from userspace allocation.  Keeping a user from writing to low pages
-          can help reduce the impact of kernel NULL pointer bugs.
-
-          For most ia64, ppc64 and x86 users with lots of address space
-          a value of 65536 is reasonable and should cause no problems.
-          On arm and other archs it should not be higher than 32768.
-          Programs which use vm86 functionality would either need additional
-          permissions from either the LSM or the capabilities module or have
-          this protection disabled.
-
-          This value can be changed after boot using the
-          /proc/sys/vm/mmap_min_addr tunable.
 
+          If you are unsure how to answer this question, answer N.
 
 source security/selinux/Kconfig
 source security/smack/Kconfig
diff --git a/security/Makefile b/security/Makefile
index fa77021d9778..c67557cdaa85 100644
--- a/security/Makefile
+++ b/security/Makefile
@@ -16,6 +16,9 @@ obj-$(CONFIG_SECURITYFS)		+= inode.o
 # Must precede capability.o in order to stack properly.
 obj-$(CONFIG_SECURITY_SELINUX)          += selinux/built-in.o
 obj-$(CONFIG_SECURITY_SMACK)            += smack/built-in.o
+ifeq ($(CONFIG_AUDIT),y)
+obj-$(CONFIG_SECURITY_SMACK)            += lsm_audit.o
+endif
 obj-$(CONFIG_SECURITY_TOMOYO)           += tomoyo/built-in.o
 obj-$(CONFIG_SECURITY_ROOTPLUG)         += root_plug.o
 obj-$(CONFIG_CGROUP_DEVICE)             += device_cgroup.o
diff --git a/security/commoncap.c b/security/commoncap.c
index beac0258c2a8..48b7e0228fa3 100644
--- a/security/commoncap.c
+++ b/security/commoncap.c
@@ -28,6 +28,28 @@
 #include <linux/prctl.h>
 #include <linux/securebits.h>
 
+/*
+ * If a non-root user executes a setuid-root binary in
+ * !secure(SECURE_NOROOT) mode, then we raise capabilities.
+ * However if fE is also set, then the intent is for only
+ * the file capabilities to be applied, and the setuid-root
+ * bit is left on either to change the uid (plausible) or
+ * to get full privilege on a kernel without file capabilities
+ * support.  So in that case we do not raise capabilities.
+ *
+ * Warn if that happens, once per boot.
+ */
+static void warn_setuid_and_fcaps_mixed(char *fname)
+{
+        static int warned;
+        if (!warned) {
+                printk(KERN_INFO "warning: `%s' has both setuid-root and"
+                        " effective capabilities. Therefore not raising all"
+                        " capabilities.\n", fname);
+                warned = 1;
+        }
+}
+
 int cap_netlink_send(struct sock *sk, struct sk_buff *skb)
 {
         NETLINK_CB(skb).eff_cap = current_cap();
@@ -464,6 +486,15 @@ int cap_bprm_set_creds(struct linux_binprm *bprm)
 
         if (!issecure(SECURE_NOROOT)) {
                 /*
+                 * If the legacy file capability is set, then don't set privs
+                 * for a setuid root binary run by a non-root user.  Do set it
+                 * for a root user just to cause least surprise to an admin.
+                 */
+                if (effective && new->uid != 0 && new->euid == 0) {
+                        warn_setuid_and_fcaps_mixed(bprm->filename);
+                        goto skip;
+                }
+                /*
                  * To support inheritance of root-permissions and suid-root
                  * executables under compatibility mode, we override the
                  * capability sets for the file.
@@ -478,6 +509,7 @@ int cap_bprm_set_creds(struct linux_binprm *bprm)
                 if (new->euid == 0)
                         effective = true;
         }
+skip:
 
         /* Don't let someone trace a set[ug]id/setpcap binary with the revised
          * credentials unless they have the appropriate permit
diff --git a/security/inode.c b/security/inode.c
index f3b91bfbe4cb..f7496c6a022b 100644
--- a/security/inode.c
+++ b/security/inode.c
@@ -287,7 +287,7 @@ void securityfs_remove(struct dentry *dentry)
 {
         struct dentry *parent;
 
-        if (!dentry)
+        if (!dentry || IS_ERR(dentry))
                 return;
 
         parent = dentry->d_parent;
diff --git a/security/integrity/ima/ima_audit.c b/security/integrity/ima/ima_audit.c
index 1e082bb987be..ff513ff737f5 100644
--- a/security/integrity/ima/ima_audit.c
+++ b/security/integrity/ima/ima_audit.c
@@ -22,18 +22,9 @@ static int ima_audit;
 static int __init ima_audit_setup(char *str)
 {
         unsigned long audit;
-        int rc, result = 0;
-        char *op = "ima_audit";
-        char *cause;
 
-        rc = strict_strtoul(str, 0, &audit);
-        if (rc || audit > 1)
-                result = 1;
-        else
-                ima_audit = audit;
-        cause = ima_audit ? "enabled" : "not_enabled";
-        integrity_audit_msg(AUDIT_INTEGRITY_STATUS, NULL, NULL,
-                            op, cause, result, 0);
+        if (!strict_strtoul(str, 0, &audit))
+                ima_audit = audit ? 1 : 0;
         return 1;
 }
 __setup("ima_audit=", ima_audit_setup);
@@ -50,23 +41,14 @@ void integrity_audit_msg(int audit_msgno, struct inode *inode,
 
         ab = audit_log_start(current->audit_context, GFP_KERNEL, audit_msgno);
         audit_log_format(ab, "integrity: pid=%d uid=%u auid=%u ses=%u",
-                         current->pid, current->cred->uid,
+                         current->pid, current_cred()->uid,
                          audit_get_loginuid(current),
                          audit_get_sessionid(current));
         audit_log_task_context(ab);
-        switch (audit_msgno) {
-        case AUDIT_INTEGRITY_DATA:
-        case AUDIT_INTEGRITY_METADATA:
-        case AUDIT_INTEGRITY_PCR:
-        case AUDIT_INTEGRITY_STATUS:
-                audit_log_format(ab, " op=%s cause=%s", op, cause);
-                break;
-        case AUDIT_INTEGRITY_HASH:
-                audit_log_format(ab, " op=%s hash=%s", op, cause);
-                break;
-        default:
-                audit_log_format(ab, " op=%s", op);
-        }
+        audit_log_format(ab, " op=");
+        audit_log_string(ab, op);
+        audit_log_format(ab, " cause=");
+        audit_log_string(ab, cause);
         audit_log_format(ab, " comm=");
         audit_log_untrustedstring(ab, current->comm);
         if (fname) {
diff --git a/security/integrity/ima/ima_crypto.c b/security/integrity/ima/ima_crypto.c
index 50d572b74caf..63003a63aaee 100644
--- a/security/integrity/ima/ima_crypto.c
+++ b/security/integrity/ima/ima_crypto.c
@@ -103,7 +103,7 @@ int ima_calc_template_hash(int template_len, void *template, char *digest)
         return rc;
 }
 
-static void ima_pcrread(int idx, u8 *pcr)
+static void __init ima_pcrread(int idx, u8 *pcr)
 {
         if (!ima_used_chip)
                 return;
@@ -115,7 +115,7 @@ static void ima_pcrread(int idx, u8 *pcr)
 /*
  * Calculate the boot aggregate hash
  */
-int ima_calc_boot_aggregate(char *digest)
+int __init ima_calc_boot_aggregate(char *digest)
 {
         struct hash_desc desc;
         struct scatterlist sg;
diff --git a/security/integrity/ima/ima_fs.c b/security/integrity/ima/ima_fs.c
index 510186f0b72e..6bfc7eaebfda 100644
--- a/security/integrity/ima/ima_fs.c
+++ b/security/integrity/ima/ima_fs.c
@@ -15,6 +15,7 @@
  *      implemenents security file system for reporting
  *      current measurement list and IMA statistics
  */
+#include <linux/fcntl.h>
 #include <linux/module.h>
 #include <linux/seq_file.h>
 #include <linux/rculist.h>
@@ -283,6 +284,9 @@ static atomic_t policy_opencount = ATOMIC_INIT(1);
  */
 int ima_open_policy(struct inode * inode, struct file * filp)
 {
+        /* No point in being allowed to open it if you aren't going to write */
+        if (!(filp->f_flags & O_WRONLY))
+                return -EACCES;
         if (atomic_dec_and_test(&policy_opencount))
                 return 0;
         return -EBUSY;
@@ -315,7 +319,7 @@ static struct file_operations ima_measure_policy_ops = {
         .release = ima_release_policy
 };
 
-int ima_fs_init(void)
+int __init ima_fs_init(void)
 {
         ima_dir = securityfs_create_dir("ima", NULL);
         if (IS_ERR(ima_dir))
@@ -349,7 +353,7 @@ int ima_fs_init(void)
                 goto out;
 
         ima_policy = securityfs_create_file("policy",
-                                            S_IRUSR | S_IRGRP | S_IWUSR,
+                                            S_IWUSR,
                                             ima_dir, NULL,
                                             &ima_measure_policy_ops);
         if (IS_ERR(ima_policy))
diff --git a/security/integrity/ima/ima_iint.c b/security/integrity/ima/ima_iint.c
index ec79f1ee992c..b8dd693f8790 100644
--- a/security/integrity/ima/ima_iint.c
+++ b/security/integrity/ima/ima_iint.c
@@ -196,7 +196,7 @@ static void init_once(void *foo)
         kref_set(&iint->refcount, 1);
 }
 
-void ima_iintcache_init(void)
+void __init ima_iintcache_init(void)
 {
         iint_cache =
             kmem_cache_create("iint_cache", sizeof(struct ima_iint_cache), 0,
diff --git a/security/integrity/ima/ima_init.c b/security/integrity/ima/ima_init.c
index 0b0bb8c978cc..a40da7ae5900 100644
--- a/security/integrity/ima/ima_init.c
+++ b/security/integrity/ima/ima_init.c
@@ -38,7 +38,7 @@ int ima_used_chip;
  * a different value.) Violations add a zero entry to the measurement
  * list and extend the aggregate PCR value with ff...ff's.
  */
-static void ima_add_boot_aggregate(void)
+static void __init ima_add_boot_aggregate(void)
 {
         struct ima_template_entry *entry;
         const char *op = "add_boot_aggregate";
@@ -71,7 +71,7 @@ err_out:
                             audit_cause, result, 0);
 }
 
-int ima_init(void)
+int __init ima_init(void)
 {
         u8 pcr_i[IMA_DIGEST_SIZE];
         int rc;
diff --git a/security/integrity/ima/ima_main.c b/security/integrity/ima/ima_main.c
index f4e7266f5aee..6f611874d10e 100644
--- a/security/integrity/ima/ima_main.c
+++ b/security/integrity/ima/ima_main.c
@@ -29,20 +29,8 @@ int ima_initialized;
 char *ima_hash = "sha1";
 static int __init hash_setup(char *str)
 {
-        const char *op = "hash_setup";
-        const char *hash = "sha1";
-        int result = 0;
-        int audit_info = 0;
-
-        if (strncmp(str, "md5", 3) == 0) {
-                hash = "md5";
-                ima_hash = str;
-        } else if (strncmp(str, "sha1", 4) != 0) {
-                hash = "invalid_hash_type";
-                result = 1;
-        }
-        integrity_audit_msg(AUDIT_INTEGRITY_HASH, NULL, NULL, op, hash,
-                            result, audit_info);
+        if (strncmp(str, "md5", 3) == 0)
+                ima_hash = "md5";
         return 1;
 }
 __setup("ima_hash=", hash_setup);
@@ -128,10 +116,6 @@ static int get_path_measurement(struct ima_iint_cache *iint, struct file *file,
 {
         int rc = 0;
 
-        if (IS_ERR(file)) {
-                pr_info("%s dentry_open failed\n", filename);
-                return rc;
-        }
         iint->opencount++;
         iint->readcount++;
 
@@ -141,6 +125,15 @@ static int get_path_measurement(struct ima_iint_cache *iint, struct file *file,
         return rc;
 }
 
+static void ima_update_counts(struct ima_iint_cache *iint, int mask)
+{
+        iint->opencount++;
+        if ((mask & MAY_WRITE) || (mask == 0))
+                iint->writecount++;
+        else if (mask & (MAY_READ | MAY_EXEC))
+                iint->readcount++;
+}
+
 /**
  * ima_path_check - based on policy, collect/store measurement.
  * @path: contains a pointer to the path to be measured
@@ -156,10 +149,10 @@ static int get_path_measurement(struct ima_iint_cache *iint, struct file *file,
  *      - Opening a file for read when already open for write,
  *        could result in a file measurement error.
  *
- * Return 0 on success, an error code on failure.
- * (Based on the results of appraise_measurement().)
+ * Always return 0 and audit dentry_open failures.
+ * (Return code will be based upon measurement appraisal.)
  */
-int ima_path_check(struct path *path, int mask)
+int ima_path_check(struct path *path, int mask, int update_counts)
 {
         struct inode *inode = path->dentry->d_inode;
         struct ima_iint_cache *iint;
@@ -173,11 +166,8 @@ int ima_path_check(struct path *path, int mask)
                 return 0;
 
         mutex_lock(&iint->mutex);
-        iint->opencount++;
-        if ((mask & MAY_WRITE) || (mask == 0))
-                iint->writecount++;
-        else if (mask & (MAY_READ | MAY_EXEC))
-                iint->readcount++;
+        if (update_counts)
+                ima_update_counts(iint, mask);
 
         rc = ima_must_measure(iint, inode, MAY_READ, PATH_CHECK);
         if (rc < 0)
@@ -196,7 +186,19 @@ int ima_path_check(struct path *path, int mask)
                 struct dentry *dentry = dget(path->dentry);
                 struct vfsmount *mnt = mntget(path->mnt);
 
-                file = dentry_open(dentry, mnt, O_RDONLY, current->cred);
+                file = dentry_open(dentry, mnt, O_RDONLY | O_LARGEFILE,
+                                   current_cred());
+                if (IS_ERR(file)) {
+                        int audit_info = 0;
+
+                        integrity_audit_msg(AUDIT_INTEGRITY_PCR, inode,
+                                            dentry->d_name.name,
+                                            "add_measurement",
+                                            "dentry_open failed",
+                                            1, audit_info);
+                        file = NULL;
+                        goto out;
+                }
                 rc = get_path_measurement(iint, file, dentry->d_name.name);
         }
 out:
@@ -206,6 +208,7 @@ out:
         kref_put(&iint->refcount, iint_free);
         return 0;
 }
+EXPORT_SYMBOL_GPL(ima_path_check);
 
 static int process_measurement(struct file *file, const unsigned char *filename,
                                int mask, int function)
@@ -234,7 +237,16 @@ out:
         return rc;
 }
 
-static void opencount_get(struct file *file)
+/*
+ * ima_opens_get - increment file counts
+ *
+ * - for IPC shm and shmat file.
+ * - for nfsd exported files.
+ *
+ * Increment the counts for these files to prevent unnecessary
+ * imbalance messages.
+ */
+void ima_counts_get(struct file *file)
 {
         struct inode *inode = file->f_dentry->d_inode;
         struct ima_iint_cache *iint;
@@ -246,8 +258,14 @@ static void opencount_get(struct file *file)
                 return;
         mutex_lock(&iint->mutex);
         iint->opencount++;
+        if ((file->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)
+                iint->readcount++;
+
+        if (file->f_mode & FMODE_WRITE)
+                iint->writecount++;
         mutex_unlock(&iint->mutex);
 }
+EXPORT_SYMBOL_GPL(ima_counts_get);
 
 /**
  * ima_file_mmap - based on policy, collect/store measurement.
@@ -272,18 +290,6 @@ int ima_file_mmap(struct file *file, unsigned long prot)
         return 0;
 }
 
-/*
- * ima_shm_check - IPC shm and shmat create/fput a file
- *
- * Maintain the opencount for these files to prevent unnecessary
- * imbalance messages.
- */
-void ima_shm_check(struct file *file)
-{
-        opencount_get(file);
-        return;
-}
-
 /**
  * ima_bprm_check - based on policy, collect/store measurement.
  * @bprm: contains the linux_binprm structure
diff --git a/security/integrity/ima/ima_policy.c b/security/integrity/ima/ima_policy.c
index b5291ad5ef56..e1278399b345 100644
--- a/security/integrity/ima/ima_policy.c
+++ b/security/integrity/ima/ima_policy.c
@@ -45,24 +45,30 @@ struct ima_measure_rule_entry {
         } lsm[MAX_LSM_RULES];
 };
 
-/* Without LSM specific knowledge, the default policy can only be
+/*
+ * Without LSM specific knowledge, the default policy can only be
  * written in terms of .action, .func, .mask, .fsmagic, and .uid
  */
+
+/*
+ * The minimum rule set to allow for full TCB coverage.  Measures all files
+ * opened or mmap for exec and everything read by root.  Dangerous because
+ * normal users can easily run the machine out of memory simply building
+ * and running executables.
+ */
 static struct ima_measure_rule_entry default_rules[] = {
-        {.action = DONT_MEASURE,.fsmagic = PROC_SUPER_MAGIC,
-         .flags = IMA_FSMAGIC},
+        {.action = DONT_MEASURE,.fsmagic = PROC_SUPER_MAGIC,.flags = IMA_FSMAGIC},
         {.action = DONT_MEASURE,.fsmagic = SYSFS_MAGIC,.flags = IMA_FSMAGIC},
         {.action = DONT_MEASURE,.fsmagic = DEBUGFS_MAGIC,.flags = IMA_FSMAGIC},
         {.action = DONT_MEASURE,.fsmagic = TMPFS_MAGIC,.flags = IMA_FSMAGIC},
-        {.action = DONT_MEASURE,.fsmagic = SECURITYFS_MAGIC,
-         .flags = IMA_FSMAGIC},
-        {.action = DONT_MEASURE,.fsmagic = 0xF97CFF8C,.flags = IMA_FSMAGIC},
+        {.action = DONT_MEASURE,.fsmagic = SECURITYFS_MAGIC,.flags = IMA_FSMAGIC},
+        {.action = DONT_MEASURE,.fsmagic = SELINUX_MAGIC,.flags = IMA_FSMAGIC},
         {.action = MEASURE,.func = FILE_MMAP,.mask = MAY_EXEC,
          .flags = IMA_FUNC | IMA_MASK},
         {.action = MEASURE,.func = BPRM_CHECK,.mask = MAY_EXEC,
          .flags = IMA_FUNC | IMA_MASK},
         {.action = MEASURE,.func = PATH_CHECK,.mask = MAY_READ,.uid = 0,
-         .flags = IMA_FUNC | IMA_MASK | IMA_UID}
+         .flags = IMA_FUNC | IMA_MASK | IMA_UID},
 };
 
 static LIST_HEAD(measure_default_rules);
@@ -71,6 +77,14 @@ static struct list_head *ima_measure;
 
 static DEFINE_MUTEX(ima_measure_mutex);
 
+static bool ima_use_tcb __initdata;
+static int __init default_policy_setup(char *str)
+{
+        ima_use_tcb = 1;
+        return 1;
+}
+__setup("ima_tcb", default_policy_setup);
+
 /**
  * ima_match_rules - determine whether an inode matches the measure rule.
  * @rule: a pointer to a rule
@@ -96,7 +110,7 @@ static bool ima_match_rules(struct ima_measure_rule_entry *rule,
         if ((rule->flags & IMA_UID) && rule->uid != tsk->cred->uid)
                 return false;
         for (i = 0; i < MAX_LSM_RULES; i++) {
-                int rc;
+                int rc = 0;
                 u32 osid, sid;
 
                 if (!rule->lsm[i].rule)
@@ -109,7 +123,7 @@ static bool ima_match_rules(struct ima_measure_rule_entry *rule,
                         security_inode_getsecid(inode, &osid);
                         rc = security_filter_rule_match(osid,
                                                         rule->lsm[i].type,
-                                                        AUDIT_EQUAL,
+                                                        Audit_equal,
                                                         rule->lsm[i].rule,
                                                         NULL);
                         break;
@@ -119,7 +133,7 @@ static bool ima_match_rules(struct ima_measure_rule_entry *rule,
                         security_task_getsecid(tsk, &sid);
                         rc = security_filter_rule_match(sid,
                                                         rule->lsm[i].type,
-                                                        AUDIT_EQUAL,
+                                                        Audit_equal,
                                                         rule->lsm[i].rule,
                                                         NULL);
                 default:
@@ -164,11 +178,17 @@ int ima_match_policy(struct inode *inode, enum ima_hooks func, int mask)
  * ima_measure points to either the measure_default_rules or the
  * the new measure_policy_rules.
  */
-void ima_init_policy(void)
+void __init ima_init_policy(void)
 {
-        int i;
+        int i, entries;
+
+        /* if !ima_use_tcb set entries = 0 so we load NO default rules */
+        if (ima_use_tcb)
+                entries = ARRAY_SIZE(default_rules);
+        else
+                entries = 0;
 
-        for (i = 0; i < ARRAY_SIZE(default_rules); i++)
+        for (i = 0; i < entries; i++)
                 list_add_tail(&default_rules[i].list, &measure_default_rules);
         ima_measure = &measure_default_rules;
 }
@@ -227,7 +247,7 @@ static int ima_lsm_rule_init(struct ima_measure_rule_entry *entry,
 
         entry->lsm[lsm_rule].type = audit_type;
         result = security_filter_rule_init(entry->lsm[lsm_rule].type,
-                                           AUDIT_EQUAL, args,
+                                           Audit_equal, args,
                                            &entry->lsm[lsm_rule].rule);
         return result;
 }
diff --git a/security/lsm_audit.c b/security/lsm_audit.c
new file mode 100644
index 000000000000..94b868494b31
--- /dev/null
+++ b/security/lsm_audit.c
@@ -0,0 +1,386 @@
+/*
+ * common LSM auditing functions
+ *
+ * Based on code written for SELinux by :
+ *                      Stephen Smalley, <sds@epoch.ncsc.mil>
+ *                      James Morris <jmorris@redhat.com>
+ * Author : Etienne Basset, <etienne.basset@ensta.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2,
+ * as published by the Free Software Foundation.
+ */
+
+#include <linux/types.h>
+#include <linux/stddef.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/init.h>
+#include <net/sock.h>
+#include <linux/un.h>
+#include <net/af_unix.h>
+#include <linux/audit.h>
+#include <linux/ipv6.h>
+#include <linux/ip.h>
+#include <net/ip.h>
+#include <net/ipv6.h>
+#include <linux/tcp.h>
+#include <linux/udp.h>
+#include <linux/dccp.h>
+#include <linux/sctp.h>
+#include <linux/lsm_audit.h>
+
+/**
+ * ipv4_skb_to_auditdata : fill auditdata from skb
+ * @skb : the skb
+ * @ad : the audit data to fill
+ * @proto : the layer 4 protocol
+ *
+ * return  0 on success
+ */
+int ipv4_skb_to_auditdata(struct sk_buff *skb,
+                struct common_audit_data *ad, u8 *proto)
+{
+        int ret = 0;
+        struct iphdr *ih;
+
+        ih = ip_hdr(skb);
+        if (ih == NULL)
+                return -EINVAL;
+
+        ad->u.net.v4info.saddr = ih->saddr;
+        ad->u.net.v4info.daddr = ih->daddr;
+
+        if (proto)
+                *proto = ih->protocol;
+        /* non initial fragment */
+        if (ntohs(ih->frag_off) & IP_OFFSET)
+                return 0;
+
+        switch (ih->protocol) {
+        case IPPROTO_TCP: {
+                struct tcphdr *th = tcp_hdr(skb);
+                if (th == NULL)
+                        break;
+
+                ad->u.net.sport = th->source;
+                ad->u.net.dport = th->dest;
+                break;
+        }
+        case IPPROTO_UDP: {
+                struct udphdr *uh = udp_hdr(skb);
+                if (uh == NULL)
+                        break;
+
+                ad->u.net.sport = uh->source;
+                ad->u.net.dport = uh->dest;
+                break;
+        }
+        case IPPROTO_DCCP: {
+                struct dccp_hdr *dh = dccp_hdr(skb);
+                if (dh == NULL)
+                        break;
+
+                ad->u.net.sport = dh->dccph_sport;
+                ad->u.net.dport = dh->dccph_dport;
+                break;
+        }
+        case IPPROTO_SCTP: {
+                struct sctphdr *sh = sctp_hdr(skb);
+                if (sh == NULL)
+                        break;
+                ad->u.net.sport = sh->source;
+                ad->u.net.dport = sh->dest;
+                break;
+        }
+        default:
+                ret = -EINVAL;
+        }
+        return ret;
+}
+#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
+/**
+ * ipv6_skb_to_auditdata : fill auditdata from skb
+ * @skb : the skb
+ * @ad : the audit data to fill
+ * @proto : the layer 4 protocol
+ *
+ * return  0 on success
+ */
+int ipv6_skb_to_auditdata(struct sk_buff *skb,
+                struct common_audit_data *ad, u8 *proto)
+{
+        int offset, ret = 0;
+        struct ipv6hdr *ip6;
+        u8 nexthdr;
+
+        ip6 = ipv6_hdr(skb);
+        if (ip6 == NULL)
+                return -EINVAL;
+        ipv6_addr_copy(&ad->u.net.v6info.saddr, &ip6->saddr);
+        ipv6_addr_copy(&ad->u.net.v6info.daddr, &ip6->daddr);
+        ret = 0;
+        /* IPv6 can have several extension header before the Transport header
+         * skip them */
+        offset = skb_network_offset(skb);
+        offset += sizeof(*ip6);
+        nexthdr = ip6->nexthdr;
+        offset = ipv6_skip_exthdr(skb, offset, &nexthdr);
+        if (offset < 0)
+                return 0;
+        if (proto)
+                *proto = nexthdr;
+        switch (nexthdr) {
+        case IPPROTO_TCP: {
+                struct tcphdr _tcph, *th;
+
+                th = skb_header_pointer(skb, offset, sizeof(_tcph), &_tcph);
+                if (th == NULL)
+                        break;
+
+                ad->u.net.sport = th->source;
+                ad->u.net.dport = th->dest;
+                break;
+        }
+        case IPPROTO_UDP: {
+                struct udphdr _udph, *uh;
+
+                uh = skb_header_pointer(skb, offset, sizeof(_udph), &_udph);
+                if (uh == NULL)
+                        break;
+
+                ad->u.net.sport = uh->source;
+                ad->u.net.dport = uh->dest;
+                break;
+        }
+        case IPPROTO_DCCP: {
+                struct dccp_hdr _dccph, *dh;
+
+                dh = skb_header_pointer(skb, offset, sizeof(_dccph), &_dccph);
+                if (dh == NULL)
+                        break;
+
+                ad->u.net.sport = dh->dccph_sport;
+                ad->u.net.dport = dh->dccph_dport;
+                break;
+        }
+        case IPPROTO_SCTP: {
+                struct sctphdr _sctph, *sh;
+
+                sh = skb_header_pointer(skb, offset, sizeof(_sctph), &_sctph);
+                if (sh == NULL)
+                        break;
+                ad->u.net.sport = sh->source;
+                ad->u.net.dport = sh->dest;
+                break;
+        }
+        default:
+                ret = -EINVAL;
+        }
+        return ret;
+}
+#endif
+
+
+static inline void print_ipv6_addr(struct audit_buffer *ab,
+                                   struct in6_addr *addr, __be16 port,
+                                   char *name1, char *name2)
+{
+        if (!ipv6_addr_any(addr))
+                audit_log_format(ab, " %s=%pI6", name1, addr);
+        if (port)
+                audit_log_format(ab, " %s=%d", name2, ntohs(port));
+}
+
+static inline void print_ipv4_addr(struct audit_buffer *ab, __be32 addr,
+                                   __be16 port, char *name1, char *name2)
+{
+        if (addr)
+                audit_log_format(ab, " %s=%pI4", name1, &addr);
+        if (port)
+                audit_log_format(ab, " %s=%d", name2, ntohs(port));
+}
+
+/**
+ * dump_common_audit_data - helper to dump common audit data
+ * @a : common audit data
+ *
+ */
+static void dump_common_audit_data(struct audit_buffer *ab,
+                                   struct common_audit_data *a)
+{
+        struct inode *inode = NULL;
+        struct task_struct *tsk = current;
+
+        if (a->tsk)
+                tsk = a->tsk;
+        if (tsk && tsk->pid) {
+                audit_log_format(ab, " pid=%d comm=", tsk->pid);
+                audit_log_untrustedstring(ab, tsk->comm);
+        }
+
+        switch (a->type) {
+        case LSM_AUDIT_DATA_IPC:
+                audit_log_format(ab, " key=%d ", a->u.ipc_id);
+                break;
+        case LSM_AUDIT_DATA_CAP:
+                audit_log_format(ab, " capability=%d ", a->u.cap);
+                break;
+        case LSM_AUDIT_DATA_FS:
+                if (a->u.fs.path.dentry) {
+                        struct dentry *dentry = a->u.fs.path.dentry;
+                        if (a->u.fs.path.mnt) {
+                                audit_log_d_path(ab, "path=", &a->u.fs.path);
+                        } else {
+                                audit_log_format(ab, " name=");
+                                audit_log_untrustedstring(ab,
+                                                 dentry->d_name.name);
+                        }
+                        inode = dentry->d_inode;
+                } else if (a->u.fs.inode) {
+                        struct dentry *dentry;
+                        inode = a->u.fs.inode;
+                        dentry = d_find_alias(inode);
+                        if (dentry) {
+                                audit_log_format(ab, " name=");
+                                audit_log_untrustedstring(ab,
+                                                 dentry->d_name.name);
+                                dput(dentry);
+                        }
+                }
+                if (inode)
+                        audit_log_format(ab, " dev=%s ino=%lu",
+                                        inode->i_sb->s_id,
+                                        inode->i_ino);
+                break;
+        case LSM_AUDIT_DATA_TASK:
+                tsk = a->u.tsk;
+                if (tsk && tsk->pid) {
+                        audit_log_format(ab, " pid=%d comm=", tsk->pid);
+                        audit_log_untrustedstring(ab, tsk->comm);
+                }
+                break;
+        case LSM_AUDIT_DATA_NET:
+                if (a->u.net.sk) {
+                        struct sock *sk = a->u.net.sk;
+                        struct unix_sock *u;
+                        int len = 0;
+                        char *p = NULL;
+
+                        switch (sk->sk_family) {
+                        case AF_INET: {
+                                struct inet_sock *inet = inet_sk(sk);
+
+                                print_ipv4_addr(ab, inet->rcv_saddr,
+                                                inet->sport,
+                                                "laddr", "lport");
+                                print_ipv4_addr(ab, inet->daddr,
+                                                inet->dport,
+                                                "faddr", "fport");
+                                break;
+                        }
+                        case AF_INET6: {
+                                struct inet_sock *inet = inet_sk(sk);
+                                struct ipv6_pinfo *inet6 = inet6_sk(sk);
+
+                                print_ipv6_addr(ab, &inet6->rcv_saddr,
+                                                inet->sport,
+                                                "laddr", "lport");
+                                print_ipv6_addr(ab, &inet6->daddr,
+                                                inet->dport,
+                                                "faddr", "fport");
+                                break;
+                        }
+                        case AF_UNIX:
+                                u = unix_sk(sk);
+                                if (u->dentry) {
+                                        struct path path = {
+                                                .dentry = u->dentry,
+                                                .mnt = u->mnt
+                                        };
+                                        audit_log_d_path(ab, "path=", &path);
+                                        break;
+                                }
+                                if (!u->addr)
+                                        break;
+                                len = u->addr->len-sizeof(short);
+                                p = &u->addr->name->sun_path[0];
+                                audit_log_format(ab, " path=");
+                                if (*p)
+                                        audit_log_untrustedstring(ab, p);
+                                else
+                                        audit_log_n_hex(ab, p, len);
+                                break;
+                        }
+                }
+
+                switch (a->u.net.family) {
+                case AF_INET:
+                        print_ipv4_addr(ab, a->u.net.v4info.saddr,
+                                        a->u.net.sport,
+                                        "saddr", "src");
+                        print_ipv4_addr(ab, a->u.net.v4info.daddr,
+                                        a->u.net.dport,
+                                        "daddr", "dest");
+                        break;
+                case AF_INET6:
+                        print_ipv6_addr(ab, &a->u.net.v6info.saddr,
+                                        a->u.net.sport,
+                                        "saddr", "src");
+                        print_ipv6_addr(ab, &a->u.net.v6info.daddr,
+                                        a->u.net.dport,
+                                        "daddr", "dest");
+                        break;
+                }
+                if (a->u.net.netif > 0) {
+                        struct net_device *dev;
+
+                        /* NOTE: we always use init's namespace */
+                        dev = dev_get_by_index(&init_net, a->u.net.netif);
+                        if (dev) {
+                                audit_log_format(ab, " netif=%s", dev->name);
+                                dev_put(dev);
+                        }
+                }
+                break;
+#ifdef CONFIG_KEYS
+        case LSM_AUDIT_DATA_KEY:
+                audit_log_format(ab, " key_serial=%u", a->u.key_struct.key);
+                if (a->u.key_struct.key_desc) {
+                        audit_log_format(ab, " key_desc=");
+                        audit_log_untrustedstring(ab, a->u.key_struct.key_desc);
+                }
+                break;
+#endif
+        } /* switch (a->type) */
+}
+
+/**
+ * common_lsm_audit - generic LSM auditing function
+ * @a:  auxiliary audit data
+ *
+ * setup the audit buffer for common security information
+ * uses callback to print LSM specific information
+ */
+void common_lsm_audit(struct common_audit_data *a)
+{
+        struct audit_buffer *ab;
+
+        if (a == NULL)
+                return;
+        /* we use GFP_ATOMIC so we won't sleep */
+        ab = audit_log_start(current->audit_context, GFP_ATOMIC, AUDIT_AVC);
+
+        if (ab == NULL)
+                return;
+
+        if (a->lsm_pre_audit)
+                a->lsm_pre_audit(ab, a);
+
+        dump_common_audit_data(ab, a);
+
+        if (a->lsm_post_audit)
+                a->lsm_post_audit(ab, a);
+
+        audit_log_end(ab);
+}
diff --git a/security/root_plug.c b/security/root_plug.c
index 40fb4f15e27b..2f7ffa67c4d2 100644
--- a/security/root_plug.c
+++ b/security/root_plug.c
@@ -71,18 +71,6 @@ static int rootplug_bprm_check_security (struct linux_binprm *bprm)
 }
 
 static struct security_operations rootplug_security_ops = {
-        /* Use the capability functions for some of the hooks */
-        .ptrace_may_access =            cap_ptrace_may_access,
-        .ptrace_traceme =               cap_ptrace_traceme,
-        .capget =                       cap_capget,
-        .capset =                       cap_capset,
-        .capable =                      cap_capable,
-
-        .bprm_set_creds =               cap_bprm_set_creds,
-
-        .task_fix_setuid =              cap_task_fix_setuid,
-        .task_prctl =                   cap_task_prctl,
-
         .bprm_check_security =          rootplug_bprm_check_security,
 };
 
diff --git a/security/security.c b/security/security.c
index 5284255c5cdf..dc7674fbfc7a 100644
--- a/security/security.c
+++ b/security/security.c
@@ -26,9 +26,6 @@ extern void security_fixup_ops(struct security_operations *ops);
 
 struct security_operations *security_ops;       /* Initialized to NULL */
 
-/* amount of vm to protect from userspace access */
-unsigned long mmap_min_addr = CONFIG_SECURITY_DEFAULT_MMAP_MIN_ADDR;
-
 static inline int verify(struct security_operations *ops)
 {
         /* verify the security_operations structure exists */
diff --git a/security/selinux/avc.c b/security/selinux/avc.c
index 7f9b5fac8779..b2ab60859832 100644
--- a/security/selinux/avc.c
+++ b/security/selinux/avc.c
@@ -927,7 +927,7 @@ int avc_has_perm_noaudit(u32 ssid, u32 tsid,
         if (denied) {
                 if (flags & AVC_STRICT)
                         rc = -EACCES;
-                else if (!selinux_enforcing || security_permissive_sid(ssid))
+                else if (!selinux_enforcing || (avd->flags & AVD_FLAGS_PERMISSIVE))
                         avc_update_node(AVC_CALLBACK_GRANT, requested, ssid,
                                         tsid, tclass, avd->seqno);
                 else
diff --git a/security/selinux/hooks.c b/security/selinux/hooks.c
index 2fcad7c33eaf..195906bce266 100644
--- a/security/selinux/hooks.c
+++ b/security/selinux/hooks.c
@@ -1980,10 +1980,6 @@ static int selinux_sysctl(ctl_table *table, int op)
         u32 tsid, sid;
         int rc;
 
-        rc = secondary_ops->sysctl(table, op);
-        if (rc)
-                return rc;
-
         sid = current_sid();
 
         rc = selinux_sysctl_get_sid(table, (op == 0001) ?
@@ -2375,10 +2371,8 @@ static void selinux_bprm_committed_creds(struct linux_binprm *bprm)
 {
         const struct task_security_struct *tsec = current_security();
         struct itimerval itimer;
-        struct sighand_struct *psig;
         u32 osid, sid;
         int rc, i;
-        unsigned long flags;
 
         osid = tsec->osid;
         sid = tsec->sid;
@@ -2398,22 +2392,20 @@ static void selinux_bprm_committed_creds(struct linux_binprm *bprm)
                 memset(&itimer, 0, sizeof itimer);
                 for (i = 0; i < 3; i++)
                         do_setitimer(i, &itimer, NULL);
-                flush_signals(current);
                 spin_lock_irq(&current->sighand->siglock);
-                flush_signal_handlers(current, 1);
-                sigemptyset(&current->blocked);
-                recalc_sigpending();
+                if (!(current->signal->flags & SIGNAL_GROUP_EXIT)) {
+                        __flush_signals(current);
+                        flush_signal_handlers(current, 1);
+                        sigemptyset(&current->blocked);
+                }
                 spin_unlock_irq(&current->sighand->siglock);
         }
 
         /* Wake up the parent if it is waiting so that it can recheck
          * wait permission to the new task SID. */
-        read_lock_irq(&tasklist_lock);
-        psig = current->parent->sighand;
-        spin_lock_irqsave(&psig->siglock, flags);
-        wake_up_interruptible(&current->parent->signal->wait_chldexit);
-        spin_unlock_irqrestore(&psig->siglock, flags);
-        read_unlock_irq(&tasklist_lock);
+        read_lock(&tasklist_lock);
+        wake_up_interruptible(&current->real_parent->signal->wait_chldexit);
+        read_unlock(&tasklist_lock);
 }
 
 /* superblock security operations */
diff --git a/security/selinux/include/security.h b/security/selinux/include/security.h
index 5c3434f7626f..ca835795a8b3 100644
--- a/security/selinux/include/security.h
+++ b/security/selinux/include/security.h
@@ -8,14 +8,13 @@
 #ifndef _SELINUX_SECURITY_H_
 #define _SELINUX_SECURITY_H_
 
+#include <linux/magic.h>
 #include "flask.h"
 
 #define SECSID_NULL                     0x00000000 /* unspecified SID */
 #define SECSID_WILD                     0xffffffff /* wildcard SID */
 #define SECCLASS_NULL                   0x0000 /* no class */
 
-#define SELINUX_MAGIC 0xf97cff8c
-
 /* Identify specific policy version changes */
 #define POLICYDB_VERSION_BASE           15
 #define POLICYDB_VERSION_BOOL           16
@@ -91,9 +90,11 @@ struct av_decision {
         u32 auditallow;
         u32 auditdeny;
         u32 seqno;
+        u32 flags;
 };
 
-int security_permissive_sid(u32 sid);
+/* definitions of av_decision.flags */
+#define AVD_FLAGS_PERMISSIVE    0x0001
 
 int security_compute_av(u32 ssid, u32 tsid,
         u16 tclass, u32 requested,
diff --git a/security/selinux/nlmsgtab.c b/security/selinux/nlmsgtab.c
index c6875fd3b9d6..dd7cc6de77f9 100644
--- a/security/selinux/nlmsgtab.c
+++ b/security/selinux/nlmsgtab.c
@@ -112,6 +112,8 @@ static struct nlmsg_perm nlmsg_audit_perms[] =
         { AUDIT_DEL_RULE,       NETLINK_AUDIT_SOCKET__NLMSG_WRITE    },
         { AUDIT_USER,           NETLINK_AUDIT_SOCKET__NLMSG_RELAY    },
         { AUDIT_SIGNAL_INFO,    NETLINK_AUDIT_SOCKET__NLMSG_READ     },
+        { AUDIT_TRIM,           NETLINK_AUDIT_SOCKET__NLMSG_WRITE    },
+        { AUDIT_MAKE_EQUIV,     NETLINK_AUDIT_SOCKET__NLMSG_WRITE    },
         { AUDIT_TTY_GET,        NETLINK_AUDIT_SOCKET__NLMSG_READ     },
         { AUDIT_TTY_SET,        NETLINK_AUDIT_SOCKET__NLMSG_TTY_AUDIT   },
 };
diff --git a/security/selinux/selinuxfs.c b/security/selinux/selinuxfs.c
index 2d5136ec3d54..b4fc506e7a87 100644
--- a/security/selinux/selinuxfs.c
+++ b/security/selinux/selinuxfs.c
@@ -527,10 +527,10 @@ static ssize_t sel_write_access(struct file *file, char *buf, size_t size)
                 goto out2;
 
         length = scnprintf(buf, SIMPLE_TRANSACTION_LIMIT,
-                          "%x %x %x %x %u",
+                          "%x %x %x %x %u %x",
                           avd.allowed, 0xffffffff,
                           avd.auditallow, avd.auditdeny,
-                          avd.seqno);
+                          avd.seqno, avd.flags);
 out2:
         kfree(tcon);
 out:
@@ -803,10 +803,6 @@ static ssize_t sel_read_bool(struct file *filep, char __user *buf,
                 goto out;
         }
 
-        if (count > PAGE_SIZE) {
-                ret = -EINVAL;
-                goto out;
-        }
         page = (char *)get_zeroed_page(GFP_KERNEL);
         if (!page) {
                 ret = -ENOMEM;
diff --git a/security/selinux/ss/services.c b/security/selinux/ss/services.c
index deeec6c013ae..500e6f78e115 100644
--- a/security/selinux/ss/services.c
+++ b/security/selinux/ss/services.c
@@ -410,6 +410,7 @@ static int context_struct_compute_av(struct context *scontext,
         avd->auditallow = 0;
         avd->auditdeny = 0xffffffff;
         avd->seqno = latest_granting;
+        avd->flags = 0;
 
         /*
          * Check for all the invalid cases.
@@ -528,31 +529,6 @@ inval_class:
         return 0;
 }
 
-/*
- * Given a sid find if the type has the permissive flag set
- */
-int security_permissive_sid(u32 sid)
-{
-        struct context *context;
-        u32 type;
-        int rc;
-
-        read_lock(&policy_rwlock);
-
-        context = sidtab_search(&sidtab, sid);
-        BUG_ON(!context);
-
-        type = context->type;
-        /*
-         * we are intentionally using type here, not type-1, the 0th bit may
-         * someday indicate that we are globally setting permissive in policy.
-         */
-        rc = ebitmap_get_bit(&policydb.permissive_map, type);
-
-        read_unlock(&policy_rwlock);
-        return rc;
-}
-
 static int security_validtrans_handle_fail(struct context *ocontext,
                                            struct context *ncontext,
                                            struct context *tcontext,
@@ -767,6 +743,10 @@ int security_compute_av(u32 ssid,
 
         rc = context_struct_compute_av(scontext, tcontext, tclass,
                                        requested, avd);
+
+        /* permissive domain? */
+        if (ebitmap_get_bit(&policydb.permissive_map, scontext->type))
+            avd->flags |= AVD_FLAGS_PERMISSIVE;
 out:
         read_unlock(&policy_rwlock);
         return rc;
diff --git a/security/smack/smack.h b/security/smack/smack.h
index 42ef313f9856..243bec175be0 100644
--- a/security/smack/smack.h
+++ b/security/smack/smack.h
@@ -20,6 +20,7 @@
 #include <net/netlabel.h>
 #include <linux/list.h>
 #include <linux/rculist.h>
+#include <linux/lsm_audit.h>
 
 /*
  * Why 23? CIPSO is constrained to 30, so a 32 byte buffer is
@@ -179,6 +180,20 @@ struct smack_known {
 #define MAY_NOT         0
 
 /*
+ * Number of access types used by Smack (rwxa)
+ */
+#define SMK_NUM_ACCESS_TYPE 4
+
+/*
+ * Smack audit data; is empty if CONFIG_AUDIT not set
+ * to save some stack
+ */
+struct smk_audit_info {
+#ifdef CONFIG_AUDIT
+        struct common_audit_data a;
+#endif
+};
+/*
  * These functions are in smack_lsm.c
  */
 struct inode_smack *new_inode_smack(char *);
@@ -186,8 +201,8 @@ struct inode_smack *new_inode_smack(char *);
 /*
  * These functions are in smack_access.c
  */
-int smk_access(char *, char *, int);
-int smk_curacc(char *, u32);
+int smk_access(char *, char *, int, struct smk_audit_info *);
+int smk_curacc(char *, u32, struct smk_audit_info *);
 int smack_to_cipso(const char *, struct smack_cipso *);
 void smack_from_cipso(u32, char *, char *);
 char *smack_from_secid(const u32);
@@ -237,4 +252,93 @@ static inline char *smk_of_inode(const struct inode *isp)
         return sip->smk_inode;
 }
 
+/*
+ * logging functions
+ */
+#define SMACK_AUDIT_DENIED 0x1
+#define SMACK_AUDIT_ACCEPT 0x2
+extern int log_policy;
+
+void smack_log(char *subject_label, char *object_label,
+                int request,
+                int result, struct smk_audit_info *auditdata);
+
+#ifdef CONFIG_AUDIT
+
+/*
+ * some inline functions to set up audit data
+ * they do nothing if CONFIG_AUDIT is not set
+ *
+ */
+static inline void smk_ad_init(struct smk_audit_info *a, const char *func,
+                               char type)
+{
+        memset(a, 0, sizeof(*a));
+        a->a.type = type;
+        a->a.function = func;
+}
+
+static inline void smk_ad_setfield_u_tsk(struct smk_audit_info *a,
+                                         struct task_struct *t)
+{
+        a->a.u.tsk = t;
+}
+static inline void smk_ad_setfield_u_fs_path_dentry(struct smk_audit_info *a,
+                                                    struct dentry *d)
+{
+        a->a.u.fs.path.dentry = d;
+}
+static inline void smk_ad_setfield_u_fs_path_mnt(struct smk_audit_info *a,
+                                                 struct vfsmount *m)
+{
+        a->a.u.fs.path.mnt = m;
+}
+static inline void smk_ad_setfield_u_fs_inode(struct smk_audit_info *a,
+                                              struct inode *i)
+{
+        a->a.u.fs.inode = i;
+}
+static inline void smk_ad_setfield_u_fs_path(struct smk_audit_info *a,
+                                             struct path p)
+{
+        a->a.u.fs.path = p;
+}
+static inline void smk_ad_setfield_u_net_sk(struct smk_audit_info *a,
+                                            struct sock *sk)
+{
+        a->a.u.net.sk = sk;
+}
+
+#else /* no AUDIT */
+
+static inline void smk_ad_init(struct smk_audit_info *a, const char *func,
+                               char type)
+{
+}
+static inline void smk_ad_setfield_u_tsk(struct smk_audit_info *a,
+                                         struct task_struct *t)
+{
+}
+static inline void smk_ad_setfield_u_fs_path_dentry(struct smk_audit_info *a,
+                                                    struct dentry *d)
+{
+}
+static inline void smk_ad_setfield_u_fs_path_mnt(struct smk_audit_info *a,
+                                                 struct vfsmount *m)
+{
+}
+static inline void smk_ad_setfield_u_fs_inode(struct smk_audit_info *a,
+                                              struct inode *i)
+{
+}
+static inline void smk_ad_setfield_u_fs_path(struct smk_audit_info *a,
+                                             struct path p)
+{
+}
+static inline void smk_ad_setfield_u_net_sk(struct smk_audit_info *a,
+                                            struct sock *sk)
+{
+}
+#endif
+
 #endif  /* _SECURITY_SMACK_H */
diff --git a/security/smack/smack_access.c b/security/smack/smack_access.c
index ac0a2707f6d4..513dc1aa16dd 100644
--- a/security/smack/smack_access.c
+++ b/security/smack/smack_access.c
@@ -59,11 +59,18 @@ LIST_HEAD(smack_known_list);
  */
 static u32 smack_next_secid = 10;
 
+/*
+ * what events do we log
+ * can be overwritten at run-time by /smack/logging
+ */
+int log_policy = SMACK_AUDIT_DENIED;
+
 /**
  * smk_access - determine if a subject has a specific access to an object
  * @subject_label: a pointer to the subject's Smack label
  * @object_label: a pointer to the object's Smack label
  * @request: the access requested, in "MAY" format
+ * @a : a pointer to the audit data
  *
  * This function looks up the subject/object pair in the
  * access rule list and returns 0 if the access is permitted,
@@ -78,10 +85,12 @@ static u32 smack_next_secid = 10;
  * will be on the list, so checking the pointers may be a worthwhile
  * optimization.
  */
-int smk_access(char *subject_label, char *object_label, int request)
+int smk_access(char *subject_label, char *object_label, int request,
+               struct smk_audit_info *a)
 {
         u32 may = MAY_NOT;
         struct smack_rule *srp;
+        int rc = 0;
 
         /*
          * Hardcoded comparisons.
@@ -89,8 +98,10 @@ int smk_access(char *subject_label, char *object_label, int request)
          * A star subject can't access any object.
          */
         if (subject_label == smack_known_star.smk_known ||
-            strcmp(subject_label, smack_known_star.smk_known) == 0)
-                return -EACCES;
+            strcmp(subject_label, smack_known_star.smk_known) == 0) {
+                rc = -EACCES;
+                goto out_audit;
+        }
         /*
          * An internet object can be accessed by any subject.
          * Tasks cannot be assigned the internet label.
@@ -100,20 +111,20 @@ int smk_access(char *subject_label, char *object_label, int request)
             subject_label == smack_known_web.smk_known ||
             strcmp(object_label, smack_known_web.smk_known) == 0 ||
             strcmp(subject_label, smack_known_web.smk_known) == 0)
-                return 0;
+                goto out_audit;
         /*
          * A star object can be accessed by any subject.
          */
         if (object_label == smack_known_star.smk_known ||
             strcmp(object_label, smack_known_star.smk_known) == 0)
-                return 0;
+                goto out_audit;
         /*
          * An object can be accessed in any way by a subject
          * with the same label.
          */
         if (subject_label == object_label ||
             strcmp(subject_label, object_label) == 0)
-                return 0;
+                goto out_audit;
         /*
          * A hat subject can read any object.
          * A floor object can be read by any subject.
@@ -121,10 +132,10 @@ int smk_access(char *subject_label, char *object_label, int request)
         if ((request & MAY_ANYREAD) == request) {
                 if (object_label == smack_known_floor.smk_known ||
                     strcmp(object_label, smack_known_floor.smk_known) == 0)
-                        return 0;
+                        goto out_audit;
                 if (subject_label == smack_known_hat.smk_known ||
                     strcmp(subject_label, smack_known_hat.smk_known) == 0)
-                        return 0;
+                        goto out_audit;
         }
         /*
          * Beyond here an explicit relationship is required.
@@ -148,28 +159,36 @@ int smk_access(char *subject_label, char *object_label, int request)
          * This is a bit map operation.
          */
         if ((request & may) == request)
-                return 0;
-
-        return -EACCES;
+                goto out_audit;
+
+        rc = -EACCES;
+out_audit:
+#ifdef CONFIG_AUDIT
+        if (a)
+                smack_log(subject_label, object_label, request, rc, a);
+#endif
+        return rc;
 }
 
 /**
  * smk_curacc - determine if current has a specific access to an object
  * @obj_label: a pointer to the object's Smack label
  * @mode: the access requested, in "MAY" format
+ * @a : common audit data
  *
  * This function checks the current subject label/object label pair
  * in the access rule list and returns 0 if the access is permitted,
  * non zero otherwise. It allows that current may have the capability
  * to override the rules.
  */
-int smk_curacc(char *obj_label, u32 mode)
+int smk_curacc(char *obj_label, u32 mode, struct smk_audit_info *a)
 {
         int rc;
+        char *sp = current_security();
 
-        rc = smk_access(current_security(), obj_label, mode);
+        rc = smk_access(sp, obj_label, mode, NULL);
         if (rc == 0)
-                return 0;
+                goto out_audit;
 
         /*
          * Return if a specific label has been designated as the
@@ -177,14 +196,105 @@ int smk_curacc(char *obj_label, u32 mode)
          * have that label.
          */
         if (smack_onlycap != NULL && smack_onlycap != current->cred->security)
-                return rc;
+                goto out_audit;
 
         if (capable(CAP_MAC_OVERRIDE))
                 return 0;
 
+out_audit:
+#ifdef CONFIG_AUDIT
+        if (a)
+                smack_log(sp, obj_label, mode, rc, a);
+#endif
         return rc;
 }
 
+#ifdef CONFIG_AUDIT
+/**
+ * smack_str_from_perm : helper to transalate an int to a
+ * readable string
+ * @string : the string to fill
+ * @access : the int
+ *
+ */
+static inline void smack_str_from_perm(char *string, int access)
+{
+        int i = 0;
+        if (access & MAY_READ)
+                string[i++] = 'r';
+        if (access & MAY_WRITE)
+                string[i++] = 'w';
+        if (access & MAY_EXEC)
+                string[i++] = 'x';
+        if (access & MAY_APPEND)
+                string[i++] = 'a';
+        string[i] = '\0';
+}
+/**
+ * smack_log_callback - SMACK specific information
+ * will be called by generic audit code
+ * @ab : the audit_buffer
+ * @a  : audit_data
+ *
+ */
+static void smack_log_callback(struct audit_buffer *ab, void *a)
+{
+        struct common_audit_data *ad = a;
+        struct smack_audit_data *sad = &ad->lsm_priv.smack_audit_data;
+        audit_log_format(ab, "lsm=SMACK fn=%s action=%s", ad->function,
+                         sad->result ? "denied" : "granted");
+        audit_log_format(ab, " subject=");
+        audit_log_untrustedstring(ab, sad->subject);
+        audit_log_format(ab, " object=");
+        audit_log_untrustedstring(ab, sad->object);
+        audit_log_format(ab, " requested=%s", sad->request);
+}
+
+/**
+ *  smack_log - Audit the granting or denial of permissions.
+ *  @subject_label : smack label of the requester
+ *  @object_label  : smack label of the object being accessed
+ *  @request: requested permissions
+ *  @result: result from smk_access
+ *  @a:  auxiliary audit data
+ *
+ * Audit the granting or denial of permissions in accordance
+ * with the policy.
+ */
+void smack_log(char *subject_label, char *object_label, int request,
+               int result, struct smk_audit_info *ad)
+{
+        char request_buffer[SMK_NUM_ACCESS_TYPE + 1];
+        struct smack_audit_data *sad;
+        struct common_audit_data *a = &ad->a;
+
+        /* check if we have to log the current event */
+        if (result != 0 && (log_policy & SMACK_AUDIT_DENIED) == 0)
+                return;
+        if (result == 0 && (log_policy & SMACK_AUDIT_ACCEPT) == 0)
+                return;
+
+        if (a->function == NULL)
+                a->function = "unknown";
+
+        /* end preparing the audit data */
+        sad = &a->lsm_priv.smack_audit_data;
+        smack_str_from_perm(request_buffer, request);
+        sad->subject = subject_label;
+        sad->object  = object_label;
+        sad->request = request_buffer;
+        sad->result  = result;
+        a->lsm_pre_audit = smack_log_callback;
+
+        common_lsm_audit(a);
+}
+#else /* #ifdef CONFIG_AUDIT */
+void smack_log(char *subject_label, char *object_label, int request,
+               int result, struct smk_audit_info *ad)
+{
+}
+#endif
+
 static DEFINE_MUTEX(smack_known_lock);
 
 /**
@@ -209,7 +319,8 @@ struct smack_known *smk_import_entry(const char *string, int len)
                 if (found)
                         smack[i] = '\0';
                 else if (i >= len || string[i] > '~' || string[i] <= ' ' ||
-                         string[i] == '/') {
+                         string[i] == '/' || string[i] == '"' ||
+                         string[i] == '\\' || string[i] == '\'') {
                         smack[i] = '\0';
                         found = 1;
                 } else
diff --git a/security/smack/smack_lsm.c b/security/smack/smack_lsm.c
index 98b3195347ab..0023182078c7 100644
--- a/security/smack/smack_lsm.c
+++ b/security/smack/smack_lsm.c
@@ -30,7 +30,6 @@
 #include <net/netlabel.h>
 #include <net/cipso_ipv4.h>
 #include <linux/audit.h>
-
 #include "smack.h"
 
 #define task_security(task)     (task_cred_xxx((task), security))
@@ -103,14 +102,24 @@ struct inode_smack *new_inode_smack(char *smack)
 static int smack_ptrace_may_access(struct task_struct *ctp, unsigned int mode)
 {
         int rc;
+        struct smk_audit_info ad;
+        char *sp, *tsp;
 
         rc = cap_ptrace_may_access(ctp, mode);
         if (rc != 0)
                 return rc;
 
-        rc = smk_access(current_security(), task_security(ctp), MAY_READWRITE);
+        sp = current_security();
+        tsp = task_security(ctp);
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
+        smk_ad_setfield_u_tsk(&ad, ctp);
+
+        /* we won't log here, because rc can be overriden */
+        rc = smk_access(sp, tsp, MAY_READWRITE, NULL);
         if (rc != 0 && capable(CAP_MAC_OVERRIDE))
-                return 0;
+                rc = 0;
+
+        smack_log(sp, tsp, MAY_READWRITE, rc, &ad);
         return rc;
 }
 
@@ -125,14 +134,24 @@ static int smack_ptrace_may_access(struct task_struct *ctp, unsigned int mode)
 static int smack_ptrace_traceme(struct task_struct *ptp)
 {
         int rc;
+        struct smk_audit_info ad;
+        char *sp, *tsp;
 
         rc = cap_ptrace_traceme(ptp);
         if (rc != 0)
                 return rc;
 
-        rc = smk_access(task_security(ptp), current_security(), MAY_READWRITE);
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
+        smk_ad_setfield_u_tsk(&ad, ptp);
+
+        sp = current_security();
+        tsp = task_security(ptp);
+        /* we won't log here, because rc can be overriden */
+        rc = smk_access(tsp, sp, MAY_READWRITE, NULL);
         if (rc != 0 && has_capability(ptp, CAP_MAC_OVERRIDE))
-                return 0;
+                rc = 0;
+
+        smack_log(tsp, sp, MAY_READWRITE, rc, &ad);
         return rc;
 }
 
@@ -327,8 +346,14 @@ static int smack_sb_kern_mount(struct super_block *sb, int flags, void *data)
 static int smack_sb_statfs(struct dentry *dentry)
 {
         struct superblock_smack *sbp = dentry->d_sb->s_security;
+        int rc;
+        struct smk_audit_info ad;
+
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_FS);
+        smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
 
-        return smk_curacc(sbp->smk_floor, MAY_READ);
+        rc = smk_curacc(sbp->smk_floor, MAY_READ, &ad);
+        return rc;
 }
 
 /**
@@ -346,8 +371,12 @@ static int smack_sb_mount(char *dev_name, struct path *path,
                           char *type, unsigned long flags, void *data)
 {
         struct superblock_smack *sbp = path->mnt->mnt_sb->s_security;
+        struct smk_audit_info ad;
+
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_FS);
+        smk_ad_setfield_u_fs_path(&ad, *path);
 
-        return smk_curacc(sbp->smk_floor, MAY_WRITE);
+        return smk_curacc(sbp->smk_floor, MAY_WRITE, &ad);
 }
 
 /**
@@ -361,10 +390,14 @@ static int smack_sb_mount(char *dev_name, struct path *path,
 static int smack_sb_umount(struct vfsmount *mnt, int flags)
 {
         struct superblock_smack *sbp;
+        struct smk_audit_info ad;
 
-        sbp = mnt->mnt_sb->s_security;
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_FS);
+        smk_ad_setfield_u_fs_path_dentry(&ad, mnt->mnt_mountpoint);
+        smk_ad_setfield_u_fs_path_mnt(&ad, mnt);
 
-        return smk_curacc(sbp->smk_floor, MAY_WRITE);
+        sbp = mnt->mnt_sb->s_security;
+        return smk_curacc(sbp->smk_floor, MAY_WRITE, &ad);
 }
 
 /*
@@ -441,15 +474,20 @@ static int smack_inode_init_security(struct inode *inode, struct inode *dir,
 static int smack_inode_link(struct dentry *old_dentry, struct inode *dir,
                             struct dentry *new_dentry)
 {
-        int rc;
         char *isp;
+        struct smk_audit_info ad;
+        int rc;
+
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_FS);
+        smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry);
 
         isp = smk_of_inode(old_dentry->d_inode);
-        rc = smk_curacc(isp, MAY_WRITE);
+        rc = smk_curacc(isp, MAY_WRITE, &ad);
 
         if (rc == 0 && new_dentry->d_inode != NULL) {
                 isp = smk_of_inode(new_dentry->d_inode);
-                rc = smk_curacc(isp, MAY_WRITE);
+                smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry);
+                rc = smk_curacc(isp, MAY_WRITE, &ad);
         }
 
         return rc;
@@ -466,18 +504,24 @@ static int smack_inode_link(struct dentry *old_dentry, struct inode *dir,
 static int smack_inode_unlink(struct inode *dir, struct dentry *dentry)
 {
         struct inode *ip = dentry->d_inode;
+        struct smk_audit_info ad;
         int rc;
 
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_FS);
+        smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
+
         /*
          * You need write access to the thing you're unlinking
          */
-        rc = smk_curacc(smk_of_inode(ip), MAY_WRITE);
-        if (rc == 0)
+        rc = smk_curacc(smk_of_inode(ip), MAY_WRITE, &ad);
+        if (rc == 0) {
                 /*
                  * You also need write access to the containing directory
                  */
-                rc = smk_curacc(smk_of_inode(dir), MAY_WRITE);
-
+                smk_ad_setfield_u_fs_path_dentry(&ad, NULL);
+                smk_ad_setfield_u_fs_inode(&ad, dir);
+                rc = smk_curacc(smk_of_inode(dir), MAY_WRITE, &ad);
+        }
         return rc;
 }
 
@@ -491,17 +535,24 @@ static int smack_inode_unlink(struct inode *dir, struct dentry *dentry)
  */
 static int smack_inode_rmdir(struct inode *dir, struct dentry *dentry)
 {
+        struct smk_audit_info ad;
         int rc;
 
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_FS);
+        smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
+
         /*
          * You need write access to the thing you're removing
          */
-        rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE);
-        if (rc == 0)
+        rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
+        if (rc == 0) {
                 /*
                  * You also need write access to the containing directory
                  */
-                rc = smk_curacc(smk_of_inode(dir), MAY_WRITE);
+                smk_ad_setfield_u_fs_path_dentry(&ad, NULL);
+                smk_ad_setfield_u_fs_inode(&ad, dir);
+                rc = smk_curacc(smk_of_inode(dir), MAY_WRITE, &ad);
+        }
 
         return rc;
 }
@@ -525,15 +576,19 @@ static int smack_inode_rename(struct inode *old_inode,
 {
         int rc;
         char *isp;
+        struct smk_audit_info ad;
+
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_FS);
+        smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry);
 
         isp = smk_of_inode(old_dentry->d_inode);
-        rc = smk_curacc(isp, MAY_READWRITE);
+        rc = smk_curacc(isp, MAY_READWRITE, &ad);
 
         if (rc == 0 && new_dentry->d_inode != NULL) {
                 isp = smk_of_inode(new_dentry->d_inode);
-                rc = smk_curacc(isp, MAY_READWRITE);
+                smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry);
+                rc = smk_curacc(isp, MAY_READWRITE, &ad);
         }
-
         return rc;
 }
 
@@ -548,13 +603,15 @@ static int smack_inode_rename(struct inode *old_inode,
  */
 static int smack_inode_permission(struct inode *inode, int mask)
 {
+        struct smk_audit_info ad;
         /*
          * No permission to check. Existence test. Yup, it's there.
          */
         if (mask == 0)
                 return 0;
-
-        return smk_curacc(smk_of_inode(inode), mask);
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_FS);
+        smk_ad_setfield_u_fs_inode(&ad, inode);
+        return smk_curacc(smk_of_inode(inode), mask, &ad);
 }
 
 /**
@@ -566,13 +623,16 @@ static int smack_inode_permission(struct inode *inode, int mask)
  */
 static int smack_inode_setattr(struct dentry *dentry, struct iattr *iattr)
 {
+        struct smk_audit_info ad;
         /*
          * Need to allow for clearing the setuid bit.
          */
         if (iattr->ia_valid & ATTR_FORCE)
                 return 0;
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_FS);
+        smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
 
-        return smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE);
+        return smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
 }
 
 /**
@@ -584,7 +644,12 @@ static int smack_inode_setattr(struct dentry *dentry, struct iattr *iattr)
  */
 static int smack_inode_getattr(struct vfsmount *mnt, struct dentry *dentry)
 {
-        return smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ);
+        struct smk_audit_info ad;
+
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_FS);
+        smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
+        smk_ad_setfield_u_fs_path_mnt(&ad, mnt);
+        return smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ, &ad);
 }
 
 /**
@@ -602,6 +667,7 @@ static int smack_inode_getattr(struct vfsmount *mnt, struct dentry *dentry)
 static int smack_inode_setxattr(struct dentry *dentry, const char *name,
                                 const void *value, size_t size, int flags)
 {
+        struct smk_audit_info ad;
         int rc = 0;
 
         if (strcmp(name, XATTR_NAME_SMACK) == 0 ||
@@ -619,8 +685,11 @@ static int smack_inode_setxattr(struct dentry *dentry, const char *name,
         } else
                 rc = cap_inode_setxattr(dentry, name, value, size, flags);
 
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_FS);
+        smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
+
         if (rc == 0)
-                rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE);
+                rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
 
         return rc;
 }
@@ -672,7 +741,12 @@ static void smack_inode_post_setxattr(struct dentry *dentry, const char *name,
  */
 static int smack_inode_getxattr(struct dentry *dentry, const char *name)
 {
-        return smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ);
+        struct smk_audit_info ad;
+
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_FS);
+        smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
+
+        return smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ, &ad);
 }
 
 /*
@@ -686,6 +760,7 @@ static int smack_inode_getxattr(struct dentry *dentry, const char *name)
  */
 static int smack_inode_removexattr(struct dentry *dentry, const char *name)
 {
+        struct smk_audit_info ad;
         int rc = 0;
 
         if (strcmp(name, XATTR_NAME_SMACK) == 0 ||
@@ -696,8 +771,10 @@ static int smack_inode_removexattr(struct dentry *dentry, const char *name)
         } else
                 rc = cap_inode_removexattr(dentry, name);
 
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_FS);
+        smk_ad_setfield_u_fs_path_dentry(&ad, dentry);
         if (rc == 0)
-                rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE);
+                rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad);
 
         return rc;
 }
@@ -856,12 +933,16 @@ static int smack_file_ioctl(struct file *file, unsigned int cmd,
                             unsigned long arg)
 {
         int rc = 0;
+        struct smk_audit_info ad;
+
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_FS);
+        smk_ad_setfield_u_fs_path(&ad, file->f_path);
 
         if (_IOC_DIR(cmd) & _IOC_WRITE)
-                rc = smk_curacc(file->f_security, MAY_WRITE);
+                rc = smk_curacc(file->f_security, MAY_WRITE, &ad);
 
         if (rc == 0 && (_IOC_DIR(cmd) & _IOC_READ))
-                rc = smk_curacc(file->f_security, MAY_READ);
+                rc = smk_curacc(file->f_security, MAY_READ, &ad);
 
         return rc;
 }
@@ -875,7 +956,11 @@ static int smack_file_ioctl(struct file *file, unsigned int cmd,
  */
 static int smack_file_lock(struct file *file, unsigned int cmd)
 {
-        return smk_curacc(file->f_security, MAY_WRITE);
+        struct smk_audit_info ad;
+
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_FS);
+        smk_ad_setfield_u_fs_path_dentry(&ad, file->f_path.dentry);
+        return smk_curacc(file->f_security, MAY_WRITE, &ad);
 }
 
 /**
@@ -889,8 +974,12 @@ static int smack_file_lock(struct file *file, unsigned int cmd)
 static int smack_file_fcntl(struct file *file, unsigned int cmd,
                             unsigned long arg)
 {
+        struct smk_audit_info ad;
         int rc;
 
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_FS);
+        smk_ad_setfield_u_fs_path(&ad, file->f_path);
+
         switch (cmd) {
         case F_DUPFD:
         case F_GETFD:
@@ -898,7 +987,7 @@ static int smack_file_fcntl(struct file *file, unsigned int cmd,
         case F_GETLK:
         case F_GETOWN:
         case F_GETSIG:
-                rc = smk_curacc(file->f_security, MAY_READ);
+                rc = smk_curacc(file->f_security, MAY_READ, &ad);
                 break;
         case F_SETFD:
         case F_SETFL:
@@ -906,10 +995,10 @@ static int smack_file_fcntl(struct file *file, unsigned int cmd,
         case F_SETLKW:
         case F_SETOWN:
         case F_SETSIG:
-                rc = smk_curacc(file->f_security, MAY_WRITE);
+                rc = smk_curacc(file->f_security, MAY_WRITE, &ad);
                 break;
         default:
-                rc = smk_curacc(file->f_security, MAY_READWRITE);
+                rc = smk_curacc(file->f_security, MAY_READWRITE, &ad);
         }
 
         return rc;
@@ -944,14 +1033,21 @@ static int smack_file_send_sigiotask(struct task_struct *tsk,
 {
         struct file *file;
         int rc;
+        char *tsp = tsk->cred->security;
+        struct smk_audit_info ad;
 
         /*
          * struct fown_struct is never outside the context of a struct file
          */
         file = container_of(fown, struct file, f_owner);
-        rc = smk_access(file->f_security, tsk->cred->security, MAY_WRITE);
+        /* we don't log here as rc can be overriden */
+        rc = smk_access(file->f_security, tsp, MAY_WRITE, NULL);
         if (rc != 0 && has_capability(tsk, CAP_MAC_OVERRIDE))
-                return 0;
+                rc = 0;
+
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
+        smk_ad_setfield_u_tsk(&ad, tsk);
+        smack_log(file->f_security, tsp, MAY_WRITE, rc, &ad);
         return rc;
 }
 
@@ -964,7 +1060,10 @@ static int smack_file_send_sigiotask(struct task_struct *tsk,
 static int smack_file_receive(struct file *file)
 {
         int may = 0;
+        struct smk_audit_info ad;
 
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
+        smk_ad_setfield_u_fs_path(&ad, file->f_path);
         /*
          * This code relies on bitmasks.
          */
@@ -973,7 +1072,7 @@ static int smack_file_receive(struct file *file)
         if (file->f_mode & FMODE_WRITE)
                 may |= MAY_WRITE;
 
-        return smk_curacc(file->f_security, may);
+        return smk_curacc(file->f_security, may, &ad);
 }
 
 /*
@@ -1053,6 +1152,22 @@ static int smack_kernel_create_files_as(struct cred *new,
 }
 
 /**
+ * smk_curacc_on_task - helper to log task related access
+ * @p: the task object
+ * @access : the access requested
+ *
+ * Return 0 if access is permitted
+ */
+static int smk_curacc_on_task(struct task_struct *p, int access)
+{
+        struct smk_audit_info ad;
+
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
+        smk_ad_setfield_u_tsk(&ad, p);
+        return smk_curacc(task_security(p), access, &ad);
+}
+
+/**
  * smack_task_setpgid - Smack check on setting pgid
  * @p: the task object
  * @pgid: unused
@@ -1061,7 +1176,7 @@ static int smack_kernel_create_files_as(struct cred *new,
  */
 static int smack_task_setpgid(struct task_struct *p, pid_t pgid)
 {
-        return smk_curacc(task_security(p), MAY_WRITE);
+        return smk_curacc_on_task(p, MAY_WRITE);
 }
 
 /**
@@ -1072,7 +1187,7 @@ static int smack_task_setpgid(struct task_struct *p, pid_t pgid)
  */
 static int smack_task_getpgid(struct task_struct *p)
 {
-        return smk_curacc(task_security(p), MAY_READ);
+        return smk_curacc_on_task(p, MAY_READ);
 }
 
 /**
@@ -1083,7 +1198,7 @@ static int smack_task_getpgid(struct task_struct *p)
  */
 static int smack_task_getsid(struct task_struct *p)
 {
-        return smk_curacc(task_security(p), MAY_READ);
+        return smk_curacc_on_task(p, MAY_READ);
 }
 
 /**
@@ -1111,7 +1226,7 @@ static int smack_task_setnice(struct task_struct *p, int nice)
 
         rc = cap_task_setnice(p, nice);
         if (rc == 0)
-                rc = smk_curacc(task_security(p), MAY_WRITE);
+                rc = smk_curacc_on_task(p, MAY_WRITE);
         return rc;
 }
 
@@ -1128,7 +1243,7 @@ static int smack_task_setioprio(struct task_struct *p, int ioprio)
 
         rc = cap_task_setioprio(p, ioprio);
         if (rc == 0)
-                rc = smk_curacc(task_security(p), MAY_WRITE);
+                rc = smk_curacc_on_task(p, MAY_WRITE);
         return rc;
 }
 
@@ -1140,7 +1255,7 @@ static int smack_task_setioprio(struct task_struct *p, int ioprio)
  */
 static int smack_task_getioprio(struct task_struct *p)
 {
-        return smk_curacc(task_security(p), MAY_READ);
+        return smk_curacc_on_task(p, MAY_READ);
 }
 
 /**
@@ -1158,7 +1273,7 @@ static int smack_task_setscheduler(struct task_struct *p, int policy,
 
         rc = cap_task_setscheduler(p, policy, lp);
         if (rc == 0)
-                rc = smk_curacc(task_security(p), MAY_WRITE);
+                rc = smk_curacc_on_task(p, MAY_WRITE);
         return rc;
 }
 
@@ -1170,7 +1285,7 @@ static int smack_task_setscheduler(struct task_struct *p, int policy,
  */
 static int smack_task_getscheduler(struct task_struct *p)
 {
-        return smk_curacc(task_security(p), MAY_READ);
+        return smk_curacc_on_task(p, MAY_READ);
 }
 
 /**
@@ -1181,7 +1296,7 @@ static int smack_task_getscheduler(struct task_struct *p)
  */
 static int smack_task_movememory(struct task_struct *p)
 {
-        return smk_curacc(task_security(p), MAY_WRITE);
+        return smk_curacc_on_task(p, MAY_WRITE);
 }
 
 /**
@@ -1199,18 +1314,23 @@ static int smack_task_movememory(struct task_struct *p)
 static int smack_task_kill(struct task_struct *p, struct siginfo *info,
                            int sig, u32 secid)
 {
+        struct smk_audit_info ad;
+
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
+        smk_ad_setfield_u_tsk(&ad, p);
         /*
          * Sending a signal requires that the sender
          * can write the receiver.
          */
         if (secid == 0)
-                return smk_curacc(task_security(p), MAY_WRITE);
+                return smk_curacc(task_security(p), MAY_WRITE, &ad);
         /*
          * If the secid isn't 0 we're dealing with some USB IO
          * specific behavior. This is not clean. For one thing
          * we can't take privilege into account.
          */
-        return smk_access(smack_from_secid(secid), task_security(p), MAY_WRITE);
+        return smk_access(smack_from_secid(secid), task_security(p),
+                          MAY_WRITE, &ad);
 }
 
 /**
@@ -1221,11 +1341,15 @@ static int smack_task_kill(struct task_struct *p, struct siginfo *info,
  */
 static int smack_task_wait(struct task_struct *p)
 {
+        struct smk_audit_info ad;
+        char *sp = current_security();
+        char *tsp = task_security(p);
         int rc;
 
-        rc = smk_access(current_security(), task_security(p), MAY_WRITE);
+        /* we don't log here, we can be overriden */
+        rc = smk_access(sp, tsp, MAY_WRITE, NULL);
         if (rc == 0)
-                return 0;
+                goto out_log;
 
         /*
          * Allow the operation to succeed if either task
@@ -1239,8 +1363,12 @@ static int smack_task_wait(struct task_struct *p)
          * the smack value.
          */
         if (capable(CAP_MAC_OVERRIDE) || has_capability(p, CAP_MAC_OVERRIDE))
-                return 0;
-
+                rc = 0;
+        /* we log only if we didn't get overriden */
+ out_log:
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_TASK);
+        smk_ad_setfield_u_tsk(&ad, p);
+        smack_log(sp, tsp, MAY_WRITE, rc, &ad);
         return rc;
 }
 
@@ -1456,12 +1584,19 @@ static int smack_netlabel_send(struct sock *sk, struct sockaddr_in *sap)
         int sk_lbl;
         char *hostsp;
         struct socket_smack *ssp = sk->sk_security;
+        struct smk_audit_info ad;
 
         rcu_read_lock();
         hostsp = smack_host_label(sap);
         if (hostsp != NULL) {
                 sk_lbl = SMACK_UNLABELED_SOCKET;
-                rc = smk_access(ssp->smk_out, hostsp, MAY_WRITE);
+#ifdef CONFIG_AUDIT
+                smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_NET);
+                ad.a.u.net.family = sap->sin_family;
+                ad.a.u.net.dport = sap->sin_port;
+                ad.a.u.net.v4info.daddr = sap->sin_addr.s_addr;
+#endif
+                rc = smk_access(ssp->smk_out, hostsp, MAY_WRITE, &ad);
         } else {
                 sk_lbl = SMACK_CIPSO_SOCKET;
                 rc = 0;
@@ -1657,6 +1792,25 @@ static void smack_shm_free_security(struct shmid_kernel *shp)
 }
 
 /**
+ * smk_curacc_shm : check if current has access on shm
+ * @shp : the object
+ * @access : access requested
+ *
+ * Returns 0 if current has the requested access, error code otherwise
+ */
+static int smk_curacc_shm(struct shmid_kernel *shp, int access)
+{
+        char *ssp = smack_of_shm(shp);
+        struct smk_audit_info ad;
+
+#ifdef CONFIG_AUDIT
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
+        ad.a.u.ipc_id = shp->shm_perm.id;
+#endif
+        return smk_curacc(ssp, access, &ad);
+}
+
+/**
  * smack_shm_associate - Smack access check for shm
  * @shp: the object
  * @shmflg: access requested
@@ -1665,11 +1819,10 @@ static void smack_shm_free_security(struct shmid_kernel *shp)
  */
 static int smack_shm_associate(struct shmid_kernel *shp, int shmflg)
 {
-        char *ssp = smack_of_shm(shp);
         int may;
 
         may = smack_flags_to_may(shmflg);
-        return smk_curacc(ssp, may);
+        return smk_curacc_shm(shp, may);
 }
 
 /**
@@ -1681,7 +1834,6 @@ static int smack_shm_associate(struct shmid_kernel *shp, int shmflg)
  */
 static int smack_shm_shmctl(struct shmid_kernel *shp, int cmd)
 {
-        char *ssp;
         int may;
 
         switch (cmd) {
@@ -1704,9 +1856,7 @@ static int smack_shm_shmctl(struct shmid_kernel *shp, int cmd)
         default:
                 return -EINVAL;
         }
-
-        ssp = smack_of_shm(shp);
-        return smk_curacc(ssp, may);
+        return smk_curacc_shm(shp, may);
 }
 
 /**
@@ -1720,11 +1870,10 @@ static int smack_shm_shmctl(struct shmid_kernel *shp, int cmd)
 static int smack_shm_shmat(struct shmid_kernel *shp, char __user *shmaddr,
                            int shmflg)
 {
-        char *ssp = smack_of_shm(shp);
         int may;
 
         may = smack_flags_to_may(shmflg);
-        return smk_curacc(ssp, may);
+        return smk_curacc_shm(shp, may);
 }
 
 /**
@@ -1766,6 +1915,25 @@ static void smack_sem_free_security(struct sem_array *sma)
 }
 
 /**
+ * smk_curacc_sem : check if current has access on sem
+ * @sma : the object
+ * @access : access requested
+ *
+ * Returns 0 if current has the requested access, error code otherwise
+ */
+static int smk_curacc_sem(struct sem_array *sma, int access)
+{
+        char *ssp = smack_of_sem(sma);
+        struct smk_audit_info ad;
+
+#ifdef CONFIG_AUDIT
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
+        ad.a.u.ipc_id = sma->sem_perm.id;
+#endif
+        return smk_curacc(ssp, access, &ad);
+}
+
+/**
  * smack_sem_associate - Smack access check for sem
  * @sma: the object
  * @semflg: access requested
@@ -1774,11 +1942,10 @@ static void smack_sem_free_security(struct sem_array *sma)
  */
 static int smack_sem_associate(struct sem_array *sma, int semflg)
 {
-        char *ssp = smack_of_sem(sma);
         int may;
 
         may = smack_flags_to_may(semflg);
-        return smk_curacc(ssp, may);
+        return smk_curacc_sem(sma, may);
 }
 
 /**
@@ -1790,7 +1957,6 @@ static int smack_sem_associate(struct sem_array *sma, int semflg)
  */
 static int smack_sem_semctl(struct sem_array *sma, int cmd)
 {
-        char *ssp;
         int may;
 
         switch (cmd) {
@@ -1819,8 +1985,7 @@ static int smack_sem_semctl(struct sem_array *sma, int cmd)
                 return -EINVAL;
         }
 
-        ssp = smack_of_sem(sma);
-        return smk_curacc(ssp, may);
+        return smk_curacc_sem(sma, may);
 }
 
 /**
@@ -1837,9 +2002,7 @@ static int smack_sem_semctl(struct sem_array *sma, int cmd)
 static int smack_sem_semop(struct sem_array *sma, struct sembuf *sops,
                            unsigned nsops, int alter)
 {
-        char *ssp = smack_of_sem(sma);
-
-        return smk_curacc(ssp, MAY_READWRITE);
+        return smk_curacc_sem(sma, MAY_READWRITE);
 }
 
 /**
@@ -1881,6 +2044,25 @@ static char *smack_of_msq(struct msg_queue *msq)
 }
 
 /**
+ * smk_curacc_msq : helper to check if current has access on msq
+ * @msq : the msq
+ * @access : access requested
+ *
+ * return 0 if current has access, error otherwise
+ */
+static int smk_curacc_msq(struct msg_queue *msq, int access)
+{
+        char *msp = smack_of_msq(msq);
+        struct smk_audit_info ad;
+
+#ifdef CONFIG_AUDIT
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
+        ad.a.u.ipc_id = msq->q_perm.id;
+#endif
+        return smk_curacc(msp, access, &ad);
+}
+
+/**
  * smack_msg_queue_associate - Smack access check for msg_queue
  * @msq: the object
  * @msqflg: access requested
@@ -1889,11 +2071,10 @@ static char *smack_of_msq(struct msg_queue *msq)
  */
 static int smack_msg_queue_associate(struct msg_queue *msq, int msqflg)
 {
-        char *msp = smack_of_msq(msq);
         int may;
 
         may = smack_flags_to_may(msqflg);
-        return smk_curacc(msp, may);
+        return smk_curacc_msq(msq, may);
 }
 
 /**
@@ -1905,7 +2086,6 @@ static int smack_msg_queue_associate(struct msg_queue *msq, int msqflg)
  */
 static int smack_msg_queue_msgctl(struct msg_queue *msq, int cmd)
 {
-        char *msp;
         int may;
 
         switch (cmd) {
@@ -1927,8 +2107,7 @@ static int smack_msg_queue_msgctl(struct msg_queue *msq, int cmd)
                 return -EINVAL;
         }
 
-        msp = smack_of_msq(msq);
-        return smk_curacc(msp, may);
+        return smk_curacc_msq(msq, may);
 }
 
 /**
@@ -1942,11 +2121,10 @@ static int smack_msg_queue_msgctl(struct msg_queue *msq, int cmd)
 static int smack_msg_queue_msgsnd(struct msg_queue *msq, struct msg_msg *msg,
                                   int msqflg)
 {
-        char *msp = smack_of_msq(msq);
-        int rc;
+        int may;
 
-        rc = smack_flags_to_may(msqflg);
-        return smk_curacc(msp, rc);
+        may = smack_flags_to_may(msqflg);
+        return smk_curacc_msq(msq, may);
 }
 
 /**
@@ -1962,9 +2140,7 @@ static int smack_msg_queue_msgsnd(struct msg_queue *msq, struct msg_msg *msg,
 static int smack_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg,
                         struct task_struct *target, long type, int mode)
 {
-        char *msp = smack_of_msq(msq);
-
-        return smk_curacc(msp, MAY_READWRITE);
+        return smk_curacc_msq(msq, MAY_READWRITE);
 }
 
 /**
@@ -1977,10 +2153,14 @@ static int smack_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg,
 static int smack_ipc_permission(struct kern_ipc_perm *ipp, short flag)
 {
         char *isp = ipp->security;
-        int may;
+        int may = smack_flags_to_may(flag);
+        struct smk_audit_info ad;
 
-        may = smack_flags_to_may(flag);
-        return smk_curacc(isp, may);
+#ifdef CONFIG_AUDIT
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_IPC);
+        ad.a.u.ipc_id = ipp->id;
+#endif
+        return smk_curacc(isp, may, &ad);
 }
 
 /**
@@ -2239,8 +2419,12 @@ static int smack_unix_stream_connect(struct socket *sock,
 {
         struct inode *sp = SOCK_INODE(sock);
         struct inode *op = SOCK_INODE(other);
+        struct smk_audit_info ad;
 
-        return smk_access(smk_of_inode(sp), smk_of_inode(op), MAY_READWRITE);
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_NET);
+        smk_ad_setfield_u_net_sk(&ad, other->sk);
+        return smk_access(smk_of_inode(sp), smk_of_inode(op),
+                                 MAY_READWRITE, &ad);
 }
 
 /**
@@ -2255,8 +2439,11 @@ static int smack_unix_may_send(struct socket *sock, struct socket *other)
 {
         struct inode *sp = SOCK_INODE(sock);
         struct inode *op = SOCK_INODE(other);
+        struct smk_audit_info ad;
 
-        return smk_access(smk_of_inode(sp), smk_of_inode(op), MAY_WRITE);
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_NET);
+        smk_ad_setfield_u_net_sk(&ad, other->sk);
+        return smk_access(smk_of_inode(sp), smk_of_inode(op), MAY_WRITE, &ad);
 }
 
 /**
@@ -2371,7 +2558,7 @@ static int smack_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
         char smack[SMK_LABELLEN];
         char *csp;
         int rc;
-
+        struct smk_audit_info ad;
         if (sk->sk_family != PF_INET && sk->sk_family != PF_INET6)
                 return 0;
 
@@ -2389,13 +2576,19 @@ static int smack_socket_sock_rcv_skb(struct sock *sk, struct sk_buff *skb)
 
         netlbl_secattr_destroy(&secattr);
 
+#ifdef CONFIG_AUDIT
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_NET);
+        ad.a.u.net.family = sk->sk_family;
+        ad.a.u.net.netif = skb->iif;
+        ipv4_skb_to_auditdata(skb, &ad.a, NULL);
+#endif
         /*
          * Receiving a packet requires that the other end
          * be able to write here. Read access is not required.
          * This is the simplist possible security model
          * for networking.
          */
-        rc = smk_access(csp, ssp->smk_in, MAY_WRITE);
+        rc = smk_access(csp, ssp->smk_in, MAY_WRITE, &ad);
         if (rc != 0)
                 netlbl_skbuff_err(skb, rc, 0);
         return rc;
@@ -2524,6 +2717,7 @@ static int smack_inet_conn_request(struct sock *sk, struct sk_buff *skb,
         struct iphdr *hdr;
         char smack[SMK_LABELLEN];
         int rc;
+        struct smk_audit_info ad;
 
         /* handle mapped IPv4 packets arriving via IPv6 sockets */
         if (family == PF_INET6 && skb->protocol == htons(ETH_P_IP))
@@ -2537,11 +2731,17 @@ static int smack_inet_conn_request(struct sock *sk, struct sk_buff *skb,
                 strncpy(smack, smack_known_huh.smk_known, SMK_MAXLEN);
         netlbl_secattr_destroy(&secattr);
 
+#ifdef CONFIG_AUDIT
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_NET);
+        ad.a.u.net.family = family;
+        ad.a.u.net.netif = skb->iif;
+        ipv4_skb_to_auditdata(skb, &ad.a, NULL);
+#endif
         /*
          * Receiving a packet requires that the other end be able to write
          * here. Read access is not required.
          */
-        rc = smk_access(smack, ssp->smk_in, MAY_WRITE);
+        rc = smk_access(smack, ssp->smk_in, MAY_WRITE, &ad);
         if (rc != 0)
                 return rc;
 
@@ -2643,6 +2843,7 @@ static int smack_key_permission(key_ref_t key_ref,
                                 const struct cred *cred, key_perm_t perm)
 {
         struct key *keyp;
+        struct smk_audit_info ad;
 
         keyp = key_ref_to_ptr(key_ref);
         if (keyp == NULL)
@@ -2658,8 +2859,13 @@ static int smack_key_permission(key_ref_t key_ref,
          */
         if (cred->security == NULL)
                 return -EACCES;
-
-        return smk_access(cred->security, keyp->security, MAY_READWRITE);
+#ifdef CONFIG_AUDIT
+        smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_KEY);
+        ad.a.u.key_struct.key = keyp->serial;
+        ad.a.u.key_struct.key_desc = keyp->description;
+#endif
+        return smk_access(cred->security, keyp->security,
+                                 MAY_READWRITE, &ad);
 }
 #endif /* CONFIG_KEYS */
 
@@ -2828,15 +3034,7 @@ struct security_operations smack_ops = {
 
         .ptrace_may_access =            smack_ptrace_may_access,
         .ptrace_traceme =               smack_ptrace_traceme,
-        .capget =                       cap_capget,
-        .capset =                       cap_capset,
-        .capable =                      cap_capable,
         .syslog =                       smack_syslog,
-        .settime =                      cap_settime,
-        .vm_enough_memory =             cap_vm_enough_memory,
-
-        .bprm_set_creds =               cap_bprm_set_creds,
-        .bprm_secureexec =              cap_bprm_secureexec,
 
         .sb_alloc_security =            smack_sb_alloc_security,
         .sb_free_security =             smack_sb_free_security,
@@ -2860,8 +3058,6 @@ struct security_operations smack_ops = {
         .inode_post_setxattr =          smack_inode_post_setxattr,
         .inode_getxattr =               smack_inode_getxattr,
         .inode_removexattr =            smack_inode_removexattr,
-        .inode_need_killpriv =          cap_inode_need_killpriv,
-        .inode_killpriv =               cap_inode_killpriv,
         .inode_getsecurity =            smack_inode_getsecurity,
         .inode_setsecurity =            smack_inode_setsecurity,
         .inode_listsecurity =           smack_inode_listsecurity,
@@ -2882,7 +3078,6 @@ struct security_operations smack_ops = {
         .cred_commit =                  smack_cred_commit,
         .kernel_act_as =                smack_kernel_act_as,
         .kernel_create_files_as =       smack_kernel_create_files_as,
-        .task_fix_setuid =              cap_task_fix_setuid,
         .task_setpgid =                 smack_task_setpgid,
         .task_getpgid =                 smack_task_getpgid,
         .task_getsid =                  smack_task_getsid,
@@ -2896,7 +3091,6 @@ struct security_operations smack_ops = {
         .task_kill =                    smack_task_kill,
         .task_wait =                    smack_task_wait,
         .task_to_inode =                smack_task_to_inode,
-        .task_prctl =                   cap_task_prctl,
 
         .ipc_permission =               smack_ipc_permission,
         .ipc_getsecid =                 smack_ipc_getsecid,
@@ -2923,9 +3117,6 @@ struct security_operations smack_ops = {
         .sem_semctl =                   smack_sem_semctl,
         .sem_semop =                    smack_sem_semop,
 
-        .netlink_send =                 cap_netlink_send,
-        .netlink_recv =                 cap_netlink_recv,
-
         .d_instantiate =                smack_d_instantiate,
 
         .getprocattr =                  smack_getprocattr,
diff --git a/security/smack/smackfs.c b/security/smack/smackfs.c
index 11d2cb19d7a6..f83a80980726 100644
--- a/security/smack/smackfs.c
+++ b/security/smack/smackfs.c
@@ -41,6 +41,7 @@ enum smk_inos {
         SMK_AMBIENT     = 7,    /* internet ambient label */
         SMK_NETLBLADDR  = 8,    /* single label hosts */
         SMK_ONLYCAP     = 9,    /* the only "capable" label */
+        SMK_LOGGING     = 10,   /* logging */
 };
 
 /*
@@ -775,7 +776,7 @@ static ssize_t smk_write_netlbladdr(struct file *file, const char __user *buf,
         struct sockaddr_in newname;
         char smack[SMK_LABELLEN];
         char *sp;
-        char data[SMK_NETLBLADDRMAX];
+        char data[SMK_NETLBLADDRMAX + 1];
         char *host = (char *)&newname.sin_addr.s_addr;
         int rc;
         struct netlbl_audit audit_info;
@@ -1192,6 +1193,69 @@ static const struct file_operations smk_onlycap_ops = {
 };
 
 /**
+ * smk_read_logging - read() for /smack/logging
+ * @filp: file pointer, not actually used
+ * @buf: where to put the result
+ * @cn: maximum to send along
+ * @ppos: where to start
+ *
+ * Returns number of bytes read or error code, as appropriate
+ */
+static ssize_t smk_read_logging(struct file *filp, char __user *buf,
+                                size_t count, loff_t *ppos)
+{
+        char temp[32];
+        ssize_t rc;
+
+        if (*ppos != 0)
+                return 0;
+
+        sprintf(temp, "%d\n", log_policy);
+        rc = simple_read_from_buffer(buf, count, ppos, temp, strlen(temp));
+        return rc;
+}
+
+/**
+ * smk_write_logging - write() for /smack/logging
+ * @file: file pointer, not actually used
+ * @buf: where to get the data from
+ * @count: bytes sent
+ * @ppos: where to start
+ *
+ * Returns number of bytes written or error code, as appropriate
+ */
+static ssize_t smk_write_logging(struct file *file, const char __user *buf,
+                                size_t count, loff_t *ppos)
+{
+        char temp[32];
+        int i;
+
+        if (!capable(CAP_MAC_ADMIN))
+                return -EPERM;
+
+        if (count >= sizeof(temp) || count == 0)
+                return -EINVAL;
+
+        if (copy_from_user(temp, buf, count) != 0)
+                return -EFAULT;
+
+        temp[count] = '\0';
+
+        if (sscanf(temp, "%d", &i) != 1)
+                return -EINVAL;
+        if (i < 0 || i > 3)
+                return -EINVAL;
+        log_policy = i;
+        return count;
+}
+
+
+
+static const struct file_operations smk_logging_ops = {
+        .read           = smk_read_logging,
+        .write          = smk_write_logging,
+};
+/**
  * smk_fill_super - fill the /smackfs superblock
  * @sb: the empty superblock
  * @data: unused
@@ -1221,6 +1285,8 @@ static int smk_fill_super(struct super_block *sb, void *data, int silent)
                         {"netlabel", &smk_netlbladdr_ops, S_IRUGO|S_IWUSR},
                 [SMK_ONLYCAP]   =
                         {"onlycap", &smk_onlycap_ops, S_IRUGO|S_IWUSR},
+                [SMK_LOGGING]   =
+                        {"logging", &smk_logging_ops, S_IRUGO|S_IWUSR},
                 /* last one */ {""}
         };
 
diff --git a/security/tomoyo/common.c b/security/tomoyo/common.c
index ddfb9cccf468..fdd1f4b8c448 100644
--- a/security/tomoyo/common.c
+++ b/security/tomoyo/common.c
@@ -28,7 +28,13 @@ static const char *tomoyo_mode_2[4] = {
         "disabled", "enabled", "enabled", "enabled"
 };
 
-/* Table for profile. */
+/*
+ * tomoyo_control_array is a static data which contains
+ *
+ *  (1) functionality name used by /sys/kernel/security/tomoyo/profile .
+ *  (2) initial values for "struct tomoyo_profile".
+ *  (3) max values for "struct tomoyo_profile".
+ */
 static struct {
         const char *keyword;
         unsigned int current_value;
@@ -39,7 +45,13 @@ static struct {
         [TOMOYO_VERBOSE]          = { "TOMOYO_VERBOSE",      1,       1 },
 };
 
-/* Profile table. Memory is allocated as needed. */
+/*
+ * tomoyo_profile is a structure which is used for holding the mode of access
+ * controls. TOMOYO has 4 modes: disabled, learning, permissive, enforcing.
+ * An administrator can define up to 256 profiles.
+ * The ->profile of "struct tomoyo_domain_info" is used for remembering
+ * the profile's number (0 - 255) assigned to that domain.
+ */
 static struct tomoyo_profile {
         unsigned int value[TOMOYO_MAX_CONTROL_INDEX];
         const struct tomoyo_path_info *comment;
@@ -428,7 +440,6 @@ void tomoyo_fill_path_info(struct tomoyo_path_info *ptr)
         const char *name = ptr->name;
         const int len = strlen(name);
 
-        ptr->total_len = len;
         ptr->const_len = tomoyo_const_part_length(name);
         ptr->is_dir = len && (name[len - 1] == '/');
         ptr->is_patterned = (ptr->const_len < len);
@@ -866,7 +877,6 @@ static struct tomoyo_profile *tomoyo_find_or_assign_new_profile(const unsigned
 
         if (profile >= TOMOYO_MAX_PROFILES)
                 return NULL;
-        /***** EXCLUSIVE SECTION START *****/
         mutex_lock(&lock);
         ptr = tomoyo_profile_ptr[profile];
         if (ptr)
@@ -880,7 +890,6 @@ static struct tomoyo_profile *tomoyo_find_or_assign_new_profile(const unsigned
         tomoyo_profile_ptr[profile] = ptr;
  ok:
         mutex_unlock(&lock);
-        /***** EXCLUSIVE SECTION END *****/
         return ptr;
 }
 
@@ -1009,7 +1018,19 @@ static int tomoyo_read_profile(struct tomoyo_io_buffer *head)
         return 0;
 }
 
-/* Structure for policy manager. */
+/*
+ * tomoyo_policy_manager_entry is a structure which is used for holding list of
+ * domainnames or programs which are permitted to modify configuration via
+ * /sys/kernel/security/tomoyo/ interface.
+ * It has following fields.
+ *
+ *  (1) "list" which is linked to tomoyo_policy_manager_list .
+ *  (2) "manager" is a domainname or a program's pathname.
+ *  (3) "is_domain" is a bool which is true if "manager" is a domainname, false
+ *      otherwise.
+ *  (4) "is_deleted" is a bool which is true if marked as deleted, false
+ *      otherwise.
+ */
 struct tomoyo_policy_manager_entry {
         struct list_head list;
         /* A path to program or a domainname. */
@@ -1018,7 +1039,36 @@ struct tomoyo_policy_manager_entry {
         bool is_deleted; /* True if this entry is deleted. */
 };
 
-/* The list for "struct tomoyo_policy_manager_entry". */
+/*
+ * tomoyo_policy_manager_list is used for holding list of domainnames or
+ * programs which are permitted to modify configuration via
+ * /sys/kernel/security/tomoyo/ interface.
+ *
+ * An entry is added by
+ *
+ * # echo '<kernel> /sbin/mingetty /bin/login /bin/bash' > \
+ *                                        /sys/kernel/security/tomoyo/manager
+ *  (if you want to specify by a domainname)
+ *
+ *  or
+ *
+ * # echo '/usr/lib/ccs/editpolicy' > /sys/kernel/security/tomoyo/manager
+ *  (if you want to specify by a program's location)
+ *
+ * and is deleted by
+ *
+ * # echo 'delete <kernel> /sbin/mingetty /bin/login /bin/bash' > \
+ *                                        /sys/kernel/security/tomoyo/manager
+ *
+ *  or
+ *
+ * # echo 'delete /usr/lib/ccs/editpolicy' > \
+ *                                        /sys/kernel/security/tomoyo/manager
+ *
+ * and all entries are retrieved by
+ *
+ * # cat /sys/kernel/security/tomoyo/manager
+ */
 static LIST_HEAD(tomoyo_policy_manager_list);
 static DECLARE_RWSEM(tomoyo_policy_manager_list_lock);
 
@@ -1050,7 +1100,6 @@ static int tomoyo_update_manager_entry(const char *manager,
         saved_manager = tomoyo_save_name(manager);
         if (!saved_manager)
                 return -ENOMEM;
-        /***** EXCLUSIVE SECTION START *****/
         down_write(&tomoyo_policy_manager_list_lock);
         list_for_each_entry(ptr, &tomoyo_policy_manager_list, list) {
                 if (ptr->manager != saved_manager)
@@ -1072,7 +1121,6 @@ static int tomoyo_update_manager_entry(const char *manager,
         error = 0;
  out:
         up_write(&tomoyo_policy_manager_list_lock);
-        /***** EXCLUSIVE SECTION END *****/
         return error;
 }
 
@@ -1117,10 +1165,9 @@ static int tomoyo_read_manager_policy(struct tomoyo_io_buffer *head)
                                  list);
                 if (ptr->is_deleted)
                         continue;
-                if (!tomoyo_io_printf(head, "%s\n", ptr->manager->name)) {
-                        done = false;
+                done = tomoyo_io_printf(head, "%s\n", ptr->manager->name);
+                if (!done)
                         break;
-                }
         }
         up_read(&tomoyo_policy_manager_list_lock);
         head->read_eof = done;
@@ -1197,13 +1244,11 @@ static bool tomoyo_is_select_one(struct tomoyo_io_buffer *head,
 
         if (sscanf(data, "pid=%u", &pid) == 1) {
                 struct task_struct *p;
-                /***** CRITICAL SECTION START *****/
                 read_lock(&tasklist_lock);
                 p = find_task_by_vpid(pid);
                 if (p)
                         domain = tomoyo_real_domain(p);
                 read_unlock(&tasklist_lock);
-                /***** CRITICAL SECTION END *****/
         } else if (!strncmp(data, "domain=", 7)) {
                 if (tomoyo_is_domain_def(data + 7)) {
                         down_read(&tomoyo_domain_list_lock);
@@ -1447,15 +1492,14 @@ static int tomoyo_read_domain_policy(struct tomoyo_io_buffer *head)
                     TOMOYO_DOMAIN_FLAGS_IGNORE_GLOBAL_ALLOW_READ)
                         ignore_global_allow_read
                                 = TOMOYO_KEYWORD_IGNORE_GLOBAL_ALLOW_READ "\n";
-                if (!tomoyo_io_printf(head,
-                                      "%s\n" TOMOYO_KEYWORD_USE_PROFILE "%u\n"
-                                      "%s%s%s\n", domain->domainname->name,
-                                      domain->profile, quota_exceeded,
-                                      transition_failed,
-                                      ignore_global_allow_read)) {
-                        done = false;
+                done = tomoyo_io_printf(head, "%s\n" TOMOYO_KEYWORD_USE_PROFILE
+                                        "%u\n%s%s%s\n",
+                                        domain->domainname->name,
+                                        domain->profile, quota_exceeded,
+                                        transition_failed,
+                                        ignore_global_allow_read);
+                if (!done)
                         break;
-                }
                 head->read_step = 2;
 acl_loop:
                 if (head->read_step == 3)
@@ -1463,24 +1507,22 @@ acl_loop:
                 /* Print ACL entries in the domain. */
                 down_read(&tomoyo_domain_acl_info_list_lock);
                 list_for_each_cookie(apos, head->read_var2,
-                                      &domain->acl_info_list) {
+                                     &domain->acl_info_list) {
                         struct tomoyo_acl_info *ptr
                                 = list_entry(apos, struct tomoyo_acl_info,
-                                              list);
-                        if (!tomoyo_print_entry(head, ptr)) {
-                                done = false;
+                                             list);
+                        done = tomoyo_print_entry(head, ptr);
+                        if (!done)
                                 break;
-                        }
                 }
                 up_read(&tomoyo_domain_acl_info_list_lock);
                 if (!done)
                         break;
                 head->read_step = 3;
 tail_mark:
-                if (!tomoyo_io_printf(head, "\n")) {
-                        done = false;
+                done = tomoyo_io_printf(head, "\n");
+                if (!done)
                         break;
-                }
                 head->read_step = 1;
                 if (head->read_single_domain)
                         break;
@@ -1550,11 +1592,10 @@ static int tomoyo_read_domain_profile(struct tomoyo_io_buffer *head)
                 domain = list_entry(pos, struct tomoyo_domain_info, list);
                 if (domain->is_deleted)
                         continue;
-                if (!tomoyo_io_printf(head, "%u %s\n", domain->profile,
-                                      domain->domainname->name)) {
-                        done = false;
+                done = tomoyo_io_printf(head, "%u %s\n", domain->profile,
+                                        domain->domainname->name);
+                if (!done)
                         break;
-                }
         }
         up_read(&tomoyo_domain_list_lock);
         head->read_eof = done;
@@ -1594,13 +1635,11 @@ static int tomoyo_read_pid(struct tomoyo_io_buffer *head)
                 const int pid = head->read_step;
                 struct task_struct *p;
                 struct tomoyo_domain_info *domain = NULL;
-                /***** CRITICAL SECTION START *****/
                 read_lock(&tasklist_lock);
                 p = find_task_by_vpid(pid);
                 if (p)
                         domain = tomoyo_real_domain(p);
                 read_unlock(&tasklist_lock);
-                /***** CRITICAL SECTION END *****/
                 if (domain)
                         tomoyo_io_printf(head, "%d %u %s", pid, domain->profile,
                                          domain->domainname->name);
@@ -2138,7 +2177,13 @@ static ssize_t tomoyo_write(struct file *file, const char __user *buf,
         return tomoyo_write_control(file, buf, count);
 }
 
-/* Operations for /sys/kernel/security/tomoyo/ interface. */
+/*
+ * tomoyo_operations is a "struct file_operations" which is used for handling
+ * /sys/kernel/security/tomoyo/ interface.
+ *
+ * Some files under /sys/kernel/security/tomoyo/ directory accept open(O_RDWR).
+ * See tomoyo_io_buffer for internals.
+ */
 static const struct file_operations tomoyo_operations = {
         .open    = tomoyo_open,
         .release = tomoyo_release,
diff --git a/security/tomoyo/common.h b/security/tomoyo/common.h
index 678f4ff16aa4..6d6ba09af457 100644
--- a/security/tomoyo/common.h
+++ b/security/tomoyo/common.h
@@ -26,16 +26,43 @@
 struct dentry;
 struct vfsmount;
 
-/* Temporary buffer for holding pathnames. */
+/*
+ * tomoyo_page_buffer is a structure which is used for holding a pathname
+ * obtained from "struct dentry" and "struct vfsmount" pair.
+ * As of now, it is 4096 bytes. If users complain that 4096 bytes is too small
+ * (because TOMOYO escapes non ASCII printable characters using \ooo format),
+ * we will make the buffer larger.
+ */
 struct tomoyo_page_buffer {
         char buffer[4096];
 };
 
-/* Structure for holding a token. */
+/*
+ * tomoyo_path_info is a structure which is used for holding a string data
+ * used by TOMOYO.
+ * This structure has several fields for supporting pattern matching.
+ *
+ * (1) "name" is the '\0' terminated string data.
+ * (2) "hash" is full_name_hash(name, strlen(name)).
+ *     This allows tomoyo_pathcmp() to compare by hash before actually compare
+ *     using strcmp().
+ * (3) "const_len" is the length of the initial segment of "name" which
+ *     consists entirely of non wildcard characters. In other words, the length
+ *     which we can compare two strings using strncmp().
+ * (4) "is_dir" is a bool which is true if "name" ends with "/",
+ *     false otherwise.
+ *     TOMOYO distinguishes directory and non-directory. A directory ends with
+ *     "/" and non-directory does not end with "/".
+ * (5) "is_patterned" is a bool which is true if "name" contains wildcard
+ *     characters, false otherwise. This allows TOMOYO to use "hash" and
+ *     strcmp() for string comparison if "is_patterned" is false.
+ * (6) "depth" is calculated using the number of "/" characters in "name".
+ *     This allows TOMOYO to avoid comparing two pathnames which never match
+ *     (e.g. whether "/var/www/html/index.html" matches "/tmp/sh-thd-\$").
+ */
 struct tomoyo_path_info {
         const char *name;
         u32 hash;          /* = full_name_hash(name, strlen(name)) */
-        u16 total_len;     /* = strlen(name)                       */
         u16 const_len;     /* = tomoyo_const_part_length(name)     */
         bool is_dir;       /* = tomoyo_strendswith(name, "/")      */
         bool is_patterned; /* = tomoyo_path_contains_pattern(name) */
@@ -51,7 +78,20 @@ struct tomoyo_path_info {
  */
 #define TOMOYO_MAX_PATHNAME_LEN 4000
 
-/* Structure for holding requested pathname. */
+/*
+ * tomoyo_path_info_with_data is a structure which is used for holding a
+ * pathname obtained from "struct dentry" and "struct vfsmount" pair.
+ *
+ * "struct tomoyo_path_info_with_data" consists of "struct tomoyo_path_info"
+ * and buffer for the pathname, while "struct tomoyo_page_buffer" consists of
+ * buffer for the pathname only.
+ *
+ * "struct tomoyo_path_info_with_data" is intended to allow TOMOYO to release
+ * both "struct tomoyo_path_info" and buffer for the pathname by single kfree()
+ * so that we don't need to return two pointers to the caller. If the caller
+ * puts "struct tomoyo_path_info" on stack memory, we will be able to remove
+ * "struct tomoyo_path_info_with_data".
+ */
 struct tomoyo_path_info_with_data {
         /* Keep "head" first, for this pointer is passed to tomoyo_free(). */
         struct tomoyo_path_info head;
@@ -61,7 +101,15 @@ struct tomoyo_path_info_with_data {
 };
 
 /*
- * Common header for holding ACL entries.
+ * tomoyo_acl_info is a structure which is used for holding
+ *
+ *  (1) "list" which is linked to the ->acl_info_list of
+ *      "struct tomoyo_domain_info"
+ *  (2) "type" which tells
+ *      (a) type & 0x7F : type of the entry (either
+ *          "struct tomoyo_single_path_acl_record" or
+ *          "struct tomoyo_double_path_acl_record")
+ *      (b) type & 0x80 : whether the entry is marked as "deleted".
  *
  * Packing "struct tomoyo_acl_info" allows
  * "struct tomoyo_single_path_acl_record" to embed "u16" and
@@ -81,7 +129,28 @@ struct tomoyo_acl_info {
 /* This ACL entry is deleted.           */
 #define TOMOYO_ACL_DELETED        0x80
 
-/* Structure for domain information. */
+/*
+ * tomoyo_domain_info is a structure which is used for holding permissions
+ * (e.g. "allow_read /lib/libc-2.5.so") given to each domain.
+ * It has following fields.
+ *
+ *  (1) "list" which is linked to tomoyo_domain_list .
+ *  (2) "acl_info_list" which is linked to "struct tomoyo_acl_info".
+ *  (3) "domainname" which holds the name of the domain.
+ *  (4) "profile" which remembers profile number assigned to this domain.
+ *  (5) "is_deleted" is a bool which is true if this domain is marked as
+ *      "deleted", false otherwise.
+ *  (6) "quota_warned" is a bool which is used for suppressing warning message
+ *      when learning mode learned too much entries.
+ *  (7) "flags" which remembers this domain's attributes.
+ *
+ * A domain's lifecycle is an analogy of files on / directory.
+ * Multiple domains with the same domainname cannot be created (as with
+ * creating files with the same filename fails with -EEXIST).
+ * If a process reached a domain, that process can reside in that domain after
+ * that domain is marked as "deleted" (as with a process can access an already
+ * open()ed file after that file was unlink()ed).
+ */
 struct tomoyo_domain_info {
         struct list_head list;
         struct list_head acl_info_list;
@@ -108,10 +177,18 @@ struct tomoyo_domain_info {
 #define TOMOYO_DOMAIN_FLAGS_TRANSITION_FAILED        2
 
 /*
- * Structure for "allow_read/write", "allow_execute", "allow_read",
- * "allow_write", "allow_create", "allow_unlink", "allow_mkdir", "allow_rmdir",
- * "allow_mkfifo", "allow_mksock", "allow_mkblock", "allow_mkchar",
- * "allow_truncate", "allow_symlink" and "allow_rewrite" directive.
+ * tomoyo_single_path_acl_record is a structure which is used for holding an
+ * entry with one pathname operation (e.g. open(), mkdir()).
+ * It has following fields.
+ *
+ *  (1) "head" which is a "struct tomoyo_acl_info".
+ *  (2) "perm" which is a bitmask of permitted operations.
+ *  (3) "filename" is the pathname.
+ *
+ * Directives held by this structure are "allow_read/write", "allow_execute",
+ * "allow_read", "allow_write", "allow_create", "allow_unlink", "allow_mkdir",
+ * "allow_rmdir", "allow_mkfifo", "allow_mksock", "allow_mkblock",
+ * "allow_mkchar", "allow_truncate", "allow_symlink" and "allow_rewrite".
  */
 struct tomoyo_single_path_acl_record {
         struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_SINGLE_PATH_ACL */
@@ -120,7 +197,18 @@ struct tomoyo_single_path_acl_record {
         const struct tomoyo_path_info *filename;
 };
 
-/* Structure for "allow_rename" and "allow_link" directive. */
+/*
+ * tomoyo_double_path_acl_record is a structure which is used for holding an
+ * entry with two pathnames operation (i.e. link() and rename()).
+ * It has following fields.
+ *
+ *  (1) "head" which is a "struct tomoyo_acl_info".
+ *  (2) "perm" which is a bitmask of permitted operations.
+ *  (3) "filename1" is the source/old pathname.
+ *  (4) "filename2" is the destination/new pathname.
+ *
+ * Directives held by this structure are "allow_rename" and "allow_link".
+ */
 struct tomoyo_double_path_acl_record {
         struct tomoyo_acl_info head; /* type = TOMOYO_TYPE_DOUBLE_PATH_ACL */
         u8 perm;
@@ -153,7 +241,29 @@ struct tomoyo_double_path_acl_record {
 #define TOMOYO_VERBOSE                       2
 #define TOMOYO_MAX_CONTROL_INDEX             3
 
-/* Structure for reading/writing policy via securityfs interfaces. */
+/*
+ * tomoyo_io_buffer is a structure which is used for reading and modifying
+ * configuration via /sys/kernel/security/tomoyo/ interface.
+ * It has many fields. ->read_var1 , ->read_var2 , ->write_var1 are used as
+ * cursors.
+ *
+ * Since the content of /sys/kernel/security/tomoyo/domain_policy is a list of
+ * "struct tomoyo_domain_info" entries and each "struct tomoyo_domain_info"
+ * entry has a list of "struct tomoyo_acl_info", we need two cursors when
+ * reading (one is for traversing tomoyo_domain_list and the other is for
+ * traversing "struct tomoyo_acl_info"->acl_info_list ).
+ *
+ * If a line written to /sys/kernel/security/tomoyo/domain_policy starts with
+ * "select ", TOMOYO seeks the cursor ->read_var1 and ->write_var1 to the
+ * domain with the domainname specified by the rest of that line (NULL is set
+ * if seek failed).
+ * If a line written to /sys/kernel/security/tomoyo/domain_policy starts with
+ * "delete ", TOMOYO deletes an entry or a domain specified by the rest of that
+ * line (->write_var1 is set to NULL if a domain was deleted).
+ * If a line written to /sys/kernel/security/tomoyo/domain_policy starts with
+ * neither "select " nor "delete ", an entry or a domain specified by that line
+ * is appended.
+ */
 struct tomoyo_io_buffer {
         int (*read) (struct tomoyo_io_buffer *);
         int (*write) (struct tomoyo_io_buffer *);
diff --git a/security/tomoyo/domain.c b/security/tomoyo/domain.c
index 2d6748741a26..1d8b16960576 100644
--- a/security/tomoyo/domain.c
+++ b/security/tomoyo/domain.c
@@ -19,11 +19,63 @@
 /* The initial domain. */
 struct tomoyo_domain_info tomoyo_kernel_domain;
 
-/* The list for "struct tomoyo_domain_info". */
+/*
+ * tomoyo_domain_list is used for holding list of domains.
+ * The ->acl_info_list of "struct tomoyo_domain_info" is used for holding
+ * permissions (e.g. "allow_read /lib/libc-2.5.so") given to each domain.
+ *
+ * An entry is added by
+ *
+ * # ( echo "<kernel>"; echo "allow_execute /sbin/init" ) > \
+ *                                  /sys/kernel/security/tomoyo/domain_policy
+ *
+ * and is deleted by
+ *
+ * # ( echo "<kernel>"; echo "delete allow_execute /sbin/init" ) > \
+ *                                  /sys/kernel/security/tomoyo/domain_policy
+ *
+ * and all entries are retrieved by
+ *
+ * # cat /sys/kernel/security/tomoyo/domain_policy
+ *
+ * A domain is added by
+ *
+ * # echo "<kernel>" > /sys/kernel/security/tomoyo/domain_policy
+ *
+ * and is deleted by
+ *
+ * # echo "delete <kernel>" > /sys/kernel/security/tomoyo/domain_policy
+ *
+ * and all domains are retrieved by
+ *
+ * # grep '^<kernel>' /sys/kernel/security/tomoyo/domain_policy
+ *
+ * Normally, a domainname is monotonically getting longer because a domainname
+ * which the process will belong to if an execve() operation succeeds is
+ * defined as a concatenation of "current domainname" + "pathname passed to
+ * execve()".
+ * See tomoyo_domain_initializer_list and tomoyo_domain_keeper_list for
+ * exceptions.
+ */
 LIST_HEAD(tomoyo_domain_list);
 DECLARE_RWSEM(tomoyo_domain_list_lock);
 
-/* Structure for "initialize_domain" and "no_initialize_domain" keyword. */
+/*
+ * tomoyo_domain_initializer_entry is a structure which is used for holding
+ * "initialize_domain" and "no_initialize_domain" entries.
+ * It has following fields.
+ *
+ *  (1) "list" which is linked to tomoyo_domain_initializer_list .
+ *  (2) "domainname" which is "a domainname" or "the last component of a
+ *      domainname". This field is NULL if "from" clause is not specified.
+ *  (3) "program" which is a program's pathname.
+ *  (4) "is_deleted" is a bool which is true if marked as deleted, false
+ *      otherwise.
+ *  (5) "is_not" is a bool which is true if "no_initialize_domain", false
+ *      otherwise.
+ *  (6) "is_last_name" is a bool which is true if "domainname" is "the last
+ *      component of a domainname", false otherwise.
+ */
 struct tomoyo_domain_initializer_entry {
         struct list_head list;
         const struct tomoyo_path_info *domainname;    /* This may be NULL */
@@ -34,7 +86,23 @@ struct tomoyo_domain_initializer_entry {
         bool is_last_name;
 };
 
-/* Structure for "keep_domain" and "no_keep_domain" keyword. */
+/*
+ * tomoyo_domain_keeper_entry is a structure which is used for holding
+ * "keep_domain" and "no_keep_domain" entries.
+ * It has following fields.
+ *
+ *  (1) "list" which is linked to tomoyo_domain_keeper_list .
+ *  (2) "domainname" which is "a domainname" or "the last component of a
+ *      domainname".
+ *  (3) "program" which is a program's pathname.
+ *      This field is NULL if "from" clause is not specified.
+ *  (4) "is_deleted" is a bool which is true if marked as deleted, false
+ *      otherwise.
+ *  (5) "is_not" is a bool which is true if "no_initialize_domain", false
+ *      otherwise.
+ *  (6) "is_last_name" is a bool which is true if "domainname" is "the last
+ *      component of a domainname", false otherwise.
+ */
 struct tomoyo_domain_keeper_entry {
         struct list_head list;
         const struct tomoyo_path_info *domainname;
@@ -45,7 +113,16 @@ struct tomoyo_domain_keeper_entry {
         bool is_last_name;
 };
 
-/* Structure for "alias" keyword. */
+/*
+ * tomoyo_alias_entry is a structure which is used for holding "alias" entries.
+ * It has following fields.
+ *
+ *  (1) "list" which is linked to tomoyo_alias_list .
+ *  (2) "original_name" which is a dereferenced pathname.
+ *  (3) "aliased_name" which is a symlink's pathname.
+ *  (4) "is_deleted" is a bool which is true if marked as deleted, false
+ *      otherwise.
+ */
 struct tomoyo_alias_entry {
         struct list_head list;
         const struct tomoyo_path_info *original_name;
@@ -67,14 +144,12 @@ void tomoyo_set_domain_flag(struct tomoyo_domain_info *domain,
 {
         /* We need to serialize because this is bitfield operation. */
         static DEFINE_SPINLOCK(lock);
-        /***** CRITICAL SECTION START *****/
         spin_lock(&lock);
         if (!is_delete)
                 domain->flags |= flags;
         else
                 domain->flags &= ~flags;
         spin_unlock(&lock);
-        /***** CRITICAL SECTION END *****/
 }
 
 /**
@@ -94,7 +169,42 @@ const char *tomoyo_get_last_name(const struct tomoyo_domain_info *domain)
         return cp0;
 }
 
-/* The list for "struct tomoyo_domain_initializer_entry". */
+/*
+ * tomoyo_domain_initializer_list is used for holding list of programs which
+ * triggers reinitialization of domainname. Normally, a domainname is
+ * monotonically getting longer. But sometimes, we restart daemon programs.
+ * It would be convenient for us that "a daemon started upon system boot" and
+ * "the daemon restarted from console" belong to the same domain. Thus, TOMOYO
+ * provides a way to shorten domainnames.
+ *
+ * An entry is added by
+ *
+ * # echo 'initialize_domain /usr/sbin/httpd' > \
+ *                               /sys/kernel/security/tomoyo/exception_policy
+ *
+ * and is deleted by
+ *
+ * # echo 'delete initialize_domain /usr/sbin/httpd' > \
+ *                               /sys/kernel/security/tomoyo/exception_policy
+ *
+ * and all entries are retrieved by
+ *
+ * # grep ^initialize_domain /sys/kernel/security/tomoyo/exception_policy
+ *
+ * In the example above, /usr/sbin/httpd will belong to
+ * "<kernel> /usr/sbin/httpd" domain.
+ *
+ * You may specify a domainname using "from" keyword.
+ * "initialize_domain /usr/sbin/httpd from <kernel> /etc/rc.d/init.d/httpd"
+ * will cause "/usr/sbin/httpd" executed from "<kernel> /etc/rc.d/init.d/httpd"
+ * domain to belong to "<kernel> /usr/sbin/httpd" domain.
+ *
+ * You may add "no_" prefix to "initialize_domain".
+ * "initialize_domain /usr/sbin/httpd" and
+ * "no_initialize_domain /usr/sbin/httpd from <kernel> /etc/rc.d/init.d/httpd"
+ * will cause "/usr/sbin/httpd" to belong to "<kernel> /usr/sbin/httpd" domain
+ * unless executed from "<kernel> /etc/rc.d/init.d/httpd" domain.
+ */
 static LIST_HEAD(tomoyo_domain_initializer_list);
 static DECLARE_RWSEM(tomoyo_domain_initializer_list_lock);
 
@@ -135,7 +245,6 @@ static int tomoyo_update_domain_initializer_entry(const char *domainname,
         saved_program = tomoyo_save_name(program);
         if (!saved_program)
                 return -ENOMEM;
-        /***** EXCLUSIVE SECTION START *****/
         down_write(&tomoyo_domain_initializer_list_lock);
         list_for_each_entry(ptr, &tomoyo_domain_initializer_list, list) {
                 if (ptr->is_not != is_not ||
@@ -161,7 +270,6 @@ static int tomoyo_update_domain_initializer_entry(const char *domainname,
         error = 0;
  out:
         up_write(&tomoyo_domain_initializer_list_lock);
-        /***** EXCLUSIVE SECTION END *****/
         return error;
 }
 
@@ -193,13 +301,12 @@ bool tomoyo_read_domain_initializer_policy(struct tomoyo_io_buffer *head)
                         from = " from ";
                         domain = ptr->domainname->name;
                 }
-                if (!tomoyo_io_printf(head,
-                                      "%s" TOMOYO_KEYWORD_INITIALIZE_DOMAIN
-                                      "%s%s%s\n", no, ptr->program->name, from,
-                                      domain)) {
-                        done = false;
+                done = tomoyo_io_printf(head,
+                                        "%s" TOMOYO_KEYWORD_INITIALIZE_DOMAIN
+                                        "%s%s%s\n", no, ptr->program->name,
+                                        from, domain);
+                if (!done)
                         break;
-                }
         }
         up_read(&tomoyo_domain_initializer_list_lock);
         return done;
@@ -273,7 +380,44 @@ static bool tomoyo_is_domain_initializer(const struct tomoyo_path_info *
         return flag;
 }
 
-/* The list for "struct tomoyo_domain_keeper_entry". */
+/*
+ * tomoyo_domain_keeper_list is used for holding list of domainnames which
+ * suppresses domain transition. Normally, a domainname is monotonically
+ * getting longer. But sometimes, we want to suppress domain transition.
+ * It would be convenient for us that programs executed from a login session
+ * belong to the same domain. Thus, TOMOYO provides a way to suppress domain
+ * transition.
+ *
+ * An entry is added by
+ *
+ * # echo 'keep_domain <kernel> /usr/sbin/sshd /bin/bash' > \
+ *                              /sys/kernel/security/tomoyo/exception_policy
+ *
+ * and is deleted by
+ *
+ * # echo 'delete keep_domain <kernel> /usr/sbin/sshd /bin/bash' > \
+ *                              /sys/kernel/security/tomoyo/exception_policy
+ *
+ * and all entries are retrieved by
+ *
+ * # grep ^keep_domain /sys/kernel/security/tomoyo/exception_policy
+ *
+ * In the example above, any process which belongs to
+ * "<kernel> /usr/sbin/sshd /bin/bash" domain will remain in that domain,
+ * unless explicitly specified by "initialize_domain" or "no_keep_domain".
+ *
+ * You may specify a program using "from" keyword.
+ * "keep_domain /bin/pwd from <kernel> /usr/sbin/sshd /bin/bash"
+ * will cause "/bin/pwd" executed from "<kernel> /usr/sbin/sshd /bin/bash"
+ * domain to remain in "<kernel> /usr/sbin/sshd /bin/bash" domain.
+ *
+ * You may add "no_" prefix to "keep_domain".
+ * "keep_domain <kernel> /usr/sbin/sshd /bin/bash" and
+ * "no_keep_domain /usr/bin/passwd from <kernel> /usr/sbin/sshd /bin/bash" will
+ * cause "/usr/bin/passwd" to belong to
+ * "<kernel> /usr/sbin/sshd /bin/bash /usr/bin/passwd" domain, unless
+ * explicitly specified by "initialize_domain".
+ */
 static LIST_HEAD(tomoyo_domain_keeper_list);
 static DECLARE_RWSEM(tomoyo_domain_keeper_list_lock);
 
@@ -296,7 +440,6 @@ static int tomoyo_update_domain_keeper_entry(const char *domainname,
         struct tomoyo_domain_keeper_entry *ptr;
         const struct tomoyo_path_info *saved_domainname;
         const struct tomoyo_path_info *saved_program = NULL;
-        static DEFINE_MUTEX(lock);
         int error = -ENOMEM;
         bool is_last_name = false;
 
@@ -315,7 +458,6 @@ static int tomoyo_update_domain_keeper_entry(const char *domainname,
         saved_domainname = tomoyo_save_name(domainname);
         if (!saved_domainname)
                 return -ENOMEM;
-        /***** EXCLUSIVE SECTION START *****/
         down_write(&tomoyo_domain_keeper_list_lock);
         list_for_each_entry(ptr, &tomoyo_domain_keeper_list, list) {
                 if (ptr->is_not != is_not ||
@@ -341,7 +483,6 @@ static int tomoyo_update_domain_keeper_entry(const char *domainname,
         error = 0;
  out:
         up_write(&tomoyo_domain_keeper_list_lock);
-        /***** EXCLUSIVE SECTION END *****/
         return error;
 }
 
@@ -394,13 +535,12 @@ bool tomoyo_read_domain_keeper_policy(struct tomoyo_io_buffer *head)
                         from = " from ";
                         program = ptr->program->name;
                 }
-                if (!tomoyo_io_printf(head,
-                                      "%s" TOMOYO_KEYWORD_KEEP_DOMAIN
-                                      "%s%s%s\n", no, program, from,
-                                      ptr->domainname->name)) {
-                        done = false;
+                done = tomoyo_io_printf(head,
+                                        "%s" TOMOYO_KEYWORD_KEEP_DOMAIN
+                                        "%s%s%s\n", no, program, from,
+                                        ptr->domainname->name);
+                if (!done)
                         break;
-                }
         }
         up_read(&tomoyo_domain_keeper_list_lock);
         return done;
@@ -446,7 +586,36 @@ static bool tomoyo_is_domain_keeper(const struct tomoyo_path_info *domainname,
         return flag;
 }
 
-/* The list for "struct tomoyo_alias_entry". */
+/*
+ * tomoyo_alias_list is used for holding list of symlink's pathnames which are
+ * allowed to be passed to an execve() request. Normally, the domainname which
+ * the current process will belong to after execve() succeeds is calculated
+ * using dereferenced pathnames. But some programs behave differently depending
+ * on the name passed to argv[0]. For busybox, calculating domainname using
+ * dereferenced pathnames will cause all programs in the busybox to belong to
+ * the same domain. Thus, TOMOYO provides a way to allow use of symlink's
+ * pathname for checking execve()'s permission and calculating domainname which
+ * the current process will belong to after execve() succeeds.
+ *
+ * An entry is added by
+ *
+ * # echo 'alias /bin/busybox /bin/cat' > \
+ *                            /sys/kernel/security/tomoyo/exception_policy
+ *
+ * and is deleted by
+ *
+ * # echo 'delete alias /bin/busybox /bin/cat' > \
+ *                            /sys/kernel/security/tomoyo/exception_policy
+ *
+ * and all entries are retrieved by
+ *
+ * # grep ^alias /sys/kernel/security/tomoyo/exception_policy
+ *
+ * In the example above, if /bin/cat is a symlink to /bin/busybox and execution
+ * of /bin/cat is requested, permission is checked for /bin/cat rather than
+ * /bin/busybox and domainname which the current process will belong to after
+ * execve() succeeds is calculated using /bin/cat rather than /bin/busybox .
+ */
 static LIST_HEAD(tomoyo_alias_list);
 static DECLARE_RWSEM(tomoyo_alias_list_lock);
 
@@ -476,7 +645,6 @@ static int tomoyo_update_alias_entry(const char *original_name,
         saved_aliased_name = tomoyo_save_name(aliased_name);
         if (!saved_original_name || !saved_aliased_name)
                 return -ENOMEM;
-        /***** EXCLUSIVE SECTION START *****/
         down_write(&tomoyo_alias_list_lock);
         list_for_each_entry(ptr, &tomoyo_alias_list, list) {
                 if (ptr->original_name != saved_original_name ||
@@ -499,7 +667,6 @@ static int tomoyo_update_alias_entry(const char *original_name,
         error = 0;
  out:
         up_write(&tomoyo_alias_list_lock);
-        /***** EXCLUSIVE SECTION END *****/
         return error;
 }
 
@@ -522,12 +689,11 @@ bool tomoyo_read_alias_policy(struct tomoyo_io_buffer *head)
                 ptr = list_entry(pos, struct tomoyo_alias_entry, list);
                 if (ptr->is_deleted)
                         continue;
-                if (!tomoyo_io_printf(head, TOMOYO_KEYWORD_ALIAS "%s %s\n",
-                                      ptr->original_name->name,
-                                      ptr->aliased_name->name)) {
-                        done = false;
+                done = tomoyo_io_printf(head, TOMOYO_KEYWORD_ALIAS "%s %s\n",
+                                        ptr->original_name->name,
+                                        ptr->aliased_name->name);
+                if (!done)
                         break;
-                }
         }
         up_read(&tomoyo_alias_list_lock);
         return done;
@@ -567,7 +733,6 @@ int tomoyo_delete_domain(char *domainname)
 
         name.name = domainname;
         tomoyo_fill_path_info(&name);
-        /***** EXCLUSIVE SECTION START *****/
         down_write(&tomoyo_domain_list_lock);
         /* Is there an active domain? */
         list_for_each_entry(domain, &tomoyo_domain_list, list) {
@@ -581,7 +746,6 @@ int tomoyo_delete_domain(char *domainname)
                 break;
         }
         up_write(&tomoyo_domain_list_lock);
-        /***** EXCLUSIVE SECTION END *****/
         return 0;
 }
 
@@ -600,7 +764,6 @@ struct tomoyo_domain_info *tomoyo_find_or_assign_new_domain(const char *
         struct tomoyo_domain_info *domain = NULL;
         const struct tomoyo_path_info *saved_domainname;
 
-        /***** EXCLUSIVE SECTION START *****/
         down_write(&tomoyo_domain_list_lock);
         domain = tomoyo_find_domain(domainname);
         if (domain)
@@ -619,7 +782,6 @@ struct tomoyo_domain_info *tomoyo_find_or_assign_new_domain(const char *
                     domain->domainname != saved_domainname)
                         continue;
                 flag = false;
-                /***** CRITICAL SECTION START *****/
                 read_lock(&tasklist_lock);
                 for_each_process(p) {
                         if (tomoyo_real_domain(p) != domain)
@@ -628,7 +790,6 @@ struct tomoyo_domain_info *tomoyo_find_or_assign_new_domain(const char *
                         break;
                 }
                 read_unlock(&tasklist_lock);
-                /***** CRITICAL SECTION END *****/
                 if (flag)
                         continue;
                 list_for_each_entry(ptr, &domain->acl_info_list, list) {
@@ -651,7 +812,6 @@ struct tomoyo_domain_info *tomoyo_find_or_assign_new_domain(const char *
         }
  out:
         up_write(&tomoyo_domain_list_lock);
-        /***** EXCLUSIVE SECTION END *****/
         return domain;
 }
 
@@ -739,7 +899,7 @@ int tomoyo_find_next_domain(struct linux_binprm *bprm,
         }
 
         /* Check execute permission. */
-        retval = tomoyo_check_exec_perm(old_domain, &r, tmp);
+        retval = tomoyo_check_exec_perm(old_domain, &r);
         if (retval < 0)
                 goto out;
 
diff --git a/security/tomoyo/file.c b/security/tomoyo/file.c
index 2316da8ec5bc..5ae3a571559f 100644
--- a/security/tomoyo/file.c
+++ b/security/tomoyo/file.c
@@ -14,21 +14,50 @@
 #include "realpath.h"
 #define ACC_MODE(x) ("\000\004\002\006"[(x)&O_ACCMODE])
 
-/* Structure for "allow_read" keyword. */
+/*
+ * tomoyo_globally_readable_file_entry is a structure which is used for holding
+ * "allow_read" entries.
+ * It has following fields.
+ *
+ *  (1) "list" which is linked to tomoyo_globally_readable_list .
+ *  (2) "filename" is a pathname which is allowed to open(O_RDONLY).
+ *  (3) "is_deleted" is a bool which is true if marked as deleted, false
+ *      otherwise.
+ */
 struct tomoyo_globally_readable_file_entry {
         struct list_head list;
         const struct tomoyo_path_info *filename;
         bool is_deleted;
 };
 
-/* Structure for "file_pattern" keyword. */
+/*
+ * tomoyo_pattern_entry is a structure which is used for holding
+ * "tomoyo_pattern_list" entries.
+ * It has following fields.
+ *
+ *  (1) "list" which is linked to tomoyo_pattern_list .
+ *  (2) "pattern" is a pathname pattern which is used for converting pathnames
+ *      to pathname patterns during learning mode.
+ *  (3) "is_deleted" is a bool which is true if marked as deleted, false
+ *      otherwise.
+ */
 struct tomoyo_pattern_entry {
         struct list_head list;
         const struct tomoyo_path_info *pattern;
         bool is_deleted;
 };
 
-/* Structure for "deny_rewrite" keyword. */
+/*
+ * tomoyo_no_rewrite_entry is a structure which is used for holding
+ * "deny_rewrite" entries.
+ * It has following fields.
+ *
+ *  (1) "list" which is linked to tomoyo_no_rewrite_list .
+ *  (2) "pattern" is a pathname which is by default not permitted to modify
+ *      already existing content.
+ *  (3) "is_deleted" is a bool which is true if marked as deleted, false
+ *      otherwise.
+ */
 struct tomoyo_no_rewrite_entry {
         struct list_head list;
         const struct tomoyo_path_info *pattern;
@@ -141,7 +170,31 @@ static int tomoyo_update_single_path_acl(const u8 type, const char *filename,
                                          struct tomoyo_domain_info *
                                          const domain, const bool is_delete);
 
-/* The list for "struct tomoyo_globally_readable_file_entry". */
+/*
+ * tomoyo_globally_readable_list is used for holding list of pathnames which
+ * are by default allowed to be open()ed for reading by any process.
+ *
+ * An entry is added by
+ *
+ * # echo 'allow_read /lib/libc-2.5.so' > \
+ *                               /sys/kernel/security/tomoyo/exception_policy
+ *
+ * and is deleted by
+ *
+ * # echo 'delete allow_read /lib/libc-2.5.so' > \
+ *                               /sys/kernel/security/tomoyo/exception_policy
+ *
+ * and all entries are retrieved by
+ *
+ * # grep ^allow_read /sys/kernel/security/tomoyo/exception_policy
+ *
+ * In the example above, any process is allowed to
+ * open("/lib/libc-2.5.so", O_RDONLY).
+ * One exception is, if the domain which current process belongs to is marked
+ * as "ignore_global_allow_read", current process can't do so unless explicitly
+ * given "allow_read /lib/libc-2.5.so" to the domain which current process
+ * belongs to.
+ */
 static LIST_HEAD(tomoyo_globally_readable_list);
 static DECLARE_RWSEM(tomoyo_globally_readable_list_lock);
 
@@ -166,7 +219,6 @@ static int tomoyo_update_globally_readable_entry(const char *filename,
         saved_filename = tomoyo_save_name(filename);
         if (!saved_filename)
                 return -ENOMEM;
-        /***** EXCLUSIVE SECTION START *****/
         down_write(&tomoyo_globally_readable_list_lock);
         list_for_each_entry(ptr, &tomoyo_globally_readable_list, list) {
                 if (ptr->filename != saved_filename)
@@ -187,7 +239,6 @@ static int tomoyo_update_globally_readable_entry(const char *filename,
         error = 0;
  out:
         up_write(&tomoyo_globally_readable_list_lock);
-        /***** EXCLUSIVE SECTION END *****/
         return error;
 }
 
@@ -249,17 +300,44 @@ bool tomoyo_read_globally_readable_policy(struct tomoyo_io_buffer *head)
                                  list);
                 if (ptr->is_deleted)
                         continue;
-                if (!tomoyo_io_printf(head, TOMOYO_KEYWORD_ALLOW_READ "%s\n",
-                                      ptr->filename->name)) {
-                        done = false;
+                done = tomoyo_io_printf(head, TOMOYO_KEYWORD_ALLOW_READ "%s\n",
+                                        ptr->filename->name);
+                if (!done)
                         break;
-                }
         }
         up_read(&tomoyo_globally_readable_list_lock);
         return done;
 }
 
-/* The list for "struct tomoyo_pattern_entry". */
+/* tomoyo_pattern_list is used for holding list of pathnames which are used for
+ * converting pathnames to pathname patterns during learning mode.
+ *
+ * An entry is added by
+ *
+ * # echo 'file_pattern /proc/\$/mounts' > \
+ *                             /sys/kernel/security/tomoyo/exception_policy
+ *
+ * and is deleted by
+ *
+ * # echo 'delete file_pattern /proc/\$/mounts' > \
+ *                             /sys/kernel/security/tomoyo/exception_policy
+ *
+ * and all entries are retrieved by
+ *
+ * # grep ^file_pattern /sys/kernel/security/tomoyo/exception_policy
+ *
+ * In the example above, if a process which belongs to a domain which is in
+ * learning mode requested open("/proc/1/mounts", O_RDONLY),
+ * "allow_read /proc/\$/mounts" is automatically added to the domain which that
+ * process belongs to.
+ *
+ * It is not a desirable behavior that we have to use /proc/\$/ instead of
+ * /proc/self/ when current process needs to access only current process's
+ * information. As of now, LSM version of TOMOYO is using __d_path() for
+ * calculating pathname. Non LSM version of TOMOYO is using its own function
+ * which pretends as if /proc/self/ is not a symlink; so that we can forbid
+ * current process from accessing other process's information.
+ */
 static LIST_HEAD(tomoyo_pattern_list);
 static DECLARE_RWSEM(tomoyo_pattern_list_lock);
 
@@ -284,7 +362,6 @@ static int tomoyo_update_file_pattern_entry(const char *pattern,
         saved_pattern = tomoyo_save_name(pattern);
         if (!saved_pattern)
                 return -ENOMEM;
-        /***** EXCLUSIVE SECTION START *****/
         down_write(&tomoyo_pattern_list_lock);
         list_for_each_entry(ptr, &tomoyo_pattern_list, list) {
                 if (saved_pattern != ptr->pattern)
@@ -305,7 +382,6 @@ static int tomoyo_update_file_pattern_entry(const char *pattern,
         error = 0;
  out:
         up_write(&tomoyo_pattern_list_lock);
-        /***** EXCLUSIVE SECTION END *****/
         return error;
 }
 
@@ -373,17 +449,44 @@ bool tomoyo_read_file_pattern(struct tomoyo_io_buffer *head)
                 ptr = list_entry(pos, struct tomoyo_pattern_entry, list);
                 if (ptr->is_deleted)
                         continue;
-                if (!tomoyo_io_printf(head, TOMOYO_KEYWORD_FILE_PATTERN "%s\n",
-                                      ptr->pattern->name)) {
-                        done = false;
+                done = tomoyo_io_printf(head, TOMOYO_KEYWORD_FILE_PATTERN
+                                        "%s\n", ptr->pattern->name);
+                if (!done)
                         break;
-                }
         }
         up_read(&tomoyo_pattern_list_lock);
         return done;
 }
 
-/* The list for "struct tomoyo_no_rewrite_entry". */
+/*
+ * tomoyo_no_rewrite_list is used for holding list of pathnames which are by
+ * default forbidden to modify already written content of a file.
+ *
+ * An entry is added by
+ *
+ * # echo 'deny_rewrite /var/log/messages' > \
+ *                              /sys/kernel/security/tomoyo/exception_policy
+ *
+ * and is deleted by
+ *
+ * # echo 'delete deny_rewrite /var/log/messages' > \
+ *                              /sys/kernel/security/tomoyo/exception_policy
+ *
+ * and all entries are retrieved by
+ *
+ * # grep ^deny_rewrite /sys/kernel/security/tomoyo/exception_policy
+ *
+ * In the example above, if a process requested to rewrite /var/log/messages ,
+ * the process can't rewrite unless the domain which that process belongs to
+ * has "allow_rewrite /var/log/messages" entry.
+ *
+ * It is not a desirable behavior that we have to add "\040(deleted)" suffix
+ * when we want to allow rewriting already unlink()ed file. As of now,
+ * LSM version of TOMOYO is using __d_path() for calculating pathname.
+ * Non LSM version of TOMOYO is using its own function which doesn't append
+ * " (deleted)" suffix if the file is already unlink()ed; so that we don't
+ * need to worry whether the file is already unlink()ed or not.
+ */
 static LIST_HEAD(tomoyo_no_rewrite_list);
 static DECLARE_RWSEM(tomoyo_no_rewrite_list_lock);
 
@@ -407,7 +510,6 @@ static int tomoyo_update_no_rewrite_entry(const char *pattern,
         saved_pattern = tomoyo_save_name(pattern);
         if (!saved_pattern)
                 return -ENOMEM;
-        /***** EXCLUSIVE SECTION START *****/
         down_write(&tomoyo_no_rewrite_list_lock);
         list_for_each_entry(ptr, &tomoyo_no_rewrite_list, list) {
                 if (ptr->pattern != saved_pattern)
@@ -428,7 +530,6 @@ static int tomoyo_update_no_rewrite_entry(const char *pattern,
         error = 0;
  out:
         up_write(&tomoyo_no_rewrite_list_lock);
-        /***** EXCLUSIVE SECTION END *****/
         return error;
 }
 
@@ -489,11 +590,10 @@ bool tomoyo_read_no_rewrite_policy(struct tomoyo_io_buffer *head)
                 ptr = list_entry(pos, struct tomoyo_no_rewrite_entry, list);
                 if (ptr->is_deleted)
                         continue;
-                if (!tomoyo_io_printf(head, TOMOYO_KEYWORD_DENY_REWRITE "%s\n",
-                                      ptr->pattern->name)) {
-                        done = false;
+                done = tomoyo_io_printf(head, TOMOYO_KEYWORD_DENY_REWRITE
+                                        "%s\n", ptr->pattern->name);
+                if (!done)
                         break;
-                }
         }
         up_read(&tomoyo_no_rewrite_list_lock);
         return done;
@@ -745,7 +845,6 @@ static int tomoyo_update_single_path_acl(const u8 type, const char *filename,
         saved_filename = tomoyo_save_name(filename);
         if (!saved_filename)
                 return -ENOMEM;
-        /***** EXCLUSIVE SECTION START *****/
         down_write(&tomoyo_domain_acl_info_list_lock);
         if (is_delete)
                 goto delete;
@@ -800,7 +899,6 @@ static int tomoyo_update_single_path_acl(const u8 type, const char *filename,
         }
  out:
         up_write(&tomoyo_domain_acl_info_list_lock);
-        /***** EXCLUSIVE SECTION END *****/
         return error;
 }
 
@@ -836,7 +934,6 @@ static int tomoyo_update_double_path_acl(const u8 type, const char *filename1,
         saved_filename2 = tomoyo_save_name(filename2);
         if (!saved_filename1 || !saved_filename2)
                 return -ENOMEM;
-        /***** EXCLUSIVE SECTION START *****/
         down_write(&tomoyo_domain_acl_info_list_lock);
         if (is_delete)
                 goto delete;
@@ -884,7 +981,6 @@ static int tomoyo_update_double_path_acl(const u8 type, const char *filename1,
         }
  out:
         up_write(&tomoyo_domain_acl_info_list_lock);
-        /***** EXCLUSIVE SECTION END *****/
         return error;
 }
 
@@ -1025,13 +1121,11 @@ int tomoyo_check_file_perm(struct tomoyo_domain_info *domain,
  *
  * @domain:   Pointer to "struct tomoyo_domain_info".
  * @filename: Check permission for "execute".
- * @tmp:      Buffer for temporary use.
  *
  * Returns 0 on success, negativevalue otherwise.
  */
 int tomoyo_check_exec_perm(struct tomoyo_domain_info *domain,
-                           const struct tomoyo_path_info *filename,
-                           struct tomoyo_page_buffer *tmp)
+                           const struct tomoyo_path_info *filename)
 {
         const u8 mode = tomoyo_check_flags(domain, TOMOYO_MAC_FOR_FILE);
 
diff --git a/security/tomoyo/realpath.c b/security/tomoyo/realpath.c
index 40927a84cb6e..5f2e33263371 100644
--- a/security/tomoyo/realpath.c
+++ b/security/tomoyo/realpath.c
@@ -220,7 +220,6 @@ void *tomoyo_alloc_element(const unsigned int size)
                 = roundup(size, max(sizeof(void *), sizeof(long)));
         if (word_aligned_size > PATH_MAX)
                 return NULL;
-        /***** EXCLUSIVE SECTION START *****/
         mutex_lock(&lock);
         if (buf_used_len + word_aligned_size > PATH_MAX) {
                 if (!tomoyo_quota_for_elements ||
@@ -251,7 +250,6 @@ void *tomoyo_alloc_element(const unsigned int size)
                 }
         }
         mutex_unlock(&lock);
-        /***** EXCLUSIVE SECTION END *****/
         return ptr;
 }
 
@@ -267,7 +265,16 @@ static unsigned int tomoyo_quota_for_savename;
  */
 #define TOMOYO_MAX_HASH 256
 
-/* Structure for string data. */
+/*
+ * tomoyo_name_entry is a structure which is used for linking
+ * "struct tomoyo_path_info" into tomoyo_name_list .
+ *
+ * Since tomoyo_name_list manages a list of strings which are shared by
+ * multiple processes (whereas "struct tomoyo_path_info" inside
+ * "struct tomoyo_path_info_with_data" is not shared), a reference counter will
+ * be added to "struct tomoyo_name_entry" rather than "struct tomoyo_path_info"
+ * when TOMOYO starts supporting garbage collector.
+ */
 struct tomoyo_name_entry {
         struct list_head list;
         struct tomoyo_path_info entry;
@@ -281,10 +288,10 @@ struct tomoyo_free_memory_block_list {
 };
 
 /*
- * The list for "struct tomoyo_name_entry".
- *
- * This list is updated only inside tomoyo_save_name(), thus
- * no global mutex exists.
+ * tomoyo_name_list is used for holding string data used by TOMOYO.
+ * Since same string data is likely used for multiple times (e.g.
+ * "/lib/libc-2.5.so"), TOMOYO shares string data in the form of
+ * "const struct tomoyo_path_info *".
  */
 static struct list_head tomoyo_name_list[TOMOYO_MAX_HASH];
 
@@ -318,7 +325,6 @@ const struct tomoyo_path_info *tomoyo_save_name(const char *name)
                 return NULL;
         }
         hash = full_name_hash((const unsigned char *) name, len - 1);
-        /***** EXCLUSIVE SECTION START *****/
         mutex_lock(&lock);
         list_for_each_entry(ptr, &tomoyo_name_list[hash % TOMOYO_MAX_HASH],
                              list) {
@@ -366,7 +372,6 @@ const struct tomoyo_path_info *tomoyo_save_name(const char *name)
         }
  out:
         mutex_unlock(&lock);
-        /***** EXCLUSIVE SECTION END *****/
         return ptr ? &ptr->entry : NULL;
 }
 
diff --git a/security/tomoyo/tomoyo.c b/security/tomoyo/tomoyo.c
index e42be5c4f055..3194d09fe0f4 100644
--- a/security/tomoyo/tomoyo.c
+++ b/security/tomoyo/tomoyo.c
@@ -262,6 +262,10 @@ static int tomoyo_dentry_open(struct file *f, const struct cred *cred)
         return tomoyo_check_open_permission(tomoyo_domain(), &f->f_path, flags);
 }
 
+/*
+ * tomoyo_security_ops is a "struct security_operations" which is used for
+ * registering TOMOYO.
+ */
 static struct security_operations tomoyo_security_ops = {
         .name                = "tomoyo",
         .cred_prepare        = tomoyo_cred_prepare,
diff --git a/security/tomoyo/tomoyo.h b/security/tomoyo/tomoyo.h
index 41c6ebafb9c5..0fd588a629cf 100644
--- a/security/tomoyo/tomoyo.h
+++ b/security/tomoyo/tomoyo.h
@@ -17,13 +17,11 @@ struct path;
 struct inode;
 struct linux_binprm;
 struct pt_regs;
-struct tomoyo_page_buffer;
 
 int tomoyo_check_file_perm(struct tomoyo_domain_info *domain,
                            const char *filename, const u8 perm);
 int tomoyo_check_exec_perm(struct tomoyo_domain_info *domain,
-                           const struct tomoyo_path_info *filename,
-                           struct tomoyo_page_buffer *buf);
+                           const struct tomoyo_path_info *filename);
 int tomoyo_check_open_permission(struct tomoyo_domain_info *domain,
                                  struct path *path, const int flag);
 int tomoyo_check_1path_perm(struct tomoyo_domain_info *domain,
@@ -90,17 +88,10 @@ static inline struct tomoyo_domain_info *tomoyo_domain(void)
         return current_cred()->security;
 }
 
-/* Caller holds tasklist_lock spinlock. */
 static inline struct tomoyo_domain_info *tomoyo_real_domain(struct task_struct
                                                             *task)
 {
-        /***** CRITICAL SECTION START *****/
-        const struct cred *cred = get_task_cred(task);
-        struct tomoyo_domain_info *domain = cred->security;
-
-        put_cred(cred);
-        return domain;
-        /***** CRITICAL SECTION END *****/
+        return task_cred_xxx(task, security);
 }
 
 #endif /* !defined(_SECURITY_TOMOYO_TOMOYO_H) */
diff --git a/sound/oss/Kconfig b/sound/oss/Kconfig
index 1ca7427c4b6d..bcf2a0698d54 100644
--- a/sound/oss/Kconfig
+++ b/sound/oss/Kconfig
@@ -561,7 +561,7 @@ endif	# SOUND_OSS
 
 config SOUND_SH_DAC_AUDIO
         tristate "SuperH DAC audio support"
-        depends on CPU_SH3
+        depends on CPU_SH3 && HIGH_RES_TIMERS
 
 config SOUND_SH_DAC_AUDIO_CHANNEL
         int "DAC channel"
diff --git a/sound/oss/sh_dac_audio.c b/sound/oss/sh_dac_audio.c
index 78cfb66e4c59..b2ed8757542a 100644
--- a/sound/oss/sh_dac_audio.c
+++ b/sound/oss/sh_dac_audio.c
@@ -18,47 +18,36 @@
 #include <linux/sound.h>
 #include <linux/soundcard.h>
 #include <linux/interrupt.h>
+#include <linux/hrtimer.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
 #include <asm/irq.h>
 #include <asm/delay.h>
 #include <asm/clock.h>
-#include <asm/cpu/dac.h>
-#include <asm/cpu/timer.h>
+#include <cpu/dac.h>
 #include <asm/machvec.h>
 #include <mach/hp6xx.h>
 #include <asm/hd64461.h>
 
 #define MODNAME "sh_dac_audio"
 
-#define TMU_TOCR_INIT   0x00
-
-#define TMU1_TCR_INIT   0x0020  /* Clock/4, rising edge; interrupt on */
-#define TMU1_TSTR_INIT  0x02    /* Bit to turn on TMU1 */
-
 #define BUFFER_SIZE 48000
 
 static int rate;
 static int empty;
 static char *data_buffer, *buffer_begin, *buffer_end;
 static int in_use, device_major;
+static struct hrtimer hrtimer;
+static ktime_t wakeups_per_second;
 
 static void dac_audio_start_timer(void)
 {
-        u8 tstr;
-
-        tstr = ctrl_inb(TMU_TSTR);
-        tstr |= TMU1_TSTR_INIT;
-        ctrl_outb(tstr, TMU_TSTR);
+        hrtimer_start(&hrtimer, wakeups_per_second, HRTIMER_MODE_REL);
 }
 
 static void dac_audio_stop_timer(void)
 {
-        u8 tstr;
-
-        tstr = ctrl_inb(TMU_TSTR);
-        tstr &= ~TMU1_TSTR_INIT;
-        ctrl_outb(tstr, TMU_TSTR);
+        hrtimer_cancel(&hrtimer);
 }
 
 static void dac_audio_reset(void)
@@ -77,38 +66,30 @@ static void dac_audio_sync(void)
 static void dac_audio_start(void)
 {
         if (mach_is_hp6xx()) {
-                u16 v = inw(HD64461_GPADR);
+                u16 v = __raw_readw(HD64461_GPADR);
                 v &= ~HD64461_GPADR_SPEAKER;
-                outw(v, HD64461_GPADR);
+                __raw_writew(v, HD64461_GPADR);
         }
 
         sh_dac_enable(CONFIG_SOUND_SH_DAC_AUDIO_CHANNEL);
-        ctrl_outw(TMU1_TCR_INIT, TMU1_TCR);
 }
 static void dac_audio_stop(void)
 {
         dac_audio_stop_timer();
 
         if (mach_is_hp6xx()) {
-                u16 v = inw(HD64461_GPADR);
+                u16 v = __raw_readw(HD64461_GPADR);
                 v |= HD64461_GPADR_SPEAKER;
-                outw(v, HD64461_GPADR);
+                __raw_writew(v, HD64461_GPADR);
         }
 
-        sh_dac_output(0, CONFIG_SOUND_SH_DAC_AUDIO_CHANNEL);
+        sh_dac_output(0, CONFIG_SOUND_SH_DAC_AUDIO_CHANNEL);
         sh_dac_disable(CONFIG_SOUND_SH_DAC_AUDIO_CHANNEL);
 }
 
 static void dac_audio_set_rate(void)
 {
-        unsigned long interval;
-        struct clk *clk;
-
-        clk = clk_get(NULL, "module_clk");
-        interval = (clk_get_rate(clk) / 4) / rate;
-        clk_put(clk);
-        ctrl_outl(interval, TMU1_TCOR);
-        ctrl_outl(interval, TMU1_TCNT);
+        wakeups_per_second = ktime_set(0, 1000000000 / rate);
 }
 
 static int dac_audio_ioctl(struct inode *inode, struct file *file,
@@ -265,32 +246,26 @@ const struct file_operations dac_audio_fops = {
       .release =        dac_audio_release,
 };
 
-static irqreturn_t timer1_interrupt(int irq, void *dev)
+static enum hrtimer_restart sh_dac_audio_timer(struct hrtimer *handle)
 {
-        unsigned long timer_status;
-
-        timer_status = ctrl_inw(TMU1_TCR);
-        timer_status &= ~0x100;
-        ctrl_outw(timer_status, TMU1_TCR);
-
         if (!empty) {
                 sh_dac_output(*buffer_begin, CONFIG_SOUND_SH_DAC_AUDIO_CHANNEL);
                 buffer_begin++;
 
                 if (buffer_begin == data_buffer + BUFFER_SIZE)
                         buffer_begin = data_buffer;
-                if (buffer_begin == buffer_end) {
+                if (buffer_begin == buffer_end)
                         empty = 1;
-                        dac_audio_stop_timer();
-                }
         }
-        return IRQ_HANDLED;
+
+        if (!empty)
+                hrtimer_start(&hrtimer, wakeups_per_second, HRTIMER_MODE_REL);
+
+        return HRTIMER_NORESTART;
 }
 
 static int __init dac_audio_init(void)
 {
-        int retval;
-
         if ((device_major = register_sound_dsp(&dac_audio_fops, -1)) < 0) {
                 printk(KERN_ERR "Cannot register dsp device");
                 return device_major;
@@ -306,21 +281,25 @@ static int __init dac_audio_init(void)
         rate = 8000;
         dac_audio_set_rate();
 
-        retval =
-            request_irq(TIMER1_IRQ, timer1_interrupt, IRQF_DISABLED, MODNAME, 0);
-        if (retval < 0) {
-                printk(KERN_ERR "sh_dac_audio: IRQ %d request failed\n",
-                       TIMER1_IRQ);
-                return retval;
-        }
+        /* Today: High Resolution Timer driven DAC playback.
+         * The timer callback gets called once per sample. Ouch.
+         *
+         * Future: A much better approach would be to use the
+         * SH7720 CMT+DMAC+DAC hardware combination like this:
+         * - Program sample rate using CMT0 or CMT1
+         * - Program DMAC to use CMT for timing and output to DAC
+         * - Play sound using DMAC, let CPU sleep.
+         * - While at it, rewrite this driver to use ALSA.
+         */
+
+        hrtimer_init(&hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
+        hrtimer.function = sh_dac_audio_timer;
 
         return 0;
 }
 
 static void __exit dac_audio_exit(void)
 {
-        free_irq(TIMER1_IRQ, 0);
-
         unregister_sound_dsp(device_major);
         kfree((void *)data_buffer);
 }
diff --git a/virt/kvm/ioapic.c b/virt/kvm/ioapic.c
index c3b99def9cbc..1eddae94bab3 100644
--- a/virt/kvm/ioapic.c
+++ b/virt/kvm/ioapic.c
@@ -85,7 +85,7 @@ static unsigned long ioapic_read_indirect(struct kvm_ioapic *ioapic,
 
 static int ioapic_service(struct kvm_ioapic *ioapic, unsigned int idx)
 {
-        union ioapic_redir_entry *pent;
+        union kvm_ioapic_redirect_entry *pent;
         int injected = -1;
 
         pent = &ioapic->redirtbl[idx];
@@ -142,149 +142,40 @@ static void ioapic_write_indirect(struct kvm_ioapic *ioapic, u32 val)
         }
 }
 
-static int ioapic_inj_irq(struct kvm_ioapic *ioapic,
-                           struct kvm_vcpu *vcpu,
-                           u8 vector, u8 trig_mode, u8 delivery_mode)
-{
-        ioapic_debug("irq %d trig %d deliv %d\n", vector, trig_mode,
-                     delivery_mode);
-
-        ASSERT((delivery_mode == IOAPIC_FIXED) ||
-               (delivery_mode == IOAPIC_LOWEST_PRIORITY));
-
-        return kvm_apic_set_irq(vcpu, vector, trig_mode);
-}
-
-static void ioapic_inj_nmi(struct kvm_vcpu *vcpu)
-{
-        kvm_inject_nmi(vcpu);
-        kvm_vcpu_kick(vcpu);
-}
-
-u32 kvm_ioapic_get_delivery_bitmask(struct kvm_ioapic *ioapic, u8 dest,
-                                    u8 dest_mode)
-{
-        u32 mask = 0;
-        int i;
-        struct kvm *kvm = ioapic->kvm;
-        struct kvm_vcpu *vcpu;
-
-        ioapic_debug("dest %d dest_mode %d\n", dest, dest_mode);
-
-        if (dest_mode == 0) {   /* Physical mode. */
-                if (dest == 0xFF) {     /* Broadcast. */
-                        for (i = 0; i < KVM_MAX_VCPUS; ++i)
-                                if (kvm->vcpus[i] && kvm->vcpus[i]->arch.apic)
-                                        mask |= 1 << i;
-                        return mask;
-                }
-                for (i = 0; i < KVM_MAX_VCPUS; ++i) {
-                        vcpu = kvm->vcpus[i];
-                        if (!vcpu)
-                                continue;
-                        if (kvm_apic_match_physical_addr(vcpu->arch.apic, dest)) {
-                                if (vcpu->arch.apic)
-                                        mask = 1 << i;
-                                break;
-                        }
-                }
-        } else if (dest != 0)   /* Logical mode, MDA non-zero. */
-                for (i = 0; i < KVM_MAX_VCPUS; ++i) {
-                        vcpu = kvm->vcpus[i];
-                        if (!vcpu)
-                                continue;
-                        if (vcpu->arch.apic &&
-                            kvm_apic_match_logical_addr(vcpu->arch.apic, dest))
-                                mask |= 1 << vcpu->vcpu_id;
-                }
-        ioapic_debug("mask %x\n", mask);
-        return mask;
-}
-
 static int ioapic_deliver(struct kvm_ioapic *ioapic, int irq)
 {
-        u8 dest = ioapic->redirtbl[irq].fields.dest_id;
-        u8 dest_mode = ioapic->redirtbl[irq].fields.dest_mode;
-        u8 delivery_mode = ioapic->redirtbl[irq].fields.delivery_mode;
-        u8 vector = ioapic->redirtbl[irq].fields.vector;
-        u8 trig_mode = ioapic->redirtbl[irq].fields.trig_mode;
-        u32 deliver_bitmask;
-        struct kvm_vcpu *vcpu;
-        int vcpu_id, r = -1;
+        union kvm_ioapic_redirect_entry *entry = &ioapic->redirtbl[irq];
+        struct kvm_lapic_irq irqe;
 
         ioapic_debug("dest=%x dest_mode=%x delivery_mode=%x "
                      "vector=%x trig_mode=%x\n",
-                     dest, dest_mode, delivery_mode, vector, trig_mode);
-
-        deliver_bitmask = kvm_ioapic_get_delivery_bitmask(ioapic, dest,
-                                                          dest_mode);
-        if (!deliver_bitmask) {
-                ioapic_debug("no target on destination\n");
-                return 0;
-        }
+                     entry->fields.dest, entry->fields.dest_mode,
+                     entry->fields.delivery_mode, entry->fields.vector,
+                     entry->fields.trig_mode);
+
+        irqe.dest_id = entry->fields.dest_id;
+        irqe.vector = entry->fields.vector;
+        irqe.dest_mode = entry->fields.dest_mode;
+        irqe.trig_mode = entry->fields.trig_mode;
+        irqe.delivery_mode = entry->fields.delivery_mode << 8;
+        irqe.level = 1;
+        irqe.shorthand = 0;
 
-        switch (delivery_mode) {
-        case IOAPIC_LOWEST_PRIORITY:
-                vcpu = kvm_get_lowest_prio_vcpu(ioapic->kvm, vector,
-                                deliver_bitmask);
 #ifdef CONFIG_X86
-                if (irq == 0)
-                        vcpu = ioapic->kvm->vcpus[0];
-#endif
-                if (vcpu != NULL)
-                        r = ioapic_inj_irq(ioapic, vcpu, vector,
-                                       trig_mode, delivery_mode);
-                else
-                        ioapic_debug("null lowest prio vcpu: "
-                                     "mask=%x vector=%x delivery_mode=%x\n",
-                                     deliver_bitmask, vector, IOAPIC_LOWEST_PRIORITY);
-                break;
-        case IOAPIC_FIXED:
-#ifdef CONFIG_X86
-                if (irq == 0)
-                        deliver_bitmask = 1;
-#endif
-                for (vcpu_id = 0; deliver_bitmask != 0; vcpu_id++) {
-                        if (!(deliver_bitmask & (1 << vcpu_id)))
-                                continue;
-                        deliver_bitmask &= ~(1 << vcpu_id);
-                        vcpu = ioapic->kvm->vcpus[vcpu_id];
-                        if (vcpu) {
-                                if (r < 0)
-                                        r = 0;
-                                r += ioapic_inj_irq(ioapic, vcpu, vector,
-                                               trig_mode, delivery_mode);
-                        }
-                }
-                break;
-        case IOAPIC_NMI:
-                for (vcpu_id = 0; deliver_bitmask != 0; vcpu_id++) {
-                        if (!(deliver_bitmask & (1 << vcpu_id)))
-                                continue;
-                        deliver_bitmask &= ~(1 << vcpu_id);
-                        vcpu = ioapic->kvm->vcpus[vcpu_id];
-                        if (vcpu) {
-                                ioapic_inj_nmi(vcpu);
-                                r = 1;
-                        }
-                        else
-                                ioapic_debug("NMI to vcpu %d failed\n",
-                                                vcpu->vcpu_id);
-                }
-                break;
-        default:
-                printk(KERN_WARNING "Unsupported delivery mode %d\n",
-                       delivery_mode);
-                break;
+        /* Always delivery PIT interrupt to vcpu 0 */
+        if (irq == 0) {
+                irqe.dest_mode = 0; /* Physical mode. */
+                irqe.dest_id = ioapic->kvm->vcpus[0]->vcpu_id;
         }
-        return r;
+#endif
+        return kvm_irq_delivery_to_apic(ioapic->kvm, NULL, &irqe);
 }
 
 int kvm_ioapic_set_irq(struct kvm_ioapic *ioapic, int irq, int level)
 {
         u32 old_irr = ioapic->irr;
         u32 mask = 1 << irq;
-        union ioapic_redir_entry entry;
+        union kvm_ioapic_redirect_entry entry;
         int ret = 1;
 
         if (irq >= 0 && irq < IOAPIC_NUM_PINS) {
@@ -305,7 +196,7 @@ int kvm_ioapic_set_irq(struct kvm_ioapic *ioapic, int irq, int level)
 static void __kvm_ioapic_update_eoi(struct kvm_ioapic *ioapic, int pin,
                                     int trigger_mode)
 {
-        union ioapic_redir_entry *ent;
+        union kvm_ioapic_redirect_entry *ent;
 
         ent = &ioapic->redirtbl[pin];
 
diff --git a/virt/kvm/ioapic.h b/virt/kvm/ioapic.h
index a34bd5e6436b..7080b713c160 100644
--- a/virt/kvm/ioapic.h
+++ b/virt/kvm/ioapic.h
@@ -40,22 +40,7 @@ struct kvm_ioapic {
         u32 id;
         u32 irr;
         u32 pad;
-        union ioapic_redir_entry {
-                u64 bits;
-                struct {
-                        u8 vector;
-                        u8 delivery_mode:3;
-                        u8 dest_mode:1;
-                        u8 delivery_status:1;
-                        u8 polarity:1;
-                        u8 remote_irr:1;
-                        u8 trig_mode:1;
-                        u8 mask:1;
-                        u8 reserve:7;
-                        u8 reserved[4];
-                        u8 dest_id;
-                } fields;
-        } redirtbl[IOAPIC_NUM_PINS];
+        union kvm_ioapic_redirect_entry redirtbl[IOAPIC_NUM_PINS];
         struct kvm_io_device dev;
         struct kvm *kvm;
         void (*ack_notifier)(void *opaque, int irq);
@@ -79,13 +64,13 @@ static inline struct kvm_ioapic *ioapic_irqchip(struct kvm *kvm)
         return kvm->arch.vioapic;
 }
 
-struct kvm_vcpu *kvm_get_lowest_prio_vcpu(struct kvm *kvm, u8 vector,
-                                       unsigned long bitmap);
+int kvm_apic_match_dest(struct kvm_vcpu *vcpu, struct kvm_lapic *source,
+                int short_hand, int dest, int dest_mode);
+int kvm_apic_compare_prio(struct kvm_vcpu *vcpu1, struct kvm_vcpu *vcpu2);
 void kvm_ioapic_update_eoi(struct kvm *kvm, int vector, int trigger_mode);
 int kvm_ioapic_init(struct kvm *kvm);
 int kvm_ioapic_set_irq(struct kvm_ioapic *ioapic, int irq, int level);
 void kvm_ioapic_reset(struct kvm_ioapic *ioapic);
-u32 kvm_ioapic_get_delivery_bitmask(struct kvm_ioapic *ioapic, u8 dest,
-                                u8 dest_mode);
-
+int kvm_irq_delivery_to_apic(struct kvm *kvm, struct kvm_lapic *src,
+                struct kvm_lapic_irq *irq);
 #endif
diff --git a/virt/kvm/iommu.c b/virt/kvm/iommu.c
index 4c4037503600..15147583abd1 100644
--- a/virt/kvm/iommu.c
+++ b/virt/kvm/iommu.c
@@ -39,11 +39,16 @@ int kvm_iommu_map_pages(struct kvm *kvm,
         pfn_t pfn;
         int i, r = 0;
         struct iommu_domain *domain = kvm->arch.iommu_domain;
+        int flags;
 
         /* check if iommu exists and in use */
         if (!domain)
                 return 0;
 
+        flags = IOMMU_READ | IOMMU_WRITE;
+        if (kvm->arch.iommu_flags & KVM_IOMMU_CACHE_COHERENCY)
+                flags |= IOMMU_CACHE;
+
         for (i = 0; i < npages; i++) {
                 /* check if already mapped */
                 if (iommu_iova_to_phys(domain, gfn_to_gpa(gfn)))
@@ -53,8 +58,7 @@ int kvm_iommu_map_pages(struct kvm *kvm,
                 r = iommu_map_range(domain,
                                     gfn_to_gpa(gfn),
                                     pfn_to_hpa(pfn),
-                                    PAGE_SIZE,
-                                    IOMMU_READ | IOMMU_WRITE);
+                                    PAGE_SIZE, flags);
                 if (r) {
                         printk(KERN_ERR "kvm_iommu_map_address:"
                                "iommu failed to map pfn=%lx\n", pfn);
@@ -88,7 +92,7 @@ int kvm_assign_device(struct kvm *kvm,
 {
         struct pci_dev *pdev = NULL;
         struct iommu_domain *domain = kvm->arch.iommu_domain;
-        int r;
+        int r, last_flags;
 
         /* check if iommu exists and in use */
         if (!domain)
@@ -107,12 +111,29 @@ int kvm_assign_device(struct kvm *kvm,
                 return r;
         }
 
+        last_flags = kvm->arch.iommu_flags;
+        if (iommu_domain_has_cap(kvm->arch.iommu_domain,
+                                 IOMMU_CAP_CACHE_COHERENCY))
+                kvm->arch.iommu_flags |= KVM_IOMMU_CACHE_COHERENCY;
+
+        /* Check if need to update IOMMU page table for guest memory */
+        if ((last_flags ^ kvm->arch.iommu_flags) ==
+                        KVM_IOMMU_CACHE_COHERENCY) {
+                kvm_iommu_unmap_memslots(kvm);
+                r = kvm_iommu_map_memslots(kvm);
+                if (r)
+                        goto out_unmap;
+        }
+
         printk(KERN_DEBUG "assign device: host bdf = %x:%x:%x\n",
                 assigned_dev->host_busnr,
                 PCI_SLOT(assigned_dev->host_devfn),
                 PCI_FUNC(assigned_dev->host_devfn));
 
         return 0;
+out_unmap:
+        kvm_iommu_unmap_memslots(kvm);
+        return r;
 }
 
 int kvm_deassign_device(struct kvm *kvm,
diff --git a/virt/kvm/irq_comm.c b/virt/kvm/irq_comm.c
index 864ac5483baa..a8bd466d00cc 100644
--- a/virt/kvm/irq_comm.c
+++ b/virt/kvm/irq_comm.c
@@ -22,6 +22,9 @@
 #include <linux/kvm_host.h>
 
 #include <asm/msidef.h>
+#ifdef CONFIG_IA64
+#include <asm/iosapic.h>
+#endif
 
 #include "irq.h"
 
@@ -43,57 +46,73 @@ static int kvm_set_ioapic_irq(struct kvm_kernel_irq_routing_entry *e,
         return kvm_ioapic_set_irq(kvm->arch.vioapic, e->irqchip.pin, level);
 }
 
-static int kvm_set_msi(struct kvm_kernel_irq_routing_entry *e,
-                       struct kvm *kvm, int level)
+inline static bool kvm_is_dm_lowest_prio(struct kvm_lapic_irq *irq)
 {
-        int vcpu_id, r = -1;
-        struct kvm_vcpu *vcpu;
-        struct kvm_ioapic *ioapic = ioapic_irqchip(kvm);
-        int dest_id = (e->msi.address_lo & MSI_ADDR_DEST_ID_MASK)
-                        >> MSI_ADDR_DEST_ID_SHIFT;
-        int vector = (e->msi.data & MSI_DATA_VECTOR_MASK)
-                        >> MSI_DATA_VECTOR_SHIFT;
-        int dest_mode = test_bit(MSI_ADDR_DEST_MODE_SHIFT,
-                                (unsigned long *)&e->msi.address_lo);
-        int trig_mode = test_bit(MSI_DATA_TRIGGER_SHIFT,
-                                (unsigned long *)&e->msi.data);
-        int delivery_mode = test_bit(MSI_DATA_DELIVERY_MODE_SHIFT,
-                                (unsigned long *)&e->msi.data);
-        u32 deliver_bitmask;
-
-        BUG_ON(!ioapic);
-
-        deliver_bitmask = kvm_ioapic_get_delivery_bitmask(ioapic,
-                                dest_id, dest_mode);
-        /* IOAPIC delivery mode value is the same as MSI here */
-        switch (delivery_mode) {
-        case IOAPIC_LOWEST_PRIORITY:
-                vcpu = kvm_get_lowest_prio_vcpu(ioapic->kvm, vector,
-                                deliver_bitmask);
-                if (vcpu != NULL)
-                        r = kvm_apic_set_irq(vcpu, vector, trig_mode);
-                else
-                        printk(KERN_INFO "kvm: null lowest priority vcpu!\n");
-                break;
-        case IOAPIC_FIXED:
-                for (vcpu_id = 0; deliver_bitmask != 0; vcpu_id++) {
-                        if (!(deliver_bitmask & (1 << vcpu_id)))
-                                continue;
-                        deliver_bitmask &= ~(1 << vcpu_id);
-                        vcpu = ioapic->kvm->vcpus[vcpu_id];
-                        if (vcpu) {
-                                if (r < 0)
-                                        r = 0;
-                                r += kvm_apic_set_irq(vcpu, vector, trig_mode);
-                        }
+#ifdef CONFIG_IA64
+        return irq->delivery_mode ==
+                (IOSAPIC_LOWEST_PRIORITY << IOSAPIC_DELIVERY_SHIFT);
+#else
+        return irq->delivery_mode == APIC_DM_LOWEST;
+#endif
+}
+
+int kvm_irq_delivery_to_apic(struct kvm *kvm, struct kvm_lapic *src,
+                struct kvm_lapic_irq *irq)
+{
+        int i, r = -1;
+        struct kvm_vcpu *vcpu, *lowest = NULL;
+
+        if (irq->dest_mode == 0 && irq->dest_id == 0xff &&
+                        kvm_is_dm_lowest_prio(irq))
+                printk(KERN_INFO "kvm: apic: phys broadcast and lowest prio\n");
+
+        for (i = 0; i < KVM_MAX_VCPUS; i++) {
+                vcpu = kvm->vcpus[i];
+
+                if (!vcpu || !kvm_apic_present(vcpu))
+                        continue;
+
+                if (!kvm_apic_match_dest(vcpu, src, irq->shorthand,
+                                        irq->dest_id, irq->dest_mode))
+                        continue;
+
+                if (!kvm_is_dm_lowest_prio(irq)) {
+                        if (r < 0)
+                                r = 0;
+                        r += kvm_apic_set_irq(vcpu, irq);
+                } else {
+                        if (!lowest)
+                                lowest = vcpu;
+                        else if (kvm_apic_compare_prio(vcpu, lowest) < 0)
+                                lowest = vcpu;
                 }
-                break;
-        default:
-                break;
         }
+
+        if (lowest)
+                r = kvm_apic_set_irq(lowest, irq);
+
         return r;
 }
 
+static int kvm_set_msi(struct kvm_kernel_irq_routing_entry *e,
+                       struct kvm *kvm, int level)
+{
+        struct kvm_lapic_irq irq;
+
+        irq.dest_id = (e->msi.address_lo &
+                        MSI_ADDR_DEST_ID_MASK) >> MSI_ADDR_DEST_ID_SHIFT;
+        irq.vector = (e->msi.data &
+                        MSI_DATA_VECTOR_MASK) >> MSI_DATA_VECTOR_SHIFT;
+        irq.dest_mode = (1 << MSI_ADDR_DEST_MODE_SHIFT) & e->msi.address_lo;
+        irq.trig_mode = (1 << MSI_DATA_TRIGGER_SHIFT) & e->msi.data;
+        irq.delivery_mode = e->msi.data & 0x700;
+        irq.level = 1;
+        irq.shorthand = 0;
+
+        /* TODO Deal with RH bit of MSI message address */
+        return kvm_irq_delivery_to_apic(kvm, NULL, &irq);
+}
+
 /* This should be called with the kvm->lock mutex held
  * Return value:
  *  < 0   Interrupt was ignored (masked or not delivered for other reasons)
@@ -252,7 +271,7 @@ static int setup_routing_entry(struct kvm_kernel_irq_routing_entry *e,
                         delta = 8;
                         break;
                 case KVM_IRQCHIP_IOAPIC:
-                                e->set = kvm_set_ioapic_irq;
+                        e->set = kvm_set_ioapic_irq;
                         break;
                 default:
                         goto out;
diff --git a/virt/kvm/kvm_main.c b/virt/kvm/kvm_main.c
index 4d0dd390aa50..e21194566b71 100644
--- a/virt/kvm/kvm_main.c
+++ b/virt/kvm/kvm_main.c
@@ -41,6 +41,8 @@
 #include <linux/pagemap.h>
 #include <linux/mman.h>
 #include <linux/swap.h>
+#include <linux/bitops.h>
+#include <linux/spinlock.h>
 
 #include <asm/processor.h>
 #include <asm/io.h>
@@ -60,9 +62,6 @@
 MODULE_AUTHOR("Qumranet");
 MODULE_LICENSE("GPL");
 
-static int msi2intx = 1;
-module_param(msi2intx, bool, 0);
-
 DEFINE_SPINLOCK(kvm_lock);
 LIST_HEAD(vm_list);
 
@@ -95,38 +94,96 @@ static struct kvm_assigned_dev_kernel *kvm_find_assigned_dev(struct list_head *h
         return NULL;
 }
 
+static int find_index_from_host_irq(struct kvm_assigned_dev_kernel
+                                    *assigned_dev, int irq)
+{
+        int i, index;
+        struct msix_entry *host_msix_entries;
+
+        host_msix_entries = assigned_dev->host_msix_entries;
+
+        index = -1;
+        for (i = 0; i < assigned_dev->entries_nr; i++)
+                if (irq == host_msix_entries[i].vector) {
+                        index = i;
+                        break;
+                }
+        if (index < 0) {
+                printk(KERN_WARNING "Fail to find correlated MSI-X entry!\n");
+                return 0;
+        }
+
+        return index;
+}
+
 static void kvm_assigned_dev_interrupt_work_handler(struct work_struct *work)
 {
         struct kvm_assigned_dev_kernel *assigned_dev;
+        struct kvm *kvm;
+        int irq, i;
 
         assigned_dev = container_of(work, struct kvm_assigned_dev_kernel,
                                     interrupt_work);
+        kvm = assigned_dev->kvm;
 
         /* This is taken to safely inject irq inside the guest. When
          * the interrupt injection (or the ioapic code) uses a
          * finer-grained lock, update this
          */
-        mutex_lock(&assigned_dev->kvm->lock);
-        kvm_set_irq(assigned_dev->kvm, assigned_dev->irq_source_id,
-                    assigned_dev->guest_irq, 1);
-
-        if (assigned_dev->irq_requested_type & KVM_ASSIGNED_DEV_GUEST_MSI) {
-                enable_irq(assigned_dev->host_irq);
-                assigned_dev->host_irq_disabled = false;
+        mutex_lock(&kvm->lock);
+        spin_lock_irq(&assigned_dev->assigned_dev_lock);
+        if (assigned_dev->irq_requested_type & KVM_DEV_IRQ_HOST_MSIX) {
+                struct kvm_guest_msix_entry *guest_entries =
+                        assigned_dev->guest_msix_entries;
+                for (i = 0; i < assigned_dev->entries_nr; i++) {
+                        if (!(guest_entries[i].flags &
+                                        KVM_ASSIGNED_MSIX_PENDING))
+                                continue;
+                        guest_entries[i].flags &= ~KVM_ASSIGNED_MSIX_PENDING;
+                        kvm_set_irq(assigned_dev->kvm,
+                                    assigned_dev->irq_source_id,
+                                    guest_entries[i].vector, 1);
+                        irq = assigned_dev->host_msix_entries[i].vector;
+                        if (irq != 0)
+                                enable_irq(irq);
+                        assigned_dev->host_irq_disabled = false;
+                }
+        } else {
+                kvm_set_irq(assigned_dev->kvm, assigned_dev->irq_source_id,
+                            assigned_dev->guest_irq, 1);
+                if (assigned_dev->irq_requested_type &
+                                KVM_DEV_IRQ_GUEST_MSI) {
+                        enable_irq(assigned_dev->host_irq);
+                        assigned_dev->host_irq_disabled = false;
+                }
         }
+
+        spin_unlock_irq(&assigned_dev->assigned_dev_lock);
         mutex_unlock(&assigned_dev->kvm->lock);
 }
 
 static irqreturn_t kvm_assigned_dev_intr(int irq, void *dev_id)
 {
+        unsigned long flags;
         struct kvm_assigned_dev_kernel *assigned_dev =
                 (struct kvm_assigned_dev_kernel *) dev_id;
 
+        spin_lock_irqsave(&assigned_dev->assigned_dev_lock, flags);
+        if (assigned_dev->irq_requested_type & KVM_DEV_IRQ_HOST_MSIX) {
+                int index = find_index_from_host_irq(assigned_dev, irq);
+                if (index < 0)
+                        goto out;
+                assigned_dev->guest_msix_entries[index].flags |=
+                        KVM_ASSIGNED_MSIX_PENDING;
+        }
+
         schedule_work(&assigned_dev->interrupt_work);
 
         disable_irq_nosync(irq);
         assigned_dev->host_irq_disabled = true;
 
+out:
+        spin_unlock_irqrestore(&assigned_dev->assigned_dev_lock, flags);
         return IRQ_HANDLED;
 }
 
@@ -134,6 +191,7 @@ static irqreturn_t kvm_assigned_dev_intr(int irq, void *dev_id)
 static void kvm_assigned_dev_ack_irq(struct kvm_irq_ack_notifier *kian)
 {
         struct kvm_assigned_dev_kernel *dev;
+        unsigned long flags;
 
         if (kian->gsi == -1)
                 return;
@@ -146,28 +204,30 @@ static void kvm_assigned_dev_ack_irq(struct kvm_irq_ack_notifier *kian)
         /* The guest irq may be shared so this ack may be
          * from another device.
          */
+        spin_lock_irqsave(&dev->assigned_dev_lock, flags);
         if (dev->host_irq_disabled) {
                 enable_irq(dev->host_irq);
                 dev->host_irq_disabled = false;
         }
+        spin_unlock_irqrestore(&dev->assigned_dev_lock, flags);
 }
 
-/* The function implicit hold kvm->lock mutex due to cancel_work_sync() */
-static void kvm_free_assigned_irq(struct kvm *kvm,
-                                  struct kvm_assigned_dev_kernel *assigned_dev)
+static void deassign_guest_irq(struct kvm *kvm,
+                               struct kvm_assigned_dev_kernel *assigned_dev)
 {
-        if (!irqchip_in_kernel(kvm))
-                return;
-
         kvm_unregister_irq_ack_notifier(&assigned_dev->ack_notifier);
+        assigned_dev->ack_notifier.gsi = -1;
 
         if (assigned_dev->irq_source_id != -1)
                 kvm_free_irq_source_id(kvm, assigned_dev->irq_source_id);
         assigned_dev->irq_source_id = -1;
+        assigned_dev->irq_requested_type &= ~(KVM_DEV_IRQ_GUEST_MASK);
+}
 
-        if (!assigned_dev->irq_requested_type)
-                return;
-
+/* The function implicit hold kvm->lock mutex due to cancel_work_sync() */
+static void deassign_host_irq(struct kvm *kvm,
+                              struct kvm_assigned_dev_kernel *assigned_dev)
+{
         /*
          * In kvm_free_device_irq, cancel_work_sync return true if:
          * 1. work is scheduled, and then cancelled.
@@ -184,17 +244,64 @@ static void kvm_free_assigned_irq(struct kvm *kvm,
          * now, the kvm state is still legal for probably we also have to wait
          * interrupt_work done.
          */
-        disable_irq_nosync(assigned_dev->host_irq);
-        cancel_work_sync(&assigned_dev->interrupt_work);
+        if (assigned_dev->irq_requested_type & KVM_DEV_IRQ_HOST_MSIX) {
+                int i;
+                for (i = 0; i < assigned_dev->entries_nr; i++)
+                        disable_irq_nosync(assigned_dev->
+                                           host_msix_entries[i].vector);
+
+                cancel_work_sync(&assigned_dev->interrupt_work);
+
+                for (i = 0; i < assigned_dev->entries_nr; i++)
+                        free_irq(assigned_dev->host_msix_entries[i].vector,
+                                 (void *)assigned_dev);
+
+                assigned_dev->entries_nr = 0;
+                kfree(assigned_dev->host_msix_entries);
+                kfree(assigned_dev->guest_msix_entries);
+                pci_disable_msix(assigned_dev->dev);
+        } else {
+                /* Deal with MSI and INTx */
+                disable_irq_nosync(assigned_dev->host_irq);
+                cancel_work_sync(&assigned_dev->interrupt_work);
 
-        free_irq(assigned_dev->host_irq, (void *)assigned_dev);
+                free_irq(assigned_dev->host_irq, (void *)assigned_dev);
 
-        if (assigned_dev->irq_requested_type & KVM_ASSIGNED_DEV_HOST_MSI)
-                pci_disable_msi(assigned_dev->dev);
+                if (assigned_dev->irq_requested_type & KVM_DEV_IRQ_HOST_MSI)
+                        pci_disable_msi(assigned_dev->dev);
+        }
 
-        assigned_dev->irq_requested_type = 0;
+        assigned_dev->irq_requested_type &= ~(KVM_DEV_IRQ_HOST_MASK);
 }
 
+static int kvm_deassign_irq(struct kvm *kvm,
+                            struct kvm_assigned_dev_kernel *assigned_dev,
+                            unsigned long irq_requested_type)
+{
+        unsigned long guest_irq_type, host_irq_type;
+
+        if (!irqchip_in_kernel(kvm))
+                return -EINVAL;
+        /* no irq assignment to deassign */
+        if (!assigned_dev->irq_requested_type)
+                return -ENXIO;
+
+        host_irq_type = irq_requested_type & KVM_DEV_IRQ_HOST_MASK;
+        guest_irq_type = irq_requested_type & KVM_DEV_IRQ_GUEST_MASK;
+
+        if (host_irq_type)
+                deassign_host_irq(kvm, assigned_dev);
+        if (guest_irq_type)
+                deassign_guest_irq(kvm, assigned_dev);
+
+        return 0;
+}
+
+static void kvm_free_assigned_irq(struct kvm *kvm,
+                                  struct kvm_assigned_dev_kernel *assigned_dev)
+{
+        kvm_deassign_irq(kvm, assigned_dev, assigned_dev->irq_requested_type);
+}
 
 static void kvm_free_assigned_device(struct kvm *kvm,
                                      struct kvm_assigned_dev_kernel
@@ -226,190 +333,244 @@ void kvm_free_all_assigned_devices(struct kvm *kvm)
         }
 }
 
-static int assigned_device_update_intx(struct kvm *kvm,
-                        struct kvm_assigned_dev_kernel *adev,
-                        struct kvm_assigned_irq *airq)
+static int assigned_device_enable_host_intx(struct kvm *kvm,
+                                            struct kvm_assigned_dev_kernel *dev)
 {
-        adev->guest_irq = airq->guest_irq;
-        adev->ack_notifier.gsi = airq->guest_irq;
+        dev->host_irq = dev->dev->irq;
+        /* Even though this is PCI, we don't want to use shared
+         * interrupts. Sharing host devices with guest-assigned devices
+         * on the same interrupt line is not a happy situation: there
+         * are going to be long delays in accepting, acking, etc.
+         */
+        if (request_irq(dev->host_irq, kvm_assigned_dev_intr,
+                        0, "kvm_assigned_intx_device", (void *)dev))
+                return -EIO;
+        return 0;
+}
 
-        if (adev->irq_requested_type & KVM_ASSIGNED_DEV_HOST_INTX)
-                return 0;
+#ifdef __KVM_HAVE_MSI
+static int assigned_device_enable_host_msi(struct kvm *kvm,
+                                           struct kvm_assigned_dev_kernel *dev)
+{
+        int r;
 
-        if (irqchip_in_kernel(kvm)) {
-                if (!msi2intx &&
-                    (adev->irq_requested_type & KVM_ASSIGNED_DEV_HOST_MSI)) {
-                        free_irq(adev->host_irq, (void *)adev);
-                        pci_disable_msi(adev->dev);
-                }
+        if (!dev->dev->msi_enabled) {
+                r = pci_enable_msi(dev->dev);
+                if (r)
+                        return r;
+        }
 
-                if (!capable(CAP_SYS_RAWIO))
-                        return -EPERM;
+        dev->host_irq = dev->dev->irq;
+        if (request_irq(dev->host_irq, kvm_assigned_dev_intr, 0,
+                        "kvm_assigned_msi_device", (void *)dev)) {
+                pci_disable_msi(dev->dev);
+                return -EIO;
+        }
 
-                if (airq->host_irq)
-                        adev->host_irq = airq->host_irq;
-                else
-                        adev->host_irq = adev->dev->irq;
+        return 0;
+}
+#endif
 
-                /* Even though this is PCI, we don't want to use shared
-                 * interrupts. Sharing host devices with guest-assigned devices
-                 * on the same interrupt line is not a happy situation: there
-                 * are going to be long delays in accepting, acking, etc.
-                 */
-                if (request_irq(adev->host_irq, kvm_assigned_dev_intr,
-                                0, "kvm_assigned_intx_device", (void *)adev))
-                        return -EIO;
+#ifdef __KVM_HAVE_MSIX
+static int assigned_device_enable_host_msix(struct kvm *kvm,
+                                            struct kvm_assigned_dev_kernel *dev)
+{
+        int i, r = -EINVAL;
+
+        /* host_msix_entries and guest_msix_entries should have been
+         * initialized */
+        if (dev->entries_nr == 0)
+                return r;
+
+        r = pci_enable_msix(dev->dev, dev->host_msix_entries, dev->entries_nr);
+        if (r)
+                return r;
+
+        for (i = 0; i < dev->entries_nr; i++) {
+                r = request_irq(dev->host_msix_entries[i].vector,
+                                kvm_assigned_dev_intr, 0,
+                                "kvm_assigned_msix_device",
+                                (void *)dev);
+                /* FIXME: free requested_irq's on failure */
+                if (r)
+                        return r;
         }
 
-        adev->irq_requested_type = KVM_ASSIGNED_DEV_GUEST_INTX |
-                                   KVM_ASSIGNED_DEV_HOST_INTX;
         return 0;
 }
 
-#ifdef CONFIG_X86
-static int assigned_device_update_msi(struct kvm *kvm,
-                        struct kvm_assigned_dev_kernel *adev,
-                        struct kvm_assigned_irq *airq)
+#endif
+
+static int assigned_device_enable_guest_intx(struct kvm *kvm,
+                                struct kvm_assigned_dev_kernel *dev,
+                                struct kvm_assigned_irq *irq)
 {
-        int r;
+        dev->guest_irq = irq->guest_irq;
+        dev->ack_notifier.gsi = irq->guest_irq;
+        return 0;
+}
 
-        adev->guest_irq = airq->guest_irq;
-        if (airq->flags & KVM_DEV_IRQ_ASSIGN_ENABLE_MSI) {
-                /* x86 don't care upper address of guest msi message addr */
-                adev->irq_requested_type |= KVM_ASSIGNED_DEV_GUEST_MSI;
-                adev->irq_requested_type &= ~KVM_ASSIGNED_DEV_GUEST_INTX;
-                adev->ack_notifier.gsi = -1;
-        } else if (msi2intx) {
-                adev->irq_requested_type |= KVM_ASSIGNED_DEV_GUEST_INTX;
-                adev->irq_requested_type &= ~KVM_ASSIGNED_DEV_GUEST_MSI;
-                adev->ack_notifier.gsi = airq->guest_irq;
-        } else {
-                /*
-                 * Guest require to disable device MSI, we disable MSI and
-                 * re-enable INTx by default again. Notice it's only for
-                 * non-msi2intx.
-                 */
-                assigned_device_update_intx(kvm, adev, airq);
-                return 0;
+#ifdef __KVM_HAVE_MSI
+static int assigned_device_enable_guest_msi(struct kvm *kvm,
+                        struct kvm_assigned_dev_kernel *dev,
+                        struct kvm_assigned_irq *irq)
+{
+        dev->guest_irq = irq->guest_irq;
+        dev->ack_notifier.gsi = -1;
+        return 0;
+}
+#endif
+#ifdef __KVM_HAVE_MSIX
+static int assigned_device_enable_guest_msix(struct kvm *kvm,
+                        struct kvm_assigned_dev_kernel *dev,
+                        struct kvm_assigned_irq *irq)
+{
+        dev->guest_irq = irq->guest_irq;
+        dev->ack_notifier.gsi = -1;
+        return 0;
+}
+#endif
+
+static int assign_host_irq(struct kvm *kvm,
+                           struct kvm_assigned_dev_kernel *dev,
+                           __u32 host_irq_type)
+{
+        int r = -EEXIST;
+
+        if (dev->irq_requested_type & KVM_DEV_IRQ_HOST_MASK)
+                return r;
+
+        switch (host_irq_type) {
+        case KVM_DEV_IRQ_HOST_INTX:
+                r = assigned_device_enable_host_intx(kvm, dev);
+                break;
+#ifdef __KVM_HAVE_MSI
+        case KVM_DEV_IRQ_HOST_MSI:
+                r = assigned_device_enable_host_msi(kvm, dev);
+                break;
+#endif
+#ifdef __KVM_HAVE_MSIX
+        case KVM_DEV_IRQ_HOST_MSIX:
+                r = assigned_device_enable_host_msix(kvm, dev);
+                break;
+#endif
+        default:
+                r = -EINVAL;
         }
 
-        if (adev->irq_requested_type & KVM_ASSIGNED_DEV_HOST_MSI)
-                return 0;
+        if (!r)
+                dev->irq_requested_type |= host_irq_type;
 
-        if (irqchip_in_kernel(kvm)) {
-                if (!msi2intx) {
-                        if (adev->irq_requested_type &
-                                        KVM_ASSIGNED_DEV_HOST_INTX)
-                                free_irq(adev->host_irq, (void *)adev);
+        return r;
+}
 
-                        r = pci_enable_msi(adev->dev);
-                        if (r)
-                                return r;
-                }
+static int assign_guest_irq(struct kvm *kvm,
+                            struct kvm_assigned_dev_kernel *dev,
+                            struct kvm_assigned_irq *irq,
+                            unsigned long guest_irq_type)
+{
+        int id;
+        int r = -EEXIST;
+
+        if (dev->irq_requested_type & KVM_DEV_IRQ_GUEST_MASK)
+                return r;
 
-                adev->host_irq = adev->dev->irq;
-                if (request_irq(adev->host_irq, kvm_assigned_dev_intr, 0,
-                                "kvm_assigned_msi_device", (void *)adev))
-                        return -EIO;
+        id = kvm_request_irq_source_id(kvm);
+        if (id < 0)
+                return id;
+
+        dev->irq_source_id = id;
+
+        switch (guest_irq_type) {
+        case KVM_DEV_IRQ_GUEST_INTX:
+                r = assigned_device_enable_guest_intx(kvm, dev, irq);
+                break;
+#ifdef __KVM_HAVE_MSI
+        case KVM_DEV_IRQ_GUEST_MSI:
+                r = assigned_device_enable_guest_msi(kvm, dev, irq);
+                break;
+#endif
+#ifdef __KVM_HAVE_MSIX
+        case KVM_DEV_IRQ_GUEST_MSIX:
+                r = assigned_device_enable_guest_msix(kvm, dev, irq);
+                break;
+#endif
+        default:
+                r = -EINVAL;
         }
 
-        if (!msi2intx)
-                adev->irq_requested_type = KVM_ASSIGNED_DEV_GUEST_MSI;
+        if (!r) {
+                dev->irq_requested_type |= guest_irq_type;
+                kvm_register_irq_ack_notifier(kvm, &dev->ack_notifier);
+        } else
+                kvm_free_irq_source_id(kvm, dev->irq_source_id);
 
-        adev->irq_requested_type |= KVM_ASSIGNED_DEV_HOST_MSI;
-        return 0;
+        return r;
 }
-#endif
 
+/* TODO Deal with KVM_DEV_IRQ_ASSIGNED_MASK_MSIX */
 static int kvm_vm_ioctl_assign_irq(struct kvm *kvm,
-                                   struct kvm_assigned_irq
-                                   *assigned_irq)
+                                   struct kvm_assigned_irq *assigned_irq)
 {
-        int r = 0;
+        int r = -EINVAL;
         struct kvm_assigned_dev_kernel *match;
-        u32 current_flags = 0, changed_flags;
+        unsigned long host_irq_type, guest_irq_type;
 
-        mutex_lock(&kvm->lock);
+        if (!capable(CAP_SYS_RAWIO))
+                return -EPERM;
 
+        if (!irqchip_in_kernel(kvm))
+                return r;
+
+        mutex_lock(&kvm->lock);
+        r = -ENODEV;
         match = kvm_find_assigned_dev(&kvm->arch.assigned_dev_head,
                                       assigned_irq->assigned_dev_id);
-        if (!match) {
-                mutex_unlock(&kvm->lock);
-                return -EINVAL;
-        }
-
-        if (!match->irq_requested_type) {
-                INIT_WORK(&match->interrupt_work,
-                                kvm_assigned_dev_interrupt_work_handler);
-                if (irqchip_in_kernel(kvm)) {
-                        /* Register ack nofitier */
-                        match->ack_notifier.gsi = -1;
-                        match->ack_notifier.irq_acked =
-                                        kvm_assigned_dev_ack_irq;
-                        kvm_register_irq_ack_notifier(kvm,
-                                        &match->ack_notifier);
-
-                        /* Request IRQ source ID */
-                        r = kvm_request_irq_source_id(kvm);
-                        if (r < 0)
-                                goto out_release;
-                        else
-                                match->irq_source_id = r;
-
-#ifdef CONFIG_X86
-                        /* Determine host device irq type, we can know the
-                         * result from dev->msi_enabled */
-                        if (msi2intx)
-                                pci_enable_msi(match->dev);
-#endif
-                }
-        }
+        if (!match)
+                goto out;
 
-        if ((match->irq_requested_type & KVM_ASSIGNED_DEV_HOST_MSI) &&
-                 (match->irq_requested_type & KVM_ASSIGNED_DEV_GUEST_MSI))
-                current_flags |= KVM_DEV_IRQ_ASSIGN_ENABLE_MSI;
+        host_irq_type = (assigned_irq->flags & KVM_DEV_IRQ_HOST_MASK);
+        guest_irq_type = (assigned_irq->flags & KVM_DEV_IRQ_GUEST_MASK);
 
-        changed_flags = assigned_irq->flags ^ current_flags;
+        r = -EINVAL;
+        /* can only assign one type at a time */
+        if (hweight_long(host_irq_type) > 1)
+                goto out;
+        if (hweight_long(guest_irq_type) > 1)
+                goto out;
+        if (host_irq_type == 0 && guest_irq_type == 0)
+                goto out;
 
-        if ((changed_flags & KVM_DEV_IRQ_ASSIGN_MSI_ACTION) ||
-            (msi2intx && match->dev->msi_enabled)) {
-#ifdef CONFIG_X86
-                r = assigned_device_update_msi(kvm, match, assigned_irq);
-                if (r) {
-                        printk(KERN_WARNING "kvm: failed to enable "
-                                        "MSI device!\n");
-                        goto out_release;
-                }
-#else
-                r = -ENOTTY;
-#endif
-        } else if (assigned_irq->host_irq == 0 && match->dev->irq == 0) {
-                /* Host device IRQ 0 means don't support INTx */
-                if (!msi2intx) {
-                        printk(KERN_WARNING
-                               "kvm: wait device to enable MSI!\n");
-                        r = 0;
-                } else {
-                        printk(KERN_WARNING
-                               "kvm: failed to enable MSI device!\n");
-                        r = -ENOTTY;
-                        goto out_release;
-                }
-        } else {
-                /* Non-sharing INTx mode */
-                r = assigned_device_update_intx(kvm, match, assigned_irq);
-                if (r) {
-                        printk(KERN_WARNING "kvm: failed to enable "
-                                        "INTx device!\n");
-                        goto out_release;
-                }
-        }
+        r = 0;
+        if (host_irq_type)
+                r = assign_host_irq(kvm, match, host_irq_type);
+        if (r)
+                goto out;
 
+        if (guest_irq_type)
+                r = assign_guest_irq(kvm, match, assigned_irq, guest_irq_type);
+out:
         mutex_unlock(&kvm->lock);
         return r;
-out_release:
+}
+
+static int kvm_vm_ioctl_deassign_dev_irq(struct kvm *kvm,
+                                         struct kvm_assigned_irq
+                                         *assigned_irq)
+{
+        int r = -ENODEV;
+        struct kvm_assigned_dev_kernel *match;
+
+        mutex_lock(&kvm->lock);
+
+        match = kvm_find_assigned_dev(&kvm->arch.assigned_dev_head,
+                                      assigned_irq->assigned_dev_id);
+        if (!match)
+                goto out;
+
+        r = kvm_deassign_irq(kvm, match, assigned_irq->flags);
+out:
         mutex_unlock(&kvm->lock);
-        kvm_free_assigned_device(kvm, match);
         return r;
 }
 
@@ -427,7 +588,7 @@ static int kvm_vm_ioctl_assign_device(struct kvm *kvm,
                                       assigned_dev->assigned_dev_id);
         if (match) {
                 /* device already assigned */
-                r = -EINVAL;
+                r = -EEXIST;
                 goto out;
         }
 
@@ -464,8 +625,12 @@ static int kvm_vm_ioctl_assign_device(struct kvm *kvm,
         match->host_devfn = assigned_dev->devfn;
         match->flags = assigned_dev->flags;
         match->dev = dev;
+        spin_lock_init(&match->assigned_dev_lock);
         match->irq_source_id = -1;
         match->kvm = kvm;
+        match->ack_notifier.irq_acked = kvm_assigned_dev_ack_irq;
+        INIT_WORK(&match->interrupt_work,
+                  kvm_assigned_dev_interrupt_work_handler);
 
         list_add(&match->list, &kvm->arch.assigned_dev_head);
 
@@ -878,6 +1043,8 @@ static void kvm_destroy_vm(struct kvm *kvm)
 #endif
 #if defined(CONFIG_MMU_NOTIFIER) && defined(KVM_ARCH_WANT_MMU_NOTIFIER)
         mmu_notifier_unregister(&kvm->mmu_notifier, kvm->mm);
+#else
+        kvm_arch_flush_shadow(kvm);
 #endif
         kvm_arch_destroy_vm(kvm);
         mmdrop(mm);
@@ -919,9 +1086,8 @@ int __kvm_set_memory_region(struct kvm *kvm,
 {
         int r;
         gfn_t base_gfn;
-        unsigned long npages;
-        int largepages;
-        unsigned long i;
+        unsigned long npages, ugfn;
+        unsigned long largepages, i;
         struct kvm_memory_slot *memslot;
         struct kvm_memory_slot old, new;
 
@@ -1010,6 +1176,14 @@ int __kvm_set_memory_region(struct kvm *kvm,
                         new.lpage_info[0].write_count = 1;
                 if ((base_gfn+npages) % KVM_PAGES_PER_HPAGE)
                         new.lpage_info[largepages-1].write_count = 1;
+                ugfn = new.userspace_addr >> PAGE_SHIFT;
+                /*
+                 * If the gfn and userspace address are not aligned wrt each
+                 * other, disable large page support for this slot
+                 */
+                if ((base_gfn ^ ugfn) & (KVM_PAGES_PER_HPAGE - 1))
+                        for (i = 0; i < largepages; ++i)
+                                new.lpage_info[i].write_count = 1;
         }
 
         /* Allocate page dirty bitmap if needed */
@@ -1043,8 +1217,10 @@ int __kvm_set_memory_region(struct kvm *kvm,
 
         kvm_free_physmem_slot(&old, npages ? &new : NULL);
         /* Slot deletion case: we have to update the current slot */
+        spin_lock(&kvm->mmu_lock);
         if (!npages)
                 *memslot = old;
+        spin_unlock(&kvm->mmu_lock);
 #ifdef CONFIG_DMAR
         /* map the pages in iommu page table */
         r = kvm_iommu_map_pages(kvm, base_gfn, npages);
@@ -1454,12 +1630,14 @@ void kvm_vcpu_block(struct kvm_vcpu *vcpu)
         for (;;) {
                 prepare_to_wait(&vcpu->wq, &wait, TASK_INTERRUPTIBLE);
 
-                if (kvm_cpu_has_interrupt(vcpu) ||
-                    kvm_cpu_has_pending_timer(vcpu) ||
-                    kvm_arch_vcpu_runnable(vcpu)) {
+                if ((kvm_arch_interrupt_allowed(vcpu) &&
+                                        kvm_cpu_has_interrupt(vcpu)) ||
+                                kvm_arch_vcpu_runnable(vcpu)) {
                         set_bit(KVM_REQ_UNHALT, &vcpu->requests);
                         break;
                 }
+                if (kvm_cpu_has_pending_timer(vcpu))
+                        break;
                 if (signal_pending(current))
                         break;
 
@@ -1593,6 +1771,88 @@ static int kvm_vcpu_ioctl_set_sigmask(struct kvm_vcpu *vcpu, sigset_t *sigset)
         return 0;
 }
 
+#ifdef __KVM_HAVE_MSIX
+static int kvm_vm_ioctl_set_msix_nr(struct kvm *kvm,
+                                    struct kvm_assigned_msix_nr *entry_nr)
+{
+        int r = 0;
+        struct kvm_assigned_dev_kernel *adev;
+
+        mutex_lock(&kvm->lock);
+
+        adev = kvm_find_assigned_dev(&kvm->arch.assigned_dev_head,
+                                      entry_nr->assigned_dev_id);
+        if (!adev) {
+                r = -EINVAL;
+                goto msix_nr_out;
+        }
+
+        if (adev->entries_nr == 0) {
+                adev->entries_nr = entry_nr->entry_nr;
+                if (adev->entries_nr == 0 ||
+                    adev->entries_nr >= KVM_MAX_MSIX_PER_DEV) {
+                        r = -EINVAL;
+                        goto msix_nr_out;
+                }
+
+                adev->host_msix_entries = kzalloc(sizeof(struct msix_entry) *
+                                                entry_nr->entry_nr,
+                                                GFP_KERNEL);
+                if (!adev->host_msix_entries) {
+                        r = -ENOMEM;
+                        goto msix_nr_out;
+                }
+                adev->guest_msix_entries = kzalloc(
+                                sizeof(struct kvm_guest_msix_entry) *
+                                entry_nr->entry_nr, GFP_KERNEL);
+                if (!adev->guest_msix_entries) {
+                        kfree(adev->host_msix_entries);
+                        r = -ENOMEM;
+                        goto msix_nr_out;
+                }
+        } else /* Not allowed set MSI-X number twice */
+                r = -EINVAL;
+msix_nr_out:
+        mutex_unlock(&kvm->lock);
+        return r;
+}
+
+static int kvm_vm_ioctl_set_msix_entry(struct kvm *kvm,
+                                       struct kvm_assigned_msix_entry *entry)
+{
+        int r = 0, i;
+        struct kvm_assigned_dev_kernel *adev;
+
+        mutex_lock(&kvm->lock);
+
+        adev = kvm_find_assigned_dev(&kvm->arch.assigned_dev_head,
+                                      entry->assigned_dev_id);
+
+        if (!adev) {
+                r = -EINVAL;
+                goto msix_entry_out;
+        }
+
+        for (i = 0; i < adev->entries_nr; i++)
+                if (adev->guest_msix_entries[i].vector == 0 ||
+                    adev->guest_msix_entries[i].entry == entry->entry) {
+                        adev->guest_msix_entries[i].entry = entry->entry;
+                        adev->guest_msix_entries[i].vector = entry->gsi;
+                        adev->host_msix_entries[i].entry = entry->entry;
+                        break;
+                }
+        if (i == adev->entries_nr) {
+                r = -ENOSPC;
+                goto msix_entry_out;
+        }
+
+msix_entry_out:
+        mutex_unlock(&kvm->lock);
+
+        return r;
+}
+#endif
+
 static long kvm_vcpu_ioctl(struct file *filp,
                            unsigned int ioctl, unsigned long arg)
 {
@@ -1864,6 +2124,11 @@ static long kvm_vm_ioctl(struct file *filp,
                 break;
         }
         case KVM_ASSIGN_IRQ: {
+                r = -EOPNOTSUPP;
+                break;
+        }
+#ifdef KVM_CAP_ASSIGN_DEV_IRQ
+        case KVM_ASSIGN_DEV_IRQ: {
                 struct kvm_assigned_irq assigned_irq;
 
                 r = -EFAULT;
@@ -1874,6 +2139,18 @@ static long kvm_vm_ioctl(struct file *filp,
                         goto out;
                 break;
         }
+        case KVM_DEASSIGN_DEV_IRQ: {
+                struct kvm_assigned_irq assigned_irq;
+
+                r = -EFAULT;
+                if (copy_from_user(&assigned_irq, argp, sizeof assigned_irq))
+                        goto out;
+                r = kvm_vm_ioctl_deassign_dev_irq(kvm, &assigned_irq);
+                if (r)
+                        goto out;
+                break;
+        }
+#endif
 #endif
 #ifdef KVM_CAP_DEVICE_DEASSIGNMENT
         case KVM_DEASSIGN_PCI_DEVICE: {
@@ -1917,7 +2194,29 @@ static long kvm_vm_ioctl(struct file *filp,
                 vfree(entries);
                 break;
         }
+#ifdef __KVM_HAVE_MSIX
+        case KVM_ASSIGN_SET_MSIX_NR: {
+                struct kvm_assigned_msix_nr entry_nr;
+                r = -EFAULT;
+                if (copy_from_user(&entry_nr, argp, sizeof entry_nr))
+                        goto out;
+                r = kvm_vm_ioctl_set_msix_nr(kvm, &entry_nr);
+                if (r)
+                        goto out;
+                break;
+        }
+        case KVM_ASSIGN_SET_MSIX_ENTRY: {
+                struct kvm_assigned_msix_entry entry;
+                r = -EFAULT;
+                if (copy_from_user(&entry, argp, sizeof entry))
+                        goto out;
+                r = kvm_vm_ioctl_set_msix_entry(kvm, &entry);
+                if (r)
+                        goto out;
+                break;
+        }
 #endif
+#endif /* KVM_CAP_IRQ_ROUTING */
         default:
                 r = kvm_arch_vm_ioctl(filp, ioctl, arg);
         }
@@ -2112,15 +2411,15 @@ EXPORT_SYMBOL_GPL(kvm_handle_fault_on_reboot);
 static int kvm_reboot(struct notifier_block *notifier, unsigned long val,
                       void *v)
 {
-        if (val == SYS_RESTART) {
-                /*
-                 * Some (well, at least mine) BIOSes hang on reboot if
-                 * in vmx root mode.
-                 */
-                printk(KERN_INFO "kvm: exiting hardware virtualization\n");
-                kvm_rebooting = true;
-                on_each_cpu(hardware_disable, NULL, 1);
-        }
+        /*
+         * Some (well, at least mine) BIOSes hang on reboot if
+         * in vmx root mode.
+         *
+         * And Intel TXT required VMX off for all cpu when system shutdown.
+         */
+        printk(KERN_INFO "kvm: exiting hardware virtualization\n");
+        kvm_rebooting = true;
+        on_each_cpu(hardware_disable, NULL, 1);
         return NOTIFY_OK;
 }
 
@@ -2354,9 +2653,6 @@ int kvm_init(void *opaque, unsigned int vcpu_size,
 
         kvm_preempt_ops.sched_in = kvm_sched_in;
         kvm_preempt_ops.sched_out = kvm_sched_out;
-#ifndef CONFIG_X86
-        msi2intx = 0;
-#endif
 
         return 0;